Parte 3: GPIO: Assemblaggio ARM: Line Follower: TI-RSLK: 6 passaggi

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

Ciao. Questa è la prossima puntata in cui continuiamo a utilizzare l'assembly ARM (invece di un linguaggio di livello superiore). L'ispirazione per questo Instructable è il Lab 6 del Texas Instruments Robotics System Learning Kit, o TI-RSLK.

Utilizzeremo il microcontrollore del kit, la scheda di sviluppo MSP432 LaunchPad, ma forse troverai qualcosa di utile da estrarre da questo Instructable anche se non stai utilizzando il LaunchPad o se segui il T. I. curriculum.

Abbiamo iniziato con un Instructable che introduceva ARM Assembly, l'ambiente di sviluppo e come realizzare un progetto.

Il prossimo Instructable su ARM Assembly ha introdotto come interagire con input/output (GPIO).

Quindi abbiamo ampliato le nostre conoscenze e introdotto funzioni, controllando LED e interruttori.

Ora con questo Instructable, possiamo usare ciò che abbiamo imparato per fare qualcosa di più divertente, più utile: rilevare una linea.

Questo può aiutarci in seguito quando costruiremo un robot line-follower.

Nel curriculum, la maggior parte della programmazione viene eseguita in C o C++, ma è utile acquisire familiarità con l'assembly, prima di iniziare a dipendere da linguaggi e librerie di livello superiore.

Passaggio 1: l'hardware

Non voglio ripassare l'hardware in dettaglio, poiché ci sono già fonti, ma aggiungeremo spiegazioni dove necessario.

Per questo Instructable, utilizzeremo il Reflectance Sensor Arrray di Pololu, poiché fa parte del TI-RSLK (il kit del robot). È quello utilizzato nel corso e nel Lab 6 del curriculum.

Se non lo possiedi, puoi utilizzare qualsiasi rilevatore IR (o serie di essi) che emetta un segnale digitale, ALTO o BASSO, per presenza e assenza.

Il sensore array è il migliore perché può aiutare a rilevare se siamo proprio al centro della linea o da un lato. Inoltre, come vedremo in seguito, può aiutarci a rilevare l'angolo del robot rispetto alla linea.

L'array di riflettanza ha rivelatori molto vicini l'uno all'altro. Ciò significa che dovremmo ricevere più segnali di rilevamento, a seconda ovviamente dello spessore della linea.

Se è così, allora se il robot non è direttamente in linea con la linea, allora dovrebbe restituire un output che la linea è più larga di quanto dovrebbe essere (perché siamo ad angolo).

Per una migliore spiegazione di quanto sopra, dai un'occhiata al documento Lab 6.

Per assistenza nel cablaggio/collegamento del sensore alla scheda di sviluppo MSP432 LaunchPad, ecco alcune istruzioni utili.

Ho anche aggiunto le stesse (simili?) istruzioni PDF a questo passaggio.

Se leggi attentamente i documenti Pololu, spiegano il motivo del "bypass a 3.3V", che vorrai ponticellare se stai usando 3.3V invece di 5V.

Poiché non stiamo ancora costruendo il robot, ma stiamo solo imparando l'assemblaggio di ARM e anche come interagire con i pezzi (sottosistemi) del robot, non dobbiamo seguire alla lettera le istruzioni di cui sopra.

Per ora, il collegamento dell'array del sensore di linea si riduce/riduce a quanto segue:

• collegare 3.3V e GND dalla scheda MSP432 all'array di sensori.
• collegare un pin della porta (suggerisco P5.3) dall'MSP432 al pin di abilitazione LED sull'array del sensore di linea. Quel pin sul sensore è compreso tra 3,3 V e GND.
• collegare tutti gli otto pin/bit di una singola porta (suggerisco da P7.0 a P7.7) agli otto pin dell'array di sensori etichettati da "1" a "8". Queste sono le linee che diventeranno ALTE o BASSE a seconda di ciò che percepiscono.

