Gestione dell'interrupt con il microcontrollore ATMega328 (scheda Arduino)

Transcript

1 Gestione dell'interrupt con il microcontrollore ATMega328 (scheda Arduino) Un microcontrollore normalmente esegue le istruzioni nella sequenza definita in fase di programmazione (fig. 1). Comunque, il microcontrollore può essere programmato per trattare eventi non schedulati, ovvero eventi che non si verificano con scadenze fisse di temporizzazione, e che necessitano di un livello di priorità differente a seconda delle esigenze. La risposta da parte del microcontrollore a questi eventi deve essere pianificata a priori dal programmatore, anche se non si conosce quando gli stessi eventi si verificheranno. Quando un interrupt (interruzione) viene generato da una periferica, il microcontrollore completa l'istruzione in corso (il tempo di risposta è inferiore al microsecondo) e poi salta al programma specifico della gestione dell'interrupt (ISR = Interrupt Service Routine) associato alla periferica che ha richiesto l'attenzione del microcontrollore. Ogni differente interrupt viene gestito da un programma specifico dove è possibile avere differenti risposte alla stessa periferica. Quando il software di gestione dell'interrupt è terminato il microcontrollore riprende ad eseguire il normale programma da dove era stato interrotto prima del verificarsi dell'evento generato dalla periferica. Figura 1 Gestione dell'interrupt con il microcontrollore ATMEGA328 L'ATMEGA328 possiede una potente e flessibile gestione di 26 differenti sorgenti dell'interrupt. Due interrupt sono generati da un segnale esterno mentre i rimanenti 24 interrupt supportano in modo efficiente le periferiche disponibili all interno del chip del microcontrollore. Utilizzare la tabella 1 per consultare l'elenco degli interrupt disponibili. L'elenco è visualizzato in ordine discendente del livello di priorità per la gestione dell'interrupt. Vettore (vector) Indirizzo (address) Sorgente (source) Descrizione 1 Nome utilizzato nell Interrupt Service Routine con il compilatore AVR-GCC 1 0x0000 RESET Pin esterno, Power-on reset, 2 0x0002 INT0 richiesta 0 di interrupt esterno (pin 4 del microcontrollore) INT0_vect 3 0x0004 INT1 richiesta 1 di interrupt esterno (pin 5 del microcontrollore) INT1_vect 4 0x0006 PCINT0 richiesta 0 di interrupt del cambio livello (pin 14 del micro) PCINT0_vect 5 0x0008 PCINT1 richiesta 1 di interrupt del cambio livello (pin 15 del micro) PCINT1_vect 6 0x000A PCINT2 richiesta 2 di interrupt del cambio livello (pin 16 del micro) PCINT2_vect 7 0x000C WDT interrupt dovuto all'overflow (time-out) del watchdog WDT_vect 8 0x000E TIMER2COMPA interrupt dovuto al confronto A con il TIMER/COUNTER 2 TIMER2_COMPA_vect 9 0x0010 TIMER2COMPB interrupt dovuto al confronto B con il TIMER/COUNTER 2 TIMER2_COMPB_vect 10 0x0012 TIMER2OVF interrupt dovuto all'overflow del TIMER/COUNTER 2 TIMER2_OVF_vect 11 0x0014 TIMER1CAPT interrupt dovuto alla cattura evento con il TIMER/COUNTER 1 TIMER1_CAPT_vect 12 0x0016 TIMER1COMPA interrupt dovuto al confronto A con il TIMER/COUNTER 1 TIMER1_COMPA_vect 13 0x0018 TIMER1COMPB interrupt dovuto al confronto B con il TIMER/COUNTER 1 TIMER1_COMPB_vect 14 0x001A TIMER1OVF interrupt dovuto all'overflow del TIMER/COUNTER 1 TIMER1_OVF_vect 15 0x001C TIMER0COMPA interrupt dovuto al confronto A con il TIMER/COUNTER 0 TIMER0_COMPA_vect 16 0x001E TIMER0COMPB interrupt dovuto al confronto B con il TIMER/COUNTER 0 TIMER0_COMPB_vect 17 0x0020 TIMER0OVF interrupt dovuto all'overflow del TIMER/COUNTER 0 TIMER0_OVF_vect 18 0x0022 SPI, STC interrupt della periferica SPI Serial Transfer Complete SPI_STC_vect 19 0x0024 USART, RX interrupt della periferica USART con ricezione Rx completata USART_RX_vect 20 0x0026 USART, UDRE interrupt della periferica USART con il Data Register vuoto (Empty) USART_UDRE_vect 21 0x0028 USART, TX interrupt della periferica USART con trasmissione Tx completata USART_TX_vect 22 0x002A ADC interrupt generato dalla conversione A/D completata ADC_vect 23 0X002C EE READY interrupt della EEPROM disponibile (Ready) EE_READY_vect 24 0x002E ANALOG COMP interrupt generato dal comparatore analogico (analog Comparator) ANALOG_COMP_vect 25 0x0030 TWI interrupt generato dall'interfaccia seriale a 2 fili (2-wire Serial Interface) TWI_vect 26 0x0032 SPM READY interrupt generato dalla memorizzazione nella memoria di programma (Store Program Memory Ready) SPM_READY_vect Tabella 1. - Vettori dell'interrupt e relativi nomi predefiniti Come risulta disponibile l'interrupt denominato "RESET" che possiede il livello massimo di priorità, seguito dalla richiesta di interrupt relativo al pin 4 denominato "INT0" e al pin 5 denominato "INT1". I rimanenti interrupt sono riferiti al chip interno dell ATMEGA328. Quando interviene un evento la corrispondente periferica genera un interrupt e il microcontrollore completata l'istruzione corrente che stava eseguendo, memorizza l'indirizzo dell'istruzione successiva nello stack (area di memoria RAM del tipo LIFO, ovvero Last In First Out) ed inizia l'esecuzione tramite l'isr corrispondente al particolare interrupt generato. Durante tutta l'esecuzione del programma di interrupt viene disabilitato l'interrupt stesso in modo da evitare che ogni ulteriore gestione dello stesso possa mandare in overflow la memoria riservata allo stack (si consideri che sono pochi byte a disposizione 16 o 32). L'esecuzione della gestione relativa all'interrupt termina quando il microcontrollore esegue l'istruzione in assembly RETI (RETurn from Interrupt). In tal caso il flusso del programma riprende nel programma principale dall istruzione successiva a dove era stato interrotto. Programmazione degli interrupt Il software deve essere programmato nel seguente modo per gestire gli interrupt: 1) assicurarsi che il software di gestione dell'interrupt (ISR = Interrupt Service Routine) per uno specifico interrupt sia correttamente collegato alla tabella degli indirizzi dei vettori di interrupt (Interrupt Vector Address) in modo che punti al corrispondente indirizzo di partenza del software. 2) assicurarsi che il software abbia abilitato il flag "globally interrupt", cioè che l'interrupt sia abilitato globalmente tramite l'istruzione in assembly "SEI" 3) assicurarsi che il software abbia abilitato il singolo interrupt 4) assicurarsi che i registri utilizzati all'interno dell'interrupt siano salvati all'inizio della routine e che vengano ripristinati al termine della stessa. Questa necessità è dovuta al fatto che non risulta possibile determinare in quale punto del programma principale avverrà l'interruzione e quindi necessario cautelarsi memorizzando i registri e/o le variabili che vengono utilizzate all'interno della gestione dell'interrupt.

2 Esempio di programmazione dell'interrupt esterno utilizzando il compilatore IDE della scheda Arduino (vers. 0022) Nel compilatore Arduino esistono 4 funzioni predefinite per supportare gli interrupt esterni alla scheda: a) la funzione denominata "interrupts();" serve per abilitare l'interrupt globale. b) la funzione denominata "nointerrupts();" serve per disabilitare l'interrupt globale. c) la funzione denominata "attachinterrupt(interrupt, function, mode);" serve per collegare l'interrupt alla tabella dei vettori dell'interrupt. d) la funzione denominata "detachinterrupt(interrupt);" serve per disabilitare l'interrupt specificato. La scheda UNO / Arduino 2009 gestisce 2 differenti interrupt esterni: INT0 collegato al pin 2 (digitale della scheda Arduino) e INT1 collegato al pin 3 (digitale della scheda Arduino). La funzione "attachinterrupt(interrupt, function, mode)" è utilizzata per collegare il pin hardware all'appropriata gestione del software di interrupt. I tre argomenti della funzione devono essere configurati nel seguente modo: interrupt. --> Specifica il numero dell'interrupt. Valori possibili sono 0 oppure 1. function. specifica il nome della routine di gestione dell'interrupt. mode. Specifica quale tipo di attività deve essere valutata quando si verifica l'evento che genera l'interrupt. Nella modalità denominata "LOW" si genera un interrupt quando il pin è a livello basso. Nella modalità denominata "CHANGE" si genera un interrupt quando il pin passa da un livello all'altro, cioè quando si passa da HIGH a LOW e viceversa. Nella modalità denominata "RISING" si genera un interrupt solo quando il pin passa dal livello LOW al livello HIGH. Nella modalità denominata "FALLING" si genera un interrupt solo quando il pin passa dal livello HIGH al livello LOW. Le principali caratteristiche del compilatore di Arduino 1) consente di gestire sino ad un massimo di 26 interrupt 2) supporta un meccanismo per: a) richiamare una funzione C all occorrenza di un determinato evento di interrupt b) generare in maniera automatica il codice per entrare ed uscire dalle routine di interrupt Per quanto riguarda la programmazione si ricordi che le funzioni di interrupt: 1) non hanno argomenti 2) non ritornano valori 3) non devono essere richiamate direttamente (le conseguenze di una chiamata diretta sono imprevedibili e generalmente producono errori) 4) quando si richiama una funzione ISR in linguaggio assembly essa per prima cosa deve salvare sullo stack i registri che userà per poi ripristinarli prima dell uscita Nell'esempio denominato "Interrupt_esempio_1.pde" viene illustrato la gestione di un evento esterno alla scheda Arduino. In pratica un pulsante collegato al pin 2 (INT0) permette di variare la velocità di aggiornamento di un contatore visualizzabile sulla seriale. /* nome progetto: GESTIONE INTERRUPT ESTERNO Specifiche del progetto: Si richiedono i seguenti punti: Creare un software in grado di leggere un input digitale, ovvero un pulsante di tipo normalmente aperto collegato al pin 2 tramite la gestione dell'interrupt. Se il pulsante risulta NON PREMUTO effettuare l'incremento di un contatore ogni secondo e visualizzare la variabile sul Personal Computer tramite la seriale, mentre il led collegato al pin 13 risulta spento. Se il pulsante viene PREMUTO e per tutto il tempo che rimane premuto occorre incrementare il contatore ogni decimo di secondo e mantenere acceso il led collegato al pin 13. Il pulsante e' collegato con un R = 10 Kohm di pull-up a VCC = +5V, mentre il led e' collegato con l'anodo al pin 13 e il Catodo a massa. creato da: G. Carpignano data: 07/11/2011 compilatore: compilato con la scheda Arduino ver */ const int pulsante = 2; // collegamento del pulsante sul pin 2 (INT0) const int led = 13; // pin 13 della scheda Arduino collegato al led unsigned long counter; // variabile utilizzata per il conteggio void setup() // funzione di inizializzazione dei INPUT/OUTPUT // definisci il numero di Interrupt = 0, definisci il nome della funzione di gestione // dell'interrupt = int0_isr, definisci che ogni volta che il pin2 (INT0) passa dal // livello logico HIGH al livello logico LOW genera un interrupt attachinterrupt(0, int0_isr, FALLING); Serial.begin(9600); // seriale RS232 con 9600baud, 8bit dati, 0bit parità e 1bit stop pinmode(led, OUTPUT); // inizializza il pin 13 come OUTPUT pinmode(pulsante, INPUT); // inizializza il pin 2 come INPUT collegato al pulsante n.a. digitalwrite(pulsante, HIGH); // attiva la resistenza interna di pullup 10Kohm sul pin 2 void loop() // programma principale (main) --> ciclo infinito (loop) digitalwrite(led, LOW); // settaggio iniziale forzato basso while (1) // ripeti il ciclo all'infinito delay(1000); // ritardo di un secondo = 1000 msec. counter++; // aggiorna contatore Serial.println(counter, DEC); // visualizza sulla seriale // fine istruzione "while" // fine istruzione "loop" // funzione di gestione dell'interrupt collegato al pin 2 (INT0). // Questa funzione viene richiamata ogni volta // che il pin 2 passa dal livello logico "HIGH" al livello logico "LOW" void int0_isr(void) 2

