Interaktiv geodesisk LED -kuppel: 15 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:28

Jeg konstruerede en geodesisk kuppel bestående af 120 trekanter med en LED og sensor ved hver trekant. Hver LED kan adresseres individuelt, og hver sensor er indstillet specifikt til en enkelt trekant. Domen er programmeret med en Arduino til at lyse op og producere et MIDI -signal afhængigt af hvilken trekant du placerer din hånd.

Jeg designet kuplen til at være en sjov skærm, der får folk til at interessere sig for lys, elektronik og lyd. Fordi kuplen deles fint i fem dele, designede jeg kuplen til at have fem separate MIDI -udgange, der hver kan have en anden lyd. Dette gør kuplen til et kæmpe musikinstrument, ideelt til at spille musik med flere mennesker samtidigt. Udover at spille musik programmerede jeg også kuplen til lysshows og afspilning af en gengivelse af Simon og Pong. Den endelige struktur er lidt mere end en meter i diameter og 70 cm høj og er primært konstrueret med træ-, akryl- og 3D -trykte dele.

Der er flere gode instruktioner på LED borde og terninger, der inspirerede mig til at starte dette projekt. Jeg ville dog prøve at arrangere lysdioderne i en anden geometri. Jeg kunne ikke tænke mig en bedre struktur til projektet end en geodesisk kuppel, som også er veldokumenteret på Instructables. Så dette projekt er et remix/mashup af LED -borde og geodesiske kupler. Nedenfor er links til LED -bordet og Geodesic dome Instructables, som jeg tjekkede ud i starten af projektet.

LED borde og terninger:

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

Geodetisk kuppel:

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

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

Trin 1: Forsyningsliste

Materialer:

1. Træ til kuppelben og kuppelbund (mængden afhænger af kuppelens type og størrelse)

2. Adresserbar LED -strip (16,4ft/5m adresserbar farve LED Pixel Strip 160leds Ws2801 Dc5v)

3. Arduino Uno (Atmega328 - samlet)

4. Prototype board (Penta Angel Double-Side Prototype PCB Universal (7x9cm))

5. Akryl til diffusion af lysdioder (støbt akrylark, klart, 12 "x 12" x 0,118 "størrelse)

6. Strømforsyning (Aiposen 110/220V til DC12V 30A 360W switch strømforsyningsdriver)

7. Buck-konverter til Arduino (RioRand LM2596 DC-DC Buck Converter 1.23V-30V)

8. Buck -konverter til lysdioder og sensorer (DROK Mini Electric Buck Voltage Converter 15A)

9. 120 IR -sensorer (Infrarødt forhindringssensormodul)

10. Fem 16 -kanals multiplexere (Analog/Digital MUX Breakout - CD74HC4067)

11. Seks 8 -kanals multiplexere (Multiplexer Breakout - 8 kanaler (74HC4051))

12. Fem 2 -kanals multiplexere (MAX4544CPA+)

13. Wire wrap wire (PCB Loddemetal 0,25 mm Tinbelagt Kobbersnor Dia Wire-wrapping Wire 305M 30AWG Rød)

14. Tilslutningstråd (Solid Core, 22 AWG)

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

16. Fem MIDI-stik (brødbræt-venlige MIDI-stik (5-benet DIN))

17. Ti 220ohm modstande til MIDI -stik

18. Stand-off afstandsstykker til montering af elektronik til kuppel (Stand-off afstandsstykke Hex M3 han x M3 hun)

19. Gevindadaptere til tilslutning af afstande til træ (E-Z Lok gevindindsats, messing, knivtråd)

20. Epoxy eller Gorilla Superlim

21. Elektrisk tape

22. Lodning

Værktøjer:

1. Lodde Station

2. El -boremaskine

3. Rundsav

4. Kantslibemaskine

5. Jigssav

6. Geringssav

7. Vinkelmåler

8. 3D -printer

9. Trådskærere

10. Wire wrap værktøj

11. Laserskærer til skæring af LED -plader (valgfrit)

12. CNC -shopbot til kuppelbund (valgfrit)

Trin 2: Design af Geodesic Dome

Som jeg nævnte i introduktionen, er der flere online kilder til at bygge din egen geodesiske kuppel. Disse websteder indeholder kuppelberegnere, der bestemmer længden af hver side (dvs. stiver) og antallet af stik, der kræves til den type kuppel, du vil bygge. Kompleksiteten af en geodesisk kuppel (dvs. trekanternes tæthed) er specificeret af dens klasse (1V, 2V, 3V og så videre), hvor højere kompleksitet bliver en bedre tilnærmelse til en perfekt sfærisk overflade. For at konstruere din egen kuppel skal du først vælge en kuppeldiameter og klasse.

Jeg brugte et websted kaldet Domerama til at hjælpe mig med at designe en 4V -kuppel, der blev afkortet til 5/12 af en kugle med en radius på 40 cm. For denne type kuppel er der seks stivere i forskellige længder:

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

Det er i alt 190 stivere, der tilføjer op til 2223 cm (73 fod) materiale. Jeg brugte 1x3 (3/4 "× 2-1/2") fyrretræ til stiverne i denne kuppel. For at forbinde stiverne designede jeg og 3D -printede stik ved hjælp af Autocad. STL -filerne kan downloades i slutningen af dette trin. Antallet af stik til en 4V 5/12 dome er:

20 X 4-stik

6 x 5-stik

45 X 6-stik

I det næste trin beskriver jeg, hvordan denne kuppel er konstrueret med træstiverne og de 3D -printede stik, jeg designede.

Trin 3: Konstruktion af kuppel med stiver og stik

Ved hjælp af beregningerne fra Domerama for en 4V 5/12 kuppel skar jeg stiverne af med en cirkelsav. De 190 stiver blev mærket og lagt i en æske efter skæring. De 71 stik (20 fire-stik, 6 fem-stik og 45 seks-stik) blev 3D-printet ved hjælp af en Makerbot. Træstiverne blev indsat i konnektorerne i henhold til diagrammet skabt af Domerama. Jeg startede konstruktionen fra toppen og bevægede mig radialt udad.

Efter at alle stiverne var forbundet, fjernede jeg en stiver ad gangen og tilføjede epoxy til træet og stikket. Stikkene blev designet til at have fleksibilitet i, hvordan de forbandt strukturer, så det var vigtigt at kontrollere kuppelens symmetri, før der tilføjes epoxy.

Trin 4: Laserskæring og montering af grundplader

Nu hvor kuppelens skelet er konstrueret, er det tid til at skære de trekantede bundplader. Disse bundplader er fastgjort til bunden af stiverne og bruges til at montere lysdioderne på kuplen. Jeg skar oprindeligt bundpladerne ud af 5 mm (3/16”) tyk krydsfiner ved at måle de fem forskellige trekanter, der er på kuplen: AAB (30 trekanter), BCC (25 trekanter), DDE (20 trekanter), CDF (40 trekanter)) og EEE (5 trekanter). Dimensionerne på hver side og trekantenes form blev bestemt ved hjælp af en kuppelberegner (Domerama) og en vis geometri. Efter at have skåret testplader med et stiksav, tegnede jeg trekantsdesignet ved hjælp af Coral Draw og skar de resterende bundplader med en laserskærer (meget hurtigere!). Hvis du ikke har adgang til en laserskærer, kan du trække bundpladerne på krydsfiner ved hjælp af en lineal og vinkelmåler og skære dem alle sammen med et stiksav. Når bundpladerne er skåret, vendes kuplen, og pladerne limes til kuplen ved hjælp af trælim.

Trin 5: Oversigt over elektronik

På ovenstående figur er vist en skematisk oversigt over elektronikken til kuplen. En Arduino Uno bruges til at skrive og læse signaler til kuplen. For at tænde kuplen køres en RGB LED -strimmel over kuplen, så en LED er placeret ved hver af de 120 trekanter. For information om, hvordan en LED -strimmel fungerer, kan du læse denne instruks. Hver LED kan adresseres separat ved hjælp af Arduino, som producerer serielle data og urssignal for båndet (se A0 og A1 pin i skematisk). Med strimlen og disse to signaler alene kan du få en fantastisk lysende kuppel. Der er andre måder at skrive signaler på masser af LED fra en Arduino, såsom Charlieplexing og skiftregistre.

For at interagere med kuplen opsatte jeg en IR -sensor over hver LED. Disse sensorer bruges til at registrere, når en persons hånd er tæt på en trekant på kuplen. Fordi hver trekant på kuplen har sin egen IR -sensor, og der er 120 trekanter, bliver du nødt til at lave en form for multiplexing før Arduino. Jeg besluttede at bruge fem 24-kanals multiplexere (MUX) til de 120 sensorer på kuplen. Her er en instruktion om multiplexing, hvis du ikke er bekendt. En 24 -kanals MUX kræver fem styresignaler. Jeg valgte pins 8-12 på Arduino, så jeg kunne udføre portmanipulation (se trin 10 for flere oplysninger). Outputtet fra MUX-kortene læses ind ved hjælp af ben 3-7.

Jeg inkluderede også fem MIDI -udgange på kuplen, så den kunne producere lyd (trin 11). Med andre ord kan fem personer spille kuplen samtidigt, mens hvert output spiller en anden lyd. Der er kun en TX -pin på Arduino, så fem MIDI -signaler kræver demultiplexering. Fordi MIDI -output produceres på et andet tidspunkt end IR -sensoraflæsning, brugte jeg de samme styresignaler.

Når alle IR -sensorindgange er læst ind i Arduino, kan kuplen lyse og afspille lyde, men du programmerer Arduino. Jeg har et par eksempler i trin 14 af denne instruerbare.

Trin 6: Montering af lysdioder på kuppel

Fordi kuplen er så stor, skal LED -strimlen skæres for at placere en LED på hver trekant. Hver LED limes på trekanten ved hjælp af superlim. På hver side af LED'en bores der et hul gennem bundpladen, så kabler kan føres gennem kuplen. Jeg loddet derefter tilslutningstråd ved hver kontakt på LED'en (5V, jord, ur, signal) og førte ledningerne gennem bundpladen. Disse ledninger er skåret, så de er lange nok til at nå den næste LED på kuplen. Ledningerne trækkes igennem til den næste LED, og processen fortsættes. Jeg tilsluttede lysdioderne i en konfiguration, der ville minimere mængden af ledning, der kræves, mens det stadig giver mening at adressere lysdioderne ved hjælp af Arduino senere. En mindre kuppel ville fjerne behovet for at skære strimlen og spare meget tid på lodning. En anden mulighed er at bruge separate RGB LED'er med skiftregistre.

Seriel kommunikation til båndet opnås ved hjælp af to ben (en data- og urnål) fra Arduino. Med andre ord overføres dataene til belysning af kuplen fra den ene LED til den næste, når den forlader datapinden. Her er eksempelkode ændret fra dette Arduino forum:

// Få hele kuppel til at øge og reducere intensiteten af enkelt farve

#define numLeds 120 // Antal lysdioder // OUTPUT PINS // int clockPin = A1; // definer urnål int dataPin = A0; // definer datapind // VARIABLES // int red [numLeds]; // Initialiser array for LED strip int green [numLeds]; // Initialiser array til LED strip int blue [numLeds]; // Initialiser array til LED -bånd // KONSTANT dobbelt skalaA = {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}; // brøkdel af intensiteten af LED'er ugyldig opsætning () {pinMode (clockPin, OUTPUT); pinMode (dataPin, OUTPUT); memset (rød, 0, numLeds); memset (grøn, 0, numLeds); memset (blå, 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 ++) // loop for at øge lysintensiteten af dome {dobbelt skala = skalaA [p]; forsinkelse (20); for (int i = 0; i <numLeds; i ++) // gennemgå alle lysdioder {rød = 255 * skala; grøn = 80 * skala; blå = 0; } updatestring (rød, grøn, blå); // opdater led strip}}

Trin 7: Design og implementering af sensormontering

Jeg besluttede at bruge IR -sensorer til kuplen. Disse sensorer har en IR LED og modtager. Når et objekt kommer foran sensoren, reflekteres noget IR -stråling fra IR -LED'en mod modtageren. Jeg startede dette projekt med at lave mine egne IR -sensorer, som var baseret på Richardouvinas instruerbare. Al lodning tog alt for lang tid, så jeg købte 120 IR -sensorer fra eBay, der hver producerer et digitalt output. Sensortærsklen er indstillet med et potentiometer på tavlen, så output kun er højt, når en hånd er nær den trekant.

Hver trekant består af en krydsfiner LED-bundplade, et ark diffusivt akryl monteret cirka 2,5 cm over LED-pladen og en IR-sensor. Sensoren for hver trekant blev monteret på et ark tyndt krydsfiner formet som en femkant eller sekskant afhængigt af placeringen på kuplen (se figuren ovenfor). Jeg borede huller i IR-sensorbasen for at montere IR-sensorerne og tilsluttede derefter jorden og 5V ben med wire-wrap wire og et wire-wrap værktøj (røde og sorte ledninger). Efter at have tilsluttet jord og 5V, viklede jeg lang wire-wire på hver output (gul), jord og 5V for at løbe gennem kuplen.

De sekskantede eller femkantede IR -sensorbeslag blev derefter epoxet til kuplen, lige over 3D -printede stik, så ledningen kunne løbe gennem kuplen. Ved at have sensorerne over konnektorerne kunne jeg også få adgang til og justere potentiometrene på IR -sensorerne, der styrer sensorenes følsomhed. I det næste trin vil jeg beskrive, hvordan udgangene fra IR -sensorerne er forbundet til multiplexere og læses ind i Arduino.

Trin 8: Multiplexing sensor output

Fordi Arduino Uno kun har 14 digitale I/O -ben og 6 analoge indgangsstifter, og der er 120 sensorsignaler, der skal læses, kræver kuplen, at multiplexere læser alle signalerne. Jeg valgte at konstruere fem 24-kanals multiplexere, der hver læste 24 af IR-sensorerne (se figuren til oversigt over elektronik). 24-kanals MUX består af et 8-kanals MUX breakout board, 16-channel MUX breakout board og 2-channel MUX. Pinhoveder blev loddet til hvert breakout board, så de kunne forbindes til prototype board. Ved hjælp af et wire-wrap-værktøj tilsluttede jeg derefter jord, 5V og styresignalstifterne på MUX breakout boards.

En 24-kanals MUX kræver fem kontrolsignaler, som jeg valgte at forbinde til pin 8-12 på Arduino. Alle fem 24-kanals MUX modtager de samme styresignaler fra Arduino, så jeg tilsluttede ledningen fra Arduino-benene til 24-kanals MUX. IR-sensorernes digitale udgange er forbundet til input-benene på den 24-kanals MUX, så de serielt kan læses til Arduino. Fordi der er fem separate ben til aflæsning i alle 120 sensorudgange, er det nyttigt at forestille sig, at kuplen er delt i fem separate sektioner bestående af 24 trekanter (tjek kuplens farver i figur).

Ved hjælp af Arduino portmanipulation kan du hurtigt øge kontrolsignalerne, der sendes af ben 8-12 til multiplexerne. Jeg har vedhæftet en eksempelkode til betjening af multiplexerne her:

int numChannel = 24;

// UDGANG // int s0 = 8; // MUX -kontrol 0 - PORTbD int s1 = 9; // MUX -kontrol 1 - PORTb int s2 = 10; // MUX -kontrol 2 - PORTb int s3 = 11; // MUX -kontrol 3 - PORTb int s4 = 12; // MUX -kontrol 4 - PORTb // INPUTS // int m0 = 3; // MUX input 0 int m1 = 4; // MUX input 1 int m2 = 5; // MUX input 2 int m3 = 6; // MUX input 3 int m4 = 7; // MUX input 4 // VARIABLES // int arr0r; // digital læsning fra MUX0 int arr1r; // digital læsning fra MUX1 int arr2r; // digital læsning fra MUX2 int arr3r; // digital læsning fra MUX3 int arr4r; // digital læsning fra MUX4 hulrumsopsætning () {// sæt din opsætningskode her for at køre én gang: DDRB = B11111111; // indstiller Arduino pins 8 til 13 som input 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 () {// sæt din hovedkode her for at køre gentagne gange: PORTB = B00000000; // SET kontrolstifter til mux low for (int i = 0; i <numChannel; i ++) {// Digital læseudgang fra MUX0 - MUX4 til IR -sensor i // Hvis IR -sensor er LO, berøres trekanten af afspilleren. arr0r = digitalRead (m0); // læsning fra Mux 0, IR -sensor i arr1r = digitalRead (m1); // læsning fra Mux 1, IR -sensor i arr2r = digitalRead (m2); // læsning fra Mux 2, IR -sensor i arr3r = digitalRead (m3); // læsning fra Mux 3, IR -sensor i arr4r = digitalRead (m4); // læsning fra Mux 4, IR -sensor i // GØR NOGET MED MUX -INDGANGE ELLER OPBEVAR I ET ARRAY HER // PORTB ++; // stigningskontrolsignaler til MUX}}

Trin 9: Spredning af lys med akryl

For at sprede lyset fra lysdioderne slibede jeg transparent akryl med en cirkulær slibemaskine. Slibemaskinen blev flyttet over begge sider af akrylen i en figur-8 bevægelse. Jeg fandt denne metode til at være meget bedre end "frostet glas" spraymaling.

Efter slibning og rengøring af akryl brugte jeg en laserskærer til at skære trekanter ud, så de passede over lysdioderne. Det er muligt at skære akryl ved hjælp af et akrylskæreværktøj eller endda et stiksav, hvis akrylen ikke revner. Akrylen blev holdt over lysdioderne med 5 mm tykke krydsfinerrektangler, der også blev skåret med en laserskærer. Disse små planker blev limet til stiverne på kuplen, og akryl trekanterne blev epoxet på plankerne.

Trin 10: Lav musik med kuplen ved hjælp af MIDI

Jeg ville have, at kuplen skulle kunne producere lyd, så jeg oprettede fem MIDI -kanaler, en for hver delmængde af kuplen. Du skal først købe fem MIDI -stik og tilslutte det som vist i skematikken (se denne vejledning fra Arduino -support for mere info).

Fordi der kun er en transmitterende seriel pin på Arduino Uno (pin 2 mærket som TX-pin), skal du de-multiplexe signalerne, der sendes til de fem MIDI-stik. Jeg brugte de samme styresignaler (pin 8-12), fordi MIDI-signaler sendes på et andet tidspunkt, end når IR-sensorerne læses ind i Arduino. Disse styresignaler sendes til en 8-kanals demultiplexer, så du styrer hvilket MIDI-stik, der modtager MIDI-signalet, der er oprettet af Arduino. MIDI -signalerne blev genereret af Arduino med det fantastiske MIDI -signalbibliotek skabt af Francois Best. Her er nogle eksempler på kode til fremstilling af flere MIDI -udgange til forskellige MIDI -stik med en Arduino Uno:

#include // inkludere MIDI -bibliotek

#define numChannel 24 // Antal IR pr. trekant #define numSections 5 // antal sektioner i dome, antal 24channel MUX, antal MIDI -stik // OUTPUTS // int s0 = 8; // MUX -kontrol 0 - PORTbD int s1 = 9; // MUX -kontrol 1 - PORTb int s2 = 10; // MUX -kontrol 2 - PORTb int s3 = 11; // MUX -kontrol 3 - PORTb int s4 = 12; // MUX -kontrol 4 - PORTb // INPUTS // int m0 = 3; // MUX input 0 int m1 = 4; // MUX input 1 int m2 = 5; // MUX input 2 int m3 = 6; // MUX input 3 int m4 = 7; // MUX input 4 // VARIABLES // int arr0r; // digital læsning fra MUX0 int arr1r; // digital læsning fra MUX1 int arr2r; // digital læsning fra MUX2 int arr3r; // digital læsning fra MUX3 int arr4r; // digital læsning fra MUX4 int midArr [numSections]; // Gem, om der er blevet trykket på en note af en af spillerne int note2play [numSections] eller ej; // Gem note, der skal afspilles, hvis sensoren berøres int notes [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; // pause mellem midisignaler MIDI_CREATE_DEFAULT_INSTANCE (); void setup () {// sæt din opsætningskode her for at køre en gang: DDRB = B11111111; // sætter Arduino pins 8 til 13 som input 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 () {// sæt din hovedkode her for at køre gentagne gange: PORTB = B00000000; // SET kontrolstifter til mux low for (int i = 0; i <numChannel; i ++) {// Digital læseudgang fra MUX0 - MUX4 til IR -sensor i // Hvis IR -sensor er LO, berøres trekanten af afspilleren. arr0r = digitalRead (m0); // læsning fra Mux 0, IR -sensor i arr1r = digitalRead (m1); // læsning fra Mux 1, IR -sensor i arr2r = digitalRead (m2); // læsning fra Mux 2, IR -sensor i arr3r = digitalRead (m3); // læsning fra Mux 3, IR -sensor i arr4r = digitalRead (m4); // læsning fra Mux 4, IR -sensor i hvis (arr0r == 0) // Sensor på sektion 0 blev blokeret {midArr [0] = 1; // Spiller 0 har ramt en note, indstil HI, så der er MIDI -output for spiller 0 note2play [0] = noter ; // Bemærk at afspille for spiller 0} hvis (arr1r == 0) // Sensor på sektion 1 blev blokeret {midArr [1] = 1; // Spiller 0 har ramt en note, indstil HI, så der er MIDI -output for spiller 0 note2play [1] = noter ; // Bemærk at afspille for spiller 0} hvis (arr2r == 0) // Sensor på sektion 2 blev blokeret {midArr [2] = 1; // Spiller 0 har ramt en note, indstil HI, så der er MIDI -output for spiller 0 note2play [2] = noter ; // Bemærk at afspille for spiller 0} hvis (arr3r == 0) // Sensor i sektion 3 blev blokeret {midArr [3] = 1; // Spiller 0 har ramt en note, indstil HI, så der er MIDI -output for spiller 0 note2play [3] = noter ; // Bemærk at afspille for spiller 0} hvis (arr4r == 0) // Sensor på sektion 4 blev blokeret {midArr [4] = 1; // Spiller 0 har ramt en note, indstil HI, så der er MIDI -output for spiller 0 note2play [4] = noter ; // Bemærk til afspilning for Player 0} PORTB ++; // stigningskontrolsignaler til MUX} updateMIDI (); } ugyldig updateMIDI () {PORTB = B00000000; // SET kontrolpinde til mux low if (midArr [0] == 1) // Spiller 0 MIDI -output {MIDI.sendNoteOn (note2play [0], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [0], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // øge MUX if (midArr [1] == 1) // Spiller 1 MIDI -output {MIDI.sendNoteOn (note2play [1], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [1], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // øge MUX if (midArr [2] == 1) // Spiller 2 MIDI -output {MIDI.sendNoteOn (note2play [2], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [2], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // øge MUX if (midArr [3] == 1) // Spiller 3 MIDI -output {MIDI.sendNoteOn (note2play [3], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [3], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // øge MUX if (midArr [4] == 1) // Spiller 4 MIDI -output {MIDI.sendNoteOn (note2play [4], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [4], 127, 1); delayMicroseconds (pauseMidi); } midArr [0] = 0; midArr [1] = 0; midArr [2] = 0; midArr [3] = 0; midArr [4] = 0; }

Trin 11: Tænd for kuplen

Der er flere komponenter, der skal strømforsynes i kuplen. Du bliver derfor nødt til at beregne ampere trukket fra hver komponent for at bestemme den strømforsyning, du skal købe.

LED -strimlen: Jeg brugte cirka 3,75 meter Ws2801 LED -strimmel, som bruger 6,4 W/meter. Dette svarer til 24W (3,75*6,4). For at konvertere dette til ampere skal du bruge strøm = strøm*volt (P = iV), hvor V er spændingen på LED -strimlen, i dette tilfælde 5V. Derfor er strømmen fra LED'erne 4,8A (24W/5V = 4,8A).

IR -sensorerne: Hver IR -sensor trækker omkring 25mA, i alt 3A for 120 sensorer.

Arduino: 100mA, 9V

Multiplexerne: Der er fem 24 -kanals multiplexere, der hver består af en 16 -kanals multiplexer og 8 -kanals multiplexer. Den 8 -kanals og 16 -kanals MUX forbruger hver cirka 100mA. Derfor er det samlede strømforbrug for alle MUX 1A.

Sammenlagt disse komponenter forventes det samlede strømforbrug at være omkring 9A. LED -strimlen, IR -sensorer og multiplexere har indgangsspænding ved 5V, og Arduino har 9V indgangsspænding. Derfor valgte jeg en 12V 15A strømforsyning, en 15A buck converter til at konvertere 12V til 5V og en 3A buck converter til at konvertere 12V til 9V til Arduino.

Trin 12: Circular Dome Base

Kuplen hviler på et cirkulært stykke træ med en femkant skåret ud af midten for let adgang til elektronikken. For at skabe denne cirkulære base blev et 4x6 'ark krydsfiner skåret ved hjælp af en træ CNC -router. En stiksav kunne også bruges til dette trin. Efter at basen blev skåret, blev kuplen fastgjort til den ved hjælp af små 2x3”træblokke.

Oven på basen tilsluttede jeg strømforsyningen med epoxy og MUX’erne og Buck-omformerne med PCB-afstandsstykker. Afstandsstykkerne blev fastgjort til krydsfiner ved hjælp af E-Z Lok gevindadaptere.

Trin 13: Pentagon Dome Base

Ud over den cirkulære bund konstruerede jeg også en femkantet base til kuplen med et vinduesglas i bunden. Denne bund og det udseende vindue blev også lavet af krydsfiner skåret med en træ CNC -router. Pentagons sider er lavet af træplanker, hvor den ene side har et hul i det, som konnektorerne kan gå igennem. Ved hjælp af metalbeslag og 2x3 blokfuger er træplankerne fastgjort til femkantens bund. En afbryder, MIDI -stik og USB -stik er knyttet til et frontpanel, som jeg har oprettet ved hjælp af en laserskærer. Hele femkantens bund skrues til den cirkulære bund beskrevet i trin 12.

Jeg installerede et vindue i bunden af kuplen, så alle kan se op i kuplen for at se elektronikken. Glasset er fremstillet af akrylskåret med en laserskærer og epoxieres til et cirkulært stykke krydsfiner.

Trin 14: Programmering af kuplen

Der er uendelige muligheder for programmering af kuplen. Hver cyklus af koden optager signalerne fra IR -sensorerne, som angiver de trekanter, der er blevet rørt af nogen. Med disse oplysninger kan du farve kuplen med enhver RGB -farve og/eller producere et MIDI -signal. Her er et par eksempler på programmer, som jeg skrev til kuplen:

Farv kuplen: Hver trekant går gennem fire farver, når den berøres. Når farverne ændrer sig, afspilles en arpeggio. Med dette program får du farve kuplen på tusinder af forskellige måder.

Kuppelmusik: Domen er farvet med fem farver, hvert afsnit svarer til en anden MIDI -udgang. I programmet kan du vælge, hvilke toner hver trekant spiller. Jeg valgte at starte ved midten C i toppen af kuplen og øge banen, når trekanterne flyttede tættere på basen. Fordi der er fem output, er dette program ideelt til at få flere mennesker til at spille kuplen samtidigt. Ved hjælp af et MIDI -instrument eller MIDI -software kan disse MIDI -signaler fås til at lyde som ethvert instrument.

Simon: Jeg skrev en gengivelse af Simon, det klassiske hukommelsesoplysningsspil. En tilfældig sekvens af lys lyser en ad gangen over hele kuppelen. I hver tur skal spilleren kopiere sekvensen. Hvis spilleren matcher sekvensen korrekt, tilføjes et ekstra lys til sekvensen. Den høje score gemmes på en af sektionerne af kuplen. Dette spil er også meget sjovt at spille med flere mennesker.

Pong: Hvorfor ikke spille pong på en kuppel? En bold formerer sig over kuplen, indtil den rammer padlen. Når den gør det, produceres et MIDI -signal, der angiver, at padlen har ramt bolden. Den anden spiller skal derefter lede padlen langs bunden af kuplen, så den rammer bolden tilbage.

Trin 15: Billeder af færdiggjort kuppel

Storpris i Arduino -konkurrencen 2016

Anden pris i Remix -konkurrencen 2016

Anden pris i Make it Glow Contest 2016