1. Introduction

Combien de fois nous est-il arrivé que lorsque nous partons en voyage, nous devons toujours nous soucier et prier qu’aucun malheur n’est arrivé à la maison, à notre télé adorée ! Il faut utiliser une camera ou un système de surveillance me diriez-vous! C'est précisément sur quoi tient mon projet; je voulais comprendre le concept d'une caméra de surveillance pour l'implémenter dans mon projet en guise d'introduction dans le monde de la programmation.

But

Le but de ce projet H est de créer un prototype de système caméra de surveillance avec un ARDUINO UNO ; la caméra bouge à l’aide d’un servomoteur lorsqu’un des capteurs de mouvement à infrarouge détecte un mouvement. Pour indiquer quel capteur détecte, un LED s’allume au-dessus. Le but reel de mon projet est de me familiariser avec la programmation. J'ai choisi de prendre comme medium l'ARDUINO pour ainsi m'amener à avoir des connaissances et expérience avec l'électronique et le language de programmation qui les relie.

Les limitations anticipées

L’artefact ne peut détecter qu’un seul objet en mouvement à la fois pour ainsi éviter que notre servomoteur commence à chauffer et danser dans tous les sens. Un autre point à retenir, les dispositif nécessite la présence de la lumière pour que la caméra puisse visionner l’objet alors plus clair à mettre en evidence efficacement. Une camera ordinaire comme utilisée ici ne peut filmer le noir absolu contrairement à une caméra nocturne ou de chaleur.

2. Matériel et méthodes

2.1 Principe

Le principe est de suivre une personne qui bouge, à l’aide d’un système de 5 détecteurs de mouvement donnant sur une vue de 150° (car la limitation du servo est de 160°). Lorsqu’un des détecteurs capte un objet en mouvement, un servomoteur bougera dans sa direction et un LED s’allumera au-dessus du capteur à titre indicatif.

2.2 Liste du matériel

  • 1 ARDUINO UNO avec logiciel ARDUINO IDE
  • 5 LEDS
  • 5 résistantes de 330 Ω
  • 5 capteurs PIR HC-SR501
  • 12 câbles Jumper Wire ou Male/Male
  • 25 cables Male/Female Wire
  • 1 servomoteur "Mini servo"
  • Styrofoam (type de polystyrène)
  • Colle spécial non organique
  • 1 caméra Mini Camera (Made in China)
  • Outils de bricolage (coupeur thermique, colle fixe, ruban adhésif, mètre, ...)

Carte microcontrôleur ARDUINO UNO

ARDUINO est un microcontrôleur qui gère ses périphériques d’entrées et de sortie ; il interagit avec le monde extérieur à l’aide des capteurs et selon un programme implémenté, il exécutera une action dans le monde physique à l’aide des actionneurs. Typiquement dans ce cas de figure, les PIR sont des capteurs et les LEDs et le servo sont des actionneurs.

LED (5x)

L’utilisation des LED est pratique car ils permettent d’indiquer à la fois si le capteur PIR a détecté un mouvement et lequel en a détecté sur un ensemble de 5 capteurs. En revanche pour intégrer une LED dans le circuit, il est impératif de la relier à une résistance ici de 330 ‎Ω, la LED étant trop sensible à une forte variation de potentiel dans le circuit. L’emplacement de la résistance dans le circuit en série importe peu vu que le courant reste uniforme, j’ai toutefois choisi de l’emplacer au côté de l’anode (-)des LEDs. La cathode(+) attaché au Breadboard est par extension "reliée" avec un fil au pin digital de l’ARDUINO.

PIR (5x)

Bien faire attention au sens des deux potentiomètres; il y en a un pour le délai du HIGH et l'autre la sensivité (distance , rayon de propagation)

Photo_potentio.JPG

Le PIR HC-SR501 a besoin d’un autre type de câbles (3 paire pour chaque PIR) pour être relié avec le microcontrôleur : ici j’ai plutôt utilisé des câbles « Male/Female Wire » comme sur la photo plus haut. Le câble noir le relie avec le GND, le rouge avec 5V et le blanc utilisé comme signal connecté à un pin digital du Board.

