Programmazione di un Micro:Bit Robot e Joystick:Bit Controller con MicroPython: 11 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

Per Robocamp 2019, il nostro campo estivo di robotica, i giovani di età compresa tra 10 e 13 anni stanno saldando, programmando e costruendo un "robot antipeso" della BBC basato su micro:bit, oltre a programmare un micro:bit da utilizzare come telecomando.

Se sei attualmente su Robocamp, vai al passaggio 3, poiché abbiamo eseguito i primi due passaggi in gruppo

Questa è una guida passo passo per far comunicare un robot micro:bit con un controller joystick:bit.

Non è il percorso più veloce per far funzionare tutto, ma prova le cose in piccoli blocchi in modo che tu possa testare il codice mentre procedi, apporre il tuo timbro su di esso e capire perché stiamo facendo le cose che stiamo facendo !

Per questa attività, stiamo utilizzando il nostro robot personalizzato, ma funzionerà con qualsiasi robot che utilizza un driver motore simile, come un L9110s.

I file di progettazione per il nostro robot possono essere trovati qui:

Questa guida è scritta per i principianti, ma se non hai mai usato un micro:bit con MicroPython prima, ti consigliamo di provare prima un programma più semplice, come il nostro badge nominativo Instructable: https://www.instructables.com/id/Felt -Microbit-Nam…

Forniture

2x BBC micro: bit

Robot che funziona con un micro:bit BBC (vedi spiegazione sopra)

