500 LED ები კედელი ESP32: 16 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:17

Გამარჯობა ყველას! ამ გაკვეთილის ბოლოს თქვენ გეცოდინებათ როგორ შექმნათ თქვენი საკუთარი LED კედელი.

ეს გაკვეთილი ემყარება საზაფხულო პროგრამას, რომელიც შემოთავაზებულია წმინდა გულის უნივერსიტეტში.

Გაერთე!

მარაგები

მასალები ქვემოთ ჩამოთვლილი.

ნაბიჯი 1: მარაგი

დავიწყოთ ყველაფრის შეგროვებით, რაც გვჭირდება ჩვენი Led Wall– ის დასასრულებლად:

(ბმულები შეიქმნა 7/10/2019)

Arduino IDE პროგრამული უზრუნველყოფა

ESP32 მიკრო კონტროლერი

LED პიქსელის შუქი

Ენერგიის წყარო

Დენის კაბელი

მავთულის გასახსნელი ინსტრუმენტი

Breadboard Jumper კაბელები

ელექტრო მავთული

ნაბიჯი 2: თქვენი LedWall- ის სწორი კვების წყაროს განსაზღვრა

არსებობს მარტივი მათემატიკური გზა იმის გასარკვევად, თუ რომელი კვების წყაროა თქვენთვის საუკეთესო.

ჩვენ ვიყენებთ ომის ძალაუფლების კანონს: P = IxV (სიმძლავრე = ინტენსივობა x ძაბვა)

ძაბვა განისაზღვრება ჩვენი LED- ებით: ამ შემთხვევაში 5V.

ინტენსივობა დამოკიდებულია აპარატურაზე, ერთი Led მოიხმარს 30mA.

თითოეული ზოლი 50 Leds მოიხმარს 50 x 30mA = 1250mA = 1.25A.

ამიტომ ჩვენი 500 Led კედელი მოიხმარს 10 -ჯერ, ვიდრე (10 ზოლები): 12.5A.

ენერგიის მოხმარება არის 5V x 12.5A = 62.5W Leds– ისთვის.

რა თქმა უნდა, Leds– ის თავზე თქვენ უნდა გაითვალისწინოთ ESP და თქვენი წრის ყველა სხვა ელემენტი.

ჩვენ გვაქვს 60A დენის წყარო, ჩვენ გვაქვს გაცილებით მეტი ვიდრე გვჭირდება.

ნაბიჯი 3: დენის კაბელი

ჩვენს ელექტრომომარაგებას გააჩნია მავთულის კონექტორები. ჩვენ უნდა მოვახდინოთ დენის კაბელის ადაპტირება 110V შტეფსელთან დასაკავშირებლად.

- გათიშეთ ქალი კონექტორი დენის კაბელიდან. ჩვენ შევინარჩუნებთ მამაკაცის ნაწილს, წინააღმდეგ შემთხვევაში ცნობილია როგორც NEMA 5-15P.

- გათიშეთ კაბელი ისე, რომ ყველა მავთულზე ჩანს დაახლოებით 3 მმ სპილენძი.

აქ არის სწრაფი ვიდეო გაკვეთილი, თუ როგორ უნდა მოიხსნას მავთულები:

ნაბიჯი 4: დენის წყაროს გაყვანილობა

ახლა ჩვენ მზად ვართ დავამყაროთ ჩვენი კვების წყარო!

ყოველთვის გამორთეთ კვების ბლოკი, როდესაც მასზე მუშაობთ.

გაყვანილობა

• შავი მავთული (ფაზა) უკავშირდება კვების ბლოკის 'L' პინს
• თეთრი მავთული (ნეიტრალური) აკავშირებს კვების ბლოკის 'N' პინს
• მწვანე მავთული უკავშირდება დენის წყაროს 'გრუნტის' პინს

(თუ თქვენი დენის კაბელის შიდა მავთულები არ არის იგივე ფერები, როგორც ჩვენი, იყავით უსაფრთხო და გადახედეთ სქემებს ინტერნეტით.)

ტესტირება

შეაერთეთ კომპიუტერის კვების კაბელი ნებისმიერ კვების ბლოკში. დენის წყაროს მწვანე LED უნდა ჩაირთოს.

ნაბიჯი 5: ჩართვა ESP32S

თქვენი ESP– ის დათვალიერებისას ყველა პინის გვერდით უნდა იყოს წარწერები. თუ ის არ არის მონიშნული, შეგიძლიათ მოძებნოთ თქვენი ინდივიდუალური ESP– ის „pinout“ინტერნეტით.

მამრობითი და მდედრობითი breadboard jumper მავთულის ან ელექტრო მავთულის გამოყენებით, დააკავშირეთ:

• "5V" ESP32S პინი კვების ბლოკის "+V" - მდე (ნარინჯისფერი ზემოთ ფოტოში)
• "GND" ESP32S პინი კვების ბლოკის "-V" განყოფილებაში (შავი ზემოთ ფოტოში)

(ზოგიერთ ESP– ზე '5V' პინი აღინიშნება, როგორც 'VCC', ისინი ორივე ერთსა და იმავეს ნიშნავს.)

გთხოვთ გაითვალისწინოთ, რომ თქვენს ESP– ს შეიძლება ჰქონდეს განსხვავებული „pinout“, ვიდრე ჩვენ ვიყენებთ. როგორც ასეთი, თქვენ შეიძლება დაუკავშიროთ თქვენი მავთულები სხვა ადგილას, ვიდრე ზემოთ მოცემულ სურათზე. სანამ თქვენ დაუკავშირდებით სწორ ქინძისთავებს (5V და GND), დაფაზე ფიზიკურ მდებარეობას მნიშვნელობა არ აქვს.

ტესტირება ისევ ჩართეთ კვების ბლოკი და თუ თქვენს ESP– ს აქვს LED ინდიკატორი (უმეტესობა აქვს), ის ანათებს იმის მანიშნებლად, რომ ენერგია იგზავნება ESP– ზე. გილოცავთ!

ნაბიჯი 6: LED სინათლის ზოლების ჩართვა

ელექტრო მავთულის გამოყენება:

- შეაერთეთ LED სინათლის ზოლის წითელი მავთული V+ დენის წყაროსთან.

- შეაერთეთ LED სინათლის ზოლის ლურჯი მავთული V- დენის წყაროსთან.

ნაბიჯი 7: ESP32- ის დაკავშირება LED სინათლის ზოლებთან

ჩვენი ESP32 აცნობებს WS2811 დრაივერს, რომელიც დაკავშირებულია თითოეულ მათგანთან.

Leds– ის ზოლები მოდის 3 მავთულის კონექტორით:

- წითელი: ძალა- ლურჯი: ნეიტრალური- თეთრი: მონაცემები

მოდით დავუკავშიროთ თეთრი Led ზოლის კაბელი ESP- ის ციფრულ პინს. გთხოვთ, დაიმახსოვროთ PIN ნომერი შერჩეული, რადგან ჩვენ დაგვჭირდება მისი კოდში შესარჩევად. ჩვენ შევაერთეთ ჩვენი პინ 13.

ნაბიჯი 8: კომპიუტერის მომზადება: C2102 დრაივერი

ახლა, როდესაც ჩვენი აპარატურა არის სადენიანი, ჩვენ გვინდა, რომ ატვირთოთ ჩვენი პირველი კოდი მის შესამოწმებლად. სტანდარტულად, Windows ან MacOs ვერ დაუკავშირდება ჩვენს ESP32- ს. ამისათვის ჩვენ უნდა გადმოვწეროთ "მძღოლი" ESP USB საკომუნიკაციო ჩიპისთვის: C2102.

ეს დრაივერი უნდა გადმოწერილი და დაინსტალირებული:

- Windows 10: https://www.silabs.com/documents/public/software/C…- Windows 7/8/8.1: https://www.silabs.com/documents/public/software/C…- Mac:

(ბმულები 7/10/2019)

ნაბიჯი 9: Arduino პროგრამული უზრუნველყოფა - ESP32 მხარდაჭერის დამატება - ნაბიჯი 1

სანამ ჩვენ შეგვიძლია გამოვიყენოთ ჩვენი ESP32 Arduino პროგრამულ უზრუნველყოფასთან ერთად, ჩვენ უნდა დავრწმუნდეთ, რომ ის არის აღიარებული. სტანდარტულად, Arduino პროგრამულ უზრუნველყოფას არ შეუძლია შეადგინოს კოდი ჩვენი ESP32– ისთვის, მოდით გავასწოროთ ის:

