RGB Matrix Audio Visualizer mit Arduino

Notwendige Werkzeuge und Maschinen

Bohrschrauber / Akkuschrauber

Über dieses Projekt

In diesem Artikel erkläre ich, wie man einen RGB-LED-Matrix-Audiovisualisierer mit einem Arduino, einem RGB-LED-Matrix-Schild und einem Audio-Spektrum-Analysator-Schild baut und es dann in ein Gehäuse steckt, damit Sie ein fertiges Projekt haben, das Sie können Anzeige von Ihrem Musiksystem, um eine schöne Lichtshow Ihrer Musik zu haben!

Für die Audiospektrumanalyse verwende ich das Spectrum Shield von SparkFun, das zwei grafische Equalizer-Anzeigefilter MSGEQ7 verwendet, die einen Stereo-Audioeingang in 7-Bänder (pro Kanal) aufteilen und die Amplitude von jedem mit dem ADC auf Ihrem Arduino lesen. Es wird mit Arduino-Beispielskizzen geliefert, um loszulegen.

Für die RGB-LED-Matrix verwende ich das NeoPixel Shield von Adafruit für Arduino, das aus 40 RGB-NeoPixeln besteht (Adafruits Terminologie für ihre WS2812-Lichtquelle). Rote, grüne und blaue LEDs sind neben einem Treiberchip in einem winzigen SMD-Gehäuse integriert, das über einen einzigen Draht gesteuert wird. Sie können einzeln verwendet, zu längeren Strings verkettet oder zu noch interessanteren Formfaktoren zusammengestellt werden. Im Fall des Shields sind sie aneinander gekettet. Das Shield wird auch mit der Adafruit_NeoMatrix-Bibliothek geliefert, die den Zugriff auf die RGB-LED-Matrix und die Steuerung der LEDs vereinfacht.

Als letztes kommt das Gehäuse. Einige von Ihnen wissen vielleicht, dass ich ein neues stapelbares, modulares Gehäusesystem namens ProtoStax entwickelt habe. Es war ein persönlicher Juckreiz, den ich kratzen musste - ich wollte ein Gehäuse, das verschiedene Phasen des Prototyping unterstützt, Schutz und offenen Zugang zu Beginn bietet, mit der Möglichkeit, später Seitenwände und die Oberseite hinzuzufügen, aber auch die Möglichkeit zum Stapeln hat mehrere Einheiten entweder nebeneinander oder übereinander, wodurch die Möglichkeit besteht, mit Prototyping-Anforderungen und dem Hinzufügen anderer Platinen und Komponenten zu erweitern.

In diesem Beispiel verwende ich ProtoStax für Arduino, ein durchsichtiges Acrylgehäuse für das Arduino – es passt sowohl auf den Uno/Leonardo-Footprint als auch auf den größeren Mega/Due-Footprint – das ist auch stapelbar und modular und bietet bequem Platz für die beiden Schilde (mit einigen geringfügigen Änderungen, die ich skizzieren werde). Er ist klar und robust und hat Gummifüße, um ihn leicht anzuheben und die Oberfläche Ihres Tisches zu schützen, damit Sie Ihren Audio Visualizer und seine Lichtshow zusammen mit Ihrem Musiksystem anzeigen können!

Okay, fangen wir an, ja?

Schritt 1 - Montieren Sie das Arduino an der Gehäusegrundplatte

Montieren wir zuerst den Arduino (Uno in unserem Beispiel) auf der Grundplatte des Gehäuses. Dies bietet Schutz und bietet gleichzeitig vollen offenen Zugriff, um das Arduino zu konfigurieren und einzurichten und damit herumzuspielen. Wenn Sie bereit sind, es zu schließen, können Sie die Seitenwände und die obere Platte einfach hinzufügen und alles mit Schrauben befestigen.

Montieren Sie das Arduino auf der Grundplatte und fügen Sie Füße und andere Hardware hinzu, um das Gehäuse in der Plattformkonfiguration vorzubereiten . Sehen Sie sich die Schritte unten in der Diashow an - die Bildunterschrift ist nummeriert und enthält zusätzliche Erklärungen für jeden Schritt.

Hier sind alle Schritte als animiertes Gif:

Schritt 2 - Bereiten Sie das SparkFun Spectrum Shield für den Arduino vor

Das SparkFun Spectrum Shield wird ohne Header geliefert. Zum Glück für uns kommt Adafruit NeoPixel Shield für Arduino sowohl mit Stacking-Headern als auch mit einfachen Headern. Da ich möchte, dass das NeoPixel Shield oben ist, möchte ich einfache Header damit verwenden, damit es bündig ist, und so bleiben die Stacking-Header für die Verwendung mit dem Spectrum Shield übrig, was genau das ist, was ich will!

Allerdings passt das Spectrum Shield mit Stacking-Headern nicht genau - die USB- und Power-Ports des Arduino Uno sind im Weg, wie im Bild unten gezeigt.

Ich habe die folgenden zwei Änderungen vorgenommen -

• Schneiden Sie das Ende des Spectrum Shield über den USB- und Stromanschlüssen ab (dieser Teil hat einen Prototyping-Bereich, der nicht verwendet wird. Selbst wenn Sie ihn verwenden, schneiden Sie am Ende nur eine Reihe von Löchern ab) Dies macht das Spectrum Shield sitzt fest auf dem Arduino.
• Die Beine der Stapelleisten sind möglicherweise immer noch zu lang, als dass der Spectrum Shield fest sitzen könnte. Ich habe die Beine der Stapelköpfe ein Haar abgeschnitten, damit das Spectrum Shield mit den Stapelköpfen eng auf dem Arduino sitzt.

Jetzt passt es genau!

Schritt 3 - Setzen Sie das Adafruit NeoPixel Shield für Arduino in den Stacking-Header des Spectrum Shield ein

Das Adafruit NeoPixel Shield geht über das Spectrum Shield. Sie müssen zuerst die regulären Header (die mitgeliefert wurden) einlöten. Ich habe auch den mitgelieferten Anschlussstecker eingelötet, obwohl ich ihn in diesem Beispiel mit dem Arduino betreibe, da sich nicht alle LEDs gleichzeitig einschalten, sodass der Stromverbrauch innerhalb der Mengen liegt, die das Arduino bereitstellen kann .

Nachricht von Adafruits NeoPixel Shield für Arduino-Seite:

Schritt 4 – Democode

Werfen wir einen Blick auf den Demo-Code und sehen Sie, was er bewirkt. Dazu können wir es in zwei Hauptteile aufteilen:

• Spektrumanalyse und Ergebnisse speichern
• Übersetzen in ein Anzeige-/Farbschema für die 8x5 NeoPixel Matrix.

Hier können Sie schnell auf den Democode zugreifen:

https://github.com/protostax/ProtoStax_Audio_Visualizer_Demo/blob/master/ProtoStax_Audio_Visualizer_Demo.ino

Spektrumanalyse

Weitere Informationen zum Spectrum Shield finden Sie im Spectrum Shield-Anschlusshandbuch. Die Informationen habe ich hier zusammengefasst.

Indem Sie eine digitale Sequenz an die STROBE- und RESET-Pins des Spectrum Shield schreiben, initialisieren Sie die vom Shield verwendeten MSGEQ7-Chips. Sie können dann fortfahren, die Größe jedes der 7 verschiedenen Frequenzbänder abzulesen, in die das Spektrum aufgeteilt ist. Jedes Band wird gelesen, gefolgt von einem Pulsieren des STROBE-Pins, um das Lesen des nächsten Bands einzuleiten. Die Werte werden in Frequencies_One[7] und Frequencies_Two[7] für die beiden Kanäle des Stereoeingangs gespeichert. Die Werte werden mit den 10-Bit-ADCs des Arduino gelesen und der Ausgabewert kann somit 0 - 1023 sein - sie liefern eine Darstellung der Amplitude jedes Frequenzbandes.

//Spektrumschild-Pin-Verbindungen deklarieren#define STROBE 4#define RESET 5#define DC_One A0#define DC_Two A1 //Spektrumvariablen definierenint freq_amp;int Frequencies_One[7];int Frequencies_Two[7]; int ich; Void setup () { ... // Spektrumanalysatoren initialisieren digitalWrite (STROBE, LOW); Verzögerung (1); digitalWrite (RESET, HIGH); Verzögerung (1); digitalWrite (STROBE, HOCH); Verzögerung (1); digitalWrite (STROBE, NIEDRIG); Verzögerung (1); digitalWrite(RESET, LOW);...} void loop() {... Read_Frequencies();...} /********************Frequenzen aus ziehen Spectrum Shield********************/void Read_Frequencies () {... // Frequenzen für jedes Band lesen für (freq_amp =0; freq_amp<7; freq_amp++) { Frequencies_One[freq_amp] =(analogRead(DC_One) + analogRead(DC_One) )>> 1; Frequencies_Two[freq_amp] =(analogRead(DC_Two) + analogRead(DC_Two))>> 1; ... digitalWrite(STROBE, HIGH); digitalWrite (STROBE, NIEDRIG); }} 

Die 7 Bänder des Frequenzspektrums sind:

• 63Hz
• 160Hz
• 400Hz
• 1kHz
• 2,5 kHz
• 6,25 kHz
• 16 kHz

Ich habe diese in 3 Bereiche aufgeteilt - BASS, MID_RANGE und TREBLE. Der typische Bassbereich liegt zwischen 60 und 250 Hz, die ersten beiden Bänder liegen also im BASS-Bereich. Mittlere Frequenzen sind typischerweise 500 Hz bis 2 kHz, daher gruppiere ich die nächsten 3 Bänder in MID_RANGE. Die restlichen 2 Bänder gruppiere ich in TREBLE.

[Anmerkung:Ich notiere auch den maximalen Messwert jedes der Bänder in einer separaten Variablen. Dies kann möglicherweise verwendet werden, um die Messwerte automatisch auf den durch die RGB-Matrix-Spalten repräsentierten Pegel zu skalieren - dies ist nützlich, wenn das Eingangssignal niedrig ist - sonst würden dann nur sehr wenige der RGB-Matrix aufleuchten. ]

RGB-Matrix

Weitere Informationen zum NeoPixel Shield und zu NeoPixels im Allgemeinen finden Sie im Adafruit NeoPixel Überguide. Die Informationen zu unserer Nutzung habe ich hier zusammengefasst.

Der Hauptpunkt, den ich zu klären versuchen werde, was ich zunächst etwas verwirrend fand, ist die Richtung und Ausrichtung des NeoPixel Shields und die Nummerierung des Koordinatensystems. Der Überguide erklärt es, aber ich denke, ich kann es ein wenig einfacher machen.

Als erstes ist zu beachten, dass sich [0, 0] im Koordinatensystem unabhängig von der Ausrichtung IMMER auf die obere linke Seite bezieht.

Als nächstes notieren Sie die BREITE, gefolgt von der HÖHE, der Ausrichtung, an der Sie interessiert sind (z. B. 5 x 8 vs. 8 x 5 bei unserem Schild)

Drittens ist die Position der PHYSIKALISCHEN LED #0 (gekennzeichnet durch das niedliche Adafruit-Logo) zu beachten. OBEN-RECHTS, OBEN-LINKS, UNTEN-LINKS und BOTTOM-RECHTS, je nachdem. Beachten Sie auch die Ausrichtung des Verlaufs der physikalischen LEDs. Das Layout ist in unserem Board PROGRESSIV (die nächste physikalische LED nach dem Ende einer Reihe beginnt am Anfang der nächsten Reihe, wie durch die GELBE Linie angezeigt). Die Ausrichtung der Progression ist entlang der REIHEN, wenn die Breite breiter ist (horizontale Ausrichtung) (wie durch die kurzen GRÜNEN Pfeile angezeigt) und SÄULEN mit der Breite schmaler ist (vertikale Ausrichtung) (wiederum durch die kurzen GRÜNEN Pfeile angezeigt ).

Diese werden durch die 4 Bilder unten in der Slideshow veranschaulicht. Die Bildunterschriften beinhalten jeweils die dazugehörigen Einstellungen!

In unserem Beispiel haben wir 7 Frequenzbänder und eine 8 x 5 (oder 5 x 8 je nach Betrachtungsweise!) Matrix. Ich habe mich dafür entschieden, die 7 Bänder entlang der 8-Dimension anzuzeigen (wobei eine ungenutzt bleibt). Ich würde dann die Amplitudendarstellung jedes Frequenzbandes entlang der 5-Dimension anzeigen. Mit anderen Worten, ich möchte, dass mein Fortschritt wie folgt aussieht:

