Una guida per principianti al breadboard di Raspberry Pi con il gioco Simon
Una breadboard ti consente di creare circuiti senza dover saldare nulla. È un ottimo strumento per sperimentare con l'elettronica, ma può intimidire. Avere un progetto da costruire può aiutarti a rimanere motivato mentre impari.
Ci sono diversi giochi semplici che rendono fantastici progetti per principianti Raspberry Pi. Un gioco facile per iniziare è il gioco Simon. Simon è un gioco di memoria in cui una serie di luci lampeggiano in ordine casuale e il giocatore deve ricordare la sequenza. Man mano che il giocatore avanza, la lunghezza della sequenza aumenta.
Componenti richiesti
Per iniziare, avrai bisogno delle seguenti cose:
- Un Raspberry Pi
- Una scheda microSD lampeggiava con il sistema operativo Raspbian
- 4 x LED di diversi colori
- 4 x resistori (qualsiasi cosa da 220 Ohm a 1 Kilo-Ohm)
- 4 x pulsanti
- 1 x breadboard
- Cavi jumper per collegare tutto
Puoi utilizzare qualsiasi Raspberry Pi per questo progetto, ma i modelli Pi Zero non si collegano facilmente alle breadboard senza un po 'di saldatura. Qualunque modello tu usi, avrai anche bisogno di una fonte di alimentazione, un monitor, una tastiera e un mouse.
Se non hai mai configurato un Raspberry Pi prima, puoi imparare come preparare tutto per questo tutorial nella guida per principianti Raspberry Pi .
Scriverai codice Python in questo tutorial e puoi usare qualsiasi editor di testo per scriverlo, ma potresti trovare un editor di codice più semplice. Ce ne sono diversi già installati sul sistema operativo Raspberry Pi e Thonny è progettato per essere facile per i principianti. Qualunque sia quello che usi, dovrai essere in grado di salvare ed eseguire il tuo codice per seguire questo tutorial.
Iniziare con una breadboard
Se non hai mai usato una breadboard prima, potresti iniziare leggendo un tutorial sulla breadboard . Capire come funziona una breadboard ti aiuterà a capire come creare circuiti.
Il Raspberry Pi ha due file di pin di input / output (GPIO) per uso generico. Questi pin ti consentono di collegare i componenti al tuo Raspberry Pi. Alcuni pin inviano informazioni, altri forniscono alimentazione e alcuni mettono a terra l'elettronica.
Inizieremo aggiungendo una luce LED alla nostra breadboard. Se non hai mai lavorato prima con le luci LED su una breadboard, potresti voler leggere un tutorial che spiegherà come funziona in modo più approfondito .
Inizia collegando un pin GPIO alla tua scheda. Non importa quale pin, purché sia un pin GPIO e non un pin di alimentazione o di terra. Sopra c'è un grafico dei pin GPIO, che ti aiuterà a determinare quale pin utilizzare. Questo tutorial utilizza il pin numero 18, che è anche etichettato GPIO 24.
Il pin fornirà energia alla breadboard e consentirà al Raspberry Pi di comunicare con i componenti sulla scheda. Quindi collega il pin numero 6 sul Pi alla guida di terra della breadboard. Questo metterà a terra la scheda e ci consentirà di creare circuiti.
La potenza proveniente dal Raspberry è troppo alta per collegare direttamente il LED. L'uso di un resistore abbassa il livello di potenza e impedisce al LED di bruciarsi. Collega un lato del resistore alla stessa linea a cui è collegato il pin GPIO e l'estremità all'altro lato della breadboard. Quindi posizionare il lato positivo del LED dopo il resistore. L'estremità negativa del LED può essere collegata direttamente alla guida negativa. Il risultato finale dovrebbe essere simile al diagramma sopra. Controlla attentamente il cablaggio e accendi il Pi. Il LED dovrebbe accendersi.
Ora hai creato un circuito usando il tuo Raspberry Pi che puoi controllare usando il codice.
Utilizzo del codice Python per controllare i LED
Questo tutorial ti guida attraverso il codice in passaggi, ma se vuoi fare riferimento al codice finito in qualsiasi momento, è disponibile su Pastebin .
In questo momento, l'alimentazione sta andando al LED, ma vogliamo controllare quando si accende e si spegne. Il seguente codice Python ci permetterà di parlare con il consiglio.
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
red = 18
GPIO.setup(red, GPIO.OUT)
GPIO.output(red, GPIO.LOW)
Le prime righe impostano le cose. La libreria GPIO di Raspberry Pi viene importata. Il come GPIO solo ci permette di riferimento a RPi.GPIO come GPIO per salvare un po 'di battitura. La modalità pin GPIO è impostata su BOARD . Non è necessario utilizzare questa impostazione, ma può essere più semplice fare riferimento ai pin in base al loro ordine nelle righe GPIO.
Infine, impostiamo gli avvisi su false. Ciò interromperà gli avvisi non necessari.
Le tre linee successive controllano il LED. Il LED rosso è collegato al pin 18 GPIO. Invece di ricordarlo, la variabile rossa memorizzerà la posizione. Avanti, GPIO.setup dice il nostro programma che si sta inviando le informazioni fuori al pin rosso. Infine, impostiamo il GPIO. uscita sul pin rosso al minimo . Quando esegui questo programma, la luce si spegne. Per riattivarlo, imposta GPIO.LOW su GPIO.HIGH ed esegui nuovamente il programma.
Salva il codice e fai clic su Esegui per vederlo in azione. Se non è presente alcun pulsante Esegui nell'editor di codice, salvalo ed esegui python nomefile.py nella finestra del terminale. Dovrai prima navigare nella stessa directory del tuo nuovo file Python. Controlla il cheat sheet di Raspberry Pi se non sei sicuro di come.
Aggiunta di più di un LED
Per creare il gioco Simon, abbiamo bisogno di quattro luci di colori diversi. Gli stessi passaggi utilizzati per impostare il LED rosso possono essere utilizzati per configurare gli altri tre. Il tuo cablaggio dovrebbe essere simile allo schema seguente:
Il tuo codice dovrebbe assomigliare a questo:
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
red = 18
yellow = 22
green = 24
blue = 26
GPIO.setup(red, GPIO.OUT)
GPIO.setup(yellow, GPIO.OUT)
GPIO.setup(green, GPIO.OUT)
GPIO.setup(blue, GPIO.OUT)
GPIO.output(red, GPIO.HIGH)
GPIO.output(yellow, GPIO.HIGH)
GPIO.output(green, GPIO.HIGH)
GPIO.output(blue, GPIO.HIGH)
Dopo aver testato i LED, impostare GPIO.output su GPIO.LOW per spegnerli nuovamente.
Anche se il colore dei fili che usi non ha importanza, cerca di usare colori che abbiano un significato per te per aiutarti a leggere più facilmente la lavagna. Ad esempio, i fili neri sono spesso usati per i fili di terra. In questo circuito, potresti voler abbinare il colore del filo al colore della luce LED.
Controllo dei LED con i pulsanti
Inizia aggiungendo un pulsante alla tua bacheca. Il pulsante dovrà essere collegato sia a terra che a un pin GPIO. Il circuito dovrebbe assomigliare a questo:
Per fare in modo che il pulsante controlli un LED, dobbiamo aggiungere al nostro codice. L'impostazione del pulsante è simile alla configurazione di un LED, tranne per il fatto che il pin GPIO è impostato per essere un ingresso, non un'uscita. Questo codice imposta anche il resistore di pull-up interno sul Pi, necessario per far funzionare correttamente il pulsante.
GPIO.setup (32, GPIO.IN, pull_up_down = GPIO.PUD_UP)
Ora abbiamo bisogno di un codice che controlli per vedere se il pulsante è stato premuto.
game = True
while game:
redButtonState = GPIO.input(32)
if redButtonState == 0:
GPIO.output(red, GPIO.HIGH)
time.sleep(1)
GPIO.output(red, GPIO.LOW)
Vogliamo che il nostro programma continui a controllare se viene premuto un pulsante, quindi usiamo un ciclo while . Poiché il ciclo non sarà mai falso, continua a funzionare ea controllare il pulsante finché non terminiamo il programma manualmente premendo il pulsante di arresto o utilizzando la scorciatoia da tastiera Ctrl + c .
Successivamente, per rendere più semplice il riferimento all'input che il pin GPIO del nostro pulsante ci sta inviando, salviamo tali informazioni nella variabile redButtonState . Se il nostro input di pulsante cambia a 0, sappiamo che il pulsante è stato premuto.
Se il pulsante viene premuto, il LED rosso si accenderà. Quindi, dopo un secondo, il LED si spegnerà. Per calcolare il tempo, usiamo la funzione time.sleep (1) . Per fare in modo che funzioni, dovrai importare la libreria del tempo nella parte superiore dello script.
Una volta che un pulsante funziona, è possibile aggiungerne altri tre, uno per ciascun LED. Il tuo codice dovrebbe assomigliare a questo:
import random
import time
import RPi.GPIO as GPIO
GPIO.setmode (GPIO.BOARD)
GPIO.setwarnings(False)
red = 18
yellow = 22
green = 24
blue = 26
GPIO.setup(red, GPIO.OUT)
GPIO.setup(yellow, GPIO.OUT)
GPIO.setup(green, GPIO.OUT)
GPIO.setup(blue, GPIO.OUT)
GPIO.setup(32, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(36, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(38, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(40, GPIO.IN, pull_up_down=GPIO.PUD_UP)
game = True
while game:
redButtonState = GPIO.input(32)
if redButtonState == 0:
GPIO.output(red, GPIO.HIGH)
time.sleep(1)
GPIO.output(red, GPIO.LOW)
yellowButtonState = GPIO.input(36)
if yellowButtonState == 0:
GPIO.output(yellow, GPIO.HIGH)
time.sleep(1)
GPIO.output(yellow, GPIO.LOW)
greenButtonState = GPIO.input(38)
if greenButtonState == 0:
GPIO.output(green, GPIO.HIGH)
time.sleep(1)
GPIO.output(green, GPIO.LOW)
blueButtonState = GPIO.input(40)
if blueButtonState == 0:
GPIO.output(blue, GPIO.HIGH)
time.sleep(1)
GPIO.output(blue, GPIO.LOW)
La tua scheda dovrebbe assomigliare a questo:
Tutta l'elettronica è ora a posto. In caso di problemi, controlla il codice per eventuali errori. Ricorda, puoi scaricare il codice completo da Pastebin se rimani bloccato!
Creare il gioco
Questo progetto ha già coperto tutte le nozioni di base che devi sapere per iniziare a utilizzare una breadboard. Ma trasformare queste abilità in un gioco mostrerà davvero quello che puoi fare!
In Simon, un giocatore vede una serie di luci lampeggiare e deve ricordare lo schema. Si avvia facilmente con una sola luce. Ogni livello aggiunge una luce casuale allo schema per rendere il gioco più difficile.
Creazione del pattern
Questo passaggio è abbastanza semplice. Un array manterrà il nostro schema luminoso. Un secondo array memorizzerà i pin GPIO per le nostre luci . Ad ogni ciclo di gioco, una nuova luce casuale verrà aggiunta alla fine della matrice del pattern . Usiamo il casuale. funzione randint () per scegliere un numero compreso tra 0 e 3, che rappresenta i 4 LED.
pattern = []
lights = [red, yellow, green, blue]
while game:
pattern.append(random.randint(0,3))Successivamente, dobbiamo accendere le luci per mostrare lo schema.
while game:
pattern.append(random.randint(0,3))
for x in pattern:
GPIO.output(lights[x], GPIO.HIGH)
time.sleep(1)
GPIO.output(lights[x], GPIO.LOW)
time.sleep(0.5)
È importante fare una pausa tra due luci. Rende più facile vedere se la stessa luce viene utilizzata back-to-back nel pattern.
Ottenere input dal giocatore
Successivamente, il gioco deve attendere che il giocatore indovini l'ordine delle luci. Il programma deve controllare ogni luce nello schema e attendere che il giocatore prema un pulsante. Ciò richiede cicli annidati:
for x in pattern:
waitingForInput = True
while waitingForInput:
redButtonState = GPIO.input(32)
yellowButtonState = GPIO.input(36)
greenButtonState = GPIO.input(38)
blueButtonState = GPIO.input(40)
if redButtonState == 0:
GPIO.output(red, GPIO.HIGH)
waitingForInput = False
time.sleep(1)
GPIO.output(red, GPIO.LOW)
if yellowButtonState == 0:
GPIO.output(yellow, GPIO.HIGH)
waitingForInput = False
time.sleep(1)
GPIO.output(yellow, GPIO.LOW)
if greenButtonState == 0:
GPIO.output(green, GPIO.HIGH)
waitingForInput = False
time.sleep(1)
GPIO.output(green, GPIO.LOW)
if blueButtonState == 0:
GPIO.output(blue, GPIO.HIGH)
waitingForInput = False
time.sleep(1)
GPIO.output(blue, GPIO.LOW)
La maggior parte del codice sopra sta riutilizzando il codice che abbiamo scritto per testare i pulsanti.
Controlla l'input del giocatore
Da qui, è abbastanza facile controllare se il giocatore ha inserito lo schema corretto. Ogni volta che premono un pulsante, il gioco può verificare se quello era il pulsante corretto. Per fare ciò, aggiungi un'altra istruzione if a ciascun input del pulsante:
if redButtonState == 0:
GPIO.output(red, GPIO.HIGH)
waitingForInput = False
if x != 0:
game = False
time.sleep(1)
GPIO.output(red, GPIO.LOW)
La variabile x del nostro ciclo for ha il numero della luce successiva. La luce LED rossa è nella prima posizione, o numero 0. Se il giocatore ha premuto il pulsante LED rosso quando abbiamo uno 0 nel nostro schema, hanno ragione! In caso contrario, perdono la partita. L'impostazione della variabile game su false interromperà il ciclo di gioco e terminerà il programma.
Congratulazioni! Hai costruito un gioco da zero!
La creazione di un gioco ha aggiunto molto più codice a questo progetto rispetto alla semplice aggiunta di LED e pulsanti. Lavorare a un progetto finale che puoi mostrare ai tuoi amici e familiari può aiutarti a mantenerti motivato.
Questo gioco è abbastanza semplice. Sfida te stesso per migliorare il design di base. Forse le luci potrebbero lampeggiare se il giocatore perde. Forse vuoi metterti alla prova per aggiungere suoni al gioco. La tua immaginazione è l'unico limite!
Ok, questo e l'hardware che hai a portata di mano.
