Jingle Bells Arduino-code: 4 kerstliedjes voor een buzzer
Jingle Bells Arduino-code plus We Wish You a Merry Christmas, Silent Night en Deck the Halls op een passieve buzzer: notentabel, tempo en een ledspeler op basis van millis.
Om Jingle Bells op een Arduino te spelen heb je alleen een passieve buzzer en de functie tone() nodig: je zet de frequentie en lengte van elke noot in een array en de Arduino stuurt ze één voor één naar de buzzer. In deze post vind je nauwkeurige arrays met noten en duur voor Jingle Bells, We Wish You a Merry Christmas, Silent Night en Deck the Halls, overgenomen uit bladmuziek in plaats van op het gehoor geraden. Alle vier de melodieën zijn traditionele stukken van ruim honderd jaar oud, dus je kunt ze in elk project gebruiken zonder je zorgen te maken over auteursrechten.
We beginnen met een korte sketch voor één lied en gaan daarna verder met een muziekdoos die alle vier de liedjes na elkaar speelt, twee leds met de noten laat knipperen en met een knop van lied wisselt. Die tweede sketch gebruikt millis() in plaats van delay(), zodat hij tijdens het afspelen ook andere taken kan blijven afhandelen, zoals knoppen, sensoren of een ledstrip. Aan het einde zetten we dezelfde melodieën over naar een ESP32-kerstkaart met aanraaksensor en naar MicroPython op een Raspberry Pi Pico.

Welke buzzer heb je nodig: actief of passief?
Een actieve buzzer heeft een eigen oscillator aan boord; geef hem 5 V en hij piept altijd op dezelfde toonhoogte, dus hij kan geen melodie spelen. Een passieve buzzer werkt als een piepklein luidsprekertje: hij klinkt op de frequentie waarmee de Arduino-pin aan en uit schakelt. Je herkent het verschil eenvoudig door de buzzer even tegen een batterij van 3–5 V te houden: een continue pieptoon betekent actief, een enkele klik betekent passief. Actieve modellen hebben meestal een wit stickertje en een gesloten onderkant, terwijl passieve aan de onderkant een groene printplaat laten zien. Meer details vind je in Wat is een buzzer?.
| Eigenschap | Actieve buzzer | Passieve buzzer |
|---|---|---|
| Ingebouwde oscillator | Ja | Nee |
| Speelt melodieën? | Nee, slechts één toon | Ja, elke noot met tone() |
| Aansturing | digitalWrite() | tone(pin, frequentie, duur) |
| Tegen een batterij gehouden | Continue pieptoon | Enkele klik |
| Luidste bereik | Vast (meestal 2–2,5 kHz) | Circa 2–4 kHz (resonantie) |
Bedrading: buzzer, twee leds en een knop
| Onderdeel | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Passieve buzzer + | D8 | GPIO 25 | GP15 |
| Passieve buzzer − | GND | GND | GND |
| Led 1 (met 220 Ω) | D6 | GPIO 26 | GP14 |
| Led 2 (met 220 Ω) | D7 | GPIO 27 | GP13 |
| Knop (andere pootje naar GND) | D2 | GPIO 4 | GP2 |
| Aanraakfolie | - | GPIO 32 (T9) | - |
Nootfrequenties: de 14 noten die in deze kerstliedjes worden gebruikt
In de westerse muziek is elk octaaf verdeeld in 12 halve tonen, en een halve toon omhoog vermenigvuldigt de frequentie met de twaalfde machtswortel van 2, ongeveer 1,0595. De referentienoot A4 is 440 Hz; een noot met MIDI-nummer n heeft de frequentie f = 440 × 2^((n − 69) / 12). C5 is bijvoorbeeld MIDI 72: 440 × 2^(3/12) = 523,25 Hz. Een octaaf omhoog verdubbelt de frequentie precies, daarom is C6 1047 Hz. Kleine passieve buzzers klinken zwak onder 500 Hz, dus hebben we alle vier de liedjes naar het 5e en 6e octaaf verplaatst; de tabel bevat elke noot die de code gebruikt.
| Noot | Naam | Frequentie (Hz) | Codeconstante |
|---|---|---|---|
| B4 | B | 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 | Bes | 932 | NOTE_AS5 |
| B5 | B | 988 | NOTE_B5 |
| C6 | C | 1047 | NOTE_C6 |
| D6 | D | 1175 | NOTE_D6 |
| E6 | E | 1319 | NOTE_E6 |
| F6 | F | 1397 | NOTE_F6 |
Tempo en nootlengtes
In plaats van elke lengte in milliseconden op te schrijven, gebruiken we de kortste noot, de achtste noot, als eenheid: 1 is een achtste, 2 een kwart, 3 een gepunteerde kwart, 4 een halve, 6 een gepunteerde halve en 8 een hele noot. Het tempo is het aantal kwartnoten per minuut (BPM); een kwart duurt 60000 / BPM milliseconden en een achtste is de helft daarvan. Bij 120 BPM duurt een kwart 500 ms en een achtste 250 ms. Om de snelheid van een lied te veranderen pas je alleen de lengte van de achtste noot aan en blijven de arrays ongemoeid. Elke noot klinkt 90% van zijn lengte en de laatste 10% is stil, zodat herhaalde noten (zoals de drie E's in Jingle Bells) niet in één lange toon overlopen.
| Lied | Maatsoort | Tempo | Achtste (ms) | Kwart (ms) | Noten |
|---|---|---|---|---|---|
| Jingle Bells (refrein) | 4/4 | 120 BPM | 250 | 500 | 51 |
| We Wish You a Merry Christmas | 3/4 | 150 BPM | 200 | 400 | 30 |
| Silent Night | 3/4 | 75 BPM | 400 | 800 | 46 |
| Deck the Halls | 4/4 | ongeveer 130 BPM | 230 | 460 | 68 |
Eerste sketch: het refrein van Jingle Bells
- Sluit het +-draadje van de passieve buzzer aan op D8 en het andere draadje op GND.
- Open de Arduino IDE, plak de onderstaande code en kies Arduino Uno als board.
- Upload de code; het refrein wordt één keer afgespeeld zodra het board opstart. Druk op de resetknop om het opnieuw te horen.
- Als het te langzaam of te snel klinkt, pas dan EIGHTH_MS aan: 200 speelt sneller, 300 langzamer.
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}De sketch gebruikt twee parallelle arrays: melody bevat de nootfrequenties en beats de lengte van elke noot, in achtsten, in dezelfde volgorde. Voor elke noot start de lus het geluid met tone() en wacht de volledige nootlengte af met delay(). Als tone() een duur als derde argument krijgt, stopt het geluid vanzelf; omdat we 90% van de nootlengte meegeven, valt er tussen de noten een korte adempauze. Beide arrays moeten evenveel elementen hebben; voeg je een noot toe aan de ene en vergeet je de lengte in de andere, dan loopt de melodie scheef en wordt willekeurig geheugen voorbij het einde van de array afgespeeld. De witregels in de arrays komen overeen met maatstrepen, waardoor je de noten gemakkelijk met de bladmuziek kunt vergelijken.
Notenarrays voor alle vier de liedjes
De onderstaande tabel toont de toonsoort van elk lied en de noten van de eerste regel; dat helpt als je de code op het gehoor controleert. Een streepje (–) is een maatstreep en een punt (.) een gepunteerde noot. We Wish You a Merry Christmas begint met een opmaat (anacrusis): de eerste C5 is een losse kwartnoot vóór maat één. Silent Night is langzaam en breed, dus hebben we de laatste C5 12 achtsten aangehouden, twee volle maten. Het enige kruis in Deck the Halls is de Fis (F#5) in de stijgende "fa-la-la"-reeks.
| Lied | Toonsoort | Noten van de eerste regel | Let op |
|---|---|---|---|
| Jingle Bells | C-groot | E E E – E E E – E G C. D – E | Gepunteerde kwart + achtste op "all the way" |
| We Wish You a Merry Christmas | F-groot | C – F F G F E – D D D | 3/4-maat, gebruikt Bes (A#5) |
| Silent Night | C-groot (een octaaf hoger) | G. A G – E – G. A G – E | Langzaam tempo, gepunteerde halve noten |
| Deck the Halls | C-groot | G. F E D – C D E C | "Fa-la-la"-achtsten, Fis (F#5) |
Een kerstliedjesspeler met leds op basis van millis (4 liedjes + knop)
Nu zetten we alle vier de liedjes in één sketch. De noten staan in een Note-struct met paren van {frequentie, lengte} en worden met PROGMEM in het flashgeheugen opgeslagen; de Uno heeft maar 2 KB RAM, dus 195 noten uit flash lezen in plaats van ze in RAM te bewaren is een goede gewoonte. De leds wisselen bij elke noot, de knop op D2 gebruikt de interne pull-up en met een druk spring je naar het volgende lied. Als een lied afgelopen is, volgt er 1,5 seconde stilte voordat het volgende begint.
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}Het hart van de code is de timingcontrole in loop(): als millis() − noteStart de lengte van de noot heeft overschreden, begint de volgende noot; zo niet, dan gaat loop door zonder te wachten. Zo wordt de knop bij elke ronde gelezen en mis je geen enkele druk; met delay() zou de knop tijdens de slotnoot van 4,8 seconden in Silent Night helemaal niet reageren. memcpy_P() kopieert een noot uit flash naar een tijdelijke variabele in RAM. Als een lied afloopt, is noteIndex gelijk aan het aantal noten en die waarde wordt gebruikt als "pauze"-toestand; als de pauze voorbij is, wordt nextSong() aangeroepen. De gecompileerde sketch gebruikt ongeveer 3,9 KB flash en 67 bytes RAM op een Uno. Lees voor meer over waarom we millis() boven delay() kozen millis versus delay.
Kerstliedjes op de ESP32: een kerstkaart met aanraaksensor
De bovenstaande spelersketch compileert ook ongewijzigd op een ESP32: het blok #if defined(ESP32) schakelt de pins automatisch om naar GPIO 25, 26, 27 en 4. Versie 2.x en 3.x van de ESP32-core bevatten tone(), dat achter de schermen de LEDC-PWM-eenheid gebruikt. Omdat ESP32-pins 3,3 V uitsturen, klinkt het geluid iets zachter dan op een Uno. De korte sketch hieronder gebruikt de aanraakpins van de ESP32: raak een ster van aluminiumfolie aan die op GPIO 32 is aangesloten, en de eerste regel van Jingle Bells klinkt terwijl de led oplicht. De code meet bij het opstarten de waarde zonder aanraking en stelt de drempel zelf in; meer over aanraakpins vind je in ESP32-aanraakpins.
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}Kerstliedjes op de Raspberry Pi Pico met MicroPython
De Pico heeft geen tone(), maar machine.PWM doet hetzelfde: freq() stelt de nootfrequentie in en duty_u16(32768) stelt een duty cycle van 50% in, waarmee een buzzer het luidst klinkt. duty_u16(0) maakt hem stil. Het script speelt twee liedjes na elkaar; druk op de knop op GP2 en het huidige lied stopt en het volgende begint. Je kunt de andere twee liedjes in hetzelfde formaat toevoegen met de getallen uit de Arduino-sketch; frequenties en lengtes zijn identiek. Als MicroPython nieuw voor je is, begin dan met de Thonny-installatie in Wat is de Raspberry Pi Pico?.
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)Harder en mooier laten klinken
- Transistor en luidspreker: Ga van de pin via een weerstand van 1 kΩ naar de basis van een NPN-transistor (2N2222, BC337), sluit de luidspreker aan tussen 5 V en de collector en de emitter op GND. Een kleine luidspreker van 8 Ω klinkt veel voller dan een buzzer; een serieweerstand van 47–100 Ω beperkt de stroom.
- Resonantiebereik: Kleine piëzobuzzers zijn het luidst rond 2–4 kHz. Als je de melodie een octaaf omhoog zet, klinkt hij duidelijk luider, hoewel niet zo veel als met een transistor.
- Behuizingseffect: Als je de buzzer in een kartonnen doos of een kerstbal plaatst, met het gaatje naar buiten, versterkt dat het geluid vanzelf.
- Om het zachter te maken: Voor een project dat 's nachts draait, plaats je een weerstand van 100–470 Ω in serie met de buzzer; het volume daalt en de melodie blijft intact.
- Slechts één stem: Op de Uno produceert tone() maar op één pin tegelijk geluid. Voor akkoorden of tweestemmige muziek is een mp3-module zoals de DFPlayer Mini een betere keuze; we vergelijken de opties in Arduino-muziekprojecten.
Veelvoorkomende problemen en oplossingen
| Probleem | Oorzaak | Oplossing |
|---|---|---|
| Altijd dezelfde pieptoon | Je gebruikt een actieve buzzer | Gebruik een passieve buzzer; die hoort te klikken als je hem tegen een batterij houdt |
| Melodie onherkenbaar, noten verschoven | De arrays melody en beats hebben verschillende lengtes | Zorg voor hetzelfde aantal elementen en controleer maat voor maat |
| Herhaalde noten klinken als één lange toon | Geen stilte tussen de noten | Maak de tone()-duur 90% van de noot |
| Led op D3 of D11 flikkert | tone() gebruikt Timer2 | Verplaats de led naar een andere pin, zoals D6 of D7 |
| Eén druk slaat meerdere liedjes over | Contactdender van de knop | Vang de dalende flank op en voeg een blokkade van 250 ms toe |
| 'tone' was not declared op ESP32 | Zeer oude ESP32-core (1.x) | Werk bij naar 2.x of 3.x in de Boards Manager |
| Geluid stopt niet na het lied op de Pico | duty_u16(0) wordt niet aangeroepen | Roep duty_u16(0) aan na elke noot en aan het einde |
Projectideeën met kerstliedjes
- Kerstmandetector: Als een PIR-sensor beweging voor de open haard ziet, speel je Jingle Bells af; de bouw staat in Kerstmandetector.
- Muzikale kerstboom: Laat de kleuren op een WS2812B-strip met de noten veranderen terwijl het lied speelt; voor de boom zelf zie je Kerstboomleds.
- Middernachtmelodie: Speel We Wish You a Merry Christmas af wanneer de aftelklok voor nieuwjaar op nul staat.
- Deurbel: Speel de hele december de eerste regel van Deck the Halls af in plaats van de gebruikelijke ding-dong wanneer op de deurbelknop wordt gedrukt.
- Knoppenpiano: Speel deze noten zelf met acht knoppen; de schakeling en code staan in Arduino-piano. Voor meer ideeën rond de feestdagen bekijk je de lijst met Arduino-kerstprojecten.
Wil je je eerste melodie op een buzzer spelen? Met de gratis buzzerprojecten in de BlueGrays-app ga je van een eerste pieptoon naar frequentiebeheersing en een complete melodie van een volkslied; elk project bevat een schakelschema, bedrading stap voor stap en kant-en-klare code. Met de gewoontes die je daar opdoet, kun je de vier kerstliedjes uit deze post eenvoudig aan je eigen muziekdoos of kerstkaart toevoegen.
Veelgestelde vragen
Hoe speel je Jingle Bells op een Arduino?
Sluit het +-draadje van de passieve buzzer aan op D8 en het andere draadje op GND, en zet de nootfrequenties in één array en hun lengtes in een andere. Roep in de lus voor elke noot tone(8, frequentie, duur) aan en wacht met delay(duur). Het refrein begint met E E E, E E E, E G C D E, en bij 120 BPM duurt een achtste noot 250 ms.
Kan een actieve buzzer kerstliedjes spelen?
Nee. Een actieve buzzer heeft een oscillator met vaste frequentie aan boord en piept op dezelfde toonhoogte, wat je er ook naartoe stuurt. Voor melodieën heb je een passieve buzzer, een piëzoschijfje of een kleine luidspreker via een transistor nodig.
Hoe gebruik je de Arduino-functie tone()?
tone(pin, frequentie) geeft een blokgolf met 50% duty cycle op de pin en blijft spelen tot noTone(pin) wordt aangeroepen. Als je milliseconden als derde argument meegeeft, stopt het geluid vanzelf na die tijd. Op de Uno gebruikt tone() Timer2, dus PWM op D3 en D11 werkt niet zolang het speelt.
Hoe kan ik een buzzer luider laten klinken?
De effectiefste manier is een NPN-transistor vanaf de pin aansturen via een weerstand van 1 kΩ en een kleine luidspreker via de transistor van 5 V voorzien. Zonder transistor helpt het ook om de melodie een octaaf omhoog te zetten, omdat piëzobuzzers het luidst zijn rond 2–4 kHz. Ook de buzzer in een afgesloten ruimte zoals een doos plaatsen versterkt het geluid.
Kan de Arduino andere dingen doen terwijl een lied speelt?
Zolang een melodie met delay() speelt, kan de Arduino niets anders doen. Als je met millis() controleert wanneer elke noot eindigt, keert loop() terug zonder te wachten, zodat knoppen lezen, leds laten branden of sensorwaarden meten blijft werken terwijl het lied doorgaat.
Heeft de Raspberry Pi Pico tone()?
MicroPython heeft geen tone(), maar machine.PWM doet hetzelfde. Op een PWM(Pin(15))-object stel je de noot in met freq(frequentie) en een duty cycle van 50% met duty_u16(32768); duty_u16(0) maakt het stil. De nootfrequenties zijn precies dezelfde als op de Arduino.
Projecten om hierna te bouwen
Alle projecten bekijken
Een buzzer gebruiken
Heb je je ooit afgevraagd hoe een deurbel of alarm geluid maakt? De Arduino laat een kleine buzzer met korte tussenpozen piepen: piep, pauze, piep, pauze.

