დისტანციური მართვის LED თვალები და კოსტუმი: 7 ნაბიჯი (სურათებით)

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

ბეკი შტერნი ავტორის ავტორი:

შესახებ: შექმნა და გაზიარება არის ჩემი ორი უდიდესი ვნება! საერთო ჯამში მე გამოვაქვეყნე ასობით სახელმძღვანელო ყველაფრის შესახებ მიკროკონტროლერებიდან ქსოვამდე. მე ვარ ნიუ იორკის მოტოციკლისტი და მოუნანიებელი ძაღლის დედა. My wo… მეტი bekathwia- ს შესახებ »

ტყუპი ჯავა! ორმაგი ორკო! ორი მოჩვენება ჯადოქარი Bubble-Bobble– დან! ეს კოსტუმის გამწოვი შეიძლება იყოს ნებისმიერი LED- eyed არსება, რომელსაც ირჩევთ მხოლოდ ფერების შეცვლით. მე პირველად გავაკეთე ეს პროექტი 2015 წელს ძალიან მარტივი სქემით და კოდით, მაგრამ წელს მინდოდა შევქმნა განახლებული ვერსია ერთდროულად ანიმაციური კონტროლით ორ კოსტიუმზე. ეს წრე იყენებს ერთ მარტივ, ახლო მანძილზე RF დისტანციურ კონტროლს ორი მიმღების ერთი სიხშირით და Arduino კოდი იყენებს შეფერხებებს მგრძნობიარე ანიმაციის ცვლილებების მისაღწევად, ბილ ერლის სასწავლო კოდის საფუძველზე.

ამ პროექტისთვის დაგჭირდებათ:

• ორი ნეოპიქსელის სამკაული
• GEMMA M0 მიკროკონტროლი
• 315 MHz უკაბელო მიმღები, საკეტი ტიპის
• 315MHz უკაბელო RF დისტანციური ოთხი, ორი ან ერთი ღილაკის კონფიგურაციით
• სილიკონის დაფარული ძაფის მავთული (რეკომენდირებულია 30awg)
• Soldering რკინის და solder
• მავთულის სტრიპტიზატორები
• ფლეში საჭრელი
• პინცეტი
• მესამე ხელით დამხმარე ინსტრუმენტი (სურვილისამებრ)
• სამკერვალო ქინძისთავები
• მკერავის ცარცი (სურვილისამებრ)
• 19awg გალვანზირებული ფოლადის მავთული
• სქელი ქსოვილი ქუდისთვის/კონცხისთვის (ამ ვერსიისთვის მე გამოვიყენე თეთრი თამბაქოს ქსოვილის ორი ფენა და ერთი თეთრი ფაფის ქსოვილი, შემდეგ გამწოვის შიდა ნაწილი დაფარული მყარი შავი ფერით, რათა შუქი დაბლოკოს)
• გამჭვირვალე შავი ქსოვილი სახის პანელისთვის
• Საკერავი მანქანა
• Მაკრატელი
• Ნემსი და ძაფი
• 3D პრინტერი მოქნილი ძაფით (სურვილისამებრ)

იმის გასაგრძელებლად, რაზეც ვმუშაობ, გამომყევით YouTube- ზე, Instagram- ზე, Twitter- ზე, Pinterest- ზე და გამოიწერეთ ჩემი ბიულეტენი. როგორც ამაზონის ასოცირებული, მე ვიღებ შესყიდვების შესასრულებლად, რომელსაც აკეთებთ ჩემი შვილობილი ბმულების გამოყენებით.

სანამ დაიწყებთ, შეიძლება დაგჭირდეთ შემდეგი წინაპირობების წაკითხვა:

• წარმოგიდგენთ Gemma M0- ს
• NeoPixel Uberguide
• გამწოვის პროექტის პირველი ვერსია (აშენდა 2015 წელს კლასიკური გემა და უკაბელო კონტროლის გარეშე)
• Arduino pt 3 მრავალ ამოცანა

ნაბიჯი 1: წრიული დიაგრამა და კოდი

წრიული კავშირები შემდეგია:

• Gemma D2 უკაბელო მიმღებამდე D0
• Gemma D0 უკაბელო მიმღებამდე D1
• Gemma 3V უკაბელო მიმღებამდე +5V
• Gemma GND უკაბელო მიმღებამდე GND და NeoPixel სამკაულები GND
• Gemma D1 to NeoPixel Jewel data IN
• Gemma Vout to NeoPixel Jewels PWR
• NeoPixel საიუველირო მონაცემები სხვა NeoPixel Jewel მონაცემებით IN

იხილეთ შემდეგი ნაბიჯი ასამბლეის შენიშვნებისთვის.

