Villancicos con Arduino y buzzer: Jingle Bells y 3 melodías
Villancicos con Arduino y buzzer pasivo: Jingle Bells, Noche de paz, We Wish You a Merry Christmas y Deck the Halls con tabla de notas, tempo y reproductor LED.
Para tocar villancicos con Arduino solo necesitas un buzzer pasivo y la función tone(): escribes la frecuencia y la duración de cada nota en un array y Arduino las envía al buzzer una tras otra. En este artículo encontrarás arrays de notas y duraciones correctos para Jingle Bells (Navidad, Navidad), We Wish You a Merry Christmas, Noche de paz y Deck the Halls, sacados de la partitura y no adivinados de oído. Las cuatro melodías son piezas tradicionales de hace más de cien años, así que puedes usarlas en cualquier proyecto sin preocuparte por los derechos de autor.
Empezaremos con un sketch corto de una sola canción y después pasaremos a una caja de música que toca las cuatro canciones seguidas, hace parpadear dos LED con las notas y cambia de canción con un pulsador. Ese segundo sketch usa millis() en lugar de delay(), así que mientras suena la canción puede seguir atendiendo pulsadores, sensores o una tira LED. Al final llevamos las mismas melodías a una tarjeta navideña táctil con ESP32 y a MicroPython en una Raspberry Pi Pico.
¿Qué buzzer necesitas: activo o pasivo?
Un buzzer activo lleva su propio oscilador dentro; si le das 5 V siempre pita con el mismo tono, así que no puede tocar melodías. Un buzzer pasivo funciona como un altavoz diminuto: suena a la frecuencia con la que el pin de Arduino se enciende y se apaga. La forma fácil de distinguirlos es tocar un instante una pila de 3–5 V con el buzzer: un pitido continuo indica activo y un solo clic indica pasivo. Los modelos activos suelen llevar una pegatina blanca y tienen la base cerrada, mientras que en los pasivos se ve una placa verde por debajo. Para más detalles, consulta ¿Qué es un buzzer?.
| Característica | Buzzer activo | Buzzer pasivo |
|---|---|---|
| Oscilador interno | Sí | No |
| ¿Toca melodías? | No, un solo tono | Sí, cualquier nota con tone() |
| Comando | digitalWrite() | tone(pin, frecuencia, duración) |
| Al tocar una pila | Pitido continuo | Un solo clic |
| Rango más fuerte | Fijo (normalmente 2–2,5 kHz) | Unos 2–4 kHz (resonancia) |
Conexión: buzzer, dos LED y un pulsador
| Componente | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Buzzer pasivo + | D8 | GPIO 25 | GP15 |
| Buzzer pasivo − | GND | GND | GND |
| LED 1 (con 220 Ω) | D6 | GPIO 26 | GP14 |
| LED 2 (con 220 Ω) | D7 | GPIO 27 | GP13 |
| Pulsador (otra pata a GND) | D2 | GPIO 4 | GP2 |
| Papel de aluminio táctil | - | GPIO 32 (T9) | - |
Frecuencias de las notas: las 14 notas de estos villancicos
En la música occidental cada octava se divide en 12 semitonos, y subir un semitono multiplica la frecuencia por la raíz duodécima de 2, aproximadamente 1,0595. La nota de referencia la4 (A4) es 440 Hz; una nota con número MIDI n tiene la frecuencia f = 440 × 2^((n − 69) / 12). Por ejemplo, do5 (C5) es MIDI 72: 440 × 2^(3/12) = 523,25 Hz. Subir una octava duplica exactamente la frecuencia; por eso do6 es 1047 Hz. Los buzzers pasivos pequeños suenan débiles por debajo de 500 Hz, así que pasamos las cuatro canciones a las octavas 5 y 6; la tabla incluye todas las notas que usa el código.
| Nota | Solfeo | Frecuencia (Hz) | Constante del código |
|---|---|---|---|
| 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 sostenido | 740 | NOTE_FS5 |
| G5 | Sol | 784 | NOTE_G5 |
| A5 | La | 880 | NOTE_A5 |
| A#5 / Bb5 | Si bemol | 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 y duración de las notas
En lugar de escribir cada duración en milisegundos, tomamos como unidad la nota más corta, la corchea: 1 es una corchea, 2 una negra, 3 una negra con puntillo, 4 una blanca, 6 una blanca con puntillo y 8 una redonda. El tempo es el número de negras por minuto (BPM); una negra dura 60000 / BPM milisegundos y una corchea la mitad. A 120 BPM, la negra dura 500 ms y la corchea 250 ms. Para cambiar la velocidad de una canción solo cambias la duración de la corchea y no tocas los arrays. Cada nota suena el 90 % de su duración y el 10 % restante queda en silencio, así las notas repetidas (como los tres mi de Jingle Bells) no se funden en un único sonido largo.
| Canción | Compás | Tempo | Corchea (ms) | Negra (ms) | Notas |
|---|---|---|---|---|---|
| Jingle Bells (estribillo) | 4/4 | 120 BPM | 250 | 500 | 51 |
| We Wish You a Merry Christmas | 3/4 | 150 BPM | 200 | 400 | 30 |
| Noche de paz | 3/4 | 75 BPM | 400 | 800 | 46 |
| Deck the Halls | 4/4 | unos 130 BPM | 230 | 460 | 68 |
Primer sketch: el estribillo de Jingle Bells
- Conecta la pata + del buzzer pasivo a D8 y la otra a GND.
- Abre el Arduino IDE, pega el código de abajo y elige Arduino Uno como placa.
- Súbelo; el estribillo suena una vez en cuanto arranca la placa. Para oírlo otra vez, pulsa el botón de reset.
- Si suena demasiado lento o rápido, cambia EIGHTH_MS: 200 toca más rápido y 300 más 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}El sketch guarda dos arrays paralelos: melody con las frecuencias de las notas y beats con la duración de cada nota, en corcheas, en el mismo orden. Para cada nota, el bucle inicia el sonido con tone() y espera la duración completa con delay(). Cuando tone() recibe una duración como tercer parámetro, corta el sonido por sí solo; como le pasamos el 90 % de la nota, queda una breve respiración entre notas. Los dos arrays deben tener el mismo número de elementos; si añades una nota a uno y olvidas la duración en el otro, la melodía se desplaza y se toca memoria aleatoria más allá del final del array. Los espacios en los arrays coinciden con las barras de compás, así es fácil comparar las notas con la partitura.
Los arrays de notas de las cuatro canciones
La tabla muestra la tonalidad de cada canción y las notas de su primera frase; te servirá para comprobar el código de oído. El guion (–) es una barra de compás y el punto (.) una nota con puntillo. We Wish You a Merry Christmas empieza con una anacrusa: el primer do5 es una negra suelta antes del primer compás. Noche de paz es lenta y amplia, así que mantuvimos el último do5 durante 12 corcheas, dos compases enteros. La única nota alterada de Deck the Halls es el fa sostenido (F#5) en la subida del "fa-la-la".
| Canción | Tonalidad | Notas de la primera frase | Atención |
|---|---|---|---|
| Jingle Bells | Do mayor | Mi Mi Mi – Mi Mi Mi – Mi Sol Do. Re – Mi | Negra con puntillo + corchea en "all the way" |
| We Wish You a Merry Christmas | Fa mayor | Do – Fa Fa Sol Fa Mi – Re Re Re | Compás de 3/4, usa si bemol (A#5) |
| Noche de paz | Do mayor (una octava arriba) | Sol. La Sol – Mi – Sol. La Sol – Mi | Tempo lento, blancas con puntillo |
| Deck the Halls | Do mayor | Sol. Fa Mi Re – Do Re Mi Do | Corcheas del "fa-la-la", fa sostenido (F#5) |
Reproductor de villancicos con millis y LED (4 canciones + pulsador)
Ahora juntamos las cuatro canciones en un solo sketch. Las notas van en una estructura Note de pares {frecuencia, duración} y se guardan en la flash con PROGMEM; el Uno solo tiene 2 KB de RAM, así que leer 195 notas desde la flash en vez de tenerlas en RAM es un buen hábito. Los LED se alternan en cada nota, el pulsador en D2 usa el pull-up interno y cada pulsación salta a la siguiente canción. Al terminar una canción hay 1,5 segundos de silencio y luego empieza la siguiente.
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}El corazón del código es la comprobación de tiempo dentro de loop(): si millis() − noteStart ha superado la duración de la nota, empieza la siguiente; si no, loop sigue sin esperar. Así el pulsador se lee en cada vuelta y no se pierde ninguna pulsación; con delay(), el pulsador no respondería durante los 4,8 segundos de la última nota de Noche de paz. memcpy_P() copia una nota de la flash a una variable temporal en RAM. Cuando termina una canción, noteIndex es igual al número de notas y ese valor se usa como estado de "pausa"; al acabar la pausa se llama a nextSong(). El sketch compilado ocupa unos 3,9 KB de flash y 67 bytes de RAM en un Uno. Si quieres ver con más detalle por qué preferimos millis() a delay(), lee millis vs delay.
Villancicos con ESP32: una tarjeta navideña táctil
El sketch del reproductor también compila sin cambios en un ESP32: el bloque #if defined(ESP32) cambia los pines automáticamente a GPIO 25, 26, 27 y 4. Las versiones 2.x y 3.x del core de ESP32 incluyen tone(), que por debajo usa la unidad PWM LEDC. Como los pines del ESP32 dan 3,3 V, suena algo más bajo que en un Uno. El sketch corto de abajo aprovecha los pines táctiles del ESP32: toca una estrella de papel de aluminio conectada a GPIO 32 y sonará la primera frase de Jingle Bells mientras se enciende el LED. El código mide al arrancar el valor sin tocar y fija el umbral él solo; tienes más información sobre los pines táctiles en pines táctiles del 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}Villancicos con Raspberry Pi Pico y MicroPython
La Pico no tiene tone(), pero machine.PWM hace lo mismo: freq() fija la frecuencia de la nota y duty_u16(32768) un ciclo de trabajo del 50 %, que es el que da el sonido más fuerte al buzzer. duty_u16(0) lo silencia. El script toca dos canciones seguidas; si pulsas el botón de GP2, la canción actual se corta y empieza la siguiente. Puedes añadir las otras dos canciones con el mismo formato usando los números del sketch de Arduino; las frecuencias y duraciones son idénticas. Si eres nuevo en MicroPython, mira primero la instalación de Thonny en ¿Qué es la 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)Más volumen y mejor sonido
- Transistor y altavoz: Ve desde el pin con una resistencia de 1 kΩ a la base de un transistor NPN (2N2222, BC337), conecta el altavoz entre 5 V y el colector y el emisor a GND. Un altavoz pequeño de 8 Ω suena mucho más lleno que un buzzer; una resistencia en serie de 47–100 Ω limita la corriente.
- Rango de resonancia: Los buzzers piezo pequeños suenan más fuerte entre 2 y 4 kHz. Subir la melodía una octava aumenta claramente el volumen, aunque no tanto como un transistor.
- Efecto caja: Colocar el buzzer dentro de una caja de cartón o una bola del árbol, con el agujero hacia fuera, refuerza el sonido de forma natural.
- Para bajar el volumen: En un proyecto que funcione de noche, pon una resistencia de 100–470 Ω en serie con el buzzer; baja el volumen y la melodía se mantiene.
- Una sola voz: En el Uno, tone() solo genera sonido en un pin a la vez. Para acordes o música a dos voces encaja mejor un módulo MP3 como el DFPlayer Mini; comparamos las opciones en proyectos de música con Arduino.
Errores comunes y soluciones
| Problema | Causa | Solución |
|---|---|---|
| Siempre el mismo pitido | Estás usando un buzzer activo | Pon un buzzer pasivo; al tocar una pila debe hacer clic |
| Melodía irreconocible, notas desplazadas | Los arrays melody y beats tienen distinta longitud | Iguala el número de elementos y revisa compás a compás |
| Notas repetidas suenan como una sola | No hay silencio entre notas | Pon la duración de tone() al 90 % de la nota |
| El LED de D3 o D11 parpadea | tone() usa el Timer2 | Mueve el LED a otro pin, como D6 o D7 |
| Una pulsación salta varias canciones | Rebote del pulsador | Detecta el flanco de bajada y bloquea 250 ms |
| 'tone' was not declared en ESP32 | Core de ESP32 muy antiguo (1.x) | Actualiza a 2.x o 3.x en el Gestor de placas |
| En la Pico el sonido no para al acabar | Falta duty_u16(0) | Llama a duty_u16(0) tras cada nota y al final |
Ideas de proyectos con villancicos
- Detector de Papá Noel: Cuando un sensor PIR vea movimiento delante de la chimenea, que suene Jingle Bells; el montaje está en detector de Papá Noel.
- Árbol de Navidad musical: Haz que los colores de una tira WS2812B cambien con las notas mientras suena la canción; para el árbol, consulta luces del árbol de Navidad.
- Melodía de medianoche: Que suene We Wish You a Merry Christmas cuando la cuenta atrás de Año Nuevo llegue a cero.
- Timbre: Durante todo diciembre, que el timbre toque la primera frase de Deck the Halls en lugar del habitual din-don.
- Piano de pulsadores: Toca tú mismo estas notas con ocho pulsadores; el circuito y el código están en piano con Arduino. Para más ideas de temporada, mira la lista de proyectos navideños con Arduino.
Si quieres tocar tu primera melodía con un buzzer, los proyectos de buzzer gratuitos de la app BlueGrays te llevan del primer pitido al control de frecuencia y a una melodía de himno completa, cada uno con esquema del circuito, conexión paso a paso y código listo. Con los hábitos que adquieras ahí, añadirás fácilmente los cuatro villancicos de este artículo a tu propia caja de música o tarjeta navideña.
Preguntas frecuentes
¿Cómo se toca Jingle Bells con Arduino?
Conecta la pata + del buzzer pasivo a D8 y la otra a GND, y escribe las frecuencias de las notas en un array y sus duraciones en otro. En el bucle, llama a tone(8, frecuencia, duración) para cada nota y espera con delay(duración). El estribillo empieza mi mi mi, mi mi mi, mi sol do re mi, y a 120 BPM una corchea dura 250 ms.
¿Se pueden tocar villancicos con un buzzer activo?
No. Un buzzer activo tiene dentro un oscilador de frecuencia fija y pita con el mismo tono le envíes lo que le envíes. Para melodías necesitas un buzzer pasivo, un disco piezoeléctrico o un altavoz pequeño con transistor.
¿Cómo se usa la función tone() de Arduino?
tone(pin, frecuencia) genera en el pin una onda cuadrada con ciclo de trabajo del 50 % y suena hasta que llamas a noTone(pin). Si le pasas milisegundos como tercer parámetro, el sonido se corta solo al final de ese tiempo. En el Uno, tone() usa el Timer2, por lo que el PWM de D3 y D11 deja de funcionar mientras suena.
¿Cómo subir el volumen de un buzzer?
Lo más eficaz es controlar un transistor NPN desde el pin con una resistencia de 1 kΩ y alimentar un altavoz pequeño desde 5 V a través del transistor. Sin transistor también ayuda subir la melodía una octava, porque los buzzers piezo suenan más fuerte entre 2 y 4 kHz. Meter el buzzer en un espacio cerrado como una caja también aumenta el sonido.
¿Puede Arduino hacer otras cosas mientras suena una canción?
Mientras suena una melodía escrita con delay(), Arduino no puede hacer nada más. Si compruebas con millis() cuándo termina cada nota, loop() vuelve sin esperar, y leer pulsadores, encender LED o medir sensores sigue funcionando mientras continúa la canción.
¿La Raspberry Pi Pico tiene tone()?
MicroPython no tiene tone(), pero machine.PWM hace lo mismo. En un objeto PWM(Pin(15)) fijas la nota con freq(frecuencia) y el 50 % de ciclo de trabajo con duty_u16(32768); duty_u16(0) lo silencia. Las frecuencias de las notas son exactamente las mismas que en Arduino.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Uso del zumbador
¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio. Ves cómo se crea sonido con electricidad y
Ajuste de frecuencia con zumbador
Controlas el sonido de un zumbador con cuatro botones: uno lo enciende, otro lo calla y los otros dos lo hacen más agudo o más grave. Si mantienes pulsado el botón de subir o bajar, el tono cambia pas
Himno nacional turco con zumbador
Pulsas el botón y un pequeño zumbador empieza a tocar el himno nacional de Turquía, nota a nota. El Arduino toca cada nota con la altura y la duración justas, interpreta dos estrofas del himno de prin
Reproducir melodías con mando IR y zumbador
Construye una caja de música que toca melodías con los botones del mando de la tele. Un receptor de infrarrojos capta la señal del mando; un botón hace sonar en el zumbador una melodía animada de vide
Piano sencillo con zumbador y botón
Monta tu propio pequeño piano con ocho botones. Cada botón es una nota, de grave a agudo: do, re, mi, fa, sol, la, si y el do agudo. La nota suena en el zumbador mientras mantienes el botón pulsado y
ESP32 Reproducción de melodías con zumbador
Tocando una melodía simple (Twinkle Twinkle Little Star) con un zumbador pasivo. Tocamos las notas con las funciones tone() y noTone() como en Arduino - la misma sintaxis funciona con ESP32 Arduino Core 3.0+. Se debe utilizar un zumbador pasivo (el zumbador activo no reproduce la melodía).
Arduino Test de Reacción con Aviso Sonoro: Mide tus Reflejos en Milisegundos (LCD + Zumbador + 3 LED)
¿Tienes buenos reflejos? Pulsa el botón: el LED rojo dice preparados, el amarillo dice listos y empieza una espera aleatoria de 1,5 a 3,5 segundos. En cuanto se enciende el LED verde y suena el zumbador, vuelve a pulsar; tu tiempo de reacción aparece en milisegundos en la LCD I2C, con tu récord de la sesión y tu media debajo. Si pulsas antes del verde, la pantalla muestra TOO EARLY! y suena un tono de derrota. Mantén pulsado para un nuevo jugador con las mismas esperas.