English

Leçons · Leçon A1 · Actionneurs et moteurs · 30 min

Le son, buzzers et haut-parleurs

Distingue un buzzer actif d’un buzzer passif, joue des notes et une courte mélodie avec tone(), et découvre le DFPlayer Mini pour les fichiers MP3. Environ 30 minutes, avec un piano sur lequel tu peux appuyer.

De l’air qui va et vient

Ce qui arrive à ton oreille n’est pas un objet mais une poussée : de l’air comprimé, puis relâché, encore et encore. Cette onde de pression, c’est ce que l’oreille perçoit comme du son [3]. Un son, c’est de l’air qui va et vient.

Un buzzer fabrique cette poussée en petit. Un buzzer piézo contient un cristal qui change de forme quand on lui applique une tension. Le cristal appuie sur un fin disque, comme le cône d’un minuscule haut-parleur, et le disque crée l’onde de pression. Change la vitesse à laquelle la tension va et vient, et tu changes le son que tu entends [3].

Dans cette leçon, tu vas :

  1. distinguer les deux sortes de buzzers,
  2. jouer une note de ton choix, puis une courte mélodie,
  3. voir ce qu’apporte un DFPlayer Mini quand tu veux de vrais fichiers MP3.
Le son, c’est de l’air qui va et vient En haut : un cône de haut-parleur, à gauche, pousse et tire l’air. Devant lui, des rangées de points d’air sont serrées par endroits et espacées à d’autres ; ces bandes voyagent vers la droite, jusqu’à une oreille. Rien ne fait tout le trajet : chaque morceau d’air va et vient seulement, la poussée se transmet. En bas, deux ondes de même hauteur dessinées sur la même durée : à gauche, une lente avec peu d’allers-retours, une note grave ; à droite, une rapide avec beaucoup d’allers-retours, une note aiguë. FIG. 1 — LE SON DANS L’AIRaUne poussée transmise par l’aircône du haut-parleurserréespacéla poussée voyageoreilleChaque morceau d’air va et vient seulement : la poussée se transmet.bNote gravelente : peu d’allers-retoursmême hauteur, même duréecNote aiguërapide : beaucoup d’allers-retoursmême hauteur, même durée
Touche le schéma pour l’ouvrir en plein écran.

Actif ou passif ?

Deux pièces qui se ressemblent peuvent se comporter très différemment.

  • Un buzzer actif contient son propre circuit de commande : un piézo plus un circuit qui le fait osciller. Tu l’alimentes et il bipe. La fiche d’Adafruit pour l’un d’eux dit qu’il chante à 2 kHz et qu’on ne peut pas changer cette fréquence [1]. Il convient donc aux alarmes « bip ! », comme celle de la leçon K2.
  • Un buzzer passif est seulement l’élément piézo. Il n’a pas de circuit de commande, donc il lui faut un signal qui change, une onde carrée, fournie par ta carte [2]. La fiche dit de relier une broche à la masse et l’autre à une onde carrée issue d’un microcontrôleur, et précise qu’il est le plus fort vers 4 kHz et fonctionne bien de 2 à 10 kHz [2].

Lequel choisir ? Pour un simple bip d’alarme, l’actif est plus simple. Pour des notes différentes, il te faut un passif, car la hauteur du son vient du signal que tu envoies.

Comment les distinguer. Lis d’abord la fiche ou l’étiquette de la pièce. Ensuite, tu peux faire un test avec ce que tu connais déjà. Branche-le sur la GPIO 25 à travers une résistance de 150 Ω (au cas où il serait magnétique, voir l’écran suivant) et reprends l’idée de la leçon K2 : digitalWrite(25, HIGH) et rien d’autre. Une tension constante n’est pas un signal qui change : un piézo passif ne donnera donc pas de son continu [2], alors qu’un buzzer actif sonnera, puisqu’il apporte son propre oscillateur [1]. S’il bipe avec une tension constante, il est actif. S’il reste muet, ce n’est pas une preuve : à travers la résistance, un buzzer actif prévu pour 5 V peut être trop faible pour sonner. Fie-toi alors à la fiche, ou essaie le programme de mélodie plus bas : seul un buzzer passif joue des notes nettement différentes.

Là où l’image s’arrête : sur une table, les deux se ressemblent presque, et un module à trois broches peut être l’un ou l’autre. Ne te fie pas à l’apparence. Teste-le, ou lis la page du vendeur.

