1. Introduction

On m’a souvent reproché d’oublier d’éteindre la lumière de ma chambre lorsque j’en sors et j’ai beau y avoir mis tous les efforts que je pouvais, je continue parfois d’oublier d’éteindre cette lumière. Voilà pourquoi je veux utiliser une machine, bien plus rigoureuse que moi, pour pallier à mes inattentions.

Le projet n’est pas très compliqué autant sur le plan matériel que logiciel mais étant donné que c’est le premier que j’entreprends, la tâche me parait adaptée.

Le système que je vais fabriquer devra pouvoir détecter quand une ou plusieurs personnes entrent dans la chambre et en sortent et allumer et éteindre en conséquence la lumière lorsqu’une ou plusieurs personnes se trouvent dans la chambre.

Pour cela, je me suis directement tourné vers un système infrarouge qui est très utile pour détecter une présence et même, lorsqu’il y en a plusieurs, un mouvement. Un émetteur infrarouge est situé en face de deux récepteurs, tous les trois accrochés sur une porte à l’aide d’un support. Lorsqu’une personne rentre ou sort, un des récepteurs est bloqué puis l’autre ce qui nous indique sa direction. Dès lors, un simple compte des personnes présentes dans la salle permet d’activer au besoin un relais électrique qui va allumer ou éteindre ce qui y est branché. Une trace des entrées et des sorties est également gardée.

2. Matériel et méthodes

2.1 Matériel

  • 1 x Rasberry Pi 3 (Model B)
  • 1 x grande breadboard
  • 2 x Sparkfun Solderable Breadboard Mini
  • 1 x câble d’alimentation USB à mini-USB
  • 1 x câble Ethernet RJ45
  • 1 x imprimante 3D Ultimaker
  • 1 x fer à souder Atten AT938D
  • 1 x bobine de soudure
  • 4 x connecteurs pins femelles individuels
  • 1 x ordinateur portable (avec le logiciel PuTTY installé si sous Windows et le logiciel SketchUp installé)
  • 1 x LED infrarouge
  • 1 x alimentation externe 5V (ici à piles électriques AAA)
  • 2 x Photorécepteurs infrarouges
  • 1 x Beefcake Relay Control
  • 1 x ADC 10-bit 8-channel MPU3008
  • 1 x multiprise "ouverte" avec câble électrique disponibles
  • câbles électriques normaux de différentes couleurs (une trentaine environ)
  • 3 x câbles électriques de minimum 1m de long
  • 1 x potentiomètre
  • 2 x LED RGB
  • 1 x LED jaune
  • 4 x résistances de 220 Ohms
  • 2 x résistances de 10'000 Ohms
  • 1 x jeu de tournevis plats de précision (de 1.4 à 3.0 mm)
  • 1 x cutter
  • 4 x vis de 2.9 mm de diamètre et de 13 mm de longueur
  • 2 x ressort de 10.8 mm de diamètre et 30 mm de longueur
  • 4 x pads antidérapants de dimensions 15x15 mm ou supérieure
  • (quelques bouts de ficelles)

2.2 Méthode

La réalisation de ce projet s’est divisée en sept parties :

2.2.1 Préparation du Raspberry Pi

La première étape à réaliser est la préparation du Raspberry Pi afin de pouvoir l’utiliser par la suite. On connecte le Raspberry Pi avec le cable d'alimentation en USB et avec le cable Ethernet RJ45 et on se connecte en SSH en utilisant PuTTY sous Windows. Cela peut paraitre simple mais c’est loin d’être une partie de plaisir, car il faut trouver l’adresse IP du Raspberry Pi. Pour cela, j’ai finalement connecté mon Raspberry Pi sur un moniteur externe et branché un clavier et une souris à celui-ci, puis j'ai suivi . A savoir que cette étape n'est pas indispensable. J'ai appris plus tard qu'un petit logiciel nommé Nmap permet de le faire depuis son ordi.

Avec cette adresse trouvée, on entre l'adresse IP dans le "Host name" et on ouvre la connection. Un terminal s'ouvre et nous demande le mot de passe. Après l'avoir rentré, on peut finalement commencer à coder.

Ce projet a été programmé en python, qui est un language de programmation simple à apprendre et à coder. Le code s'est inspiré de l'exemple skel.py, fourni sur le GIT, qui rend la gestion des erreurs et la programmation en elle-même plus simple et plus sûre. L'environnement de programmation Python était déjà installé sur le Raspberry Pi.

2.2.2 Montage provisoire du système

Le montage s'est d'abord effectué sur Arduino car mon idée de base était d'utiliser Arduino et Raspberry conjointement. Quelques essais notamment pour la partie infrarouge et le contrôle du relais sont sur le GIT. Le projet s'est au final rapidement détaché de la plateforme Arduino car le Raspberry offrait toutes les options nécessaires. Le système se compose de deux petites breadboards, un émettrice et l'autre réceptrice. L'émettrice est composée d'une LED infrarouge et d'une LED RGB normale de contrôle, toutes deux connectés en parallèle à du courant avec pour chacune une résistance de 220 Ohms. Le courant est fourni par une alimentation externe à pile électrique AAA. Cette partie va donc émettre continuellement des infrarouges. La LED de contrôle est uniquement là pour s'assurer que le système fonctionne bien, elle s'allume en vert tant qu'il fonctionne.

Figure 1 : Photo du système, fév. 2017

La réceptrice se compose de deux photodiodes infrarouges, toutes deux connectés en parallèle à une alimentation de 3.3V avec des résistances de 10'000 Ohms, mais avec des sorties séparées. La plateforme réceptrice est connectée à la grande breadboard de contrôle qui est elle directement connecté au Raspberry. Le courant est fourni par le Raspberry et les deux sorties des photodiodes sont traitées séparément.

Figure 2 : Photo du système, fév. 2017

Les photodiodes vont chacune laisser passer une certaine quantité de courant selon la luminosité en infrarouges. C'est pour cela que les sorties sont séparées, c'est car elles transportent une information analogique très importante qui va être utilisée. Lorsque le courant provenant de ces sorties diminue, on sait que la luminosité en infrarouges diminue également et que donc que les infrarouges de la plateforme émettrice ne sont plus captés car quelque chose bloque le chemin. On peut donc détecter que quelqu'un est passé devant le système et en sachant laquelle des photodiodes réagit avant l'autre, on peut savoir si cette personne rentrait (la photodiode de l'intérieur est activée avant la photodiode de l'extérieur) ou sortait (le contraire). C'est pour cela que deux photodiodes sont nécessaires. Les valeurs analogiques provenant de cette plateforme réceptrice doivent être traité par le Raspberry Pi mais celui-ci ne peut que traiter des valeurs digitales. On utilise donc un ADC (Analogic-to-Digital-Converter), un convertisseur analogique-digital, ici le MPU3008. Cette pièce n'est pas facile à utiliser mais beaucoup de documentation existe sur le site du vendeur . Le câblage s'est donc effectué sans trop de problème en suivant consciencieusement l'exemple fourni sur le site. La configuration de l'ADC a été faite de manière logicielle et sera donc expliquée plus tard.

Le relais électrique, ici un beefcake relay control, a également été raccordé à la breadboard principale au courant ainsi qu'au pin de contrôle qui servira à l'allumer et à l'éteindre. Il dispose d'une LED de contrôle intégrée avec laquelle il est possible de le tester. Il n'est donc pas encore relié au réseau électrique.

Une LED de contrôle globale a également été installé pour montrer quand est-ce que le programme a été lancé car le démarrage prend un certain temps et certaine opérations importantes doivent s'effectuer avant toute interaction de l’utilisateur. Celles-ci seront expliquées dans la partie logicielle. La LED s'allume en vert quand le système est prêt et qu'il fonctionne. A cela a également été ajouté une LED de signal, qui s'allume en jaune lorsque qu'une entrée et une sortie. Celle-ci n'est pas indispensable mais très utile pour tester le système sans ordinateur. Un potentiomètre a plus tard été ajouté pour permettre un contrôle de la sensibilité du système. Celui-ci reçoit un courant de 5V du Raspberry Pi, en revoie une partie sous le GND ("ground") mais en dévie une partie dans un troisième pin. Cette quantité de courant peut alors être interprétée comme une valeur analogique par l'ADC déjà installé et peut donc servir à contrôler la sensibilité du système, comme démontrée dans la partie logicielle.

Figure 3 : Montage du système, fév. 2017

Figure 4 : Montage du système, fév. 2017

Figure 5 : Montage du système, fév. 2017

2.2.3 Programmation du code provisoire

Le code a avancé petit à petit en commençant sur Arduino avant de continuer sur Python sur le Raspberry. Ici ne sera décrit que le code Python final car c'est lui qui a été utilisé au final mais tous les autres sont disponibles sur le GIT.

Un fichier d'exemple skel.py nous a été donné pour faciliter notre programmation mais il est tout de même important d'expliquer, même brièvement ce qu'il fait.

Premièrement, quelques librairies sont importés : celle qui permet d'utiliser le GPIO (General Purpose Input Output) et d'utiliser spécialement chacun des pins du Raspberry Pi et une autre qui permet de dire au Raspberry à certains endroits du programme d'attendre.

import RPi.GPIO as GPIO  
from time import sleep

Deuxièmement, le GPIO est programmé pour utiliser une numérotation des pins plus simple, la numérotation BCM.

GPIO.setmode(GPIO.BCM)

Troisièmement, le programme rentre dans une sorte de mode "conditionnel" dans lequel les erreurs sont "capturés" puis affichés et qui permet à l'utilisateur de quitter à tout temps le programme en appuyant sur CTRL+C. Le code écrit dans cette partie est donc "surveillé" et contrôlé ce qui rend la chasse aux bugs et autres problèmes beaucoup plus simple.

try:
# Main code
except KeyboardInterrupt:  
    # ctrl+c
    pass
except Exception as error: 
    # error
    print error

Finalement, les ports du GPIO utilisés sont"nettoyés" à la fin du programme pour éviter que des erreurs se produisent après l'utilisation du programme.

finally:  
# always clean up before leaving
 GPIO.cleanup()

Le reste du code a été fait dans le cadre de ce projet en s'inspirant toutefois de plein d'autres codes mais ceux-ci seront cités quand ils seront décrits. Après avoir copié le code de skel.py dans un nouveau fichier nommé rasp_project.py, la première chose à faire a été d'importer deux librairies de plus dans le code. C'est les seules lignes de commande qui se trouve en dehors du mode "conditionnel" dont j'ai parlé précedemment. La première, spécifique à l'ADC MPU3008, est nécessaire pour le faire fonctionner correctement.

# import ADC MCP3008 library for SPI
import Adafruit_MCP3008

La deuxième sera nécessaire plus tard pour trouver la date et l'heure actuelle qui seront utilisées dans le fichier log mais cela sera expliqué plus tard.

  1. import datetime module to print dates and time

import datetime

