1. Introduction

Ne serait-ce pas génial de pouvoir contrôler les objets à distance, de ne plus avoir à se lever pour éteindre la lumière ? C'est à partir de cette simple idée que m'est venue l'idée de mon projet. Je souhaite pouvoir commander la lampe de ma chambre à l’aide d’un objet que j’ai toujours sous la main : mon téléphone portable.

Ce projet consistera à connecter l'ampoule du plafond de ma chambre à un relais contrôlé par un RaspberryPi zero. Par le biais du HomeKit proposé par Apple, je pourrai contrôler le Raspberry et lui demander d'allumer et d'éteindre la lampe par la simple utilisation de ma voix. Je vais également essayer de pouvoir choisir la couleur de la lampe à l'aide d'une LED RGB. Ce projet me permettra de me familiariser avec les langages de programmations utilisés pour contrôler le RaspberryPi, que je désire utiliser afin de réaliser ce projet, et à mieux me représenter le fonctionnement des circuits électriques.

2. Matériel et méthodes

2.1 Matériel

  • 1 x RaspberryPi zero w
  • 1x Carte SD vierge
  • 1 x Relais 24V
  • Câbles
  • 1 x LED RGB
  • 1 x Breadboard
  • 3 x Résistances
  • 1 x Lampe
  • Pince à dénuder les câbles
  • Tournevis

2.2 Méthode

La réalisation de ce projet est divisée en huit parties.

2.2.1 Soudure du GPIO

Le GPIO du RaspberryPi zero n'est pas soudé initialement. Il m'a donc fallu le souder à l'aide d'un fer à souder. Le GPIO est conçu de façon à ce que l'on puisse le planter directement dans le relais, car le relais est un HAT. Je n'ai donc pas besoin de connecter le RaspberryPi au relais à l'aide d'un câble ou d'une breadboard.

2.2.2 Configurer la carte SD

Pour cette étape, j'ai utilisé une carte SD vierge formatée en FAT. Sur le site de raspberrypi.org, j'ai téléchargé l'installateur de système d'exploitation NOOBS (New Out Of the Box Software), qui contient Raspbian. Une fois le téléchargement terminé, j'ai copié les fichiers présents dans le dossier NOOBS sur ma carte SD vierge.
J'ai ensuite inséré la carte dans le RaspberryPi zero, et l'ai branché à ma télévision ainsi qu'à un clavier. Il m'a fallu ensuite sélectionner la langue du clavier (CH) et connecter le Raspberry au WiFi. J'ai ensuite installé le système d'exploitation Raspbian.

2.2.3 Configurer le relais

La première chose à faire une fois le Raspberry branché sur le relais est de le configurer. Il faut tout d'abord assigner un pin du GPIO à une des relais. Pour cela, il suffit d'appuyer sur le bouton noir à côté du relais. Le moniteur va d'abord afficher le mode de numérotation ("gP" pour numérotation du GPIO ou "Pn" pour numérotation du pin). J'ai choisi d'assigner le pin n°26 au relais.

Le moniteur va afficher un trait pour chaque relais allumé. Comme je n'ai besoin que d'un relais pour mon projet, si le moniteur affiche une barre, ma lampe sera allumée, et si toutes les barres sont éteintes, l'ampoule l'est également.

2.2.4 Brancher la lampe au relais

Je n'ai pas encore branché le relais à la lampe de mon plafond. Pour mon projet, j'ai commencé par utilisé une vieille lampe de bureau qui ne me servait plus. J'ai donc coupé un des deux fils du câble de cette lampe, et les ai dénudé. J'ai ensuite vissé les deux bouts du câble dans le relais. J'ai choisi de le mettre en Normally Open, afin d'éviter que la lumière reste allumée en cas de problème avec le Raspberry.

2.2.5 Ecrire les scripts pour contrôler le relais

