Hymne national américain avec lumières et sons
Composants et fournitures
 | | × | 1 | |
 | | × | 1 | |
 | | Interrupteur à bouton-poussoir SparkFun 12mm |
| × | 2 | |
| | Interrupteur à bascule 250V 3A |
| × | 1 | |
 | | × | 3 | |
 | | × | 6 | |
 | | Planche à pain à souder SparkFun - Mini |
| × | 1 | |
 | | × | 1 | |
À propos de ce projet
J'ai commencé au cours de la dernière année à faire de la programmation pour un éventuel projet de lumières de Noël et de musique. C'est un projet parallèle que quelqu'un m'a demandé de faire et a pensé que ce serait amusant. Au départ, cela n'allait être qu'une seule chanson avec des lumières, mais c'est juste nul.
Voici un lien au cas où vous auriez des problèmes avec la vidéo :
https://youtu.be/C2jyn80Mjus
Ce projet utilise un Arduino Nano. Dans ce projet, j'utilise deux boutons poussoirs différents pour faire deux chansons différentes en utilisant la fonction Tone(). L'un est le son « charge » et l'autre est l'« hymne national américain ». Jusqu'à ce que les boutons soient enfoncés, il fait juste un éclairage aléatoire pour les effets.
Dans ce croquis, j'utilise beaucoup de fonctions pour simplifier mon processus d'écriture des fonctions, mais je garde le contrôle total du processus d'éclairage/son afin de pouvoir apporter de petits ajustements si je n'aime pas ce que j'entends/vois avec très peu de difficulté .
Mon objectif en postant ce projet est de partager certaines des choses que j'ai apprises dans la conception/le codage afin que si vous faites quelque chose de similaire, cela puisse vous aider.
Voici à quoi ressemblait la conception initiale sur la maquette alors que je testais le système et le code.
Voici la configuration du système d'alimentation. Je choisis une batterie de 9 volts pour la taille et ne dépend pas d'un mur USB ou d'une alimentation informatique.
Voilà à quoi cela ressemble une fois que tout est soudé de l'intérieur. Je recommande vivement de souder avec uniquement le couvercle supérieur, puis d'ajouter les côtés plus tard
Code
USA_ANTHEM_Updated.inoArduino
La bannière étoilée avec LED, charge, tonalité, toutes les fonctions. Copiez et collez simplement./* Bannière étoilée avec LEDCréé par Ryan Aebi juin 2018Structure de code-Boucle de base pour faire référence à d'autres fonctions-Les boutons poussoirs font soit la bannière étoilée, soit les sons de charge avec des lumièresNotes de bannière étoilée étoilé-La fonction a une note attribuée par entier pour la fréquence (Hz) et la durée (temps en n) - La LED est choisie par moi-même de manière semi-aléatoire lors de l'écriture de la fonction - La fonction est conçue pour augmenter la hauteur à chaque jeu (réinitialise à la hauteur normale au démarrage / réinitialisation matérielle) - Hauteur calculé est 1/12 d'un ensemble ou .06 Conception de bouton/câblage-3 ensembles de LED de rouge, bleu et vert sur chaque canal, y compris 2 de chaque en parallèle. ///****************************************************** ***************Entiers déclarés const int ChargeButton=3 ; //(Nano D3) uno pin 2 doit être une broche d'interruption const int StartButton=5; //(Nano D5) uno pin 4 const int BuzzerPin=9; //(Nano D9) uno pin 9 const int RedLED=6; //(Nano D6) uno pin 6 const int WhiteLED=7; //(Nano D7) uno pin 7 const int BlueLED=8; //(Nano D8) uno pin 8 int n=1000; //déclarant l'entier cette valeur changera avec chaque chanson int DurationOn=n; //la déclaration d'entier pour plus tard sera utilisée dans les calculs stacatto int DurationRest=n; //la déclaration d'entier pour plus tard sera utilisée dans les calculs stacatto //la somme de x &y devrait être 1 J'ai plus de notes à ce sujet plus tard sur float x=.66; //déclarer float pour le temps sur float y=.34; //déclaration flottante pour le temps libre //taux auquel les lumières clignotent de manière aléatoire pendant l'attente de l'entrée du bouton int Twinkle_Rate=250; //notez que si les boutons sont augmentés de manière drastique, ils peuvent ne pas répondre 100 % du temps //le taux de scintillement inférieur améliore la réponse à la pression des boutons //définit les nombres entiers pour les états des boutons int StartButtonState ; int ChargeButtonState; //notez que le do médian est 4C (si bémols et mi bémols) int Note1=233; //3Bb 233Hz int Note2=294; //4D 294Hz int Note3=330; //4E 330Hz int Note4=349; //4F 349Hz int Note5=392; //4G 392Hz int Note6=440; //4A 440Hz int Note7=466; //4Bb 466Hz int Note8=523; //5C 523Hz int Note9=587; //5D 587Hz int Note10=622; //5Eb 622Hz int Note11=698; //5F 698Hz //************************************************ ******************Fonction de charge/Songvoid Charge(){ n=600 ; //taux auquel la chanson progresse //Format :écrivez les broches, le ton à une fréquence spécifique (de cette façon, ce n'est pas sujet aux //changements à la fin de l'hymne national, plus à ce sujet plus tard), retardez le même temps que tonalité pour synchroniser la musique, // écrire la ou les broches qui étaient allumées et retarder pour un repos digitalWrite (RedLED, HIGH); tonalité (BuzzerPin, 392, n/3); retard(n/3); digitalWrite(RedLED, LOW); retard (70); digitalWrite (WhiteLED, HIGH); tonalité (BuzzerPin, 523, n/3); retard(n/3); digitalWrite (WhiteLED, LOW); retard (70); digitalWrite (BlueLED, HAUT); tonalité (BuzzerPin, 659, n/3); retard(n/3); digitalWrite (BlueLED, LOW); retard (70); digitalWrite (LED rouge, ÉLEVÉ); digitalWrite (WhiteLED, HIGH); digitalWrite (BlueLED, HAUT); tonalité (BuzzerPin, 784, n*3/4); retard (n*3/4); digitalWrite (BlueLED, LOW); digitalWrite(RedLED, LOW); digitalWrite (WhiteLED, LOW); retard (70); digitalWrite (BlueLED, HAUT); tonalité (BuzzerPin, 659, n/4); retard (n/4); digitalWrite (BlueLED, LOW); retard (70); digitalWrite (LED rouge, ÉLEVÉ); digitalWrite (WhiteLED, HIGH); digitalWrite (BlueLED, HAUT); tonalité (BuzzerPin, 784, n*2) ; retard(n*2) ; digitalWrite (BlueLED, LOW); digitalWrite(RedLED, LOW); digitalWrite (WhiteLED, LOW); retard (70);}//****************************************** ********************SingleDW functionvoid SingleDWwithNote(int HZ, int TurnOn, int Duration, int Staccato){ //Hertz auquel la note est (références Note#) / /allumer =broche (LED rouge/blanche/bleue) qui sera réglée //la durée correspond à la durée //Staccato 1=oui, 0=non donne une note légèrement raccourcie, ou une valeur élevée x int comme juste un brève pause if (Staccato==1){DurationOn=Duration*x;} // combien de temps la tonalité et les lumières sont allumées est DurationShort else if (Staccato==0){DurationOn=Duration;} digitalWrite(TurnOn, HIGH); tonalité (BuzzerPin, HZ, DurationOn); délai(DuréeOn); digitalWrite(TurnOn, LOW); if (Staccato==1) { DurationRest=Duration*y; delay(DurationRest); }}//************************************************ **************** Fonction de l'hymne national des États-Unis/Songvoid Hymne national des États-Unis(){ n=577; //taux auquel le son est joué calculé à partir de :60 000 (facteur ms/BPM) / 104 BPM =577 ms /* la valeur de la noire est n la valeur de la blanche en n*2 croches it n/2 la croche pointée est n*3 /4 */ // les entiers x &y sont pour le staccato/l'ajout de silence après une note //notez que x+y doit =1 ou l'entier. le taux n sera supprimé //diminuer x et augmenter y cependant pour rendre les notes plus prononcées et sautillantes/optimisées x=.92 ; //le vrai staccato est d'environ 1/2 ou 2/3, donc la valeur x est d'environ 0,5 à 0,7 pour un vrai staccato y =0,08 ; //1.00-.92(valeur x) =.08 //barres 1-5, lignes 1 SingleDWwithNote(Note4, RedLED, n*3/4, 1); SingleDWwithNote(Note2, WhiteLED, n/4, 1); SingleDWwithNote(Note1, RedLED, n, 1); SingleDWwithNote(Note2, WhiteLED, n, 1); SingleDWwithNote(Note4, RedLED, n, 1); SingleDWwithNote(Note7, WhiteLED, n*2, 1); SingleDWwithNote(Note9, BlueLED, n*3/4, 1); SingleDWwithNote(Note8, WhiteLED, n/4, 1); SingleDWwithNote(Note7, RedLED, n, 1); SingleDWwithNote(Note2, WhiteLED, n, 1); SingleDWwithNote(Note3, BlueLED, n, 1); SingleDWwithNote(Note4, RedLED, n*2, 1); SingleDWwithNote(Note4, RedLED, n/2, 1); SingleDWwithNote(Note4, RedLED, n/2, 1); //bar6-9 ligne 2 SingleDWwithNote(Note9, BlueLED, n*3/2, 1); SingleDWwithNote(Note8, WhiteLED, n/2, 1); SingleDWwithNote(Note7, RedLED, n, 1); SingleDWwithNote(Note6, BlueLED, n*2, 1); SingleDWwithNote(Note5, WhiteLED, n/2, 1); SingleDWwithNote(Note6, BlueLED, n/2, 1); SingleDWwithNote(Note7, RedLED, n, 1); SingleDWwithNote(Note7, RedLED, n, 1); SingleDWwithNote(Note4, BlueLED, n, 1); SingleDWwithNote(Note2, WhiteLED, n, 1); SingleDWwithNote(Note1, BlueLED, n, 1); SingleDWwithNote(Note4, RedLED, n*3/4, 1); SingleDWwithNote(Note2, WhiteLED, n/4, 1); //barres 10-13 ligne 3 SingleDWwithNote(Note1, RedLED, n, 1); SingleDWwithNote(Note2, WhiteLED, n, 1); SingleDWwithNote(Note4, RedLED, n, 1); SingleDWwithNote(Note7, WhiteLED, n*2, 1); SingleDWwithNote(Note9, BlueLED, n*3/4, 1); SingleDWwithNote(Note8, WhiteLED, n/4, 1); SingleDWwithNote(Note7, RedLED, n, 1); SingleDWwithNote(Note2, WhiteLED, n, 1); SingleDWwithNote(Note3, BlueLED, n, 1); SingleDWwithNote(Note4, RedLED, n*2, 1); SingleDWwithNote(Note4, RedLED, n/2, 1); SingleDWwithNote(Note4, RedLED, n/2, 1); //barre 14-17, ligne 4, fin de page 1 SingleDWwithNote(Note9, BlueLED, n*3/2, 1); SingleDWwithNote(Note8, WhiteLED, n/2, 1); SingleDWwithNote(Note7, RedLED, n, 1); SingleDWwithNote(Note6, BlueLED, n*2, 1); SingleDWwithNote(Note5, WhiteLED, n/2, 1); SingleDWwithNote(Note6, BlueLED, n/2, 1); SingleDWwithNote(Note7, RedLED, n, 1); SingleDWwithNote(Note7, RedLED, n, 1); SingleDWwithNote(Note4, BlueLED, n, 1); SingleDWwithNote(Note2, WhiteLED, n, 1); SingleDWwithNote(Note1, RedLED, n, 1); SingleDWwithNote(Note9, BlueLED, n/2, 1); SingleDWwithNote(Note9, BlueLED, n/2, 1); //barres 18-21, ligne 5, début de la page 2 SingleDWwithNote(Note9, BlueLED, n, 1); SingleDWwithNote(Note10, RedLED, n, 1); SingleDWwithNote(Note11, WhiteLED, n, 1); SingleDWwithNote(Note11, WhiteLED, n*2, 1); SingleDWwithNote(Note10, RedLED, n/2, 1); SingleDWwithNote(Note9, BlueLED, n/2, 1); SingleDWwithNote(Note8, WhiteLED, n, 1); SingleDWwithNote(Note9, BlueLED, n, 1); SingleDWwithNote(Note10, RedLED, n, 1); SingleDWwithNote(Note10, RedLED, n*2, 1); SingleDWwithNote(Note10, RedLED, n, 1); //barres 22-25, ligne 6 SingleDWwithNote(Note9, WhiteLED, n*3/2, 1); SingleDWwithNote(Note8, BlueLED, n/2, 1); SingleDWwithNote(Note7, WhiteLED, n, 1); SingleDWwithNote(Note6, RedLED, n*2, 1); SingleDWwithNote(Note5, BlueLED, n/2, 1); SingleDWwithNote(Note6, RedLED, n/2, 1); SingleDWwithNote(Note7, WhiteLED, n, 1); SingleDWwithNote(Note2, BlueLED, n, 1); SingleDWwithNote(Note3, RedLED, n, 1); SingleDWwithNote(Note4, WhiteLED, n*2, 1); SingleDWwithNote(Note4, RedLED, n, 1); n=n*1,08 ; //60 000 / 96 bpm =625 ms ; juste un léger retard //barres 26-28, ligne 7 SingleDWwithNote(Note7, WhiteLED, n, 1); SingleDWwithNote(Note7, WhiteLED, n, 1); SingleDWwithNote(Note7, WhiteLED, n/2, 1); SingleDWwithNote(Note6, BlueLED, n/2, 1); SingleDWwithNote(Note5, RedLED, n, 1); SingleDWwithNote(Note5, RedLED, n, 1); SingleDWwithNote(Note5, RedLED, n, 1); SingleDWwithNote(Note8, WhiteLED, n, 1); SingleDWwithNote(Note10, RedLED, n/2, 1); SingleDWwithNote(Note9, BlueLED, n/2, 1); SingleDWwithNote(Note8, WhiteLED, n/2, 1); SingleDWwithNote(Note7, RedLED, n/2, 1); //barres 29-30 SingleDWwithNote(Note7, RedLED, n, 1); SingleDWwithNote(Note6, BlueLED, n*2, 1); //2x pour contenir SingleDWwithNote(Note4, RedLED, n/2, 1); SingleDWwithNote(Note4, RedLED, n/2, 1); SingleDWwithNote(Note7, BlueLED, n*3/2, 1); SingleDWwithNote(Note8, WhiteLED, n/2, 1); SingleDWwithNote(Note9, BlueLED, n/2, 1); SingleDWwithNote(Note10, RedLED, n/2, 1); n=n*1,2 ; //grand retard //barres 31-34 fin de la chanson SingleDWwithNote(Note11, WhiteLED, n*2, 1); // attente supplémentaire sur SingleDWwithNote gratuit (Note7, RedLED, n/2, 1); SingleDWwithNote(Note8, WhiteLED, n/2, 1); SingleDWwithNote(Note9, BlueLED, n*3/2, 1); SingleDWwithNote(Note10, RedLED, n/2, 1); SingleDWwithNote(Note8, WhiteLED, n, 1); SingleDWwithNote(Note7, RedLED, n*3, 1); // ne tenant que pour 3 valeurs // rasie toutes les notes par 3 étapes // 1.06 dérivé de la théorie musicale. Prenez une note en hertz puis divisez par la //note en dessous (les dièses et les bémols comptent comme une note) jusqu'à 1,06 //Vous pouvez supprimer ce paragraphe suivant pour éviter les changements de fréquence ou le modifier si vous le souhaitez Note1=Note1 *1,06*1,06*1,06 ; Note2=Note2*1.06*1.06*1.06 ; Note3=Note3*1.06*1.06*1.06; Note4=Note4*1.06*1.06*1.06; Note5=Note5*1,06*1,06*1,06 ; Note6=Note6*1.06*1.06*1.06; Note7=Note7*1.06*1.06*1.06; Note8=Note8*1,06*1,06*1,06 ; Remarque 9 =Remarque 9 * 1,06 * 1,06 * 1,06; Note10=Note10*1.06*1.06*1.06; Note11=Note11*1.06*1.06*1.06;}//****************************************** *************************Twinkle void Twinkle(int Twinkle_Time) //Placez un nombre dans () montre combien de temps le scintillement se produit{ //construit cette fonction pour une autre utilisation, donc elle a un calcul bizarre de départ inutile //change le temps et le taux en un nombre entier plus petit, notez que le front-end arrondit Twinkle_Time=Twinkle_Time/Twinkle_Rate; // dans ce cas Tiwkle Time is =to Twinkle Rate donc la valeur est 1 for(Twinkle_Time;Twinkle_Time>0;Twinkle_Time--) //puisque la valeur est 1 ne traite qu'une seule fois { int B=random(1,4); //entier aléatoire de 1, 2 ou 3 int C=random(1,4); //entier aléatoire de 1, 2 ou 3 //aucun problème si les deux entiers sont identiques, une seule LED s'allume, ajoute à l'aléatoire //évalue chaque entier pour qu'il s'exécute sur une LED de couleur spécifique if(B==1){ digitalWrite(RedLED, HIGH);} if(B==2){digitalWrite(WhiteLED, HIGH);} if(B==3){digitalWrite(BlueLED, HIGH);} if(C==1){digitalWrite( RedLED, HIGH);} if(C==2){digitalWrite(WhiteLED, HIGH);} if(C==3){digitalWrite(BlueLED, HIGH);} delay(Twinkle_Rate);// maintient la LED allumée pendant un définir la période de temps // puis nous écrivons les LED correspondantes basses. froid peut-être simlify et juste écrire les 3 low peut accélérer le timing if(B==1){digitalWrite(RedLED, LOW);} if(B==2){digitalWrite(WhiteLED, LOW);} if(B==3){digitalWrite(BlueLED, LOW);} if(C==1){digitalWrite(RedLED, LOW);} if(C==2){digitalWrite(WhiteLED, LOW);} if(C==3) {digitalWrite(BlueLED, LOW);} }} //****************************************** *************************Setupvoid setup(){ pinMode(ChargeButton, INPUT_PULLUP); // met en entrée et active la résistance de rappel interne pour le bouton pinMode (StartButton, INPUT_PULLUP); // met en entrée et active la résistance de rappel interne pour le bouton pinMode (RedLED, OUTPUT); //LED configurée comme sortie pinMode(WhiteLED, OUTPUT); //LED configurée comme sortie pinMode (BlueLED, OUTPUT); //LED configurée comme sortie pinMode (BuzzerPin, OUTPUT); //Buzzer configuré comme sortie //digitalWrite(ChargeButton, HIGH); pas nécessaire car il est activé en tant que pullup, c'est juste redondant //digitalWrite(StartButton, HIGH); pas nécessaire car il est activé en tant que pullup, c'est juste redondant // règle toutes les LED sur LOW pour éviter toute erreur. Pour ma conception HIGH=ON, LOW=OFF digitalWrite(RedLED, LOW); digitalWrite (WhiteLED, LOW); digitalWrite (BlueLED, LOW); } //****************************************************** ***************Main Loopvoid loop () { // lit les états des boutons, les broches ont été accrochées à la résistance interne configurée comme haute // les broches seront basses lorsqu'elles sont enfoncées StartButtonState =digitalRead (StartButton); //bas=pressé ChargeButtonState =digitalRead(ChargeButton); //low=pressed //values contre des entiers pour faire la 1ère broche de fonction qui a été résistée comme faible //le taux d'échantillonnage pour les boutons de lecture est le twinkle_rate int (0,25 secondes) if (StartButtonState==LOW){USNationalAnthem();} else if (ChargeButtonState==LOW){Charge();} else{Twinkle(Twinkle_Rate);} // si aucune broche n'est enfoncée, scintille ! encore... et encore... et encore... } Schémas
Affiche les connexions électriques à l'aide de la maquette 
Affiche les connexions de câblage sans soudure 
Suivez les fils ! 
Affiche le coût de chaque article, le coût total et le lieu d'achat. 
