ESP32-S3 RGB LED મેટ્રિક્સ પ્રોજેક્ટ 1- મૂળભૂત ડોટ

ESP32-S3 RGB LED મેટ્રિક્સ પ્રોજેક્ટ 1- મૂળભૂત ડોટ

પ્રોજેક્ટ 1 – ESP32-S3 RGB LED મેટ્રિક્સ પર ફરતું બિંદુ અને હાર્ટ એનિમેશન

આ પ્રોજેક્ટમાં આપણે ESP32-S3 RGB LED મેટ્રિક્સ પર સૌથી સરળ શક્ય એનિમેશનથી શરૂઆત કરીએ છીએ: 8×8 RGB ડિસ્પ્લે પર એક જ બિંદુ ફરતું હોય છે. તેની ઉપર, આપણે એક નાનું હાર્ટ એનિમેશન ઉમેરીએ છીએ જેથી તમે બોર્ડને પાવર ચાલુ હોય ત્યારે તેને એક નાના સુશોભન ડિસ્પ્લેમાં ફેરવી શકો. મેટ્રિક્સ પર વ્યક્તિગત પિક્સેલ્સ, રંગો અને એનિમેશન ઝડપને નિયંત્રિત કરવામાં આરામદાયક બનવા માટે આ એક ઉત્તમ પ્રથમ પગલું છે.

આ શ્રેણીના તમામ છ પ્રોજેક્ટ્સ એક જ વિડિયોમાં દર્શાવવામાં અને સમજાવવામાં આવ્યા છે. તે જ વિડિયો આ પૃષ્ઠ પર એમ્બેડ કરેલો છે, તેથી તમે ફરતા બિંદુ અને હાર્ટ એનિમેશનનું સંપૂર્ણ પગલું-દર-પગલું સમજૂતી અને લાઇવ પ્રદર્શન જોઈ શકો છો. આ પ્રોજેક્ટ માટેનો સંપૂર્ણ કોડ લેખની નીચે આપમેળે લોડ થાય છે, અને તમે કોડ વિભાગ હેઠળ સૂચિબદ્ધ એફિલિએટ સ્ટોર્સમાંથી ESP32-S3 RGB LED મેટ્રિક્સ મોડ્યુલ ખરીદી શકો છો.

જો તમે હમણાં જ આ બોર્ડ સાથે શરૂઆત કરી રહ્યા છો, તો આ પ્રોજેક્ટ આ માટે એક ઉત્તમ રીત છે:

• ચકાસો કે તમારું ESP32-S3 બોર્ડ અને USB કનેક્શન કાર્યરત છે.
• પુષ્ટિ કરો કે 8×8 RGB મેટ્રિક્સ યોગ્ય પિન સાથે વાયર્ડ છે.
• મૂળભૂત એનિમેશન સમય, રંગ અને તેજ સાથે પ્રયોગ કરો.

ESP32-S3 RGB LED મેટ્રિક્સ મોડ્યુલ ઝાંખી

આ પ્રોજેક્ટમાં વપરાયેલું બોર્ડ ESP32-S3 માઇક્રોકંટ્રોલર પર આધારિત છે, જે 8×8 RGB LED મેટ્રિક્સ (64 વ્યક્તિગત રીતે સંબોધિત RGB LEDs), પાછળની બાજુએ QMI8658C મોશન સેન્સર અને પાવર અને પ્રોગ્રામિંગ માટે USB પોર્ટ સાથે જોડાયેલું છે.

આ મોડ્યુલની મુખ્ય વિશેષતાઓ:

• ESP32-S3 ડ્યુઅલ-કોર માઇક્રોકંટ્રોલર Wi-Fi અને બ્લૂટૂથ સપોર્ટ સાથે.
• 8×8 RGB LED મેટ્રિક્સ (64 RGB LEDs) બોર્ડની આગળની બાજુએ, ચિહ્નો, ટેક્સ્ટ અને નાની રમતો માટે આદર્શ.
• QMI8658C એક્સેલેરોમીટર / મોશન સેન્સર પાછળની બાજુએ, જેથી તમે ઇન્ટરેક્ટિવ પ્રોજેક્ટ્સ માટે ઝુકાવ, હલનચલન અને દિશા શોધી શકો.
• USB પોર્ટ પ્રોગ્રામિંગ અને પાવર બંને માટે.
• સુલભ પિન કિનારીઓની આસપાસ, જેથી બોર્ડનો ઉપયોગ અન્ય IO પ્રોજેક્ટ્સ માટે નિયમિત ESP32 ની જેમ થઈ શકે.
• બૂટ અને રીસેટ બટનો પ્રોગ્રામિંગ મોડમાં પ્રવેશવા અને તમારા સ્કેચને ફરીથી શરૂ કરવા માટે.

