Archivi tag: Arduino UNO R4

Esercitazione 4 – Macchina a stati per un ciclo automatico con start, pausa, allarme e reset

2 Repliche

Allenamento per l’esame di maturità
Percorso di laboratorio con Arduino per studenti di quinta ITIS

Obiettivo didattico

Modellare un ciclo automatico come macchina a stati: attesa, marcia, pausa, allarme e reset. L’attività avvicina gli studenti al modo in cui si progetta un processo tecnico da esame.

Materiali suggeriti

  • Arduino UNO R3 o UNO R4,
  • 3 pulsanti (START, PAUSA, RESET);
  • 2 LED;
  • 2 Resistori da 220 Ohm (per i LED);
  • jumper.

Schema di collegamento

Richiamo teorico

Una macchina a stati finiti rappresenta un processo come un insieme di stati mutuamente esclusivi. In ogni stato il sistema esegue azioni ben definite e attende eventi che causano il passaggio allo stato successivo. Questo metodo riduce gli errori logici nei programmi complessi.

Schema logico dell’attività

  • All’avvio il sistema è in ATTESA;
  • se arriva START passa a MARCIA;
  • in MARCIA può ricevere PAUSA oppure entrare in ALLARME se scade il tempo massimo;
  • in PAUSA attende una nuova pressione di START;
  • da ALLARME si esce solo con RESET, che riporta il sistema in ATTESA.

Diagramma a stati

Per rappresentare in modo corretto il comportamento di questo esercizio è molto utile affiancare al codice un diagramma a stati. In questo caso, infatti, il sistema non si limita a eseguire istruzioni una dopo l’altra, ma cambia comportamento in funzione della condizione operativa in cui si trova.

Il programma può trovarsi in un solo stato per volta, e ogni stato descrive una precisa fase di funzionamento del sistema. Nel nostro sketch gli stati sono quattro:

  • STATO_ATTESA
  • STATO_MARCIA
  • STATO_PAUSA
  • STATO_ALLARME

Il diagramma a stati è particolarmente adatto a questa situazione perché mostra in modo immediato tre aspetti fondamentali:

  • quali sono gli stati possibili del sistema;
  • quali eventi provocano il passaggio da uno stato all’altro;
  • quale logica di funzionamento è stata implementata nel codice.

In altre parole, mentre il diagramma di flusso descrive bene la sequenza dei controlli svolti nel loop(), il diagramma a stati descrive meglio la struttura logica del processo.

Stato iniziale del sistema

Nel diagramma compare il simbolo iniziale che punta verso STATO_ATTESA. Questo significa che, all’accensione di Arduino o dopo un reset, il sistema parte nello stato di attesa.

In questa fase il ciclo automatico non è attivo. Il LED di marcia è spento, il LED di allarme è spento e il programma controlla continuamente i pulsanti in attesa di un comando di avvio.

Dal punto di vista didattico, questo è il comportamento tipico di molti sistemi automatici: il processo non parte in modo autonomo, ma richiede un comando esplicito dell’operatore.

Transizione da ATTESA a MARCIA

Dal nodo STATO_ATTESA parte una freccia verso STATO_MARCIA con l’etichetta:

START premuto / istanteInizioMarcia = millis()

Questa notazione va letta così: se il sistema si trova in attesa e viene rilevata la pressione del pulsante START, allora il programma passa allo stato di marcia. Durante questa transizione viene anche eseguita un’azione importante, cioè il salvataggio dell’istante iniziale della marcia tramite millis().

Questo passaggio è fondamentale perché permette al sistema di iniziare a contare il tempo trascorso in marcia senza bloccare il programma. In pratica, nel momento in cui parte la marcia, viene memorizzato il riferimento temporale da cui inizierà il controllo del timeout.

Significato dello stato MARCIA

Lo stato STATO_MARCIA rappresenta la fase in cui il sistema è attivo.

In questa condizione il LED di marcia viene acceso, il LED di allarme resta spento e il programma continua a controllare due possibili situazioni:

    • la richiesta di pausa;
    • il superamento del tempo massimo consentito.

Importante: nello stato di marcia il sistema non esegue una sola azione, ma resta in una condizione operativa in cui il programma continua a verificare gli eventi che possono modificare il comportamento complessivo del processo.

Transizione da MARCIA a PAUSA

Se durante la marcia viene premuto il pulsante PAUSA, il sistema passa a STATO_PAUSA.

Questa transizione rappresenta una sospensione del ciclo. Dal punto di vista logico, il processo non è terminato, ma è momentaneamente fermo in attesa di un nuovo comando.

Nel diagramma questa freccia mostra che la pausa può essere richiesta solo quando il sistema si trova effettivamente in marcia. Questo rende molto chiaro un concetto fondamentale: non tutti i comandi hanno senso in tutti gli stati. Il significato di un ingresso dipende dallo stato corrente del sistema.

Transizione da MARCIA a ALLARME

La seconda uscita possibile da STATO_MARCIA conduce a STATO_ALLARME ed è attivata dal superamento del tempo massimo di marcia.

Nel codice questa condizione è realizzata confrontando il tempo attuale, ottenuto con millis(), con l’istante iniziale salvato all’ingresso nello stato di marcia. Quando la differenza raggiunge o supera il valore impostato in TEMPO_MASSIMO_MARCIA, il sistema genera l’allarme.

Questo passaggio è interessante perché mostra come una macchina a stati possa cambiare stato non solo in risposta a un pulsante, ma anche in risposta a una condizione temporale. In molti sistemi automatici reali, infatti, il tempo costituisce un vincolo di sicurezza o di controllo del processo.

Significato dello stato PAUSA

Lo stato STATO_PAUSA rappresenta una sospensione controllata del ciclo.

In questa fase il LED di marcia è spento e il LED di allarme è spento. Il programma non torna allo stato iniziale, ma resta in una condizione intermedia da cui il processo può riprendere.

Dal diagramma si vede che da questo stato esiste una sola transizione utile: la pressione di START, che riporta il sistema in STATO_MARCIA.

È importante però osservare un dettaglio del codice: quando si torna in marcia dalla pausa, il programma esegue di nuovo l’istruzione che salva istanteInizioMarcia = millis(). Questo significa che il conteggio del tempo massimo non viene congelato e poi ripreso, ma riparte da zero.

Questo aspetto è importante, perché aiuta a capire che il diagramma descrive la struttura generale del comportamento, mentre le variabili e le azioni associate alle transizioni determinano il comportamento concreto del sistema.

Significato dello stato ALLARME

Lo stato STATO_ALLARME rappresenta una condizione anomala o di sicurezza.

Quando il sistema entra in allarme, il LED di marcia viene spento e il LED di allarme viene acceso. In questo modo l’operatore può riconoscere immediatamente che il ciclo si è interrotto per il superamento del limite previsto.

Dal diagramma si vede che da STATO_ALLARME non si può tornare direttamente in marcia. L’unica uscita prevista è verso STATO_ATTESA, e questa transizione è attivata dal pulsante RESET.

Anche questa è una scelta molto importante dal punto di vista progettuale: in presenza di un allarme il sistema non riparte automaticamente, ma richiede un intervento esplicito da parte dell’operatore. È una logica tipica dei sistemi in cui la sicurezza o il controllo delle anomalie hanno priorità sulla continuità del funzionamento.

IMPORTANTE

Quando si studiano le macchine a stati è utile distinguere tra:

      • azioni di stato, cioè ciò che il sistema fa mentre si trova in un determinato stato;
      • azioni di transizione, cioè ciò che il sistema esegue nel momento in cui passa da uno stato a un altro.

Nell’esercizio proposto, l’accensione o lo spegnimento dei LED, è un’azione associata allo stato, perché avviene nel blocco di codice relativo a ciascun case.

Il salvataggio di istanteInizioMarcia, invece, è un’azione di transizione, perché viene eseguito nel momento in cui il sistema entra nello stato di marcia.
Questa distinzione è molto utile per comprendere meglio sia il diagramma sia il codice.

Continua a leggere→

Related posts:

  1. Domande dagli utenti – Perché Arduino legge valori strani se il pin non è collegato?
  2. Quick References per lo studio – Checklist pre-verifica
  3. Esercitazione 3 – Scheduler cooperativo con tre task e supervisione dei tempi
  4. I miei corsi: Apprendimento attivo con Raspberry Pi e Arduino

Esercitazione 3 – Scheduler cooperativo con tre task e supervisione dei tempi

2 Repliche

Allenamento per l’esame di maturità
Percorso di laboratorio con Arduino per studenti di quinta ITIS

