Interactieve geodetische LED-koepel - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

Ik bouwde een geodetische koepel bestaande uit 120 driehoeken met een LED en sensor bij elke driehoek. Elke LED kan afzonderlijk worden geadresseerd en elke sensor is specifiek afgestemd op een enkele driehoek. De dome is geprogrammeerd met een Arduino om op te lichten en een MIDI-signaal te produceren, afhankelijk van in welke driehoek je je hand plaatst.

Ik heb de koepel ontworpen als een leuk display dat mensen interesseert in licht, elektronica en geluid. Omdat de koepel mooi in vijf delen is verdeeld, heb ik de koepel zo ontworpen dat hij vijf afzonderlijke MIDI-uitgangen heeft die elk een ander geluid kunnen hebben. Dit maakt de dome tot een gigantisch muziekinstrument, ideaal om met meerdere mensen tegelijk muziek te spelen. Naast het spelen van muziek heb ik de koepel ook geprogrammeerd voor lichtshows en het spelen van een vertolking van Simon en Pong. De uiteindelijke structuur is iets meer dan een meter in diameter en 70 cm hoog, en is voornamelijk gebouwd met hout, acryl en 3D-geprinte onderdelen.

Er zijn verschillende geweldige Instructables op LED-tafels en kubussen die me inspireerden om dit project te starten. Ik wilde echter proberen de LED's in een andere geometrie te rangschikken. Ik kon geen betere structuur voor het project bedenken dan een geodetische koepel, die ook goed is gedocumenteerd op Instructables. Dit project is dus een remix/mashup van LED-tafels en geodetische koepels. Hieronder staan links naar de LED-tafel en geodetische koepel Instructables die ik aan het begin van het project heb uitgecheckt.

LED tafels en kubussen:

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

Geodetische koepel:

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

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

Stap 1: Bevoorradingslijst

Materialen:

1. Hout voor stutten van koepel en basis van koepel (hoeveelheid is afhankelijk van type en grootte koepel)

2. Adresseerbare LED-strip (16,4 ft / 5 m adresseerbare kleuren LED Pixel Strip 160 leds Ws2801 Dc5v)

3. Arduino Uno (Atmega328 - gemonteerd)

4. Prototype bord (Penta Angel dubbelzijdig prototype PCB universeel (7x9cm))

5. Acryl voor het verspreiden van LED's (gegoten acrylplaat, helder, 12 "x 12" x 0,118 "afmetingen)

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

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

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

9. 120 IR-sensoren (Infrared Obstacle Avoidance Sensor Module)

10. Vijf 16-kanaals multiplexers (analoge/digitale MUX Breakout - CD74HC4067)

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

12. Vijf 2-kanaals multiplexers (MAX4544CPA+)

13. Draadwikkeldraad (PCB-soldeer 0,25 mm vertind koperen snoer Dia draadwikkeldraad 305M 30AWG rood)

14. Aansluitdraad (Solid Core, 22 AWG)

15. Pin-headers (Gikfun 1 x 40 pin 2,54 mm enkele rij afgescheiden mannelijke pin-header)

16. Vijf MIDI-aansluitingen (Breadboard-vriendelijke MIDI-aansluiting (5-pins DIN))

17. Tien 220ohm-weerstanden voor MIDI-aansluitingen

18. Afstandhouders voor montage van elektronica aan dome (afstandhouder Hex M3 Male x M3 Female)

19. Draadadapters om afstandhouders aan hout te verbinden (E-Z Lok schroefdraadinzet, messing, mesdraad)

20. Epoxy- of Gorilla-superlijm

21. Elektrische tape

22. Soldeer

Gereedschap:

1. Soldeerstation

2. Boormachine

3. Cirkelzaag

4. Vlakschuurmachine

5. Decoupeerzaag

6. Verstekzaag

7. Gradenboog

8. 3D-printer

9. Draadknippers

10. Draadwikkelgereedschap

11. Lasersnijder voor het snijden van LED-platen (optioneel)

12. CNC-shopbot voor basis van koepel (optioneel)

Stap 2: De geodetische koepel ontwerpen

