Raspberry Pi 5 avec Java et Python
Une étude de mon tout dernier Pi
Date de la dernière modification: 8 décembre 2024 et commencé mi-septembre 2024
En travail : études des différences avec les anciennes versions du Pi, en particulier les broches GPIO!
Au début, il y aura sans doute quelques erreurs, des imprécisions et pas mal d’adaptations dues aux libraries et au modèles anciens comme le Raspberry Pi 4!
Le Raspberry Pi est un outil didactique incroyable comme pour apprendre à configurer un système d’exploitation, à utiliser les commandes Linux, sa console et évidemment la programmation Python et Java (deux des languages les plus présents dans le monde informatique d’aujourd’hui). J’ai découvert récemment Gemini de Google, une intelligence artificielle (IA, AI), qui donne aussi de superbe réponse lorsqu’on recherche du code ou des API à utiliser en langage Python et Java.
Dans plusieurs cas d’application, utiliser un micro-controlleur du type ESP32 ou Arduino pourra aider à comprendre, à configurer et à programmer un capteur ou un relais.
Le point de départ c’est évidemment mon Un livre sur Java, Python, Eclipse et le Raspberry Pi 3 dont je reprends les exemples, fais des adaptations pour le Pi 5 et découvre des alternatives de design!
Projet: au choix, minuterie pour ma pompe de filtration (piscine) ou luminaire intérieur.
Besoin, au minimum: un relais (5 – 220V), un ou plusieurs capteurs de température et un senseur de lumière.
Pas d’écran, mais accès avec une connexion à distance et un serveur Web.
Développement du logiciel sur PC (dont Eclipse ou simplement Notepad++ ).
Pour les débutants “tout neufs” je conseillerais peut-être de commencer par le capteur de présence (PIR) en fin d’article.
L’application décrite dans l’article Raspberry Pi 3 – Java – Un projet conséquent fonctionne depuis plus de 10 ans sur mon armoire à l’entrée avec un Pi Zero (un de mes 6 Raspberry Pi)!
Les luminaires sont allumés en fonction des heures du lever et du coucher du soleil. Il y a une partie d’aléatoire (simulation de présence) ainsi qu’un capteur de mouvements si je descend les escaliers et qu’il y a pas assez de lumière (donc un autre capteur).
Celui que j’utilise le plus souvent, ces jours-ci, en début d’automne 2024, est décrit dans Comment régler sa pompe à chaleur pour une consommation optimale d’électricité. Je consulte son interface Web plusieurs fois par jour!
Il faut parfois pas mal de courage pour s’y retrouver dans l’utilisation de ces capteurs. Moi-même j’ai souvent un ESP32 allumé à côté de mon Raspberry Pi et avec un Arduino IDE actif sur mon PC. L’article PIR Sensor Interfacing with ESP32 devrait donner des idées aux lecteurs. L’ESP32 possède deux cœurs où il est possible de traiter deux “applications” en parallèle similaire à deux threads en Java. Donc un moyen de tester le fonctionnement des timings des capteurs et d’analyser d’autres approches de design!
L’idée ici est de programmer le Pi 5 comme on le ferait avec une minuterie journalière mécanique, où il suffit d’abaisser les touches des quarts d’heure. Pour une piscine, les périodes de filtrations dépendent essentiellement de la température de l’eau et il pourrait être possible de passer en auto-consommation si l’on possède une installation photovoltaïque (partie à étudier encore)!
Un peu d’histoire et quelles versions
Mon premier Raspberry Pi date de 2014, il n’avait ni Wi-Fi, ni Java.
J’y avais ajouté un dongle Wi-Fi USB et installé à la main une machine virtuelle Java (mon langage de programmation favori)!
On trouver de nos jours, sur le Web, une foule d’articles et de codes dédiés aux composants électroniques divers qu’on peut attacher aux broches (pinouts) GPIO du Raspberry Pi.
Les exemples en Python d’avant Pi 5 (donc avec la librairie RPi.GPIO) devront donc être adaptés et revisités pour satisfaire ce nouveau Pi 5 avec de nouvelles bibliothèques GPIO (un peu déçu et contrarié).
Donc attention: un Ctrl-C Ctrl-V d’anciens scripts code Python ne suffira pas.
J’ai l’habitude de noter dans mes script Python à la fois le numéro de la broche et celui du GPIO. Par exemple:
RelayPin = 23 # broche 16 (GPIO 23 – PI 5)
On le comprendra bien sur le schéma Raspberry Pi 5 Pinouts including GPIO for the 40 Pin Header où pin c’est broche et le pin 01 (3.3V) est à l’intérieur comme tous les impaires.
Voir aussi, par exemple: Voici le Raspberry Pi 5 avec des améliorations à tous les étages!
J’ai actuellement trois Raspberry Pi actifs, deux en travail sur mon bureau , donc 5 IPs différents.
La commande cat /sys/firmware/devicetree/base/model retourne le modèle et c’est pratique pour s’y retrouver, parfois!!
Si on a des doutes sur la version d’OS installée, c’est la commande cat /etc/os-release.
Parfois on ne sait plus avec quelles versions de Java ou de Python on travaille, alors java -version et python -V.
Lorsqu’on bricole avec de petits programmes, c’est mieux de positionner ces outils dans des répertoires fixes sur la racine /home/pi comme chez moi dans des sous-répertoires séparés python ou jbb_java.
The Pi 5 est similaire au Pi 4 avec les mêmes broches GPIO, mais attention aux librairies GPIO.
Installation
Le logiciel Windows Raspberry Pi Imager v1.8.5, pour créer la carte SD, est disponible sur le site du Raspberry Pi.
Cette carte sera ensuite insérée sous le boîtier du Pi 5.
Ce logiciel permet aussi de créer une carte SD avec un autre système d’exploitation supporté et valide pour par exemple le Raspberry Pi 4.
Le Pi 5 avec Bookworm 64 bits ne fonctionne pas pour mesurer la lumière avec un photo senseur et la librairie gpiozero. Il faut alors utiliser un Pi 4 avec Bullseye 32 bits et la librairie RPi.GPIO qui est utilisée mon livre Programmer en Java pour le Raspberry Pi).
Il peut arriver qu’on joue à la fois sur un Pi 4 et et un Pi 5 et c’est facile avec nos planches à pain puisque les broches (pinouts) sont équivalentes.
Pour les anciens Raspberry Pi, la partie de la configuration WiFi et du SSH étaient bien moins agréable!
On lance l’application pour ensuite choisir le modèle Pi 5 et la version PI OS (64 bit) plus rapide de 25% que la 32 bit.
On choisira le stockage (K: chez moi), un lecteur USB de cartes SD avec une carte vierge ou effaçable (SanDisk Ultra PLUS microSDHC de 32 GBytes pour moi).
En cliquant sur SUIVANT on obtient la fenêtre suivante:
Le bouton MODIFIER REGLAGE permet de définir un nom pour ce Pi et le paramètres WiFi. J’utilise le même mot de passe que mes autres Pi et il faut connaître les paramètres du routeur!
Dans l’onglet SERVICES positioner les cases SSH avec mot de passe!
On enregistre les réglages (bouton ENREGISTRER) , on les applique et on en démarre l’écriture avec le bouton OUI.
Accepter que toutes les données soient effacées (disque USB K: chez moi) et c’est parti:
A la fin de l’écriture on reçoit un message indiquant qu’on peut retirer la carte SD! Celle-ci contient le système d’exploitation Raspberry Pi OS.
Je lance mon outil Web pour l’accès à mon routeur, j’insère la mini carte SD dans (sous) le Pi 5, je branche l’alimentation et j’attends de voir le clignotement de la led verte: je vois alors dans mon outil du routeur mon nouvel appareil actif avec l’adresse IP 192.168.1.121 (ou autre) et le nom attribué PiPiscine!
Avec la page Web qui gère le réseau de mon routeur, je lui attribue une adresse IP fixe, c’est bien pratique!
Premier accès avec Putty (expliquer: à faire)
Il me permet d’accéder à mon nouveau Pi 5 dans une console!
Et ça fonctionne!
Premier accès avec WinScp (expliquer: à faire)
C’est un accès pour transférer des fichiers depuis ou sur mon PC.
Et ça fonctionne!
Pour terminer, dans Putty, la commande sudo halt permet de stopper correctement le Pi, c’est beaucoup mieux que de couper l’alimentation!
Utiliser un écran et un clavier
Ce Pi 5 sera installé quelque part dans la maison, sans écran, ni clavier, ni souris: un “simple” objet connecté accessible avec PuTTY et WinSCP et plus tard au travers du Web!
L’installation décrite ci-dessus a évidemment monté tout le logiciel afin de pouvoir travailler avec un écran HDMI, un clavier USB et une souris USB. Il faudra sans doute un mini adaptateur pour un câble standard HDMI. Le Pi 5 c’est MICRO-HDMI.
A tout moment on pourra donc configurer son matériel et son Pi 5 pour y travailler (voire jouer ou consulter le Web) comme un PC traditionnel.
J’y reviendrai à l’occasion pour les détails de configuration (écran, langue, etc) avec la commande sudo raspi-config , voire avec un VNC client. En octobre 2024 une nouvelle version est sortie qu’il faudrait sans doute considérer:
Mise à niveau et test de Python
C’est nécessaire, et l’info ici: https://www.pcguide.com/raspberry-pi/how-to-update/
sudo apt update (long processus, plusieurs minutes)
sudo apt full-upgrade (assez plus rapide)
sudo apt dist-upgrade
sudo apt autoremove
sudo reboot
On relance et on vérifie un mini script Python déposé dans le répertoire python:
pi@PiPiscine:~/python $ python hello.py
Hello world!
pi@PiPiscine:~/python $
Cool, cela fonctionne, et je ne suis pas vraiment surpris! Par contre le script suivant ne marche pas:
pi@PiPiscine:~/python $ python relay.py
Traceback (most recent call last):
File “/home/pi/python/relay.py”, line 19, in <module>
setup()
File “/home/pi/python/relay.py”, line 9, in setup
GPIO.setup(RelayPin, GPIO.OUT) # RelayPin en mode output
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
RuntimeError: Cannot determine SOC peripheral base address
pi@PiPiscine:~/py
C’est un script tiré de mon livre pour vérifier un relais connecté sur les broches GPIO et c’est la librairie RPi.GPIO qui est en cause!
Il y a donc du travail, pour comprendre voire réutiliser du logiciel fonctionnant sur mes Raspberry Pi d’anciennes générations !
De nombreux exemples de code Python sur le Web contiennent des références comme import RPi.GPIO as GPIO qu’il faudra adapter ou recoder (voir ci-dessous, par exemple avec la librairie gpiozero).
Un certain nombres de scripts Python tirés de mon livre, dont ce script relay.py, se trouvent sur mon site dans le fichier CodePython.zip.
Ils sont valides pour les versions du Raspberry Pi jusqu’au Pi4.
J’ai aussi écrit de nombreux articles comme le Python Web Flask et SQLite pour le Raspberry Pi et d’autres disponible ici dans la catégorie Raspberry Pi 3/4.
Documentation: la librairie gpiozero
Ce n’est pas forcément un bon début, mais tout y est: gpiozero 2.0.1 Documentation Release 2.0.1! C’est un PDF de 266 pages!
Les habitués comme moi de la librairie RPi.GPIO pourront consulter ce guide de migration:
https://gpiozero.readthedocs.io/en/stable/migrating_from_rpigpio.html
Avant de faire une quelconque installation il fait vérifier si elle n’est pas déjà installée!
Programmer en Python sur le Pi 5 ou sur un PC Windows
Pour débuter pourquoi pas cette liste de livres sur le langage Python que je dois encore vérifier.
Pour tous mes Raspberry Pi j’ai toujours développé mon code Python sous PC Windows. Il y a évidemment l’alternative de travailler sur le Pi 5 avec un écran et un clavier. Je ne l’ai jamais fait, pour l’instant.
Souvent le code Python est vraiment minimaliste chez moi, puisque je travaille en Java pour le cœur de mes programmes. Donc une simple console avec vi ou nano suffit, et on exécute directement!
Si on est débutant en Python, il y aura des soucis, car il faudra comprendre le code, trouver des exemples et les essayer. Sur le PC on a pas de GPIO, et il faudra se débrouiller. Mon outil de travail c’est Eclipse avec Java, mais on peut jouer aussi avec Python. Je devrai sans doute revisiter mon article PyDev, un IDE pour Python, sous Eclipse et pour le Raspberry Pi 3 pour ce Pi 5.
Pour de simples vérifications, on peut entrer le code directement:
pi@PiPiscine:~/python $ python
Python 3.11.2 (main, Aug 26 2024, 07:20:54) [GCC 12.2.0] on linux
Type “help”, “copyright”, “credits” or “license” for more information.
>>> from gpiozero import LED
>>> led = LED(23)
>>> led.on()
>>> led.off()
>>>
Ici j’utilise la librairie gpiozero et j’entre les 4 instructions l’une après l’autre dans ma fenêtre PuTTY de Windows!
Pour de simples vérifications, comme l’existence de la librairie avec from gpiozero import LED, on peut entrer le code directement.
Nous voyons LED ici, mais chez moi, c’est un relais connecté au GPIO 23 (la broche 16), avec l’alimentation 3.3 Volt, et il clique bien aux enclenchements/déclenchements du relais!
Dans le document Raspberry Pi Zero WH j’explique comment je travaille avec WinSCP et PuTTY.
Ici j’ai édité sur mon PC avec Notepad++ le fichier relayPi5.py avant transfert et exécution sur le Pi 5.
S’il y a des erreurs, je peux revenir dans Notepad++ (c’est très efficace).
Les broches GPIO du Raspberry Pi 5 avec la librairie gpiozero
Donc j’utilise la librairie gpiozero.
On pourra se balader sur ce site Web et ses nombreux articles en liens dans la barre de gauche.
Ici une image bien propre de la définition des broches et de la numérotation GPIO du Raspberry Pi 5 (cliquer sur X pour le retour). Le RELAY_PIN ci-dessous est bien le GPIO 23 sur la broche physique 16.
Un joli serveur en Python pour le relais
Je l’ai nommé gpioRelayServer.py!
import os
import time
import gpiozero
print('Python GPIO Relay Server')
RELAY_PIN = 23
relay = gpiozero.OutputDevice(RELAY_PIN, active_high=False, initial_value=False)
relay.on()
time.sleep(2)
relay.off()
time.sleep(1)
relay.on()
time.sleep(1)
relay.off()
while True:
if os.path.isfile('input.txt'):
str = open('input.txt', 'r').read()
if (str.startswith('RELAY ON')):
relay.on()
else:
if (str.startswith('RELAY OFF')):
relay.off()
os.remove("input.txt")Cela fonctionne super bien! On lance ce script en arrière-plan dans une console PuTTY avec la commande python gpioRelayServer.py &. C’est une boucle infinie. Le fichier input.txt sera effacé en cas d’activation ou de coupure du relais.
Il suffit alors d’écrire le texte RELAY ON ou RELAY OFF dans le fichier input.txt pour enclencher ou déclencher le relais.
On fera sans doute l’exercice plus loin en Java!
Certains diront que c’est assez exotique (on pourrait utiliser une communication socket par exemple) mais cette interface fichier est très efficace pour développer une grosse application comme ma minuterie et/ou en plus une interface Web.
Ne pas oublier: sans boucle, le programme Python sera stoppé et avec lui l’instance de l’objet relay qui coupera le relais!
Installation de Java et testing (en travail)
En développant un mini Web server écrit en Java et déposé sur ce dernier Pi 5, j’aurai finalisé cette partie.
C’est assez vite fait, ça fonctionne, mais il y aura du travail à expliquer la bête:
Cela consiste en:
- installer la machine virtuelle Java sur le Pi 5
- expliquer l’environment Eclipse pour Java sur PC
- écrire un classe de test consistant en un mini serveur Web sur le port 8000 et la vérifier d’abbord sur PC
- télécharger les classes .class sur le Pi 5 avec WinScp et vérifier le résultat ci-dessus!
Juste un peu de temps à présent pour la description. Patience!
Mes notes actuelles à documenter ici:
Mise en place du Pi4J
C’est la partie la plus délicate et la plus intéressante pour moi.
C’était le cœur de mon bouquin, la bibliothèque Pi4J pour Java pour l’interface GPIO du Raspberry Pi!
On trouvera une introduction dans Welcome to Pi4J. avec les différentes versions.
L’architecture et les chips du Pi 5 demande une nouvelle version 2 de Pi4J et une version Java supérieure à 8.
Ici un excellent article: Java on Raspberry Pi 5 with Pi4J
Je suis un peu dans l’expectative après avoir vu quelques exemples de code et j’ai de la peine à mettre en place tout ce bazar (PC, Eclipse, etc). Je vais sans doute faire pareil que pour les librairies Python RPi.GPIO et gpiozero où j’installerai les versions Pi4J respectivement sur mes systèmes de développement Pi4 et Pi5.
Donc … du travail pour moi!
Je commence avec un Raspberry Pi 4 et l’info se trouve sur la page Pi4J Downloads et l’on trouvera la commande curl -sSL https://pi4j.com/install | sudo bash pour la version 1. Je fais l’installation sur la racine de mon Pi 4 et je reçois pour terminer:
...
====================================================
Pi4J INSTALLATION COMPLETE
====================================================
The Pi4J JAR files are located at:
/opt/pi4j/lib
Example Java programs are located at:
/opt/pi4j/examples
You can compile the examples using this script:
sudo /opt/pi4j/examples/build
Please see https://pi4j.com for more information.
Avec sudo /opt/pi4j/examples/build on pourra compiler les exemples …. et j’ai oublié d’installer Java sur ce Raspberry Pi tout nouvellement installé ou de vérifier que c’était fait! Java 8 pour la version 1 de Pi4J.
Donc (à expliquer encore):
sudo apt update
sudo apt install openjdk-8-jdk openjdk-8-jre
pi@Pi4BTest:~ $ sudo /opt/pi4j/examples/build
————————————————————————-
BUILDING Pi4J EXAMPLES
————————————————————————-
[01 of 42] … compiling : BlinkGpioExample.java
BlinkGpioExample.java:32: error: cannot access GpioController
import com.pi4j.io.gpio.GpioController;
^
bad class file: /opt/pi4j/lib/pi4j-core.jar(com/pi4j/io/gpio/GpioController.class)
class file has wrong version 55.0, should be 52.0
Please remove or make sure it appears in the correct subdirectory of the classpath.
Piste?: https://phoenixnap.com/kb/install-java-raspberry-pi
C’est typique du Raspberry Pi, il faut vraiment être un MAKER, un super MAKER : il faut bricoler voire recommencer (quand j’ai écrit mon livre j’ai dû parfois refaire 5-6 fois les procédure, voire la carte SD pour avoir une description 100% exacte).
A suivre!
Mesure de température avec un Dallas DS18B20
Le Dallas DS18B20 est un capteur de température digital qui utilise le protocole 1-wire. J’en ai connecté un sur la broche 07 (GPIO 04).
On n’utilise pas de librairie GPIO et tout se fait au travers du système d’exploitation avec un lecture de fichier, par exemple, pour moi: /sys/bus/w1/devices/28-021318ab83aa/w1_slave!
Il faudra simplement lire ce fichier et décoder la température, ici, 25.3 degrés du t=:
cat /sys/bus/w1/devices/28-021318ab83aa/w1_slave
95 01 4b 46 7f ff 0c 10 65 : crc=65 YES
95 01 4b 46 7f ff 0c 10 65 t=25312
Donc, à suivre, … aussi en travail!
Donner plus de détails (sudo raspi-config (Interface option, I2C, etc, sudo modprobe w1-gpio, sudo modprobe w1-therm, …) !
J’aime bien Rui Santos (https://randomnerdtutorials.com/), beaucoup utilisé pour mes ESP. Voir donc son Raspberry Pi: Temperature Readings with DS18B20 Sensor (Python).
Le code de Raspberry_DS18B20_Tutorial.py fonctionne correctement, mais il faudra mettre des parenthèses pour l’instruction print (question de version de Python).
Mesure d’intensité de lumière
Ici il nous faut un photosenseur et une capacité, donc pas besoin de module supplémentaire ADC (conversion analoqique à digital).
Le script qui suit fonctionne bien sur un Raspberry Pi 4 avec avec Bullseye 32 bits et la librairie RPi.GPIO.
C’est impossible, pour l’instant, de faire l’équivalent sur un Pi 5 et Raspbian Bookworm avec la librairie gpiozero.
On trouvera des références sur le Web (octobre 2024) mais pas d’indication sur une correction possible dans l’OS.
#coding: utf-8
#Pin 7 GPIO 4 Alim: 3.3V
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
#Définition du pin sur la broche 7
pin_to_circuit = 7 # (GPIO 4)
def rc_time (pin_to_circuit):
count = 0
#Configuration en sortie
GPIO.setup(pin_to_circuit, GPIO.OUT)
GPIO.output(pin_to_circuit, GPIO.LOW)
time.sleep(0.1) #pause de charge
#Configuration en entrée
GPIO.setup(pin_to_circuit, GPIO.IN)
#Comptage
while (GPIO.input(pin_to_circuit) == GPIO.LOW):
count += 1
return count
try:
# Boucle éternelle
while True:
print rc_time(pin_to_circuit)
time.sleep(2)
except KeyboardInterrupt:
pass
finally:
GPIO.cleanup()J’ai nommé ce script light_sensor_verif.py.
Un des côtés du capteur de lumière est branché sur l’alimentation 3.3 Volt.
L’autre côté du capteur va à la fois sur la broche GPIO4 (broche physique 07, car on utilise ici le mode GPIO.BOARD) et la capacité (condensateur) 1uF sur son fil long!
L’autre côté de la capacité (fil court) va sur la terre GND (j’utilise la broche physique 09 du même côté dans le même secteur!
On passera la main en dessus du capteur et une nouvelle valeur viendra chaque 2 secondes dans la fenêtre Putty pour la commande python light_sensor_verif.py!
Donc, encore une fois, si on a besoin absolument de la mesure de lumière pour activer par exemple un relais, il faudra rester avec le Pi 4.
Si un oiseau ou une main passe sur le capteur pendant la mesure, il y aura un souci. Donc il faudra adapter ce script pour faire une moyenne dans le temps en retirant quelques valeurs extrêmes et pourquoi pas déposer le résultat dans une fichier lisible par une application ou un serveur Web. C’est avec ce genre de code qu’on apprend à maitriser la programmation!
Voici maintenant une version améliorée:
#coding: utf-8
#Pin 7 GPIO 4 Alim: 3.3V
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
#Définition du pin sur la broche 7
pin_to_circuit = 7 # (GPIO 4)
def rc_time (pin_to_circuit):
count = 0
#Configuration en sortie
GPIO.setup(pin_to_circuit, GPIO.OUT)
GPIO.output(pin_to_circuit, GPIO.LOW)
time.sleep(0.1) #pause de charge
#Configuration en entrée
GPIO.setup(pin_to_circuit, GPIO.IN)
#Comptage
while (GPIO.input(pin_to_circuit) == GPIO.LOW):
count += 1
return count
try:
# Boucle éternelle
while True:
i = 0
themesures = []
while i < 5:
i = i + 1
themesures.append(rc_time(pin_to_circuit))
time.sleep(.1)
themesures.sort()
#print(themesures[2])
f = open("lightValue.txt", "w")
f.write(str(themesures[2]))
f.write("\n")
f.close()
except KeyboardInterrupt:
pass
finally:
GPIO.cleanup()
Le principe est simple: nous lisons 5 valeurs avec un délai de 0.1 secondes, nous déposons la valeurs dans une liste, nous les trions et nous piquons celle du milieu en ignorant les extrêmes! La vitesse de lecture sera proportionnelle à l’intensité: plus c’est sombre, plus c’est lent. En écrivant la valeur dans un fichier, c’est réutilisable, par exemple par un programme Java qui pourrait ensuite utiliser le script gpioRelayServer.py ci-dessus pour par exemple allumer ou éteindre un luminaire ou une pompe piscine!
Un capteur de présence (PIR)
C’est sans doute un des meilleures composants électroniques pour débuter avec le Raspberry Pi (voire avec un ESP32) et mettre en place de jolies applications!).
L’article Raspberry Pi: Detect Motion using a PIR Sensor with Python devrait suffire. On y trouve plein d’exemples et de détails techniques avec l’utilisation de la librairie gpiozero!
Attention, il faudra calibrer le capteur avec des potentiomètres (voir par exemple Troubleshooting PIR Sensor and sensitivity adjustment) et jouer avec les deux “vis” oranges sur le côté, sinon le délai de réponse pourrait être trop court ou trop long! Pour tous les composants utilisés sur les broches GPIO, lors d’une recherche Google, on indiquera, en plus du mot clé Raspberry Pi, ceux d’ESP ou d’Arduino pour obtenir de meilleures résultats. Pour le “monde” ESP et Arduino le lecteur pourrait lire mon article Un tutoriel pour débutant pour l’ESP32: un thermomètre digital (en travail continuel)!
Avec Gemini, un chatbot de Google, et en entrant par exemple “Calibrer un PIR pour un Raspberry pi“, nous obtiendrons une foule d’information et même un exemple avec l’ancienne librairie GPIO du Pi!
from gpiozero import MotionSensor
from gpiozero import LED
pir = MotionSensor(14)
led = LED(26)
while True:
pir.wait_for_motion()
led.on()
print("You moved")
pir.wait_for_no_motion()
led.off()
print("No move anymore")
J’ai nommé ce script Python pir_led.py et l’ai déposé dans mon répertoire /home/pi/python de mon dernier Pi4. Il utilise la librairie gpiozero!
Sur The Raspberry Pi GPIO pinout guide on voit comment j’ai utilisé les broches physiques 8 (GPIO14) et 37 (GPIO26) aux deux extrêmes. Ce sera plus facile lorsqu’on ajoutera d’autres composants sans trop se mélanger les fils! C’est plus facile de compter 1,2,3, .. dans la direction choisie!
L’utilisation d’une LED est pratique: on n’a pas besoin d’avoir une fenêtre Putty pour identifier que cela marche.
Son exécution à présent:
pi@Pi4BTest:~/python $ python pir_led.py
You moved
No move
You moved
No move
You moved
No move
.....
La led se serra ici allumé et éteint 6 fois.
A présent je vais y ajouter un relais (5/220Volt). Attention au montage côté 220V, ce n’est pas pour les enfants! J’utilise un boitier isolé pour cette partie!
Avec le PIR et la LED de chaque côté avec les broches physiques 8 et 37, je peux prendre pour le relais la broche 36 (GPIO16) à l’extérieur en comptant 1, 2 et 3. On prendra le 5V restant (broche physique 4) et le GND au 34. Lors des branchements mon Pi est éteint (j’en ai grillé un une fois!!)!
Il y a plein d’articles sur le Web comme Contrôle d’un dispositif basse tension via Raspberry Pi et un relais et les broches sont bien indiquées sur le relais lui-même. On a pas besoin de brancher la haute tension: le relais fera des “clics”.
On pourra reprendre le code ci-dessus (gpioRelayServer.py), sans l’écriture du fichier et étendre le script pir_led.py en pir_led_relay.py par exemple!
Mais regardez ce code:
from gpiozero import LED
import time
led = LED(16)
led.on()
time.sleep(2)
led.off()
time.sleep(2)
On est bien sur le GPIO16, notre relais (pas un LED) et cela fonctionne évidemment.
La différence est au niveau du circuit: la LED a besoin d’un résistance et est alimentée par la broche GPIO.
Le relais lui a besoin d’être alimenté (5V et GND) et enclenché ou déclenché par la broche digitale GPIO.
Sur un ESP32 ou un Arduino la broche est analogique et on pourrait définir un niveau de luminescence sur la LED!
Je laisse le lecteur s’imaginer comment intégrer cet évènement de mouvement avec une LED et un relais dans une application Python ou Java. Je déposerai sans doute ici quelques idées!
Pour toutes, voire n’importe quelles questions, suggestions ou demandes de code, on pourra utiliser Ma forme de contact