Archivi tag: loop

Arduino: cicli infiniti ed uscita da un ciclo infinito

Per rispondere ad un quesito che mi è stato posto questa mattina a lezione da alcuni allievi condivido questo breve approfondimento sulla gestione dei cicli infiniti.

Parliamo di un ciclo infinito quando il controllo entra nel corpo del ciclo e non esce mai da esso, ciò accade quando la condizione di test del loop non è mai false.

Possiamo realizzare un ciclo infinito in C in diversi modi:

for (int i = 0; i >= 0; )
{
    // corpo del ciclo in cui la variabile i non viene mai modificata
}

Nell’esempio la variabile i viene inizializzata a 0 e la condizione di controllo i>=0 all’inizio è vera. La variabile i non viene modificato in nessun punto del codice inoltre l’espressione di aggiornamento della variabile non è presente, ciò implica che i avrà sempre come valore 0 e la condizione di controllo i>=0 non è mai falsa e quindi il corpo del for viene eseguito ad ogni ciclo.

Un modo più sintetico per realizzare un ciclo infinito è quello di utilizzare una condizione sempre vera utilizzando l’istruzione while:

while (true)
{
    // corpo del while
}

Questo comportamento può essere realizzato anche scrivendo 1 per indicare “condizione sempre vera”.

while (1)
{
    // corpo del while ripetuto per sempre
}

o ancora utilizzando un’uguaglianza sempre vera:

while (3==3)
{
    // corpo del while ripetuto per sempre
}

che nella programmazione con Arduino può essere ottenuto anche con:

while (HIGH)
{
    // corpo del while ripetuto per sempre
}

E’ possibile realizzare un ciclo infinito anche con l’istruzione for omettendo la condizione di ripetizione del ciclo, cioè che bisognerebbe inserire tra i due punti e virgola.

for (;;)
{
    // corpo del for ripetuto per sempre
}

Terminare un ciclo infinito

Negli esempi visti precedentemente la condizione sempre vera causava la ripetizione infinita del corpo dell’istruzione, però esiste il modo per terminare un ciclo infinito utilizzando l’istruzione break usata appunto per uscire da un ciclo: for, while oppure do..while, ma anche per uscire da una istruzione switch case.

Poiché nelle nostre sperimentazioni utilizziamo Arduino vediamo come realizzare l’uscita da un loop infinito.

Lo scopo è quello di far lampeggiare ripetutamente un LED e bloccare il lampeggio con la pressione di un pulsante.

Realizzimo il seguente circuito:

Utilizzando l’istruzione while.

Esempio 1

/*
  Prof. Michele Maffucci
  Data: 16.11.2020
  Esempio1: Funzionamento dell'istruzione break
*/
const int pinPulsante = 8; // pin digitale 8

void setup()
{
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT); // abilita il pin a cui è connesso il LED come output
  pinMode(pinPulsante, INPUT);  // abilita il pin a cui è connesso il pulsante come input
}
void loop()
{
  while (true) // ciclo infinito
  {
    if (digitalRead(pinPulsante) == HIGH)
    {
      break; // esce dal ciclo se si preme il pulsante
    }
    lampeggio(); // chiama la funzione che accende e spegne il LED
  }
}
void lampeggio()
{
  digitalWrite(LED_BUILTIN, HIGH);
  delay(100);
  digitalWrite(LED_BUILTIN, LOW);
  delay(100);
}

Come si può notare viene utilizzata l’istruzione break per uscire dal ciclo. Fino a quando il pulsante non sarà premuto la condizione: digitalRead(pinPulsante) == HIGH sarà falsa, pertanto non verrà eseguito il corpo dell’if e quindi non potrà essere eseguito il break, in questa condizione ciò che segue l’if è la chiamata della funzione lampeggia().

Nel caso in cui il pulsante viene premuto, la condizione digitalRead(pinPulsante) == HIGH risulta vera, pertanto viene eseguito il corpo dell’if che contiene l’istruzione break che causerà l’uscita dal ciclo while.

Il codice sopra indicato funziona anche se nel while viene sostituito true con HIGH:

...
while (true) // ciclo infinito
  {
       // corpo del while
  }
...

con

...
while (HIGH) // ciclo infinito
  {
       // corpo del while
  }
