Interaktyvusis geodezinis LED kupolas: 15 žingsnių (su paveikslėliais)

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:48

Aš sukūriau geodezinį kupolą, susidedantį iš 120 trikampių su LED ir jutikliu kiekviename trikampyje. Kiekvienas šviesos diodas gali būti adresuojamas atskirai, o kiekvienas jutiklis yra pritaikytas konkrečiam trikampiui. Kupolas yra užprogramuotas „Arduino“, kad užsidegtų ir skleistų MIDI signalą, priklausomai nuo to, į kurį trikampį padėsite ranką.

Sukūriau kupolą kaip įdomų ekraną, kuris žmones domina šviesa, elektronika ir garsu. Kadangi kupolas gražiai dalijasi į penkias dalis, suprojektavau kupolą, kad jame būtų penki atskiri MIDI išėjimai, kurie gali turėti skirtingą garsą. Dėl to kupolas yra milžiniškas muzikos instrumentas, idealiai tinkantis groti muziką su keliais žmonėmis vienu metu. Be muzikos grojimo, aš taip pat suprogramavau kupolą šviesos šou ir grojau Simono ir Pongo perteikimu. Galutinė konstrukcija yra šiek tiek daugiau nei metro skersmens ir 70 cm aukščio, daugiausia pagaminta iš medžio, akrilo ir 3D spausdintų dalių.

Ant LED stalų ir kubelių yra keletas puikių instrukcijų, kurios mane įkvėpė pradėti šį projektą. Tačiau norėjau pabandyti išdėstyti šviesos diodus kita geometrija. Aš negalėjau galvoti apie geresnę projekto struktūrą nei geodezinis kupolas, kuris taip pat gerai dokumentuotas „Instructables“. Taigi šis projektas yra LED stalų ir geodezinių kupolų remiksas/mišinys. Žemiau yra nuorodos į šviesos diodų stalą ir geodezinius kupolus, kuriuos patikrinau projekto pradžioje.

LED stalai ir kubeliai:

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-…

Geodezinis kupolas:

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

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

1 žingsnis: tiekimo sąrašas

Medžiagos:

1. Mediena kupolo statramsčiams ir kupolo pagrindui (kiekis priklauso nuo kupolo tipo ir dydžio)

2. Adresuojama LED juostelė (16,4 pėdų/5 m adresuota spalvota LED pikselių juostelė 160leds Ws2801 Dc5v)

3. „Arduino Uno“(„Atmega328“- surinktas)

4. Prototipo plokštė (Penta Angel Double-Side Prototype PCB Universal (7x9cm))

5. Akrilas šviesos diodams skleisti (lietinis akrilo lakštas, skaidrus, 12 "x 12" x 0,118 "dydžio)

6. Maitinimo šaltinis (nuo Aiposen 110/220V iki DC12V 30A 360W jungiklio maitinimo šaltinio tvarkyklės)

7. „Buck“konverteris, skirtas „Arduino“(„RioRand LM2596 DC-DC Buck Converter 1.23V-30V“)

8. „Buck“keitiklis šviesos diodams ir jutikliams („DROK Mini Electric Buck Voltage Converter 15A“)

9. 120 IR jutikliai (infraraudonųjų spindulių kliūčių vengimo jutiklio modulis)

10. Penki 16 kanalų multiplekseriai (analoginis/skaitmeninis MUX Breakout - CD74HC4067)

11. Šeši 8 kanalų multiplekseriai (Multiplexer Breakout - 8 Channel (74HC4051))

12. Penki 2 kanalų multiplekseriai (MAX4544CPA+)

13. Vielos apvyniojimo viela (PCB lydmetalis 0,25 mm alavo padengto vario laido skersmuo vielos vyniojimo viela 305M 30AWG raudona)

14. Prijungimo viela (vientisa šerdis, 22 AWG)

15. Smeigtukų antraštės („Gikfun“1 x 40 kontaktų 2,54 mm vienos eilės atsiskyrimo vyriško kaiščio antraštė)

16. Penki MIDI lizdai („Breadboard“pritaikytas „MIDI Jack“(5 kontaktų DIN))

17. Dešimt 220 omų rezistorių MIDI lizdams

18. Atskirtieji tarpikliai, skirti elektronikai pritvirtinti prie kupolo (Stand-off Spacer Hex M3 male x M3 Female)

19. Siūlų adapteriai, skirti atramoms prijungti prie medžio (E-Z Lok srieginis įdėklas, žalvaris, peilio sriegis)

20. Epoksidas arba „Gorilla Superglue“

21. Elektros juosta

22. Lituoklis

Įrankiai:

1. Litavimo stotis

2. Elektrinis gręžtuvas

3. Diskinis pjūklas

4. Orbitinis šlifuoklis

5. Džigo pjūklas

6. Pjautinis pjūklas

7. Dūmtraukis

8. 3D spausdintuvas

9. Vielos pjaustytuvai

10. Vielos apvyniojimo įrankis

11. Lazerinis pjoviklis LED plokštėms pjauti (neprivaloma)

12. CNC parduotuvė kupolo pagrindui (neprivaloma)

2 žingsnis: Geodezinio kupolo projektavimas

Kaip jau minėjau įžangoje, yra keli internetiniai šaltiniai, kaip sukurti savo geodezinį kupolą. Šiose svetainėse pateikiami kupoliniai skaičiuotuvai, kurie nustato kiekvienos pusės ilgį (t. Geodezinio kupolo sudėtingumą (t. Y. Trikampių tankį) lemia jo klasė (1V, 2V, 3V ir pan.), O didesnis sudėtingumas tampa geresniu tobula sferinio paviršiaus aproksimacija. Norėdami sukurti savo kupolą, pirmiausia turite pasirinkti kupolo skersmenį ir klasę.

Aš panaudojau svetainę, pavadintą „Domerama“, kad padėčiau suprojektuoti 4 V kupolą, kuris buvo sutrumpintas iki 5/12 sferos, kurio spindulys yra 40 cm. Šio tipo kupolui yra šeši skirtingo ilgio statramsčiai:

30 X „A“- 8,9 cm

30 X „B“- 10,4 cm

50 X „C“- 12,4 cm

40 X „D“- 12,5 cm

20 X „E“- 13,0 cm

20 X „F“- 13,2 cm

Iš viso tai yra 190 statramsčių, kurie sudaro 2223 cm (73 pėdų) medžiagos. Šio kupolo statramsčiams naudojau 1x3 (3/4 "× 2-1/2") pušies medieną. Norėdami prijungti statramsčius, suprojektavau ir 3D spausdinau jungtis naudodami „Autocad“. STL failus galima atsisiųsti šio veiksmo pabaigoje. 4V 5/12 kupolo jungčių skaičius yra:

20 X 4 jungtis

6 X 5 jungtis

45 X 6 jungtis

Kitame žingsnyje aprašysiu, kaip šis kupolas yra sukonstruotas naudojant medinius statramsčius ir mano sukurtas 3D spausdintas jungtis.

3 žingsnis: kupolo konstravimas su statramsčiais ir jungtimis

Naudodamas „Domerama“skaičiavimus 4V 5/12 kupolui, aš pjoviau statramsčius, naudodamas diskinį pjūklą. 190 statramsčių buvo paženklinti ir supjaustomi į dėžę. 71 jungtis (20 keturių jungčių, 6 penkių jungčių ir 45 šešių jungčių) buvo atspausdinta 3D naudojant „Makerbot“. Mediniai statramsčiai buvo įkišti į jungtis pagal „Domerama“sukurtą schemą. Pradėjau statybą nuo viršaus ir radialiai judėjau į išorę.

Sujungus visus statramsčius, aš nuėmiau vieną statramstį ir į medieną bei jungtį įdėjau epoksidinės dervos. Jungtys buvo suprojektuotos taip, kad būtų lanksčiai sujungtos konstrukcijos, todėl prieš pridedant epoksidinės medžiagos buvo svarbu patikrinti kupolo simetriją.

4 žingsnis: pjovimo ir montavimo pagrindo plokštės lazeriu

Dabar, kai kupolo skeletas yra sukonstruotas, laikas nupjauti trikampio pagrindo plokštes. Šios pagrindo plokštės pritvirtintos prie statramsčių apačios ir yra naudojamos šviesos diodams pritvirtinti prie kupolo. Iš pradžių aš iškirpiau pagrindines plokštes iš 5 mm (3/16 colių) storio faneros, išmatuodama penkis skirtingus trikampius, esančius ant kupolo: AAB (30 trikampių), BCC (25 trikampiai), DDE (20 trikampių), CDF (40 trikampių)), ir EEĮ (5 trikampiai). Kiekvienos kraštinės matmenys ir trikampių forma buvo nustatyti naudojant kupolo skaičiuotuvą (Domerama) ir tam tikrą geometriją. Pjaudamas bandomąsias pagrindo plokštes dėlionės pagalba, nubraižiau trikampio dizainą, naudodamas „Coral Draw“, o likusias pagrindo plokštes nukirpau lazeriniu pjaustytuvu (daug greičiau!). Jei neturite prieigos prie lazerinio pjaustytuvo, galite nubrėžti pagrindo plokštes ant faneros, naudodami liniuotę ir gaubtuvą, ir jas visas nupjauti dėlionės pagalba. Kai pagrindo plokštės yra supjaustytos, kupolas apverčiamas ir plokštės priklijuojamos prie kupolo naudojant medienos klijus.

5 žingsnis: Elektronikos apžvalga

Aukščiau esančiame paveikslėlyje parodyta kupolo elektronikos schema. „Arduino Uno“naudojamas kupolo signalams rašyti ir skaityti. Norėdami apšviesti kupolą, RGB šviesos diodų juosta perbraukiama virš kupolo taip, kad šviesos diodas būtų kiekviename iš 120 trikampių. Norėdami gauti informacijos apie tai, kaip veikia LED juostelė, peržiūrėkite šią instrukciją. Į kiekvieną šviesos diodą galima kreiptis atskirai naudojant „Arduino“, kuris sukuria juostos serijinius duomenis ir laikrodžio signalą (schemoje žr. A0 ir A1 kaiščius). Vien tik su juostele ir šiais dviem signalais galite turėti nuostabų apšvietimo kupolą. Yra ir kitų būdų, kaip rašyti signalus daugeliui „Arduino“šviesos diodų, pvz., „Charlieplexing“ir „shift“registrai.

Kad galėčiau sąveikauti su kupolu, virš kiekvieno šviesos diodo pastatiau IR jutiklį. Šie jutikliai naudojami aptikti, kai kieno nors ranka yra arti kupolo trikampio. Kadangi kiekvienas trikampis ant kupolo turi savo IR jutiklį ir yra 120 trikampių, prieš „Arduino“turėsite atlikti tam tikrą multipleksavimą. Aš nusprendžiau naudoti penkis 24 kanalų multiplekserius (MUX) 120 kupolo jutiklių. Čia yra instrukcija apie multipleksavimą, jei esate nepažįstamas. 24 kanalų MUX reikia penkių valdymo signalų. „Arduino“pasirinkau 8-12 kaiščius, kad galėčiau manipuliuoti prievadu (daugiau informacijos rasite 10 veiksme). MUX plokščių išvestis skaitoma naudojant kaiščius 3-7.

Aš taip pat įtraukiau penkis MIDI išėjimus ant kupolo, kad jis galėtų skleisti garsą (11 veiksmas). Kitaip tariant, penki žmonės gali groti kupolu vienu metu, o kiekvienas išėjimas leidžia skirtingą garsą. „Arduino“yra tik vienas TX kaištis, todėl penkis MIDI signalus reikia demultipleksuoti. Kadangi MIDI išvestis gaminama kitu laiku nei IR jutiklio rodmenys, naudojau tuos pačius valdymo signalus.

Kai visi IR jutiklio įėjimai bus perskaityti į „Arduino“, kupolas gali užsidegti ir leisti garsus, kad ir kaip programuotumėte „Arduino“. Turiu keletą pavyzdžių šios instrukcijos 14 žingsnyje.

6 žingsnis: šviesos diodų montavimas ant kupolo

Kadangi kupolas yra toks didelis, LED juostelę reikia nupjauti, kad ant kiekvieno trikampio būtų vienas šviesos diodas. Kiekvienas šviesos diodas yra klijuojamas ant trikampio naudojant super klijus. Abiejose šviesos diodo pusėse per pagrindo plokštę išgręžiama skylė, skirta kabeliams pravesti per kupolą. Tada prie kiekvieno šviesos diodo kontakto (5 V, įžeminimas, laikrodis, signalas) lituodavau prijungimo laidą ir tiekiu laidus per pagrindo plokštę. Šie laidai yra supjaustyti taip, kad būtų pakankamai ilgi, kad pasiektų kitą kupolo šviesos diodą. Laidai ištraukiami iki kito šviesos diodo ir procesas tęsiamas. Prijungiau šviesos diodus tokios konfigūracijos, kad būtų sumažintas reikalingas laidų kiekis, tačiau būtų prasminga vėliau kreiptis į šviesos diodus naudojant „Arduino“. Mažesnis kupolas pašalintų juostos pjovimo poreikį ir sutaupytų daug litavimo laiko. Kitas variantas yra naudoti atskirus RGB šviesos diodus su pamainų registrais.

Serijinis ryšys su juostele pasiekiamas naudojant du „Arduino“kaiščius (duomenų ir laikrodžio kaištį). Kitaip tariant, kupolo apšvietimo duomenys perduodami iš vieno šviesos diodo į kitą, kai jie palieka duomenų kaištį. Čia yra kodo pavyzdys, pakeistas iš šio „Arduino“forumo:

// Padarykite, kad visas kupolas padidėtų ir sumažėtų vienos spalvos intensyvumas

#define numLeds 120 // Šviesos diodų skaičius // OUTPUT PINS // int clockPin = A1; // apibrėžti laikrodžio kaištį int dataPin = A0; // apibrėžti duomenų kaištį // KINTAMIEJI // int red [numLeds]; // Inicijuoti masyvą LED juostai int žalia [numLeds]; // Inicijuoti masyvą LED juostelėms int blue [numLeds]; // Inicijuoti LED juostos masyvą // KONSTANTUS dvigubas mastelis 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}; // šviesos diodų intensyvumo dalis void setup () {pinMode (clockPin, OUTPUT); pinMode (dataPin, OUTPUT); memset (raudona, 0, numLeds); memset (žalia, 0, numLeds); memset (mėlyna, 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 ++) // kilpa, skirta padidinti kupolo šviesos intensyvumą {double scale = scaleA [p]; vėlavimas (20); for (int i = 0; i <numLeds; i ++) // ciklu per visus šviesos diodus {red = 255 * skale; žalia = 80 * skalė; mėlyna = 0; } atnaujinimo eilutė (raudona, žalia, mėlyna); // atnaujinti LED juostą}}

7 žingsnis: jutiklio laikiklio projektavimas ir įgyvendinimas

Aš nusprendžiau naudoti infraraudonųjų spindulių jutiklius kupolui. Šie jutikliai turi IR šviesos diodą ir imtuvą. Kai objektas patenka priešais jutiklį, kai kuri IR spinduliuotė iš IR šviesos diodo atsispindi imtuvo link. Aš pradėjau šį projektą sukurdamas savo IR jutiklius, kurie buvo pagrįsti Richardouvina instrukcijomis. Visas litavimas užtruko per ilgai, todėl iš „eBay“įsigijau 120 IR jutiklių, kurių kiekvienas gamina skaitmeninę išvestį. Jutiklio slenkstis nustatomas naudojant plokštėje esantį potenciometrą, kad išėjimas būtų didelis tik tada, kai ranka yra šalia to trikampio.

Kiekvieną trikampį sudaro faneros LED pagrindo plokštė, difuzinio akrilo lakštas, sumontuotas apie 2,5 cm virš LED plokštės, ir IR jutiklis. Kiekvieno trikampio jutiklis buvo sumontuotas ant plonos faneros lapo, suformuoto kaip penkiakampis arba šešiakampis, atsižvelgiant į padėtį ant kupolo (žr. Paveikslėlį aukščiau). Aš išgręžiau skylutes į IR jutiklio pagrindą, kad galėčiau sumontuoti IR jutiklius, tada prijungiau įžeminimo ir 5 V kaiščius vielos apvyniojimo viela ir vielos apvyniojimo įrankiu (raudoni ir juodi laidai). Prijungęs įžeminimą ir 5 V, aš apvyniojau ilgą vielos apvyniojimo laidą ant kiekvienos išvesties (geltonos spalvos), įžeminimo ir 5 V, kad praeitų per kupolą.

Tada šešiakampio arba penkiakampio IR jutiklio laikikliai buvo epoksiduojami ant kupolo, tiesiai virš 3D spausdintų jungčių, kad viela galėtų praeiti per kupolą. Turėdamas jutiklius virš jungčių, taip pat galėjau pasiekti ir reguliuoti IR jutiklių, kurie valdo jutiklių jautrumą, potenciometrus. Kitame žingsnyje aprašysiu, kaip IR jutiklių išėjimai yra prijungti prie multiplekserių ir nuskaitomi „Arduino“.

8 žingsnis: Jutiklio multipleksavimo išvestis

Kadangi „Arduino Uno“turi tik 14 skaitmeninių įvesties/išvesties kaiščių ir 6 analoginio įvesties kaiščius ir yra 120 jutiklių signalų, kuriuos reikia perskaityti, kupolui reikia, kad visi signalai būtų nuskaityti. Aš nusprendžiau sukurti penkis 24 kanalų multiplekserius, kurių kiekvienas skaitė 24 IR jutiklius (žr. Elektronikos apžvalgos paveikslėlį). 24 kanalų MUX sudaro 8 kanalų MUX pertraukimo plokštė, 16 kanalų MUX pertraukimo plokštė ir 2 kanalų MUX. Prie kiekvienos pertraukos plokštės buvo lituojamos kaiščių antraštės, kad jas būtų galima prijungti prie plokštės prototipo. Naudodamas vielos apvyniojimo įrankį, aš prijungiau įžeminimo, 5 V ir MUX pertraukimo plokščių valdymo signalo kaiščius.

24 kanalų MUX reikia penkių valdymo signalų, kuriuos pasirinkau prijungti prie „Arduino“8-12 kaiščio. Visi penki 24 kanalų MUX gauna tuos pačius valdymo signalus iš „Arduino“, todėl prijungiau laidą iš „Arduino“kaiščių prie 24 kanalų MUX. Skaitmeniniai IR jutiklių išėjimai yra prijungti prie 24 kanalų MUX įvesties kaiščių, kad juos būtų galima nuosekliai skaityti „Arduino“. Kadangi visuose 120 jutiklių išėjimuose yra penki atskiri kaiščiai skaitymui, naudinga įsivaizduoti, kad kupolas yra padalintas į penkias atskiras dalis, susidedančias iš 24 trikampių (patikrinkite kupolo spalvas paveiksle).

Naudodami manipuliavimą „Arduino“prievadu, galite greitai padidinti valdymo signalus, siunčiamus 8-12 kaiščiais į multiplekserius. Čia pridėjau keletą pavyzdžių, kaip valdyti multiplekserius:

int numChannel = 24;

// IŠVADOS // int s0 = 8; // MUX valdymas 0 - PORTbD int s1 = 9; // MUX valdymas 1 - PORTb int s2 = 10; // MUX valdymas 2 - PORTb int s3 = 11; // MUX valdymas 3 - PORTb int s4 = 12; // MUX valdymas 4 - PORTb // ĮVADAI // int m0 = 3; // MUX įėjimas 0 int m1 = 4; // MUX įėjimas 1 int m2 = 5; // MUX įėjimas 2 int m3 = 6; // MUX įėjimas 3 int m4 = 7; // MUX įvestis 4 // KINTAMOSIOS // int arr0r; // skaitmeninis skaitymas iš MUX0 int arr1r; // skaitmeninis skaitymas iš MUX1 int arr2r; // skaitmeninis skaitymas iš MUX2 int arr3r; // skaitmeninis skaitymas iš MUX3 int arr4r; // skaitmeninis skaitymas iš MUX4 void setup () {// įdėkite čia savo sąrankos kodą, kad jis būtų paleistas vieną kartą: DDRB = B11111111; // nustato „Arduino“kaiščius nuo 8 iki 13 kaip įvestis 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 () {// čia įdėkite pagrindinį kodą, kad jis būtų paleistas pakartotinai: PORTB = B00000000; // SET valdymo kaiščiai, skirti mažam mux (int i = 0; i <numChannel; i ++) {// Skaitmeninis MUX0 - MUX4 skaitymo išėjimas IR jutikliui i // Jei IR jutiklis yra LO, grotuvas paliečia trikampį. arr0r = digitalRead (m0); // skaitymas iš Mux 0, IR jutiklis i arr1r = digitalRead (m1); // skaitymas iš Mux 1, IR jutiklis i arr2r = digitalRead (m2); // skaitymas iš „Mux 2“, IR jutiklis i arr3r = digitalRead (m3); // skaitymas iš Mux 3, IR jutiklis i arr4r = digitalRead (m4); // skaitymas iš „Mux 4“, IR jutiklio i // DARYK KAŽKĄ SU MUX ĮVADAIS ARBA PARDUOTUVĖ KLAIDYJE ČIA // PORTB ++; // didinimo valdymo signalai MUX}}

9 žingsnis: išsklaidykite šviesą akrilu

Norėdami išsklaidyti šviesos diodų šviesą, aš šlifavau skaidrų akrilą apvaliu orbitiniu šlifuokliu. Šlifuoklis buvo perkeltas per abi akrilo puses 8 paveikslo judesiu. Man pasirodė, kad šis metodas yra daug geresnis už „matinio stiklo“purškiamus dažus.

Po šlifavimo ir akrilo valymo aš panaudojau lazerinį pjaustytuvą, kad iškirpčiau trikampius, kad jie tilptų virš šviesos diodų. Akrilą galima pjaustyti naudojant akrilo pjovimo įrankį ar net dėlionę, jei akrilas neskilinėja. Akrilą virš šviesos diodų laikė 5 mm storio faneros stačiakampiai, taip pat supjaustyti lazeriniu pjaustytuvu. Šios mažos lentos buvo priklijuotos prie kupolo statramsčių, o akrilo trikampiai buvo epoksiduojami ant lentų.

10 veiksmas: muzikavimas su kupolu naudojant MIDI

Norėjau, kad kupolas galėtų skleisti garsą, todėl sukūriau penkis MIDI kanalus, po vieną kiekvienam kupolo pogrupiui. Pirmiausia turite nusipirkti penkis MIDI lizdus ir prijungti, kaip parodyta schemoje (daugiau informacijos rasite šioje „Arduino“palaikymo pamokoje).

Kadangi „Arduino Uno“yra tik vienas perdavimo nuoseklusis kaištis (2 kaištis pažymėtas kaip TX kištukas), turite išardyti signalus, siunčiamus į penkis MIDI lizdus. Aš naudoju tuos pačius valdymo signalus (8-12 kaištis), nes MIDI signalai siunčiami kitu laiku nei tada, kai IR jutikliai nuskaitomi į „Arduino“. Šie valdymo signalai siunčiami į 8 kanalų demultiplekserį, kad galėtumėte valdyti, kuris MIDI lizdas gauna „Arduino“sukurtą MIDI signalą. MIDI signalus sukūrė „Arduino“su nuostabia MIDI signalų biblioteka, kurią sukūrė Francois Best. Štai keletas kodo pavyzdžių, kaip sukurti kelis MIDI išėjimus į skirtingus MIDI lizdus naudojant „Arduino Uno“:

#include // include MIDI biblioteka

#define numChannel 24 // IR skaičius per trikampį #define numSections 5 // sekcijų skaičius kupole, 24 kanalų MUX skaičius, MIDI lizdų skaičius // OUTPUTS // int s0 = 8; // MUX valdymas 0 - PORTbD int s1 = 9; // MUX valdymas 1 - PORTb int s2 = 10; // MUX valdymas 2 - PORTb int s3 = 11; // MUX valdymas 3 - PORTb int s4 = 12; // MUX valdymas 4 - PORTb // ĮVADAI // int m0 = 3; // MUX įėjimas 0 int m1 = 4; // MUX įėjimas 1 int m2 = 5; // MUX įėjimas 2 int m3 = 6; // MUX įėjimas 3 int m4 = 7; // MUX įvestis 4 // KINTAMOSIOS // int arr0r; // skaitmeninis skaitymas iš MUX0 int arr1r; // skaitmeninis skaitymas iš MUX1 int arr2r; // skaitmeninis skaitymas iš MUX2 int arr3r; // skaitmeninis skaitymas iš MUX3 int arr4r; // skaitmeninis skaitymas iš MUX4 int midArr [numSections]; // Saugoti, ar pastabą paspaudė vienas iš žaidėjų int not22 [numSections]; // Išsaugoti pastabą, kuri bus paleista, jei jutiklis paliestas int natose [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; // pauzės laikas tarp midi signalų MIDI_CREATE_DEFAULT_INSTANCE (); void setup () {// įdėkite čia savo sąrankos kodą, kad jis būtų paleistas vieną kartą: DDRB = B11111111; // nustato „Arduino“kaiščius nuo 8 iki 13 kaip įvestis 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 () {// čia įdėkite pagrindinį kodą, kad jis būtų paleistas pakartotinai: PORTB = B00000000; // SET valdymo kaiščiai, skirti mažam mux (int i = 0; i <numChannel; i ++) {// Skaitmeninis MUX0 - MUX4 skaitymo išėjimas IR jutikliui i // Jei IR jutiklis yra LO, grotuvas paliečia trikampį. arr0r = digitalRead (m0); // skaitymas iš Mux 0, IR jutiklis i arr1r = digitalRead (m1); // skaitymas iš Mux 1, IR jutiklis i arr2r = digitalRead (m2); // skaitymas iš „Mux 2“, IR jutiklis i arr3r = digitalRead (m3); // skaitymas iš Mux 3, IR jutiklis i arr4r = digitalRead (m4); // skaitymas iš „Mux 4“, IR jutiklis i if (arr0r == 0) // Jutiklis 0 skyriuje buvo užblokuotas {midArr [0] = 1; // Žaidėjas 0 pataikė į natą, nustatykite HI taip, kad būtų 0 žaidėjo MIDI išvestis note2play [0] = užrašai ; // Pastaba, kurią reikia žaisti žaidėjui 0}, jei (arr1r == 0) // 1 skyriaus jutiklis buvo užblokuotas {midArr [1] = 1; // Žaidėjas 0 pataikė į natą, nustatykite HI taip, kad būtų 0 žaidėjo MIDI išvestis note2play [1] = užrašai ; // Pastaba, kurią reikia žaisti žaidėjui 0}, jei (arr2r == 0) // 2 skyriaus jutiklis buvo užblokuotas {midArr [2] = 1; // Žaidėjas 0 pataikė į natą, nustatykite HI taip, kad būtų 0 žaidėjo MIDI išvestis note2play [2] = užrašai ; // Pastaba, kurią reikia žaisti žaidėjui 0}, jei (arr3r == 0) // 3 sekcijos jutiklis buvo užblokuotas {midArr [3] = 1; // Žaidėjas 0 pataikė į natą, nustatykite HI taip, kad būtų 0 žaidėjo MIDI išvestis note2play [3] = užrašai ; // Pastaba, kurią reikia žaisti žaidėjui 0}, jei (arr4r == 0) // Jutiklis 4 skyriuje buvo užblokuotas {midArr [4] = 1; // Žaidėjas 0 pataikė į natą, nustatykite HI taip, kad būtų 0 žaidėjo MIDI išvestis note2play [4] = užrašai ; // Pastaba, kurią reikia leisti žaidėjui 0} PORTB ++; // didinimo valdymo signalai MUX} updateMIDI (); } void updateMIDI () {PORTB = B00000000; // SET valdymo kaiščiai, skirti „mux low“, jei (midArr [0] == 1) // Leistuvės 0 MIDI išvestis {MIDI.sendNoteOn (note2play [0], 127, 1); delayMikrosekundės (pauseMidi); MIDI.sendNoteOff (note2play [0], 127, 1); delayMikrosekundės (pauseMidi); } PORTB ++; // padidinti MUX, jei (midArr [1] == 1) // 1 grotuvo MIDI išvestis {MIDI.sendNoteOn (note2play [1], 127, 1); delayMikrosekundės (pauseMidi); MIDI.sendNoteOff (note2play [1], 127, 1); delayMikrosekundės (pauseMidi); } PORTB ++; // padidinti MUX, jei (midArr [2] == 1) // 2 grotuvo MIDI išvestis {MIDI.sendNoteOn (note2play [2], 127, 1); delayMikrosekundės (pauseMidi); MIDI.sendNoteOff (note2play [2], 127, 1); delayMikrosekundės (pauseMidi); } PORTB ++; // padidinti MUX, jei (midArr [3] == 1) // 3 grotuvo MIDI išvestis {MIDI.sendNoteOn (note2play [3], 127, 1); delayMikrosekundės (pauseMidi); MIDI.sendNoteOff (note2play [3], 127, 1); delayMikrosekundės (pauseMidi); } PORTB ++; // padidinti MUX, jei (midArr [4] == 1) // 4 grotuvo MIDI išvestis {MIDI.sendNoteOn (note2play [4], 127, 1); delayMikrosekundės (pauseMidi); MIDI.sendNoteOff (note2play [4], 127, 1); delayMikrosekundės (pauseMidi); } vidurioArr [0] = 0; midArr [1] = 0; midArr [2] = 0; midArr [3] = 0; midArr [4] = 0; }

11 žingsnis: maitinimas kupolu

Yra keli komponentai, kuriuos reikia maitinti kupolu. Todėl turėsite apskaičiuoti stiprintuvus, paimtus iš kiekvieno komponento, kad nustatytumėte reikiamą maitinimo šaltinį.

LED juostelė: naudojau maždaug 3,75 metro Ws2801 LED juostos, kuri sunaudoja 6,4 W/metras. Tai atitinka 24W (3,75*6,4). Norėdami konvertuoti tai į stiprintuvus, naudokite galią = srovę*voltų (P = iV), kur V yra šviesos diodų juostos įtampa, šiuo atveju 5 V. Todėl srovė, gaunama iš šviesos diodų, yra 4,8A (24W/5V = 4,8A).

IR jutikliai: Kiekvienas IR jutiklis sugeria apie 25 mA, iš viso 3A 120 jutiklių.

„Arduino“: 100 mA, 9 V.

Multiplekseriai: Yra penki 24 kanalų multiplekseriai, kurių kiekvienas susideda iš 16 kanalų ir 8 kanalų multiplekserio. 8 ir 16 kanalų MUX sunaudoja apie 100 mA. Todėl bendras visų MUX energijos suvartojimas yra 1A.

Susumavus šiuos komponentus, bendras energijos suvartojimas turėtų būti apie 9A. Šviesos diodų juostos, IR jutiklių ir multiplekserių įėjimo įtampa yra 5 V, o „Arduino“- 9 V įėjimo įtampa. Todėl „Arduino“pasirinkau 12V 15A maitinimo šaltinį, 15A konverterį, skirtą 12V konvertuoti į 5V, ir 3A kintamosios srovės keitiklį, skirtą 12V konvertuoti į 9V.

12 žingsnis: apskrito kupolo pagrindas

Kupolas remiasi į apskritą medžio gabalą, kurio viduryje iškirptas penkiakampis, kad būtų galima lengvai pasiekti elektroniką. Norint sukurti šį apskritą pagrindą, naudojant medinį CNC frezą, buvo išpjautas 4x6 colių faneros lapas. Šiam žingsniui taip pat galima naudoti dėlionę. Nupjovus pagrindą, kupolas buvo pritvirtintas prie jo naudojant mažus 2x3 colių medienos blokus.

Ant pagrindo prijungiau maitinimo šaltinį su epoksidine derva ir MUX ir Buck keitiklius su PCB stand-off tarpikliais. Tarpikliai buvo pritvirtinti prie faneros naudojant „E-Z Lok“sriegio adapterius.

13 žingsnis: Pentagono kupolo bazė

Be apskrito pagrindo, aš taip pat sukonstravau penkiakampį kupolo pagrindą su stiklo langu apačioje. Šis pagrindas ir atrodantis langas taip pat buvo pagaminti iš faneros, supjaustytos mediniu CNC maršrutizatoriumi. Penkiakampio šonai yra pagaminti iš medinių lentų, kurių viena pusė turi skylę jungtims praeiti. Naudojant metalinius laikiklius ir 2x3 blokines jungtis, medinės lentos tvirtinamos prie penkiakampio pagrindo. Maitinimo jungiklis, MIDI jungtys ir USB jungtis yra pritvirtintos prie priekinio skydelio, kurį sukūriau naudojant lazerinį pjaustytuvą. Visas penkiakampis pagrindas yra prisukamas prie apskrito pagrindo, aprašyto 12 veiksme.

Aš įdėjau langą į kupolo apačią, kad kiekvienas galėtų pažvelgti į kupolą ir pamatyti elektroniką. Stiklas yra pagamintas iš akrilo, supjaustyto lazeriniu pjaustytuvu, ir epoksiduojamas ant apskrito faneros gabalo.

14 žingsnis: kupolo programavimas

Programuoti kupolą yra begalė galimybių. Kiekvienas kodo ciklas priima signalus iš IR jutiklių, kurie nurodo trikampius, kuriuos kažkas palietė. Turėdami šią informaciją galite nuspalvinti kupolą bet kokia RGB spalva ir (arba) sukurti MIDI signalą. Štai keletas programų, kurias parašiau kupolui, pavyzdžių:

Spalvinkite kupolą: kiekvienas trikampis paliečiamas per keturias spalvas. Keičiantis spalvoms, grojamas arpeggio. Naudodami šią programą galite nuspalvinti kupolą tūkstančiais skirtingų būdų.

Kupolo muzika: kupolas nuspalvintas penkiomis spalvomis, kiekviena sekcija atitinka skirtingą MIDI išvestį. Programoje galite pasirinkti, kurias natas groja kiekvienas trikampis. Aš nusprendžiau pradėti nuo C vidurio kupolo viršuje ir padidinti žingsnį, kai trikampiai priartėjo prie pagrindo. Kadangi yra penki išėjimai, ši programa idealiai tinka keliems žmonėms vienu metu žaisti kupolą. Naudojant MIDI instrumentą arba MIDI programinę įrangą, šie MIDI signalai gali skambėti kaip bet kuris instrumentas.

Simonas: Aš parašiau Simono, klasikinio atminties apšvietimo žaidimo, perdavimą. Visame kupole po vieną apšviečiama atsitiktinė žibintų seka. Kiekvieno posūkio metu žaidėjas turi nukopijuoti seką. Jei grotuvas teisingai atitinka seką, prie sekos pridedama papildoma lemputė. Aukščiausias balas saugomas vienoje iš kupolo sekcijų. Šį žaidimą taip pat labai smagu žaisti su keliais žmonėmis.

Pong: Kodėl nežaisti teniso ant kupolo? Kamuolys sklinda per kupolą, kol pataiko į irklą. Kai tai padaroma, sukuriamas MIDI signalas, rodantis, kad irklas pataikė į kamuolį. Kitas žaidėjas turi nukreipti irklą išilgai kupolo apačios taip, kad jis atsitrenktų atgal.

15 žingsnis: Užbaigto kupolo nuotraukos

Pagrindinis prizas „Arduino“konkurse 2016 m

Antrasis prizas „Remix“konkurse 2016 m

Antrasis prizas konkurse „Padaryk švytėjimą 2016“