Archivi tag: sistemi elettronici

Arduino – istruzione “do…while” – soluzione esercizi proposti

Lascia una risposta

In riferimento alla lezione: Arduino – istruzione “do…while”: eseguire almeno una volta, poi verificare pubblico una possibile soluzione agli esercizi proposti.

Esercizio 01 – Attendi pulsante

  • Consegna: attendere che un pulsante su D2 venga premuto; durante l’attesa far lampeggiare il LED integrato.
  • Vincoli: usare while come attesa in ingresso (while(digitalRead(…)==HIGH)).
  • Extra: al termine, stampare “OK” e fermarsi.

Soluzione

/*
  Prof. Maffucci Michele
  data: 27.10.25

  Soluzione esercizio 01 - Attendi pulsante
  Hardware:
    - Pulsante su D2 con INPUT_PULLUP (un capo a D2, l'altro a GND)
    - LED integrato (pin 13)
  Obiettivo:
    - Lampeggiare il LED mentre si attende la pressione del pulsante
    - Usare while(digitalRead(PIN_BTN) == HIGH) come attesa
    - Quando il pulsante viene premuto -> stampare "OK" e fermarsi
*/

// PIN_BTN dichiarato come byte e non come int per occupare meno spazio di memoria
// collegare il pulsante a GND (INPUT_PULLUP)

const byte PIN_BTN = 2;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(PIN_BTN, INPUT_PULLUP);
  Serial.begin(9600);
  Serial.println("Premi il pulsante per continuare...");
}

void loop() {
  // Attesa attiva: finché il pulsante NON è premuto (HIGH con pull-up)
  // il LED_BUILTIN (13) lampeggia
  while (digitalRead(PIN_BTN) == HIGH) {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(150);
    digitalWrite(LED_BUILTIN, LOW);
    delay(150);
  }

  // Debounce semplice per elimina rimbalzi meccanici
  // realizzato con piccolo ritardo
  delay(30);
  
  while (digitalRead(PIN_BTN) == LOW) {  // resta qui finché è tenuto premuto
  }

  Serial.println("OK");
  digitalWrite(LED_BUILTIN, HIGH);      // lascia il LED acceso come conferma
  while (true) {}                       // ferma la demo
}

Esercizio 02 – Svuota buffer seriale

  • Consegna: quando l’utente invia testo, fare echo e svuotare tutti i caratteri residui.
  • Vincoli: usare while(Serial.available()>0).
  • Extra: contare quanti byte sono stati letti e mostrarli.

Soluzione

/*
  Prof. Maffucci Michele
  data: 27.10.25

  Soluzione esercizio 02 — Svuota buffer seriale
  Obiettivo:
    - Appena arriva del testo, fare echo di TUTTI i caratteri presenti nel buffer
    - Usare while(Serial.available() > 0) per svuotare il buffer
    - Contare i byte letti e mostrarli
  Ricordare:
    - Impostare il Serial Monitor a 9600 baud
*/

void setup() {
  Serial.begin(9600);
  Serial.println("Scrivi una riga di testo e premi invio...");
}

void loop() {
  if (Serial.available() > 0) {
    int conteggioByte = 0;

    Serial.print("Echo: ");
    // Legge TUTTO ciò che è attualmente in buffer
    while (Serial.available() > 0) {
      char c = Serial.read();     // leggi un byte
      Serial.write(c);            // echo (stampa il carattere così com'è)
      conteggioByte++;            // conta i byte letti
      // piccola attesa facoltativa per dare tempo al buffer di riempirsi
      delay(1);
    }
    Serial.println();
    Serial.print("Byte letti: ");
    Serial.println(conteggioByte);
    Serial.println("----");
  }
  // Se serve introdurre qui altro codice non bloccante
}

Attenzione!

Può capitare che vengano contati due byte in più, ciò accade perché la Serial Monitor (in basso a destra)
aggiunge automaticamente i caratteri di fine riga quando premete invio.

  • entrambi NL & CR (Both NL & CR) > aggiunge due byte: \r (CR, 13) e \n (LF, 10) → ecco il tuo +2 costante;
  • a capo NL (Newline) > aggiunge un byte: \n > +1;
  • ritorno carrello (CR) (Carriage return) > aggiunge un byte: \r > +1;
  • nessuna fine riga (No line ending) > +0 (il conteggio coincide con i caratteri digitati, salvo caratteri non ASCII).

Esercizio 03 – Timer regressivo

  • Consegna: da un valore t letto da Serial (es. 5..20), eseguire un countdown finché t>0.
  • Vincoli: usare while(t>0) con t– e stampa del tempo.
  • Extra: beep finale + messaggio “Decollo!”.

