Aller au contenu principal
Retour au blogue

Développement logiciel

Allumer et éteindre une lumière de manière intelligente

Cydrick Trudel
31 juil. ∙ 10 mins
Allumer et éteindre une lumière de manière intelligente

Une de mes passions est d'intégrer différentes choses ensemble. Donc, en tant que projet d'été, j'ai décidé de m'essayer de faire de l'automation de maison avec des circuits électroniques et des senseurs. Je suis ici pour dire que c'est plus facile et moins dispendieux que vous le pensez. Voici un tutoriel que j'aurais aimé avoir avant de commencer.

La première chose que j'ai essayé de faire est d'allumer et d'éteindre une lumière en appuyant sur un bouton. Tout ce dont vous avez besoin est de batteries, d'une lumière, d'un bouton et voilà!

Pas très intéressant. Mais c'est correct, nous allons le faire de manière intelligente.

Le Raspberry Pi

Photo d'un Raspberry Pi

Ceci est un Raspberry Pi. C'est un ordinateur complet qui se vend pour $45 CAD. Pour son prix, il est remarquablement bien fourni. Autre que de pouvoir exécuter le système d'exploitation Linux, il possède:

  • 4 ports USB
  • Ethernet Gigabit
  • Une prise d'écouteurs 3.5mm
  • WiFi
  • Bluetooth
  • Jusqu'à 8GB de mémoire de vive, dépendant des variantes
  • Jusqu'à 2 prises HDMI supportant chacun des écrans 4K, dépendant des variantes
  • Une tête d'entrée / sortie à usage général (en anglais: General-Purpose Input / Output, ou GPIO)

C'est cette tête GPIO qui est particulièrement intéressante pour l'automatisation. La tête GPIO est composée d'une série de 40 broches (ou pins en anglais) qui peuvent soit:

  • Générer 3.3 volts
  • Générer 5 volts
  • Est mis-à-terre (grounded en anglais)
  • Possède l'habileté de contrôler le voltage d'une broche ou bien d'obtenir le voltage appliqué à la broche à partir d'un logiciel (appelé les broches GPIO)

Chaque broche est généralement identifiée par un nombre. Voici un schéma qui identifie ces broches (ceci va être utile plus tard) :

Schéma de la tête GPIO

Il existe un schéma de numérotation alternatif, mais nous allons garder les choses simples dans ce tutoriel. Notez aussi que les broches GPIO supportent au plus 3.3 volts, donc il n'est pas possible de raccorder une broche 5 volts à une broche GPIO. Très important à savoir pour ne pas griller votre Raspberry Pi…

Voltages et GPIOs

Le voltage peut être décrit comme une différence d'énergie potentielle. Une bonne analogie est celle de la chute d'eau: l'eau en haut de la chute possède une forte énergie potentielle, et durant sa chute, son énergie potentielle baisse. On dit que c'est de l'énergie potentielle puisque l'eau d'elle même ne possède aucune énergie, mais des tâches peuvent être accomplies avec de l'eau qui tombe: il est possible de mettre une turbine pour générer de l'électricité, de mettre des roches en dessous pour éventuellement les éroder, etc. S'il n'y avait pas de différence de hauteur entre le haut et le bas de la chute d'eau (essentiellement du sol plat), il n'y aurait pas de libération d'énergie potentielle. La hauteur de la chute d'eau peut être considérée comme le voltage dans un circuit électronique.

Quand on dit qu'une source électrique fournit 3.3 volts, on y décrit la différence entre l'état élevé d'énergie potentielle (référencée par +, 1 ou HIGH) et l'état bas d'énergie potentielle (référencée par -, 0 ou LOW). Dans le Raspberry Pi, les broches de mise-à-terre (ou ground en anglais) représentent l'état bas d'énergie potentielle et les broches qui fournissent 3.3 volts possèdent une énergie potentielle relative à la mise-à-terre. Les broches identifiées comme GPIO peuvent être contrôlées à partir d'un logiciel pour émettre soit un état HIGH ou LOW, ou bien pour lire le voltage appliquée à la broche.

Comprendre les platines d'expérimentation

Même si son nom semble complexe, les platines d'expérimentation sont un outil simple pour prototyper des circuits électroniques. Les circuits prototypées sur une platine d'expérimentation peuvent être convertis en un circuit électronique qu'on peut retrouver dans des jouets par exemple.

Survol d'une platine d'expérimentation