Come puoi vedere nelle immagini di questo passaggio e nel video, non ho collegato il sensore al telaio del robot, perché volevo facilità di programmazione, debug, test, apprendimento.

Quindi, con tutto ciò che è connesso, siamo pronti per entrare nel software.

Passaggio 2: seguire la riga

Il sensore array di riflettanza è piuttosto elegante perché può aiutare in almeno due modi.

• Determina se il robot è centrato sulla linea o si sposta da un lato.
• Il robot è allineato nella direzione della linea o è inclinato.

Ciascuno dei rivelatori dell'array fornisce essenzialmente un bit di informazione, ALTO o BASSO.

L'idea è di combinare tutti quei bit in un singolo numero o un singolo modello di bit e utilizzare quel modello per prendere decisioni (per muoversi correttamente).

Passaggio 3: prima di poter davvero iniziare…

.. abbiamo bisogno di imparare qualcosa di nuovo sulla programmazione degli assembly ARM. E non intendo solo un'altra istruzione. Quelli tendono ad essere minori.

Finora non abbiamo utilizzato lo "stack" nei nostri programmi.

Abbiamo fatto affidamento sull'utilizzo della maggior parte dei registri core della CPU a livello globale attraverso diverse subroutine.

L'unica cosa che abbiamo fatto è stata salvare e ripristinare l'indirizzo LR (registro di collegamento) per una funzione, quella che ha chiamato diverse altre funzioni. (Uso "funzione" e "subroutine" in modo intercambiabile qui).

Quello che abbiamo fatto non va bene. E se volessimo nidificare altre funzioni? E se abbiamo più di un livello di nidificazione?

Negli esempi precedenti, abbiamo scelto di utilizzare il registro R6 come memoria per LR o indirizzo di ritorno. Ma se vogliamo fare una nidificazione più profonda, non possiamo continuare a cambiare il valore di R6. Dovremmo scegliere un altro registro. E un altro. E poi diventa oneroso tenere traccia di quale registro core della CPU contiene quale LR ripristinare a quale funzione.

Quindi ora diamo un'occhiata allo "stack".

Passaggio 4: la pila

Ecco del materiale di lettura che spiega lo stack.

Sono un grande sostenitore di un paio di idee:

• solo la quantità di teoria necessaria, passa alla pratica rapidamente
• impara se necessario, concentrati sul fare effettivamente qualcosa e non solo su esercizi o esempi senza scopo.

C'è un sacco di documentazione ARM e MSP432 online che parla dello stack, quindi non ripasserò tutto questo. Ho anche intenzione di mantenere l'utilizzo dello stack qui al minimo - salvando l'indirizzo di ritorno (il registro di collegamento).

In sostanza, abbiamo solo bisogno di istruzioni:

PUSH {lista di registrazione}

POP{elenco registri}

Oppure, nel nostro caso, nello specifico:

PREMERE {LR}

POP {LR}

Quindi, una funzione/subroutine di assembly sarebbe simile a:

funcLabel:.asmfunc

PUSH{LR};questa dovrebbe essere probabilmente una delle prime istruzioni all'inserimento.; fai più codice qui..; bla… bla… bla…; ok, abbiamo finito con la funzione, pronti per tornare alla funzione chiamante POP{LR}; questo ripristina l'indirizzo di ritorno corretto alla chiamata; funzione. BXLR; return.endasmfunc

Il video mostra un esempio dal vivo di diverse funzioni nidificate.

Passaggio 5: il software

Il file allegato etichettato "MSP432_Chapter…" contiene molte buone informazioni sulle porte dell'MSP432, e da quel documento otteniamo le seguenti porte, registri, indirizzi, ecc. Tuttavia è un po' datato. Tuttavia, non ho visto gli indirizzi dettagliati elencati per la porta 5 e successive. (solo "funzioni alternative"). Ma è ancora utile.

Useremo due porte. P5, P7, P1 e P2.

