Interaktív geodéziai LED -kupola: 15 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:42

Geodéziai kupolát építettem, amely 120 háromszögből állt, mindegyik háromszögben LED -del és érzékelővel. Minden LED külön -külön címezhető, és minden érzékelő kifejezetten egyetlen háromszöghez van hangolva. A kupola Arduino programozásával világít és MIDI jelet ad ki attól függően, hogy melyik háromszögbe helyezi a kezét.

A kupolát szórakoztató kijelzőnek terveztem, amely felkelti az emberek érdeklődését a fény, az elektronika és a hang iránt. Mivel a kupola szépen öt részre oszlik, úgy terveztem a kupolát, hogy öt különálló MIDI -kimenettel rendelkezzen, amelyek mindegyike eltérő hanggal rendelkezhet. Ez teszi a kupolát óriási hangszerré, amely ideális több ember egyidejű zenéléséhez. A zenélés mellett programoztam a kupolát fényműsorokra és Simon és Pong feldolgozásának lejátszására is. A végső szerkezet valamivel több mint egy méter átmérőjű és 70 cm magas, és elsősorban fából, akrilból és 3D nyomtatott alkatrészekből épül fel.

Számos nagyszerű utasítás található a LED asztalokon és kockákon, amelyek inspiráltak a projekt elindítására. Azonban meg akartam próbálni a LED -eket más geometriába rendezni. Nem tudtam jobb konstrukciót elképzelni a projekthez, mint egy geodéziai kupola, amely szintén jól dokumentált az Instructables -en. Tehát ez a projekt egy LED asztalok és geodéziai kupolák remixje/mashupja. Az alábbiakban linkek találhatók a LED asztalra és a geodéziai kupola utasításokra, amelyeket a projekt elején megnéztem.

LED asztalok és kockák:

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

Geodéziai kupola:

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

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

1. lépés: Ellátási lista

Anyagok:

1. Fa a kupola és a kupola alátámasztásához (mennyiség függ a kupola típusától és méretétől)

2. Címezhető LED szalag (16,4 láb/5 m címezhető színes LED Pixel Strip 160leds Ws2801 Dc5v)

3. Arduino Uno (Atmega328 - összeszerelt)

4. Prototípus tábla (Penta Angel Double-Side Prototype PCB Universal (7x9cm))

