Christian Couderc

2 connectés # #

Petit haut-parleur + clavier
pour Arduino
avec un seul fil

Les perles du Net
Quel buzzer choisir ?
Premier survol du schéma
Autres approches en digital
La solution magique ATTiny
Les vraies notes de musique
La bibliothèque d’utilitaires « sons »
Synthétiseur tout fait
Amplification vers le haut-parleur
Conclusion
Annexe : Contenu du Pack_Sons

Maj : 02/05/2026

Abstract :
It is simple to create sounds with an Arduino, but there is a variety of solutions from worse to the best. We need to experiment a simple, but efficient solution, and understand what we do.
On bonus, this system offer freely how to read a lot of push buttons, with this alone wire.

Résumé :
Il est simple de créer des sons avec un Arduino, mais il existe une variété de solutions de la pire à la meilleure. Nous devons expérimenter une solution simple mais efficace, en comprenant ce que nous faisons.
En bonus, ce système offre librement la possibilité de lire un grand nombre de boutons poussoirs, avec ce seul fil.

Les perles du Net

Dans ce texte, par facilité, je parlerai de « buzzer » mais le terme exact serait « petit haut-parleur », car au sens strict, un buzzer vibre à fréquence fixe quand il est alimenté en continu, alors que dans notre application nous fournirons un signal carré variable pour tenter de produire des sons variés bien que peu mélodieux.
Vous trouverez sur le Net pléthore de montages du buzzer (lire : dispositif sonore), chacun ayant recopié sans le comprendre un montage trouvé n’importe où.
Les plus simplistes attaquent directement le buzzer sur un GPIO ce qui parasite le microcontrôleur, d’autres rajoutent une résistance en protection, certains une diode de roue libre, d’autres un transistor…
Nous allons voir qu’un montage propre est un peu plus compliqué mais donne de meilleurs résultats.

De plus, avec un seul fil commun, il permet aussi de gérer 3 à 9 boutons poussoirs, ce qui économise les rares GPIOs disponibles sur une carte à ESP32.

Attention la fonction <tone> ne fonctionne pas sur les ESP32!

Quel buzzer choisir ?

La loterie !

Disques acceptables

Dans tous les cas un vrai petit haut-parleur de récupération
sera bien meilleur que les petits gadgets !

Traditionnellement, nous utiliserons les modèles chinois à bas prix, ronds de 14 mm de diamètre sur 8 mm de haut. Il sont constitués de disques piezzoélectriques avec une résistance parallèle interne de moins de 15 Ohms.

Mais la sélection est très difficile sur les sites chinois, les descriptions sont totalement farfelues !
La description « mini haut-parleur » « buzzer actif », « buzzer passif », peut s’appliquer au même composant qu’il est souvent impossible d’identifier. En tout cas si vous voyez une fréquence de résonnance indiquée, par exemple 2400*/- 200 Hertz, ou s’il est indiqué une tension continue, ce n’est pas le bon…
Dans un boitier identique les vrais buzzers et les pseudos haut-parleurs existent pour quelques Euros la dizaine. Quand vous recevrez la petite enveloppe chinoise, vous aurez la surprise de la découverte.
Vous trouverez chez les chinois (4€ les 10) les TDK PS1240P02CT3 (voir le datasheet), qu’il faudra associer à la diode de roue libre ou resistance.
Evidement le son sera médiocre avec ce module qui accroche vers les aigus, le son serait bien plus agréable avec un vrai petit haut-parleur, mais sur une carte la place est comptée.

Il est aussi possible de monter les disques nus piezzo sous la carte, si la carte est posée sur entretoises.
Ne vous trompez pas en commandant, les descriptions chinoises sont farfelues et vous risquez de recevoir de vrais buzzers inutilisables.

Remarque : Petits haut-parleurs originaux
Il est facile de récupérer les casques jetables lors des voyages en avion. Il existe deux familles suivant les compagnies :
La version 30 Ohms, inutilisable ici, son très faible ;
La version 300 Ohms, qui contient deux surprenants petits haut-parleurs, bien meilleurs que les faux buzzers noirs. Voir l’oscillogramme plus bas.

Créer des sons avec des signaux carrés

Dans le chapitre suivant nous voulons créer des sons, non pas avec un haut-parleur attaqué par de beaux signaux sinusoïdaux, mais par un dispositif très rudimentaire qui travaille en binaire.

Il ne faudra pas espérer reproduire un Stradivarius, mais simplement générer de petits sons caractéristiques pour marquer les étapes d’un programme.
L’attaque en signaux carrés produit des harmoniques très déplaisants à l’oreille, mais comme nous voulons produire des signaux sur le spectre audible, il serait beaucoup trop compliqué de réaliser un passe-bas efficace piloté, nous nous contenterons d’un son médiocre.

Décomposition d’un signal rectangulaire.

Il y a pléthore sur le Net de pages montrant les calculs de la décomposition d’un signal en séries de Fourier (Jean Baptiste Joseph Fourier est un génie mathématique de la période révolutionnaire).
Nous ne reprendrons pas cela ici et nous contenterons du résultat pour un signal carré, pour ce cas particulier simple, nous obtenons une fondamentale à la fréquence du signal, et une série infinie de raies impaires d’amplitudes rapidement décroissantes : 1/3, 1/5, 1/7…

Cette image empruntée à Wikipédia montre l’effet des premiers harmoniques.

Premier survol du schéma

Pour commencer, voyons très simplement le comportement d’un petit mosFet N (AO3400A), source à la masse, charge résistive sur le drain à Vcc 3.3V, attaque de la gate par une rampe 0..Vcc (en jaune). La courbe Violette est la tension drain.

De Vgate 0 à 0.7V, le mosFet est bloqué, Vdrain= Vcc.
Zone résistive jusqu’à 1V qu’il faut éviter.
Au-delà de 1 V le mosFet conduit à résistance très faible.

Donc attaqué en signal carré : bloqué à OV, conduit à Vcc.

Montage proposé

Circuit de gate :

Rgate (1 k Ohms) est une simple protection, le courant étant nul.
RSEC de très forte valeur (100 kOhms) est une protection pour le cas où la pin BUZ serait en l’air, cela évite un claquage par décharge électrostatique.

Le condensateur Ccont est utile , car si par erreur la sortie GPio (pin BUZ) restait à l’état haut, le haut-parleur recevrait un courant permanent.
Voir sur les documents Expressif les nombreuses limitations des GPIOs des ESP32! -> pinMode(buzzer, output);

En négligeant Rgate, le circuit de gate est constitue par Rsec + Ccont dont le Tau = R*C est égal à :
100 kOms * 0.1 µF = (100* 10e3) *(0.1 10e-6) = 10 milliSecondes, c’est le retard que vous constatez sur les fronts des oscillogrammes suivants.

Circuit de drain :

Sur le buzzer, deux composants optionnels :
Une résistance indispensable seulement avec un piezo nu qui se comporte comme un condensateur qu’il fait décharger à Vdrain = 0.
Un condensateur crée un petit passe-bas pour casser les fronts raides.
Rlim (peut être beaucoup réduite suivant le haut-parleur) est une sécurité pour limiter les courants.

Le réglage du volume se fait basiquement par une résistance mobile (1/4 watt) sur la prise 1-3, c’est moins encombrant qu’un potentiomètre et on ne le règle qu’une seule fois. Le branchement en 1-2 permet de tester divers autres dispositifs.
Un transformateur BF améliorerait le son, mais il est bien trop gros pour tenir sur la carte.

La résistance en parallèle ainsi que la diode de roue libre sont inutiles avec un vrai haut-parleur.
Avec des disques piézo-électriques seuls, c'est absolument indispensable, car l’ensemble se comporte comme un simple condensateur qui se chargerait à Vcc sur les impulsions positives sans pouvoir de décharger, et l’on n’entendrait qu’un unique petit « clic ».

En jaune tension Vgate, en violet Vdrain, sur charge résistive 1 kOhm, attaque en signal carré.

Première courbe pour une fréquence très basse de 10 Hz, il y a un petit retard de 20ms lié au Tau = R*C.
La réponse n’est plus symétrique, la phase active est beaucoup plus courte ce qui affaiblit beaucoup le son avec un haut-parleur.

Si l’on veut produire des sons très bas, il faudra augmenter le Tau = R*C pour remonter le volume.

Deuxième courbe pour une fréquence très haute de 10 kHz.

Le condensateur est presque un court-circuit et a peu d’influence, sauf à raccourcir un peu la période active, mais l’oreille ne perçoit pas la différence d’avec un vrai court-circuit qui produirait un créneau à 50%.

Remarque :
Ces oscillogrammes montrent la réponse d’une charge seulement résistive, la réponse d’un transducteur (haut-parleur, buzzer, …) est beaucoup plus complexe à cause du comportement non linéaire (résonnance) suivant la fréquence, ce qui perturberait la compréhension.

	<--- Sur cet exemple, le buzzer accroche à 660Hz, pics très violents, son agressif
	<--- Voici à l’analyseur de spectre audio le son émis pris au microphone à cette fréquence d’accrochage. Ce bruit affreux est produit par cette infinité de raies parasites. On est bien loin ici de la raie très pure à 440 Hz d’un diapason…

Le clavier supplémentaire

Et en bonus, un clavier qui utilise le même GPIO !
J’ai séparé ce bout de schéma pour ne pas créer de confusion.

Hors production de son, la pin GPIO est en entrée analogique, tirée au +, ce qui n’affecte pas le buzzer grâce au condensateur Ccont.
Cette entrée est lue périodiquement, si aucune touche n’est appuyée, lecture Vcc, on passe.
Si une touche est appuyée, détection d’une tension qui identifie la touche.
Il est simple de rajouter des touches et de remplacer les résistances par un chapelet de diodes.

Avec 3.3V et des diodes de 0.6 V, il est possible de lire 5 touches sans ambiguïté grace au CAN incorporé.

Autres approches, toujours en signal digital

Approche PWM
L’ESP32 possède 16 PWM, mais il y en a peu d’utilisables à cause de limitations.
Les fréquences utilisables sont : 1,5,8 et 10 kHz. La résolution est entre 1 et 16 bits.

Approche modulation delta
Un seul bit commande, soit la charge (bit = 1), soit la décharge (bit = 0), d’un condensateur.
Il est ainsi possible d’obtenir, derrière un simple passe-bas pour éliminer les dents de scie, toute tension entre 0 et Vcc. Il suffit d’un MosFet et de deux résistances pour réaliser le montage (plus RC du passe-bas)
Le choix de la commande est simple. Si "Vsortie > référence", commande 0, sinon 1.
Le problème est qu’il faut comparer en permanence la sortie au signal de commande, donc faire une lecture analogique ce qui prend du temps.

Ces deux systèmes sont parfaits pour contrôler des variations lentes (vitesse de moteurs, chauffage, variations d’éclairage d’une led…), mais ils ne permettent pas de suivre un signal sonore beaucoup trop rapide.

Pour l’ESP32, il est très intéressant d’utiliser ledc, prévu à l’origine pour moduler les leds.
Le soft est très simple mais est limité pour les basses fréquences.
Attention, l’écriture n’est pas la mème en IDE 2.xx ou IDE 3.xx : Cette page Expressif le précise très clairement.

La solution magique ATTiny 85

Un gros problème apparait quand on doit gérer simultanément des routines qui prennent du temps machine, par exemple :
Quand l’ESP32 ne fait rien, en sommeil entre deux actions, je commande des leds WS2182 (voir la page ici) qui « pompent » doucement, avec une faible lueur jaune pour montrer que le système est vivant.
Pendant ce temps le clavier est actif (déclenché par une interruption), et un son long peut être en train de jouer… C’est du multitâches. .
Il existe évidement la solution Expressif pour activer le deuxième cœur, mais cela ne se fait pas simplement, il faut utiliser ESP-IDF, basé sur FreeRTOS, et la programmation implique de nombreux outils qui dépassent les compétences du petit bricoleur habitué au seul Arduino.

Pour résoudre ce problème, je rajoute sur ma carte de développement, un ATTiny 85 qui va gérer seul avec ses petites 8 pattes, clavier, son, détection de présence (radar et ultrasons) et leds.
Il communique en I2C avec l’ESP32, sans gaspiller un GPIO, et ils échangent des commandes de quelques bytes pour lancer des actions, chacun vivant à part.
Il ne prend que très peu de place sur la carte mais fait beaucoup de choses. Il est possible de l’utiliser sous ses deux formes :
Version sur support en boîtier DIL 8 pattes car il est plus simple de le sortir de son support pour le reprogrammer.
Version CMS avec une prise de programmation et des straps.

Si vous avez des idées de grandeur, utilisez l’ATTiny 1616, c’est un monstre de puissance, low power et plein de GPIOs...
Comme son petit frère, il n’a besoin que d’un seul fil UPDI (et alim) pour se programmer.

Pour reprendre les exemples précédents, mes bibliothèques allégées, sons, clavier et WS2182 et leurs routines .ino, sont seulement implantées dans l’ATTiny 85, laissant à l’ESP32 les tâches nobles.
Cet ajout d’un deuxième microcontrôleur peut sembler surabondant, mais à 2€ le composant, il va vite apparaitre comme un sous-traitant incontournable.
L'ATTiny 85 est vraiment un composant fascinant.
Il dispose de : 8k Bytes de flash pour le programme, 512 bytes EEprom, 512 bytes Sram, ADC 10 bits.
Cela permet de faire tourner beaucoup de routines performantes.
Si vous ne l’avez pas testé, lisez un descriptif des multiples combinaisons du vieux NE555, et pour vous faire la main, réalisez toutes les temporisations et monostables en ATTiny, c’est encore beaucoup mieux… Vous développez sur une carte Arduino quelconque, et quand le firmware est au point, il suffit de le transférer vers l’ATTiny.
Je les utilise aussi pour des décodages de clavier de portier, la conversion de signaux NMEA183 en RS232, des déclencheurs photo, etc..

L’approche convertisseur Digital vers Analogique

Dans les exemples précédents, nous attaquions via un mosFet, le haut-parleur en signaux carrés générant plein d’harmoniques désagréables.
Maintenant les commandes seront des sinusoïdes pures ce qui améliore considérablement les résultats après amplification.

L’ESP32 Devkit V1 possède deux broches spéciales utilisables en convertisseur Digital vers Analogique, ce n’est que du 8 bits, mais suffisant pour des applications basses fréquences. DAC1 utilise GPIO25, et DAC2 utilise GPIO26.
Attention, le ESP32-S3 est dépourvu de sorties Digital vers Analogique, il faut utiliser un DAC externe, comme le MCT4725 en I2C qui possède une résolution de 12 bits.

Considérons ce début de programme :

Il ne fait que créer un tableau de de 256 bytes représentant une période de sinus, entre 0 et 255.

#define stepResol 8
int8_t sn[256];// = 2 exp stepResol
// ---------------------------------
void setup() {...
int resol = pow(2,stepResol);// 8-> 256
for (int i = 0; i < resol; i++) {
sn[i] = (int) (127*(1+sin (PI*i*2/resol)+.5))) ; }}

Nous pouvons envoyer ce tableau dans un des DAC ce beau signal sinusoïdal de 731 Hz.
Attention ici le mosFet ne convient plus, nous parlerons plus tard de l’amplification à transistors.

Les puristes remarquent un petit glitch en fin de période (sur les curseurs), il est inévitable car dans la boucle for, si la condition est FALSE, l’exécution prend quelques cycles de plus que pour les 256 conditions TRUE (256 fois).
C’est imperceptible à l’oreille d’un non musicien car le haut-parleur lisse ce minuscule défaut.

void loop() {
for (byte j = 0; j < pow(2,resol); j++){
dacWrite(dacOutput, sn[j]); }}

Si maintenant nous changeons la taille de la table (2 exp 8 = 256) en passant à une résolution de 5,
la table n’a plus que (2 exp 5 = 16) termes et la fréquence est (2 exp (8-5) = 8) fois plus grande.
Suivant la résolution nous obtenons :

Avec 256 points, la résolution est bien trop grande pour ce que nous voulons faire.
Comme lors de la compression d’image avec perte (bmp -> jpg) la dégradation ne se fait pas sentir si l’on n’est pas trop exigeant.
Pour notre petit haut-parleur, la table de 16 octets sera suffisante. Un petit condensateur lissera les marches d’escalier.

Résolution	Taille table	Fréquence
3	8	23.4 kHz
4	16	11.7 kHz
5	32	5.85 kHz
6	64	2.92 kHz
7	128	1.46 kHz
8	256	731 Hz
9	512	386.5 Hz

Nous savons faire une fréquence unique avec une table unique, mais on peut faire bien mieux !

Multiplication de fréquence
Si dans la condition « for » nous remplaçons j++ par j+=shift, suivant la valeur de byte shift nous sautons des points dans la table.
Avec shift = 2 nous prenons un point sur 2 donc doublons la fréquence
Avec shift = 3 nous prenons un point sur 3 donc triplons la fréquence...

256 points -> 731 Hz

16 points -> 11.7 kHz

Décrémentation de fréquence
Si dans la boucle « for » nous ajoutons un delayMicrodeconds (tempo), nos rallongeons la boucle donc baissons la fréquence.
Pour la table de 256, avec une tempo de 160 µS, la fréquence est de 23.4 Hz, la période est de 42.74 mS, il y a 256 boucles,
donc le traitement de la condition for + dacWrite +160 µS prend à peu près 42.74/255 = 167 µS, donc <condition for> + dacWrite = 7 µS
En rajoutant notre délai, la nouvelle fréquence sera environ de 1/(256* (7+tempo)), car il y a l’arrondi, le délai ne prenant que des entiers.

Par exemple pour s’approcher du La 3 à 440 Hz, l’appel avec shift=1 et tempo= 3µS, nous donnera 421 Hz plus proche du Sol# ou La bémol à 415 Hz.
C’est comme jouer une partition sur un piano désaccordé...

Fréquence en Hz	délai en µS
542	1
240	10
148	20
84.6	40
44.3	80
23.4	160

En passant à cette petite boucle « for » les entiers shift et tempo, nous pouvons obtenir toute la gamme audible. Les fréquences se calculent par de simples tables Excel.
Cela a toutefois un défaut, les fréquences obtenues sont serrées, mais ne tombent pas juste sur les notes de la gamme.
Pour des bruitages, aucun problème, mais pour jouer un son parfait sur un bon haut-parleur, les écarts aux vraies notes seront trop sensibles pour un musicien.

Amélioration de la résolution

Dans ce chapitre nous prendrons un shift de 2, donc 128 points par période. Le delayMicrosecond est trop long pour faire un réglage fin.
Nous remarquons que delayMicrosecond(255), qui nous donnait une fréquence de 14.95 Hz prend exactement le même temps que :

for (int i = 0; i < 20540; i++) {
asm volatile("nop"); }// attendre 1 cycle d'horloge

Donc <la boucle for> + <l’instruction nop> prennent exactement 255µS/20540, soit environ 12.41 nanoSecondes, soit 3 coups d'horloge (2 pour la boucle, 1 pour le nop) à 240 MHz.
Cela donne un delai 80 fois plus fin que delayMicrosecond()
Nous pouvons maintenant ajuster plus finement les notes de la gamme, par exemple :
Octave 1 : La 110 Hz avec 2616 boucles (exactement)
Octave 2 : La 220 Hz avec 1207 boucles (exactement)
Octave 3 : La 440 Hz avec 501 boucles (exactement)
en descendant les octaves le nombre de boucles augmente ainsi que la résolution, mais en montant les octaves la précision diminue de plus en plus :

Equation Fréquence/ tempo

Octave 4 : La 880 Hz, avec 149 -> 886 Hz et avec 150 -> 874.4 Hz
Octave 5 : La 1760 Hz, impossible, trop rapide, avec 1 boucle -> 1464 Hz seulement
La synthèse ne sera juste que dans les graves ce qui pose problème…Avec un shift de 2, donc 128 points on obtient un nouveau jeu de fréquences mais le problème se pose toujours.

Si l'on prend un shift de 1, on descend encore d'une octave sur les valeurs précedentes.

Le ESP32 S3 a perdu ces DACs

J’ai abandonné le Devkit V1 pour passer au ESP32 S3.
Un problème est apparu, les deux GPIO utilisables sur le Devkit, de DAC (25 et 26) n’existent plus !
Cette version est bien plus performante mais a supprimé cette possibilité.
Il faudra donc utiliser d’autres artifices comme le PWM ou un convertisseur numérique-analogique externe pour contourner ce problème gênant.

Les vraies notes de musique

Vous trouvez partout des tables de fréquence des notes arrondies, mais quand on veut créer des sons exactement avec un synthétiseur, cela n’est pas suffisamment précis.

Ma table Excel ci jointe vous donne les notes exactes. Elle est très simple !
Elle se base sur la fréquence de référence du La3 à 440 Hertz.
On passe d’une octave à l’autre en multipliant/divisant par 2.
On passe d’une note à l’autre en multipliant/divisant par 2 puissance 1/12
Remarquez les touches noires du piano, qui sont les dièse/bémol intercalés entre certaines notes.

Cliquez pour obtenir la feuille Excel

La bibliothèque d’utilitaires « sons »

La classe < C_utils_Sons> utilise seulement la sortie numérique et le mosFet comme décrit en début de page.
Elle n’utilise pas la synthèse sinusoïdale du chapitre précèdent.

La classe < C_utils_Sons> contient les outils nécessaires pour produire divers bruitages, sans utiliser le fonction « tone » qui ne fonctionne pas sur ESP332.
Elle est remplacée par la méthode « ton ». Cette méthode accepte plusieurs formats :
void ton (float note, uint8_t octave, int duration, int pause);
void ton (float note, uint8_t octave, int duration);
void ton (float frequency, int duration);

Dans cette classe, les notes (et dièses) sont écrites en toutes lettres, ce qui rend leur interprétation précise et sans ambiguïté. Pour l'ESP32-S3, j'ai utilisé à la place le module ledc, qui fonctionne très bien.
Le terminal série de la démo permet de lancer l'ensemble des sons en séquence, ou d'appeler chaque son individuellement en tapant son numéro au clavier:

Petits sons utilitaires pour ponctuer les actions courantes.
Sirènes réglementaires — SAMU, pompiers, ambulance, police — fidèlement reproduites, le ministère de l'Intérieur publiant des normes très précises à ce sujet.
Quelques thèmes musicaux, modestes mais identifiables en huit mesures.
J'avais envisagé d'intégrer des sons d'explosion, de chocs métalliques ou de chants d'oiseaux, mais cela s'avère impossible sans recourir à de lourdes tables de centaines d'octets — auquel cas, autant passer directement au MP3. J'ai tenu à garder la bibliothèque aussi compacte que possible, et j'ai donc renoncé à tout ce qui ne peut pas se jouer au piano, d'un seul doigt de la main droite.
Cette contrainte limite considérablement les possibilités et explique la pauvreté relative des rendus.

Synthétiseur tout fait

De nombreux circuits synthétiseurs audio existent, en solution « clefs en main », fournissant une sortie audio parfaite, bien meilleure que ce qui fait l’objet de cette page consacrée à l’approche par le firmware seul.
C'est une excellente approche pour des oreilles sensibles. Une recherche sur Internet <synthétiseur audio arduino> vous donnera de nombreuses pistes. Il y a beaucoup moins de choix en synthétiseurs BF qu’en HF.

Pensez aussi au très riche format Midi très bien documenté.

Autre alternative performante, la carte annexe jouant des MP3 contenus dans sa mémoire SD. Vous pouvez échantillonner toute musique, voix parlées ou chantées, des bruits…
Il existe de multiples applications spécialisées, pour traiter les sons.

La meilleure solution que je connaisse est le MAX98357A (facilement trouvable sur Google). Il ne s'agit pas d'un synthétiseur, mais d'un convertisseur numérique-analogique couplé à un amplificateur audio de qualité. Il accepte le signal audio au format I2S, un protocole bien documenté et largement répandu.

La mise en œuvre est particulièrement simple. Le schéma ci-joint n'est pas de ma conception, il est parfait avec ses découplages !
Il est extrait de la documentation de mes cartes actuelles Makerfabs MaTouch ESP32-S3 Parallel with Touch 7" V1.2.

L’exemple fourni avec la carte contient un exemple de sortie vocale qui illustre parfaitement les capacités de ce circuit. Le code source permet de mettre rapidement le circuit en œuvre pour jouer des MP3 (fichiers sur SD ou mémoire). L’intérêt du MP3 est que l’on peut enregistrer des paroles et les rejouer avec une très bonne qualité pour faire sa propre sortie vocale.
Ma bibliothèque « son » s’adapte parfaitement au format I2S, seules les méthodes « initSons » et « ton » sont à modifier.
Le volume se règle par un pont résistif, ou un potentiomètre numérique I2C (exemple : DS1841, MCP4551 ...) si l’on veut faire varier le niveau dans le programme. Les 256 positions linéaires peuvent paraitre surabondantes, mais comme l’oreille a une sensibilité logarithmique, il faudra ruser pour afficher quelques paliers à 3dB !

Mais cela nous éloigne évidemment du cahier des charges original pour cette page, qui était de faire du son en utilisant simplement une sortie GPIO et quelques lignes de code…

Amplification du signal vers le haut-parleur

Si l’on veut plus de puissance (?) , il faut rajouter un petit circuit intégré amplificateur. Voir par exemple le LM4890MX.
Il existe des modules chinois qui comportent l’ampli et le haut-parleur sur la même plaquette comme le SC8002B, mais vous pouvez utiliser un quelconque ampli de récupération qui traîne dans une de vos boîtes.
Avantages et inconvénients de l’amplificateur SC8002B (ou LM4871)
+ Coût dérisoire
+ Fonctionne à 3.3 V (c’est rare)
+ Surpuissant pour notre application, mais le niveau est simple à contrôler avec une résistance
+ Meilleur son possible sur un petit haut-parleur
- Consommation permanente de quelques milliampères incompatible avec des montages « low power », mais une coupure automatique de l’alimentation en rajoutant un MosFet est simple
- S’il n’est pas en stock, délai pour commande en Chine

Conclusion

N’hésitez pas à m’envoyer vos remarques sur le fond (parties à compléter ou modifier), et sur la forme (fautes de frappe…).

L’expérimentation sur Arduino est très enrichissante, mais se contenter de pomper des pages douteuses sans comprendre ce que l’on fait n’est pas une bonne idée.
Il faut essayer d’aller plus profondément si l’on veut en tirer une satisfaction intellectuelle…

Ne vous attendez pas à faire du son haute-fidélité aussi simplement avec un Arduino, pensez à l’alternative des circuits spécialisés évoqués.
Pour de simples petits sons ponctuant un programme, le montage décrit dans cette page suffit.

De plus, les fréquences sont calculées exactement, mais l’horloge de l’ESP32 n’est pas très stable.
Pour s’en convaincre, il suffit de réaliser une pendule élémentaire qui se base sur millis(), sans autre code parasite et la laisser tourner pour regarder la dérive importante, variable d’un chip à l’autre.
Donc quand vous lisez « le La 3 est callé exactement à 440 Hz », il faut comprendre « pour autant que millis() batte exactement la milliSeconde », ce qui n’est jamais exact.
A titre d’exemple, sur une de cartes ESP32S3, le 440 Hz généré en utilisant ledc, donne 439.882 exact.
Vous trouverez joint un petit programme qui envoie le temps toutes les minutes, calez vous sur un top à l’heure entière et laissez tourner pour voir les dérives, entre autres liés à la température (testez dans le frigo sur batterie).

Annexe : Contenu du Pack_Sons

Classe de base
Classe <C_utils_Sons> pour l’utilisation de la sortie digitale sur un GPIO et haut-parleur sur mosFet. Collection des petits gadgets pour générer divers sons.

Fichiers ino
Demo_Sons : Test des méthodes de la classe et collection de sons
Dac : Synthétiseur sinusoïdal basse fréquence utilisant une sortie DAC 25 ou 26
Top_Hour : Petit gadget pour vérifier la stabilité de l’horloge 240 MHz de l’ESP32

Fichiers Excel
Vraie_gamme : Calculs exacts des fréquences des notes de la gamme
Frequence_delai_nop : Détail de la courbe des fréquences octave 3 avec le synthétiseur
Clavier_diodes : Tensions du clavier à touches. Faites varier les valeurs en entrant en colonne E2 la tension des diodes que vous testez (0.6 V pour silicium 1N4148, moins de 0.4 pour de bonnes zeners)

L’ensemble des outils, la classe et
les fichiers.ino de démonstration,
est disponible ici dans le <Pack_Sons> :

mise à jour: 07 04 2026

* Page vue 12439 fois IP : 172.17.0.1

Dernière retouche le 02 Mai 2026 à 15 h