Buzzer actif ou passif ? Deux buzzers côte à côte. a, actif : vue en coupe d’un boîtier de buzzer qui contient un disque piézo et un petit circuit étiqueté oscillateur à l’intérieur. Une tension constante de 3 V à 5 V entre, dessinée en ligne plate ; une note sort. Il chante à une seule hauteur fixe, par exemple 2 kHz. b, passif : un disque piézo nu, en laiton avec un centre en céramique. Une onde carrée entre, étiquetée ta carte fabrique l’onde ; une note sort, à la hauteur de cette onde. En bas : le test de la tension constante. digitalWrite(25, HIGH) et rien d’autre : un buzzer actif bipe, un piézo passif ne donne pas de son continu. Sur une table, ils se ressemblent beaucoup : lis la fiche ou fais le test. FIG. 2 — DEUX SORTES DE BUZZERaActifbPassifdisque piézooscillateur à l’intérieur3 V à 5 V constantune seule hauteur fixe(par exemple 2 kHz)bien pour les bips d’alarmecéramiquedisque de laitononde carréeta carte fabrique l’ondela hauteur est celle de l’ondebien pour les notes et les airsLe test de la tension constantedigitalWrite(25, HIGH);actif : il bipepassif : pas de son continuSur une table, ils se ressemblent beaucoup : lis la fiche, ou fais le test.
Touche le schéma pour l’ouvrir en plein écran.

Jouer une note

Branche le buzzer passif sur la GPIO 25, à la place de l’actif : l’autre patte va à GND. Le bouton reste sur la GPIO 27 (autre patte à GND) et la DEL sur la GPIO 26 avec 220 Ω, comme dans la leçon K2.

Vérifie quel buzzer passif tu as. Un élément piézo (sa fiche dit « piezo », comme le PS1240) peut aller directement sur la broche : sa fiche dit de relier une broche à la masse et l’autre à un microcontrôleur [2]. Certaines pièces vendues comme « buzzer passif » sont d’un autre type, magnétique : une minuscule bobine, avec une faible résistance indiquée sur la fiche, par exemple 16 Ω. Branchée directement sur une broche, une telle bobine demande bien plus que les 20 mA environ qu’une broche d’ESP32 est prévue pour fournir (voir K2). Si le tien est magnétique, ou si la fiche ne le dit pas, mets une résistance de 150 Ω entre la GPIO 25 et le buzzer. Le son sera un peu moins fort, et la broche reste protégée.

Câblage A1 : buzzer passif sur 25, DEL sur 26, bouton sur 27 Plaque d’essai vue de dessus, disposée comme dans la leçon K2. DevKitC à cheval sur la rainure, USB à gauche, broches 25, 26, 27 et GND sur la rangée du haut, colonne j libre. Huit fils numérotés. 1 noir : broche GND vers le rail moins du haut. 2 orange : GPIO 25 vers la rangée 22. Une résistance de 150 ohms relie les rangées 22 et 26 : buzzer magnétique, ou dans le doute. Avec un élément piézo, un fil court de la rangée 22 à la rangée 26 peut la remplacer. La patte plus du buzzer passif est en rangée 26, son autre patte en rangée 29 ; 3 noir : rangée 29 vers le rail moins. 4 vert : GPIO 26 vers la rangée 31 ; la résistance de 220 ohms relie les rangées 31 et 35 ; la patte longue de la DEL est en rangée 35, la courte en rangée 36 ; 5 noir : rangée 36 vers le rail moins. 6 bleu : GPIO 27 vers la rangée 40, le bouton est à cheval sur la rainure en rangées 40 et 42 ; 7 noir : la patte opposée du bouton, rangée 42, vers le rail moins du bas ; 8 noir : rail moins du bas vers rail moins du haut. Pas de 5 V dans ce montage. FIG. 3 — CÂBLAGE, VUE PLAQUE D’ESSAI+−−+jihgfedcba1510152226293135404246ENBOOT5VCMDD3D213GND121427262533323534VNVPEN3V3++12345678150 Ω220 Ωbuzzer passifDELbouton150 Ω : buzzer magnétique ou dans le douteélément piézo : un fil court à la place1noir : broche GND → rail − du haut2orange : GPIO 25 → 150 Ω (rangée 22)3noir : − du buzzer (rangée 29) → rail −4vert : GPIO 26 → 220 Ω (rangée 31)5noir : − de la DEL (rangée 36) → rail −6bleu : GPIO 27 → bouton (rangée 40)7noir : bouton, patte opposée → rail − du bas8noir : rail − du bas → rail − du hautMêmes broches que la leçon K2 : le buzzer passif prend la place de l’actif sur la GPIO 25.La patte + du buzzer (si elle est marquée) va côté résistance. Pas de 5 V dans ce montage.
Touche le schéma pour l’ouvrir en plein écran.

Téléverse ce programme et ouvre le moniteur série à 115200 baud :

// Tinker Mission, leçon A1 : une hauteur de son de ton choix, avec tone() et noTone()
// Câblage (buzzer passif, même broche que le buzzer actif de la leçon K2) :
//   Buzzer passif : une patte à la GPIO 25 (la patte + si la tienne est marquée), autre patte à GND (module à 3 broches : S à la GPIO 25, broche du milieu à 3V3, - à GND)
//   Buzzer magnétique (bobine, faible résistance) ou pas sûr ? Ajoute une résistance de 150 ohms entre la GPIO 25 et le buzzer.
//   Bouton : une patte à la GPIO 27, la patte diagonalement opposée à GND (pas de résistance nécessaire)
//   DEL : GPIO 26 -> résistance de 220 ohms -> patte longue de la DEL ; patte courte de la DEL -> GND
// Au démarrage : un bip à 440 Hz pendant une demi-seconde.
// Ensuite : tiens le bouton pour entendre 880 Hz. Relâche-le et le son s'arrête.
// À toi : change les deux nombres et écoute comment la hauteur du son change.

const int BUZZER_PIN = 25;
const int LED_PIN = 26;
const int BUTTON_PIN = 27;

const unsigned int START_FREQ = 440;    // hertz : vibrations par seconde
const unsigned int BUTTON_FREQ = 880;   // deux fois plus de vibrations par seconde

void setup() {
  Serial.begin(115200);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);

  Serial.println("Start beep: 440 Hz");
  tone(BUZZER_PIN, START_FREQ, 500);    // broche, fréquence, durée en ms (n'attend pas)
  delay(600);                           // le laisse finir avant que loop() commence
}

bool wasPressed = false;               // l'état du bouton au dernier passage

void loop() {
  bool pressed = (digitalRead(BUTTON_PIN) == LOW);
  if (pressed && !wasPressed) {
    // on vient d'appuyer : on lance la note une seule fois
    tone(BUZZER_PIN, BUTTON_FREQ);      // sans durée : sonne jusqu'à noTone()
    digitalWrite(LED_PIN, HIGH);
  } else if (!pressed && wasPressed) {
    // on vient de relâcher : on l'arrête
    noTone(BUZZER_PIN);
    digitalWrite(LED_PIN, LOW);
  }
  wasPressed = pressed;
  delay(10);
}

Télécharger le dossier du croquis (.zip)

Tu entends un court bip au démarrage. Ensuite, tiens le bouton : un son plus aigu retentit, et s’arrête quand tu relâches.

Ce que font les nouvelles lignes :

  • tone(pin, frequency) génère sur la broche une onde carrée de cette fréquence, avec un rapport cyclique de 50 %, et elle continue jusqu’à noTone() [4].
  • tone(pin, frequency, duration) fait pareil, mais pendant le nombre de millisecondes indiqué [4]. Il ne fait pas attendre le programme [4] ; c’est pourquoi nous ajoutons delay(600).
  • noTone(pin) arrête l’onde [5].
  • wasPressed garde l’état du bouton au passage précédent : la note démarre une fois quand tu appuies et s’arrête une fois quand tu relâches. Sans elle, la boucle rappellerait tone() à chaque passage, environ 100 fois par seconde, pour rien.
  • La fréquence est en hertz, le nombre d’allers-retours par seconde. La référence Arduino précise qu’il est impossible de produire des sons en dessous de 31 Hz [4].

Un seul son peut retentir à la fois. Un second appel sur une autre broche n’a aucun effet tant que le premier joue ; pour changer de broche, appelle noTone() sur la première avant tone() sur la suivante [4].