5. Akril a LED -ek szórásához (öntött akril lap, átlátszó, 12 "x 12" x 0,118 "méret)

6. Tápegység (Aiposen 110/220V to DC12V 30A 360W Switch Power Supply Driver)

7. Buck konverter az Arduino számára (RioRand LM2596 DC-DC Buck Converter 1.23V-30V)

8. Buck konverter LED -ekhez és érzékelőkhöz (DROK Mini Electric Buck Voltage Converter 15A)

9. 120 infravörös érzékelő (infravörös akadálykerülő érzékelő modul)

10. Öt 16 csatornás multiplexer (analóg/digitális MUX Breakout - CD74HC4067)

11. Hat 8 csatornás multiplexer (Multiplexer Breakout - 8 csatornás (74HC4051))

12. Öt kétcsatornás multiplexer (MAX4544CPA+)

13. Huzalcsomagoló huzal (NYÁK forrasztó 0,25 mm-es ónozott rézkábel átmérő huzalcsomagoló huzal 305M 30AWG piros)

14. Csatlakozó huzal (szilárd mag, 22 AWG)

15. Tűfejfej (Gikfun 1 x 40 tűs, 2,54 mm -es egysoros leválasztható hímcsapfej)

16. Öt MIDI jack (Breadboard-barát MIDI Jack (5-pin DIN))

17. Tíz 220ohmos ellenállás a MIDI aljzatokhoz

18. Elkülönítő távtartók az elektronika kupolához való rögzítéséhez (Stand-off Spacer Hex M3 male x M3 Female)

19. Menetes adapterek az állványok és a fa összekapcsolásához (E-Z Lok menetes betét, sárgaréz, késszál)

20. Epoxy vagy Gorilla Superglue

21. Elektromos szalag

22. Forrasztás

Eszközök:

1. Forrasztóállomás

2. Fúrógép

3. Körfűrész

4. Orbitális csiszoló

5. Jig fűrész

6. Gérvágó fűrész

7. Szögmérő

8. 3D nyomtató

9. Drótvágók

10. Dróttekercselő szerszám

11. Lézervágó LED lemezek vágásához (opcionális)

12. CNC shopbot kupolalaphoz (opcionális)

2. lépés: A geodéziai kupola tervezése

Amint a bevezetőben említettem, számos online forrás létezik saját geodéziai kupola építéséhez. Ezek a webhelyek olyan kupolaszámítógépeket kínálnak, amelyek meghatározzák az oldalak hosszát (azaz a támasztólábakat) és a csatlakozók számát, amelyet bármilyen típusú kupola számára meg kell építeni. A geodéziai kupola összetettségét (azaz a háromszögek sűrűségét) az osztálya határozza meg (1V, 2V, 3V stb.), A nagyobb összetettség pedig a tökéletes gömbfelület jobb közelítésévé válik. A saját kupola építéséhez először ki kell választania a kupola átmérőjét és osztályát.

A Domerama nevű webhely segítségével segítettem egy 4 V -os kupola megtervezésében, amelyet 40 cm sugarú gömb 5/12 -ére csonkítottak. Az ilyen típusú kupolákhoz hat különböző hosszúságú támasz létezik:

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

Ez összesen 190 támasz, amely 2223 cm (73 láb) anyagot tesz ki. Ebben a kupolában a támaszokhoz 1x3 (3/4 "× 2-1/2") fenyőfát használtam. A támaszok csatlakoztatásához terveztem és 3D nyomtatott csatlakozókat az Autocad segítségével. Az STL fájlok letölthetők a lépés végén. A 4V 5/12 kupola csatlakozóinak száma:

20 X 4 csatlakozó

6 X 5 csatlakozó

45 X 6 csatlakozó

A következő lépésben leírom, hogyan épül fel ez a kupola az általam tervezett fa támaszokkal és 3D nyomtatott csatlakozókkal.

3. lépés: A kupola építése támaszokkal és csatlakozókkal

A 4V 5/12 kupola Domerama számításait felhasználva körfűrésszel vágtam le a támaszokat. A 190 támasztót felcímkézték, és vágás után dobozba helyezték. A 71 csatlakozót (20 négycsatlakozó, 6 ötcsatlakozó és 45 hatcsatlakozó) 3D nyomtatással készítették el Makerbot segítségével. A fatámaszokat a Domerama által készített ábra szerint illesztették be a csatlakozókba. Az építést felülről kezdtem, és sugárirányban kifelé haladtam.

Miután az összes támasztót csatlakoztatta, egyenként eltávolítottam egy támaszt, és epoxidot adtam a fához és a csatlakozóhoz. A csatlakozókat úgy tervezték, hogy rugalmasak legyenek a szerkezetek összekapcsolásában, ezért fontos volt, hogy az epoxi hozzáadása előtt ellenőrizze a kupola szimmetriáját.

4. lépés: Lézervágó és rögzítő alaplapok

Most, hogy a kupola vázát felépítettük, ideje levágni a háromszög alakú alaplapokat. Ezek az alaplemezek a támaszok aljára vannak rögzítve, és a LED -ek rögzítésére szolgálnak a kupolára. Kezdetben 5 mm (3/16”) vastagságú rétegelt lemezből vágtam ki az alaplemezeket, mérve a kupolán lévő öt különböző háromszöget: AAB (30 háromszög), BCC (25 háromszög), DDE (20 háromszög), CDF (40 háromszög)), és EEE (5 háromszög). Az egyes oldalak méreteit és a háromszögek alakját kupolaszámológéppel (Domerama) és bizonyos geometriával határoztuk meg. Miután kiraktuk a vizsgálati alaplemezeket egy szúrófűrésszel, a Coral Draw segítségével megrajzoltam a háromszög -mintát, a maradék alaplapokat pedig lézervágóval vágtam le (sokkal gyorsabban!). Ha nincs hozzáférése lézervágóhoz, vonalzó és szögmérő segítségével rajzolhatja az alaplemezeket rétegelt lemezre, és mindegyiket kirakhatja egy szúrófűrésszel. Miután az alaplapokat levágták, a kupolát megfordítják, és a lemezeket faragasztóval ragasztják a kupolához.

5. lépés: Az elektronika áttekintése

A fenti ábrán a kupola elektronikájának vázlata látható. Az Arduino Uno -t a kupola jeleinek írására és olvasására használják. A kupola megvilágításához egy RGB LED -szalagot futtatnak a kupolán úgy, hogy a 120 -as háromszög mindegyikén egy -egy LED kerüljön elhelyezésre. A LED szalag működésével kapcsolatos információkért tekintse meg ezt az útmutatót. Minden LED külön címezhető az Arduino segítségével, amely soros adatot és órajelet állít elő a csíkra (lásd az A0 és A1 tűt a sematikus ábrán). Csak a csíkkal és ezzel a két jelzéssel fantasztikus világító kupolát kaphat. Más módokon is írhat jeleket sok Arduino LED -hez, például Charlieplexing és shift regiszterek.

Annak érdekében, hogy kölcsönhatásba léphessek a kupolával, minden LED fölé egy infravörös érzékelőt állítottam be. Ezek az érzékelők arra szolgálnak, hogy érzékeljék, ha valakinek a keze közel van a kupolán lévő háromszöghez. Mivel a kupola minden háromszögének saját IR -érzékelője van, és 120 háromszög van, az Arduino előtt valamilyen multiplexelést kell végeznie. Úgy döntöttem, hogy öt 24 csatornás multiplexert (MUX) használok a kupola 120 érzékelőjéhez. Itt van egy utasítás a multiplexelésről, ha nem ismeri. Egy 24 csatornás MUX öt vezérlőjelet igényel. A 8-12-es csapokat választottam az Arduino-n, hogy port manipulációt végezhessek (további információért lásd a 10. lépést). A MUX kártyák kimenete a 3-7.

A kupolán öt MIDI kimenetet is szerepeltettem, hogy hangot adhassanak ki (11. lépés). Más szóval, öt ember játszhatja egyszerre a kupolát, miközben minden kimenet más hangot játszik le. Az Arduino -n csak egy TX pin van, így öt MIDI jel demultiplexelést igényel. Mivel a MIDI kimenetet más időpontban állítják elő, mint az infravörös érzékelő leolvasását, ugyanazokat a vezérlőjeleket használtam.

Miután az összes infravörös érzékelő bemenetet beolvasta az Arduino -ba, a kupola kigyulladhat és hangokat adhat le, bármennyire is programozza az Arduino -t. Van néhány példa az oktatható 14. lépésben.

6. lépés: A LED -ek felszerelése a kupolára

Mivel a kupola olyan nagy, a LED -szalagot le kell vágni, hogy minden háromszögre egy LED kerüljön. Minden LED -et szuperragasztóval ragasztanak a háromszögre. A LED mindkét oldalán lyukat fúrnak az alaplemezre a kábelek átvezetéséhez a kupolán. Ezután forrasztottam a csatlakozó vezetéket a LED minden érintkezőjénél (5V, föld, óra, jel), és a vezetékeket az alaplemezen keresztül táplálom. Ezeket a vezetékeket úgy vágják el, hogy elég hosszúak legyenek ahhoz, hogy elérjék a kupola következő LED -jét. A vezetékeket áthúzzák a következő LED -hez, és a folyamat folytatódik. A LED -eket olyan konfigurációban kötöttem össze, amely minimálisra csökkenti a szükséges vezetékmennyiséget, miközben van értelme a LED -ek későbbi Arduino használatával történő kezeléséhez. Egy kisebb kupola megszünteti a szalag vágásának szükségességét, és sok időt takarít meg a forrasztásnál. Egy másik lehetőség, hogy külön RGB LED -eket használnak váltásregiszterekkel.

A szalaggal való soros kommunikációt az Arduino két csapja (adat- és órajel) biztosítja. Más szóval, a kupola megvilágítására vonatkozó adatok átkerülnek az egyik LED -ről a másikra, amikor elhagyja az adatcsapot. Itt van egy példa kód az Arduino fórumból módosítva:

// A teljes kupola növelése és csökkentése az egyszínű intenzitással

#define numLeds 120 // LED -ek száma // OUTPUT PINS // int clockPin = A1; // órajel meghatározása int dataPin = A0; // data pin meghatározása // VÁLTOZÓK // int red [numLeds]; // Initsialize tömb LED szalag int zöld [numLeds]; // Inicializálja a tömböt a LED szalagra int blue [numLeds]; // Tömb inicializálása a LED szalaghoz // CONSTANT dupla skála 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}; // a LED -ek intenzitásának töredéke void setup () {pinMode (clockPin, OUTPUT); pinMode (dataPin, OUTPUT); memset (piros, 0, numLeds); memset (zöld, 0, numLeds); memset (kék, 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 a kupola fényintenzitásának növeléséhez {double scale = scaleA [p]; késleltetés (20); for (int i = 0; i <numLeds; i ++) // ciklus az összes LED -en keresztül {red = 255 * scale; zöld = 80 * skála; kék = 0; } updatestring (piros, zöld, kék); // led csík frissítése}}

7. lépés: Érzékelő tartó tervezése és megvalósítása

Úgy döntöttem, hogy infravörös érzékelőket használok a kupolához. Ezek az érzékelők IR LED -del és vevővel rendelkeznek. Amikor egy tárgy az érzékelő elé kerül, az IR LED -ből származó infravörös sugárzás visszaverődik a vevő felé. Ezt a projektet azzal kezdtem, hogy saját IR -érzékelőket készítettem, amelyek Richardouvina utasításai alapján készültek. Az összes forrasztás túl sokáig tartott, ezért 120 infravörös érzékelőt vásároltam az eBay -től, amelyek mindegyike digitális kimenetet produkál. Az érzékelő küszöbét a táblán lévő potenciométerrel állítják be, így a kimenet csak akkor magas, ha egy kéz a háromszög közelében van.

Mindegyik háromszög egy rétegelt lemezből készült LED-alaplapból, egy diffúzív akril lapból, amely körülbelül 2,5 cm-re van felszerelve a LED-lemez fölé, és egy IR-érzékelőből. Az egyes háromszögek érzékelőjét egy vékony rétegelt lemezre szerelték fel, amely ötszög vagy hatszög alakú, a kupola helyzetétől függően (lásd a fenti ábrát). Lyukakat fúrtam az infravörös érzékelő alapjába az infravörös érzékelők felszereléséhez, majd összekötöttem a földet és az 5 V-os csapokat dróthálóval és dróthálóval (piros és fekete vezetékek). A föld és az 5 V csatlakoztatása után minden huzalra (sárga), földre és 5 V-ra hosszú huzaltekercselő kábelt tekertem, hogy átfussak a kupolán.

A hatszög vagy ötszög infravörös érzékelő rögzítőelemeit epoxírozták a kupolára, közvetlenül a 3D nyomtatott csatlakozók fölé, hogy a vezeték át tudjon futni a kupolán. Azáltal, hogy az érzékelők a csatlakozók felett voltak, hozzá tudtam férni és beállíthattam az infravörös érzékelők potenciométereit, amelyek az érzékelők érzékenységét szabályozzák. A következő lépésben leírom, hogyan csatlakoznak az infravörös érzékelők kimenetei a multiplexerekhez, és hogyan olvassák be az Arduino -ba.

8. lépés: Multiplexelő érzékelő kimenet

Mivel az Arduino Uno csak 14 digitális I/O tűvel és 6 analóg bemeneti tűvel rendelkezik, és 120 érzékelőjelet kell leolvasni, a kupola megköveteli a multiplexerek beolvasását. Öt 24 csatornás multiplexer építését választottam, amelyek mindegyike 24 infravörös érzékelőt olvas (lásd az elektronika áttekintő ábráját). A 24 csatornás MUX 8 csatornás MUX megszakító kártyából, 16 csatornás MUX megszakítópanelből és 2 csatornás MUX-ból áll. A tűfejléceket minden kitörési táblához forrasztották, hogy össze lehessen kötni a prototípus táblával. Egy dróttekercselő szerszám segítségével csatlakoztattam a földet, az 5 V-ot és a MUX szakítótáblák vezérlőjel-csapjait.