Ensuite, le code se sépare en deux parties : les préparatifs et la boucle principale. En tout premier, un petit bout de code qui a été ajouté un peu en catastrophe. En effet, après avoir soudé les composants de la partie émettrice et réceptrice et l'avoir testé un peu, j'ai vite pu remarquer que les résultats n'étaient plus les mêmes. La cause du problème a rapidement été détectées, la LED infrarouge avait été soudées sur le côté et non pas au milieu du breadboard. Etant donné que cette LED est directionnelle et qu'elle était plus en face d'un des récepteurs que de l'autre, celui-la (celui à l'intérieur, "inside") détectait une valeur plus haute que l'autre (celui à l'extérieur, "outside"). Pour corriger ce problème, j'ai simplement compensé avec une valeur fixe mis à 20 pour que les valeurs des deux récépteurs reviennet à peu près égales. Cette méthode n'est clairement pas parfaite car cet écart peut varier selon la disposition des supports mais elle marche pour l'instant.

  1. compensation

c = 20

Maintenant dans les préparatifs, il a fallu tout d'abord configurer l'ADC en utilisant la librairie importée auparavant. L'exemple fourni par le site de l'ADC a été repris mot pour mot sans se poser de question car la documentation s'est avérée un peu compliquée. La configuration a été faite de manière logicielle car c'était la plus simple et lorsque les branchements ont été faits correctement et que les bons pins ont été attribués, le programme d'exemple fourni par ce même site a fonctionné. Il a donc été laissé tel quel.

Figure 6 : Pins de l'ADC MPU3008, fév. 2017

# software SPI
CLK = 18
MISO = 23
MOSI = 24
CS = 25
mcp = Adafruit_MCP3008.MCP3008(clk=CLK, cs=CS, miso=MISO, mosi=MOSI)

Deux canaux (channels) ont ensuite mis en place, le 0 et le 1 (voir figure x), respectivement inside (pour la photodiode à l'intérieur) et outside (pour la photodiode à l'extérieur). Etant donné que l'orientation est faite pour rester toujours la même, ceci ne devrait pas avoir besoin d'être changé mais dans un cas (rare) ou le placement des supports sur la porte ne permet pas de les mettre dans cet ordre, il faudrait alors les inverser dans le code également.

# ADC channel setup
inside = 0
outside = 1

Le relais électrique est également configuré dans les préparatifs. On lui attribue un pin et, important, on définit ce pin comme pin de sortie (output). Ceci a été une des causes principales pour laquelle mon code n'a jamais marché au début.

# relay setup
relay = 17
GPIO.setup(relay, GPIO.OUT)

On va ensuite préparer le système de contrôle de la sensibilité. Dans les préparatifs, on va juste attribuer dans une variable le pin de celui-ci ainsi que créer une variable vide, qui nous sera utile plus tard. Ce pin-là est celui de l'ADC car c'est une valeur analogique qu'on va devoir lire. Etant donné que le contrôle se fera dynamiquement, la valeur de celui-ci est donnée dans la boucle principale. Ensuite, on va prendre une valeur de sensibilité par défaut, on prend juste la moyenne des deux valeurs captés par les récepteurs. C'est cette valeur qui sera notre seuil en-dessous duquel les récepteurs détecteront un passage. La valeur du potentiomètre contrôlé par l'utilisateur permettra donc de faire varier légèrement ce seuil.

  1. IR_marge and IR_default

potentiometer = 2 IR_default = /2

Pour continuer, on crée déjà la variable du nombre de personne dans la salle. Celle-ci n'est pas indispensable ici mais elle est utile pour pouvoir se repérer plus tard.

# people counter
in_room = 0

On va également créer pendant les préparatifs le fichier dans lequel seront enregistrées toutes les entrées et sorties (fichier log). Ce sera un simple fichier texte . La création de fichiers n'est pas très compliquée sous Python. Je me suis implement aidé de ce guide . Ici, on créé simplement une "instance" sous la forme d'un fichier dans laquelle on va ensuite écrire dans le mode "a" (pour Append), c'est à dire à la suite du texte précédent. Il est juste important de se rappeler de fermer cette instance après avoir fini d'écrire sans quoi les données finissent souvent à la trappe. Le backslah-n (\n) est utilisé pour revenir à la ligne à chaque fois.

# create logfile
f = open("log.txt", "a")
f.write("Log\n")
f.close()

On met ensuite en place la LED de signal qui va s'allumer à chaque entrée ou sortie.

# signal LED
signal_LED = 5 
GPIO.setup(signal_LED, GPIO.OUT)

On met également en place un "bloqueur d'événements" qui sera expliqué en détails plus tard.

# event_blocker
block = 0

Finalement, pour indiquer à l'utilisateur que le système est prêt. On va allumer une LED en vert. On la paramètre donc avec son pin en sortie (output) et on envoie le courant.

#READY
LED_ready = 4
GPIO.setup(LED_ready, GPIO.OUT)
GPIO.output(LED_ready, GPIO.HIGH)

Ensuite vient la boucle principale et la première chose que l'on va faire est de mettre la date et l'heure actuelle dans une variable appelée "now". La commande utilisée vient du module datetime et l'exemple que j'ai utilisé dans mon programme vient ce site. La commande datetime du module du même nom va nous donner la date au format aaaa-mm-jj et l'heure au format hh:mm:ss.uuuu (u pour microsecondes).

# get datetime
now = datetime.datetime.now()

Ensuite, on va régler la valeur de notre seuil de luminosité infrarouge. Il est important que cela soit fait au début de la boucle car la suite en dépend. Pour cela, on va récupérer la valeur du potentiomètre grâce à l'ADC comme expliquée plus tôt et la diviser par 10 pour obtenir une valeur plus facile à manipuler (0-102 au lieu de 0-1024). On va ensuite utiliser la valeur par défaut déterminées dans les préparatifs et soustraire la valeur de contrôle de l'utilisateur pour déterminer notre seuil. Plus la valeur de contrôle de l'utilisateur sera élevée, moins le sera le seuil.

# set IR_marge and IR_seuil
IR_marge = mcp.read_adc(potentiometer)/10
IR_seuil = IR_default - IR_marge

C'est ensuite que vient le cœur du programme. On va ici lire les valeurs renvoyées par les photodiodes et les comparer à la valeur du seuil. Si la valeur de l'extérieur descend en dessous du seuil, on teste alors la valeur de l'intérieur et si celle-si descend aussi en dessous du seuil, cela veut dire que quelqu’un vient de rentrer dans la salle. On ajoute donc une personne à la variable in_room et on ouvre le fichier texte pour y écrire la date, l'heure et le nombre de personnes présentes dans la salle et on ferme le fichier log. On va ensuite activer le "bloqueur d'événements" qui va être important pour la suite. On signale ensuite le passage en allumant la LED de signal et on attend 1 secondes que la personne ait le temps de traverser la porte et on éteint la LED de signal.

# detect IR change
if mcp.read_adc(outside) < IR_seuil:
       if (mcp.read_adc(inside) -  c) < IR_seuil:
               # add person in_room
               in_room+=1
               # open log and write date, time and peaople in room
               f = open("log.txt", "a")
               f.write(str(now)+ "	|	in_room = "+str(in_room)+"\n")
               f.close()
               # block the events
               block = 1
               # signal the passage
               GPIO.output(signal_LED, GPIO.HIGH)
               # wait
               sleep(1)
               GPIO.output(signal_LED, GPIO.LOW)

Par contre, si c'est d'abord la valeur de l'intérieur qui descend en dessous du seuil puis la valeur de l'extérieur, c'est que quelqu'un vient de sortir de la salle. On va alors appliquer les mêmes actions à quelques différences près. Cette partie du programme ne va s'effectuer seulement si la première ne s'est pas effectuée pour éviter que un passage soit compté à double. On utilise pour ça la valeur "block". On entre dans cette partie que si celle-ci est égale à 0, ce n'est pas le cas quand la première partie s'est déclenchée (elle est alors égale à 1). Cette valeur est par la suite remise à 0. On va ensuite enlever une personne de la variable in_room et si cette variable est en dessous de 0, ce qui veut dire qu'une erreur s'est produise, on va la remettre à 0. Tout le reste s'effectue comme dans la première partie.

if (mcp.read_adc(inside) - c) < IR_seuil and block == 0:
       if mcp.read_adc(outside) < IR_seuil:
               # remove person in_room
               in_room-=1
               # reset value in case of error
               if in_room < 0:
                       in_room = 0
                       # open log and write date, time and peaople in room
                       f = open("log.txt", "a")
                       f.write(str(now)+"	|	in_room = "+str(in_room)+"\n")
                       f.close()
                       # signal the passage
                       GPIO.output(signal_LED, GPIO.HIGH)
                       # wait
                       sleep(1)
                       GPIO.output(signal_LED, GPIO.LOW)

A la fin de notre boucle, on va activer le relais électrique ou non selon s'il y a des personnes dans la salle.

if in_room>0:
       # activate the relay
       GPIO.output(relay, GPIO.HIGH)
else:
       # de-activate the relay
       GPIO.output(relay, GPIO.LOW)

On va également réinitialiser la variable "block" pour la prochaine boucle.

# de-block the events
block = 0

Puis c’est reparti ! La boucle redémarre et continue à tourner indéfiniment en répétant toujours les mêmes instructions. Le code complet est disponible sur le GIT

2.2.4 Installation de la multiprise sur le relais électrique

L'installation de la multiprise sur le relais électrique a été extrêmement simple car une multiprise "ouverte" m'a été fournie. Sur cette multiprise, les deux câbles électriques la composant étaient à l'air libre. Il m'a donc suffit de les attacher au support du relais électriques et de les y visser pour les maintenir en place. Une photo du système est disponible en dessous. Figure x : Relais électrique fixé sur la multiprise

Figure 7 : Montage du système, fév. 2017

2.2.5 Soudure du système infrarouge

La soudure des composants de la partie émettrice et réceptrice s'est effectuée sans problème à part le fait que la LED infrarouge ait été soudée pas au milieu mais sur un côté, ce qui comme expliqué plus tôt a posé un problème pour la précision du système. Les composants n'utilisent à chaque fois qu'une moitié des mini breadboards, l'autre a donc été coupée au cutter pour gagner de la place.

2.2.6 Impression en 3D des supports

Deux supports étaient nécessaires pour fixer les parties émettrice et réceptrice sur la porte. Ceux-ci devaient pouvoir s’adapter à (presque) tous types de portes et accueillir mes deux mini breadboards. Etant donné qu’un tel système qui répondait à tous mes besoins n’était pas disponible, j’ai décidé de créer le mien grâce à une imprimante 3D. J’ai utilisé le logiciel SketchUp pour faire mes modèles en 3D. Le principe est assez simple. Les deux supports consistent d'une pièce centrale en forme de U qui vient entourer le cadre de la porte. Un trou dans un des côté de cette pièce laisse passer une vis qui va servir à serrer le support sur la porte. Pour maintenir la pièce en place, un ressort accompagne la vis et va maintenir la pièce principale appuyée contre le cadre de la porte. Quelques pads antidérapants sont collés de part et d'autre pour assurer le maintien et un endroit est arrangé pour pouvoir y visser les supports avec deux vis à chaque fois. Les deux supports se font face vu qu'ils sont situés de part et d'autre du cadre de la porte. Sur l'émetteur, un emplacement pour la batterie qui alimente le tout a été aménagé. Sur le récépteur, une encoche dans laquelle on peut faire passer les fils qui descendent jusqu'à la breadboard principale a été également aménagée. Les modèles SketchUp sont disponibles dans la médiathèque du blog.

Support émetteur : IR_emetter_final.skp

Support émetteur, fév. 2017

Support récépteur : IR_receiver_final.skp

Support récepteur, fév. 2017

Vis de serrage (présentes à deux exemplaires) : IR_serrage_2Xaxe.skp

2.2.7 Montage du système final

Finalement, avec le Raspberry Pi paramétré, le matériel en place, le code qui marche, la multiprise raccordée, les breadboards soudés et les supports imprimés, il ne restait plus qu'à assembler. Cette étape a été assez facile mais est venue avec une "surprise". En effet, le système qui marchait très bien en théorie et en parties, ne donnait plus les mêmes résultats une fois en situation réelle. Les valeurs captés par les récepteurs infrarouges étaient beaucoup plus fluctuantes et le système beaucoup moins réactif et efficace. N'ayant pas le temps de refaire le projet de A à Z, j'ai continué avec ce que j'avais en tête. La machine a été parametré pour qu'elle lance le programme au démarrage, pour cela je me suis aidé de cette page web. Mon projet était donc fini.

Montage final, fév. 2017g

Si jamais je revenais à le démonter ce qui va surement arriver pour le transport, il est important de savoir où les câbles de la partie réceptrice se fixent sur la breadboard principale. Le câble bleu va sur l'alimentation 3.3 V du Raspberry Pi, le câble jaune va sur le channel 0 de l'ADC et le câble vert sur le channel 1 (voir Figure 6). Tout le reste n'a pas besoin d'être démonté et les différentes figures permette de remettre rapidement le système en place.

3. Résultats

L'objectif a été atteint mais les résultats sont quelque peu décevant. En effet, même si le matériel, le code et tout le concept marche comme je le voulais, la détéction des entrées et sorties laisse un peu à désirer. La sensibilité du système est difficile à régler correctement et comprend toujours quelques bugs qui n'ont, malgré tous mes efforts, pas réussi à être éliminés, comme le fait que si on tourne le potentiomètre dans un sens jusqu'au bout, le système entier se met à dérailler et les récepteurs infrarouges renvoient des valeurs fausses sans raison apparente. De plus, même si le code fonctionne bien, le système a de la peine à différencier les entrées des sorties voire à les détecter tout simplement ce qui rend toute utilisation dans la vie réelle difficile.

4. Discussion

La réalisation de ce projet a été difficile, non pas par sa taille ou sa complexité qui étaient assez standards mais par la multitude d'aspects qu'il touche. Pour le mener à bien, il a fallu apprendre à utiliser le Raspberry et les différents composants utilisés, à coder en Python, à souder à modéliser des objets en 3D, etc. Il a été par contre une grande source d'inspiration et de motivation pour de futurs projets et une entrée dans le monde de l'électronique. Mais comme on peut l'attendre de tout premier projet, les erreurs et les limitations de ma connaissance à ce sujet n'ont pas exactement donné les résultats attendus. Les connections infructueuses au Raspberry Pi et au GIT, les incessantes erreurs de Python dans mon code et les difficultés à assembler les différentes parties du système ensemble en sont quelques exemples. Le temps a aussi été un facteur qui n'a pas joué en ma faveur. J'avais pourtant mis un plan de répartition de mon travail en place mais j'ai sous-estimé un peu le projet. Beaucoup de remarques dont je pourrais prendre compte lors d’un prochain projet.

5. Conclusion

Au final, le système marche si l'on va suffisamment lentement mais il fait quand même un grand nombre d'erreur. Le projet est tout de même arrivé à son terme et cela constitue déjà un petit succès en soi. Pour l'utiliser, voilà une sorte de mode d'emploi :

  1. Fixer le support émetteur sur le cadre de la porte à hauteur de taille et l'allumer avec le switch "on/off" de la batterie. Une LED devrait s'allumer en vert lorsque cela est fini.
  2. Fixer le support récepteur sur le cadre de la porte en face de l'autre.
  3. Brancher le Raspberry Pi au courant et le laisser démarrer. Une LED va alors briller faiblement en vert. Lorsque le démarrage et fini et que le programme est lancé. La LED verte devrait briller plus fortement.
  4. Régler la sensibilité du système avec le potentiomètre bleu. Une LED jaune s'allume à chaque passage. Si elle est constamment allumée, c'est que la sensibilité est trop haute ou trop basse, veuillez alors la régler convenablement puis redémarrer le Raspberry Pi.
  5. Brancher la multiprise connectée au réseau électrique et y brancher un appareil électrique de votre choix.
  6. Le système est prêt à être utilisé. Quand il y a des personnes dans la salle, l'appareil électrique connecté va s'allumer puis s'éteindre quand il n'y a plus personne.
  7. Le fichier log est consultable sur le Raspberry Pi sous /home/pi/Desktop/Projet/log.txt