Arduino Debug Facile

Arduino Debugging: Come non perdersi mai più tra le funzioni del tuo Sketch

Ti è mai capitato di caricare uno sketch su Arduino, aprire il Monitor Seriale e vedere che tutto si blocca, oppure che i dati stampati non hanno senso? Inizi a riempire il codice di messaggi improvvisati, per poi ritrovarti con una cascata di scritte anonime sul monitor e ancora più confusione in testa.

Quando i tuoi progetti iniziano a crescere e passi da un semplice codice lineare a uno sketch organizzato in molte funzioni (magari una per leggere i sensori, una per calcolare la media, una per muovere i motori e una per aggiornare il display), capire dove sta girando il programma in tempo reale diventa fondamentale.

Oggi scopriamo un trucco magico e automatico per fare debugging come i professionisti, usando una parolina segreta: __FUNCTION__.

Il problema: Il labirinto delle funzioni

Immagina di avere un robot che evita gli ostacoli. Il tuo loop principale chiama una funzione per controllare i sensori, la quale chiama una funzione per calcolare la distanza, che a sua volta potrebbe attivare la funzione di frenata.

Se il robot si blocca, come fai a sapere esattamente in quale di queste funzioni si è incagliato?

Andare a scrivere a mano il nome di ogni funzione dentro i vari comandi di stampa è lungo, noioso e rischi di fare copia-incolla sbagliando i nomi. È qui che entra in gioco l'automazione.

Cos'è FUNCTION?

In Arduino, __FUNCTION__ (scritto con due trattini bassi prima e dopo) è una macro speciale. Non devi definirla tu: il compilatore di Arduino sa già cos'è. Quando la usi, viene automaticamente sostituita con il nome della funzione in cui si trova in quel momento.

Se la metti nel setup(), stamperà "setup". Se la metti in una funzione chiamata leggiTemperatura(), stamperà "leggiTemperatura". Magico, vero?

Il Trucco Supremo: Automatizzare il Tracciamento

Per evitare di scrivere righe e righe di codice all'inizio e alla fine di ogni funzione, possiamo usare un piccolo trucco avanzato. Creiamo un sistema automatico: basta mettere una sola riga di codice all'inizio di ogni funzione per ottenere sul Monitor Seriale l'avviso di quando la funzione inizia ($START) e quando finisce ($END).

Ecco lo sketch di esempio pronto da testare:

// --- IL TRUCCO MAGICO (Copia questo blocco all'inizio dello sketch) ---
class Tracciatore {
  private:
    const char* nomeFunzione;
  public:
    // Quando la funzione inizia, stampa il $START
    Tracciatore(const char* func) : nomeFunzione(func) {
      Serial.print("$START ");
      Serial.println(nomeFunzione);
    }
    // Quando la funzione finisce, stampa il $END in automatico
    ~Tracciatore() {
      Serial.print("$END ");
      Serial.println(nomeFunzione);
    }
};
// Creiamo una scorciatoia comoda da scrivere
#define TRACCIA() Tracciatore t(__FUNCTION__)
// ---------------------------------------------------------------------

void setup() {
  Serial.begin(9600);
  while (!Serial); // Aspetta che il monitor seriale sia pronto

  TRACCIA(); // <-- Diciamo ad Arduino di tracciare il setup

  Serial.println("Sto avviando il sistema...");
   
  // Chiamiamo le nostre funzioni di esempio
  letturaSensori();
  elaborazioneDati();
}

void loop() {
  // Lo lasciamo vuoto per non intasare il monitor seriale
}

void letturaSensori() {
  TRACCIA(); // <-- Basta questa riga!
  
  Serial.println(" -> Sto leggendo il sensore ultrasonico...");
  delay(200); 
}

void  elaborazioneDati() {
  TRACCIA(); // <-- Basta questa riga!
  
  Serial.println(" -> Sto calcolando la media dei valori...");
  delay(200);
}

Cosa succede nel Monitor Seriale?

Se carichi questo codice sul tuo Arduino e apri il Monitor Seriale, vedrai apparire esattamente questo testo pulito e ordinato:

$START setup
Sto avviando il sistema...
$START letturaSensori
-> Sto leggendo il sensore ultrasonico...
$END letturaSensori
$START elaborazioneDati
-> Sto calcolando la media dei valori...
$END elaborazioneDati
$END setup

Riesci a vedere visivamente il "flusso" del tuo programma. Vedi quando Arduino entra in una determinata sezione, cosa fa dentro, quando esce e quando passa alla fase successiva.

Perché questo metodo è fantastico per chi inizia?

1. Scrivi meno, scopri di più: Metti solo TRACCIA(); all'inizio della funzione. La scritta di fine funzione apparirà da sola grazie al distruttore della classe, anche se la funzione si interrompe prima del previsto.
2. Trovi subito i crash: Se il tuo Arduino si blocca a causa di un calcolo errato, sul monitor vedrai l'ultimo $START nomeFunzione senza il rispettivo $END. Saprai al volo qual è la funzione colpevole!
3. Mantiene il codice pulito: Quando hai finito il debug, ti basta commentare o rimuovere la riga di tracciamento per riportare tutto alla normalità.

Buon divertimento e buon debugging con il tuo prossimo progetto Arduino! I banner pubblicitari sono una vera seccatura, ma se fai un solo click su uno di essi, contribuirai senza spendere un centesimo , al mantenimento del server.