joystick: controller bit (il nostro l'abbiamo preso da Cool Components)

Passaggio 1: configurazione del robot

Hai alcune opzioni per scrivere il codice MicroPython per il tuo micro:bit:

• Mu, che puoi scaricare e installare da qui:
• L'editor online, che puoi trovare qui:

Queste istruzioni presuppongono che tu stia usando Mu

Apri Mu e collega il tuo micro:bit al tuo computer. Mu dovrebbe riconoscere che stai usando un micro:bit e selezionare micro:bit 'Modalità', ma se non lo fa, cambialo manualmente.

Ottieni una copia del codice di test del motore del robot da qui:

Se non sei abituato a Github, può essere poco intuitivo! Due semplici modi per ottenere questo codice sono:

1. Salva il file Raw sul tuo computer, quindi caricalo in Mu:
2. Copia e incolla tutto il codice fornito in un nuovo file in Mu.

Ora fai clic sul pulsante 'Flash' dalla barra degli strumenti di Mu, per inviare il tuo nuovo codice al micro:bit.

Questo non funzionerà a meno che il micro:bit non sia collegato

La spia gialla sul retro del micro:bit inizierà a lampeggiare. Al termine, il codice è stato trasferito.

IMPOSTAZIONE DELLE DIREZIONI DEL MOTORE

Questo programma accenderà i motori in direzioni diverse quando si preme il pulsante 'A' sul micro:bit.

Quello che vuoi che accada è:

• Quando viene visualizzato 'A', motore sinistro in avanti
• Quando viene visualizzato 'B', motore sinistro all'indietro
• Quando viene visualizzato 'C', motore destro in avanti
• Quando viene visualizzato 'D', motore destro all'indietro

Questo probabilmente non sarà il caso, poiché dipende da come hai cablato il tuo robot!

Nella parte superiore del codice, troverai un elenco di variabili, che determinano quale pin sul micro:bit controlla quale direzione del motore.

Se stai utilizzando uno dei nostri robot (file), scambia i nomi delle variabili per far muovere il robot nelle direzioni corrette:

Se stai usando un tuo robot, controlla a quali pin è collegato il driver del motore prima di modificare il codice.

PROVA DELLA GUIDA

Ora controlla come guida il tuo robot sostituendo il codice di prova nel ciclo principale con un codice tuo.

Dici al robot di guidare chiamando la funzione drive(). Questo richiede due argomenti: un valore per il motore sinistro e un valore per i motori destro, compreso tra 0 (spento) e 1023 (velocità massima).

Chiamando drive(500, 500), ad esempio, stai dicendo a entrambi i motori di accendersi, nella direzione avanti, a circa metà velocità.

Prova alcune opzioni per avere un'idea di quanto va dritto e quanto bene gira.

Suggerimento: i test del motore erano all'interno di un ciclo while True e di un'istruzione if: i motori non giravano fino a quando non si premeva il pulsante A sul micro: bit, e controlla continuamente se è stato premuto il pulsante A.

Suggerimento: i motori non si spengono finché non glielo dici tu! Continueranno sempre a fare la loro ultima istruzione.

OPTIONAL: MIGLIORARE LA GUIDA IN LINEA RETTA

Se il tuo robot non guida in linea retta, uno dei tuoi motori potrebbe girare più velocemente dell'altro.

Dopo aver verificato che non ci sia nulla che impedisca fisicamente alla ruota di girare liberamente, è possibile modificare il codice nella funzione di guida per ridurre la velocità del motore più veloce.

Scorri verso l'alto per trovare la definizione della funzione di guida e guarda le prime due istruzioni:

def unità (L, R):

# Di seguito è riportata una regolazione per correggere la discrepanza della velocità del motore L = int(L*1) R = int(R*1)

Queste due linee attualmente prendono il valore di L e R, moltiplicale per 1, quindi assicurati che siano ancora numeri interi (int).

Ad esempio, se il tuo motore sinistro è più veloce, cambia *1 sulla sua linea in *0.9 e vedi se questo migliora le cose.

Non sarai in grado di renderlo perfetto, ma puoi continuare a regolarlo finché non si raddrizza.

IMPOSTAZIONE DELLA RADIO

Ora imposta la radio, aggiungendo le seguenti righe all'inizio del tuo codice:

importare radio

radio.config(canale=7, gruppo=0, coda=1) radio.on()

Ciò consentirà al tuo robot di ricevere istruzioni da un altro micro:bit, ma al momento riceverà istruzioni da qualsiasi altro micro:bit.

Questo perché il canale 7 e il gruppo 0 sono i canali predefiniti.

Modificare questi numeri, scegliendo un canale tra 0-82 e un gruppo tra 0-255. Ora il tuo micro:bit riceverà istruzioni solo da altri con le stesse informazioni di configurazione.

coda = 1 significa che il micro: bit manterrà solo un messaggio in arrivo alla volta - questo dà un tempo di risposta leggermente più veloce rispetto al valore predefinito, che è 3.

Ora è necessario modificare il codice del ciclo principale per, invece di eseguire istruzioni quando si preme un pulsante, attendere un messaggio radio in arrivo e rispondere in modo appropriato.

Prova il seguente codice come test (non farà nulla finché non avrai impostato il joystick nel passaggio 2):

mentre vero:

message = radio.receive() if message == 'forward': drive(500, 500)

Passaggio 2: configurazione del joystick

Scollega il micro:bit del tuo robot e collega invece il micro:bit del joystick

Ottieni una copia del codice di configurazione del joystick da qui:

Imposta la radio utilizzando la stessa configurazione (canale e numero di gruppo) utilizzata per il robot: questo consentirà ai due di comunicare tra loro.

Alla fine del programma, avvia il tuo ciclo principale:

mentre vero:

if button_a.was_pressed(): radio.send('forward')

Questo codice non usa ancora il joystick:bit. Utilizza il pulsante A del micro:bit per inviare un messaggio.

Assicurati che sia il tuo robot che il tuo controller micro:bit siano alimentati, quindi premi il pulsante per inviare il tuo messaggio.

Se il messaggio viene ricevuto con successo e il tuo robot si muove… ben fatto! Hai finito con le istruzioni di installazione.

SUGGERIMENTI PER LA RISOLUZIONE DEI PROBLEMI

Se ricevi un messaggio di errore sul tuo controller micro:bit… esegui il debug del codice del controller

Se ricevi un messaggio di errore sul tuo robot micro:bit… il tuo messaggio radio è stato inviato con successo! Ma il robot non può capirlo, quindi controlla che il messaggio che hai inviato e il messaggio che hai detto al robot di ascoltare corrispondano.

Se non succede nulla

• Assicurati di aver lampeggiato il codice corretto su ogni micro:bit - è facile far lampeggiare accidentalmente quello sbagliato!
• Assicurati che i numeri del tuo canale e del gruppo corrispondano su ogni micro:bit

Passaggio 3: verifica dei valori del joystick

I prossimi passaggi utilizzano tutti il codice del controller

Prima di poter utilizzare il joystick sul controller, devi sapere che tipo di valori ottieni quando premi lo stick.

Sostituisci il tuo ciclo principale con il seguente codice:

mentre vero:

joystick = joystick_push() print(joystick) sleep(500)

Flash questo codice sul tuo micro: bit, quindi fai clic sul pulsante REPL sulla barra degli strumenti di Mu. Questo aprirà un terminale nella parte inferiore dell'editor, che ti darà un collegamento in tempo reale al micro:bit.

Questo non funzionerà a meno che il micro:bit non sia collegato

Con REPL aperto, premi il pulsante di ripristino sul retro del tuo micro:bit.

Dovresti vedere alcuni valori portare "stampato" sullo schermo:

Premi la levetta del joystick e guarda cosa succede ai numeri.

Prendere nota dei valori forniti quando il joystick è in posizione centrale - nel mio caso (518, 523).

Fare nuovamente clic sul pulsante REPL sulla barra degli strumenti di Mu per chiuderla: non sarà possibile eseguire il flashing del nuovo codice sul micro: bit mentre è aperto.

Passaggio 4: regolazione delle variabili X e Y

Si desidera modificare i valori dati dalla funzione joystick, in modo che:

• al centro è zero
• up è positivo
• giù è negativo.

Questo corrisponde alle istruzioni necessarie al robot: un numero positivo per guidare in avanti e un numero negativo per guidare all'indietro.

Guarda i numeri che hai ottenuto nell'ultimo passaggio. Il primo numero è x e il secondo numero è y.

Modifica la definizione joystick_push() che è già nel programma, per ridurre i tuoi valori dall'originale:

def joystick_push():

x = pin0.read_analog() - 518 y = pin1.read_analog() - 523 return x, y

Usa i tuoi numeri, potrebbero essere diversi dai miei

Lampeggia il tuo nuovo codice, apri REPL, premi il pulsante di reset del micro:bit e controlla i tuoi valori.

Stai ottenendo (0, 0)?

Passaggio 5: conversione di X e Y in valori per i motori sinistro e destro

Al momento, questo joystick non sarà molto utile per guidare un robot. Spinto in avanti fino in fondo, otterrai un valore come (0, 500).

Se dessi questi numeri al robot, accenderebbe il motore destro ma non quello sinistro, il che non è quello che vuoi che accada!

Questo diagramma mostra cosa succede ai valori x e y quando muovi il joystick e cosa vogliamo che il robot faccia quando muovi il joystick.

Devi usare un po' di matematica per mescolare i valori x e y, per darti qualcosa di più utile.

n

LA MATEMATICA

Iniziamo spingendo il joystick completamente in avanti.

Un esempio dei valori che potresti ottenere è:

x = 0

y = 500

Per essere utile al robot, vuoi ottenere valori come questi:

sinistra = 500

destra = 500

Proviamo ad aggiungere x e y in diversi modi per vedere quali numeri otteniamo:

x + y = 0 + 500 = 500

x - y = 0 - 500 = -500 y + x = 500 + 0 = 500 y - x = 500 - 0 = 500

Ora vediamo cosa succede se spingiamo il joystick completamente a destra.

Un esempio dei valori che potresti ottenere è:

x = 500

y = 0

Per far girare il robot a destra, vuoi che il motore sinistro vada in avanti e il motore destro che guidi all'indietro:

sinistra = 500

destra = -500

Proviamo di nuovo la nostra formula:

x + y = 500 + 0 = 500

x - y = 500 - 0 = 500 y + x = 0 + 500 = 500 y - x = 0 - 500 = -500

Confronta i due set di formule per capire quale opzione ti darà il valore corretto a sinistra e quale opzione ti darà il valore corretto a destra.

Provalo con alcuni dei valori che ottieni dal tuo joystick, per assicurarti che la formula scelta funzioni sempre.

n

ESPANSIONE DELLA FUNZIONE JOYSTICK

Espandi e modifica la funzione del joystick per creare due nuove variabili per sinistra e destra e per restituire quei valori invece di x e y:

def joystick_push():

x = pin0.read_analog() - 518 y = pin1.read_analog() - 523 left = right = torna a sinistra, a destra

Lampeggia il tuo nuovo codice, apri REPL, premi il pulsante di reset del micro:bit e controlla i tuoi valori.

Stai ottenendo i valori che ti aspetti?

Se hai bisogno di ulteriore aiuto, controlla il nostro codice di esempio qui:

Passaggio 6: invio dei valori come messaggi radio

Ora hai alcuni valori pronti da inviare al tuo robot.

Modifica il tuo ciclo principale, in modo che controlli i valori del joystick, ma invece di stampare i valori, li prepara per l'invio come messaggio radio.

mentre vero:

joystick = joystick_push() messaggio = str(joystick[0]) + " " + str(joystick[1])

Questo non invierà ancora il messaggio!

Cosa sta succedendo in questa nuova riga di codice?

• joystick[0] indica la prima informazione che esce dalla funzione joystick (sinistra)
• joystick[1] è l'informazione successiva (a destra)
• str() converte entrambi questi numeri in formato stringa (testo invece di numeri) - questo è necessario per poter inviare le informazioni via radio.

Sarai abituato a vedere + per indicare l'addizione: può sia sommare numeri che concatenare stringhe, il che significa che unirà i due bit di informazione.

Esempio:

150 + 100 = 250

str(150) + str(100) = 150100

Quindi la concatenazione unirà i tuoi valori sinistro e destro insieme.

Per forzare una separazione tra i due bit di informazione (in modo che il robot sappia che sono due bit di informazione), concatena una stringa in più tra di loro usando " ". I segni di discorso intorno allo spazio significano che è già una stringa.

Infine, estendi il tuo codice per inviare questo messaggio appena creato alla radio:

radio.send(messaggio)

dormire(10)

Lo sleep rallenta l'invio dei messaggi in modo che il micro:bit ricevente non venga sovraccaricato di troppe informazioni!

Invia questo codice al tuo controller micro:bit ed esegui il debug di eventuali errori prima di passare al passaggio successivo

Passaggio 7: ricezione dei messaggi sul tuo robot

Torna al codice del tuo robot dall'inizio: ricordati di scollegare il controller micro:bit in modo da non fargli lampeggiare accidentalmente il codice del robot

Scorri verso il basso fino al tuo ciclo principale: rimuovi il codice di test e aggiungi questo:

mentre vero:

messaggio = radio.receive() print(messaggio) sleep(100)

Questo imposta una variabile uguale al messaggio in arrivo e stampa il messaggio sul REPL - per verificare che i messaggi arrivino come previsto.

Lampeggia il tuo nuovo codice, collegati al REPL, quindi premi il joystick.

Dovresti ottenere qualcosa del genere:

SUGGERIMENTI PER LA RISOLUZIONE DEI PROBLEMI

Se ricevi un messaggio di errore sul tuo controller micro:bit… esegui il debug del codice del controller

Se ricevi un messaggio di errore sul tuo robot micro:bit… il tuo messaggio radio è stato inviato con successo! Ma il robot non può capirlo, quindi controlla che il messaggio che hai inviato e il messaggio che hai detto al robot di ascoltare corrispondano.

Se non succede nulla

• Assicurati di aver lampeggiato il codice corretto per ogni micro:bit - è facile far lampeggiare accidentalmente quello sbagliato!
• Assicurati che i numeri del tuo canale e del gruppo corrispondano su ogni micro:bit

Passaggio 8: utilizzo dei messaggi in arrivo per controllare i motori del robot

Ora stai ricevendo due numeri inviati via radio come una stringa.

Devi dividere questo messaggio in due stringhe, quindi riconvertire le stringhe in numeri e passarlo alla funzione drive. Molte cose in corso in una volta!

Prima di fare ciò, devi verificare che il messaggio che stai ricevendo sia nel formato corretto.

Se non vengono inviati messaggi, riceverai invece "Nessuno". Se provi a dividerlo, riceverai un messaggio di errore.

mentre vero:

message = radio.receive() se message non è None: message = message.split() drive(int(message[0]), int(message[1]))

Cosa sta succedendo qui?

• Il nuovo codice verrà eseguito se il messaggio è diverso da "Nessuno".
• message.split() verifica la presenza di uno spazio nel messaggio (che abbiamo aggiunto nell'ultimo passaggio) e lo utilizza per dividere il messaggio in due.
• int(message[0]), int(message[1]) fa l'opposto di quello che abbiamo fatto nel passaggio precedente: ottiene ogni informazione individualmente e la converte in un intero (un numero intero).
• int(messaggio[0]) viene utilizzato come valore per il motore sinistro nella funzione di azionamento e int(messaggio[1]) viene utilizzato come valore per il motore destro.

Controlla che funzioni: i motori girano quando spingi il joystick?

In caso contrario, è tempo di eseguire il debug!

Se sì, fantastico! Hai un robot telecomandato funzionante!

Dedica un po' di tempo a esercitarti con il tuo robot prima di passare al passaggio successivo. Guida come ti aspetti?

I passaggi successivi ti mostreranno come utilizzare i pulsanti sul joystick per aggiungere funzionalità extra al tuo robot

Se vuoi vedere la nostra versione di questo codice finora:

• Robot:
• Controllore:

Passaggio 9: utilizzo dei pulsanti - ricezione di messaggi aggiuntivi

Al momento, il tuo codice proverà a dividere qualsiasi messaggio che non sia Nessuno. Ciò significa che se riceve, ad esempio, "ciao", riceverai un messaggio di errore.

Per consentire al tuo micro:bit di interpretare altri messaggi, dovrà prima controllare ogni messaggio previsto, quindi dividere il messaggio solo se non gli è stato detto di fare qualcos'altro con esso.

Espandi il tuo codice in questo modo:

se il messaggio non è Nessuno:

if message == 'ciao': display.show(Image. HAPPY) elif message == 'duck': display.show(Image. DUCK) else: message = message.split() drive(int(message[0]), int(messaggio[1]))

Innanzitutto, controllerà se ha ricevuto il messaggio "ciao". Se lo è, mostrerà un'immagine felice, quindi torna all'inizio del ciclo e controlla il messaggio successivo.

Se il messaggio non è ciao, controllerà se il messaggio è "anatra".

Se il messaggio non è "ciao" O "anatra", farà l'ultima cosa nell'elenco, ovvero dividere il messaggio e accendere i motori. Non proverà a dividere il messaggio se ha ricevuto "ciao" o "anatra", il che significa che non riceverai un messaggio di errore da nessuno di questi due messaggi.

Il doppio segno di uguale è importante - significa "è uguale a", rispetto a un singolo segno di uguale, che sta impostando qualcosa (quindi messaggio = "ciao" significa che stiamo impostando la variabile su "ciao", messaggio == "ciao" significa che stiamo chiedendo se il messaggio è uguale a 'ciao').

Provalo con solo due opzioni per ora, per provarlo: puoi aggiungere tutti gli altri messaggi che vuoi in seguito.

Link al codice funzionante:

Passaggio 10: invio di messaggi aggiuntivi utilizzando i pulsanti del controller

Scollega il micro:bit del tuo robot e collega invece il micro:bit del joystick

Torna al codice del controller da modificare.

Simile al codice del robot, vogliamo che il controller controlli se stai provando a inviare altri messaggi, prima di inviare i valori del joystick.

Nella parte superiore del ciclo, vogliamo ancora che controlli i valori correnti del joystick, ma vogliamo anche che controlli se un pulsante è attualmente premuto:

mentre vero:

joystick = joystick_push() pulsante = button_press()

button_press() restituisce un valore A, B, C, D, E o F a seconda del pulsante attualmente premuto (se non viene premuto nulla, restituisce Nessuno).

Ora possiamo fare un'istruzione if-elif-else, come abbiamo fatto per il codice del robot, usando due pulsanti e inviando il valore del joystick se non viene premuto alcun pulsante.

if pulsante == 'A':

radio.send('ciao') sleep(500) pulsante elif == 'B': radio.send('duck') sleep(500) else: message = str(joystick[0]) + " " + str(joystick [1]) radio.send(messaggio) sleep(10)

Quando viene premuto un pulsante, invia uno dei messaggi che hai detto al robot di cercare nel passaggio precedente.

Il messaggio verrà inviato ogni volta che si preme il pulsante e i computer sono molto più veloci delle persone! Quindi potrebbe inviare il messaggio molte volte prima che tu sia riuscito a togliere il dito dal pulsante.

Il sonno dopo l'invio del messaggio lo rallenta, in modo che non controlli di nuovo il pulsante così velocemente - prova alcuni numeri qui per ottenere la quantità di tempo perfetta per te - troppo lentamente e non sarà reattivo, anche rapidamente e il tuo robot riceverà così tanti messaggi sui pulsanti che potrebbe smettere di rispondere al joystick!

Funziona?

Se ricevi messaggi di errore, pensa attentamente a cosa hai appena cambiato e cosa sta succedendo.

Se ricevi un errore sul robot quando premi un pulsante sul controller, sai che il messaggio sta arrivando, ma sta confondendo il robot. Verifica che il messaggio che hai inviato e il messaggio che hai detto al robot di cercare siano gli stessi.

Link al codice funzionante:

Passaggio 11: passaggi successivi

Ora hai le conoscenze necessarie per lavorare con i motori del tuo robot e con il tuo joystick: controller bit

Usa questa conoscenza per migliorare i due programmi e renderli tuoi. Alcune idee qui sotto!

Hai sei pulsanti sul tuo controller! Cosa vuoi che facciano?

• Che ne dici di programmare una routine di ballo per il tuo robot da eseguire a comando? Scrivi un algoritmo di comandi drive(), separati da comandi sleep()!
• Vuoi cambiare la direzione in cui si muove il robot in modo che possa facilmente guidare a testa in giù? Pensa ai valori x e y del tuo joystick. Cosa rappresentano e come potresti manipolarli?
• Il tuo robot ha (o potresti aggiungere!) funzioni extra come LED, altoparlante o sensori?

Idee per migliorare il codice

• Potresti aiutare il tuo robot a far fronte ai messaggi sconosciuti usando il codice try/eccetto?
• I calcoli matematici utilizzati per calcolare i valori sinistro e destro dal joystick non forniscono l'intera gamma di valori (l'unità del robot può accettare un numero fino a 1023). Puoi modificare questo codice per ottenere un intervallo migliore?
• Esistono altri metodi per combinare i valori del joystick: puoi trovare un modo migliore per farlo?