ESP32-S3 RGB LED மேட்ரிக்ஸ் திட்டம் 2 - உருளும் உரை

ESP32-S3 RGB LED மேட்ரிக்ஸ் திட்டம் 2 - உருளும் உரை

திட்டம் 2 – ESP32-S3 RGB LED மேட்ரிக்ஸில் உரை உருளல்

இந்த திட்டத்தில், ESP32-S3 RGB LED மேட்ரிக்ஸை ஒரு சிறிய உரை பேனராக மாற்றுகிறோம். ஒரு குறுகிய செய்தி (எடுத்துக்காட்டாக Robojax) 8×8 RGB காட்சியில் உருளும், மேலும் உரை, நிறம், பிரகாசம் மற்றும் உருள் வேகத்தை நேரடியாக குறியீட்டில் எளிதாக மாற்றலாம். எளிய அறிவிப்புகள், பெயர் குறிச்சீட்டுகள் அல்லது சிறிய நிலை செய்திகளுக்கு இது மிகவும் பயனுள்ளதாக இருக்கும்.

இந்த தொடரில் உள்ள ஆறு திட்டங்களும் ஒரே YouTube வீடியோவில் நிரூபிக்கப்பட்டு விளக்கப்பட்டுள்ளன. அதே வீடியோ இந்த பக்கத்தில் இணைக்கப்பட்டுள்ளது, எனவே உரை உருளல் நேரடியாக எப்படி இருக்கும் மற்றும் ஒவ்வொரு அமைப்பும் அசைவூட்டலை எவ்வாறு பாதிக்கிறது என்பதை நீங்கள் சரியாக பார்க்கலாம். இந்த திட்டத்திற்கான முழுமையான குறியீடு கட்டுரைக்கு கீழே தானாக ஏற்றப்படுகிறது, மேலும் குறியீடு பகுதியின் கீழ் பட்டியலிடப்பட்டுள்ள இணைந்த கடைகளிலிருந்து ESP32-S3 RGB LED மேட்ரிக்ஸ் தொகுதியை வாங்கலாம்.

இந்த திட்டம் திட்டம் 1 (நகரும் புள்ளி மற்றும் நிற கட்டுப்பாடு) அடிப்படைகளை உருவாக்கி, NeoMatrix நூலகத்தைப் பயன்படுத்தி உரை வழங்கல் மற்றும் உருளலைச் சேர்க்கிறது.

ESP32-S3 RGB LED மேட்ரிக்ஸ் தொகுதி கண்ணோட்டம்

ஆறு திட்டங்களிலும் வன்பொருள் ஒன்றுதான்: Wi-Fi மற்றும் புளூடூத் கொண்ட ESP32-S3 மைக்ரோகண்ட்ரோலர், 8×8 RGB LED மேட்ரிக்ஸ் (64 முகவரியிடக்கூடிய RGB LEDகள்), QMI8658C முடுக்கமானி, USB போர்ட் மற்றும் அணுகக்கூடிய IO பின்கள்.:contentReference[oaicite:0]{index=0}

• ESP32-S3 – மேம்பட்ட திட்டங்களுக்கு Wi-Fi/BLE கொண்ட முக்கிய CPU.
• 8×8 RGB மேட்ரிக்ஸ் – சின்னங்கள், உரை மற்றும் அசைவூட்டல்களுக்கு 64 RGB LEDகள்.
• QMI8658C முடுக்கமானி – பிந்தைய திட்டங்களில் சாய்வு மற்றும் திசைக்கு பயன்படுத்தப்படுகிறது.
• USB போர்ட் – Arduino IDE வழியாக மின்சாரம் மற்றும் நிரலாக்கத்திற்கு பயன்படுகிறது.
• வெளிப்படுத்தப்பட்ட பின்கள் – மற்ற IO களுக்கு போர்டை சாதாரண ESP32 போல பயன்படுத்த அனுமதிக்கிறது.
• Boot / Reset பொத்தான்கள் – ஃபார்ம்வேர் பதிவேற்றம் மற்றும் ஸ்கெட்ச்களை மறுதொடக்கம் செய்ய.

திட்டம் 2 இல் நாம் முக்கியமாக மேட்ரிக்ஸ் மற்றும் NeoMatrix உரை செயல்பாடுகளில் கவனம் செலுத்துகிறோம். முடுக்கமானி இன்னும் பயன்படுத்தப்படவில்லை, ஆனால் அதே போர்டு பிந்தைய அனைத்து தொடர்பு மற்றும் விளையாட்டு திட்டங்களையும் கையாளும்.

வீடியோவில் உள்ளடக்கிய திட்டங்கள் (நேர முத்திரைகள்)

இந்த கட்டுரையுடன் செல்லும் வீடியோ ஆறு திட்டங்களையும் உள்ளடக்கியது. தோராயமான நேர முத்திரைகள்:

• 00:00 – அறிமுகம்
• 02:01 – ESP32 போர்டுகளை நிறுவுதல்
• 03:32 – நூலகங்களை நிறுவுதல்
• 05:32 – திட்டம் 1: நகரும் புள்ளி
• 11:11 – திட்டம் 2: உரை உருளல்
• 12:59 – திட்டம் 3: HTTP உரை
• 16:41 – திட்டம் 4: சாய்வு புள்ளி
• 18:55 – திட்டம் 5: மேல் அம்பு
• 20:02 – திட்டம் 6: இலக்கு விளையாட்டு

இந்த கட்டுரையைப் படிக்கும்போது வீடியோவைப் பார்க்க ஊக்குவிக்கப்படுகிறீர்கள். இது LED மேட்ரிக்ஸில் உரை நேரடியாக உருள்வதைக் காட்டுகிறது மற்றும் Arduino IDE இல் உள்ள அனைத்து படிகளையும் விளக்குகிறது.

Arduino IDE இல் ESP32 போர்டுகளை நிறுவுதல்

உரை உருள் குறியீட்டை இயக்குவதற்கு முன், உங்கள் Arduino IDE இல் ESP32 ஆதரவு நிறுவப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும்:

1. File > Preferences ஐ திறந்து, “Additional Boards Manager URLs” இல் ESP32 போர்டுகள் URL ஐ சேர்க்கவும்.
2. Tools > Board > Boards Manager… க்கு சென்று, ESP32 ஐ தேடி, அதிகாரப்பூர்வ ESP32 தொகுப்பை நிறுவவும்.
3. Tools > Board இலிருந்து உங்கள் ESP32-S3 RGB மேட்ரிக்ஸ் போர்டை தேர்ந்தெடுக்கவும்.
4. தொகுதியை USB வழியாக இணைத்து, Tools > Port இன் கீழ் சரியான COM/சீரியல் போர்ட்டை தேர்ந்தெடுக்கவும்.

போர்டு வகை அல்லது போர்ட் சரியாக இல்லாவிட்டால், ஸ்கெட்ச் பதிவேற்றப்படாது.

NeoMatrix மற்றும் தேவையான நூலகங்களை நிறுவுதல்

உரை உருளல் Adafruit NeoMatrix மற்றும் அதன் சார்புகளைப் பயன்படுத்தி செயல்படுத்தப்படுகிறது. வீடியோவில், அவை Library Manager வழியாக நிறுவப்படுகின்றன.

உங்களுக்கு தேவைப்படும்:

• Adafruit NeoMatrix
• Adafruit NeoPixel
• Adafruit GFX Library

1. Sketch > Include Library > Manage Libraries… ஐ திறக்கவும்.
2. Adafruit NeoMatrix ஐ தேடி Install என்பதை கிளிக் செய்யவும்.
3. கேட்கும்போது, Adafruit GFX மற்றும் Adafruit NeoPixel சார்புகளாக நிறுவ அனுமதிக்கவும்.

நிறுவல் வெற்றிகரமாக இருந்தால், File > Examples > Adafruit NeoMatrix மற்றும் File > Examples > Adafruit NeoPixel இன் கீழ் எடுத்துக்காட்டு ஸ்கெட்ச்களை நீங்கள் காண வேண்டும்.

திட்டம் 2 – குறியீடு அமைப்புகள் (உரை உருளல்)

முழுமையான உரை உருள் ஸ்கெட்ச் இந்த கட்டுரைக்கு கீழே இணையதளத்தில் தானாக ஏற்றப்படுகிறது. இங்கே நாம் நீங்கள் திருத்த விரும்பக்கூடிய உள்ளமைவு மதிப்புகளில் மட்டுமே கவனம் செலுத்துகிறோம்: பின், மேட்ரிக்ஸ் அளவு, பிரகாசம், உரை சரம், நிறம், உருள் வேகம் மற்றும் விருப்ப திசை.

கீழே உள்ள அனைத்து பகுதிகளும் ஸ்கெட்ச்சின் மேலே உள்ள உள்ளமைவு பகுதியிலிருந்து எடுக்கப்பட்டவை, எனவே முக்கிய தர்க்கத்தைத் தொடாமல் நடத்தையை விரைவாக சரிசெய்யலாம்.

மேட்ரிக்ஸ் பின் மற்றும் அளவு

திட்டம் 1 போலவே, RGB மேட்ரிக்ஸ் GPIO 14 உடன் இணைக்கப்பட்டுள்ளது மற்றும் 64 LEDகளை (8×8) கொண்டுள்ளது. இந்த இரண்டு வரிகளும் உங்கள் தொகுதியுடன் பொருந்துகின்றனவா என்பதை உறுதிப்படுத்தவும்:

 // 8×8 RGB மேட்ரிக்ஸுடன் இணைக்கப்பட்ட பின் 