3 digitalwrite(led, HIGH); // accendi il led do counter++; // aggiorna contatore Serial.println(counter, DEC); // visualizza sulla seriale delay (100); // aspetta un decimo di secondo = 0,1 sec. = 100 msec. while(digitalread(pulsante) == 0); // attendi finche' il pulsante e' premuto delay (10); // aspetta 10 ms = 0,01 secondi per evitare i rimbalzi del pulsante digitalwrite(led, LOW); // spegni il led Esempio di programmazione dell'interrupt interno utilizzando il compilatore della scheda Arduino (vers. 0022) Nel prossimo esempio verrà utilizzato un interrupt generato da una periferica interna al microcontrollore, in pratica viene utilizzato il Timer/Counter0 del microcontrollore ATMEGA328 nella modalità a 8 bit con il Timer 0. Ogni volta che si raggiunge e si supera la massima capacità di conteggio del Timer 0, ovvero dopo 256 impulsi di clock applicati al Timer (vengono denominati comunemente "ticks") si ottiene la generazione di un interrupt associato al timer0. Se il relativo interrupt è abilitato si ottiene il salto alla relativa routine di gestione ogni volta che il Timer0 passa dal conteggio del valore 255 al valore 0. Il compilatore della scheda Arduino utilizza i tool del compilatore AVR Libc per compilare il programma, quindi occorre utilizzare le convenzioni utilizzate dagli utenti AVR-GCC per configurare correttamente l'interrupt interno. I nomi corretti dei vettori dell'interrupt sono stati inseriti nell'ultima colonna alla destra della tabella 1 (vedi pagina 1). Inoltre occorre evidenziare che le schede: Arduino 2009 e Arduino Uno funzionano con una frequenza di 16 MHz di clock. Semaforo con contatore posti auto disponibili per autorimessa Il candidato implementi un software in linguaggio C per la scheda Arduino in grado di segnalare con una lampadina (denominata L1 da 12V ma collegata al pin 4, si consideri che un uscita alta sul pin 4 determina l accensione della lampada) di colore verde e una lampadina (denominata L2 da 12V - 100mA collegata al pin 5, si consideri che un uscita alta sul pin 5 determina l accensione della lampada) di colore rosso la disponibilità (lampada verde accesa, rossa spenta) o meno (lampada rossa accesa, verde spenta) ad entrare in un garage che può contenere al massimo 10 posti auto. Si richiedono i seguenti punti: 1. L'ingresso e l'uscita dal garage è unico e permette il passaggio di una sola vettura alla volta in ingresso oppure in uscita. 2. La lampadina di colore verde (L1) rimarrà accesa solo se risultano ancora disponibili dei posti auto. In caso di posti auto esauriti la lampada verde si spegne e si accende la lampada rossa (L2). 3. I sensori utilizzati per aggiornare il conteggio delle autovetture sono di tipo ottico e sono due sensori (Sensore_A collegato al pin 2 e Sensore_B collegato al pin 3 della scheda Arduino) disposti all'ingresso del garage in modo tale da poter decrementare o incrementare il contatore dei posti auto disponibili quando una vettura entra oppure esce dal locale garage. 4. Non si consideri il passaggio pedonale perché avviene in un corridoio senza sensori. Figura 2 5. I due sensori ottici di rilevamento del passaggio sono dei fototransistor o fotoresistori che rilevano l'interruzione del fascio di luce proiettato da due piccoli faretti orientabili sul rispettivo sensore disposti ad una distanza di circa cm tra loro. I fototransistori funzionano come dei transistori che sono rispettivamente in saturazione se colpiti da un raggio luminoso d adeguata intensità oppure in interdizione se il raggio luminoso non raggiunge più i fototransistori. In Fig. 2 è possibile vedere una piantina con la disposizione corretta delle lampadine, dei sensori e delle lampade di segnalazione. Si ricordi che l'automobile in entrata nel garage deve percorrere uno stretto corridoio dove risultano posizionati i due sensori determinando in tal modo l'interruzione del fascio luminoso prima quello del Sensore_A (fototransistor non più illuminato, quindi livello logico alto all'ingresso del Trigger di Schmitt) poi quello del Sensore_B. È importante per un corretto funzionamento del software che deve discriminare il movimento in entrata o in uscita controllare che la distanza tra i due sensori non sia superiore alla lunghezza della vettura, nel nostro caso si è scelto una larghezza compresa tra i 80 ed i 100 cm. 3

4 6. Sequenza di rilevamento in entrata nel garage che determina un decremento del contatore numero posti disponibili all interno del garage: Uscita Sensore_A (input Pin 2) Uscita Sensore_B (input Pin 3) Nessuna auto sui sensori 0V 0V Auto in ingresso che copre solo il Sensore_A 5V 0V Auto in ingresso che copre entrambi i Sensori 5V 5V Auto in ingresso che copre solo il Sensore_B 0V 5V Nessuna auto presente sui sensori 0V 0V 7. Sequenza di rilevamento in uscita dal garage che determina un incremento del contatore numero posti disponibili all interno del garage: Uscita Sensore_A (input Pin 2) Uscita Sensore_B (input Pin 3) Nessuna auto sui sensori 0V 0V Auto in uscita che copre solo il Sensore_B 0V 5V Auto in uscita che copre entrambi i Sensori 5V 5V Auto in uscita che copre solo il Sensore_A 5V 0V Nessuna auto presente sui sensori 0V 0V 8. all'accensione il circuito si deve azzerare automaticamente. 9. disegnare lo schema elettrico dei collegamenti esterni alla scheda Arduino /* nome progetto: GARAGE_CON_INTERRUPT.PDE Considerazioni da effettuate: 1) Se l AUTO TRANSITA IN INGRESSO NEL GARAGE occorre decrementare il numero dei posti disponibili e il diagramma temporale sara : Sensore_A Sensore_B 2) Se l AUTO TRANSITA IN USCITA DAL GARAGE occorre incrementare il numero dei posti disponibili e il diagramma temporale sara : Sensore_B Sensore_A int L1 = 4; int L2 = 5; creato da: G. Carpignano data: 27/01/2012 compilatore: Arduino 0022 */ /* lampadina di colore verde (denominata L1 da 12V ma collegata al Pin 4, si consideri che un uscita alta sul Pin 4 determina l accensione della lampada) */ /* lampadina di colore rosso (denominata L2 da 12V ma collegata al Pin 5, si consideri che un uscita alta sul Pin 5 determina l accensione della lampada) */ int Sensore_A = 2; /* Sensore a fototransistor collegato al Pin 2 */ int Sensore_B = 3; /* Sensore a fototransistor collegato al Pin 3 */ unsigned int num_auto_garage = 0; /* contatore del numero di auto posteggiate dentro il garage */ unsigned int posti_auto = 10; /* numero di posti auto disponibili nel garage */ void setup() // funzione di inizializzazione dei INPUT/OUTPUT // definisci il numero di Interrupt (esempio: '0', dopo il nome della funzione di gestione // dell'interrupt esempio: 'int0_isr', definisce che ogni volta che il pin2 (INT0) oppure // il pin3 (INT1) passano dal livello logico HIGH al livello logico LOW genera un interrupt attachinterrupt(0, interrupt_0_isr, FALLING); attachinterrupt(1, interrupt_1_isr, FALLING); Serial.begin(9600); // seriale RS232 con 9600baud, 8bit dati, 0bit parità e 1bit stop pinmode(l1, OUTPUT); // inizializza il pin 4 come OUTPUT pinmode(l2, OUTPUT); // inizializza il pin 5 come OUTPUT pinmode(sensore_a, INPUT); // inizializza il pin 2 come INPUT collegato al pulsante n.a. // digitalwrite(sensore_a, HIGH); // attiva la resistenza interna di pullup 10Kohm sul pin 4 pinmode(sensore_b, INPUT); // inizializza il pin 3 come INPUT collegato al pulsante n.a. // digitalwrite(sensore_b, HIGH); // attiva la resistenza interna di pullup 10Kohm sul pin 3 4

5 void loop() // programma principale (main) --> ciclo infinito (loop) digitalwrite(l1, HIGH); // settaggio iniziale forzato alto --> lampada verde accesa digitalwrite(l2, LOW); // settaggio iniziale forzato basso --> lampada rossa spenta Serial.print ("\r\nnum. di automobile dentro al garage: "); Serial.println (num_auto_garage, DEC); while (1) // ripeti il ciclo all'infinito /* Stato di attesa del passaggio di un'auto che transiti davanti ai sensori posti all'ingresso finché uno dei due sensori commuta dal livello ALTO al livello BASSO (fronte di discesa). */ // fine istruzione "while" // fine istruzione "loop" // funzione di gestione dell'interrupt collegato al pin 2 (INT0). // Questa funzione viene richiamata ogni volta // che il pin 2 passa dal livello logico "HIGH" al livello logico "LOW" void interrupt_0_isr(void) if (digitalread (Sensore_B) == 1) // se sul fronte di discesa del Sensore_A // il Sensore_B e' a livello ALTO significa che l'auto ENTRA NEL GARAGE num_auto_garage++; // incrementa contatore del numero di auto parcheggiate dentro il garage Serial.print ("\r\nnum. di automobile dentro al garage: "); Serial.println (num_auto_garage, DEC); // controllo del numero di posti ancora disponibili all'interno del garage if (num_auto_garage < posti_auto) digitalwrite(l1, HIGH); // accendi lampadina VERDE digitalwrite(l2, LOW); // spegni lampadina ROSSA Serial.print ("\nlamp. VERDE -> Accesa\n Lamp. ROSSA -> Spenta"); else digitalwrite(l1, LOW); // spegni lampadina VERDE digitalwrite(l2, HIGH); // accendi lampadina ROSSA Serial.print ("\n Lamp. VERDE -> Spenta\n Lamp. ROSSA -> Accesa"); // funzione di gestione dell'interrupt collegato al pin 3 (INT1). // Questa funzione viene richiamata ogni volta // che il pin 3 passa dal livello logico "HIGH" al livello logico "LOW" void interrupt_1_isr(void) if (digitalread (Sensore_A) == 1) // se sul fronte di discesa del Sensore_B // il Sensore_A e' a livello ALTO significa che l'auto ESCE DAL GARAGE num_auto_garage--; // decrementa contatore del numero di auto parcheggiate dentro il garage Serial.print ("\r\nnum. di automobile dentro al garage: "); Serial.println (num_auto_garage, DEC); // controllo del numero di posti ancora disponibili all'interno del garage if (num_auto_garage < posti_auto) digitalwrite(l1, HIGH); // accendi lampadina VERDE digitalwrite(l2, LOW); // spegni lampadina ROSSA Serial.print ("\nlamp. VERDE -> Accesa\n Lamp. ROSSA -> Spenta"); else digitalwrite(l1, LOW); // spegni lampadina VERDE digitalwrite(l2, HIGH); // accendi lampadina ROSSA Serial.print ("\n Lamp. VERDE -> Spenta\n Lamp. ROSSA -> Accesa"); In figura 3 è disponibile il collegamento delle periferiche di input/output alla scheda Arduino. 5

6 6