Arduino – lezione 03: controlliamo un led con un pulsante

Impariamo in questa lezione ad usare un sensore per controllare l’accensione di un diodo led. Useremo il più semplice dei sensori: il pulsante.

Scopo della lezione:
realizzare un programma che permette di accendere una luce quando premiamo un pulsante e quando viene nuovamente premuto il pulsante spegne la luce, comportamento analogo a quello che si ha per un impianto di illuminazione.

Per controllare lo stato di un pulsante utilizzeremo l’istruzione digitalRead(), questa istruzione legge il valore su uno specifico pin digitale che può assumere due valori, HIGH o LOW, detto in modo meno informatico e più elettronico, verifica se su un determinato pin è applicata una tensione di +5V (definito HIGH) o 0V (definito LOW).

Nella lezione 2 abbiamo realizzato un programma che permetteva di far lampeggiare un led, con la nuova istruzione digitalRead() siamo in grado di eseguire qualcosa di più evoluto, l’accensione di un led solamente se cambia una situazione esterna, in questo esercizio, lo stato di un pulsante.
Quindi con digitalRead() possiamo leggere uno stato di un sensore e memorizzare questo stato nella memoria di Arduino per fare qualcosa.

Per procedere con questa lezione abbiamo necessità di un po’ di hardware elettronico:

  • 1 breadboard
  • 1 pulsante
  • 1 diodo led
  • 1 resistenza da 10 K Ohm
  • filo elettrico per breadboard
  • ed ovviamente Arduino duemilanove :-)

Il circuito che deve essere realizzato è il seguente.

l’immagine è stata realizzata utilizzando Fritzing

Dettagli sui collegamenti:

Questo l’immagine del circuito reale:

Ricordate di collegare il catodo del diodo LED su GND e l’anodo all’uscita digitale 13.

Questo il codice usato per controllare il LED:

// Esempio 01: accendi il led appena è premuto il pulsante

#define LED 13                // LED collegato al pin digitale 13
#define BUTTON 7              // pin di input dove è collegato il pulsante
int  val = 0;                 // si userà val per conservare lo stato del pin di input

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

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

  // controlla che l'input sia HIGH (pulsante premuto)
  if (val == HIGH) {
    digitalWrite(LED, HIGH);  //accende il led
  }
  else {
    digitalWrite(LED, LOW);   //spegne il led
  }
}

Come potete constatare oltre all’istruzione digitalRead() in grado di leggere lo stato di un sensore esterno abbiamo anche l’istruzione if e if…else

L’istruzione if…else consente di prendere delle decisioni in funzione del fatto che una determinata condizione logica sia VERA o FALSA.
Nel caso in cui la condizione sia VERA viene eseguito il primo blocco di istruzioni, nel caso in cui la condizione sia FALSA, viene eseguito il secondo blocco di memoria.
La condizione logica espressa tra parentesi tonde, segue la parola if

Esempio:

if (x < 100)
{
  // blocco A
}
else
{
  // blocco B
}

Se la condizione X<100 è vera viene eseguito il blocco di istruzioni del “blocco A”, se la condizione X<100 è falsa viene eseguito il blocco di istruzioni del “blocco B”.

Nota:
Dire che una condizione è VERA vuol dire che assume un valore binario pari a 1, ma in senso booleano, è VERA qualsiasi condizione diversa da zero, per cui -50, -7, -1, 3, 9 sono tutti considerati VERO in senso booleano.
Per maggiori dettagli si consulti il reference su Arduino.cc

Tornando al codice del programma “Esempio 1″ notate che ho usato “==” invece che “=” per confrontare due elementi.

Nel linguaggio di programmazione di Arduino il simbolo “==” (vai al manuale) viene utilizzato per confrontare due entità (confronto logico) e restituisce TRUE o FALSE, mentre il simbolo “=” (vai al manuale) viene utilizzato per assegnare un valore ad una variabile.

Analizziamo il programma

Poiché vogliamo ottenere una funzionalità simile a quello di un interruttore per attivare l’illuminazione in una casa, bisogna in qualche modo ricordare lo stato del pulsante, per far ciò definiamo una variabile intera di nome val a cui assegnamo inizialmente il valore 0.

Come potete vedere nel programma useremo val per conservare il valore di digitalRead()

I valori di qualsiasi variabile usata con Arduino vengono inseriti nella memoria RAM, valori che vengono persi una volta che si toglie l’alimentazione alla scheda Arduino.

All’interno della codice di loop() viene assegnata alla variabile val lo stato del valore di input mediante l’istruzione digitalRead(BUTTON), ovvero l’istruzione legge il valore dell’input (pulsante) e restituisce un valore 0 oppure 1:

// legge il valore dell'input e lo conserva
val = digitalRead(BUTTON);

successivamente viene controllato mediante l’istruzione if…else se il pulsante è premuto:

  // controlla che l'input sia HIGH (pulsante premuto)
  if (val == HIGH) {
    digitalWrite(LED, HIGH);  //accende il led
  }
  else {
    digitalWrite(LED, LOW);   //spegne il led
  }
}

Se il valore di val è HIGH (valore logico 1) vuol dire che il pulsante è premuto e allora, tramite l’istruzione “digitalWrite(LED, HIGH);” viene acceso il LED, se il primo confronto risulta falso, ciò vuol dire che il pulsante non è premuto come conseguenza viene eseguita la parte di codice else che spegne il LED,  ciò viene eseguito con l’istruzione: “digitalWrite(LED, LOW);”

Però lo scopo di questa terza lezione è quello di realizzare un circuito simile a quello di un impianto di illuminazione: “premo il pulsante accendo la luce, premo una seconda volta e spengo la luce”, l’esempio 1, ci costringe a mantenere il dito sul pulsante per mantenere acceso il led.

Questa la prima versione del programma che risolve il problema:

// Esempio 02: accendi il led appena è premuto il pulsante mantenendolo acceso quando si rilascia
// premendo una seconda volta il pulsante spegne il led

#define LED 13                // LED collegato al pin digitale 13
#define BUTTON 7              // pin di input dove è collegato il pulsante
int val = 0;                  // si userà val per conservare lo stato del pin di input
int stato = 0;                // ricorda lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso

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

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

  // controlla che l'input sia HIGH (pulsante premuto)
  // e cambia lo stato del led
  if (val == HIGH) {
    stato = 1 - stato;
  } 

  if (stato == 1) {
    digitalWrite(LED, HIGH);   // accende il led
  }
  else {
    digitalWrite(LED, LOW);    //spegne il led
  }
}

Prima di provare il risultato su Arduino vediamo come funziona il programma.

Passo 1: pulsante non premuto – diodo spento

Il valore assunto da val è 0 in quanto il pulsante non è premuto (l’istruzione “digitalRead(BUTTON);” restituisce 0), la condizione logica val == HIGH del prim if restituisce falso e la variabie stato resta al valore iniziale 0.

Poiché il confronto stato == 1 del secondo if restituisce falso, viene eseguito l’else in cui è presente l’istruzione “digitalWrite(LED, LOW);” che spegne il diodo led.

Passo 2: pulsante premuto – diodo acceso

Il valore assunto da val è 1 in quanto il pulsante è premuto (l’istruzione “digitalRead(BUTTON);” restituisce 1), la condizione logica val == HIGH del primo if restituisce vero e la variabie stato viene impostata a stato = 1 - 0, cioè a 1.

Poiché il confronto stato == 1 del secondo if restituisce vero, viene eseguita l’istruzione che segue, cioè: “digitalWrite(LED, HIGH);” che accende il diodo led.

Passo 3: pulsante premuto – diodo spento

Il valore assunto da val è 1 in quanto il pulsante è premuto (l’istruzione “digitalRead(BUTTON);” restituisce 1), la condizione logica val == HIGH del primo if restituisce vero e la variabie stato viene impostata a stato = 1 - 1 (stato è stato impostato ad 1 nel passo precedente), cioè a 0.

Poiché il confronto stato == 1 del secondo if restituisce falso, viene eseguito l’else in cui è presente l’istruzione “digitalWrite(LED, LOW);” che spegne il diodo led.

Se provate il programma noterete un funzionamento molto strano, potrebbe capitare che premendo e rilasciando il pulsante il led non si accende e si spegne correttamente, ad esempio premo e non si accende oppure se acceso premendo il pulsante non si spegne il led. Ciò è dovuto al fatto che Arduino legge le istruzioni del vostro programma ad una velocità di milioni di istruzioni al secondo ciò vuol dire che la lettura dello stato del pulsante viene letta moltissime volte al secondo e l’accensione e lo spegnimento del diodo led potrebbe essere imprevedibile.

Per comprendere questa situazione immaginate che al Passo 3 precedente si continui a mantenere premuto il pulsante, noterete che la variabile stato ad ogni ciclo, assume valori diversi che possono portare ad una situazione di accensione o spegnimento del diodo.

Per ovviare a questo problema bisogna riuscire a identificare il momento esatto in cui il pulsante viene premuto è questo può essere fatto conservando in una variabile lo stato del pulsante al passo precedente:

// Esempio 03: antirimbalzo
// accendi il led appena è premuto il pulsante mantenendolo acceso quando si rilascia
// premendo una seconda volta il pulsante spegne il led

#define LED 13                // LED collegato al pin digitale 13
#define BUTTON 7              // pin di input dove è collegato il pulsante
int val = 0;                  // si userà val per conservare lo stato del pin di input
int vecchio_val = 0;          // si userà vecchio_val per conservare lo stato del pin di input al passo precedente
int stato = 0;                // ricorda lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso

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

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

  // controlla se è accaduto qualcosa
  if ((val == HIGH) && (vecchio_val == LOW)){
    stato = 1 - stato;
  } 

  vecchio_val = val;            // ricordiamo il valore precedente di val

  if (stato == 1) {
    digitalWrite(LED, HIGH);   // accende il led
  }
  else {
    digitalWrite(LED, LOW);    //spegne il led
  }
}

In questo caso usiamo la variabile vecchio_val per conservare lo stato al ciclo precedente, in questo modo verifichiamo lo stato effettivo del pulsante verificando se lo stato attuale è “pulsante premuto” E “pulsante non premuto al passo precedente“, se la condizione è vera viene modificato lo stato.
L’operatore boleano utilizzato è AND che nel linguaggio di programmazione si indica con &&.

La cosa più bella nell’applicare l’informatica al mondo reale e che è indispensabile far i conti con le caratteristiche fisiche dei dispositivi su cui operiamo.
Come potete vedere dal filmato, non appena aumentiamo la frequenza con cui premete il pulsante, si ricade in una situazione di incongruenza per cui il led non risponde più ai comandi. Questo problema avviene perché il pulsante è un apparato meccanico costituito da contatti elettrici ed una molla, quando premiamo e rilasciamo, si manifestano situazioni di rimbalzo del contatto che creano dei segnali non corretti, detti spuri, che modificano lo stato del diodo led.

Per risolvere il problema è sufficiente attendere che questi rimbalzi spuri si concludano e quindi bisogna attendere una certa quantità di tempo dopo che è stato rilevato un cambiamento di stato, provate con valori non superiori a 50 millisecondi, nell’esempio ho introdotto un valore di 15 millisecondi di ritardo.

// Esempio 04: antirimbalzo2 - accendi il led appena è premuto il pulsante mantenendolo acceso quando si rilascia
// premendo una seconda volta il pulsante spegne il led

#define LED 13                // LED collegato al pin digitale 13
#define BUTTON 7              // pin di input dove è collegato il pulsante
int val = 0;                  // si userà val per conservare lo stato del pin di input
int vecchio_val = 0;          // si userà vecchio_val per conservare lo stato del pin di input al passo precedente
int stato = 0;                // ricorda lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso

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

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

  // controlla se è accaduto qualcosa
  if ((val == HIGH) && (vecchio_val == LOW)){
    stato = 1 - stato;
    delay(15);                // attesa di 15 millisecondi
  } 

  vecchio_val = val;            // ricordiamo il valore precedente di val

    if (stato == 1) {
    digitalWrite(LED, HIGH);   // accende il led
  } 
  else {
    digitalWrite(LED, LOW);    //spegne il led
  }
}

Ora come esercizio uniamo ciò che abbiamo imparato nella lezione n. 2 e ciò che abbiamo imparato in questa lezione.

Esercizio:
realizzare un programma che esegue questa funzione: quando si preme un pulsante il diodo led lampeggia, quando premo una seconda volta il pulsante il led termina di lampeggiare:

// Esempio 05: led lampeggia se premo il pulsante
// premendo una seconda volta il pulsante si spegne il led

#define LED 13                // LED collegato al pin digitale 13
#define BUTTON 7              // pin di input dove è collegato il pulsante
int val = 0;                  // si userà val per conservare lo stato del pin di input
int vecchio_val = 0;          // si userà vecchio_val per conservare lo stato del pin di input al passo precedente
int stato = 0;                // ricorda lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso

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

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

  // controlla se è accaduto qualcosa
  if ((val == HIGH) && (vecchio_val == LOW)){
    stato = 1 - stato;
    delay(15);                // attesa di 15 millisecondi
  } 

  vecchio_val = val;          // ricordiamo il valore precedente di val

    if (stato == 1) {
    digitalWrite(LED, HIGH);  // accende il LED
    delay(1000);              // aspetta un secondo
    digitalWrite(LED, LOW);   // spegne il LED
    delay(1000);              // aspetta un secondo
  }
  else {
    digitalWrite(LED, LOW);    //spegne il led
  }
}

Un piccolo esercizio.
Se provate ad aumentare la frequenza con cui premete il pulsante noterete che non riuscite a spegnere il diodo led, siete in grado di risolvere questo problema?

Buon Lavoro :-)


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, elettronica e contrassegnata con , , . Contrassegna il permalink.

56 risposte a Arduino – lezione 03: controlliamo un led con un pulsante

  1. Fabio scrive:

    Salve prof.
    Ho provato a fare un nuovo esempio.
    Vedendo script non ho potuto resistere :D

    Non ho potuto verificarne il funzionamento, ma credo che almeno in compilazione non ci siano errori.

    // 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;
      }
    }

    Per quanto riguarda quella domanda…sicuramente la causa di quel problema sono i 15ms di attesa, credo che basterebbe verificare lo stato precedente del pulsante con lo stato attuale, se questi due sono uguali il pulsante non è stato premuto e si va avanti, no? Credo che infatti nel mio esempio non dovrebbero servire, ma come ho già detto, non ho modo di verificarlo =)

    • admin scrive:

      Ciao Fabio.

      Estendo la spiegazione che a dicembre ti avevo dato a lezione con la lezione n. 4′ su Arduino: realizzare un programma che identifica le variazioni di stato.
      Trovi tutti gli approfondimenti seguendo il link.

      Saluti.

  2. pss scrive:

    Salve,
    Io l’esempio numero 4 l’avrei fatto in questo modo:

    #define Led 13
    #define Button 2
    boolean val1 = 0;
    
    void setup() {
      pinMode(Led, OUTPUT);
      pinMode(Button, INPUT);
    }
    void loop() {
      boolean Val = digitalRead(Button);
    
      if (Val== 1){ 
        val1 = 1 -val1;
      } 
      if (val1== 1) {
        digitalWrite( Led,HIGH);
        while(Val== 1){
          Val = digitalRead(Button);
        }
      }
    
      else {
        digitalWrite( Led, LOW);
        while(Val== 1){
          Val = digitalRead(Button);
        }
      }  
    }
    
  3. Aldo Biscotti scrive:

    Buon giorno Professore e a tutti i lettori,
    mi chiamo Aldo Biscotti e sono un esordiente in questa materia.
    Sono affascinato dalle tue lezioni, dove sto anzi spero di imparare un po’ di questa tecnica
    di programmazione.
    Sto cercando di cimentarmi con arduino 2009, vorrei realizzare un software che mi permetta di illuminare le scale di casa, non ti nascondo che forse, anzi sicuramente, mi sono avventurato in un
    progetto troppo ambizioso x me, questa cosa ormai e’ diventata un’ ossessione prendendomi tutto il tempo libero e buona parte della notte.
    Prima di iniziare, ti voglio ringraziare per la pubblicazione della lezione 3: come accendere un led con un interruttore, e seguendo i tuoi consigli, ho continuato a provare, provare e ancora provare e con grande soddisfazione mi ha fatto raggiungere parte dell’ obbiettivo, ovvero l’inserimento di un interruttore per far partire un software non ciclato.
    Avevo gia’ letto la lezione, ma non le ho dato la giusta importanza proprio perche’ sono un principiante e ho iniziato dall’ effetto che desideravo, riflettendoci ho capito che avrei iniziato dalla fine. Avendo gia’ una parte di programma invece di adattare il sensore o l’interruttore a quest’ultimo, ho pensato fosse piu’ logico prendere lo sketch del pulsante, modificarlo adattandolo alle mia necessita’ e con mia grossa sorpresa ha funzionato.
    Ora sono arrivato al momento del raddoppio, cioe’ l’ inserimento di un secondo interruttore che serve ad avviare in modo inverso l’ accensione dei led, guarda ho provato in tutti i modi ma niente da fare, non funziona. Se hai tempo, potresti dare un’ occhiata ai miei sketch e come ho interpretato il software, e darmi un consiglio?
    Ecco cosa vorrei realizzare: l’ esempio riportato e’ di due led che simulano due gradini, ovviamente basta aggiungere tanti led quanti gradini bisogna illuminare e i tempi di delay sono simbolici.
    TARGET: ( I pulsanti 1 e 2 saranno sostituiti da sensori di presenza anche se non so cosa usare l’importante e’che non facciano partire il ciclo al passaggio del cane o del gatto. )
    Pulsante 1: (salita) start, accensione del led 1, dopo 2 secondi accensione led 2, dopo 2 secondi spegnimento led 1, dopo 2 secondi spegnimento led 2, end.
    Pulsante 2: (discesa) start, accensione del led 2, dopo 2 secondi accensione led 1, dopo 2 secondi spegnimento led 2, dopo 2 secondi spegnimento led 1, end.

    Inizio con la prima modifica dello sketch dell’ interruttore:

    int led_1 = 8;  
    int led_2 = 9; 
    int btn_pin = 2;  
        
    void setup() {  
         pinMode(led_1, OUTPUT);  
         pinMode(led_2, OUTPUT);  
         pinMode(btn_pin, INPUT);  
    }  
        
    void loop()  
    {  
         int in = digitalRead(btn_pin);  
         if (in == LOW)  
         {  
             digitalWrite(led_1, LOW); 
             delay (2000); 
             digitalWrite(led_2, LOW);  
             delay (2000); 
         }  
          else
         {  
             digitalWrite(led_1, HIGH); 
             delay (2000);
             digitalWrite(led_2, HIGH);
             delay (2000);
             
         }  
    }
    

    Questo sketch gira benissimo: start, accensione del led 1, dopo 2 secondi accensione led 2, dopo 2 secondi spegnimento led 1, dopo 2 secondi spegnimento led 2, end.
    Proprio quello che volevo, non male vero? Pensare che solo due mesi fa pensavo ad Arduino come ad un vecchio compagno delle elementari.
    Dovendo inserire il secondo pulsante per il senso inverso, inizialmente ho pensato a questo sketch:

    int led_1 = 8;  
    int led_2 = 9; 
    int btn_pin_1 = 2;  
    int btn_pin_2 = 3;  
        
    void setup() {  
         pinMode(led_1, OUTPUT);  
         pinMode(led_2, OUTPUT);  
         pinMode(btn_pin_1, INPUT);  
         pinMode(btn_pin_2, INPUT);
    }  
        
    void loop()  
    {  
         int in = digitalRead(btn_pin_1);  
         if (in == LOW) 
         int in = digitalRead(btn_pin_2);  
         if (in == LOW)   
         {  
             digitalWrite(led_1, LOW); 
             delay (2000); 
             digitalWrite(led_2, LOW);  
             delay (2000); 
         }  
          else
         {  
             digitalWrite(led_1, HIGH); 
             delay (2000);
             digitalWrite(led_2, HIGH);
             delay (2000);
         }
         
        
         { 
        digitalWrite(led_2, LOW); 
             delay (2000); 
             digitalWrite(led_1, LOW);  
             delay (2000);    
         } 
     
         {
           
        digitalWrite(led_2, HIGH); 
             delay (2000);
             digitalWrite(led_1, HIGH);
             delay (2000);
         }
    }
    

    Ho eseguito il test prima del upload, perfetto non dava errori, ma scaricandolo su arduino una gran delusione, non rispetta i tempi, cicla, insomma un fallimento, ho abbandonato lo sketch.
    Sono trooooppo scarso……….
    Il giorno seguente a forza di pensarci mi e’ venuta una nuova idea:

    int led_1 = 8;  
    int led_2 = 9; 
    int btn_pin_1 = 2;  
    int btn_pin_2 = 3;  
        
    void setup() {  
         pinMode(led_1, OUTPUT);  
         pinMode(led_2, OUTPUT);  
         pinMode(btn_pin_1, INPUT);  
         pinMode(btn_pin_2, INPUT);
    }  
        
    void loop()  
    {  
         int in = digitalRead(btn_pin_1);  
         if (in == LOW) 
         
         {  
             digitalWrite(led_1, LOW); 
             delay (2000); 
             digitalWrite(led_2, LOW);  
             delay (2000); 
         }  
          else
         {  
             digitalWrite(led_1, HIGH); 
             delay (2000);
             digitalWrite(led_2, HIGH);
             delay (2000);
         }
         int in = digitalRead(btn_pin_2);  
         if (in == LOW)   
        
         { 
        digitalWrite(led_2, LOW); 
             delay (2000); 
             digitalWrite(led_1, LOW);  
             delay (2000);    
         } 
        else
         {
           
        digitalWrite(led_2, HIGH); 
             delay (2000);
             digitalWrite(led_1, HIGH);
             delay (2000);
         }
    }
    

    Mi sembrava piu’ equilibrato piu’ pulito del precedente ma non va’, mi da’ errore sul secondo pulsante.
    Mi sorge un dubbio: si puo’ mettere 2 o piu’ interruttori per eseguire un software? Secondo me si. COME SI FA’?
    Puoi darmi un aiuto?
    Ti ringrazio anticipatamente un caloroso saluto .
    Aldo

  4. pss scrive:

    @Aldo Biscotti
    ti da l’errore perché dichiari due volte la variabile “in”.
    Comunque credo che si dovrebbero usare due variabili invece di una.
    Ciao, spero di esserti stato utile.

  5. Aldo Biscotti scrive:

    Grazie Pss, provo a fare dei test ma non saprei proprio che variabili mettere puoi fare
    degli esempi?
    Ciao e grazie di nuovo.

  6. admin scrive:

    Ciao Aldo.
    Ho risposto alla tua domanda, sull’accensione delle luci delle scale di casa tua, con il post: Arduino – lezione 05: controllo presenza. Se hai dubbi scrivi quando vuoi.
    Contrariamente a quanto ti avevo promesso ho pensato di realizzare una lezione specifica (la prossima) sulla modulazione di larghezza di impulso (PWM) per il controllo della luminosità dei LED. Ho notato che la lezione 5 stava diventando troppo corposa ed ho pensato di spezzarla in due.
    Credo di pubblicare in settimana la lezione 6.

    Un caro saluto.

  7. massimo scrive:

    grazie mille per il tutorial: veramente spiegato bene e utile!

    Ho una domanda: al posto del LED ho voluto alimentare una piccola ventolina che da 5V, 1W.

    Se attacco la ventola al catodo GND e all’anodo da 5V (o anche quello da 3.3V) funziona, invece se inserisco la ventola nel circuito al posto del LED con l’intento di comandarla con il pulsante non funziona.

    Dov’è il problema? All’uscita del pin13 non ci sono abbastanza volt?

  8. admin scrive:

    Ciao Massimo.
    Grazie per aver letto la mia lezione.

    Innanzitutto mi permetto, non sapendo quali sono le tue conoscenze di elettronica, di fare alcune precisazioni che ti serviranno per procedere nello studio dell’elettronica e dell’uso di Arduino.

    Una ventola (motorino elettrico) non ha un anodo ed un catodo, parliamo ad esempio di anodo e catoto in un diodo. In un motore, ad esempio in CC abbiamo un positivo ed un negativo.
    Non si tratta della quantità di volt presenti sul pin 13, ma della corrente necessaria al motorino per funzionare, in teoria per piccoli motorini che non hanno un assorbimento elevato di corrente, si potrebbe riuscire a far funzionare il motorino collegandolo direttamente tra un pin digitale e GND (ground = terra), ma meglio non procedere in questo modo.

    Tieni in conto che quando il campo magnetico di un motorino viene interrotto (quando togli alimentazione) si viene a creare ai capi del motorino una tensione elevate, puoi verificare questo ad esempio quando colleghi una batteria ai capi di un motorino e poi lentamente scolleghi un terminale, se vedi una scintilla vuol dire: “tanti volt” in grado di provocare danni alla tua scheda e per ovviare a questo inconveniente dovresti assolutamente procedere in altro modo.

    Ti accenno velocemente come funziona il circuito tralasciando le spiegazioni teoriche che dovrai approfondire e che prevedono i seguenti prerequisiti:

    sapere come funziona un diodo ed un transistor ed un motorino in CC.

    Il circuito che dovresti realizzare è il seguente:

    che fornisce sufficiente corrente per poter pilotare un motorino piccoli, simile a quelli dei modellini.

    Questa la lista componenti

    R: 2,2 K Ohm
    D: Diodo 1N4001
    Tr: Transistor P2N2222

    Come transistor puoi usare al posto di un 2N2222 anche un 2N3904.

    Un transitor ha 3 piedini chiamati: emettitore, base e collettore e possono essere di tipo NPN o PNP. Per un transistor NPN come quello del disegno si collegherà il carico (nel tuo caso il motorino) al collettore e l’emettitore a massa.

    Questa configurazione si chiama pilotaggio on/off di un motore.

    Il transistor lavora in commutazione (come un interruttore) cioè o in conduzione o come circuito aperto. Nello schema come vedi è presente anche il diodo ai capi del motore, questo diodo evita il problema della tensione elevata (la scintilla di cui sopra).

    Quando il transistor entra in conduzione la tensione ai suoi capi è prossima a 0 volt invece quella presente ai capi del motore è praticamente la Vcc (5V nel nel disegno), in questo caso il motore gira alla velocità massima.
    Quando la tensione sulla base è 0V (sul pin9 abbiamo un livello basso) il transitor non conduce, si comporta come un circuito aperto ed il motore non gira.

    Quindi il motore o è fermo oppure gira alla velocità massima e quindi con questo circuito non puoi regolare la velocità di rotazione, ma in ogni caso può servire per incominciare a fare qualche esperimento ed approfondire gli aspetti teorici.

    Saluti.

  9. massimo scrive:

    grazie mille per la spiegazione dettagliata!

    Se ho capito bene con l’interruttore a pulsante dovrei controllare il transistor che funge da interruttore per il motore elettrico. Giusto?

    domanda: nel mio kit sono presenti anche dei Transistor NPN BC547B. Possono andare bene? come faccio a identificare sul componente i pin B, C, E?

    continuero’ a seguire con molta attenzione le tue lezioni : )

  10. admin scrive:

    Ciao Massimo.

    Si, con il pulsante fai in modo tale che sul pin9 vi sia un valore “ALTO” o “BASSO” e ti permetterà di controllare l’accensione del motorino attraverso il transistor.

    Il transitor che hai indicato, guardando velocemente le caratteristiche, dovrebbe andare bene. Per identificare base emettitore e collettore segui il link al datasheet del transistor NPN BC547B

    Saluti.

  11. massimo scrive:

    grazie Michele per la disponibilita’,

    una piccola domanda: come faccio a determinare il valore della resistenza da mettere sulla BASE del transistor?

    la ricavo prendendo il volore di corrente “I- peak base current” sul datasheet e inserendola nella formula V=RI (dove V=5V)?

  12. admin scrive:

    Ciao Massimo.

    Dovresti ricavare dalle caratteristiche del motorino elettrico la corrente massima di assorbimento, che è la corrente Ic (corrente di collettore).
    Dalle specifiche del transistor ti vai a cercare il valore di Hfe e poi per il calcolo della Ib (corrente di base) applichi la formula:

    Ib = Ic / Hfe

    Ti ricavi la differenza di potenziale ai capi della R sapendo che in uscita al pin9 di Arduino quando abbiamo un valore “ALTO” hai 5V, sapendo che la d.d.p. tra base ed emettitore è di circa 0,6 volt, allora sulla R avrai:

    Vr = 5 – 0,6 = 4,4 V

    Applichi la legge di ohm:

    R = V/I

    e ti ricavi la R da inserire nel tuo circuito.

    Ciao.

  13. massimo scrive:

    corrente nominale ventola: 180mA

    Ib = Ic / Hfe= 180/150=1,2mA
    Vr = 5 – 0,6 = 4,4 V

    R = V/I=4,4/0,0012=3660 Ohm=3,6 kOhm

    E’ corretto? Cosa succede se metto una resistenza inferiore a 3,6 kOhm? Si danneggia il transistor?

  14. massimo scrive:

    Ho appena fatto il circuito che mi hai mostrato inserendo una ventolina come motore M.

    Ho un piccolo problema:

    - ho inserito la ventola ma non gira

    ho provato a inserire un LED al posto della ventola per verificare se i collegamenti con il transistor sono corretti: il led si accende e si spegne correttamente con il segnale del pulsante.

    Allora ho provato a misurare la tensione ai capi del LED: il multimetro segna appena 3V, non raggiungo 5V. E’ questo il problema? come faccio a risolverlo?

  15. Fabio scrive:

    Ciao massimo.
    Credo che rilevi circa 3v perché, proprio come oggi mi spiegava il professore, sul pin 13 e già presente una resistenza interna ad arduino.
    Come consiglio, prova a cambiare pin.

    Ciao!

  16. admin scrive:

    Ciao Massimo.

    Scusa per il ritardo, ma ho avuto giorni lavorativi di fuoco.

    Si, il calcolo che hai fatto per la resistenza è corretto, se sottostimi la resistenza potrebbe rovinarsi il transistor, ma dipende anche dal carico (in questo caso il motorino) e quindi dalla corrente di collettore.
    Per quanto riguarda il non funzionamento del motorino, ciò che dice Fabio è corretto, se colleghi al pin 13 potresti avere dei problemi, collega ad altro pin.

    In ogni caso prova in questo modo:

    scollega il motorino e mantieni il diodo collegato in parallelo e collega in serie al motore un multimetro in modalità amperometro, aumenta pian piano la tensione e verifica quale è la corrente che vi circola quando incomincia a funzionare, questa è la corrente che userai come Ic, usa questa nel calcolo della corrente di base Ib e dalle formule sopra ricavati la Rb.

    Fammi sapere.

    Saluti.

  17. massimo scrive:

    Ho fatto due misure con il tester ma non capisco

    - ho attaccato la ventola all’alimentazione da 5V, ho misurato con il tester una corrente di 250mA (andando a mettere i capi del tester sul capi dei fili della ventola tutta la corrente andava sul tester e la ventola smetteva di girare)

    nel circuito con il transistor non funziona perchè non arriva corrente sufficiente al collettore? (max 200 mA da datasheet)

  18. Antonino scrive:

    Salve, sto aspettando che mi arrivi arduino per cimentarmi in questo nuovo mondo :)
    Grazie per questi tutorial che sono veramente utili per chi si avvicina a questa realtà.
    Domandina da novellino (non ho mai studiato elettronica e cose del genere, programmo in c e c++ sotto linux da oltre 10 anni per passione ed ho cominciato ad amare i computer nel 1980 sig… quanto tempo =I).
    A che serve la resistenza dello schema (non mi piace copiare bovinamente:P) ?
    Sarebbe utile, se vorresti astendere l’uso di questi tutorial anche a quelli come me, se oltre a spiegare il programma passo passo, che tra l’altro fai benissimo) faresti lo stesso con lo schema elettrico (ovviamente poi chi lo desidera approfondirà le cose) .

    • admin scrive:

      Ciao Antonino.

      Originariamente le lezioni erano pensate per i miei studenti di elettronica, peró molti utenti come te sempre più spesso chiedono approfondimenti di elettronica, per cui ok cercheró di spiegare con maggior dettaglio questo aspetto.
      Non riesco nell’immediato ad ampliare le lezioni realizzate, ma cercherò appena di rientro dalle vacanze di fare i dovuti ampliamenti e magari miglioreró anche la sezione elettronica per principianti. Per quanto riguarda la resistenza a cui fai riferimento, prova a realizzare lo schema elettrico noterai subito che se non ci fosse la R quando il pulsante viene premuto metteresti in corto + 5V con GND.
      Ti sto rispondendo con il cell, appena mi è possibile ti faccio un piccolo schema e ti spiego con maggior precisione.

      Grazie per il tuo commento.
      Saluti.

  19. Federico scrive:

    Salve, complimenti per la chiarezza espositiva.
    Vorrei chiederle a cosa serve la resistenza collegata all’interruttore.
    Chiedo anche come mai si collega un led direttamente ad Arduino se la tensione di uscita è di 5V, non dovrebbe bruciare?
    Grazie.

  20. Etti scrive:

    Salve, domanda a parte il cicuitino anti rimbalzo del pulsante che fa sempre bene anche se io ci mettere un condensatore e non solo la resistenza ma forse andava bene nella logica cablata, ma se usassimo l’interrupt o IRQ che quando arriva il segnale del pulsante controlla lo stato del led e controlla la variabile o stato precedente se il pulsante era stato premuto di conseguenza compie lo spegnimento o l’accensione dello stesso led al nuovo comando e ne memorizza lo stato?
    Ps. Non conosco le istruzioni per tanto non presento un’elaborato, comunque è meraviglioso usare anche se con qualche variante il linguaggio C……anche se mi manca la funzione main(), prendendo spunto dalla funzione main la funzione setup() restituisce dei valori che potrebbe andare bene per un’altro Hardware collegato in seriale o con una memoria in comune?
    Ciao

  21. franco scrive:

    Prima di tutto bravo all’amministratore del sito e per l’aiuto che offre.

    Vorrei inserire 4 pulsanti al bellissimo progetto qui sopra, che inserisca un colore personalizabile al led (io ho fatto tutto con un rgb) ed elimini il loop automatico del set di colori preimpostati .
    esempio:
    pulsante 1 rosso
    pulsante 2 viola
    pulsante 3 blu
    vi chiederete: e il pulsante 4? beh, che ritorni il loopautomatico.
    se qualcuno mi può aiutare?

    • franco scrive:

      ops, mi sono dimenticato codice loop automatico :
      /*Programma iniziale di April 2007, Clay Shirky
      * tradotto e modificato da Fabio Casson
      */

      // Output
      int redPin = 4; // Red LED, connesso al pin 9
      int grnPin = 5; // Green LED, connesso al pin pin 10
      int bluPin = 6; // Blue LED, connesso al pin pin 11

      // Colori arrays
      int black[3] = { 0, 0, 0 };
      int white[3] = { 100, 100, 100 };
      int red[3] = { 100, 0, 0 };
      int green[3] = { 0, 100, 0 };
      int blue[3] = { 0, 0, 100 };
      int yellow[3] = { 40, 95, 0 };
      int dimWhite[3] = { 30, 30, 30 };
      // etc.

      // set di colori iniziali
      int redVal = black[0];
      int grnVal = black[1];
      int bluVal = black[2];

      int wait = 30; // 30ms interni (crossFade) di attesa; incremento tra fade di colori
      int hold = 0; // Opzionale da tenere quando un colore è completo, prima della dissolvenza tra grossfade
      int DEBUG = 1; // DEBUG contatore; se e settato a 1, scriverà i valori con seriale
      int loopCount = 60; // ogni quanto il DEBUG rapporto?
      int repeat = 0; // Quante volte facciamo il ciclo prima di fermarsi? (0 per continuo)
      int j = 0; // Contatore del ciclo per ripetere

      // Inizializzazione colori variabili
      int prevR = redVal;
      int prevG = grnVal;
      int prevB = bluVal;

      // Settaggio delle uscite dei LED (qui si usa un rgb e non tre led)

      void setup()
      {
      pinMode(redPin, OUTPUT); // settaggio dei pin in output
      pinMode(grnPin, OUTPUT);
      pinMode(bluPin, OUTPUT);

      if (DEBUG) { // Se vogliamo vedere i valori per il debug
      Serial.begin(9600); // …settaggio della porta seriale
      }
      }

      // programma Principale : lista dell’ordine delle dissolvenze incrociate
      void loop()
      {
      crossFade(blue);
      crossFade(yellow);
      crossFade(blue);
      crossFade(yellow);
      crossFade(red);
      if (repeat) { // Abbiamo un ciclo di numero finito di volte?
      j += 1;
      if (j >= repeat) { // siamo arrivati?
      exit(j); // Se è così, stop.
      }
      }
      }

      /* Sotto di questa linea ‘LA MATEMATICA” non dovrebbe essere necessario per cambiare questo per le basi
      *
      * Il programma funziona in questo modo:
      * Immaginate una dissolvenza incrociata che si muove cosi: LED rosso 0-10,
      * Il verde da 0-5, e l’azzurro 10-7, in
      * Dieci passi.
      * si vuole contare i 30 passi e aumentare o
      * Diminuire i valori dei colori, con incrementi in modo uniforme a gradini.
      * Immaginate un + indicaca, sollevando un valore di 1, e una -
      * Uguale abbassandolo. la nostro dissolvenza punto 30 sarà simile:
      *
      * 1 2 3 4 5 6 7 8 9 10
      * R + + + + + + + + + +
      * G + + + + +
      * B – – -
      *
      * Il rosso sale da 0 a 30 in trenta passi, il verde da
      * 0-15 in 15 fasi, e l’azzurro scende dal 30-7 in 23 fasi.
      *
      * Nel programma vero, le percentuali dei colori vengono convertiti in
      * 0-255 valori, e ci sono 1020 punti (255 * 4).
      *
      * Per capire quanto è grande un passo ci dovrebbe essere tra un up-o
      * Down-tick di uno dei valori a LED, che noi chiamiamo calculateStep (),
      * Che calcola la distanza assoluta tra i valori iniziale e finale,
      * E poi divide divario da 1020 per determinare la dimensione del passo
      * Tra rettifiche di valore.
      * /

      int calculateStep(int prevValue, int endValue) {
      int step = endValue – prevValue; // Qual è la distanza complessiva?
      if (step) { // se non è zero,
      step = 1020/step; // divide per 1020
      }
      return step;
      }

      / * La funzione successiva è calculateVal. Quando il valore del ciclo, i,
      * Raggiunge il passo appropriato per uno dei
      * Colori, aumenta o diminuisce il valore di quel colore di 1.
      * (R, G e B sono tutte calcolate separatamente.)
      * /

      int calculateVal(int step, int val, int i) {

      if ((step) && i % step == 0) { // Se il passo è diverso da zero e arrivato il tempo di cambiare un valore,
      if (step > 0) { // incrementare il valore se il step è positivo …
      val += 1;
      }
      else if (step 255) {
      val = 255;
      }
      else if (val < 0) {
      val = 0;
      }
      return val;
      }

      /* crossFade():converte i colori ad una percentuale
      * 0-255 gamma, loop poi 1020 volte, controllare se
      * Il valore deve essere aggiornato ogni volta, poi la scrittura
      * Il colore valori ai pin corretti.
      * /

      void crossFade(int color[3]) {
      // Convert to 0-255
      int R = (color[0] * 255) / 100;
      int G = (color[1] * 255) / 100;
      int B = (color[2] * 255) / 100;

      int stepR = calculateStep(prevR, R);
      int stepG = calculateStep(prevG, G);
      int stepB = calculateStep(prevB, B);

      for (int i = 0; i <= 1020; i++) {
      redVal = calculateVal(stepR, redVal, i);
      grnVal = calculateVal(stepG, grnVal, i);
      bluVal = calculateVal(stepB, bluVal, i);

      analogWrite(redPin, redVal); //Scrivi i valori correnti ai pin LED
      analogWrite(grnPin, grnVal);
      analogWrite(bluPin, bluVal);

      delay(wait); // Pausa per 'attendere' millisecondi prima di riprendere il ciclo
      if (DEBUG) { // Se vogliamo stamparlo all'uscita della seriale,
      if (i == 0 or i % loopCount == 0) { // all'inizio e ad ogni giro (loopCount)
      Serial.print("Loop/RGB: #");
      Serial.print(i);
      Serial.print(" | ");
      Serial.print(redVal);
      Serial.print(" / ");
      Serial.print(grnVal);
      Serial.print(" / ");
      Serial.println(bluVal);
      }
      DEBUG += 1;
      }
      }
      // Aggiornare i valori correnti per il ciclo successivo
      prevR = redVal;
      prevG = grnVal;
      prevB = bluVal;
      delay(hold); // Pausa di millisecondi 'wait' opzionale prima di riprendere il ciclo
      }

  22. carlo scrive:

    ciao…perchè il mio pulsante premuto corrisponde a val=LOW??

  23. Dario scrive:

    Ottime lezioni interessantissime e utilissime. Sto provando a realizzare l’esempio della lezione 3 ma ho qualche problema: il led rimane acceso anche quando il pulsante non è premuto o meglio è acceso a una intensità minore di quella che si ha quando si preme il pulsante. La differenza di intensità è minima ma visibile. _Dove sbaglio? Grazie

  24. nicola scrive:

    Io non ho capito perchè il resistore dev’essere di 10 k ohm, cioè da che calcolo viene fuori 10kohm?

    • admin scrive:

      Ciao Nicola.

      Scusami se rispondo solo adesso.
      Lo schema elettrico del circuito è il seguente:

      schema elettrico

      La resistenza che vedi nel circuito è detta di pull down, questa resistenza consente di far si che nel momento in cui premo il pulsante (per rilevare lo stato HIGH) non si crei un cortocircuito tra Vcc e GND, cioè la resistenza limita la corrente che vi circola, inserendo una resistenza da 10KOhm avrai una corrente pari a: I = V/R = 5 V/10000 Ohm = 0,5mA.

      Puoi usare valori di resistenza anche superiori, in genere valori da 10K a 47K vanno bene.

      Saluti.

      • Samuele scrive:

        Buon giorno, mi scusi se mi intrometto, mi sono appena avvicinato al mondo di arduino anche se in passato ho avuto altre esperienze in questo campo.

        Dopo averci pensato un po’ ho capito che il suo circuito funziona perché quando si dichiara un pin in INPUT con l’apposita funziona viene attivata una resistenza interna al pin di 20Kohm. Diversamente il pin brucerebbe dato che la corrente segue la via di minor resistenza.

        Mi corregga se sbaglio, spero di essere stato utile e non aver creato confusione.

      • Mario scrive:

        Salve, ho un’unica perplessità. Arduino non ha già delle resistenze al suo interno che evitano la formazione di corti? Altra domanda riguardante però i pin configurati come output. 50 mA è la massima corrente che può erogare arduino o è il limite massimo da rispettare per evitare danni al pin? cioè se collego un pin output di arduino a qualcosa, devo preoccuparmi io di mantenere una corrente di 50 mA nel circuito (mediante eventuali resistenze) oppure il fatto che il pin sia in configurazione output mi garantisce che più di 50mA non fluiscono nel circuito (in questo caso anche collegare un pin output impostato su high direttamente su GND non mi darebbe alcun problema perché la corrente sarebbe fissata)? Chiedo scusa se ho scritto banalità o pronunciato assurdità ma sono abbastanza alle prime armi.

  25. Luigi Rosati scrive:

    Buongiorno Professore,
    prima di tutto complimenti per l’approccio con cui insegna ai suoi alunni questa materia.. sono davvero fortunati ad avere una persona come lei!!
    Sono neofita , arduino mi sta appassionando moltissimo ed ho cominciato a seguire le sue lezioni, volevo un chiarimentosul circuito qui illustrato:
    La resistenza messa in serie dopo il pulsante, serve per non generare un cortocircuito quando il pulsante è in condizioni normali?( cioè quando non vien premuto?)
    Grazie per la sua attenzione
    Saluti e complimenti ancora

  26. Roberto B. scrive:

    Salve sono uno Nuovo, ed ho appena comprato il mio primo Arduino e vi ringrazio xkè grazie a voi sto imparando ad usarlo (oggi è il mio primo giorno).
    Spero di essere riuscito a risolvere il problema (almeno credo, verificandolo così sembrerebbe) degli spuri come indicato nella lezione, e omettendo il ritardo del pulsante, aggiungendo la variabile di vecchio stato all’esterno del ciclo di pressione del pulsante ed inserendolo in uno nuovo di ciclo di pulsante non premuto.
    (non credo di essere stato esauriente, sono alle prime armi con Arduino, in elettronica ,e nei Forum, quindi spero si comprenda meglio leggendo il codice riportato di seguito)
    Datemi le vostre impressioni e suggerimenti, migliorire… Ecco il codice:
    // Accendere e spegnere il led ad ogni pressione del pulsante (pulsante come interruttore)

    #define Led13 13 // LED13 collegato al pin digitale 13
    #define Pulsante 7 // pin di input dove è collegato il pulsante
    int Valore = 0; // per conservare lo stato del pin di input (pulsante)
    int Stato = 0; // per conservare lo stato del led
    int OldStato = 1; // per effettuare l’autoritenuta del pulsante salvando lo stato precedente

    void setup() {
    pinMode(Led13, OUTPUT); // imposta il pin digitale come output per il led
    pinMode(Pulsante, INPUT); // imposta il pin digitale come input per il pulsante
    Serial.begin(9600); // Non importante se non si vuole vedere a monitor il cambio delle variabili
    }

    void loop() {
    Valore = digitalRead(Pulsante); // legge il valore dell’input e lo conserva ( stato del pulsante)
    if ((Valore == HIGH) && (Stato ==0) && (OldStato == 1) ) { // 101 controlla che l’input sia HIGH (pulsante premuto) se il led è spento( 0 ) e lo stato prencedente del led era acceso (1)
    digitalWrite(Led13, HIGH); //accende il led
    Stato = 1; } // => -1- imposta lo Stato ad 1

    if ((Valore == HIGH) && (Stato ==1) && (OldStato == 0) ) { // 110 controlla che l’input sia HIGH (pulsante premuto) se il led è acceso( 1 ) e lo stato prencedente del led era spento (0)
    digitalWrite(Led13, LOW); // spegne il led
    Stato = 0; } //=> -0- imposta lo Stato su 0

    if ((Valore == 0) && (Stato == 1) && (OldStato == 1) ) { // 011 controlla che l’input sia 0 (pulsante NON premuto = LOW ) se lo Stato del led è acceso ( 1 ) e lo stato prencedente del led era acceso (1)
    OldStato = 0; } // => 0-0 modifica il OldState (il vecchio stato) su 0
    if ((Valore == 0) && (Stato == 0) && (OldStato == 0)) { // 000 controlla che l’input sia 0 (pulsante NON premuto = LOW ) se lo Stato del led è spento ( 0 ) e lo stato prencedente del led era acceso (0)
    OldStato = 1; } // => 0-1 modifica il OldState (il vecchio stato) su 1
    }

  27. luigi scrive:

    premetto che sono un neofita di arduino, nella lezione 3 (controlliamo un led con un pulsante) ho scritto il listato esempio 04 alla righa 12(piMode(BUTTON,INPUT); mi errore dove dice il pulsante non e stato dichiarato in questo ambito.qualquno puo aiutarmi a capire dove sbaglio? grazie

  28. claudio scrive:

    Caro professore,
    Mi sto avvicinando con circospezione all’elettronica e ad Arduino. Sto seguendo le sue indicazioni e i suoi esempi che trovo utilissimi. Ora sono alle prese con pulsanti, led, motori passo-passo e programmazione C (in una vita passata ho usato assembler IBM, COBOL, FORTRAN, VBASIC, PASCAL, Java, lisp… ma elettronica e C mi mancavano proprio!).
    Ho un dubbio sulle resistenze di Pull-up down. Dopo aver spulciato un pò di siti avevo deciso che una resistenza di 1.5 o 2 KOhms poteva andare bene e poi sono inciampato sul forum e, a valle di una risposta da lei data a un nibbio come me, mi sono ritrovato con un valore di 10 KOhms. Devo dire che ci ho battuto un pò la testa sino a quando non ho verificato la formula di esempio da lei utilizzata.

    Sbaglio o il valore della corrente è 0,5 mA? Per cui la mia resistenza da 1.5 KOhms può andare bene.
    Molti ringraziamenti per le sue lezioni.
    Claudio

    • admin scrive:

      Ciao Claudio.

      Si hai ragione tu, scusami tanto, ho fatto io un’errore ed ho corretto, la corrente è di 0,5 mA.
      Un valore di 1,5 KOhm va bene lo stesso, tieni in conto però che così facendo la corrente che scorre nella R è più elevata e quindi si spreco un po’ più di energia.

  29. federico scrive:

    ciao sono federico
    vorrei chiederti se potresti aiutarmi a fare l’implementazione di questo programma:
    comandare un led con due bottoni
    il primo lo accende
    il secondo lo spegne
    grazie

    • admin scrive:

      Ciao Federico.

      Incomincio a realizzare questi due programmi indipendenti:
      1. realizza un primo sketch in cui accendi un LED che inizialmente è spento.
      2. realizza un secondo circuito in cui spegni un LED che inizialmente e acceso.

      Prova a ragionare come integrare queste due funzionalità.
      Fammi sapere.

  30. Andrea M. scrive:

    Buongiono Professore.
    Mi volevo congratulare con Lei per gli esempi che ha codiviso con tutti. Sono molto chiari ed esplicativi. Premetto che sono un principiante avendo comprato una scheda aeduino UNO da meno di una settimana. Sto seguendo i suoi esempi passo passo per fare esperienza.
    Lo scopo del mio lavoro è quello di poter acquisire dei dati che provengono da un ponte estensimetrico opportunamente amplificato. Hai dei consigli su come posso immagazzinare in un file in funzione del tempo sul PC utilizzando Arduino? Mi aiuterebbe molto. La ringrazio anticipatamente.
    Distinti saluti
    Andrea M.

    • admin scrive:

      Gentile Andrea.

      La maniera più rapida che mi viene in mente potrebbe essere quella di implementare uno sketch Processing in grado di gestire il salvataggio dei dati provenienti da Arduino e farli salvare su PC.

      Cercherò, non prometto :-) di realizzare nel prossimo futuro qualche esempio.

      Saluti.

  31. colcyber scrive:

    Buongiorno,
    grazie per i tutorial,
    ho comprato Arduino da poco e mi sto cimentando con i primi esperimenti.
    ora mi metto a seguire anche le basi sull’elettronica che ha pubblicato, ma vorrei farle una domanda veloce,
    come mai la presenza della resistenza in questo circuito?
    pensavo che servissero per evitare sovraccarichi ai componenti, ma il led 13 ha una resistenza di suo (se non sbaglio), oppure la resistenza è messa li per il pulsante? come mai?

    grazie

    • admin scrive:

      Ciao.

      Se non metti la resistenza collegata al pulsante nel momento in cui premi il pulsante collegheresti direttamente +Vcc a massa creando un cortocircuito.

      Ciao.

  32. Massimiliano P. scrive:

    Gentile Prof. ,
    ma non esiste un modo per interrompere il loop.
    Es. premo il pulsante il led si accende per 1 sec o lampeggia con una certa frequenza e per un determinato tempo (dipende da cosa ho dichiarato nell’ if) , poi si spegne e posso ripremere il pulsante.
    Grazie e complimenti per la passione che mette nei suoi articoli.

    • admin scrive:

      Ciao Massimiliano.

      Non mi è ben chiaro ciò che mi chiedi.
      Ciò che si vuole realizzare con gli esempi esposti è quello di identificare il cambiamento di stato che si verifica quando premiamo o rilasciamo un pulsante, perché dovrei bloccare il loop?
      Fammi sapre, grazie.

      Saluti.

  33. Roberto scrive:

    Salve, è da pochissimo che sono entrato in questo mondo e ho già dei problemi di cui non capisco l’orinine.

    Procedo con i collegamenti per accendere il led tramite pulsante
    Collego il led al GND e al pin 13
    inserisco il filo al pin 7 … e solo che mi avvicino al filo ad una distanza di 3cm il led già si accende e se sposto la mano più lontano il led si spegne
    è normale?

    • admin scrive:

      Ciao Roberto.

      sei sicuro di aver definito tutto nel setup?


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

      Fammi sapere.
      Saluti.

  34. Dario scrive:

    potresti dirmi come collegare un servo a due pulsanti i quali debbano essere collegati a 2 pin digitali ?
    potresti inoltre scrivermi lo sketch in modo che premendo un pulsante incrementi la posizione del servo e premendo l’altro pulsante decrementi la posizione del servo?
    sottolineo che i pulsanti devono essere collegati a 2 pin digitali.

    grazie in anticipo.

  35. Andrea scrive:

    salve stò provando a utilizzare 2 pulsanti come interrutori come nel video che lei ha fatto, però con due pulsanti non ci riesco può darmi qualche consiglio ??

  36. Andrea scrive:

    int servo1=9;
    int servo2=10;
    int w=0;
    int y=0;
    int p1=12;
    int p2=13;
    int a=6;
    int b=7;
    int zio=0;
    void setup(){
    pinMode (servo1,OUTPUT);
    pinMode (servo2,OUTPUT);
    pinMode (p1, INPUT);
    pinMode (p2, INPUT);
    pinMode (a, OUTPUT);
    pinMode (b, OUTPUT);
    }

    void loop (){
    w= digitalRead(p1);
    y= digitalRead(p2);
    if ((w==HIGH)&&(y==LOW)&&(zio==0))
    {

    digitalWrite(a,HIGH);
    digitalWrite(b,HIGH);
    digitalWrite(servo2,HIGH);
    digitalWrite(servo2,LOW);
    digitalWrite(servo1,HIGH);
    delay(1.5);
    digitalWrite(servo1,LOW);
    delay(10);

    zio=1;
    delay(1000);

    }
    if ((w==LOW)&&(y==HIGH)&&(zio==1)){
    {

    digitalWrite(a,LOW);
    digitalWrite(b,LOW);

    digitalWrite(servo1,HIGH);
    delay(2.5);
    digitalWrite(servo1,LOW);

    delay(10);
    zio=0;
    delay(1000);
    }
    }}

    questo è il programma funziona però come vede stò comando 2 servi a rotazione continua è i pulsanti non riescono a comandare i servi gli alti stati sn 2 led ,può aiutarmi grazie

  37. domenico alfano scrive:

    Salve, è da poco tempo che uso Arduino e trovo le sue lezioni davvero fantastiche!

    Vorrei poter realizzare un sistema composto da 4 pulsanti ovvero 3 preset e 1 edit per poter memorizzare e richiamare le combinazioni di 3 led. il sistema funzionerebbe così :
    si schiaccia il pulsante edit ed il sistema entra in modalità memorizzazione delle combinazioni, si premono poi gli altri 3 pulsanti (relativi ai 3 led) in base alla combinazione che si vuole realizzare e poi per memorizzare la combinazione si schiaccia di nuovo edit.

    Una volta fatto questo torniamo nella modalità preset e quindi schiacciando uno dei 3 pulsanti preset si richiama uno delle 3 combinazioni precedentemente memorizzate.

    Ad ogni riaccensione di arduino il sistema dovrà poi partire sempre dalla modalità preset.

    E’ complicato realizzare una cosa del genere, magari anche espandibile a più di 3 led ?

    Attendo fiducioso una risposta !
    Grazie,
    Domenico

  38. roberto mazza scrive:

    sono sempre interessanti le sue cose prof .

    non smettono mai insegnare e SOPRATTUTTO NON ANNOIANO .

  39. roberto mazza scrive:

    forse domani lo comprerò ,e guarderò solo il suo sito.

  40. nicola scrive:

    Buon giorno. Essendo novizio in materia avrei bisogno di sapere se con questo sketch si riesce a far partire un loop di istruzioni . Ossia ho realizzato un programma che mi gestisce una cella frigo ma vorrei che partisse alla pressione di un tasto e non appena do tensione. Grazie buon lavoro a tutti

  41. Marco scrive:

    Salve. Ho seguito con passione le sue lezioni. sono ad un livello avanzato in elettronica ma ho difficoltà con la programmazione.
    Sto cercando di realizzare uno SKETCH con un pulsante che accende un led, alla successiva pressione spegne il primo e accende il secondo, alla terza ricomincia il ciclo, questo pero per poi associarlo a due LoopA e loopB gia creati che fanno partire due “programmi” gia funzionanti su arduino e che singolarmente funzionano.
    PER la questione rimbalsi, non sono un problema… non mi interessano se dovessero esserci, li bypassero a livello fisico!
    Riesce a darmi un indicazione in merito…. esempi con un pulsante e due led non ne ho trovati! grazie infinite

  42. massimiliano scrive:

    ciao a tutti sembra che qui sia tutto fermo a dicembre …che peccato :(
    comunque provo lo stesso a fare un a domanda :)
    è possibile utilizzare arduino come interruttore wifi ?
    cioè vorrei collegandomi tramite internet da smartphone o altro comandare arduino per accendere una stufa ……tutto qua :9
    grazie a tutti
    Max

  43. Denis scrive:

    Salve Prof. Maffucci. Mi chiamo Denis e sono un semplice appassionato di elettronica ed ora anche di Arduino. Trovo le sue lezioni molto esaustive e piacevoli da seguire quindi complimenti vivissimi per il lavoro svolto e per il senso di altruismo nel voler aiutare pure i suoi “alunni” virtuali.

    Una sola domanda:

    Il suo ultimo esercizio proposto, quello di comandare con un pulsante il led lampeggiante ed il relativo spegnimento, ne suggerisce un altro, ossia quello di risolvere il problema che si crea con la pressione troppo frequente del pulsante che causa il mancato spegnimento del led.

    Ci ho pensato su molto ma… la soluzione???

    Ancora complimenti per il magnifico sito!!!

Lascia un Commento

L'indirizzo email non verrà pubblicato. I campi obbligatori sono contrassegnati *

È possibile utilizzare questi tag ed attributi XHTML: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>