ინტერაქტიული გეოდეზიური LED გუმბათი: 15 ნაბიჯი (სურათებით)

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

მე ავაშენე გეოდეზიური გუმბათი, რომელიც შედგება 120 სამკუთხედისგან, LED და სენსორი თითოეულ სამკუთხედში. თითოეული LED შეიძლება მიმართოს ინდივიდუალურად და თითოეული სენსორი მორგებულია სპეციალურად ერთი სამკუთხედისთვის. გუმბათი დაპროგრამებულია Arduino– ით, რომ აანთოს და აწარმოოს MIDI სიგნალი იმისდა მიხედვით, თუ რომელ სამკუთხედს დადებთ ხელს.

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

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

LED მაგიდები და კუბურები:

www.instructables.com/id/RGB-LED-Pixel-Touc…

www.instructables.com/id/Touch-LED-Table-Re…

www.instructables.com/id/Led-Cube-8x8x8/

www.instructables.com/id/500-LED-Pixel-RGB-…

გეოდეზიური გუმბათი:

www.instructables.com/id/Folding-Geodesic-D…

www.instructables.com/id/Geodesic-dome-kit/

ნაბიჯი 1: მიწოდების სია

მასალები:

1. ხე გუმბათის საყრდენებისთვის და გუმბათის ფუძისთვის (რაოდენობა დამოკიდებულია გუმბათის ტიპზე და ზომაზე)

2. მიმართვადი LED ზოლები (16.4ft/5m Addressable ფერი LED Pixel Strip 160leds Ws2801 Dc5v)

3. არდუინო უნო (Atmega328 - აწყობილი)

4. პროტოტიპის დაფა (Penta Angel Double-Side Prototype PCB Universal (7x9 სმ))

5. აკრილის გამადიდებელი შუქდიოდური ნათურები (ჩამოსხმული აკრილის ფურცელი, გამჭვირვალე, 12 "x 12" x 0.118 "ზომა)

6. კვების ბლოკი (Aiposen 110/220V to DC12V 30A 360W Switch Power Supply Driver)

7. Buck კონვერტორი Arduino– სთვის (RioRand LM2596 DC-DC Buck Converter 1.23V-30V)

8. Buck კონვერტორი LED- ებისთვის და სენსორებისთვის (DROK Mini Electric Buck Voltage Converter 15A)

9. 120 IR სენსორი (ინფრაწითელი დაბრკოლების თავიდან აცილების სენსორის მოდული)

10. ხუთი 16 არხიანი მულტიპლექსერი (ანალოგური/ციფრული MUX Breakout - CD74HC4067)

11. ექვსი 8 არხიანი მულტიპლექსერი (Multiplexer Breakout - 8 Channel (74HC4051))

12. ხუთი 2 არხიანი მულტიპლექსერი (MAX4544CPA+)

13. მავთულის გადატანა

14. შემაერთებელი მავთული (მყარი ბირთვი, 22 AWG)

15. Pin Headers (Gikfun 1 x 40 Pin 2.54mm Single Row Breakaway Male Pin Header)

16. ხუთი MIDI ბუდე (Breadboard-friendly MIDI Jack (5-pin DIN))

17. ათი 220ohm რეზისტორი MIDI ჯეკებისთვის

18. დგომა შუასადებები ელექტრონიკის გუმბათზე დასაყენებლად (Stand-off Spacer Hex M3 მამაკაცი x M3 ქალი)

19. ძაფის გადამყვანები სადგამებთან დასაკავშირებლად (E-Z Lok ხრახნიანი ჩასმა, თითბერი, დანის ძაფი)

20. ეპოქსიდური ან გორილა სუპერწებო

21. ელექტრო ფირზე

22. ჯარისკაცი

ინსტრუმენტები:

1. შედუღების სადგური

2. დენის საბურღი

3. წრიული ხერხი

4. ორბიტალური სანდრი

5. ჯიგმა დაინახა

6. მიტრის ხერხი

7. პროტრაქტორი

8. 3D პრინტერი

9. მავთულის საჭრელი

10. მავთულის შესაფუთი ინსტრუმენტი

11. ლაზერული საჭრელი LED ფირფიტების დასაჭრელად (სურვილისამებრ)

12. CNC მაღაზიის ბოტი გუმბათის ბაზისთვის (სურვილისამებრ)

ნაბიჯი 2: გეოდეზიური გუმბათის დიზაინი

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

მე გამოვიყენე საიტი სახელწოდებით Domerama, რათა დამეხმარებინა 4V გუმბათის შემუშავებაში, რომელიც მოწყვეტილი იყო სფეროს 5/12, 40 სმ რადიუსით. ამ ტიპის გუმბათისთვის არის ექვსი განსხვავებული სიგრძის საყრდენი:

30 X "A" - 8.9 სმ

30 X "B" - 10.4 სმ

50 X “C” - 12.4 სმ

40 X "D" - 12.5 სმ

20 X "E" - 13.0 სმ

20 X "F" - 13.2 სმ

ეს არის სულ 190 საყრდენი, რომელიც ამატებს 2223 სმ (73 ფუტი) მასალას. მე გამოვიყენე 1x3 (3/4 "× 2-1/2") ფიჭვის ხე ამ გუმბათის საყრდენებისთვის. საყრდენების დასაკავშირებლად, მე შევქმენი და 3D დაბეჭდილი კონექტორები Autocad– ის გამოყენებით. STL ფაილების ჩამოტვირთვა შესაძლებელია ამ ნაბიჯის ბოლოს. კონექტორების რაოდენობა 4V 5/12 გუმბათისთვის არის:

20 X 4 კონექტორი

6 X 5 კონექტორი

45 X 6-კონექტორი

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

ნაბიჯი 3: გუმბათის აგება საყრდენებითა და კონექტორებით

4V 5/12 გუმბათისთვის დომერამადან გამოთვლების გამოყენებით, მე წრიული ხერხის გამოყენებით დავჭერი. 190 საყრდენი ეტიკეტირებული იყო და მოთავსებული იყო ყუთში ჭრის შემდეგ. 71 კონექტორი (20 ოთხკონექტორი, 6 ხუთ კონექტორი და 45 ექვსკონექტორი) 3D ბეჭდვა იყო მაკერბოტის გამოყენებით. ხის საყრდენები ჩასმული იყო კონექტორებში დომერამას მიერ შექმნილი დიაგრამის მიხედვით. მე დავიწყე მშენებლობა ზემოდან და რადიალურად გადავედი გარედან.

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

ნაბიჯი 4: ბაზის ფირფიტების ლაზერული ჭრა და მონტაჟი

ახლა, როდესაც გუმბათის ჩონჩხი აგებულია, დროა სამკუთხა საყრდენების მოჭრა. ეს ფირფიტები მიმაგრებულია საყრდენების ბოლოში და გამოიყენება გუმბათზე LED- ების დასაყენებლად. თავდაპირველად 5 მმ (3/16”) სისქის პლაივუდიდან ამოვიღე დაფები ხუთი განსხვავებული სამკუთხედის გაზომვით, რომლებიც გუმბათზეა: AAB (30 სამკუთხედი), BCC (25 სამკუთხედი), DDE (20 სამკუთხედი), CDF (40 სამკუთხედი)) და EEE (5 სამკუთხედი). თითოეული მხარის ზომები და სამკუთხედების ფორმა განისაზღვრა გუმბათის კალკულატორის (დომერამა) და ზოგიერთი გეომეტრიის გამოყენებით. სატესტო ფირფიტების jigsaw– ით მოჭრის შემდეგ, მე დავხატე სამკუთხედის დიზაინი Coral Draw– ის გამოყენებით და დანარჩენი დაფები დავჭრა ლაზერული საჭრელით (ბევრად უფრო სწრაფად!). თუ თქვენ არ გაქვთ წვდომა ლაზერულ საჭრელზე, შეგიძლიათ დაფაზე დაფაროთ პლაივუდი მმართველი და პროტრაქტორის გამოყენებით და ყველა მათგანი მოჭერით ხერხით. მას შემდეგ, რაც დაფები იჭრება, გუმბათი გადაბრუნდება და ფირფიტები გუმბათზე ხის წებოს გამოყენებით არის მიბმული.

ნაბიჯი 5: ელექტრონიკის მიმოხილვა

ზემოთ მოცემულ ფიგურაში ნაჩვენებია გუმბათის ელექტრონიკის სქემატური სქემა. Arduino Uno გამოიყენება გუმბათის სიგნალების დასაწერად და წასაკითხად. გუმბათის გასანათებლად, RGB LED ზოლი გადადის გუმბათზე ისე, რომ LED განთავსდეს 120 სამკუთხედის თითოეულ მათგანზე. ინფორმაციისთვის, თუ როგორ მუშაობს LED ზოლები, გადახედეთ ამ ინსტრუქციას. თითოეული LED შეიძლება ცალკე იყოს მიმართული Arduino– ს გამოყენებით, რომელიც აწარმოებს სერიულ მონაცემებს და საათის სიგნალს ზოლისთვის (იხ. A0 და A1 pin სქემატურ სქემაში). ზოლით და მხოლოდ ამ ორი სიგნალით, შეგიძლიათ გქონდეთ გასაოცარი განათების გუმბათი. არსებობს სხვა გზები არდუინოს მრავალი LED სიგნალის დასაწერად, როგორიცაა Charlieplexing და ცვლის რეგისტრები.

გუმბათთან ურთიერთობის მიზნით, მე დავაყენე IR სენსორი თითოეული LED- ის ზემოთ. ეს სენსორები გამოიყენება იმის დასადგენად, როდესაც ვიღაცის ხელი გუმბათზე სამკუთხედთან არის ახლოს. იმის გამო, რომ გუმბათის თითოეულ სამკუთხედს აქვს საკუთარი IR სენსორი და არის 120 სამკუთხედი, არდუინოს წინ მოგიწევთ რაიმე სახის მულტიპლექსირების გაკეთება. მე გადავწყვიტე გამოვიყენო ხუთი 24-არხიანი მულტიპლექსერი (MUX) გუმბათზე 120 სენსორისთვის. აქ არის ინსტრუქცია მულტიპლექსირების შესახებ, თუ თქვენ არ იცნობთ. 24 არხიანი MUX მოითხოვს ხუთ საკონტროლო სიგნალს. მე ავირჩიე 8-12 პინდი არდუინოზე, ასე რომ შემეძლო გამეკეთებინა პორტის მანიპულირება (იხ. ნაბიჯი 10 დამატებითი ინფორმაციისათვის). MUX დაფების გამომუშავება იკითხება ქინძისთავების გამოყენებით 3-7.

მე ასევე ჩავრთე ხუთი MIDI გამომავალი გუმბათზე ისე, რომ მას შეეძლო ხმის გამომუშავება (ნაბიჯი 11). სხვა სიტყვებით რომ ვთქვათ, ხუთ ადამიანს შეუძლია გუმბათის დაკვრა ერთდროულად, თითოეული გამოსვლისას განსხვავებული ხმით. Arduino– ზე არის მხოლოდ ერთი TX პინი, ამიტომ ხუთი MIDI სიგნალი მოითხოვს დემულტიპლექსს. იმის გამო, რომ MIDI გამომავალი იწარმოება სხვა დროს, ვიდრე IR სენსორის კითხვა, მე იგივე კონტროლის სიგნალები გამოვიყენე.

მას შემდეგ, რაც IR სენსორის ყველა შესასვლელი წაიკითხება არდუინოში, გუმბათს შეუძლია აანთოს და დაუკრა ბგერები, თუმცა არდუინოს პროგრამით. მე მაქვს რამდენიმე მაგალითი ამ სასწავლო ინსტრუქციის მე –14 ნაბიჯში.

ნაბიჯი 6: LED- ების დამონტაჟება გუმბათზე

იმის გამო, რომ გუმბათი იმდენად დიდია, LED ზოლები უნდა გაიჭრას, რათა თითოეულ სამკუთხედზე ერთი LED განთავსდეს. თითოეული LED არის წებოვანი სამკუთხედზე სუპერ წებოს გამოყენებით. შუქდიოდის ორივე მხარეს, ხვრელი იჭრება საბაზისო ფირფიტაზე, რათა კაბელებმა გაიარონ გუმბათი. შემდეგ გავამაგრე დამაკავშირებელი მავთული LED- ზე თითოეულ კონტაქტზე (5V, მიწა, საათი, სიგნალი) და ვკვებებ მავთულხლართებს ბაზის დაფაზე. ეს მავთულები ისეა გაჭრილი, რომ საკმარისად გრძელია, რათა მიაღწიოს გუმბათზე მომდევნო LED- ს. მავთულები გადადის შემდეგ LED- ზე და პროცესი გრძელდება. მე დავუკავშირე LED- ები კონფიგურაციაში, რაც მინიმუმამდე შეამცირებს საჭირო მავთულის რაოდენობას, თუმცა აზრი ექნება მოგვიანებით LED- ების მიმართვას Arduino– ს გამოყენებით. უფრო პატარა გუმბათი გამორიცხავს ზოლის მოჭრის აუცილებლობას და დაზოგავს ბევრ დროს შედუღებას. კიდევ ერთი ვარიანტია გამოიყენოთ ცალკეული RGB LEDS ცვლის რეგისტრატორებით.