Soluzione

/*
  Prof. Maffucci Michele
  data: 27.10.25

  Soluzione esercizio 03 — Timer regressivo
  Obiettivo:
    - Leggere un intero t (5..20) dal Serial Monitor
    - Eseguire while(t > 0) con stampa del tempo e t--
    - Al termine: beep su D5 e messaggio "Decollo!"
  Note:
    - Usa Serial.parseInt() per semplicità (attende un numero)
    - Per maggior informazioni sull'uso di parseInt() consultare il link:
      https://wp.me/p4kwmk-4Ah
*/

const int PIN_BUZ = 5;  // collegare un buzzer piezo (se disponibile)

void setup() {
  Serial.begin(9600);
  pinMode(PIN_BUZ, OUTPUT);
  Serial.println("Inserisci un numero intero t tra 5 e 20 e premi invio:");
}

void loop() {
  int t = 0;

  // Attendi un numero valido nell'intervallo [5..20]
  while (t < 5 || t > 20) {
    if (Serial.available() > 0) {
      t = Serial.parseInt();  // legge il primo intero disponibile
      // Svuota residui (ad es. '\n')
      while (Serial.available() > 0) Serial.read();

      if (t < 5 || t > 20) {
        Serial.println("Valore non valido. Inserisci un numero tra 5 e 20:");
      }
    }
  }

  // Countdown con while(t > 0)
  while (t > 0) {
    Serial.print("T-");
    Serial.println(t);
    delay(1000);  // 1 secondo
    t--;
  }

  // Fine: beep + messaggio
  tone(PIN_BUZ, 880, 350);  // beep di 350 ms
  Serial.println("Decollo!");

  while (true) {}  // ferma la demo
}

Buon lavoro.

Related posts:

  1. ROB-O-COD un evento da replicare a scuola – lo racconterò a Fossano (Cn) il 6 giugno prossimo
  2. La micro matita
  3. Imparare a creare applicazioni utilizzando le API di Google Drive
  4. I miei corsi: Apprendimento attivo con Raspberry Pi e Arduino

Progettare bene, programmare meglio: pseudocodice e diagrammi di flusso per sistemi elettronici – lezione 3/5

Lascia una risposta


Ripasso di inizio anno – appunti per la classe.

Lo pseudocodice è un modo semplice e strutturato di descrivere un algoritmo in lingua naturale (italiano+parole chiave) senza la rigidità della sintassi di un linguaggio di programmazione.
È come scrivere una ricetta: elenchi ingredienti (dati), spieghi i passaggi (istruzioni) e le condizioni (“se… allora…”). Non lo “esegue” il computer, ma lo capiscono persone (docenti, compagni, te stesso domani) e ti guida a tradurre poi tutto in codice (es. Arduino/C++).

Cosa rende utile lo pseudocodice

Chiedere agli studenti di scrivere pseudocodice non è un esercizio di progettazione, ma neanche un modo per semplificare la progettazione del nostro sistema, è un modo che permette di decidere prima che cosa deve accadere, poi si penserà a come scriverlo in un linguaggio di programmazione, nel nostro caso in C/C++ per Arduino.

Possiamo definire lo pseudocodice come ad una lingua ponte: viene compreso sia da chi programma ma anche da chi ancora non programma; detto in altro modo possiamo dire che “mette in fila le idee”, riduce gli errori di distrazione, rende veloce il debug e lascia una traccia chiara e leggibile del progetto.

E’ sicuramente uno strumento inclusivo: abbassa la soglia d’ingresso per chi fatica con la sintassi ed è più abile nel ragionamento.

Nella pratica se so raccontare bene l’algoritmo con verbi chiari (LEGGI, SE, MENTRE, RITORNA), tradurlo in codice diventa un’operazione quasi meccanica.

Avrete intuito che saper scrivere pseudocodice non è solo un’attività di progettazione del software, ma anche un modo per comprendere sistemi complessi che interessano non solo la programmazione ma la nostra vita quotidiana: organizzare lo studio, pianificare un viaggio, andare a scuola, ecc… tutto può essere reso pseudocodice, se vi allenerete a scrivere pseudocodice vi accorgerete di avere maggior percezione di un problema e lo comprenderete meglio.

Sintetizziamo quanto sopra detto con una lista puntata che vi servirà nello studio.

Vantaggi dello pseudocodice

  • Chiarezza di idee: separate il cosa fare dal come scriverlo in C/C++.
  • Comunicazione: è una lingua comune tra chi sa e chi non sa ancora programmare, oppure una lingua comune tra persone che serve per comprendere un sistema.
  • Progettazione top-down: partite dal problema, lo scomponete in sotto-problemi, definite funzioni e responsabilità.
  • Riduzione errori: se l’algoritmo è corretto in pseudocodice, gli errori in codice molto probabilmente si ridurranno a dettagli sintattici.
  • Debug più rapido: quando il programma non funziona, si verifica prima la logica (lo pseudocodice), poi la sintassi.
  • Documentazione: lasciate tracce intelligibili del progetto, quindi ottimo per la relazione di laboratorio.
  • Valutazione: mostra il processo e non solo il risultato. Un buon pseudocodice rivela le vostre competenze di analisi, decomposizione, gestione dei casi limite (pensate a quanto diventa utile anche durante la prova scritta dell’esame di maturità… ne parlo più avanti)
  • Inclusione: aiuta chi ha poca dimestichezza con la sintassi a concentrarsi sui concetti fondamentali (input, output, decisioni, cicli, dati).

Perché è importante usarlo nel laboratorio di sistemi elettronici

In laboratorio non scriviamo solo righe di codice: progettiamo sistemi con sensori, attuatori, tempi, soglie e stati.
Lo pseudocodice costringe a dichiarare pin, costanti e variabili di stato, a prevedere debounce, time-out, condizioni di errore, cioè chiarisce il flusso:

inizializzazione > letture > decisioni > azioni

e rivolgendomi agli studenti, vedrete che renderà i test al banco di lavoro più rapidi, nel senso che saprete già quali valori provare e che risposta aspettarmi su ad esempio un LED, buzzer o seriale.

Ritengo che tra i vantaggi più importanti nella realizzazione dello pseudocodice ci sia quella di facilitare il lavoro di gruppo:

ognuno implementa una funzione sapendo dove si inserisce nel flusso generale. Risultato: meno tentativi a vuoto, più tempo speso a capire cosa fa davvero il nostro sistema.

Nelle esercitazioni che svilupperete con Arduino ma in generale con qualsiasi scheda a microcontrollore, c’è sempre un “sistema” da far funzionare: sensori, attuatori, logica, tempi, soglie, stati.

Se scriverete prima lo pseudocodice:

  • sarete obbligati a dichiarare ingressi (sensori), uscite (attuatori), costanti (soglie, pin), variabili di stato;
  • sarà più chiaro il flusso: inizializzazione > ciclo principale > gestione eventi > funzioni di servizio;
  • vi aiuterà a ragionare su casi limite (esempio: debounce, errori di misura, time-out);
  • diventerete più rapidi nel passaggio alla codifica e nella verifica sperimentale al banco.

In pratica: pseudocodice = “schema funzionale” del vostro impianto in forma testuale.

Pensiamo ora ad un evento che vi coinvolgerà: l’esame di maturità

Sarebbe bello ottimizzare il tempo della prova scritta di sistemi (se questa sarà la materia della seconda prova) ma l’uso dello pseudocodice va bene anche per la progettazione di qualsiasi tipo di prova, anche per strutturare un tema di italiano.
All’orale la commissione potrebbe valutare anche come progettate, quindi non solo se il codice funziona. Saper scrivere su un foglio:

Requisiti > Pseudocodice > Schema I/O > Stralcio di codice > Piano di test

sicuramente comunica metodo, ordine e padronanza… e quindi fate una bella figura 😉

Lo pseudocodice vi aiuta a spiegare le scelte: perché una soglia? perché una macchina a stati? come gestisci i casi limite?
E vi mette al sicuro quando vi chiedono una variazione durante l’orale: se la logica è chiara, sapete subito dove intervenire. È un modo semplice per far vedere che sapete passare dall’idea all’implementazione in modo professionale.

Immaginate poi ad un insegnante che dovrà correggere il vostro compito, avere un buon pseudocodice vi assicuro che lo aiuta 😉

Quindi sintetizzando è molto importante ricordare:

  • esporre prima lo pseudocodice mette in luce le vostre capacità progettuali;
  • mostra che sapete astrarre dal codice e motivare le scelte;
  • facilita domande e risposte: il docente può chiedervi di modificare una parte, ad esempio aggiungere un sensore e voi sapete intervenire nel flusso.

e non ultimo farà pensare: “questa persona è professionale”.

Ora andiamo al nocciolo della questione, vediamo come si fa lo pseudocodice, in realtà vi darò una linea guida, qualche esempio ed esercizi semplici che coinvolgono la vostra vita quotidiana, imparerete in brevissimo tempo.

Quello che scrivo da questo momento in poi dovrebbe essere inserito nelle prime pagine del vostro quaderno, dove andrete ad inserire i riferimenti delle schede che utilizziamo, della sintassi di programmazione ecc…

Nota i miei studenti (da recuperare)

Ricordo che ogni attività di progettazione che farete e consegnerete dovrà includere:

    • diagramma di flusso
    • pseudocodice
    • sketch Arduino commentato in ogni parte
    • breve relazione di funzionamento
    • eventuale:
      • schema elettrico
      • schema topografico di collegamenti
      • tabella misure
      • grafici
    • Sitografia
    • Bibliografia

A tal proposito vi mostrerò un format di foglio di lavoro che potrete poi modificare secondo necessità.

Ogni progetto deve essere esposto anche oralmente.

In alcune occasioni vi sarà azione di debate, ovvero un confronto tra gruppi su specifici problemi tecnici da risolvere.

Regole di base

  • Una istruzione per riga; rientra (indenta) i blocchi.
  • Parole chiave in MAIUSCOLO: SE, ALTRIMENTI, MENTRE, PER, FUNZIONE, RITORNA, ATTENDI.
  • Date nomi chiari a variabili e costanti: sogliaLuce, tempoGiallo, pinLedRosso, cioè usiamo la convenzione camelcase che combina più parole in un’unica stringa, scrivendo la prima parola in minuscolo e le parole successive con la loro iniziale maiuscola ad esempio: nomeUtente.
  • In testa: Pin, Costanti, Variabili. Poi: Inizializzazione, Loop, Funzioni.
  • Commentate perché fate qualcosa, non scrivete l’ovvio: “sommo 1 al contatore perché ogni impulso accende il led…”

Di seguito un template da copiare ed incollare:

/* Requisito sintetico: cosa deve fare il sistema */

COSTANTI:
    pinLed = ...
    pinBtn = ...
    soglia = ...

VARIABILI:
    stato = ...
    conteggio = ...

INIZIALIZZA:
    configura pin
    azzera conteggi

LOOP PRINCIPALE:
    leggi sensori
    SE (condizione) ALLORA:
        azione
    ALTRIMENTI SE (...) ALLORA:
        altra azione
    ALTRIMENTI:
        default
    aggiorna attuatori
    ATTENDI t ms

FUNZIONI:
    FUNZIONE nome(parametri):
        passi...
        RITORNA valore

La checklist da seguire ASSOLUTAMENTE è questa:

  1. Input/Output identificati? (pin, range, unità)
  2. Costanti definite? (soglie, tempi, limiti)
  3. Stati chiari? (idle, misura, allarme, reset…)
  4. Casi limite previsti? (debounce, isteresi, time-out, valori anomali)
  5. Test plan minimo? (quali valori proverai e cosa ti aspetti di vedere)

Ora facciamo qualche esempio che coinvolge la nostra vita

01 – Sveglia e alzarsi

Diagramma di flusso Mermaid

graph TD
    A[Inizio] --> B[Suona sveglia]
    B --> C{Ancora sonno?}
    C -- Si --> D[Attendi 5 minuti]
    D --> B
    C -- No --> E[Alzati dal letto]
    E --> Z[Fine]

Diagramma di flusso

Pseudocodice

RIPETI
  SUONA_SVEGLIA()
  LEGGI risposta // "si" se hai ancora sonno, "no" altrimenti
  SE risposta == "si" ALLORA
     ATTENDI 5 minuti
  ALTRIMENTI
     ESCI DAL CICLO
  FINE SE
FINCHÉ VERO
ALZATI_DAL_LETTO()
SCRIVI "Pronto per iniziare la giornata"

02 – Colazione semplice

Si pone che la scelta sia tra due tipologie di colazione, latte o te, in alternativa bisogna bere acqua.

Diagramma di flusso Mermaid

graph TD
    A[Inizio] --> B[Apri cucina]
    B --> C{Hai fame?}
    C -- Si --> D[Scegli bevanda]
    D --> E{Bevanda scelta latte?}
    E -- Si --> F[Prepara latte]
    E -- No --> G[Prepara te]
    F --> H[Mangia colazione]
    G --> H
    C -- No --> I[Bevi acqua]
    H --> Z[Fine]
    I --> Z

Diagramma di flusso

Pseudocodice

APRI_CUCINA()
LEGGI fame // "si" oppure "no"

SE fame == "si" ALLORA
   SCRIVI "Scegli una bevanda"
   LEGGI bevanda // "latte" oppure "te"
   SE bevanda == "latte" ALLORA
      PREPARA_LATTE()
   ALTRIMENTI
      PREPARA_TE()
   FINE SE
   MANGIA_COLAZIONE()
ALTRIMENTI
   BEVI_ACQUA()
FINE SE

SCRIVI "Colazione terminata"

03 – Prepara lo zaino

Diagramma di flusso Mermaid

APRI_DIARIO()
LEGGI listaLibriRichiesti
IMPOSTA zaino = lista_vuota
PER ciascun libro IN listaLibriRichiesti:
   AGGIUNGI libro A zaino
FINE PER

CONTROLLA_ASTUCCIO()

LEGGI mancaQualcosa // "si" oppure "no"
MENTRE mancaQualcosa == "si" FAI
   LEGGI cosaManca
   AGGIUNGI cosaManca A zaino
   LEGGI mancaQualcosa // ricontrolla
FINE MENTRE

SCRIVI "Zaino pronto"

Diagramma di flusso

Pseudocodice

APRI_DIARIO()
LEGGI listaLibriRichiesti
IMPOSTA zaino = lista_vuota
PER ciascun libro IN listaLibriRichiesti:
   AGGIUNGI libro A zaino
FINE PER

CONTROLLA_ASTUCCIO()

LEGGI mancaQualcosa // "si" oppure "no"
MENTRE mancaQualcosa == "si" FAI
   LEGGI cosaManca
   AGGIUNGI cosaManca A zaino
   LEGGI mancaQualcosa // ricontrolla
FINE MENTRE

SCRIVI "Zaino pronto"

04 – Uscire di casa in base al meteo

Si pone che, in funzione del tempo, la scelta sia tra due oggetti alternativi: ombrello o cappellino.

Diagramma di flusso Mermaid

graph TD
    A[Inizio] --> B[Leggi meteo]
    B --> C{Pioggia?}
    C -- Si --> D[Prendi ombrello]
    C -- No --> E[Prendi cappellino]
    D --> F[Esci di casa]
    E --> F
    F --> Z[Fine]

Diagramma di flusso

Pseudocodice

LEGGI meteo // "pioggia" oppure "sereno"

SE meteo == "pioggia" ALLORA
   PRENDI_OMBRELLO()
ALTRIMENTI
   PRENDI_CAPPELLINO()
FINE SE

ESCI_DI_CASA()
SCRIVI "Buona giornata"

05 – Zaino intelligente (liste + loop)

Diagramma di flusso Mermaid

graph TD
    A[Inizio] --> B[Leggi orarioDelGiorno come elenco di materie]
    B --> C[Inizializza libriNecessari come lista vuota]
    C --> D[Imposta i = 0]
    D --> E[Calcola n uguale a numero di materie]
    E --> F{i minore di n?}

    F -- Si --> G[Prendi materia in posizione i]
    G --> H[Aggiungi materia a libriNecessari]
    H --> I[Incrementa i di 1]
    I --> F

    F -- No --> L[Stampa Metti nello zaino elenco libriNecessari]
    L --> Z[Fine]

Diagramma di flusso

Pseudocodice

LEGGI orarioDelGiorno   // lista, es: ["Mate","Storia","Inglese","Sistemi"]
IMPOSTA libriNecessari a lista vuota

PER ogni materia in orarioDelGiorno:
    AGGIUNGI materia a libriNecessari

SCRIVI "Metti nello zaino: " + libriNecessari

… e magari fate anche la versione per il quaderno e i materiali da portare con voi.

06 – Pomodoro di studio (ciclo + timer)

Visto che adotto questo metodo nella mia vita lavorativa, non potevo non propinare lo pseudocodice della tecnica del pomodoro.

Studiare a blocchi da 25’ con pause da 5’, per 4 cicli.

Diagramma di flusso Mermaid

graph TD
    A[Inizio] --> B[Imposta pomodoro = 1]
    B --> C{pomodoro <= 4} C -->|Si| D[Stampa Studia 25 minuti Pomodoro pomodoro]
    D --> E[Attendi 25 minuti]
    E --> F{pomodoro < 4} F -->|Si| G[Stampa Pausa 5 minuti]
    G --> H[Attendi 5 minuti]
    H --> J[Incrementa pomodoro di 1]
    F -->|No| I[Salta pausa]
    I --> J
    J --> C
    C -->|No| K[Stampa Sessione completata]
    K --> Z[Fine]

Diagramma di flusso

Pseudocodice

PER pomodoro da 1 a 4:
    SCRIVI "Studia 25 minuti (Pomodoro " + pomodoro + ")"
    ATTENDI 25 minuti
    SE (pomodoro < 4) ALLORA:
        SCRIVI "Pausa 5 minuti"
        ATTENDI 5 minuti
SCRIVI "Sessione completata!"

Per i miei studenti

Lista degli esercizi che dovrete fare come compito (vi dirò quando):

    1. Lavarsi i denti (tempo minimo per lavaggio 2 min).
    2. Merenda e soldi (se soldi maggiore di 2€ compro panino, altrimenti porto merenda da casa).
    3. Smartphone e batteria (se livello della batteria è inferiore al 20% ricaricare).
    4. Spegnere la luce uscendo di casa (tenere conto anche della chiusura con chiavi della porta di casa).
    5. Priorità compiti (ordinamento concettuale, ordinare le attività per scadenza e importanza).
    6. Vestiti in base al meteo (vestirsi in base al meteo (IF multiplo)).
    7. Abitudine acqua (promemoria ciclico, bere 1 bicchiere ogni ora tra le 9 e le 13).
    8. Media dei voti e situazione (input + aritmetica. Calcolare media e capire se sei sopra la soglia 6).

Seguiranno altri esercizi.

Nella prossima lezione vedremo come passare dallo pseudocodice ad uno sketch Arduino.

Buon pseudocodice a tutti 😉

Related posts:

  1. Lezione 8 – Corso di Elettronica Creativa con Arduino Sensor Kit
  2. Progettare bene, programmare meglio: diagrammi di flusso – cos’è il formato Mermaid? – Lezione 2/5
  3. Quick References per lo studio – Tecnica del pomodoro
  4. Il MaKey MaKey tra le mie mani

Esercitazioni di base di Arduino – visualizzazione luminosità LED mediante una barra di avanzamento su display 16×2

Lascia una risposta


Continuo nell’aggiornamento delle esercitazioni di base per gli studenti di 3′ dell’ITIS (Elettronica ed Automazione) e per gli utenti che iniziano con Arduino.
Utilizzeremo un display LCD 16×2 di tipo I2C su cui visualizzeremo mediante una barra di avanzamento, la quantità di luminosità impostata per il LED, mediante un potenziometro.

Per la gestione di un display LCD di tipo I2C rimando alla mia lezione: Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T.

Per la creazione di caratteri personalizzati rimando alla mia lezione: Disegnare caratteri personalizzati con Arduino per un LCD 16×2.

Lista componenti

  • N.1 Arduino UNO
  • N.1 Breadboard
  • N.1 LCD 16×2 I2C
  • N.1 Potenziometri da 10 KOhm
  • N.1 LED da 5 mm
  • N.1 Resistore da 220 Ohm
  • jumper

Schema di collegamento

Scketch

Di seguito viene indicato il codice i base, all’interno i commenti che ne dettagliano il funzionamento di ogni parte:

/*
   Prof. Maffucci Michele
   https://www.maffucci.it
   Ver.1 - 27.12.21
   Controllo di luminosità LED con
   visualizzazione intensità mediante una
   barra di avanzamento su display 16x2
*/

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

byte pinPot = A0;           // pin analogico 0 a cui connettere il potenziometro per controllare la luminosità
byte pinLed = 3;            // pin PWM a cui connettere il LED
int  analogVal = 0;         // variabile in cui memorizzare il valore impostato dal potenziometro
int  luminosita = 0;        // variabile in cui memorizzare la luminosità
byte barraAvanzamento = 0;  // indice barra avanzamento

// Per maggiori informazioni sulla realizzazione di caratteri speciali:
// https://www.maffucci.it/2020/01/18/disegnare-caratteri-personalizzati-con-arduino-per-un-lcd-16x2/

// Carattere personalizzato per disegnare la barraAvanzamento di avanzamento
byte iconaBarra[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

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

void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione

  // Inpostazione ad OUTPUT del pin a cui connettiamo il LED
  pinMode(pinLed, OUTPUT);

  // Cancella il display
  lcd.clear();

  // Stampa il messaggio sulla prima riga del display
  lcd.print("Luminosita' LED");

  //Creazione del carattere per la barra di avanzamento
  lcd.createChar(0, iconaBarra);
}

// Per maggiori informazioni sull'uso del display 16x2 I2C:
// https://www.maffucci.it/2019/01/25/utilizzo-delllcd-16x2-hitachi-hd44780-1602-con-modulo-i2c-pcf8574t/
//-----------------------------

void loop() {
  // Cancella il display
  lcd.clear();

  // Stampa il messsaggio sulla prima riga
  lcd.print("Luminosita' LED");

  //Posiziona il cursore nella seconda riga, prima colonna
  lcd.setCursor(0,1);

  // Lettura del valore impostato dal potenziometro
  analogVal = analogRead(pinPot);

  // Conversione del valore analogico impostato con il potenziometro
  // in Duty Cicle per impostare la luminosità del LED
  luminosita=map(analogVal, 0, 1024, 0, 255);

  // Impostazione della luminosità del LED
  analogWrite(pinLed, luminosita);

  // Conversione della luminosità in quantità di caratteri della barra da stampare
  barraAvanzamento=map(luminosita, 0, 255, 0, 15);

  // Stampa la barra di avanzamento
  for (byte i = 0; i < barraAvanzamento; i++)
  {
    lcd.setCursor(i, 1);
    lcd.write(byte(0));
  }
  // leggero ritardo di 500 ms per visualizzare la barra
  delay(500);
}

Proposta esercizi

Esercizio 1
Nell’esempio proposto viene utilizzato un delay() finale per permettere la visualizzazione dei caratteri sul display. Sostituire il delay() ed utilizzare l’istruzione millis() per valutare il tempo trascorso e controllare la stampa dei caratteri sul display.

Esercizio 2
Modificare il programma precedente raddoppiando il numero di caratteri che rappresenta la barra di avanzamento.

Esercizio 3
Modificare l’esercizio proposto variando la barra di avanzamento in funzione dell’approssimarsi al valore massimo o minimo della luminosità.

Esercizio 4
Modificare l’esercizio proposte inserendo un buzzer che emette un suono la cui frequenza varia in funzione dell’intensità luminosa del LED.

Buon Making a tutti 🙂

Related posts:

  1. Utilizzare un orologio RTC con Arduino – Modulo Tiny RTC I2C – Visualizzazione su display I2C
  2. Errori comuni nell’uso di Arduino – confondere pin analogici con pin digitali
  3. Lezione 3 – Arduino GamePad – LCD1602 Keypad Shield della Keyestudio
  4. Papà mi costruisci una lampada ecosostenibile?

Esercitazione di Sistemi Elettronici – Arduino – impianto semaforico ad 1 via

Lascia una risposta

Questa esercitazione è dedicata ai miei studenti di 3′ (Automazione ed Elettronica Biomedicale) che come compito per le vacanze natalizie dovranno, partendo dall’esempio svolto, realizzare le 4 varianti richieste al fondo di questa lezione.

Introduzione

  • In questo progetto bisognerà realizzare l’impianto semaforico per automobili e modificarlo secondo le specifiche indicate al fondo di questo post
  • vengono utilizzati 3 LED: verde, giallo e rosso per simulare un semaforo reale
  • vengono utilizzati 2 LED : verde e rosso per simulare il semaforo per i pedoni
  • è presente un pulsante di richiesta attraversamento per i pedoni

Lista componenti

  • 1 Breadboard
  • 1 Arduino UNO
  • 3 LED da 5mm (rosso, giallo, verde)
  • 2 LEd da 5mm LED (rosso, verde)
  • 5 resistori da 220 Ohm
  • 1 resistore da 10 kOhm
  • 1 pulsante normalmente aperto
  • jumper

Collegamenti

Sketch

Per la realizzazione di questo progetto non avrete necessità di nessuna libreria da aggiungere all’IDE di Arduino.

L’automazione del semaforo sarà la seguente:

  • Il semaforo per le automobili è sempre verde e la luce pedonale risulta sempre rossa a meno che qualcuno preme il pulsante.
  • Quando viene premuto il pulsante dal pedone:
    • il semaforo auto cambia da giallo e successivamente si spegne il giallo e si accende il rosso;
    • sul semaforo pedonale si spegne il rosso e si accende il verde;
    • le luci del semaforo pedonale rimangono in questo stato per un tempo pari a tempoAttraversamento
    • successivamente il verde del semaforo pedonale lampeggia, terminata la sequenza di lampeggio si spegne e si accende il rosso;
  • il semaforo delle auto passa da rosso a verde

Tutte queste funzioni sono svolte dalla funzione cambiabentoLuci().

/*
   Prof. Maffucci Michele
   Ver.1 - 22.12.21
   Impianto semaforico con attraversamento
   pedonale a richiesta
*/

// pin a cui sono connessi i LED
byte rossoAuto = 13;
byte gialloAuto = 12;
byte verdeAuto = 11;
byte rossoPedone = 10;
byte verdePedone = 9;

// pin a cui è connesso il pulsante di richiesta
byte pulsante = 8;

// tempo massimo di attraversamento del pedone
int tempoAttraversamento = 10000;

// definizione della variabile per l'impostazione
// del cambio stato del semaforo auto
unsigned long tempoCambio;

void setup() {
  // inizializzazione timer
  tempoCambio = millis();

  // inizializzazione dei pin come OUTPUT

  pinMode(rossoAuto, OUTPUT);
  pinMode(gialloAuto, OUTPUT);
  pinMode(verdeAuto, OUTPUT);
  pinMode(rossoPedone, OUTPUT);
  pinMode(verdePedone, OUTPUT);

  // inizializzazione pin come INPUT
  pinMode(pulsante, INPUT);

  // accensione luci verdi
  // all'avvio le auto hanno il verde e i pedoni il rosso
  digitalWrite(verdeAuto, HIGH);
  digitalWrite(rossoPedone, HIGH);
  digitalWrite(rossoAuto, LOW);
  digitalWrite(gialloAuto, LOW);
  digitalWrite(verdePedone, LOW);

  // inizializzazione della Serial Monitor
  Serial.begin(9600);
}

void loop() {
  // la variabile state viene utilizzata per sapere se il
  // pulsante di attraversamento viene premuto
  int stato = digitalRead(pulsante);

  // lo stato del pulsante viene visualizzato sulla Serial Monitor
  Serial.println(stato);

  // Se viene premuto il pulsante e se sono
  // passati 5 secondi dall'ultima pressione del pulsante

  if (stato == HIGH && (millis() - tempoCambio) > 5000) {
    // chiama la funzione per il cambio luci
    cambioLuci();
  }
}

void cambioLuci() {
  digitalWrite(verdeAuto, LOW);      // il LED verde viene spento
  digitalWrite(gialloAuto, HIGH);    // il LED giallo viene acceso per 2 secondi
  delay(2000);

  digitalWrite(gialloAuto, LOW);    // il LED giallo viene spento
  digitalWrite(rossoAuto, HIGH);    // il LED rosso viene acceso per 5 secondi

  digitalWrite(rossoPedone, LOW);   // il LED rosso del pedone viene spento
  digitalWrite(verdePedone, HIGH);  // il LED verde del pedone viene acceso
  delay(tempoAttraversamento);

  // lampeggio del LED verde dei pedoni
  for (int x = 0; x < 10; x++) {
    digitalWrite(verdePedone, LOW);
    delay(100);
    digitalWrite(verdePedone, HIGH);
    delay(100);
  }
  digitalWrite(verdePedone, LOW);
  digitalWrite(rossoAuto, LOW);
  digitalWrite(rossoPedone, HIGH);
  digitalWrite(verdeAuto, HIGH);

  tempoCambio = millis();
}

Esercizio 1
Aggiungere un sensore ad ultrasuoni che rileva la presenza del pedone in fase di attraversamento, fino a quando viene rilevato il pedone viene mantenuto il verde per il pedone ed il rosso per le auto. E’ presente sempre il pulsante di richiesta attraversamento.

Esercizio 2
Ampliare l’esercizio 1 aggiungendo un display a 7 segmenti utilizzato come conto alla rovescia (da 9 a 0) per i pedoni quando attraversano.

Esercizio 3
Ampliare l’esercizio 1 aggiungendo un buzzer che con un segnale pulsante variabile, indica l’approssimarsi del rosso.

Esercizio 4
Ampliare l’esercizio proposto in questa lezione trasformando l’impianto semaforico da 1 via a 4 vie con rispettivi attraversamenti pedonali sulle 4 strade.

Per coloro che non sono miei studenti, sul mio Patreon nei prossimi giorni verrà proposta:

  • La soluzione a tutti gli esercizi proposti con schemi di collegamento e codice
  • Video di spiegazione
  • Sorgenti STL per la stampa 3D di un semaforo da poter essere inseriti all’interno di un plastico
  • Proposta progettuale per la realizzazione di un kit didattico per lo sviluppo di questa tipologia di esercizi.

Buon Making a tutti.

Related posts:

  1. ROB-O-COD un evento da replicare a scuola – lo racconterò a Fossano (Cn) il 6 giugno prossimo
  2. Imparare a creare applicazioni utilizzando le API di Google Drive
  3. La micro matita
  4. Papà mi costruisci una lampada ecosostenibile?