Guarda su YouTube

Progetto Matrice LED RGB ESP32-S3 2 - Testo Scorrevole

Progetto 2 - Scorrimento testo su matrice LED RGB ESP32-S3

In questo progetto trasformiamo la matrice LED RGB ESP32-S3 in un piccolo striscione di testo. Un messaggio breve (ad esempioRobojax) scorre attraverso il display RGB 8×8, e puoi facilmente cambiare il testo, il colore, la luminosità e la velocità di scorrimento direttamente nel codice. Questo è molto utile per semplici notifiche, etichette con nome o piccoli messaggi di stato.

Tutti e sei i progetti di questa serie sono mostrati e spiegati in un unico video su YouTube. Lo stesso video è incorporato in questa pagina, quindi puoi vedere esattamente come appare lo scorrimento del testo in tempo reale e come ogni impostazione influisce sull'animazione. Il codice completo per questo progetto è caricato automaticamente sotto l'articolo, e puoi acquistare il modulo matrice LED RGB ESP32-S3 presso i negozi affiliati elencati nella sezione codice.

Questo progetto si basa sui fondamenti del Progetto 1 (movimento del punto e controllo del colore) e aggiunge il rendering del testo e lo scorrimento utilizzando la libreria NeoMatrix.

Panoramica del modulo matrice LED RGB ESP32-S3

L'hardware è lo stesso in tutti e sei i progetti: un microcontrollore ESP32-S3 con Wi-Fi e Bluetooth, una matrice LED RGB 8×8 (64 LED RGB indirizzabili), un accelerometro QMI8658C, una porta USB e pin di I/O accessibili.:contentReference[oaicite:0]{index=0}

• ESP32-S3- CPU principale con Wi-Fi/BLE per progetti avanzati.
• matrice RGB 8×8- 64 LED RGB per icone, testo e animazioni.
• QMI8658C accelerometro- utilizzato in progetti successivi per inclinazione e orientamento.
• porta USB- utilizzato per alimentazione e programmazione tramite Arduino IDE.
• Pin esposti- ti permette di utilizzare la scheda come un normale ESP32 per altre I/O.
• Pulsanti di avvio / ripristino- per il caricamento del firmware e il riavvio dei progetti.

Nel Progetto 2 ci concentriamo principalmente sulle funzioni di testo matrix e NeoMatrix. L'accelerometro non è ancora utilizzato, ma la stessa scheda gestirà anche tutte le interazioni e i progetti di gioco successivi.

Progetti Coperti nel Video (Timestamp)

Il video che accompagna questo articolo copre tutti e sei i progetti. I timestamp approssimativi sono:

• 00:00- Introduzione
• 02:01- Installazione delle schede ESP32
• 03:32- Installazione delle librerie
• 05:32- Progetto 1: Punto in Movimento
• 11:11- Progetto 2: Scorrimento del testo
• 12:59- Progetto 3: Testo HTTP
• 16:41- Progetto 4: Tilt Dot
• 18:55- Progetto 5: Freccia Su
• 20:02- Progetto 6: Gioco del Target

Sei incoraggiato a guardare il video mentre leggi questo articolo. Mostra il testo che scorre in tempo reale sulla matrice LED e spiega tutti i passaggi nell'IDE di Arduino.

Installazione delle schede ESP32 in Arduino IDE

Prima di eseguire il codice per lo scorrimento del testo, assicurati che il supporto ESP32 sia installato nel tuo Arduino IDE:

1. ApriFile > Preferencese aggiungi l'URL delle schede ESP32 a "URL aggiuntivi del gestore delle schede".
2. Vai aTools > Board > Boards Manager…, cerca diESP32e installa il pacchetto ufficiale ESP32.
3. Seleziona la tua scheda RGB Matrix ESP32-S3 daTools > Board.
4. Collegare il modulo tramite USB e scegliere la corretta porta COM/seriale sottoTools > Port.

