In un precedente articolo, utilizzando Arduino UNO avevamo parlato degli interrupt, spiegando cosa sono e come gestirli. Anche la Raspberry Pi Pico, come la maggior parte dei microcontrollori è in grado di gestire gli interrupt. Utilizzando il linguaggio Micropython questa operazione diventa molto semplice.

Questo meccanismo è molto utile perché sostituisce il meccanismo di polling che in un microcontrollore può essere molto svantaggioso. Ad esempio se devo controllare ciclicamente lo stato di un ingresso non posso mettere il microcontrollore in sleep mode perchè andrei a fermare il controllo del pin mentre un interrupt viene gestito dall’hardware e quindi è possibile superare questo limite.

Nel caso della Pico, programmata usando Micropython non sono sicuro se questa funzione sia disponibile anche quando il microcontrollore è in sleep mode.

Gestire le interruzioni

Come accade per Arduino dobbiamo definire una funzione (che verrà richiamata quando avviene l’evento di interrupt) e definire un pin capace di gestire l’interrupt.

Nello schema seguente viene mostrato come ho eseguito i collegamenti di un circuito di test.

Mentre il codice seguente descrive le istruzioni necessarie a gestire l’interrupt:

import machine
import utime

#definisco il pin 0 come ingresso
#su questo pin è collegato un pulsante con una
#resistenza di pull down
button = machine.Pin(0, machine.Pin.IN, machine.Pin.PULL_DOWN)
#definisco il pin 1 come uscita
#su questo pin collego un led e una resistenza da 330 ohm
led = machine.Pin(1, machine.Pin.OUT)

#definisco una funzione che verrà richiamata quando
#viene scatenato l'interrupt
def ev_handler(pin):
    print("bottone premuto")
    
#associo al pin in ingresso la funzione di interrupt
#l'evento videne generato usando il parametro RISING
button.irq(trigger=machine.Pin.IRQ_RISING, handler=ev_handler)

#loop che fa blinkare il led
while True:
    led.toggle()
    utime.sleep(1)

Dopo le dichiarazione dei pi e della funzione il codice entra nel ciclo while ed esegue continuamente la commutazione del pin 1. Non appena premiamo il pulsante collegato al pin 0 viene generato un evento che interrompe il ciclo e richiamata la funzione ev_handler(). Terminata l’esecuzione del codice nella funzione ev_handler() viene ripresa l’esecuzione del codice del ciclo while().

Da notare che l’interruzione non è asincrona quindi il codice nella funzione ev_handler() deve essere il più rapido possibile per non impattare sul codice del ciclo while().

The post Pi Pico usare gli interrupt appeared first on Esperimenti con logiche programmabili.

Un interrupt (interruzione) è un evento che viene generato in presenza di una variazione di livello su un particolare pin della board Arduino. Questo evento viene gestito direttamente dal microcontrollore ed è controllabile via software tramite delle apposite istruzioni. Quando viene scatenata una interruzione è possibile eseguire del codice in modo automatico, interrompendo momentaneamente il normale flusso di codice all’interno del blocco loop().

L0 schema seguente illustra il concetto

La variazione di stato del segnale applicato all’Arduino può essere gestita in vari modi, a seconda del parametro utilizzato per la gestione dell’interrupt. La tabella seguente mostra i parametri che determinano come deve essere generata l’interruzione.

	Zero	A+	B	B+	2B
IDLE	100mA	100mA	360mA	200mA	230mA
Riproduzione Video Full HD	140mA	140mA	420mA	240mA	290mA

di seguito viene esposto lo schema del circuito che ho realizzato per testare questa funzione. Un generatore di segnali ad onda quadra è stato collegato al pin3 della board Arduino mentre sul pin8 è stato collegato un oscilloscopio. Il segnale presente sul pin8 è funzione di quello presente sul pin3 come vedremo dal codice di esempio.

Per testare questa funzione possiamo usare lo sketch seguente

int pin = 8;
//Notare l'uso di 'volatile'
volatile int state = LOW;

void setup()
{
  //definisco il pin8 come uscita
  pinMode(pin, OUTPUT);
  //inizializzo l'uscita a livelo basso
  digitalWrite(pin, LOW);
  //Creo un gestore di interrupt e lo associo al pin3
  attachInterrupt(1, GestInt, LOW);
}

void loop()
{
  //fai qualcosa...
  delay(10);
}

void GestInt()
{
  state = !state;
  digitalWrite(pin, state);
}

Il codice gestisce gli interrupt generati dal segnale in ingresso. Quandosi verifica un’interruzione, viene eseguita automaticamente la funzione GestInt(), che permette di cambiare lo stato del pin8, rilevabile con l’oscilloscopio. I grafici sottostanti, illustrano il comportamento dei segnali a seconda del parametro utilizzato per generare l’interrupt.

Il primo parametro, LOW, genera una serie di interruzioni ogni qualvolta il segnale applicato al pin3 rimane basso. La funzione GestInt() viene eseguita a una frequenza di circa 47,6KHz

Quando invece selezioniamo il parametro CHANGE, l’interruzione viene generata ogni volta che il segnale applicato al pin3 passa dal valore basso a quello alto e viceversa. La funzione GestInt() genera sul pin8 lo stesso segnale applicato al pin3.

Utilizzando invece il parametro RISING, l’interruzione viene generata solamente sui fronti di salita del segnale applicato sul pin3. La funzione GestInt() viene eseguita con una frequenza dimezzata rispetto al segnale applicato al pin3

Infine impiegando il parametro FALLING, gli interrupt verranno generati quando il segnale applicato sul pin3 passa da alto a basso. Anche in questo caso la funzione GestInt() viene eseguita con una frequenza dimezzata rispetto al segnale applicato al pin3

Riepilogando i pin dell’arduino sensibili alle variazioni di segnale sono i pin2 e pin3 che rispettivamente vengono specificati nella funzione attachInterrupt come 0 e 1. Nella funzione attachInterrupt , oltre a specificare il pin  che vogliamo monitorare dobbiamo specificare il nome della funzione da eseguire quando si scatena l’interruzione e il modo in cui l’interruzione deve essere interpretata.
La variabili state viene dichiarata utilizzando l’attributo volatile, questo perchè la funzione gestita dall’interrupt viene eseguita in contemporanea al blocco loop() ed è necessario che in fase di compilazione la variabile sia caricata nella RAM.

The post Progetti Arduino gestione degli interrupt appeared first on Esperimenti con logiche programmabili.