Ich möchte, dass mein Ursprung in der unteren linken Ecke beginnt (die die niedrigste Ebene des niedrigsten Frequenzbands darstellt) und sich nach oben vorarbeitet. Da aber im Koordinatensystem als erstes zu beachten ist, dass sich [0, 0] immer auf TOP-LEFT bezieht, sollten Sie Ihren Kopf nach links neigen und sich das Bild unten ansehen, um die Wahl der Werte für die Initialisierung der NeoMatrix zu verstehen ! 😊(BREITE =5, HÖHE =8, OBEN-RECHTS, SÄULEN PROGRESSIV)

Lassen Sie uns ein wenig in den Democode der NeoMatrix eintauchen und die Frequenzen grafisch darstellen. Zuerst haben wir festgestellt, dass unser NeoPixel WIDTH=5, HEIGHT=8 hat und die Ausrichtung, die wir mögen, OBEN-RECHTS und COLUMNS PROGRESSIVE ist. Folgen Sie dem für die Matrix erforderlichen Setup in der Funktion setup().

In der Schleife () lesen wir jede serielle Eingabe, um das Farbschema auszuwählen - ich habe 3 verschiedene Farbschemata definiert

enum SCHEME { MAGNITUDE_HUE =0, MAGNITUDE_HUE_2 =1, HSV_COLOR_WHEEL =2}; 

Dann rufe ich Graph_Frequencies mit dieser Farbschemaauswahl auf. Beachten Sie auch den ersten Parameter, der den anzuzeigenden Frequenzbereich auswählen kann (BASS, MID-RANGE oder TREBLE)

enum RANGE { BASS =0, MID_RANGE =1, TREBLE =2, ALL =3}; 

Im Moment wähle ich alle anzuzeigenden Bereiche aus - es bleibt dem Leser als Übung überlassen, die Auswahl der anzuzeigenden Bereiche zu implementieren - entweder über die serielle Eingabe oder durch Einfügen einer kurzzeitigen Drucktaste zum Umschalten der Anzeige zwischen BASS, MID_RANGE, TREBLE oder ALLE. Die Auswahl des RANGE bestimmt den "von"- und "bis"-Bereich der anzuzeigenden Zeilen.

Für jede Reihe (Frequenzband) wählen wir den größeren der beiden Frequenzgrößen (rechter Kanal und linker Kanal des Stereoeingangs). Dieser Wert liegt zwischen 0 und 1023, wie wir bereits besprochen haben. Wir müssen dies in 5 verschiedene Spalten der Anzeige abbilden, also teilen wir die Frequenz durch den FREQ_DIV_FACTOR, der als 204 definiert ist (1023/204 =5, was eine Ausgabe von 1023 auf 5 abbildet). Zur Sicherheit stellen wir außerdem sicher, dass die anzuzeigende numCol nicht größer als 5 ist. Dies bestimmt die Anzahl der anzuzeigenden Spalten für jedes Frequenzband.

Dann verwende ich matrix.drawPixel(), um das entsprechende Pixel in der entsprechenden Farbe anzuzeigen.

Ich verwende das HSV-Farbrad in meiner grafischen Anzeige. Dies führte zu einigen zusätzlichen Falten, die es zu überwinden galt.

Typischerweise ist die Verwendung matrix.drawPixel(column, row, Color(r, g, b)), wobei Color(r, g, b) eine Farbe darstellt, die durch die Werte ROT, GRÜN und BLAU angegeben wird. Die Verwendung von HSV ermöglicht jedoch einige schöne sanfte Farbübergänge.

NeoMatrix stellt die Methode matrix.ColorHSV(uint16_t hue) bereit, die einen einzelnen uint16_t hue-Wert verwendet und eine uint32_t HSV-Farbe zurückgibt.

Matrix.Color(r, g, b) gibt jedoch eine uint16_t-Farbe zurück. matrix.drawPixel erwartet auch eine 16-Bit-Farbe.