L’avantage de ce PIR en particulier est qu’il peut directement fournir des entrées digitales ce qui est parfait dans ce cas vu qu’il faut savoir quand est-ce que le capteur détecte (HIGH) ou pas(LOW).

Servomoteur

J’ai utilisé un servomoteur ici le « mini servo » du kit de base de Sparkfun. L’avantage du servo sur le moteur est qu’il peut être tourné à un angle précis bien avantageux pour mon cas de figure pour tourner précisement le servo et donc la caméra en direction du capteur qui a détecté.

3 fils sont déjà intégrés au servo mais il y a besoin d’y attacher 3 autres fils pour le relier au Breadboard. Il y en a 3 comme pour le PIR, sauf qu’au niveau du code couleur, le brun sert de GND, le rouge de PULSE et l’orange du signal.

Caméra

J’ai utilisé la caméra MINI Camera qui a pour avantage d’être non seulement toute petite et adorable mais aussi très légère qui était la principale raison pour laquelle je l’ai choisie. J’ai voulu éviter que le servo mini se force en essayant de tourner avec du poids trop lourd pour lui par-dessus.

Styrofoam

Pour construire ma base matérielle sur laquelle j'ai par la suite attaché les PIRs et les LEDs j'ai utilisé du Styrofoam, une matière du même type que du polystyrène qui peut être flexible, isolant et facile à manier pour contenir tout le matériel. Je tiens à preciser qu’aucun composant n’a été fixé au risque de les abîmer maladroite que je suis! J’ai donc essayé d’entourer le PIR et fixer la LED avec le Styrofoam sans colle spécial. En effet, cette matière a besoin d’une colle non organique sinon au contact de tout autre liquide, elle devient moue. J’ai dû en utiliser pour fixer tout le prototype sur une planche par exemple. Pour « couper » le styrofoam, je n’ai pas utilisé de ciseaux sinon elle devient toute rugueuse, j’ai plutôt dû chauffer pour séparer la matière en pièce à l’aide d’un « thermo cutter » soit un coupeur thermique.

2.3 Procédure

Par rapport à mon vécu sur la réalisation du projet, j’ai suivi un ordre d’étape pour arriver à sa concrétisation. Je tiens donc à expliquer les étapes que j’ai suivi pour arriver à la finalisation de mon projet. Après avoir mis en place la liste du matériel de base, je savais sur quoi m’attaquer. Mais avant toute chose, j’ai dû d’abord aller à la quête des capteurs de mouvement PIR...

  1. Acheter le matériel nécessaire

En l’occurence j’ai dû me procurer 5 capteurs PIR de movement et j'ai choisi de prendre le modèle HC-SR501.

  1. S’amuser avec les composants séparement

Pour débuter sur ARDUINO, j'ai testé quelques expériences avec des programmes déjà préinstallés comme exemples sur l'IDE comme clignoter un LED, tourner un servo et j'en passe. Ces

  1. Connecter 1 PIR à l’Arduino et contrôler sa détection de mouvement
  2. Relier un LED et la faire clignoter selon la détection
  3. Faire bouger le servomoteur et l’intégrer dans le système
  4. Connecter un 2ème PIR avec sa LED

J'ai pu déja comprendre comment en faisant fonctionner mon projet sur un ensemble de deux capteurs, faire fonctionner tout un système de 5 PIR.

  1. Programmer le mouvement du servo vers le PIR qui détecte

À l’aide de la commande if et la logique bouléenne du ‘’et’’ logique

  1. Programmer le servo avec les 5 PIRs
  2. Construire le montage final
  3. Tester tout l’artefact pour les éventuels améliorations jusqu'au rendu final

2.4 Montage

J’ai construit mon montage lorsque tout mon circuit était au complet donc il n’y a pas eu de dimensions précalculées.

Pour entourer les capteurs PIR, j'ai utilisé 2 bouts rectangulaires du Styrofoam à l'avant et un à l'arrière pour le contenir et protéger. La carte ARDUINO se situe en dehors du dispositif et les fils sont contenus au centre intérieur de l'assemblage.

Les dimensions ne sont pas importantes tant que le dispositif peut contenir tous les composants ainsi que de les sécuriser.

Schéma du circuit complet

Fritzing_Projet_H_v2-Vrinda_PARASHAR-3MP2.PNG

Le montage en développement

_20170130_234418_1_.JPG

_20170130_234453_1_.JPG

mid_develop.JPG

Dernière ligne droite

final_beneath.JPG

final_beneath_2.JPG

2.5 Code

Mon code final est en fait un bloc de code utilisé pour chacun des 5 capteurs. Il y a donc une même série d’instructions qui est répété 5 fois.

PIR

Le contrôle de la détéction des PIR est l’essence même de la programmation de mon projet. Avant de commencer quoi que ce soit, j’ai dû tout d’abord laisser du temps aux capteurs de se calibrer dans mon void.setup(). Les PIRs prennent de toute façon du temps pour se mettre à 0 allant de quelques secondes à quelques minutes mais cela dépend du capteur. Les miens pouvaient prendre entre 10 et 25 secondes pour tarer. J’ai donc choisi de consacrer 15 secondes pendant lesquelles le moniteur m’affiche que l’initialisation est en cours et donc que je ne commence pas à déranger le système. Lorsque la phase d’initialisation est terminée et donc que tous les PIRs sont remis à 0 (ou LOW), le moniteur m’indique que l’experience peut enfin commencer.

Serial.print ("Setting PIR sensors ");

for(int c = 0; c < 15; c++)// calibrer PIR jusqu'à 15 sec
     {  
     Serial.print(".");
     delay(1000); 
     } 
Serial.println ("PIR Ready to go!");

servo.write(50); // bouger servo position initial 50 degrés

L’avantage que j’ai eu avec les capteurs de mouvement HC-SR501 est qu’elles avaient la possibilité de fournir des entrées digitales qu’il m’était plus simple de manier par la suite. Les entrées digitales sont soit HIGH (ou 1) soit LOW(ou 0). Le HIGH correspond à la détection de mouvement et le LOW l’absence de détection. Par exemple, entre les 5 PIRs, le fait que le PIR1 détecte est que si et seulement si lui seul a détecté c’est-à-dire qu’il est HIGH et que chacun des 4 autres PIR sont LOW, alors le servo bougera de son coté. Sinon, lorsqu’une des prémisses s’avère être fausse, alors la condition n’est plus valable. Il est très important de mettre en évidence cette condition car cela fait tout l’intérêt du code. Le LED au-dessus du PIR qui a détecté s’allumera également. Pour ce faire, la logique bouléenne plus spécifiquement celle du « et » logique m’a paru profitable dans mon projet.

Si deux capteurs détectent simultanément alors le servo ne saurait pas où tourner. C’est pourquoi il doit n’y avoir qu’un seul objet en mouvement à la fois.

Le servo quant à lui doit être bougé en direction des PIRs . Mon servo pouvait bouger entre 8 et 150° donc au total 142° mais cette marge dépend encore une fois du servomoteur.. Cela n’a heureusement pas affecté la taille du montage en soi mais j’ai dû ajuster mon code proportionnellement à 150° et non 180°. J’ai attribué les angles suivant selon la postion des PIRs : 150°, 130°, 90°, 40° et 8° du PIR1 au PIR5 respectivement.

J’ai donc utilisé comme condition, la logique bouléenne du ‘’et’’ logique pour chacun des 5 PIRs dans le void.loop() comme suit

//Exemple avec le PIR1 
if (PIRvalue1 == HIGH && PIRvalue2 == LOW && PIRvalue3 == LOW && 
    PIRvalue4 == LOW && PIRvalue5 == LOW)  
     // si seul PIRvalue1 est HIGH
     { 
       digitalWrite(LED1, HIGH); //allumer sa LED correspondante
       digitalWrite(LED2, LOW);
       digitalWrite(LED3, LOW);
       digitalWrite(LED4, LOW);
       digitalWrite(LED5, LOW);
       
       servo.write(150); //bouger servo en direction du PIR1
       Serial.println("Position servo : PIR1, Motion detected"); //afficher le PIR détecté
    }

A la fin de mon void.loop() je termine avec un else, condition si aucun des capteurs ne détecte de mouvement alors seulement le serial monitor est sollicité. Cette fois je n’ai pas ajouter d’instructions pour les LED ce qui est pratique pour savoir lequel des PIR avait capté en dernier et au cas où la détection a été trop courte pour moi de voir sur le moniteur .

J’avais d’abord essayé de mettre la condition if pour chacun des PIRvalue mais j’ai très vite remarqué que le servo essayait d’aller dans tous les sens. C’est parce que la condition n’était pas assez précise. J’ai donc appliqué la condition que SI un des capteurs PIR est HIGH ou égal à 1 ET que CHACUN des restes de capteurs est LOW alors, alors le servo bougera à un angle donné qui correspond à la postion du PIR qui a capté .

Il est aussi envisageable de simplifier le code des LED en réutilisant les PIRvalue comme l’état des LEDs.

if (PIRvalue1 == HIGH && PIRvalue2 == LOW && PIRvalue3 == LOW && 
    PIRvalue4 == LOW && PIRvalue5 == LOW) 
     { 
       digitalWrite(LED1, PIRvalue1);
       digitalWrite(LED2, PIRvalue2);
       digitalWrite(LED3, PIRvalue3);
       digitalWrite(LED4, PIRvalue4);
       digitalWrite(LED5, PIRvalue5);
       
       servo.write(150); 
       Serial.println("Position servo : PIR1 , Motion detected");
    }

3. Résultats

Lorsqu'un des capteurs de mouvement détecte une présence par son mouvement, le servo bouge exactement dans la direction du capteur qui a détecté et sa LED correspondante est allumée. Grâce à cela, la camera que le servomoteur dirige filme efficacement dans la direction de la détection.

Final_plongee.JPG

Final_profil.JPG

Code final

Note: J'ai affiché le code suivant tout entire si jamais vous n'arriviez pas à accéder l'entrée direct au serveur GIT.

Entrée du code final

https://dev.gyre.ch/git?p=gyreoci-1...

#include <Servo.h> //inclure la bibliothèque du servomoteur (ses commandes spécifiques)
Servo servo; //assigner l'objet "servo" comme servomoteur

int LED1 = 8 ;  //pins respectifs des LED
int LED2 = 10;
int LED3 = 11;
int LED4 = 12;
int LED5 = 13;
int PIR1 = 2;   //pins respectifs des capteurs PIR 
int PIR2 = 3;
int PIR3 = 4;
int PIR4 = 5;
int PIR5 = 6;
// désigner les variables PIRvalue comme bouléenne 
// c'est à dire soit  TRUE ou HIGH (détection) soit FALSE ou LOW(non détection)
boolean PIRvalue1; 
boolean PIRvalue2; 
boolean PIRvalue3; 
boolean PIRvalue4; 
boolean PIRvalue5; 

void setup()  {
     Serial.begin(9600); //interpeller le serial monitor pour afficher output sur serial monitor
     servo.attach(9); // pin servo D9
 
     pinMode(PIR1, INPUT);
     pinMode(PIR2, INPUT);
     pinMode(PIR3, INPUT);
     pinMode(PIR4, INPUT);  
     pinMode(PIR5, INPUT);
     pinMode(LED1, OUTPUT);
     pinMode(LED2, OUTPUT);
     pinMode(LED3, OUTPUT);
     pinMode(LED4, OUTPUT);   
     pinMode(LED5, OUTPUT);   
     //TARER - Temps pour PIRs de se (re)mettre en LOW, phase initiale
     Serial.print ("Setting PIR sensors ");
     for(int c = 0; c < 15; c++)// calibrer PIR jusqu'à 15 sec
     {  
           Serial.print(".");
           delay(1000); 
     } 
     Serial.println ("PIR Ready to go!");
     servo.write(50); // bouger servo position initial 50 degrés  
} 

void loop()  {
     // les variables PIRvalue(bouléenne) stockent les inputs digitales (état) 
     // de leur PIR respectif soit H ou L
     PIRvalue1 = digitalRead(PIR1); 
     PIRvalue2 = digitalRead(PIR2);
     PIRvalue3 = digitalRead(PIR3);
     PIRvalue4 = digitalRead(PIR4);
     PIRvalue5 = digitalRead(PIR5);
     // Mouvement servo lors détection PIR1
     if (PIRvalue1 == HIGH && PIRvalue2 == LOW && PIRvalue3 == LOW && 
         PIRvalue4 == LOW && PIRvalue5 == LOW) // && désigne le "et logique" bouléenne
     { 
           digitalWrite(LED1, HIGH);
           digitalWrite(LED2, LOW);
           digitalWrite(LED3, LOW);
           digitalWrite(LED4, LOW);
           digitalWrite(LED5, LOW);
     
           servo.write(150);
           Serial.println("Position servo : PIR1, Motion detected");
     } 
     //Mouvement servo lors détection PIR2
     else if (PIRvalue1 == LOW && PIRvalue2 == HIGH && PIRvalue3 == LOW && 
                 PIRvalue4 == LOW && PIRvalue5 == LOW) 
     { 
           digitalWrite(LED1, LOW);
           digitalWrite(LED2, HIGH);
           digitalWrite(LED3, LOW);
           digitalWrite(LED4, LOW);
           digitalWrite(LED5, LOW);
     
           servo.write(130);
           Serial.println("Position servo : PIR2, Motion detected");
     } 
     //Mouvement servo lors détection PIR3
     else if (PIRvalue1 == LOW && PIRvalue2 == LOW && PIRvalue3 == HIGH && 
                 PIRvalue4 == LOW && PIRvalue5 == LOW) 
     { 
           digitalWrite(LED1, LOW);
           digitalWrite(LED2, LOW);
           digitalWrite(LED3, HIGH);
           digitalWrite(LED4, LOW);
           digitalWrite(LED5, LOW);
     
           servo.write(90);
           Serial.println("Position servo : PIR3, Motion detected");
     } 
     //Mouvement servo lors détection PIR4
     else if (PIRvalue1 == LOW && PIRvalue2 == LOW && PIRvalue3 == LOW && 
                 PIRvalue4 == HIGH && PIRvalue5 == LOW) 
     { 
           digitalWrite(LED1, LOW);
           digitalWrite(LED2, LOW);
           digitalWrite(LED3, LOW);
           digitalWrite(LED4, HIGH);
           digitalWrite(LED5, LOW);
     
           servo.write(40);
           Serial.println("Position servo : PIR4, Motion detected");
     } 
     //Mouvement servo lors détection PIR5
     else if (PIRvalue1 == LOW && PIRvalue2 == LOW && PIRvalue3 == LOW && 
                 PIRvalue4 == LOW && PIRvalue5 == HIGH) 
     { 
           digitalWrite(LED1, LOW);
           digitalWrite(LED2, LOW);
           digitalWrite(LED3, LOW);
           digitalWrite(LED4, LOW);
           digitalWrite(LED5, HIGH);
     
           servo.write(8);
           Serial.println("Position servo : PIR5, Motion detected");
     } 
     // Si aucun des PIR ne détecte de mouvement
     else  
           // Instruction des LEDs pas nécessaire, bien pratique pour connaître l'état précédent 
           // car LED reste allumée jusqu'à nouvelle détection
     {
           Serial.println("No motion");
     }  
}

