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 LEDகள்), பின்புறத்தில் QMI8658C மோஷன் சென்சார் மற்றும் மின்சாரம் மற்றும் நிரலாக்கத்திற்கான USB போர்ட் ஆகியவற்றுடன் இணைக்கப்பட்டுள்ளது.

இந்த தொகுதியின் முக்கிய அம்சங்கள்:

• ESP32-S3 Wi-Fi மற்றும் புளூடூத் ஆதரவுடன் இரட்டை-கோர் மைக்ரோகண்ட்ரோலர்.
• 8×8 RGB LED மேட்ரிக்ஸ் (64 RGB LEDகள்) பலகையின் முன்புறத்தில், ஐகான்கள், உரை மற்றும் சிறிய விளையாட்டுகளுக்கு ஏற்றது.
• 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 ஐ திறந்து File > Preferences க்கு செல்லவும்.
2. “Additional Boards Manager URLs” புலத்தில், அதிகாரப்பூர்வ ESP32 பலகைகள் URL ஐ சேர்க்கவும்.
3. Tools > Board > Boards Manager… ஐ திறந்து, ESP32 ஐ தேடி, ESP32 பலகைகளுக்கான தொகுப்பை நிறுவவும்.
4. நிறுவிய பிறகு, Tools > Board க்கு சென்று உங்கள் ESP32-S3 RGB மேட்ரிக்ஸ் தொகுதிக்கான சரியான பலகை உள்ளீட்டை தேர்ந்தெடுக்கவும்.
5. பலகையை USB வழியாக இணைத்து, Tools > Port இன் கீழ் அதன் சீரியல் போர்ட்டை தேர்ந்தெடுக்கவும்.

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

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

LED மேட்ரிக்ஸ் உள்ளே Adafruit NeoPixel இயக்கியைப் பயன்படுத்துகிறது, மேலும் எளிதான 2D வரைபடத்திற்காக Adafruit NeoMatrix நூலகத்தைப் பயன்படுத்துகிறோம். NeoMatrix ஐ நிறுவுவது தானாகவே சார்புகளை இழுக்கும்.

NeoMatrix மற்றும் சார்புகள்

நூலக மேலாளரிடமிருந்து பின்வருவனவற்றை நிறுவவும்:

• Adafruit NeoMatrix
• Adafruit NeoPixel
• Adafruit GFX Library

நூலக மேலாளரில்:

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

QMI8658C மோஷன் சென்சார் நூலகம் (பிற்கால திட்டங்களுக்கு)

திட்டம் 1 முடுக்கமானியை நேரடியாகப் பயன்படுத்தாது, ஆனால் இப்போதே மோஷன் சென்சார் நூலகத்தை நிறுவுவது நல்லது, ஏனெனில் இது திட்டங்கள் 4, 5 மற்றும் 6 க்கு தேவைப்படும்.

நூலக மேலாளரிடமிருந்து:

1. QMI8658 நூலகத்தை அதன் ஆசிரியர் பெயரால் தேடவும்.
2. விரைவான சோதனைக்காக File > Examples இன் கீழ் தோன்றும் வகையில் நூலகத்தை நிறுவவும்.

திட்டம் 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 பிக்சல்களையும் எவ்வாறு அணுகுவது, நிறத்தை கட்டுப்படுத்துவது, பிரகாசத்தை சரிசெய்வது, மற்றும் அனிமேஷன் வேகத்தை அமைப்பது என்பதை நீங்கள் கற்றுக்கொள்கிறீர்கள். அதே வன்பொருளில் நகரும் புள்ளியிலிருந்து நிலையான அல்லது அனிமேஷன் இதயத்திற்கு மாறுவது எவ்வளவு எளிது என்பதையும் நீங்கள் பார்க்கிறீர்கள்.

நகரும் புள்ளி மற்றும் இதய அனிமேஷன்களின் முழுமையான, படிப்படியான ஆர்ப்பாட்டத்திற்காக இந்த பக்கத்தில் உட்பொதிக்கப்பட்ட முழு வீடியோவைப் பார்க்க மறக்காதீர்கள், மீதமுள்ள ஐந்து புராஜெக்ட்களுடன். முழு மூல குறியீடு இந்த கட்டுரைக்கு கீழே கிடைக்கிறது, மேலும் குறியீடு பிரிவின் கீழ் பட்டியலிடப்பட்டுள்ள இணைப்பு இணைப்புகள் மூலம் தொகுதியை வாங்குவதன் மூலம் எதிர்கால புராஜெக்ட்களை ஆதரிக்கலாம்.

படங்கள்

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



}