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:
byte frame[8][12] = {
{ 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0 },
{ 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
{ 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 },
{ 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
Per rendere leggibile e più snello il codice scriverò in altro modo la matrice sopra:
uint8_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
// Prof. Maffucci Michele
// 27/07/23
// Blink striscia led (linea 7) su matrice
// Esercizio 01
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix matrix;
void setup() {
Serial.begin(115200);
matrix.begin();
}
uint8_t frame[8][12] = {0};
// accensione linea 7 della matrice
void barraOn() {
//barra
for (int x=0; x<12; x++){
frame[7][x] = 1;
}
}
// spegnimento linea 7 della matrice
void barraOff() {
//barra
for (int x=0; x<12; x++){
frame[7][x] = 0;
}
}
void loop() {
barraOn();
matrix.renderBitmap(frame, 8, 12);
delay(1000);
barraOff();
matrix.renderBitmap(frame, 8, 12);
delay(1000);
}
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.
// Prof. Maffucci Michele
// 27/07/23
// Accensione/spegnimento in una direzione striscia led (linea 7) su matrice
// Esercizio 02
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix matrix;
void setup() {
Serial.begin(115200);
matrix.begin();
}
uint8_t frame[8][12] = {0};
// accensione linea 7 della matrice
void barraOn() {
for (int x=0; x<12; x++){
frame[7][x] = 1;
matrix.renderBitmap(frame, 8, 12);
delay(100);
}
}
// spegnimento linea 7 della matrice
void barraOff() {
//barra
for (int x=0; x<12; x++){
frame[7][x] = 0;
matrix.renderBitmap(frame, 8, 12);
delay(100);
}
}
void loop() {
barraOn();
barraOff();
}
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.
// Prof. Maffucci Michele
// 27/07/23
// Accensione/spegnimento in due direzioni striscia led (linea 7) su matrice
// Esercizio 03
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix matrix;
void setup() {
Serial.begin(115200);
matrix.begin();
}
uint8_t frame[8][12] = {0};
// accensione linea 7 della matrice
void barraOn() {
for (int x=0; x<12; x++){
frame[7][x] = 1;
matrix.renderBitmap(frame, 8, 12);
delay(100);
}
}
// spegnimento linea 7 della matrice
void barraOff() {
for (int x=11; x>=0; x--){
frame[7][x] = 0;
matrix.renderBitmap(frame, 8, 12);
delay(100);
}
}
void loop() {
barraOn();
barraOff();
}
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.
// Prof. Maffucci Michele
// 27/07/23
// Accensione/spegnimento in due direzioni (linea) BASSO>ALTO ALTO>BASSO matrice led
// Esercizio 04
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix matrix;
void setup() {
Serial.begin(115200);
matrix.begin();
}
uint8_t frame[8][12] = {0};
// accensione linea BASSO>ALTO (dalla linea 7)
void barraOn() {
for (int y = 8; y >= 0; y--) {
for (int x = 0; x < 12; x++) {
frame[y][x] = 1;
}
matrix.renderBitmap(frame, 8, 12);
delay(100);
}
}
// spegnimento linea ALTO>BASSO (dalla linea 0)
void barraOff() {
for (int y = 0; y <=8 ; y++) {
for (int x = 11; x >= 0; x--) {
frame[y][x] = 0;
}
matrix.renderBitmap(frame, 8, 12);
delay(100);
}
}
void loop() {
barraOn();
barraOff();
}
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.
// Prof. Maffucci Michele
// 27/07/23
// Accensione/spegnimento in due direzioni SX>DX DX>SX (partenza colonna 0) matrice led
// Esercizio 05
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix matrix;
void setup() {
Serial.begin(115200);
matrix.begin();
}
uint8_t frame[8][12] = {0};
// accensione colonna SX>DX (dalla colonna 0)
void barraOn() {
for (int x = 0; x < 12; x++) {
for (int y = 0 ; y < 8; y++) {
frame[y][x] = 1;
}
matrix.renderBitmap(frame, 8, 12);
delay(100);
}
}
// spegnimento colonna DX>SX (dalla colonna 11)
void barraOff() {
for (int x = 11; x >= 0 ; x--) {
for (int y = 7 ; y >= 0; y--) {
frame[y][x] = 0;
}
matrix.renderBitmap(frame, 8, 12);
delay(100);
}
}
void loop() {
barraOn();
barraOff();
}
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.
// Prof. Maffucci Michele
// 27/07/23
// Accensione e spegnimento sequenziale dall'alto al basso - matrice led
// Esercizio 06
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix matrix;
void setup() {
Serial.begin(115200);
matrix.begin();
}
uint8_t frame[8][12] = { 0 };
// puntino cadente
void puntino() {
for (int x = 0; x < 12; x++) {
for (int y = 0; y < 8; y++) {
frame[y][x] = 1;
matrix.renderBitmap(frame, 8, 12);
delay(20);
frame[y][x] = 0;
matrix.renderBitmap(frame, 8, 12);
delay(20);
}
}
}
void loop() {
puntino();
}
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.
// Prof. Maffucci Michele
// 27/07/23
// Accensione e spegnimento sequenziale SX > DX dall'alto al basso - matrice led
// Esercizio 07
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix matrix;
void setup() {
Serial.begin(115200);
matrix.begin();
}
uint8_t frame[8][12] = { 0 };
// puntino cadente
void puntino() {
for (int y = 0; y < 8; y++) {
for (int x = 0; x < 12; x++) {
frame[y][x] = 1;
matrix.renderBitmap(frame, 8, 12);
delay(20);
frame[y][x] = 0;
matrix.renderBitmap(frame, 8, 12);
delay(20);
}
}
}
void loop() {
puntino();
}
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.
// Prof. Maffucci Michele
// 27/07/23
// Puntino che rimbalza SX > DX - DX > SX - matrice led
// Esercizio 08
#include "Arduino_LED_Matrix.h"
ArduinoLEDMatrix matrix;
void setup() {
Serial.begin(115200);
matrix.begin();
}
uint8_t frame[8][12] = { 0 };
// puntino rimbalza su riga 4
void puntinoSxDx() {
for (int x = 0; x < 12; x++) {
frame[4][x] = 1;
matrix.renderBitmap(frame, 8, 12);
delay(50);
frame[4][x] = 0;
matrix.renderBitmap(frame, 8, 12);
delay(50);
}
}
void puntinoDxSx() {
for (int x = 11; x >= 0; x--) {
frame[4][x] = 1;
matrix.renderBitmap(frame, 8, 12);
delay(50);
frame[4][x] = 0;
matrix.renderBitmap(frame, 8, 12);
delay(50);
}
}
void loop() {
puntinoSxDx();
puntinoDxSx();
}
Buon Making a tutti 🙂