Come Realizzare un Circuito Antirimbalzo per Pulsante e come Implementare questa Funzione in modo Software…
INTRO
Il problema del “rimbalzo” è un problema che si presenta quando all’interno del circuito si hanno dei pulsanti o degli interruttori, oppure dei contatti metallici. Si può presentare anche nel caso di segnali rumorosi per via dell’ambiente (posti in cui ci sono macchine elettriche o altri elementi che creano rumore elettromagnetico) o lunghezza dei cavi.
Consiste in più commutazione non volute che si hanno quando si vuole una singola commutazione del segnale. Ovvero se ho un pulsante che mi fornisce un’uscita logica bassa, premendolo voglio una commutazione logica bassa-alta ma per via della meccanica del pulsante ottengo un segnale non stabile dopo aver premuto il pulsante. Ad esempio si ha un segnale di questo tipo:
Se si usa lo schema classico del pulsante, con pulsante e resistore di pull-up, dopo la pressione del pulsante si hanno dei rimbalzi del segnale, ovvero dovrebbe andare a livello logico basso ma non rimane stabile, in particolare invece di avere una sola commutazione nell’esempio se ne hanno 4. Se il pulsante con resistore di pull-up è connesso ad un microcontrollore che conta quante volte il tasto viene premuto, invece di contare una volta sola, per via dei rimbalzi vi sarà un conteggio errato. Questo problema di rimbalzi multipli dura per un tempo che dipende dal pulsante usato, alcuni hanno tempi di 100uS circa mentre altri arrivano a circa 1mS di commutazioni spurie.
Vi sono modi software e modi hardware per risolvere questo problema, in questo tutorial vedremo le implementazioni più semplici e ne vedremo alcuni di entrambi i tipi, hardware e software analizzando i pro e i contro.
FILTRO ANTIRIMBALZO RC
Il primo circuito di debouncing è composto semplicemente da due resistori e un solo condensatore. Si avrà il seguente circuito:
Nel primo caso se il tasto non è premuto si ha in uscita un segnale a livello logico alto, mentre nel circuito di destra se non è premuto il tasto si ha in uscita un livello logico basso.
Consideriamo il primo circuito, quello di sinistra, il condensatore C1 viene caricato attraverso R1 ed R2, mentre per scaricarlo la corrente passa attraverso il pulsante ed R2. Quindi serve un tempo doppio per il passaggio da livello logico basso a livello alto rispetto al passaggio da livello logico alto a basso.
Il tempo è dato dalla seguente equazione che considera 2/3 di VCC come valore di passaggio:
Considerando che i rimbalzi durano circa 500uS questo tempo calcolato deve essere maggiore di 500uS. Ad esempio con i valori riportati sopra si hanno tempi di 760us al minimo, quindi il circuito permette di eliminare tutti i rimbalzi ma nel caso peggiore serve circa 1mS perché il microcontrollore rilevi la variazione del segnale dopo averlo premuto nel primo caso e dopo averlo rilasciato nel secondo caso.
Se invece di un pulsante ho un segnale con commutazione spurie bisogna far si che il tempo massimo di commutazione sia circa 10 volte minore della frequenza del segnale.
I pro di questo circuito sono che è molto semplice e richiede il minor numero di componenti mentre i contro sono che vi sarà un certo ritardo (nell’ordine dei ms) tra la pressione o il rilascio del pulsante e il rilevamento della variazione da parte del microcontrollore.
FILTRO ANTIRIMBALZO RC CON DIODO
Se serve un circuito che alla pressione del pulsante faccia cambiare istantaneamente il valore del segnale di uscita bisogna usare il seguente schema:
Lo schema è molto simile a quello precedente solo che vi è un diodo che nel primo caso permette di scaricare immediatamente la capacità mentre nel secondo caso la carica velocemente, permettendo al microcontrollore di rilevare istantaneamente la pressione del pulsante.
Per rilevare il rilascio del pulsante serve sempre un tempo pari a 3.3(R1+R2)C1 oppure 3.3(R3+R4)C2 nel secondo caso.
I pro di questo circuito sono che è molto semplice come quello precedente e non vi è nessun ritardo di rilevamento della pressione mentre i contro sono che rimane il ritardo di rilevamento del rilascio e serve un diodo connesso nella giusta posizione oltre a resistori e condensatori.
ALTRI SCHEMI E SOLUZIONI
Tra gli schemi possibili da realizzare per eliminare i rimbalzi introdotti da un pulsante vi è il seguente:
Questo schema è composto da due porte logiche di tipo NAND che realizzano un flip flop J-K. Si basa sull’uso di un deviatore o switch a tre contatti e sul fatto che il segnale dello switch viene portato in uscita solo quando sarà stabile. I pro sono che questo sistema non ha ritardi di variazione dell’uscita e inoltre elimina tutti i rimbalzi mentre i contro sono che serve un chip contente porte logiche o flip-flop j-k complicando lo schema visto che serve questa struttura per ogni ingresso.
Esistono anche soluzioni integrate che realizzano il debouncing, come i chip della Maxim Integrated MAX6816 o simili.
SOLUZIONI SOFTWARE
Le soluzioni software hanno il vantaggio di non richiedere componenti esterni ma hanno lo svantaggio di introdurre un ritardo antirimbalzo nel codice e inoltre non sempre sono efficaci. Supponiamo di usare un microcontrollore PIC e scrivere il codice con MIKROC, l’antirimbalzo può essere realizzato sia in un ciclo normale di polling sia in una struttura di interrupt come possibile vedere nel seguente esempio:
if(pulsante == 1){ //controlla stato pulsante
delay_ms(100); //Ritardo anti-rimbalzo
if(pulsante == 1){ //Ricontrolla il pulsante
//Istruzioni da eseguire
}
}
void interrupt() iv 0x0018 ics ICS_AUTO { //funzione richiamata dall'interrupt
delay_ms(100); //Ritardo anti-rimbalzo
if(pulsante == 1){ //Ricontrolla il pulsante
//Istruzioni da eseguire
}
}
In entrambi i casi vi è un ritardo di 100mS dopo il primo rilevamento del cambio del pulsante e dopo questo ritardo, considerando che tutti i rimbalzi dovrebbero essere conclusi si va a verificare lo stato del pulsante.
Il codice per Arduino può essere eseguito come nel caso precedente controllando il pulsante, aspettando un delay di 100ms e poi ricontrollando lo stato dell’ingresso oppure con una soluzione più complessa dal punto di vista del codice:
if (digitalRead(ingresso)==1){ //Se il pulsante viene premuto... delay(100); //Aspetta 100ms if (digitalRead(ingresso)==1){ //Se è ancora premuto... //Istruzioni da eseguire //Esegui le istruzioni } } unsigned long debounceDelay = 50; //Delay antirimbalzo in ms int reading = digitalRead(buttonPin); //Leggi stato pulsante if (reading != lastButtonState) { //Se lo stato è cambiato esegui... lastDebounceTime = millis(); //Resetta timer debouncing } if ((millis() - lastDebounceTime) > debounceDelay) { //Se l'ingresso è stabile per un tempo superiore al delay... if (reading != buttonState) { //Se l'ingresso cambia stato buttonState = reading; //Aggiorna lo stato //Istruzioni da eseguire lastButtonState = reading; //Salva il valore dell'ingresso } }
Nel secondo caso quindi si inizializza una variabile che è il tempo dei rimbalzi e poi si va a controllare il tempo in cui il segnale di ingresso è stabile, se il segnale è stabile per un tempo maggiore a quello dei rimbalzi (50ms nell’esempio) allora possono essere eseguite le istruzioni da eseguire dopo la pressione del pulsante.