Se il tipo di scheda o la porta non sono corretti, lo sketch non verrà caricato.

Installazione di NeoMatrix e librerie richieste

Il testo scorre è implementato utilizzando Adafruit NeoMatrix e le sue dipendenze. Nel video, vengono installati tramite il Gestore Librerie.

Avrai bisogno di:

• Adafruit NeoMatrix
• Adafruit NeoPixel
• Adafruit GFX Library

1. ApriSketch > Include Library > Manage Libraries….
2. Cerca perAdafruit NeoMatrixe cliccaInstalla.
3. Quando richiesto, consentire l'installazione.Adafruit GFXeAdafruit NeoPixelcome dipendenze.

Se l'installazione ha avuto successo, dovresti vedere degli esempi di sketch sottoFile > Examples > Adafruit NeoMatrixeFile > Examples > Adafruit NeoPixel.

Progetto 2 - Impostazioni Codice (Scorrimento Testo)

Il testo completo dello schizzo di scorrimento è caricato automaticamente sotto questo articolo sul sito web. Qui ci concentriamo solo sui valori di configurazione che probabilmente vorrai modificare: pin, dimensione della matrice, luminosità, stringa di testo, colore, velocità di scorrimento e direzione opzionale.

Tutti gli snippet qui sotto sono tratti dalla sezione di configurazione nella parte superiore dello sketch, in modo da poter regolare rapidamente il comportamento senza toccare la logica principale.

Pin e dimensione della matrice

Proprio come il Progetto 1, la matrice RGB è collegata al GPIO 14 e contiene 64 LED (8×8). Assicurati che queste due righe corrispondano al tuo modulo:

 // Pin connected to 8×8 RGB matrix 
const int MATRIX_PIN = 14; // must be 14 on this module // Matrix size (width and height)
 const int MATRIX_WIDTH = 8; 
const int MATRIX_HEIGHT = 8; 

Se copi un esempio dalla libreria NeoMatrix, potrebbe utilizzare un pin o una dimensione diversi; assicurati sempre di modificarli per adattarli a questa scheda.

Luminosità del testo

La luminosità è solitamente controllata con un valore compreso tra 0 e 255, dove 0 è spento e 255 è la massima luminosità. Un valore moderato è di solito sufficiente:

// Overall matrix brightness (0–255) 
uint8_t matrixBrightness = 40; // comfortable indoor brightness // In 
setup(): 
matrix.setBrightness(matrixBrightness); 

Se utilizzi il pannello in un ambiente luminoso o per un breve periodo, puoi aumentare questo valore, ma evita di esagerare se sei vicino al display.

Testo da scorrere

Il messaggio attuale è memorizzato come una stringa. Nel video, il testo d'esempio èRobojaxPuoi cambiarlo con qualsiasi etichetta breve o messaggio che preferisci:

 // Text to scroll on the 8×8 matrix const char scrollText[] = "Robojax";
 // change this to your message 

Tieni presente che si tratta solo di una matrice 8×8, quindi messaggi molto lunghi richiederanno più tempo per scorrere e potrebbero diventare difficili da leggere.

Colore del testo (valori RGB)

Il colore del testo scorrevole è impostato dai componenti rosso, verde e blu (0-255). Ad esempio, il rosso puro è(255, 0, 0), verde puro è(0, 255, 0), e blu puro è(0, 0, 255)Nel disegno vedrai qualcosa di simile:

 // Text color (R, G, B) uint8_t textRed = 255; // red component uint8_t textGreen = 0; // green component uint8_t textBlue = 0; // blue component 

Per cambiare il colore:

• Giallo:textRed = 255; textGreen = 255; textBlue = 0;
• Ciano:textRed = 0; textGreen = 255; textBlue = 255;
• Bianco:textRed = 255; textGreen = 255; textBlue = 255;

Il video dimostra anche come utilizzare un selettore di colori online per trovare i valori RGB e poi inserirli nel codice.:contentReference[oaicite:1]{index=1}

