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 પિન.

• ESP32-S3 – અદ્યતન પ્રોજેક્ટ્સ માટે Wi-Fi/BLE સાથેનું મુખ્ય CPU.
• 8×8 RGB મેટ્રિક્સ – આઇકોન્સ, ટેક્સ્ટ અને એનિમેશન માટે 64 RGB LED.
• QMI8658C એક્સેલરોમીટર – પછીના પ્રોજેક્ટ્સમાં ટિલ્ટ અને ઓરિએન્ટેશન માટે વપરાય છે.
• USB પોર્ટ – Arduino IDE દ્વારા પાવર અને પ્રોગ્રામિંગ માટે વપરાય છે.
• ખુલ્લા પિન – તમને અન્ય IO માટે બોર્ડને સામાન્ય ESP32 ની જેમ ઉપયોગ કરવા દે છે.
• બૂટ / રીસેટ બટનો – ફર્મવેર અપલોડ અને સ્કેચ ફરી શરૂ કરવા માટે.

પ્રોજેક્ટ 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. ફાઇલ > પ્રેફરન્સિસ ખોલો અને “એડિશનલ બોર્ડ્સ મેનેજર URLs” માં ESP32 બોર્ડ્સ URL ઉમેરો.
2. ટૂલ્સ > બોર્ડ > બોર્ડ્સ મેનેજર… પર જાઓ, ESP32 શોધો અને સત્તાવાર ESP32 પેકેજ ઇન્સ્ટોલ કરો.
3. ટૂલ્સ > બોર્ડ માંથી તમારું ESP32-S3 RGB મેટ્રિક્સ બોર્ડ પસંદ કરો.
4. મોડ્યુલને USB દ્વારા કનેક્ટ કરો અને ટૂલ્સ > પોર્ટ હેઠળ યોગ્ય COM/સીરિયલ પોર્ટ પસંદ કરો.

જો બોર્ડ પ્રકાર અથવા પોર્ટ સાચું ન હોય, તો સ્કેચ અપલોડ થશે નહીં.

NeoMatrix અને જરૂરી લાઇબ્રેરીઓ ઇન્સ્ટોલ કરવી

ટેક્સ્ટ સ્ક્રોલ Adafruit NeoMatrix અને તેની નિર્ભરતાઓનો ઉપયોગ કરીને લાગુ કરવામાં આવે છે. વિડિયોમાં, તે લાઇબ્રેરી મેનેજર દ્વારા ઇન્સ્ટોલ કરવામાં આવે છે.

તમારે આની જરૂર પડશે:

• Adafruit NeoMatrix
• Adafruit NeoPixel
• Adafruit GFX લાઇબ્રેરી

1. સ્કેચ > લાઇબ્રેરી શામેલ કરો > લાઇબ્રેરીઓ મેનેજ કરો… ખોલો.
2. Adafruit NeoMatrix શોધો અને ઇન્સ્ટોલ પર ક્લિક કરો.
3. જ્યારે સંકેત આપવામાં આવે, ત્યારે તેને નિર્ભરતા તરીકે Adafruit GFX અને Adafruit NeoPixel ઇન્સ્ટોલ કરવાની મંજૂરી આપો.

જો ઇન્સ્ટોલેશન સફળ થાય, તો તમારે ફાઇલ > ઉદાહરણો > Adafruit NeoMatrix અને ફાઇલ > ઉદાહરણો > 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 મેટ્રિક્સ મોડ્યુલ પણ ખરીદી શકો છો.

Images

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