Zoals ik in de intro al zei, zijn er verschillende online bronnen voor het bouwen van je eigen geodetische koepel. Deze sites bieden koepelcalculators die de lengte van elke zijde (d.w.z. steun) en het aantal benodigde connectoren bepalen voor elk type koepel dat u wilt bouwen. De complexiteit van een geodetische koepel (d.w.z. de dichtheid van driehoeken) wordt gespecificeerd door zijn klasse (1V, 2V, 3V, enzovoort), waarbij een hogere complexiteit een betere benadering wordt van een perfect bolvormig oppervlak. Om uw eigen koepel te bouwen, moet u eerst een koepeldiameter en klasse selecteren.

Ik gebruikte een site genaamd Domerama om me te helpen bij het ontwerpen van een 4V-koepel die was afgekapt tot 5/12 van een bol met een straal van 40 cm. Voor dit type koepel zijn er zes verschillende lengtes stutten:

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

Dat zijn in totaal 190 stutten die samen 2223 cm (73 ft) materiaal opleveren. Ik gebruikte 1x3 (3/4" × 2-1 / 2") grenen hout voor de stutten in deze koepel. Voor het verbinden van de stutten heb ik connectoren ontworpen en 3D geprint met behulp van Autocad. De STL-bestanden kunnen aan het einde van deze stap worden gedownload. Het aantal connectoren voor een 4V 5/12 dome is:

20 X 4-connector

6 X 5-connector

45 X 6-connector

In de volgende stap beschrijf ik hoe deze koepel is gebouwd met de houten stutten en de 3D-geprinte connectoren die ik heb ontworpen.

Stap 3: Koepel bouwen met stutten en connectoren

Met behulp van de berekeningen van Domerama voor een 4V 5/12-koepel heb ik de stutten gesneden met een cirkelzaag. De 190 stutten werden gelabeld en na het snijden in een doos geplaatst. De 71 connectoren (20 vierconnectoren, 6 vijfconnectoren en 45 zesconnectoren) zijn 3D-geprint met een Makerbot. De houten stutten werden in de connectoren gestoken volgens het diagram gemaakt door Domerama. Ik begon de constructie vanaf de bovenkant en bewoog radiaal naar buiten.

Nadat alle stutten waren aangesloten, heb ik één stut tegelijk verwijderd en epoxy aan het hout en de connector toegevoegd. De connectoren zijn ontworpen om flexibel te zijn in de manier waarop ze de constructies met elkaar verbinden, dus het was belangrijk om de symmetrie van de koepel te controleren voordat epoxy werd toegevoegd.

Stap 4: Lasersnijden en montage van grondplaten

Nu het skelet van de koepel is geconstrueerd, is het tijd om de driehoekige grondplaten te snijden. Deze baseplates worden aan de onderkant van de stutten bevestigd en worden gebruikt om de LED's op de dome te monteren. Ik heb aanvankelijk de grondplaten uit multiplex van 5 mm (3/16 ) dik gesneden door de vijf verschillende driehoeken op de koepel te meten: AAB (30 driehoeken), BCC (25 driehoeken), DDE (20 driehoeken), CDF (40 driehoeken), en EEE (5 driehoeken). De afmetingen van elke zijde en de vorm van de driehoeken werden bepaald met behulp van een koepelcalculator (Domerama) en wat geometrie. Na het uitsnijden van testgrondplaten met een decoupeerzaag, tekende ik het driehoekige ontwerp met Coral Draw en sneed ik de resterende grondplaten met een lasersnijder (veel sneller!). Als u niet over een lasersnijder beschikt, kunt u de grondplaten met een liniaal en gradenboog op multiplex tekenen en ze allemaal met een decoupeerzaag uitzagen. Nadat de grondplaten zijn gesneden, wordt de koepel omgedraaid en worden de platen met houtlijm op de koepel gelijmd.

Stap 5: Elektronica-overzicht

