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

vedi sorgente
stampa?
1// Prof. Maffucci Michele
2// 31/07/23
3// Visualizzazione livello luminoso su matrice LED Uno R4 WiFi
4// con calibrazione sensore e visualizzazione timer di calibrazione
5// con l'accensione di 5 LED della matrice
6 
7// Esercizio 01
8 
9// inclusione della libreria per la gestione della matrice
10#include "Arduino_LED_Matrix.h"
11 
12// creazione dell’oggetto matrix
13ArduinoLEDMatrix matrix;
14 
15// inizializzazione dell'array per inizializzare lo stato della matrice
16uint8_t frame[8][12] = { 0 };
17 
18// pin a cui collegare il sensore
19int pinSensore = A0;
20 
21// variabile in cui memorizzare il valore letto dal sensore
22int valoreSensore = 0;
23 
24// variabili per calibrazione lovello minimo e massimo luce ambiente
25int sensoreMin = 1023;  // valore minimo sensore
26int sensoreMax = 0;     // valore massimo sensore
27 
28// contatore passi di calibrazione
29int contatore = 0;
30 
31// valore del millis al passo precedente
32unsigned long millisPrecedente = 0;
33// valore del millis attuale
34unsigned long millisCorrente = 0;
35 
36// intervallo in millisecondi per l'accensione di una riga di LED
37const long intervallo = 1000;
38 
39// riga LED precedentemente accesa
40int precedenteLivello = 0;
41 
42void setup() {
43  // inizializzazione della velocità della serial monitor
44  Serial.begin(115200);
45 
46  // avvio della matrice di LED
47  matrix.begin();
48 
49  // calibrazione del sensore nei primi 5 secondi di avvio di Arduino
50  while (millis() < 5000) {
51 
52    // memorizzazione dle valore attuale del millis
53    millisCorrente = millis();
54 
55    // lettura valore
56    valoreSensore = analogRead(pinSensore);
57 
58    // registra il valore massimo rilevato dal sensore
59    if (valoreSensore > sensoreMax) {
60      sensoreMax = valoreSensore;
61    }
62 
63    // registra il valore minimo rilevato dal sensore
64    if (valoreSensore < sensoreMin) {
65      sensoreMin = valoreSensore;
66    }
67 
68    // timer
69    if (millisCorrente - millisPrecedente >= intervallo) {
70      millisPrecedente = millisCorrente;
71      frame[7][contatore] = 1;
72      matrix.renderBitmap(frame, 8, 12);
73      contatore++;
74    }
75  }
76  // accensione dell'ultimo LED al 5' secondo
77  frame[7][4] = 1;
78  matrix.renderBitmap(frame, 8, 12);
79 
80  // attesa di 0,5 secondi prima di spegnere tutti i LED
81  delay(500);
82 
83  // spegnimento di tutti i LED della matrice
84  uint8_t frame[8][12] = { 0 };
85  matrix.renderBitmap(frame, 8, 12);
86}
87 
88// Accensione linee matrice (dalla riga 7)
89// maggiore e' il valore numeriico di "livello" (riga LED) più bassa sarà l'intensità luminosa
90// minore e' e' il valore numeriico di "livello" (riga LED) più alta sarà l'intensità luminosa
91 
92// Livello minimo di intensità = accensione della sola riga 7
93// Livello massimo di intensità = accensione di tutte le linee della matrice
94 
95void barra(int livello) {
96  // spegnimento della riga "livello"
97  if (livello > precedenteLivello) {
98    for (int y = livello; y >= precedenteLivello; y--) {
99      // spegnimento dei 12 LED della riga "livello"
100      for (int x = 0; x < 12; x++) {
101        frame[y][x] = 0;
102      }
103      matrix.renderBitmap(frame, 8, 12);
104      delay(1);
105    }
106    // accensione della riga "livello"
107  } else {
108    for (int y = 7; y >= precedenteLivello; y--) {
109      for (int x = 0; x < 12; x++) {
110        frame[y][x] = 1;
111      }
112      matrix.renderBitmap(frame, 8, 12);
113      delay(1);
114    }
115  }
116  precedenteLivello = livello;
117}
118 
119void loop() {
120 
121  // per evitare sprechi di memoria viene utilizzata usata una stessa variabile: valoreSensore
122  // per memorizzare ad ogni passo valori diversi
123 
124  // lettura del valore del sensore
125  valoreSensore = analogRead(pinSensore);
126 
127  // Forzare il valore all'interno del valore minimo e del massimo nel caso di errori di lettura.
128  // Nel caso non si aggiungesse il "constrain" nel caso di errore si blocca l'esecuzione
129  valoreSensore = constrain(valoreSensore, sensoreMin, sensoreMax);
130 
131  // Il valore minimo di lettura è associato all'accensione della riga 7
132  // quindi si rimappa tra 7 e 0
133  valoreSensore = map(valoreSensore, sensoreMin, sensoreMax, 7, 0);
134 
135  // barra(valoreSensore) è la funzione che gestisce l'accensione delle linee di LED
136  barra(valoreSensore);
137}