HomeKit a besoin de trois scripts en python pour contrôler une lampe: un pour allumer la lampe, un pour l'éteindre et un pour connaître son état. Dans chacun des codes ci-dessous, j'ai commencé par importer les modules. J'ai ensuite indiqué de supprimer les messages d'erreur, et d'utiliser le numéro du board comme numéro de pin (afin que ce soit le même que sur mon relais, c'est-à-dire le 26).

#!/usr/bin/python
import RPi.GPIO as GPIO
import time
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)

Dans le premier code, pour éteindre la lampe, j'indique que le pin 26 est une sortie initialement à l'état haut (sans tension), donc allumé.

GPIO.setup(26, GPIO.OUT, initial=GPIO.HIGH)

Dans le deuxième code, pour éteindre la lampe, j'indique que le pin 26 est une sortie initialement à l'état bas (sans tension), donc éteint.

GPIO.setup(26, GPIO.OUT, initial=GPIO.LOW)

Dans le troisième code, servant à connaître l'état de la lampe, le pin 26 est une sortie. J'indique au Raspberry d'écrire l'état de la lampe ("1" pour allumé, "0" pour éteint).

print GPIO.input(26)

2.2.6 Configurer un accessoire

Afin de configurer un accessoire à HomeKit, j'ai utilisé un plugin appelé Script2. Il m'a tout d'abord fallu l'installer le script à l'aide de la commande:

sudo npm install -g homebridge-script2

J'ai ensuite écrit un script en Jason, donnant les informations sur ma lampe.

{
"bridge": {
"name": "Heloise Homebridge",
"username": "CC:22:3D:E3:CE:34",
"port": 51826,
"pin": "555-55-555"
},

Cette première partie de code donne des informations sur l'utilisateur et donne le code PIN associé au QR code de l'accessoire.

"accessories": [
{
"accessory": "Script2",
"name": "Bedroom Light",
"on": "/home/pi/laborelay/on.py",
"off": "/home/pi/laborelay/off.py",
"state": "/home/pi/laborelay/status.py",
"on_value": "1"
}
]
}

Cette deuxième partie donne des informations sur l'accessoire. J'ai appelé ma lampe "Bedroom light". J'ai indiqué à HomeKit d'exécuter le fichier /on.py pour allumer la lampe, et /off.py pour l'éteindre. Pour connaître l'état de la lampe, le fichier /status.py sera exécuté. La valeur affichée lorsque la lampe est allumée est 1, et 0 lorsqu'elle est éteinte.

2.2.7 Installer Homebridge

Afin de pouvoir contrôler mon Raspberry avec HomeKit, je suis passée par Homebridge. J'ai utilisé un code suivant, disponible à cet URL.

Il s'agit d'un code qui démarre l'installation automatique de Homebridge. L'installation prend environ 20 minutes. Une fois l'installation terminée, j'ai pu lancer Homebridge.

homebridge

Cette action nous donne un QR code, qu'il faut scanner avec l'application Maison sur iPhone. Cela va ajouter un accessoire, et il suffira de demander à Siri de l'allumer ou de l'éteindre.

2.2.8 Choisir la couleur de la lampe

Afin d'ajouter un peu de code à mon projet, je veux essayer de contrôler la couleur de ma lampe. Je ne voulais pas acheter d'ampoule qui change de couleur, alors j'ai opté pour une LED RGB que je contrôle par le biais de la breadboard. J'ai commencé par brancher la LED dans la breadboard. Une LED RGB comporte quatre pins. Le plus grand pin est la cathode, que j'ai connecté au ground. Le deuxième pin le plus long contrôle le vert, puis le rouge, et enfin, le plus court contrôle le bleu. Je les ai chacune connectés à un pin du GPIO en passant par une résistance.

Il m'a ensuite fallu écrire un code pour contrôler les couleurs de la lampe. J'ai commencé par les commandes habituelles pour contrôler le GPIO:

import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

J'ai ensuite crée des variables qui correspondent au numéro du pin de chaque couleur, afin de pouvoir changer une seule ligne si je souhaite utiliser un autre pin:

RED = 21
BLUE = 19
GREEN = 12

J'ai ensuite indiqué que les trois pins sont des sorties, et qu'elles sont initialement à l'état bas (donc éteintes):

GPIO.setup(RED, GPIO.OUT)
GPIO.setup(GREEN, GPIO.OUT)
GPIO.setup(BLUE, GPIO.OUT)
GPIO.output(RED, GPIO.LOW)
GPIO.output(GREEN, GPIO.LOW)
GPIO.output(BLUE, GPIO.LOW)

Pour finir, j'ai crée une boucle continue. L'utilisateur pourra entrer un nombre à trois chiffres entre 0 et 1. A l'aide d'un masquage, j'ai indiqué que la valeur du pin rouge sera égale au premier chiffre, le deuxième chiffre pour le vert et le troisième pour le bleu.

try:
while(True) :
request = raw_input("RGB-->")
if (len(request) == 3) :
GPIO.output(RED, int(request0))
GPIO.output(GREEN, int(request1))
GPIO.output(BLUE, int(request2))

except KeyboardInterrupt :
pass
finally:
GPIO.cleanup()

Ainsi, si l'entrée est 010, seul le vert sera allumé. Si l'entrée est 101, la LED donnera du bleu et du rouge, soit du violet. La LED sera blanche si l'entrée est 111, et éteinte en 000.

3. Résultats

Globalement, je suis très contente du résultat de ce projet. En effet, le contrôle de la lampe à distance par le biais de Siri fonctionne très bien, que ce soit pour allumer, éteindre ou connaître l'état de la lampe. Il me restera encore à brancher la lampe de ma chambre au relais à la place de la lampe de bureau, mais le résultat devrait être le même. En ce qui concerne la LED, la programmation fonctionne tout à fait dans la mesure où les câbles sont bien branchés. On peut tout à fait obtenir les 7 couleurs possibles. Le seul inconvénient est que la lumière rouge est moins forte que les autres, et a donc tendance à se faire dominer, surtout par le vert. J'ai tout de même très bien obtenu le résultat attendu.

4. Discussion

Ce projet n'était pas très compliqué, que ce soit au niveau du code ou de l'installation, mais il m'a tout de même pris beaucoup plus de temps que prévu. En effet, c'était la première fois que j'utilisais le Raspberry, un relais et une breadboard, et il m'a donc fallu me familiariser avec le matériel. Chaque étape paraissait simple, mais j'ai dû commencer de zéro, que ce soit la programmation en python, l'utilisation de HomeKit ou la base des circuits électriques, et j'ai dû surmonter de nombreux problèmes avant que tout ne fonctionne. Pour améliorer mon projet, je pourrais acheter une ampoule RGB et essayer de la contrôler avec Siri, mais cela demanderait beaucoup plus de connaissances car il n'existe pas de plugin permettant de configurer une lampe changeant de couleur. Je me suis donc contentée de contrôler la couleur de la lampe par le terminal pour ce premier projet.

5. Conclusion

J'ai beaucoup aimé faire ce projet, car il m'a apporté beaucoup de base dans plusieurs domaines. En effet, j'ai pu me familiariser avec la programmation du GPIO du Raspberry ainsi qu'aux bases de la breadboard grâce à la LED RGB. J'ai aussi appris à programmer en python afin de faire fonctionner le relais. J'ai pu également mieux comprendre le lien entre le monde physique et l'informatique en programmant une ampoule. J'ai également pu me familiariser avec le système Homebridge, permettant de connecter le Raspberry et Siri.

Je pense pouvoir affirmer que j'ai atteint mon objectif en réalisant ce projet. Il était certes basique, mais c'était un très bon premier projet, et il m'a beaucoup apporté. J'espère maintenant pouvoir continuer à progresser afin de pouvoir encore l'améliorer, car il n'est évidemment pas parfait. J'espère également pouvoir me lancer dans d'autres projets plus complexes à l'avenir.

Références

Package Script 2
RGB LED Control
Homebridge Installation
Download NOOBS
Relay Board Control