આ પ્રથમ પ્રોજેક્ટમાં આપણે ફક્ત બોર્ડના LED મેટ્રિક્સ ભાગનો ઉપયોગ કરીએ છીએ, પરંતુ તે જ હાર્ડવેર ટેક્સ્ટ ડિસ્પ્લે, વેબ-નિયંત્રિત સંદેશાઓ, મોશન-નિયંત્રિત રમતો અને વધુ ચલાવવા માટે પૂરતું શક્તિશાળી છે — જે આ શ્રેણીના અન્ય પ્રોજેક્ટ્સમાં આવરી લેવામાં આવ્યા છે.

વિડિયોમાં આવરી લેવાયેલા પ્રોજેક્ટ્સ (ટાઇમસ્ટેમ્પ્સ)

બધા છ પ્રોજેક્ટ્સ સમાન YouTube વિડિયો શેર કરે છે. અંદાજિત ટાઇમસ્ટેમ્પ્સ છે:

• 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: ટાર્ગેટ ગેમ

શ્રેષ્ઠ સમજણ માટે, તમને આ લેખને અનુસરીને વિડિયો જોવાની ભારપૂર્વક ભલામણ કરવામાં આવે છે. વિડિયો મેટ્રિક્સ પર બિંદુ અને હાર્ટનું લાઇવ વર્તન, તેમજ Arduino IDE ની અંદરના તમામ પગલાંઓ દર્શાવે છે.

Arduino IDE માં ESP32 બોર્ડ્સ ઇન્સ્ટોલ કરવું

ESP32-S3 પર કોઈપણ કોડ અપલોડ કરતા પહેલા, તમારે Arduino IDE માં ESP32 બોર્ડ સપોર્ટ પેકેજ ઇન્સ્ટોલ કરવું આવશ્યક છે. વિડિયોમાં, આ "બોર્ડ્સ ઇન્સ્ટોલ કરવું" વિભાગની આસપાસ દર્શાવવામાં આવ્યું છે.

સામાન્ય પગલાંઓ:

1. Arduino IDE ખોલો અને ફાઇલ > પ્રેફરન્સ પર જાઓ.
2. "વધારાના બોર્ડ્સ મેનેજર URLs" ફીલ્ડમાં, સત્તાવાર ESP32 બોર્ડ્સ URL ઉમેરો.
3. ટૂલ્સ > બોર્ડ > બોર્ડ્સ મેનેજર… ખોલો, ESP32 શોધો અને ESP32 બોર્ડ્સ માટે પેકેજ ઇન્સ્ટોલ કરો.
4. ઇન્સ્ટોલેશન પછી, ટૂલ્સ > બોર્ડ પર જાઓ અને તમારા ESP32-S3 RGB મેટ્રિક્સ મોડ્યુલ માટે યોગ્ય બોર્ડ એન્ટ્રી પસંદ કરો.
5. બોર્ડને USB દ્વારા કનેક્ટ કરો અને ટૂલ્સ > પોર્ટ હેઠળ તેનો સીરિયલ પોર્ટ પસંદ કરો.

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

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

LED મેટ્રિક્સ આંતરિક રીતે Adafruit NeoPixel ડ્રાઇવરનો ઉપયોગ કરે છે, અને સરળ 2D ડ્રોઇંગ માટે આપણે Adafruit NeoMatrix લાઇબ્રેરીનો ઉપયોગ કરીએ છીએ. NeoMatrix ઇન્સ્ટોલ કરવાથી આપમેળે નિર્ભરતાઓ ખેંચાઈ આવશે.

NeoMatrix અને નિર્ભરતાઓ

લાઇબ્રેરી મેનેજરમાંથી નીચેની ઇન્સ્ટોલ કરો:

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

લાઇબ્રેરી મેનેજરમાં:

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

QMI8658C મોશન સેન્સર લાઇબ્રેરી (પછીના પ્રોજેક્ટ્સ માટે)

પ્રોજેક્ટ 1 એક્સેલેરોમીટરનો સીધો ઉપયોગ કરતું નથી, પરંતુ હવે મોશન સેન્સર લાઇબ્રેરી ઇન્સ્ટોલ કરવી એ સારો વિચાર છે કારણ કે તે પ્રોજેક્ટ્સ 4, 5 અને 6 માટે જરૂરી થશે.

લાઇબ્રેરી મેનેજરમાંથી:

1. QMI8658 લાઇબ્રેરી તેના લેખકના નામ દ્વારા શોધો.
2. લાઇબ્રેરી ઇન્સ્ટોલ કરો જેથી તે ઝડપી પરીક્ષણ માટે ફાઇલ > ઉદાહરણો હેઠળ દેખાય.

પ્રોજેક્ટ 1 – કોડ સેટિંગ્સ (ફરતું બિંદુ અને હાર્ટ)

પ્રોજેક્ટ 1 ચલાવતો સંપૂર્ણ સ્કેચ આ લેખની નીચે વેબસાઇટ પર આપમેળે લોડ થાય છે. અહીં આપણે ફક્ત તે મુખ્ય સેટિંગ્સ પર ધ્યાન કેન્દ્રિત કરીએ છીએ જે તમે બદલવાની શક્યતા ધરાવો છો: પિન, પિક્સેલ્સની સંખ્યા, તેજ, રંગ અને એનિમેશન ઝડપ. હાર્ટ એનિમેશન માટે આપણે એ પણ બતાવીએ છીએ કે રંગને કેવી રીતે નિયંત્રિત કરવો અને હાર્ટ ભરેલું છે કે ફક્ત રૂપરેખા છે.

LED પિન અને પિક્સેલ્સની સંખ્યા

આ મોડ્યુલ પર, 8×8 RGB મેટ્રિક્સ ESP32-S3 ના GPIO 14 સાથે જોડાયેલું છે. પિક્સેલ્સની કુલ સંખ્યા 64 (8 × 8) છે. તમારા કોડમાં, તમારે આના જેવું કંઈક જોવું જોઈએ:

 
// 8×8 RGB મેટ્રિક્સ સાથે જોડાયેલી પિન 
const int MATRIX_PIN = 14;
 // આ મોડ્યુલ પર 14 જ હોવી જોઈએ 
// LED ની કુલ સંખ્યા (8 × 8 મેટ્રિક્સ) 
const int NUMPIXELS = 64; // જો તમે અલગ મેટ્રિક્સ સાઇઝ વાપરો તો જ બદલો 

જો તમે ભૂલથી NUMPIXELS ને 16 પર છોડી દો (મૂળ NeoPixel ઉદાહરણમાંથી), તો મેટ્રિક્સનો માત્ર એક ક્વાર્ટર ઉપયોગ થશે અને એનિમેશન સંપૂર્ણ 8×8 સ્ક્રીન ભરશે નહીં.

રંગ ક્રમ અને LED પ્રકાર

વિવિધ LED સ્ટ્રીપ્સ અને મેટ્રિક્સ અલગ રંગ ક્રમ વાપરી શકે છે (ઉદાહરણ તરીકે, RGB ને બદલે GRB). આ બોર્ડ પરનું મેટ્રિક્સ RGB ક્રમની અપેક્ષા રાખે છે. NeoPixel અથવા NeoMatrix કન્સ્ટ્રક્ટરમાં, ખાતરી કરો કે રંગ પ્રકાર યોગ્ય રીતે સેટ છે:

 // NeoPixel-શૈલી ઑબ્જેક્ટ માટે ઉદાહરણ: 
