Archivi categoria: arduino

Arduino: controllo sequenziale uscite digitali

Durante la progettazione di un sistema di automazione accade frequentemente di avere la necessità di ripetere, sequenzialmente e in modo continuo, l’attivazione di apparati (ad es. motori) oppure la lettura continua dei dati provenienti da più sensori. Come attività di ripasso per i miei studenti ho deciso di riprendere alcuni argomenti affrontati nelle scorse settimane con specifiche esperienze di laboratorio:

automi a stati finiti;
utilizzo degli array;
input valori interi da serial monitor;
marcia, arresto, pausa di sequenze;
controllo uscite digitali mediante ingressi analogici;
realizzazione di commutatori con pulsanti con uno o più pulsanti;
utilizzo corretto dei tipi di dati per risparmiare memoria;
e molto altro

Di seguito 9 sketch in cui vengono ripresi gli argomenti sopra elencati e che potranno essere utilizzati nei prossimi mesi per sviluppare ulteriori sperimentazioni.
Come sempre all’interno degli sketch proposti trovate le spiegazioni di ogni parte del codice ed in alcuni casi trovate link di approfondimento che rimandano a questo sito.

Per ripercorrere gli argomenti svolti partirò dal classico sketch che permette di realizza l’accensione sequenziale di LED, come quello che potete trovare nelle mie slice: Alfabeto Arduino – Lezione 2 a pagina 66.
I LED nel circuito identificano gli apparati da attivare sequenzialmente, realizzando così il classico effetto “super car” (i diversamente giovani 🙂 sanno perché si chiama così).
Circuito e sketch verranno poi modificati per rispondere alle specifiche indicate ad inizio di ogni esempio.

Sketch 01

Sequenza di accensione e spegnimento da destra e sinistra e viceversa di 8 LED con tempo di accensione di 100 millisecondi.

/* Prof. Michele Maffucci
   30.12.2020
   Lezione di riferimento: https://wp.me/p4kwmk-4D3

   Versione 01
   Sequenza di accensione e spegnimento alternato
   da destra e sinistra e viceversa di 8 LED con
   tempo di accensione di 100 millisecondi.

   Questo codice è di dominio pubblico
 */

// creazione di un array di 8 pin a cui vanno collegati i LED
// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
// http://wp.me/p4kwmk-26e

byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};

// per approfondimenti sull'uso dei tipi di dati
// si consultino i link:
// https://wp.me/p4kwmk-4As
// https://wp.me/p4kwmk-1zF

// intervallo di accensione/spegnimento
byte ritardoLed = 100;

// indicatore di direzione di accensione
byte direzione = 1;

// indice dell'array per l'accensione del LED
byte ledCorrente = 0;

// variabile in cui memorizzare il tempo di accensione di Arduino
// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
// http://wp.me/p4kwmk-1zF

unsigned long tempoTrascorso;

void setup() {
  // impostiamo tutti i pin ad output
  for (byte x=0; x<8; x++) {
    pinMode(ledPin[x], OUTPUT);
  }

  // Memorizzazione del tempo trascorso
  // dal momento in cui avviamo Arduino
  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
  // http://wp.me/p4kwmk-1QG

  tempoTrascorso = millis();
}

void loop() {
  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento
  if ((millis() - tempoTrascorso) > ritardoLed) {
    cambiaStatoLed();
    tempoTrascorso = millis();
  }
}

// la funzione cambiaStatoLed() permette di controllare
// la sequenza di accensione dei LED

void cambiaStatoLed() {
  // spegne tutti i LED
  for (byte x=0; x<8; x++) {
    digitalWrite(ledPin[x], LOW);
  }
  // accende il LED corrente
  digitalWrite(ledPin[ledCorrente], HIGH);
  // incrementa la variabile direzione
  ledCorrente += direzione;
  // cambia la direzione se si arriva alla fine
  if (ledCorrente == 7) {
    direzione = -1;
  }
  if (ledCorrente == 0) {
    direzione = 1;
  }
}

Sketch 02

Sequenza di accensione e spegnimento da destra e sinistra e viceversa di 8 LED. Con un trimmer è possibile variare il tempo di accensione nell’intervallo da 50 millisecondi a 1000 millisecondi (1 secondo).

/* Prof. Michele Maffucci
   30.12.2020
   Lezione di riferimento: https://wp.me/p4kwmk-4D3

   Versione 02
   Sequenza di accensione e spegnimento alternato
   da destra e sinistra e viceversa di 8 LED controllato
   da un trimmer che permetterà di variare il tempo di accensione
   da 50 millisecondi a 1000 millisecondi (1 secondo).

   Questo codice è di dominio pubblico
 */

// creazione di un array di 8 pin a cui vanno collegati i LED
// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
// http://wp.me/p4kwmk-26e

byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};

// per approfondimenti sull'uso dei tipi di dati
// si consultino i link:
// https://wp.me/p4kwmk-4As
// https://wp.me/p4kwmk-1zF

// intervallo di accensione/spegnimento
int ritardoLed;

// variabile in cui memorizzare il valore restituito dall'analogRead
int val = 0;

// indicatore di direzione di accensione
byte direzione = 1;

// indice dell'array per l'accensione del LED
byte ledCorrente = 0;

// variabile in cui memorizzare il tempo di accensione di Arduino
// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
// http://wp.me/p4kwmk-1zF

unsigned long tempoTrascorso;

void setup() {
  Serial.begin(9600);
  // impostiamo tutti i pin ad output
  for (byte x=0; x<8; x++) {
    pinMode(ledPin[x], OUTPUT);
  }

  // Memorizzazione del tempo trascorso
  // dal momento in cui avviamo Arduino
  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
  // http://wp.me/p4kwmk-1QG

  tempoTrascorso = millis();
}