In de bovenstaande afbeelding wordt een schema weergegeven van de elektronica voor de koepel. Een Arduino Uno wordt gebruikt voor het schrijven en lezen van signalen voor de dome. Om de koepel te verlichten wordt een RGB LED-strip over de koepel gelopen zodat op elk van de 120 driehoeken een LED komt te staan. Bekijk deze instructable voor informatie over hoe een LED-strip werkt. Elke LED kan afzonderlijk worden aangesproken met behulp van de Arduino, die een serieel data- en kloksignaal voor de strip produceert (zie de A0- en A1-pin in het schema). Met alleen de strip en deze twee signalen kun je een geweldige lichtkoepel hebben. Er zijn andere manieren om signalen voor veel LED's van een Arduino te schrijven, zoals Charlieplexing en schuifregisters.

Om met de koepel te communiceren, heb ik boven elke LED een IR-sensor geplaatst. Deze sensoren worden gebruikt om te detecteren wanneer iemands hand zich in de buurt van een driehoek op de koepel bevindt. Omdat elke driehoek op de dome zijn eigen IR-sensor heeft en er 120 driehoeken zijn, zul je voor de Arduino een soort multiplexing moeten doen. Ik besloot om vijf 24-kanaals multiplexers (MUX) te gebruiken voor de 120 sensoren op de dome. Hier is een instructable over multiplexen, als je niet bekend bent. Een 24-kanaals MUX vereist vijf stuursignalen. Ik koos pinnen 8-12 op de Arduino, zodat ik poortmanipulatie kon doen (zie stap 10 voor meer informatie). De output van de MUX-boards wordt ingelezen met pinnen 3-7.

Ik heb ook vijf MIDI-uitgangen op de dome geplaatst, zodat deze geluid kon produceren (stap 11). Met andere woorden, vijf mensen kunnen de dome tegelijkertijd bespelen, waarbij elke uitgang een ander geluid speelt. Er is slechts één TX-pin op de Arduino, dus vijf MIDI-signalen vereisen demultiplexing. Omdat de MIDI-uitgang op een ander tijdstip wordt geproduceerd dan de IR-sensormeting, heb ik dezelfde besturingssignalen gebruikt.

Nadat alle IR-sensoringangen in de Arduino zijn ingelezen, kan de dome oplichten en geluiden afspelen, hoe je de Arduino ook programmeert. Ik heb een paar voorbeelden in stap 14 van deze instructable.

Stap 6: LED's op de koepel monteren

Omdat de koepel zo groot is, moet de LED-strip worden doorgesneden om op elke driehoek één LED te plaatsen. Elke LED wordt met superlijm op de driehoek gelijmd. Aan weerszijden van de LED wordt een gat geboord door de grondplaat om kabels door de koepel te leiden. Vervolgens heb ik bij elk contact op de LED aansluitdraad gesoldeerd (5V, aarde, klok, signaal) en de draden door de grondplaat geleid. Deze draden zijn zo afgeknipt dat ze lang genoeg zijn om de volgende LED op de koepel te bereiken. De draden worden doorgetrokken naar de volgende LED en het proces wordt voortgezet. Ik heb de LED's aangesloten in een configuratie die de benodigde hoeveelheid draad tot een minimum zou beperken, terwijl het toch zinvol was om de LED's later met behulp van de Arduino te adresseren. Een kleinere koepel zou het snijden van de strip overbodig maken en veel tijd besparen bij het solderen. Een andere optie is het gebruik van aparte RGB LEDS met schuifregisters.

Seriële communicatie naar de strip wordt bereikt met behulp van twee pinnen (een data- en klokpen) van de Arduino. Met andere woorden, de gegevens voor het verlichten van de koepel worden doorgegeven van de ene LED naar de volgende wanneer deze de datapin verlaat. Hier is een voorbeeldcode die is aangepast van dit Arduino-forum:

// Laat de hele koepel de intensiteit van een enkele kleur verhogen en verlagen

#define numLeds 120 // Aantal LED's // OUTPUT PINS // int clockPin = A1; // definieer klokpin int dataPin = A0; // definieer gegevenspin // VARIABELEN // int red [numLeds]; // Initialiseer array voor LED-strip int groen [numLeds]; // Initialiseer array voor LED-strip int blauw [numLeds]; // Initialiseer array voor LED-strip //CONSTANT dubbele schaal 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}; // fractie van intensiteit van LED's void setup () { pinMode (clockPin, OUTPUT); pinMode (dataPin, UITGANG); memset (rood, 0, numLeds); memset (groen, 0, numLeds); memset (blauw, 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, groenA); shiftOut(dataPin, clockPin, MSBFIRST, blueA); } } void loop() { for (int p = 0; p < 20; p++) // loop voor het verhogen van de lichtintensiteit van de dome { double scale = scaleA[p]; vertraging(20); for (int i = 0; i < numLeds; i++) // doorloop alle LEDS { red = 255 * scale; groen = 80 * schaal; blauw = 0; } updatestring (rood, groen, blauw); // update ledstrip } }

Stap 7: Ontwerp en implementatie van sensormontage

Ik besloot om IR-sensoren te gebruiken voor de koepel. Deze sensoren hebben een IR LED en ontvanger. Wanneer een object voor de sensor komt, wordt een deel van de IR-straling van de IR-led naar de ontvanger gereflecteerd. Ik begon dit project door mijn eigen IR-sensoren te maken, die waren gebaseerd op de instructable van Richardouvina. Al het solderen duurde veel te lang, dus kocht ik 120 IR-sensoren van eBay die elk een digitale output produceren. De drempel van de sensor wordt ingesteld met een potentiometer op het bord, zodat de output alleen hoog is als een hand in de buurt van die driehoek is.

Elke driehoek bestaat uit een multiplex LED-basisplaat, een plaat van diffuus acryl die ongeveer 2,5 cm boven de LED-plaat is gemonteerd, en een IR-sensor. De sensor voor elke driehoek was gemonteerd op een plaat van dun triplex in de vorm van een vijfhoek of zeshoek, afhankelijk van de positie op de koepel (zie de afbeelding hierboven). Ik boorde gaten in de basis van de IR-sensor om de IR-sensoren te monteren en verbond vervolgens de grond- en 5V-pinnen met wire-wrap-draad en een wire-wrap-tool (rode en zwarte draden). Nadat ik aarde en 5V had aangesloten, wikkelde ik lange draadomwikkelde draad op elke uitgang (geel), aarde en 5V om door de koepel te lopen.

De zeshoekige of vijfhoekige IR-sensorbevestigingen werden vervolgens geëpoxeerd op de koepel, recht boven de 3D-geprinte connectoren, zodat de draad door de koepel kon lopen. Door de sensoren boven de connectoren te plaatsen, kon ik ook toegang krijgen tot de potentiometers op de IR-sensoren die de gevoeligheid van de sensoren regelen. In de volgende stap zal ik beschrijven hoe de uitgangen van de IR-sensoren worden aangesloten op multiplexers en in de Arduino worden ingelezen.

Stap 8: Sensoruitgang multiplexen

Omdat de Arduino Uno slechts 14 digitale I/O-pinnen en 6 analoge ingangspinnen heeft en er 120 sensorsignalen zijn die gelezen moeten worden, heeft de dome multiplexers nodig om alle signalen in te lezen. Ik koos ervoor om vijf 24-kanaals multiplexers te bouwen, die elk 24 van de IR-sensoren uitlezen (zie de elektronica-overzichtsfiguur). De 24-kanaals MUX bestaat uit een 8-kanaals MUX-breakoutboard, een 16-kanaals MUX-breakoutboard en een 2-kanaals MUX. Op elk breakout-bord werden pin-headers gesoldeerd, zodat ze op het prototype-bord konden worden aangesloten. Met behulp van een wire-wrap-tool heb ik vervolgens aarde, 5V en de stuursignaalpinnen van de MUX-breakout-kaarten aangesloten.

Een 24-kanaals MUX vereist vijf stuursignalen, die ik heb gekozen om aan te sluiten op pin 8-12 op de Arduino. Alle vijf 24-kanaals MUX ontvangen dezelfde besturingssignalen van de Arduino, dus ik heb de draad van de Arduino-pinnen aangesloten op de 24-kanaals MUX. De digitale uitgangen van de IR-sensoren zijn verbonden met de ingangspinnen van de 24-kanaals MUX zodat ze serieel kunnen worden ingelezen naar de Arduino. Omdat er vijf afzonderlijke pinnen zijn voor het uitlezen van alle 120 sensoruitgangen, is het handig om je voor te stellen dat de koepel wordt opgesplitst in vijf afzonderlijke secties bestaande uit 24 driehoeken (controleer de kleuren van de koepel in de afbeelding).

Met behulp van Arduino-poortmanipulatie kunt u de besturingssignalen die door pinnen 8-12 naar de multiplexers worden verzonden snel verhogen. Ik heb hier een voorbeeldcode voor het bedienen van de multiplexers bijgevoegd:

int numChannel = 24;

// UITGANGEN // int s0 = 8; // MUX-besturing 0 - PORTbD int s1 = 9; // MUX-besturing 1 - PORTb int s2 = 10; // MUX-besturing 2 - PORTb int s3 = 11; // MUX-besturing 3 - PORTb int s4 = 12; // MUX-besturing 4 - PORTb // INGANGEN // int m0 = 3; // MUX-ingang 0 int m1 = 4; // MUX-ingang 1 int m2 = 5; // MUX-ingang 2 int m3 = 6; // MUX-ingang 3 int m4 = 7; // MUX-ingang 4 // VARIABELEN // int arr0r; // digitaal lezen van MUX0 int arr1r; // digitaal lezen van MUX1 int arr2r; // digitaal lezen van MUX2 int arr3r; // digitaal lezen van MUX3 int arr4r; // digitaal lezen van MUX4 void setup () {// plaats hier je setup-code om een keer uit te voeren: DDRB = B1111111; // stelt Arduino-pinnen 8 tot 13 in als ingangen pinMode (s0, OUTPUT); pinMode (s1, UITGANG); pinMode (s2, UITGANG); pinMode(s3, UITGANG); pinMode (s4, UITGANG); pinMode (m0, INGANG); pinMode (m1, INGANG); pinMode (m2, INGANG); pinMode (m3, INGANG); pinMode (m4, INGANG); } void loop() { // plaats hier je hoofdcode, om herhaaldelijk uit te voeren: PORTB = B00000000; // SET control pins voor mux low voor (int i = 0; i < numChannel; i++) {// Digitale leesuitgang van MUX0 - MUX4 voor IR-sensor i // Als IR-sensor LO is, wordt de driehoek aangeraakt door de speler. arr0r = digitalRead (m0); // lezen van Mux 0, IR-sensor i arr1r = digitalRead (m1); // lezen van Mux 1, IR-sensor i arr2r = digitalRead (m2); // lezen van Mux 2, IR-sensor i arr3r = digitalRead (m3); // lezen van Mux 3, IR-sensor i arr4r = digitalRead (m4); // lezen van Mux 4, IR-sensor i // DOE IETS MET MUX-INGANGEN OF BEWAAR HIER IN EEN ARRAY // PORTB ++; // increment besturingssignalen voor MUX } }

Stap 9: licht verspreiden met acryl

Om het licht van de LED's te verspreiden, heb ik transparant acryl geschuurd met een cirkelvormige vlakschuurmachine. De schuurmachine werd in een 8-beweging over beide zijden van het acryl bewogen. Ik vond deze methode veel beter dan "frosted glass" spuitverf.

Na het schuren en opruimen van het acryl, heb ik een lasersnijder gebruikt om driehoeken uit te snijden die over de LED's passen. Het is mogelijk om het acryl te snijden met een acryl snijgereedschap of zelfs een decoupeerzaag als het acryl niet barst. Het acryl werd over de LED's gehouden door 5 mm dikke multiplex rechthoeken die ook waren gesneden met een lasersnijder. Deze kleine planken werden op de stutten op de koepel gelijmd en de acryldriehoeken werden op de planken geëpoxeerd.

Stap 10: Muziek maken met de koepel met behulp van MIDI

Ik wilde dat de dome geluid zou kunnen produceren, dus stelde ik vijf MIDI-kanalen in, één voor elke subset van de dome. Je moet eerst vijf MIDI-aansluitingen kopen en deze aansluiten zoals weergegeven in het schema (zie deze tutorial van Arduino-ondersteuning voor meer info).

