Archivi tag: serial monitor

Visualizzare i dati inviati da un micro:bit ad un computer via seriale con un emulatore di terminale

Durante le attività di sperimentazione del mio prossimo corso sui laboratori green mostrerò l’uso di RTC per la rilevazione automatica dei dati provenienti da sensori, sarà quindi necessario leggere i dati ricevuti dal micro:bit ed inviati al micro:bit attraverso un PC via seriale USB. Per leggere le informazioni che transitano sulla seriale è possibile usare qualsiasi emulatore di terminale. Seguendo il link: Outputing serial data from the micro:bit to a computer trovate la documentazione dell’help online di microbit.org che mostra l’utilizzo di alcuni emulatori terminali per i diversi sistemi operativi.

Una modalità estremamente semplice e che vi tornerà utile anche in altre occasioni, è quella che fa uso della Serial Monitor di Arduino, vediamo di seguito come fare questa operazione.

Configurazione

Passo 1
Qualche tempo fa avevo indicato come usare l’IDE di Arduino per programmare micro:bit, seguite la procedura indicata nel link

Passo 2
Impostare la scheda

Passo 3
Impostare la porta a cui è connesso il micro:bit

Passo 4
Aprire uno sketch vuoto e fare click sull’icona Monitor Seriale

Passo 5
Impostate la velocità di comunicazione a 115200 baud

Il risultato che vedete nell’immagine è quello che deriva dalla realizzazione di un programma scritto in Blocks con l’IDE grafico di micro:bit in cui viene inviato ogni minuto sulla seriale:

  • la data della misurazione
  • l’ora della misurazione
  • la temperatura rilevata dal sensore di temperatura del micro:bit e la temperatura rilevata dal sensore disposto sull’RTC DS3231.

Ovviamente questi dati potranno essere inviati ad altri dispositivi con modalità di trasmissione diverse, tutto questo sarà approfondito durante il corso.

Buon Making a tutti 🙂

CoolTerm – Alternative alla Serial Monitor di Arduino

La comunicazione seriale viene usata in moltissimi dispositivi elettronici che utilizziamo ogni giorno. Rispetto alla comunicazione parallela (4, 8 o 64-bit), la comunicazione seriale è utilizzata spesso nei sistemi embedded a causa del basso costo e della trasmissione efficace nelle lunghe distanze.
Per chi opera con Arduino, sa che l’uso della Serial Monitor è necessario per la lettura di dati inviati serialemente tra Arduino ed il computer con altri dispositivi elettronici, ad esempio l’invio sulla Serial Monitor dei valori di temperatura rilevata da un sensore di temperatura connesso ad Arduino.

La comunicazione seriale è inoltre uno strumento utilissimo per effettuare il debug, ovvero inviare dei messaggi sulla seriale per l’utente al fine di rilevare errori o mettere in evidenza i passi di esecuzione di un programma o lo stato di un sistema.

I dati inviati da Arduino al Computer o viceversa possono essere visualizzati sul monitor del computer (attraverso la finestra della Serial Monitor) o su altri dispositivi come ad esempio un display LCD connesso ad Arduino.

Ho mostrato più volte in precedenti lezioni l’uso dei comandi seriali: Serial.begin(), Serial.print(), Serial.read() e l’utilizzo della Serial Plotter che permette di visualizzare il grafico su piano cartesiano dei dati seriali trasmessi da Arduino.

Sicuramente anche voi, nell’uso costante della Serial Monitor, avrete notato i limiti dello strumento, come esempio l’impossibilità del salvataggio dei dati inviati ad un file di log.
E’ utile quindi considerare l’uso di un terminale alternativo che offra maggiori funzionalità rispetto alla Serial Monitor, come ad esempio visualizzare:

  • i caratteri di controllo;
  • i dati in formato testo o binario o entrambi;
  • salvare i dati rilevati in un file di log.

Tra i molti software disponibili il mio consiglio va a CoolTerM, un terminale user-friendly estremamente utile.
CoolTerM viene distribuito con licenza freeware / donationware sviluppato da Roger Meier ed è disponibile per dispositivi Windows, Mac, Linux.

Come si usa CoolTerM per rilevare dati che provengono da Arduino.

A titolo di esempio sfruttiamo quanto già svolto in passato, visualizzimo su CoolTerM la distanza di un ostacolo rilevato da un sensore ad ultrasuoni.
Prendiamo come riferimento lo sketch che segue, tratto da una mia lezione sull’uso del sensore ad ultrasuoni per un kit robotico, nello stesso post trovate la teoria di funzionamento del sensore HC-SR04.

/* Prof. Maffucci Michele
   
   Utilizzo del sensore ultrasuoni HC-SR04
   Misura della distanza di un ostacolo

*/

long durata;          // durata dell'impulso
long distanza;        // distanza dell'oggetto
int pin_echo = 7;     // pin Arduino a cui è collegato il sensore SR04
int pin_trig = 9;     // pin Arduino a cui è collegato il sensore SR04

