L’architettura dei microcontrollori ha raggiunto ottimi livelli di affidabilità con elevati livelli prestazionali. Solitamente, quando si parla di affidabilità, si intende la capacità del micro di funzionare in ambienti critici, dove gli intervalli di temperature sono estesi (-40°C +85°C) o dove la presenza di rumori elettromagnetici o altri elementi fisici non deve certamente bloccare il funzionamento del microcontrollore.

Nella maggior parte dei casi i blocchi software sono ancora causati da errori di scrittura del firmware che gira sul micro. Questi blocchi sono tipicamente dovuti a loop infiniti o deadlock; errori che aumentano all’aumentare della complessità del codice.

Quando non possiamo permetterci nessun tipo di blocco vengono impiegati sistemi di supervisione hardware che, tramite sistemi integrati all’interno del micro stesso (Watchdog Timer) o con specifici moduli esterni, possono eseguire un reset del micro appena ‘si accorgono’ che l’esecuzione del codice del micro è bloccata.

Alcuni moduli permettono anche di controllare la qualità della tensione di alimentazione, e di eseguire un reset non appena si verificano abbassamenti di tensione.

Il dispositivo che ho utilizzato per questo tutorial è l’integrato ADM1232 prodotto da Analog Device, molto semplice da utilizzare e dal costo contenuto (circa 2 €).

L’idea di base è quella di controllare la presenza di uno strobe, un segnale impulsivo, generato dal microcontrollore, che deve presentarsi costantemente entro certi valori di tempo.

Se questo segnale dovesse mancare (indice di un blocco di funzionamento del microcontrollore), il circuito di supervisione ADM1232 eseguirà un reset del microcontrollore.

La figura seguente mostra il tipico collegamento tra il circuito di supervisione ed il microcontrollore:

Il diagramma a blocchi è rappresentato nella figura seguente:

Il dispositivo genera un impulso di reset ad intervalli che possono variare tra 150ms, 600ms e 1200ms. Questi tre valori sono impostabili tramite il pin TD (Time Delay), per selezionare 150ms il TD va collegato a massa, per selezionare 600ms il pin TD va lasciato appeso (senza collegarlo ne a Gnd ne a Vcc), per selezionare 1200ms va collegato alla Vcc.

Per evitare la generazione dell’evento reset, dobbiamo inviare un impulso negativo al pin STROBE.

Questo impulso deve essere inferiore del tempo di reset impostato, quindi se ad esempio abbiamo selezionato il tempo di 1200ms, al pin STROBE dovrà arrivare un segnale impulsivo con un periodo inferiore ai 1200ms.

I grafici seguenti mostrano l’andamento dei segnali:

Mentre il seguente grafico mostra la generazione dell’impulso di reset quando il segnale di strobe supera i 1200ms:

Affrontiamo la parte pratica realizzando il circuito seguente utilizzando un ATMEGA328P Stand Alone:

Ho impostato il TD a 1200ms, portando a +5V il pin TD dell’integrato supervisore ADM1232.

Lo sketch di test esegue una commutazione del pin 9, per generare il segnale di STROBE che permette di interdire la generazione del segnale RESET. Ho inserito un ritardo software di 500ms per simulare l’esecuzione di altro codice.

In questa condizione il segnale di STROBE è generato ogni 100ms circa e quindi essendo inferiore al tempo di 1200ms, il segnale di RESET non viene generato.

void setup()
{
  //pin 9 in uscita
  pinMode(9, OUTPUT);
}

void loop()
{
  //condizione per la quale non viene
  //generato il reset poichè il tempo di
  //esecuzione è inferiore ai 1200ms

  //segnale STROBE
  digitalWrite(9,HIGH);
  digitalWrite(9,LOW);

  //simulazione ritardo esecuzione
  delay(500);
}

Invece nello sketch seguente viene simulato un ritardo maggiore di 1200ms, in questo caso il chip ADM1232 non ricevendo il segnale di STROBE entro i 1200ms produrrà il segnale di RESET per riavviare l’esecuzione del codice sulla ATMEGA328P.

void setup()
{
  //pin 9 in uscita
  pinMode(9, OUTPUT);
}

void loop()
{
  //condizione per la quale non viene
  //generato il reset poichè il tempo di
  //esecuzione è inferiore ai 1200ms

  //segnale STROBE
  digitalWrite(9,HIGH);
  digitalWrite(9,LOW);

  //simulazione ritardo esecuzione
  delay(2000);
}

Attenzione il circuito supervisore ADM1232 può essere usato solo su dispositivi privi di bootloader. Infatti la presenza del bootloader renderà l’esecuzione del codice, al primo avvio molto lenta, circa 1,5 secondi. Dato questo tempo il circuito supervisore non potra mai ricevere, entro la soglia di 1,2 secondi, l’impulso di strobe, di conseguenza resetterà perennemente il microcontrollore.

Quando il vostro progetto è particolarmente complesso o richiede sicurezze aggiuntive, avere un circuito di supervisione permetterà di utilizzarlo in situazioni dove è richiesta una maggiore affidabilità ad esempio di definendo nel blocco setup() delle impostazioni di default di sicurezza, come il posizionamento iniziale di motori o la diseccitazione dei relè.

The post Circuito supervisore watchdog timer ADM1232 appeared first on Esperimenti con logiche programmabili.

Avere la possibilità di riavviare l’esecuzione del programma può risultare utile nei casi in cui ci sia l’esigenza di ripristinare la board a una condizione iniziale certa, soprattutto quando si trova in una posizione non accessibile o remota.
Supponiamo il caso di una Arduino Ethernet, o comunque con capacità di avere un collegamento ethernet o wifi, che si trova a lavorare in un posizione remota e che per qualsiasi motivo vogliamo seguire un riavvio della scheda per poter inizializzare nuovamente il programma che gira sulla scheda.
In questo caso possiamo usare una funzione, che se richiamata, permette di riavviare il programma come quando alimentiamo la scheda.

Sul sito Arduino.cc hè disponibile nella sezione guide, una utile funzione che permette appunto di riavviare la scheda. Il codice seguente permette di testare questa funzione affinché possiamo capirne il funzionamento e poterla applicare secondo le nostre esigenze:

int var = 0;

//Dichiarazione di funzione che punta all'indirizzo zero
void(* Riavvia)(void) = 0;

void setup()
{
  //inizializzo la seriale
  Serial.begin(9600);
  //avvio
  Serial.println("AVVIO");
  //attendo 1s
  delay(1000);

}

void loop()
{
  //incremento la variabile
  var++;
  //visualizzo sul serial monitor
  //il valore della variabile
  Serial.println(var);
  //attendo 5s
  Serial.println("Attesa");
  delay(5000);
  //reset via software
  Serial.println("Reset!!");
  Riavvia();

}

Il codice dichiara, prima del blocco setup, una funzione che in pratica è un puntatore a funzione che viene fatto puntare alla posizione zero (scusate il gioco di parole!!). Richiamare questa funzione permette ad Arduino di eseguire il codice se fosse stato appena stato resettato (anche se non vi è un vero e proprio reset hardware).
Ho inserito una variabile per verificare che il suo valore fosse, ad ogni riavvio, inizializzato a zero. I vari messaggi inviati al serial monitor permettono di dimostare e capire il funzionamento del codice.

Riavviare Arduino su richiesta

In questo codice di esempio viene eseguito il riavvio della scheda quando inviamo, tramite comunicazione seriale, usando il Serial Monitor, un particolare carattere:

String var = "";
 
//Dichiarazione di funzione che punta all'indirizzo zero
void(* Riavvia)(void) = 0;
 
void setup()
{
  Serial.begin(9600);
  Serial.println("AVVIO");
  delay(100);
}
 
void loop()
{
  //verifico la presenza di un dato sulla seriale
  if (Serial.available() > 0)
  {
    var = Serial.readString();
    //Invio la lettera R tramite Serial Monitor
    if (var == "R") //R
    {
    //reset software
    Serial.println("Riavvio...");
    delay(100);
    Riavvia();
    }
  }
 
 //Altro codice da eseguire...
 delay(10);
 
}