Esempio 02

L’esempio che segue differisce solamente per la visualizzazione sulla serial monitor del numero di riga di LED acceso.

sketch02

vedi sorgente
stampa?
1// Prof. Maffucci Michele
2// 31/07/23
3// Visualizzazione livello luminoso su matrice LED Uno R4 WiFi
4// con calibrazione sensore e visualizzazione timer di calibrazione
5// con l'accensione di 5 LED della matrice
6 
7// Stampa sulla serial monitor del livello della riga LED acceso
8// Esercizio 02
9 
10// inclusione della libreria per la gestione della matrice
11#include "Arduino_LED_Matrix.h"
12 
13// creazione dell’oggetto matrix
14ArduinoLEDMatrix matrix;
15 
16// inizializzazione dell'array per inizializzare lo stato della matrice
17uint8_t frame[8][12] = { 0 };
18 
19// pin a cui collegare il sensore
20int pinSensore = A0;
21 
22// variabile in cui memorizzare il valore letto dal sensore
23int valoreSensore = 0;
24 
25// variabili per calibrazione lovello minimo e massimo luce ambiente
26int sensoreMin = 1023;  // valore minimo sensore
27int sensoreMax = 0;     // valore massimo sensore
28 
29// contatore passi di calibrazione
30int contatore = 0;
31 
32// valore del millis al passo precedente
33unsigned long millisPrecedente = 0;
34// valore del millis attuale
35unsigned long millisCorrente = 0;
36 
37// intervallo in millisecondi per l'accensione di una riga di LED
38const long intervallo = 1000;
39 
40// riga LED precedentemente accesa
41int precedenteLivello = 0;
42 
43void setup() {
44  // inizializzazione della velocità della serial monitor
45  Serial.begin(115200);
46 
47  // avvio della matrice di LED
48  matrix.begin();
49 
50  // calibrazione del sensore nei primi 5 secondi di avvio di Arduino
51  while (millis() < 5000) {
52 
53    // memorizzazione dle valore attuale del millis
54    millisCorrente = millis();
55 
56    // lettura valore
57    valoreSensore = analogRead(pinSensore);
58 
59    // registra il valore massimo rilevato dal sensore
60    if (valoreSensore > sensoreMax) {
61      sensoreMax = valoreSensore;
62    }
63 
64    // registra il valore minimo rilevato dal sensore
65    if (valoreSensore < sensoreMin) {
66      sensoreMin = valoreSensore;
67    }
68 
69    // timer
70    if (millisCorrente - millisPrecedente >= intervallo) {
71      millisPrecedente = millisCorrente;
72      frame[7][contatore] = 1;
73      matrix.renderBitmap(frame, 8, 12);
74      contatore++;
75    }
76  }
77  // accensione dell'ultimo LED al 5' secondo
78  frame[7][4] = 1;
79  matrix.renderBitmap(frame, 8, 12);
80 
81  // attesa di 0,5 secondi prima di spegnere tutti i LED
82  delay(500);
83 
84  // spegnimento di tutti i LED della matrice
85  uint8_t frame[8][12] = { 0 };
86  matrix.renderBitmap(frame, 8, 12);
87}
88 
89// Accensione linee matrice (dalla riga 7)
90// maggiore e' il valore numeriico di "livello" (riga LED) più bassa sarà l'intensità luminosa
91// minore e' e' il valore numeriico di "livello" (riga LED) più alta sarà l'intensità luminosa
92 
93// Livello minimo di intensità = accensione della sola riga 7
94// Livello massimo di intensità = accensione di tutte le linee della matrice
95 
96void barra(int livello) {
97  // spegnimento della riga "livello"
98  if (livello > precedenteLivello) {
99    for (int y = livello; y >= precedenteLivello; y--) {
100      // spegnimento dei 12 LED della riga "livello"
101      for (int x = 0; x < 12; x++) {
102        frame[y][x] = 0;
103      }
104      matrix.renderBitmap(frame, 8, 12);
105      delay(1);
106    }
107    // accensione della riga "livello"
108  } else {
109    for (int y = 7; y >= precedenteLivello; y--) {
110      for (int x = 0; x < 12; x++) {
111        frame[y][x] = 1;
112      }
113      matrix.renderBitmap(frame, 8, 12);
114      delay(1);
115    }
116  }
117  precedenteLivello = livello;
118}
119 
120void loop() {
121 
122  // per evitare sprechi di memoria viene utilizzata usata una stessa variabile: valoreSensore
123  // per memorizzare ad ogni passo valori diversi
124 
125  // lettura del valore del sensore
126  valoreSensore = analogRead(pinSensore);
127 
128  // Forzare il valore all'interno del valore minimo e del massimo nel caso di errori di lettura.
129  // Nel caso non si aggiungesse il "constrain" nel caso di errore si blocca l'esecuzione
130  valoreSensore = constrain(valoreSensore, sensoreMin, sensoreMax);
131 
132  // Il valore minimo di lettura è associato all'accensione della riga 7
133  // quindi si rimappa tra 7 e 0
134  valoreSensore = map(valoreSensore, sensoreMin, sensoreMax, 7, 0);
135 
136  // barra(valoreSensore) è la funzione che gestisce l'accensione delle linee di LED
137  barra(valoreSensore);
138 
139  // stampa sulla Serial Monitor del livello della riga LED
140  Serial.print("Valore letto dal sensore = ");
141  Serial.println(valoreSensore);
142  delay(2);
143}

Esempio 03

Rispetto all’esempio precedente, in questo caso il timer di calibrazione viene visualizzato mediante l’accensione delle prime 5 colonne di LED (partendo da sinistra).

sketch03

vedi sorgente
stampa?
1// Prof. Maffucci Michele
2// 31/07/23
3// Visualizzazione livello luminoso su matrice LED Uno R4 WiFi
4// con calibrazione sensore e visualizzazione timer di calibrazione
5// con incremento dell'accensione di 5 colonne della matrice di LED
6 
7// Stampa sulla serial monitor del livello della riga LED acceso
8// Esercizio 03
9 
10// inclusione della libreria per la gestione della matrice
11#include "Arduino_LED_Matrix.h"
12 
13// creazione dell’oggetto matrix
14ArduinoLEDMatrix matrix;
15 
16// inizializzazione dell'array per inizializzare lo stato della matrice
17uint8_t frame[8][12] = { 0 };
18 
19// pin a cui collegare il sensore
20int pinSensore = A0;
21 
22// variabile in cui memorizzare il valore letto dal sensore
23int valoreSensore = 0;
24 
25// variabili per calibrazione lovello minimo e massimo luce ambiente
26int sensoreMin = 1023;  // valore minimo sensore
27int sensoreMax = 0;     // valore massimo sensore
28 
29// contatore passi di calibrazione
30int contatore = 0;
31 
32// valore del millis al passo precedente
33unsigned long millisPrecedente = 0;
34// valore del millis attuale
35unsigned long millisCorrente = 0;
36 
37// intervallo in millisecondi per l'accensione di una riga di LED
38const long intervallo = 1000;
39 
40// riga LED precedentemente accesa
41int precedenteLivello = 0;
42 
43void setup() {
44  // inizializzazione della velocità della serial monitor
45  Serial.begin(115200);
46 
47  // avvio della matrice di LED
48  matrix.begin();
49 
50  // calibrazione del sensore nei primi 5 secondi di avvio di Arduino
51  while (millis() < 5000) {
52 
53    // memorizzazione dle valore attuale del millis
54    millisCorrente = millis();
55 
56    // lettura valore
57    valoreSensore = analogRead(pinSensore);
58 
59    // registra il valore massimo rilevato dal sensore
60    if (valoreSensore > sensoreMax) {
61      sensoreMax = valoreSensore;
62    }
63 
64    // registra il valore minimo rilevato dal sensore
65    if (valoreSensore < sensoreMin) {
66      sensoreMin = valoreSensore;
67    }
68 
69    // timer
70    if (millisCorrente - millisPrecedente >= intervallo) {
71      millisPrecedente = millisCorrente;
72      colonnaOn(contatore);
73      contatore++;
74    }
75  }
76  // accensione 5 colonna
77  colonnaOn(4);
78 
79  // attesa di 0,5 secondi prima di spegnere tutti i LED
80  delay(500);
81 
82  // spegnimento di tutti i LED della matrice
83  uint8_t frame[8][12] = { 0 };
84  matrix.renderBitmap(frame, 8, 12);
85}
86 
87// accensione colonna SX>DX (dalla colonna 0)
88void colonnaOn(int barre) {
89  for (int y = 0; y < 8; y++) {
90    frame[y][barre] = 1;
91  }
92  matrix.renderBitmap(frame, 8, 12);
93  delay(1);
94}
95 
96// Accensione linee matrice (dalla riga 7)
97// maggiore e' il valore numeriico di "livello" (riga LED) più bassa sarà l'intensità luminosa
98// minore e' e' il valore numeriico di "livello" (riga LED) più alta sarà l'intensità luminosa
99 
100// Livello minimo di intensità = accensione della sola riga 7
101// Livello massimo di intensità = accensione di tutte le linee della matrice
102 
103void barra(int livello) {
104  // spegnimento della riga "livello"
105  if (livello > precedenteLivello) {
106    for (int y = livello; y >= precedenteLivello; y--) {
107      // spegnimento dei 12 LED della riga "livello"
108      for (int x = 0; x < 12; x++) {
109        frame[y][x] = 0;
110      }
111      matrix.renderBitmap(frame, 8, 12);
112      delay(1);
113    }
114    // accensione della riga "livello"
115  } else {
116    for (int y = 7; y >= precedenteLivello; y--) {
117      for (int x = 0; x < 12; x++) {
118        frame[y][x] = 1;
119      }
120      matrix.renderBitmap(frame, 8, 12);
121      delay(1);
122    }
123  }
124  precedenteLivello = livello;
125}
126 
127void loop() {
128 
129  // per evitare sprechi di memoria viene utilizzata usata una stessa variabile: valoreSensore
130  // per memorizzare ad ogni passo valori diversi
131 
132  // lettura del valore del sensore
133  valoreSensore = analogRead(pinSensore);
134 
135  // Forzare il valore all'interno del valore minimo e del massimo nel caso di errori di lettura.
136  // Nel caso non si aggiungesse il "constrain" nel caso di errore si blocca l'esecuzione
137  valoreSensore = constrain(valoreSensore, sensoreMin, sensoreMax);
138 
139  // Il valore minimo di lettura è associato all'accensione della riga 7
140  // quindi si rimappa tra 7 e 0
141  valoreSensore = map(valoreSensore, sensoreMin, sensoreMax, 7, 0);
142 
143  // barra(valoreSensore) è la funzione che gestisce l'accensione delle linee di LED
144  barra(valoreSensore);
145 
146  // stampa sulla Serial Monitor del livello della riga LED
147  Serial.print("Valore letto dal sensore = ");
148  Serial.println(valoreSensore);
149  delay(2);
150}

Esempio 04

In questo caso la visualizzazione del trascorrere del tempo di calibrazione avviene mediante di 4 colonne costituite ciascuna da 3 colonne di LED.

sketch04

vedi sorgente
stampa?
1// Prof. Maffucci Michele
2// 31/07/23
3// Visualizzazione livello luminoso su matrice LED Uno R4 WiFi
4// con calibrazione sensore e visualizzazione timer di calibrazione
5// con incremento dell'accensione di 4 colonne LED della matrice costrituite ciascuna da 3 colonne da 1 LED
6 
7// Stampa sulla serial monitor del livello della riga LED acceso
8// Esercizio 04
9 
10// inclusione della libreria per la gestione della matrice
11#include "Arduino_LED_Matrix.h"
12 
13// creazione dell’oggetto matrix
14ArduinoLEDMatrix matrix;
15 
16// inizializzazione dell'array per inizializzare lo stato della matrice
17uint8_t frame[8][12] = { 0 };
18 
19// pin a cui collegare il sensore
20int pinSensore = A0;
21 
22// variabile in cui memorizzare il valore letto dal sensore
23int valoreSensore = 0;
24 
25// variabili per calibrazione lovello minimo e massimo luce ambiente
26int sensoreMin = 1023;  // valore minimo sensore
27int sensoreMax = 0;     // valore massimo sensore
28 
29// contatore passi di calibrazione
30int contatore = 1;
31 
32// valore del millis al passo precedente
33unsigned long millisPrecedente = 0;
34// valore del millis attuale
35unsigned long millisCorrente = 0;
36 
37// intervallo in millisecondi per l'accensione di una riga di LED
38const long intervallo = 1000;
39 
40// riga LED precedentemente accesa
41int precedenteLivello = 0;
42 
43void setup() {
44  // inizializzazione della velocità della serial monitor
45  Serial.begin(115200);
46 
47  // avvio della matrice di LED
48  matrix.begin();
49 
50  // calibrazione del sensore nei primi 5 secondi di avvio di Arduino
51  while (millis() < 5000) {
52 
53    // memorizzazione dle valore attuale del millis
54    millisCorrente = millis();
55 
56    // lettura valore
57    valoreSensore = analogRead(pinSensore);
58 
59    // registra il valore massimo rilevato dal sensore
60    if (valoreSensore > sensoreMax) {
61      sensoreMax = valoreSensore;
62    }
63 
64    // registra il valore minimo rilevato dal sensore
65    if (valoreSensore < sensoreMin) {
66      sensoreMin = valoreSensore;
67    }
68 
69    // timer
70    if (millisCorrente - millisPrecedente >= intervallo) {
71      millisPrecedente = millisCorrente;
72      colonnaOn(contatore);
73      contatore++;
74    }
75  }
76 
77  // attesa di 0,5 secondi prima di spegnere tutti i LED
78  delay(500);
79 
80  // spegnimento di tutti i LED della matrice
81  uint8_t frame[8][12] = { 0 };
82  matrix.renderBitmap(frame, 8, 12);
83}
84 
85// accensione colonna SX>DX (dalla colonna 0)
86void colonnaOn(int barre) {
87  for (int colonna = 1; colonna <= barre*3; colonna++) {
88    for (int y = 0; y < 8; y++) {
89      frame[y][colonna-1] = 1;
90    }
91    matrix.renderBitmap(frame, 8, 12);
92    delay(1);
93  }
94}
95 
96// Accensione linee matrice (dalla riga 7)
97// maggiore e' il valore numeriico di "livello" (riga LED) più bassa sarà l'intensità luminosa
98// minore e' e' il valore numeriico di "livello" (riga LED) più alta sarà l'intensità luminosa
99 
100// Livello minimo di intensità = accensione della sola riga 7
101// Livello massimo di intensità = accensione di tutte le linee della matrice
102 
103void barra(int livello) {
104  // spegnimento della riga "livello"
105  if (livello > precedenteLivello) {
106    for (int y = livello; y >= precedenteLivello; y--) {
107      // spegnimento dei 12 LED della riga "livello"
108      for (int x = 0; x < 12; x++) {
109        frame[y][x] = 0;
110      }
111      matrix.renderBitmap(frame, 8, 12);
112      delay(1);
113    }
114    // accensione della riga "livello"
115  } else {
116    for (int y = 7; y >= precedenteLivello; y--) {
117      for (int x = 0; x < 12; x++) {
118        frame[y][x] = 1;
119      }
120      matrix.renderBitmap(frame, 8, 12);
121      delay(1);
122    }
123  }
124  precedenteLivello = livello;
125}
126 
127void loop() {
128 
129  // per evitare sprechi di memoria viene utilizzata usata una stessa variabile: valoreSensore
130  // per memorizzare ad ogni passo valori diversi
131 
132  // lettura del valore del sensore
133  valoreSensore = analogRead(pinSensore);
134 
135  // Forzare il valore all'interno del valore minimo e del massimo nel caso di errori di lettura.
136  // Nel caso non si aggiungesse il "constrain" nel caso di errore si blocca l'esecuzione
137  valoreSensore = constrain(valoreSensore, sensoreMin, sensoreMax);
138 
139  // Il valore minimo di lettura è associato all'accensione della riga 7
140  // quindi si rimappa tra 7 e 0
141  valoreSensore = map(valoreSensore, sensoreMin, sensoreMax, 7, 0);
142 
143  // barra(valoreSensore) è la funzione che gestisce l'accensione delle linee di LED
144  barra(valoreSensore);
145 
146  // stampa sulla Serial Monitor del livello della riga LED
147  Serial.print("Valore letto dal sensore = ");
148  Serial.println(valoreSensore);
149  delay(2);
150}

Esempio 05

In questo esempio sono stati realizzati, mediante il LED Matrix Editor, 5 numeri rappresentati ciascuno dal proprio array inclusi all’interno del codice.

sketch05

vedi sorgente
stampa?
1// Prof. Maffucci Michele
2// 31/07/23
3// Visualizzazione livello luminoso su matrice LED Uno R4 WiFi
4// con calibrazione sensore e visualizzazione timer di calibrazione
5// Timer realizzato con numeri disegnati con il LED Matrix Editor
6// I numeri sono inclusi nel codice
7 
8// Stampa sulla serial monitor del livello della riga LED acceso
9// Esercizio 05
10 
11// inclusione della libreria per la gestione della matrice
12#include "Arduino_LED_Matrix.h"
13 
14// creazione dell’oggetto matrix
15ArduinoLEDMatrix matrix;
16 
17// inizializzazione dell'array per inizializzare lo stato della matrice
18uint8_t frame[8][12] = { 0 };
19 
20// pin a cui collegare il sensore
21int pinSensore = A0;
22 
23// variabile in cui memorizzare il valore letto dal sensore
24int valoreSensore = 0;
25 
26// variabili per calibrazione lovello minimo e massimo luce ambiente
27int sensoreMin = 1023;  // valore minimo sensore
28int sensoreMax = 0;     // valore massimo sensore
29 
30// contatore passi di calibrazione
31int contatore = 0;
32 
33// valore del millis al passo precedente
34unsigned long millisPrecedente = 0;
35// valore del millis attuale
36unsigned long millisCorrente = 0;
37 
38// intervallo in millisecondi per l'accensione di una riga di LED
39const long intervallo = 1000;
40 
41// riga LED precedentemente accesa
42int precedenteLivello = 0;
43 
44void setup() {
45  // inizializzazione della velocità della serial monitor
46  Serial.begin(115200);
47 
48  // avvio della matrice di LED
49  matrix.begin();
50 
51  // calibrazione del sensore nei primi 5 secondi di avvio di Arduino
52  while (millis() < 5000) {
53 
54    // memorizzazione dle valore attuale del millis
55    millisCorrente = millis();
56 
57    // lettura valore
58    valoreSensore = analogRead(pinSensore);
59 
60    // registra il valore massimo rilevato dal sensore
61    if (valoreSensore > sensoreMax) {
62      sensoreMax = valoreSensore;
63    }
64 
65    // registra il valore minimo rilevato dal sensore
66    if (valoreSensore < sensoreMin) {
67      sensoreMin = valoreSensore;
68    }
69 
70    // timer
71    if (millisCorrente - millisPrecedente >= intervallo) {
72      millisPrecedente = millisCorrente;
73      numero(contatore);
74      contatore++;
75    }
76  }
77   
78  // stampa del n. 5
79  numero(4);
80 
81  // attesa di 0,5 secondi prima di spegnere tutti i LED
82  delay(500);
83 
84  // spegnimento di tutti i LED della matrice
85  uint8_t frame[8][12] = { 0 };
86  matrix.renderBitmap(frame, 8, 12);
87}
88 
89// numeri da 1 a 5
90const uint32_t uno[] = {
91  // 1
92  0x400c014,
93  0x400400,
94  0x400400e0,
95  66
96};
97 
98const uint32_t due[] = {
99  // 2
100  0xf001002,
101  0x400800,
102  0x800800f0,
103  66
104};
105const uint32_t tre[] = {  // 3
106  0xf001002,
107  0x400200,
108  0x100100f0,
109  66
110};
111const uint32_t quattro[] = {
112  // 4
113  0x1002004,
114  0x801001,
115  0x200f0020,
116  66
117};
118const uint32_t cinque[] = {
119  // 5
120  0xf808008,
121  0xf00080,
122  0x80080f0,
123  66
124};
125 
126// selezione della cifra per il timer
127void numero(int cifra) {
128  switch (cifra) {
129    case 0:
130      matrix.loadFrame(uno);
131      break;
132    case 1:
133      matrix.loadFrame(due);
134      break;
135    case 2:
136      matrix.loadFrame(tre);
137      break;
138    case 3:
139      matrix.loadFrame(quattro);
140      break;
141    case 4:
142      matrix.loadFrame(cinque);
143      break;
144    default:
145      break;
146  }
147}
148 
149// Accensione linee matrice (dalla riga 7)
150// maggiore e' il valore numeriico di "livello" (riga LED) più bassa sarà l'intensità luminosa
151// minore e' e' il valore numeriico di "livello" (riga LED) più alta sarà l'intensità luminosa
152 
153// Livello minimo di intensità = accensione della sola riga 7
154// Livello massimo di intensità = accensione di tutte le linee della matrice
155 
156void barra(int livello) {
157  // spegnimento della riga "livello"
158  if (livello > precedenteLivello) {
159    for (int y = livello; y >= precedenteLivello; y--) {
160      // spegnimento dei 12 LED della riga "livello"
161      for (int x = 0; x < 12; x++) {
162        frame[y][x] = 0;
163      }
164      matrix.renderBitmap(frame, 8, 12);
165      delay(1);
166    }
167    // accensione della riga "livello"
168  } else {
169    for (int y = 7; y >= precedenteLivello; y--) {
170      for (int x = 0; x < 12; x++) {
171        frame[y][x] = 1;
172      }
173      matrix.renderBitmap(frame, 8, 12);
174      delay(1);
175    }
176  }
177  precedenteLivello = livello;
178}
179 
180void loop() {
181 
182  // per evitare sprechi di memoria viene utilizzata usata una stessa variabile: valoreSensore
183  // per memorizzare ad ogni passo valori diversi
184 
185  // lettura del valore del sensore
186  valoreSensore = analogRead(pinSensore);
187 
188  // Forzare il valore all'interno del valore minimo e del massimo nel caso di errori di lettura.
189  // Nel caso non si aggiungesse il "constrain" nel caso di errore si blocca l'esecuzione
190  valoreSensore = constrain(valoreSensore, sensoreMin, sensoreMax);
191 
192  // Il valore minimo di lettura è associato all'accensione della riga 7
193  // quindi si rimappa tra 7 e 0
194  valoreSensore = map(valoreSensore, sensoreMin, sensoreMax, 7, 0);
195 
196  // barra(valoreSensore) è la funzione che gestisce l'accensione delle linee di LED
197  barra(valoreSensore);
198 
199  // stampa sulla Serial Monitor del livello della riga LED
200  Serial.print("Valore letto dal sensore = ");
201  Serial.println(valoreSensore);
202  delay(2);
203}

Esempio 06

Rispetto all’esempio precedente è stato creato un file esterno, numeri.h, che rappresenta la lista degli array che rappresentano i numeri. Questo file è stato generato con il LED Matrix Editor.

numeri.h

vedi sorgente
stampa?
1const uint32_t numeri[][4] = {
2    {
3    // 1
4        0x400c014,
5        0x400400,
6        0x400400e0,
7        66
8    },
9    {
10    // 2
11        0xf001002,
12        0x400800,
13        0x800800f0,
14        66
15    },
16    {
17    // 3
18        0xf001002,
19        0x400200,
20        0x100100f0,
21        66
22    },
23    {
24    // 4
25        0x1002004,
26        0x801001,
27        0x200f0020,
28        66
29    },
30    {
31    // 5
32        0xf808008,
33        0xf00080,
34        0x80080f0,
35        66
36    }
37};

sketch 06

vedi sorgente
stampa?
1// Prof. Maffucci Michele
2// 31/07/23
3// Visualizzazione livello luminoso su matrice LED Uno R4 WiFi
4// con calibrazione sensore e visualizzazione timer di calibrazione
5// Timer realizzato con numeri disegnati con il LED Matrix Editor
6// I numeri vengono inclusi mediante il file numeri.h
7 
8// Stampa sulla serial monitor del livello della riga LED acceso
9// Esercizio 06
10 
11// inclusione della libreria per la gestione della matrice
12#include "Arduino_LED_Matrix.h"
13#include "numeri.h"
14 
15// creazione dell’oggetto matrix
16ArduinoLEDMatrix matrix;
17 
18// inizializzazione dell'array per inizializzare lo stato della matrice
19uint8_t frame[8][12] = { 0 };
20 
21// pin a cui collegare il sensore
22int pinSensore = A0;
23 
24// variabile in cui memorizzare il valore letto dal sensore
25int valoreSensore = 0;
26 
27// variabili per calibrazione lovello minimo e massimo luce ambiente
28int sensoreMin = 1023;  // valore minimo sensore
29int sensoreMax = 0;     // valore massimo sensore
30 
31// contatore passi di calibrazione
32int contatore = 0;
33 
34// valore del millis al passo precedente
35unsigned long millisPrecedente = 0;
36// valore del millis attuale
37unsigned long millisCorrente = 0;
38 
39// intervallo in millisecondi per l'accensione di una riga di LED
40const long intervallo = 1000;
41 
42// riga LED precedentemente accesa
43int precedenteLivello = 0;
44 
45void setup() {
46  // inizializzazione della velocità della serial monitor
47  Serial.begin(115200);
48 
49  // avvio della matrice di LED
50  matrix.begin();
51 
52  // calibrazione del sensore nei primi 5 secondi di avvio di Arduino
53  while (millis() < 5000) {
54 
55    // memorizzazione dle valore attuale del millis
56    millisCorrente = millis();
57 
58    // lettura valore
59    valoreSensore = analogRead(pinSensore);
60 
61    // registra il valore massimo rilevato dal sensore
62    if (valoreSensore > sensoreMax) {
63      sensoreMax = valoreSensore;
64    }
65 
66    // registra il valore minimo rilevato dal sensore
67    if (valoreSensore < sensoreMin) {
68      sensoreMin = valoreSensore;
69    }
70 
71    // timer
72    if (millisCorrente - millisPrecedente >= intervallo) {
73      millisPrecedente = millisCorrente;
74      numero(contatore);
75      contatore++;
76    }
77  }
78   
79  // stampa del n. 5
80  matrix.loadFrame(numeri[4]);
81 
82  // attesa di 0,5 secondi prima di spegnere tutti i LED
83  delay(500);
84 
85  // spegnimento di tutti i LED della matrice
86  uint8_t frame[8][12] = { 0 };
87  matrix.renderBitmap(frame, 8, 12);
88}
89 
90// selezione della cifra per il timer
91void numero(int cifra) {
92  switch (cifra) {
93    case 0:
94      matrix.loadFrame(numeri[0]);
95      break;
96    case 1:
97      matrix.loadFrame(numeri[1]);
98      break;
99    case 2:
100      matrix.loadFrame(numeri[2]);
101      break;
102    case 3:
103      matrix.loadFrame(numeri[3]);
104      break;
105    case 4:
106     matrix.loadFrame(numeri[4]);
107      break;
108    default:
109      break;
110  }
111}
112 
113// Accensione linee matrice (dalla riga 7)
114// maggiore e' il valore numeriico di "livello" (riga LED) più bassa sarà l'intensità luminosa
115// minore e' e' il valore numeriico di "livello" (riga LED) più alta sarà l'intensità luminosa
116 
117// Livello minimo di intensità = accensione della sola riga 7
118// Livello massimo di intensità = accensione di tutte le linee della matrice
119 
120void barra(int livello) {
121  // spegnimento della riga "livello"
122  if (livello > precedenteLivello) {
123    for (int y = livello; y >= precedenteLivello; y--) {
124      // spegnimento dei 12 LED della riga "livello"
125      for (int x = 0; x < 12; x++) {
126        frame[y][x] = 0;
127      }
128      matrix.renderBitmap(frame, 8, 12);
129      delay(1);
130    }
131    // accensione della riga "livello"
132  } else {
133    for (int y = 7; y >= precedenteLivello; y--) {
134      for (int x = 0; x < 12; x++) {
135        frame[y][x] = 1;
136      }
137      matrix.renderBitmap(frame, 8, 12);
138      delay(1);
139    }
140  }
141  precedenteLivello = livello;
142}
143 
144void loop() {
145 
146  // per evitare sprechi di memoria viene utilizzata usata una stessa variabile: valoreSensore
147  // per memorizzare ad ogni passo valori diversi
148 
149  // lettura del valore del sensore
150  valoreSensore = analogRead(pinSensore);
151 
152  // Forzare il valore all'interno del valore minimo e del massimo nel caso di errori di lettura.
153  // Nel caso non si aggiungesse il "constrain" nel caso di errore si blocca l'esecuzione
154  valoreSensore = constrain(valoreSensore, sensoreMin, sensoreMax);
155 
156  // Il valore minimo di lettura è associato all'accensione della riga 7
157  // quindi si rimappa tra 7 e 0
158  valoreSensore = map(valoreSensore, sensoreMin, sensoreMax, 7, 0);
159 
160  // barra(valoreSensore) è la funzione che gestisce l'accensione delle linee di LED
161  barra(valoreSensore);
162 
163  // stampa sulla Serial Monitor del livello della riga LED
164  Serial.print("Valore letto dal sensore = ");
165  Serial.println(valoreSensore);
166  delay(2);
167}

Buon Making a tutti 🙂

Articoli correlati:

  1. Usare la matrice LED di Arduino UNO R4 WiFi
  2. Arduino UNO R4 WiFi – usare la matrice LED per esercitarsi con i cicli for
  3. Arduino – realizzare un sensore di seduta a pressione con un tubo di gomma
  4. Arduino UNO R4 WiFi e Minima
  5. Iniziare con Arduino UNO R4 WiFi

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito utilizza Akismet per ridurre lo spam. Scopri come vengono elaborati i dati derivati dai commenti.