Archivi tag: arduino

EduRobot 4WD – Bluetooth

Alcuni lettori hanno notato nella lezione in cui ho condiviso i sorgenti per la stampa 3D del robot, che la scheda motori utilizzata è una Adafruit Motor Shield V01 e mi è stato fatto notare che esiste la V02 della scheda, quindi perché ho usato la versione precedente? La risposta non è tecnica ma economica, ho acquistato ad un prezzo interessante, su uno store cinese, una grande quantità di queste schede che poi ho usato per i miei corsi. Ovviamente nulla vieta che voi possiate utilizzare una qualsiasi altra scheda, la logica di programmazione è la medesima, ma certamente varieranno il nome delle istruzioni che controllano il motore, se avete necessità contattatemi.

Lista componenti

N. 1 Arduino UNO R3
N. 1 Adafruit Motor Shield V01
Modulo Bluetooth HC05
N. 4 Motori DC 6V
N. 4 Ruote

Di seguito trovate i collegamenti elettrici effettuati e il primo sketch di esempio con cui parto per svolgere le successive esercitazioni. Per gli allievi e i docenti che si iscriveranno ai miei corsi darò ulteriori esempi e spiegazioni.

Lo shield per il controllo motori può gestire fino a 4 motori DC in entrambe le direzioni, ciò vuol dire che possono essere azionati sia in avanti che all’indietro. La velocità può anche essere variata con incrementi dello 0,5% utilizzando PWM integrato sulla scheda, ciò permetterà un movimento uniforme e non brusca del robot.

Il ponte H presente sulla scheda può pilotare carichi NON superiori ai 0,6A o che hanno picchi di richiesta corrente NON superiori a 1,2A, quindi utilizzate questa scheda per piccoli motori, i classici motori gialli da 6V vanno più che bene.

Collegamento motori allo shield Arduino Motor Driver

Come indicato nell’immagine che segue è molto semplice:
– saldate due cavi al motorino (in commercio trovate motori con fili saldati)
– collegate i motori ai morsetti: M1, M2, M3 o M4.

Collegamento scheda Bluetooth HC-05 allo shield Arduino Motor Driver

Come sicuramente saprete, il modulo Bluetooth HC-05 permette di convertire una porta seriale UART in una porta Bluetooth e la utilizzeremo per inviare su seriale i caratteri selezionati da una specifica app Android, per comandare direzione e velocità dei motori del robot.

I collegamenti sono:

HC05 <-> Arduino Motor Driver
RX - Pin 1
TX - Pin 0
G - GND
V - +5V

Orientamento ruote.

Collegamento motori M1 e M2.

Collegamento motori M3 e M4.

Modulo Bluetooth HC-05.

Connessione dei pin RX e TX del modulo Bluetooth HC-05 alla seriale di Arduino (pin 0 e pin 1).

Alimentazione del modulo Bluetooth HC-05 attraverso lo shield.

Alimentazione dello shield.

Continua a leggere→

Realizziamo un orologio con l’RTC di Arduino UNO R4 WiFi

5 Repliche

Arduino UNO R4 WiFi possiede un RTC interno facilmente programmabile che ci consentirà di mantenere costantemente traccia dell’ora e della data corrente.

Per chi ha iniziato da poco le sperimentazioni elettroniche ricordo che un Real-Time Clock (RTC), o Orologio in Tempo Reale, è un tipo di orologio costituito da un circuito elettronico utilizzato per tracciare il tempo in tempo reale. Questo significa che tiene traccia del giorno della settimana, della data e dell’ora corrente, dei minuti, dei secondi, proprio come un orologio normale, inoltre è possibile impostare un RTC per gestire l’ora legale e l’ora solare.

Nelle versione precedente di Arduino, UNO R3 non era presente un RTC pertanto bisognava utilizzare un apposito circuito elettronico esterno così come dettagliato nel post su questo sito: Utilizzare un orologio RTC con Arduino – Modulo Tiny RTC I2C, modulo RTC dotato di un integrato DS1307 cuore fondamentale della scheda.