Um dies zu umgehen, verwenden Sie matrix.setPassThruColor (32-Bit-Farbwert). Dies setzt ein Flag in der Matrix, das bewirkt, dass drawPixel sein Farbargument ignoriert und stattdessen die 32-Bit-Farbe verwendet, die bereits durch die obige Methode festgelegt wurde. Denken Sie daran, matrix.setPassThruColor() aufzurufen, um das fragliche Flag zurückzusetzen. Nicht super elegant, aber es funktioniert. Beispiel:

 statisch uint16_t hue =0; //21845 22250 bis -250 uint16_t hueDelta =200; Farbton +=FarbtonDelta;... rgbcolor =matrix.ColorHSV(hue);... matrix.setPassThruColor(rgbcolor); matrix.drawPixel(col, row, (uint16_t)0); // Farbe spielt hier keine Rolle matrix.setPassThruColor();...matrix.show(); 

Mit HSV ist es möglich, den 16-Bit-Farbton zu erhöhen und den HSV-Farbcode zu generieren, wodurch schöne weiche Farbübergänge erzielt werden.

Hier sind die verschiedenen Codestücke als Referenz:

  #define NEO_MATRIX_WIDTH 5 # definieren NEO_MATRIX_HEIGHT 8 # definieren NEOPIXEL_PIN 6 // Schild bildet sie 6Adafruit_NeoMatrix matrix =Adafruit_NeoMatrix (NEO_MATRIX_WIDTH, NEO_MATRIX_HEIGHT, NEOPIXEL_PIN, NEO_MATRIX_TOP NEO_MATRIX_RIGHT + + + NEO_MATRIX_COLUMNS NEO_MATRIX_PROGRESSIVE, NEO_GRB + NEO_KHZ800) zu; .... void setup() {... matrix.begin(); matrix.setTextWrap(false); matrix.setHelligkeit(40); matrix.fillScreen(0); matrix.show();...} void loop() { static int scheme =0; while (Serial.available ()> 0) { Schema =Serial.parseInt (); }... Graph_Frequencies(ALL, scheme);... delay(50);} void Graph_Frequencies(CHANNEL c, SCHEME s){... for( row=from; row Frequencies_One[row])?Frequencies_Two[row]:Frequencies_One[row]; int numCol =(Freq/FREQ_DIV_FACTOR); if (numCol> 5) numCol =5; for (int col =0; col  