Velocità di Scorrimento (Ritardo Tra I Fotogrammi)

La velocità di scorrimento è controllata da un valore di ritardo in millisecondi tra ciascun passo di aggiornamento. Un valore più piccolo fa muovere il testo più velocemente; un valore più grande lo rallenta. Nel programma di esempio, dovresti trovare una variabile come:

// Delay between scroll steps (in milliseconds) int scrollDelayMs = 50; 
// smaller = faster, larger = slower 

Esempi:

• scrollDelayMs = 20;→ scorrimento veloce.
• scrollDelayMs = 50;→ velocità media (simile al video).
• scrollDelayMs = 100;o più → scorrimento lento e facile da leggere.

Dentro illoop(), questo valore è utilizzato in undelay(scrollDelayMs);chiama dopo ogni nuovo disegno della posizione del testo.

Direzione di scorrimento (Opzionale)

Nel progetto "basic text scroll" di solito scorriamo verso sinistra, ma è utile definire una variabile di direzione simbolica in modo da poter sperimentare con altre direzioni in seguito (sinistra, destra, sopra, sotto).

Un modello comune è:

 // Scroll direction selector // 0 = left, 1 = right, 2 = up, 3 = down 
int scrollDirection = 0; // default: scroll to the left 

Il ciclo principale quindi controllascrollDirectione sposta il testo nella direzione scelta. Per il Progetto 2 puoi lasciarlo a0(a sinistra), ma se estendi il progetto in seguito puoi aggiungere condizioni come:

 if (scrollDirection == 0) { 
// move text left 
} else if (scrollDirection == 1) { 
// move text right 
} else if (scrollDirection == 2) { 
// move text up
 } else if (scrollDirection == 3) { 
// move text down 
}
 

Per questo articolo documentiamo solo l'impostazione. La piena implementazione fa parte del codice caricato sotto l'articolo.

Riepilogo

Il Progetto 2 trasforma il tuo matrice LED RGB ESP32-S3 in un semplice ma accattivante display di testo. Modificando solo alcune variabili nella parte superiore del codice, puoi cambiare rapidamente:

• Quale messaggio viene visualizzato (scrollText).
• Il colore del testotextRed,textGreen,textBlue).
• La luminosità della matricematrixBrightness).
• La velocità di scorrimentoscrollDelayMs).
• La direzione dello scorrimentoscrollDirection, se scegli di usarlo).

Il disegno completo per questo progetto è disponibile qui sotto questo articolo (caricato automaticamente dal sito web). Per una configurazione dettagliata passo dopo passo e una dimostrazione dal vivo del testo scorrevole in azione, assicurati di guardare la sezione corrispondente del video. Se ti piace il progetto e vuoi costruirlo tu stesso, puoi anche acquistare il modulo matrice di LED RGB ESP32-S3 dai link affiliati elencati sotto il codice.

Immagini

ESP32 S3 Matrix

ESP32 S3 Matrix pin out

ESP32-S3_RGB_8x8_matrix1

ESP32-S3_RGB_8x8_matrix-2

ESP32-S3-Mtrix - Alway Up

ESP32 S3 Matrix

ESP32 S3 Matrix pin out

ESP32-S3_RGB_8x8_matrix1

ESP32-S3_RGB_8x8_matrix-2

ESP32-S3-Mtrix - Alway Up

/*
 * Progetto 2: Scorrimento testo - Matrice LED RGB ESP32-S3 (Waveshare)
 * 
 * Questo sketch visualizza il testo scorrevole su matrice 8x8
 * 
 * ▶️ Video Tutorial:
 * https://youtu.be/JKLuYrRcLMI
 * 
 * 📚⬇️ Risorse & Pagina Codice:
 * https://robojax.com/RJT829
 * 
 * QMI8658_RGB_2
 */
#include <Arduino.h>
#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

 // -------- CONFIGURAZIONE MATRICE LED --------