L’utilizzo dell’RTC su Arduino UNO R4 WiFi avviene utilizzando la libreria RTC che consente di impostare oppure ottenere l’orario o ancora gestire allarmi per attivare interrupt.

Come accennato ad inizio post l’RTC integrato dispone di un pin VRTC, che viene utilizzato per mantenere in funzione l’RTC, anche quando l’alimentazione della scheda viene interrotta. Per utilizzare questa funzione è sufficiente fornire una tensione compresa tra 1,6 e 3,6 V al pin VRTC. In un post successivo mostrerò come utilizzare il pin VRTC.

Facendo riferimento agli esempi disponibili sul sito Arduino e nell’IDE analizziamo le fasi di configurazione dell’RTC.

Impostazione della data e dell’ora

RTCTime startTime(01, Month::AUGUST, 2023, 20, 49, 00, DayOfWeek::TUESDAY, SaveLight::SAVING_TIME_ACTIVE)

RTC.setTime(startTime)

Per impostare l’orario bisogna creare un oggetto RTCTime, in cui deve essere specificato il giorno, il mese, l’anno, l’ora, il minuto, il secondo, il giorno della settimana e l’attivazione dell’ora legale se prevista nella nazione in cui si sta utilizzando la scheda, quindi per impostare l’orario bisogna usare il metodo startTime.

Per chi incomincia con la programmazione il concetto di metodo appartiene alla programmazione ad orientata agli oggetti come ad esempio in C++, quando si programma in C è meglio parlare di funzione, ma spesso i due concetti vengono usati in modo alternativo.

Il primo sketch non fa altro che impostare l’ora corrente:

// inclusione della libreria RTC
#include "RTC.h"

void setup() {

  // impostazione della velocità della serial monitor
  Serial.begin(9600);

  // avvio dell'RTC
  RTC.begin();

  // creazione dell'oggetto RTCTime (possiamo assegnare un nome a piacimento)
  // data del giorno, mese, anno, ore, minuti, secondi, giorno della settimana, attivazione passaggio all'ora legale
  RTCTime startTime(2, Month::AUGUST, 2023, 9, 15, 00, DayOfWeek::WEDNESDAY, SaveLight::SAVING_TIME_ACTIVE);

  // impostazione dell'RTC con la data e lora configurate per RTCTime
  RTC.setTime(startTime);
}

// il loop non contiene nulla
void loop() {
}

Continua a leggere→

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

Lascia una risposta

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 🙂

Usare la matrice LED di Arduino UNO R4 WiFi

Lascia una risposta

L’elemento caratterizzante più evidente di Arduino R4 è senza alcun dubbio la matrice di LED, che potremo utilizzare come sistema di output immediato, ma anche per creare animazioni o giochi, o ancora mettere in evidenza lo stato di un sensore. La matrice LED è costituita da 12×8 LED.

La matrice e la sua API sono sviluppate per essere programmate in diversi modi, ciascuno adatto per diverse applicazioni. Questa breve lezione vi guiderà attraverso i concetti di base per gestire la matrice di LED aiutandovi a creare le vostre animazioni, mostrando tre diversi metodi di gestione dei LED che potrete scegliere in funzione del progetto che desiderate implementare.

Per lo svolgimento di questa lezione avete necessità solamente della scheda Arduino UNO R4 e di un cavo USB C.

Inizializzare la matrice

L’inizializzazione della matrice di LED avviene in 3 passi:

inclusione nel vostro sketch della libreria:

#include "Arduino_LED_Matrix.h"

creazione dell’oggetto matrix aggiungendo la seguente riga:

ArduinoLEDMatrix matrix;

L’oggetto ovviamente potrà avere un nome a vostro piacimento nell’esempio è stato scelto: “matrix”