ზოლური სერიული კომუნიკაცია მიიღწევა Arduino– დან ორი ქინძისთავის (მონაცემისა და საათის პინის) გამოყენებით. სხვა სიტყვებით რომ ვთქვათ, გუმბათის განათების მონაცემები გადადის ერთი LED– დან მეორეზე, რადგან ის ტოვებს მონაცემთა pin– ს. აქ არის კოდი Arduino ფორუმიდან შეცვლილი:

// მთლიანი გუმბათი გაზრდის და ამცირებს ერთი ფერის ინტენსივობას

#განსაზღვრეთ numLeds 120 // LED- ების რაოდენობა // OUTPUT PINS // int clockPin = A1; // განსაზღვრეთ საათის პინი int dataPin = A0; // განსაზღვრეთ მონაცემთა პინი // ცვალებადი // int წითელი [numLeds]; // მასივის ინიციალიზაცია LED ზოლისთვის მწვანე [numLeds]; // მასივის ინიციალიზაცია LED ზოლისთვის ლურჯში [numLeds]; // მასივის ინიციალიზაცია LED ზოლისთვის // მუდმივი ორმაგი მასშტაბი A = {0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1}; // LED- ების ინტენსივობის ფრაქცია void setup () {pinMode (clockPin, OUTPUT); pinMode (dataPin, OUTPUT); memset (წითელი, 0, numLeds); memset (მწვანე, 0, numLeds); memset (ლურჯი, 0, numLeds); } void Updatestring (int redA [numLeds], int greenA [numLeds], int blueA [numLeds]) {for (int i = 0; i <numLeds; i ++) {shiftOut (dataPin, clockPin, MSBFIRST, redA ); shiftOut (dataPin, clockPin, MSBFIRST, greenA ); shiftOut (dataPin, clockPin, MSBFIRST, blueA ); }} void loop () {for (int p = 0; p <20; p ++) // მარყუჟი გუმბათის სინათლის ინტენსივობის გასაზრდელად {ორმაგი მასშტაბი = მასშტაბიA [p]; დაგვიანება (20); for (int i = 0; i <numLeds; i ++) // იმოძრავეთ ყველა LEDS– ით {წითელი = 255 * მასშტაბი; მწვანე = 80 * მასშტაბი; ლურჯი = 0; } Updatestring (წითელი, მწვანე, ლურჯი); // განახლება led ზოლები}}

ნაბიჯი 7: სენსორის მთის დიზაინი და განხორციელება

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

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

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

ნაბიჯი 8: მულტიპლექსირების სენსორის გამომუშავება

იმის გამო, რომ Arduino Uno– ს აქვს მხოლოდ 14 ციფრული I/O ქინძისთავები და 6 ანალოგური შეყვანის ქინძისთავები და არის 120 სენსორული სიგნალი, რომელიც უნდა წაიკითხოთ, გუმბათი მოითხოვს მულტიპლექსერს, რომ წაიკითხოს ყველა სიგნალი. მე ავირჩიე ხუთი 24-არხიანი მულტიპლექსერის აგება, რომელთაგან თითოეულში იკითხებოდა 24 IR სენსორი (იხ. ელექტრონიკის მიმოხილვის ფიგურა). 24-არხიანი MUX შედგება 8-არხიანი MUX გარღვევის დაფის, 16-არხიანი MUX გარღვევის დაფისა და 2-არხიანი MUX- ისგან. პინის სათაურები გაერთიანდა თითოეულ ბრეაკოუტ დაფაზე, რათა შესაძლებელი ყოფილიყო მათი დაკავშირება პროტოტიპის დაფაზე. მავთულის შესაფუთი ხელსაწყოს გამოყენებით, მე დავუკავშირე მიწა, 5 ვ და MUX გარღვევის დაფების საკონტროლო სიგნალის ქინძისთავები.

24-არხიანი MUX მოითხოვს ხუთ საკონტროლო სიგნალს, რომელიც მე შევარჩიე Arduino– ს პინ 8-12 – თან დასაკავშირებლად. ხუთივე 24-არხიანი MUX იღებს ერთსა და იმავე საკონტროლო სიგნალს Arduino– დან, ასე რომ მე Arduino ქინძისთავებიდან მავთული დავუკავშირე 24 – არხიან MUX– ს. IR სენსორების ციფრული შედეგები დაკავშირებულია 24-არხიანი MUX- ის შესასვლელთან, რათა მათი სერიული წაკითხვა Arduino– ზე მოხდეს. იმის გამო, რომ სენსორის ყველა 120 გამოსასვლელში არის ხუთი ცალკეული ქინძისთავი წაკითხვისთვის, სასარგებლოა წარმოვიდგინოთ, რომ გუმბათი იყოფა ხუთ ცალკეულ ნაწილად, რომელიც შედგება 24 სამკუთხედისგან (შეამოწმეთ გუმბათის ფერები ფიგურაში).

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

int numChannel = 24;

// გამოსვლები // int s0 = 8; // MUX კონტროლი 0 - PORTbD int s1 = 9; // MUX კონტროლი 1 - PORTb int s2 = 10; // MUX კონტროლი 2 - PORTb int s3 = 11; // MUX კონტროლი 3 - PORTb int s4 = 12; // MUX კონტროლი 4 - PORTb // INPUTS // int m0 = 3; // MUX შეყვანა 0 int m1 = 4; // MUX შეყვანა 1 int m2 = 5; // MUX შეყვანა 2 int m3 = 6; // MUX შეყვანა 3 int m4 = 7; // MUX შეყვანა 4 // ცვალებადი // int arr0r; // ციფრული წაკითხვა MUX0 int arr1r; // ციფრული წაკითხვა MUX1 int arr2r; // ციფრული წაკითხვა MUX2 int arr3r; // ციფრული წაკითხვა MUX3 int arr4r; // ციფრული წაკითხვა MUX4 void setup () {// განათავსეთ თქვენი კონფიგურაციის კოდი აქ, ერთხელ გასაშვებად: DDRB = B11111111; // ადგენს Arduino ქინძისთავებს 8 -დან 13 -მდე შეყვანის pinMode (s0, OUTPUT); pinMode (s1, OUTPUT); pinMode (s2, OUTPUT); pinMode (s3, OUTPUT); pinMode (s4, OUTPUT); pinMode (m0, INPUT); pinMode (m1, INPUT); pinMode (m2, INPUT); pinMode (m3, INPUT); pinMode (m4, INPUT); } void loop () {// განათავსეთ თქვენი მთავარი კოდი აქ, განმეორებით გასაშვებად: PORTB = B00000000; // SET კონტროლის ქინძისთავები mux დაბალია (int i = 0; i <numChannel; i ++) {// ციფრული წაკითხვის გამომავალი MUX0 - MUX4 IR სენსორისთვის i // თუ IR სენსორი არის LO, სამკუთხედს ეხება მოთამაშე რა arr0r = digitalRead (m0); // კითხვა Mux 0 -დან, IR სენსორი i arr1r = digitalRead (m1); // კითხვა Mux 1 -დან, IR სენსორი i arr2r = digitalRead (m2); // კითხვა Mux 2 -დან, IR სენსორი i arr3r = digitalRead (m3); // კითხვა Mux 3 -დან, IR სენსორი i arr4r = digitalRead (m4); // კითხულობს Mux 4 – დან, IR სენსორიდან // აკეთე რამე მუქსი ინექციებით ან შეინახე მასივში აქ // PORTB ++; // დამატებითი კონტროლის სიგნალები MUX}}

ნაბიჯი 9: სინათლის დიფუზია აკრილით

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

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

ნაბიჯი 10: მუსიკის შექმნა გუმბათის საშუალებით MIDI გამოყენებით

მინდოდა, რომ გუმბათს შეეძლო ხმის გამომუშავება, ამიტომ შევქმენი ხუთი MIDI არხი, ერთი გუმბათის თითოეული ქვეგანყოფილებისთვის. თქვენ ჯერ უნდა შეიძინოთ ხუთი MIDI ჯეკი და დააკავშიროთ ის სქემატურად (იხ. ეს სახელმძღვანელო Arduino– ს მხარდაჭერიდან დამატებითი ინფორმაციისთვის).

იმის გამო, რომ Arduino Uno– ზე არის მხოლოდ ერთი გადამცემი სერიული პინი (პინი 2 ეტიკეტირებული როგორც TX პინი), თქვენ უნდა გააუქმოთ სიგნალები, რომლებიც იგზავნება ხუთ MIDI ჯეკზე. მე იგივე კონტროლის სიგნალები გამოვიყენე (პინი 8-12), რადგან MIDI სიგნალები იგზავნება სხვა დროს, ვიდრე მაშინ, როდესაც IR სენსორები იკითხება არდუინოში. ეს საკონტროლო სიგნალები იგზავნება 8 არხიან დემულტიპლექსერზე, რათა თქვენ გააკონტროლოთ რომელი MIDI ბუდე მიიღებს Arduino– ს მიერ შექმნილ MIDI სიგნალს. MIDI სიგნალები შეიქმნა Arduino– ს მიერ და შესანიშნავი MIDI სიგნალის ბიბლიოთეკამ შექმნა ფრანსუა ბესტი. აქ არის რამოდენიმე მაგალითი კოდი მრავალჯერადი MIDI გამოსასვლელად სხვადასხვა MIDI ჯეკებზე Arduino Uno– ით:

#მოიცავს // მოიცავს MIDI ბიბლიოთეკას

#განსაზღვრეთ numChannel 24 // IR- ის რაოდენობა სამკუთხედზე #განსაზღვრეთ num სექციები 5 // გუმბათის მონაკვეთების რაოდენობა, 24 არხი MUX, MIDI ჯეკების რაოდენობა // OUTPUTS // int s0 = 8; // MUX კონტროლი 0 - PORTbD int s1 = 9; // MUX კონტროლი 1 - PORTb int s2 = 10; // MUX კონტროლი 2 - PORTb int s3 = 11; // MUX კონტროლი 3 - PORTb int s4 = 12; // MUX კონტროლი 4 - PORTb // INPUTS // int m0 = 3; // MUX შეყვანა 0 int m1 = 4; // MUX შეყვანა 1 int m2 = 5; // MUX შეყვანა 2 int m3 = 6; // MUX შეყვანა 3 int m4 = 7; // MUX შეყვანა 4 // ცვალებადი // int arr0r; // ციფრული წაკითხვა MUX0 int arr1r; // ციფრული წაკითხვა MUX1 int arr2r; // ციფრული წაკითხვა MUX2 int arr3r; // ციფრული წაკითხვა MUX3 int arr4r; // ციფრული წაკითხვა MUX4 int midArr [numSections]; // შეინახეთ შენიშვნა დაჭერილია თუ არა რომელიმე მოთამაშემ int note2play [numSections]; // შეინახეთ ჩანაწერი, რომელიც უნდა დაკვრა, თუკი სენსორი შეეხება ნოტებს [numChannel] = {60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83}; int pauseMidi = 4000; // პაუზის დრო midi სიგნალებს შორის MIDI_CREATE_DEFAULT_INSTANCE (); void setup () {// განათავსეთ თქვენი დაყენების კოდი აქ, ერთხელ გასაშვებად: DDRB = B11111111; // ადგენს Arduino ქინძისთავებს 8 -დან 13 -მდე, როგორც MIDI.begin (MIDI_CHANNEL_OFF) შესასვლელს; pinMode (s0, OUTPUT); pinMode (s1, OUTPUT); pinMode (s2, OUTPUT); pinMode (s3, OUTPUT); pinMode (s4, OUTPUT); pinMode (m0, INPUT); pinMode (m1, INPUT); pinMode (m2, INPUT); pinMode (m3, INPUT); pinMode (m4, INPUT); } void loop () {// განათავსეთ თქვენი მთავარი კოდი აქ, განმეორებით გასაშვებად: PORTB = B00000000; // SET კონტროლის ქინძისთავები mux დაბალია (int i = 0; i <numChannel; i ++) {// ციფრული წაკითხვის გამომავალი MUX0 - MUX4 IR სენსორისთვის i // თუ IR სენსორი არის LO, სამკუთხედს ეხება მოთამაშე რა arr0r = digitalRead (m0); // კითხვა Mux 0 -დან, IR სენსორი i arr1r = digitalRead (m1); // კითხვა Mux 1 -დან, IR სენსორი i arr2r = digitalRead (m2); // კითხვა Mux 2 -დან, IR სენსორი i arr3r = digitalRead (m3); // კითხვა Mux 3 -დან, IR სენსორი i arr4r = digitalRead (m4); // კითხულობს Mux 4 -დან, IR სენსორი i if (arr0r == 0) // სენსორი 0 მონაკვეთზე დაბლოკილია {midArr [0] = 1; // მოთამაშე 0 მოხვდა ნოტაზე, დააყენეთ HI ისე, რომ იყოს MIDI გამომავალი მოთამაშისთვის 0 note2play [0] = შენიშვნები ; // შენიშვნა მოთამაშესთვის 0} თამაშზე თუ (arr1r == 0) // სექცია 1 -ის სენსორი დაბლოკილია {midArr [1] = 1; // მოთამაშე 0 მოხვდა ნოტაზე, დააყენეთ HI ისე, რომ იყოს MIDI გამომავალი მოთამაშისთვის 0 note2play [1] = შენიშვნები ; // შენიშვნა მოთამაშესთვის 0} თამაშზე თუ (arr2r == 0) // სექცია 2 -ის სენსორი დაბლოკილია {midArr [2] = 1; // მოთამაშე 0 მოხვდა ნოტაზე, დააყენეთ HI ისე, რომ იყოს MIDI გამომავალი მოთამაშისთვის 0 note2play [2] = შენიშვნები ; // შენიშვნა მოთამაშესთვის 0} თამაშზე თუ (arr3r == 0) // სექცია 3 სენსორი დაბლოკილია {midArr [3] = 1; // მოთამაშე 0 მოხვდა ნოტაზე, დააყენეთ HI ისე, რომ იყოს MIDI გამომავალი მოთამაშისთვის 0 note2play [3] = შენიშვნები ; // შენიშვნა მოთამაშესთვის 0} თამაშზე თუ (arr4r == 0) // მე –4 ნაწილზე სენსორი დაბლოკილია {midArr [4] = 1; // მოთამაშე 0 მოხვდა ნოტაზე, დააყენეთ HI ისე, რომ იყოს MIDI გამომავალი მოთამაშისთვის 0 note2play [4] = შენიშვნები ; // შენიშვნა, რომ ითამაშო მოთამაშე 0} PORTB ++; // დამატებითი კონტროლის სიგნალები MUX} updateMIDI (); } void updateMIDI () {PORTB = B00000000; // SET კონტროლის ქინძისთავები mux low if (midArr [0] == 1) // მოთამაშე 0 MIDI გამომავალი {MIDI.sendNoteOn (note2play [0], 127, 1); გადადება მიკრო წამი (პაუზა შუალედი); MIDI.sendNoteOff (note2play [0], 127, 1); გადადება მიკრო წამი (პაუზა შუალედი); } PORTB ++; // გაზრდა MUX თუ (midArr [1] == 1) // მოთამაშე 1 MIDI გამომავალი {MIDI.sendNoteOn (note2play [1], 127, 1); გადადება მიკრო წამი (პაუზა შუალედი); MIDI.sendNoteOff (note2play [1], 127, 1); გადადება მიკრო წამი (პაუზა შუალედი); } PORTB ++; // გაზრდა MUX თუ (midArr [2] == 1) // მოთამაშე 2 MIDI გამომავალი {MIDI.sendNoteOn (note2play [2], 127, 1); გადადება მიკრო წამი (პაუზა შუალედი); MIDI.sendNoteOff (note2play [2], 127, 1); გადადება მიკრო წამი (პაუზა შუალედი); } PORTB ++; // გაზრდა MUX თუ (midArr [3] == 1) // მოთამაშე 3 MIDI გამომავალი {MIDI.sendNoteOn (note2play [3], 127, 1); გადადება მიკრო წამი (პაუზა შუალედი); MIDI.sendNoteOff (note2play [3], 127, 1); გადადება მიკრო წამი (პაუზა შუალედი); } PORTB ++; // გაზრდა MUX თუ (midArr [4] == 1) // მოთამაშე 4 MIDI გამომავალი {MIDI.sendNoteOn (note2play [4], 127, 1); გადადება მიკრო წამი (პაუზა შუალედი); MIDI.sendNoteOff (note2play [4], 127, 1); გადადება მიკრო წამი (პაუზა შუალედი); } midArr [0] = 0; შუა არი [1] = 0; შუა არი [2] = 0; შუა არი [3] = 0; შუა არი [4] = 0; }

ნაბიჯი 11: გუმბათის გაძლიერება

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

LED ზოლები: მე გამოვიყენე Ws2801 LED ზოლის დაახლოებით 3.75 მეტრი, რომელიც მოიხმარს 6.4 ვტ/მეტრს. ეს შეესაბამება 24W (3.75*6.4). ამპერებზე გადასაყვანად გამოიყენეთ სიმძლავრე = მიმდინარე*ვოლტი (P = iV), სადაც V არის LED ზოლის ძაბვა, ამ შემთხვევაში 5V. ამრიგად, LED- ებიდან ამოღებული დენი არის 4.8A (24W/5V = 4.8A).

IR სენსორები: თითოეული IR სენსორი იზიდავს დაახლოებით 25 mA, ჯამში 3A 120 სენსორზე.

არდუინო: 100mA, 9V

მულტიპლექსერები: არის ხუთი 24 არხიანი მულტიპლექსერი, რომელთაგან თითოეული შედგება 16 არხის მულტიპლექსერისა და 8 არხის მულტიპლექსერისგან. 8 არხი და 16 არხი MUX თითოეული მოიხმარს დაახლოებით 100mA. ამრიგად, მთლიანი MUX ენერგიის მოხმარება არის 1A.

ამ კომპონენტების დამატებით, ენერგიის მთლიანი მოხმარება სავარაუდოდ იქნება 9 ა. LED ზოლს, IR სენსორებს და მულტიპლექსერებს აქვთ შეყვანის ძაბვა 5V- ზე, ხოლო Arduino- ს აქვს 9V შეყვანის ძაბვა. ამიტომ, მე შევარჩიე 12V 15A კვების ბლოკი, 15A მამლის გადამყვანი 12V- ზე 5V- ზე და 3A მამლის კონვერტორი 12V- მდე 9V- ზე Arduino- სთვის.

ნაბიჯი 12: წრიული გუმბათის ბაზა

გუმბათი ეყრდნობა ხის წრიულ ნაჭერს, პენტაგონი შუიდან ამოჭრილია ელექტრონიკაში მოსახერხებლად. ამ წრიული ბაზის შესაქმნელად, 4X6’პლაივუდის ფურცელი ხის CNC როუტერის გამოყენებით იყო მოჭრილი. Jigsaw ასევე შეიძლება გამოყენებულ იქნას ამ ნაბიჯი. ბაზის მოჭრის შემდეგ, გუმბათი მიმაგრებული იყო ხის პატარა 2x3”ბლოკის გამოყენებით.

ბაზის თავზე, მე დავამატე კვების წყარო ეპოქსიდურით და MUX– ისა და Buck– ის გადამყვანები PCB დგას გამშვები პუნქტებით. შუასადებები იყო დამაგრებული პლაივუდზე E-Z Lok ძაფის გადამყვანების გამოყენებით.

ნაბიჯი 13: პენტაგონის გუმბათის ბაზა

წრიული ფუძის გარდა, მე ასევე ავაშენე გუმბათის პენტაგონის საფუძველი, რომლის ქვედა სარკმელი ბოლოში იყო. ეს ბაზა და გარე ფანჯარა ასევე გაკეთდა პლაივუდისგან, რომელიც მოჭრილია ხის CNC როუტერით. პენტაგონის მხარე დამზადებულია ხის ფიცრებისგან, ერთ მხარეს აქვს ხვრელი კონექტორების გასავლელად. ლითონის ფრჩხილების და 2x3 ბლოკის სახსრების გამოყენებით, ხის ფიცრები მიმაგრებულია პენტაგონის ბაზაზე. დენის გადამრთველი, MIDI კონექტორები და USB კონექტორი მიმაგრებულია წინა პანელზე, რომელიც მე შევქმენი ლაზერული საჭრელის გამოყენებით. მთელი პენტაგონის ბაზა ხრახნიან მე –12 ნაბიჯში აღწერილ წრიულ ბაზაზე.

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

ნაბიჯი 14: გუმბათის დაპროგრამება

გუმბათის დაპროგრამების უსასრულო შესაძლებლობები არსებობს. კოდის თითოეული ციკლი იღებს სიგნალებს IR სენსორებისგან, რომლებიც მიუთითებენ სამკუთხედებზე, რომლებსაც ვინმე შეეხო. ამ ინფორმაციის საშუალებით თქვენ შეგიძლიათ შეღებოთ გუმბათი ნებისმიერი RGB ფერით და/ან შექმნათ MIDI სიგნალი. აქ მოცემულია პროგრამების რამდენიმე მაგალითი, რომლებიც მე დავწერე გუმბათისთვის:

გუმბათის ფერი: შეხებისას თითოეული სამკუთხედი ცვლის ოთხ ფერს. ფერების შეცვლასთან ერთად არპეჯიო უკრავს. ამ პროგრამის საშუალებით თქვენ გუმბათის ფერს ათასობით სხვადასხვა გზით იღებთ.

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

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

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

ნაბიჯი 15: დასრულებული გუმბათის ფოტოები

გრანდიოზული პრიზი არდუინოს კონკურსში 2016

მეორე პრიზი რემიქსის კონკურსში 2016

მეორე პრიზი Make it Glow კონკურსში 2016