...

Come spiegato ad inizio lezione, un ciclo infinito può essere ottenuto anche con un’istruzione for quindi si ottiene il medesimo risultato se si utilizza il codice che segue.

Esempio 2

/*
  Prof. Michele Maffucci
  Data: 16.11.2020
  Funzionamento dell'istruzione break
*/
const int pinPulsante = 8; // pin digitale 8

void setup()
{
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT); // abilita il pin a cui è connesso il LED come output
  pinMode(pinPulsante, INPUT);  // abilita il pin a cui è connesso il pulsante come input
}
void loop()
{
  for (;;) // ciclo infinito
  {
    if (digitalRead(pinPulsante) == HIGH)
    {
      break; // esce dal ciclo se si preme il pulsante
    }
    lampeggio(); // chiama la funzione che accende e spegne il LED
  }
}
void lampeggio()
{
  digitalWrite(LED_BUILTIN, HIGH);
  delay(100);
  digitalWrite(LED_BUILTIN, LOW);
  delay(100);
}

Differenze tra ciclo for e ciclo while

  • Il ciclo for ha necessità di una variabile al suo interno, mente il ciclo while può utilizzare qualsiasi variabile definita prima dell’istruzione while.
  • L’uso del ciclo do-while permette di realizzare sempre una volta il corpo delle istruzioni in esso contenuto (indipendentemente dall’espressione condizionale) e ciò non può essere fatto con un  ciclo for.

Esercizio per i miei studenti

Esercizio 1

Realizzare le stesse funzionalità dell’esempio precedente (usando un ciclo infinito nel loop()) aggiungendo la stampa sequenziale crescente di un numero n = n + 1 sulla Serial Monitor. Alla pressione del pulsante si interrompe il lampeggio del LED e si azzera il contatore.

Buon Coding a tutti 🙂

Evitare il loop di messaggi inviati sulla Serial Monitor

Con questo post rispondo ad alcuni miei studenti su quesiti posti sull’uso di Arduino durante il ripasso condotto in questi giorni sulla modalità di stampa di messaggi sulla Serial Monitor.

L’esercizio assegnato consisteva nella tipica accensione e spegnimento di un LED mediante un pulsante con antirimbalzo software, nella seconda parte bisognava aggiungere un secondo pulsante che permetteva di accendere e spegnere un secondo LED e nella terza fase segnalare l’accensione e lo spegnimento sulla Serial Monitor mediante i messaggi:

“LED Rosso ON”
“LED Rosso OFF”
“LED Verde ON”
“LED Verde OFF”

Qundi per ciascun LED, alla prima pressione del pulsante accensione del LED e segnalazione ON sulla Serial, alla seconda pressione del pulsante segnalazione OFF sulla Serial e spegnimento del LED, ovviamente senza alcun limite sul numero di pressioni sui pulsanti.

Gli studenti sono riusciti a realizzare lo sketch ma con il solito problema di ripetizione in loop del testo di segnalazione sulla Serial.

Il problema può essere superato utilizzando un codice simile al seguente:

int stampaMessaggio = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  if(!stampaMessaggio)
  {
     Serial.println(“Qualsiasi testo da stampare una sola volta…“);
     stampaMessaggio = 1;
  }
}

Nel primo ciclo di loop la condizione dell’if risulterà vera e ciò permetterà l’esecuzione della stampa del testo,  successivamente impostata la variabile “stampaMessaggio” ad 1 non sarà più possibile stampare il testo al ciclo di loop successivo in quanto “!stampaMessaggio” risulterà uguale a 0.

Di seguito le due soluzioni, la prima con testo in loop sulla Serial, mentre la seconda con testo NON in loop.

Al fondo del post un esercizio aggiuntivo per i miei studenti.

All’interno del codice la spiegazione del funzionamento.

Soluzione con testo di output in loop

/*
   Prof. Michele Maffucci
   Accensione e spegnimento
   23.09.19

   Accensione e spegnimento di LED mediante pulsanti
   con antirimbalzo e messaggio ripetuto dello stato del LED
   sulla Serial Monitor

   Pulsante Rosso: accensione e spegnimento LED Rosso
   (prima pressione accende, seconda pressione spegne)

   Pulsante Verde: accensione e spegnimento LED Verde
   (prima pressione accende, seconda pressione spegne)

*/

// ledRosso variabile di tipo intero a cui viene assegnato
// il valore intero 5 che sarà associato al pin digitale 5

int ledRosso = 5;

// ledVerde variabile di tipo intero a cui viene assegnato
// il valore intero 4 che sarà associato al pin digitale 4

int ledVerde = 4;


// pulsanteRosso variabile di tipo intero a cui viene assegnato
// il valore intero 7 che sarà associato al pin digitale 7
// a cui sarà collegato il pulsante che comanda il LED Rosso

int pulsanteRosso = 7;

// pulsanteVerde variabile di tipo intero a cui viene assegnato
// il valore intero 6 che sarà associato al pin digitale 6
// a cui sarà collegato il pulsante che comanda il LED Verde

int pulsanteVerde = 6;

// inizializzazione della variabili in cui verrà memorizzato il valore della
// digitalRead: 0 non premuto, 1 premuto

int valRosso = 0;
int valVerde = 0;

// inizializzazione della variabili in cui verrà memorizzato lo stato del pulsante
// All'avvio dello sketch i pulsanti non sono premuti

int statoRosso = 0;
int statoVerde = 0;

// inizializzazione della variabili in cui verrà memorizzato lo stato precedente del pulsante
// All'avvio dello sketch i pulsanti non sono premuti

int valRossoOld = 0;
int valVerdeOld = 0;

void setup() {
  pinMode(ledRosso, OUTPUT);           // imposta il pin digitale come output
  pinMode(ledVerde, OUTPUT);           // imposta il pin digitale come output
  pinMode(pulsanteRosso, INPUT);       // imposta il pin digitale come input
  pinMode(pulsanteVerde, INPUT);       // imposta il pin digitale come input

  Serial.begin(9600);                 // imposta la velocità di scrittura della serial monitor
}

void loop() {

  valRosso = digitalRead(pulsanteRosso);  // lettura dell'input (pulsante) e memorizzazione in valRosso
  valVerde = digitalRead(pulsanteVerde);  // lettura dell'input (pulsante) e memorizzazione in valVerde

  // ---------- Controllo pulsante LED Rosso ----------

  if ((valRosso == HIGH) && (valRossoOld == LOW)) {
    statoRosso = 1 - statoRosso;

    // antirimbalzo software - attesa di 15 ms per attendere che l'input si stabilizzi
    delay(15);
  }


  // memorizzazione del valore precedente restituito dalla digitalRead

  valRossoOld = valRosso;

  // ---------- Controllo pulsante LED Verde ----------

  // viene controllato che l'input sia HIGH (pulsante premuto) e cambia lo stato del LED

  if ((valVerde == HIGH) && (valVerdeOld == LOW)) {
    statoVerde = 1 - statoVerde;

    // antirimbalzo software - attesa di 15 ms per attendere che l'input si stabilizzi

    delay(15);

    // memorizzazione del valore precedente restituito dalla digitalRead
  }
  
  valVerdeOld = valVerde;

  // ---------- Stampa sulla Serial Monitor dello stato del LED Rosso ----------

  // Se il pulsante è stato premuto la condizione dell'if risulta vera ed il LED Rosso si accende

  if (statoRosso == 1) {
    digitalWrite(ledRosso, HIGH);
    Serial.println("LED Rosso ON");
  }

  // nel caso in cui il pulsante non sia premuto o nello stato precedente era stato premuto
  // allora il LED dovrà essere spento ed il messaggio sulla seriale dovrà essere "LED Rosso OFF"

  else {
    digitalWrite(ledRosso, LOW);
    Serial.println("LED Rosso OFF");
  }

  // ---------- Stampa sulla Serial Monitor dello stato del LED Verde ----------

  // Se il pulsante è stato premuto la condizione dell'if risulta vera ed il LED Verde si accende

  if (statoVerde == 1) {
    digitalWrite(ledVerde, HIGH);
    Serial.println("LED Verde ON");
  }

  // nel caso in cui il pulsante non sia premuto o nello stato precedente era stato premuto
  // allora il LED dovrà essere spento ed il messaggio sulla seriale dovrà essere "LED Verde OFF"

  else {
    digitalWrite(ledVerde, LOW);
    Serial.println("LED Verde OFF");
  }
}

