Gidsen · 9 min leestijd

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.

Passieve buzzer voor Arduino-kerstliedjes
Een passieve buzzer speelt elke frequentie die tone() hem geeft, waardoor hij de juiste keuze is voor melodieën.

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?.

EigenschapActieve buzzerPassieve buzzer
Ingebouwde oscillatorJaNee
Speelt melodieën?Nee, slechts één toonJa, elke noot met tone()
AansturingdigitalWrite()tone(pin, frequentie, duur)
Tegen een batterij gehoudenContinue pieptoonEnkele klik
Luidste bereikVast (meestal 2–2,5 kHz)Circa 2–4 kHz (resonantie)

Bedrading: buzzer, twee leds en een knop

OnderdeelArduino UnoESP32Raspberry Pi Pico
Passieve buzzer +D8GPIO 25GP15
Passieve buzzer −GNDGNDGND
Led 1 (met 220 Ω)D6GPIO 26GP14
Led 2 (met 220 Ω)D7GPIO 27GP13
Knop (andere pootje naar GND)D2GPIO 4GP2
Aanraakfolie-GPIO 32 (T9)-
Op de Uno gebruikt tone() Timer2, dus terwijl een lied speelt werkt analogWrite() niet op D3 en D11. Als je leds op die pins zet en ze probeert te dimmen, zie je geflikker of helemaal geen licht. Een buzzer rechtstreeks op een pin aansluiten is prima, maar sluit nooit een luidspreker van 8 Ω rechtstreeks op een pin aan; gebruik de transistorschakeling in het onderstaande gedeelte over harder maken.

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.

NootNaamFrequentie (Hz)Codeconstante
B4B494NOTE_B4
C5C523NOTE_C5
D5D587NOTE_D5
E5E659NOTE_E5
F5F698NOTE_F5
F#5Fis740NOTE_FS5
G5G784NOTE_G5
A5A880NOTE_A5
A#5 / Bb5Bes932NOTE_AS5
B5B988NOTE_B5
C6C1047NOTE_C6
D6D1175NOTE_D6
E6E1319NOTE_E6
F6F1397NOTE_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.

LiedMaatsoortTempoAchtste (ms)Kwart (ms)Noten
Jingle Bells (refrein)4/4120 BPM25050051
We Wish You a Merry Christmas3/4150 BPM20040030
Silent Night3/475 BPM40080046
Deck the Halls4/4ongeveer 130 BPM23046068

Eerste sketch: het refrein van Jingle Bells

  1. Sluit het +-draadje van de passieve buzzer aan op D8 en het andere draadje op GND.
  2. Open de Arduino IDE, plak de onderstaande code en kies Arduino Uno als board.
  3. Upload de code; het refrein wordt één keer afgespeeld zodra het board opstart. Druk op de resetknop om het opnieuw te horen.
  4. Als het te langzaam of te snel klinkt, pas dan EIGHTH_MS aan: 200 speelt sneller, 300 langzamer.
C++ (Arduino IDE)
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.

LiedToonsoortNoten van de eerste regelLet op
Jingle BellsC-grootE E E – E E E – E G C. D – EGepunteerde kwart + achtste op "all the way"
We Wish You a Merry ChristmasF-grootC – F F G F E – D D D3/4-maat, gebruikt Bes (A#5)
Silent NightC-groot (een octaaf hoger)G. A G – E – G. A G – ELangzaam tempo, gepunteerde halve noten
Deck the HallsC-grootG. 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.

C++ (Arduino IDE)
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.

Om een lied een octaaf omhoog te zetten, vermenigvuldig je de frequentie in de tone()-regel met 2: tone(BUZZER_PIN, n.freq * 2, ...). Passieve buzzers zijn het luidst rond 2–4 kHz, dus deze kleine aanpassing maakt het geluid merkbaar luider; maar liedjes die al hoog klimmen, zoals Silent Night, kunnen schel en schrapend gaan klinken.

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.

C++ (Arduino IDE)
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?.

MicroPython
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

ProbleemOorzaakOplossing
Altijd dezelfde pieptoonJe gebruikt een actieve buzzerGebruik een passieve buzzer; die hoort te klikken als je hem tegen een batterij houdt
Melodie onherkenbaar, noten verschovenDe arrays melody en beats hebben verschillende lengtesZorg voor hetzelfde aantal elementen en controleer maat voor maat
Herhaalde noten klinken als één lange toonGeen stilte tussen de notenMaak de tone()-duur 90% van de noot
Led op D3 of D11 flikkerttone() gebruikt Timer2Verplaats de led naar een andere pin, zoals D6 of D7
Eén druk slaat meerdere liedjes overContactdender van de knopVang de dalende flank op en voeg een blokkade van 250 ms toe
'tone' was not declared op ESP32Zeer 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 Picoduty_u16(0) wordt niet aangeroepenRoep duty_u16(0) aan na elke noot en aan het einde
Om een eigen lied toe te voegen, schrijf je de melodie eerst maat voor maat uit bladmuziek op en controleer je het totaal aan achtsten van elke maat: een 4/4-maat moet optellen tot 8 achtsten en een 3/4-maat tot 6. Klopt het totaal niet, dan ontbreekt er een noot of heeft die de verkeerde lengte; zo vind je dat veel sneller dan op het gehoor.

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.

Alle projecten bekijken
Een buzzer gebruiken
AR-13Beginner

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.

4.7(92)
170
Frequentie instellen met een buzzer
AR-14Gemiddeld

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.

4.6(69)
120
Turks volkslied met een buzzer
AR-15Gemiddeld

Turks volkslied met een buzzer

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

4.8(114)
234
Melodieën afspelen met IR-afstandsbediening en buzzer
AR-18Beginner
Premium

Melodieën afspelen met IR-afstandsbediening en buzzer

Bouw een muziekdoos die melodieën speelt met de knoppen van een tv-afstandsbediening.

4.8(58)
75
Eenvoudige piano met buzzer en knoppen
AR-26Gevorderd
Premium

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.

4.9(67)
89
Melodie afspelen met een buzzer op de ESP32
ES-12Beginner
Premium

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).

4.8(30)
55
Arduino-reactietest met geluidssignaal: meet je reflexen in milliseconden (LCD + buzzer + 3 leds)
AR-95Gemiddeld
Premium

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.

4.6(33)
50