Quando progettiamo un circuito basato su microcontrollore che deve avere delle funzionalità per cui è possibile resettarlo in caso di mal funzionamenti, possiamo utilizzare le funzionalità del Watchdog timer o di un circuito di supervisione esterna.

The post Riavviare Arduino via software appeared first on Esperimenti con logiche programmabili.

Il watchdog è un sistema molto interessante impiegato per supervisionare il normale ciclo di istruzioni  eseguite dalla cpu.
L’idea è quella di monitorare l’esecuzione del programma per evitare blocchi o cicli infiniti (dead loop), dovuti a bug logici o situazioni esterne che portano il microcontrollore ad attender, per esempio, a input che non arriveranno mai.

In questo caso il watchdog interviene resettando il microcontrollore e riavviando automaticamente l’esecuzione del codice.

Questo meccanismo è solitamente implementato in hardware e, anche Arduino, basato sul microcontrollore ATMega328, supporta questa funzione

Se il programma che andiamo a scrivere per la board Arduino è progettato considerando tutti gli aspetti e le variabili che possono bloccare la cpu, non è necessario gestire il Watchdog, che di default è disabilitato.
Capita comunque che si verificano delle particolari condizioni che portano il programma a rimanere in attesa, ad esempio, di un particolare input che per cause esterne, non gestibili, potrebbe non arrivare mai.

Il watchdog quindi attende per un certo periodo e se, allo scadere di questo tempo l’input non è arrivato il Watchdog resetta la cpu facendola riavviare. In caso contrario, quando l’input arriva entro questo tempo, è fondamentale che il codice resetti il watchdog per evitare che questo resetti continuamente la cpu.

Il diagramma a blocchi seguente illustra in modo banale il meccanismo del watchdog

Codice da utilizzare

Per utilizzare il Watchdog inseriamo nello sketch il riferimento alla libreria wdt.h

#include <avr/wdt.h>

I tempi di reset del Watchdog sono prestabiliti e possono essere scelti utilizzando i valori specificati nella tabella seguente

Nel blocco setup() decidiamo di abilitare il watchdog specificando il tempo di reset utilizzando la seguente funzione:

//abilito il watchdog e imposto come tempo di reser 2 secondi 
wdt_enable(WDTO_2S);

questo significa che se entro 2 secondi non resettiamo il conteggio del watchdog, esso eseguirà automaticamente il reset della cpu.
Per resettarlo impieghiamo la seguente funzione:

//resetto il watchdog 
wdt_reset();

Il codice seguente mostra meglio il funzionamento del sistema

#include <avr/wdt.h> 
void setup() {
  //attivo il watchdog e lo imposto 
  //per una soglia di tempo di 2 Secondi 
  wdt_enable(WDTO_2S);
} 

void loop() { 
  //eseguo qualcosa... 
  delay(500); 
  //resetto il watchdog 
  wdt_reset(); 
}

All’interno del blocco loop() eseguo un delay di 500 ms e poi resetto il watchdog, in questo caso il watchdog non resetterà mai la cpu poiché non arriverà mai a contare i due secondi preimpostati, dato che il reset avviene ogni 500 ms.
Vediamo invece questa situazione:

#include <avr/wdt.h>

void setup()
{
  //attivo il watchdog e lo imposto
  //per una soglia di tempo di 2 Secondi
  wdt_enable(WDTO_2S);

}

void loop()
{
  //eseguo qualcosa...
  delay(3000); //3 secondi

  //resetto il watchdog
  wdt_reset();
}

Il codice precedente mette in funzione il sistema di auto reset in quanto, il delay di 3 secondi, fa in modo che il watchdog arrivi a contare i 2 secondi preimpostati facendo resettare la cpu.

Di fatto l’istruzione wdt_reset() non verrà mai eseguita.

Consiglio di utilizzare questo meccanismo in tutte le situazioni critiche che richiedono una certezza che la cpu esegua costantemente il suo compito evitando blocchi che porterebbero all’interruzione del servizio.

The post Arduino resettare automaticamente la scheda utilizzando il WatchDog Timer appeared first on Esperimenti con logiche programmabili.