Nota: TUTTI i prodotti OSOYOO per Arduino sono schede di terze parti completamente compatibili con Arduino.

Introduzione

In questa lezione spiegherò come impostare il monitor seriale in modo da poter eseguire il debug e interagire con un programma in esecuzione sulla scheda. Si tratta di un’operazione piuttosto semplice, ma che all’inizio può creare un po’ di confusione, soprattutto se si è alle prime armi con la programmazione e con la scheda.

In questa lezione costruiremo un semplice circuito per dimostrare come sia possibile ricevere e inviare comandi attraverso il monitor seriale.

Preparazione

Hardware

Boars di base Osoyoo (completamente compatibile con Arduino UNO rev.3) x 1

Tavoletta di pane x 1

Resistenza da 200 ohm x 1

LED x 1

Ponticelli M/M

Cavo USB x 1

PC x 1

Software

IDE (version 1.6.4+)

Connessione

Si collegano i componenti come mostrato nel diagramma seguente.

Carica schizzo

Una volta completate le operazioni sopra descritte, collegare la scheda al computer tramite il cavo USB. Il LED verde di alimentazione (PWR) dovrebbe accendersi.

Codice Programma

È possibile download the sketch from this link o copiare il codice sottostante nella finestra dell’IDE:

int redLedPin = 2; // Pin Red LED is connected to 
int count = 0; 
void setup() { 
pinMode(redLedPin, OUTPUT); //Set led pin to output 
Serial.begin(9600); //Set serial to the 9600 band 
while (! Serial); // Allow serial to initialise  
Serial.println("Enter Y to turn on the LED:"); 
} 
void loop() { 
if (Serial.available())  {  
char ch = Serial.read();  
if (ch == 'y'||ch == 'Y')  
{  
digitalWrite(redLedPin, HIGH);  
Serial.println("You have turned on the LED!!");  
Serial.print("The LED was off for ");  
Serial.print(count);  
Serial.println(" seconds");  
Serial.println("If you want to switch it off, simply enter N or n!"); 
count = 0;  
}  
if (ch == 'n'||ch == 'N')  {  
digitalWrite(redLedPin, LOW);  
Serial.println("You have turned off the LED!!");  
Serial.print("The LED was on for ");  
Serial.print(count);  
Serial.println(" seconds");  
Serial.println("If you want to switch it on, simply enter Y or y!");  
count = 0;  
}  
}  
delay(1000);  count += 1; 
}

Compilazione e caricamento

Aprire l’IDE e selezionare il tipo di scheda e il tipo di porta corrispondenti alla propria scheda.

Dopo aver compilato lo sketch, è sufficiente fare clic sul pulsante “Upload” nell’ambiente. Attendere qualche secondo: si dovrebbero vedere lampeggiare i led RX e TX sulla scheda. Se il caricamento è riuscito, nella barra di stato apparirà il messaggio “Done uploading.”.

Pochi secondi dopo il termine del caricamento, fate clic sul pulsante più a destra della barra degli strumenti dell’IDE. Il pulsante è cerchiato qui sotto.

The following window will open.

Questa finestra si chiama Serial Monitor e fa parte del software IDE. Il suo compito è quello di consentire sia l’invio di messaggi dal computer alla scheda (tramite USB) sia la ricezione di messaggi dalla scheda stessa.

Analisi del codice

Il codice che utilizzeremo è ancora una volta molto semplice e ha lo scopo di mostrare le basi di come si può utilizzare il monitor seriale per visualizzare e inviare dati. Vi spiegherò ogni riga che stiamo usando e come potete utilizzarla nel vostro prossimo progetto per eseguire il debug o interagire con la scheda. Se volete scaricare subito il codice, potete farlo tramite il modulo  here.

Per iniziare, inizializziamo una variabile intera per il nostro LED, che è il numero del pin che porta al LED. Inizializziamo anche una variabile chiamata count, che memorizzerà il tempo di accensione e spegnimento del LED.

int redLedPin = 2;
int count = 0;

Nella funzione di impostazione impostiamo innanzitutto il LED rosso come uscita, in modo da poterlo spegnere e accendere.

Chiamiamo quindi la funzioneserial.beg con un valore di parametro pari a 9600. Il valore che impostiamo è noto come velocità di bits per second (baud) rate. Questo valore può essere impostato su diverse velocità, ma noi useremo 9600, che sembra essere il valore predefinito e funziona senza problemi con la maggior parte dei dispositivi. È molto importante impostare questa velocità, altrimenti non sarà possibile comunicare con la scheda.

Si attende quindi che l’interfaccia seriale si inizializzi e si connetta al computer/dispositivo. Quindi chiamiamo una funzione chiamataSerial.println(), che ci permette di stampare una riga sul monitor seriale. Si noterà che questa funzione stampa il testo e poi inizia una nuova riga per l’input/output successivo.