Omdat er slechts één seriële zendpin op de Arduino Uno is (pin 2 aangeduid als de TX-pin), moet je de signalen die naar de vijf MIDI-aansluitingen worden verzonden, de-multiplexen. Ik heb dezelfde stuursignalen gebruikt (pin 8-12), omdat MIDI-signalen op een ander tijdstip worden verzonden dan wanneer de IR-sensoren in de Arduino worden ingelezen. Deze stuursignalen worden naar een 8-kanaals demultiplexer gestuurd, zodat je bepaalt welke MIDI-aansluiting het door de Arduino gecreëerde MIDI-signaal ontvangt. De MIDI-signalen werden gegenereerd door de Arduino met de geweldige MIDI-signaalbibliotheek gemaakt door Francois Best. Hier is een voorbeeldcode voor het produceren van meerdere MIDI-uitgangen naar verschillende MIDI-aansluitingen met een Arduino Uno:

#include // include MIDI-bibliotheek

#define numChannel 24 //Aantal IR per Triangle #define numSections 5 // aantal secties in dome, aantal 24-kanaals MUX, aantal MIDI-aansluitingen // OUTPUTS // int s0 = 8; // MUX-besturing 0 - PORTbD int s1 = 9; // MUX-besturing 1 - PORTb int s2 = 10; // MUX-besturing 2 - PORTb int s3 = 11; // MUX-besturing 3 - PORTb int s4 = 12; // MUX-besturing 4 - PORTb // INGANGEN // int m0 = 3; // MUX-ingang 0 int m1 = 4; // MUX-ingang 1 int m2 = 5; // MUX-ingang 2 int m3 = 6; // MUX-ingang 3 int m4 = 7; // MUX-ingang 4 // VARIABELEN // int arr0r; // digitaal lezen van MUX0 int arr1r; // digitaal lezen van MUX1 int arr2r; // digitaal lezen van MUX2 int arr3r; // digitaal lezen van MUX3 int arr4r; // digitaal gelezen van MUX4 int midArr [numSections]; // Bewaar of een noot al dan niet is ingedrukt door een van de spelers int note2play[numSections]; // Sla de noot op die moet worden gespeeld als de sensor wordt aangeraakt 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; // pauzetijd tussen midi-signalen MIDI_CREATE_DEFAULT_INSTANCE(); void setup () {// plaats hier uw setup-code om een keer uit te voeren: DDRB = B11111111; // stelt Arduino-pinnen 8 tot 13 in als ingangen MIDI.begin (MIDI_CHANNEL_OFF); pinMode (s0, UITGANG); pinMode (s1, UITGANG); pinMode (s2, UITGANG); pinMode(s3, UITGANG); pinMode (s4, UITGANG); pinMode (m0, INGANG); pinMode (m1, INGANG); pinMode (m2, INGANG); pinMode (m3, INGANG); pinMode (m4, INGANG); } void loop() { // plaats hier je hoofdcode, om herhaaldelijk uit te voeren: PORTB = B00000000; // SET control pins voor mux low voor (int i = 0; i < numChannel; i++) {// Digitale leesuitgang van MUX0 - MUX4 voor IR-sensor i // Als IR-sensor LO is, wordt de driehoek aangeraakt door de speler. arr0r = digitalRead (m0); // lezen van Mux 0, IR-sensor i arr1r = digitalRead (m1); // lezen van Mux 1, IR-sensor i arr2r = digitalRead (m2); // lezen van Mux 2, IR-sensor i arr3r = digitalRead (m3); // lezen van Mux 3, IR-sensor i arr4r = digitalRead (m4); // lezen van Mux 4, IR-sensor i if (arr0r == 0)// Sensor op sectie 0 was geblokkeerd {midArr[0] = 1; // Speler 0 heeft een noot geraakt, stel HI in zodat er MIDI-uitvoer is voor speler 0 note2play[0] = notes; // Opmerking om te spelen voor speler 0 } als (arr1r == 0)// Sensor op sectie 1 was geblokkeerd { midArr[1] = 1; // Speler 0 heeft een noot geraakt, stel HI in zodat er MIDI-uitvoer is voor speler 0 note2play[1] = notes; // Opmerking om te spelen voor speler 0 } als (arr2r == 0)// Sensor op sectie 2 was geblokkeerd { midArr[2] = 1; // Speler 0 heeft een noot geraakt, stel HI in zodat er MIDI-uitvoer is voor speler 0 note2play[2] = notes; // Opmerking om te spelen voor speler 0 } als (arr3r == 0)// Sensor op sectie 3 was geblokkeerd { midArr[3] = 1; // Speler 0 heeft een noot geraakt, stel HI in zodat er MIDI-uitvoer is voor speler 0 note2play[3] = notes; // Opmerking om te spelen voor speler 0 } als (arr4r == 0)// Sensor op sectie 4 was geblokkeerd { midArr[4] = 1; // Speler 0 heeft een noot geraakt, stel HI in zodat er MIDI-uitvoer is voor speler 0 note2play[4] = notes; // Opmerking om te spelen voor speler 0 } PORTB ++; // increment besturingssignalen voor MUX } updateMIDI (); } void updateMIDI() { PORTB = B00000000; // SET control pins voor mux low if (midArr[0] == 1) // Player 0 MIDI output {MIDI.sendNoteOn(note2play[0], 127, 1); vertraging Microseconden (pauzeMidi); MIDI.sendNoteOff(note2play[0], 127, 1); vertraging Microseconden (pauzeMidi); } PORTB ++; // MUX verhogen als (midArr [1] == 1) // Speler 1 MIDI-uitgang {MIDI.sendNoteOn(note2play[1], 127, 1); vertraging Microseconden (pauzeMidi); MIDI.sendNoteOff(note2play[1], 127, 1); vertraging Microseconden (pauzeMidi); } PORTB ++; // MUX verhogen als (midArr [2] == 1) // Speler 2 MIDI-uitvoer {MIDI.sendNoteOn (note2play [2], 127, 1); vertraging Microseconden (pauzeMidi); MIDI.sendNoteOff(note2play[2], 127, 1); vertraging Microseconden (pauzeMidi); } PORTB ++; // MUX verhogen als (midArr [3] == 1) // Speler 3 MIDI-uitvoer {MIDI.sendNoteOn (note2play [3], 127, 1); vertraging Microseconden (pauzeMidi); MIDI.sendNoteOff(note2play[3], 127, 1); vertraging Microseconden (pauzeMidi); } PORTB ++; // MUX verhogen als (midArr [4] == 1) // Speler 4 MIDI-uitgang {MIDI.sendNoteOn(note2play[4], 127, 1); vertraging Microseconden (pauzeMidi); MIDI.sendNoteOff(note2play[4], 127, 1); vertraging Microseconden (pauzeMidi); } midArr[0] = 0; midArr[1] = 0; midArr[2] = 0; midArr[3] = 0; midArr[4] = 0; }