Als nächstes folgt die Auswahl des Farbschemas. Beachten Sie, dass ich Vorkehrungen getroffen habe, um Farben für verschiedene Frequenzbereiche (bassHue, midHue, trebleHue) auswählen zu können. Ich habe 3 verschiedene Farbschemata erstellt - eines, das einen grünen bis roten / rosa Bereich für die Anzeige von der niedrigsten Amplitude bis zum höchsten verwendet, und das andere, das einen eher rosa / blau verschobenen Bereich verwendet. Das dritte Schema verwendet dieselbe Farbe für alle Pixel, durchläuft jedoch das gesamte Farbrad, während es fortschreitet. Ich zeige Ihnen ein Video von allen 3 Farbschemata.

 switch(s) { case MAGNITUDE_HUE:bassHue =22250; mittlerer Farbton =22250; ///54613 trebleHue =22250; // 43690 if (Zeile>=0 &&Zeile <2) { rgbcolor =matrix.ColorHSV (bassHue - (7416 * col)); aufrechtzuerhalten. Sonst if (Zeile>=2 &&Reihe <5) {rgbcolor =matrix.ColorHSV (midHue - (7416 * col)); aufrechtzuerhalten. Sonst if (Reihe>=5 &&Reihe <7) { rgbcolor =matrix.ColorHSV (trebleHue - (7416 * col)); } brechen; Fall MAGNITUDE_HUE_2:bassHue =54613; mittlerer Farbton =54613; ///54613 trebleHue =54613; // 43690 if (Zeile>=0 &&Zeile <2) { rgbcolor =matrix.ColorHSV (bassHue - (7416 * col)); aufrechtzuerhalten. Sonst if (Zeile>=2 &&Reihe <5) {rgbcolor =matrix.ColorHSV (midHue - (7416 * col)); aufrechtzuerhalten. Sonst if (Reihe>=5 &&Reihe <7) { rgbcolor =matrix.ColorHSV (trebleHue - (7416 * col)); } brechen; case HSV_COLOR_WHEEL:rgbcolor =matrix.ColorHSV(hue); brechen; } 

Schritt 6 – Alles testen

Hier ist ein Video, in dem Sie alles testen

Schritt 6 – Schließen Sie es ab

Montieren Sie die oberen Versteifungselemente, Seitenwände, Audiokabel und die Oberseite. Sehen Sie sich die Schritte unten in der Diashow an - die Bildunterschrift ist nummeriert und enthält zusätzliche Erklärungen für jeden Schritt.

Hier sind alle Schritte in einem einzigen animierten Gif:

Schritt 7 – Präsentieren Sie Ihre Kreation und machen Sie schöne Musik noch schöner!

Sie können jetzt einen lustigen Audiovisualisierer haben, den Sie neben Ihrem Musiksystem anzeigen und mit coolen hausgemachten Lichtaktionen Ihre Musik ergänzen können!

Schritt 8 – Weitermachen

Hier sind einige Ideen, um das Projekt noch weiter voranzutreiben!

1. Derzeit werden die Audiokabel (Eingang und Ausgang) in das Spectrum Shield im Gehäuse eingesteckt, und dadurch haben Sie dieses Gehäuse mit diesen Drähten verbunden und baumeln draußen. Stattdessen können Sie an der Seitenwand in der Nähe der Stereobuchsen des Spectrum Shield ein paar Stereobuchsen für die Panelmontage (aufgeführt in der Liste der verwendeten "Dinge") anbringen und dann ein Audiokabel mit einer 3,5-mm-Stereo-Audiobuchse verlöten zu jedem, und stecken Sie diese dann stattdessen an die Audiobuchsen des Spectrum Shield. In diesem Fall wird Ihr Gehäuse sehr ordentlich und die gesamte Verkabelung ist in sich geschlossen, wobei nur Audiobuchsen am Gehäuse vorhanden sind, an die externe Systeme angeschlossen werden können.

2. Sie können Ihrem Audio Visualizer noch mehr Lichtschemata hinzufügen - verschiedene Farbbereiche, verschiedene Muster.

3. Fügen Sie die Option zum Aktivieren/Deaktivieren von Frequenzbereichen über den seriellen Eingang hinzu - derzeit können nur Farbschemata geändert werden, jedoch nicht die anzuzeigenden Frequenzbereiche.

4. Fügen Sie einen Schalter hinzu, um zwischen verschiedenen Farbschemata umzuschalten, anstatt den seriellen Eingang zu verwenden. Modifizieren Sie das Gehäuse, um ein Loch zu einer der langen Seitenwände hinzuzufügen, um einen kurzzeitigen Druckknopfschalter für die Schalttafelmontage aufzunehmen (aufgelistet in der Liste der verwendeten "Dinge").

5. Fügen Sie einen zweiten Schalter hinzu, um zwischen verschiedenen angezeigten Frequenzbereichen umzuschalten (BASS, MID_RANGE, TREBLE, ALL) und montieren Sie diesen Schalter an der Seitenwand des Gehäuses.

6. Da das Gehäuse aus Acryl besteht, können Sie zum Schutz der Oberfläche etwas blaues Malerband darüber verwenden und mit einem Bohrer ein Loch auf der erforderlichen Seite bohren, um die Stereobuchsen und/oder Schalter für die Schalttafelmontage zu montieren. Es wird empfohlen, einen Stufenbohrer zu verwenden oder mit einem kleineren Loch zu beginnen und das Loch dann zu erweitern, bis es die gewünschte Größe hat. Die aufgeführten Stereobuchsen benötigen ein Befestigungsloch von 5/16" und die Switches benötigen ein Befestigungsloch von 0,47".

7. Die Oberseite der oberen Platte leicht und gleichmäßig schleifen. Dies wirkt als Lichtdiffusor und gibt Ihnen einen diffuseren und sanfteren Lichteffekt.

Bei ausreichendem Interesse werde ich das Projekt aktualisieren, um es mit den Audiobuchsen und Schaltern und einem opaken Lichtdiffusor-Oberteil zu zeigen - bitte senden Sie mir eine Nachricht, wenn Sie das aktualisierte Projekt sehen möchten!

Fällt dir noch mehr ein? Schreiben Sie unten einen Kommentar, um es uns mitzuteilen! 😊 Stellen Sie auch gerne Ihre Fragen!

Viel Spaß beim Machen!