avviare la matrice aggiungendo nel setup():

matrix.begin();

Il codice di avvio sarà il seguente:

#include "Arduino_LED_Matrix.h"

ArduinoLEDMatrix matrix;

void setup() {
  Serial.begin(115200);
  matrix.begin();
}

Come realizzare un frame

Il principio di funzionamento della libreria di gestione della matrice di LED è quello basato sulla creazione di un frame (fotogramma) memorizzato in un buffer di memoria e poi visualizzato.

Un frame è ciò che viene chiamato anche “immagine” visualizzata in un dato momento sulla matrice di LED. Un’animazione è costituita da una serie di immagini pertanto possiamo dire in altro modo che un’animazione è costituita da una sequenza di frame .

Per controllare la matrice LED 12×8 è indispensabile utilizzare uno spazio in memoria che sia di almeno 96 bit e la libreria fornisce due modi per farlo.

Modo n. 1

Il primo è quello di creare un array bidimensionale di byte nel modo che segue:

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 }
};

La prima modalità è molto semplice da capire, la struttura frame rappresenta la matrice di LED e la serie di 1 indicherà quali LED saranno accesi, mentre quelli a 0 rappresentano i LED spenti. L’array sopra permetterà di visualizzare sulla matrice un cuore.

Suggerimento: Potete vedere il cuore più facilmente se evidenziate tutti gli “1” sulla pagina premendo CTRL/command + F e cercando “1”.

Per fare riferimento ad un pixel specifico ricordare che l’origine degli assi si trova in alto a sinistra ed avrà coordinate (0, 0) pertanto il codice che segue permette di porre ad 1 (on) il terzo pixel da sinistra e secondo dall’alto:

frame[2][1] = 1;
matrix.renderBitmap(frame, 8, 12);

Questo metodo però richiede più memoria di quella necessaria. Anche se ogni LED ha bisogno solo di un singolo bit per memorizzare il suo stato, vengono usati per ognuno di esse otto bit (un byte). Il metodo più efficiente, in termini di memoria per memorizzare un fotogramma è utilizzare un array di interi a 32 bit, descritto di seguito.

Vedremo ora come realizzare uno o più fotogrammi, realizzazione che può anche essere svolta con il LED Matrix tool messo a disposizione da Arduino, ma al fine di comprenderne a pieno il funzionamento, consiglio di seguire le indicazioni che trovate di seguito.

La parte di programma che utilizza codici esadecimali e rappresenta l’immagine del cuore indicata sopra è:

unsigned long frame[] = {
  0x3184a444,
  0x42081100,
  0xa0040000
};

Una variabile long senza segno contiene 32 bit, quindi per gestire 92 LED (bit) avremo necessità di 96/32 che corrisponde a 3 variabili long in grado di rappresentare ogni immagine che appare sulla matrice di LED, pertanto un array di tre variabili long senza segno è un modo efficiente per contenere tutti i bit necessari per rappresentare un’immagine sulla matrice di LED.

Ma come sono relazionate la serie dei 3 valori esadecimali con la posizione di ogni songolo pixel?

Ciò dovrà essere fatto convertendo i valori esadecimali in binario utilizzando il codice che segue:

for (int b = 0; b < 3; b++) {
    Serial.println(frame[b], BIN);
  }

Che permetterà di stampare tutti i valori dei bit dell’array. L’output sarà il seguente:

110001100001001010010001000100
1000010000010000001000100000000
10100000000001000000000000000000

Questo metodo, però, non mostra tutti i bit. Ogni elemento dell’array deve avere 32 bit. Se completiamo correttamente, aggiungendo gli zeri mancanti alla fine avremo i 32 bit di ogni elemento:

00110001100001001010010001000100
01000010000010000001000100000000
10100000000001000000000000000000

Ora suddividiamo il blocco precedente in gruppi da 12 bit ed otterremo nuovamente l’immagine del cuore:

001100011000
010010100100
010001000100
001000001000
000100010000
000010100000
000001000000
000000000000

Se si hanno diversi fotogrammi, è possibile caricarli e visualizzarli in questo modo:

const uint32_t felice[] = {
    0x19819,
    0x80000001,
    0x81f8000
};

const uint32_t cuore[] = {
    0x3184a444,
    0x44042081,
    0x100a0040
};

  matrix.loadFrame(felice);
  delay(500);

  matrix.loadFrame(cuore);
  delay(500);

Proviamo il codice

Applichiamo questi concetti con due sketch che visualizzano fotogrammi diversi sulla tua scheda.

Esempio 01

Creiamo prima 3 fotogrammi interi a 32 bit e carichiamoli sulla scheda uno alla volta.

#include "Arduino_LED_Matrix.h"

ArduinoLEDMatrix matrix;

void setup() {
  Serial.begin(115200);
  matrix.begin();
}

const uint32_t felice[] = {
    0x19819,
    0x80000001,
    0x81f8000
};
const uint32_t cuore[] = {
    0x3184a444,
    0x44042081,
    0x100a0040
};

void loop(){
  matrix.loadFrame(felice);
  delay(500);

  matrix.loadFrame(cuore);
  delay(500);
}

Lo sketch è molto semplice è permette di mostrate due stati diversi.

Esempio 02

Cambiamo ora approccio è creiamo un’immagine che cambia durante l’esecuzione del programma. Il programma include diverse funzioni che concorrono alla costruzione del volto e modificano alcuni pixel che permettono di fare l’occhiolino dall’occhio sinistro.

#include "Arduino_LED_Matrix.h"

ArduinoLEDMatrix matrix;

void setup() {
  Serial.begin(115200);
  matrix.begin();
}

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

void occhioSinistro() {
  //Occhio sinistro
  frame[1][3] = 1;
  frame[1][4] = 1;
  frame[2][3] = 1;
  frame[2][4] = 1;
}

void occhiolino() {
  //Fare un occhiolino con occhio sinistro
  frame[1][3] = 0;
  frame[1][4] = 0;
  frame[2][3] = 1;
  frame[2][4] = 1;
}

void occhioDestro() {
  //Occhio destro
  frame[1][8] = 1;
  frame[1][9] = 1;
  frame[2][8] = 1;
  frame[2][9] = 1;
}

void bocca() {
  //Bocca
  frame[5][3] = 1;
  frame[5][9] = 1;
  frame[6][3] = 1;
  frame[6][4] = 1;
  frame[6][5] = 1;
  frame[6][6] = 1;
  frame[6][7] = 1;
  frame[6][8] = 1;
  frame[6][9] = 1;
}

void loop() {
  occhioSinistro();
  occhioDestro();
  bocca();

  matrix.renderBitmap(frame, 8, 12);

  delay(1000);
  occhiolino();

  matrix.renderBitmap(frame, 8, 12);
  delay(1000);
}

Esempio 03

Vediamo ora come, usando il LED Matrix tool, possono essere realizzati due visi sorridenti di cui uno che fa l’occhiolino.
Lascio a voi capire come usare gli strumenti da disegno, essenziale però descrivervi come effettuare il download dei frame.
Costruire due immagini una che riporta un viso con sorriso e l’altra un viso con sorriso che fa l’occhiolino:

Esportare il codice:

aprire il file scaricato: animazione.h ed includerlo all’interno del codice:

#include "Arduino_LED_Matrix.h"
#include <stdint.h>

ArduinoLEDMatrix matrix;

const uint32_t animazione[][4] = {
	// viso sorridente - frame n. 0
  {
		0x18c18,
		0xc0000000,
		0x1041fc,
		66
	},
  // viso sorridente con occhiolino - frame n. 1
	{
		0xc18,
		0xc0000000,
		0x1041fc,
		66
	}
};