#define MATRIX_PIN    14
#define MATRIX_WIDTH  8
#define MATRIX_HEIGHT 8

Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(
  MATRIX_WIDTH, MATRIX_HEIGHT, MATRIX_PIN,
  NEO_MATRIX_TOP + NEO_MATRIX_LEFT +
  NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE,
  NEO_RGB + NEO_KHZ800
);

 // =========================
 // IMPOSTAZIONI UTENTE
 // =========================

 // Testo da scorrere
const char* MESSAGE = "ROBOJAX ";

 // Luminosità (0-255)
uint8_t BRIGHTNESS = 10;

 // Velocità di scorrimento (millisecondi tra i passi)
 // Più piccolo = più veloce
uint16_t SCROLL_DELAY = 80;

 // Direzione di scorrimento
enum ScrollDir {
  SCROLL_LEFT,
  SCROLL_RIGHT,
  SCROLL_UP,
  SCROLL_DOWN
};

 // Cambia questo per impostare la direzione
ScrollDir DIRECTION = SCROLL_LEFT;

 // Colore del testo (impostare RGB qui)
uint8_t COLOR_R = 255;
uint8_t COLOR_G = 0;
uint8_t COLOR_B = 0;

 // =========================
 // STATO INTERNO
 // =========================
uint16_t textColor;
int16_t posX, posY;
int16_t textWidth, textHeight;
uint32_t lastStepTime = 0;

 // Calcola la dimensione del testo in pixel per il font predefinito 5x7.
void computeTextSize() {
  int16_t x1, y1;
  uint16_t w, h;
  matrix.getTextBounds((char*)MESSAGE, 0, 0, &x1, &y1, &w, &h);
  textWidth  = (int16_t)w;
  textHeight = (int16_t)h;
}

 // Inizializza la posizione di partenza in base alla direzione
void resetScrollPosition() {
  switch (DIRECTION) {
    case SCROLL_LEFT:
 // Inizia appena a destra del bordo.
      posX = matrix.width();
      posY = 0; // riga superiore per 8x8
      break;

    case SCROLL_RIGHT:
 // Inizia appena all'inizio a sinistra
      posX = -textWidth;
      posY = 0;
      break;

    case SCROLL_UP:
      posX = 0;
      posY = matrix.height(); // inizia sotto il fondo
      break;

    case SCROLL_DOWN:
      posX = 0;
      posY = -textHeight; // iniziare sopra il sopra
      break;
  }
}

 // Un passo di scorrimento
void stepScroll() {
 // Sposta posizione
  switch (DIRECTION) {
    case SCROLL_LEFT:
      posX--;
      if (posX < -textWidth) {
        posX = matrix.width();
      }
      break;

    case SCROLL_RIGHT:
      posX++;
      if (posX > matrix.width()) {
        posX = -textWidth;
      }
      break;

    case SCROLL_UP:
      posY--;
      if (posY < -textHeight) {
        posY = matrix.height();
      }
      break;

    case SCROLL_DOWN:
      posY++;
      if (posY > matrix.height()) {
        posY = -textHeight;
      }
      break;
  }

 // Disegna il telaio
  matrix.fillScreen(0);
  matrix.setCursor(posX, posY);
  matrix.print(MESSAGE);
  matrix.show();
}

void setup() {
  matrix.begin();
  matrix.setBrightness(BRIGHTNESS);
  matrix.setTextWrap(false); // Nessuna chiusura automatica
  matrix.setTextSize(1); // Font predefinito 5x7
  textColor = matrix.Color(COLOR_R, COLOR_G, COLOR_B);
  matrix.setTextColor(textColor);

  computeTextSize();
  resetScrollPosition();

  matrix.fillScreen(0);
  matrix.show();
}

void loop() {
  uint32_t now = millis();
  if (now - lastStepTime >= SCROLL_DELAY) {
    lastStepTime = now;
    stepScroll();
  }
}