US-Nationalhymne mit Licht und Ton

Notwendige Werkzeuge und Maschinen

Lötkolben (generisch) Es liegt an Ihnen, wenn Sie löten möchten

Über dieses Projekt

Ich habe im letzten Jahr damit begonnen, für ein eventuelles Weihnachtsbeleuchtungs- und Musikprojekt zu programmieren. Dies ist ein Nebenprojekt, um das mich jemand gebeten hat und der dachte, es würde Spaß machen. Ursprünglich sollte dies nur ein Song mit Lichtern sein, aber das ist einfach lahm.

Hier ist ein Link, falls du Probleme mit dem Video hast:

https://youtu.be/C2jyn80Mjus

Dieses Projekt verwendet einen Arduino Nano. In diesem Projekt verwende ich zwei verschiedene Druckknöpfe, um zwei verschiedene Songs mit der Funktion Tone () zu machen. Einer ist der „Charge“-Sound und der andere ist die „US-Nationalhymne“. Bis die Tasten gedrückt werden, erfolgt eine zufällige Beleuchtung für Effekte.

In dieser Skizze nutze ich häufig Funktionen, um meinen Schreibprozess der Funktionen zu vereinfachen, aber die volle Kontrolle über den Licht- / Tonprozess zu behalten, damit ich kleine Anpassungen vornehmen kann, wenn mir das, was ich höre / sehe, mit sehr geringen Schwierigkeiten nicht gefällt .

Mein Ziel beim Posten dieses Projekts ist es, einige der Dinge zu teilen, die ich im Bereich Design/Codierung gelernt habe, damit dies hilfreich sein kann, wenn Sie etwas Ähnliches tun.

So sah das ursprüngliche Design auf dem Steckbrett aus, als ich das System und den Code testete.

Hier ist, was das Power-System-Setup ist. Ich wähle eine 9-Volt-Batterie aufgrund ihrer Größe und bin nicht auf eine USB-Steckdose oder Computerstrom angewiesen.

So sieht es aus, wenn alles von innen verlötet ist. Es wird dringend empfohlen, nur mit der oberen Abdeckung zu löten und dann die Seiten später hinzuzufügen

Code

• USA_ANTHEM_Updated.ino

USA_ANTHEM_Updated.inoArduino

/*Star Spangled Banner mit LEDsErstellt von Ryan Aebi Juni 2018Code Structure-Basic Loop, um auf andere Funktionen zu verweisen Ganzzahl für Frequenz(Hz), &Dauer(Zeit in n)-LED wird bei der Schreibfunktion halbzufällig von mir selbst ausgewählt berechnet ist 1/12 eines Ganzen oder .06 Tastendesign/Verdrahtung-3 LED-Sets von Rot, Blau und Grün auf jedem Kanal, davon jeweils 2 parallel. ///************************************************ ****************Deklarierte Ganzzahlen const int ChargeButton=3; // (Nano D3) uno Pin 2 sollte ein Interrupt-Pin sein 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; // Deklaration der Ganzzahl ändert sich dieser Wert mit jedem Song int DurationOn=n; //Integer für später deklarieren wird in Stacatto-Berechnungen verwendet int DurationRest=n; //Integer für später deklarieren wird in Stacatto-Berechnungen verwendet //Summe von x &y sollte 1 sein Ich habe später mehr Notizen dazu float x=.66; // Float für Zeit auf Float deklarieren y=.34; // Float für Auszeit deklarieren // Rate, mit der die Lichter beim Warten zufällig blinken input int Twinkle_Rate=250; // Beachten Sie, dass die Tasten bei einer drastischen Erhöhung möglicherweise nicht 100% der Zeit reagieren // Eine niedrigere Blinkrate verbessert die Reaktion auf das Drücken der Tasten // Setzt Ganzzahlen für die Tastenzustände int StartButtonState; int ChargeButtonState; // Note mittleres C ist 4C (B &Es) Int Note1 =233; ///3Bb 233Hz int Note2=294; //D 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; //C 523Hz int Note9=587; //D 587Hz int Note10=622; //Eb 622Hz int Note11=698; ///5F 698Hz //******************************************** ****************** Ladefunktion/Songvoid Charge () { n =600; // Geschwindigkeit, mit der der Song fortschreitet // Format:Pin(s) schreiben, Ton bei bestimmter Frequenz (auf diese Weise unterliegt er nicht // Änderungen am Ende der Nationalhymne, mehr dazu später), Verzögerung um dieselbe Zeit wie Ton, um Musik zu synchronisieren, // Pin (s) ausschreiben, die eingeschaltet waren, und für eine Pause verzögern DigitalWrite (RedLED, HIGH); Ton (SummerPin, 392, n/3); Verzögerung (n/3); digitalWrite (Rote LED, NIEDRIG); Verzögerung (70); digitalWrite (WhiteLED, HIGH); Ton (SummerPin, 523, n/3); Verzögerung (n/3); digitalWrite (WhiteLED, NIEDRIG); Verzögerung (70); digitalWrite (BlueLED, HIGH); Ton (SummerPin, 659, n/3); Verzögerung (n/3); digitalWrite (BlueLED, NIEDRIG); Verzögerung (70); digitalWrite (Rote LED, HOCH); digitalWrite (WhiteLED, HIGH); digitalWrite (BlueLED, HIGH); Ton (SummerPin, 784, n*3/4); Verzögerung (n*3/4); digitalWrite (BlueLED, NIEDRIG); digitalWrite (Rote LED, NIEDRIG); digitalWrite (WhiteLED, NIEDRIG); Verzögerung (70); digitalWrite (BlueLED, HIGH); Ton (SummerPin, 659, n/4); Verzögerung (n/4); digitalWrite (BlueLED, NIEDRIG); Verzögerung (70); digitalWrite (Rote LED, HOCH); digitalWrite (WhiteLED, HIGH); digitalWrite (BlueLED, HIGH); Ton (SummerPin, 784, n*2); Verzögerung (n*2); digitalWrite (BlueLED, NIEDRIG); digitalWrite (Rote LED, NIEDRIG); digitalWrite (WhiteLED, NIEDRIG); Verzögerung(70);} //******************************************** ********************SingleDW functionvoid SingleDWwithNote(int HZ, int TurnOn, int Duration, int Staccato){//Hertz bei welcher Note ist (Referenzen Note#) / /turn on=Pin (rote/weiße/blaue LED), der eingeschaltet wird //Dauer ist wie lange //Staccato 1=ja, 0=nein führt zu einer leicht verkürzten Note oder einem hohen int x-Wert wie nur a kurze Pause if (Staccato==1){DurationOn=Duration*x;} // wie lange Ton &Lichter an sind ist DurationShort else if (Staccato==0){DurationOn=Duration;} digitalWrite(TurnOn, HIGH); Ton (SummerPin, HZ, DurationOn); Verzögerung (DauerEin); digitalWrite (Einschalten, NIEDRIG); if (Staccato==1) { DurationRest=Dauer*y; Verzögerung (DauerRest); }} //************************************************ **************** Funktion der US-Nationalhymne/Songvoid USNationalAnthem () { n =577; // Rate, mit der der Sound abgespielt wird, berechnet aus:60.000 (ms/BPM-Faktor) / 104 BPM =577 ms /* Viertelnotenwert ist n Halbnotenwert in n*2 Achtelnoten es n/2 punktierte Achtelnoten sind n*3 /4 */ //x &y Integer sind für Staccato/Hinzufügen von Pausen nach einer Note //beachten Sie, dass x+y =1 sein muss oder die int. n Rate wird weggeworfen //verringern Sie x und erhöhen Sie y, um die Noten ausgeprägter und sprunghafter / optimistischer zu machen x=.92; // wahre Stacatio ist ungefähr 1/2 oder 2/3 Wert, also x-Wert ungefähr 0,5 bis 0,7 für ein echtes Staccato y =0,08; //1.00-.92(x-Wert) =.08 //Balken 1-5, Zeilen 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 Zeile 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); // Balken 10-13 Zeile 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); // Takt 14-17, Zeile 4, Ende der Seite 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); // Takte 18-21, Zeile 5, Seitenanfang 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); // Balken 22-25, Zeile 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; nur eine leichte Verzögerung // Balken 26-28, Zeile 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); // Balken 29-30 SingleDWwithNote(Note7, RedLED, n, 1); SingleDWwithNote(Note6, BlueLED, n*2, 1); //x zum Halten von 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; // große Verzögerung // Takte 31-34 Ende des Songs SingleDWwithNote (Note 11, WhiteLED, n * 2, 1); // zusätzliches Halten auf kostenlosem SingleDWwithNote(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); // nur 3 Werte halten // alle Noten um 3 Schritte rasieren // 1.06 aus der Musiktheorie abgeleitet. Nehmen Sie eine Note in Hertz und dividieren Sie dann durch die // Note darunter (Sharps und Flats zählen als Note) rundum auf 1,06 // Sie können diesen nächsten Absatz löschen, um Frequenzänderungen zu vermeiden, oder ihn ändern, wenn Sie möchten Note1=Note1 *1,06*1,06*1,06; Hinweis2=Hinweis2*1,06*1,06*1,06; Anmerkung3=Anmerkung3*1,06*1,06*1,06; Hinweis4=Hinweis4*1,06*1,06*1,06; Hinweis5=Hinweis5*1,06*1,06*1,06; Hinweis6=Hinweis6*1,06*1,06*1,06; Hinweis7=Hinweis7*1,06*1,06*1,06; Hinweis8=Hinweis8*1,06*1,06*1,06; Hinweis9=Hinweis9*1,06*1,06*1,06; Hinweis10=Hinweis10*1,06*1,06*1,06; Hinweis11=Hinweis11*1.06*1.06*1.06;}//**************************************** ************************Twinkle void Twinkle (int Twinkle_Time) // Platziere eine Zahl in () zeigt an, wie lange das Twinkle auftritt { // gebaut diese Funktion für eine andere Verwendung, so dass sie eine bizarr beginnende unnötige Berechnung hat // ändert time&rate in eine kleinere ganze Zahl, beachten Sie, dass das Frontend rundet Twinkle_Time=Twinkle_Time/Twinkle_Rate; // in diesem Fall ist Tiwkle Time =to Twinkle Rate, also ist der Wert 1 for(Twinkle_Time;Twinkle_Time>0;Twinkle_Time--) //da der Wert 1 ist, wird nur einmal verarbeitet { int B=random(1,4); //zufällige ganze Zahl von 1, 2 oder 3 int C=random(1,4); // zufällige Ganzzahl von 1, 2 oder 3 // keine Probleme, wenn beide Ganzzahlen gleich sind, nur eine LED leuchtet, erhöht die Zufälligkeit // wertet jede Ganzzahl aus, um auf einer bestimmten Farb-LED zu laufen 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); // hält die LED für a . an Zeitraum einstellen // und dann schreiben wir die entsprechenden LEDs niedrig. kalt möglicherweise vereinfachen und einfach alle 3 niedrig schreiben kann das Timing beschleunigen 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); // gibt als Eingang ein und aktiviert den internen Pull-Up-Widerstand für den Button PinMode (StartButton, INPUT_PULLUP); // gibt als Eingang ein und aktiviert den internen Pull-Up-Widerstand für den Button PinMode (RedLED, OUTPUT); // LED als Ausgang konfiguriert PinMode (WhiteLED, OUTPUT); // LED als Ausgang konfiguriert PinMode (BlueLED, OUTPUT); // LED als Ausgang konfiguriert PinMode (BuzzerPin, OUTPUT); // Summer als Ausgang konfiguriert // digitalWrite (ChargeButton, HIGH); nicht notwendig, da es als Pullup aktiviert ist, es ist nur redundant //digitalWrite(StartButton, HIGH); nicht notwendig, da es als Pullup aktiviert ist, es ist nur redundant // setzt alle LEDs auf LOW, um Fehler zu vermeiden. Für mein Design HIGH =ON, LOW =OFF digitalWrite (RedLED, LOW); digitalWrite (WhiteLED, NIEDRIG); digitalWrite (BlueLED, NIEDRIG); } //************************************************ ************** Main Loopvoid loop () {// liest die Tastenzustände, die Pins wurden mit dem internen Widerstand verbunden, der als hoch konfiguriert ist // Pins sind niedrig, wenn sie gedrückt werden StartButtonState =digitalRead (StartButton); // niedrig =gedrückt ChargeButtonState =digitalRead (ChargeButton); // niedrig =gedrückt // Werte gegen Ganzzahlen aus, um den ersten Funktions-Pin auszuführen, der als niedrig gesperrt wurde // Abtastrate für das Lesen von Schaltflächen ist die int twinkle_rate (0,25 Sekunden) if (StartButtonState ==LOW) {USNationalAnthem ();} else if (ChargeButtonState==LOW){Charge();} else{Twinkle(Twinkle_Rate);} // wenn keine Pins gedrückt werden, dann blinken! wieder... und nochmal... und nochmal... }

Schaltpläne