Arduino – lezione 04: realizzare un programma che identifica le variazioni di stato

Prenderò spunto dal commento che mi è stato lasciato da un mio studente per introdurre l’uso delle istruzioni:

if
if...else
Switch Case

Lo scopo di questa lezione è quello di realizzare un programma che conta quante volte il pulsante viene premuto, per un ciclo di 4 pressioni, alla quinta pressione il led lampeggia una volta e poi si riavvia il ciclo.

Per questa lezione useremo:

1. breadboard
2. 4 diodi led
3. 1 pulsante
4. 1 resistenza da 10KOhm
5. Arduino duemilanove

La prima versione del programma è quella che è stata realizzata dal mio studente, realizzazione di uno sketch per effettuare la seguente funzione:

Prima pressione: led lampeggia ogni mezzo secondo
Seconda pressione: led lampeggia ogni secondo
Terza pressione: led lampeggia ogni secondo e mezzo
Quarta pressione: led si spegne

Realizziamo un circuito come indicato nelle immagini che seguono:

La proposta interessante ed elegante dell’allievo, sfrutta l’istruzione “Switch Case” che permette di definire quale porzione di codice eseguire in funzione del valore di una variabile. Ciò consente di evitare lunghe catene di if-else.
Il “break” alla fine di ogni “case” viene usato per interrompere il controllo degli altri “case“.

// Esempio 05:
// Primo tocco: led lampeggia ogni mezzo secondo
// Secondo tocco: led lampeggia ogni secondo
// Terzo tocco: led lampeggia ogni secondo e mezzo
// Quarto tocco: led si spegne

const int  BUTTON = 2;    // pin di input a cui è collegato il pulsante
const int LED = 13;       // LED collegato al pin digitale 13

// Variabili globali (tutti interi)
int statoButton     = 0;      // stato del pulsante (inizialmente non premuto)
int lastStatoButton = 0;      // ultimo stato del pulsante (per ora non premuto)
int countButton     = 0;      // Conteggio del bottone

// Avvio dell'applicazione
void setup()
{
  pinMode(LED, OUTPUT);       // imposta il pin digitale come output
  pinMode(BUTTON, INPUT);     // imposta il pin digitale come input
}

// Avvio del loop
void loop()
{

  // Verifico se l'utente ha premuto il bottone
  if(digitalRead(BUTTON))
  {
    // Aspetto 15ms per far alzare il dito all'utente
    delay(15);
    // Cambio l'ultimo stato del bottone
    if(lastStatoButton==0) lastStatoButton=1;
    else lastStatoButton=0;
    // Aumento il count del bottone
    if(countButton<=3) countButton=countButton+1;
    else countButton=0;
  }

  // In base allo stato del bottone scelgo l'azione del led
  switch (countButton)
  {
    // Led lampeggia ogni mezzo secondo
  case 1:
    digitalWrite(LED, HIGH);  // accende il LED
    delay(500);              // aspetta un secondo
    digitalWrite(LED, LOW);   // spegne il LED
    delay(500);              // aspetta un secondo
    break;

    // Led lampeggia ogni secondo
  case 2:
    digitalWrite(LED, HIGH);  // accende il LED
    delay(1000);              // aspetta un secondo
    digitalWrite(LED, LOW);   // spegne il LED
    delay(1000);              // aspettaun secondo
    break;

    // led lampeggia ogni secondo e mezzo
  case 3:
    digitalWrite(LED, HIGH);  // accende il LED
    delay(1500);              // aspetta un secondo
    digitalWrite(LED, LOW);   // spegne il LED
    delay(1500);              // aspetta un secondo
    break;

    // Led si spegne
  case 0:
    delay(15);
    digitalWrite(LED, LOW);
    delay(5000);              // aspetta un secondo
    break;
  }
}

Il programma come si intuisce dal filmato, presenta alcuni problemi.

Rimbalzo
Il problema dei segnali spuri dovuti al rimbalzo del pulsante non consente di controllare esattamente la selezione.

Attesa
Durante l’attesa, mentre si vede lampeggiare il led, premendo il pulsante non si ha cambiamento di stato fino a quando non termina il tempo in cui lampeggia il led.

Discriminare
Difficoltà di discriminare in quale situazione ci si trova, tempi troppo brevi per percepire la differenza delle 4 condizioni.

Per risolvere i problemi sopra elencati vi propongo 6 varianti all’esempio 1, ciò mi permetterà di introdurre nuove istruzioni del linguaggio di programmazione.

Prima di fornirvi le mie soluzioni ho necessità di introdurre l’uso dell’istruzioni Serial ed utilizzare il programma “StateChangeDetection” che potete trovare in File > Examples > 2.Digitale > StateChangeDetection o direttamente on-line sul sito Arduino che trovate di seguito

/*  State change detection (edge detection)

 Often, you don't need to know the state of a digital input all the time,
 but you just need to know when the input changes from one state to another.
 For example, you want to know when a button goes from OFF to ON.  This is called
 state change detection, or edge detection.

 This example shows how to detect when a button or button changes from off to on
 and on to off.

 The circuit:
 * pushbutton attached to pin 2 from +5V
 * 10K resistor attached to pin 2 from ground
 * LED attached from pin 13 to ground (or use the built-in LED on
   most Arduino boards)

 created  27 Sep 2005
 modified 30 Dec 2009
 by Tom Igoe

This example code is in the public domain.

 http://arduino.cc/en/Tutorial/ButtonStateChange

 */

// this constant won't change:
const int  buttonPin = 2;    // the pin that the pushbutton is attached to
const int ledPin = 13;       // the pin that the LED is attached to

// Variables will change:
int buttonPushCounter = 0;   // counter for the number of button presses
int buttonState = 0;         // current state of the button
int lastButtonState = 0;     // previous state of the button

void setup() {
  // initialize the button pin as a input:
  pinMode(buttonPin, INPUT);
  // initialize the LED as an output:
  pinMode(ledPin, OUTPUT);
  // initialize serial communication:
  Serial.begin(9600);
}

void loop() {
  // read the pushbutton input pin:
  buttonState = digitalRead(buttonPin);

  // compare the buttonState to its previous state
  if (buttonState != lastButtonState) {
    // if the state has changed, increment the counter
    if (buttonState == HIGH) {
      // if the current state is HIGH then the button
      // wend from off to on:
      buttonPushCounter++;
      Serial.println("on");
      Serial.print("number of button pushes:  ");
      Serial.println(buttonPushCounter, DEC);
    }
    else {
      // if the current state is LOW then the button
      // wend from on to off:
      Serial.println("off");
    }

    // save the current state as the last state,
    //for next time through the loop
    lastButtonState = buttonState;
  }

  // turns on the LED every four button pushes by
  // checking the modulo of the button push counter.
  // the modulo function gives you the remainder of
  // the division of two numbers:
  if (buttonPushCounter % 4 == 0) {
    digitalWrite(ledPin, HIGH);
  } else {
   digitalWrite(ledPin, LOW);
  }

}

Il programma utilizza l’istruzione “Serial” usata per comunicare tra Arduino e il computer oppure altri dispositivi. La comunicazione tra Arduino e dispositivi esterni tramite la porta USB oppure tramite i pin 0 (RX) e 1 (TX). Ovviamente se si utilizzano i pin 1 e 0 per la comunicazione esterna, questi non potranno essere usati come input e output digitali.

All’interno dell’ambiente di sviluppo è implementata una shell per la comunicazione con la scheda, la trovate in Tools > Serial Monitor apparirà una finestra come quella rappresentata di seguito, in cui dovete specificare lo stesso baud rate che viene specificato nel begin().

Tornando al programma StateChangeDetection si noti

Serial.begin(9600);

con cui apriamo la porta seriale USB e la inizializziamo a 9600 bps.

Nel programma troviamo l’istruzione:

Serial.println("on");

println() stampa sulla console di uscita il testo specificato tra parentesi e tra virgolette: “on” seguito da un return (ASCII 13, o ‘\r’) e una nuova linea (ASCII 10, or ‘\n’).

Serial.print("number of button pushes:  ");

print() nel nostro caso stampa sulla console di uscita il testo specificato tra parentesi e tra virgolette: “number of button pushes: “.

Dal reference on-line di Arduino
Con print() i numeri sono stampati utilizzando un carattere ASCII per ogni cifra, i float allo stesso modo ma con solo due numeri decimali, i byte vengono stampati come singoli caratteri, caratteri e stringhe vengono stampate senza nessuna conversione.

Esempio:

Serial.print(78) stampa “78”
Serial.print(1.23456) stampa “1.23”
Serial.print(byte(78)) stampa “N” (whose ASCII value is 78)
Serial.print(‘N’) stampa “N”
Serial.print(“Hello world.”) stampa “Hello world.”

print() può avere un secondo parametro che indica il formato usato nel primo parametro. Il formato può essere: BYTE, BIN (binario), OCT (ottale), DEC (decimale), HEX (esadecimale). Per i numeri in floating point il secondo parametro indica il numero di decimali presi in consideraione.

Per esempio:

Serial.print(78, BYTE) stampa “N”
Serial.print(78, BIN) stampa “1001110”
Serial.print(78, OCT) stampa “116”
Serial.print(78, DEC) stampa “78”
Serial.print(78, HEX) stampa “4E”
Serial.println(1.23456, 0) stampa “1”
Serial.println(1.23456, 2) stampa “1.23”
Serial.println(1.23456, 4) stampa “1.2346”

Torniamo all’analisi del programma CountStateDetection

buttonState = digitalRead(buttonPin);
buttonState = digitalRead(buttonPin);

immagazziniamo in buttonState lo stato del pulsante

