Vive le vent Arduino buzzer : 4 chants de Noël avec tone()
Vive le vent (Jingle Bells) sur Arduino avec un buzzer passif, plus Douce nuit, We Wish You a Merry Christmas et Deck the Halls : notes, tempo et lecteur à LED.
Pour jouer Vive le vent sur Arduino, il te suffit d'un buzzer passif et de la fonction tone() : tu écris la fréquence et la durée de chaque note dans un tableau, et l'Arduino les envoie au buzzer l'une après l'autre. Dans cet article, tu trouveras des tableaux de notes et de durées justes pour Jingle Bells (Vive le vent), We Wish You a Merry Christmas (Nous vous souhaitons un joyeux Noël), Douce nuit et Deck the Halls, relevés sur la partition et non devinés à l'oreille. Les quatre mélodies sont des airs traditionnels de plus de cent ans : tu peux les utiliser dans n'importe quel projet sans souci de droits d'auteur.
On commence par un court sketch pour une seule chanson, puis on passe à une boîte à musique qui enchaîne les quatre chants, fait clignoter deux LED au rythme des notes et change de morceau avec un bouton. Ce second sketch utilise millis() au lieu de delay() : pendant que la chanson joue, il peut donc continuer à gérer des boutons, des capteurs ou un ruban LED. Pour finir, on porte les mêmes mélodies sur une carte de Noël tactile avec l'ESP32 et en MicroPython sur la Raspberry Pi Pico.
Quel buzzer choisir : actif ou passif ?
Un buzzer actif contient son propre oscillateur ; dès que tu lui donnes 5 V, il sonne toujours sur la même note, il ne peut donc pas jouer de mélodie. Un buzzer passif fonctionne comme un minuscule haut-parleur : il sonne à la fréquence à laquelle la broche de l'Arduino s'allume et s'éteint. Pour les distinguer, touche brièvement une pile de 3 à 5 V avec le buzzer : un bip continu signifie actif, un simple clic signifie passif. Les modèles actifs portent souvent un autocollant blanc et ont un dessous fermé, alors qu'on voit un petit circuit vert sous les modèles passifs. Pour plus de détails, lis Qu'est-ce qu'un buzzer ?.
| Caractéristique | Buzzer actif | Buzzer passif |
|---|---|---|
| Oscillateur intégré | Oui | Non |
| Joue des mélodies ? | Non, une seule note | Oui, toutes les notes avec tone() |
| Commande | digitalWrite() | tone(broche, fréquence, durée) |
| Contre une pile | Bip continu | Un seul clic |
| Plage la plus forte | Fixe (souvent 2–2,5 kHz) | Environ 2–4 kHz (résonance) |
Câblage : buzzer, deux LED et un bouton
| Composant | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Buzzer passif + | D8 | GPIO 25 | GP15 |
| Buzzer passif − | GND | GND | GND |
| LED 1 (avec 220 Ω) | D6 | GPIO 26 | GP14 |
| LED 2 (avec 220 Ω) | D7 | GPIO 27 | GP13 |
| Bouton (autre patte à GND) | D2 | GPIO 4 | GP2 |
| Feuille d'aluminium tactile | - | GPIO 32 (T9) | - |
Fréquences des notes : les 14 notes de ces chants de Noël
Dans la musique occidentale, chaque octave est divisée en 12 demi-tons, et monter d'un demi-ton multiplie la fréquence par la racine douzième de 2, environ 1,0595. La note de référence la4 (A4) vaut 440 Hz ; une note de numéro MIDI n a pour fréquence f = 440 × 2^((n − 69) / 12). Par exemple, do5 (C5) est le MIDI 72 : 440 × 2^(3/12) = 523,25 Hz. Monter d'une octave double exactement la fréquence, c'est pourquoi do6 vaut 1047 Hz. Les petits buzzers passifs sonnent faiblement sous 500 Hz, on a donc placé les quatre chants dans les octaves 5 et 6 ; le tableau donne toutes les notes utilisées par le code.
| Note | Solfège | Fréquence (Hz) | Constante du code |
|---|---|---|---|
| B4 | Si | 494 | NOTE_B4 |
| C5 | Do | 523 | NOTE_C5 |
| D5 | Ré | 587 | NOTE_D5 |
| E5 | Mi | 659 | NOTE_E5 |
| F5 | Fa | 698 | NOTE_F5 |
| F#5 | Fa dièse | 740 | NOTE_FS5 |
| G5 | Sol | 784 | NOTE_G5 |
| A5 | La | 880 | NOTE_A5 |
| A#5 / Bb5 | Si bémol | 932 | NOTE_AS5 |
| B5 | Si | 988 | NOTE_B5 |
| C6 | Do | 1047 | NOTE_C6 |
| D6 | Ré | 1175 | NOTE_D6 |
| E6 | Mi | 1319 | NOTE_E6 |
| F6 | Fa | 1397 | NOTE_F6 |
Tempo et durée des notes
Plutôt que d'écrire chaque durée en millisecondes, on a pris comme unité la note la plus courte, la croche : 1 est une croche, 2 une noire, 3 une noire pointée, 4 une blanche, 6 une blanche pointée et 8 une ronde. Le tempo est le nombre de noires par minute (BPM) ; une noire dure 60000 / BPM millisecondes et une croche la moitié. À 120 BPM, la noire dure 500 ms et la croche 250 ms. Pour changer la vitesse d'un chant, tu modifies seulement la durée de la croche, sans toucher aux tableaux. Chaque note sonne pendant 90 % de sa durée et les 10 % restants sont silencieux : ainsi les notes répétées (comme les trois mi de Vive le vent) ne se fondent pas en un seul son long.
| Chant | Mesure | Tempo | Croche (ms) | Noire (ms) | Notes |
|---|---|---|---|---|---|
| Vive le vent (refrain) | 4/4 | 120 BPM | 250 | 500 | 51 |
| We Wish You a Merry Christmas | 3/4 | 150 BPM | 200 | 400 | 30 |
| Douce nuit | 3/4 | 75 BPM | 400 | 800 | 46 |
| Deck the Halls | 4/4 | environ 130 BPM | 230 | 460 | 68 |
Premier sketch : le refrain de Vive le vent
- Relie la patte + du buzzer passif à D8 et l'autre patte à GND.
- Ouvre l'Arduino IDE, colle le code ci-dessous et choisis Arduino Uno comme carte.
- Téléverse-le ; le refrain joue une fois dès que la carte démarre. Pour le réécouter, appuie sur le bouton reset.
- Si c'est trop lent ou trop rapide, modifie EIGHTH_MS : 200 joue plus vite, 300 plus lentement.
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}Le sketch garde deux tableaux parallèles : melody contient les fréquences des notes et beats la durée de chaque note, en croches, dans le même ordre. Pour chaque note, la boucle lance le son avec tone() et attend toute la durée de la note avec delay(). Quand tone() reçoit une durée en troisième paramètre, il coupe le son tout seul ; comme on lui passe 90 % de la note, il reste une courte respiration entre les notes. Les deux tableaux doivent avoir le même nombre d'éléments : si tu ajoutes une note dans l'un et oublies la durée dans l'autre, la mélodie se décale et de la mémoire aléatoire située après la fin du tableau est jouée. Les espaces dans les tableaux correspondent aux barres de mesure, ce qui facilite la comparaison avec la partition.
Les tableaux de notes des quatre chants
Le tableau ci-dessous indique la tonalité de chaque chant et les notes de sa première phrase ; il t'aidera à vérifier le code à l'oreille. Le tiret (–) est une barre de mesure et le point (.) une note pointée. We Wish You a Merry Christmas commence par une anacrouse : le premier do5 est une noire isolée avant la première mesure. Douce nuit est lente et ample, on a donc tenu le dernier do5 pendant 12 croches, soit deux mesures entières. La seule altération de Deck the Halls est le fa dièse (F#5) dans la montée du "fa-la-la".
| Chant | Tonalité | Notes de la première phrase | Attention |
|---|---|---|---|
| Vive le vent (Jingle Bells) | Do majeur | Mi Mi Mi – Mi Mi Mi – Mi Sol Do. Ré – Mi | Noire pointée + croche sur "all the way" |
| We Wish You a Merry Christmas | Fa majeur | Do – Fa Fa Sol Fa Mi – Ré Ré Ré | Mesure à 3/4, utilise le si bémol (A#5) |
| Douce nuit | Do majeur (une octave plus haut) | Sol. La Sol – Mi – Sol. La Sol – Mi | Tempo lent, blanches pointées |
| Deck the Halls | Do majeur | Sol. Fa Mi Ré – Do Ré Mi Do | Croches du "fa-la-la", fa dièse (F#5) |
Lecteur de chants de Noël avec millis et LED (4 chants + bouton)
On réunit maintenant les quatre chants dans un seul sketch. Les notes sont stockées dans une structure Note faite de paires {fréquence, durée} et rangées en mémoire flash avec PROGMEM ; l'Uno n'a que 2 Ko de RAM, lire les 195 notes depuis la flash au lieu de les garder en RAM est donc une bonne habitude. Les LED s'alternent à chaque note, le bouton sur D2 utilise le pull-up interne et chaque appui passe au chant suivant. À la fin d'un chant, il y a 1,5 seconde de silence, puis le suivant commence.
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}Le cœur du code est le test de temps dans loop() : si millis() − noteStart a dépassé la durée de la note, la note suivante démarre ; sinon, loop continue sans attendre. Le bouton est ainsi lu à chaque passage et aucun appui n'est perdu ; avec delay(), le bouton ne réagirait pas du tout pendant les 4,8 secondes de la dernière note de Douce nuit. memcpy_P() copie une note de la flash vers une variable temporaire en RAM. Quand un chant se termine, noteIndex est égal au nombre de notes et cette valeur sert d'état de "pause" ; une fois la pause écoulée, nextSong() est appelée. Le sketch compilé occupe environ 3,9 Ko de flash et 67 octets de RAM sur un Uno. Pour comprendre plus en détail pourquoi on préfère millis() à delay(), lis millis ou delay.
Chants de Noël avec l'ESP32 : une carte de Noël tactile
Le sketch du lecteur ci-dessus se compile aussi tel quel sur l'ESP32 : le bloc #if defined(ESP32) bascule automatiquement les broches sur GPIO 25, 26, 27 et 4. Les versions 2.x et 3.x du core ESP32 intègrent tone(), qui utilise en coulisse l'unité PWM LEDC. Comme les broches de l'ESP32 délivrent 3,3 V, le son est un peu plus faible que sur un Uno. Le court sketch ci-dessous exploite les broches tactiles de l'ESP32 : touche une étoile en papier aluminium reliée à GPIO 32 et la première phrase de Vive le vent se joue pendant que la LED s'allume. Le code mesure au démarrage la valeur au repos et fixe le seuil tout seul ; tu trouveras plus d'infos dans les broches tactiles de l'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}Chants de Noël avec la Raspberry Pi Pico et MicroPython
La Pico n'a pas de tone(), mais machine.PWM fait la même chose : freq() règle la fréquence de la note et duty_u16(32768) un rapport cyclique de 50 %, celui qui donne le son le plus fort au buzzer. duty_u16(0) coupe le son. Le script joue deux chants à la suite ; si tu appuies sur le bouton GP2, le chant en cours s'arrête et le suivant commence. Tu peux ajouter les deux autres chants au même format avec les nombres du sketch Arduino ; les fréquences et durées sont identiques. Si tu débutes en MicroPython, regarde d'abord l'installation de Thonny dans Qu'est-ce que 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)Plus de volume et un meilleur son
- Transistor et haut-parleur : Pars de la broche avec une résistance de 1 kΩ vers la base d'un transistor NPN (2N2222, BC337), branche le haut-parleur entre le 5 V et le collecteur, et l'émetteur à GND. Un petit haut-parleur de 8 Ω sonne bien plus plein qu'un buzzer ; une résistance série de 47 à 100 Ω limite le courant.
- Plage de résonance : Les petits buzzers piézo sonnent le plus fort vers 2 à 4 kHz. Monter la mélodie d'une octave augmente nettement le volume, même si l'effet reste inférieur à celui d'un transistor.
- Effet de boîtier : Placer le buzzer dans une boîte en carton ou une boule de sapin, trou vers l'extérieur, renforce naturellement le son.
- Pour baisser le volume : Pour un projet qui tourne la nuit, ajoute une résistance de 100 à 470 Ω en série avec le buzzer ; le volume baisse sans abîmer la mélodie.
- Une seule voix : Sur l'Uno, tone() ne produit du son que sur une broche à la fois. Pour des accords ou de la musique à deux voix, un module MP3 comme le DFPlayer Mini convient mieux ; on compare les options dans projets musique Arduino.
Erreurs fréquentes et solutions
| Problème | Cause | Solution |
|---|---|---|
| Toujours le même bip | Buzzer actif utilisé | Mets un buzzer passif ; contre une pile, il doit faire clic |
| Mélodie méconnaissable, notes décalées | Tableaux melody et beats de longueurs différentes | Égalise le nombre d'éléments et vérifie mesure par mesure |
| Notes répétées collées en un seul son | Pas de silence entre les notes | Règle la durée de tone() à 90 % de la note |
| La LED sur D3 ou D11 scintille | tone() utilise le Timer2 | Déplace la LED sur une autre broche, comme D6 ou D7 |
| Un appui saute plusieurs chants | Rebond du bouton | Détecte le front descendant et bloque 250 ms |
| 'tone' was not declared sur ESP32 | Core ESP32 très ancien (1.x) | Mets à jour en 2.x ou 3.x dans le gestionnaire de cartes |
| Le son ne s'arrête pas après le chant sur la Pico | duty_u16(0) non appelé | Appelle duty_u16(0) après chaque note et à la fin |
Idées de projets avec des chants de Noël
- Détecteur de Père Noël : Quand un capteur PIR voit un mouvement devant la cheminée, joue Vive le vent ; le montage est dans détecteur de Père Noël.
- Sapin musical : Fais changer les couleurs d'un ruban WS2812B au rythme des notes ; pour le sapin lui-même, vois guirlande LED pour sapin.
- Mélodie de minuit : Joue We Wish You a Merry Christmas quand le compte à rebours du Nouvel An arrive à zéro.
- Sonnette : Pendant tout le mois de décembre, joue la première phrase de Deck the Halls au lieu du ding-dong habituel quand on sonne.
- Piano à boutons : Joue toi-même ces notes avec huit boutons ; le circuit et le code sont dans piano Arduino. Pour d'autres idées de saison, parcours la liste des projets Arduino de Noël.
Si tu veux jouer ta première mélodie sur un buzzer, les projets buzzer gratuits de l'application BlueGrays t'emmènent du premier bip au réglage de fréquence jusqu'à une mélodie d'hymne complète, chacun avec schéma, câblage pas à pas et code prêt à l'emploi. Avec les réflexes acquis là-bas, tu ajouteras facilement les quatre chants de Noël de cet article à ta propre boîte à musique ou carte de Noël.
Questions fréquentes
Comment jouer Vive le vent avec Arduino ?
Relie la patte + du buzzer passif à D8 et l'autre à GND, puis écris les fréquences des notes dans un tableau et leurs durées dans un autre. Dans la boucle, appelle tone(8, fréquence, durée) pour chaque note et attends avec delay(durée). Le refrain commence par mi mi mi, mi mi mi, mi sol do ré mi, et à 120 BPM une croche dure 250 ms.
Peut-on jouer des chants de Noël avec un buzzer actif ?
Non. Un buzzer actif contient un oscillateur à fréquence fixe et sonne toujours sur la même note, quoi que tu lui envoies. Pour des mélodies, il faut un buzzer passif, un disque piézo ou un petit haut-parleur commandé par un transistor.
Comment utiliser la fonction tone() d'Arduino ?
tone(broche, fréquence) génère sur la broche un signal carré à 50 % de rapport cyclique et joue jusqu'à l'appel de noTone(broche). Si tu donnes des millisecondes en troisième paramètre, le son s'arrête tout seul à la fin de ce délai. Sur l'Uno, tone() utilise le Timer2 : le PWM sur D3 et D11 ne fonctionne donc plus pendant qu'il joue.
Comment rendre un buzzer plus fort ?
Le plus efficace est de piloter un transistor NPN depuis la broche via une résistance de 1 kΩ et d'alimenter un petit haut-parleur en 5 V à travers ce transistor. Sans transistor, monter la mélodie d'une octave aide aussi, car les buzzers piézo sonnent le plus fort vers 2 à 4 kHz. Placer le buzzer dans un espace fermé, comme une boîte, augmente aussi le son.
L'Arduino peut-il faire autre chose pendant qu'un chant joue ?
Pendant une mélodie écrite avec delay(), l'Arduino ne peut rien faire d'autre. Si tu vérifies la fin de chaque note avec millis(), loop() repart sans attendre : lire des boutons, allumer des LED ou mesurer des capteurs continue de fonctionner pendant le chant.
La Raspberry Pi Pico a-t-elle une fonction tone() ?
MicroPython n'a pas de tone(), mais machine.PWM fait la même chose. Sur un objet PWM(Pin(15)), tu règles la note avec freq(fréquence) et un rapport cyclique de 50 % avec duty_u16(32768) ; duty_u16(0) coupe le son. Les fréquences des notes sont exactement les mêmes que sur Arduino.
Projets à réaliser après cet article
Voir tous les projets
Utilisation du buzzer
Tu t'es déjà demandé comment une sonnette ou une alarme produit son son ? L'Arduino fait biper un petit buzzer à intervalles courts : bip, silence, bip, silence. Tu vois comment l'électricité devient
Réglage de la fréquence avec buzzer
Tu contrôles le son d'un buzzer avec quatre boutons : l'un lance le son, l'autre le coupe, et les deux derniers le rendent plus aigu ou plus grave. Garde le bouton plus ou moins enfoncé et la note cha
Hymne national turc avec un buzzer
Appuie sur le bouton et un petit buzzer se met à jouer l'hymne national turc, note après note. L'Arduino joue chaque note à la bonne hauteur et pendant la bonne durée, interprète deux strophes de l'hy
Jouer des mélodies avec une télécommande IR et un buzzer
Fabrique une boîte à musique qui joue des airs avec les touches d'une télécommande de télé. Un récepteur infrarouge capte le signal ; une touche fait jouer au buzzer un air de jeu vidéo entraînant, un
Piano simple avec buzzer et bouton
Construis ton propre petit piano avec huit boutons. Chaque bouton est une note, de la plus grave à la plus aiguë : do, ré, mi, fa, sol, la, si et le do aigu. La note sonne dans le buzzer tant que tu g
ESP32 Lecture de mélodies avec buzzer
Jouer une mélodie simple (Twinkle Twinkle Little Star) avec un buzzer passif. Nous jouons les notes avec les fonctions tone() et noTone() comme dans Arduino - la même syntaxe fonctionne avec ESP32 Arduino Core 3.0+. Un buzzer passif doit être utilisé (un buzzer actif ne joue pas la mélodie).
Arduino Test de Réaction avec Signal Sonore : Mesure tes Réflexes en Millisecondes (LCD + Buzzer + 3 LED)
Tes réflexes sont-ils rapides ? Appuie sur le bouton : la LED rouge dit à vos marques, la jaune prêts, puis une attente aléatoire de 1,5 à 3,5 secondes commence. Dès que la LED verte s'allume et que le buzzer bipe, appuie à nouveau ; ton temps de réaction s'affiche en millisecondes sur l'écran LCD I2C, avec ton record et ta moyenne en dessous. Appuie avant le vert et l'écran affiche TOO EARLY! avec un son de défaite. Maintiens appuyé : nouveau joueur, même ordre d'attentes.