Interaktiivne geodeetiline LED -kuppel: 15 sammu (piltidega)

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:49

Ma ehitasin geodeetilise kupli, mis koosnes 120 kolmnurgast, kus iga kolmnurga LED ja andur. Igale LED -ile saab adresseerida eraldi ja iga andur on häälestatud spetsiaalselt ühe kolmnurga jaoks. Kuppel on programmeeritud Arduinoga, et see süttiks ja tekitaks MIDI -signaali sõltuvalt sellest, millise kolmnurga käe asetate.

Kujundasin kupli lõbusaks ekraaniks, mis tekitab inimestes huvi valguse, elektroonika ja heli vastu. Kuna kuppel jaguneb kenasti viieks osaks, kujundasin kupli viieks eraldi MIDI -väljundiks, millest igaühel võib olla erinev heli. See muudab kupli hiiglaslikuks muusikariistaks, mis sobib ideaalselt muusika mängimiseks mitme inimesega samaaegselt. Lisaks muusika mängimisele programmeerisin kupli ka valgusetendusteks ning Simoni ja Pongi esituse esitamiseks. Lõplik struktuur on veidi üle meetri läbimõõduga ja 70 cm kõrge ning see on peamiselt valmistatud puidust, akrüülist ja 3D -trükitud osadest.

LED -laudadel ja -kuubikutel on mitu suurepärast juhendit, mis inspireerisid mind selle projektiga alustama. Siiski tahtsin proovida LED -ide paigutamist erineva geomeetriaga. Ma ei osanud projekti jaoks paremat struktuuri mõelda kui geodeetiline kuppel, mis on samuti hästi dokumenteeritud Instructablesis. Nii et see projekt on LED -laudade ja geodeetiliste kuplite remiks/mashup. Allpool on lingid LED -lauale ja geodeetilise kupli juhistele, mida ma projekti alguses vaatasin.

LED lauad ja kuubikud:

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

Geodeetiline kuppel:

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

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

Samm: tarnekiri

Materjalid:

1. Puit kupli ja kupli aluste jaoks (kogus sõltub kupli tüübist ja suurusest)

2. Aadressitav LED -riba (16,4 jalga/5 m adresseeritav värviline LED -piksliriba 160leds Ws2801 Dc5v)

3. Arduino Uno (Atmega328 - kokkupandud)

4. Prototüüpplaat (Penta Angel Double-Side Prototype PCB Universal (7x9cm))

5. Akrüül valgusdioodide hajutamiseks (valatud akrüülleht, selge, suurus 12 x 12 tolli x 0,118 tolli)

6. Toide (Aiposen 110/220V to DC12V 30A 360W Switch Power Supply Driver)

7. Buck converter Arduino jaoks (RioRand LM2596 DC-DC Buck Converter 1.23V-30V)

8. Buck -muundur LED -ide ja andurite jaoks (DROK Mini Electric Buck Voltage Converter 15A)

9. 120 IR -andurit (infrapuna takistuste vältimise andurimoodul)

10. Viis 16 -kanalilist multiplekserit (analoog/digitaalne MUX -katkestus - CD74HC4067)

11. Kuus 8 kanaliga multiplekserit (multiplekserite katkestus - 8 kanaliga (74HC4051))

12. Viis kahe kanaliga multiplekserit (MAX4544CPA+)

13. Traatpakenditraat (trükkplaadi jootekomponent 0,25 mm tinaga kaetud vaskkaabli dia Traadi mähkimistraat 305M 30AWG punane)

14. Haaketraat (tahke südamik, 22 AWG)

15. Nööpnõelad

16. Viis MIDI pesa (leivaplaadisõbralik MIDI pesa (5-pin DIN))

17. Kümme 220 oomi takistit MIDI pesade jaoks

18. Seisukohad elektroonika kuplile kinnitamiseks

19. Niidiadapterid puidust eraldusvõimaluste ühendamiseks (E-Z Lok keermestatud sisestus, messing, nuganiit)

20. Epoksiid või Gorilla superliim

21. Elektrilint

22. Jootma

Tööriistad:

1. Jootmisjaam

2. Jõutrell

3. Ketassaag

4. Orbitaallihvmasin

5. Jigsaag

6. Mitrasaag

7. Protraktor

8. 3D printer

9. Traadi lõikurid

10. Traatmähise tööriist

11. Laserlõikur LED -plaatide lõikamiseks (valikuline)

12. CNC shopbot kupli aluse jaoks (valikuline)

2. samm: Geodeetilise kupli kujundamine

Nagu ma sissejuhatuses mainisin, on oma geodeetilise kupli ehitamiseks mitmeid online -allikaid. Need saidid pakuvad kuplakalkulaatoreid, mis määravad kummagi külje pikkuse (st tugipostid) ja konnektorite arvu, mis on vajalikud mis tahes tüüpi kupli jaoks, mida soovite ehitada. Geodeetilise kupli keerukust (st kolmnurkade tihedust) määrab selle klass (1V, 2V, 3V jne), kusjuures suurem keerukus muutub täiusliku sfäärilise pinna paremaks lähendamiseks. Oma kupli ehitamiseks peate esmalt valima kupli läbimõõdu ja klassi.

Kasutasin saidi nimega Domerama, mis aitas mul projekteerida 4 V kupli, mis oli kärbitud 5/12 keraga, mille raadius oli 40 cm. Seda tüüpi kuplite jaoks on kuus erineva pikkusega toed:

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

See on kokku 190 tugiposti, mis annavad kokku 2223 cm (73 jalga) materjali. Selle kupli tugipostide jaoks kasutasin 1x3 (3/4 "× 2-1/2") männipuitu. Toestuste ühendamiseks kujundasin ja 3D -trükitud pistikud, kasutades Autocadi. STL -failid on selle sammu lõpus allalaadimiseks saadaval. 4V 5/12 kupli pistikute arv on järgmine:

20 X 4-pistik

6 X 5-pistik

45 X 6-pistik

Järgmises etapis kirjeldan, kuidas see kuppel on konstrueeritud minu loodud puidust tugipostide ja 3D -prinditud pistikutega.

Samm: kupli ehitamine tugipostide ja pistikutega

Kasutades Domerama arvutusi 4V 5/12 kupli jaoks, lõikasin toed ketassaega. 190 tugiposti märgistati ja pandi pärast lõikamist karpi. 71 pistikut (20 nelja pistikut, 6 viie pistikut ja 45 kuue pistikut) trükiti 3D-vormingus Makerboti abil. Puidust tugipostid sisestati pistikutesse vastavalt Domerama loodud skeemile. Alustasin ehitust ülevalt ja liikusin radiaalselt väljapoole.

Pärast kõigi tugipostide ühendamist eemaldasin ühe tugiposti korraga ja lisasin puidule ja pistikule epoksü. Pistikud olid konstrueeritud nii, et need oleksid konstruktsioonide ühendamisel paindlikud, mistõttu oli oluline enne kupli lisamist kontrollida kupli sümmeetriat.

4. samm: alusplaadid laserlõikamiseks ja paigaldamiseks

Nüüd, kui kupli luustik on ehitatud, on aeg kolmnurksed alusplaadid lõigata. Need alusplaadid on kinnitatud tugipostide põhja ja neid kasutatakse valgusdioodide kinnitamiseks kupli külge. Algselt lõikasin alusplaadid 5 mm (3/16”) paksusest vineerist välja, mõõtes kuplil olevaid viit erinevat kolmnurka: AAB (30 kolmnurka), BCC (25 kolmnurka), DDE (20 kolmnurka), CDF (40 kolmnurka)) ja EEE (5 kolmnurka). Mõlema külje mõõtmed ja kolmnurkade kuju määrati kuplakalkulaatori (Domerama) ja mõne geomeetria abil. Pärast testpõhjaplaatide lõikamist mosaiigiga joonistasin Coral Draw abil kolmnurga kujunduse ja ülejäänud alusplaadid lõikasin laserlõikuriga (palju kiiremini!). Kui teil pole juurdepääsu laserlõikurile, saate joonlaua ja eenduri abil alusplaadid joonistada vineerile ja lõigata need kõik mosaiigi abil. Kui alusplaadid on lõigatud, pööratakse kuppel ümber ja plaadid liimitakse puiduliimi abil kupli külge.

5. samm: elektroonika ülevaade

Ülaltoodud joonisel on näidatud kupli elektroonika skeem. Arduino Unot kasutatakse kupli signaalide kirjutamiseks ja lugemiseks. Kupli valgustamiseks juhitakse kupli kohale RGB LED -riba nii, et 120 -st kolmnurgast asetatakse LED. LED -riba toimimise kohta teabe saamiseks vaadake seda juhendit. Iga LED -i saab eraldi käsitleda, kasutades Arduino, mis toodab riba jaoks seeriaandmeid ja kella signaali (vt skemaatiliselt A0 ja A1 tihvti). Ainult riba ja nende kahe signaaliga saate suurepärase süttiva kupli. Arduino paljude LED -ide jaoks signaalide kirjutamiseks on ka teisi viise, näiteks Charlieplexing ja vahetusregistrid.

Kupliga suhtlemiseks seadistasin iga LED -i kohale IR -anduri. Neid andureid kasutatakse tuvastamiseks, kui kellegi käsi on kupli kolmnurga lähedal. Kuna igal kupli kolmnurgal on oma IR -andur ja seal on 120 kolmnurka, peate enne Arduino -d tegema mingisuguse multipleksimise. Otsustasin kasutada kupli 120 anduri jaoks viit 24-kanalilist multiplekserit (MUX). Siin on õpetus multipleksimise kohta, kui te pole tuttav. 24 kanaliga MUX vajab viit juhtimissignaali. Valisin Arduino tihvtid 8-12, et saaksin teha pordiga manipuleerimist (lisateabe saamiseks vt 10. sammu). MUX-plaatide väljund loetakse sisse tihvtide 3-7 abil.

Lisasin kuplile ka viis MIDI väljundit, et see saaks heli tekitada (11. samm). Teisisõnu, viis inimest saavad kupli mängida korraga, kui iga väljund mängib erinevat heli. Arduino -l on ainult üks TX -tihvt, nii et viis MIDI -signaali nõuab demultipleksimist. Kuna MIDI -väljund toodetakse muul ajal kui IR -anduri näit, kasutasin samu juhtsignaale.

Kui kõik IR -anduri sisendid on Arduinosse sisse loetud, võib kuppel süttida ja helisid esitada, olenemata Arduino programmeerimisest. Selle juhendi 14. sammus on mul mõned näited.

6. samm: valgusdioodide paigaldamine kuplile

Kuna kuppel on nii suur, tuleb LED -riba lõigata, et asetada igale kolmnurgale üks LED. Iga LED liimitakse kolmnurgale superliimi abil. Mõlemal pool LED -i puuritakse läbi alusplaadi auk, et kaablid läbi kupli viia. Seejärel jootsin LED-i iga kontakti (5V, maandus, kell, signaal) külge haaketraadi ja juhtisin juhtmed läbi alusplaadi. Need juhtmed on lõigatud nii, et need on piisavalt pikad, et jõuda kupli järgmise valgusdioodini. Juhtmed tõmmatakse järgmise LED -i juurde ja protsessi jätkatakse. Ühendasin valgusdioodid konfiguratsiooniga, mis minimeeriks vajaliku traadi koguse, kuid oleks siiski mõttekas LED -ide käsitlemiseks hiljem Arduino abil. Väiksem kuppel kaotaks vajaduse riba lõikamiseks ja säästaks palju jootmise aega. Teine võimalus on kasutada vahetusregistritega eraldi RGB LED -e.

Jadaühendus ribaga saavutatakse Arduino kahe tihvti (andmete ja kella tihvti) abil. Teisisõnu, kupli valgustamiseks vajalikud andmed edastatakse ühelt LED -ilt teisele, kui see lahkub andmestikust. Siin on sellest Arduino foorumist muudetud näite kood:

// Pane kogu kuppel suurendama ja vähendama ühevärvilist intensiivsust