La platine d'expérimentation (breadboard en anglais) est une série de trous connectés d'une manière spécifique en dessous. Des personnes voulant prototyper un circuit vont prendre des fils et connecter les trous du dessus ensemble. Depuis le dessous, le courant électrique peut parcourir deux chemins. Si nous nous concentrons sur la moitié de gauche de la platine, le courant parcourt les deux colonnes de trous de gauche. Ces deux colonnes transportent généralement le + et le -. Puis, les ensembles de cinq trous de droite sont connectés en ligne. Chaque ligne est indépendante des autres. La même configuration est inversée sur le côté droit de la platine d'expérimentation.

Chemin du courant sur une platine d'expérimentation

Il est fréquent de connecter la source d'alimentation aux colonnes + et-, d'utiliser des fils de petite taille pour transporter le courant des deux colonnes vers des lignes spécifiques, et finalement de connecter les composantes électroniques sur les lignes. Voici un exemple d'un circuit fermé, ce qui veut dire que le courant passe de 3.3 volts sur la broche 1 directement vers la mise-à-terre à la broche 9:

Exemple d'un circuit fermé

Allumé et éteint

Maintenant que nous avons établis les bases, nous allons commencer par allumer et éteindre une lumière à partir d'un logiciel. Pour accomplir cette tâche, nous devons pouvoir envoyer un signal HIGH et LOW à la lumière en utilisant une broche GPIO controllable par un logiciel. La broche GPIO 3 va être utilisée pour cet usage, et la broche 9 va être utilisée comme mise-à-terre ou LOW. Notez que n'importe quel broche identifié comme GPIO et ground aurait pu être utilisé à cet usage. Un autre fait intéressant est que la longue broche de la lumière doit être connectée au +. La lumière que vous utilisez dans le circuit doit être compatible avec un signal de 3.3 volts, sans quoi il est nécessaire d'inclure des résistances dans le circuit. Voici le schéma du premier circuit.

Schéma du premier circuit

Et voici une photo du premier circuit:

Photo du premier circuit

Nous allons maintenant porter notre attention au logiciel. Nous allons utiliser le langage de programmation Python pour contrôler l'état de la lumière, mais rien de très avancé. Il existe plusieurs tutoriels pour installer Python. Vous aurez ensuite besoin d'installer la librairie appelée RPi.GPIO pour contrôler les broches GPIO. Pour se faire, roulez la commande suivante: pip install RPi.GPIO

Voici le code que nous allons utiliser pour allumer et éteindre la lumière:

import RPi.GPIO as GPIO
from time import sleep

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(3, GPIO.OUT, initial=GPIO.LOW)

state = GPIO.LOW
while(True):
	if(state == GPIO.HIGH):
		state = GPIO.LOW
	else:
		state = GPIO.HIGH
	sleep(1)
	print(f'Sending {state} to GPIO 3')
	GPIO.output(3, state)

Voici une décomposition du code:

Lignes
Description
1, 2 Import de librairies, particulièrement la librairie RPi.GPIO qui va permettre de contrôler les lumières.
4 Nous disons à la librairie que nous allons utiliser un schéma de numérotation de la tête GPIO spécifiques qui commence avec 1 pour la broche en haut à gauche, consistent avec le schéma utilisé dans ce tutoriel
5 Nous retirerons les avertissements concernant l'utilisation de la tête GPIO dans différents logiciels puisque nous allons exécuter ce code plusieurs fois.
6 Voici la partie intéressante. Nous signalons au Raspberry Pi que nous voulons utiliser la broche GPIO 3 en mode de sortie, ou output. Ce mode permet de mettre la broche GPIO en mode HIGH (donc 3.3 volts relatif à la mise-à-terre) ou LOW (donc 0 volts relatif à la mise-à-terre). Nous mentionnons aussi que nous désirons commencer avec le mode LOW pour que la lumière ne commence pas déjà allumée.
8 Nous déclarons une variable state pour garder l'état de la lumière.
9 Ceci est une boucle événementielle. Si vous avez déjà programmé des jeux videos, vous serez familier avec ce concept. C'est la boucle d'exécution principale dans notre logiciel qui va s'exécuter jusqu'à l'arrêt du logiciel.
10, 11, 12, 13 Ceci est une logique simple pour changer le contenue de la variable state, soit HIGH or LOW
14 Nous mettons sur pause l'exécution du logiciel pour une seconde (ou 1 Hertz). Combinée avec la boucle d'exécution, ceci veut dire que la lumière va s'allumer et s'éteindre une fois par seconde.
15 Impression de la variable state que nous nous apprêtons à envoyer à la lumière.
16 Nous disons au Raspberry Pi d'envoyer un signal HIGH ou LOW (respectivement 3.3 volts ou 0 volts, dépendant du contenue de la variable state) à la broche 3.