4. Discussion

Limitations

J’ai décidé de changer de camera afin d’éviter que le servo ne porte trop de poids sinon il risquait d’en prendre cher…

Ajustements

J’ai eu besoin de faire quelques modifications mineures en cours de route mais rien de monumental heureusement .

Servomoteur

Tous les servos ne tournent pas à 180° bien au contraire, cela dépend du servo en soi. Le mien pouvait bouger jusqu’à 150° au maximum. C'est pourquoi j'ai ajusté les angles de mouvement du servo proportionnellement à 150° et non 180° dans mon code.

La caméra

Au début de mon projet, mon idée était inclinée vers la possibilité de poser n’importe quel appareil qui puisse prendre des photos. Mais par prévention au risque d’endommagé le servo j’ai décidé de me procurer une toute petite caméra qui est super légère et même capable de stocker une carte SD de 8GB. Cela n’empêche pas par contre à l’utiliser comme système de sécurité pour la maison car d’après quelques tests, la caméra est capable de filmer pendant 24h sans arrêt.

J’ai finalement abandonné la palette en cours de route pour ainsi éviter du surpoids sur le servo et aussi je savais que j’allais finalement utiliser une petite caméra légère donc j’ai directement attaché la mini caméra au servo à l’aide d’un ruban adhésif sur deux côtés. Mail il est clair que si j’avais besoin d’utiliser une caméra ou mon telephone qui sont plus lourds par exemple, alors à ce moment-là j’aurais eu besoin d’un plus grand servo pour porter le tout.

Améliorations possibles

La plus grande amélioration possible et la plus avancée serait la miniaturisation du prototype. En effet, si tous les composants sont miniaturiser, le dispositif pourrait se tenir en plusieurs niveaux plus que sur une carte ARDUINO. Il serait ainsi très discret voire même bien dissimulé.

Un système d’alerte au propriétaire lorsqu’il y a une détection de mouvement non-voulu dans une pièce. L'envoi d'un SMS instantané ou même une base de données où l'heure et la date de la détection/infraction ainsi qu'une photo prise sur le moment du mouvement sont enregistrées (cela donnera donc une série de photos enregistrée au cas où quelqu’un essaie d’égarer la caméra ou le dispositif). Comme dit en guise d'introduction, la caméra que j’ai utilisée est ordinaire et ne peut pas filmer dans le noir, donc il serait enviseagable s'il y en a besoin d’utiliser une caméra qui puisse visionner dans le noir.

Un plus grand servomoteur serait utile pour porter une caméra ou même un smartphone trop lourd pour le mini servo de porter. Un moteur tournant précisément sur 360° vaudrait également la peine.

Pour rendre le concept plus ludique, le dispositif pourra être entouré d’une décoration ou d’un mascot. Quoi de mieux que voir un perroquet bouger au milieux des enfants ou si nous sommes suffisament sadiques, nous pouvons ajouter une tête effrayante de zombie pour Halloween et par chance garder nos bonbons pour nous !

5. Conclusion

Mon servomoteur est en mesure de tourner précisément vers n'importe quel des 5 capteurs qui auarait détecté et dont la LED respective s'allume. Le servo peut donc parfaitement tourner seul en direction d'un capteur qui a détecté selon le programme que j'ai implémenté grâce au programme et électronique ARDUINO. J'ai reussi à atteindre mon prototype final fonctionnel comme souhaité. J’ai pu apprendre grâce à ce projet des nouvelles notions et appliqué celles que nous avons vu en cours comme la logique bouléenne pour finaliser mon projet. Après maintes erreurs et obstacles j'ai enfin compris le concept derrière un servomoteur ,par-dessus lequel une camera filme, tourne vers un capteur et aux moyens des LEDs,complémentaires au mouvement du servomoteur, indiquent la validité de l'action.

6. Annexe

Tutoriel capteur de mouvement HC-SR501

http://henrysbench.capnfatz.com/hen...