MONTAGGIO BRACCIO GPIO - T.I. KIT DI APPRENDIMENTO SISTEMA ROBOTICA - LAB 6: 3 passaggi

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

Ciao, In un precedente Instructable sull'apprendimento dell'assemblaggio ARM utilizzando il TI-RSLK di Texas Instruments (utilizza il microcontrollore MSP432), noto anche come Lab 3 se stai eseguendo il T. I. Naturalmente, abbiamo esaminato alcune istruzioni di base come la scrittura su un registro e il ciclo condizionale. Abbiamo superato l'esecuzione utilizzando l'IDE Eclipse.

I piccolissimi programmi che abbiamo eseguito non hanno fatto nulla per interagire con il mondo esterno.

Un po' noioso.

Proviamo a cambiarlo un po' oggi imparando un po' sulle porte di input/output, in particolare, i pin GPIO digitali.

Si dà il caso che questo MSP432 venga fornito su una scheda di sviluppo già dotata di due interruttori a pulsante, un LED RGB e un LED rosso, tutti collegati ad alcune porte GPIO.

Ciò significa che mentre impariamo a configurare e manipolare questi pin tramite l'assemblaggio, possiamo vedere visivamente quegli effetti.

Molto più interessante del semplice passaggio attraverso il debugger.

(Stiamo ancora andando avanti - questa sarà la nostra funzione di "ritardo"):-D

Passaggio 1: proviamo a scrivere/leggere dalla RAM

Prima di passare all'accesso e al controllo del GPIO, dovremmo fare un piccolo passo.

Iniziamo semplicemente leggendo e scrivendo su un indirizzo di memoria standard. Sappiamo dal precedente Instructable (vedi immagini lì) che la RAM inizia da 0x2000 0000, quindi usiamo quell'indirizzo.

Sposteremo i dati tra un registro principale (R0) e 0x2000 0000.

Iniziamo con una struttura di file di base o il contenuto di un programma di assemblaggio. Fare riferimento a questo Instructable per creare un progetto di assieme utilizzando Code Composer Studio (CCS) di TI e alcuni progetti di esempio.

.pollice

.text.align 2.global main.thumbfunc main main:.asmfunc;---------------------------------- ---------------------------------; (il nostro codice andrà qui);-------------------------------------------------------- ---------------------------------------.endasmfunc.end

Voglio aggiungere qualcosa di nuovo alla sezione superiore, se ci sono alcune dichiarazioni (direttive). Diventerà più chiaro in seguito.

ACONST.set 0x20000000; lo useremo più in basso (è una costante)

; ovviamente, '0x' denota ciò che segue è un valore esadecimale.

Quindi il contenuto del nostro file di partenza ora appare così:

.pollice

.text.align 2 ACONST.set 0x20000000; lo useremo più in basso (è una costante); ovviamente, '0x' denota ciò che segue è un valore esadecimale..global main.thumbfunc main main:.asmfunc;------------------------- ----------------------------; (il nostro codice andrà qui);-------------------------------------------------------- ---------------------------------------.endasmfunc.end

Ora che abbiamo quanto sopra, aggiungiamo il codice tra le linee tratteggiate.

Iniziamo con la scrittura in una posizione RAM. Per prima cosa stabiliamo il modello di dati, un valore, che scriveremo nella RAM. Usiamo un registro di base per stabilire quel valore o dati.

Nota: ricorda che nel codice, ogni riga con un punto e virgola (';') significa che è tutto un commento dopo quel punto e virgola.

;-----------------------------------------------------------------------------------------------

; SCRIVERE;------------------------------------------------ --------------------------------- MOV R0, #0x55; Il registro principale R0 conterrà i dati che vogliamo scrivere nella posizione della RAM.; ovviamente, '0x' denota ciò che segue è un valore esadecimale.

Successivamente, diamo un'occhiata alle affermazioni che NON funzionano.

; MOV MOV non è utilizzabile per scrivere dati in una posizione RAM.

; MOV è solo per i dati immediati nel registro,; o da un registro all'altro; cioè MOV R1, R0.; STR deve usare STR.; STR R0, =ACONST; Cattivo termine nell'espressione (il '='); STR R0, 0x20000000; Modalità di indirizzamento illegale per l'istruzione di memorizzazione; STR R0, ACONST; Modalità di indirizzamento illegale per le istruzioni del negozio

Senza spiegare troppo, abbiamo provato a usare quel 'ACONST' sopra. Essenzialmente, è un sostituto o una costante invece di usare un valore letterale come 0x20000000.

Non siamo stati in grado di scrivere per scrivere nella posizione della RAM utilizzando quanto sopra. Proviamo qualcos'altro.

; sembra che dobbiamo usare un altro registro contenente la posizione della RAM in

; per memorizzare in quella posizione RAM MOV R1, #0x20000000; imposta la posizione della RAM (non il suo contenuto, ma la posizione) in R1.; ovviamente, '0x' denota ciò che segue è un valore esadecimale. STR R0, [R1]; scrivi cosa c'è in R0 (0x55) nella RAM (0x20000000) usando R1.; usiamo un altro registro (R1) che ha l'indirizzo di posizione della RAM; per scrivere in quella posizione RAM.

Un altro modo per fare quanto sopra, ma usando 'ACONST' invece del valore dell'indirizzo letterale:

; ripetiamo quanto sopra, ma usiamo un simbolo invece di un valore letterale di posizione della RAM.

; vogliamo usare 'ACONST' come sostituto di 0x20000000.; dobbiamo ancora fare il '#' per indicare un valore immediato,; quindi (vedi in alto), abbiamo dovuto usare la direttiva '.set'.; per dimostrarlo, cambiamo il modello di dati in R0. MOV R0, #0xAA; ok siamo pronti per scrivere in RAM usando il simbolo al posto del valore letterale dell'indirizzo MOV R1, #ACONST STR R0, [R1]

Il video entra in qualche dettaglio in più, oltre a passare attraverso la lettura dalla posizione di memoria.

È inoltre possibile visualizzare il file.asm di origine allegato.

Passaggio 2: alcune informazioni di base sulla porta

Ora che abbiamo una buona idea su come scrivere/leggere da una posizione RAM, questo ci aiuterà a capire meglio come controllare e utilizzare il pin GPIO

Quindi come interagiamo con i pin GPIO? Dal nostro precedente sguardo a questo microcontrollore e alle sue istruzioni ARM, sappiamo come gestire i suoi registri interni e sappiamo come interagire con gli indirizzi di memoria (RAM). Ma i pin GPIO?

Succede che quei pin siano mappati in memoria, quindi possiamo trattarli come indirizzi di memoria.

Ciò significa che dobbiamo sapere quali sono questi indirizzi.

Di seguito sono riportati gli indirizzi di partenza delle porte. A proposito, per l'MSP432, una "porta" è una raccolta di pin e non solo un pin. Se hai familiarità con il Raspberry Pi, credo che sia diverso dalla situazione qui.

I cerchi blu nell'immagine sopra mostrano la scritta sulla scheda per i due interruttori e LED. Le linee blu puntano ai LED effettivi. Non dovremo toccare i ponticelli dell'intestazione.

Ho fatto le porte di cui ci occupiamo in grassetto di seguito.

• 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)

Non abbiamo ancora finito. Abbiamo bisogno di più informazioni.

Per controllare una porta, abbiamo bisogno di diversi indirizzi. Ecco perché nell'elenco sopra, vediamo "indirizzi pari" o "indirizzi dispari".

Blocchi indirizzi registro I/O

Avremo bisogno di altri indirizzi, come:

• Indirizzo del registro di ingresso porta 1 = 0x40004C00
• Indirizzo registro uscita porta 1 = 0x40004C02
• Indirizzo del registro di direzione della porta 1 = 0x40004C04
• Porta 1 Selezionare 0 Indirizzo registro = 0x40004C0A
• Porta 1 Seleziona 1 Indirizzo registro = 0x40004C0C