Et voici le résultat!

Ajouter un bouton

Nous allons complexifier les choses légèrement en ajoutant un bouton au circuit. Ce bouton va contrôler l'état de la lumière: appuyer sur le bouton va allumer la lumière, et le relâcher va éteindre la lumière.

Un bouton ne fait que fermer un circuit lorsqu'il est appuyé. Le voltage appliqué au bouton ne va pas être transmis lorsque le bouton n'est pas appuyé, et va le transmettre lorsque appuyé (agissant comme un fil). Nous allons devoir envoyer 3.3 volts à la pôle + du bouton, et connecter la pôle - du bouton à une broche GPIO qui est capable de lire le voltage sortant du bouton. Quand le bouton va être appuyé, la broche GPIO va être capable de lire que 3.3 volts (ou un signal HIGH) est reçu du bouton. Pour accomplir cette tâche, nous allons utiliser la broche 1 pour le signal 3.3 volts et la broche 13 comme la broche qui va lire le voltage. Encore une fois, n'importe quelle broche GPIO aurait pu fonctionner. Notez qu'avec ce modèle particulier de bouton, le dessous montre quel pôle est positive et négative.

Dessous du bouton

Voici le schéma que nous allons implémenter. Notez qu'il n'y a aucun changement concernant le circuit de la lumière.

Schematics of second circuit

Et voici le résultat sur la platine d'expérimentation:

Picture of second circuit

Le résultat est quelque peu chaotique, surtout en photos. Toutefois, les fils jaunes représentent le circuit de la lumière, et les fils bleus représentent le circuit du bouton.

Nous allons aussi changer le code que nous avons utilisé précédemment pour pouvoir lire le voltage provenant du bouton. Le changement le plus important est que nous allons utiliser l'état du bouton pour déterminer l'état de la lumière.

import RPi.GPIO as GPIO
from time import sleep

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(3, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(13, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

state = GPIO.LOW
previous_state = GPIO.LOW
while(True):
	sleep(0.05)
	state = GPIO.input(13)
	GPIO.output(3, state)
	
	if(state != previous_state):
		print(f'State went from {previous_state} to {state}')
		previous_state = state

Voici l'explication du code. Pour garder les choses brèves, l'emphase va être mise sur les changements principaux comparée à l'autre explication du code.

Lignes
Description
7 Nous disons au Raspberry Pi de s'attendre à une entrée sur la broche 13. Nous disons aussi d'ignorer les valeurs de voltages entre 0 et 3.3 volts en disant que la broche 13 est raccordé à un bouton poussoir (Pull Up-Down button)
12 Notre boucle événementielle précédente s'exécutait une fois par seconde. Dans ce cas, nous exécutons la boucle à chaque 0.05 seconds (ou 20 fois par seconds, ou 20 Hertz)
13 Nous obtenons l'état de la broche GPIO 13. Puisque nous avons configuré la broche 13 comme un bouton poussoir, nous pouvons nous attendre à un résultat HIGH ou LOW.
14 Nous donnons le résultat obtenu à la ligne 13 à la broche 3 qui contrôle la lumière.

Et voici le résultat!

Seulement le début

Personne n'utiliserait une méthode si élaborée pour allumer et éteindre une lumière en appuyant sur un bouton: Comme mentionné dans l'introduction, une batterie, une lumière et un bouton ferait l'affaire. Toutefois, considérez ceci: J'ai montré comment lire une entrée en Python, et comment donner un signal en sortie à partir de Python. La même logique serait applicable pour une multitude de senseurs pour ainsi créer votre propre IoT / périphérique intelligent. Voici quelques exemples de senseurs provenant d'un ensemble de 37 senseurs à $45 CAD:

Photo de senseur de niveau d'eau, d'un senseur d'alarme et d'un relais

Le senseur de niveau d'eau envoi un voltage différent de zéro s'il y a de l'eau détectée. Le senseur d'alarme émet un son lorsqu'un voltage est appliqué. Le relai laisse passer 120 volts (le même voltage que les articles électroménagers en Amérique du Nord) seulement lorsqu'un signal de 3.3 volts est appliqué sur les petites broches.

Avec ces trois modules, vous pouvez facilement fabriquer un système qui détecte s'il y a une fuite d'eau, émet un son, coupe l'électricité aux électroménagers proches et envoie une notification à l'aide du WiFi. Par conséquent, votre imagination (et la variété de senseurs qui existent) est la limite.

Image d'en-tête par Carlos Alberto Gómez Iñiguez
Icônes de bouton poussoir et de diode crées par smashingstocks - Flaticon