ESP32-S3 RGB LED-matriksprojek 2 - Roltelende teks

ESP32-S3 RGB LED-matriksprojek 2 - Roltelende teks

Projek 2 – Teksrol op ESP32-S3 RGB LED-matriks

In hierdie projek verander ons die ESP32-S3 RGB LED-matriks in 'n klein teksbanier. 'n Kort boodskap (byvoorbeeld Robojax) rol oor die 8×8 RGB-skerm, en jy kan maklik die teks, kleur, helderheid en rolsnelheid direk in die kode verander. Dit is baie nuttig vir eenvoudige kennisgewings, naametikette of klein statusboodskappe.

Al ses projekte in hierdie reeks word in 'n enkele YouTube-video gedemonstreer en verduidelik. Dieselfde video is op hierdie bladsy ingebed, sodat jy presies kan sien hoe die teksrol in reële tyd lyk en hoe elke instelling die animasie beïnvloed. Die volledige kode vir hierdie projek word outomaties onder die artikel gelaai, en jy kan die ESP32-S3 RGB LED-matriksmodule by geaffilieerde winkels koop wat onder die kode-afdeling gelys word.

Hierdie projek bou voort op die basiese beginsels van Projek 1 (bewegende kolletjie en kleurbeheer) en voeg teksweergawe en rol by met behulp van die NeoMatrix-biblioteek.

ESP32-S3 RGB LED-matriksmodule-oorsig

Die hardeware is dieselfde oor al ses projekte: 'n ESP32-S3-mikrobeheerder met Wi-Fi en Bluetooth, 'n 8×8 RGB LED-matriks (64 adresseerbare RGB LED's), 'n QMI8658C-versnellingsmeter, USB-poort en toeganklike IO-penne.:contentReference[oaicite:0]{index=0}

• ESP32-S3 – hoof-SVE met Wi-Fi/BLE vir gevorderde projekte.
• 8×8 RGB-matriks – 64 RGB LED's vir ikone, teks en animasies.
• QMI8658C-versnellingsmeter – gebruik in latere projekte vir kanteling en oriëntasie.
• USB-poort – gebruik vir krag en programmering via Arduino IDE.
• Blootgestelde penne – laat jou toe om die bord soos 'n normale ESP32 vir ander IO te gebruik.
• Boot / Reset-knoppies – vir firmware-oplaai en die herbegin van sketse.

In Projek 2 fokus ons hoofsaaklik op die matriks en die NeoMatrix-teksfunksies. Die versnellingsmeter word nog nie gebruik nie, maar dieselfde bord sal al die latere interaksie- en speletjieprojekte ook hanteer.

Projekte wat in die Video Gedek word (Tydstempels)

Die video wat by hierdie artikel hoort, dek al ses projekte. Die benaderde tydstempels is:

• 00:00 – Inleiding
• 02:01 – Installeer ESP32-borde
• 03:32 – Installeer biblioteke
• 05:32 – Projek 1: Beweegende Kolletjie
• 11:11 – Projek 2: Teksrol
• 12:59 – Projek 3: HTTP-teks
• 16:41 – Projek 4: Kantelkolletjie
• 18:55 – Projek 5: Pyl Op
• 20:02 – Projek 6: Teiken-speletjie

Jy word aangemoedig om die video te kyk terwyl jy hierdie artikel lees. Dit wys die teks wat lewendig op die LED-matriks rol en lei jou deur al die stappe in die Arduino IDE.

Installeer ESP32-borde in Arduino IDE

Voordat jy die teksrolkode laat loop, maak seker dat die ESP32-ondersteuning in jou Arduino IDE geïnstalleer is:

1. Maak File > Preferences oop en voeg die ESP32-borde-URL by “Additional Boards Manager URLs”.
2. Gaan na Tools > Board > Boards Manager…, soek vir ESP32, en installeer die amptelike ESP32-pakket.
3. Kies jou ESP32-S3 RGB-matriksbord van Tools > Board.
4. Koppel die module via USB en kies die korrekte COM/reekspoort onder Tools > Port.

As die bordtipe of poort nie korrek is nie, sal die skets nie oplaai nie.

Installeer NeoMatrix en Vereiste Biblioteke

Die teksrol word geïmplementeer met behulp van Adafruit NeoMatrix en sy afhanklikhede. In die video word hulle via Library Manager geïnstalleer.

Jy sal nodig hê:

• Adafruit NeoMatrix
• Adafruit NeoPixel
• Adafruit GFX Library

1. Maak Sketch > Include Library > Manage Libraries… oop.
2. Soek vir Adafruit NeoMatrix en klik op Installeer.
3. Wanneer gevra word, laat dit toe om Adafruit GFX en Adafruit NeoPixel as afhanklikhede te installeer.

As installasie suksesvol is, behoort jy voorbeeldsketse onder File > Examples > Adafruit NeoMatrix en File > Examples > Adafruit NeoPixel te sien.

Projek 2 – Kode-instellings (Teksrol)

Die volledige teksrolskets word outomaties onder hierdie artikel op die webwerf gelaai. Hier fokus ons slegs op die konfigurasiewaardes wat jy waarskynlik sal wil wysig: pen, matriksgrootte, helderheid, teksstring, kleur, rolsnelheid en opsionele rigting.

Al die brokkies hieronder is geneem uit die konfigurasie-afdeling aan die bokant van die skets sodat jy vinnig die gedrag kan aanpas sonder om die hooflogika te raak.

Matrikspen en -grootte

Net soos Projek 1, is die RGB-matriks aan GPIO 14 gekoppel en bevat dit 64 LED's (8×8). Maak seker hierdie twee lyne pas by jou module:

 // Pen gekoppel aan 8×8 RGB-matriks 
const int MATRIX_PIN = 14; // moet 14 wees op hierdie module // Matriksgrootte (breedte en hoogte)
 const int MATRIX_WIDTH = 8; 
const int MATRIX_HEIGHT = 8; 

As jy 'n voorbeeld van die NeoMatrix-biblioteek kopieer, mag dit 'n ander pen of grootte gebruik; verander dit altyd om by hierdie bord te pas.

Helderheid van die Teks

Helderheid word tipies beheer met 'n waarde tussen 0 en 255, waar 0 af is en 255 maksimum helderheid is. 'n Matige waarde is gewoonlik genoeg:

// Algehele matrikshelderheid (0–255)
uint8_t matrixBrightness = 40; // gemaklike binnenshuise helderheid // In
setup():
matrix.setBrightness(matrixBrightness);

As u die paneel in 'n helder omgewing of vir 'n kort tyd gebruik, kan u hierdie waarde verhoog, maar vermy om te hoog te gaan as u naby die skerm is.

Teks om te Rolle

Die werklike boodskap word as 'n string gestoor. In die video is die voorbeeldteks Robojax. U kan dit verander na enige kort etiket of boodskap wat u verkies:

 // Teks om op die 8×8-matriks te rol const char scrollText[] = "Robojax";
 // verander dit na u boodskap

Onthou dat dit slegs 'n 8×8-matriks is, so baie lang boodskappe sal langer neem om te rol en kan moeilik leesbaar word.

Tekskleur (RGB-waardes)

Die kleur van die rollende teks word deur rooi, groen en blou komponente (0–255) gestel. Byvoorbeeld, suiwer rooi is (255, 0, 0), suiwer groen is (0, 255, 0), en suiwer blou is (0, 0, 255). In die skets sal u iets soos dit sien:

 // Tekskleur (R, G, B) uint8_t textRed = 255; // rooi komponent uint8_t textGreen = 0; // groen komponent uint8_t textBlue = 0; // blou komponent 

Om die kleur te verander:

• Geel: textRed = 255; textGreen = 255; textBlue = 0;
• Siaan: textRed = 0; textGreen = 255; textBlue = 255;
• Wit: textRed = 255; textGreen = 255; textBlue = 255;

Die video demonstreer ook die gebruik van 'n aanlyn kleurkieste om die RGB-waardes te vind en dit dan in die kode in te voer.:contentReference[oaicite:1]{index=1}

Rolsnelheid (Vertraging Tussen Raampies)

Rolsnelheid word beheer deur 'n vertragingswaarde in millisekondes tussen elke opdateringstap. 'n Kleiner waarde laat die teks vinniger beweeg; 'n groter waarde vertraag dit. In die skets behoort u 'n veranderlike soos hierdie te vind:

// Vertraging tussen rolstappe (in millisekondes) int scrollDelayMs = 50;
// kleiner = vinniger, groter = stadiger

Voorbeelde:

• scrollDelayMs = 20; → vinnige rol.
• scrollDelayMs = 50; → medium spoed (soortgelyk aan die video).
• scrollDelayMs = 100; of meer → stadige, maklik-leesbare rol.

Binne die loop() word hierdie waarde gebruik in 'n delay(scrollDelayMs);-oproep na elke herteken van die teksposisie.

Rolrigting (Opsioneel)

In die “basiese teksrol”-projek rol ons gewoonlik na links, maar dit is nuttig om 'n simboliese rigtingveranderlike te definieer sodat u later met ander rigtings kan eksperimenteer (links, regs, op, af).

Een algemene patroon is:

 // Rolrigting-keuse // 0 = links, 1 = regs, 2 = op, 3 = af
int scrollDirection = 0; // standaard: rol na links

Die hooflus kontroleer dan scrollDirection en beweeg die teks in die gekose rigting. Vir Projek 2 kan u dit op 0 (links) los, maar as u die skets later uitbrei, kan u voorwaardes soos hierdie byvoeg:

 if (scrollDirection == 0) {
// beweeg teks links
} else if (scrollDirection == 1) {
// beweeg teks regs
} else if (scrollDirection == 2) {
// beweeg teks op
 } else if (scrollDirection == 3) {
// beweeg teks af
}
 

Vir hierdie artikel dokumenteer ons slegs die instelling. Die volledige implementering is deel van die kode wat onder die artikel gelaai word.

Opsomming

Projek 2 verander u ESP32-S3 RGB LED-matriks in 'n eenvoudige maar opvallende teksskerm. Deur slegs 'n paar veranderlikes aan die bokant van die kode te wysig, kan u vinnig verander:

• Watter boodskap vertoon word (scrollText).
• Die kleur van die teks (textRed, textGreen, textBlue).
• Die helderheid van die matriks (matrixBrightness).
• Die spoed van rol (scrollDelayMs).
• Die rigting van rol (scrollDirection, as u dit kies om te gebruik).

Die volledige skets vir hierdie projek is beskikbaar onder hierdie artikel (outomaties deur die webwerf gelaai). Vir gedetailleerde stap-vir-stap-konfigurasie en 'n lewendige demonstrasie van die rollende teks in aksie, maak seker dat u die ooreenstemmende gedeelte van die video kyk. As u van die projek hou en dit self wil bou, kan u ook die ESP32-S3 RGB LED-matriksmodule by die geaffilieerde skakels wat onder die kode gelys word, aankoop.

Beelde

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

/* 
  Project 2: Text scroll – ESP32-S3 RGB LED Matrix (Waveshare)

  This sketch displays the scrolling text on 8x8 matrix

  ▶️ Video Tutorial:
  https://youtu.be/JKLuYrRcLMI

  📚⬇️ Resources & Code Page:
  https://robojax.com/RJT829

  QMI8658_RGB_2
*/
#include <Arduino.h>
#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

// -------- LED MATRIX SETUP --------
#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
);

