I -controllori ARM: la logica RISC - Pessina Gianlugi...gpessina I microcontrollori 1 I...

of 66/66
1 I microcontrollori gpessina I µ - controllori ARM : la logica RISC I µ-controllori ARM (ARM è l’acronimo di Advanced RISC Machines Ltd) sono molto interessanti perché basati su di una architettura di funzionamento diversa da quella vista fino ad ora. Gli ARM appartengono a quella classe di µ-controllori detti RISC, Reduced Instruction Set computer (l’8051 e gli altri processori visti sono detti CISC, Complex Instr. Set Comp). E’ spesso difficile cercare di capire la filosofia di funzionamento di un µ- controllore. Spesso non è neanche fondamentale conoscerla. Basta sapere sfruttare quelle che sono le caratteristiche del dispositivo. Tuttavia la conoscenza dell’architettura RISC è utile per potere essere in grado di selezionare e/o discriminare il migliore candidato al progetto a cui si sta lavorando. Va subito fatta l’osservazione che RISC, malgrado la definizione, non significa tanto avere a che fare con meno istruzioni, ma bensì con una architettura circuitale che sia molto semplice nel consentire di ottenere maggiore compattezza, velocità di operazione ed esecuzione delle istruzioni in un singolo colpo di clock. La lunghezza delle istruzioni viene mantenuta costante in modo da garantire una prevedibilità nei tempi di esecuzione delle istruzioni. La semplice filosofia che sta dietro l’architettura RISC si può riassumere nella figura sotto. Abbiamo una unità centrale, il processore, che è la parte intelligente del sistema. Un insieme di registri consente di movimentare i dati all’interno della CPU. I dati e le istruzioni vengono caricati dalla memoria. Non si possono quindi eseguire operazioni dirette sui data in memoria, ma solo tra i registri interni.
  • date post

    27-Jan-2021
  • Category

    Documents

  • view

    2
  • download

    1

Embed Size (px)