Adafruit_NeoPixel pixels( NUMPIXELS, MATRIX_PIN, NEO_RGB + NEO_KHZ800 // ખાતરી કરો કે આ મેટ્રિક્સના રંગ ક્રમ સાથે મેળ ખાય છે ); 

જો તમે નોંધ કરો કે ડિસ્પ્લે પર લાલ અને લીલો અદલાબદલી થયેલા છે, તો પહેલા આ લાઇન તપાસો અને રંગ ક્રમ સુધારો.

એનિમેશન ઝડપ (પગલાં વચ્ચેનો વિલંબ)

ફરતા બિંદુની ઝડપ સામાન્ય રીતે મિલિસેકન્ડમાં સરળ વિલંબ મૂલ્ય દ્વારા નિયંત્રિત થાય છે. નાનો વિલંબ એટલે ઝડપી હિલચાલ; મોટો વિલંબ એટલે ધીમી હિલચાલ. આના જેવું ચલ જુઓ:

 
// બિંદુની હિલચાલ વચ્ચેનો વિલંબ (મિલિસેકન્ડમાં)
 int dotDelayMs = 50; // 50 ms એકદમ ઝડપી છે 

સામાન્ય ગોઠવણો:

• ખૂબ ઝડપી ફરતા બિંદુ માટે dotDelayMs = 20; સેટ કરો.
• ધીમી, શાંત એનિમેશન માટે dotDelayMs = 100; અથવા વધુ સેટ કરો.

loop() ફંક્શનમાં, આ મૂલ્ય સામાન્ય રીતે દરેક ફ્રેમ અપડેટ પછી delay(dotDelayMs); માં પસાર થાય છે.

બિંદુનો રંગ અને તેજ

ફરતા બિંદુનો RGB રંગ 0–255 ની રેન્જમાં ત્રણ મૂલ્યો દ્વારા નિયંત્રિત થાય છે (લાલ, લીલો, વાદળી). ઉદાહરણ તરીકે:

 
// બિંદુનો રંગ (R, G, B) 0–255 થી uint8_t dotRed = 255; // સંપૂર્ણ લાલ 
uint8_t dotGreen = 0; // કોઈ લીલો નહીં 
uint8_t dotBlue = 0; // કોઈ વાદળી નહીં 

આ તેજસ્વી લાલ બિંદુ ઉત્પન્ન કરશે. કેટલાક ઉપયોગી સંયોજનો:

• શુદ્ધ લાલ: (255, 0, 0)
• શુદ્ધ લીલો: (0, 255, 0)
• શુદ્ધ વાદળી: (0, 0, 255)
• પીળો: (255, 255, 0)
• સફેદ: (255, 255, 255)

એકંદર તેજ ઘણીવાર અલગ તેજ ફંક્શન દ્વારા નિયંત્રિત થાય છે:

 
// એકંદર મેટ્રિક્સ તેજ (0–255) 
uint8_t matrixBrightness = 40; // વધુ પડતી ઝગમગાટ ટાળવા માટે તેને ઓછી રાખો // setup() માં: matrix.setBrightness(matrixBrightness); 

ઘરની અંદર ઉપયોગ માટે 30–60 ની આસપાસનું મૂલ્ય સામાન્ય રીતે આરામદાયક છે.

હાર્ટ આકાર સેટિંગ્સ

ફરતા બિંદુ ઉપરાંત, બોર્ડ પ્રથમ વાર ચાલુ થાય ત્યારે તમે મેટ્રિક્સ પર નાનું હાર્ટ પ્રદર્શિત કરી શકો છો. લેખનો નમૂનો કોડ (નીચે લોડ થયેલો) આના જેવી સેટિંગ્સ શામેલ કરે છે:

 
// હાર્ટનો રંગ (ભરેલું હાર્ટ) 
uint8_t heartRed = 255; 
uint8_t heartGreen = 0; 
uint8_t heartBlue = 0; 
// વૈકલ્પિક: મેઘધનુષ્ય અથવા રૂપરેખા મોડ 
bool showOutlinedHeart = false; 
// true = ફક્ત રૂપરેખા 
bool useRainbowHeart = false; 
// true = સમય સાથે રંગો બદલો 

સામાન્ય ઉપયોગ:

• ભરેલું લાલ હાર્ટ માટે showOutlinedHeart = false; અને useRainbowHeart = false; સેટ કરો.
• ફક્ત હાર્ટની રૂપરેખા બતાવવા માટે showOutlinedHeart = true; સેટ કરો.
• મેઘધનુષ્ય અસર દ્વારા હાર્ટનો રંગ સતત બદલવા માટે useRainbowHeart = true; સેટ કરો.

હાર્ટ લેખની નીચેના કોડમાં NeoMatrix કોઓર્ડિનેટ ફંક્શનનો ઉપયોગ કરીને દોરવામાં આવે છે. તેનો દેખાવ કસ્ટમાઇઝ કરવા માટે તમારે ફક્ત ઉપરના ચલો બદલવાની જરૂર છે.

સારાંશ

પ્રોજેક્ટ 1 તમને ESP32-S3 RGB LED મેટ્રિક્સ સાથે સરળ પરંતુ શક્તિશાળી પ્રારંભિક બિંદુ આપે છે: તમે બધા 64 પિક્સેલ્સને સંબોધવાનું, રંગ નિયંત્રિત કરવાનું, તેજ ગોઠવવાનું અને એનિમેશન ઝડપ સેટ કરવાનું શીખો છો. તમે એ પણ જુઓ છો કે સમાન હાર્ડવેર પર ફરતા બિંદુથી સ્થિર અથવા એનિમેટેડ હાર્ટ પર સ્વિચ કરવું કેટલું સરળ છે.

ફરતા બિંદુ અને હાર્ટ એનિમેશનના સંપૂર્ણ, પગલું-દર-પગલાં પ્રદર્શન માટે આ પૃષ્ઠ પર એમ્બેડ કરેલો સંપૂર્ણ વિડિયો જોવાનું ભૂલશો નહીં, તેમજ બાકીના પાંચ પ્રોજેક્ટ્સ પણ. સંપૂર્ણ સ્ત્રોત કોડ આ લેખની નીચે ઉપલબ્ધ છે, અને તમે કોડ વિભાગ હેઠળ સૂચિબદ્ધ એફિલિએટ લિંક્સ દ્વારા મોડ્યુલ ખરીદીને ભવિષ્યના પ્રોજેક્ટ્સને સમર્થન આપી શકો છો.

Images

ESP32 S3 Matrix pin out

ESP32 S3 Matrix displaying green heart

ESP32 S3 Matrix displaying rainbow heart

ESP32-S3 RGB Matrix- Mobile Phone Text

ESP32-S3-Mtrix - Alway Up

ESP32 S3 Matrix pin out

ESP32 S3 Matrix displaying green heart

ESP32 S3 Matrix displaying rainbow heart

ESP32-S3 RGB Matrix- Mobile Phone Text

ESP32-S3-Mtrix - Alway Up

/* 
  Project 1: the Dot – ESP32-S3 RGB LED Matrix (Waveshare)

  dialysis a dot on scree and moves it
  
  ▶️ Video Tutorial:
  https://youtu.be/JKLuYrRcLMI

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

  QMI8658_RGB_2
*/

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
 #include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN        14 // On Trinket or Gemma, suggest changing this to 1

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS 64 // Popular NeoPixel ring size

// When setting up the NeoPixel library, we tell it how many pixels,
// and which pin to use to send signals. Note that for older NeoPixel
// strips you might need to change the third parameter -- see the
// strandtest example for more information on possible values.
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800);

#define DELAYVAL 50 // Time (in milliseconds) to pause between pixels

void setup() {
  // These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
  // Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
  clock_prescale_set(clock_div_1);
#endif
  // END of Trinket-specific code.

  pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
}

void loop() {
  pixels.clear(); // Set all pixel colors to 'off'

  // The first NeoPixel in a strand is #0, second is 1, all the way up
  // to the count of pixels minus one.
  for(int i=0; i<NUMPIXELS; i++) { // For each pixel...

    // pixels.Color() takes RGB values, from 0,0,0 up to 255,255,255
    // Here we're using a moderately bright green color:
    pixels.setPixelColor(i, pixels.Color(255, 255, 0));

    pixels.show();   // Send the updated pixel colors to the hardware.

    delay(DELAYVAL); // Pause before next pass through loop
    pixels.clear();
  }



}