Egy 24 csatornás MUX öt vezérlőjelet igényel, amelyeket az Arduino 8-12-es csatlakozójához választottam. Mind az öt 24 csatornás MUX ugyanazokat a vezérlőjeleket kapja az Arduino-tól, így az Arduino csapok vezetékét a 24 csatornás MUX-hoz kötöttem. Az infravörös érzékelők digitális kimenetei a 24 csatornás MUX bemeneti csapjaihoz vannak csatlakoztatva, így sorban olvashatók az Arduino-val. Mivel mind a 120 érzékelő kimenetben öt különálló olvasótű található, hasznos elképzelni, hogy a kupola öt különálló részre van osztva, amelyek 24 háromszögből állnak (ellenőrizze a kupola színét az ábrán).

Az Arduino port manipulációjával gyorsan növelheti a vezérlőjeleket, amelyeket a 8-12 érintkezők küldnek a multiplexereknek. Itt csatoltam néhány példakódot a multiplexerek működtetéséhez:

int numChannel = 24;

// KIMENETEK // int s0 = 8; // MUX vezérlés 0 - PORTbD int s1 = 9; // MUX vezérlés 1 - PORTb int s2 = 10; // MUX vezérlés 2 - PORTb int s3 = 11; // MUX vezérlés 3 - PORTb int s4 = 12; // MUX vezérlés 4 - PORTb // INPUTS // int m0 = 3; // MUX bemenet 0 int m1 = 4; // MUX bemenet 1 int m2 = 5; // MUX bemenet 2 int m3 = 6; // MUX bemenet 3 int m4 = 7; // MUX bemenet 4 // VÁLTOZÓK // int arr0r; // digitális olvasás a MUX0 -ból int arr1r; // digitális olvasás a MUX1 -ből int arr2r; // digitális olvasás a MUX2 -ből int arr3r; // digitális olvasás a MUX3 -ból int arr4r; // digitális olvasás a MUX4 void setup -ból () {// tegye ide a beállítási kódot, hogy egyszer fusson: DDRB = B11111111; // a 8–13 Arduino csapokat állítja be bemenetként pinMode (s0, OUTPUT); pinMode (s1, OUTPUT); pinMode (s2, OUTPUT); pinMode (s3, OUTPUT); pinMode (s4, OUTPUT); pinMode (m0, BEMENET); pinMode (m1, BEMENET); pinMode (m2, BEMENET); pinMode (m3, BEMENET); pinMode (m4, BEMENET); } void loop () {// tegye ide a fő kódot az ismételt futtatáshoz: PORTB = B00000000; // SET vezérlőcsapok a mux low számára (int i = 0; i <numChannel; i ++) {// A MUX0 digitális olvasási kimenete - MUX4 az IR szenzorhoz i // Ha az IR érzékelő LO, a játékos megérinti a háromszöget. arr0r = digitalRead (m0); // olvasás Mux 0 -ból, IR érzékelő i arr1r = digitalRead (m1); // olvasás Mux 1 -ből, IR érzékelő i arr2r = digitalRead (m2); // olvasás a Mux 2 -ből, IR érzékelő i arr3r = digitalRead (m3); // olvasás a Mux 3 -ból, IR érzékelő i arr4r = digitalRead (m4); // olvasás a Mux 4 -ből, infravörös érzékelő i // TÉLYEZZE EL VALAMIT MUX BEMENETTEL VAGY TÁROLJON ITT ARRAYBEN // PORTB ++; // növekvő vezérlőjelek a MUX számára}}

9. lépés: Fény eloszlatása akrillal

A LED -ek fényének eloszlatásához átlátszó akrilt csiszoltam kör alakú orbitális csiszológéppel. A csiszolót a 8. ábra szerinti mozdulattal az akril mindkét oldalán áthelyezték. Ezt a módszert sokkal jobbnak találtam, mint a „matt üveg” spray -festéket.

Az akril csiszolása és tisztítása után lézervágóval kivágtam háromszögeket, hogy illeszkedjenek a LED -ekhez. Lehetőség van az akril vágására akril vágószerszámmal vagy akár kirakós fűrész segítségével, ha az akril nem reped. Az akrilt a LED -ek felett 5 mm vastag rétegelt lemez téglalapok tartották, amelyeket szintén lézervágóval vágtak. Ezeket a kis deszkákat a kupola támaszaihoz ragasztották, és az akril háromszögeket epoxírozták a deszkákra.

10. lépés: Zenélés a kupolával a MIDI használatával

Azt akartam, hogy a kupola képes legyen hangot kiadni, ezért öt MIDI csatornát állítottam be, egyet a kupola minden részhalmazához. Először meg kell vásárolnia öt MIDI jack aljzatot, és csatlakoztatnia kell a vázlat szerint (további információért tekintse meg ezt az oktatóanyagot az Arduino támogatástól).

Mivel az Arduino Uno-n csak egy adás soros tű található (a 2. érintkező TX tűként van jelölve), le kell választania a multiplexelt jeleket az öt MIDI aljzatra. Ugyanazokat a vezérlőjeleket használtam (8-12. Tű), mert a MIDI jelek más időpontban kerülnek elküldésre, mint amikor az infravörös érzékelőket beolvassák az Arduino-ba. Ezeket a vezérlőjeleket egy 8 csatornás demultiplexerre küldik, így Ön szabályozhatja, hogy melyik MIDI jack fogadja az Arduino által létrehozott MIDI jelet. A MIDI jeleket az Arduino generálta a Francois Best által készített fantasztikus MIDI jelkönyvtárral. Íme néhány példakód több MIDI kimenet előállításához különböző MIDI aljzatokhoz Arduino Uno segítségével:

#include // tartalmazza a MIDI könyvtárat

#define numChannel 24 // Háromszögre jutó IR száma #define numSections 5 // szakaszok száma a kupolában, 24 csatornás MUX száma, MIDI aljzatok száma // OUTPUTS // int s0 = 8; // MUX vezérlés 0 - PORTbD int s1 = 9; // MUX vezérlés 1 - PORTb int s2 = 10; // MUX vezérlés 2 - PORTb int s3 = 11; // MUX vezérlés 3 - PORTb int s4 = 12; // MUX vezérlés 4 - PORTb // INPUTS // int m0 = 3; // MUX bemenet 0 int m1 = 4; // MUX bemenet 1 int m2 = 5; // MUX bemenet 2 int m3 = 6; // MUX bemenet 3 int m4 = 7; // MUX bemenet 4 // VÁLTOZÓK // int arr0r; // digitális olvasás a MUX0 -ból int arr1r; // digitális olvasás a MUX1 -ből int arr2r; // digitális olvasás a MUX2 -ből int arr3r; // digitális olvasás a MUX3 -ból int arr4r; // digitális olvasás a MUX4 -ből int midArr [numSections]; // Tárolja, hogy valamelyik játékos megnyomta -e a hangot int note2play [numSections]; // Jegyzet tárolása, amelyet akkor kell lejátszani, ha az érzékelőt megérinti jegyzetekben [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; // szünetidő midi jelek között MIDI_CREATE_DEFAULT_INSTANCE (); void setup () {// tegye ide a beállítási kódot, hogy egyszer fusson: DDRB = B11111111; // az Arduino 8–13. tűit állítja be bemenetként MIDI.begin (MIDI_CHANNEL_OFF); pinMode (s0, OUTPUT); pinMode (s1, OUTPUT); pinMode (s2, OUTPUT); pinMode (s3, OUTPUT); pinMode (s4, OUTPUT); pinMode (m0, BEMENET); pinMode (m1, BEMENET); pinMode (m2, BEMENET); pinMode (m3, BEMENET); pinMode (m4, BEMENET); } void loop () {// tegye ide a fő kódot az ismételt futtatáshoz: PORTB = B00000000; // SET vezérlőcsapok a mux low számára (int i = 0; i <numChannel; i ++) {// A MUX0 digitális olvasási kimenete - MUX4 az IR szenzorhoz i // Ha az IR érzékelő LO, a játékos megérinti a háromszöget. arr0r = digitalRead (m0); // olvasás Mux 0 -ból, IR érzékelő i arr1r = digitalRead (m1); // olvasás Mux 1 -ből, IR érzékelő i arr2r = digitalRead (m2); // olvasás a Mux 2 -ből, IR érzékelő i arr3r = digitalRead (m3); // olvasás a Mux 3 -ból, IR érzékelő i arr4r = digitalRead (m4); // Olvasás a Mux 4 -ből, i infravörös érzékelő, ha (arr0r == 0) // A 0. szakasz érzékelője blokkolva volt {midArr [0] = 1; // A 0. játékos eltalált egy hangot, állítsa be a HI -t, hogy legyen MIDI kimenete a 0 játékosnak note2play [0] = notes ; // Jegyzet a 0 játékos számára, ha (arr1r == 0) // Az 1. szakasz érzékelőjét blokkolta {midArr [1] = 1; // A 0. játékos eltalált egy hangot, állítsa be a HI -t, hogy legyen MIDI kimenete a 0 játékosnak note2play [1] = notes ; // Jegyzet a 0 játékos számára, ha (arr2r == 0) // A 2. szakasz érzékelője blokkolva volt {midArr [2] = 1; // A 0. játékos eltalált egy hangot, állítsa be a HI -t, hogy legyen MIDI kimenete a 0 játékosnak note2play [2] = notes ; // Jegyzet a 0 játékos számára, ha (arr3r == 0) // A 3. szakasz érzékelője blokkolva volt {midArr [3] = 1; // A 0. játékos eltalált egy hangot, állítsa be a HI -t, hogy legyen MIDI kimenete a 0 játékosnak note2play [3] = notes ; // Jegyzet a 0 játékos számára, ha (arr4r == 0) // A 4. szakasz érzékelője blokkolva volt {midArr [4] = 1; // A 0. játékos eltalált egy hangot, állítsa be a HI -t, hogy legyen MIDI kimenete a 0 játékosnak note2play [4] = notes ; // Megjegyzés a lejátszóhoz: 0} PORTB ++; // növekvő vezérlőjelek a MUX számára} updateMIDI (); } void updateMIDI () {PORTB = B00000000; // SET vezérlőcsapok a mux low számára, ha (midArr [0] == 1) // Lejátszó 0 MIDI kimenet {MIDI.sendNoteOn (note2play [0], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [0], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // növekvő MUX if (midArr [1] == 1) // 1. játékos MIDI kimenete {MIDI.sendNoteOn (note2play [1], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [1], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // növekvő MUX if (midArr [2] == 1) // 2. lejátszó MIDI kimenete {MIDI.sendNoteOn (note2play [2], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [2], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // növekvő MUX if (midArr [3] == 1) // 3. lejátszó MIDI kimenete {MIDI.sendNoteOn (note2play [3], 127, 1); delayMicroseconds (pauseMidi); MIDI.sendNoteOff (note2play [3], 127, 1); delayMicroseconds (pauseMidi); } PORTB ++; // növekvő MUX if (midArr [4] == 1) // 4. lejátszó MIDI kimenete {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; }

11. lépés: A kupola áramellátása

A kupolában több alkatrészt kell táplálni. Ezért a vásárolni kívánt tápegység meghatározásához ki kell számítani az egyes alkatrészekből vett erősítőket.

A LED szalag: körülbelül 3,75 métert használtam a Ws2801 LED szalagból, ami 6,4 W/méter. Ez 24W -nak felel meg (3,75*6,4). Ennek erősítőkre való átalakításához használja a Teljesítmény = áram*voltot (P = iV), ahol V a LED -szalag feszültsége, ebben az esetben 5V. Ezért a LED -ekből vett áram 4,8A (24W/5V = 4,8A).

Az infravörös érzékelők: Mindegyik infravörös érzékelő körülbelül 25 mA -t vesz fel, összesen 3 A -t 120 érzékelőre.

Arduino: 100mA, 9V

A multiplexerek: Öt 24 csatornás multiplexer van, amelyek mindegyike 16 csatornás és 8 csatornás multiplexerből áll. A 8 és 16 csatornás MUX egyenként körülbelül 100 mA -t fogyaszt. Ezért az összes MUX teljes fogyasztása 1A.

Ezeket az összetevőket összeadva a teljes energiafogyasztás várhatóan 9A körül lesz. A LED szalag, az IR érzékelők és a multiplexerek bemeneti feszültsége 5 V, az Arduino pedig 9 V bemeneti feszültséggel rendelkezik. Ezért választottam egy 12V 15A tápegységet, egy 15A buck átalakítót a 12V 5V átalakításához, és egy 3A buck konvertert a 12V 9V átalakításához az Arduino számára.

12. lépés: Kör alakú kupolalap

A kupola egy kör alakú fadarabon nyugszik, közepéről kivágott ötszöggel, hogy könnyen hozzáférhessen az elektronikához. Ennek a kör alakú alapnak a létrehozásához 4x6 hüvelykes rétegelt lemezeket vágtak fa CNC maró segítségével. Ehhez a lépéshez kirakós fűrészt is használhat. Az alap levágása után a kupolát kis 2x3”-os fadarabok segítségével rögzítették hozzá.

Az alap tetejére rögzítettem a tápegységet epoxiddal, valamint a MUX és Buck konvertereket PCB stand-off távtartókkal. A távtartókat E-Z Lok menetes adapterek segítségével rögzítették a rétegelt lemezhez.

13. lépés: Pentagon Dome Base

A kör alakú talpon kívül ötszög alapot is építettem a kupolához, alsó részén üvegablakkal. Ez az alap és a kinéző ablak szintén fa CNC maróval vágott rétegelt lemezből készült. Az ötszög oldalai fából készült deszkákból készülnek, az egyik oldalon lyuk van a csatlakozók áthaladásához. A fából készült deszkákat fémkonzolokkal és 2x3 tömbcsuklóval rögzítik az ötszög alapra. A főkapcsoló, a MIDI és az USB csatlakozó egy előlaphoz van rögzítve, amelyet lézervágóval készítettem. A teljes ötszög alapot a 12. lépésben leírt kör alakú alaphoz kell csavarozni.

Behelyeztem egy ablakot a kupola aljába, hogy bárki felnézhessen a kupolába, hogy lássa az elektronikát. A keresőüveg akrilból készült, lézervágóval és kör alakú rétegelt lemezre epoxálva.

14. lépés: A kupola programozása

A kupola programozására végtelen lehetőségek vannak. A kód minden ciklusa átveszi az infravörös érzékelők jeleit, amelyek jelzik azokat a háromszögeket, amelyeket valaki megérintett. Ezzel az információval bármilyen RGB színnel színezheti a kupolát, és/vagy MIDI jelet állíthat elő. Íme néhány példa a programokra, amelyeket a kupolához írtam:

Színezze ki a kupolát: Minden háromszög megérintve négy színben ciklusozik. A színek változásakor arpeggio játszódik. Ezzel a programmal több ezer különböző módon színesítheti a kupolát.

Dómzene: A kupola öt színnel van színezve, mindegyik szakasz más -más MIDI kimenetnek felel meg. A programban kiválaszthatja, hogy az egyes háromszögek mely hangokat játsszák le. Úgy döntöttem, hogy a kupola tetején lévő C középső részről indulok, és növelem a hangmagasságot, ahogy a háromszögek közelebb kerülnek az alaphoz. Mivel öt kimenet létezik, ez a program ideális ahhoz, hogy egyszerre többen játsszák a kupolát. MIDI hangszer vagy MIDI szoftver használatával ezek a MIDI jelek olyan hangzásúak lehetnek, mint bármelyik hangszer.

Simon: Simont, a klasszikus memóriavilágító játékot írtam. Egy véletlenszerű fénysorozat világít egyenként az egész kupolán. A játékosnak minden körben másolnia kell a sorozatot. Ha a lejátszó helyesen illeszkedik a sorozathoz, akkor egy további lámpa kerül a sorozatba. A magas pontszámot a kupola egyik szakaszán tárolják. Ez a játék is nagyon szórakoztató több emberrel játszani.

Pong: Miért nem játszhat pongot kupolán? A labda addig terjed a kupolán, amíg be nem ütődik a lapátra. Amikor ez megtörténik, MIDI jel keletkezik, jelezve, hogy a lapát elütötte a labdát. A másik játékosnak ekkor a lapátot a kupola alja mentén úgy kell irányítania, hogy az visszaütje a labdát.

15. lépés: A kész kupola fényképei

Fődíj az Arduino versenyen 2016

Második díj a Remix versenyen 2016

Második díj a Make it Glow versenyen 2016