L'uscita P5.3 (un singolo bit) servirà a controllare l'abilitazione del LED IR sul sensore. Usiamo P5.3 perché è un pin esposto sulla stessa intestazione delle altre connessioni MSP432 che vanno all'array di sensori.

Da P7.0 a P7.7 saranno gli otto ingressi che raccolgono i dati dal sensore; cosa "vede".

P1.0 è il singolo LED rosso e potremmo usarlo per darci qualche indicazione sui dati.

P2.0, P2.1, P2.2 è il LED RGB e possiamo usare anche quello, con le sue diverse possibilità di colore, per darci un'indicazione dei dati del sensore.

Se hai seguito gli Instructables precedenti relativi a tutto questo, allora sai già come impostare il programma.

Basta avere una sezione di dichiarazione per le porte e i bit, ecc.

Avrai una sezione "principale".

Dovrebbe esserci un ciclo, in cui leggiamo continuamente i dati da P7, prendiamo una decisione su quei dati e accendiamo i due LED di conseguenza.

Ecco di nuovo gli indirizzi del registro delle porte:

• GPIO P1: 0x4000 4C00 + 0 (indirizzi pari)
• GPIO P2: 0x4000 4C00 + 1 (indirizzi dispari)
• GPIO P3: 0x4000 4C00 + 20 (indirizzi pari)
• GPIO P4: 0x4000 4C00 + 21 (indirizzi dispari)
• GPIO P5: 0x4000 4C00 + 40 (indirizzi pari)
• GPIO P6: 0x4000 4C00 + 41 (indirizzi dispari)
• GPIO P7: 0x4000 4C00 + 60 (indirizzi pari)
• GPIO P8: 0x4000 4C00 + 61 (indirizzi dispari)
• GPIO P9: 0x4000 4C00 + 80 (indirizzi pari)
• GPIO P10: 0x4000 4C00 + 81 (indirizzi dispari)

Ciò che è in grassetto è ciò che useremo per questo Instructable.

Passaggi del programma per leggere i rilevatori IR

Quello che segue è uno pseudo-codice per scrivere il programma in C, ma è comunque utile e lo seguiremo abbastanza da vicino nella versione assembly del programma.

programma principale0) Inizializza //ports while(1) { 1) Imposta P5.3 alto (accendi il LED IR) 2) Imposta P7.0 un'uscita e impostalo alto (caricando il condensatore) 3) Attendi 10 us, Clock_Delay1us (10); 4) Rendi P7.0 un input 5) Esegui questo ciclo 10.000 volte a) Leggi P7.0 (converte la tensione su P7.0 in binario) b) Output binario su P1.0 (consente di vedere il binario in tempo reale) 6) Impostare P5.3 basso (spegnimento LED IR, risparmio energetico) 7) Attendere 10 ms, Clock_Delay1ms(10); } // ripeti (torna a while())

Passaggio 6: miglioriamo il codice

Lo scopo o l'uso dell'array di LED IR Pololu è rilevare una linea e sapere se il robot (futuro) è direttamente centrato sulla linea o su un lato. Inoltre, poiché la linea ha un certo spessore, se l'array di sensori è direttamente perpendicolare alla linea, il numero N di sensori avrà una lettura diversa rispetto al resto, mentre se l'array di LED IR è inclinato (non perpendicolare), allora Le coppie N+1 o N+2 IR LED/rivelatore ora dovrebbero fornire una lettura diversa.

Quindi, a seconda di quanti sensori indicano la presenza della linea, dovremmo sapere se siamo centrati e se siamo angolati o meno.

Per questo esperimento finale, vediamo solo se possiamo ottenere il LED rosso e il LED RGB per darci maggiori informazioni su ciò che l'array di sensori ci sta dicendo.

Il video entra in tutti i dettagli. In allegato anche il codice definitivo.

Questo completa la serie di ARM Assembly relativi a GPIO. Speriamo di tornare con più ARM Assembly in un secondo momento.

Grazie.