void loop() {

  // valore analogico letto su A0 inserito con il trimmer
  val = analogRead(A0);

// Togliere il commento per valutare
// valore massimo/minimo del valore restituito
// dall'analogRead in questo modo si potranno
// inserire nella map i valori massimi e minimi
// dell'intervallo di partenza

// Serial.println(val);
// delay(1000);

  // ValMax = 285, ValMin = 719
  // riconvertiti nell'intervallo 50, 1000

  ritardoLed = map(val, 285, 719, 50, 1000);

  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento
  if ((millis() - tempoTrascorso) > ritardoLed) {
    cambiaStatoLed();
    tempoTrascorso = millis();
  }
}

// la funzione cambiaStatoLed() permette di controllare
// la sequenza di accensione dei LED

void cambiaStatoLed() {
  // spegne tutti i LED
  for (byte x=0; x<8; x++) {
    digitalWrite(ledPin[x], LOW);
  }
  // accende il LED corrente
  digitalWrite(ledPin[ledCorrente], HIGH);
  // incrementa la variabile direzione
  ledCorrente += direzione;
  // cambia la direzione se si arriva alla fine
  if (ledCorrente == 7) {
    direzione = -1;
  }
  if (ledCorrente == 0) {
    direzione = 1;
  }
}

Sketch 03

Sequenza di accensione e spegnimento alternato da destra e sinistra e viceversa di 8 LED. L’accensione di ogni LED è fissato in partenza a 100 millisecondi. Con un messaggio sulle Serial Monitor viene richiesto di inserire un nuovo tempo di accensione e spegnimento di ogni LED (delay), tempo che può essere scelto a piacimento.

Lo schema di collegamento è analogo a quello utilizzato per lo sketch 01.

/* Prof. Michele Maffucci
   30.12.2020
   Lezione di riferimento: https://wp.me/p4kwmk-4D3

   Versione 03
   Sequenza di accensione e spegnimento alternato
   da destra e sinistra e viceversa di 8 LED.

   Partenza sequenza con 100 millisecondi e messaggio sulla
   Serial Monitor per modificare il tempo di
   accensione e spegnimento del singolo LED (delay)

   Questo codice è di dominio pubblico
 */

// creazione di un array di 8 pin a cui vanno collegati i LED
// per ulteriori informazioni sull'uso degli array si consulti il seguente link:
// http://wp.me/p4kwmk-26e

byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10};

// per approfondimenti sull'uso dei tipi di dati
// si consultino i link:
// https://wp.me/p4kwmk-4As
// https://wp.me/p4kwmk-1zF

// intervallo di accensione/spegnimento
int ritardoLed = 100;

// indicatore di direzione di accensione
byte direzione = 1;

// indice dell'array per l'accensione del LED
byte ledCorrente = 0;

// variabile in cui memorizzare il tempo di accensione di Arduino
// per ulteriori informazioni sui tipi unsigned long si consulti il seguente link:
// http://wp.me/p4kwmk-1zF

unsigned long tempoTrascorso;

// per stampare una sola volta il messaggio sulla Serial Monitor
bool abilitaMessaggio = 0;

void setup() {
  // inizializzazione della serial monitor
  Serial.begin(9600);

  // impostiamo tutti i pin ad output
  for (byte x=0; x<8; x++) {
    pinMode(ledPin[x], OUTPUT);
  }

  // Memorizzazione del tempo trascorso
  // dal momento in cui avviamo Arduino
  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
  // http://wp.me/p4kwmk-1QG
  tempoTrascorso = millis();
}

void loop() {
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio
    delay(200);
    Serial.print("Inserisci il ritardo in millisecondi: ");
    abilitaMessaggio = 1;
  }

  // Controlla se è disponibile almeno un carattere sulla seriale
  // La Serial.available() restituisce
  // 1 se presente un cattere,
  // 0 se non è presente un carattere

  // per maggior informazioni sull'uso di parseInt() consultare il link:
  // https://wp.me/p4kwmk-4Ah

  if (Serial.available())
  {
    // in r viene memorizzato il valore inserito
    // attraverso la Serial Monitor
    int r = Serial.parseInt();
    if (r != 0) {
      ritardoLed = r;
      Serial.println(ritardoLed);

      // abilita alla stampa di una nuova stringa:
      // "Inserisci il ritardo in millisecondi: "
      abilitaMessaggio = 0;
    }
  }

  // funzione che fa lampeggiare il LED su Arduino
  lampeggio();
}

void lampeggio() {
  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento
  if ((millis() - tempoTrascorso) > ritardoLed) {
    cambiaStatoLed();
    tempoTrascorso = millis();
  }
}

// la funzione cambiaStatoLed() permette di controllare
// la sequenza di accensione dei LED

void cambiaStatoLed() {
  // spegne tutti i LED
  for (byte x = 0; x < 8; x++) {
    digitalWrite(ledPin[x], LOW);
  }
  // accende il LED corrente
  digitalWrite(ledPin[ledCorrente], HIGH);
  // incrementa la variabile direzione
  ledCorrente += direzione;
  // cambia la direzione se si arriva alla fine
  if (ledCorrente == 7) {
    direzione = -1;
  }
  if (ledCorrente == 0) {
    direzione = 1;
  }
}

Continua a leggere→

Arduino: cicli infiniti ed uscita da un ciclo infinito

Lascia una risposta

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 🙂

Arduino: strutturare il codice in blocchi funzionali

Lascia una risposta

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

Lascia una risposta

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

Lascia una risposta

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()

Related posts:

Related posts:

Related posts:

Tipo di dato

Byte

Intervallo

Uso

Related posts:

Related posts: