Interaktiewe geodetiese LED -koepel: 15 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:26

Ek het 'n geodesiese koepel gebou wat bestaan uit 120 driehoeke met 'n LED en sensor by elke driehoek. Elke LED kan individueel aangespreek word en elke sensor is spesifiek ingestel vir 'n enkele driehoek. Die koepel is geprogrammeer met 'n Arduino om aan te steek en 'n MIDI -sein te produseer, afhangende van watter driehoek u u hand plaas.

Ek het die koepel ontwerp om 'n prettige vertoning te wees wat mense in lig, elektronika en klank laat belangstel. Omdat die koepel mooi in vyf dele verdeel het, het ek die koepel ontwerp om vyf aparte MIDI -uitsette te hê wat elk 'n ander klank kan hê. Dit maak die koepel 'n reuse -musiekinstrument, ideaal om gelyktydig met verskeie mense musiek te speel. Benewens die speel van musiek, het ek die koepel ook geprogrammeer vir ligte vertonings en 'n weergawe van Simon en Pong. Die finale struktuur is 'n bietjie meer as 'n meter in deursnee en 70cm lank, en is hoofsaaklik gebou met hout-, akriel- en 3D -gedrukte dele.

Daar is verskeie wonderlike instruksies op LED -tafels en -blokkies wat my geïnspireer het om met hierdie projek te begin. Ek wou egter probeer om die LED's in 'n ander meetkunde te rangskik. Ek kon nie dink aan 'n beter struktuur vir die projek as 'n geodesiese koepel nie, wat ook goed gedokumenteer is oor instruksies. Hierdie projek is dus 'n hervermenging/kombinasie van LED -tafels en geodesiese koepels. Hieronder is skakels na die LED -tafel en geodesiese koepelinstruksies wat ek aan die begin van die projek nagegaan het.

LED tafels en blokkies:

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

Geodetiese koepel:

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

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

Stap 1: Voorsieningslys

Materiaal:

1. Hout vir stutte van koepel en basis van koepel (hoeveelheid hang af van tipe en grootte van koepel)

2. Adresseerbare LED -strook (16.4ft/5m Adresseerbare kleur LED Pixel Strip 160leds Ws2801 Dc5v)

3. Arduino Uno (Atmega328 - saamgestel)

4. Prototipe bord (Penta Angel dubbel-sy prototipe PCB universeel (7x9cm))

5. Akriel vir verspreiding van LED's (gegote akrielblad, helder, 12 "x 12" x 0.118 "grootte)

6. Kragtoevoer (Aiposen 110/220V tot DC12V 30A 360W skakelaar kragbron)

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

8. Buck converter vir LED's en sensors (DROK Mini Electric Buck Voltage Converter 15A)

9. 120 IR -sensors (Module vir infrarooi obstruksie -vermyding)

10. Vyf 16 -kanaals multiplexers (analoog/digitaal MUX -uitbreek - CD74HC4067)

11. Ses 8 -kanaals multiplexers (Multiplexer Breakout - 8 Channel (74HC4051))

12. Vyf tweekanaals multiplexers (MAX4544CPA+)

13. Wire wrap wire (PCB Soldeer 0.25mm Tin Plated Copper Cord Dia Wire-wrapping Wire 305M 30AWG Red)

14. Aansluitdraad (Solid Core, 22 AWG)

15. Speldopskrifte (Gikfun 1 x 40 Speld 2.54mm Enkele ry wegbreekkopkop)

16. Vyf MIDI-aansluitings (broodbordvriendelike MIDI-aansluiting (5-pins DIN))

17. Tien 220ohm weerstande vir MIDI -aansluitings

18. Afstandhoudende afstandhouders vir die bevestiging van elektronika aan koepel (Stand-off afstandhouer Hex M3 mannetje x M3 wyfie)

19. Skroefdraadadapters om afstande met hout te verbind (EZ Lok Threaded Insert, Messing, Mes Thread)

20. Epoxy of Gorilla Superglue

21. Elektriese band

22. Soldeer

Gereedskap:

1. Soldeerstasie

2. Kragboor

3. Sirkelsaag

4. Orbitaalskuurmasjien

5. Jigsaag

6. Mitersaag

7. gradeboog

8. 3D -drukker

9. Draadsnyers

10. Gereedskap vir draaddraad

11. Lasersnyer vir die sny van LED -plate (opsioneel)

12. CNC shopbot vir basis van koepel (opsioneel)

Stap 2: Ontwerp die geodesiese koepel

Soos ek in die inleiding genoem het, is daar verskeie aanlynbronne om u eie geodesiese koepel te bou. Hierdie webwerwe bied koepelrekenaars wat die lengte van elke kant (dws stut) en die aantal verbindings bepaal wat benodig word vir watter tipe koepel u ook al wil bou. Die kompleksiteit van 'n geodesiese koepel (dit wil sê die digtheid van driehoeke) word gespesifiseer deur sy klas (1V, 2V, 3V, ensovoorts), met 'n hoër kompleksiteit 'n beter benadering van 'n perfekte sferiese oppervlak. Om u eie koepel te bou, moet u eers 'n koepeldiameter en klas kies.

Ek het 'n webwerf met die naam Domerama gebruik om my te help om 'n 4V -koepel te ontwerp wat afgesny is tot 5/12 van 'n bol met 'n radius van 40 cm. Vir hierdie tipe koepel is daar ses stutte met verskillende lengtes:

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

Dit is 'n totaal van 190 stutte wat tot 2223 cm materiaal toevoeg. Ek het 1x3 (3/4 "× 2-1/2") dennehout gebruik vir die stutte in hierdie koepel. Om die stutte te verbind, het ek verbindings ontwerp en 3D -gedruk met Autocad. Aan die einde van hierdie stap kan u die STL -lêers aflaai. Die aantal verbindings vir 'n 4V 5/12 koepel is:

20 x 4-aansluiting

6 x 5-aansluiting

45 x 6-aansluiting

In die volgende stap beskryf ek hoe hierdie koepel gebou is met die houtstutte en die 3D -gedrukte verbindings wat ek ontwerp het.

Stap 3: Bou koepel met stutte en verbindings

Met die berekeninge van Domerama vir 'n 4V 5/12 koepel, sny ek die stutte met 'n sirkelsaag. Die 190 stutte is gemerk en in 'n boks gesit nadat hulle gesny is. Die 71 verbindings (20 vier-verbindings, 6 vyf-verbindings en 45 ses-verbindings) is 3D gedruk met 'n Makerbot. Die houtstutte is in die verbindings geplaas volgens die diagram wat deur Domerama geskep is. Ek het die konstruksie van bo af begin en radiaal na buite beweeg.

Nadat al die stutte verbind was, het ek een stut op 'n slag verwyder en epoksie by die hout en koppelstuk gevoeg. Die verbindings is ontwerp om buigsaamheid te hê in die manier waarop hulle die strukture verbind, dus was dit belangrik om die simmetrie van die koepel na te gaan voordat u epoksie byvoeg.

Stap 4: Lasersny en monteer basisplate

Noudat die skelet van die koepel gebou is, is dit tyd om die driehoekige basisplate te sny. Hierdie basisplate word aan die onderkant van die stutte vasgemaak en word gebruik om die LED's aan die koepel te monteer. Ek het die basisplate aanvanklik uit 5 mm (3/16”) dik laaghout gesny deur die vyf verskillende driehoeke wat op die koepel is, te meet: AAB (30 driehoeke), BCC (25 driehoeke), DDE (20 driehoeke), CDF (40 driehoeke)) en EEE (5 driehoeke). Die afmetings van elke kant en die vorm van die driehoeke is bepaal met behulp van 'n koepelrekenaar (Domerama) en 'n mate van meetkunde. Nadat ek die toetsplate met 'n figuursaag gesny het, het ek die driehoekontwerp met Coral Draw geteken en die oorblywende basisplate met 'n lasersnyer gesny (baie vinniger!). As u nie toegang tot 'n lasersnyer het nie, kan u die basisplate met behulp van 'n liniaal en gradeboog op laaghout trek en dit met 'n figuursaag sny. Sodra die basisplate gesny is, word die koepel omgedraai en die plate met houtlym aan die koepel vasgeplak.