კოდი დაფუძნებულია ბილ ერლის Arduino სკეტჩის მრავალ დავალებაზე და შეცვლილია ორი NeoPixel სამკაულის გასაკონტროლებლად ორი ციფრული შეყვანის საშუალებით. ასე რომ თქვენ არ გჭირდებათ უკაბელო მიმღების გამოყენება- თქვენ შეგიძლიათ გამოიყენოთ ღილაკები მიკროსქემის ნაცვლად. გადმოწერეთ ეს Arduino კოდის ფაილი ამ ნაბიჯის დანართებიდან, ან დააკოპირეთ და ჩასვით აქედან ცარიელ Arduino ესკიზში:

#მოიცავს "Adafruit_NeoPixel.h"

// მოდელის ტიპები მხარდაჭერილია: enum pattern {NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE}; // მამის მიმართულებები მხარდაჭერილი: enum direction {FORWARD, REVERSE}; // NeoPattern კლასი - მიღებული Adafruit_NeoPixel კლასის კლასიდან NeoPatterns: public Adafruit_NeoPixel {public: // წევრის ცვლადები: ნიმუში ActivePattern; // რომელი ნიმუში გადის მიმართულებით Direction; // მიმართულების გასაშვებად ხელმოუწერელი გრძელი ინტერვალი; // მილიწამი განახლებებს შორის ხელმოუწერელი long last Update; // პოზიციის ბოლო განახლება uint32_t ფერი 1, ფერი 2; // რა ფერები გამოიყენება uint16_t TotalSteps; // ნაბიჯების საერთო რაოდენობა ნიმუში uint16_t ინდექსი; // მიმდინარე ნაბიჯი ნიმუშის ბათილად (*OnComplete) (); // შაბლონის დასრულების გამოძახება // კონსტრუქტორი - ზარის ბაზის კლასის კონსტრუქტორი ზოლის დასაწყებად NeoPatterns (uint16_t pixels, uint8_t pin, uint8_t type, void (*callback) ()): Adafruit_NeoPixel (pixels, pin, type) {OnComplete = გადმომირეკე; } // განაახლეთ ნიმუში void განახლება () {if ((millis () - lastUpdate)> ინტერვალი) // განახლების დრო {lastUpdate = millis (); გადართვა (ActivePattern) {case RAINBOW_CYCLE: RainbowCycleUpdate (); შესვენება; საქმე THEATER_CHASE: TheaterChaseUpdate (); შესვენება; საქმე COLOR_WIPE: ColorWipeUpdate (); შესვენება; საქმე სკანერი: ScannerUpdate (); შესვენება; საქმე FADE: FadeUpdate (); შესვენება; ნაგულისხმევი: შესვენება; }}} // ინდექსის გაზრდა და ბოლოს გადატვირთვა void გადიდება () {if (Direction == FORWARD) {Index ++; if (ინდექსი> = სულ ნაბიჯები) {ინდექსი = 0; if (OnComplete! = NULL) {OnComplete (); // დარეკეთ კონკურსის შემობრუნებაზე}}} სხვა // მიმართულება == რევერსი { -ინდექსი; თუ (ინდექსი <= 0) {ინდექსი = სულ ნაბიჯები -1; if (OnComplete! = NULL) {OnComplete (); // დარეკეთ კონკურსის უკან დასაბრუნებლად}}}} // შებრუნებული შაბლონის მიმართულების ბათილობა უკუ შებრუნება () {if (Direction == FORWARD) {Direction = REVERSE; ინდექსი = TotalSteps-1; } else {მიმართულება = წინ; ინდექსი = 0; }} // ინიციალიზაცია RainbowCycle void RainbowCycle (uint8_t ინტერვალი, მიმართულება dir = FORWARD) {ActivePattern = RAINBOW_CYCLE; ინტერვალი = ინტერვალი; სულ ნაბიჯები = 255; ინდექსი = 0; მიმართულება = რეჟ; } // განაახლეთ Rainbow Cycle Pattern void RainbowCycleUpdate () {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, Wheel ((((i * 256 / numPixels ())+Index) & 255)); } ჩვენება (); გაზრდა (); } // ინიციალიზაცია თეატრისთვის Chase void TheaterChase (uint32_t ფერი 1, uint32_t ფერი 2, uint8_t ინტერვალი, მიმართულება dir = წინ) {ActivePattern = THEATER_CHASE; ინტერვალი = ინტერვალი; TotalSteps = numPixels (); ფერი 1 = ფერი 1; ფერი 2 = ფერი 2; ინდექსი = 0; მიმართულება = რეჟ; } // განაახლეთ Theatre Chase Pattern void TheaterChaseUpdate () {for (int i = 0; i <numPixels (); i ++) {if ((i+Index) % 3 == 0) {setPixelColor (i, Color1); } else {setPixelColor (i, ფერი 2); }} ჩვენება (); გაზრდა (); } // ColorWipe– ის ინიციალიზაცია void ColorWipe (uint32_t ფერი, uint8_t ინტერვალი, მიმართულება dir = FORWARD) {ActivePattern = COLOR_WIPE; ინტერვალი = ინტერვალი; TotalSteps = numPixels (); ფერი 1 = ფერი; ინდექსი = 0; მიმართულება = რეჟ; } // განაახლეთ Color Wipe Pattern void ColorWipeUpdate () {setPixelColor (ინდექსი, ფერი 1); ჩვენება (); გაზრდა (); } // სკანირების ბათილი სკანერის ინიციალიზაცია (uint32_t ფერი 1, uint8_t ინტერვალი) {ActivePattern = სკანერი; ინტერვალი = ინტერვალი; სულ ნაბიჯები = (numPixels () - 1) * 2; ფერი 1 = ფერი 1; ინდექსი = 0; } // განაახლეთ სკანერის ნიმუში void ScannerUpdate () {for (int i = 0; i > 1, მწვანე (ფერი) >> 1, ლურჯი (ფერი) >> 1); დაბრუნება dimColor; } // ყველა პიქსელის დაყენება ფერიზე (სინქრონულად) void ColorSet (uint32_t ფერი) {for (int i = 0; i> 16) & 0xFF; } // აბრუნებს 32-ბიტიანი ფერის მწვანე კომპონენტს uint8_t მწვანე (uint32_t ფერი) {return (ფერი >> 8) & 0xFF; } // აბრუნებს 32-ბიტიანი ფერის ლურჯ კომპონენტს uint8_t Blue (uint32_t ფერი) {დაბრუნების ფერი & 0xFF; } // ფერის მნიშვნელობის მისაღებად შეიყვანეთ მნიშვნელობა 0 -დან 255 -მდე. // ფერები არის გარდამავალი r - g - b - უკან r. uint32_t ბორბალი (ბაიტი WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {დაბრუნების ფერი (255 - WheelPos * 3, 0, WheelPos * 3); } else if (WheelPos <170) {WheelPos -= 85; დაბრუნების ფერი (0, WheelPos * 3, 255 - WheelPos * 3); } სხვა {WheelPos -= 170; დაბრუნების ფერი (WheelPos * 3, 255 - WheelPos * 3, 0); }}}; void JewelsComplete (); // განსაზღვრეთ რამდენიმე NeoPatterns ორი რგოლისა და ჯოხისთვის // ასევე ზოგიერთი დასრულების რუტინა NeoPatterns Jewels (14, 1, NEO_GRBW + NEO_KHZ800, & JewelsComplete); const int სიკაშკაშე = 50; // ყველაფრის ინიციალიზაცია და მომზადება void setup– ის დასაწყებად () {Serial.begin (115200); pinMode (2, INPUT); pinMode (0, INPUT); // ყველა პიქსელის ინიციალიზაცია Jewels.setBrightness (BRIGHTNESS); Jewels.bain (); // Kick off pattern Jewels. TheaterChase (Jewels. Color (255, 50, 0), Jewels. Color (0, 0, 0, 50), 100); } // მთავარი მარყუჟის ბათილი მარყუჟი () {// განაახლეთ სამკაულები. სამკაულები. განახლება (); // ღილაკების დაჭერის ნიმუშების შეცვლა: if (digitalRead (2) == HIGH) // ღილაკი #1 დაჭერით {Jewels. Color1 = Jewels. Color (255, 50, 0); Jewels. ActivePattern = FADE; Jewels. TotalSteps = 100; სამკაულები. ინტერვალი = 1; } else if (digitalRead (0) == HIGH) // ღილაკი #2 დაჭერით {Jewels. Color1 = Jewels. Color (255, 0, 0); Jewels. ActivePattern = სკანერი; Jewels. TotalSteps = Jewels.numPixels (); Jewels. Interval = 100; } else // ნორმალურ ოპერაციაზე დაბრუნება {// ყველა ნიმუშის პარამეტრების აღდგენა ნორმალურ მნიშვნელობებზე Jewels. Color1 = Jewels. Color (255, 50, 0); Jewels. ActivePattern = THEATER_CHASE; Jewels. TotalSteps = Jewels.numPixels (); Jewels. Interval = 100; }} // -------------------------------------------------- -------------- // დასრულების რუტინები-დარეკეთ ნიმუშის დასრულების შემდეგ // ---------------------- -------------------------------------- // ძვირფასეულობის დასრულება ზარის უკან დაბრუნება void JewelsComplete () {// შემთხვევითი ფერის შეცვლა შემდეგი სკანირებისთვის // Jewels. Color1 = Jewels. Wheel (შემთხვევითი (255)); სამკაულები. საპირისპირო (); }

ნაბიჯი 2: შეიკრიბეთ წრე

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

გამოიყენეთ თხელი ნაჭერი მავთულის (დაახლოებით 6 ინ/15 წთ სიგრძის) ორ ნეოპიქსელ სამკაულს შორის კავშირებისათვის (დიაგრამა წინა საფეხურზე). თუ თქვენ იყენებთ ძალიან მოკლე მავთულხლართებს, თქვენ ვერ შეძლებთ განათავსოთ თქვენი შუქდიოდური თვალები ერთმანეთისგან საკმაოდ შორს, ხოლო თუ ძალიან ბევრ მავთულს იყენებთ, ნაოჭები გაჩნდება თქვენს სახეზე კოსტუმის ჩაცმისას.

მთავარი წრე იცხოვრებს ლაპელის არეში (სადაც მკერდი ხვდება მხარზე), ასე რომ ჯაჭვში პირველ NeoPixel ძვირფასეულობასა და ჯემას შორის კავშირები, მავთულები გაცილებით გრძელი იქნება. თქვენ შეგიძლიათ დაიჭიროთ მავთული თვალის არეში და გაამახვილოთ ის მანძილზე, რომელიც უნდა გაიაროს მავთულხლართმა, შემდეგ კი დაამატეთ ცოტა მეტი სისუსტისა და დაზღვევისთვის.

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

ნაბიჯი 3: ბატარეის სიმძლავრე

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

თქვენ შეგიძლიათ მარტივად გამოიყენოთ 3xAAA დამჭერი (ჩაატარეთ იგი ჯიბეში სამაგრის შიგნით).

ნაბიჯი 4: ქსოვის ნიმუში და ქსოვის ქსოვა

მე გამოვიყენე იგივე ნიმუში, რომელიც მე შევქმენი ამ კოსტუმის პირველი ვერსიისთვის, რომელიც არის მრავალგვერდიანი PDF, რომელიც გაერთიანებულია ნიმუშის ნაჭრების შესაქმნელად.

გადაკეცეთ თქვენი ქსოვილი, გაათანაბრეთ შებუსვილი კიდეები ქსოვილის მარცვლის გასწორების მიზნით და მოათავსეთ/დადეთ ნიმუშის ნაჭრები დასაკეცი გასწვრივ, როგორც ეს აღინიშნება. მიჰყევით ნაკერების მიღებას ნიმუშის ნაჭრების გარეთ (ნაკეცის გარდა) დაახლოებით 5/8 ინ/3 სმ მარკირების ცარცის ან ფანქრის გამოყენებით. ვინაიდან ჩემი ქსოვილი თხელი იყო, მე მინდოდა მისი გაორმაგება და მას შემდეგ, რაც ორი გამწოვი გავაკეთე, მე დავამთავრე ოთხი ნიმუშის ოთხი ნაჭერი ძირითად ქსოვილში, შემდეგ კიდევ ერთი ფენა გაჟღენთილ ტანსაცმელში, რათა გარედან ტექსტურა დავამატო და საბოლოოდ შავი ქსოვილის ფენა, როგორც ლაინერი, რათა შეაფერხოს შემოსული სინათლე. მე ვფიქრობ, რომ თუ ამას წინასწარ ვგეგმავდი, შემეძლო დაეცა ერთი საწყისი თეთრი ფენა და გამწოვები ოთხის ნაცვლად მხოლოდ სამი ფენისგან შედგებოდა.

ნაბიჯი 5: შეაგროვეთ ქსოვილის ნაჭრები

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

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

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

ნაბიჯი 6: დააინსტალირეთ წრე Hood– ში

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

ჩამოიბანეთ და გაიმეორეთ, თუ მეორე თავსახურს აკეთებთ.

ნაბიჯი 7: ჩაიცვი

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

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

Მადლობა წაკითხვისთვის! თუ მოგწონთ ეს პროექტი, შეიძლება დაგაინტერესოთ ზოგიერთი სხვა:

• 13 იდეა LED- ების გავრცელებისთვის
• გაფანტული LED ზოლის ნიშანი Arduino/Bluetooth– ით
• YouTube აბონენტთა მრიცხველი ESP8266– ით
• უსასრულობის მარტივი სარკე
• 3 დამწყები არდუინოს შეცდომა

იმის გასაგრძელებლად, რაზეც ვმუშაობ, გამომყევით YouTube- ზე, Instagram- ზე, Twitter- ზე და Pinterest- ზე.