Appuie sur les touches du piano ci-dessous : chaque touche affiche sa fréquence en hertz et dessine l’onde carrée que la carte enverrait.

Un piano sur lequel appuyer (interactif)
Un piano sur lequel appuyer (interactif) Simulation interactive, pas la vraie carte. Une octave de touches de piano, de Do4 à 262 Hz à Do5 à 523 Hz, avec le nom de la note et la fréquence sur chaque touche blanche. Appuie et maintiens une touche : le navigateur joue la note, l’affichage montre sa fréquence en hertz, et le cadre du dessous dessine l’onde carrée que la carte enverrait sur la GPIO 25, des impulsions marche/arrêt sur 10 millisecondes : peu pour une note grave, beaucoup pour une note aiguë. Un curseur de fréquence règle n’importe quelle hauteur. Passe en buzzer actif : toutes les touches donnent la même hauteur fixe, étiquetée fréquence fixe. simulation, pas la carteDo262Ré294Mi330Fa349Sol392La440Si494Do523ONOFF010 msGPIO 25, onde carrée

Simulation : le navigateur joue la note, pas ta carte.

La4 (A4) · 440 Hztone(25, 440);un aller-retour toutes les 2,27 ms

Appuie sur une touche.

Voici l’état de départ : les commandes ont besoin de JavaScript.


Une mélodie à partir de deux listes

Une mélodie, c’est une liste de notes et une liste de durées. Nous rangeons chaque liste dans un tableau, une rangée de nombres gardée sous un seul nom : melody[0] est le premier, melody[1] le deuxième, et ainsi de suite. Appuie sur le bouton et le programme les joue l’une après l’autre :

// Tinker Mission, leçon A1 : une courte mélodie à partir de deux listes (notes et durées)
// Câblage (buzzer passif) :
//   Buzzer passif : une patte à la GPIO 25 (la patte + si la tienne est marquée), autre patte à GND (module à 3 broches : S à la GPIO 25, broche du milieu à 3V3, - à GND)
//   Buzzer magnétique (bobine, faible résistance) ou pas sûr ? Ajoute une résistance de 150 ohms entre la GPIO 25 et le buzzer.
//   Bouton : une patte à la GPIO 27, la patte diagonalement opposée à GND (pas de résistance nécessaire)
//   DEL : GPIO 26 -> résistance de 220 ohms -> patte longue de la DEL ; patte courte de la DEL -> GND
// Appuie sur le bouton : les premières notes d'une comptine connue sonnent, et la DEL s'allume à chaque note.
// Un buzzer actif ne peut pas jouer ça : il ne fait que sa propre hauteur de son, toujours la même.

const int BUZZER_PIN = 25;
const int LED_PIN = 26;
const int BUTTON_PIN = 27;

// Fréquences des notes en hertz (octave du milieu). REST = silence.
const unsigned int NOTE_C4 = 262;
const unsigned int NOTE_D4 = 294;
const unsigned int NOTE_E4 = 330;
const unsigned int NOTE_F4 = 349;
const unsigned int NOTE_G4 = 392;
const unsigned int NOTE_A4 = 440;
const unsigned int REST = 0;

// La mélodie, note par note.
const unsigned int melody[] = {
  NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_A4, NOTE_G4,
  NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_C4
};

// Durée de chaque note, en fraction de ronde : 4 = une noire, 2 = une blanche.
const int lengths[] = {
  4, 4, 4, 4, 4, 4, 2,
  4, 4, 4, 4, 4, 4, 2
};

const int NOTE_COUNT = sizeof(melody) / sizeof(melody[0]);   // combien de notes dans la liste
const unsigned long WHOLE_NOTE_MS = 2000;                    // une ronde dure 2 secondes : plus petit = mélodie plus rapide

void playMelody() {
  for (int i = 0; i < NOTE_COUNT; i++) {
    unsigned long duration = WHOLE_NOTE_MS / lengths[i];      // durée de cette note en ms

    if (melody[i] == REST) {
      noTone(BUZZER_PIN);
    } else {
      tone(BUZZER_PIN, melody[i], duration * 9 / 10);         // sonne pendant 90 % du temps ...
      digitalWrite(LED_PIN, HIGH);
    }
    delay(duration * 9 / 10);
    digitalWrite(LED_PIN, LOW);
    noTone(BUZZER_PIN);
    delay(duration / 10);                                     // ... et un petit silence avant la note suivante
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);
  Serial.println("Press the button to play the melody.");
}

void loop() {
  if (digitalRead(BUTTON_PIN) == LOW) {
    Serial.println("Playing...");
    playMelody();
    Serial.println("Done. Press again.");
    delay(300);                    // courte pause pour qu'un appui long ne relance pas aussitôt
  }
}

Télécharger le dossier du croquis (.zip)

Comment la lire :

  • NOTE_C4 = 262 : chaque note n’est qu’une fréquence, tirée de la table de notes de l’exemple de mélodie d’Arduino [8]. La valeur REST, 0, veut dire silence.
  • lengths[i] : 4 signifie un quart de ronde, 2 une moitié. WHOLE_NOTE_MS / lengths[i] donne la durée en millisecondes.
  • for (int i = 0; i < NOTE_COUNT; i++) répète le bloc une fois par note.
  • tone(..., duration * 9 / 10) lance la note, puis delay(...) l’attend. Un court silence d’un dixième après chaque note sépare les notes qui se répètent.

Le programme est simple exprès : pendant qu’il joue, delay() arrête tout le reste (voir K4 pour l’éviter). Pour une mélodie, ce n’est pas gênant.

Une mélodie, ce sont deux listes : notes et durées Les quatorze notes du croquis de mélodie, dessinées en barres sur un axe de temps. La hauteur de la barre est la fréquence, de 262 Hz pour C4 à 440 Hz pour A4 ; la largeur est la durée : douze noires de 500 ms et deux blanches de 1000 ms, aux 7e et 14e places. Chaque barre sonne pendant 90 % de sa case, puis un petit espace. Sous les barres, les deux tableaux s’alignent : melody[] avec NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_C4, et lengths[] avec 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 2. L’indice i choisit la même colonne dans les deux listes. FIG. 4 — LA MÉLODIE EN BARRES262 Hz330 Hz392 Hz440 Hzfréquencetemps →C4C4G4G4A4A4G4F4F4E4E4D4D4C4espace : 10 %blanche : 1000 ms500 msmelody[]lengths[]C44[0]C44G44[2]G44A44[4]A44G42[6]F44F44[8]E44E44[10]D44D44[12]C42[13]melody[] montre les noms NOTE_ ; le croquis stocke leurs nombres (NOTE_C4 = 262). L’indice i choisit la même colonne dans les deux listes.
Touche le schéma pour l’ouvrir en plein écran.

Du vrai son : le DFPlayer Mini

Un buzzer fait des bips. Pour une voix, un tambour ou une vraie chanson, il faut du son enregistré, et le DFPlayer Mini est un petit module pour ça. C’est un minuscule lecteur MP3 : tu mets des fichiers son sur une carte microSD et ta carte lui dit quoi jouer. Sa bibliothèque Arduino est décrite comme un mini lecteur MP3 pour Arduino [6]. Dans l’exemple de la bibliothèque, une carte SD absente fait partie des raisons indiquées quand le module ne démarre pas [6].

L’idée, en quatre étapes :

  1. Mets des fichiers MP3 sur une carte microSD et glisse-la dans le module.
  2. Relie le module à la carte avec quelques fils, dont une liaison série : la carte envoie des commandes, le module joue le son. L’exemple de la bibliothèque lui parle à 9600 baud [6].
  3. Installe la bibliothèque DFRobotDFPlayerMini (Gestionnaire de bibliothèques).
  4. Dans le programme, appelle begin(), règle le volume (l’exemple utilise une plage de 0 à 30) et demande de jouer un fichier [6].

Si tu veux l’essayer, voici le câblage, d’après la fiche technique d’un module compatible, le FN-M16P, conservée dans le dépôt de la bibliothèque [9]. Câble hors tension.

  • VCC à la broche 5V de la carte. Le module accepte de 3,3 à 5 V [9].
  • GND (l’une ou l’autre) à une broche GND de la carte.
  • RX du module à la GPIO 23, TX du module à la GPIO 32 : la broche d’envoi de la carte va à la broche de réception du module, et inversement. Ce sont les broches que tu as utilisées pour Serial2 dans la leçon K5. L’exemple de la bibliothèque nomme un autre port, Serial1 : les deux fonctionnent sur l’ESP32 si tu leur donnes les broches.
  • Pas de résistance sur ces deux fils. Les broches série du module fonctionnent en 3,3 V [9], comme l’ESP32. La fiche ne demande une résistance de 1 kΩ qu’avec une carte en 5 V [9].
  • Un petit haut-parleur de 4 Ω ou 8 Ω, de moins de 3 W, entre SPK1 et SPK2 [9]. Ne relie aucune de ces deux broches à GND.

Dans l’exemple de la bibliothèque, la ligne pour l’ESP32 utilise les noms de broches D3 et D2, qui n’existent pas sur la DevKitC. Change cette ligne en FPSerial.begin(9600, SERIAL_8N1, 32, 23); (réception sur la 32, envoi sur la 23) [6]. Commence avec un volume bas, par exemple 10 sur 30 : si la carte redémarre quand le son démarre, l’alimentation USB est trop faible (la leçon A2 montre le même problème avec un servo). L’auteur d’une autre bibliothèque pour DFPlayer conseille aussi de lire la page du fabricant avant de brancher le module [7]. Le même exemple précise qu’il a été testé sur des cartes Arduino Uno, Leonardo et Mega [6] : sur un ESP32, prévois donc d’essayer et d’ajuster.

Câbler un vrai DFPlayer fera un bon premier projet plus tard. Pour l’instant, tu sais à quoi il sert : buzzer = bips fabriqués par ton propre code, DFPlayer = son enregistré depuis une carte.

Le DFPlayer Mini : du son enregistré depuis une carte Deux cadres. a, schéma-bloc sans numéros de broches : la carte ESP32 envoie des commandes série à une boîte DFPlayer Mini qui contient une carte microSD avec des fichiers MP3 ; la boîte fait sonner un petit haut-parleur. Buzzer = des bips venus de ton propre code ; DFPlayer = du son enregistré sur une carte. b, si tu veux essayer, le câblage d’après la fiche technique du module, hors tension pendant le câblage, avec des fils à embout femelle directement sur les broches et sans plaque d’essai. Les 16 broches du module sont dessinées comme sur la fiche technique, broche 1 VCC en haut à gauche, fente de la carte en haut : vérifie les étiquettes du tien. Rouge : VCC vers la broche 5V de la carte ; le module accepte de 3,3 à 5 V. Noir : GND vers une broche GND. Orange : GPIO 23, le TX2 de la carte, vers le RX du module. Jaune : le TX du module vers la GPIO 32, le RX2 de la carte : l’envoi va vers la réception, dans les deux sens. Pas de résistance sur ces deux fils : les broches série du module fonctionnent en 3,3 V. Un haut-parleur de 4 ou 8 ohms de moins de 3 W entre SPK1 et SPK2 ; aucun des deux ne va à GND. La broche 5V alimente seulement le module, par son propre fil. Dans le croquis : FPSerial.begin(9600, SERIAL_8N1, 32, 23). Commence au volume 10 sur 30. FIG. 5 — DFPLAYER MINIaCe qu’il faitcarte ESP32ton croquissérie : commandesplay, volume…DFPlayer Minicarte microSDavec des MP3haut-parleurBuzzer = des bips venus de ton code · DFPlayer = du son enregistré sur une cartebSi tu veux essayer : le câblagehors tension pendant le câblageENBOOT5VCLKCMDD0D3D1D215132GND0124141627172652518331932GND352134RXVNTXVP22EN233V3GNDfente carteBUSYUSB-USB+ADKEY1ADKEY2IO1GNDIO2VCCRXTXDAC_RDAC_LSPK1GNDSPK2DFPlayer Mini (broches selon la fiche)vérifie les étiquettes du tienhaut-parleur 4 ou 8 Ωmoins de 3 W, sur SPK1 et SPK25VGND32GND23GND12431rouge : broche 5V → VCC, fil à part (3,3 à 5 V)2noir : broche GND → GND3orange : GPIO 23 (TX2) → RX, sans résistance4jaune : TX → GPIO 32 (RX2), sans résistanceCroquis : FPSerial.begin(9600, SERIAL_8N1, 32, 23); commence au volume 10 sur 30. Fils femelles, sans plaque d’essai.
Touche le schéma pour l’ouvrir en plein écran.

À toi de modifier

Change une seule chose, téléverse, écoute.

  1. Ta propre hauteur. Dans l-a1-tone, mets BUTTON_FREQ à 440, puis 1000, puis 2000. Qu’est-ce qui change ? Un piézo passif fonctionne bien entre 2000 et 10 000 Hz [2].
  2. Mélodie plus rapide. Dans l-a1-melody, mets WHOLE_NOTE_MS à 1000, puis 4000.
  3. Ta propre mélodie. Remplace les premières notes et durées par les tiennes. N’oublie pas d’ajouter une durée pour chaque note.
  4. Un silence dans la mélodie. Mets REST entre deux notes et donne-lui une durée.
  5. Test avec un buzzer actif. Mets un buzzer actif sur la GPIO 25 et lance l-a1-melody. Qu’entends-tu ?

Quand ça ne marche pas

  • Aucun son. Vérifie le câblage : une patte sur la GPIO 25 (celle marquée + si la tienne a un marquage) et l’autre sur GND. Vérifie le numéro de broche.
  • Le bouton ne change rien. Vérifie l’autre patte à GND et la ligne INPUT_PULLUP, comme en K2.
  • Toutes les notes ont la même hauteur, seul le rythme change. Tu as sans doute un buzzer actif. Il joue une seule fréquence fixe [1].
  • Très faible. Essaie une fréquence plus proche de 4 kHz, là où le piézo passif de cette fiche est le plus fort [2].
  • Les premières notes sont coupées ou collées. Vérifie que delay() dure autant que la note et qu’un court silence suit chacune.
  • Rien dans le moniteur série. Règle-le sur 115200 baud, comme Serial.begin(115200).

Vérifie-toi

Trois petites questions. Rien n’est enregistré, prends ton temps.

  1. Tu veux que ta carte joue différentes notes. De quel buzzer as-tu besoin ?

    • D’un buzzer actif, car il fabrique le son tout seul
    • D’un buzzer passif, car c’est toi qui choisis la fréquence
    • Des deux, ils se comportent pareil
    Voir la réponse

    D’un buzzer passif, car c’est toi qui choisis la fréquence. Un buzzer actif contient son propre oscillateur et chante toujours à une seule fréquence fixe [1]. Un piézo passif ne produit que la hauteur du signal que tu lui envoies [2][3] : tone() peut donc jouer n’importe quelle note.

  2. Que fait tone(25, 440); sans durée ?

    • Il bipe pendant 440 millisecondes
    • Il joue une onde carrée de 440 Hz sur la broche 25 jusqu’à l’appel de noTone(25)
    • Il joue 25 notes à 440 Hz
    Voir la réponse

    Il joue une onde carrée de 440 Hz sur la broche 25 jusqu’à l’appel de noTone(25). Sans durée, l’onde continue jusqu’à un appel à noTone() [4][5].

  3. Tu écris tone(25, 440, 500); et la ligne suivante de ton programme s’exécute aussitôt. Pourquoi ?

    • La carte est cassée
    • tone() ne bloque pas : il lance la note et n’attend pas qu’elle se termine
    • La durée est ignorée
    Voir la réponse

    tone() ne bloque pas : il lance la note et n’attend pas qu’elle se termine. La référence Arduino dit que tone() ne bloque pas le programme, même avec une durée [4]. Si tu veux que la note se termine avant la suivante, ajoute un delay() aussi long que la note.


En bref

  • Le son, c’est de l’air qui va et vient. Un buzzer piézo fait bouger un disque avec une tension qui change [3].
  • Un buzzer actif a son propre oscillateur et une seule hauteur fixe [1]. Un buzzer passif a besoin d’une onde carrée fournie par ta carte [2].
  • tone(pin, frequency) lance une note, tone(pin, frequency, duration) la joue pendant un temps sans faire attendre le programme, et noTone(pin) l’arrête [4][5].
  • Une mélodie, ce sont deux tableaux, les notes et les durées, joués dans une boucle.
  • Un DFPlayer Mini joue des fichiers MP3 enregistrés depuis une carte microSD, sur des commandes série de ta carte [6]. La fiche technique d’un module compatible donne le câblage : 3,3 à 5 V, liaison série en 3,3 V sans résistance, haut-parleur sur SPK1 et SPK2 [9].

Prochaine étape : A2, où un autre genre de signal fait bouger un servo.


Sources

Voir les 9 sources
  1. Adafruit, « Buzzer 5V - Breadboard friendly » (référence 1536) (3 V à 5 V appliqués donnent un bip à 2 kHz ; contrairement à un piézo nu, il n’a pas besoin d’un signal alternatif ; il contient un piézo plus un circuit de commande qui oscille à 2 kHz ; on ne peut pas changer la fréquence) — https://www.adafruit.com/product/1536
  2. Adafruit, « Piezo Buzzer - PS1240 » (référence 160) (les buzzers piézo servent à faire des bips, des tonalités et des alertes ; pilotés par une onde carrée de 3 à 30 V crête à crête ; une broche à la masse et l’autre à une onde carrée issue d’un temporisateur ou d’un microcontrôleur ; le plus fort vers 4 kHz, fonctionne bien de 2 kHz à 10 kHz) — https://www.adafruit.com/product/160
  3. Adafruit, « Using Piezo Buzzers with CircuitPython & Arduino », Overview (un cristal piézo change de forme quand on lui applique une tension ; en appuyant sur une membrane, il crée une onde de pression perçue comme du son ; changer la fréquence de la tension change le son) — https://learn.adafruit.com/using-piezo-buzzers-with-circuitpython-arduino/overview
  4. Arduino, Language Reference, « tone() » (génère une onde carrée de la fréquence donnée, rapport cyclique de 50 % ; continue jusqu’à noTone() sauf si une durée est donnée ; un seul son à la fois ; impossible en dessous de 31 Hz ; ne bloque pas, même avec une durée ; appeler noTone() sur une broche avant tone() sur une autre) — https://docs.arduino.cc/language-reference/en/functions/advanced-io/tone/
  5. Arduino, Language Reference, « noTone() » (arrête l’onde carrée lancée par tone() ; sans effet si aucun son ne joue) — https://docs.arduino.cc/language-reference/en/functions/advanced-io/noTone/
  6. DFRobot, bibliothèque DFRobotDFPlayerMini, README et exemple « FullFunction » (un mini lecteur MP3 pour Arduino ; liaison série à 9600 ; begin() avec un port série, message d’erreur qui demande de vérifier la connexion et d’insérer la carte SD ; volume de 0 à 30 ; branche ESP32 de begin(9600, SERIAL_8N1, rx, tx) ; la notice renvoie au schéma de connexion du fabricant et indique un test sur Arduino Uno, Leonardo, Mega) — https://github.com/DFRobot/DFRobotDFPlayerMini
  7. Makuna, wiki de la bibliothèque DFMiniMp3, accueil (une bibliothèque qui prend en charge le module DFRobot DFPlayer Mini MP3 ; lire la page produit du fabricant avant de brancher le module fait gagner beaucoup de temps et d’efforts) — https://github.com/Makuna/DFMiniMp3/wiki
  8. Arduino, exemple « toneMelody », fichier pitches.h (NOTE_C4 262, NOTE_D4 294, NOTE_E4 330, NOTE_F4 349, NOTE_G4 392, NOTE_A4 440 Hz) — https://github.com/arduino/arduino-examples/blob/main/examples/02.Digital/toneMelody/pitches.h
  9. Flyron Technology, « FN-M16P Embedded MP3 Audio Module Datasheet » V1.0, conservée dans le dépôt DFRobotDFPlayerMini de DFRobot, dossier doc (un module au même brochage à 16 broches que le DFPlayer Mini, conservé par DFRobot avec sa bibliothèque ; VCC de 3,2 à 5,0 V dans le tableau des broches, de 3,3 à 5,0 V dans les spécifications ; RX et TX au niveau TTL 3,3 V ; 9600 baud par défaut ; résistance de 1 kΩ entre TX et RX seulement avec un microcontrôleur en 5 V ; amplificateur intégré de 3 W pour un haut-parleur de 4 Ω ou 8 Ω de moins de 3 W sur SPK1 et SPK2 ; figure 5-1, liaison série en 3,3 V) — https://github.com/DFRobot/DFRobotDFPlayerMini/blob/master/doc/FN-M16P%2BEmbedded%2BMP3%2BAudio%2BModule%2BDatasheet.pdf

Pince ou touche deux fois pour zoomer, glisse pour changer de schéma.Molette avec Ctrl ou double-clic pour zoomer. Les flèches changent de schéma.