Interaktive geodätische LED-Kuppel - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Ich konstruierte eine geodätische Kuppel bestehend aus 120 Dreiecken mit einer LED und einem Sensor an jedem Dreieck. Jede LED ist einzeln ansprechbar und jeder Sensor ist speziell auf ein einzelnes Dreieck abgestimmt. Die Kuppel ist mit einem Arduino programmiert, um zu leuchten und ein MIDI-Signal zu erzeugen, je nachdem, welches Dreieck Sie Ihre Hand platzieren.

Ich habe die Kuppel entworfen, um ein lustiges Display zu sein, das die Leute für Licht, Elektronik und Sound interessiert. Da sich der Dome schön in fünf Teile unterteilen lässt, habe ich den Dome so entworfen, dass er fünf separate MIDI-Ausgänge hat, die jeweils einen anderen Klang haben können. Dies macht die Kuppel zu einem riesigen Musikinstrument, ideal zum gleichzeitigen Musizieren mit mehreren Personen. Neben der Musik habe ich die Kuppel auch für Lichtshows programmiert und eine Wiedergabe von Simon und Pong gespielt. Die endgültige Struktur hat einen Durchmesser von etwas mehr als einem Meter und eine Höhe von 70 cm und besteht hauptsächlich aus Holz, Acryl und 3D-gedruckten Teilen.

Es gibt mehrere großartige Instructables auf LED-Tischen und Würfeln, die mich inspiriert haben, dieses Projekt zu starten. Ich wollte jedoch versuchen, die LEDs in einer anderen Geometrie anzuordnen. Ich konnte mir keine bessere Struktur für das Projekt vorstellen als eine geodätische Kuppel, die auch auf Instructables gut dokumentiert ist. Dieses Projekt ist also ein Remix / Mashup von LED-Tabellen und geodätischen Kuppeln. Unten sind Links zu den LED-Tabellen und geodätischen Kuppeln Instructables, die ich zu Beginn des Projekts ausgecheckt habe.

LED Tische und Würfel:

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ätische Kuppel:

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

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

Schritt 1: Lieferliste

Materialien:

1. Holz für Domstreben und Domfuß (Menge abhängig von Domtyp und Domgröße)

2. Adressierbarer LED-Streifen (16.4ft/5m adressierbarer Farb-LED-Pixelstreifen 160leds Ws2801 Dc5v)

3. Arduino Uno (Atmega328 - zusammengebaut)

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