#define numLeds 120 // LEDide arv // VÄLJUNDI PINSID // int clockPin = A1; // defineeri kella pin int andmedPin = A0; // andmestiku määramine // MUUTLIKUD // int punane [numLeds]; // Initsialiseeri massiivi LED -ribale int roheline [numLeds]; // Initsialiseeri massiiv LED -ribale int sinine [numLeds]; // LED -riba massiivi lähtestamine // Pidev kahekordne skaala 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}; // valgusdioodide intensiivsuse murdosa void setup () {pinMode (clockPin, OUTPUT); pinMode (dataPin, OUTPUT); memset (punane, 0, numLeds); memset (roheline, 0, numLeds); memset (sinine, 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 ++) // silmus kupli valgustugevuse suurendamiseks {double skaala = skaalaA [p]; viivitus (20); for (int i = 0; i <numLeds; i ++) // tsükkel läbi kõigi LED -ide {red = 255 * skaala; roheline = 80 * skaala; sinine = 0; } uuendusring (punane, roheline, sinine); // LED -riba värskendamine}}

7. samm: andurikinnituse projekteerimine ja rakendamine

Otsustasin kasutada kupli jaoks IR -andureid. Nendel anduritel on IR -LED ja vastuvõtja. Kui objekt satub anduri ette, peegeldub osa IR -LED -i IR -kiirgusest vastuvõtja suunas. Alustasin seda projekti, tehes oma IR -andurid, mis põhinesid Richardouvina juhendamisel. Kogu jootmine võttis liiga kaua aega, nii et ostsin eBayst 120 IR -andurit, millest igaüks toodab digitaalset väljundit. Anduri lävi seadistatakse plaadil oleva potentsiomeetriga nii, et väljund on kõrge ainult siis, kui käsi on selle kolmnurga lähedal.

Iga kolmnurk koosneb vineerist LED-alusplaadist, hajutatud akrüülist, mis on paigaldatud umbes 2,5 cm LED-plaadi kohale, ja IR-andurist. Iga kolmnurga andur paigaldati õhukese vineerilehele, mis oli kujundatud viisnurga või kuusnurga kujul, sõltuvalt kupli asendist (vt ülaltoodud joonist). Puurisin IR-anduri alusesse IR-andurite paigaldamiseks augud ja seejärel ühendasin maandus- ja 5V-nööpnõelad traatmähise traadi ja traatmähise tööriistaga (punased ja mustad juhtmed). Pärast maanduse ja 5 V ühendamist mässisin iga väljundi (kollane), maanduse ja 5 V pikkade traatidega mähitud juhtmete, et kupli kaudu läbi joosta.

Seejärel epokseeriti kuusnurkse või viisnurkse IR -anduri kinnitused kuplile, otse 3D -prinditud pistikute kohale, nii et traat saaks kupli läbida. Kuna andurid olid pistikute kohal, sain ka ligipääsu ja reguleerida andurite tundlikkust juhtivate IR -andurite potentsiomeetreid. Järgmises etapis kirjeldan, kuidas IR -andurite väljundid on multiplekseritega ühendatud ja Arduino sisse loetud.

8. etapp: multipleksimise anduri väljund

Kuna Arduino Unol on ainult 14 digitaalset sisend-/väljundpistikut ja 6 analoogsisendipistikut ning lugeda tuleb 120 andurisignaali, nõuab kuppel kõigi signaalide lugemiseks multipleksereid. Valisin viie 24-kanalilise multiplekseri ehitamise, millest igaüks luges 24 IR-andurit (vt elektroonika ülevaadet). 24-kanaliline MUX koosneb 8-kanalilisest MUX-paneelist, 16-kanalilisest MUX-i eraldusplaadist ja 2-kanalilisest MUX-ist. Tihvtide päised joodeti igale murdeplaadile, et neid saaks ühendada prototüüpplaadiga. Traatmähise tööriista abil ühendasin seejärel maanduse, 5 V ja MUX-i katkestusplaatide juhtsignaali tihvtid.

24-kanalilise MUX-i jaoks on vaja viit juhtimissignaali, mille valisin ühendamiseks Arduino pin 8-12-ga. Kõik viis 24-kanalilist MUX-i saavad Arduino'lt ühesugused juhtimissignaalid, nii et ühendasin juhtme Arduino tihvtidest 24-kanalilise MUX-iga. IR-andurite digitaalsed väljundid on ühendatud 24-kanalilise MUX-i sisendpistikutega, et neid saaks Arduinoga järjestikku lugeda. Kuna kõigis 120 anduri väljundis on lugemiseks viis eraldi tihvti, on kasulik ette kujutada, et kuppel on jagatud viieks eraldi sektsiooniks, mis koosnevad 24 kolmnurgast (kontrollige kupli värve joonisel).

