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 🙂

5 minuti da Maker: porta rasoio

Sulla mia pagina Facebook pubblico spesso alcuni brevi post che ho intitolato: 5 minuti da Maker, attività di Making familiare che risolvono qualche piccola necessità, che rispondono a piccole problemi del vivere quotidiano. E’ un esercizio che mi piace svolgere quando ho il bisogno di distrarmi un momento da un lavoro che mi stanca parecchio. L’idea nasce da una sperimentazione di qualche tempo fa che feci con alcuni allievi: una challenge di breve durata, non più di 30 minuti, in cui bisogna risolvere un problema pratico. Tipicamente si tratta di riparare o inventare un oggetto da stampare in 3D oppure riadattare oggetti per usi diversi o ancora migliorare le caratteristiche di un oggetto secondo le necessità specifiche dell’utente sia dal punto di vista meccanico che elettronico.

L’ultima challenge svolta su me stesso nasce dal seguente fatto:

Figlio: papà perché mi rubi le lamette da barba!
Io: No giovane figlio! Sei tu che rubi le MIE lamette!
Figlio: No no diversamente giovane! Sei tu tu tu tu tuuuuu!!!!
Moglie: forse essere più ordinati aiuterebbe? Visto che siete in bagno a chi tocca pulirlo oggi?
Io: Shhh Matty… pace pace pace …. ci penso io faccio due supporti per rasoio

🙂

Per prelevare i file per la stampa 3D seguire il link sulla mia pagina su Thingiverse.

Buon Making a tutti 🙂

Arduino: strutturare il codice in blocchi funzionali

Molto spesso durante le prime fasi di realizzazione di uno sketch Arduino si tende a non strutturare il proprio programma in blocchi funzionali separati, tutto il codice viene inserito all’interno del loop(). Questo tipo di approccio, soprattutto se siamo in presenza di un codice molto lungo, rende difficoltosa la lettura del programma da parte di altre persone e non permette una facile comprensione del funzionamento o l’identificazione di possibili errori.

Ho parlato in passato come strutturare il codice in blocchi funzionali nel post:
Arduino – lezione 07: lavorare con gruppi di valori e funzioni esterne, ma in quella lezione utilizzavo istruzioni che in questa fase dell’anno scolastico non sono ancora conosciute da alcuni allievi soprattutto del 3′ anno, che iniziano ad utilizzare Arduino, pertanto la presente lezione dovrebbe chiarire in modo più semplice l’argomento.

Le funzioni vengono utilizzate per organizzare le azioni eseguite dal vostro programma. Ogni funzione può essere identificata da un’azione specifica richiamata dal programma principale loop(), oppure richiamate da altre funzioni sempre all’interno del nostro sketch.

Senza saperlo quando avete iniziato a programmare con Arduino avete utilizzato delle funzioni: loop() e setup() le due funzioni sempre presenti in ogni sketch.

Per creare una funzione bisogna:

  • definire il tipo di valore restituito dalla funzione;
  • assegnare un nome alla funzione;
  • e opzionalmente impostare una serie di parametri che la funzione riceverà quando viene chiamata (si dice anche invocata).

Creiamo una semplice funzione che permette di fare lampeggiare un LED, non possiede parametri e non restituisce nessun valore.
Assegnare alla funzione il tipo void vuol dire che non restituisce nulla e non inserire nulla tra le parentesi tonde indica che la funzione non accetta nessun parametro.

Esempio 1

// Prof. Michele Maffucci
// Es.01 - Usare le funzioni
// Data: 15.11.2020

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  lampeggia();
}

// blink LED una volta
void lampeggia()
{
  digitalWrite(LED_BUILTIN, HIGH); // accende il LED
  delay(1000); // pausa di 1 secondo
  digitalWrite(LED_BUILTIN, LOW); // spegne il LED
  delay(1000); // pausa di 1 secondo
}

Ogni volta che il loop() chiama (invoca) la funzione esterna lampeggia() viene effettuato il blink del LED sulla scheda.

Esempio 2

Realizziamo ora un secondo esempio in cui la funzione “lampeggia” accetta come parametro un valore intero che definisce il delay da impostare all’interno del funzione.

// Prof. Michele Maffucci
// Es.02 - Usare le funzioni
// Data: 15.11.2020

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  lampeggia(250);
}

// blink LED una volta
// per far si che la funzione accetti un parametro in input
// bisogna dichiarare il tipo del parametro in ingresso
// nella funzione lampeggia: int pausa

void lampeggia(int pausa)
{
  digitalWrite(LED_BUILTIN, HIGH); // accende il LED
  delay(pausa); // pausa: valore inserito nella variabile "pausa"
  digitalWrite(LED_BUILTIN, LOW); // spegne il LED
  delay(pausa); // pausa: valore inserito nella variabile "pausa"
}

Esempio 3

Realizziamo ora un terzo sketch in cui i parametri di ingresso per la funzione lampeggia() sono due, uno che definisce il tempo di accensione del LED ed uno che definisce il tempo di spegnimento del LED:

// Prof. Michele Maffucci
// Es.03 - Usare le funzioni
// Data: 15.11.2020

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  lampeggia(250, 1000);
}

// blink LED una volta
// per far si che la funzione accetti duen parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn e int pausaOff

void lampeggia(int pausaOn, int pausaOff)
{
  digitalWrite(LED_BUILTIN, HIGH); // accende il LED
  delay(pausaOn); // delay LED ON
  digitalWrite(LED_BUILTIN, LOW); // spegne il LED
  delay(pausaOff); // delay LED OFF
}

Esempio 4

Definiamo ora una funzione che ha 3 parametri di ingresso: il tempo in cui il LED rimane acceso, il tempo in cui il LED rimane spento e il numero di volte (cicli) che deve ripetersi il lampeggio, al termine del numero di cicli il LED non lampeggerà più. Come specificato nei commenti la variabile chiave verrà utilizzata per eseguire una volta sola la chiamata della funzione lampeggio:

// Prof. Michele Maffucci
// Es.04 - Usare le funzioni
// Data: 15.11.2020

// chiave e la variabile che consente l'esecuzione della
// chiamata della funzione lampegga una sola volta
int chiave = 0;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  if (chiave == 0) {
    chiave = 1;
    lampeggia(250, 1000, 5);
  }
}

// blink LED una volta
// per far si che la funzione accetti tre parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn, int pausaOff, int contatore
// la variabile contatore definisce il numero di cicli di lampeggio

void lampeggia(int pausaOn, int pausaOff, int contatore)
{
  for (int i = 0; i < contatore; i++) {
    digitalWrite(LED_BUILTIN, HIGH); // accende il LED
    delay(pausaOn); // delay LED ON
    digitalWrite(LED_BUILTIN, LOW); // spegne il LED
    delay(pausaOff); // delay LED OFF
  }
}

All’interno dello sketch precedente la funzione lampeggio utilizza un ciclo for per ripetere, per il numero di volte specificato dalla variabile contatore, il codice di accensione e spegnimento (corpo del for).

Esempio 5

Per completezza e per richiamare il modo con cui utilizzare l’istruzione while, di seguito trovate lo sketch che realizza la medesima funzionalità dello sketch precedente in cui il ciclo for viene sostituito da un while:

// Prof. Michele Maffucci
// Es.05 - Usare le funzioni
// Data: 15.11.2020

// chiave e la variabile che consente l'esecuzione della
// chiamata della funzione lampegga una sola volta
int chiave = 0;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  if (chiave == 0) {
    chiave = 1;
    lampeggia(250, 1000, 5);
  }
}

// blink LED una volta
// per far si che la funzione accetti tre parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn, int pausaOff, int contatore
// la variabile contatore definisce il numero di cicli di lampeggio

void lampeggia(int pausaOn, int pausaOff, int contatore)
{
  while (contatore > 0) {
     digitalWrite(LED_BUILTIN, HIGH); // accende il LED
    delay(pausaOn); // delay LED ON
    digitalWrite(LED_BUILTIN, LOW); // spegne il LED
    delay(pausaOff); // delay LED OFF
    contatore = contatore - 1; // decremento del contatore
  }
}

Esempio 6

Nello sketch che segue realizziamo una funzione che accetta un parametro e restituisce un valore. Il parametro che viene passato alla funzione definisce la durata dei tempi di accensione e spegnimento del LED (in millisecondi). La funzione continua a far lampeggiare un LED fino a quando non viene premuto un pulsante. Il valore restituito dalla funzione è il numero di lampeggi effettuati, questo valore verrà stampato sulla Serial Monitor:

// Prof. Michele Maffucci
// Es.06 - Usare le funzioni
// Data: 15.11.2020

const int pinPulsante = 8; // pin a cui colleghiamo il pulsante

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(pinPulsante, INPUT);
  Serial.begin(9600);
}

void loop() {
  Serial.println("Premere il pulsante per interrompere il lampeggio");
  int contatore = lampeggia(500); // lampeggio del LED: 500 ms ON e 500 ms OFF
  Serial.print("Il numero di volte in cui il LED ha lampeggiato è stato di: ");
  Serial.println(contatore);
  while (digitalRead(pinPulsante) == HIGH)
  {
    // non viene fatto nulla fino a quando non rilascio il pulsante
  }
}

// la funzione fa lampeggiare il LED per un periodo specificato (int periodo)
// e restituisce il numero di volte in cui il LED ha lampeggiato

int lampeggia(int periodo)
{
  int contatoreLampeggio = 0;

  while (digitalRead(pinPulsante) == LOW)
    // ripetere finché non viene premuto il pulsante
    // cicla fino a quando il pulsante non viene premuto
  {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(periodo);
    digitalWrite(LED_BUILTIN, LOW);
    delay(periodo);
    contatoreLampeggio = contatoreLampeggio + 1; // incrementa il contatore
  }
  // in questo punto vuol dire che pinPulsante è HIGH
  // ciò vuol dire che il pulsante è premuto

  // contatoreLampeggio è il valore che viene restituito alla funzione chiamante
  return contatoreLampeggio;
}

Il tipo di dato che precede in nome della funzione:

int lampeggia()

indica il tipo di dato restituito dalla funzione. Ricordarsi che nella funzione chiamante, nel nostro caso il loop(), quando chiamiamo la funzione questa deve terminare con un punto e virgola:

int contatore = lampeggia(500);

Errori comuni che vengono commessi nella chiamata di funzioni

Rimando a queste due brevi note che mostrano alcuni errori tipici:

Buon Making a tutti 🙂

Esercizi per i miei studenti

Esercizio 1

Realizzare un circuito costituito da 4 pulsanti e 4 led, connessi ad Arduino.

  • Alla pressione del pulsante P1 il LED1 effettua il blink con un tempo di 200 ms
  • Alla pressione del pulsante P2 il LED2 effettua il blink con un tempo di 400 ms
  • Alla pressione del pulsante P3 il LED3 effettua il blink con un tempo di 600 ms
  • Alla pressione del pulsante P4 il LED4 effettua il blink con un tempo di 800 ms

Fare in modo tale che ci sia una funzione esterna, chiamata dal loop(), che effettui il blink dei led.

Esercizio 2

Aggiungere all’esercizio 1 un pulsante che se premuto accende in sequenza ripetuta i 4 led. L’accensione in sequenza deve avvenire chiamando una funzione esterna al loop().

Arduino: tipi di dati – ripasso

Noto che durante le sperimentazioni condotte dagli allievi, l’uso dei tipi di dati provoca alcune incertezze, pertanto ho pensato di aggiungere a quanto già pubblicato in passato, una tabella riepilogativa da prendere come riferimento durante le eseritazioni aggiungendo inoltre qualche precisazione. Noto che nella dichiarazione di variabili la scelta più comune del tipo di dato utilizzato è l’int (intero), però molto spesso può essere non necessario o addirittura può aggiungere imprecisioni o errori.

Sebbene il tipo di dati int (abbreviazione di intero) sia la scelta più comune per valori numerici incontrati nelle applicazioni Arduino, è possibile utilizzare le tabelle che segue per determinare il tipo di dati più opportuno, che si adatta all’intervallo di valori previsto dal vostro programma. La tabella mostra i tipi di dati per le schede a 8 bit come Arduino UNO R3.

Tipo di dato

Byte

Intervallo

Uso

int 2 –32768 a 32767 Rappresenta valori interi positivi e negativi.
unsigned int 2 0 a 65535 Rappresenta solo valori interi positivi.
long 4 –2147483648 a 2147483647 Rappresenta un intervallo di interi negativi e positivi molto più estesa rispetto agli int.
unsigned long 4 0 a 4294967295 Rappresenta solo valori interi positivi con intervallo più ampio degli unsigned int.
float 4 3.4028235E+38 a –3.4028235E+38 Rappresenta numeri con la virgola, da utilizzare per rappresentare e approssimare valori che giungono dal mondo reale.
double 4 Come i float In Arduino, double ha lo stesso utilizzo e significato di float, un sinonimo (ciò non è vero per schede a 32 bit).
bool 1 TRUE (1) o FALSE (0) Rappresenta valori veri o falsi.
char 1 –128 a 127 Rappresenta un singolo carattere. Può anche rappresentare un intero con segno compreso tra –128 e 127.
byte 1 0 a 255 Simile al tipo char, ma per valori senza segno.
String Rappresenta una sequenza di caratteri tipicamente utilizzata per contenere il una stringa di testo.
void Utilizzato solo nelle dichiarazioni di funzione in cui non viene restituito alcun valore.

