Jingle Bells Arduino buzzer: 4 canzoni di Natale con tone()
Jingle Bells con Arduino e buzzer passivo, più Astro del ciel, We Wish You a Merry Christmas e Deck the Halls: tabella delle note, tempo e lettore con LED.
Per suonare Jingle Bells con Arduino ti servono solo un buzzer passivo e la funzione tone(): scrivi frequenza e durata di ogni nota in un array e Arduino le invia al buzzer una dopo l'altra. In questo articolo trovi array di note e durate corretti per Jingle Bells, We Wish You a Merry Christmas, Astro del ciel (Silent Night) e Deck the Halls, ricavati dallo spartito e non indovinati a orecchio. Tutte e quattro le melodie sono brani tradizionali con più di cento anni, quindi puoi usarle in qualsiasi progetto senza preoccuparti del diritto d'autore.
Partiamo da uno sketch breve con una sola canzone, poi passiamo a un carillon che suona le quattro canzoni di fila, fa lampeggiare due LED a tempo con le note e cambia brano con un pulsante. Questo secondo sketch usa millis() al posto di delay(), quindi mentre la canzone suona può continuare a gestire pulsanti, sensori o una striscia LED. Alla fine portiamo le stesse melodie su un biglietto di Natale touch con l'ESP32 e in MicroPython sul Raspberry Pi Pico.
Quale buzzer serve: attivo o passivo?
Un buzzer attivo ha un oscillatore interno; se gli dai 5 V suona sempre sulla stessa nota, quindi non può suonare melodie. Un buzzer passivo si comporta come un minuscolo altoparlante: suona alla frequenza con cui il pin di Arduino si accende e si spegne. Il modo più semplice per distinguerli è appoggiare per un attimo il buzzer a una pila da 3–5 V: un bip continuo indica un buzzer attivo, un singolo clic un buzzer passivo. I modelli attivi hanno spesso un adesivo bianco e il fondo chiuso, mentre sotto quelli passivi si vede una piccola scheda verde. Per i dettagli leggi Che cos'è un buzzer?.
| Caratteristica | Buzzer attivo | Buzzer passivo |
|---|---|---|
| Oscillatore interno | Sì | No |
| Suona melodie? | No, un solo tono | Sì, qualsiasi nota con tone() |
| Comando | digitalWrite() | tone(pin, frequenza, durata) |
| Appoggiato a una pila | Bip continuo | Un singolo clic |
| Gamma più forte | Fissa (di solito 2–2,5 kHz) | Circa 2–4 kHz (risonanza) |
Collegamenti: buzzer, due LED e un pulsante
| Componente | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Buzzer passivo + | D8 | GPIO 25 | GP15 |
| Buzzer passivo − | GND | GND | GND |
| LED 1 (con 220 Ω) | D6 | GPIO 26 | GP14 |
| LED 2 (con 220 Ω) | D7 | GPIO 27 | GP13 |
| Pulsante (altro piedino a GND) | D2 | GPIO 4 | GP2 |
| Foglio di alluminio touch | - | GPIO 32 (T9) | - |
Frequenze delle note: le 14 note di queste canzoni di Natale
Nella musica occidentale ogni ottava è divisa in 12 semitoni, e salire di un semitono moltiplica la frequenza per la radice dodicesima di 2, circa 1,0595. La nota di riferimento la4 (A4) è 440 Hz; una nota con numero MIDI n ha frequenza f = 440 × 2^((n − 69) / 12). Per esempio do5 (C5) è il MIDI 72: 440 × 2^(3/12) = 523,25 Hz. Salire di un'ottava raddoppia esattamente la frequenza, per questo do6 vale 1047 Hz. I piccoli buzzer passivi suonano deboli sotto i 500 Hz, quindi abbiamo spostato le quattro canzoni nella 5ª e 6ª ottava; la tabella riporta tutte le note usate nel codice.
| Nota | Solfeggio | Frequenza (Hz) | Costante nel codice |
|---|---|---|---|
| B4 | Si | 494 | NOTE_B4 |
| C5 | Do | 523 | NOTE_C5 |
| D5 | Re | 587 | NOTE_D5 |
| E5 | Mi | 659 | NOTE_E5 |
| F5 | Fa | 698 | NOTE_F5 |
| F#5 | Fa diesis | 740 | NOTE_FS5 |
| G5 | Sol | 784 | NOTE_G5 |
| A5 | La | 880 | NOTE_A5 |
| A#5 / Bb5 | Si bemolle | 932 | NOTE_AS5 |
| B5 | Si | 988 | NOTE_B5 |
| C6 | Do | 1047 | NOTE_C6 |
| D6 | Re | 1175 | NOTE_D6 |
| E6 | Mi | 1319 | NOTE_E6 |
| F6 | Fa | 1397 | NOTE_F6 |
Tempo e durata delle note
Invece di scrivere ogni durata in millisecondi, abbiamo preso come unità la nota più breve, la croma: 1 è una croma, 2 una semiminima, 3 una semiminima puntata, 4 una minima, 6 una minima puntata e 8 una semibreve. Il tempo è il numero di semiminime al minuto (BPM); una semiminima dura 60000 / BPM millisecondi e una croma la metà. A 120 BPM la semiminima dura 500 ms e la croma 250 ms. Per cambiare la velocità di una canzone basta cambiare la durata della croma, senza toccare gli array. Ogni nota suona per il 90% della sua durata e il restante 10% resta in silenzio: così le note ripetute (come i tre mi di Jingle Bells) non si fondono in un unico suono lungo.
| Canzone | Tempo | Velocità | Croma (ms) | Semiminima (ms) | Note |
|---|---|---|---|---|---|
| Jingle Bells (ritornello) | 4/4 | 120 BPM | 250 | 500 | 51 |
| We Wish You a Merry Christmas | 3/4 | 150 BPM | 200 | 400 | 30 |
| Astro del ciel | 3/4 | 75 BPM | 400 | 800 | 46 |
| Deck the Halls | 4/4 | circa 130 BPM | 230 | 460 | 68 |
Primo sketch: il ritornello di Jingle Bells
- Collega il piedino + del buzzer passivo a D8 e l'altro a GND.
- Apri l'Arduino IDE, incolla il codice qui sotto e scegli Arduino Uno come scheda.
- Caricalo; il ritornello suona una volta appena la scheda si avvia. Per riascoltarlo premi il pulsante di reset.
- Se suona troppo lento o troppo veloce, cambia EIGHTH_MS: 200 suona più veloce, 300 più lento.
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}Lo sketch tiene due array paralleli: melody contiene le frequenze delle note e beats la durata di ogni nota, in crome, nello stesso ordine. Per ogni nota il ciclo avvia il suono con tone() e aspetta l'intera durata con delay(). Quando tone() riceve una durata come terzo parametro, interrompe il suono da solo; poiché gli passiamo il 90% della nota, resta un breve respiro tra una nota e l'altra. I due array devono avere lo stesso numero di elementi: se aggiungi una nota in uno e dimentichi la durata nell'altro, la melodia slitta e viene suonata memoria casuale oltre la fine dell'array. Gli spazi negli array coincidono con le stanghette di battuta, così è facile confrontare le note con lo spartito.
Gli array di note delle quattro canzoni
La tabella mostra la tonalità di ogni canzone e le note della sua prima frase; ti aiuta a controllare il codice a orecchio. Il trattino (–) è una stanghetta di battuta e il punto (.) una nota puntata. We Wish You a Merry Christmas inizia con un'anacrusi: il primo do5 è una semiminima isolata prima della prima battuta. Astro del ciel è lenta e ampia, quindi abbiamo tenuto l'ultimo do5 per 12 crome, cioè due battute intere. L'unica alterazione di Deck the Halls è il fa diesis (F#5) nella salita del "fa-la-la".
| Canzone | Tonalità | Note della prima frase | Attenzione |
|---|---|---|---|
| Jingle Bells | Do maggiore | Mi Mi Mi – Mi Mi Mi – Mi Sol Do. Re – Mi | Semiminima puntata + croma su "all the way" |
| We Wish You a Merry Christmas | Fa maggiore | Do – Fa Fa Sol Fa Mi – Re Re Re | Tempo 3/4, usa il si bemolle (A#5) |
| Astro del ciel | Do maggiore (un'ottava sopra) | Sol. La Sol – Mi – Sol. La Sol – Mi | Tempo lento, minime puntate |
| Deck the Halls | Do maggiore | Sol. Fa Mi Re – Do Re Mi Do | Crome del "fa-la-la", fa diesis (F#5) |
Lettore di canzoni di Natale con millis e LED (4 canzoni + pulsante)
Ora mettiamo tutte e quattro le canzoni in un unico sketch. Le note stanno in una struttura Note fatta di coppie {frequenza, durata} e sono salvate nella flash con PROGMEM; Arduino Uno ha solo 2 KB di RAM, quindi leggere 195 note dalla flash invece di tenerle in RAM è una buona abitudine. I LED si alternano a ogni nota, il pulsante su D2 usa il pull-up interno e ogni pressione passa alla canzone successiva. Quando una canzone finisce ci sono 1,5 secondi di silenzio, poi parte la successiva.
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}Il cuore del codice è il controllo del tempo dentro loop(): se millis() − noteStart ha superato la durata della nota, parte la nota successiva; altrimenti loop prosegue senza aspettare. Così il pulsante viene letto a ogni giro e nessuna pressione va persa; con delay(), il pulsante non risponderebbe affatto durante i 4,8 secondi dell'ultima nota di Astro del ciel. memcpy_P() copia una nota dalla flash in una variabile temporanea in RAM. Quando una canzone finisce, noteIndex è uguale al numero di note e questo valore funge da stato di "pausa"; finita la pausa, viene chiamata nextSong(). Lo sketch compilato occupa circa 3,9 KB di flash e 67 byte di RAM su Arduino Uno. Per capire meglio perché preferiamo millis() a delay(), leggi millis o delay.
Canzoni di Natale con l'ESP32: un biglietto di Natale touch
Lo sketch del lettore qui sopra si compila senza modifiche anche sull'ESP32: il blocco #if defined(ESP32) sposta automaticamente i pin su GPIO 25, 26, 27 e 4. Le versioni 2.x e 3.x del core ESP32 includono tone(), che dietro le quinte usa l'unità PWM LEDC. Poiché i pin dell'ESP32 forniscono 3,3 V, il suono è un po' più basso che su Arduino Uno. Il breve sketch qui sotto sfrutta i pin touch dell'ESP32: tocca una stella di alluminio collegata a GPIO 32 e suonerà la prima frase di Jingle Bells mentre il LED si accende. Il codice misura all'avvio il valore a riposo e imposta la soglia da solo; trovi altri dettagli sui pin touch in pin touch dell'ESP32.
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}Canzoni di Natale con Raspberry Pi Pico e MicroPython
Il Pico non ha tone(), ma machine.PWM fa lo stesso lavoro: freq() imposta la frequenza della nota e duty_u16(32768) un duty cycle del 50%, quello che dà al buzzer il suono più forte. duty_u16(0) lo zittisce. Lo script suona due canzoni di fila; se premi il pulsante su GP2, la canzone in corso si interrompe e parte la successiva. Puoi aggiungere le altre due canzoni nello stesso formato con i numeri dello sketch Arduino; frequenze e durate sono identiche. Se sei alle prime armi con MicroPython, guarda prima l'installazione di Thonny in Che cos'è il 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)Più volume e un suono migliore
- Transistor e altoparlante: Dal pin passa per una resistenza da 1 kΩ fino alla base di un transistor NPN (2N2222, BC337), collega l'altoparlante tra 5 V e collettore e l'emettitore a GND. Un piccolo altoparlante da 8 Ω suona molto più pieno di un buzzer; una resistenza in serie da 47–100 Ω limita la corrente.
- Gamma di risonanza: I piccoli buzzer piezo suonano più forte tra 2 e 4 kHz. Spostare la melodia un'ottava più su alza chiaramente il volume, anche se non quanto un transistor.
- Effetto cassa: Mettere il buzzer dentro una scatola di cartone o una pallina dell'albero, con il foro verso l'esterno, rinforza il suono in modo naturale.
- Per abbassare il volume: In un progetto che funziona di notte, metti una resistenza da 100–470 Ω in serie al buzzer; il volume cala e la melodia resta intatta.
- Una sola voce: Su Arduino Uno tone() genera suono su un solo pin alla volta. Per accordi o musica a due voci è più adatto un modulo MP3 come il DFPlayer Mini; confrontiamo le opzioni in progetti musicali con Arduino.
Errori comuni e soluzioni
| Problema | Causa | Soluzione |
|---|---|---|
| Sempre lo stesso bip | Stai usando un buzzer attivo | Monta un buzzer passivo; appoggiato a una pila deve fare clic |
| Melodia irriconoscibile, note sfasate | Gli array melody e beats hanno lunghezze diverse | Pareggia il numero di elementi e controlla battuta per battuta |
| Note ripetute suonano come una sola | Nessun silenzio tra le note | Imposta la durata di tone() al 90% della nota |
| Il LED su D3 o D11 sfarfalla | tone() usa il Timer2 | Sposta il LED su un altro pin, come D6 o D7 |
| Una pressione salta più canzoni | Rimbalzo del pulsante | Rileva il fronte di discesa e blocca per 250 ms |
| 'tone' was not declared su ESP32 | Core ESP32 molto vecchio (1.x) | Aggiorna a 2.x o 3.x dal Gestore schede |
| Sul Pico il suono non si ferma a fine canzone | Manca duty_u16(0) | Chiama duty_u16(0) dopo ogni nota e alla fine |
Idee di progetti con le canzoni di Natale
- Rilevatore di Babbo Natale: Quando un sensore PIR vede un movimento davanti al camino, suona Jingle Bells; il montaggio è in rilevatore di Babbo Natale.
- Albero di Natale musicale: Fai cambiare i colori di una striscia WS2812B a tempo con le note; per l'albero vedi luci per l'albero di Natale.
- Melodia di mezzanotte: Suona We Wish You a Merry Christmas quando il conto alla rovescia di Capodanno arriva a zero.
- Campanello: Per tutto dicembre, quando si preme il campanello suona la prima frase di Deck the Halls al posto del solito din-don.
- Pianoforte a pulsanti: Suona tu stesso queste note con otto pulsanti; circuito e codice sono in pianoforte con Arduino. Per altre idee di stagione, sfoglia l'elenco dei progetti Arduino di Natale.
Se vuoi suonare la tua prima melodia con un buzzer, i progetti gratuiti con il buzzer nell'app BlueGrays ti portano dal primo bip al controllo della frequenza fino a una melodia d'inno completa, ognuno con schema del circuito, collegamenti passo passo e codice pronto. Con le abitudini che acquisisci lì, aggiungerai facilmente le quattro canzoni di Natale di questo articolo al tuo carillon o biglietto di Natale.
Domande frequenti
Come si suona Jingle Bells con Arduino?
Collega il piedino + del buzzer passivo a D8 e l'altro a GND, poi scrivi le frequenze delle note in un array e le durate in un altro. Nel ciclo chiama tone(8, frequenza, durata) per ogni nota e attendi con delay(durata). Il ritornello inizia con mi mi mi, mi mi mi, mi sol do re mi, e a 120 BPM una croma dura 250 ms.
Si possono suonare canzoni di Natale con un buzzer attivo?
No. Un buzzer attivo contiene un oscillatore a frequenza fissa e suona sempre sulla stessa nota, qualunque cosa gli invii. Per le melodie serve un buzzer passivo, un disco piezo o un piccolo altoparlante pilotato da un transistor.
Come si usa la funzione tone() di Arduino?
tone(pin, frequenza) genera sul pin un'onda quadra con duty cycle del 50% e suona finché non chiami noTone(pin). Se passi i millisecondi come terzo parametro, il suono si interrompe da solo allo scadere del tempo. Su Arduino Uno tone() usa il Timer2, quindi mentre suona il PWM su D3 e D11 non funziona.
Come si alza il volume di un buzzer?
Il modo più efficace è pilotare un transistor NPN dal pin tramite una resistenza da 1 kΩ e alimentare un piccolo altoparlante dai 5 V attraverso il transistor. Senza transistor aiuta anche spostare la melodia un'ottava più su, perché i buzzer piezo suonano più forte tra 2 e 4 kHz. Mettere il buzzer in uno spazio chiuso, come una scatola, aumenta ulteriormente il suono.
Arduino può fare altro mentre suona una canzone?
Mentre suona una melodia scritta con delay(), Arduino non può fare nient'altro. Se controlli con millis() quando finisce ogni nota, loop() riparte senza aspettare e leggere pulsanti, accendere LED o misurare sensori continua a funzionare mentre la canzone va avanti.
Il Raspberry Pi Pico ha la funzione tone()?
MicroPython non ha tone(), ma machine.PWM fa lo stesso lavoro. Su un oggetto PWM(Pin(15)) imposti la nota con freq(frequenza) e il duty cycle del 50% con duty_u16(32768); duty_u16(0) lo zittisce. Le frequenze delle note sono esattamente le stesse di Arduino.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Uso del cicalino
Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa. Vedi come l'elettricità diventa suono e fai il pri
Impostazione della frequenza con cicalino
Comandi il suono di un buzzer con quattro pulsanti: uno avvia il suono, uno lo zittisce e gli altri due lo rendono più acuto o più grave. Tieni premuto il pulsante su o giù e il tono cambia passo dopo
Inno nazionale turco con cicalino
Premi il pulsante e un piccolo buzzer comincia a suonare l'inno nazionale turco, nota dopo nota. L'Arduino suona ogni nota all'altezza e con la durata giuste, esegue due strofe dell'inno dall'inizio a
Suonare melodie con telecomando IR e cicalino
Costruisci un carillon che suona melodie con i tasti del telecomando della TV. Un ricevitore a infrarossi cattura il segnale del telecomando; un tasto fa suonare al cicalino una vivace musica da video
Pianoforte semplice con cicalino e pulsante
Costruisci il tuo piccolo pianoforte con otto pulsanti. Ogni pulsante è una nota, dalla più grave alla più acuta: do, re, mi, fa, sol, la, si e il do acuto. La nota suona nel cicalino finché tieni pre
ESP32 Riproduzione di melodia con cicalino
Riproduzione di una semplice melodia (Twinkle Twinkle Little Star) con un buzzer passivo. Le note vengono riprodotte con le funzioni tone() e noTone() come in Arduino - la stessa sintassi funziona con ESP32 Arduino Core 3.0+. È necessario utilizzare un cicalino passivo (il cicalino attivo non riproduce la melodia).
Arduino Test di Reazione con Segnale Acustico: Misura i tuoi Riflessi in Millisecondi (LCD + Buzzer + 3 LED)
Quanto sono veloci i tuoi riflessi? Premi il pulsante: il LED rosso dice ai vostri posti, il giallo pronti e parte un'attesa casuale da 1,5 a 3,5 secondi. Appena si accende il LED verde e il buzzer suona, premi di nuovo; il tuo tempo di reazione compare in millisecondi sul display LCD I2C, con il record della sessione e la media sotto. Se premi prima del verde, il display mostra TOO EARLY! e senti un suono di sconfitta. Tieni premuto: nuovo giocatore, stesso ordine di attese.