E potremmo aver bisogno di altri.

Ok, ora conosciamo l'intervallo di indirizzi del registro GPIO per controllare il singolo LED rosso.

Una nota molto importante: ogni porta I/O sulla scheda MSP432 LaunchPad è un insieme di diversi (solitamente 8) pin o linee e ciascuno può essere impostato individualmente come input o output.

Ciò significa, ad esempio, che se si impostano valori per "Port 1 Direction Register Address", è necessario preoccuparsi di quale bit (o bit) si sta impostando o modificando a quell'indirizzo. Più su questo più tardi.

Sequenza di programmazione della porta GPIO

L'ultimo pezzo di cui abbiamo bisogno è un processo o un algoritmo da utilizzare per controllare il LED.

Inizializzazione una tantum:

• Configurare P1.0 (P1SEL1REG:P1SEL0REG Register) <--- 0x00, 0x00 per la normale funzionalità GPIO.
• Imposta il bit 1 del registro di direzione di P1DIRREG come output o HIGH.

Ciclo continuo:

Scrivi HIGH nel bit 0 del registro P1OUTREG per accendere il LED rosso

• Chiama una funzione di ritardo
• Scrivi LOW nel bit 0 del registro P1OUTREG per spegnere il LED rosso
• Chiama una funzione di ritardo
• Ripeti loop

Quale funzione di ingresso/uscita (Configura SEL0 e SEL1)

Molti dei pin sul LaunchPad hanno molteplici usi. Ad esempio, lo stesso pin potrebbe essere GPIO digitale standard o può essere utilizzato anche nelle comunicazioni seriali UART o I2C.

Per utilizzare una funzione specifica per quel pin, è necessario selezionare quella funzione. Devi configurare la funzione del pin.

C'è un'immagine sopra per questo passaggio che tenta di spiegare questo concetto in forma visiva.

Gli indirizzi SEL0 e SEL1 formano una combinazione di coppia che agisce come una sorta di selezione di funzioni/caratteristiche.

Per i nostri scopi, vogliamo GPIO digitale standard per il bit 0. Ciò significa che abbiamo bisogno del bit 0 per SEL0 e SEL1 per essere un LOW.

Sequenza di programmazione delle porte (di nuovo)

1. Scrivere 0x00 nel Registro P1 SEL 0 (indirizzo 0x40004C0A). Questo imposta un LOW per il bit 0

2. Scrivere 0x00 nel Registro P1 SEL 1 (indirizzo 0x40004C0C). Questo imposta un LOW per il bit 0, l'impostazione per GPIO.

3. Scrivere 0x01 nel registro DIR P1 (indirizzo 0x40004C04). Questo imposta un ALTO per il bit 0, che significa OUTPUT.

4. Accendere il LED scrivendo un 0x01 su P1 OUTPUT Register (indirizzo 0x40004C02)

5. Eseguire una sorta di ritardo (o semplicemente eseguire un singolo passaggio durante il debug)

6. Spegnere il LED scrivendo un 0x00 su P1 OUTPUT Register (indirizzo 0x40004C02)

7. Eseguire una sorta di ritardo (o semplicemente eseguire un singolo passaggio durante il debug)

8. Ripetere i passaggi da 4 a 7.

Il video associato a questo passaggio ci guida attraverso l'intero processo in una demo dal vivo, mentre analizziamo e parliamo di ogni istruzione di assemblaggio e mostriamo l'azione del LED. Scusate la lunghezza del video.

Passaggio 3: hai colto l'unico difetto nel video?

Nel video che illustra l'intero processo di programmazione e illuminazione del LED, c'era un passaggio in più nel ciclo principale, che avrebbe potuto essere spostato fino all'inizializzazione una tantum.

Grazie per aver dedicato del tempo a leggere questo Instructable.

Il prossimo si espande su ciò che abbiamo iniziato qui.