Jingle Bells no Arduino: código de 4 músicas de Natal para buzzer
Código de Jingle Bells no Arduino, além de We Wish You a Merry Christmas, Silent Night e Deck the Halls em um buzzer passivo: tabela de notas, tempo e um player com LEDs usando millis.
Para tocar Jingle Bells no Arduino, você só precisa de um buzzer passivo e da função tone(): você escreve a frequência e a duração de cada nota em um array, e o Arduino as envia ao buzzer uma a uma. Neste post você encontra arrays de notas e durações corretos para Jingle Bells, We Wish You a Merry Christmas, Silent Night e Deck the Halls, tirados da partitura e não adivinhados de ouvido. As quatro melodias são peças tradicionais com bem mais de cem anos, então você pode usá-las em qualquer projeto sem se preocupar com direitos autorais.
Vamos começar com um sketch curto de uma música só e depois passar para uma caixinha de música que toca as quatro músicas em sequência, pisca dois LEDs junto com as notas e troca de música com um botão. Esse segundo sketch usa millis() em vez de delay(), então, enquanto a música toca, ele continua cuidando de outras tarefas, como botões, sensores ou uma fita de LED. No final, levamos as mesmas melodias para um cartão de Natal ativado por toque com ESP32 e para MicroPython em um Raspberry Pi Pico.
Qual buzzer você precisa: ativo ou passivo?
Um buzzer ativo tem um oscilador próprio dentro dele; ligue-o em 5 V e ele apita sempre no mesmo tom, então não consegue tocar uma melodia. Um buzzer passivo funciona como um alto-falante minúsculo: ele soa na frequência em que o pino do Arduino liga e desliga. O jeito fácil de diferenciar os dois é encostar o buzzer por um instante em uma pilha de 3–5 V: um bipe contínuo indica ativo; um único clique, passivo. Os modelos ativos costumam ter um adesivo branco e a parte de baixo fechada, enquanto os passivos mostram uma placa de circuito verde embaixo. Para mais detalhes, veja O que é buzzer?.
| Característica | Buzzer ativo | Buzzer passivo |
|---|---|---|
| Oscilador interno | Sim | Não |
| Toca melodias? | Não, um tom só | Sim, qualquer nota com tone() |
| Comando de acionamento | digitalWrite() | tone(pino, frequência, duração) |
| Encostado em uma pilha | Bipe contínuo | Um clique |
| Faixa mais alta | Fixa (geralmente 2–2,5 kHz) | Cerca de 2–4 kHz (ressonância) |
Ligações: buzzer, dois LEDs e um botão
| Componente | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Buzzer passivo + | D8 | GPIO 25 | GP15 |
| Buzzer passivo − | GND | GND | GND |
| LED 1 (com 220 Ω) | D6 | GPIO 26 | GP14 |
| LED 2 (com 220 Ω) | D7 | GPIO 27 | GP13 |
| Botão (outro terminal no GND) | D2 | GPIO 4 | GP2 |
| Folha de toque | - | GPIO 32 (T9) | - |
Frequências das notas: as 14 notas usadas nestas músicas de Natal
Na música ocidental, cada oitava é dividida em 12 semitons, e subir um semitom multiplica a frequência pela raiz 12ª de 2, cerca de 1,0595. A nota de referência Lá4 (A4) tem 440 Hz; uma nota com número MIDI n tem a frequência f = 440 × 2^((n − 69) / 12). Por exemplo, Dó5 (C5) é o MIDI 72: 440 × 2^(3/12) = 523,25 Hz. Subir uma oitava dobra exatamente a frequência, e é por isso que o Dó6 (C6) tem 1047 Hz. Buzzers passivos pequenos soam fracos abaixo de 500 Hz, então passamos as quatro músicas para a 5ª e a 6ª oitavas; a tabela lista todas as notas que o código usa.
| Nota | Nome | Frequência (Hz) | Constante no código |
|---|---|---|---|
| B4 | Si | 494 | NOTE_B4 |
| C5 | Dó | 523 | NOTE_C5 |
| D5 | Ré | 587 | NOTE_D5 |
| E5 | Mi | 659 | NOTE_E5 |
| F5 | Fá | 698 | NOTE_F5 |
| F#5 | Fá sustenido | 740 | NOTE_FS5 |
| G5 | Sol | 784 | NOTE_G5 |
| A5 | Lá | 880 | NOTE_A5 |
| A#5 / Bb5 | Si bemol | 932 | NOTE_AS5 |
| B5 | Si | 988 | NOTE_B5 |
| C6 | Dó | 1047 | NOTE_C6 |
| D6 | Ré | 1175 | NOTE_D6 |
| E6 | Mi | 1319 | NOTE_E6 |
| F6 | Fá | 1397 | NOTE_F6 |
Tempo e duração das notas
Em vez de escrever cada duração em milissegundos, usamos a nota mais curta, a colcheia, como unidade: 1 é uma colcheia, 2 uma semínima, 3 uma semínima pontuada, 4 uma mínima, 6 uma mínima pontuada e 8 uma semibreve. O tempo é o número de semínimas por minuto (BPM); uma semínima dura 60000 / BPM milissegundos e a colcheia, metade disso. A 120 BPM, a semínima tem 500 ms e a colcheia, 250 ms. Para mudar a velocidade de uma música, basta alterar a duração da colcheia, sem mexer nos arrays. Cada nota soa por 90% da sua duração e os últimos 10% ficam em silêncio, para que notas repetidas (como os três Mi de Jingle Bells) não se misturem em um único som longo.
| Música | Compasso | Tempo | Colcheia (ms) | Semínima (ms) | Notas |
|---|---|---|---|---|---|
| Jingle Bells (refrão) | 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 | cerca de 130 BPM | 230 | 460 | 68 |
Primeiro sketch: o refrão de Jingle Bells
- Ligue o terminal + do buzzer passivo no D8 e o outro terminal no GND.
- Abra a Arduino IDE, cole o código abaixo e selecione Arduino Uno como placa.
- Carregue o código; o refrão toca uma vez assim que a placa liga. Aperte o botão de reset para ouvir de novo.
- Se estiver lento ou rápido demais, mude o EIGHTH_MS: 200 toca mais rápido, 300 mais devagar.
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}O sketch mantém dois arrays paralelos: melody guarda as frequências das notas e beats a duração de cada nota, em colcheias, na mesma ordem. Para cada nota, o laço inicia o som com tone() e espera a duração completa da nota com delay(). Quando o tone() recebe uma duração como terceiro argumento, ele mesmo corta o som; como passamos 90% da duração da nota, fica uma pequena respiração entre as notas. Os dois arrays precisam ter o mesmo número de elementos; se você adicionar uma nota em um e esquecer a duração no outro, a melodia se desloca e valores aleatórios da memória depois do fim do array são tocados. Os espaços nos arrays coincidem com as barras de compasso, o que facilita comparar as notas com a partitura.
Arrays de notas das quatro músicas
A tabela abaixo mostra a tonalidade de cada música e as notas da primeira frase; ela ajuda quando você confere o código de ouvido. Um traço (–) é uma barra de compasso e um ponto (.) indica nota pontuada. We Wish You a Merry Christmas começa com uma anacruse (pickup): o primeiro Dó5 é uma semínima sozinha antes do primeiro compasso. Silent Night é lenta e ampla, então seguramos o Dó5 final por 12 colcheias, dois compassos inteiros. O único sustenido de Deck the Halls é o Fá sustenido (F#5) na subida do “fa-la-la”.
| Música | Tonalidade | Notas da primeira frase | Atenção |
|---|---|---|---|
| Jingle Bells | Dó maior | Mi Mi Mi – Mi Mi Mi – Mi Sol Dó. Ré – Mi | Semínima pontuada + colcheia em “all the way” |
| We Wish You a Merry Christmas | Fá maior | Dó – Fá Fá Sol Fá Mi – Ré Ré Ré | Compasso 3/4, usa Si bemol (A#5) |
| Silent Night | Dó maior (uma oitava acima) | Sol. Lá Sol – Mi – Sol. Lá Sol – Mi | Tempo lento, mínimas pontuadas |
| Deck the Halls | Dó maior | Sol. Fá Mi Ré – Dó Ré Mi Dó | Colcheias do “fa-la-la”, Fá sustenido (F#5) |
Player de músicas de Natal com LEDs usando millis (4 músicas + botão)
Agora juntamos as quatro músicas em um único sketch. As notas ficam em uma struct Note de pares {frequência, duração} e são guardadas na memória flash com PROGMEM; o Uno tem só 2 KB de RAM, então ler 195 notas da flash em vez de mantê-las na RAM é um bom hábito. Os LEDs se alternam a cada nota, o botão no D2 usa o pull-up interno e, ao ser apertado, pula para a próxima música. Quando uma música termina, há 1,5 segundo de silêncio antes de a próxima começar.
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}O coração do código é a verificação de tempo dentro do loop(): se millis() − noteStart já passou da duração da nota, a próxima nota começa; se não, o loop continua sem esperar. Assim, o botão é lido a cada ciclo e nenhum aperto se perde; com delay(), o botão não reagiria durante a nota final de 4,8 segundos de Silent Night. O memcpy_P() copia uma nota da flash para uma variável temporária na RAM. Quando uma música termina, noteIndex fica igual ao número de notas e esse valor é usado como estado de “pausa”; quando a pausa acaba, nextSong() é chamada. O sketch compilado usa cerca de 3,9 KB de flash e 67 bytes de RAM em um Uno. Para entender melhor por que escolhemos millis() em vez de delay(), leia millis vs delay.
Músicas de Natal no ESP32: um cartão de Natal ativado por toque
O sketch do player acima também compila sem mudanças no ESP32: o bloco #if defined(ESP32) troca os pinos automaticamente para GPIO 25, 26, 27 e 4. As versões 2.x e 3.x do core do ESP32 incluem o tone(), que usa a unidade PWM LEDC por trás. Como os pinos do ESP32 fornecem 3,3 V, o som fica um pouco mais baixo que no Uno. O sketch curto abaixo usa os pinos de toque do ESP32: toque em uma estrela de papel-alumínio ligada ao GPIO 32 e a primeira frase de Jingle Bells toca enquanto o LED acende. O código mede o valor sem toque na inicialização e define o limite sozinho; você encontra mais sobre pinos de toque em pinos de toque do 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}Músicas de Natal no Raspberry Pi Pico com MicroPython
O Pico não tem tone(), mas o machine.PWM faz o mesmo trabalho: freq() define a frequência da nota e duty_u16(32768) define um ciclo de trabalho de 50%, que dá ao buzzer o som mais alto. duty_u16(0) silencia. O script toca duas músicas em sequência; aperte o botão no GP2 e a música atual para e a próxima começa. Você pode adicionar as outras duas músicas no mesmo formato usando os números do sketch do Arduino; frequências e durações são idênticas. Se você é novo no MicroPython, comece pela instalação do Thonny em O que é o 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)Aumentar o volume e melhorar o som
- Transistor e alto-falante: Saia do pino por um resistor de 1 kΩ até a base de um transistor NPN (2N2222, BC337), ligue o alto-falante entre 5 V e o coletor, e o emissor no GND. Um alto-falante pequeno de 8 Ω soa muito mais encorpado que um buzzer; um resistor em série de 47–100 Ω limita a corrente.
- Faixa de ressonância: Buzzers piezo pequenos soam mais alto por volta de 2–4 kHz. Subir a melodia uma oitava deixa o som claramente mais alto, embora não tanto quanto um transistor.
- Efeito da caixa: Colocar o buzzer dentro de uma caixa de papelão ou de uma bola de Natal, com o furo virado para fora, reforça o som naturalmente.
- Para deixar mais baixo: Em um projeto que funciona à noite, coloque um resistor de 100–470 Ω em série com o buzzer; o volume cai e a melodia continua intacta.
- Uma voz só: No Uno, o tone() gera som em apenas um pino por vez. Para acordes ou música a duas vozes, um módulo MP3 como o DFPlayer Mini é mais adequado; comparamos as opções em projetos de música com Arduino.
Problemas comuns e soluções
| Problema | Causa | Solução |
|---|---|---|
| Sempre o mesmo bipe | Você está usando um buzzer ativo | Use um buzzer passivo; ele deve dar um clique ao ser encostado em uma pilha |
| Melodia irreconhecível, notas deslocadas | Os arrays melody e beats têm tamanhos diferentes | Iguale o número de elementos e confira compasso por compasso |
| Notas repetidas soam como um som longo | Não há silêncio entre as notas | Faça a duração do tone() ser 90% da nota |
| LED no D3 ou D11 cintila | O tone() usa o Timer2 | Passe o LED para outro pino, como D6 ou D7 |
| Um aperto pula várias músicas | Repique do botão (bounce) | Detecte a borda de descida e adicione um bloqueio de 250 ms |
| 'tone' was not declared no ESP32 | Core do ESP32 muito antigo (1.x) | Atualize para 2.x ou 3.x no Gerenciador de Placas |
| No Pico, o som não para depois da música | duty_u16(0) não foi chamado | Chame duty_u16(0) depois de cada nota e no final |
Ideias de projetos com músicas de Natal
- Detector de Papai Noel: Quando um sensor PIR detectar movimento em frente à lareira, toque Jingle Bells; a montagem está em detector de Papai Noel.
- Árvore de Natal musical: Mude as cores de uma fita WS2812B conforme as notas enquanto a música toca; para a árvore em si, veja LEDs para árvore de Natal.
- Melodia da meia-noite: Toque We Wish You a Merry Christmas quando o contador regressivo de Ano-Novo chegar a zero.
- Campainha: Durante todo o mês de dezembro, toque a primeira frase de Deck the Halls em vez do ding-dong de sempre quando o botão da campainha for apertado.
- Piano de botões: Toque você mesmo essas notas com oito botões; o circuito e o código estão em piano com Arduino. Para mais ideias da época, confira a lista de projetos de Natal com Arduino.
Se você quer tocar sua primeira melodia em um buzzer, os projetos grátis de buzzer do app BlueGrays levam você do primeiro bipe ao controle de frequência e a uma melodia completa de hino nacional; cada um vem com esquema do circuito, ligações passo a passo e código pronto para rodar. Com os hábitos que você pega por lá, fica fácil adicionar as quatro músicas de Natal deste post à sua própria caixinha de música ou cartão de Natal.
Perguntas frequentes
Como tocar Jingle Bells no Arduino?
Ligue o terminal + do buzzer passivo no D8 e o outro terminal no GND, depois escreva as frequências das notas em um array e as durações em outro. No laço, chame tone(8, frequência, duração) para cada nota e espere com delay(duração). O refrão começa com Mi Mi Mi, Mi Mi Mi, Mi Sol Dó Ré Mi e, a 120 BPM, uma colcheia dura 250 ms.
Um buzzer ativo consegue tocar músicas de Natal?
Não. Um buzzer ativo tem um oscilador de frequência fixa dentro dele e apita no mesmo tom, não importa o que você envie. Para melodias, você precisa de um buzzer passivo, um disco piezo ou um alto-falante pequeno acionado por um transistor.
Como usar a função tone() do Arduino?
tone(pino, frequência) gera uma onda quadrada com ciclo de trabalho de 50% no pino e continua tocando até noTone(pino) ser chamada. Se você passar milissegundos como terceiro argumento, o som para sozinho ao fim desse tempo. No Uno, o tone() usa o Timer2, então o PWM no D3 e no D11 para de funcionar enquanto ele toca.
Como deixar um buzzer mais alto?
A forma mais eficaz é acionar um transistor NPN a partir do pino por um resistor de 1 kΩ e alimentar um alto-falante pequeno com 5 V através do transistor. Sem transistor, subir a melodia uma oitava também ajuda, porque buzzers piezo soam mais alto por volta de 2–4 kHz. Colocar o buzzer em um espaço fechado, como uma caixa, também reforça o som.
O Arduino consegue fazer outras coisas enquanto uma música toca?
Enquanto uma melodia escrita com delay() está tocando, o Arduino não consegue fazer mais nada. Se você verificar com millis() quando cada nota termina, o loop() retorna sem esperar, então ler botões, acender LEDs ou fazer leituras de sensores continua funcionando enquanto a música segue.
O Raspberry Pi Pico tem tone()?
O MicroPython não tem tone(), mas o machine.PWM faz o mesmo trabalho. Em um objeto PWM(Pin(15)), você define a nota com freq(frequência) e um ciclo de trabalho de 50% com duty_u16(32768); duty_u16(0) silencia. As frequências das notas são exatamente as mesmas do Arduino.
Projetos para montar depois desta leitura
Ver todos os projetos
Uso do buzzer
Já se perguntou como uma campainha ou um alarme produz som? O Arduino faz um pequeno buzzer emitir bipes em intervalos curtos: bipe, pausa, bipe, pausa. Você vê como a eletricidade produz som e dá o p
Ajuste de frequência com buzzer
Você controla o som de um buzzer com quatro botões: um inicia o som, outro o interrompe e os outros dois o deixam mais agudo ou mais grave. Mantenha pressionado o botão de aumentar ou diminuir, e o to
Hino nacional da Turquia com buzzer
Pressione o botão e um pequeno buzzer começa a tocar o hino nacional da Turquia, nota por nota. O Arduino toca cada nota na altura e na duração certas, executando duas estrofes do hino do início ao fi
Tocar melodias com receptor IR, controle remoto e buzzer
Monte uma caixinha de música que toca melodias com os botões de um controle de TV. Um receptor infravermelho capta o sinal do controle; um botão faz o buzzer tocar uma música animada de videogame, out
Piano simples com buzzer e botões
Monte seu próprio piano com oito botões. Cada botão corresponde a uma nota, da mais grave à mais aguda: dó, ré, mi, fá, sol, lá, si e dó agudo. A nota toca no buzzer enquanto você mantém o botão press
Melodia com buzzer e ESP32
Toque uma melodia simples (Brilha, brilha, estrelinha) com um buzzer passivo. Usamos as funções tone() e noTone() para tocar as notas, como no Arduino. A mesma sintaxe funciona com ESP32 Arduino Core 3.0+. É preciso usar um buzzer passivo, pois o ativo não toca melodias.
Teste de reação com Arduino e aviso sonoro: meça seus reflexos em milissegundos (LCD + buzzer + 3 LEDs)
Seus reflexos são rápidos? Aperte o botão: o LED vermelho diz preparar, o amarelo diz apontar e começa uma espera aleatória de 1,5 a 3,5 segundos. Assim que o LED verde acende e o buzzer apita, aperte de novo; seu tempo de reação aparece em milissegundos no LCD I2C, com seu recorde da sessão e sua média embaixo. Apertou antes do verde? A tela mostra TOO EARLY! e toca um som de derrota. Segure o botão para um novo jogador com a mesma ordem de esperas.