Frequentie instellen met een buzzer
Met vier knoppen bestuur je het geluid van een buzzer: één start het geluid, één stopt het en de andere twee maken het hoger of lager.

Turks volkslied met een buzzer
Druk op de knop en een kleine buzzer speelt noot voor noot het Turkse volkslied (İstiklal Marşı).

Melodieën afspelen met IR-afstandsbediening en buzzer
Bouw een muziekdoos die melodieën speelt met de knoppen van een tv-afstandsbediening.

Eenvoudige piano met buzzer en knoppen
Bouw je eigen kleine piano met acht knoppen. Elke knop is één noot, van laag naar hoog: do, re, mi, fa, sol, la, si en hoge do.

Melodie afspelen met een buzzer op de ESP32
Een eenvoudige melodie (Twinkle Twinkle Little Star) afspelen met een passieve buzzer. Net als op Arduino speel je noten met de functies tone() en noTone(); met ESP32 Arduino Core 3.0+ werkt dezelfde syntaxis. Je moet een passieve buzzer gebruiken (een actieve buzzer speelt geen melodie).

Arduino-reactietest met geluidssignaal: meet je reflexen in milliseconden (LCD + buzzer + 3 leds)
Hoe snel zijn je reflexen? Druk op de knop: rood zegt maak je klaar, geel zegt wacht, en er begint een willekeurige wachttijd van 1,5 tot 3,5 seconden. Gaat de groene led aan en piept de buzzer, druk dan opnieuw; je reactietijd verschijnt in milliseconden op de I2C-LCD, met je beste en gemiddelde tijd. Druk je vóór groen, dan toont het scherm TOO EARLY! (te vroeg) met een verliesgeluid. Houd de knop ingedrukt voor een nieuwe speler.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