ნაბიჯი 1: მენეჯერის დაფების დამატება

1 - დააწკაპუნეთ არდუინოში, ვარიანტი ფაილი >> პარამეტრები

2- "დამატებითი დაფების მენეჯერის მისამართები" ველში დააკოპირეთ შემდეგი ბმული:

ნაბიჯი 10: Arduino პროგრამული უზრუნველყოფა - ESP32 მხარდაჭერის დამატება - ნაბიჯი 2

ახლა, როდესაც Arduino პროგრამამ "იცის" მეტი დაფა, მოდით დავაყენოთ ჩვენი ESP32 მხარდაჭერა

ნაბიჯი 2: დააინსტალირეთ ESP32 მხარდაჭერა

1 - ზედა მენიუში აირჩიეთ: ინსტრუმენტები >> დაფა >> დაფების მენეჯერი

2 - გამოჩნდება ფანჯარა. გამოიყენეთ საძიებო ველი, რომელიც მდებარეობს ზედა მარჯვენა კუთხეში, რომ იპოვოთ "ESP32".

3 - იპოვნეთ espressif– ის მიერ დამზადებული. დააინსტალირეთ. (იხილეთ სურათი)

ნაბიჯი 11: Arduino პროგრამული უზრუნველყოფა - ESP32 მხარდაჭერის დამატება - ნაბიჯი 3

ახლა, როდესაც Arduino პროგრამულ უზრუნველყოფას შეუძლია დაუკავშირდეს ჩვენს ESP32- ს, მოდით შევაერთოთ იგი კომპიუტერთან და შევამოწმოთ, რომ ყველაფერი მუშაობს.

1 - დავრწმუნდეთ, რომ ჩვენ ვმუშაობთ ESP32 პლატფორმაზე:

დააწკაპუნეთ ინსტრუმენტებზე >> დაფაზე >> ESP32 Dev Module

1- დავრწმუნდეთ, რომ Arduino პროგრამულმა პროგრამამ იცის როგორ დაუკავშირდეს ჩვენს ESP– ს:

დააწკაპუნეთ ინსტრუმენტებზე >> პორტი და შეარჩიეთ ის, რომელიც გამოჩნდება ამ კაბელის ჩართვისას.

Მნიშვნელოვანი:

თუ თქვენ გაქვთ რაიმე პრობლემა კოდის ატვირთვისას თქვენს ESP– ში, ჯერ შეამოწმეთ ეს ორი მენიუ. თუ პორტი არ არის არჩეული გამშვები ნიშნით, მაშინ Arduino პროგრამული უზრუნველყოფა არ დაუკავშირდება მას.

ნაბიჯი 12: ბიბლიოთეკების დამატება Arduino IDE– ში

ახლა ჩვენ ვაპირებთ დავამატოთ ბიბლიოთეკა, რომელიც საშუალებას მოგვცემს შევამოწმოთ ჩვენი Led Wall!

1- დააწკაპუნეთ ინსტრუმენტებზე >> ბიბლიოთეკების მართვა.

2- ზედა მარჯვენა კუთხეში მოძებნეთ NeoPixelBus. იპოვეთ "NeoPixelBus by Makuna", დააინსტალირეთ (იხილეთ სურათი)

სხვა პოტენციური საინტერესო ბიბლიოთეკები: (არ არის საჭირო ამ გაკვეთილისთვის)

- ნეომატრიქსი

- FastLed

- არტნეტი

- GFX

ნაბიჯი 13: პირველი კოდი: Strand ტესტი

ჩვენი პირველი კოდი არის ბიბლიოთეკის მაგალითი.

თქვენ შეგიძლიათ დააკოპიროთ / ჩასვათ კოდი ქვემოთ ან დააწკაპუნოთ:

ფაილი >> მაგალითები >> Adafruit NeoPixelBus >> Strandtest

გთხოვთ, დარწმუნდეთ, რომ შეცვალეთ თქვენი LED_PIN ის, რასაც იყენებდით თქვენი led– ების ფიზიკურად დასაკავშირებლად. ჩვენ გამოვიყენეთ 13 ამ გაკვეთილის განმავლობაში.