5. Acryl zum Streuen von LEDs (gegossene Acrylglasplatte, klar, 12" x 12" x 0,118" Größe)

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

7. Abwärtswandler für Arduino (RioRand LM2596 DC-DC Abwärtswandler 1,23V-30V)

8. Abwärtswandler für LEDs und Sensoren (DROK Mini Electric Buck Voltage Converter 15A)

9. 120 IR-Sensoren (Infrarot-Hindernisvermeidungssensormodul)

10. Fünf 16-Kanal-Multiplexer (Analog/Digital MUX Breakout - CD74HC4067)

11. Sechs 8-Kanal-Multiplexer (Multiplexer Breakout - 8-Kanal (74HC4051))

12. Fünf 2-Kanal-Multiplexer (MAX4544CPA+)

13. Wire-Wrap-Draht (PCB-Lot 0,25 mm verzinntes Kupferkabel Durchmesser Wire-Wrapping-Draht 305M 30AWG Rot)

14. Anschlusskabel (Solid Core, 22 AWG)

15. Stiftleisten (Gikfun 1 x 40 Pin 2,54 mm einreihige Breakaway Stiftleiste)

16. Fünf MIDI-Buchsen (Breadboard-freundliche MIDI-Buchse (5-polig DIN))

17. Zehn 220 Ohm Widerstände für MIDI-Buchsen

18. Abstandshalter zur Montage der Elektronik an der Kuppel (Abstandsabstandshalter Hex M3 Male x M3 Female)

19. Gewindeadapter zum Verbinden von Abstandshaltern mit Holz (E-Z Lok-Gewindeeinsatz, Messing, Messergewinde)

20. Epoxy oder Gorilla Sekundenkleber

21. Isolierband

22. Löten

Werkzeuge:

1. Lötstation

2. Bohrmaschine

3. Kreissäge

4. Schwingschleifer

5. Stichsäge

6. Gehrungssäge

7. Winkelmesser

8. 3D-Drucker

9. Drahtschneider

10. Wire-Wrap-Tool

11. Laserschneider zum Schneiden von LED-Platten (optional)

12. CNC-Shopbot für Kuppelbasis (optional)

Schritt 2: Entwerfen der geodätischen Kuppel

Wie ich im Intro erwähnt habe, gibt es mehrere Online-Quellen für den Bau Ihrer eigenen geodätischen Kuppel. Diese Seiten bieten Dome-Rechner, die die Länge jeder Seite (d. Die Komplexität einer geodätischen Kuppel (d. h. die Dichte von Dreiecken) wird durch ihre Klasse (1V, 2V, 3V usw.) angegeben, wobei eine höhere Komplexität eine bessere Annäherung an eine perfekte sphärische Oberfläche wird. Um Ihren eigenen Dome zu konstruieren, müssen Sie zunächst einen Dome-Durchmesser und eine Dome-Klasse auswählen.

Ich habe eine Site namens Domerama verwendet, um mir zu helfen, eine 4V-Kuppel zu entwerfen, die auf 5/12 einer Kugel mit einem Radius von 40 cm gekürzt wurde. Für diese Art von Kuppel gibt es sechs unterschiedlich lange Streben:

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

Das sind insgesamt 190 Streben, die zusammen 2223 cm (73 ft) Material ergeben. Ich habe 1x3 (3/4 "× 2 1/2") Kiefernholz für die Streben in dieser Kuppel verwendet. Um die Streben zu verbinden, habe ich mit Autocad Verbinder entworfen und 3D gedruckt. Die STL-Dateien stehen am Ende dieses Schrittes zum Download bereit. Die Anzahl der Anschlüsse für eine 4V 5/12 Kuppel beträgt:

20 X 4-Stecker

6 X 5-Stecker

45 X 6-Stecker

Im nächsten Schritt beschreibe ich, wie diese Kuppel mit den Holzstreben und den von mir entworfenen 3D-gedruckten Verbindern aufgebaut ist.

Schritt 3: Konstruieren der Kuppel mit Streben und Anschlüssen

Mit den Berechnungen von Domerama für eine 4V 5/12 Kuppel habe ich die Streben mit einer Kreissäge geschnitten. Die 190 Streben wurden beschriftet und nach dem Schneiden in eine Schachtel gelegt. Die 71 Konnektoren (20 Vier-Konnektoren, 6 Fünf-Konnektoren und 45 Sechs-Konnektoren) wurden mit einem Makerbot 3D-gedruckt. Die Holzstreben wurden nach dem von Domerama erstellten Diagramm in die Verbinder eingesetzt. Ich begann die Konstruktion von oben und bewegte mich radial nach außen.

Nachdem alle Streben verbunden waren, entfernte ich eine Strebe nach der anderen und fügte dem Holz und dem Verbinder Epoxid hinzu. Die Verbinder wurden so konzipiert, dass sie flexibel sind, wie sie die Strukturen verbinden. Daher war es wichtig, die Symmetrie der Kuppel zu überprüfen, bevor Epoxidharz hinzugefügt wurde.

Schritt 4: Laserschneiden und Montage von Grundplatten

Nun, da das Skelett der Kuppel aufgebaut ist, ist es an der Zeit, die dreieckigen Grundplatten zu schneiden. Diese Grundplatten werden an der Unterseite der Streben befestigt und werden verwendet, um die LEDs an der Kuppel zu montieren. Zuerst schneide ich die Grundplatten aus 5 mm (3/16 ) dickem Sperrholz, indem ich die fünf verschiedenen Dreiecke, die sich auf der Kuppel befinden, ausgemessen habe: AAB (30 Dreiecke), BCC (25 Dreiecke), DDE (20 Dreiecke), CDF (40 Dreiecke).) und EEE (5 Dreiecke). Die Abmessungen jeder Seite und die Form der Dreiecke wurden mit einem Kuppelrechner (Domerama) und etwas Geometrie bestimmt. Nachdem ich Testgrundplatten mit einer Stichsäge geschnitten hatte, zeichnete ich das Dreiecksdesign mit Coral Draw und schneide die restlichen Grundplatten mit einem Laserschneider (viel schneller!). Wenn Sie keinen Zugang zu einem Laserschneider haben, können Sie die Grundplatten mit einem Lineal und einem Winkelmesser auf Sperrholz zeichnen und alle mit einer Stichsäge zuschneiden. Sobald die Bodenplatten geschnitten sind, wird die Kuppel umgedreht und die Platten werden mit Holzleim auf die Kuppel geklebt.

Schritt 5: Übersicht über die Elektronik

In der Abbildung oben ist ein Schema der Elektronik für die Kuppel dargestellt. Ein Arduino Uno wird zum Schreiben und Lesen von Signalen für die Kuppel verwendet. Zur Beleuchtung der Kuppel wird ein RGB-LED-Streifen über die Kuppel geführt, sodass an jedem der 120 Dreiecke eine LED positioniert ist. Informationen zur Funktionsweise eines LED-Streifens finden Sie in dieser Anleitung. Jede LED kann separat mit dem Arduino adressiert werden, der ein serielles Daten- und Taktsignal für den Streifen erzeugt (siehe A0- und A1-Pin im Schaltplan). Mit dem Streifen und diesen beiden Signalen allein können Sie eine fantastische Lichtkuppel haben. Es gibt andere Möglichkeiten, Signale für viele LEDs von einem Arduino zu schreiben, z. B. Charlieplexing und Schieberegister.

Um mit der Kuppel zu interagieren, habe ich über jeder LED einen IR-Sensor eingerichtet. Diese Sensoren werden verwendet, um zu erkennen, wenn sich die Hand einer Person in der Nähe eines Dreiecks auf der Kuppel befindet. Da jedes Dreieck auf der Kuppel einen eigenen IR-Sensor hat und es 120 Dreiecke gibt, müssen Sie vor dem Arduino eine Art Multiplexing durchführen. Ich entschied mich, fünf 24-Kanal-Multiplexer (MUX) für die 120 Sensoren der Kuppel zu verwenden. Hier ist eine Anleitung zum Multiplexen, wenn Sie nicht vertraut sind. Ein 24-Kanal-MUX benötigt fünf Steuersignale. Ich habe die Pins 8-12 auf dem Arduino gewählt, damit ich die Portmanipulation durchführen konnte (weitere Informationen finden Sie in Schritt 10). Die Ausgänge der MUX-Boards werden über die Pins 3-7 eingelesen.

Ich habe auch fünf MIDI-Ausgänge am Dome eingebaut, damit er Ton erzeugen kann (Schritt 11). Mit anderen Worten, fünf Personen können den Dome gleichzeitig spielen, wobei jeder Ausgang einen anderen Klang abspielt. Es gibt nur einen TX-Pin auf dem Arduino, daher müssen fünf MIDI-Signale demultiplexiert werden. Da die MIDI-Ausgabe zu einem anderen Zeitpunkt als die IR-Sensormessung erfolgt, habe ich die gleichen Steuersignale verwendet.

Nachdem alle IR-Sensoreingänge in das Arduino eingelesen wurden, kann die Kuppel aufleuchten und Töne abspielen, wie auch immer Sie das Arduino programmieren. Ich habe ein paar Beispiele in Schritt 14 dieses instructable.

Schritt 6: Montage von LEDs auf Dome

Da die Kuppel so groß ist, muss der LED-Streifen geschnitten werden, um eine LED auf jedem Dreieck zu platzieren. Jede LED wird mit Sekundenkleber auf das Dreieck geklebt. Auf beiden Seiten der LED wird ein Loch durch die Grundplatte gebohrt, damit Kabel durch die Kuppel geführt werden können. Ich habe dann an jedem Kontakt der LED (5V, Masse, Takt, Signal) Anschlussdraht angelötet und die Drähte durch die Grundplatte geführt. Diese Drähte werden so geschnitten, dass sie lang genug sind, um die nächste LED auf der Kuppel zu erreichen. Die Drähte werden bis zur nächsten LED durchgezogen und der Vorgang wird fortgesetzt. Ich habe die LEDs in einer Konfiguration angeschlossen, die die erforderliche Kabelmenge minimieren würde, während es dennoch Sinn macht, die LEDs später mit dem Arduino zu adressieren. Eine kleinere Kuppel würde das Schneiden des Streifens überflüssig machen und viel Zeit beim Löten sparen. Eine andere Möglichkeit besteht darin, separate RGB-LEDs mit Schieberegistern zu verwenden.

Die serielle Kommunikation mit dem Streifen wird mit zwei Pins (einem Daten- und einem Taktpin) vom Arduino erreicht. Mit anderen Worten, die Daten zum Aufleuchten der Kuppel werden beim Verlassen des Datenpins von einer LED zur nächsten weitergegeben. Hier ist ein modifizierter Beispielcode aus diesem Arduino-Forum:

// Lassen Sie die gesamte Kuppel die Intensität einer einzelnen Farbe erhöhen und verringern

#define numLeds 120 //Anzahl der LEDs // AUSGANGS-PINS // int clockPin = A1; // Clock-Pin definieren Int dataPin = A0; // Datenpin definieren // VARIABLES // int red[numLeds]; // Array für LED-Streifen initialisieren int green[numLeds]; // Array für LED-Streifen initialisieren int blue[numLeds]; // Array für LED-Streifen initialisieren // KONSTANTE DoppelskalaA = {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}; // Intensitätsanteil der LEDs void setup () {pinMode (clockPin, OUTPUT); pinMode (dataPin, AUSGANG); memset (rot, 0, numLeds); memset (grün, 0, numLeds); memset (blau, 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); aufrechtzuerhalten. aufrechtzuerhalten. Verzögerung (20); for (int i = 0; i < numLeds; i++) // alle LEDs durchlaufen { red = 255 * scale; grün = 80 * Skala; blau = 0; } Updatestring (rot, grün, blau); // LED-Streifen aktualisieren}}

Schritt 7: Design und Implementierung der Sensorhalterung

Ich beschloss, IR-Sensoren für die Kuppel zu verwenden. Diese Sensoren verfügen über eine IR-LED und einen Empfänger. Wenn ein Objekt vor den Sensor gelangt, wird ein Teil der IR-Strahlung der IR-LED zum Empfänger reflektiert. Ich begann dieses Projekt, indem ich meine eigenen IR-Sensoren herstellte, die auf Richardouvinas instructable basierten. Das ganze Löten dauerte viel zu lange, also kaufte ich 120 IR-Sensoren von eBay, die jeweils einen digitalen Ausgang erzeugen. Die Schwelle des Sensors wird mit einem Potentiometer auf der Platine so eingestellt, dass der Ausgang nur dann hoch ist, wenn sich eine Hand in der Nähe dieses Dreiecks befindet.

Jedes Dreieck besteht aus einer LED-Grundplatte aus Sperrholz, einer ca. 2,5 cm über der LED-Platte angebrachten streuenden Acrylplatte und einem IR-Sensor. Der Sensor für jedes Dreieck wurde je nach Position auf der Kuppel auf eine dünne Sperrholzplatte in Form eines Fünfecks oder Sechsecks montiert (siehe Abbildung oben). Ich bohrte Löcher in die IR-Sensorbasis, um die IR-Sensoren zu montieren, und verband dann die Masse- und 5V-Pins mit Wire-Wrap-Draht und einem Wire-Wrap-Tool (rote und schwarze Drähte). Nachdem ich Masse und 5 V angeschlossen hatte, wickelte ich einen langen Drahtwickeldraht an jedem Ausgang (gelb), Masse und 5 V, um durch die Kuppel zu laufen.

Die sechseckigen oder fünfeckigen IR-Sensorhalterungen wurden dann direkt über den 3D-gedruckten Anschlüssen auf die Kuppel geklebt, damit der Draht durch die Kuppel verlaufen konnte. Indem ich die Sensoren über den Anschlüssen hatte, konnte ich auch auf die Potentiometer der IR-Sensoren zugreifen und diese einstellen, die die Empfindlichkeit der Sensoren steuern. Im nächsten Schritt beschreibe ich, wie die Ausgänge der IR-Sensoren mit Multiplexern verbunden und in den Arduino eingelesen werden.

Schritt 8: Multiplexing-Sensorausgang

Da der Arduino Uno nur 14 digitale I/O-Pins und 6 analoge Eingangspins hat und 120 Sensorsignale gelesen werden müssen, benötigt der Dome Multiplexer, um alle Signale einzulesen. Ich habe mich entschieden, fünf 24-Kanal-Multiplexer zu konstruieren, von denen jeder 24 der IR-Sensoren ausliest (siehe die Übersichtsabbildung der Elektronik). Der 24-Kanal-MUX besteht aus einem 8-Kanal-MUX-Breakout-Board, einem 16-Kanal-MUX-Breakout-Board und einem 2-Kanal-MUX. An jede Breakout-Platine wurden Stiftleisten angelötet, damit sie mit der Prototypenplatine verbunden werden konnten. Mit einem Wire-Wrap-Tool habe ich dann Masse, 5 V und die Steuersignalpins der MUX-Breakout-Boards verbunden.

Ein 24-Kanal-MUX erfordert fünf Steuersignale, die ich an Pin 8-12 des Arduino angeschlossen habe. Alle fünf 24-Kanal-MUX empfangen die gleichen Steuersignale vom Arduino, also habe ich Kabel von den Arduino-Pins mit dem 24-Kanal-MUX verbunden. Die digitalen Ausgänge der IR-Sensoren werden mit den Eingangspins des 24-Kanal-MUX verbunden, damit sie seriell zum Arduino eingelesen werden können. Da es fünf separate Pins zum Einlesen aller 120 Sensorausgänge gibt, ist es hilfreich, sich vorzustellen, dass die Kuppel in fünf separate Abschnitte mit 24 Dreiecken unterteilt ist (siehe Farben der Kuppel in der Abbildung).

Mit der Arduino-Port-Manipulation können Sie die von den Pins 8-12 an die Multiplexer gesendeten Steuersignale schnell inkrementieren. Ich habe hier einen Beispielcode für den Betrieb der Multiplexer angehängt:

int numChannel = 24;

// AUSGÄNGE // int s0 = 8; // MUX-Steuerung 0 - PORTbD int s1 = 9; // MUX-Steuerung 1 - PORTb int s2 = 10; // MUX-Steuerung 2 - PORTb int s3 = 11; // MUX-Steuerung 3 - PORTb int s4 = 12; // MUX-Steuerung 4 - PORTb // EINGÄNGE // int m0 = 3; // MUX-Eingang 0 int m1 = 4; // MUX-Eingang 1 int m2 = 5; // MUX-Eingang 2 int m3 = 6; // MUX-Eingang 3 int m4 = 7; // MUX-Eingang 4 // VARIABLEN // int arr0r; // digital von MUX0 lesen int arr1r; // digitales Lesen von MUX1 int arr2r; // digitales Lesen von MUX2 int arr3r; // digitales Lesen von MUX3 int arr4r; // digitales Lesen von MUX4 Void setup () { // Geben Sie Ihren Setup-Code hier ein, um ihn einmal auszuführen: DDRB = B11111111; // setzt Arduino-Pins 8 bis 13 als Eingänge pinMode (s0, OUTPUT); pinMode (s1, AUSGANG); pinMode (s2, AUSGANG); pinMode (s3, AUSGANG); pinMode (s4, AUSGANG); pinMode (m0, EINGANG); pinMode (m1, EINGANG); pinMode (m2, EINGANG); pinMode (m3, EINGANG); pinMode (m4, EINGANG); aufrechtzuerhalten. Void loop () { // Setzen Sie Ihren Hauptcode hier ein, um ihn wiederholt auszuführen: PORTB = B00000000; // Steuerpins für Mux niedrig setzen für (int i = 0; i < numChannel; i++) {// Digitaler Leseausgang von MUX0 - MUX4 für IR-Sensor i // Wenn der IR-Sensor LO ist, wird das Dreieck vom Spieler berührt. arr0r = digitalRead (m0); // Lesen von Mux 0, IR-Sensor i arr1r = digitalRead (m1); // Lesen von Mux 1, IR-Sensor i arr2r = digitalRead (m2); // Lesen von Mux 2, IR-Sensor i arr3r = digitalRead (m3); // Lesen von Mux 3, IR-Sensor i arr4r = digitalRead (m4); // Lesen von Mux 4, IR-Sensor i // TUN SIE ETWAS MIT MUX-EINGÄNGEN ODER HIER IN EINEM ARRAY SPEICHERN // PORTB ++; // Steuersignale für MUX inkrementieren } }

Schritt 9: Streulicht mit Acryl

Um das Licht der LEDs zu streuen, habe ich transparentes Acryl mit einem Kreisschleifer geschliffen. Der Schleifer wurde in einer Achterbewegung über beide Seiten des Acryls bewegt. Ich fand diese Methode viel besser als „Mattglas“-Sprühfarbe.

Nach dem Schleifen und Reinigen des Acryls habe ich mit einem Laserschneider Dreiecke ausgeschnitten, die über die LEDs passen. Es ist möglich, das Acryl mit einem Acrylschneidwerkzeug oder sogar einer Stichsäge zu schneiden, wenn das Acryl nicht reißt. Das Acryl wurde von 5 mm dicken Sperrholzrechtcken über den LEDs gehalten, die ebenfalls mit einem Laserschneider geschnitten wurden. Diese kleinen Bretter wurden auf die Streben der Kuppel geklebt und die Acryldreiecke wurden auf die Bretter geklebt.

Schritt 10: Musik machen mit dem Dome mit MIDI

Ich wollte, dass die Kuppel in der Lage ist, Klang zu erzeugen, also habe ich fünf MIDI-Kanäle eingerichtet, einen für jede Untergruppe der Kuppel. Sie müssen zuerst fünf MIDI-Buchsen kaufen und wie im Schaltplan gezeigt anschließen (weitere Informationen finden Sie in diesem Tutorial vom Arduino-Support).

Da es nur einen seriellen Sendepin am Arduino Uno gibt (Pin 2 als TX-Pin bezeichnet), müssen Sie die an die fünf MIDI-Buchsen gesendeten Signale demultiplexen. Ich habe die gleichen Steuersignale (Pin 8-12) verwendet, da MIDI-Signale zu einem anderen Zeitpunkt gesendet werden, als wenn die IR-Sensoren in den Arduino eingelesen werden. Diese Steuersignale werden an einen 8-Kanal-Demultiplexer gesendet, sodass Sie steuern können, welche MIDI-Buchse das vom Arduino erzeugte MIDI-Signal empfängt. Die MIDI-Signale wurden vom Arduino mit der grandiosen MIDI-Signalbibliothek von Francois Best generiert. Hier ist ein Beispielcode zum Erzeugen mehrerer MIDI-Ausgänge an verschiedene MIDI-Buchsen mit einem Arduino Uno:

#include // MIDI-Bibliothek einbinden

#define numChannel 24 //Anzahl IR pro Dreieck #define numSections 5 // Anzahl Sektionen im Dome, Anzahl 24channel MUX, Anzahl MIDI-Buchsen // OUTPUTS // int s0 = 8; // MUX-Steuerung 0 - PORTbD int s1 = 9; // MUX-Steuerung 1 - PORTb int s2 = 10; // MUX-Steuerung 2 - PORTb int s3 = 11; // MUX-Steuerung 3 - PORTb int s4 = 12; // MUX-Steuerung 4 - PORTb // EINGÄNGE // int m0 = 3; // MUX-Eingang 0 int m1 = 4; // MUX-Eingang 1 int m2 = 5; // MUX-Eingang 2 int m3 = 6; // MUX-Eingang 3 int m4 = 7; // MUX-Eingang 4 // VARIABLEN // int arr0r; // digital von MUX0 lesen int arr1r; // digitales Lesen von MUX1 int arr2r; // digitales Lesen von MUX2 int arr3r; // digitales Lesen von MUX3 int arr4r; // digitales Lesen von MUX4 int midArr[numSections]; // Speichern, ob eine Note von einem der Spieler gedrückt wurde oder nicht int note2play[numSections]; // Zu spielende Note speichern, wenn der Sensor berührt wird 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; // Pausenzeit zwischen Midi-Signalen MIDI_CREATE_DEFAULT_INSTANCE (); Void setup () {// setzen Sie Ihren Setup-Code hier ein, um ihn einmal auszuführen: DDRB = B11111111; // setzt Arduino-Pins 8 bis 13 als Eingänge MIDI.begin (MIDI_CHANNEL_OFF); pinMode (s0, AUSGANG); pinMode (s1, AUSGANG); pinMode (s2, AUSGANG); pinMode (s3, AUSGANG); pinMode (s4, AUSGANG); pinMode (m0, EINGANG); pinMode (m1, EINGANG); pinMode (m2, EINGANG); pinMode (m3, EINGANG); pinMode (m4, EINGANG); aufrechtzuerhalten. Void loop () { // Setzen Sie Ihren Hauptcode hier ein, um ihn wiederholt auszuführen: PORTB = B00000000; // Steuerpins für Mux niedrig setzen für (int i = 0; i < numChannel; i++) {// Digitaler Leseausgang von MUX0 - MUX4 für IR-Sensor i // Wenn der IR-Sensor LO ist, wird das Dreieck vom Spieler berührt. arr0r = digitalRead (m0); // Lesen von Mux 0, IR-Sensor i arr1r = digitalRead (m1); // Lesen von Mux 1, IR-Sensor i arr2r = digitalRead (m2); // Lesen von Mux 2, IR-Sensor i arr3r = digitalRead (m3); // Lesen von Mux 3, IR-Sensor i arr4r = digitalRead (m4); // Lesen von Mux 4, IR-Sensor i if (arr0r == 0) // Sensor in Abschnitt 0 wurde blockiert { midArr [0] = 1; // Spieler 0 hat eine Note angeschlagen, HI setzen, damit für Spieler 0 MIDI ausgegeben wird note2play[0] = notes; // Hinweis zum Spielen für Spieler 0} if (arr1r == 0) // Sensor in Abschnitt 1 wurde blockiert { midArr [1] = 1; // Spieler 0 hat eine Note angeschlagen, HI setzen, damit für Spieler 0 MIDI ausgegeben wird note2play[1] = notes; // Hinweis zum Spielen für Spieler 0} if (arr2r == 0) // Sensor in Abschnitt 2 wurde blockiert { midArr [2] = 1; // Spieler 0 hat eine Note angeschlagen, HI setzen, damit für Spieler 0 MIDI ausgegeben wird note2play[2] = notes; // Hinweis zum Spielen für Spieler 0} if (arr3r == 0) // Sensor in Abschnitt 3 wurde blockiert { midArr [3] = 1; // Spieler 0 hat eine Note angeschlagen, HI setzen, damit für Spieler 0 MIDI ausgegeben wird note2play[3] = notes; // Hinweis zum Spielen für Spieler 0} if (arr4r == 0) // Sensor in Abschnitt 4 wurde blockiert { midArr[4] = 1; // Spieler 0 hat eine Note angeschlagen, setze HI, damit es MIDI-Ausgabe für Spieler 0 gibt note2play[4] = notes; // Spielnotiz für Spieler 0 } PORTB ++; // Steuersignale für MUX inkrementieren aufrechtzuerhalten. updateMIDI(); aufrechtzuerhalten. Void updateMIDI () {PORTB = B00000000; // Steuerpins für Mux niedrig setzen, wenn (midArr[0] == 1) // Player 0 MIDI-Ausgang { MIDI.sendNoteOn (note2play[0], 127, 1); VerzögerungMikrosekunden (pauseMidi); MIDI.sendNoteOff(note2play[0], 127, 1); VerzögerungMikrosekunden (pauseMidi); } PORTB++; // MUX erhöhen if (midArr[1] == 1) // Player 1 MIDI-Ausgang { MIDI.sendNoteOn(note2play[1], 127, 1); VerzögerungMikrosekunden (pauseMidi); MIDI.sendNoteOff(note2play[1], 127, 1); VerzögerungMikrosekunden (pauseMidi); } PORTB++; // MUX erhöhen if (midArr[2] == 1) // Player 2 MIDI-Ausgang { MIDI.sendNoteOn(note2play[2], 127, 1); VerzögerungMikrosekunden (pauseMidi); MIDI.sendNoteOff(note2play[2], 127, 1); VerzögerungMikrosekunden (pauseMidi); } PORTB++; // MUX erhöhen if (midArr[3] == 1) // Player 3 MIDI-Ausgang { MIDI.sendNoteOn(note2play[3], 127, 1); VerzögerungMikrosekunden (pauseMidi); MIDI.sendNoteOff(note2play[3], 127, 1); VerzögerungMikrosekunden (pauseMidi); } PORTB++; // MUX erhöhen if (midArr[4] == 1) // Player 4 MIDI-Ausgang { MIDI.sendNoteOn(note2play[4], 127, 1); delayMikrosekunden (pauseMidi); MIDI.sendNoteOff(note2play[4], 127, 1); delayMikrosekunden (pauseMidi); } midArr[0] = 0; midArr[1] = 0; midArr[2] = 0; midArr[3] = 0; midArr[4] = 0; }

Schritt 11: Stromversorgung der Kuppel

Es gibt mehrere Komponenten, die in der Kuppel mit Strom versorgt werden müssen. Sie müssen daher die von jeder Komponente gezogenen Ampere berechnen, um das Netzteil zu bestimmen, das Sie kaufen müssen.

Der LED-Streifen: Ich habe ungefähr 3,75 Meter des Ws2801-LED-Streifens verwendet, der 6,4 W / Meter verbraucht. Dies entspricht 24W (3,75*6,4). Um dies in Ampere umzuwandeln, verwenden Sie Power = Strom * Volt (P = iV), wobei V die Spannung des LED-Streifens ist, in diesem Fall 5 V. Daher beträgt der von den LEDs gezogene Strom 4,8 A (24 W/5 V = 4,8 A).

Die IR-Sensoren: Jeder IR-Sensor zieht etwa 25 mA, insgesamt 3 A für 120 Sensoren.

Der Arduino: 100mA, 9V

Die Multiplexer: Es gibt fünf 24-Kanal-Multiplexer, die jeweils aus einem 16-Kanal-Multiplexer und einem 8-Kanal-Multiplexer bestehen. Der 8-Kanal- und der 16-Kanal-MUX verbrauchen jeweils ca. 100mA. Daher beträgt der Gesamtstromverbrauch aller MUX 1A.

Addiert man diese Komponenten, wird ein Gesamtstromverbrauch von etwa 9 A erwartet. Der LED-Streifen, die IR-Sensoren und die Multiplexer haben eine Eingangsspannung von 5 V und der Arduino hat eine Eingangsspannung von 9 V. Daher habe ich ein 12V 15A Netzteil, einen 15A Abwärtswandler zum Umwandeln der 12V in 5V und einen 3A Abwärtswandler zum Umwandeln von 12V in 9V für den Arduino ausgewählt.

Schritt 12: Kreisförmige Kuppelbasis

Die Kuppel ruht auf einem runden Holzstück, in dessen Mitte ein Fünfeck ausgeschnitten ist, um einen einfachen Zugang zur Elektronik zu ermöglichen. Um diese kreisförmige Basis zu erstellen, wurde eine 4x6 Fuß große Sperrholzplatte mit einem Holz-CNC-Router geschnitten. Für diesen Schritt könnte auch eine Stichsäge verwendet werden. Nachdem die Basis geschnitten wurde, wurde die Kuppel mit kleinen 2x3” Holzblöcken daran befestigt.

Oben auf der Basis habe ich das Netzteil mit Epoxid und die MUXs und Buck-Konverter mit PCB-Abstandshaltern befestigt. Die Abstandshalter wurden mit E-Z Lok-Gewindeadaptern am Sperrholz befestigt.

Schritt 13: Pentagon Dome Base

Neben dem runden Sockel habe ich für die Kuppel auch einen Fünfecksockel mit einem Schauglas an der Unterseite konstruiert. Diese Basis und das Sichtfenster wurden ebenfalls aus Sperrholz hergestellt, das mit einer Holz-CNC-Fräse geschnitten wurde. Die Seiten des Fünfecks bestehen aus Holzbohlen, wobei eine Seite ein Loch für die Anschlüsse hat. Mit Metallklammern und 2x3 Blockverbindungen werden die Holzbohlen an der Fünfeckbasis befestigt. Ein Netzschalter, MIDI-Anschlüsse und ein USB-Anschluss sind an einer Frontplatte angebracht, die ich mit einem Laserschneider erstellt habe. Die gesamte Fünfeckbasis wird mit der in Schritt 12 beschriebenen kreisförmigen Basis verschraubt.

Ich habe ein Fenster in die Unterseite der Kuppel eingebaut, damit jeder in die Kuppel schauen kann, um die Elektronik zu sehen. Der Spiegel wird mit einem Laserschneider aus Acryl geschnitten und auf ein kreisförmiges Stück Sperrholz geklebt.

Schritt 14: Programmierung der Kuppel

Es gibt unendlich viele Möglichkeiten, die Kuppel zu programmieren. Jeder Zyklus des Codes nimmt die Signale der IR-Sensoren auf, die die von jemandem berührten Dreiecke anzeigen. Mit diesen Informationen können Sie den Dome mit einer beliebigen RGB-Farbe einfärben und/oder ein MIDI-Signal erzeugen. Hier sind ein paar Beispiele für Programme, die ich für die Kuppel geschrieben habe:

Farbe der Kuppel: Jedes Dreieck durchläuft vier Farben, wenn es berührt wird. Wenn sich die Farben ändern, wird ein Arpeggio gespielt. Mit diesem Programm können Sie die Kuppel auf tausende verschiedene Arten einfärben.

Dome-Musik: Der Dome ist mit fünf Farben gefärbt, wobei jeder Abschnitt einem anderen MIDI-Ausgang entspricht. Im Programm können Sie auswählen, welche Noten jedes Dreieck spielt. Ich entschied mich, mit dem mittleren C oben auf der Kuppel zu beginnen und die Tonhöhe zu erhöhen, wenn sich die Dreiecke näher an die Basis bewegten. Da es fünf Ausgänge gibt, ist dieses Programm ideal, um mehrere Personen gleichzeitig auf der Kuppel spielen zu lassen. Mit einem MIDI-Instrument oder einer MIDI-Software können diese MIDI-Signale wie jedes Instrument klingen.

Simon: Ich habe eine Version von Simon geschrieben, dem klassischen Memory-Light-Up-Spiel. Eine zufällige Abfolge von Lichtern wird nacheinander über die gesamte Kuppel beleuchtet. In jeder Runde muss der Spieler die Reihenfolge kopieren. Wenn der Spieler die Sequenz richtig übereinstimmt, wird der Sequenz ein zusätzliches Licht hinzugefügt. Der Highscore wird in einem der Abschnitte der Kuppel gespeichert. Es macht auch sehr viel Spaß, dieses Spiel mit mehreren Personen zu spielen.

Pong: Warum nicht auf einer Kuppel Pong spielen? Ein Ball breitet sich über die Kuppel aus, bis er das Paddel trifft. Wenn dies der Fall ist, wird ein MIDI-Signal erzeugt, das anzeigt, dass der Schläger den Ball getroffen hat. Der andere Spieler muss dann das Paddel am Boden der Kuppel entlangführen, damit es den Ball zurückschlägt.

Schritt 15: Fotos der fertigen Kuppel

Großer Preis beim Arduino-Wettbewerb 2016

Zweiter Preis beim Remix Contest 2016

Zweiter Preis beim Make it Glow Contest 2016