Stap 5: Elektroniese oorsig

In die figuur hierbo is 'n skema van die elektronika vir die koepel getoon. 'N Arduino Uno word gebruik vir die skryf en lees van seine vir die koepel. Om die koepel te verlig, word 'n RGB LED -strook oor die koepel geloop sodat 'n LED by elkeen van die 120 driehoeke geplaas word. Lees hierdie instruksies vir meer inligting oor hoe 'n LED -strook werk. Elke LED kan afsonderlik aangespreek word met behulp van die Arduino, wat 'n seriële data- en kloksignaal vir die strook lewer (sien die A0- en A1 -pen in skematiese weergawe). Met die strook en hierdie twee seine alleen, kan u 'n ongelooflike verligte koepel hê. Daar is ander maniere om seine te skryf vir baie LED's van 'n Arduino, soos Charlieplexing en skofregisters.

Om met die koepel te kommunikeer, het ek 'n IR -sensor bo elke LED opgestel. Hierdie sensors word gebruik om op te spoor wanneer iemand se hand naby 'n driehoek op die koepel is. Omdat elke driehoek op die koepel sy eie IR -sensor het en 120 driehoeke is, moet u 'n soort multiplexing voor die Arduino doen. Ek het besluit om vyf 24-kanaals multiplexers (MUX) vir die 120 sensors op die koepel te gebruik. Hier is 'n instruksie oor multiplexing, as u nie vertroud is nie. 'N 24 -kanaals MUX benodig vyf beheerseine. Ek het penne 8-12 op die Arduino gekies, sodat ek poortmanipulasie kon doen (sien stap 10 vir meer inligting). Die uitset van die MUX-borde word ingelees met behulp van penne 3-7.

Ek het ook vyf MIDI -uitsette op die koepel ingesluit sodat dit klank kon produseer (Stap 11). Met ander woorde, vyf mense kan die koepel gelyktydig speel terwyl elke uitset 'n ander klank speel. Daar is slegs een TX -pen op die Arduino, so vyf MIDI -seine vereis demultiplexing. Omdat die MIDI -uitset op 'n ander tydstip as die IR -sensorlesing geproduseer word, het ek dieselfde beheerseine gebruik.

Nadat al die ingange van die IR -sensor in die Arduino gelees is, kan die koepel brand en geluide speel, maar u programmeer die Arduino. Ek het 'n paar voorbeelde in stap 14 van hierdie instruksies.

Stap 6: Monteer LED's op die koepel

Omdat die koepel so groot is, moet die LED -strook gesny word om een LED op elke driehoek te plaas. Elke LED word met supergom op die driehoek vasgeplak. Aan weerskante van die LED word 'n gat deur die basisplaat geboor sodat kabels deur die koepel gelei kan word. Ek het toe die aansluitdraad gesoldeer by elke kontak op die LED (5V, grond, klok, sein) en voer die drade deur die basisplaat. Hierdie drade word so gesny dat hulle lank genoeg is om die volgende LED op die koepel te bereik. Die drade word deurgetrek na die volgende LED, en die proses word voortgesit. Ek het die LED's gekoppel in 'n konfigurasie wat die hoeveelheid draad tot die minimum beperk, terwyl dit steeds sinvol was om die LED's later met die Arduino aan te spreek. 'N Kleiner koepel sal die noodsaaklikheid om die strook te sny uitskakel en baie tydsoldeer bespaar. 'N Ander opsie is om aparte RGB -LED's met skofregisters te gebruik.

Seriële kommunikasie met die strook word verkry met behulp van twee penne ('n data- en klokpen) van die Arduino. Met ander woorde, die data vir die verligting van die koepel word van een LED na die volgende oorgedra terwyl dit die datapennetjie verlaat. Hier is 'n voorbeeldkode wat vanaf hierdie Arduino -forum gewysig is:

// Verhoog die hele koepel en verminder die intensiteit van die enkele kleur

#define numLeds 120 // Aantal LED's // OUTPUT PINS // int clockPin = A1; // definieer klokpen int dataPin = A0; // definieer dataspeld // VARIABLES // int red [numLeds]; // Initialiseer skikking vir LED -strook int groen [numLeds]; // Initialiseer skikking vir LED -strook int blou [numLeds]; // Initialiseer skikking vir LED -strook // KONSTANT dubbele skaal 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}; // fraksie van intensiteit van LED's leemte opstelling () {pinMode (clockPin, OUTPUT); pinMode (dataPin, OUTPUT); memset (rooi, 0, numLeds); memset (groen, 0, numLeds); memset (blou, 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 ); }} leegte lus () {vir (int p = 0; p <20; p ++) // lus om die ligintensiteit van koepel te verhoog {dubbele skaal = skaalA [p]; vertraging (20); for (int i = 0; i <numLeds; i ++) // deur alle LED's {rooi = 255 * skaal; groen = 80 * skaal; blou = 0; } updatestring (rooi, groen, blou); // werk led strip op}}

Stap 7: Ontwerp en implementering van sensorhouers

Ek het besluit om IR -sensors vir die koepel te gebruik. Hierdie sensors het 'n IR LED en ontvanger. As 'n voorwerp voor die sensor kom, word IR -straling van die IR -LED na die ontvanger gereflekteer. Ek het hierdie projek begin deur my eie IR -sensors te maak, gebaseer op die instruksies van Richardouvina. Al die soldering het te lank geneem, so ek het 120 IR -sensors by eBay gekoop wat elk 'n digitale uitset lewer. Die drumpel van die sensor is ingestel met 'n potensiometer op die bord sodat die uitset hoog is slegs as 'n hand naby die driehoek is.

Elke driehoek bestaan uit 'n laaghout-LED-basisplaat, 'n vel diffuse akriel wat ongeveer 2,5 cm bokant die LED-plaat gemonteer is, en 'n IR-sensor. Die sensor vir elke driehoek is gemonteer op 'n vel dun laaghout in die vorm van 'n vyfhoek of seshoek, afhangende van die posisie op die koepel (sien die figuur hierbo). Ek het gate in die basis van die IR-sensor geboor om die IR-sensors te monteer, en daarna die grond- en 5V-penne met draaddraad en 'n draadomhulsel (rooi en swart drade) verbind. Nadat ek grond en 5V gekoppel het, het ek lang draaddraad op elke uitset (geel), grond en 5V toegedraai om deur die koepel te loop.

Die seshoek- of vyfhoekige IR -sensorhouers is daarna aan die koepel, bokant die 3D -gedrukte verbindings, ge -epoksied, sodat die draad deur die koepel kon loop. Deur die sensors bo die verbindings te hê, kon ek ook toegang kry tot die potensiometers op die IR -sensors wat die sensitiwiteit van die sensors beheer. In die volgende stap sal ek beskryf hoe die uitsette van die IR -sensors aan multiplexers gekoppel is en in die Arduino gelees word.

Stap 8: Uitgang van veelvoudige sensor

Omdat die Arduino Uno slegs 14 digitale I/O -penne en 6 analoog -invoerpenne het en daar 120 sensorseine is wat gelees moet word, moet die koepel multiplexers in al die seine lees. Ek het gekies om vyf 24-kanaals multiplexers te bou, wat elk 24 van die IR-sensors lees (sien die elektroniese oorsigfiguur). Die 24-kanaals MUX bestaan uit 'n 8-kanaals MUX-uitbreidingskaart, 16-kanaals MUX-uitbreidingskaart en 2-kanaals MUX. Speldopskrifte is aan elke uitbreekbord gesoldeer sodat dit aan 'n prototipe -bord gekoppel kan word. Met 'n draad-omhulselgereedskap verbind ek toe die grond, 5V, en die stuurseinpenne van die MUX-uitbreekborde.

'N MUX met 24 kanale benodig vyf beheerseine, wat ek gekies het om aan pin 8-12 op die Arduino te koppel. Al vyf die 24-kanaals MUX ontvang dieselfde beheerseine van die Arduino, sodat ek die draad van die Arduino-penne aan die 24-kanaals MUX verbind het. Die digitale uitsette van die IR-sensors is gekoppel aan die ingangspennetjies van die 24-kanaals MUX sodat hulle in serie na die Arduino gelees kan word. Omdat daar in elke 120 sensoruitsette vyf afsonderlike penne is om te lees, is dit handig om voor te stel dat die koepel in vyf afsonderlike gedeeltes verdeel word wat bestaan uit 24 driehoeke (kyk die kleure van die koepel in figuur).

Deur Arduino-poortmanipulasie te gebruik, kan u vinnig die beheerseine verhoog wat deur penne 8-12 na die multiplexers gestuur word. Ek het 'n voorbeeldkode vir die bediening van die multiplexers hier aangeheg:

int numChannel = 24;

// UITSETTE // int s0 = 8; // MUX -beheer 0 - PORTbD int s1 = 9; // MUX -beheer 1 - PORTb int s2 = 10; // MUX -beheer 2 - PORTb int s3 = 11; // MUX -beheer 3 - PORTb int s4 = 12; // MUX -beheer 4 - PORTb // INVOER // int m0 = 3; // MUX -invoer 0 int m1 = 4; // MUX -invoer 1 int m2 = 5; // MUX -invoer 2 int m3 = 6; // MUX -invoer 3 int m4 = 7; // MUX -invoer 4 // VARIABLES // int arr0r; // digitale lees van MUX0 int arr1r; // digitale lees van MUX1 int arr2r; // digitale lees van MUX2 int arr3r; // digitale lees van MUX3 int arr4r; // digitale lees van MUX4 -leemte -opstelling () {// plaas u opstellingskode hier om een keer te werk: DDRB = B11111111; // stel Arduino -penne 8 tot 13 as invoer pinMode (s0, OUTPUT); pinMode (s1, OUTPUT); pinMode (s2, OUTPUT); pinMode (s3, OUTPUT); pinMode (s4, OUTPUT); pinMode (m0, INVOER); pinMode (m1, INVOER); pinMode (m2, INVOER); pinMode (m3, INVOER); pinMode (m4, INVOER); } void loop () {// plaas u hoofkode hier om herhaaldelik te werk: PORTB = B00000000; // SET bedieningspenne vir mux low vir (int i = 0; i <numChannel; i ++) {// Digitale leesuitset van MUX0 - MUX4 vir IR -sensor i // As IR -sensor LO is, word die driehoek deur die speler aangeraak. arr0r = digitalRead (m0); // lees van Mux 0, IR -sensor i arr1r = digitalRead (m1); // lees van Mux 1, IR -sensor i arr2r = digitalRead (m2); // lees van Mux 2, IR -sensor i arr3r = digitalRead (m3); // lees van Mux 3, IR -sensor i arr4r = digitalRead (m4); // lees van Mux 4, IR -sensor i // DOEN IETS MET MUX -INSETTE OF WINKEL HIER IN 'N ARRAY HIER // PORTB ++; // toename beheer seine vir MUX}}

Stap 9: Versprei lig met akriel

Om die lig van die LED's te versprei, het ek deursigtige akriel geskuur met 'n sirkelvormige baanskuurder. Die skuurmasjien is in 'n figuur 8-beweging oor beide kante van die akriel beweeg. Ek het gevind dat hierdie metode baie beter is as spuitverf van "matglas".

Nadat ek die akriel geskuur en skoongemaak het, het ek 'n lasersnyer gebruik om driehoeke uit te sny om oor die LED's te pas. Dit is moontlik om die akriel met 'n akriel snywerktuig of selfs 'n figuursaag te sny as die akriel nie kraak nie. Die akriel is oor die LED's gehou met 5 mm dik laaghout reghoeke wat ook met 'n lasersnyer gesny is. Hierdie klein planke is aan die stutte op die koepel vasgeplak, en die akriel driehoeke is op die planke ge -epoksied.

Stap 10: Musiek maak met die koepel met behulp van MIDI

Ek wou hê dat die koepel klank kan produseer, en ek het vyf MIDI -kanale opgestel, een vir elke subset van die koepel. U moet eers vyf MIDI -aansluitings aanskaf en dit koppel soos in die skema aangedui (sien hierdie tutoriaal van Arduino -ondersteuning vir meer inligting).

Omdat daar slegs een seriële pen op die Arduino Uno is (pen 2 gemerk as die TX-pen), moet u die seine wat na die vyf MIDI-aansluitings gestuur word, de-multiplex. Ek het dieselfde beheerseine gebruik (pen 8-12), omdat MIDI-seine op 'n ander tydstip gestuur word as wanneer die IR-sensors in die Arduino gelees word. Hierdie beheerseine word na 'n 8-kanaal demultiplexer gestuur sodat u kan beheer watter MIDI-aansluiting die MIDI-sein ontvang wat deur die Arduino geskep word. Die MIDI -seine is deur die Arduino gegenereer met die wonderlike MIDI -seinbiblioteek wat deur Francois Best geskep is. Hier is 'n voorbeeldkode vir die vervaardiging van verskeie MIDI -uitsette na verskillende MIDI -aansluitings met 'n Arduino Uno:

#include // sluit MIDI -biblioteek in

#define numChannel 24 // Aantal IR per driehoek #definieer numSections 5 // aantal afdelings in koepel, aantal 24 -kanaals MUX, aantal MIDI -aansluitings // UITGANTE // int s0 = 8; // MUX -beheer 0 - PORTbD int s1 = 9; // MUX -beheer 1 - PORTb int s2 = 10; // MUX -beheer 2 - PORTb int s3 = 11; // MUX -beheer 3 - PORTb int s4 = 12; // MUX -beheer 4 - PORTb // INVOER // int m0 = 3; // MUX -invoer 0 int m1 = 4; // MUX -invoer 1 int m2 = 5; // MUX -invoer 2 int m3 = 6; // MUX -invoer 3 int m4 = 7; // MUX -invoer 4 // VARIABLES // int arr0r; // digitale lees van MUX0 int arr1r; // digitale lees van MUX1 int arr2r; // digitale lees van MUX2 int arr3r; // digitale lees van MUX3 int arr4r; // digitale lees van MUX4 int midArr [numSections]; // Stoor of 'n noot deur een van die spelers ingedruk is int note2play [numSections]; // Stoor noot wat gespeel moet word as sensor aangeraak word int note [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; // pouse tyd tussen midi seine MIDI_CREATE_DEFAULT_INSTANCE (); ongeldige opstelling () {// plaas u opstellingskode hier om een keer te werk: DDRB = B11111111; // stel Arduino -penne 8 tot 13 as invoer MIDI.begin (MIDI_CHANNEL_OFF); pinMode (s0, UITGANG); pinMode (s1, OUTPUT); pinMode (s2, OUTPUT); pinMode (s3, OUTPUT); pinMode (s4, OUTPUT); pinMode (m0, INVOER); pinMode (m1, INVOER); pinMode (m2, INVOER); pinMode (m3, INVOER); pinMode (m4, INVOER); } void loop () {// plaas u hoofkode hier om herhaaldelik te werk: PORTB = B00000000; // SET bedieningspenne vir mux low vir (int i = 0; i <numChannel; i ++) {// Digitale leesuitset van MUX0 - MUX4 vir IR -sensor i // As IR -sensor LO is, word die driehoek deur die speler aangeraak. arr0r = digitalRead (m0); // lees van Mux 0, IR -sensor i arr1r = digitalRead (m1); // lees van Mux 1, IR -sensor i arr2r = digitalRead (m2); // lees van Mux 2, IR -sensor i arr3r = digitalRead (m3); // lees van Mux 3, IR -sensor i arr4r = digitalRead (m4); // lees van Mux 4, IR -sensor i as (arr0r == 0) // Sensor op afdeling 0 geblokkeer is {midArr [0] = 1; // Speler 0 het 'n noot getref, stel HI in sodat daar MIDI -uitset is vir speler 0 note2play [0] = note ; // Nota om vir speler 0} te speel as (arr1r == 0) // Sensor op afdeling 1 geblokkeer is {midArr [1] = 1; // Speler 0 het 'n noot getref, stel HI so dat daar MIDI -uitset is vir speler 0 note2play [1] = note ; // Nota om vir speler 0} te speel as (arr2r == 0) // Sensor op afdeling 2 geblokkeer is {midArr [2] = 1; // Speler 0 het 'n noot getref, stel HI so dat daar MIDI -uitset is vir speler 0 note2play [2] = note ; // Nota om vir speler 0} te speel as (arr3r == 0) // Sensor op afdeling 3 geblokkeer is {midArr [3] = 1; // Speler 0 het 'n noot getref, stel HI in sodat daar MIDI -uitset is vir speler 0 note2play [3] = note ; // Nota om vir speler 0} te speel as (arr4r == 0) // Sensor op afdeling 4 geblokkeer is {midArr [4] = 1; // Speler 0 het 'n noot getref, stel HI so dat daar MIDI -uitset is vir speler 0 note2play [4] = note ; // Nota om vir Player 0} PORTB ++ te speel; // toename beheer seine vir MUX} updateMIDI (); } ongeldig updateMIDI () {PORTB = B00000000; // SET bedieningspenne vir mux low if (midArr [0] == 1) // Speler 0 MIDI -uitvoer {MIDI.sendNoteOn (note2play [0], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [0], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // verhoog MUX as (midArr [1] == 1) // Speler 1 MIDI -uitset {MIDI.sendNoteOn (note2play [1], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [1], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // verhoog MUX as (midArr [2] == 1) // Speler 2 MIDI -uitset {MIDI.sendNoteOn (note2play [2], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [2], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // verhoog MUX as (midArr [3] == 1) // Speler 3 MIDI -uitvoer {MIDI.sendNoteOn (note2play [3], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [3], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // verhoog MUX as (midArr [4] == 1) // Speler 4 MIDI -uitset {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; }

Stap 11: Skakel die koepel aan

Daar is verskeie komponente wat in die koepel aangedryf moet word. U sal dus die versterkers van elke komponent moet bereken om die kragtoevoer wat u moet koop, te bepaal.

Die LED -strook: ek het ongeveer 3,75 meter van die Ws2801 LED -strook gebruik, wat 6,4W/meter verbruik. Dit stem ooreen met 24W (3,75*6,4). Om dit in ampère om te skakel, gebruik Power = stroom*volt (P = iV), waar V die spanning van die LED -strook is, in hierdie geval 5V. Daarom is die stroom wat van die LED's verkry word, 4,8A (24W/5V = 4,8A).

Die IR -sensors: Elke IR -sensor trek ongeveer 25mA, in totaal 3A vir 120 sensors.

Die Arduino: 100mA, 9V

Die multiplexers: Daar is vyf 24 -kanaals multiplexers wat elk bestaan uit 'n 16 -kanaals multiplexer en 8 -kanaals multiplexer. Die 8 -kanaals en 16 -kanaals MUX verbruik elk ongeveer 100mA. Daarom is die totale kragverbruik van die hele MUX 1A.

As ons hierdie komponente optel, sal die totale kragverbruik na verwagting ongeveer 9A wees. Die LED -strook, IR -sensors en multiplexers het insetspanning by 5V, en die Arduino het 'n ingangsspanning van 9V. Daarom het ek 'n 12V 15A kragtoevoer gekies, 'n 15A boksomskakelaar vir die omskakeling van die 12V na 5V en 'n 3A boksomskakelaar om 12V na 9V vir die Arduino om te skakel.

Stap 12: Circular Dome Base

Die koepel rus op 'n sirkelvormige stuk hout met 'n vyfhoek uit die middel gesny vir maklike toegang tot die elektronika. Om hierdie sirkelvormige basis te skep, is 'n 4x6 -laag laaghout met 'n hout CNC -router gesny. 'N Legkaart kan ook vir hierdie stap gebruik word. Nadat die voetstuk gesny is, is die koepel daaraan vasgemaak met klein 2x3 houtblokke.

Bo-op die basis het ek die kragtoevoer met epoxy gekoppel en die MUX's en Buck-omsetters met PCB-afstandhouers. Die afstandhouers is aan die laaghout vasgemaak met behulp van EZ Lok draadadapters.

Stap 13: Pentagon Dome Base

Benewens die sirkelvormige basis, het ek ook 'n vyfhoekige voetstuk vir die koepel gebou met 'n venster aan die onderkant. Hierdie venster en venster is ook gemaak van laaghout wat met 'n hout CNC -router gesny is. Die sye van die vyfhoek is gemaak van houtplanke, met 'n gaatjie aan die een kant om deur die verbindings te gaan. Met behulp van metaalhakies en 2x3 blokverbindings word die houtplanke aan die vyfhoekbasis geheg. 'N Kragskakelaar, MIDI -aansluitings en USB -aansluiting is aan 'n voorpaneel gekoppel wat ek met 'n lasersnyer geskep het. Die hele vyfhoekbasis word vasgeskroef aan die sirkelvormige basis wat in stap 12 beskryf is.

Ek het 'n venster aan die onderkant van die koepel geïnstalleer sodat almal na die koepel kan kyk om die elektronika te sien. Die glas is gemaak van akriel gesny met 'n lasersnyer en word ge -epoksied tot 'n sirkelvormige laaghout.

Stap 14: Die koepel programmeer

Daar is eindelose moontlikhede om die koepel te programmeer. Elke siklus van die kode neem die seine van die IR -sensors in, wat die driehoeke aandui wat deur iemand aangeraak is. Met hierdie inligting kan u die koepel met enige RGB -kleur kleur en/of 'n MIDI -sein produseer. Hier is 'n paar voorbeelde van programme wat ek vir die koepel geskryf het:

Kleur die koepel in: Elke driehoek loop deur vier kleure terwyl dit aangeraak word. Namate die kleure verander, word 'n arpeggio gespeel. Met hierdie program kan u die koepel op duisende verskillende maniere kleur.

Koepelmusiek: die koepel is gekleur met vyf kleure, elke afdeling stem ooreen met 'n ander MIDI -uitset. In die program kan u kies watter note elke driehoek speel. Ek het gekies om te begin by middel C bo -aan die koepel en die toonhoogte te verhoog namate die driehoeke nader aan die basis beweeg. Omdat daar vyf uitsette is, is hierdie program ideaal om verskeie mense gelyktydig die koepel te laat speel. Deur 'n MIDI -instrument of MIDI -sagteware te gebruik, kan hierdie MIDI -seine soos enige instrument laat klink.

Simon: Ek het 'n weergawe geskryf van Simon, die klassieke geheueverligte spel. 'N Willekeurige reeks ligte word een vir een oor die hele koepel verlig. In elke beurt moet die speler die volgorde kopieer. As die speler korrek by die reeks pas, word 'n ekstra lig by die reeks gevoeg. Die hoë telling word op een van die dele van die koepel gestoor. Hierdie speletjie is ook baie lekker om met verskeie mense te speel.

Pong: Waarom speel jy nie pong op 'n koepel nie? 'N Bal versprei oor die koepel totdat dit die spaan tref. As dit gebeur, word 'n MIDI -sein geproduseer wat aandui dat die spaan die bal getref het. Die ander speler moet dan die spaan langs die onderkant van die koepel rig sodat dit die bal terugslaan.

Stap 15: Foto's van voltooide koepel

Groot prys in die Arduino -wedstryd 2016

Tweede prys in die Remix -wedstryd 2016

Tweede prys in die Make it Glow Contest 2016