if (buttonState != lastButtonState) {
...

controlliamo se il pulsante è stato premuto, cioè se lo stato attuale del pulsante è diverso da quello precedente, se la condizione è vera viene eseguita la porzione di codice che segue:


// if the state has changed, increment the counter
if (buttonState == HIGH) {
// if the current state is HIGH then the button
// wend from off to on:
buttonPushCounter++;
Serial.println(“on”);
Serial.print(“number of button pushes: “);
Serial.println(buttonPushCounter, DEC);
}
else {
// if the current state is LOW then the button
// wend from on to off:
Serial.println(“off”);
}

se buttonState è HIGH vuol dire che si è passati da pulsante non premuto a pulsante premuto,

...
 if (buttonState == HIGH) {
...

incrementiamo di una unità la variabile che conta il numero di volte in cui il pulsante viene premuto

buttonPushCounter++;

si noti che la notazione sopra è analoga alla seguente:

buttonPushCounter = buttonPushCounter+1;

Successivamente con la porzione di codice:

...
Serial.println("on");
Serial.print("number of button pushes:  ");
Serial.println(buttonPushCounter, DEC);
...

stampiamo sul serial monitor il testo “on”, si va a capo, si stampa: “number of button pushes: ” seguito dalla stampa del numero di volte in cui il pulsante è stato premuto, dopo di che si va a capo.

Altrimenti se la condizione dell’if è falsa, cioè il pulsante non è premuto, viene eseguita la parte di codice dell’else e viene stampato “off”

...
    else {
      // if the current state is LOW then the button
      // wend from on to off:
      Serial.println("off"); 
    }
...

Il passo successivo è quello di immagazzinare lo stato del pulsante in lastButtonState.

Nel caso in cui la condizione del primo if del loop() risulta falso, cioè il pulsante non è stato premuto, sarà eseguita la porzione di codice:

...
  // turns on the LED every four button pushes by 
  // checking the modulo of the button push counter.
  // the modulo function gives you the remainder of 
  // the division of two numbers:
  if (buttonPushCounter % 4 == 0) {
    digitalWrite(ledPin, HIGH);
  } else {
   digitalWrite(ledPin, LOW);
  }
...

Si controlla se la divisione intera per 4 del contatore di pressione pulsante da resto zero, se vero ciò vuol dire che abbiamo premuto per quattro volte il pulsante, se falso, si esegue il codice nell’else, ciò vuol dire che non abbiamo premuto per 4 volte il pulsante ed il led viene mantenuto spento.
Ogni volta che si raggiungono 4 pressioni, si accende il led.

Ora incominciamo a dare soluzione al problema che ci siamo posti:
realizzare un programma che conta quante volte il pulsante viene premuto, per un ciclo di 4 pressioni, alla quinta pressione il led lampeggia una volta e poi si riavvia il ciclo.

La prima soluzione sfrutta una serie di if annidati:

// Esempio 06: conta quante volte il pulsante viene premuto, per un ciclo di 4 pressioni,
// alla quinta pressione il led lampeggia una volta e poi si riavvia il ciclo

#define BUTTON 2                                  // pin di input a cui è collegato il pulsante
#define LED 13                                    // LED collegato al pin digitale 13

// Variabili
int ContatorePulsantePremuto = 0;                   // conta il numero di volte che il pulsante è premuto buttonPushCounter 
int StatoPulsante = 0;                              // stato corrente del pulsante
int StatoPulsantePrecedente = 0;                    // stato precedente del pulsante

void setup() {
  pinMode(BUTTON, INPUT);                           // imposta il pin digitale come output
  pinMode(LED, OUTPUT);                             // imposta il pin digitale come input
  Serial.begin(9600);                               // apre la porta seriale e la inizzializza a 9600 bps
}

void loop() {
  StatoPulsante = digitalRead(BUTTON);              // legge il valore dell'input e lo conserva

  if (StatoPulsante != StatoPulsantePrecedente) {   // compara lo stato del pulsante attuale con il precedente
    if (StatoPulsante == HIGH) {                    // se lo stato è cambiato incrementa il contatore
      // se lo stato corrente è alto, il pulsante è passato da off a on
      ContatorePulsantePremuto++;
      if (ContatorePulsantePremuto == 1) {                   // controlla se il pulsante è stato premuto una volta
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        Serial.println("off");                               // stampa sulla console "off"
      }
      if (ContatorePulsantePremuto == 2) {                   // controlla se il pulsante è stato premuto due volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      } 
      if (ContatorePulsantePremuto == 3) {                   // controlla se il pulsante è stato premuto tre volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      } 
      if (ContatorePulsantePremuto == 4) {                   // controlla se il pulsante è stato premuto quattro volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      }
    } 
  }

  // salva lo stato corrente nella variabile che indica lo stato precedente per il loop successivo 
  StatoPulsantePrecedente = StatoPulsante;

  // controlla se il pulsante è stato premuto quattro volte se vero indica che è finito il ciclo
  // il led lampeggia 2 volte per 50 millisecondi
  // vengono inizializzate nuovamente le variabili
  // si riavvia il ciclo

  if (ContatorePulsantePremuto > 4) {
    Serial.println("fine ciclo");
    digitalWrite(LED, HIGH);                                 // accende il LED  
    delay(50);                                               // aspetta 50 millisecondi  
    digitalWrite(LED, LOW);                                  // spegne il LED  
    delay(50);                                               // aspetta 50 millisecondi
    // inizializzazione delle variabili
    ContatorePulsantePremuto = 0;
    StatoPulsante = 0;
    StatoPulsantePrecedente = 0;
    Serial.println("mi riavvio");                            // stampa sulla console "mi riavvio"
  }
}

come potete notare il programma è molto simile a CountStateDetection ma in questo caso verifico con una serie di if se il pulsante è stato premuto 1,2,3,4 volte,

...
      if (ContatorePulsantePremuto == 1) {                   // controlla se il pulsante è stato premuto una volta
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        Serial.println("off");                               // stampa sulla console "off"
      }
      if (ContatorePulsantePremuto == 2) {                   // controlla se il pulsante è stato premuto due volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      } 
      if (ContatorePulsantePremuto == 3) {                   // controlla se il pulsante è stato premuto tre volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      } 
      if (ContatorePulsantePremuto == 4) {                   // controlla se il pulsante è stato premuto quattro volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      }
...

alla quinta pressione, scriviamo a monitor: “fine ciclo”, facciamo lampeggiare il led per 50 millisecondi, stampiamo a monitor “mi riavvio” e si incomincia nuovamente il ciclo.

...
  // controlla se il pulsante è stato premuto quattro volte se vero indica che è finito il ciclo
  // il led lampeggia 2 volte per 50 millisecondi
  // vengono inizializzate nuovamente le variabili
  // si riavvia il ciclo

  if (ContatorePulsantePremuto > 4) {
    Serial.println("fine ciclo");
    digitalWrite(LED, HIGH);                                 // accende il LED  
    delay(50);                                               // aspetta 50 millisecondi  
    digitalWrite(LED, LOW);                                  // spegne il LED  
    delay(50);                                               // aspetta 50 millisecondi
    // inizializzazione delle variabili
    ContatorePulsantePremuto = 0;
    StatoPulsante = 0;
    StatoPulsantePrecedente = 0;
    Serial.println("mi riavvio");                            // stampa sulla console "mi riavvio"
  }
...

Poichè la visualizzazione dell’accensione del led alla quinta pressione del pulsante è troppo breve, facciamo in modo che alla quinta prssione il led lampeggi per 10 volte ad intervalli di 50 millisecondi, per far ciò utilizzerò un ciclo for (vai al reference on-line per la spiegazione).

// Esempio 07: conta quante volte il pulsante viene premuto, per un ciclo di 4 pressioni,
// alla quinta pressione il led lampeggia per 10 volte e poi si riavvia il ciclo
// per il ciclo lampeggio è stato utilizzato un ciclo for

#define BUTTON 2                                  // pin di input a cui è collegato il pulsante
#define LED 13                                    // LED collegato al pin digitale 13

// Variabili
int ContatorePulsantePremuto = 0;                   // conta il numero di volte che il pulsante è premuto buttonPushCounter 
int StatoPulsante = 0;                              // stato corrente del pulsante
int StatoPulsantePrecedente = 0;                    // stato precedente del pulsante

void setup() {
  pinMode(BUTTON, INPUT);                           // imposta il pin digitale come input
  pinMode(LED, OUTPUT);                             // imposta il pin digitale come output
  Serial.begin(9600);                               // apre la porta seriale e la inizzializza a 9600 bps
}

void loop() {
  StatoPulsante = digitalRead(BUTTON);              // legge il valore dell'input e lo conserva

  if (StatoPulsante != StatoPulsantePrecedente) {   // compara lo stato del pulsante attuale con il precedente
    if (StatoPulsante == HIGH) {                    // se lo stato è cambiato incrementa il contatore
      // se lo stato corrente è alto, il pulsante è passato da off a on
      ContatorePulsantePremuto++;
      if (ContatorePulsantePremuto == 1) {                   // controlla se il pulsante è stato premuto una volta
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        Serial.println("off");                               // stampa sulla console "off"
      }
      if (ContatorePulsantePremuto == 2) {                   // controlla se il pulsante è stato premuto due volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      } 
      if (ContatorePulsantePremuto == 3) {                   // controlla se il pulsante è stato premuto tre volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      } 
      if (ContatorePulsantePremuto == 4) {                   // controlla se il pulsante è stato premuto quattro volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      }
    } 
  }

  // salva lo stato corrente nella variabile che indica lo stato precedente per il loop successivo 
  StatoPulsantePrecedente = StatoPulsante;

  // controlla se il pulsante è stato premuto quattro volte se vero indica che è finito il ciclo
  // il led lampeggia 2 volte per 50 millisecondi
  // vengono inizializzate nuovamente le variabili
  // si riavvia il ciclo

  if (ContatorePulsantePremuto > 4) {
    Serial.println("fine ciclo");
    for (int x=0; x<10; x++) {                                 // lampeggia per 10 volte
      digitalWrite(LED, HIGH);                                 // accende il LED  
      delay(50);                                               // aspetta 50 millisecondi  
      digitalWrite(LED, LOW);                                  // spegne il LED  
      delay(50);                                               // aspetta 50 millisecondi
    }
    // inizializzazione delle variabili
    ContatorePulsantePremuto = 0;
    StatoPulsante = 0;
    StatoPulsantePrecedente = 0;
    Serial.println("mi riavvio");                            // stampa sulla console "mi riavvio"
  }
}

La parte di codice che consente di far lampeggiare 10 volte il led è:

...
    for (int x=0; x<10; x++) {                                 // lampeggia per 10 volte
      digitalWrite(LED, HIGH);                                 // accende il LED  
      delay(50);                                               // aspetta 50 millisecondi  
      digitalWrite(LED, LOW);                                  // spegne il LED  
      delay(50);                                               // aspetta 50 millisecondi
    }
...

Si inizializza la viariabile intera x a 0 e ad ogni ciclo la si incrementa di 1 (x++)

Nel programma precedente, il controllo delle volte in cui il pulsante viene premuto è effettuato dalla serie di if:

...
      if (ContatorePulsantePremuto == 1) {                   // controlla se il pulsante è stato premuto una volta
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        Serial.println("off");                               // stampa sulla console "off"
      }
      if (ContatorePulsantePremuto == 2) {                   // controlla se il pulsante è stato premuto due volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      } 
      if (ContatorePulsantePremuto == 3) {                   // controlla se il pulsante è stato premuto tre volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      } 
      if (ContatorePulsantePremuto == 4) {                   // controlla se il pulsante è stato premuto quattro volte
        Serial.println("on");
        Serial.print("numero di volte tasto premuto:  ");
        Serial.println(ContatorePulsantePremuto, DEC);
        Serial.println("off");
      }
...

dal punto di vista della programmazione ritengo più elegante e chiaro utilizzare l’istruzione case spiegato ad inizio lezione, questo è il codice:

// Esempio 08: conta quante volte il pulsante viene premuto, per un ciclo di 4 pressioni,
// alla quinta pressione il led lampeggia per 10 volte e poi si riavvia il ciclo.
// Il controllo del numero di volte in cui il pulsante viene premuto viene fatto con l'istruzione "case"

#define BUTTON 2                                  // pin di input a cui è collegato il pulsante
#define LED 13                                    // LED collegato al pin digitale 13

// Variabili
int ContatorePulsantePremuto = 0;                   // conta il numero di volte che il pulsante è premuto buttonPushCounter 
int StatoPulsante = 0;                              // stato corrente del pulsante
int StatoPulsantePrecedente = 0;                    // stato precedente del pulsante

void setup() {
  pinMode(BUTTON, INPUT);                           // imposta il pin digitale come input
  pinMode(LED, OUTPUT);                             // imposta il pin digitale come output
  Serial.begin(9600);                               // apre la porta seriale e la inizzializza a 9600 bps
}

void loop() {
  StatoPulsante = digitalRead(BUTTON);              // legge il valore dell'input e lo conserva

  if (StatoPulsante != StatoPulsantePrecedente) {   // compara lo stato del pulsante attuale con il precedente
    if (StatoPulsante == HIGH) {                    // se lo stato è cambiato incrementa il contatore
      // se lo stato corrente è alto, il pulsante è passato da off a on
      ContatorePulsantePremuto++;

      switch (ContatorePulsantePremuto) {
      case 1:  // controlla se il pulsante è stato premuto una volta
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 2:  // controlla se il pulsante è stato premuto due volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 3:  // controlla se il pulsante è stato premuto tre volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 4:  // controlla se il pulsante è stato premuto quattro volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        Serial.println("off");                               // stampa sulla console "off"
        break;
      }
    } 
  }

  // salva lo stato corrente nella variabile che indica lo stato precedente per il loop successivo 
  StatoPulsantePrecedente = StatoPulsante;

  // controlla se il pulsante è stato premuto quattro volte se vero indica che è finito il ciclo
  // il led lampeggia 2 volte per 50 millisecondi
  // vengono inizializzate nuovamente le variabili
  // si riavvia il ciclo

  if (ContatorePulsantePremuto > 4) {
    Serial.println("fine ciclo");
    for (int x=0; x<10; x++) {                                 // lampeggia per 10 volte
      digitalWrite(LED, HIGH);                                 // accende il LED  
      delay(50);                                               // aspetta 50 millisecondi  
      digitalWrite(LED, LOW);                                  // spegne il LED  
      delay(50);                                               // aspetta 50 millisecondi
    }
    // inizializzazione delle variabili
    ContatorePulsantePremuto = 0;
    StatoPulsante = 0;
    StatoPulsantePrecedente = 0;
    Serial.println("mi riavvio");                            // stampa sulla console "mi riavvio"
  }
}

L’esercizio che segue aggiunge un grado di difficoltà.
Negli esempi precedenti per controllare il numero di volte che il pulsante è stato premuto si è inviato un messaggio alla shell di output (Serial Monitor) se ricordate dai filmati l’output era questo:

Vogliamo ora, oltre che mandare messaggi alla shell di output, usare 4 led per identificare la pressione del pulsante.
Ad ogni pressione del pulsante si farà accende un led per volta e alla quinta pressione il primo led lampeggia per 10 volte.
Anche in questo caso il controllo del numero di volte in cui il pulsante viene premuto viene fatto con l’istruzione “case”.

Questo il circuito:

circuito02b-fz


Il programma:

// Esempio 9: conta quante volte il pulsante viene premuto, per un ciclo di 4 pressioni,
// ad ogni pressione del pulsante si accende un led per volta
// alla quinta pressione il primo led lampeggia per 10 volte.
// Il controllo del numero di volte in cui il pulsante viene premuto viene fatto con l'istruzione "case"

#define BUTTON 2                                   // pin di input a cui è collegato il pulsante
#define LED1 13                                    // LED collegato al pin digitale 13
#define LED2 12                                    // LED collegato al pin digitale 12
#define LED3 11                                    // LED collegato al pin digitale 11
#define LED4 10                                    // LED collegato al pin digitale 10

// Variabili
int ContatorePulsantePremuto = 0;                   // conta il numero di volte che il pulsante è premuto buttonPushCounter 
int StatoPulsante = 0;                              // stato corrente del pulsante
int StatoPulsantePrecedente = 0;                    // stato precedente del pulsante

void setup() {
  pinMode(BUTTON, INPUT);                           // imposta il pin digitale come output
  pinMode(LED1, OUTPUT);                            // imposta il pin digitale come input
  pinMode(LED2, OUTPUT);                            // imposta il pin digitale come input
  pinMode(LED3, OUTPUT);                            // imposta il pin digitale come input
  pinMode(LED4, OUTPUT);                            // imposta il pin digitale come input
  Serial.begin(9600);                               // apre la porta seriale e la inizzializza a 9600 bps
}

void loop() {
  StatoPulsante = digitalRead(BUTTON);              // legge il valore dell'input e lo conserva

  if (StatoPulsante != StatoPulsantePrecedente) {   // compara lo stato del pulsante attuale con il precedente
    if (StatoPulsante == HIGH) {                    // se lo stato è cambiato incrementa il contatore
      // se lo stato corrente è alto, il pulsante è passato da off a on
      ContatorePulsantePremuto++;

      switch (ContatorePulsantePremuto) {
      case 1:  // controlla se il pulsante è stato premuto una volta
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        digitalWrite(LED1, HIGH);                                 // accende il LED  
        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 2:  // controlla se il pulsante è stato premuto due volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        digitalWrite(LED1, LOW);                                 // accende il LED  
        digitalWrite(LED2, HIGH);                                 // accende il LED  
        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 3:  // controlla se il pulsante è stato premuto tre volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        digitalWrite(LED2, LOW);                                 // accende il LED  
        digitalWrite(LED3, HIGH);                                 // accende il LED  
        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 4:  // controlla se il pulsante è stato premuto quattro volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        digitalWrite(LED3, LOW);                                 // accende il LED  
        digitalWrite(LED4, HIGH);                                 // accende il LED  
        Serial.println("off");                               // stampa sulla console "off"
        break;
      }
    } 
  }

  // salva lo stato corrente nella variabile che indica lo stato precedente per il loop successivo 
  StatoPulsantePrecedente = StatoPulsante;

  // controlla se il pulsante è stato premuto quattro volte se vero indica che è finito il ciclo
  // il led lampeggia 2 volte per 50 millisecondi
  // vengono inizializzate nuovamente le variabili
  // si riavvia il ciclo

  if (ContatorePulsantePremuto > 4) {
    Serial.println("fine ciclo");
    digitalWrite(LED4, LOW);                                 // accende il LED  
    delay(50); 
    for (int x=0; x<10; x++) {                                 // lampeggia per 10 volte
      digitalWrite(LED1, HIGH);                                 // accende il LED  
      delay(50);                                               // aspetta 50 millisecondi  
      digitalWrite(LED1, LOW);                                  // spegne il LED  
      delay(50);                                               // aspetta 50 millisecondi
    }
    // inizializzazione delle variabili
    ContatorePulsantePremuto = 0;
    StatoPulsante = 0;
    StatoPulsantePrecedente = 0;
    Serial.println("mi riavvio");                            // stampa sulla console "mi riavvio"
  }
}

Il programma differisce dalla versione precedente sostanzialmente nella parte iniziale in cui nominiamo i vari pin con nome del led corrispondente:

...
#define LED1 13                                    // LED collegato al pin digitale 13
#define LED2 12                                    // LED collegato al pin digitale 12
#define LED3 11                                    // LED collegato al pin digitale 11
#define LED4 10                                    // LED collegato al pin digitale 10
...

e nell’area dei “case” in cui come potete notare ad ogni pressione del pulsante viene spento il led precedente e acceso il successivo:

...
      case 1:  // controlla se il pulsante è stato premuto una volta
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto

        digitalWrite(LED1, HIGH);                                 // accende il LED  

        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 2:  // controlla se il pulsante è stato premuto due volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto

        digitalWrite(LED1, LOW);                                 // accende il LED  
        digitalWrite(LED2, HIGH);                                 // accende il LED  

        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 3:  // controlla se il pulsante è stato premuto tre volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto

        digitalWrite(LED2, LOW);                                 // accende il LED  
        digitalWrite(LED3, HIGH);                                 // accende il LED  

        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 4:  // controlla se il pulsante è stato premuto quattro volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto

        digitalWrite(LED3, LOW);                                 // accende il LED  
        digitalWrite(LED4, HIGH);                                 // accende il LED  

        Serial.println("off");                               // stampa sulla console "off"
        break;
...

Lo scopo dell’ultimo esercizio è quello di creare un annidamento di “for“.
Anche in questo caso ad ogni pressione del pulsante si accende un led per volta però ora alla quinta pressione i led lampeggia per 5 volte in sequenza dal 4° al 1° led e poi si riavvia il ciclo.

// Esempio 10: conta quante volte il pulsante viene premuto, per un ciclo di 4 pressioni,
// ad ogni pressione del pulsante si accende un led per volta
// alla quinta pressione i led lampeggia per 5 volte in sequenza dal 4' al 1' led e poi si riavvia il ciclo.
// Il controllo del numero di volte in cui il pulsante viene premuto viene fatto con l'istruzione "case"

#define BUTTON 2                                    // pin di input a cui è collegato il pulsante
#define LED1 13                                     // LED collegato al pin digitale 13
#define LED2 12                                     // LED collegato al pin digitale 12
#define LED3 11                                     // LED collegato al pin digitale 11
#define LED4 10                                     // LED collegato al pin digitale 10

// Variabili
int ContatorePulsantePremuto = 0;                   // conta il numero di volte che il pulsante è premuto buttonPushCounter 
int StatoPulsante = 0;                              // stato corrente del pulsante
int StatoPulsantePrecedente = 0;                    // stato precedente del pulsante

void setup() {
  pinMode(BUTTON, INPUT);                           // imposta il pin digitale come input
  pinMode(LED1, OUTPUT);                            // imposta il pin digitale come output
  pinMode(LED2, OUTPUT);                            // imposta il pin digitale come output
  pinMode(LED3, OUTPUT);                            // imposta il pin digitale come output
  pinMode(LED4, OUTPUT);                            // imposta il pin digitale come output
  Serial.begin(9600);                               // apre la porta seriale e la inizzializza a 9600 bps
}

void loop() {
  StatoPulsante = digitalRead(BUTTON);              // legge il valore dell'input e lo conserva

  if (StatoPulsante != StatoPulsantePrecedente) {   // compara lo stato del pulsante attuale con il precedente
    if (StatoPulsante == HIGH) {                    // se lo stato è cambiato incrementa il contatore
      // se lo stato corrente è alto, il pulsante è passato da off a on
      ContatorePulsantePremuto++;

      switch (ContatorePulsantePremuto) {
      case 1:  // controlla se il pulsante è stato premuto una volta
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        digitalWrite(LED1, HIGH);                            // accende il LED1  
        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 2:  // controlla se il pulsante è stato premuto due volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        digitalWrite(LED1, LOW);                             // spegne il LED1 
        digitalWrite(LED2, HIGH);                            // accende il LED2  
        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 3:  // controlla se il pulsante è stato premuto tre volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        digitalWrite(LED2, LOW);                             // spegne il LED2  
        digitalWrite(LED3, HIGH);                            // accende il LED3 
        Serial.println("off");                               // stampa sulla console "off"
        break;
      case 4:  // controlla se il pulsante è stato premuto quattro volte
        Serial.println("on");                                // stampa sulla console "on"
        Serial.print("numero di volte tasto premuto:  ");    // stampa sulla console "numero di volte tasto premuto:"
        Serial.println(ContatorePulsantePremuto, DEC);       // stampa il numero di volte che il pulsante è stato premuto
        digitalWrite(LED3, LOW);                             // accende il LED3  
        digitalWrite(LED4, HIGH);                            // accende il LED4  
        Serial.println("off");                               // stampa sulla console "off"
        break;
      }
    } 
  }

  // salva lo stato corrente nella variabile che indica lo stato precedente per il loop successivo 
  StatoPulsantePrecedente = StatoPulsante;

  // controlla se il pulsante è stato premuto quattro volte se vero indica che è finito il ciclo
  // il led lampeggia 2 volte per 50 millisecondi
  // vengono inizializzate nuovamente le variabili
  // si riavvia il ciclo

  if (ContatorePulsantePremuto > 4) {
    Serial.println("fine ciclo");                            // stampa sulla console "fine ciclo"
    digitalWrite(LED4, LOW);                                 // spegne il LED4   
    for (int x=0; x<5; x++) {                                // ciclo di accensione e spegnimento led
      for (int n=10; n<14; n++) {                            // ciclo sui diodi da accendere e spegnere
        digitalWrite(n, HIGH);                               // accende il LED  
        delay(50);                                           // aspetta 50 millisecondi  
        digitalWrite(n, LOW);                                // spegne il LED  
        delay(50);                                           // aspetta 50 millisecondi
      }
    }
    // inizializzazione delle variabili
    ContatorePulsantePremuto = 0;
    StatoPulsante = 0;
    StatoPulsantePrecedente = 0;
    Serial.println("mi riavvio");                            // stampa sulla console "mi riavvio"
  }
}

I due cicli “for” sono nella parte terminale del programma:

...
    for (int x=0; x<5; x++) {                                // ciclo di accensione e spegnimento led
      for (int n=10; n<14; n++) {                            // ciclo sui diodi da accendere e spegnere
        digitalWrite(n, HIGH);                               // accende il LED  
        delay(50);                                           // aspetta 50 millisecondi  
        digitalWrite(n, LOW);                                // spegne il LED  
        delay(50);                                           // aspetta 50 millisecondi
      }
    }

Il ciclo “for” interno eseguirà 4 cicli (per n che va da 10 a 13). Come potete notare la variabile intera n viene inizializzata a 10 perché bisognerà accendere e poi spegnere prima il led connesso al pin 10, e così fino al diodo led connesso al pin 13 e questa sequenza sarà eseguita per 5 volte così come imposto dal ciclo “for” più esterno che eseguirà 5 (da 0 a 4) sequenze di accensione dei 4 led.

Bene!

Ora sapete usare le istruzioni: if, case e for e annidamento di for e sapete anche come inviare messaggi da Arduino al computer.


Vai alle altre lezioni:

Lezione01: Incominciamo con Arduino Arduino – lezione 02: facciamo lampeggiare un led Arduino – lezione 03: controlliamo un led con un pulsante
Lezione Arduino Lezione Arduino Lezione Arduino
Arduino – lezione 04: realizzare un programma che identifica le variazioni di stato Arduino – lezione 05: controllo presenza
Lezione Arduino Lezione Arduino

Articoli simili:

Questa voce è stata pubblicata in arduino e contrassegnata con , , , . Contrassegna il permalink.

19 risposte a Arduino – lezione 04: realizzare un programma che identifica le variazioni di stato

  1. Bertay scrive:

    volevo segnalarvi un concorso dove potete vincere la scheda arduino e non solo
    http://it.emcelettronica.com/marzuino-non-solo-arduino-ma-anche-oscilloscopio-digitale-multimetro-e

  2. admin scrive:

    Molto interessante la vostra iniziativa!
    Divulgherò sicuramente tra colleghi ed allievi.

    Cordiali saluti.

  3. massimo scrive:

    Molto bello l’articolo, vorrei solo aggiungere riguardo al sistema per gestire il fronte del pulsante che la soluzione classica è la seguente (e non occorre inizializzare le variabili):

    StatoPulsante = digitalRead(BUTTON);
    StatoChanged = (StatoPulsante) & (!StatoPulsanteOld); //non conosco bene la sintassi
    StatoPulsanteOld = digitalRead(BUTTON);
    if StatoChanged
    {
    }

  4. francesco scrive:

    Ottimo lavoro.

  5. Claudio scrive:

    Salve Prof.

    Tenendo in considerazione l’ esempio n°6. Perchè se tengo il pulsante premuto non fa il ciclo?? Qual è il comando che consente il “blocco”?

    Grazie
    Claudio

  6. maurizio scrive:

    Salve Professore
    sono da poco entrato nel mondo di arduino, i suoi tutorial sono molto interresanti e ben fatti.
    Io volevo chiedere un piccolo aiuto per un proggetto di domotica che vorrei realizzare.
    Per quanto riguarda lo sketch ho preso in considerazione e modificato quello creato da DOMOTICHOME.net, il mio problema e che vorrei comandare delle tende da sole che ad un primo impulso arduino attiva un’uscita per un tempo presatabilito dopo il quale viene disattivata, fino a qui tutto ok, quello che non riesco a realizzare e che durante la fase attiva se io voglio interrompere la stessa in un determinato momento prima del tempo prestabilito non me lo fa fare. Ho provato anche con alcuni esempi riportati nei suoi tutorial ma nulla da fare.
    Chiedo una mano
    grazie

  7. Pino scrive:

    Ciao,
    intanto volevo ringraziarla per il lavoro svolto, principalmente per noi alle prime armi!
    Ho una domanda, per gestire tutte le funzioni e i Pin della scheda, devo creare un solo File o posso fare diversi File (magari con nomi diversi)ognuno per ciascuna funzione che intendo realizzare ?
    Grazie, ciao.

  8. Mirko scrive:

    so che l’argomento è un po personale e forse non riguarda nemmemo raduino come programmazione !
    da poco tempo ho “arduino UNO” e ho letto i vostri articoli!
    ho provato a inserire un tasto come ingresso come spiegato nel vostro articolo!
    il risultato … un disastro ! l’ingresso mi manda una serie di segnali casuali apparentemente senza nessuna logica !
    tentato su altri ingressi ma il risultato sempre uguale !
    così pensando di aver bruciato arduino ho fatto un piccolo programma che mi indica una variazione sulle uscite per vedere se ci sono uscite ancora utilizzabili !
    tutto inutile le uscite ( anche quelle mai usate ) variano alimpazzata !
    avvicinando ( non toccando) una mano ad arduino il problema aumenta !
    alla fine mi sono accorto che sfiorando il terminale USB ( la parte metallica ) tutte le uscite si stabilizzano !
    cosa succede ?????
    grazie della vostra attenzione
    Mirko

  9. paolo scrive:

    salve a tutti, volevo chiedervi se era possibile modificare il programma di su, in modo che al posto di resettarsi per tornare indietro, si utilizzi un secondo pulsante per farlo, una specie di contatore up/down insomma, e quando si accende l’ultimo led, e continuo a premere up lui non faccia niente.. é possibile??
    cordiali saluti
    Paolo

  10. Gian Luca scrive:

    Buongiorno, da pochi giorni mi sto cimentando in questo bellissimo mondo… ho dei dubbi e dei problemi da principiante. Uno tra questi: effettuando la quarta lezione mi sono accorto che con una semplice pressione del bottone i segnali di input anzichè essere sempre uno a volte sono 2… posso chiedere il perchè e come posso risolvere questo problema? Grazie

  11. luigi basi scrive:

    Eccezzionale! per la chiarezza esauriente e perfetto.
    Bravi

  12. Luigi scrive:

    Nella seconda foto della Lezione 04, vedo che in LED è stato inserito direttamente tra GND e il terminale . Per la salute di ARDUINO, non è cosigliabile inserire una resistenza limitatrice da qualche centinaio di Hom ?
    Premetto che sono ai primi ma tengo a redermi conto delle cose.
    Complimenti vivissimi per i tutorial.

    • admin scrive:

      Ciao Luigi.

      Si hai ragione.
      In realtà è per la salute del LED. On-line troverai molti commenti a riguardo. Una reistenza di circa 220 Ohm va benissimo. Se non inserisci la resistenza, rischi di bruciare il LED, ma noterai che i LED comunemente usati per queste sperimentazioni (per capirci quelli di diametro 5mm) sono abbastanza resistenti e possono funzionare per brevi periodi anche in questa situazione anomale, in ogni caso non è da fare.

      Grazie per la precisazione.
      Ciao.

  13. Walter scrive:

    ATTENZIONE!!
    vorrei segnalare una imprecisione (abbastanza grave se si segue quello per realizzare il circuito in pratica!) sull’ultimo schema realizzato con fritzing:

    i diodi led sono collegati ai pin GND e +5V, inoltre sono pure collegati ai pin digitali di uscita 13,12,11,10. seguendo quello schema nel realizzare i collegamenti, al primo avvio penso che si rischia di mandare in corto circuito le uscite digitali di arduino, col rischio di rovinare l’intera schedina…

    invece dalle foto, su bread board è realizzato correttamente, con i catodi dei led collegati al pin GND, e gli anodi collegati ai soli pin digitali.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *