Arduino UNO R4 WiFi – usare la matrice LED per esercitarsi con i cicli for

Come segnalato nei precedenti, post sto realizzando le prime lezioni sull’uso di Arduino UNO R4 WiFi per i miei studenti, ma ho pensato di mostrare su queste pagine gli sketch di base che poi utilizzerò per implementare esercitazioni più estese. Gli esempi che seguono hanno l’obiettivo di mostrare l’utilizzo ed il risultato di cicli for annidati che hanno come obiettivo la realizzazioni di semplici animazioni sulla matrice di LED di Arduino, strutture di codice che potranno essere sfruttate ad esempio per visualizzare lo stato di un sensore, il valore di una variabile e molto altro.

Utilizzerò per questi esercizi il “Modo 1” indicato nella lezione precedente in cui veniva creato un array bidimensionale che inizializza e rappresenta lo stato della matrice di LED, se ricordate la struttura da includere all’inizio del codice era la seguente:

1byte frame[8][12] = {
2  { 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0 },
3  { 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
4  { 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 },
5  { 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
6  { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 },
7  { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
8  { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
9  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
10};

Per rendere leggibile e più snello il codice scriverò in altro modo la matrice sopra:

1uint8_t frame[8][12] = {0};

Esercizio 1

In questo esercizio vedremo come effettuare il blink della 7 linea di LED sulla matrice, per intenderci la base inferiore della matrice. Le inizializzazioni per l’utilizzo della matrice sono le medesime per tutti gli sketch che seguono.

Vengono definite due funzioni: barraOn() e barraOff() che si occupano di accendere e spegnere la linea 7 della matrice. Il ciclo for incluso nelle due funzioni itererà per 12 volte ponendo ad 1 il valore della linea 7, come potete notare viene vincolata a 7 la y della matrice: frame[7][x]. Nel loop verranno richiamate le due funzioni barraOn() e barraOff() con un delay di 1 secondo. Ricordate che è essenziale ad ogni modifica dello stato della matrice invocare la funzione: matrix.renderBitmap(frame, 8, 12); altrimenti non vedrete nulla sulla matrice

1// Prof. Maffucci Michele
2// 27/07/23
3// Blink striscia led (linea 7) su matrice
4// Esercizio 01
5 
6#include "Arduino_LED_Matrix.h"
7 
8ArduinoLEDMatrix matrix;
9 
10void setup() {
11  Serial.begin(115200);
12  matrix.begin();
13}
14 
15uint8_t frame[8][12] = {0};
16 
17// accensione linea 7 della matrice
18void barraOn() {
19  //barra
20  for (int x=0; x<12; x++){
21    frame[7][x] = 1;
22  }
23}
24 
25// spegnimento linea 7 della matrice
26void barraOff() {
27  //barra
28  for (int x=0; x<12; x++){
29    frame[7][x] = 0;
30  }
31}
32 
33void loop() {
34  barraOn();
35  matrix.renderBitmap(frame, 8, 12);
36 
37  delay(1000);
38  barraOff();
39 
40  matrix.renderBitmap(frame, 8, 12);
41  delay(1000);
42}

Esercizio 2

In questo secondo esercizio l’accensione dei LED dell’ultima line avviene in modo sequenziale da sinistra verso destra e successivamente questi saranno spenti sempre da sinistra verso destra dando l’impressione che il “serpente” esce dallo schermo da destra e rientri da sinistra.

Nell’esempio che segue sono state definite due funzioni: barraOn() e barraOff() in cui vincolata la linea 7 viene modificata in modo ciclico la coordinata x del LED. Per dare la sensazione di movimento l’accensione e lo spegnimento di ogni songolo LEd è stato posto a 100 millisecondi. Nel loop vengono richiamate ciclicamente le due funzioni.

1// Prof. Maffucci Michele
2// 27/07/23
3// Accensione/spegnimento in una direzione striscia led (linea 7) su matrice
4// Esercizio 02
5 
6#include "Arduino_LED_Matrix.h"
7 
8ArduinoLEDMatrix matrix;
9 
10void setup() {
11  Serial.begin(115200);
12  matrix.begin();
13}
14 
15uint8_t frame[8][12] = {0};
16 
17// accensione linea 7 della matrice
18void barraOn() {
19  for (int x=0; x<12; x++){
20    frame[7][x] = 1;
21    matrix.renderBitmap(frame, 8, 12);
22    delay(100);
23  }
24}
25 
26// spegnimento linea 7 della matrice
27void barraOff() {
28  //barra
29  for (int x=0; x<12; x++){
30    frame[7][x] = 0;
31    matrix.renderBitmap(frame, 8, 12);
32    delay(100);
33  }
34}
35 
36void loop() {
37  barraOn();
38  barraOff();
39}

Esercizio 3

In questo esempio la barra posta sulla linea 7 simula il comportamento di incremento o decremento di una variabile per cui la barra aumenta e diminuisce da un valore minimo ad un valore massimo in modo sequenziale, ma immaginate di modificare questo sketch collegandolo ad esempio alla variazione di un valore analogico. La differenza rispetto allo sketch precedente consiste solamente nel fatto che lo spegnimento dei LED avviene partendo dai LED maggiore.

1// Prof. Maffucci Michele
2// 27/07/23
3// Accensione/spegnimento in due direzioni striscia led (linea 7) su matrice
4// Esercizio 03
5 
6#include "Arduino_LED_Matrix.h"
7 
8ArduinoLEDMatrix matrix;
9 
10void setup() {
11  Serial.begin(115200);
12  matrix.begin();
13}
14 
15uint8_t frame[8][12] = {0};
16 
17// accensione linea 7 della matrice
18void barraOn() {
19  for (int x=0; x<12; x++){
20    frame[7][x] = 1;
21    matrix.renderBitmap(frame, 8, 12);
22    delay(100);
23  }
24}
25 
26// spegnimento linea 7 della matrice
27void barraOff() {
28  for (int x=11; x>=0; x--){
29    frame[7][x] = 0;
30    matrix.renderBitmap(frame, 8, 12);
31    delay(100);
32  }
33}
34 
35void loop() {
36  barraOn();
37  barraOff();
38}

Esercizio 4

L’idea di questo quarto sketch nasce dalla necessità di realizzare un indicatore per misurare ad esempio il livello di luminosità, sonoro o l’umidità presente nel terreno. Come potete notare le linee della matrice vengono attivate una alla volta dal basso verso l’alto e poi spente dall’alto verso il basso. Le due funzioni barraOn() e barraOff() includono due cicli for annidati, quello più esterno consente di fissare la linea della matrice, mentre quello più interno permette di accendere o spegnere i LED sulla stessa linea. Nel loop le due funzioni vengono richiamata ciclicamente.

1// Prof. Maffucci Michele
2// 27/07/23
3// Accensione/spegnimento in due direzioni (linea) BASSO>ALTO ALTO>BASSO matrice led
4// Esercizio 04
5 
6#include "Arduino_LED_Matrix.h"
7 
8ArduinoLEDMatrix matrix;
9 
10void setup() {
11  Serial.begin(115200);
12  matrix.begin();
13}
14 
15uint8_t frame[8][12] = {0};
16 
17// accensione linea BASSO>ALTO (dalla linea 7)
18void barraOn() {
19  for (int y = 8; y >= 0; y--) {
20    for (int x = 0; x < 12; x++) {
21      frame[y][x] = 1;
22    }
23    matrix.renderBitmap(frame, 8, 12);
24    delay(100);
25  }
26}
27 
28// spegnimento linea ALTO>BASSO (dalla linea 0)
29void barraOff() {
30  for (int y = 0; y <=8 ; y++) {
31    for (int x = 11; x >= 0; x--) {
32      frame[y][x] = 0;
33    }
34    matrix.renderBitmap(frame, 8, 12);
35    delay(100);
36  }
37}
38 
39void loop() {
40  barraOn();
41  barraOff();
42}

Esercizio 5

Lo sketch che segue ha il medesimo obiettivo del precedente, ma in questo caso l’accensione e lo spegnimento della matrice avviene per colonne, accensione da sinistra verso destra e spegnimento da destra verso sinistra. Le due funzioni barraOn() e barraOff(), costittuite entrambe da due cicli for annidati funzionano in modalità opposta allo sketch precedente, in questo caso il for più esterno vincola la colonna e quello più interno accende/spegne i LED della colonna.

1// Prof. Maffucci Michele
2// 27/07/23
3// Accensione/spegnimento in due direzioni SX>DX DX>SX (partenza colonna 0) matrice led
4// Esercizio 05
5 
6#include "Arduino_LED_Matrix.h"
7 
8ArduinoLEDMatrix matrix;
9 
10void setup() {
11  Serial.begin(115200);
12  matrix.begin();
13}
14 
15uint8_t frame[8][12] = {0};
16 
17// accensione colonna SX>DX (dalla colonna 0)
18void barraOn() {
19  for (int x = 0; x < 12; x++) {
20    for (int y = 0 ; y < 8; y++) {
21      frame[y][x] = 1;
22    }
23    matrix.renderBitmap(frame, 8, 12);
24    delay(100);
25  }
26}
27 
28// spegnimento colonna DX>SX (dalla colonna 11)
29void barraOff() {
30  for (int x = 11; x >= 0 ; x--) {
31    for (int y = 7 ; y >= 0; y--) {
32      frame[y][x] = 0;
33    }
34    matrix.renderBitmap(frame, 8, 12);
35    delay(100);
36  }
37}
38 
39void loop() {
40  barraOn();
41  barraOff();
42}

Esercizio 6

In questo esercizio si vuole mostrare come spostare, “far cadere”, un puntino dall’alto verso il basso eseguendo questa operazione per ogni colonna da sinistra verso destra. La funzione puntino() è costituita da due cicli for, il più esterno vincola la colonna su cui movimentare il LED, mentre quello più interno accende e spegne in modo sequenziale i LED della colonna selezionata dal for più esterno.

1// Prof. Maffucci Michele
2// 27/07/23
3// Accensione e spegnimento sequenziale dall'alto al basso - matrice led
4// Esercizio 06
5 
6#include "Arduino_LED_Matrix.h"
7 
8ArduinoLEDMatrix matrix;
9 
10void setup() {
11  Serial.begin(115200);
12  matrix.begin();
13}
14 
15uint8_t frame[8][12] = { 0 };
16 
17// puntino cadente
18void puntino() {
19  for (int x = 0; x < 12; x++) {
20    for (int y = 0; y < 8; y++) {
21      frame[y][x] = 1;
22      matrix.renderBitmap(frame, 8, 12);
23      delay(20);
24      frame[y][x] = 0;
25      matrix.renderBitmap(frame, 8, 12);
26      delay(20);
27    }
28  }
29}
30 
31void loop() {
32  puntino();
33}

Esercizio 7

Comportamento identico al precedente ma in questo caso lo spostamento del puntino avviene per righe dall’alto al basso ed accensione e spegnimento da destra verso sinistra. In questo vaso il for più esterno vincola la riga mentre quello più interno si occupa di accendere e spegnere i LED della riga selezionata.

1// Prof. Maffucci Michele
2// 27/07/23
3// Accensione e spegnimento sequenziale SX > DX dall'alto al basso - matrice led
4// Esercizio 07
5 
6#include "Arduino_LED_Matrix.h"
7 
8ArduinoLEDMatrix matrix;
9 
10void setup() {
11  Serial.begin(115200);
12  matrix.begin();
13}
14 
15uint8_t frame[8][12] = { 0 };
16 
17// puntino cadente
18void puntino() {
19  for (int y = 0; y < 8; y++) {
20    for (int x = 0; x < 12; x++) {
21      frame[y][x] = 1;
22      matrix.renderBitmap(frame, 8, 12);
23      delay(20);
24      frame[y][x] = 0;
25      matrix.renderBitmap(frame, 8, 12);
26      delay(20);
27    }
28  }
29}
30 
31void loop() {
32  puntino();
33}

Esercizio 8

In questo esercizio viene vincolato lo spostamento del puntino luminoso sulla riga quattro simulando uno spostamento sinistra/destra e destra/sinistra dando l’impressione di un rimbalzo sulle pareti. Per rendere più chiara la lettura da parte degli studenti ho realizzato due funzioni separate che si occupano dei due movimenti.

1// Prof. Maffucci Michele
2// 27/07/23
3// Puntino che rimbalza SX > DX - DX > SX - matrice led
4// Esercizio 08
5 
6#include "Arduino_LED_Matrix.h"
7 
8ArduinoLEDMatrix matrix;
9 
10void setup() {
11  Serial.begin(115200);
12  matrix.begin();
13}
14 
15uint8_t frame[8][12] = { 0 };
16 
17// puntino rimbalza su riga 4
18void puntinoSxDx() {
19  for (int x = 0; x < 12; x++) {
20    frame[4][x] = 1;
21    matrix.renderBitmap(frame, 8, 12);
22    delay(50);
23    frame[4][x] = 0;
24    matrix.renderBitmap(frame, 8, 12);
25    delay(50);
26  }
27}
28 
29void puntinoDxSx() {
30  for (int x = 11; x >= 0; x--) {
31    frame[4][x] = 1;
32    matrix.renderBitmap(frame, 8, 12);
33    delay(50);
34    frame[4][x] = 0;
35    matrix.renderBitmap(frame, 8, 12);
36    delay(50);
37  }
38}
39 
40void loop() {
41  puntinoSxDx();
42  puntinoDxSx();
43}

Buon Making a tutti 🙂

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.