Stap 11: De koepel van stroom voorzien

Er zijn verschillende componenten die in de dome van stroom moeten worden voorzien. U moet daarom het ampèreverbruik van elk onderdeel berekenen om te bepalen welke voeding u moet kopen.

De LED-strip: Ik heb ongeveer 3,75 meter van de Ws2801 LED-strip gebruikt, die 6,4 W/meter verbruikt. Dit komt overeen met 24W (3,75*6,4). Om dit om te rekenen naar ampère, gebruik je Power = stroom*volt (P=iV), waarbij V de spanning van de ledstrip is, in dit geval 5V. Daarom is de stroom die uit de LED's wordt getrokken 4,8A (24W/5V = 4,8A).

De IR-sensoren: Elke IR-sensor trekt ongeveer 25mA, in totaal 3A voor 120 sensoren.

De Arduino: 100mA, 9V

De multiplexers: Er zijn vijf 24-kanaals multiplexers die elk bestaan uit een 16-kanaals multiplexer en een 8-kanaals multiplexer. De 8-kanaals en 16-kanaals MUX verbruiken elk ongeveer 100mA. Daarom is het totale stroomverbruik van alle MUX 1A.

Als je deze componenten bij elkaar optelt, zal het totale stroomverbruik naar verwachting rond de 9A liggen. De LED-strip, IR-sensoren en multiplexers hebben een ingangsspanning van 5V en de Arduino heeft een ingangsspanning van 9V. Daarom heb ik gekozen voor een 12V 15A voeding, een 15A buck converter voor het converteren van de 12V naar 5V, en een 3A buck converter voor het converteren van 12V naar 9V voor de Arduino.