Soluzione con testo di output NON in loop

/*
   Prof. Michele Maffucci
   Data: 23.09.19
   
   Accensione e spegnimento di LED mediante pulsanti
   con antirimbalzo e messaggio NON ripetuto dello stato del LED
   sulla Serial Monitor
   
   Stampa 1 sola volta il messaggio dello stato del LED sulla Serial Monitor
   (non va in loop la stampa dello stato del LED)
   
   Pulsante Rosso: accensione e spegnimento LED Rosso
   (prima pressione accende, seconda pressione spegne)
   
   Pulsante Verde: accensione e spegnimento LED Verde
   (prima pressione accende, seconda pressione spegne)   
  
*/

// ledRosso variabile di tipo intero a cui viene assegnato 
// il valore intero 5 che sarà associato al pin digitale 5 

int ledRosso = 5;

// ledVerde variabile di tipo intero a cui viene assegnato
// il valore intero 4 che sarà associato al pin digitale 4 

int ledVerde = 4;


// pulsanteRosso variabile di tipo intero a cui viene assegnato
// il valore intero 7 che sarà associato al pin digitale 7
// a cui sarà collegato il pulsante che comanda il LED Rosso 

int pulsanteRosso = 7;

// pulsanteVerde variabile di tipo intero a cui viene assegnato
// il valore intero 6 che sarà associato al pin digitale 6
// a cui sarà collegato il pulsante che comanda il LED Verde 

int pulsanteVerde = 6;

// inizializzazione della variabili in cui verrà memorizzato il valore della
// digitalRead: 0 non premuto, 1 premuto

int valRosso = 0;
int valVerde = 0;

// inizializzazione della variabili in cui verrà memorizzato lo stato del pulsante
// All'avvio dello sketch i pulsanti non sono premuti

int statoRosso = 0;
int statoVerde = 0;

// inizializzazione della variabili in cui verrà memorizzato lo stato precedente del pulsante
// All'avvio dello sketch i pulsanti non sono premuti

int valRossoOld = 0;
int valVerdeOld = 0;

// inizializzazione delle variabili che consentono la stampa dello stato del LED

int stampoRossoON = 0;
int stampoRossoOFF = 0;

int stampoVerdeON = 0;
int stampoVerdeOFF = 0;

void setup() {
  pinMode(ledRosso, OUTPUT);           // imposta il pin digitale come output
  pinMode(ledVerde, OUTPUT);           // imposta il pin digitale come output
  pinMode(pulsanteRosso, INPUT);       // imposta il pin digitale come input
  pinMode(pulsanteVerde, INPUT);       // imposta il pin digitale come input
  
  Serial.begin(9600);                 // imposta la velocità di scrittura della serial monitor
  Serial.println("Avvio programma");  // stampa la stringa tra le " e va a campo
  Serial.println("---------------");  // stampa la stringa tra le " e va a campo
}

void loop() {

  valRosso = digitalRead(pulsanteRosso);  // lettura dell'input (pulsante) e memorizzazione in valRosso
  valVerde = digitalRead(pulsanteVerde);  // lettura dell'input (pulsante) e memorizzazione in valVerde

// ---------- Controllo pulsante LED Rosso ----------
 
  // viene controllato che l'input sia HIGH (pulsante premuto) e cambia lo stato del LED
  
  if ((valRosso == HIGH) && (valRossoOld == LOW)) {
    statoRosso = 1 - statoRosso;

    // antirimbalzo software - attesa di 15 ms per attendere che l'input si stabilizzi
    delay(15);

    // poichè il pulsante è stato premuto la variabile stampoRossoON viene posta a 0
    // per consentire la stampa del messaggio "LED Rosso ON"
    
    stampoRossoON = 0;
  }

  // memorizzazione del valore precedente restituito dalla digitalRead
  
  valRossoOld = valRosso;

// ---------- Controllo pulsante LED Verde ----------

  // viene controllato che l'input sia HIGH (pulsante premuto) e cambia lo stato del LED

  if ((valVerde == HIGH) && (valVerdeOld == LOW)) {
    statoVerde = 1 - statoVerde;

    // antirimbalzo software - attesa di 15 ms per attendere che l'input si stabilizzi
    
    delay(15);

    // poichè il pulsante è stato premuto la variabile stampoVerdeON viene posta a 0
    // per consentire la stampa del messaggio "LED Verde ON"
    
    stampoVerdeON = 0;
  }

  // memorizzazione del valore precedente restituito dalla digitalRead
  
  valVerdeOld = valVerde;

// ---------- Stampa sulla Serial Monitor dello stato del LED Rosso ----------

// Se il pulsante è stato premuto la condizione dell'if risulta vera ed il LED Rosso si accende

  if (statoRosso == 1) {
    digitalWrite(ledRosso, HIGH);

    // Se la variabile stampoRossoON è 0 allora !stampoRossoON vale 1
    // ciò consente la stampa del messaggio "LED Rosso ON"
    
    if (!stampoRossoON) {
      Serial.println("LED Rosso ON");

      // Per evitare una stampa continua del messaggio viene posto ad 1 stampoRossoON
      // in modo che nel ciclo di loop successivo non venga più stampato il messaggio
      // "LED Rosso ON". Viene posto a 0 stampoRossoOFF per consentire la stampa "LED Rosso OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Rosso.
      
      stampoRossoON = 1;
      stampoRossoOFF = 0;     
    }
  }

  // nel caso in cui il pulsante non sia premuto o nello stato precedente era stato premuto
  // allora il LED dovrà essere spento ed il messaggio sulla seriale dovrà essere "LED Rosso OFF"
  
  else {
    digitalWrite(ledRosso, LOW);

    if (!stampoRossoOFF) {
      Serial.println("LED Rosso OFF");

      // Per evitare una stampa continua del messaggio viene posto ad 0 stampoRossoON
      // in modo che nel ciclo di loop successivo non venga più stampato il messaggio
      // "LED Rosso OFF". Viene posto a 1 stampoRossoOFF per consentire la stampa "LED Rosso OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Rosso.
      
      stampoRossoON = 0;
      stampoRossoOFF = 1;  
    }
  }

// ---------- Stampa sulla Serial Monitor dello stato del LED Verde ----------

// Se il pulsante è stato premuto la condizione dell'if risulta vera ed il LED Verde si accende

  if (statoVerde == 1) {
    digitalWrite(ledVerde, HIGH);

    // Se la variabile stampoVerdeON è 0 allora !stampoVerdeoON vale 1
    // ciò consente la stampa del messaggio "LED verde ON"
    
    if (!stampoVerdeON) {
      Serial.println("LED Verde ON");

      // Per evitare una stampa continua del messaggio viene posto ad 1 stampoVerdeON
      // in modo che nel ciclo di loop successivo non venga più stampato il messaggio
      // "LED Verde ON". Viene posto a 0 stampoVerdeOFF per consentire la stampa "LED Verde OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Rosso.
            
      stampoVerdeON = 1;
      stampoVerdeOFF = 0; 
    }
  }

  // nel caso in cui il pulsante non sia premuto o nello stato precedente era stato premuto
  // allora il LED dovrà essere spento ed il messaggio sulla seriale dovrà essere "LED Verde OFF"
  
  else {
    digitalWrite(ledVerde, LOW);

    if (!stampoVerdeOFF) {
      Serial.println("LED Verde OFF");

      // Per evitare una stampa continua del messaggio viene posto ad 0 stampoVerdeON
      // in modo che nel ciclo di loop successivo non venga più stampato il messaggio
      // "LED Verde OFF". Viene posto a 1 stampoVerdeOFF per consentire la stampa "LED Verde OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Verde.
      
      stampoVerdeON = 0;
      stampoVerdeOFF = 1; 
    }
  }
}

Esercizio: implementare il controllo della marci e dell’arresto di un motore

Realizzare un circuito in cui con tre pulsanti vengono identificate le tre situazioni:

  1. Marcia
  2. Arresto
  3. Anomalia

Associare ad ogni situazione il colore del LED:

  1. Rosso: marcia
  2. Verde: arresto
  3. Giallo: anomalia

Alla pressione del corrispondente pulsante mostrare sulla Serial Monitor :

  1. Motore in marcia
  2. Motore fermo
  3. Anomalia motore

Buon lavoro 🙂