Visualiseur audio matriciel RVB avec Arduino

Outils et machines nécessaires

Perceuse/visseuse, sans fil

À propos de ce projet

Dans cet article, j'explique comment construire un visualiseur audio matriciel à LED RVB, à l'aide d'un Arduino, d'un blindage matriciel à LED RVB et d'un blindage d'analyseur de spectre audio, puis de le mettre dans un boîtier afin que vous puissiez avoir un projet fini que vous pouvez affichage par votre système de musique pour avoir un beau spectacle de lumière de votre musique !

Pour l'analyse du spectre audio, j'utilise le Spectrum Shield de SparkFun, qui utilise deux filtres d'affichage d'égaliseur graphique MSGEQ7, qui divisent une entrée audio stéréo en 7 bandes (par canal) et lisent l'amplitude de chacune à l'aide de l'ADC sur votre Arduino. Il est livré avec des exemples de croquis Arduino pour commencer.

Pour la matrice LED RVB, j'utilise le bouclier NeoPixel d'Adafruit pour Arduino, qui se compose de 40 NeoPixels RVB (terminologie d'Adafruit pour leur source lumineuse WS2812). Des LED rouges, vertes et bleues sont intégrées aux côtés d'une puce de commande dans un minuscule boîtier à montage en surface contrôlé par un seul fil. Ils peuvent être utilisés individuellement, enchaînés dans des chaînes plus longues ou assemblés dans des facteurs de forme encore plus intéressants. Dans le cas du Bouclier, ils sont enchaînés ensemble. Le Shield est également livré avec la bibliothèque Adafruit_NeoMatrix, qui simplifie l'accès à la matrice de LED RVB et le contrôle des LED.

Vient enfin l'enclos. Certains d'entre vous savent peut-être que j'ai créé un nouveau système de boîtier modulaire empilable appelé ProtoStax. C'était une démangeaison personnelle que je devais gratter - je voulais un boîtier prenant en charge différentes étapes de prototypage, offrant une protection et un accès ouvert au démarrage, avec la possibilité d'ajouter des parois latérales et le dessus plus tard, mais également la possibilité de s'empiler plusieurs unités côte à côte ou superposées, ayant ainsi la possibilité de s'étendre avec les besoins de prototypage et l'ajout d'autres cartes et composants.

Dans cet exemple, j'utilise ProtoStax pour Arduino, un boîtier en acrylique transparent pour l'Arduino -- il s'adapte à la fois à l'empreinte Uno/Leonardo ainsi qu'à l'empreinte Mega/Due plus grande -- qui est également empilable et modulaire et a de la place confortablement pour les deux Boucliers (avec quelques modifications mineures, que je vais décrire). Il est clair et robuste et possède également des pieds en caoutchouc pour le surélever légèrement et protéger la surface de votre table, afin que vous puissiez afficher votre Visualiseur Audio et son jeu de lumière avec votre système de musique !

Ok, commençons, voulez-vous ?

Étape 1 - Montez l'Arduino sur la plaque de base du boîtier

Montons d'abord l'Arduino (Uno dans notre exemple) sur la plaque de base du boîtier. Cela lui confère une protection tout en lui offrant un accès ouvert complet pour configurer et configurer l'Arduino et jouer avec. Lorsque vous êtes prêt à le fermer, il est facile d'ajouter les parois latérales et la plaque supérieure et de tout fixer avec des vis.

Montez l'Arduino sur la plaque de base et ajoutez des pieds et d'autres éléments matériels pour préparer le boîtier dans la Configuration de la plate-forme . Voir les étapes ci-dessous dans le diaporama - la légende de chaque image est numérotée et donne des explications supplémentaires pour chaque étape.

Voici toutes les étapes sous forme de gif animé :

Étape 2 - Préparez le bouclier de spectre SparkFun pour l'Arduino

Le SparkFun Spectrum Shield n'est pas fourni avec des en-têtes. Heureusement pour nous, Adafruit NeoPixel Shield pour Arduino est livré avec des en-têtes d'empilage et des en-têtes simples. Puisque je veux que le NeoPixel Shield soit en haut, je veux utiliser des en-têtes simples avec lui pour qu'il soit affleurant, et cela laisse les en-têtes d'empilement à utiliser avec le Spectrum Shield, ce qui est exactement ce que je veux !

Cependant, le Spectrum Shield avec en-têtes empilables ne s'adapte pas parfaitement - les ports USB et d'alimentation de l'Arduino Uno gênent, comme le montre l'image ci-dessous.

J'ai fait les deux modifications suivantes -

• Coupez l'extrémité du Spectrum Shield sur les ports USB et d'alimentation (cette partie a une zone de prototypage, qui n'est pas utilisée. Même si vous l'utilisez, vous finirez par ne couper qu'une rangée de trous) Cela rend le Spectrum Shield est bien ajusté sur l'Arduino.
• Les pieds des en-têtes d'empilage peuvent être encore trop longs pour que le Spectrum Shield soit bien ajusté. J'ai coupé les pieds des en-têtes empilables d'un cheveu pour que le Spectrum Shield soit bien ajusté sur l'Arduino avec les en-têtes empilables.

Maintenant, il est bien ajusté !

Étape 3 - Insérez le Adafruit NeoPixel Shield pour Arduino dans l'en-tête d'empilement du Spectrum Shield

Le bouclier Adafruit NeoPixel s'ajoute au bouclier spectral. Vous devrez d'abord souder les en-têtes normaux (fournis). J'ai également soudé le connecteur de borne qui l'accompagne, bien que dans cet exemple, je l'alimente à l'aide de l'Arduino, car toutes les LED ne s'allumeront pas simultanément, donc la consommation électrique est dans les limites que l'Arduino peut fournir .

Message de la page NeoPixel Shield d'Adafruit pour Arduino :

Étape 4 - Code de démonstration

Jetons un coup d'œil au code de démonstration et voyons ce qu'il fait. Pour ce faire, nous pouvons le diviser en deux parties principales :

• Analyse du spectre et enregistrement des résultats
• Traduire cela en un schéma d'affichage/de couleurs pour la matrice NeoPixel 8x5.

Vous pouvez rapidement référencer le code de démonstration ici :

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

Analyse du spectre

Vous pouvez vous référer au Guide de connexion de Spectrum Shield pour plus d'informations sur Spectrum Shield. J'ai résumé les informations ici.

En écrivant une séquence numérique sur les broches STROBE et RESET du Spectrum Shield, vous initialisez les puces MSGEQ7 utilisées par le Shield. Vous pouvez ensuite procéder à la lecture de l'amplitude de chacune des 7 bandes de fréquences différentes dans lesquelles le spectre est divisé. Chaque bande est lue suivie d'une impulsion de la broche STROBE pour lancer la lecture de la bande suivante. Les valeurs sont stockées dans Frequencies_One[7] et Frequencies_Two[7] pour les deux canaux de l'entrée stéréo. Les valeurs sont lues en utilisant les CAN 10 bits de l'Arduino, et la valeur de sortie peut donc être de 0 à 1023 - elles fournissent une représentation de l'amplitude de chaque bande de fréquence.

//Déclarer les connexions des broches du Spectrum Shield#define STROBE 4#define RESET 5#define DC_One A0#define DC_Two A1 //Définir les variables du spectreint freq_amp;int Frequencies_One[7];int Frequencies_Two[7]; int je; void setup() { ... //Initialiser les analyseurs de spectre digitalWrite(STROBE, LOW); retard(1) ; digitalWrite(RESET, HAUT); retard(1) ; digitalWrite(STROBE, ÉLEVÉ); retard(1) ; digitalWrite(STROBE, FAIBLE); retard(1) ; digitalWrite(RESET, LOW);...} void loop() {... Read_Frequencies();...} /************************ Extraire les fréquences de Spectrum Shield********************/void Read_Frequencies(){... //Lire les fréquences pour chaque bande pour (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, HAUT); digitalWrite(STROBE, FAIBLE); }} 

Les 7 bandes du spectre de fréquences sont :

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

Je les divise en 3 plages - BASS, MID_RANGE et TREBLE. La gamme de basses typique est de 60 à 250 Hz, donc les deux premières bandes sont dans la gamme BASS. Les fréquences moyennes sont généralement de 500 Hz à 2 kHz, je regroupe donc les 3 bandes suivantes dans MID_RANGE. Je regroupe les 2 bandes restantes en TREBLE.

[Remarque :je note également la lecture maximale de chacune des bandes dans une variable distincte. Cela peut éventuellement être utilisé pour mettre automatiquement à l'échelle les lectures au niveau représenté par les colonnes de la matrice RVB - cela est utile dans le cas où le signal d'entrée est faible - sinon, seule une très petite partie de la matrice RVB s'allumerait dans ce cas. ]

Matrice RVB

Vous pouvez vous référer à l'Überguide Adafruit NeoPixel pour plus d'informations sur le NeoPixel Shield et les NeoPixels en général. J'ai résumé ici les informations relatives à notre utilisation.

Le point principal que je vais essayer de clarifier, que j'ai trouvé un peu déroutant au début, est la direction et l'orientation du NeoPixel Shield et la numérotation du système de coordonnées. L'Überguide l'explique, mais je pense que je peux le rendre un peu plus facile.

La première chose à noter est que dans le système de coordonnées, [0, 0] fait TOUJOURS référence au coin supérieur gauche, quelle que soit l'orientation.

Ensuite, notez la LARGEUR, suivie de la HAUTEUR, de l'orientation qui vous intéresse (c'est-à-dire 5 x 8 contre 8 x 5 dans le cas de notre bouclier)

Troisièmement, notez la position de la LED PHYSIQUE #0 (marquée par le joli logo Adafruit). HAUT-DROITE, HAUT-GAUCHE, BAS-GAUCHE et BAS-DROITE selon le cas. Notez également l'orientation de la progression des LEDS physiques. La disposition est PROGRESSIVE dans notre tableau (la prochaine led physique après la fin d'une rangée commence au début de la rangée suivante comme indiqué par la ligne JAUNE). L'orientation de la progression est le long des LIGNES lorsque la largeur est plus large (orientation horizontale) (comme indiqué par les courtes flèches VERTES), et les COLONNES dont la largeur est plus étroite (orientation verticale) (à nouveau, comme indiqué par les courtes flèches VERTES ).

Celles-ci sont illustrées par les 4 images ci-dessous dans le diaporama. Les légendes incluent les paramètres pertinents dans chaque cas !

Dans notre exemple, nous avons 7 bandes de fréquences et une matrice 8 x 5 (ou 5 x 8, selon la façon dont vous la regardez !). J'ai choisi d'afficher les 7 bandes le long de la 8 dimension (en laissant une inutilisée). J'afficherais alors la représentation d'amplitude de chaque bande de fréquence le long de la 5 dimension. En d'autres termes, je souhaite que ma progression soit la suivante :

Je veux que mon origine commence dans le coin inférieur gauche (représentant le niveau le plus bas de la bande de fréquence la plus basse) et remonte. Mais comme la première chose à noter dans le système de coordonnées est que [0, 0] fait toujours référence à TOP-LEFT, vous devez incliner la tête vers la gauche et regarder l'image ci-dessous, pour comprendre le choix des valeurs d'initialisation de la NeoMatrix ! 😊(LARGEUR =5, HAUTEUR =8, EN HAUT À DROITE, COLONNES PROGRESSIVES)

Examinons un peu le code de démonstration relatif à la NeoMatrix et représentons graphiquement les fréquences. Tout d'abord, nous avons déterminé que notre NeoPixel a LARGEUR=5, HAUTEUR=8, et l'orientation que nous aimons est TOP-RIGHT et COLUMNS PROGRESSIVE. Suivez la configuration requise pour la matrice dans la fonction setup().

Dans la boucle(), nous lisons n'importe quelle entrée Serial pour sélectionner le schéma de couleurs - j'ai défini 3 schémas de couleurs différents

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

J'appelle ensuite Graph_Frequencies avec ce choix de schéma de couleurs. A noter également le premier paramètre qui permet de sélectionner la plage de fréquences à afficher (BASS, MID-RANGE ou TREBLE)

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

Pour l'instant, je sélectionne toutes les plages à afficher - il appartient au lecteur de mettre en œuvre la sélection des plages à afficher - soit via l'entrée série, soit en incluant un bouton-poussoir momentané pour basculer l'affichage entre BASS, MID_RANGE, AIGUS ou TOUS. La sélection de la PLAGE détermine la plage "de" et "à" des lignes à afficher.

Pour chaque ligne (bande de fréquence), nous choisissons la plus grande des deux amplitudes de fréquence (canal droit et canal gauche de l'entrée stéréo). Cette valeur est comprise entre 0 et 1023 comme nous l'avons déjà évoqué. Nous devons mapper cela en 5 colonnes distinctes de l'affichage, nous divisons donc la fréquence par le FREQ_DIV_FACTOR qui est défini comme 204 (1023/204 =5, ce qui mappera une sortie de 1023 à 5). Pour plus de sécurité, nous nous assurons également que le numCol à afficher n'est pas supérieur à 5. Cela détermine le nombre de colonnes à afficher pour chaque bande de fréquence.

J'utilise ensuite matrix.drawPixel() pour afficher le pixel approprié à la couleur appropriée.

J'utilise la roue chromatique HSV dans mon affichage graphique. Cela a posé quelques rides supplémentaires à surmonter.

En règle générale, l'utilisation est matrix.drawPixel(column, row, Color(r, g, b)), où Color(r, g, b) représente une couleur telle que spécifiée par les valeurs RED, GREEN et BLUE. Cependant, l'utilisation de HSV permet de belles transitions de couleurs douces.

NeoMatrix fournit la méthode matrix.ColorHSV(uint16_t hue) qui prend une seule valeur de teinte uint16_t et renvoie une couleur uint32_t HSV.

Cependant matrix.Color(r, g, b) renvoie une couleur uint16_t. matrix.drawPixel attend également une couleur 16 bits.

Le moyen de contourner cela consiste à utiliser matrix.setPassThruColor (valeur de couleur 32 bits). Cela définit un indicateur dans la matrice qui fait que drawPixel ignore son argument de couleur et utilise à la place la couleur 32 bits déjà définie par la méthode ci-dessus. N'oubliez pas d'appeler matrix.setPassThruColor() pour réinitialiser le drapeau en question. Pas super élégant, mais ça marche. Par exemple,

 static uint16_t hue =0 ; //21845 22250 à -250 uint16_t hueDelta =200 ; teinte +=hueDelta;... rgbcolor =matrice.CouleurHSV(teinte);... matrice.setPassThruColor(rgbcolor); matrice.drawPixel(col, rangée, (uint16_t)0) ; // la couleur n'a pas d'importance ici matrix.setPassThruColor();...matrix.show(); 

Avec HSV, il est possible d'incrémenter la teinte 16 bits et de générer le code de couleur HSV, obtenant ainsi de belles transitions de couleur douces.

Voici les différents morceaux de code pour référence :

  #define NEO_MATRIX_WIDTH 5 # 8 # définir NEO_MATRIX_HEIGHT définissent NEOPIXEL_PIN 6 // Shield il fait correspondre à la broche 6Adafruit_NeoMatrix matrice =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); .... void setup() {... matrix.begin(); matrice.setTextWrap(false); matrice.setBrightness(40); matrice.fillScreen(0); matrix.show();...} void loop() { static int schema =0; while (Serial.available()> 0) { schéma =Serial.parseInt(); }... Graph_Frequencies(ALL, schema);... 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); si (numCol> 5) numCol =5 ; for (int col =0; col  

Vient ensuite la sélection du schéma de couleurs. A noter que j'ai pris des dispositions pour pouvoir sélectionner des couleurs pour différentes gammes de fréquences (bassHue, midHue, trebleHue). J'ai créé 3 schémas de couleurs différents - un qui utilise une plage verte à rouge/rose pour l'affichage de l'amplitude la plus faible à la plus élevée, et l'autre qui utilise une plage décalée plus rose/bleu. Le 3ème schéma utilise la même couleur pour tous les pixels, mais parcourt toute la roue chromatique au fur et à mesure. Je vais vous montrer une vidéo des 3 schémas de couleurs.

commutateur(s) { cas MAGNITUDE_HUE :bassHue =22250 ; miTeinte =22250 ; //54613 trebleHue =22250; //43690 if (ligne>=0 &&ligne <2) { rgbcolor =matrice.ColorHSV(bassHue - (7416 * col) ); } else if (row>=2 &&row <5) { rgbcolor =matrix.ColorHSV(midHue - (7416 * col) ); } else if (ligne>=5 &&ligne <7) { rgbcolor =matrice.ColorHSV(trebleHue - (7416 * col) ); } Pause; cas MAGNITUDE_HUE_2 :bassHue =54613 ; mi-teinte =54613 ; //54613 trebleHue =54613; //43690 if (ligne>=0 &&ligne <2) { rgbcolor =matrice.ColorHSV(bassHue - (7416 * col) ); } else if (row>=2 &&row <5) { rgbcolor =matrix.ColorHSV(midHue - (7416 * col) ); } else if (ligne>=5 &&ligne <7) { rgbcolor =matrice.ColorHSV(trebleHue - (7416 * col) ); } Pause; cas HSV_COLOR_WHEEL :rgbcolor =matrice.ColorHSV(teinte); Pause; }

Étape 6 - Tout tester

Voici une vidéo pour tout tester

Étape 6 - Fermez-le

Installez les éléments de contreventement supérieurs, les parois latérales, les câbles audio et le dessus. Voir les étapes ci-dessous dans le diaporama - la légende de chaque image est numérotée et donne des explications supplémentaires pour chaque étape.

Voici toutes les étapes dans un seul gif animé :

Étape 7 - Affichez votre création et rendez la belle musique encore plus belle !

Vous pouvez maintenant avoir un visualiseur audio amusant que vous pouvez afficher à côté de votre système de musique et avoir une action lumineuse maison sympa pour augmenter votre musique !

Étape 8 - Aller plus loin

Voici quelques idées pour pousser le projet encore plus loin !

1. Actuellement, les câbles audio (entrée et sortie) sont branchés sur le Spectrum Shield dans l'enceinte, et ainsi vous avez cette enceinte avec ces fils connectés et qui pendent à l'extérieur. Au lieu de cela, vous pouvez ajouter quelques prises stéréo à montage sur panneau (répertoriées dans la liste des "choses" utilisées) sur la paroi latérale près des prises stéréo du Spectrum Shield, puis souder un câble audio avec une prise audio stéréo mâle de 3,5 mm à chacun, puis branchez-les à la place sur les prises audio du Spectrum Shield. Dans ce cas, votre boîtier devient très soigné et tout le câblage est autonome avec uniquement des prises audio sur le boîtier pour les systèmes externes à brancher.

2. Vous pouvez ajouter encore plus de schémas d'éclairage à votre Visualiseur Audio - différentes gammes de couleurs, différents motifs.

3. Ajoutez l'option pour activer/désactiver les plages de fréquences à l'aide de l'entrée série - actuellement, seuls les schémas de couleurs peuvent être modifiés, mais pas les plages de fréquences à afficher.

4. Ajoutez un commutateur pour basculer entre différents schémas de couleurs au lieu d'utiliser l'entrée série. Modifiez le boîtier pour ajouter un trou à l'une des longues parois latérales pour accueillir un interrupteur à bouton-poussoir momentané à montage sur panneau (répertorié dans la liste des « choses » utilisées).

5. Ajoutez un deuxième commutateur pour basculer entre les différentes gammes de fréquences affichées (BASS, MID_RANGE, TREBLE, ALL) et montez ce commutateur sur la paroi latérale de l'enceinte.

6. Étant donné que le boîtier est en acrylique, vous pouvez utiliser du ruban adhésif bleu pour protéger la surface et une perceuse pour percer un trou du côté requis pour monter les prises stéréo et/ou les commutateurs à montage sur panneau. Il est recommandé d'utiliser une perceuse étagée ou de commencer par un trou plus petit, puis d'élargir le trou jusqu'à ce qu'il atteigne la taille souhaitée. Les prises stéréo répertoriées ont besoin d'un trou de montage de 5/16", et les commutateurs ont besoin d'un trou de montage de 0,47".

7. Poncez légèrement et uniformément la surface supérieure de la plaque supérieure. Cela agira comme un diffuseur de lumière et vous donnera un effet de lumière plus diffus et plus doux.

S'il y a suffisamment d'intérêt, je mettrai à jour le projet pour le montrer avec les prises et commutateurs audio et un dessus de diffuseur de lumière opaque - veuillez m'envoyer un message si vous souhaitez voir le projet mis à jour !

Pouvez-vous penser à plus? Écrivez un commentaire ci-dessous pour nous le faire savoir! N'hésitez pas à poser également toutes vos questions !

Bonne fabrication !