In generale, come potete vedere anche negli sketch di esempio presenti nell’IDE di Arduino, gran parte delle variabli utilizzate è di tipo int, inoltre se non è richiesta la massima efficienza della memoria di Arduino l’uso di int non è un errore, ma ovviamente il tipo int può essere utilizzato solo se i valori che state gestendo non superano l’intervallo degli int e non è necessario lavorare con numeri decimali.

Certamente molto spesso è necessario utilizzare un tipo di dato specifico per la propria applicazione, ciò accade quando ad esempio utilizziamo specifiche funzioni di libreria che restituiscono valori che non appartengono all’intervallo del tipo int.

A scopo di esempio considerate la funzione millis che restituisce il numero di millisecondi trascorsi dall’avvio del programma.

unsigned long ora;

void setup() {
  // inizializzazione della erial Monitor
  Serial.begin(9600);
}
void loop() {
  Serial.print("Ora: ");
  ora = millis();

  Serial.println(ora); // stampa l'ora (in millisecondi) dall'avvio dello sketch
  delay(1000);         // attesa di un secono, viene utilizzato per non stampare
                       // velocemente una grande quantità di valori sulla Serial Monitor
}

Il tipo di valore restituito, come indicato nel reference, è un unsigned long valori compresi tra 0 e 4294967295.

Se usate un tipo int su una scheda a 8 bit per memorizzare un valore restituito da millis() non riceverete un messaggio di errore dal compilatore, ma verranno restituiti valori numerici sbagliati perché un int non è abbastanza grande da contenere il valore massimo di un unsigned long. Se provate a cambiare tipo nello sketch indicato sopra vedrete che dopo aver raggiunto il valore 32.767, il conteggio passerà a -32768.

Se invece provate a sostituire un long, –2147483648 a 2147483647 con un
unsigned int (intero senza segno) 0 a 65535, tornerete a zero dopo aver superato il massimo massimo (65535).

Alcune precisazioni

  • Durante le vostre sperimentazioni avrete bisogno a volte di valori con segno e a volte no, ecco perché sono stati resi disponibili tipi di dati con segno (signed) e senza segno (unsigned). I valori senza segno sono sempre positivi;
  • tutti i tipi che NON recano davanti la parola: unsigned possono assumere valori negativi e positivi;
  • una variabile senza segno (unsigned) può memorizzare il doppio dei valori numerici di una variabile con segno (signed);
  • nella notazione è esplicitato sempre quando la variabile è di tipo unsigned perché in questo modo viene reso evdente che quella variabile non assume valori negativi.

Dalla tabella si può notare che i tipi bool (booleani) hanno due possibili valori: vero o falso. Questo tipo di dato viene utilizzato in genere per memorizzare valori che rappresentano una condizione ON/OFF oppure in altro modo SI/NO.

Potresete vedere tipi booleani utilizzati al posto delle costanti HIGH e LOW utilizzati all’interno ad esempio di una digitalWrite() per impostare l’uscita di un pin digitale, qundi le scritture:

digitalWrite(pinLed,HIGH);
e
digitalWrite(pinLed,1);

digitalWrite(pinLed,LOW);
e
digitalWrite(pinLed,0);

Indicano la stessa cosa.

La stessa cosa accade per una digitalRead() nel caso in cui noi si debba leggere lo stato di un pin digitale. Potete qundi utilizzare true o false al posto di HIGH e LOW o ancora 1 o 0.

Esercizi per i miei studenti

Esercizio 1
Partendo dall’esempio indicato in questa lezione sulla stampa del valore restituito dalla funzione millis(), realizzare un programma che restituisca i valori di millis() memorizzati in tre variabili di tipo diverso:

unsigned long ora1;
int ora2;
unsigned int ora3;

stampare il valore delle tre variabili sulla Serial Monitor per dimostrare quanto affermato in questa lezione.

Esercizio 2
Realizzare le stese funzionalità dell’esercizio precedete aggiungendo un pulsante che se premuto azzera le tre variabili e fa ripartire (partendo da zero) la stampa sulla Serial Monitor.

Esercizio 3
Realizzare le stesse funzionalità dell’eserizio 2 aggiungendo 3 LED, ciascuno indicherà per un tempo di accensione di 10 secondi il superamento del limite del range del tipo di variabile a cui si riferisce es.:

LED1 -> ora1
LED2 -> ora2
LED3 -> ora3

Buon Making a tutti 🙂

Arduino: utilizzo del metodo parseInt() per la conversione di un stringa di testo che rappresenta un numero in un numero

Nel primo esercizio della lezione: Arduino: Stepper 28BYJ-48 – AccelStepper library veniva chiesto di impostare i parametri di azionamento del motore passo paso da Serial Monitor, questa operazione può essere svolta usando la classe toInt(), ma in modo più efficace e semplice possiamo usare la classe parseInt(). In questa breve lezione un esempio di controllo del lampeggio di un LED da Serial Monitor mediante l’uso di parseInt().

È possibile ricevere numeri con più di una cifra utilizzando i metodi parseInt e parseFloat che semplificano l’estrazione di valori numerici da seriale. (Funziona anche con Ethernet e altri oggetti derivati dalla classe Stream)

Serial.parseInt() e Serial.parseFloat() leggono i caratteri seriali e restituiscono la loro rappresentazione numerica.

I caratteri non numerici prima del numero vengono ignorati e il numero termina con il primo carattere che non è una cifra numerica (o “.” Se si utilizza parseFloat). Se non ci sono caratteri numerici nell’input, le funzioni restituiscono 0, quindi bisogna controllare i valori zero e gestirli in modo appropriato.

Nel dettaglio

  • I caratteri iniziali che non sono cifre o sono numeri negativi vengono ignorati;
  • L’analisi si interrompe quando non sono stati letti caratteri per un valore di tempo di timeout che può essere configurato oppure viene letta una non cifra;
  • Se non sono state lette cifre valide quando si verifica il timeout (vedere Serial.setTimeout ()), viene restituito 0; Serial.parseInt () eredita dalla classe Stream.

Se avete la Serial Monitor configurata per inviare una nuova riga o un ritorno a capo (o entrambi) quando fate clic su invia, parseInt o parseFloat proveranno ad interpretare il return come numero, ma poiché il ritorno a capo non è un numero il valore restituito da parseInt o parseFloat sarà zero.

Nell’esempio che segue un invio imposta blinkRitardo a zero il che implica che il LED non lampeggia.

// Prof. Maffucci Michele
// 10.11.2020
// Impostazione del delay del Blink da tastiera

int lampeggioRitardo = 0;
int chiave = 0;
void setup()
{
  Serial.begin(9600); // inizializzazione della serial monitor
  pinMode(LED_BUILTIN, OUTPUT); // imposta il pin come output
}
void loop()
{
  // ritardo per evitare una doppia scrittura
  // della prima stampa a monitor
  delay(1000);

  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (chiave == 0) {
    Serial.print("Inserisci il ritardo in millisecondi: ");
    chiave = 1;
  }

  // Controlla se è disponibile almeno un carattere sulla seriale
  // La Serial.available() restituisce
  // 1 se presente un cattere,
  // 0 se non è presente un carattere
  
  if (Serial.available())
  {
    int r = Serial.parseInt(); // in r viene memorizzato il valore inserito in numero
    if (r != 0) {
      lampeggioRitardo = r;
      Serial.println(lampeggioRitardo);

      // abilita alla stampa di una nuova stringa:
      // "Inserisci il ritardo in millisecondi: "
      chiave = 0;
    }
  }
  lampeggio(); // funzione che fa lampeggiare il LED su Arduino
}

// il LED lampeggia con i tempi di
// accensione e spegnimento determinati da lampeggioRitardo
void lampeggio()
{
  digitalWrite(LED_BUILTIN, HIGH);
  delay(lampeggioRitardo); // il delay dipende dal valore in lampeggioRitardo
  digitalWrite(LED_BUILTIN, LOW);
  delay(lampeggioRitardo);
}

Esercizio 1
Dato un LED RGB connesso ad Arduino, realizzare un selettore che da Serial Monitor consente di controllare l’accensione e lo spegnimento del rosso, del verde e del blu

Esercizio 2
Svolgere l’esercizio 1 della lezione Stepper 28BYJ-48 – AccelStepper library usando la parseInt()