Arduino pordi manipuleerimise abil saate kiiresti suurendada juhtnuppe, mida tihvtid 8-12 multiplekseritele saadavad. Lisasin siia multiplekserite käitamiseks näite koodi:

int numChannel = 24;

// VÄLJUNDID // int s0 = 8; // MUX juhtimine 0 - PORTbD int s1 = 9; // MUX juhtimine 1 - PORTb int s2 = 10; // MUX juhtimine 2 - PORTb int s3 = 11; // MUX -juhtimine 3 - PORTb int s4 = 12; // MUX -juhtimine 4 - PORTb // SISENDID // int m0 = 3; // MUX sisend 0 int m1 = 4; // MUX sisend 1 int m2 = 5; // MUX sisend 2 int m3 = 6; // MUX sisend 3 int m4 = 7; // MUX sisend 4 // MUUTUVAD // int arr0r; // digitaalne lugemine MUX0 -st int arr1r; // digitaalne lugemine MUX1 -st int arr2r; // digitaalne lugemine MUX2 -st int arr3r; // digitaalne lugemine MUX3 -st int arr4r; // digitaalne lugemine MUX4 void setupist () {// pange oma seadistuskood siia, et seda korra käivitada: DDRB = B11111111; // määrab Arduino nööpnõelad 8 kuni 13 sisenditeks pinMode (s0, OUTPUT); pinMode (s1, VÄLJUND); pinMode (s2, VÄLJUND); pinMode (s3, VÄLJUND); pinMode (s4, VÄLJUND); pinMode (m0, INPUT); pinMode (m1, INPUT); pinMode (m2, INPUT); pinMode (m3, INPUT); pinMode (m4, INPUT); } void loop () {// pange siia oma põhikood, et seda korduvalt käitada: PORTB = B00000000; // SET juhtnupud mux low jaoks (int i = 0; i <numChannel; i ++) {// Digitaalse lugemise väljund MUX0 - MUX4 IR -anduri i jaoks // Kui IR -andur on LO, puudutab mängija kolmnurka. arr0r = digitaalne lugemine (m0); // lugemine Mux 0 -st, IR -andur i arr1r = digitalRead (m1); // lugemine Mux 1 -st, IR -andur i arr2r = digitalRead (m2); // lugemine Mux 2 -st, IR -andur i arr3r = digitalRead (m3); // lugemine Mux 3 -st, IR -andur i arr4r = digitalRead (m4); // lugemine Mux 4 -st, IR -andur i // TEHA MIDAGI MUX -SISENDITE VÕI POOLE ARRAY'S SIIN // PORTB ++; // MUX -i juurdekasvu juhtimissignaalid}}

Samm: valguse hajutamine akrüüliga

Valgusdioodide valguse hajutamiseks lihvisin ümmarguse orbitaallihvimismasinaga läbipaistvat akrüüli. Lihvmasinat liigutati joonise 8 liigutusega üle akrüüli mõlema külje. Leidsin, et see meetod on palju parem kui "mattklaasist" pihustusvärv.

Pärast akrüüli lihvimist ja puhastamist kasutasin laserlõikurit, et lõigata välja kolmnurgad, mis sobiksid LED -idega. Kui akrüül ei pragune, on võimalik akrüüli lõigata akrüüllõikeriista või isegi mosaiigi abil. Akrüüli hoidsid valgusdioodide kohal 5 mm paksused vineerist ristkülikud, mis olid samuti lõigatud laserlõikuriga. Need väikesed plangud liimiti kupli tugipostide külge ja akrüülkolmnurgad epokseeriti plankudele.

Samm: kupliga muusika tegemine MIDI abil

Tahtsin, et kuppel oleks võimeline heli tekitama, seega seadistasin viis MIDI -kanalit, ühe kupli iga alamhulga kohta. Kõigepealt peate ostma viis MIDI -pistikut ja ühendama selle, nagu on näidatud skemaatiliselt (lisateabe saamiseks vaadake seda Arduino toe õpetust).

Kuna Arduino Unol on ainult üks edastusjada (tihvt 2 tähistatud kui TX-pin), peate viiest MIDI-pesast saadetavate signaalide multipleksimise lahti võtma. Kasutasin samu juhtsignaale (tihvt 8-12), sest MIDI-signaalid saadetakse muul ajal kui siis, kui IR-andureid Arduino sisse loetakse. Need juhtsignaalid saadetakse 8-kanalilisele demultiplekserile, nii et saate kontrollida, milline MIDI-pistik võtab vastu Arduino loodud MIDI-signaali. MIDI -signaalid genereeris Arduino koos Francois Besti loodud suurepärase MIDI -signaalikoguga. Siin on mõned näidiskoodid mitme MIDI -väljundi tootmiseks erinevatele MIDI -pistikupesadele Arduino Uno abil:

#include // kaasata MIDI kogu

#define numChannel 24 // IR arv kolmnurga kohta #define numSections 5 // sektsioonide arv kuplis, 24 -kanalilise MUX -i arv, MIDI -pesade arv // VÄLJUNDID // int s0 = 8; // MUX juhtimine 0 - PORTbD int s1 = 9; // MUX juhtimine 1 - PORTb int s2 = 10; // MUX juhtimine 2 - PORTb int s3 = 11; // MUX -juhtimine 3 - PORTb int s4 = 12; // MUX -juhtimine 4 - PORTb // SISENDID // int m0 = 3; // MUX sisend 0 int m1 = 4; // MUX sisend 1 int m2 = 5; // MUX sisend 2 int m3 = 6; // MUX sisend 3 int m4 = 7; // MUX sisend 4 // MUUTUVAD // int arr0r; // digitaalne lugemine MUX0 -st int arr1r; // digitaalne lugemine MUX1 -st int arr2r; // digitaalne lugemine MUX2 -st int arr3r; // digitaalne lugemine MUX3 -st int arr4r; // digitaalne lugemine MUX4 -st int midArr [numSections]; // Salvesta, kas mõni mängija on nooti vajutanud või mitte int note2play [numSections]; // Salvestage noot, mida esitada, kui andurit puudutatakse 76, 77, 78, 79, 80, 81, 82, 83}; int pauseMidi = 4000; // pausiaeg midi -signaalide vahel MIDI_CREATE_DEFAULT_INSTANCE (); void setup () {// pange oma seadistuskood siia, et seda korra käivitada: DDRB = B11111111; // määrab Arduino nööpnõelad 8 kuni 13 sisenditeks MIDI.begin (MIDI_CHANNEL_OFF); pinMode (s0, VÄLJUND); pinMode (s1, VÄLJUND); pinMode (s2, VÄLJUND); pinMode (s3, VÄLJUND); pinMode (s4, VÄLJUND); pinMode (m0, INPUT); pinMode (m1, INPUT); pinMode (m2, INPUT); pinMode (m3, INPUT); pinMode (m4, INPUT); } void loop () {// pange siia oma põhikood, et seda korduvalt käitada: PORTB = B00000000; // SET juhtnupud mux low jaoks (int i = 0; i <numChannel; i ++) {// Digitaalse lugemise väljund MUX0 - MUX4 IR -anduri i jaoks // Kui IR -andur on LO, puudutab mängija kolmnurka. arr0r = digitaalne lugemine (m0); // lugemine Mux 0 -st, IR -andur i arr1r = digitalRead (m1); // lugemine Mux 1 -st, IR -andur i arr2r = digitalRead (m2); // lugemine Mux 2 -st, IR -andur i arr3r = digitalRead (m3); // lugemine Mux 3 -st, IR -andur i arr4r = digitalRead (m4); // lugemine Mux 4 -st, IR -andur i if (arr0r == 0) // Andur jaotises 0 oli blokeeritud {midArr [0] = 1; // Mängija 0 tabas nooti, seadke HI nii, et mängija 0 jaoks oleks MIDI väljund note2play [0] = noodid ; // Märkus mängijale mängimiseks}, kui (arr1r == 0) // Jaotise 1 andur oli blokeeritud {midArr [1] = 1; // Mängija 0 tabas nooti, määrake HI nii, et mängija 0 jaoks oleks MIDI -väljund note2play [1] = noodid ; // Märkus mängijale mängimiseks}, kui (arr2r == 0) // Andur jaotises 2 oli blokeeritud {midArr [2] = 1; // Mängija 0 tabas nooti, seadke HI nii, et mängija 0 jaoks oleks MIDI väljund note2play [2] = noodid ; // Märkus, mida mängida mängijale 0}, kui (arr3r == 0) // Andur jaotises 3 oli blokeeritud {midArr [3] = 1; // Mängija 0 tabas nooti, seadke HI nii, et mängija 0 jaoks oleks MIDI -väljund note2play [3] = noodid ; // Märkus mängijale mängimiseks}, kui (arr4r == 0) // 4. jaotise andur oli blokeeritud {midArr [4] = 1; // Mängija 0 tabas nooti, seadke HI nii, et mängija 0 jaoks oleks MIDI väljund note2play [4] = noodid ; // Märkus mängijale mängimiseks 0} PORTB ++; // juurdekasvu juhtimissignaalid MUX jaoks} updateMIDI (); } tühine updateMIDI () {PORTB = B00000000; // SET kontrolli nööpnõelad mux low jaoks (midArr [0] == 1) // Mängija 0 MIDI väljund {MIDI.sendNoteOn (note2play [0], 127, 1); delayMikrosekundid (pausMidi); MIDI.sendNoteOff (note2play [0], 127, 1); delayMikrosekundid (pausMidi); } PORTB ++; // MUX -i suurendamine, kui (midArr [1] == 1) // Mängija 1 MIDI -väljund {MIDI.sendNoteOn (note2play [1], 127, 1); delayMikrosekundid (pausMidi); MIDI.sendNoteOff (note2play [1], 127, 1); delayMikrosekundid (pausMidi); } PORTB ++; // MUX -i juurdekasv, kui (midArr [2] == 1) // Mängija 2 MIDI -väljund {MIDI.sendNoteOn (note2play [2], 127, 1); delayMikrosekundid (pausMidi); MIDI.sendNoteOff (note2play [2], 127, 1); delayMikrosekundid (pausMidi); } PORTB ++; // MUX -i suurendamine, kui (midArr [3] == 1) // Mängija 3 MIDI -väljund {MIDI.sendNoteOn (note2play [3], 127, 1); delayMikrosekundid (pausMidi); MIDI.sendNoteOff (note2play [3], 127, 1); delayMikrosekundid (pausMidi); } PORTB ++; // juurdekasv MUX if (midArr [4] == 1) // Mängija 4 MIDI väljund {MIDI.sendNoteOn (note2play [4], 127, 1); delayMikrosekundid (pausMidi); MIDI.sendNoteOff (note2play [4], 127, 1); delayMikrosekundid (pausMidi); } midArr [0] = 0; midArr [1] = 0; midArr [2] = 0; midArr [3] = 0; midArr [4] = 0; }

11. samm: kupli toide

Kuplis tuleb toita mitu komponenti. Seepärast peate ostma vajaliku toiteallika arvutamiseks arvutama igast komponendist ammutatud võimendi.

LED -riba: kasutasin umbes 3,75 meetrit LED -riba Ws2801, mis tarbib 6,4 W/meeter. See vastab 24W (3,75*6,4). Selle ampritesse teisendamiseks kasutage võimsust = vool*volti (P = iV), kus V on LED -riba pinge, antud juhul 5 V. Seetõttu on valgusdioodidest võetud vool 4,8A (24W/5V = 4,8A).

IR -andurid: iga IR -andur tõmbab umbes 25 mA, kokku 3A 120 anduri jaoks.

Arduino: 100mA, 9V

Multiplekserid: On viis 24 -kanalilist multiplekserit, millest igaüks koosneb 16 -kanalilisest ja 8 -kanalilisest multiplekserist. 8 ja 16 kanaliga MUX tarbivad kumbki umbes 100 mA. Seetõttu on kõigi MUX -ide kogu energiatarve 1A.

Kui need komponendid kokku liita, on kogu energiatarve eeldatavasti umbes 9A. LED -riba, IR -andurite ja multiplekserite sisendpinge on 5 V ja Arduino sisendpinge on 9 V. Seetõttu valisin Arduino jaoks 12V 15A toiteallika, 15A buck muunduri 12V 5V muundamiseks ja 3A buck muunduri 12V 9V muundamiseks.

12. samm: ümmargune kupli alus

Kuppel toetub ümmargusele puutükile, mille keskelt on välja lõigatud viisnurk, et hõlpsasti elektroonikale juurde pääseda. Selle ümmarguse aluse loomiseks lõigati puidust CNC -ruuteri abil 4x6 -tolline vineerileht. Selle sammu jaoks võib kasutada ka mosaiiki. Pärast aluse lõikamist kinnitati kuppel selle külge, kasutades 2x3”puitplokke.

Aluse peale kinnitasin toiteploki epoksüvahega ning MUX- ja Buck-muundurid PCB eraldusribadega. Vahepaelad kinnitati vineerile E-Z Lok niidiadapterite abil.

13. samm: Pentagoni kuplibaas

Lisaks ümmargusele alusele ehitasin kupli jaoks ka viisnurkse aluse, mille allosas oli klaasklaas. See alus ja otsiv aken olid valmistatud ka puidust CNC -ruuteriga lõigatud vineerist. Viisnurga küljed on valmistatud puidust laudadest, mille ühel küljel on auk pistikute läbimiseks. Metallist sulgude ja 2x3 plokkühenduste abil kinnitatakse puidust plangud viisnurkse aluse külge. Toitelüliti, MIDI -pistikud ja USB -pistik on kinnitatud esipaneelile, mille lõin laserlõikuri abil. Kogu viisnurkne alus on kruvitud sammus 12 kirjeldatud ümmarguse aluse külge.

Paigaldasin akna kupli põhja, et igaüks saaks kupli poole vaadata, et elektroonikat näha. Klaas on valmistatud laserlõikuriga akrüülist ja epokseeritud ümmarguse vineeritükiga.

14. samm: kupli programmeerimine

Kupli programmeerimiseks on lõputult võimalusi. Iga koodi tsükkel võtab vastu IR -andurite signaale, mis näitavad kolmnurki, mida keegi on puudutanud. Selle teabe abil saate kupli värvida mis tahes RGB värviga ja/või toota MIDI -signaali. Siin on mõned näited programmidest, mille ma kupli jaoks kirjutasin:

Värvige kuppel: iga kolmnurk liigub puudutamisel läbi nelja värvi. Värvide muutudes mängitakse arpeggio. Selle programmiga saate kupli värvida tuhandetel erinevatel viisidel.

Kuppelmuusika: kuppel on värvitud viie värviga, millest igaüks vastab erinevale MIDI -väljundile. Programmis saate valida, milliseid noote iga kolmnurk mängib. Otsustasin alustada kupli ülaosas asuvast keskmisest C -st ja suurendada sammu, kui kolmnurgad liikusid alusele lähemale. Kuna väljundeid on viis, sobib see programm ideaalselt mitme inimese üheaegseks kupli mängimiseks. Kasutades MIDI -instrumenti või MIDI -tarkvara, saab need MIDI -signaalid panna kõlama nagu iga instrument.

Simon: Kirjutasin Simonist, klassikalisest mälu süttimismängust. Kogu kupli kohal süttib ükshaaval juhuslik tulede jada. Iga kord peab mängija jada kopeerima. Kui mängija vastab järjestusele õigesti, lisatakse jadale lisavalgus. Kõrge skoor salvestatakse kupli ühele osale. Seda mängu on ka väga lõbus mängida mitme inimesega.

Pong: Miks mitte mängida pongit kuppelil? Pall levib üle kupli, kuni see tabab mõla. Kui see juhtub, tekib MIDI -signaal, mis näitab, et mõla tabas palli. Seejärel peab teine mängija suunama mõla piki kupli põhja nii, et see lööb palli tagasi.

15. samm: valminud kupli fotod

Peaauhind Arduino konkursil 2016

Remix konkursi teine auhind 2016

Teine auhind konkursil Make it Glow 2016