Transcript of I -controllori ARM: la logica RISC - Pessina Gianlugi...gpessina I microcontrollori 1 I...

  • 1I microcontrollorigpessina

    I µ-controllori ARM: la logica RISCI µ-controllori ARM (ARM è l’acronimo di Advanced RISC Machines Ltd) sono molto interessanti perché basati su di una architettura di funzionamento diversa da quella vista fino ad ora.

    Gli ARM appartengono a quella classe di µ-controllori detti RISC, Reduced Instruction Set computer (l’8051 e gli altri processori visti sono detti CISC, Complex Instr. Set Comp).

    E’ spesso difficile cercare di capire la filosofia di funzionamento di un µ-controllore. Spesso non è neanche fondamentale conoscerla. Basta sapere sfruttare quelle che sono le caratteristiche del dispositivo.

    Tuttavia la conoscenza dell’architettura RISC è utile per potere essere in grado di selezionare e/o discriminare il migliore candidato al progetto a cui si sta lavorando.

    Va subito fatta l’osservazione che RISC, malgrado la definizione, non significa tanto avere a che fare con meno istruzioni, ma bensì con una architettura circuitale che sia molto semplice nel consentire di ottenere maggiore compattezza, velocità di operazione ed esecuzione delle istruzioni in un singolo colpo di clock. La lunghezza delle istruzioni viene mantenuta costante in modo da garantire una prevedibilità nei tempi di esecuzione delle istruzioni.La semplice filosofia che sta dietro l’architettura RISC si può riassumere nella figura sotto.

    Abbiamo una unità centrale, il processore, che è la parte intelligente del sistema. Un insieme di registri consente di movimentare i dati all’interno della CPU.

    I dati e le istruzioni vengono caricati dalla memoria.

    Non si possono quindi eseguire operazioni dirette sui data in memoria, ma solo tra i registri interni.

  • 2I microcontrollorigpessina

    La struttura RISC

    Per essere semplice e veloce l’architettura RISC prevede:

    Un solo formato di istruzione da 32 bit. In questo modo nella singola istruzione si può prevedere l’indicazione di più operandi, o comandi (le istruzioni dei CISC variano in numero di byte);

    Filosofia load-store, ovverosia le istruzioni che operano sui dati lo fanno solo attraverso i registri interni al cuore del processore. In seguito i dati possono essere trasposti nella memoria (nei CISC un operando può essere un dato della memoria);

    Un banco di 32 registri a 32-bit ognuno utilizzabile per un qualsiasi scopo e hard-wired, cioè indipendente dagli altri, così che la struttura load-store possa agire in modo efficiente (nei CISC i registri hanno spesso scopi definiti).

    L’organizzazione RISC prevede:

    La decodifica delle istruzioni è hard-wired (in confronto con la struttura a micro-code di molti CISC);

    L’esecuzione delle istruzioni è organizzata secondo la filosofia pipeline (la struttura CISC spesso non permette questo approccio perché le istruzioni hanno numero di byte variabile);

    Esecuzione in un solo colpo di clock (nei CISC abbiamo visto che spesso servono più colpi di clock).

    Svantaggio della struttura RISC:

    Una minore densità di codice rispetto alla struttura CISC. in una struttura RISC c’è ridondanza in molte istruzioni.

  • 3I microcontrollorigpessina

    La pipeline nei RISC 1

    Nei RISC ogni istruzione è organizzata in modo che le azioni vengano svolte seguendo sempre una medesima successione, eventualmente lasciando un buco, o NOP, se quel particolare passo non servisse.

    Questo fa si che si possa evitare di aspettare che una istruzione sia completamente eseguita, prima di iniziare la successiva. Mentre una istruzione è in corso di esecuzione se ne potrebbe iniziare un’altra. Questo approccio si dice organizzazione a pipeline .

    Nell’ARM7 classicamente si adotta una pipeline a 3 livelli:

    L’organizzazione a pipeline deve essere organizzata all’atto della realizzazione hardware del dispositivo.

    L’organizzazione a 3 livelli dell’ARM evita molte delle conflittualità possibili. Nelle ultime generazioni di ARM si è arrivati anche a 5 livelli di pipeline.

    Nelle operazioni di scrittura/lettura dalla memoria si ottiene un buon beneficio dalla struttura a pipeline.

    In termini di velocità si hanno buoni benefici.

    Occorre però fare attenzione che l’organizzazione a pipeline può portare a colli di bottiglia, se non accuratamente progettata. Altrimenti è compito dello sviluppatore dell’applicazione fare in modo che nell’esecuzione del programma si evitino situazioni di stallo.

  • 4I microcontrollorigpessina

    La pipeline nei RISC 2

    Usare troppi livelli di pipeline può portare problemi. Uno di questi è il read-before-write, ovverosia una istruzione di un livello alto nella pipeline ha bisogno di un dato che l’istruzione a livello inferiore non ha ancora prodotto, ciò che porta al così detto stallo.

    Oppure ci può essere il problema di un salto, condizionato o meno, che potrebbe portare ad un’inefficienza.

    Questi problemi portano ad una livellazione del livello di pipeline. 3 livelli di pipeline, come nell’ARM7, sono agevolmente implementabili. 5 livelli di pipeline, come nell’ARM9, rappresentano certamente un bel progresso.

  • 5I microcontrollorigpessina

    La pipeline nei RISC 3L’ARM esegue istruzioni in un solo colpo di clock. Secondo questa concezione la pipeline dovrebbe essere ridondante. In realtà il collo di bottiglia si ha quando le istruzioni ed i dati vanno presi dalla memoria e caricati nella CPU. In questa situazione la pipeline a 3 stadi consente di potere mantenere il singolo colpo di clock sia che si debba eseguire un’istruzione nella CPU che di trasferimento di dati e/o istruzioni.

    Si è detto che l’ARM ha una struttura load-and-store. Vale a dire che i dati dalla memoria, per essere elaborati, vanno prima caricati nel set di registri che compongono la CPU.

    La struttura a pipeline deve essere un parametro progettuale che deve essere tenuto in conto all’atto della realizzazione della struttura, non è solo una proprietà firmware.

    Importante: siccome il PC punta a 2 istruzioni successive a quella in svolgimento occorre fare attenzione al suo attuale valore quando si vogliono eseguire indirizzamenti relativi al PC.

    Esempio: M3= M1 + M2

  • 6I microcontrollorigpessina

    I registri nella CPU dell’ARM nella modalità standard, o dell’utilizzatore

    Veniamo ora al set di registri. Non è niente di complicato in un ARM: si tratta, nella modalità di operazione standard, di 16 registri ed un registro di stato:

    I registri da R0 a R12 sono di utilizzo completamente generale: possono essere usati per caricare dati da/verso la memoria ed utilizzati per operazioni matematiche.

    I registri da R13 a R15 svolgono invece uffici particolari, come indicato.

    Infine abbiamo il CurrentProgram (vedremo perché Current) Status Register.

    Il CPSR contiene gli essenziali flags riguardanti la descrizione del risultato dell’ultima operazione eseguita nell’ALU.

    I primi 8 bit hanno anche un significato differente.

    Si nota come la ridondanza viene impiegata qui: su 32 bits se ne usano solo 12.

    Risultati ALU

  • 7I microcontrollorigpessina

    La struttura ARM 1

    Nell’ARM la memoria dati e programmi non è necessariamente esterna al chip. E’ solamente ritenuta esterna alla CPU. Il banco di registri è dove ruota lo svolgimento del percorso dei dati.

    Innanzi tutto si può vedere come il PC sia auto-incrementato e sia connesso sia al registro indirizzi che al banco dei registri. Infatti il PC è il registro R15.

    L’eventuale indirizzo del nuovo dato deve uscire dalla ALU.

    L’ARM si avvicina al comportamento di un DSP.

    Per cui possiede una unità di moltiplicazione HW che significa: moltiplicazioni in un singolo colpo di clock.

    E pure un barrel shifter, che consente di ruotare le parole di memoria in un singolo colpo di clock (si ricorda che ogni slittamento a sinistra corrisponde ad una moltiplicazione per 2, uno a destra una divisione per 2).

    Si noti un aspetto fondamentale: l’ARM in origine, ARM7, possiede una struttura Harvard modificata in quanto non c’è una separazione tra il bus dati ed istruzioni all’interno della CPU.

  • 8I microcontrollorigpessina

    Esecuzione di un’istruzione nell’ARM: matematica tra 2 registri 1

    La nuova istruzione entra dalla pipeline (i. pipe)

    In una istruzione di processamento un operando è sempre unregistro (Rn)

    Il secondo operando può essere un registro (Rm), che può essere soggetto ad un’operazione di shift.

    Il risultato dell’operazione ritorna al banco di registri.

    Si deve osservare che mentre si svolge l’operazione nella ALU il PC viene già aggiornato.

    Il processamento di 2 numeri avviene seguendo 2 modalità: operazione tra 2 registri o tra un registro ed una valore diretto ad 8 bit contenuto nell’istruzione.

    Siccome l’istruzione è eseguita in un singolo colpo di clock, il secondo operando non può essere una cella di memoria.

  • 9I microcontrollorigpessina

    Esecuzione di un’istruzione nell’ARM: matematica tra 2 registri 2

    In una istruzione di processamento un operando è sempre unregistro (Rn)

    Il secondo operando può essere un numero immediato proveniente dalla istruzione, che può essere soggetto ad un’operazione di shift.

    Il risultato dell’operazione ritorna al banco di registri.

    Si deve osservare che mentre si svolge l’operazione nella ALU il PC viene già aggiornato.

    Una tale organizzazione consente di eseguire istruzioni a 3 registri. Per esempio:

  • 10I microcontrollorigpessina

    Tempistica

    E’ interessante notare che nell’ARM i registri non operano sul fronte di salita o discesa del clock, ma sul livello, per esempio alto. Per questa ragione dal clock principale viene creato una seconda fase che non si sovrappone alla prima.

    Ci saranno quindi registri che diventeranno trasparenti durante la prima fase del clock e registri che saranno trasparenti durante la seconda fase del clock, senza sovrapposizione.

    Va notato che la vita interna dell’ARM è cadenzata dalla presenza di registri, trasparenti all’utilizzatore, che consentono il trasferimento dei dati seguendo le tempistiche opportune.

  • 11I microcontrollorigpessina

    Modalità di funzionamento: le eccezioni (exceptions) 1

    L’ARM ha 6 modalità di funzionamento (exceptions) con le quali si fronteggiano tutte le possibili situazioni, compresi gli interrupt. Le exceptionssono sostanzialmente dei sottoprogrammi che vengono chiamati sulla base di determinate condizioni che accadono nei vari stati del sistema.

    Ad ogni modalità è associato un set di registri aventi parti in comune e distinte rispetto alla modalità usuale (Standard o User) di funzionamento.

    In questo modo la gestione di questi sottoprogrammi è svolta in modo più celere.

    Vi sono 6 diversi stati operativi. I registri comuni a tutti gli stati sono quelli non colorati. I registri colorati sono invece visibili solo allo stato pertinente.

    Il concetto è molto semplice: si vuole fare in modo che nella chiamata del sottoprogramma si minimizzino i passi da svolgere per salvare le variabili nello stack, per consentire il loro successivo ripristino. Abbiamo una funzione in più rispetto ad una chiamata standard.

  • 12I microcontrollorigpessina

    Modalità di funzionamento: le eccezioni (exceptions) 2

    Allo stesso modo che nelle interruzioni, ad ogni eccezione è assegnato un vettore, un indirizzo del codice programmi, da dove si lancerà il sottoprogramma vero e proprio.

    Abbiamo una priorità nella gestione di queste modalità operative:

  • 13I microcontrollorigpessina

    Modalità di funzionamento: le eccezioni (exceptions) 3

    Cosa succede in definitiva?

    Il gioco viene svolto essenzialmente a livello dei 3 registri R14, R15 ed SPSR.

    • Quando la modalità deve essere inserita il PC (R15) viene salvato automaticamente e contemporaneamente in R14 (LR, l’indirizzo di ritorno) della modalità finale.

    • Contemporaneamente, nel PC viene inserito il valore del vettore contenuto in R15 della modalità finale.

    • Il CPSR viene salvato, contemporaneamente, in un registro chiamato SPSR_modalità. Allo stesso tempo la modalità di interruzione viene annullata.

    Il registro R13 della modalità inserita è lo stack pointer che può essere sfruttato per conservare i registri in comune con la modalità di partenza, se necessario.

  • 14I microcontrollorigpessina

    Modalità di funzionamento: le eccezioni (exceptions) 4

    Il ritorno dalla modalità inserita al funzionamento precedente segue la procedura inversa:

    • Il PC viene aggiornato con il LR della modalità inserita

    • Il CPSR viene aggiornato con il contenuto del registro SPSR_modalità.

    Ovviamente se dei registri sono stati preservati durante la chiamata devono essere ripristinati.

    Tra tutte le modalità hanno indipendenti i registri R13 (stack pointer), R14(Link Register) e l’SPSR, ed in comune tutti gli altri eccetto la modalità FIQ, Fast Interrupt Request.

  • 15I microcontrollorigpessina

    Modalità di funzionamento: le eccezioni (exceptions) 5

    Nella modalità FIQ anche i registri da R7 ad R12 sono comuni solo alla FIQ stessa.

    In tale modo si cerca di risparmiare tempo nel dovere impilare nello stack registri: si fornisce l’opportunità di avere a disposizione un certo numero di registri indipendenti.

    Il concetto che sta alla base è che in genere è difficile che debbano verificarsi più di una interruzione per volta. Il sistema è ottimizzato per tale circostanza. Tuttavia, l’opportunità di gestione di più interruzioni in cascata è comunque implementabile. Ovviamente, in tale caso, l’efficienza si ridurrebbe a quella di un microcontrollore standard.

    Quindi, importante: l’ARM gestisce una sola interruzione per volta. Una volta che gestisce l’interruzione, tutte le altre vengono disabilitate. Volendo gestire più interruzioni contemporaneamente, è l’utilizzatore che deve inserire l’operazione, con una perdita di efficienza.

  • 16I microcontrollorigpessina

    Modalità di funzionamento: le eccezioni (exceptions) 6

    Il CPSR è il cuore della gestione delle eccezioni, oltre che a contenere i flags che descrivono il risultato dell’ultima operazione della ALU.

    I modi di operazione sono conteggiati nei primi 5 bit.

    Nei successivi 3 bit abbiamo la possibilità di disabilitare l’interrupt standard e la fast interrupt (FIQ).

    L’ultimo bit, il bit T, svolge un ruolo importante nel tipo di funzionalità.

    Se il bit T è settato si entra nella fase così detta Thumb.

    L’ARM è un microcontrollore a 32 bit. Tutta questa potenzialità risulta ridondante se l’applicazione non richiede particolare sofisticazione in termini di prestazioni.

    L’opzione Thumb consente di risparmiare risorse, fino al 30 %, semplicemente consentendo al microcontrollore di operare a 16 bit. Questa modalità è impostabile in un qualsiasi momento e posizione all’interno del programma.

  • 17I microcontrollorigpessina

    Il funzionamento in Thumb mode

    Quando il funzionamento del micro viene commutato sul Thumb model il parallelismo diviene a 16 bit. Il set di istruzioni di cui si ha a disposizione nella modalità Thumb è ridotto.

    L’occupazione di memoria si riduce, ed anche la complessità del codice.

    Ovviamente la velocità si riduce anch’essa.

    Infatti l’organizzazione non è tale da possedere un sistema separato di decodifica delle istruzioni. Semplicemente le istruzioni vengono decompresse perché diventino di tipo ARM.

    Una limitazione della modalità Thumb è nel numero di registri a disposizione: solo quelli da R0 a R7.

    Un’altra restrizione riguarda le eccezioni, che non sono gestite in Thumb. Quando si verifica una eccezione si ha la conversione automatica da Thumb a ARM.

  • 18I microcontrollorigpessina

    L’organizzazione della memoria 1

    La memoria è organizzata come se fosse tutta impilata, indipendentemente dal tipo considerato. Questo significa che i vari blocchi di memoria vengono indirizzati con degli offset opportuni.

    Qui ci sta la on CHIP-FLASH, la cui dimensione dipende dal dispositivo.

    La RAM è configurata dall’indirizzo 0x40000000.

    Il boot-loaderprogram e debug programstanno qui.

    Una eventuale memoria programmi esterna sta qui.

    Tutti i registri di configurazione delle periferiche sono qui.

  • 19I microcontrollorigpessina

    L’organizzazione della memoria 2

    Vediamo qui un’esplosione della parte di memoria riservata alla gestione delle periferiche (quella più in alto):

    VPB sta per VLSI Peripheral bus, ovvero tutte le periferiche legate all’HD.

  • 20I microcontrollorigpessina

    L’organizzazione dei dati in memoria

    L’organizzazione della memoria è a 32 bit. Però ogni parola di memoria è rappresentabile in multiplo di byte.

    Va osservato che esistono 2 sistemi di rappresentazione del tutto equivalenti: Little-Endian e Big-Endian:

    • Little-Endian: rappresentazione classica, il bit meno significativo sta a destra, quello più significativo a sinistra;

    • Big-endian: il contrario del precedente, il bit più significativo sta a destra, quello meno significativo a sinistra.

    La parola a 32-bit è detta Word, quella a 16-bit, Halfword, quella a 8-bit, Byte..

    Dal momento che si possono trattare dati di lunghezza minore di 32-bit occorre adottare un allineamento:

  • 21I microcontrollorigpessina

    I BUS di comunicazione interna all’ARM 1

    L’ARM è realizzato con un sistema di comunicazione dei dati interno ottimizzato in funzione della periferica. Questo bus si chiama AMBA, Advanced Microcontroller Bus Architecture, ed è specificato in 3 parti:

    •Il Bus AHB, Advanced High-performance Bus per conettere periferiche ad alta velocità alla CPU;

    • Il Bus ASB, Advanced System Bus, per connettere altri moduli ad alta performance;

    • Il Bus APB, Advanced Peripheral Bus è per periferiche a bassa velocità.

  • 22I microcontrollorigpessina

    I BUS di comunicazione interna all’ARM 2

    La suddivisione del Bus di comunicazione secondo questa filosofia consente di potere trasferire i dati ad alta velocità verso le periferiche come la memoria ed allo stesso tempo gestire periferiche più lente come quelle dedicate alla trasmissione seriale con UART, etc.

    Per mezzo di un ‘bridge’ si passa dal AHB al APB.

    La particolarità importante dell’APB è che la sua velocità è impostabile come sottomultiplo della frequenza di clock.

    In tale modo non si è forzati ad operare un unico bus alla frequenza più bassa, ma si hanno più bus operanti a velocità differente ed ottimizzata alla gestione della periferica.

  • 23I microcontrollorigpessina

    Qualche esempio applicativo

    Questo processore è realizzato con un processo avente:

  • 24I microcontrollorigpessina

    Bibliografia ARM

    Vedere in fondo a questo gruppo di slides.

  • 25I microcontrollorigpessina

    ARM - CORTEX M3 (1): introduzione (**)I µ-controllori ARM sono stati sviluppati per cercare di soddisfare le emergenti richieste del mercato e sfruttare i benefici conseguibili dall’evoluzione tecnologica che consente di implementare sempre più funzioni.

    D’altra parte ARM (Advanced RISC Machines ltd) stessa è una società così detta fables, vale a dire che sviluppa la struttura del processore e la parte fisica, l’implementazione elettrica del layout, senza realizzarla, ma vendendo la proprietà intellettuale in cambio di percentuali sui prodotti venduti. Per questa ragione sono molte le società che realizzano e vendono processori ARM.

    Qui sotto abbiamo la tabella che mostra le famiglie di processori. L’ordine è per famiglia, non per potenza elaborativa. ARM ha sviluppato le varie famiglie in funzione delle esigenze di mercato.

    La tabella continua (**): un grazie a Filippo Bianchi e Lorenzo RotaPer gli importanti dettagli suggeriti.

  • 26I microcontrollorigpessina

    ARM - CORTEX M3 (2)

    Una significativa modifica al cuore del processore si è avuta con la generazione dei CORTEX.

    Questa generazione di microprocessori rispondono alle nuove esigenze di mercato in termini di portabilità e gestione di molti processi di comunicazione.

    Le nuove generazioni di ARM sono stati adottate negli smart-phones e nei tablet PC con ottimi risultati di mercato.

    Le innovazioni stanno nella velocità di esecuzione del codice ma anche nel basso risparmio energetico di fondamentale importanza nelle applicazioni a batteria.

  • 27I microcontrollorigpessina

    ARM - CORTEX M3 (3): unità centraleLa struttura interna di un Cortex presenta significative differenze rispetto a quella del tradizionale ARM.

    Nel Cortex all’interno della CPU ora si hanno il bus istruzioni ed il bus dati separati: la struttura è diventata puramente Harvard. Questo consente un significativo miglioramento nelle prestazioni in velocità ed un’ottimizzazione della struttura pipeline.

    La separazione dei 2 bus consente una razionalizzazione del funzionamento. Tuttavia la memoria viene considerata come se fosse una sola, anche se fisicamente sono distinte. Intervalli di indirizzamento stabiliti identificano e caratterizzano il tipo di memoria che si sta trattando.

    Ovviamente la locazione utilizzata è trasparente all’utilizzatore e viene assegnata direttamente dal compilatore se si usano i soliti criteri di definizione in C (nella flash viene messo il codice e i dati dichiarati costanti).

  • 28I microcontrollorigpessina

    ARM - CORTEX M3 (4)

    Qui abbiamo una visione più aperta dei blocchi principali del CORTEX. Dove si vedono tutti i blocchi che servono al debug sulla destra.

    Il CORTEX ha una profondità di pipeline di 3 stadi:

    C’e’ un blocco dedicato alla gestione delle interruzioni. Si tratta del NVIC(Nested Vectored Interrupt Controller). In questo blocco risiede anche il Systick, l’orologio utilizzato dal sistema operativo, quando adottato nell’applicazione.

  • 29I microcontrollorigpessina

    ARM - CORTEX M3 (5)

    In questo altro diagramma espanso sono messi invece in evidenza tutti i blocchi interni al micro con i bus di interfaccia usati in funzione delle periferiche.

  • 30I microcontrollorigpessina

    ARM - CORTEX M3 (6): memoriaEcco come si evidenzia la mappa della memoria. Fisicamente i blocchi possono essere memorie differenti i cui indirizzi devono essere codificati come sotto riportati per potere essere individuati ed interpretati.

    Al solito la memoria programmi parte dall’indirizzo 0, zona in cui risiedono anche i vettori per le interruzioni.

    Oramai la memoria integrata riesce ad avere capacità adeguata. Quindi la memoria programmi risiede o tutta o la prima parte all’interno del micro.

  • 31I microcontrollorigpessina

    ARM - CORTEX M3 (7)

    Ecco un esempio di distribuzione della memoria più in dettaglio:

    Di nuovo nel Cortex c’e’ la regione di bit-band dove si può adottare l’indirizzamento per bit.

    Sostanzialmente, all’indirizzo 0x20yyyyyy ci sono le celle che possono essere memorizzate per bit o per parole. Per scrivere il bit si usa la memoria alias di indirizzo 0x22yyyyyy. In sostanza ogni cella nella memoria alias contiene solo 1 bit (gli altri 31 vengono buttati). Ecco la ragione per cui se a 0x20yyyyyy c’è 1 Mb di spazio, a 0x22yyyyyy ne servono 32 Mb.

  • 32I microcontrollorigpessina

    ARM - CORTEX M3 (8): bit-bandAnche nell’8051 abbiamo visto la presenza di una zona di memoria indirizzabile per parola e per bit.

    La regione di memoria dove sono i registri bit-band interpretabili come registri standard inizia con: 0x20yyyyyy.

    Se si intende indirizzare i singoli bit si deve usare l’alias 0x22yyyyyy. L’indirizzo di ogni bit si ottiene incrementando per 4, partendo da 0.

    L’esempio è eloquente:

    Mem A

    Mem B

    Il metodo consiste nel ri-mappare un’area di memoria A in un’area di memoria B, detta Bit Band Aalias. Ad ogni bit della memoria A corrisponde una word (32 bit) della memoria B. Andando a scrivere un valore diverso da zero in una word di B, il corrispondente bit nella memoria A viene posto ad 1. Da qui la ragione di disporre di una memoria di alias che sia 32 volte più grande della memoria di bit-mapping. La formula per l’alias è:

    ( )Ind _ in _ B Offset _ mem _ B Ind _ word _ del _ bi _ in _ A Offset _ mem _ A *32 n _ bit *4= + − +

  • 33I microcontrollorigpessina

    ARM - CORTEX M3 (9): bit-band

    In Assembly l’implementazione del bit-mapping è ovvia.

    Siccome in C non esiste il corrispettivo si deve introdurre l’alias:

    Informazioni su questa proprietà e su molte altre proprietà del Cortex, nonché della manualistica si possono trovare nei siti: www.ARM.com e www.OnArm.com.

    http://www.arm.com/

  • 34I microcontrollorigpessina

    ARM - CORTEX M3 (10): registriContinuiamo nella verifica della differente natura del Cortex e del classico ARM.

    Una differenza peculiare tra l’ARM tradizionale ed il Cortex è la capacità di gestire Interruzioni multiple in naturale mediante il blocco NVIC, che sta appunto per Nested Vector Interrupt Controller. Come vedremo tra breve. In particolare l’NVIC fa parte dell’unità centrale. Mentre nell’ARM7 era sviluppato in proprio da chi implementava il micro stesso.

    La possibilità di gestire interruzioni temporanee ha portato ad una diversa distribuzione del banco di registri interni alla CPU.

  • 35I microcontrollorigpessina

    ARM - CORTEX M3 (11)

    I banchi di registri che venivano scambiati all’occorrenza delle interruzioni, in funzione del tipo di interruzione sono spariti tutti. E’ rimasto solo un banco di 16 registri di cui i primi 13 sono di utilizzo generale.

    R13 è lo stack pointer, rappresentato da 2 registri. L’MSP è il solo usato durante l’ handler mode (interruzioni). PSP o MSP possono essere usati nel thread mode (modalità standard). La selezione è effettuabile nel Control Register.

    R14 è il classico Link Register dove va ad essere memorizzato il contenuto del Program Counter quando viene chiamato un sottoprogramma di qualsiasi natura.

    Infine R15 è il Program Counter vero e proprio, il cui valore può essere modificato dall’utilizzatore se si intendono eseguire salti di tipo particolare. Alcune di queste modifiche possono essere eseguite solo in Assembly, altre sono visibili anche al C .

  • 36I microcontrollorigpessina

    ARM - CORTEX M3 (16): interruzioniLe interruzioni non sono più suddivise in FAST, SWI, ecc come nell’ARM. Ma sono semplicemente numerate. La priorità che si imposta determina il grado di precedenza.

    Ci sono delle eccezioni, o interruzioni, che sono comuni a tutti i micro, poi ci sono quelle individuabili ed ammesse all’utilizzatore. Nella tabella sotto sono 240.

    La priorità è tanto maggiore quanto più piccolo è il valore assegnato. Per tale ragione al reset è assegnata la priorità maggiore, -3, cui segue l’interruzione non-mascherata, ovvero che può verificarsi senza essere subordinata ad altre eventualità con priorità -2. Quindi ci sono una serie di condizioni di interruzione dovuti ad errori che possono verificarsi.

  • 37I microcontrollorigpessina

    ARM - CORTEX M3 (17)

    Al solito al verificarsi dell’interruzione deve essere chiamato il sottoprogramma che la gestisce. Per questo è adibita una tabella di vettori, o puntatori, dove sono contenuti gli indirizzi dei sottoprogrammi a cui si deve saltare.

    La tabella dei vettori è rilocabile. Infatti sopra qui sono individuati gli offset da aggiungere all’indirizzo di partenza della tabella.

    L’indirizzo di partenza della tabella è contenuto in uno dei registri NVIC, precisamente il Vector Table Offset Register, con questa sintassi:

  • 38I microcontrollorigpessina

    ARM - CORTEX M3 (18)

    E’ interessante vedere come avvenga il reset. Il primo indirizzo è quello che contiene la posizione dello Stack, mentre il secondo quello della partenza del programma.

    Qui abbiamo un esempio di come potrebbe essere localizzato lo Stack e l’inizio del programma.

  • 39I microcontrollorigpessina

    ARM - CORTEX M3 (19)

    Il numero di interruzione effettivamente disponibili dipende da come è stato implementato l’hd del micro, 256 è il massimo.

    Ad ogni interruzione occorre dare una priorità, più o meno marcata. Per questo si devono impostare 8 bit di un registro, uno per ogni interruzione.

    Il registro è a sua volta diviso in 2 parti: preempt-priority-field e subpriority-field:

    Il preempt-priority-field è considerato per verificare se l’interruzione che si sta eseguendo deve essere sopraffatta da una nuova interruzione con priorità maggiore.

    Il subpriority-field è considerato solo quando 2 interruzioni aventi la stessa preempt accadono contemporaneamente: viene eseguita quella con priorità maggiore.

    Se le priorità preempt sono meno di 128 (il bit 0 non può essere usato nella preempt nel gruppo 0). Si toglie un numero di bit adeguato nella parte meno significativa, come nell’esempio qui, dove vengono usati solo 3 bit:

  • 40I microcontrollorigpessina

    ARM - CORTEX M3 (20)A questo punto occorre abilitare le interruzioni che servono. Le abilitazioni si attuano scrivendo nel registro Interrupt set Enable. Il registro è a 32 bit, per cui ve ne potranno essere più di uno: SETENA0, SETENA1, ecc.

    Per disabilitare un’interruzione non bisogna scrivere nel registro SETENA, ma bensì nel registro Interrupt Clear Enable Register. Anche qui potremmo avere più di un tale registro: CLRENA0, CLRENA1, ecc.

    Un altro registro utile è l’ Interrupt Set-Pending Register: SETPEND0, SETPEND1, ecc. Questo registro ha una doppia funzionalità. Leggendolo siamo in grado di capire chi sta in coda. Scrivendoci possiamo forzare in attesa una interruzione manualmente. Se invece volessimo cancellare una interruzione in attesa dobbiamo scrivere nel registro CLRPEND0, CLRPEND1, ecc.

    In C l’abilitazione dell’interruzione con l’impostazione della sua priorità si fa così:

    IMPORTANTE: occorre includere nel progetto i file .h opportuni contenenti le funzioni menzionate.

    La filosofia da adottare è capire dall’help che .h serve. Sviscerare il .h alla ricerca delle funzioni che servono. Tipicamente quella di inizializzazione, abilitazione, ecc.

    Peculiare per queste istruzioni è anche il manuale CMSIS, che si può trovare a www.onarm.com.

  • 41I microcontrollorigpessina

    ARM - CORTEX M3 (21)

    E’ possibile disabilitare tutte le interruzioni in un colpo mediante i registri PRIMASK e FAULTMASK. PRIMASK disabilita tutte le interruzioni dell’utente eccetto la NMI e hard fault. FAULTMASK blocca anche l’hard fault. Esempio di utilizzo in C:

    Il registro BASEPRI disabilita tutte le priorità al di sotto del livello a cui viene impostato:

    Il BASEPRI può essere annullato con:

  • 42I microcontrollorigpessina

    ARM - CORTEX M3 (22)

    A questo punto occorre assegnare il sottoprogramma alle interruzioni. Questo viene realizato assegnando dei nomi prestabiliti che devono avere le funzioni. Per individuarli occorre andare nel file di configurazione del micro che deve essere allegato al progetto. Il file ha nome startup_nome_micro.s. Qui un esempio dei vettori:

    __Vectors DCD __initial_sp ; Top of StackDCD Reset_Handler ; Reset HandlerDCD NMI_Handler ; NMI HandlerDCD HardFault_Handler ; Hard Fault HandlerDCD MemManage_Handler ; MPU Fault HandlerDCD BusFault_Handler ; Bus Fault HandlerDCD UsageFault_Handler ; Usage Fault HandlerDCD 0 ; ReservedDCD 0 ; ReservedDCD 0 ; ReservedDCD 0 ; ReservedDCD SVC_Handler ; SVCall HandlerDCD DebugMon_Handler ; Debug Monitor HandlerDCD 0 ; ReservedDCD PendSV_Handler ; PendSV HandlerDCD SysTick_Handler ; SysTick Handler

    ; External InterruptsDCD WDT_IRQHandler ; 16: Watchdog TimerDCD TIMER0_IRQHandler ; 17: Timer0DCD TIMER1_IRQHandler ; 18: Timer1DCD TIMER2_IRQHandler ; 19: Timer2DCD TIMER3_IRQHandler ; 20: Timer3DCD UART0_IRQHandler ; 21: UART0DCD UART1_IRQHandler ; 22: UART1DCD UART2_IRQHandler ; 23: UART2DCD UART3_IRQHandler ; 24: UART3

  • 43I microcontrollorigpessina

    ARM - CORTEX M3 (23)

    Quindi in C la gestione della UART1 può essere fatta così:

    Naturalmente la UART è un caso particolare perché sia la ricezione che la trasmissione generano la stessa interruzione. Quindi va individuato l’autore della richiesta. Inoltre nella UART in genere è l’utilizzatore che dve annullare la richiesta e non è svolto automaticamente all’uscita dal sottoprogramma.

  • 44I microcontrollorigpessina

    ARM - CORTEX M3 (24): suggerimenti

    Come per l’8051 è importante l’inclusione del file che configura il micro nell’IDE. Per esempio, per il Cortex della serie LPC17xx di NXP, all’inizio del progetto si deve scrivere:

    #include

    Questo file appartiene poi alle librerie CMSIS di base del Cortex.

    In questo file si trovano tutte le definizioni delle periferiche, definite ognuna come una struttura, struct, col nome:

    LPC_nomeperiferica

    I vari registri sono quindi indirizzabili con:

    LPC_nomeperiferica->nome_registro

    ad esempio, per impostare il match register 0 del timer 2, si cerca il nome del timer 2 nel file (ovvero LPC_TIM2) e poi si indirizza il registro con

    LPC_TIM2->MR0 = 0x00acd;

    Altra utilità: all’inizio del file c’è una tabella con i nomi di tutti le interruzioni.

    I file come LPC17xx.h rispettano lo standard CMSIS. La loro documentazione si trova nella guida completa di uVision cercando “CMSIS Overview”. Ancora, in CMSIS usage sono elencati i file da includere ed utilizzare.

    Ad esempio, nel file core_cm3.h sono riportate tutte le istruzioni “di default” per gli interrupt. Si trovano anche alla voce “Nested Vectored Interrupt Controller” nella guida sempre di uVision.

  • 45I microcontrollorigpessina

    ARM - CORTEX M3 (25)Ecco un esempio di utilizzo di interruzione: la seriale. Cominciamo dalla sua inizializzazione:

    /* Enable UART0 interrupt */LPC_UART0->IER = 0x01 | 0x02 | 0x03;NVIC_EnableIRQ(UART0_IRQn);

    Ora invece la funzione chiamata quando si verifica l’vento:

    void UART0_IRQHandler (void){static char r;

    switch ((LPC_UART0->IIR&0x0F)) { */IIR=registro evento/*case 0x01: /* no int pending, called by UART0_putstring? */ */ Si è chiamto

    l’UART in modo artificiale, abilitando il pending register/*if ((LPC_UART0->LSR>>5)&0x01){ /* check for empty THR: se

    vuoto ultima trasmissione terminata */UART0_send_buffer(); /* start transmission */

    } break;

    case 0x06: /* error */ // debug here?break;

    case 0x04: /* data received */r = LPC_UART0->RBR;UART0_rec_buffer(r);break;

    case 0x0C: /* data in time out */r = LPC_UART0->RBR;UART0_rec_buffer(r);break;

    case 0x02: /* THR-Empty interrupt */if (UART0_Buffer->out_n == 0) {

    /* if buffer is empty, do nothing */break;

    } UART0_send_buffer();break;

    }}

  • 46I microcontrollorigpessina

    Bibliografia (1)

    N.Storey,ELECTRONICS A SYSTEMS APPROACHAddison Wesley, 1992.

    Bibliografia 8051:

    M.Predko,PROGRAMMING AND CUSTOMIZING THE 8051 MICROCONTROLLERMc Graw-Hill, 1999.

    Ken ArnoldEMBEDDED CONTROLLER HARDWARE DESIGNLLH Technology Publishing, 2000. Cod. Biblio: 621.3916 arnk.emb 2001

    Bibliografia ARM:

    Steve FurberARMSystem-on-chip architecture, second editionAddison-Wesley, 2000, cod. Biblio 004 165 URS ARM 2000BS (2 copie)

    Trevor MartinThe Insider's Guide To The Philips ARM7-Based MicrocontrollersHitex (UK) Ltd.

    A.N.Sloss, D.Symes, C.WrightARM System Developer’s GuideElsevier, 2004, Cod. Biblio 005.1 SLOA.ARM/2004

    D.SealARM Architecture Reference Manual (2nd Edition)Addison-Wesley Professional, 2001, Cod. Biblio 004.22SEAD.ARM /2001

    Bibliografia ARM CORTEX M3:

    J. YiuThe definitive guide to the ARM CORTEX-M3, second EditionElsevier 2010. Biblio 621.3916 YIUJ.DEF/2010.

  • 47I microcontrollorigpessina

    Bibliografia (2)

    Inoltre, nella pagina privata del corso si trova documentazione nella cartella:

    ARM e CORTEX

    Invece nella pagina del corso c’e’ un riferimento ad un ebook scaricabile dalla nostra biblioteca.

  • 48I microcontrollorigpessina

    Appendice A: Come impostare ad 1 un bit di un registro lasciando inalterati gli altri 1

    A B A | B0 0 01 0 10 1 11 1 1

    Cominciamo col capire come funziona l’operatore di OR logico che , in C, è identificato dal simbolo «|».

    Possiamo quindi dire che:

    A | 1 = 1 qualsiasi sia il valore di A;A | 0= A

    Di conseguenza, volendo impostare ad 1 un bit di un registro, lasciando tutti gli altri immutati, basta eseguire un OR con un registro avente tutti 0, tranne un 1 nella posizione desiderata.ES. Vogliamo impostare ad 1 il bit 3 di un registro a 5 bit:

    A x x x x xOR

    Maschera 0 1 0 0 0

    Risultato x 1 x x x

  • 49I microcontrollorigpessina

    Appendice A: Come impostare ad 1 un bit di un registro lasciando inalterati gli altri 2

    Di conseguenza, se vogliamo impostare ad 1 il bit nella posizione k (attenzione: la posizione dei bit di un registro si contano a partire da zero!) del registro pippo possiamo scrivere:

    pippo = pippo | (1

  • 50I microcontrollorigpessina

    Appendice B: Come impostare uno o più bit di un registro lasciando inalterati gli altri 1

    A B A & B0 0 01 0 00 1 01 1 1

    Cominciamo col capire come funziona l’operatore di AND logico che , in C, è identificato dal simbolo «&».

    Possiamo quindi dire che:

    A & 1 = A;A | 0= 0;

    Sulla base di quanto visto sopra occorre: portare a zero tutti i bit che si vogliono impostare, usando la funzione AND con una maschera che abbia zero nei bit di interesse ed uno in tutti gli altri, per poi impostare al valore finale usando la funzione OR con una maschera che abbia tutti 0 trane che nei bit in cui si voglia impostare gli uni.ES. In un registro a 5 bit si voglia impostare il valore 10 nei bit 2 e 3.

    A x x x x xAND

    Maschera1 1 0 0 1 1

    Risultato1 x 0 0 x x

  • 51I microcontrollorigpessina

    Appendice B: Come impostare uno o più bit di un registro lasciando inalterati gli altri 2

    Quindi ora:

    Risultato1 x 0 0 x xOR

    Maschera2 0 1 0 0 0

    Risultato x 1 0 x x

    Per cui, se vogliamo scrivere yy nella posizione k e k+1 del registro pippo dobbiamo agire con 2 istruzioni:

    pippo &= ∼(11

  • 52I microcontrollorigpessina

    Appendice C: Le strutture in C

    Le strutture sono variabili a più campi e sono utili quando si vogliono raggruppare informazioni omogenee riguardanti una variabile.

    Ad esempio, nella UART abbiamo i registri di configurazione, di ricezione, di trasmissione, etc.

    Potremmo allora agire così.

    Prima di tutto dobbiamo definire il tipo:

    Typedef struct {unsigned int uart_CR1;unsigned int uart_CR2;unsigned char uart_transmit; //Le sotto variabili non devono

    essere ugualiunsigned char uart_receive;

    } seriale_struct //questo è il nome che useremo come tipo in seguito

    Quindi per usarla:

    Main{seriale_struct UART0; //definiamo la struttura per la uart0Unsigned char pippo;

    UART0.uart_CR2 = 34; //Assegno un valore al campo CR2//Il punto individua l’inizio della sottostruttura.

    pippo= UART0.uart_receive; //Leggo il valore ricevuto

    }

  • 53I microcontrollorigpessina

    Appendice C: Le strutture in C 2

    Naturalmente possiamo sfruttare i puntatori anche con le strutture: i puntatori a struttura.

    Riferendoci all’esempio precedente:

    typedef struct {unsigned int uart_CR1;unsigned int uart_CR2;unsigned char uart_transmit; //Le sotto variabili non devono

    essere ugualiunsigned char uart_receive;

    } seriale_struct //questo è il nome che useremo come tipo in seguito

    Main{seriale_struct UART0; //definiamo la struttura per la uart0Unsigned char pippo;seriale_struct *UART_generico;

    UART_generico=UART0; //UART_generico contiene l’indirizzo di inizio di// UART0

    UART_generico -> uart_CR2 = 34; //Assegno un valore al campo CR2//Quando si usa il puntatore si introduce il «->» per individuare il//campo, non il «.»

    pippo= UART_generico -> uart_receive; //Leggo il valore ricevuto

    }

  • 54I microcontrollorigpessina

    Appendice C: Le strutture in C 3

    typedef struct{

    __IO uint32_t CR1; /*!< USART Control register 1*/ __IO uint32_t CR2; /*!< USART Control register 2*/ __IO uint32_t CR3; /*!< USART Control register 3*/__IO uint32_t BRR; /*!< USART Baud rate register*/__IO uint32_t GTPR; /*!< USART Guard time */__IO uint32_t RTOR; /*!< USART Receiver TimeOut register*/ __IO uint32_t RQR; /*!< USART Request register*/__IO uint32_t ISR; /*!< USART Interrupt and status register*/__IO uint32_t ICR; /*!< USART Interrupt flag Clear register*/__IO uint16_t RDR; /*!< USART Receive Data register*/uint16_t RESERVED1; /*!< Reserved*/__IO uint16_t TDR; /*!< USART Transmit Data register*/uint16_t RESERVED2; /*!< Reserved*/

    } USART_TypeDef;

    Ecco un esempio di definizione di struttura per la configurazione della UART del micro STM. Possiamo vedere che sono elencati nella struttura tutti i registri che servono, con tutti i flag:

  • 55I microcontrollorigpessina

    Appendice D: Note sul micro STM32f072RB 1

    #define USART2 ((USART_TypeDef *) USART2_BASE)

    Il DNA del microcontrollore STM, ovvero il file dove stanno tutte le definizioni, sta nel file stm32f072xb.h.

    Si parte costruendo l’indirizzo della struttura:

    #define PERIPH_BASE ((uint32_t)0x40000000U)#define APBPERIPH_BASE PERIPH_BASE#define USART2_BASE (APBPERIPH_BASE + 0x00004400)

    Si cerca, per quanto possibile, di minimizzare l’uso di numeri usando delle definizioni. In questo modo la definizione può essere usata in molti contesti e se si deve cambiare il suo numero, per una qualsiasi ragione, lo si fa solo in un punto.

    La definizione vera e propria della struttura è fatta così:

    USART_TypeDef *pippo;

    pippo = USART2_BASE;

    #define USART2 pippo

    Essendo USART2 un puntatore, quando lo usiamo dobbiamo usare questa sintassi:

    USART2 -> CR1 = 37;

    USART2 è un puntatore a USART2_BASE di tipo USART_TypeDef, quindi è il capostipite della struttura.

    La scrittura (USART_TypeDef *) individua un cast. E’ un’abbreviazione che si può interpretare così:

  • 56I microcontrollorigpessina

    Appendice D: Note sul micro STM32f072RB 2

    Per intenderci. Se si fosse definito USART2 così:

    Ed in questo caso USART2 non avrebbe individuato un puntatore, ma la struttura stessa. Ovvero si sarebbe dovuto usare così:

    Il fatto di avere definito un puntatore piuttosto che la struttura è una scelta di comodità: normalmente si privilegia l’utilizzo dei puntatori.

    USART2.CR1 = 37;

    Sarebbe stato equivalente a scrivere:

    #define USART2 (*(USART_TypeDef *) USART2_BASE)

    USART_TypeDef *pippo;

    pippo = USART2_BASE;

    #define USART2 *pippo

  • 57I microcontrollorigpessina

    Appendice D: Note sul micro STM32f072RB 3Vien poi introdotta una cosa utile che è la definizione di tutti i flag dei registri. Per cui basta conoscere il nome per poterlo impostare: in rosso 2 esempi.

    Quindi per impostare, per esempio UE, basta fare così:

    USART2 -> CR1 |= USART_CR1_UE;

    /****************** Bit definition for USART_CR1 register *******************/

    #define USART_CR1_UE_Pos (0U)

    #define USART_CR1_UE_Msk (0x1U

  • 58I microcontrollorigpessina

    APPENDICE E 1: STM32 con display/termometro I2C

    Obiettivo della esercitazione è la gestione dell’ADC del micro e del display ed un termometro I2C realizzati su una schedina (*) installata sulla scheda di sviluppo stessa.

    (*) Progetto e realizzazione di Andrea Passerini (UNIMIB).

    Tutta la documentazione, schematici e datasheet, per questa esperienza si trovano sulla pagina web, cartella «Esperienza display STM32».

    Il funzionamento dell’I2C si trova sull’user manual del micro STM32.

  • 59I microcontrollorigpessina

    APPENDICE E 2: STM32 e display/termometro I2CIl display è connesso al micro con 4 pin: • L’I2C1 con PB8 e PB9 (attenzione questi 2 pin non sono quelli

    scelti canonicamente dal CUBE; il CUBE sceglie PB6 e PB7. Però, una volta abilitata, basta poi cliccare su PB8 e PB9 ed indicare di trasferire lì). Le resistenze di pull-up dell’I2C sono già assemblate e sono R7 ed R8. L’indirizzo del display è fissato a 0x3E (#define LCD_ADDRESS (0x3E

  • 60I microcontrollorigpessina

    APPENDICE E 3: STM32 e display/termometro I2C

    Termometro: • L’I2C1, con PB8 e PB9, è connessa anche al termometro, il cui

    indirizzo è fisato a 0x48 (#define LM76_ADDRESS (0x48

  • 61I microcontrollorigpessina

    APPENDICE E 4: STM32 e display/termometro I2C

    ADC: • L’ADC_IN0 è connesso ad un potenziometro a manopola (blu), in

    modo da potere variare la tensione di ingresso sotto misura.

  • 62I microcontrollorigpessina

    APPENDICE E 5: STM32 e display/termometro I2C

    LED: • Infine è possibile usare 4 LED, che sono stati connessi ai pin

    PB0, .., PB3.

  • 63I microcontrollorigpessina

    APPENDICE E 6: display I2CIl display si può solo impostare, scrivere.La sequenza da impostare in ogni comunicazione è:

    1. Indirizzo display in scrittura;2. Comando;3. dato

    All’accensione il display va inizializzato con una sequenza di impostazioni che servono per stabilire la sua condizione di lavoro.Le impostazioni sono:

    uint8_t initdata[] = {0x38, 0x39, 0x14, 0x74, 0x54, 0x6F, 0x0F, 0x01};

    Prima di ogni impostazione va inviato il comando 0x00.

    IMPORTANTE: tra un’impostazione e la successiva va lasciato passare almeno 1.1 ms per lasciare il tempo al display di eseguire le impostazioni.

    I comandi:

    • 0x00: il dato dopo questo commando indica una sola istruzione, ovvero impostazione, per il display. Il byte successivo ancora sarà un dato da scrivere, o si termina la comunicazione.

    • 0x80: il byte successivo è un byte di istruzione, quello successivo ancora sarà un altro byte di controllo,

    • 0x40: il o i byte successivi sono dati che si scriveranno sul display.

    • 0x40: il dato seguente è il carattere, o più caratteri, ASCII che verrà scritto nella cella di memoria, posizione del display, corrente. Scrivendo in continuazione la casella di memoria viene incrementata automaticamente.Sostanzialmente il display si comporta come una memoria il contenuto delle cui celle è mostrato.

  • 64I microcontrollorigpessina

    APPENDICE E 7: display I2C

    All’accensione il display va inizializzato con una sequenza di impostazioni che servono per stabilire la sua condizione di lavoro.Le impostazioni sono:

    uint8_t initdata[] = {0x38, 0x39, 0x14, 0x74, 0x54, 0x6F, 0x0F, 0x01};

    Prima di ogni impostazione va inviato il comando 0x00.

    IMPORTANTE: tra un’impostazione e la successiva va lasciato passare almeno 1.1 ms per lasciare il tempo al display di eseguire le impostazioni.

    Le 8 istruzioni sopra hanno il seguente significato:

    • 0x38: si seleziona 8 bit in comunicazione e 2 linee per il display;

    • 0x39: si seleziona 8 bit in comunicazione e 2 linee per il display e

    la tabella di istruzioni estesa;

    • 0x14: impostazione dell'oscillatore interno;

    • 0x74: impostazione contrasto;

    • 0x54: circuito di booster on;

    • 0x6F: controllo del follower;

    • 0x0F: Display ON, Cursor ON e Cursor blinking;

    • 0x01: Cancella il display

  • 65I microcontrollorigpessina

    APPENDICE E 8: display I2C

    Alcune impostazioni utili:

    • #define LCD_CLEAR 0x01 // CANCELLA IL DISPLAY;

    • #define LCD_HOME 0x02 // SPOSTA ALLA POSIZIONE HOME;

    • Imposta l’indirizzo della display data RAM, DDRAM:1 A6 A5 A4 A3 A2 A1 A0, dove A0, .., A6 è l’indirizzo che si vuole impostare. Cioè, in questo caso la sequenza dovrebbe essere:0x00, (0x80 + indirizzo).Volendo scrivere dalla prima cella si può fare:0x80 (il prossimo bye è un comando), 0x80 (indirizzo della prima cella della prima riga), 0x40, serie di caratteri. (i prossimi dati sono caratteri ASCII da scrivere nel display)Volendo scrivere dall’inizio della seconda riga:0x80, 0xC0, 0x40, serie di caratteri. Qui 0xC0=0x80+0x40 dove 0x40 è, per questi display, l’indirizzo della prima cella della seconda riga.

  • 66I microcontrollorigpessina

    APPENDICE E 9: display I2C

    Per scrivere un carattere sul display si usa la sequenza:

    • Indirizzo display in scrittura;

    • Comando 0x40;

    • Codice ASCII del carattere.

    E’ possibile anche scrivere una sequenza di caratteri:

    • Indirizzo display in scrittura;

    • Comando 0x40;

    • Codice ASCII della stringa di caratteri in sequenza.

    I -controllori ARM: la logica RISCLa struttura RISC La pipeline nei RISC 1La pipeline nei RISC 2La pipeline nei RISC 3I registri nella CPU dell’ARM nella modalità standard, o �dell’utilizzatoreLa struttura ARM 1Esecuzione di un’istruzione nell’ARM: matematica tra �2 registri 1Esecuzione di un’istruzione nell’ARM: matematica �tra 2 registri 2TempisticaModalità di funzionamento: le eccezioni (exceptions) 1Modalità di funzionamento: le eccezioni (exceptions) 2Modalità di funzionamento: le eccezioni (exceptions) 3Modalità di funzionamento: le eccezioni (exceptions) 4Modalità di funzionamento: le eccezioni (exceptions) 5Modalità di funzionamento: le eccezioni (exceptions) 6Il funzionamento in Thumb modeL’organizzazione della memoria 1L’organizzazione della memoria 2L’organizzazione dei dati in memoriaI BUS di comunicazione interna all’ARM 1I BUS di comunicazione interna all’ARM 2Qualche esempio applicativoBibliografia ARMARM - CORTEX M3 (1): introduzione (**)ARM - CORTEX M3 (2)ARM - CORTEX M3 (3): unità centraleARM - CORTEX M3 (4)ARM - CORTEX M3 (5)ARM - CORTEX M3 (6): memoriaARM - CORTEX M3 (7)ARM - CORTEX M3 (8): bit-bandARM - CORTEX M3 (9): bit-bandARM - CORTEX M3 (10): registriARM - CORTEX M3 (11)ARM - CORTEX M3 (16): interruzioniARM - CORTEX M3 (17)ARM - CORTEX M3 (18)ARM - CORTEX M3 (19)ARM - CORTEX M3 (20)ARM - CORTEX M3 (21)ARM - CORTEX M3 (22)ARM - CORTEX M3 (23)ARM - CORTEX M3 (24): suggerimentiARM - CORTEX M3 (25)Bibliografia (1)Bibliografia (2)Appendice A: Come impostare ad 1 un bit di �un registro lasciando inalterati gli altri 1Appendice A: Come impostare ad 1 un bit di �un registro lasciando inalterati gli altri 2Appendice B: Come impostare uno o più bit di �un registro lasciando inalterati gli altri 1Appendice B: Come impostare uno o più bit di �un registro lasciando inalterati gli altri 2Appendice C: Le strutture in CAppendice C: Le strutture in C 2Appendice C: Le strutture in C 3Appendice D: Note sul micro STM32f072RB 1Appendice D: Note sul micro STM32f072RB 2Appendice D: Note sul micro STM32f072RB 3APPENDICE E 1: STM32 con display/termometro I2CAPPENDICE E 2: STM32 e display/termometro I2CAPPENDICE E 3: STM32 e display/termometro I2CAPPENDICE E 4: STM32 e display/termometro I2CAPPENDICE E 5: STM32 e display/termometro I2CAPPENDICE E 6: display I2CAPPENDICE E 7: display I2CAPPENDICE E 8: display I2CAPPENDICE E 9: display I2C