Archivi tag: arduino

Arduino: realizzare un menù di selezione utilizzando un Diaplay LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T

Continuo la lezione cominciata la scorsa settimana con i miei studenti di 5A Automazione dell’ITIS G.B. Pininfarina di Moncalieri in merito alla gestione degli input mediante pulsanti e segnalazione stato LED sulla Serial Monitor, questa volta utilizzeremo come sistema di output un Display 16×2 con modulo I2C.

Rispetto all’esercizio svolto nella precedente lezione questa volta utilizzeremo 3 pulsanti la cui pressione provocherà l’accensione rispettivamente di un LED Rosso un LED Verde ed un LED Giallo.

L’esercizio è suddiviso in due parti, la prima parte prevede che l’accensione dei LED avvenga premendo il pulsante ad esso associato, il rilascio provoca lo spegnimento del LED. Lo stato del LED dovrà essere segnalato con il testo ON oppure OFF e nel momento in cui lo stato risulta ON a fianco del testo ON dovrà comparire una sequenza di caratteri che simula la rotazione di un’elica, così come evidenziato dalle immagini che seguono.

Le lettere R, V, G indicano rispettivamente il colore: Rosso, Verde, Giallo dei LED la cui accensione è comandata da un pulsante NO.

La seconda parte dell’esercizio consiste nella realizzazione di uno sketch che permette il mantenimento dello stato ON oppure OFF anche al rilascio del pulsante, il cambiamento di stato avviene nella successiva pressione del pulsante.

Per i dettagli sull’uso del display 16×2 I2C vi rimando al tutorial su questo sito seguendo il link: Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T

Componenti utilizzati

Arduino UNO R3
N. 3 pulsanti NO
N. 3 resistori da 10 KOhm
N. 3 resistori da 220 Ohm
N. 1 LED Rosso
N. 1 LED Verde
N. 1 LED Giallo

Di seguito lo schema di collegamento:

Il funzionamento degli sketch è spiegato mediante commenti all’interno del codice.

Parte 1

/*
   Prof. Michele Maffucci
   Accensione e spegnimento led con segnalazione su Display LCD I2C
   30.09.19

   Accensione e spegnimento di LED mediante pulsanti
   con antirimbalzo e messaggio ripetuto dello stato del LED
   sul Display

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

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

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

*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

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

int ledRosso = 2;

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

int ledVerde = 3;

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

int ledGiallo = 4;

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

int pulsanteRosso = 10;

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

int pulsanteVerde = 11;

// pulsanteGiallo variabile di tipo intero a cui viene assegnato
// il valore intero 12 che sarà associato al pin digitale 12
// a cui sarà collegato il pulsante che comanda il LED Giallo

int pulsanteGiallo = 12;

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

int valRosso = 0;
int valVerde = 0;
int valGiallo = 0;

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
//-----------------------------
void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione

  // imposta i pin digitali a cui sono collegati i LED ad OUTPUT
  pinMode(ledRosso, OUTPUT);
  pinMode(ledVerde, OUTPUT);
  pinMode(ledGiallo, OUTPUT);

  // imposta i pin digitali a cui sono collegati i pulsanti ad OUTPUT
  pinMode(pulsanteRosso, INPUT);
  pinMode(pulsanteVerde, INPUT);
  pinMode(pulsanteGiallo, INPUT);

  // messaggio di Avvio visualizzato una sola volta
  lcd.setCursor(0, 0);      // posiziona curasore in colonna 0 e riga 0
  lcd.print("Ciao");        // stampa del testo su display
  lcd.setCursor(0, 1);      // posiziona curasore in colonna 0 e riga 1
  lcd.print("Comando LED"); // stampa del testo su display
  delay(2000);              // pausa di 2 secondi
  lcd.clear();              // cancella il contenuto del display

}
//-----------------------------

void loop()
{
  valRosso = digitalRead(pulsanteRosso);    // lettura dell'input (pulsante) e memorizzazione in valRosso
  valVerde = digitalRead(pulsanteVerde);    // lettura dell'input (pulsante) e memorizzazione in valVerde
  valGiallo = digitalRead(pulsanteGiallo);  // lettura dell'input (pulsante) e memorizzazione in valGiallo

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

  /* Se il pulsante viene premuto viene acceso il LED rosso
   * posizionato il cursore in colonna 0 riga 0
   * stampato il testo: R: ON
   * avviata l'animazione
   */

  if (valRosso == HIGH) {
    digitalWrite(ledRosso, HIGH);
    lcd.setCursor(0, 0);
    lcd.print("R: ON ");
    animazione(6,0);
  }

  /* Se il pulsante NON viene premuto viene spento il LED rosso
   * posizionato il cursore in colonna 0 riga 0
   * stampato il testo: R: OFF
   * interrotta l'animazione
   */

  else {
    digitalWrite(ledRosso, LOW);
    lcd.setCursor(0, 0);
    lcd.print("R: OFF ");
  }

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

   /* Se il pulsante viene premuto viene acceso il LED verde
   * posizionato il cursore in colonna 0 riga 1
   * stampato il testo: V: ON
   * avviata l'animazione
   */

  if (valVerde == HIGH) {
    digitalWrite(ledVerde, HIGH);
    lcd.setCursor(9, 0);
    lcd.print("V: ON ");
    animazione(15,0);
  }

  /* Se il pulsante NON viene premuto viene spento il LED verde
   * posizionato il cursore in colonna 0 riga 1
   * stampato il testo: V: OFF
   * interrotta l'animazione
   */

  else {
    digitalWrite(ledVerde, LOW);
    lcd.setCursor(9, 0);
    lcd.print("V: OFF ");
  }

  // ---------- Controllo pulsante LED Giallo ----------

   /* Se il pulsante viene premuto viene acceso il LED giallo
   * posizionato il cursore in colonna 0 riga 1
   * stampato il testo: G: ON
   * avviata l'animazione
   */

  if (valGiallo == HIGH) {
    digitalWrite(ledGiallo, HIGH);
    lcd.setCursor(0, 1);
    lcd.print("G: ON ");
    animazione(6,1);
  }

  /* Se il pulsante NON viene premuto viene spento il LED giallo
   * posizionato il cursore in colonna 9 riga 0
   * stampato il testo: G: OFF
   * interrotta l'animazione
   */

  else {
    digitalWrite(ledGiallo, LOW);
    lcd.setCursor(0, 1);
    lcd.print("G: OFF ");
  }
}

// Funzione che stampa un cursore che ruota

void animazione(int colonna, int riga) {
  lcd.setCursor(colonna, riga);
  lcd.print("/");
  delay(150);
  lcd.setCursor(colonna, riga);
  lcd.print("-");
  delay(150);
  lcd.setCursor(colonna, riga);
  lcd.print("|");
  delay(150);
  lcd.setCursor(colonna, riga);
  lcd.print("/");
  delay(150);
  lcd.setCursor(colonna, riga);
  lcd.print("-");
  delay(150);
  lcd.setCursor(colonna, riga);
  lcd.print("|");
  delay(150);
}

Parte 2

/*
   Prof. Michele Maffucci
   Data: 30.09.19

   Accensione e spegnimento di LED mediante pulsanti
   con antirimbalzo e messaggio NON ripetuto dello stato del LED
   sulla su Display LCD I2C

   Stampa 1 sola volta il messaggio dello stato del LED Sul Display I2C
   (non va in loop la stampa dello stato del LED)

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

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

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

*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

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

int ledRosso = 2;

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

int ledVerde = 3;

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

int ledGiallo = 4;

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

int pulsanteRosso = 10;

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

int pulsanteVerde = 11;

// pulsanteGiallo variabile di tipo intero a cui viene assegnato
// il valore intero 12 che sarà associato al pin digitale 12
// a cui sarà collegato il pulsante che comanda il LED Giallo

int pulsanteGiallo = 12;

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

int valRosso = 0;
int valVerde = 0;
int valGiallo = 0;

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

int statoRosso = 0;
int statoVerde = 0;
int statoGiallo = 0;

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

int valRossoOld = 0;
int valVerdeOld = 0;
int valGialloOld = 0;

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

int stampoRossoON = 0;
int stampoRossoOFF = 0;

int stampoVerdeON = 0;
int stampoVerdeOFF = 0;

int stampoGialloON = 0;
int stampoGialloOFF = 0;

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
//-----------------------------
void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione

  // imposta i pin digitali a cui sono collegati i LED ad OUTPUT
  pinMode(ledRosso, OUTPUT);
  pinMode(ledVerde, OUTPUT);
  pinMode(ledGiallo, OUTPUT);

  // imposta i pin digitali a cui sono collegati i pulsanti ad OUTPUT
  pinMode(pulsanteRosso, INPUT);
  pinMode(pulsanteVerde, INPUT);
  pinMode(pulsanteGiallo, INPUT);

  // messaggio di Avvio visualizzato una sola volta
  lcd.setCursor(0, 0);      // posiziona curasore in colonna 0 e riga 0
  lcd.print("Ciao");        // stampa del testo su display
  lcd.setCursor(0, 1);      // posiziona curasore in colonna 0 e riga 1
  lcd.print("Comando LED"); // stampa del testo su display
  delay(2000);              // pausa di 2 secondi
  lcd.clear();              // cancella il contenuto del display
}
//-----------------------------


void loop()
{
  valRosso = digitalRead(pulsanteRosso);    // lettura dell'input (pulsante) e memorizzazione in valRosso
  valVerde = digitalRead(pulsanteVerde);    // lettura dell'input (pulsante) e memorizzazione in valVerde
  valGiallo = digitalRead(pulsanteGiallo);  // lettura dell'input (pulsante) e memorizzazione in valGiallo

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

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

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

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

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

    stampoRossoON = 0;
  }

  // memorizzazione del valore precedente restituito dalla digitalRead

  valRossoOld = valRosso;

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

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

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

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

    delay(15);

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

    stampoVerdeON = 0;
  }

  // memorizzazione del valore precedente restituito dalla digitalRead

  valVerdeOld = valVerde;

  // ---------- Controllo pulsante LED Giallo ----------

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

  if ((valGiallo == HIGH) && (valGialloOld == LOW)) {
    statoGiallo = 1 - statoGiallo;

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

    delay(15);

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

    stampoGialloON = 0;
  }

  // memorizzazione del valore precedente restituito dalla digitalRead

  valGialloOld = valGiallo;

  // ---------- Stampa sul display lo stato del LED Rosso ----------

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

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

    // Se la variabile stampoRossoON è 0 allora !stampoRossoON vale 1
    // ciò consente la stampa del messaggio "LED Rosso ON"

    if (!stampoRossoON) {
      lcd.setCursor(0, 0);
      lcd.print("R: ON ");

      // Viene posto a 0 stampoRossoOFF per consentire la stampa "LED Rosso OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Rosso.

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

  else {
    digitalWrite(ledRosso, LOW);

    if (!stampoRossoOFF) {
      lcd.setCursor(0, 0);
      lcd.print("R: OFF");

      // Viene posto a 1 stampoRossoOFF per consentire la stampa "LED Rosso OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Rosso.

      stampoRossoOFF = 1;
    }
  }

  // ---------- Stampa sul disolay lo stato del LED Verde ----------

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

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

    // Se la variabile stampoVerdeON è 0 allora !stampoVerdeoON vale 1
    // ciò consente la stampa del messaggio "LED verde ON"

    if (!stampoVerdeON) {
      lcd.setCursor(7, 0);
      lcd.print("V: ON ");

      // Viene posto a 0 stampoVerdeOFF per consentire la stampa "LED Verde OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Rosso.

      stampoVerdeOFF = 0;
    }
  }

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

  else {
    digitalWrite(ledVerde, LOW);

    if (!stampoVerdeOFF) {
      lcd.setCursor(7, 0);
      lcd.print("V: OFF");

      // Viene posto a 1 stampoVerdeOFF per consentire la stampa "LED Verde OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Verde.

      stampoVerdeOFF = 1;
    }
  }

  // ---------- Stampa sul disolay lo stato del LED Giallo ----------

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

  if (statoGiallo == 1) {
    digitalWrite(ledGiallo, HIGH);

    // Se la variabile stampoGialloON è 0 allora !stampoGialloON vale 1
    // ciò consente la stampa del messaggio "LED giallo ON"

    if (!stampoGialloON) {
      lcd.setCursor(0, 1);
      lcd.print("G: ON ");

      // Viene posto a 0 stampoGialloOFF per consentire la stampa "LED Giallo OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Giallo.

      stampoGialloOFF = 0;
    }
  }

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

  else {
    digitalWrite(ledGiallo, LOW);

    if (!stampoGialloOFF) {
      lcd.setCursor(0, 1);
      lcd.print("G: OFF");

      // Viene posto a 1 stampoGialloOFF per consentire la stampa "LED Giallo OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Giallo.

      //stampoGialloON = 0;
    }
  }
}

Esercizio: utilizzare gli esempi precedenti per realizzare un sistema che consente di avviare ed arrestare 2 ventole, ciascuna comandata da un pulsante. Un terzo pulsante dovrà essere utilizzato come consenso per permettere l’utilizzo del sistema, quindi:

Pulsante Marcia/Arresto ventola 1
Pulsante Marcia/Arresto ventola 2
Pulsante accensione spegnimento sistema

Gli stati dovranno essere indicati mediante LED e con messaggio sul display.

Buon Lavoro 🙂

Programmare una scheda Arduino con l’Arduino Web Editor

1 Replica

Dedico questo articolo ai miei nuovi studenti di 3B Automazione (ITIS G.B. Pininfarina di Moncalieri) con cui ho incominciato a spiegare l’utilizzo di Arduino. Le prime lezioni come sempre sono dedicate all’analisi della scheda elettronica, dei componenti presenti su di essa, al funzione del microcontrollore e primi esercizi di programmazione, cercando di trovare soluzioni divertenti, pensate per le loro competenze di elettrotecnica ed elettronica, quindi semplice accensione di LED per la creazione di modellini di impianti semaforici stampati in 3D in modo da prendere pratico con l’uso dei pin I/O digitali di Arduino.

Parallelamente sto mostrando i diversi ambienti di programmazione e simulazione della scheda. Nelle prime lezioni usiamo l’IDE Arduino standard caricato sui vari PC, ma utilizzeremo anche la versione più pratica e sempre aggiornata dell’Arduino Web Editor versione on-line dell’IDE Arduino.
Ma perché pensare di adottare questa soluzione a scuola?
Banalmente per avere sempre con se, in qualsiasi momento, su qualsiasi computer gli sketch sviluppati.

Il tutorial che segue mostra una procedura guidata relativamente semplice, ma come sempre preferisco non dare mai nulla per scontato, soprattutto con i giovanissimi studenti che incominciano il percorso di Automazione, quindi condurre per mano nel primo mese di scuola in modo che siano poi autonomi e liberi di sperimentare anche a casa.

E’ possibile accedere all’Arduino Web Editor dalla home page del sito www.arduino.cc: “software > online tools” giungerete alla home page di Arduino Create

oppure direttamente seguendo il link: create.arduino.cc

Su questa pagina selezionate: Arduino Web Editor

Sarete reindirizzati in una pagina di login in cui dovrete inserire nome utente e password, se non avete mai effettuato la registrazione sul sito Arduino procedete come indicato nell’immagine che segue, facendo click su: “CREATE A NEW ACCOUNT”

Continua a leggere→

Evitare il loop di messaggi inviati sulla Serial Monitor

Lascia una risposta

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

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

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

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

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

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

int stampaMessaggio = 0;

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

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

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

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

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

All’interno del codice la spiegazione del funzionamento.

Soluzione con testo di output in loop

/*
   Prof. Michele Maffucci
   Accensione e spegnimento
   23.09.19

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

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

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

*/

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

int ledRosso = 5;

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

int ledVerde = 4;


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

int pulsanteRosso = 7;

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

int pulsanteVerde = 6;

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

int valRosso = 0;
int valVerde = 0;

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

int statoRosso = 0;
int statoVerde = 0;

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

int valRossoOld = 0;
int valVerdeOld = 0;

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

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

void loop() {

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

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

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

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


  // memorizzazione del valore precedente restituito dalla digitalRead

  valRossoOld = valRosso;

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

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

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

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

    delay(15);

    // memorizzazione del valore precedente restituito dalla digitalRead
  }

  valVerdeOld = valVerde;

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

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

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

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

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

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

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

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

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

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

Soluzione con testo di output NON in loop

/*
   Prof. Michele Maffucci
   Data: 23.09.19

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

   Stampa 1 sola volta il messaggio dello stato del LED sulla Serial Monitor
   (non va in loop la stampa dello stato del LED)

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

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

*/

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

int ledRosso = 5;

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

int ledVerde = 4;


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

int pulsanteRosso = 7;

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

int pulsanteVerde = 6;

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

int valRosso = 0;
int valVerde = 0;

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

int statoRosso = 0;
int statoVerde = 0;

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

int valRossoOld = 0;
int valVerdeOld = 0;

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

int stampoRossoON = 0;
int stampoRossoOFF = 0;

int stampoVerdeON = 0;
int stampoVerdeOFF = 0;

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

  Serial.begin(9600);                 // imposta la velocità di scrittura della serial monitor
  Serial.println("Avvio programma");  // stampa la stringa tra le " e va a campo
  Serial.println("---------------");  // stampa la stringa tra le " e va a campo
}

void loop() {

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

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

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

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

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

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

    stampoRossoON = 0;
  }

  // memorizzazione del valore precedente restituito dalla digitalRead

  valRossoOld = valRosso;

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

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

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

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

    delay(15);

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

    stampoVerdeON = 0;
  }

  // memorizzazione del valore precedente restituito dalla digitalRead

  valVerdeOld = valVerde;

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

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

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

    // Se la variabile stampoRossoON è 0 allora !stampoRossoON vale 1
    // ciò consente la stampa del messaggio "LED Rosso ON"

    if (!stampoRossoON) {
      Serial.println("LED Rosso ON");

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

      stampoRossoON = 1;
      stampoRossoOFF = 0;
    }
  }

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

  else {
    digitalWrite(ledRosso, LOW);

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

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

      stampoRossoON = 0;
      stampoRossoOFF = 1;
    }
  }

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

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

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

    // Se la variabile stampoVerdeON è 0 allora !stampoVerdeoON vale 1
    // ciò consente la stampa del messaggio "LED verde ON"

    if (!stampoVerdeON) {
      Serial.println("LED Verde ON");

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

      stampoVerdeON = 1;
      stampoVerdeOFF = 0;
    }
  }

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

  else {
    digitalWrite(ledVerde, LOW);

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

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

      stampoVerdeON = 0;
      stampoVerdeOFF = 1;
    }
  }
}

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

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

Marcia
Arresto
Anomalia

Associare ad ogni situazione il colore del LED:

Rosso: marcia
Verde: arresto
Giallo: anomalia

Alla pressione del corrispondente pulsante mostrare sulla Serial Monitor :

Motore in marcia
Motore fermo
Anomalia motore

Buon lavoro 🙂

Errori comuni nell’uso di Arduino – evitare lo stato flottante di un pin di Arduino

2 Repliche

Uno degli errori tipici che riscontro durante le correzioni degli esercizi dei miei studenti alle prime esperienze nell’uso dei microcontrollori, è quello di ritenere che su un pin non collegato a nulla vi sia la presenza di uno stato logico LOW, questo non è corretto. Viene definito floating (flottante) un pin di ingresso a cui non è collegato nulla, in questa condizione sul pin potrebbe essere presente qualsiasi stato.

L’uso di un resistore collegato in modalità pull-up o pull-down costringerà il pin a uno stato noto, ma questa non è l’unica modalità. E’ possibile fissare uno stato su un pin utilizzando un metodo, in parte già illustrato in un mio precedente post, che sfrutta l’utilizzo di un resistore di pull-up interno alla scheda. Per abilitare questa resistenza sarà sufficiente indicare all’interno del setup la funzione pinMode() con largomento “INPUT_PULLUP” oppure nella stessa maniera utilizzando le istruzioni:

pinMode(pin, INPUT);       // imposta 'pin' come input
digitalWrite(pin, HIGH);   // attiva la resistenza di pull-up,
                           //'pin' viene impostato HIGH

Per entrambe le modalità noterete che il LED è normalmente accesso, alla pressione del pulsante si spegnerà.

Circuito

Modalità 1

void setup() {
  pinMode(8, OUTPUT);       // Utilizzo del LED sul pin 8

  // Abilita la resistenza interna di Pull-Up
  pinMode(7, INPUT);        // Collegamento del pulsante al pin 7
  digitalWrite(7, HIGH);    // attiva la resistenza di pull-up, sul pin 7

}

void loop() {
  bool statoPulsante = digitalRead(7);   // memorizza lo stato corrente sul pin 7
  digitalWrite(8, statoPulsante);        // accende il LED se statoPulsante e 1, lo spegne se 0
}

Modalità 2

void setup() {
  pinMode(8, OUTPUT);

  // INPUT_PULLUP abilita la resistenza interna di Pull-Up
  pinMode(7, INPUT_PULLUP);       // Collegamento del pulsante al pin 7
}

void loop() {
  bool statoPulsante = digitalRead(7);  // memorizza lo stato corrente sul pin 7
  digitalWrite(8, statoPulsante);       // accende il LED se statoPulsante e 1, lo spegne se 0
}

Nel caso abbiate la necessità di invertire lo stato e fare in modo che il LED sia normalmente spento e si accenda alla pressione del pulsante sarà sufficiente applicare l’operatore NOT, indicato con il simbolo “!” alla funzione digitalRead(7):

bool statoPulsante = !digitalRead(7);

Lo sketch completo sarà:

void setup() {
  pinMode(8, OUTPUT);

  // INPUT_PULLUP abilita la resistenza interna di Pull-Up
  pinMode(7, INPUT_PULLUP);       // Collegamento del pulsante al pin 7
}

void loop() {
  bool statoPulsante = !digitalRead(7);  // memorizza lo stato corrente sul pin 10
  digitalWrite(8, statoPulsante);        // accende il LED se statoPulsante e 1, lo spegne se 0
}

Potete trovare un ulteriore esempio di applicazione alla pagina 78 delle slide: Alfabeto di Arduino – lezione 2

Arduino – Approfondimenti sulla modulazione di larghezza di impulso (PWM)

2 Repliche

Scrivo questo post ad integrazione della lezione: Arduino – lezione 06: modulazione di larghezza di impulso (PWM) che sto utilizzando con i miei studenti di 4′ informatica per illustrare le modulazioni di tipo digitali. L’obiettivo è quello di mostrare sull’oscilloscopio come varia il Duty Cycle di un’onda quadra su un pin di tipo PWM di Arduino utilizzato per impostare l’intensità luminosa di un LED mediante una regolazione applicata attraverso un trimmer connesso al pin A0 di Arduino.

Oltre alla visualizzazione sull’oscilloscopio si desidera, come riscontro, la stampa sulla Serial Monitor dei seguenti valori:

Tensione in input sul pin A0
Valore restituito dalla funzione analogRead() – (tra 0 e 1023)
Valore restituito dall’analogWrite – (tra 0 e 254)
Valore percentuale del Duty Cycle (tra 0% e 100%)

Il circuito da realizzare con l’indicazione delle connessioni all’oscilloscopio è il seguente:

Sul canale X verrà visualizzata l’onda quadra in uscita dal pin 11 il cui Duty Cycle sarà regolato agendo sul trimmer.

Sul canale Y verrà visualizzata la tensione continua in input sul pin A0, che sarà convertita dal convertitore Analogico Digitale di Arduino in un valore compreso tra 0 e 1023 (risoluzione di 10 bit). Ricordo che tale conversione sarà fatta con l’istruzione analogRead(pin).

Poiché uno degli obiettivi è quello di visualizzare la tensione rilevata sul pin A0, ricordo che tale misurazione viene fatta utilizzando la funzione analogRead(pin) che legge il valore di tensione (compreso tra 0 e 5V) applicato sul piedino analogico ‘pin’ con una risoluzione di 10 bit e la converte in un valore numerico compreso tra 0 e 1023, corrispondente quindi ad un intervallo di 1024 valori, pertanto ogni intervallo corrisponde ad un valore di tensione Vu di:

Per sapere quindi il valore di tensione rilevato (nell’intervallo tra 0V e 5V) sarà sufficiente moltiplicare la tensione unitaria Vu per il valore restituito dalla funzione analogRead(pin), valore quantizzato indicato con Vq compreso tra 0 e 1023:

Sapendo che Vu corrisponde a 4,88 mV

possiamo anche scrivere che:

Questa formula sarà inserita all’interno dello sketch.

Di seguito la schermata dell’oscilloscopio che visualizza la situazione indicata dai dati stampati sulla Serial Monitor:

Vmax(2) indica la tensione in ingresso ad A0 (la piccola discrepanza tra valore indicato sull’oscilloscopio e la stampa sulla Serial Monitor dipende dalle approssimazioni di calcolo).
Vmax(1) indica il valore di picco della tensione sul pin 11.

La spiegazione del funzionamento dello sketch sono dettagliate nei commenti:

/* Prof. Michele Maffucci
   03.06.2019

   Regolazione luminosità LED mediante
   trimmer, si utilizza la funzione map

   Stampa sulla seriale:
   - del valore di tensione sul pin A0
   - del valore restituito dall'analogRead
   - del valore restituito dall'analogWrite
   - del valore del Duty Cycle %

   Questo codice è di dominio pubblico
*/

// pin analogico su cui inviare la tensione analogica (pin A0)
int misura = 0;

// pin a cui è connesso il LED
int pinLed = 11;

// variabile in cui conservare il valore inserito su A0
long val = 0;

// variabile in cui memorizzare il Duty Cycle
int inputVal = 0;

const long VoltRiferimento = 5.0; // valore di riferimento


void setup(){
  Serial.begin(9600);      // inizializzazione della comunicazione seriale
  pinMode(pinLed, OUTPUT); // definizione di ledPin come output
}

void loop(){
  // analogRead leggerà il valore su A0 restituendo un valore tra 0 e 1023
  // per approfondimenti si consulti il link: http://wp.me/p4kwmk-1Qd
  val = analogRead(misura);

  // analogWrite() accetta come secondo parametro (PWM) valori tra 0 e 254
  // pertanto "rimappiamo" i valori letti da analogRead() nell'intervallo
  // tra 0 e 254 usando la funzione map
  // per approfondimenti si consulti il link: http://wp.me/p4kwmk-1Tu
  inputVal = map(val, 0, 1023, 0, 254);

  // accendiamo il LED con un valore del Duty Cycle pari a val
  analogWrite(pinLed,inputVal);

  // Tensione inviata sul pin analogico A0.
  // Valore in virgola mobile.

  float volt = (VoltRiferimento/1024.0)*val;

  // visualizzazione il valore della tensione su A0,
  // del valore restituito dalla analogRead,
  // del valore restituito dall'analogWrite
  // e del Duty Cycle %

  // per approfondimenti sull'uso di String si consulti il link: https://www.arduino.cc/reference/en/language/variables/data-types/stringobject/

  Serial.println(String("Tensione su A0: ") + volt + "V" + String(";  ") + "analogRead: " + val + String(";  ") + String("Valore analogWrite: ") + inputVal + String("; ") + String("Duty Cycle %: ") + (inputVal/255.0)*100 + String("%;"));
  delay(500); // stampa una strina di valori ogni mezzo secondo
}

Buon Coding a tutti 🙂

Related posts:

Related posts:

Related posts:

Related posts:

Related posts: