Weihnachtslieder mit Arduino-Buzzer: Jingle Bells und mehr
Weihnachtslieder mit Arduino und Buzzer: Jingle Bells, Stille Nacht, We Wish You a Merry Christmas und Deck the Halls mit Notentabelle, Tempo und LED-Player.
Um Weihnachtslieder mit dem Arduino zu spielen, brauchst du nur einen passiven Buzzer und die Funktion tone(): Du schreibst Frequenz und Länge jeder Note in ein Array, und der Arduino schickt sie nacheinander an den Buzzer. In diesem Beitrag findest du für Jingle Bells, We Wish You a Merry Christmas, Stille Nacht und Deck the Halls korrekte Noten- und Längen-Arrays, die aus dem Notenblatt übertragen und nicht nach Gehör geraten wurden. Alle vier Melodien sind traditionelle Stücke, die weit über hundert Jahre alt sind; du kannst sie also ohne Urheberrechtssorgen in jedem Projekt verwenden.
Wir beginnen mit einem kurzen Sketch für ein einzelnes Lied und gehen dann zu einer Spieluhr über, die alle vier Lieder nacheinander spielt, zwei LEDs im Takt der Noten blinken lässt und per Taster das Lied wechselt. Dieser zweite Sketch nutzt millis() statt delay() und kann deshalb während des Liedes weiter Taster, Sensoren oder einen LED-Streifen bedienen. Am Ende übertragen wir die Melodien auf eine Touch-Weihnachtskarte mit dem ESP32 und auf MicroPython mit dem Raspberry Pi Pico.
Welcher Buzzer: aktiv oder passiv?
Ein aktiver Buzzer hat einen eigenen Oszillator eingebaut; legst du 5 V an, piept er immer im selben Ton und kann daher keine Melodie spielen. Ein passiver Buzzer verhält sich wie ein winziger Lautsprecher: Er klingt in genau der Frequenz, mit der der Arduino-Pin ein- und ausschaltet. Am einfachsten unterscheidest du sie, indem du den Buzzer kurz an eine 3–5-V-Batterie hältst: Ein Dauerpiepton bedeutet aktiv, ein einzelnes Knacken bedeutet passiv. Aktive Modelle tragen meist einen weißen Aufkleber und haben eine geschlossene Unterseite, bei passiven sieht man unten eine grüne Platine. Mehr dazu findest du unter Was ist ein Buzzer?.
| Eigenschaft | Aktiver Buzzer | Passiver Buzzer |
|---|---|---|
| Eingebauter Oszillator | Ja | Nein |
| Spielt Melodien? | Nein, nur ein Ton | Ja, jede Note mit tone() |
| Ansteuerung | digitalWrite() | tone(pin, frequenz, dauer) |
| An Batterie gehalten | Dauerpiepton | Einzelnes Knacken |
| Lautester Bereich | Fest (meist 2–2,5 kHz) | Etwa 2–4 kHz (Resonanz) |
Verdrahtung: Buzzer, zwei LEDs und ein Taster
| Bauteil | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Passiver Buzzer + | D8 | GPIO 25 | GP15 |
| Passiver Buzzer − | GND | GND | GND |
| LED 1 (mit 220 Ω) | D6 | GPIO 26 | GP14 |
| LED 2 (mit 220 Ω) | D7 | GPIO 27 | GP13 |
| Taster (anderes Bein an GND) | D2 | GPIO 4 | GP2 |
| Touch-Folie | - | GPIO 32 (T9) | - |
Notenfrequenzen: die 14 Noten dieser Weihnachtslieder
In der westlichen Musik ist jede Oktave in 12 Halbtöne geteilt, und ein Halbton höher multipliziert die Frequenz mit der 12. Wurzel aus 2, also etwa 1,0595. Der Kammerton A4 hat 440 Hz; eine Note mit der MIDI-Nummer n hat die Frequenz f = 440 × 2^((n − 69) / 12). Das C5 ist zum Beispiel MIDI 72: 440 × 2^(3/12) = 523,25 Hz. Eine Oktave höher verdoppelt die Frequenz exakt, deshalb hat C6 1047 Hz. Kleine passive Buzzer klingen unter 500 Hz dünn, darum haben wir alle vier Lieder in die 5. und 6. Oktave gelegt; die Tabelle enthält jede Note aus dem Code. Achtung: Im Deutschen heißt das englische B4 "H" und das englische Bb "B".
| Note | Deutscher Name | Frequenz (Hz) | Code-Konstante |
|---|---|---|---|
| B4 | H | 494 | NOTE_B4 |
| C5 | C | 523 | NOTE_C5 |
| D5 | D | 587 | NOTE_D5 |
| E5 | E | 659 | NOTE_E5 |
| F5 | F | 698 | NOTE_F5 |
| F#5 | Fis | 740 | NOTE_FS5 |
| G5 | G | 784 | NOTE_G5 |
| A5 | A | 880 | NOTE_A5 |
| A#5 / Bb5 | B | 932 | NOTE_AS5 |
| B5 | H | 988 | NOTE_B5 |
| C6 | C | 1047 | NOTE_C6 |
| D6 | D | 1175 | NOTE_D6 |
| E6 | E | 1319 | NOTE_E6 |
| F6 | F | 1397 | NOTE_F6 |
Tempo und Notenlängen
Statt jede Länge in Millisekunden zu schreiben, haben wir die kürzeste Note, die Achtelnote, als Einheit genommen: 1 ist eine Achtel, 2 eine Viertel, 3 eine punktierte Viertel, 4 eine Halbe, 6 eine punktierte Halbe und 8 eine Ganze. Das Tempo ist die Zahl der Viertel pro Minute (BPM); eine Viertel dauert 60000 / BPM Millisekunden, eine Achtel die Hälfte davon. Bei 120 BPM sind das 500 ms für die Viertel und 250 ms für die Achtel. Willst du das Tempo ändern, passt du nur die Achtellänge an und lässt die Arrays in Ruhe. Jede Note klingt 90 % ihrer Länge, die letzten 10 % bleiben stumm; so verschwimmen wiederholte Noten (wie die drei E in Jingle Bells) nicht zu einem langen Ton.
| Lied | Takt | Tempo | Achtel (ms) | Viertel (ms) | Noten |
|---|---|---|---|---|---|
| Jingle Bells (Refrain) | 4/4 | 120 BPM | 250 | 500 | 51 |
| We Wish You a Merry Christmas | 3/4 | 150 BPM | 200 | 400 | 30 |
| Stille Nacht | 3/4 | 75 BPM | 400 | 800 | 46 |
| Deck the Halls | 4/4 | etwa 130 BPM | 230 | 460 | 68 |
Erster Sketch: der Refrain von Jingle Bells
- Verbinde das +-Bein des passiven Buzzers mit D8 und das andere mit GND.
- Öffne die Arduino IDE, füge den Code unten ein und wähle Arduino Uno als Board.
- Lade ihn hoch; der Refrain spielt einmal, sobald das Board startet. Zum erneuten Anhören drückst du die Reset-Taste.
- Ist es zu langsam oder zu schnell, ändere EIGHTH_MS: 200 spielt schneller, 300 langsamer.
1// Jingle Bells nakaratı - pasif buzzer D8 / Jingle Bells chorus - passive buzzer on D8
2#define NOTE_C5 523
3#define NOTE_D5 587
4#define NOTE_E5 659
5#define NOTE_F5 698
6#define NOTE_G5 784
7
8const int BUZZER_PIN = 8; // pasif buzzer + ucu / passive buzzer + lead
9const int EIGHTH_MS = 250; // 120 BPM: dörtlük 500 ms, sekizlik 250 ms / quarter 500 ms, eighth 250 ms
10
11const int melody[] = {
12 NOTE_E5, NOTE_E5, NOTE_E5, NOTE_E5, NOTE_E5, NOTE_E5,
13 NOTE_E5, NOTE_G5, NOTE_C5, NOTE_D5, NOTE_E5,
14 NOTE_F5, NOTE_F5, NOTE_F5, NOTE_F5, NOTE_F5, NOTE_E5, NOTE_E5, NOTE_E5, NOTE_E5,
15 NOTE_E5, NOTE_D5, NOTE_D5, NOTE_E5, NOTE_D5, NOTE_G5,
16 NOTE_E5, NOTE_E5, NOTE_E5, NOTE_E5, NOTE_E5, NOTE_E5,
17 NOTE_E5, NOTE_G5, NOTE_C5, NOTE_D5, NOTE_E5,
18 NOTE_F5, NOTE_F5, NOTE_F5, NOTE_F5, NOTE_F5, NOTE_E5, NOTE_E5, NOTE_E5, NOTE_E5,
19 NOTE_G5, NOTE_G5, NOTE_F5, NOTE_D5, NOTE_C5
20};
21// süreler sekizlik cinsinden: 1 = sekizlik, 2 = dörtlük, 3 = noktalı dörtlük, 4 = ikilik, 8 = birlik
22// lengths in eighths: 1 = eighth, 2 = quarter, 3 = dotted quarter, 4 = half, 8 = whole
23const byte beats[] = {
24 2, 2, 4, 2, 2, 4,
25 2, 2, 3, 1, 8,
26 2, 2, 3, 1, 2, 2, 2, 1, 1,
27 2, 2, 2, 2, 4, 4,
28 2, 2, 4, 2, 2, 4,
29 2, 2, 3, 1, 8,
30 2, 2, 3, 1, 2, 2, 2, 1, 1,
31 2, 2, 2, 2, 8
32};
33
34void setup() {
35 int count = sizeof(melody) / sizeof(melody[0]); // 51 nota / 51 notes
36 for (int i = 0; i < count; i++) {
37 int duration = beats[i] * EIGHTH_MS;
38 tone(BUZZER_PIN, melody[i], duration * 9 / 10); // notalar arasında %10 boşluk / 10% gap between notes
39 delay(duration);
40 }
41 noTone(BUZZER_PIN);
42}
43
44void loop() {
45 // bir kez çalar; tekrar için reset tuşuna bas / plays once, press reset to replay
46}Der Sketch führt zwei parallele Arrays: melody enthält die Notenfrequenzen, beats die Länge jeder Note in Achteln in derselben Reihenfolge. Für jede Note startet die Schleife den Ton mit tone() und wartet mit delay() die volle Notenlänge. Bekommt tone() als dritten Parameter eine Dauer, beendet es den Ton selbst; weil wir 90 % der Notenlänge übergeben, entsteht eine kurze Atempause zwischen den Noten. Beide Arrays müssen gleich viele Elemente haben; fügst du in einem eine Note hinzu und vergisst die Länge im anderen, verrutscht die Melodie und es wird zufälliger Speicher hinter dem Array-Ende abgespielt. Die Lücken in den Arrays entsprechen den Taktstrichen, so lassen sich die Noten leicht mit dem Notenblatt vergleichen.
Die Noten-Arrays aller vier Lieder
Die Tabelle zeigt die Tonart jedes Liedes und die Noten seiner ersten Zeile; das hilft, wenn du den Code nach Gehör prüfst. Ein Strich (–) ist ein Taktstrich, ein Punkt (.) eine punktierte Note. We Wish You a Merry Christmas beginnt mit einem Auftakt: Das erste C5 ist eine einzelne Viertel vor dem ersten Takt. Stille Nacht ist langsam und breit, deshalb halten wir das letzte C5 zwölf Achtel lang, also zwei ganze Takte. Das einzige Kreuz in Deck the Halls ist das Fis (F#5) im aufsteigenden "Fa-la-la"-Lauf.
| Lied | Tonart | Noten der ersten Zeile | Achte auf |
|---|---|---|---|
| Jingle Bells | C-Dur | E E E – E E E – E G C. D – E | Punktierte Viertel + Achtel bei "all the way" |
| We Wish You a Merry Christmas | F-Dur | C – F F G F E – D D D | 3/4-Takt, nutzt das B (A#5) |
| Stille Nacht | C-Dur (eine Oktave höher) | G. A G – E – G. A G – E | Langsames Tempo, punktierte Halbe |
| Deck the Halls | C-Dur | G. F E D – C D E C | "Fa-la-la"-Achtel, Fis (F#5) |
Weihnachtslieder-Player mit millis und LEDs (4 Lieder + Taster)
Jetzt packen wir alle vier Lieder in einen Sketch. Die Noten stehen in einer Note-Struktur aus {Frequenz, Länge}-Paaren und liegen mit PROGMEM im Flash; der Uno hat nur 2 KB RAM, deshalb ist es eine gute Gewohnheit, 195 Noten aus dem Flash zu lesen, statt sie im RAM zu halten. Die LEDs wechseln bei jeder Note, der Taster an D2 nutzt den internen Pull-up, und ein Druck springt zum nächsten Lied. Ist ein Lied zu Ende, folgen 1,5 Sekunden Stille, dann startet das nächste.
1// 4 Noel şarkısı: millis ile çalar, LED'ler notaya göre yanar, buton sonraki şarkıya geçer
2// 4 Christmas songs: millis-based player, LEDs follow the notes, button skips to the next song
3#define REST 0
4#define NOTE_B4 494
5#define NOTE_C5 523
6#define NOTE_D5 587
7#define NOTE_E5 659
8#define NOTE_F5 698
9#define NOTE_FS5 740
10#define NOTE_G5 784
11#define NOTE_A5 880
12#define NOTE_AS5 932
13#define NOTE_B5 988
14#define NOTE_C6 1047
15#define NOTE_D6 1175
16#define NOTE_E6 1319
17#define NOTE_F6 1397
18
19#if defined(ESP32)
20const int BUZZER_PIN = 25; // ESP32 pinleri / ESP32 pins
21const int LED_PINS[2] = {26, 27};
22const int BUTTON_PIN = 4;
23#else
24const int BUZZER_PIN = 8; // Arduino Uno pinleri / Arduino Uno pins
25const int LED_PINS[2] = {6, 7};
26const int BUTTON_PIN = 2;
27#endif
28
29struct Note { uint16_t freq; uint8_t len; }; // len: sekizlik sayısı / length in eighths
30
31// Jingle Bells (Do majör, 4/4) / (C major, 4/4)
32const Note JINGLE[] PROGMEM = {
33 {NOTE_E5,2},{NOTE_E5,2},{NOTE_E5,4}, {NOTE_E5,2},{NOTE_E5,2},{NOTE_E5,4},
34 {NOTE_E5,2},{NOTE_G5,2},{NOTE_C5,3},{NOTE_D5,1}, {NOTE_E5,8},
35 {NOTE_F5,2},{NOTE_F5,2},{NOTE_F5,3},{NOTE_F5,1}, {NOTE_F5,2},{NOTE_E5,2},{NOTE_E5,2},{NOTE_E5,1},{NOTE_E5,1},
36 {NOTE_E5,2},{NOTE_D5,2},{NOTE_D5,2},{NOTE_E5,2}, {NOTE_D5,4},{NOTE_G5,4},
37 {NOTE_E5,2},{NOTE_E5,2},{NOTE_E5,4}, {NOTE_E5,2},{NOTE_E5,2},{NOTE_E5,4},
38 {NOTE_E5,2},{NOTE_G5,2},{NOTE_C5,3},{NOTE_D5,1}, {NOTE_E5,8},
39 {NOTE_F5,2},{NOTE_F5,2},{NOTE_F5,3},{NOTE_F5,1}, {NOTE_F5,2},{NOTE_E5,2},{NOTE_E5,2},{NOTE_E5,1},{NOTE_E5,1},
40 {NOTE_G5,2},{NOTE_G5,2},{NOTE_F5,2},{NOTE_D5,2}, {NOTE_C5,8}
41};
42
43// We Wish You a Merry Christmas (Fa majör, 3/4) / (F major, 3/4)
44const Note WE_WISH[] PROGMEM = {
45 {NOTE_C5,2},
46 {NOTE_F5,2},{NOTE_F5,1},{NOTE_G5,1},{NOTE_F5,1},{NOTE_E5,1}, {NOTE_D5,2},{NOTE_D5,2},{NOTE_D5,2},
47 {NOTE_G5,2},{NOTE_G5,1},{NOTE_A5,1},{NOTE_G5,1},{NOTE_F5,1}, {NOTE_E5,2},{NOTE_C5,2},{NOTE_C5,2},
48 {NOTE_A5,2},{NOTE_A5,1},{NOTE_AS5,1},{NOTE_A5,1},{NOTE_G5,1}, {NOTE_F5,2},{NOTE_D5,2},{NOTE_C5,1},{NOTE_C5,1},
49 {NOTE_D5,2},{NOTE_G5,2},{NOTE_E5,2}, {NOTE_F5,6}
50};
51
52// Silent Night (Do majör, 3/4, bir oktav yukarı) / (C major, 3/4, one octave up)
53const Note SILENT[] PROGMEM = {
54 {NOTE_G5,3},{NOTE_A5,1},{NOTE_G5,2}, {NOTE_E5,6}, {NOTE_G5,3},{NOTE_A5,1},{NOTE_G5,2}, {NOTE_E5,6},
55 {NOTE_D6,4},{NOTE_D6,2}, {NOTE_B5,6}, {NOTE_C6,4},{NOTE_C6,2}, {NOTE_G5,6},
56 {NOTE_A5,4},{NOTE_A5,2}, {NOTE_C6,3},{NOTE_B5,1},{NOTE_A5,2}, {NOTE_G5,3},{NOTE_A5,1},{NOTE_G5,2}, {NOTE_E5,6},
57 {NOTE_A5,4},{NOTE_A5,2}, {NOTE_C6,3},{NOTE_B5,1},{NOTE_A5,2}, {NOTE_G5,3},{NOTE_A5,1},{NOTE_G5,2}, {NOTE_E5,6},
58 {NOTE_D6,4},{NOTE_D6,2}, {NOTE_F6,3},{NOTE_D6,1},{NOTE_B5,2}, {NOTE_C6,6}, {NOTE_E6,6},
59 {NOTE_C6,2},{NOTE_G5,2},{NOTE_E5,2}, {NOTE_G5,3},{NOTE_F5,1},{NOTE_D5,2}, {NOTE_C5,12}
60};
61
62// Deck the Halls (Do majör, 4/4) / (C major, 4/4)
63const Note DECK[] PROGMEM = {
64 {NOTE_G5,3},{NOTE_F5,1},{NOTE_E5,2},{NOTE_D5,2}, {NOTE_C5,2},{NOTE_D5,2},{NOTE_E5,2},{NOTE_C5,2},
65 {NOTE_D5,1},{NOTE_E5,1},{NOTE_F5,1},{NOTE_D5,1},{NOTE_E5,3},{NOTE_D5,1}, {NOTE_C5,2},{NOTE_B4,2},{NOTE_C5,4},
66 {NOTE_G5,3},{NOTE_F5,1},{NOTE_E5,2},{NOTE_D5,2}, {NOTE_C5,2},{NOTE_D5,2},{NOTE_E5,2},{NOTE_C5,2},
67 {NOTE_D5,1},{NOTE_E5,1},{NOTE_F5,1},{NOTE_D5,1},{NOTE_E5,3},{NOTE_D5,1}, {NOTE_C5,2},{NOTE_B4,2},{NOTE_C5,4},
68 {NOTE_D5,3},{NOTE_E5,1},{NOTE_F5,2},{NOTE_D5,2}, {NOTE_E5,3},{NOTE_F5,1},{NOTE_G5,2},{NOTE_D5,2},
69 {NOTE_E5,1},{NOTE_FS5,1},{NOTE_G5,2},{NOTE_A5,1},{NOTE_B5,1},{NOTE_C6,2}, {NOTE_B5,2},{NOTE_A5,2},{NOTE_G5,4},
70 {NOTE_G5,3},{NOTE_F5,1},{NOTE_E5,2},{NOTE_D5,2}, {NOTE_C5,2},{NOTE_D5,2},{NOTE_E5,2},{NOTE_C5,2},
71 {NOTE_A5,1},{NOTE_A5,1},{NOTE_A5,1},{NOTE_A5,1},{NOTE_G5,3},{NOTE_F5,1}, {NOTE_E5,2},{NOTE_D5,2},{NOTE_C5,4}
72};
73
74struct Song { const Note* notes; uint8_t count; uint16_t eighthMs; };
75const Song SONGS[] = {
76 {JINGLE, sizeof(JINGLE) / sizeof(Note), 250}, // 120 BPM
77 {WE_WISH, sizeof(WE_WISH) / sizeof(Note), 200}, // 150 BPM
78 {SILENT, sizeof(SILENT) / sizeof(Note), 400}, // 75 BPM
79 {DECK, sizeof(DECK) / sizeof(Note), 230} // yaklaşık 130 BPM / about 130 BPM
80};
81const uint8_t SONG_COUNT = sizeof(SONGS) / sizeof(Song);
82const unsigned long SONG_GAP_MS = 1500; // şarkılar arası sessizlik / silence between songs
83
84uint8_t song = 0;
85int noteIndex = -1; // -1: şarkı başlamadı / song not started
86unsigned long noteStart = 0;
87unsigned long noteLength = 0;
88bool lastButton = HIGH;
89unsigned long lastPress = 0;
90
91void ledsOff() {
92 digitalWrite(LED_PINS[0], LOW);
93 digitalWrite(LED_PINS[1], LOW);
94}
95
96void startNote() {
97 Note n;
98 memcpy_P(&n, &SONGS[song].notes[noteIndex], sizeof(Note)); // flash'tan oku / read from flash
99 noteLength = (unsigned long)n.len * SONGS[song].eighthMs;
100 if (n.freq != REST) {
101 tone(BUZZER_PIN, n.freq, noteLength * 9 / 10); // %10 boşluk / 10% gap
102 digitalWrite(LED_PINS[noteIndex % 2], HIGH); // LED'ler sırayla / LEDs alternate
103 digitalWrite(LED_PINS[(noteIndex + 1) % 2], LOW);
104 } else {
105 noTone(BUZZER_PIN);
106 ledsOff();
107 }
108 noteStart = millis();
109}
110
111void nextSong() {
112 noTone(BUZZER_PIN);
113 ledsOff();
114 song = (song + 1) % SONG_COUNT;
115 noteIndex = 0;
116 startNote();
117}
118
119void setup() {
120 pinMode(LED_PINS[0], OUTPUT);
121 pinMode(LED_PINS[1], OUTPUT);
122 pinMode(BUTTON_PIN, INPUT_PULLUP); // buton GND'ye / button to GND
123 noteIndex = 0;
124 startNote();
125}
126
127void loop() {
128 unsigned long now = millis();
129
130 // Buton: düşen kenar + 250 ms kilit / button: falling edge + 250 ms lockout
131 bool button = digitalRead(BUTTON_PIN);
132 if (lastButton == HIGH && button == LOW && now - lastPress > 250) {
133 lastPress = now;
134 nextSong();
135 }
136 lastButton = button;
137
138 // Nota süresi doldu mu? / has the note finished?
139 if (now - noteStart >= noteLength) {
140 noteIndex++;
141 if (noteIndex < SONGS[song].count) {
142 startNote();
143 } else if (noteIndex == SONGS[song].count) { // şarkı bitti: ara ver / song over: pause
144 ledsOff();
145 noteLength = SONG_GAP_MS;
146 noteStart = now;
147 } else {
148 nextSong(); // aradan sonra sıradaki şarkı / next song after the pause
149 }
150 }
151}Das Herz des Codes ist die Zeitprüfung in loop(): Ist millis() − noteStart länger als die Note, startet die nächste Note; wenn nicht, läuft loop ohne Warten weiter. So wird der Taster bei jedem Durchlauf gelesen und kein Druck geht verloren; mit delay() würde der Taster während der 4,8 Sekunden langen Schlussnote von Stille Nacht gar nicht reagieren. memcpy_P() kopiert eine Note aus dem Flash in eine temporäre Variable im RAM. Endet ein Lied, ist noteIndex gleich der Notenzahl, und dieser Wert dient als "Pause"-Zustand; nach der Pause wird nextSong() aufgerufen. Der kompilierte Sketch belegt auf dem Uno etwa 3,9 KB Flash und 67 Byte RAM. Warum wir millis() statt delay() nehmen, erklärt der Beitrag millis und delay im Vergleich ausführlicher.
Weihnachtslieder mit dem ESP32: eine Touch-Weihnachtskarte
Der Player-Sketch oben lässt sich auch auf dem ESP32 unverändert kompilieren: Der Block #if defined(ESP32) stellt die Pins automatisch auf GPIO 25, 26, 27 und 4 um. Die Versionen 2.x und 3.x des ESP32-Cores enthalten tone(), das im Hintergrund die LEDC-PWM-Einheit nutzt. Weil die ESP32-Pins 3,3 V liefern, klingt es etwas leiser als am Uno. Der kurze Sketch unten nutzt die Touch-Pins des ESP32: Berührst du einen Stern aus Alufolie an GPIO 32, spielt die erste Zeile von Jingle Bells und die LED leuchtet. Der Code misst beim Start den unberührten Wert und legt die Schwelle selbst fest; mehr über Touch-Pins steht in ESP32-Touch-Pins.
1// ESP32 dokunmatik Noel kartı: folyo yıldıza dokununca Jingle Bells çalar
2// ESP32 touch Christmas card: touch the foil star and Jingle Bells plays
3const int BUZZER_PIN = 25; // pasif buzzer / passive buzzer
4const int LED_PIN = 26; // yıldızın LED'i / star LED
5const int TOUCH_PIN = 32; // T9: folyoya giden kablo / T9: wire to the foil
6
7const int EIGHTH_MS = 250;
8const int melody[] = {659, 659, 659, 659, 659, 659, 659, 784, 523, 587, 659}; // E E E, E E E, E G C D E
9const byte beats[] = {2, 2, 4, 2, 2, 4, 2, 2, 3, 1, 8};
10int threshold = 0;
11
12void setup() {
13 Serial.begin(115200);
14 pinMode(LED_PIN, OUTPUT);
15 long sum = 0;
16 for (int i = 0; i < 20; i++) { // dokunmadan ortalama al / average while untouched
17 sum += touchRead(TOUCH_PIN);
18 delay(20);
19 }
20 threshold = (sum / 20) * 7 / 10; // eşik: ortalamanın %70'i / threshold: 70% of the average
21 Serial.printf("Esik / threshold: %d\n", threshold);
22}
23
24void loop() {
25 if (touchRead(TOUCH_PIN) < threshold) { // dokununca değer düşer / the value drops when touched
26 digitalWrite(LED_PIN, HIGH);
27 for (int i = 0; i < 11; i++) {
28 int duration = beats[i] * EIGHTH_MS;
29 tone(BUZZER_PIN, melody[i], duration * 9 / 10);
30 delay(duration);
31 }
32 noTone(BUZZER_PIN);
33 digitalWrite(LED_PIN, LOW);
34 delay(1000); // art arda tetiklenmesin / avoid instant retrigger
35 }
36}Weihnachtslieder mit dem Raspberry Pi Pico und MicroPython
Der Pico hat kein tone(), aber machine.PWM erledigt dasselbe: freq() setzt die Notenfrequenz und duty_u16(32768) einen Tastgrad von 50 %, der beim Buzzer den lautesten Klang ergibt. duty_u16(0) schaltet den Ton ab. Das Skript spielt zwei Lieder nacheinander; drückst du den Taster an GP2, bricht das aktuelle Lied ab und das nächste beginnt. Die anderen beiden Lieder kannst du im selben Format mit den Zahlen aus dem Arduino-Sketch ergänzen; Frequenzen und Längen sind identisch. Bist du neu bei MicroPython, schau dir zuerst die Thonny-Installation in Was ist der Raspberry Pi Pico? an.
1# Raspberry Pi Pico (MicroPython): Jingle Bells + We Wish You a Merry Christmas
2from machine import Pin, PWM
3import time
4
5buzzer = PWM(Pin(15)) # pasif buzzer GP15 / passive buzzer on GP15
6leds = [Pin(14, Pin.OUT), Pin(13, Pin.OUT)]
7button = Pin(2, Pin.IN, Pin.PULL_UP) # buton GP2 -> GND / button GP2 -> GND
8
9C5, D5, E5, F5, G5, A5, AS5 = 523, 587, 659, 698, 784, 880, 932
10
11JINGLE = [(E5,2),(E5,2),(E5,4),(E5,2),(E5,2),(E5,4),(E5,2),(G5,2),(C5,3),(D5,1),(E5,8),
12 (F5,2),(F5,2),(F5,3),(F5,1),(F5,2),(E5,2),(E5,2),(E5,1),(E5,1),
13 (E5,2),(D5,2),(D5,2),(E5,2),(D5,4),(G5,4),
14 (E5,2),(E5,2),(E5,4),(E5,2),(E5,2),(E5,4),(E5,2),(G5,2),(C5,3),(D5,1),(E5,8),
15 (F5,2),(F5,2),(F5,3),(F5,1),(F5,2),(E5,2),(E5,2),(E5,1),(E5,1),
16 (G5,2),(G5,2),(F5,2),(D5,2),(C5,8)]
17WE_WISH = [(C5,2),(F5,2),(F5,1),(G5,1),(F5,1),(E5,1),(D5,2),(D5,2),(D5,2),
18 (G5,2),(G5,1),(A5,1),(G5,1),(F5,1),(E5,2),(C5,2),(C5,2),
19 (A5,2),(A5,1),(AS5,1),(A5,1),(G5,1),(F5,2),(D5,2),(C5,1),(C5,1),
20 (D5,2),(G5,2),(E5,2),(F5,6)]
21SONGS = [(JINGLE, 250), (WE_WISH, 200)] # (notalar, sekizlik ms) / (notes, eighth ms)
22
23def play(notes, eighth_ms):
24 for i, (freq, length) in enumerate(notes):
25 duration = length * eighth_ms
26 leds[i % 2].on()
27 leds[(i + 1) % 2].off()
28 if freq:
29 buzzer.freq(freq)
30 buzzer.duty_u16(32768) # %50 doluluk = en yüksek ses / 50% duty = loudest
31 time.sleep_ms(duration * 9 // 10)
32 buzzer.duty_u16(0) # %10 sessizlik / 10% silence
33 time.sleep_ms(duration // 10)
34 if button.value() == 0: # basılırsa şarkıyı kes / stop the song on press
35 break
36 for led in leds:
37 led.off()
38
39song = 0
40while True:
41 play(*SONGS[song])
42 song = (song + 1) % len(SONGS)
43 time.sleep_ms(1500)Lauter und schöner klingen lassen
- Transistor und Lautsprecher: Führe vom Pin über einen 1-kΩ-Widerstand an die Basis eines NPN-Transistors (2N2222, BC337), schließe den Lautsprecher zwischen 5 V und Kollektor an und lege den Emitter auf GND. Ein kleiner 8-Ω-Lautsprecher klingt viel voller als ein Buzzer; ein 47–100-Ω-Vorwiderstand begrenzt den Strom.
- Resonanzbereich: Kleine Piezo-Buzzer sind um 2–4 kHz am lautesten. Die Melodie eine Oktave höher zu legen, macht sie spürbar lauter, wenn auch nicht so stark wie ein Transistor.
- Gehäuse-Effekt: Setzt du den Buzzer in eine Pappschachtel oder eine Christbaumkugel, mit dem Loch nach außen, wird der Klang ganz natürlich verstärkt.
- Leiser machen: Für ein Projekt, das nachts läuft, schalte einen 100–470-Ω-Widerstand in Reihe zum Buzzer; die Lautstärke sinkt, die Melodie bleibt erhalten.
- Nur eine Stimme: Auf dem Uno erzeugt tone() immer nur an einem Pin gleichzeitig Ton. Für Akkorde oder zweistimmige Musik passt ein MP3-Modul wie der DFPlayer Mini besser; die Optionen vergleichen wir in Arduino-Musikprojekte.
Häufige Fehler und Lösungen
| Problem | Ursache | Lösung |
|---|---|---|
| Immer derselbe Piepton | Aktiver Buzzer im Einsatz | Passiven Buzzer einsetzen; an der Batterie sollte er knacken |
| Melodie unkenntlich, Noten verrutscht | Arrays melody und beats unterschiedlich lang | Elementzahl angleichen und Takt für Takt prüfen |
| Gleiche Noten klingen wie ein langer Ton | Keine Pause zwischen den Noten | tone()-Dauer auf 90 % der Note setzen |
| LED an D3 oder D11 flackert | tone() nutzt Timer2 | LED auf einen anderen Pin wie D6 oder D7 legen |
| Ein Druck überspringt mehrere Lieder | Tasterprellen | Fallende Flanke erkennen und 250 ms sperren |
| 'tone' was not declared auf dem ESP32 | Sehr alter ESP32-Core (1.x) | Im Boardverwalter auf 2.x oder 3.x aktualisieren |
| Ton hört am Pico nach dem Lied nicht auf | duty_u16(0) nicht aufgerufen | Nach jeder Note und am Ende duty_u16(0) aufrufen |
Projektideen mit Weihnachtsliedern
- Weihnachtsmann-Detektor: Sieht ein PIR-Sensor vor dem Kamin eine Bewegung, spielt Jingle Bells; den Aufbau findest du im Weihnachtsmann-Detektor.
- Musikalischer Weihnachtsbaum: Lass die Farben eines WS2812B-Streifens im Takt der Noten wechseln; für den Baum selbst siehe Weihnachtsbaum-Beleuchtung.
- Mitternachtsmelodie: Spiel We Wish You a Merry Christmas, wenn der Silvester-Countdown null erreicht.
- Türklingel: Spiel im ganzen Dezember beim Druck auf die Klingel statt des üblichen Ding-Dong die erste Zeile von Deck the Halls.
- Taster-Klavier: Spiel diese Noten selbst mit acht Tastern; Schaltung und Code stehen in Arduino-Klavier. Weitere saisonale Ideen findest du in der Liste Arduino-Weihnachtsprojekte.
Wenn du deine erste Melodie auf einem Buzzer spielen willst: Die kostenlosen Buzzer-Projekte in der BlueGrays-App führen dich vom ersten Piepton über die Frequenzsteuerung bis zu einer vollständigen Hymnen-Melodie, jeweils mit Schaltplan, Schritt-für-Schritt-Verdrahtung und fertigem Code. Mit den Gewohnheiten, die du dort lernst, baust du die vier Weihnachtslieder aus diesem Beitrag leicht in deine eigene Spieluhr oder Weihnachtskarte ein.
Häufige Fragen
Wie spielt man Jingle Bells mit dem Arduino?
Verbinde das +-Bein des passiven Buzzers mit D8 und das andere mit GND, schreib die Notenfrequenzen in ein Array und ihre Längen in ein zweites. In der Schleife rufst du für jede Note tone(8, frequenz, dauer) auf und wartest mit delay(dauer). Der Refrain beginnt mit E E E, E E E, E G C D E, und bei 120 BPM dauert eine Achtel 250 ms.
Kann ein aktiver Buzzer Weihnachtslieder spielen?
Nein. Ein aktiver Buzzer hat einen Oszillator mit fester Frequenz eingebaut und piept immer im selben Ton, egal was du sendest. Für Melodien brauchst du einen passiven Buzzer, eine Piezoscheibe oder einen kleinen Lautsprecher mit Transistor.
Wie funktioniert die Arduino-Funktion tone()?
tone(pin, frequenz) erzeugt am Pin ein Rechtecksignal mit 50 % Tastgrad und spielt, bis noTone(pin) aufgerufen wird. Übergibst du als dritten Parameter Millisekunden, endet der Ton nach dieser Zeit von selbst. Auf dem Uno nutzt tone() den Timer2, daher funktioniert PWM an D3 und D11 währenddessen nicht.
Wie macht man einen Buzzer lauter?
Am wirksamsten ist es, über einen 1-kΩ-Widerstand einen NPN-Transistor anzusteuern und über ihn einen kleinen Lautsprecher aus 5 V zu speisen. Ohne Transistor hilft es auch, die Melodie eine Oktave höher zu legen, weil Piezo-Buzzer um 2–4 kHz am lautesten sind. Ein geschlossenes Gehäuse wie eine Schachtel verstärkt den Klang zusätzlich.
Kann der Arduino etwas anderes tun, während ein Lied läuft?
Solange eine mit delay() geschriebene Melodie spielt, kann der Arduino nichts anderes tun. Prüfst du das Ende jeder Note mit millis(), kehrt loop() ohne Warten zurück; Taster lesen, LEDs schalten oder Sensoren messen funktioniert dann auch während des Liedes.
Gibt es tone() auf dem Raspberry Pi Pico?
In MicroPython gibt es kein tone(), aber machine.PWM erledigt dasselbe. An einem PWM(Pin(15))-Objekt setzt du mit freq(frequenz) die Note und mit duty_u16(32768) 50 % Tastgrad; duty_u16(0) schaltet den Ton ab. Die Notenfrequenzen sind genau dieselben wie beim Arduino.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Verwendung des Summers
Hast du dich mal gefragt, wie eine Türklingel oder ein Alarm seinen Ton erzeugt? Der Arduino lässt einen kleinen Summer in kurzen Abständen piepen: piep, Pause, piep, Pause. Du siehst, wie Strom zu Kl
Frequenzeinstellung mit Buzzer
Mit vier Knöpfen steuerst du den Ton eines Summers: Einer startet den Ton, einer macht ihn stumm, die anderen beiden machen ihn höher oder tiefer. Hältst du den Plus- oder Minusknopf gedrückt, ändert
Türkische Nationalhymne mit Summer
Drückst du den Knopf, spielt ein kleiner Summer die türkische Nationalhymne, Note für Note. Der Arduino spielt jede Note in der richtigen Höhe und Länge, trägt zwei Strophen der Hymne von Anfang bis E
Melodien abspielen mit IR-Fernbedienung und Summer
Bau eine Spieluhr, die mit den Tasten einer Fernbedienung Melodien spielt. Ein Infrarotempfänger fängt das Signal der Fernbedienung auf; eine Taste spielt über den Summer eine flotte Videospielmelodie
Einfaches Klavier mit Summer und Taste
Bau dir mit acht Tastern dein eigenes kleines Klavier. Jeder Taster ist ein Ton, von tief nach hoch: do, re, mi, fa, so, la, ti und das hohe do. Solange du drückst, erklingt der Ton aus dem Summer, be
ESP32 Melodie-Wiedergabe mit Buzzer
Spielen einer einfachen Melodie (Twinkle Twinkle Little Star) mit einem passiven Buzzer. Wir spielen die Noten mit den Funktionen tone() und noTone() wie in Arduino - die gleiche Syntax funktioniert mit ESP32 Arduino Core 3.0+. Es muss ein passiver Buzzer verwendet werden (ein aktiver Buzzer spielt keine Melodie).
Arduino Reaktionstest mit Tonsignal: Miss deine Reflexe in Millisekunden (LCD + Buzzer + 3 LEDs)
Wie schnell sind deine Reflexe? Drück den Taster: Die rote LED heißt Auf die Plätze, die gelbe Fertig, dann beginnt eine zufällige Wartezeit von 1,5 bis 3,5 Sekunden. Sobald die grüne LED leuchtet und der Buzzer piept, drückst du erneut; deine Reaktionszeit erscheint in Millisekunden auf dem I2C-LCD, darunter Sitzungsrekord und Durchschnitt. Wer vor Grün drückt, sieht TOO EARLY! und hört einen Verliererton. Gedrückt halten startet einen neuen Spieler mit derselben Wartefolge.