void setup()
{
    Serial.begin(9600);
	pinMode(pin_trig, OUTPUT);
  	pinMode(pin_echo, INPUT);
  	Serial.println("Sensore ad ultrasuini");
}

void loop()
{
  Serial.print("Distanza ostacolo: ");
  Serial.println(distanzaOstacolo());
  delay(100);
}

// rilevazione distanza ostacolo

// misura la distanza dell'ostacolo
long distanzaOstacolo()
{
  digitalWrite(pin_trig, LOW);
  delayMicroseconds(2);
  digitalWrite(pin_trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(pin_trig, LOW);
  durata = pulseIn(pin_echo, HIGH);
  distanza = (durata / 2.0) / 29.1;
  delay(100);
  return distanza;
}

Con Arduino connesso al computer aprire CoolTerM e selezionare “Options”, da quì impostare la porta a cui è connessa la scheda e la velocità di connessione a 9600, una velocità diversa non permetterà una lettura corretta dei dati.

Torna alla schermata principale fate clic su “Connect”, ciò permetterà di avviare la trasmissione dei dati tra Arduino e il computer e i dati inizieranno ad apparire.
Quando desiderate interrompere la trasmissione ovviamente farete clic su “Disconnetti”.

E’ spesso utile analizzare i dati raccolti, in tal caso selezionate: Connection > Capture to Text/Binary File > Start ciò permetterà di salvare i vostri dati in un file TXT che potrà poi essere analizzato ad esempio con un foglio di calcolo.

CoolTerM offre ulteriori funzionalità molto utili:

  • se disponibile è possibile connettere più porte seriali concorrenti;
  • visualizzazione dei dati in formato semplice o esadecimale (HEX);
  • salvataggio e caricamento delle opzioni di connessione;
  • gestione dei caratteri speciali;
  • scripting;
  • eco locale di dati trasmessi / ricevuti;

Buon Making a tutti 🙂

Arduino: controllo sequenziale uscite digitali

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

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

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

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

Sketch 01

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

 

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

   Versione 01
   Sequenza di accensione e spegnimento alternato
   da destra e sinistra e viceversa di 8 LED con
   tempo di accensione di 100 millisecondi.
   
   Questo codice è di dominio pubblico 
 */

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

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

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

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

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

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

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

unsigned long tempoTrascorso;

void setup() {                
  // impostiamo tutti i pin ad output
  for (byte x=0; x<8; x++) {
    pinMode(ledPin[x], OUTPUT);
  }
    
  // Memorizzazione del tempo trascorso
  // dal momento in cui avviamo Arduino
  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
  // http://wp.me/p4kwmk-1QG
  
  tempoTrascorso = millis();
}

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

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

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

Sketch 02

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

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

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

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

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

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

// intervallo di accensione/spegnimento
int ritardoLed;

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

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

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

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

unsigned long tempoTrascorso;

void setup() {
  Serial.begin(9600);            
  // impostiamo tutti i pin ad output
  for (byte x=0; x<8; x++) {
    pinMode(ledPin[x], OUTPUT);
  }
    
  // Memorizzazione del tempo trascorso
  // dal momento in cui avviamo Arduino
  // Per ulteriori informazioni sull'uso di millis() si consulti il seguente link:
  // http://wp.me/p4kwmk-1QG
  
  tempoTrascorso = millis();
}

void loop() {

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

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

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

  // ValMax = 285, ValMin = 719
  // riconvertiti nell'intervallo 50, 1000
  
  ritardoLed = map(val, 285, 719, 50, 1000);
  
  // Se sono passati "ritardoLed" millisecondi dall'ultimo cambiamento
  if ((millis() - tempoTrascorso) > ritardoLed) {
    cambiaStatoLed();
    tempoTrascorso = millis();
  }
}

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

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

Sketch 03

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

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

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

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

   Partenza sequenza con 100 millisecondi e messaggio sulla
   Serial Monitor per modificare il tempo di
   accensione e spegnimento del singolo LED (delay)
   
   Questo codice è di dominio pubblico 
 */

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

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

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

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

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

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

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

unsigned long tempoTrascorso;

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

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

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

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

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

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

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

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

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

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

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

Continua a leggere

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

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

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

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

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

Nel dettaglio

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

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

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

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

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

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

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

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

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

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

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

Evitare il loop di messaggi inviati sulla Serial Monitor

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:

  1. Marcia
  2. Arresto
  3. Anomalia

Associare ad ogni situazione il colore del LED:

  1. Rosso: marcia
  2. Verde: arresto
  3. Giallo: anomalia

Alla pressione del corrispondente pulsante mostrare sulla Serial Monitor :

  1. Motore in marcia
  2. Motore fermo
  3. Anomalia motore

Buon lavoro 🙂