Interrupt con Arduino: un ottimo modo per procedere senza ritardi tra ingresso e uscita
Con questo articolo vorrei chiarire una potenzialità nascosta di Arduino che permette di definire azioni di interrupt leggendo il segnale d'ingresso. Con questo ciclo di azioni e…
https://www.electronics-engineering.com/it/interrupt-con-arduino-un-ottimo-modo-di-procedere-senza-ritardi-tra-ingresso-e-uscita/
Con questo articolo vorrei chiarire una potenzialità nascosta di Arduino che permette di definire azioni di interrupt leggendo il segnale d’ingresso. Con questo ciclo di azioni si evitano i ritardi dei vari “if” nel codice.
INTERRUPT E COMUNICAZIONE SERIALE
Con questo programma Arduino genera un impulso di 20 us dalla funzione loop. Questo impulso entra in un altro ingresso di Arduino. Un interrupt da questo secondo ingresso genera un comando seriale e viene generata una nuova uscita. Dalla seriale si ottiene un “1” per ogni impulso, e la nuova uscita rappresenta un’onda quadra i cui fronti sono gli istanti degli impulsi.
// A simple sketch to read GPS data and parse the $GPRMC string
// see http://www.ladyada.net/make/gpsshield for more info
#include <NewSoftSerial.h>
NewSoftSerial mySerial = NewSoftSerial(2, 3);
#define GPSRATE 4800
//#define GPSRATE 38400
int pbIn = 0; // Interrupt 0 is on DIGITAL PIN 2!
int ledOut = 13; // The output LED pin
volatile int state = LOW; // The input state toggle
int ledPin = 8;
void setup() {
pinMode(ledPin, OUTPUT); // sets the digital pin as output
// Set up the digital pin 2 to an Interrupt and Pin 4 to an Output
pinMode(ledOut, OUTPUT);
//Attach the interrupt to the input pin and monitor for ANY Change
attachInterrupt(pbIn, stateChange, RISING);
Serial.begin(GPSRATE);
mySerial.begin(GPSRATE);
}
void loop() {
digitalWrite(ledPin, HIGH); // sets the LED on
delayMicroseconds(17); // waits for 17ms
digitalWrite(ledPin, LOW); // sets the LED off
delay(1000); // wait for 1s with tune
}
void stateChange() {
Serial.print("1");
state = !state;
digitalWrite(ledOut, state);
}Introduzione agli interrupt
Perché dovrei usare un interrupt? I robot passano molto tempo ad aspettare che succeda qualcosa. Un esempio comune: il tuo robot vuole andare dritto finché un sensore IR dice che un oggetto è troppo vicino. Sembra abbastanza semplice. Codice:
driveForward();
while(sensor_value == DIGITAL_HIGH){
// maybe do some other stuff, like follow a wall.
};
stop();Questo codice fa il “polling” del sensore: controlla il valore continuamente, a mano (nel software). Funziona, naturalmente, ma cosa succede se le “altre cose” diventano un processo davvero lungo? Si potrebbe andare oltre e sbattere contro il muro. E se l’evento che vogliamo rilevare è molto breve? Si potrebbe perderlo. In questi casi conviene usare un interrupt. Esempi comuni in cui si usano gli interrupt:
- Contare gli impulsi di un encoder (sono brevissimi e arrivano molto spesso)
- Catturare un impulso breve (come quello da 10 ms emesso da un sensore UVTron)
- Usare interruttori o sensori IR digitali come paraurti (e si vuole un arresto istantaneo)
Che cos’è un interrupt?
La cosa davvero bella dei microcontrollori è che hanno hardware sofisticato in grado di fare PWM, conversione analogico-digitale e interrupt. Un interrupt è un piccolo pezzo di hardware che resta in attesa di rilevare un evento di innesco, per esempio un certo pin che passa dallo stato basso allo stato alto. Quando questo evento si verifica:
- scatta l’interrupt
- il microcontrollore smette di eseguire il programma corrente
- il microcontrollore inizia a eseguire una routine di servizio dell’interrupt (Interrupt Service Routine, ISR)
- quando l’ISR ha finito, si torna al programma originale
Quindi un interrupt hardware è un po’ come quando il Presidente interrompe la tua serata davanti alla TV per dirti che l’economia è crollata. L’evento di innesco è il crollo dell’economia, e subito dopo l’hardware (il Presidente) esegue una ISR (il suo discorso alla nazione).
Nella tua ISR metteresti il codice che esegue l’elaborazione necessaria a gestire l’evento. Per esempio, la tua ISR potrebbe:
- incrementare il valore di un contatore, se stessi contando gli impulsi di un encoder
- impostare un flag che dice “fuoco trovato”, se stessi controllando un UVTron
- fermare il robot, se usassi paraurti a interrupt
La maggior parte dei microcontrollori supporta un’ampia varietà di inneschi di interrupt:
- un certo pin che passa da basso ad alto
- un certo pin che passa da alto a basso
- qualsiasi cambiamento su un certo pin
Di solito i microcontrollori hanno solo pochi interrupt, su pin specifici. Vedremo una piccola variante più sotto, nella sezione “Aspetta, ho finito gli interrupt!”. Un altro punto interessante, che qui non approfondiremo, è che il PWM e i timer/contatori hardware si basano interamente su hardware simile agli interrupt.
Il paraurti a interrupt
Realizziamo ora un esempio con Arduino. Arduino è basato su un AVR ATMEGA168. Questo chip ha 2 interrupt hardware (chiamati 0 e 1). I pin usabili per innescare gli interrupt sono legati rispettivamente ai pin digitali 2 e 3. Arduino rende abbastanza facile usare gli interrupt: ha una funzione AttachInterrupt(interrupt, ISR, trigger):
- interrupt indica quale interrupt hardware usare: 0 (digitale 2) o 1 (digitale 3).
- ISR è la funzione da usare come ISR
- trigger è RISING, FALLING o CHANGE, cioè gli eventi che fanno scattare l’interrupt
Il codice qui sotto usa alcune pseudo-funzioni che dovrai implementare per il tuo robot:
- DriveForward() – fa muovere il robot in avanti a una velocità regolare
- DriveBackward() – fa muovere il robot all’indietro a una velocità regolare
- Stop() – ferma il robot
- TurnLeft() – fa una piccola svolta a sinistra, di circa 45 gradi
Nel nostro esempio supponiamo che tu abbia un interruttore di contatto. Va collegato tra massa e il pin d’ingresso digitale (useremo una resistenza di pull-up per tenerlo a 5 V quando non è premuto).
Qui succedono alcune cose. Per prima cosa partiamo in avanti. Abbiamo un intero usato come flag, che vale 0 quando non abbiamo urtato nulla e 1 quando abbiamo colpito qualcosa. Quando urtiamo qualcosa scatta un interrupt, che ferma il robot per evitare danni e imposta anche il nostro flag. Poi il ciclo principale si occuperà di far arretrare il robot appena ne avrà la possibilità. Ci sono alcuni motivi per scrivere il codice così. Primo, delay() si basa sugli interrupt. Secondo, non si vuole mai che gli interrupt durino a lungo, perché di solito impediscono agli altri interrupt di scattare, e questo può essere devastante quando c’è qualcosa come un orologio di sistema che dipende dagli interrupt (come in Arduino).
Codice:
// Interrupt-Driver Bumper Example
// A bumper switch on the front of the robot should be tied to digital pin 2 and ground
#include
volatile int bumper; // have we hit something
void setup(){
pinMode(2, INPUT); // Make digital 2 an input
digitalWrite(2, HIGH); // Enable pull up resistor
// attach our interrupt pin to it's ISR
attachInterrupt(0, bumperISR, FALLING);
// we need to call this to enable interrupts
interrupts();
// start moving
bumper = 0;
DriveForward();
}
// The interrupt hardware calls this when we hit our left bumper
void bumperISR(){
Stop();
bumper = 1;
}
void loop(){
// if bumper triggered
if(bumper > 0){
DriveBackward(); // set motors to reverse
delay(1000); // back up for 1 second
TurnRight(); // turn right (away from obstacle)
bumper = 0;
DriveForward(); // drive off again...
}
// we could do lots of other stuff here.
}
Aspetta, ho finito gli interrupt!
La libreria di Arduino supporta solo 2 interrupt su pin, perché usa solo i 2 interrupt hardware dedicati. Tuttavia l’ATMEGA168 (il chip su cui è costruito Arduino) può in realtà generare interrupt su ogni porta, è solo un po’ più complicato. Si chiamano Pin Change Interrupt. Ogni porta dell’AVR ha il suo vettore di interrupt, e si possono abilitare gli interrupt per tutti i pin che si vogliono. Ci sono però alcune limitazioni. Primo, l’interrupt viene generato per qualsiasi cambiamento del pin: non si può limitare l’hardware ai soli fronti di salita o di discesa, anche se lo si potrebbe fare nella propria ISR. Secondo, poiché tutti i pin di una porta condividono un vettore di interrupt, se si usa più di un pin in una porta bisogna controllare a mano quale pin ha generato l’interrupt. Va notato che il passaggio nella ISR richiede diversi cicli di clock, quindi la ISR non parte istantaneamente e può essere difficile “controllare” quale pin abbia generato l’interrupt. Infine, poiché non esiste una libreria, bisogna scrivere un po’ più di codice.
Nota che Arduino dà ai suoi pin nomi arbitrari, che non c’entrano con i nomi dell’AVR: bisogna usare il datasheet dell’ATMEGA168 insieme allo schema dei pin di Arduino per ricavare i valori dei registri. È di sicuro un argomento avanzato, ma è un ottimo modo per imparare qualche dettaglio in più dell’architettura AVR.
Codice:
// Quick example of using pin change interrupts
// This shows how to use Digital Pin 4 (PCINT18/PD2) as an interrupt
#include
// we need to remember that the Arduino environment uses different pin numbers
// than the ATMEGA168 itself.
void setup(){
// Make digital 4 (PCINT18/PD2) an input
pinMode(4, INPUT);
// this is ATMEGA168 specific, see page 70 of datasheet
// Pin change interrupt control register - enables interrupt vectors
// Bit 2 = enable PC vector 2 (PCINT23..16)
// Bit 1 = enable PC vector 1 (PCINT14..8)
// Bit 0 = enable PC vector 0 (PCINT7..0)
PCICR |= (1 << PCIE2);
// Pin change mask registers decide which pins are enabled as triggers
PCMSK2 |= (1 << PCINT18);
// enable interrupts
interrupts();
}
void loop(){
// do nothing...
}
// we have to write our own interrupt vector handler..
ISR(PCINT2_vect){
// this code will be called anytime that PCINT18 switches
// (hi to lo, or lo to hi)
}Qualche avvertenza per chi usa Arduino
Su Arduino non usare le funzioni delay() o millis() dentro una ISR. Il motivo è che dipendono dall’orologio di sistema, che a sua volta è generato da un interrupt. Nell’architettura AVR, quando un interrupt inizia a eseguire la sua ISR, tutti gli altri interrupt sono disabilitati temporaneamente. Per lo stesso motivo conviene tenere la ISR il più corta possibile (per non disturbare l’orologio di sistema stesso).
Note finali
Questo copre più o meno le basi degli interrupt, con alcuni esempi su Arduino. Dai un’occhiata al mio tutorial sulla retroazione ad anello chiuso per maggiori informazioni sull’uso degli encoder.






Welcome to the page on “Interrupt with Arduino: A Great Method to Proceed Without Delay Between Input and Output”. I wrote it for engineering students: if a step does not add up, an exercise gives you a different result or you would like more material on the topic, just ask in the comments and I will reply. A star rating above helps me understand which pages to improve.