void setup() {
  pinMode(redLedPin, OUTPUT);
  Serial.begin(9600);
  while (! Serial);
  Serial.println("Enter Y to turn on the LED:");
}

Infine, c’è il loop, che continua a scorrere finché non viene caricato un nuovo programma o finché la scheda non viene spenta.

All’interno della funzione loop abbiamo un’istruzione if che controlla se ci sono dati in attesa nel buffer seriale (Serial.Available). In parole povere, stiamo controllando se abbiamo inviato un comando. Se ci sono dati, entriamo nell’istruzione if.

Quindi creiamo una variabile chiamataSerial.read()che ci fornirà i dati attualmente in attesa nel buffer seriale. Tenete presente che questa funzione ci fornirà solo il primo byte dei dati in arrivo sulla scheda. Se si desidera ottenere un’intera stringa, è necessario utilizzare qualcosa comeSerial.readString.

Se il byte di dati è y o n, inseriamo la relativa istruzione if. Qui noterete che cambiamo l’uscita del pin del LED in alta o bassa. Quindi stampiamo una serie di istruzioni. Serial.println stamperà i dati e passerà a una nuova riga, mentre Serial.print stamperà i dati ma rimarrà sulla stessa riga durante l’output. Si noterà anche che è possibile stampare variabili come l’esempio dicountex nel codice sottostante. In questo modo è possibile eseguire il debug dei valori durante l’elaborazione dei dati.

Infine, ritardo di un secondo e aggiungo 1 al conteggio. Questo è solo un esempio di aggiunta di dati a una variabile e di stampa attraverso l’uscita seriale.

void loop(){
  if (Serial.available()){
    char ch = Serial.read();
    if (ch == 'y' ||	ch == 'Y'){
      digitalWrite(redLedPin, HIGH);
      Serial.println("You have turned on the LED!!");
      Serial.print("The LED was off for ");
      Serial.print(count);
      Serial.println(" seconds");
      Serial.println("If you want to switch it off, simply enter N or n!");
      count = 0;
    }
    if (ch == 'n' ||	ch == 'N'){
      digitalWrite(redLedPin, LOW);
      Serial.println("You have turned off the LED!!");
      Serial.print("The LED was on for ");
      Serial.print(count);
      Serial.println(" seconds");
      Serial.println("If you want to switch it on, simply enter Y or y!");
      count = 0;
    }
  }
    delay(1000);
    count += 1;
}

Una volta terminato, si dovrebbe essere in grado di distribuire il codice sulla scheda. Nella prossima parte vi mostrerò come collegare, ricevere e inviare dati alla scheda.

Collegamento, ricezione e invio di dati alla scheda

Ora che il codice è stato caricato sulla scheda, dobbiamo aprire il monitor seriale. Si tratta di un’operazione abbastanza semplice e ci sono solo poche opzioni che dovrò spiegare.

Per aprire il monitor seriale, andare su Strumenti e selezionare Monitor seriale. In alternativa, anche CTRL+MAIUSC+M consente di aprire la stessa finestra. Assicuratevi di essere collegati alla scheda, altrimenti la finestra non si aprirà.

A questo punto si dovrebbe aprire una finestra simile a quella qui sotto.
Nella parte superiore della schermata dovrebbe essere presente un’area di immissione. Qui è possibile digitare e inviare il testo alla lavagna. Per inviare il testo digitato è sufficiente premere il pulsante di invio.

In basso si trova la finestra di output, dove vengono visualizzati tutti i dati inviati. Se si utilizza il codice di esempio sopra riportato, si potrà vedere il testo contenuto nelle funzioni Serial.println.

In fondo abbiamo 3 diverse opzioni. La prima è abbastanza autoesplicativa: lo scorrimento automatico disabilita e abilita lo scorrimento automatico della casella di output.

La seconda è l’opzione di fine riga. È possibile impostare il monitor in modo che aggiunga automaticamente un finale di riga dopo ciò che viene immesso/inviato alla scheda.

In terzo luogo, abbiamo la velocità di trasmissione di cui ho parlato sopra. Assicurarsi che corrisponda a quella impostata nel codice. Se è diversa, il testo in uscita apparirà incomprensibile. Se si ricevono messaggi incomprensibili, la causa è probabilmente questa.

Questo è sostanzialmente tutto ciò che occorre sapere per comprendere le basi del monitor seriale. Ci sono altre cose che si possono imparare, come l’uso delle stringhe attraverso l’interfaccia seriale e altro ancora, ma probabilmente questo è tutto ciò che dovete sapere per ora.

Spero che ora abbiate capito come utilizzare correttamente il monitor seriale e che vi sia d’aiuto nei futuri progetti per Arduino. Se ho tralasciato qualcosa, se ho sbagliato qualcosa, se avete commenti o altro, lasciate pure un commento qui sotto.