// =========================
// USER SETTINGS
// =========================

// Text to scroll
const char* MESSAGE = "ROBOJAX ";

// Brightness (0–255)
uint8_t BRIGHTNESS = 10;

// Scroll speed (milliseconds between steps)
// Smaller = faster
uint16_t SCROLL_DELAY = 80;

// Scroll direction
enum ScrollDir {
  SCROLL_LEFT,
  SCROLL_RIGHT,
  SCROLL_UP,
  SCROLL_DOWN
};

// Change this to set direction
ScrollDir DIRECTION = SCROLL_LEFT;

// Text color (set RGB here)
uint8_t COLOR_R = 255; 
uint8_t COLOR_G = 0;
uint8_t COLOR_B = 0;

// =========================
// INTERNAL STATE
// =========================
uint16_t textColor;
int16_t posX, posY;
int16_t textWidth, textHeight;
uint32_t lastStepTime = 0;

// Compute text size in pixels for default 5x7 font
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;
}

// Initialize starting position based on direction
void resetScrollPosition() {
  switch (DIRECTION) {
    case SCROLL_LEFT:
      // Start just off the right edge
      posX = matrix.width();
      posY = 0; // top row for 8x8
      break;

    case SCROLL_RIGHT:
      // Start just off the left edge
      posX = -textWidth;
      posY = 0;
      break;

    case SCROLL_UP:
      posX = 0;
      posY = matrix.height(); // start below bottom
      break;

    case SCROLL_DOWN:
      posX = 0;
      posY = -textHeight; // start above top
      break;
  }
}

// One scroll step
void stepScroll() {
  // Move position
  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;
  }

  // Draw frame
  matrix.fillScreen(0);
  matrix.setCursor(posX, posY);
  matrix.print(MESSAGE);
  matrix.show();
}

void setup() {
  matrix.begin();
  matrix.setBrightness(BRIGHTNESS);
  matrix.setTextWrap(false);       // No automatic wrapping
  matrix.setTextSize(1);           // Default 5x7 font
  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();
  }
}