Dans les premiers exemples, nous avons connu les broches GPIO comme des sorties que nous avons commutées sur HIGH pour faire briller une LED. Mais GPIO signifie General Purpose Input/Output. Tu peux donc aussi programmer les broches comme entrée. On peut alors déterminer s'il y a une tension à l'entrée (HIGH) ou non (LOW). Le Raspberry Pi n'a que des entrées numériques (nous verrons plus tard comment mesurer les tensions analogiques), mais la tension présente ne doit pas être exactement de 3,3V pour être reconnue comme HIGH, et pas de 0V pour être reconnue comme LOW. Jusqu'à environ 1,4V, il est reconnu comme LOW, tout ce qui est supérieur à 1,9V est certainement reconnu comme HIGH. Seule la petite zone autour de ½ de 3,3V et une broche libre à laquelle rien n'est connecté posent problème.
Nous allons découvrir plusieurs capteurs numériques qui doivent déclencher une alarme ou une action spécifique dans notre programme (par exemple, les détecteurs de mouvement). Le plus simple de ces capteurs est le bouton (angl. button), un interrupteur à ressort qui ferme un circuit lorsqu'on appuie sur le bouton et l'ouvre à nouveau lorsqu'on le relâche.
Si nous connectons un contact du bouton à une broche GPIO et l'autre à 3,3V, le signal HIGH est clairement détecté lorsque le bouton est appuyé. Le problème commence après le relâchement du bouton. Quel est alors l'état du GPIO ? Un état indéfini ! On ne peut pas programmer avec ça. Dans l'état éteint, le GPIO devrait donc être en permanence sur le potentiel GND. Mais cela provoquerait un court-circuit lorsque le bouton est appuyé. Pour y remédier, il faut une résistance suffisamment grande pour que seul un petit courant circule. Les résistances habituelles sont de 4,7 k (=4700 ohms) ou de 10 kΩ (=10 000 ohms). On appelle ces résistances des résistances pull-down.
Mais tu peux aussi programmer le GPIO de manière à ce qu'il indique normalement HIGH et qu'il reconnaisse la pression de la touche vers GND comme un changement vers LOW. La résistance est alors appelée résistance pull-up. Et pour rendre le tout encore plus confus pour les débutants, les GPIO Raspberry Pi ont une résistance interne Pull-up ou Pull-down qui peut être activée ou désactivée dans le programme. Heureusement, les premiers circuits deviennent ainsi très simples.
Le schéma de câblage : Bouton-poussoir sur le Raspberry Pi
Le code du programme : Bouton-poussoir sur le Raspberry Pi
from gpiozero import LED, bouton
from signal import pause
led = LED(12)
button = bouton(16)
button.when_pressed = led.on
button.when_released = led.off
pause()
A partir du module gpiozero, les classes LED et bouton sont importées, séparées par une virgule, puis les objets led et button sont instanciés avec les numéros GPIO respectifs.
Au lieu de la sleep()-Fonction du module time on utilise pause du module signal sleep() signifierait un arrêt complet, la pression sur la touche ne serait pas remarquée pendant ce temps. Sans pause(), le programme se terminerait et plus rien ne se passerait.
L'instanciation de button a été très simple, car nous n'avons indiqué que le numéro GPIO et avons utilisé les paramètres par défaut (voir la définition de la classe à la ligne suivante). Pour ceux qui souhaitent s'en écarter, il faut ajouter des paramètres supplémentaires sous forme d'arguments de mots-clés.
class gpiozero.bouton(pin, *, pull_up=True, active_state=None, bounce_time=None,
hold_time=1, hold_repeat=False, pin_factory=None)
Pour plus de détails sur gpiozero, voir ici.
Extension de la structure expérimentale : un cycle de feux de signalisation doit être lancé avec un Raspberry Pi lorsqu'un bouton est actionné.
La construction expérimentale s'inspire du premier exemple. Au lieu d'une LED, on utilise un feu de signalisation LED. Celle-ci a des résistances intégrées. Nous instancions trois objets LED et définissions une fonction trafficLight qui est appelée lorsqu'un bouton est appuyé.
Le code du programme : Cycle de feux de signalisation sur Raspberry Pi
from gpiozero import LED, bouton
from signal import pause
from time import sleep
redled = LED(16)
yellowled = LED(20)
greenled = LED(21)
button = bouton(12)
def trafficLight() :
redled.on()
sleep(1)
yellowled.on()
sleep(1)
greenled.on()
redled.off()
yellowled.off()
sleep(1)
yellowled.on()
greenled.off()
sleep(1)
redled.on()
yellowled.off()
sleep(1)
redled.off()
button.when_pressed = trafficLight
pause()
Extension : jeu de réaction avec deux boutons sur Raspberry Pi
Tu as besoin de deux boutons, d'un buzzer ainsi que d'une LED rouge et d'une jaune. Après le lancement du Reaction Game, c'est d'abord la LED jaune qui s'allume. Avec time = uniform(5, 10) après un temps aléatoire entre cinq et dix secondes, la LED rouge s'allume. Ensuite, deux joueurs peuvent chacun appuyer sur leur bouton le plus rapidement possible. Celui qui appuie trop tôt est pris en flagrant délit de triche, le buzzer retentit pendant une demi-seconde.
Le code du programme : Cible de réaction avec deux boutons sur Raspberry Pi
# ! /usr/bin/python3
# Jeu de réaction - push button, quand la LED rouge s'allume
# based on gpiozero documentation, Basic Recipes
# amélioré pour reconnaître les tricheries par Bernd Albrecht
# Red LED lights-up 5 - 10 sec after the yellow LED
from gpiozero import bouton, LED, buzzer
from time import sleep
from random import uniform
from sys import exit
led_red = LED(16)
led_yellow = LED(20)
buzzer = buzzer(12)
player_1 = bouton(23)
player_2 = bouton(18)
led_yellow.on()
time = uniform(5, 10)
sleep(temps)
if player_1.is_pressed :
print("Player 1 is cheating !")
buzzer.on()
sleep(0.5)
buzzer.off()
led_yellow.off()
exit()
if player_2.is_pressed :
print("Player 2 is cheating !")
buzzer.on()
sleep(0.5)
buzzer.off()
led_yellow.off()
exit()
led_red.on()
led_yellow.off()
while True :
if player_1.is_pressed :
print("Player 1 wins !")
break
if player_2.is_pressed :
print("Player 2 wins !")
break
led_red.off()
