Gérer le GPIO avec Python

1. Connecter la LED au GPIO

En suivant le schéma ci-dessus :

2. Piloter la LED en Python

>>>import gpiozero 

>>>rouge = gpiozero.LED(23) 

1. Exécuter directement le script

#!/usr/bin/python3 

1. Connecter le bouton poussoir au GPIO

Les contacts du bouton poussoir sont reliés aux pins 18 (GPIO 24) et 20 (masse).

Par rapport au câblage préconisé dans le chapitre Matériel utilisé, il faut noter l’absence de toute résistance dans le circuit du bouton poussoir.

Ceci s’explique par le fait que gpiozero active une résistance de tirage interne au SoC (R1) qui relie le GPIO 24 au +3,3 V.

Quand le bouton poussoir est relâché, la pin 24 est à 1 (3,3 V). Lorsque l’on appuie sur le bouton poussoir, la pin 24 est mise à la masse (0 V). Par rapport au schéma du chapitre précédent, le danger est que si la pin 24 est programmée en sortie, elle pourrait être endommagée en cas d’appui sur le bouton poussoir alors que la sortie est à 1 (3,3 V).

Si les manipulations sont faites par des débutants inexpérimentés, il est rassurant de prévoir une résistance R2 de l’ordre de 1 kΩ (non critique) pour protéger le GPIO 24 en cas d’erreur.

Le câblage prend alors cette forme. Le fonctionnement n’est pas modifié, mais la sécurité de la carte est assurée.

2. Lire la position du bouton poussoir

1  from gpiozero import Button 
2   
3  position = Button(24) 
4   
5  while True: 
6      if position.is_pressed: 
7          print("Le bouton est appuyé") 
8      else: 
9          print("Le bouton est relâché")...

1. Méthode "classique"

L’étape suivante consiste à allumer une LED lorsque l’utilisateur appuie sur le bouton poussoir. Avec les instructions vues précédemment, il est simple de réaliser cette fonctionnalité. C’est la façon "classique" de réaliser le script avec gpiozero.

1  from gpiozero import LED, Button 
2  from signal import pause 
3   
4  rouge = LED(23) 
5  bouton = Button(24) 
6   
7  print ("Appuyez sur le bouton pour allumer la LED") 
8  bouton.when_pressed = rouge.on 
9  bouton.when_released = rouge.off 
10 
11 pause() 

Après importation des bibliothèques nécessaires au projet (lignes 1 et 2), on informe gpiozero qu’une LED est connectée au GPIO 23 et un bouton poussoir au GPIO 24.

Le script informe l’utilisateur de l’action à réaliser (ligne 7).

L’action sur le bouton poussoir provoque l’exécution de rouge.on ou rouge.off selon que le bouton est appuyé ou relâché (lignes 8 et 9).

La ligne 11 pause() maintient le script actif.

1. Cahier des charges

Le fonctionnement est identique à celui du feu tricolore réel. La séquence d’allumage est :

2. Câblage du feu tricolore

En suivant le schéma ci-dessus :

3. Script du feu tricolore

Avant de passer à la suite, réfléchissez à la création du script permettant d’animer le feu tricolore, à partir des instructions utilisées précédemment. Écrivez et testez votre script. Le script qui suit : FEU_01.py propose une façon de réaliser un feu tricolore.

1  from gpiozero import TrafficLights 
2  from time import sleep 
3  from signal import pause 
4 
5  feu = TrafficLights(16, 20, 21) 
6  # Dans l'ordre GPIO des LED rouge, orange, verte 
7  # En anglais red, amber, green 
8   
9  while True: 
10     feu.red.on() 
11     sleep(5) 
12     feu.red.off() 
13     feu.green.on() ...

1. Clignotement

1  from gpiozero import LED 
2  from signal import pause 
3  led = LED(23) 
4   
5  led.blink() 
6   
7  pause() 

1. Cahier des charges

Faire varier la luminosité d’une LED grâce à deux boutons poussoirs. L’un des boutons fait augmenter la luminosité, l’autre la fait diminuer.

Lorsque la luminosité est égale à 0 % ou à 100 %, elle ne varie plus.

La valeur de la luminosité s’affiche à l’écran.

2. Câblage du variateur de luminosité

La LED est connectée au GPIO 23 (pin 16) et les boutons poussoirs aux GPIO 24 et 25 (respectivement pin 18 et 22).

3. Analyse du déroulement du script

Lorsqu’un projet devient plus complexe, il est souvent utile de poser les idées sur le papier avant de se lancer dans l’écriture du script. Cela permet d’imaginer le déroulement du script, de l’optimiser et d’aider à la compréhension des éventuels dysfonctionnements.

L’organigramme de programmation aussi appelé logigramme est une des possibilités graphiques d’analyser un problème. Il comporte un certain nombre de formes standardisées. Plus d’informations sont disponibles sur https://fr.wikipedia.org/wiki/Organigramme_de_programmation.

L’organigramme ci-dessus utilise un jeu réduit et simplifié...

1. Cahier des charges

Au lancement du programme, la LED s’allume puis s’éteint après un temps aléatoire, compris entre 1 et 5 secondes.

Lorsque la LED s’éteint, les deux joueurs appuient chacun sur leur bouton poussoir. Le script détermine lequel des deux joueurs a appuyé en premier et affiche le vainqueur à l’écran.

2. Câblage du jeu de réflexes

Le câblage comprend une LED et deux boutons poussoirs. Il est identique au montage utilisé pour faire varier la luminosité de la LED.

3. Écriture du script

# Importer les bibliothèques utilisées par le script 
from gpiozero import LED, Button 
from time import sleep 
# uniform fournit un nombre aléatoire arrondi entre deux valeurs 
# les bornes de l'intervalle sont comprises 
from random import uniform 
from signal...

1. Brochage de la LED RVB

Les LED RVB ont des longueurs de pattes différentes, ce qui permet de les identifier. La patte la plus longue est la patte commune. Pour cet atelier, la LED RVB choisie est un modèle à cathode commune.

2. Câblage de la LED RVB

En suivant le schéma ci-dessus :

3. Script Python pour tester la LED RVB

# Importation des bibliothèques 
from gpiozero import RGBLED 
from time import sleep 
 
# Déclaration des GPIO qui commandent les LED 
# Dans l'ordre rouge - vert - bleu 
led = RGBLED(16, 20, 21) 
 
# Allumer la LED bleue 
led.color = (0,0,1) 
#Attendre 0.5 seconde 
sleep(0.5) 
# Allumer la LED verte 
led.color = (0,1,0) 
sleep(0.5) 
# Allumer la LED rouge  
led.color = (1,0,0) 
sleep(0.5) 
# Allumer les LED bleu + vert...

1. Bibliothèque WS2812

La bibliothèque gpiozero ne gère pas les LED RVB de type WS2812. L’intégration de ce composant dans la bibliothèque a été proposée, mais pas encore implémentée. La bibliothèque est disponible sur pypi et s’installe simplement (https://pypi.org/project/rpi-ws281x/).

Il faut donc utiliser une bibliothèque supplémentaire pour gérer les LED WS2812.

L sudo pip3 install rpi_ws281x 

2. Connexion des LED RGB

3. Test des LED WS2812

wget https://raw.githubusercontent.com/jgarff/rpi_ws281x/master/python/
examples/strandtest.py 

Le programme est également disponible dans les fichiers téléchargés en complément du livre (LF10/strandtest.py). Pour tester les LED, le script va devoir accéder au matériel. Il faut...

1. Installation de la bibliothèque

La gestion en Python de la matrice avec le circuit 7219 et le bus SPI est facilitée par l’emploi de la bibliothèque LUMA.

Son installation passe par pip3 qui est le système de gestion de paquets utilisé pour installer et gérer des librairies écrites en Python. C’est l’équivalent d’apt-get pour le système. Les librairies se trouvent dans PyPi (Python Package Index).

cd 

sudo usermod -a -G spi,gpio pi 

sudo apt-get install build-essential python3-dev python3-pip libfreetype6-dev 
libjpeg-dev 

sudo pip3 install --upgrade --force-reinstall  pip setuptools 

sudo pip3 install --upgrade luma.led_matrix 

1. Cahier des charges

Afficher un texte défilant sur un bloc de trois matrices à LED 8x8 en utilisant la bibliothèque LUMA. Reprenez le programme de démonstration matrix_demo.py fourni avec la bibliothèque LUMA pour en extraire la partie intéressante pour ce projet. Elle se situe au début de la fonction demo.

2. Câblage du journal lumineux

Le câblage est identique à celui qui a été vu à la section précédente Gestion d’une matrice de LED.

3. Script du journal lumineux

#!/usr/bin/env python3 
# -*- coding: utf-8 -*- 
 
# Importation des bibliothèques utilisées par le script 
import time 
# Gestion du circuit 7219 
from luma.led_matrix.device import max7219 
# Gestion du bus SPI 
from luma.core.interface.serial import spi, noop 
# Affichage des messages 
from luma.core.legacy import show_message 
# Polices utilisées par le script 
from luma.core.legacy.font import proportional...

1. Câblage

Le servomoteur nécessite une alimentation 5 V. Il sera connecté sur la broche 5 V du connecteur (broche 2).

Le fil de commande est relié à la broche 40 du connecteur (GPIO 21).

2. Script de commande du servomoteur

# Programme test du servomoteur SG90 
# Positionne le servomoteur sur 3 positions fixes 
 
# Importation des bibliothèques utilisées par le script 
 
from gpiozero import Servo 
from time import sleep 
 
# Connecte le servomoteur au GPIO21 
servo = Servo(21) 
 ...

1. Cahier des charges

L’objectif est d’afficher le sens de rotation du codeur incrémental à l’écran. Par la suite, il sera possible d’utiliser cette information pour piloter le volume de sortie d’un amplificateur, la luminosité ou la couleur d’une LED ou d’un ruban de LED…

2. Branchement au GPIO

Le codeur rotatif est relié au +3,3 V et à la masse et les deux fils S1 et S2 rejoignent les GPIO 24 et 25. La broche non connectée sur le codeur correspond au bouton poussoir qui est actionné en appuyant verticalement sur l’axe du codeur. Il n’est pas utilisé ici.

3. Programme

#!/usr/bin/python3 
# Utilisation d'un codeur rotatif incrémental 
 
# Importer les bibliothèques utilisées par le script 
from gpiozero import Button 
from signal import pause 
from time import sleep 
 
# Déclarer les entrées du codeur comme des boutons 
S2 = Button(24) 
S1 = Button(25) 
 
def S1_pressed(): 
   print ('S1 appuyé') 
   sleep(0.15) 
 
def S2_pressed(): 
   print ('S2 appuyé') 
   sleep(0.15) 
 ...

1. Cahier des charges

Une LED RVB émet une lumière de couleur. Les huit couleurs de base (noir, blanc, rouge, vert, bleu, jaune, magenta, cyan) sont affichées successivement grâce à la rotation d’un encodeur rotatif. Le défilement des couleurs dépend du sens de rotation du codeur.

2. Câblage

Le câblage du codeur incrémental rotatif est identique à celui de la section précédente. La LED RVB est connectée comme dans la section Câblage de la LED RVB et le codeur incrémental remplace le bouton poussoir de ce schéma.

3. Script de défilement de couleurs

#!/usr/bin/env python3 
# -*- coding: utf-8 -*- 
 
# Importation des bibliothèques utilisées par le script 
from gpiozero import RGBLED, Button 
from colorzero import Color 
from time import sleep 
from signal import pause 
 
# Cette bibliothèque permet de créer une file d'attente pour ranger les événements 
# La file utilisée ici est de type FIFO = First In First Out = Premier entré 
Premier Sorti 
import queue 
 
# Créer la file d'attente FIFO 
eventq = queue.Queue() 
 ...

1. Choix de la carte

De nombreuses solutions existent et il faut choisir la carte qui sera la plus appropriée en fonction du projet.

Pour la station météo, il existe une carte à base de convertisseur Analogique/Numérique MCP3008 conçue par Alex Eames pour RasPiO. Elle permet de convertir huit valeurs analogiques et donne accès aux ports GPIO qui sont ramenés sur des pastilles de la carte. La carte est fournie sous forme d’un kit comportant le circuit imprimé et l’ensemble des composants.

La carte se connecte sur les ports GPIO du Raspberry Pi 4 (connecteur en haut de la photo ci-dessus). Sous ce connecteur, une rangée de pastilles identifiées par sérigraphie donne accès à chaque port du GPIO. On trouve ensuite U6, le convertisseur analogique/numérique (CAN ou ADC). Les huit entrées analogiques A0 à A7 recevront les tensions à mesurer (0 à 3,3 V maximum). Sur la droite, une série de pastilles offre la possibilité de câbler...