Obiettivo didattico

Organizzare il programma come scheduler cooperativo con tre task indipendenti: acquisizione analogica, lampeggio di stato e trasmissione seriale periodica. L’attività mostra come il loop() possa diventare un piccolo supervisore software.

Materiali suggeriti

  • Arduino UNO R3 o UNO R4;
  • 1 potenziometro;
  • 2 LED;
  • 2 resitori (per i LED);
  • breadboard;
  • cavetti jumper.

Schema di collegamento

Richiamo teorico

In un sistema embedded semplice non si usa un vero sistema operativo, ma si può costruire uno scheduler cooperativo con millis(). Ogni task possiede il proprio intervallo e il proprio istante dell’ultima esecuzione. Il loop() controlla se ciascun task è pronto e lo richiama.

Schema logico dell’attività

Il programma inizializza i timer dei tre task. Nel loop legge il tempo corrente e verifica uno dopo l’altro se è il momento di eseguire il task di acquisizione, quello di segnalazione e quello di stampa seriale. Se il tempo non è scaduto, passa al controllo successivo.

Diagramma di flusso

Diagramma di flusso Mermaid

flowchart TD
    A[Inizio] --> B[Configura pin, seriale e timer]
    B --> C[Leggi tempo attuale]
    C --> D{Task acquisizione pronto?}
    D -- Sì --> E[Esegui acquisizione]
    D -- No --> F{Task LED pronto?}
    E --> F
    F -- Sì --> G[Commuta LED di stato]
    F -- No --> H{Task seriale pronto?}
    G --> H
    H -- Sì --> I[Invia dati in seriale]
    H -- No --> J[Ritorna al loop]
    I --> J
    J --> C

Programma

/*
  Prof. Maffucci Michele
  Esercizio 3: scheduler cooperativo con tre task indipendenti
*/

const int PIN_SENSORE = A0;
const int PIN_LED_STATO = 8;
const int PIN_LED_SOGLIA = 9;

// ---------------------------
// Intervalli dei tre task
// ---------------------------
const unsigned long PERIODO_ACQUISIZIONE = 50;
const unsigned long PERIODO_LED = 300;
const unsigned long PERIODO_SERIALE = 500;

// ---------------------------
// Istanti ultima esecuzione
// ---------------------------
unsigned long ultimoTaskAcquisizione = 0;
unsigned long ultimoTaskLed = 0;
unsigned long ultimoTaskSeriale = 0;

// ---------------------------
// Variabili condivise
// ---------------------------
int valoreGrezzo = 0;
float tensione = 0.0;
bool statoLed = false;

void setup() {
  pinMode(PIN_LED_STATO, OUTPUT);
  pinMode(PIN_LED_SOGLIA, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  // Il loop assume il ruolo di piccolo scheduler.
  unsigned long adesso = millis();

  // ---------------------------
  // Task 1: acquisizione
  // ---------------------------
  if ((adesso - ultimoTaskAcquisizione) >= PERIODO_ACQUISIZIONE) {
    ultimoTaskAcquisizione = adesso;
    taskAcquisizione();
  }

  // ---------------------------
  // Task 2: LED di stato
  // ---------------------------
  if ((adesso - ultimoTaskLed) >= PERIODO_LED) {
    ultimoTaskLed = adesso;
    taskLed();
  }

  // ---------------------------
  // Task 3: seriale
  // ---------------------------
  if ((adesso - ultimoTaskSeriale) >= PERIODO_SERIALE) {
    ultimoTaskSeriale = adesso;
    taskSeriale();
  }
}

// ----------------------------------------------------------
// Legge il sensore e calcola una tensione equivalente.
// ----------------------------------------------------------
void taskAcquisizione() {
  valoreGrezzo = analogRead(PIN_SENSORE);

  // Conversione esplicita ADC -> tensione.
  tensione = (valoreGrezzo * 5.0) / 1023.0;

  // Uso della misura per attivare un LED di soglia.
  if (tensione >= 2.50) {
    digitalWrite(PIN_LED_SOGLIA, HIGH);
  } else {
    digitalWrite(PIN_LED_SOGLIA, LOW);
  }
}

// ----------------------------------------------------------
// Task di segnalazione periodica.
// ----------------------------------------------------------
void taskLed() {
  if (statoLed == false) {
    statoLed = true;
    digitalWrite(PIN_LED_STATO, HIGH);
  } else {
    statoLed = false;
    digitalWrite(PIN_LED_STATO, LOW);
  }
}

// ----------------------------------------------------------
// Task di comunicazione seriale.
// ----------------------------------------------------------
void taskSeriale() {
  Serial.print("ADC = ");
  Serial.print(valoreGrezzo);
  Serial.print("  Tensione = ");
  Serial.print(tensione, 2);
  Serial.println(" V");
}

Continua a leggere→

Related posts:

  1. Capire prima di costruire: una nuova serie di elettrotecnica ed elettronica
  2. Multitasking con Arduino – lezione 1/3
  3. Arduino VENTUNO Q: la nuova piattaforma per AI, robotica e attuazione
  4. Arduino nello zaino, upgrade: un saldatore TS101 in un rugged case stampato in 3D

Arduino UNO R4 WiFi – DAC – generazione di onde sinusoidali, quadre e a dente di sega

Lascia una risposta

Una delle nuove caratteristiche presenti in entrambe le schede Arduino Uno R4, Minima e WiFi, è l’inclusione di un singolo DAC a 12 bit. Questo può generare tensioni di uscita discrete da 0 a 5 volt. Poiché questa funzionalità può essere di estremo interesse nelle attività di laboratorio di Elettronica ne indico di seguito il principio di funzionamento per sviluppare future esercitazioni.

Principio di funzionamento

Un DAC, o Convertitore Digitale-Analogico (in inglese: Digital-to-Analog Converter), è un dispositivo che converte un valore digitale (in binario) in un valore analogico (segnali continui che possono assumere un’infinità di valori all’interno di un intervallo).
Si tratta dell’operazione inversa di quella eseguita da un ADC, o Convertitore Analogico-Digitale, che converte un segnale analogico in una rappresentazione digitale.

Il processo di conversione avviene in tre fasi:

  1. lettura in input dei dati digitali,
  2. conversione in analogico
  3. output del segnale analogico

Il DAC riceve in input un segnale digitale, che è rappresentato da una serie di valori binari (0 e 1), l’elettronica del DAC consente successivamente di convertire i valori binari in un segnale di output analogico che può essere utilizzato per pilotare dispositivi analogici come altoparlanti, motori, o altre apparecchiature che necessitano di un ingresso analogico.

Dal punto di vista pratico un DAC può essere utilizzato per creare un’uscita analogica a partire da un valore digitale utile per molte applicazioni, ad esempio per generare forme d’onda audio, per pilotare dispositivi che richiedono un input analogico, o per creare segnali di tensione variabile. Ad esempio nei sistemi audio un DAC converte i segnali audio digitali (come quelli presenti nei file MP3 o nei CD) in segnali analogici che possono essere riprodotti attraverso altoparlanti o cuffie.

Per semplificare ulteriormente nell’utilizzo con Arduino UNO R4, immaginate di avere un valore digitale che varia da 0 a 4095 (rappresentando un range di 12 bit). Un DAC potrebbe convertire questo valore in una tensione che varia, ad esempio, da 0V a 5V. Quindi, se il valore digitale fosse 512 (circa metà del range), l’uscita del DAC potrebbe essere di circa 0,6V.

Vediamo un esempio pratico.

Lo sketch che segue genera una forma d’onda sinusoidale o, meglio, una forma d’onda sinusoidale “simulata”. La frequenza della forma d’onda sinusoidale viene controllata da potenziometro.

Utilizzeremo un oscilloscopio per visualizzare l’onda sinusoidale, il collegamento è piuttosto semplice, abbiamo bisogno di un potenziometro lineare con una resistenza di 5 KOhm o superiore, io ho utilizzato un potenziometro da 10 KOhm.

La sonda dell’oscilloscopio deve essere connessa al pin A0 che viene usata come uscita del DAC. Il potenziometro ha il pin centrale connesso ad A5 (ingresso del DAC), un pin laterale connesso a 5V sulla scheda e l’altro pin laterale connesso a GND sulla scheda.

Se non possedete un oscilloscopio potete inviare l’output ad un amplificatore audio in modo che possiate ascoltare la tonalità generata, ricordate però che se procedete in questo modo bisogna assicurarsi che il controllo del volume sull’amplificatore sia al minimo, dopo di che lentamente aumentate il volume.

Il codice indicato di seguito è tratto dall’esempio di riferimento sul sito Arduino e all’interno degli esempi dell’IDE su cui ho inserito i commenti tradotti in italiano e fatto una piccola correzione.

La spiegazione del funzionamento la trovate nei commenti.

// Prof. Maffucci Michele
// Arduino UNO R4 Digital-to-Analog Converter (DAC)
// Sketch di esempio tratto da: https://docs.arduino.cc/tutorials/uno-r4-wifi/dac/

// libreria per la generazione di forme d'onda analogiche
#include "analogWave.h"

// Crea un'istanza della classe analogWave, usando il pin DAC
analogWave wave(DAC);

int frequenza = 10; // variabile intera che conterrà la frequenza rilevata

void setup() {
Serial.begin(115200);
// pinMode(A5, INPUT); // non necessaria perchè ingresso analogico
wave.sine(frequenza);
}

void loop() {
// legge un valore analogico dal pin A5 e lo mappa nell'intervallo 0 - 10000 Hz
frequenza = map(analogRead(A5), 0, 1024, 0, 10000);

// Stampa l'aggiornmento dell frequenza impostata sulla serial monitor
Serial.println("La frequenza e' " + String(frequenza) + " hz");

// Imposta la frequenza del generatore di forma d'onda sul valore aggiornato
wave.freq(frequenza);

// aspetta un secondo prima di ripetere la successiv rilevazione
delay(1000);
}

Volutamente ho lasciato commentata nel setup() la riga di codice in cui viene impostato il pinMode del pin A5 perché non è necessario inizializzare un pin Analogico, nell’esempio originale invece viene inizializzata.
A tal proposito per chi inizia con Arduino consiglio la lettura della guida: “Errori comuni nell’uso di Arduino – confondere pin analogici con pin digitali“.

Il risultato sarà il seguente:

E’ possibile quindi generare forme d’onda non solo sinusoidali, la funzione wave permette di impostare:

  • sine – onda sinusoidale
  • square – onda quadra
  • saw – onda a dente di sega

sarà sufficiente sostituire wave.sine(frequenza) presente nella sezione setup() rispettivamente con:

  • wave.square(frequenza);
  • wave.saw(frequenza);

Onda quadra:

Onda a dente di sega:

Buon Making a tutti 🙂

Related posts:

  1. IoT con WeMos D1 Mini usando Arduino IDE e Blynk
  2. I miei corsi: Apprendimento attivo con Raspberry Pi e Arduino
  3. MaKey MaKey nella Robot Pet Therapy e non solo
  4. Corso di Processing – lezione 04

EduRobot MicroMoto – Versione Arduino

Lascia una risposta

Qualche mese fa durante un corso per docenti avevo realizzato EduRobot MicroMoto un piccolo kit robotico nato dalla necessità di realizzare attività di Coding e Robotica che potessero essere sperimentate da un numero elevato di allievi, inclusivo dal punto di vista economico, facile da assemblare e personalizzare.

MicroMoto nasce per essere essenziale, sia nella costruzione che nell’uso quotidiano, con  una forma compatta per essere utilizzato comodamente a scuola, sia aula che in laboratorio o a casa.

Il piccolo MicroMoto è stato adottato da diverse classi 🙂 e ringrazio i colleghi che hanno seguito i miei corsi per aver usato questo progetto. In questi mesi mi sono giunte richieste per la realizzazione di una versione Arduino, nello specifico della versione R4 che permette comunicazione Bluetooth e WiFi con un display per mostrare gli stati del sistema e possibilità di essere programmato in C ed in MicroPython e questa versione la utilizzerò da domani per un corso di robotica indirizzato a docenti.

La modalità costruttiva per questa versione Arduino è la medesima di quella realizzata per la versione BBC micro:bit con scheda motori :MOVE, sono presenti però alcune piccole differenze nella faccia superiore, nel taglio delle palline da Ping Pong utilizzate come Caster Ball e nell’uso di un pacco batteria posto nella parte interna del robot, fate riferimento a questo breve tutorial ed utilizzate il PDF allegato effettuare i tagli.

Ricordo che la modalità per vincolare i motori alla struttura avviene sempre con elastici.

Come già segnalato nel post di presentazione, il design del kit è stato pensato per essere minimale e simmetrico, misurando solamente 10×10 cm. Assomiglia a una piccola scatola, assemblata con colla a caldo, un metodo che non solo garantisce maggiore sicurezza durante il montaggio, ma accelera anche significativamente il processo rispetto alle precedenti versioni che utilizzavano viti, facilitando così tutto il lavoro di costruzione.

Utilizzando cartone come materiale base, il kit permette una grande flessibilità per l’espansione e la personalizzazione. L’uso è quello di un cartone di 4 mm di spessore, ricoperto da un foglio bianco adesivo su cui sono stampati i contorni per il taglio. Questo permette agli studenti di esprimere la loro creatività, colorando e personalizzando le superfici bianche. MicroMoto può essere ulteriormente arricchito incollando pezzi Lego sulle sue superfici, offrendo così una versatile adattabilità a diverse esigenze educative.

Nel corso che sto realizzando verranno aggiunte altre funzionalità:

  • evita ostacoli
  • segui linea
  • segui luce

Allego il file PDF con i profili ritaglio in colore rosso. Nel video allegato ho usato un foglio A4 adesivo bianco, ma è possibile utilizzare anche un comune foglio di carta che potrà essere incollato al cartone.

Di seguito le istruzioni per la costruzione.

Continua a leggere→

Related posts:

  1. EduRobot Circuit Blocks – dalla manualità al PCB: L’Evoluzione di un Apprendimento Pratico dell’elettronica
  2. Laboratorio di inclusione – dall’Idea alla realtà: costruire una Clessidra ad Acqua
  3. Da Prof. 2.0: Il primo giorno (di scuola) che vorrei
  4. I miei corsi per Tecnica della Scuola: Corso: Realizzare laboratori green con il Making e il Coding – 4 ed.

Arduino UNO R4 WiFi – Visualizzare il livello di una grandezza fisica mediante una barra incrementale sulla matrice LED di Arduino

Lascia una risposta

Come anticipato nelle scorse lezioni vediamo in questo tutorial come visualizzare il livello di una grandezza fisica mediante una barra incrementale sulla matrice LED dell’Arduino UNO R4 WiFi.
Gli esempi mostrati possono essere adattati per qualsiasi tipologia di sensore, per semplicità e rapidità di realizzazione ho scelto di rilevare l’intensità luminosa mediante un LDR. Lascio a voi correzioni e miglioramenti a quanto ho scritto.

La matrice, come sapete è costituita da 8 righe di LED, Il numero di linee LED attive sarà proporzionale all’intensità luminosa rilevata:

  • Livello minimo di intensità = accensione della sola riga 7
  • Livello massimo di intensità = accensione di tutte le righe della matrice

I 6 sketch di esempio che seguono sono molto simili, tutti eseguono la calibrazione del sensore, basata sullo sketch standard che trovate all’interno degli esempi dell’IDE di Arduino. Il codice di calibrazione prevede 5 secondi di analisi che permettono di impostare il livello minimo e massimo della grandezza da misurare. Ho aggiunto per ognuno dei 6 esempi alternative diverse per mostrare sulla matrice di LED il timer di 5 secondi.

Il funzionamento di ogni parte del codice dei 6 sketch, è dettagliato mediante commenti, se avete necessità di chiarimenti non esitate a contattarmi.

Circuito

Il circuito prevede l’utilizzo di:

  • Arduino UNO R4 WiFi
  • LDR
  • Resitore da 10 KOhm

Esempio 01

Il trascorrere del tempo di calibrazione è mostrato dall’accensione sequenziale dei primi 5 LED posti sulla riga n. 7, terminata la fase di calibrazione, dopo 0,5 secondi l’array della matrice viene azzerato e viene poi avviata la rilevazione.

sketch01

// Prof. Maffucci Michele
// 31/07/23
// Visualizzazione livello luminoso su matrice LED Uno R4 WiFi
// con calibrazione sensore e visualizzazione timer di calibrazione
// con l'accensione di 5 LED della matrice

// Esercizio 01

// inclusione della libreria per la gestione della matrice
#include "Arduino_LED_Matrix.h"

// creazione dell’oggetto matrix
ArduinoLEDMatrix matrix;

// inizializzazione dell'array per inizializzare lo stato della matrice
uint8_t frame[8][12] = { 0 };

// pin a cui collegare il sensore
int pinSensore = A0;

// variabile in cui memorizzare il valore letto dal sensore
int valoreSensore = 0;

// variabili per calibrazione lovello minimo e massimo luce ambiente
int sensoreMin = 1023;  // valore minimo sensore
int sensoreMax = 0;     // valore massimo sensore

// contatore passi di calibrazione
int contatore = 0;

// valore del millis al passo precedente
unsigned long millisPrecedente = 0;
// valore del millis attuale
unsigned long millisCorrente = 0;

// intervallo in millisecondi per l'accensione di una riga di LED
const long intervallo = 1000;

// riga LED precedentemente accesa
int precedenteLivello = 0;

void setup() {
  // inizializzazione della velocità della serial monitor
  Serial.begin(115200);

  // avvio della matrice di LED
  matrix.begin();

  // calibrazione del sensore nei primi 5 secondi di avvio di Arduino
  while (millis() < 5000) {

    // memorizzazione dle valore attuale del millis
    millisCorrente = millis();

    // lettura valore
    valoreSensore = analogRead(pinSensore);

    // registra il valore massimo rilevato dal sensore
    if (valoreSensore > sensoreMax) {
      sensoreMax = valoreSensore;
    }

    // registra il valore minimo rilevato dal sensore
    if (valoreSensore < sensoreMin) {
      sensoreMin = valoreSensore;
    }

    // timer
    if (millisCorrente - millisPrecedente >= intervallo) {
      millisPrecedente = millisCorrente;
      frame[7][contatore] = 1;
      matrix.renderBitmap(frame, 8, 12);
      contatore++;
    }
  }
  // accensione dell'ultimo LED al 5' secondo
  frame[7][4] = 1;
  matrix.renderBitmap(frame, 8, 12);

  // attesa di 0,5 secondi prima di spegnere tutti i LED
  delay(500);

  // spegnimento di tutti i LED della matrice
  uint8_t frame[8][12] = { 0 };
  matrix.renderBitmap(frame, 8, 12);
}

// Accensione linee matrice (dalla riga 7)
// maggiore e' il valore numeriico di "livello" (riga LED) più bassa sarà l'intensità luminosa
// minore e' e' il valore numeriico di "livello" (riga LED) più alta sarà l'intensità luminosa

// Livello minimo di intensità = accensione della sola riga 7
// Livello massimo di intensità = accensione di tutte le linee della matrice

void barra(int livello) {
  // spegnimento della riga "livello"
  if (livello > precedenteLivello) {
    for (int y = livello; y >= precedenteLivello; y--) {
      // spegnimento dei 12 LED della riga "livello"
      for (int x = 0; x < 12; x++) {
        frame[y][x] = 0;
      }
      matrix.renderBitmap(frame, 8, 12);
      delay(1);
    }
    // accensione della riga "livello"
  } else {
    for (int y = 7; y >= precedenteLivello; y--) {
      for (int x = 0; x < 12; x++) {
        frame[y][x] = 1;
      }
      matrix.renderBitmap(frame, 8, 12);
      delay(1);
    }
  }
  precedenteLivello = livello;
}

void loop() {

  // per evitare sprechi di memoria viene utilizzata usata una stessa variabile: valoreSensore
  // per memorizzare ad ogni passo valori diversi

  // lettura del valore del sensore
  valoreSensore = analogRead(pinSensore);

  // Forzare il valore all'interno del valore minimo e del massimo nel caso di errori di lettura.
  // Nel caso non si aggiungesse il "constrain" nel caso di errore si blocca l'esecuzione
  valoreSensore = constrain(valoreSensore, sensoreMin, sensoreMax);

  // Il valore minimo di lettura è associato all'accensione della riga 7
  // quindi si rimappa tra 7 e 0
  valoreSensore = map(valoreSensore, sensoreMin, sensoreMax, 7, 0);

  // barra(valoreSensore) è la funzione che gestisce l'accensione delle linee di LED
  barra(valoreSensore);
}

Continua a leggere→

Related posts:

  1. Usare la matrice LED di Arduino UNO R4 WiFi
  2. Iniziare con Arduino UNO R4 WiFi
  3. I miei corsi: Apprendimento attivo con Raspberry Pi e Arduino
  4. BBC micro:bit – Esercizio: Realizzare un timer per il lavaggio delle mani