ასევე დარწმუნდით, რომ ადაპტირებთ ძაფის ზომას LED_COUNT ცვლადთან.

// ძირითადი ყოველდღიური LED Striptest პროგრამა.

#მოიცავს #ifdef _AVR_ #მოიცავს // საჭიროა 16 MHz Adafruit Trinket #endif // Arduino– ს რომელი პინია დაკავშირებული NeoPixels– თან? #განსაზღვრეთ LED_PIN 13 // რამდენი NeoPixel ერთვის არდუინოს? #განსაზღვრეთ LED_COUNT 500 // გამოაცხადეთ ჩვენი NeoPixel ზოლის ობიექტი: Adafruit_NeoPixel ზოლები (LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); // არგუმენტი 1 = პიქსელების რაოდენობა NeoPixel ზოლში // არგუმენტი 2 = Arduino pin ნომერი (უმეტესობა მოქმედებს) // არგუმენტი 3 = პიქსელის ტიპის დროშები, საჭიროებისამებრ დაამატეთ: // NEO_KHZ800 800 KHz ბიტ -სტრიმი (ყველაზე NeoPixel პროდუქტები w/ WS2812 LED- ები // NEO_KHZ400 400 KHz (კლასიკური 'v1' (არა v2) FLORA პიქსელი, WS2811 დრაივერი) // NEO_GRB პიქსელები სადენიანია GRB ბიტრემისთვის (უმეტესობა NeoPixel პროდუქტებით) // NEO_RGB პიქსელები მავთულხლართულია RGB ბიტრემისთვის (v1 FLORA პიქსელი, არა v2) // NEO_RGBW პიქსელები მიერთებულია RGBW ბიტრემისთვის (NeoPixel RGBW პროდუქტები) // setup () ფუნქცია-მუშაობს გაშვებისას ერთხელ -------------------- ------------ void setup () {// ეს ხაზები სპეციალურად არის Adafruit Trinket 5V 16 MHz მხარდაჭერისთვის. // ნებისმიერი სხვა დაფა, შეგიძლიათ ამოიღოთ ეს ნაწილი (მაგრამ მისი დატოვება არანაირ ზიანს არ აყენებს): #თუ განსაზღვრულია (_ AVR_ATtiny85_) && (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Trinket- ის სპეციფიკური კოდის დასასრული. ზოლები. დაწყება (); // ინიციალიზაცია NeoPixel ზოლის ობიექტი (საჭირო) strip.show (); // გამორთეთ ყველა პიქსელი ASAP strip.setBrightness (50); // დააყენეთ BRIGHTNESS დაახლოებით 1/5 (max = 255)} // loop () ფუნქცია-გადის არაერთხელ, სანამ დაფა ჩართულია --------------- void loop () {// შეავსეთ ზოლის სიგრძის გასწვრივ სხვადასხვა ფერები… colorWipe (ზოლები. ფერი (255, 0, 0), 50); // წითელი ფერი Wipe (ზოლები. ფერი (0, 255, 0), 50); // მწვანე ფერი Wipe (ზოლები. ფერი (0, 0, 255), 50); // ცისფერი // შეასრულეთ თეატრის ეფექტი სხვადასხვა ფერებში… theaterChase (strip. Color (127, 127, 127), 50); // თეთრი, ნახევრად სიკაშკაშის თეატრი Chase (ზოლები. ფერი (127, 0, 0), 50); // წითელი, ნახევრად სიკაშკაშის თეატრი Chase (ზოლები. ფერი (0, 0, 127), 50); // ცისფერი, ნახევრად სიკაშკაშის ცისარტყელა (10); // ცისარტყელას ციკლი მთელი ზოლის თეატრის გასწვრივ ChaseRainbow (50); // Rainbow- ით გაძლიერებული theaterChase ვარიანტი} // ჩვენი ზოგიერთი ფუნქცია ანიმაციური ეფექტების შესაქმნელად ----------------- // შეავსეთ ზოლების პიქსელები ერთმანეთის მიყოლებით ფერის. ზოლები არ არის გასუფთავებული // პირველი; ყველაფერი იქ დაფარული იქნება პიქსელი პიქსელით. გაიაროს ფერი // (როგორც ერთი "შეფუთული" 32 ბიტიანი მნიშვნელობა, რომელიც შეგიძლიათ მიიღოთ // ზოლზე დარეკვით. ფერი (წითელი, მწვანე, ლურჯი) როგორც ეს ნაჩვენებია მარყუჟში () ზემოთ), // და ა შეფერხების დრო (მილიწამებში) პიქსელებს შორის. void colorWipe (uint32_t ფერი, int ლოდინი) {for (int i = 0; i strip.setPixelColor (i, ფერი); // პიქსელის ფერის დაყენება (RAM- ში) strip.show (); // განახლების ზოლის შეფერხების შესატყვისი (დაელოდეთ); // ერთი წუთით პაუზა}} // თეატრის მარკის სტილის შუქების დევნა. გაიარეთ ფერი (32 ბიტიანი მნიშვნელობა, // a la strip. ფერი (r, g, b) როგორც ზემოთ აღინიშნა), და დაყოვნების დრო (ms) // ჩარჩოებს შორის. void theaterChase (uint32_t ფერი, int ლოდინი) {for (int a = 0; a <10; a ++) {// გაიმეორეთ 10 -ჯერ… for (int b = 0; b <3; b ++) {// 'b' ითვლის 0 -დან 2 -მდე… strip.clear (); // RAM- ში ყველა პიქსელის დაყენება 0 -ზე (გამორთული) // 'c' ითვლის 'b' -დან ბოლომდე ზოლები 3 საფეხურით… for (int c = b; c strip.setPixelColor (c, ფერი); // დააწესეთ pixel 'c' მნიშვნელობის 'ფერი'} strip.show (); // ზოლის განახლება ახალი შინაარსის დაყოვნებით (დაელოდეთ); // პაუზა ერთი წუთით}}} // ცისარტყელას ციკლი მთელი ზოლის გასწვრივ. გაიარეთ შეფერხების დრო (ms) ჩარჩოებს შორის. void rainbow (int ლოდინი) {// პირველი პიქსელის ელფერი გადის 5 სრულ მარყუჟს შორის ფერადი ბორბალი. // ფერთა ბორბალს აქვს 65536 დიაპაზონი, მაგრამ ეს არის კარგი, თუ გადავაბრუნებთ, ასე რომ // უბრალოდ დაითვალეთ 0 -დან 5 -მდე*65536. ყოველ ჯერზე 256 -ის დამატება firstPixelHue // ნიშნავს, რომ ჩვენ გავაკეთებთ 5*65536/256 = 1280 გადის ამ გარე მარყუჟში: for (long firstPixelHue = 0; firstPixelHue <5*65536; firstPixelHue += 256) {for (int i = 0; I. i * 65536L / strip.numPixels ()); // strip. ColorHSV () შეიძლება მიიღოს 1 ან 3 არგუმენტი: ელფერი (0 -დან 65535 -მდე) ან // სურვილისამებრ დაამატოთ გაჯერება და მნიშვნელობა (სიკაშკაშე) (თითოეული 0 -დან 255 -მდე). // აქ ჩვენ ვიყენებთ მხოლოდ ერთი არგუმენტის ელფერით ვარიანტს. შედეგი // გადადის strip.gamma32 ()-ში, რათა უზრუნველყოს "ჭეშმარიტი" ფერები // თითოეული პიქსელისთვის მინიჭებამდე: strip.setPixelColor (i, strip.gamma32 (strip. ColorHSV (pixelHue)));} strip.show (); // განაახლეთ ზოლები ახალი შინაარსით დაგვიანებით (დაელოდეთ); // ერთი წუთით პაუზა}} // Rainbow- ით გაძლიერებული თეატრის საყრდენი. გაიარეთ დაგვიანების დრო (in ms) ჩარჩოებს შორის. void theaterChaseRainbow (int ელოდება) {i nt პირველიPixelHue = 0; // პირველი პიქსელი იწყება წითელიდან (ტონი 0) for (int a = 0; a <30; a ++) {// გაიმეორეთ 30 -ჯერ… (int b = 0; b RGB strip.setPixelColor (c, ფერი); / / დააყენეთ პიქსელი 'c' მნიშვნელობის 'ფერი'} strip.show (); // განაახლეთ ზოლები ახალი შინაარსის დაყოვნებით (დაელოდეთ); // პირველი პაუზა ერთი წუთით PixelHue += 65536 /90; // ფერადი ბორბლის ერთი ციკლი 90 -ზე მეტი ჩარჩო}}}

ნაბიჯი 14: SHU ნიმუშის კოდი

ჩვენი კოდი ჩართავს ყველა Led- ს სათითაოდ, რომ დარწმუნდეს რომ ისინი მუშაობენ:

// ეს მაგალითი ციკლდება 500 პიქსელის წითლად ჩვენებას შორის

#includeconst uint16_t PixelCount = 500; // ეს მაგალითი ითვალისწინებს 4 პიქსელს, რაც უფრო მცირე გახდება გამოიწვევს უკმარისობას const uint8_t PixelPin = 13; // დარწმუნდით, რომ დააყენეთ ეს სწორი პინზე, იგნორირებულია Esp8266– ისთვის

#განსაზღვრეთ ფერი გაჯერება 128 // სამი ელემენტის პიქსელი, სხვადასხვა თანმიმდევრობით და სიჩქარით

NeoPixelBus ზოლები (PixelCount, PixelPin);

// NeoPixelBus ზოლები (PixelCount, PixelPin); Rgb ფერი წითელი (0, ფერი გაჯერება, 0); RgbColor მწვანე (ფერი გაჯერება, 0, 0); Rgb ფერი ლურჯი (0, 0, ფერი გაჯერება); RgbColor თეთრი (ფერი გაჯერება); RgbColor შავი (0); HslColor hslRed (წითელი); HslColor hslGreen (მწვანე); HslColor hslBlue (ლურჯი); HslColor hsl თეთრი (თეთრი); HslColor hslBlack (შავი); void setup () {Serial.begin (115200) while (! Serial); // დაელოდეთ სერიულ მიმაგრებას Serial.println (); Serial.println ("ინიციალიზაცია …"); Serial.flush (); // ეს აღადგენს ყველა ნეოპიქსელს გამორთვის მდგომარეობის ზოლზე. დაწყება (); ზოლები. ჩვენება (); Serial.println (); Serial.println ("გაშვებული …"); } void loop () {დაგვიანებით (100); Serial.println ("ფერები R, G, B, W …"); for (int i = 0; i <= 499; i ++) {// დააყენეთ ფერები, // თუ ისინი არ ემთხვევა წესრიგს, თქვენ უნდა გამოიყენოთ NeoGrbFeature ფუნქციის ზოლები. SetPixelColor (i, წითელი); ზოლები. ჩვენება (); დაგვიანება (100); ზოლები. SetPixelColor (i, hslRed); ზოლები. ჩვენება (); დაგვიანება (100); }}

ნაბიჯი 15: კოდის ატვირთვა ESP32– ში

Მნიშვნელოვანი:

იმისათვის, რომ შეძლოთ კოდის ატვირთვა ნებისმიერ მიკრო კონტროლერზე, ის უნდა იყოს პროგრამირების რეჟიმში. უმეტესობა ამას ავტომატურად აკეთებს და თქვენ მხოლოდ უნდა დააჭიროთ პროგრამულ უზრუნველყოფაში ატვირთვას.

ჩვენი ESP32 მოითხოვს, რომ დაიჭიროთ პროგრამირების ღილაკი კოდის გაგზავნისას. თქვენ ასევე გჭირდებათ მისი გადატვირთვა კოდის ატვირთვის შემდეგ გადატვირთვის ღილაკზე დაჭერით.

ჩვენი ESP32 პროგრამირების ღილაკი მდებარეობს მარცხნივ, გადატვირთვის ღილაკი მარჯვნივ. გთხოვთ მიმართოთ თქვენს სახელმძღვანელოს, თუ სხვა მიკროკონტროლი გაქვთ.

ნაბიჯი 16: ციტატები

ეს ინსტრუქცია გაკეთდა შემდეგი გაკვეთილების დახმარებით:

randomnerdtutorials.com/installing-the-esp…

გამოიყენება ESP32– ის ინსტალაციისთვის Arduino IDE– ში.

ავტორები:

ნატანიელ ბარონე გაბრიელ კასტრო

რედაქტორი:

სედრიკ ბლეიმლინგი