Stap 12: Ronde koepelbasis

De koepel rust op een rond stuk hout met een vijfhoek uit het midden gesneden voor gemakkelijke toegang tot de elektronica. Om deze cirkelvormige basis te maken, werd een 4x6 'plaat multiplex gesneden met behulp van een houten CNC-router. Voor deze stap kan ook een puzzel worden gebruikt. Nadat de basis was gesneden, werd de koepel eraan bevestigd met behulp van kleine 2x3 blokken hout.

Bovenop de basis heb ik de voeding bevestigd met epoxy en de MUX's en Buck-converters met PCB-afstandhouders. De afstandhouders werden aan het triplex bevestigd met behulp van E-Z Lok-draadadapters.

Stap 13: Pentagon Dome Base

Naast de ronde basis heb ik ook een vijfhoekige basis gemaakt voor de koepel met een kijkvenster aan de onderkant. Deze basis en het kijkvenster zijn ook gemaakt van multiplex dat is gesneden met een houten CNC-router. De zijkanten van de vijfhoek zijn gemaakt van houten planken met aan één kant een gat waar de connectoren doorheen kunnen. Met behulp van metalen beugels en 2x3 blokverbindingen worden de houten planken bevestigd aan de vijfhoekige basis. Een aan / uit-schakelaar, MIDI-connectoren en USB-connector zijn bevestigd aan een voorpaneel dat ik heb gemaakt met behulp van een lasersnijder. De hele vijfhoekige basis wordt op de ronde basis geschroefd die in stap 12 is beschreven.

Ik heb een raam in de onderkant van de koepel geïnstalleerd, zodat iedereen in de koepel kan kijken om de elektronica te zien. Het kijkglas is gemaakt van acryl dat met een lasersnijder is gesneden en is geëpoxeerd op een cirkelvormig stuk multiplex.

Stap 14: De koepel programmeren

Er zijn oneindig veel mogelijkheden om de dome te programmeren. Elke cyclus van de code neemt de signalen van de IR-sensoren op, die de driehoeken aangeven die door iemand zijn aangeraakt. Met deze informatie kunt u de dome kleuren met elke RGB-kleur en/of een MIDI-signaal produceren. Hier zijn een paar voorbeelden van programma's die ik voor de dome heb geschreven:

Kleur de koepel: elke driehoek doorloopt vier kleuren wanneer deze wordt aangeraakt. Als de kleuren veranderen, wordt een arpeggio gespeeld. Met dit programma kun je de koepel op duizenden verschillende manieren kleuren.

Koepelmuziek: de koepel is gekleurd met vijf kleuren, waarbij elke sectie overeenkomt met een andere MIDI-uitgang. In het programma kun je kiezen welke noten elke driehoek speelt. Ik koos ervoor om bij de middelste C bovenaan de koepel te beginnen en de toonhoogte te vergroten naarmate de driehoeken dichter bij de basis kwamen. Omdat er vijf uitgangen zijn, is dit programma ideaal om meerdere mensen tegelijk op de dome te laten spelen. Met behulp van een MIDI-instrument of MIDI-software kunnen deze MIDI-signalen klinken als elk instrument.

Simon: Ik heb een versie van Simon geschreven, het klassieke memory light-up-spel. Een willekeurige reeks lichten wordt één voor één over de hele koepel verlicht. In elke beurt moet de speler de reeks kopiëren. Als de speler de reeks correct matcht, wordt er een extra licht aan de reeks toegevoegd. De hoogste score wordt opgeslagen op een van de secties van de koepel. Dit spel is ook erg leuk om met meerdere mensen te spelen.

Pong: Waarom speel je geen pong op een koepel? Een bal verspreidt zich over de koepel totdat hij de peddel raakt. Wanneer dit het geval is, wordt een MIDI-signaal geproduceerd, wat aangeeft dat de peddel de bal heeft geraakt. De andere speler moet dan de peddel langs de onderkant van de koepel richten zodat deze de bal terugslaat.

Stap 15: Foto's van voltooide koepel

Hoofdprijs in de Arduino-wedstrijd 2016

Tweede prijs in de Remix Contest 2016

Tweede prijs in de Make it Glow-wedstrijd 2016