const int MATRIX_PIN = 14; // இந்த தொகுதியில் 14 ஆக இருக்க வேண்டும் // மேட்ரிக்ஸ் அளவு (அகலம் மற்றும் உயரம்)
 const int MATRIX_WIDTH = 8; 
const int MATRIX_HEIGHT = 8; 

NeoMatrix நூலகத்திலிருந்து ஒரு எடுத்துக்காட்டை நகலெடுத்தால், அது வேறு பின் அல்லது அளவைப் பயன்படுத்தலாம்; இந்த போர்டுடன் பொருந்துமாறு எப்போதும் அவற்றை மாற்றவும்.

உரையின் பிரகாசம்

பிரகாசம் பொதுவாக 0 முதல் 255 வரையிலான மதிப்புடன் கட்டுப்படுத்தப்படுகிறது, இதில் 0 அணைக்கப்பட்டது மற்றும் 255 அதிகபட்ச பிரகாசம். ஒரு மிதமான மதிப்பு பொதுவாக போதுமானது:

// ஒட்டுமொத்த மேட்ரிக்ஸ் பிரகாசம் (0–255)
uint8_t matrixBrightness = 40; // வசதியான உட்புற பிரகாசம் // In
setup():
matrix.setBrightness(matrixBrightness);

நீங்கள் பேனலை பிரகாசமான சூழலில் அல்லது குறுகிய நேரத்திற்கு பயன்படுத்தினால், இந்த மதிப்பை அதிகரிக்கலாம், ஆனால் காட்சிக்கு அருகில் இருந்தால் அதிகமாக செல்லாமல் இருங்கள்.

ஸ்க்ரோல் செய்ய வேண்டிய உரை

உண்மையான செய்தி ஒரு சரமாக சேமிக்கப்படுகிறது. வீடியோவில், எடுத்துக்காட்டு உரை Robojax ஆகும். அதை நீங்கள் விரும்பும் எந்த குறுகிய லேபிளாகவோ அல்லது செய்தியாகவோ மாற்றலாம்:

 // 8×8 மேட்ரிக்ஸில் ஸ்க்ரோல் செய்ய வேண்டிய உரை const char scrollText[] = "Robojax";
 // இதை உங்கள் செய்திக்கு மாற்றவும்

இது 8×8 மேட்ரிக்ஸ் மட்டுமே என்பதை நினைவில் கொள்ளுங்கள், எனவே மிக நீண்ட செய்திகள் ஸ்க்ரோல் செய்ய அதிக நேரம் எடுக்கும் மற்றும் படிக்க கடினமாக இருக்கலாம்.

உரை நிறம் (RGB மதிப்புகள்)

ஸ்க்ரோலிங் உரையின் நிறம் சிவப்பு, பச்சை மற்றும் நீல கூறுகளால் (0–255) அமைக்கப்படுகிறது. எடுத்துக்காட்டாக, தூய சிவப்பு (255, 0, 0), தூய பச்சை (0, 255, 0), மற்றும் தூய நீலம் (0, 0, 255) ஆகும். ஸ்கெட்ச்சில் நீங்கள் இதுபோன்ற ஒன்றைக் காண்பீர்கள்:

 // உரை நிறம் (R, G, B) uint8_t textRed = 255; // சிவப்பு கூறு uint8_t textGreen = 0; // பச்சை கூறு uint8_t textBlue = 0; // நீல கூறு 

நிறத்தை மாற்ற:

• மஞ்சள்: textRed = 255; textGreen = 255; textBlue = 0;
• சியான்: textRed = 0; textGreen = 255; textBlue = 255;
• வெள்ளை: textRed = 255; textGreen = 255; textBlue = 255;

வீடியோ RGB மதிப்புகளைக் கண்டறிய ஆன்லைன் கலர் பிக்கரைப் பயன்படுத்துவதையும், பின்னர் அவற்றை குறியீட்டில் உள்ளிடுவதையும் நிரூபிக்கிறது.:contentReference[oaicite:1]{index=1}

ஸ்க்ரோல் வேகம் (பிரேம்களுக்கு இடையிலான தாமதம்)

ஸ்க்ரோல் வேகம் ஒவ்வொரு புதுப்பிப்பு படிக்கும் இடையிலான மில்லி விநாடிகளில் உள்ள தாமத மதிப்பால் கட்டுப்படுத்தப்படுகிறது. சிறிய மதிப்பு உரையை வேகமாக நகர்த்துகிறது; பெரிய மதிப்பு அதை மெதுவாக்குகிறது. ஸ்கெட்ச்சில், நீங்கள் இதுபோன்ற ஒரு மாறியைக் காண வேண்டும்:

// ஸ்க்ரோல் படிகளுக்கு இடையிலான தாமதம் (மில்லி விநாடிகளில்) int scrollDelayMs = 50;
// சிறியது = வேகமானது, பெரியது = மெதுவானது

எடுத்துக்காட்டுகள்:

• scrollDelayMs = 20; → வேகமான ஸ்க்ரோலிங்.
• scrollDelayMs = 50; → நடுத்தர வேகம் (வீடியோவைப் போன்றது).
• scrollDelayMs = 100; அல்லது அதற்கு மேல் → மெதுவான, எளிதாக படிக்கக்கூடிய ஸ்க்ரோல்.

loop() க்குள், இந்த மதிப்பு உரை நிலையின் ஒவ்வொரு மறுவரைவுக்குப் பிறகு delay(scrollDelayMs); அழைப்பில் பயன்படுத்தப்படுகிறது.

ஸ்க்ரோல் திசை (விருப்பத்தேர்வு)

“அடிப்படை உரை ஸ்க்ரோல்” திட்டத்தில் நாம் பொதுவாக இடதுபுறமாக ஸ்க்ரோல் செய்கிறோம், ஆனால் பிற திசைகளில் (இடது, வலது, மேல், கீழ்) பரிசோதனை செய்ய ஒரு குறியீட்டு திசை மாறியை வரையறுப்பது பயனுள்ளதாக இருக்கும்.

ஒரு பொதுவான முறை:

 // ஸ்க்ரோல் திசை தேர்வாளர் // 0 = இடது, 1 = வலது, 2 = மேல், 3 = கீழ்
int scrollDirection = 0; // இயல்புநிலை: இடதுபுறமாக ஸ்க்ரோல்

முக்கிய லூப் பின்னர் scrollDirection ஐ சரிபார்த்து தேர்ந்தெடுக்கப்பட்ட திசையில் உரையை நகர்த்துகிறது. திட்டம் 2 க்கு நீங்கள் அதை 0 (இடது) இல் விடலாம், ஆனால் பின்னர் ஸ்கெட்ச்சை நீட்டித்தால், நீங்கள் இதுபோன்ற நிபந்தனைகளைச் சேர்க்கலாம்:

 if (scrollDirection == 0) {
// உரையை இடதுபுறமாக நகர்த்தவும்
} else if (scrollDirection == 1) {
// உரையை வலதுபுறமாக நகர்த்தவும்
} else if (scrollDirection == 2) {
// உரையை மேலே நகர்த்தவும்
 } else if (scrollDirection == 3) {
// உரையை கீழே நகர்த்தவும்
}
 

இந்த கட்டுரைக்கு நாங்கள் அமைப்பை மட்டுமே ஆவணப்படுத்துகிறோம். முழு செயலாக்கம் கட்டுரையின் கீழ் ஏற்றப்பட்ட குறியீட்டின் பகுதியாகும்.

சுருக்கம்

திட்டம் 2 உங்கள் ESP32-S3 RGB LED மேட்ரிக்ஸை எளிய ஆனால் கவர்ச்சிகரமான உரை காட்சியாக மாற்றுகிறது. குறியீட்டின் மேலே உள்ள சில மாறிகளை மட்டும் திருத்துவதன் மூலம், நீங்கள் விரைவாக மாற்றலாம்:

• எந்த செய்தி காட்டப்படுகிறது (scrollText).
• உரையின் நிறம் (textRed, textGreen, textBlue).
• மேட்ரிக்ஸின் பிரகாசம் (matrixBrightness).
• ஸ்க்ரோலிங்கின் வேகம் (scrollDelayMs).
• ஸ்க்ரோலிங்கின் திசை (scrollDirection, நீங்கள் அதைப் பயன்படுத்த தேர்வுசெய்தால்).

இந்த திட்டத்திற்கான முழு ஸ்கெட்ச் இந்த கட்டுரையின் கீழே கிடைக்கிறது (இணையதளத்தால் தானாக ஏற்றப்படுகிறது). விரிவான படிப்படியான உள்ளமைவு மற்றும் செயலில் உள்ள ஸ்க்ரோலிங் உரையின் நேரடி ஆர்ப்பாட்டத்திற்கு, வீடியோவின் தொடர்புடைய பகுதியைப் பார்க்க மறக்காதீர்கள். நீங்கள் திட்டத்தை விரும்பி அதை நீங்களே உருவாக்க விரும்பினால், குறியீட்டின் கீழ் பட்டியலிடப்பட்டுள்ள இணைப்பு இணைப்புகளிலிருந்து ESP32-S3 RGB LED மேட்ரிக்ஸ் தொகுதியையும் வாங்கலாம்.

படங்கள்

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