void setup() {
  // inizializzazione della seriale
  Serial.begin(115200);
  // avvio della matrice di LED
  matrix.begin();
}

void loop() {
  // caricamento dalla prima animazione e visualizzazione su display
  matrix.loadFrame(animazione[0]);
  // attesa di 1 secondo
  delay(1000);

  // caricamento dalla seconda animazione e visualizzazione su display
  matrix.loadFrame(animazione[1]);
  // attesa di 1 secondo
  delay(1000);
}

Esempio 04

Vediamo ora come sincronizzare la visualizzazione alternata delle due immagini con il lampeggio del LED L. Nel setup() bisognerà impostare il pin a cui è connesso il LED L ad output, dopo di che richiamare accensione e spegnimento eattamente nella stessa posizione in cui viene richiamata la funzione matrix.loadFrame():

#include "Arduino_LED_Matrix.h"
#include <stdint.h>

ArduinoLEDMatrix matrix;

const uint32_t animazione[][4] = {
	// viso sorridente - frame n. 0
  {
		0x18c18,
		0xc0000000,
		0x1041fc,
		66
	},
  // viso sorridente con occhiolino - frame n. 1
	{
		0xc18,
		0xc0000000,
		0x1041fc,
		66
	}
};

void setup() {
  // inizializzazione della seriale
  Serial.begin(115200);
  // avvio della matrice di LED
  matrix.begin();
  // pin a cui collegato il LED L (pin 13) impostato come output
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // caricamento dalla prima animazione e visualizzazione su display
  matrix.loadFrame(animazione[0]);
  // accensione del LED L
  digitalWrite(LED_BUILTIN, HIGH);
  // attesa di 1 secondo
  delay(1000);

  // caricamento dalla seconda animazione e visualizzazione su display
  matrix.loadFrame(animazione[1]);
  // spegnimento del LED L
  digitalWrite(LED_BUILTIN, LOW);
  // attesa di 1 secondo
  delay(1000);
}

Buon Making a tutti 🙂

Arduino UNO R4 WiFi e Minima

Lascia una risposta

Con l’introduzione della nuova release Arduino UNO R4 è stata compiuta senza alcun dubbio un’evoluzione tecnologica che non rappresenta solamente un avanzamento considerevole in termini di capacità di elaborazione e di connessione, ma inaugura anche una nuova era nel panorama dell’elettronica del fai da te.

Sono ormai passati 13 anni dal lancio di Arduino UNO R3, ora la versione R4 arriva per rivoluzionare il nostro approccio alla prototipazione, alla produzione, all’innovazione, ma soprattutto dal mio punto di vista una grande possibilità didattica.

Arduino UNO R4 innalza le potenzialità di prototipazione con un microcontrollore Renesas RA4M1 (Arm® Cortex®-M4) a 32 bit, ed un incremento della memoria 16 volte superiore al suo predecessore. UNO R4 viene proposto in due versioni: UNO R4 Minima e UNO R4 WiFi.

Arduino UNO R4 WiFi

(scheda tecnica ufficiale)

Il modello WiFi R4 conserva l’aspetto fisico di una classica Arduino UNO, così come la tensione operativa di 5 V prevista dalla maggioranza degli shields, ma su di essa troviamo il WiFi è integrato gestito da un coprocessore ESP32-S3, che permette anche connessioni Bluetooth/BLE.

Tra i vari miglioramenti troviamo una porta USB-C per la programmazione e le funzionalità HID (Human Interface Devices), permettendo quindi l’utilizzo di un Arduino UNO R4 come una tastiera o un mouse. Molto interessante la presenza di un connettore QWIIC per un collegamento I2C agevole a sensori e attuatori che rispettano questo standard di comunicazione senza la necessità di shields o breadboard.

Ben visibile nell’area sottostante della scheda una matrice di LED 12×8 che permette di disporre di un sistema di output integrato in grado di visualizzare in modo schematico (pixel) animazioni di caratteri alfanumerici e icone ed inoltre, grazie al software online LED Matrix Editor, messo a disposizione di Arduino è possibile realizzare la propria grafica pixel da includere nei propri sketch.

Di seguito elencate tutte le nuove caratteristiche della versione WiFi

Compatibilità hardware con il formato UNO: viene conservata la stessa struttura, l’organizzazione dei pin e la tensione operativa a 5 V della versione R3, assicurando così una totale compatibilità senza inconvenienti per le schede e i progetti preesistenti.
Memoria più ampia e clock più rapido: memoria ampliata (256 kB Flash, 32 kB RAM) e velocità di clock superiore (45MHz), permettendo elaborazioni più rapide e una gestione fluida di progetti anche sofisticati.
Alimentazione estesa fino a 24 V: la scheda supporta un intervallo più vasto di tensioni di alimentazioni d’ingresso, permettendo un’integrazione migliore con motori, strisce LED e altri attuatori mediante un’unica fonte di alimentazione.
Wi-Fi® e Bluetooth®: la scheda incorpora un modulo ESP32-S3, permettendo l’integrazione di connettività wireless nei propri progetti e la gestione remota attraverso Arduino IoT Cloud.
Periferiche aggiuntive incorporate: un DAC a 12 bit rende possibile la creazione di progetti audio complessi, CAN BUS e un OP AMP, fornendo una capacità di progettazione e una flessibilità accresciute.
Supporto HID: grazie al supporto HID incorporato, sarà possibile emulare un mouse o una tastiera quando è connesso a un computer via USB, agevolando l’invio di comandi da tastiera e movimenti del mouse.
Connettore QWIIC: un connettore Qwiic I2C, permette con estrema facilità l’interconnessione di sensori ed attuatori I2C in una modalità standard e sicura.
Supporto per RTC alimentato a batteria: sulla scheda sono incorporati pin supplementari, tra cui un pin “OFF” per spegnere la scheda e un pin “VRTC” per garantire l’alimentazione e il funzionamento dell’orologio in tempo reale integrato.
Matrice LED: matrice LED rossa 12×8, permette la visualizzazione di animazioni o visualizzazione di dati da sensori, evitando la necessità di hardware supplementare.
Diagnosi degli errori durante l’esecuzione: Arduino UNO R4 Wi-Fi dispone di un sistema di identificazione degli errori che rileva i crash durante l’esecuzione e fornisce descrizioni approfondite e consigli relativi alla riga di codice che ha provocato il crash.

Specifiche tecniche


Scheda	Nome	Arduino® UNO R4 WiFi
SKU	ABX00087
Microcontrollore	Renesas RA4M1 (Arm® Cortex®-M4)
Modulo radio	ESP32-S3-MINI-1-N8
USB	USB-C®	Porta di programmazione
Pin	I/O Digitali	14
Pin Analogici	6
DAC	1
pin PWM	6
Comunicazione	UART	1
I2C	1
SPI	1
CAN	1
Tensione di funzionamento	Tensione operativa	5 V (ESP32-S3 is 3.3 V)
Tensione di alimentazione (VIN)	6-24 V
Corrente continua per i pin I/O	8 mA
Velocità di clock	RA4M1	48 MHz
ESP32-S3-MINI-1-N8	fino a 240 MHz
Memoria	RA4M1	256 kB Flash, 32 kB RAM
ESP32-S3-MINI-1-N8	384 kB ROM, 512 kB SRAM
Dimensioni	Larghezza	68.85 mm
Lunghezza	53.34 mm

IMPORTANTE

Connettore ESP: il modulo ESP32-S3 su questa scheda funziona a 3,3 V. Il connettore ESP, situato vicino al connettore USB-C®, supporta solo i 3,3 V e non deve essere collegato a 5 V. Ciò potrebbe danneggiare la tua scheda.

Connettore Qwiic: il connettore Qwiic è collegato a un bus I2C secondario: IIC0. Questo connettore supporta solo i 3,3 V, collegare tensioni superiori potrebbe danneggiare la scheda. Per inizializzare questo bus usare l’istruzione Wire1.begin().

Assorbimento massimo di corrente per pin: l’assorbimento massimo di corrente per ogni pin della GPIO della serie UNO R4 è di 8 mA, quindi inferiore rispetto alle versioni R3 precedente. Superare questo limite potrebbe danneggiare il pin o la scheda.

Arduino UNO R4 Minima

(scheda tecnica ufficiale)

Le caratteristiche tecniche differiscono per l’assenza rispetto alla versione WiFi:

della matrice di LED
porta QWIIC

però su questa scheda è dotata di un connettore SWD, assente nella versione WiFi che permette la connessione esterna di un debugger per controllare il funzionamento di uno sketch in condizioni controllate e rilevare quindi errori o più semplicemente verificare lo stato del programma in tempo reale (variabili, memoria usata, ecc…)

Specifiche tecniche


Scheda	Nome	Arduino® UNO R4 WiFi
SKU	ABX00080
Microcontrollore	Renesas RA4M1 (Arm® Cortex®-M4)
Modulo radio	ESP32-S3-MINI-1-N8
USB	USB-C®	Porta di programmazione
Pin	I/O Digitali	14
Pin Analogici	6
DAC	1
pin PWM	6
Comunicazione	UART	1
I2C	1
SPI	1
CAN	1
Tensione di funzionamento	Tensione operativa	5 V (ESP32-S3 is 3.3 V)
Tensione di alimentazione (VIN)	6-24 V
Corrente continua per i pin I/O	8 mA
Velocità di clock	RA4M1	48 MHz
ESP32-S3-MINI-1-N8	fino a 240 MHz
Memoria	RA4M1	256 kB Flash, 32 kB RAM
ESP32-S3-MINI-1-N8	384 kB ROM, 512 kB SRAM
Dimensioni	Larghezza	68.85 mm
Lunghezza	53.34 mm

IMPORTANTE

Anche per la versione Minima l’assorbimento massimo di corrente per pin: l’assorbimento massimo di corrente per ogni pin della GPIO della serie UNO R4 è di 8 mA, quindi inferiore rispetto alle versioni R3 precedente. Superare questo limite potrebbe danneggiare il pin o la scheda.

Michele Maffucci

… my stories, life and work

Archivi tag: arduino

EduRobot 4WD – Bluetooth

Lista componenti

Collegamento motori allo shield Arduino Motor Driver

Collegamento scheda Bluetooth HC-05 allo shield Arduino Motor Driver

Realizziamo un orologio con l’RTC di Arduino UNO R4 WiFi

Impostazione della data e dell’ora

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

Esercizio 1

Esercizio 2

Esercizio 3

Esercizio 4

Esercizio 5

Esercizio 6

Esercizio 7

Esercizio 8

Usare la matrice LED di Arduino UNO R4 WiFi

Inizializzare la matrice

Come realizzare un frame

Modo n. 1

Proviamo il codice

Arduino UNO R4 WiFi e Minima

Arduino UNO R4 WiFi

Arduino UNO R4 Minima

Lista componenti

Collegamento motori allo shield Arduino Motor Driver

Collegamento scheda Bluetooth HC-05 allo shield Arduino Motor Driver

Related posts:

Impostazione della data e dell’ora

Related posts:

Esercizio 1

Esercizio 2

Esercizio 3

Esercizio 4

Esercizio 5

Esercizio 6

Esercizio 7

Esercizio 8

Related posts:

Inizializzare la matrice

Come realizzare un frame

Modo n. 1

Proviamo il codice

Related posts:

Arduino UNO R4 WiFi

Arduino UNO R4 Minima

Related posts: