Nei primi esempi, abbiamo imparato a conoscere i pin GPIO come uscite da commutare su HIGH per far accendere un LED. Ma GPIO è l'acronimo di General Purpose Input/Output. Quindi puoi anche programmare i pin come ingressi. In questo modo è possibile determinare se c'è una tensione all'ingresso (HIGH) o meno (LOW). Il Raspberry Pi dispone solo di ingressi digitali (più avanti vedremo un workaround per misurare le tensioni analogiche), ma la tensione applicata non deve essere esattamente di 3,3V per essere riconosciuta come ALTA e non di 0V per essere riconosciuta come BASSA. Fino a circa 1,4V viene riconosciuto come BASSO, mentre tutto ciò che supera 1,9V viene sicuramente riconosciuto come ALTO. Solo il piccolo intervallo intorno a ½ di 3,3V e un pin libero senza alcun collegamento sono problematici.
Conosceremo diversi sensori digitali che dovrebbero attivare un allarme o una determinata azione nel nostro programma (ad esempio un rilevatore di movimento). Il più semplice di questi sensori è il pulsante, un interruttore a molla che chiude un circuito quando il pulsante viene premuto e lo riapre quando viene rilasciato.
Se colleghiamo un contatto del pulsante a un pin GPIO e l'altro a 3,3V, il segnale ALTO viene chiaramente rilevato quando il pulsante viene premuto. Il problema inizia dopo il rilascio del pulsante. Qual è lo stato del GPIO? Uno stato non definito! Non è possibile programmare con questo stato. Nello stato di spegnimento, il GPIO dovrebbe essere permanentemente a potenziale GND. Tuttavia, questo porterebbe a un cortocircuito quando si preme il pulsante. Il rimedio è un resistore che deve essere abbastanza grande da far passare solo una piccola corrente. Sono comuni resistenze di 4,7 k (=4700 Ohm) o 10 kΩ (=10.000 Ohm). Questi resistori sono chiamati resistenze di pull-down.
Tuttavia, puoi anche programmare il GPIO in modo che indichi normalmente ALTO e riconosca la pressione del tasto su GND come un passaggio a BASSO. In questo caso il resistore si chiama resistenza di pull-up. Per confondere ancora di più i principianti, i GPIO di Raspberry Pi hanno una resistenza interna di pull-up o pull-down che può essere attivata o disattivata nel programma. Fortunatamente, questo rende i circuiti iniziali molto semplici.
Lo schema del circuito: Pulsante su Raspberry Pi
Il codice del programma: Pulsante su Raspberry Pi
da gpiozero importa LED, Pulsante
da signal import pause
led = LED(12)
pulsante = pulsante(16)
pulsante.quando_premuto = led.on
pulsante.quando_rilasciato = led.off
pausa()
Dal modulo gpiozero vengono importate le classi LED e button, separate da virgole, quindi gli oggetti led e button vengono istanziati con i rispettivi numeri GPIO.
Al posto del metodo sleep()-Del modulo time modulo, pausa dal modulo segnale sleep() significherebbe un arresto completo, la pressione dei tasti non verrebbe notata durante il tempo. Senza pause(), il programma terminerebbe e non accadrebbe nulla.
L'istanziazione del pulsante è stata molto semplice perché abbiamo specificato solo il numero di GPIO e per il resto abbiamo utilizzato le impostazioni predefinite (vedi la definizione della classe nella riga successiva). Se vuoi discostarti da questa impostazione, devi inserire altri parametri come argomenti delle parole chiave.
classe gpiozero.Button(pin, *, pull_up=True, active_state=None, bounce_time=None,
hold_time=1, hold_repeat=False, pin_factory=None)
Maggiori dettagli su gpiozero si possono trovare qui.
Estensione del setup sperimentale: un ciclo semaforico deve essere avviato con un Raspberry Pi quando viene premuto un pulsante.
Il setup sperimentale si basa sul primo esempio. Al posto di un LED, viene utilizzato un semaforo a LED. Questo ha resistenze in serie integrate. Istanziamo tre oggetti LED e definiamo una funzione trafficLight, che viene richiamata quando viene premuto un pulsante.
Il codice del programma: Ciclo del semaforo su Raspberry Pi
da gpiozero import LED, Button
da signal import pause
da time import sleep
redled = LED(16)
yellowled = LED(20)
greenled = LED(21)
pulsante = pulsante(12)
def trafficLight():
redled.on()
sleep(1)
yellowled.on()
dormire(1)
greenled.on()
redled.off()
yellowled.off()
dormire(1)
yellowled.on()
greenled.off()
dormire(1)
redled.on()
yellowled.off()
dormire(1)
redled.off()
button.when_pressed = trafficLight
pausa()
Estensione: gioco di reazione con due pulsanti su Raspberry Pi
Hai bisogno di due pulsanti, un cicalino e un LED rosso e giallo. Dopo aver avviato il gioco di reazione, il LED giallo si accende per primo. Con tempo = uniforme(5, 10) il LED rosso si accende dopo un tempo casuale compreso tra cinque e dieci secondi. A questo punto due giocatori possono premere ciascuno il proprio pulsante il più velocemente possibile. Se si preme troppo presto, si verrà scoperti a barare e il cicalino suonerà per mezzo secondo.
Il codice del programma: Sonda di reazione con due pulsanti su Raspberry Pi
#! /usr/bin/python3
# Gioco di reazione - premi il pulsante, quando il LED rosso si accende
# basato sulla documentazione di gpiozero, Ricette di base
# migliorato per riconoscere gli imbrogli da Bernd Albrecht
# Il LED rosso si accende 5-10 secondi dopo il LED giallo
da gpiozero import Button, LED, Buzzer
da time import sleep
da random import uniform
da sys import exit
led_rosso = LED(16)
led_giallo = LED(20)
buzzer = cicalino(12)
giocatore_1 = Pulsante(23)
player_2 = Pulsante(18)
led_giallo.on()
tempo = uniforme(5, 10)
sleep(time)
se player_1.is_pressed:
print("Il giocatore 1 sta barando!")
cicalino.on()
sleep(0,5)
cicalino.off()
led_giallo.off()
exit()
se player_2.is_pressed:
print("Il giocatore 2 sta barando!")
cicalino.on()
sleep(0,5)
cicalino.off()
led_giallo.off()
exit()
led_rosso.on()
led_giallo.off()
mentre Vero:
se player_1.is_pressed:
print("Il giocatore 1 vince!")
pausa
se player_2.is_pressed:
print("Il giocatore 2 vince!")
pausa
led_red.off()
