Mini module haut-parleur amplifié SC8002B pour Arduino Images
Ce petit module audio réunit sur une seule carte un amplificateur SC8002B, un haut-parleur et un potentiomètre de réglage du volume.
Ce module amplificateur audio réunit sur une seule petite carte un circuit amplificateur SC8002B, un haut-parleur et un potentiomètre de réglage du volume. Il se raccorde en trois fils à une carte Arduino ou à tout autre microcontrôleur et permet de donner enfin un vrai niveau sonore aux signaux audio de vos montages, là où un simple buzzer se contente d'un bip.
Dans la plupart des montages à microcontrôleur, le son se limite à un buzzer piézo : utile pour signaler une alarme, très vite insuffisant dès que l'on veut jouer une mélodie, faire parler un montage ou simplement être entendu à l'autre bout de la salle. Le problème n'est pas le microcontrôleur, qui sait parfaitement générer un signal audio, mais la puissance : une sortie de carte ne délivre que quelques dizaines de milliampères, très loin de ce qu'exige un haut-parleur.
C'est exactement le rôle de ce module. Le circuit SC8002B qu'il embarque est un amplificateur de puissance audio qui reprend le faible signal présent sur son entrée et l'amplifie d'un facteur d'environ 8,5 avant de l'envoyer vers le haut-parleur intégré. Vous conservez donc votre programme et votre façon de générer le son, mais vous passez d'un bip fluet à un niveau sonore annoncé à 80 dB.
L'intérêt pédagogique est direct : le module matérialise la notion d'étage d'amplification, que l'on retrouve dans toute chaîne audio, sur un exemple que l'élève entend immédiatement. Tourner le potentiomètre et constater la variation, débrancher l'amplificateur pour comparer avec le signal brut, mesurer l'amplitude à l'oscilloscope en entrée puis en sortie : autant de manipulations courtes et parlantes.
Tout est déjà assemblé et câblé sur la platine, il n'y a rien à souder. Vous y trouverez le circuit amplificateur SC8002B, un haut-parleur monté directement sur la carte, un potentiomètre ajustable qui fixe le volume de sortie, et un connecteur à 3 points accompagné de son cordon.
Le raccordement se résume donc à trois fils : l'alimentation 5 Vcc, la masse, et l'entrée du signal audio à amplifier. Prévoyez une source d'alimentation capable de fournir au moins 500 mA : c'est le point que l'on néglige le plus souvent, et un montage alimenté par un port USB déjà chargé produira un son qui décroche dès que le volume monte.
La carte est utilisable de 0 à 40 °C. Le circuit SC8002B accepte une puissance maximale de 2 W, mais le haut-parleur monté sur la platine est donné pour 0,15 W : c'est lui, et non l'amplificateur, qui fixe la limite réelle de l'ensemble. Nous y revenons dans les précautions d'emploi, car le point mérite d'être lu avant la première mise sous tension.
La mise en œuvre tient en quatre gestes. Reliez d'abord la broche d'alimentation du module au 5 V de votre carte et la masse à la masse. Reliez ensuite l'entrée de signal à la broche de votre choix sur le microcontrôleur : dans l'exemple qui suit, nous utilisons la broche numérique D3 d'une carte Arduino.
Avant toute mise sous tension, ramenez le potentiomètre à son minimum. Vous ne l'augmenterez qu'ensuite, progressivement, une fois le programme chargé et le son établi. Cette précaution n'est pas une formalité : un haut-parleur de cette taille attaqué d'emblée à plein volume peut être détérioré en quelques secondes.
Pour les essais, la méthode la plus simple consiste à envoyer sur l'entrée un signal carré de fréquence et de durée variables, ce que la fonction tone() d'Arduino produit nativement. En faisant varier la fréquence, vous faites varier la hauteur du son ; en faisant varier la durée, vous obtenez des notes. C'est tout le principe du programme de démonstration ci-dessous.
Le programme ci-dessous joue une mélodie complète sur le haut-parleur du module : l'Hymne à la joie de Beethoven, dont la simplicité rythmique en fait un cas d'école idéal. Il est ici entièrement traduit en français et commenté ligne à ligne, de façon à pouvoir être distribué tel quel à des élèves. Copiez-le dans l'IDE Arduino et téléversez-le.
Toute la logique repose sur une idée simple, qu'il est utile d'expliciter avant de lire le code. Une partition, c'est deux informations par note : quelle note jouer et combien de temps la tenir. Le programme stocke donc ces deux informations dans deux tableaux parallèles de même longueur : melodie[] contient la fréquence de chaque note en hertz, duree[] contient sa durée exprimée en fraction de temps. La case numéro 5 du premier tableau et la case numéro 5 du second décrivent ensemble la cinquième note du morceau.
Il ne reste plus qu'à parcourir ces tableaux du premier au dernier élément avec une boucle for, en jouant chaque note pendant la durée associée. C'est une structure que l'on retrouve dans quantité d'applications bien au-delà de la musique, dès qu'il s'agit d'associer deux grandeurs à un même indice.
/* =================================================================
Module amplificateur audio OPENSE8002B
Programme de demonstration : lecture d'une melodie
Melodie : "Hymne a la joie" (Ludwig van Beethoven)
Cablage sur une carte Arduino :
- Alimentation du module ...... 5 V de la carte
- Masse du module ............. GND de la carte
- Entree signal du module ..... broche D3 de la carte
Avant la mise sous tension, placez le potentiometre du module
au minimum, puis augmentez le volume progressivement.
================================================================= */
/* -----------------------------------------------------------------
1) FREQUENCES DES NOTES, EN HERTZ
-----------------------------------------------------------------
Le chiffre qui suit le nom de la note indique son octave.
DO4 (262 Hz) est le do medium, celui du milieu d'un clavier.
Chaque fois que l'on monte d'une octave, la frequence double :
DO4 = 262 Hz, DO5 = 523 Hz, DO6 = 1047 Hz.
----------------------------------------------------------------- */
#define SILENCE -1 // valeur particuliere : aucune note n'est jouee
// Octave 4 (registre grave)
#define DO4 262
#define RE4 294
#define MI4 330
#define FA4 349
#define SOL4 392
#define LA4 440
#define SI4 494
// Octave 5 (registre medium, celui de notre melodie)
#define DO5 523
#define RE5 587
#define MI5 659
#define FA5 698
#define SOL5 784
#define LA5 880
#define SI5 988
// Octave 6 (registre aigu)
#define DO6 1047
#define RE6 1175
#define MI6 1319
#define FA6 1397
#define SOL6 1568
#define LA6 1760
#define SI6 1976
/* -----------------------------------------------------------------
2) DUREES DES NOTES
-----------------------------------------------------------------
Les durees sont exprimees en nombre de temps, comme sur une
partition : la noire vaut 1 temps, la croche un demi-temps,
la blanche 2 temps, et le point ajoute la moitie de la valeur
de la note qu'il suit (noire pointee = 1 + 0,5 = 1,5 temps).
----------------------------------------------------------------- */
#define CROCHE 0.5
#define NOIRE 1.0
#define NOIRE_POINTEE 1.5
#define BLANCHE 2.0
// Duree d'un temps, en millisecondes.
// 500 ms par noire correspond a un tempo de 120 pulsations par minute.
// Augmentez cette valeur pour ralentir le morceau, diminuez-la pour
// l'accelerer : c'est le seul reglage a modifier pour changer le tempo.
#define DUREE_DU_TEMPS 500
// Tres court silence insere entre deux notes. Sans lui, deux notes
// identiques qui se suivent s'entendraient comme une seule note longue.
#define BLANC_ENTRE_NOTES 30
/* -----------------------------------------------------------------
3) LA PARTITION
-----------------------------------------------------------------
Les deux tableaux ci-dessous se lisent ensemble : la case n du
tableau melodie[] donne la note a jouer, la case n du tableau
duree[] donne sa duree. Ils contiennent donc imperativement le
meme nombre d'elements. Chaque ligne du code correspond a une
mesure de la partition, ce qui facilite les modifications.
----------------------------------------------------------------- */
int melodie[] =
{
MI5, MI5, FA5, SOL5,
SOL5, FA5, MI5, RE5,
DO5, DO5, RE5, MI5,
MI5, RE5, RE5,
MI5, MI5, FA5, SOL5,
SOL5, FA5, MI5, RE5,
DO5, DO5, RE5, MI5,
RE5, DO5, DO5,
RE5, RE5, MI5, DO5,
RE5, MI5, FA5, MI5, DO5,
RE5, MI5, FA5, MI5, RE5,
DO5, RE5, SOL4, SILENCE,
MI5, MI5, FA5, SOL5,
SOL5, FA5, MI5, FA5, RE5,
DO5, DO5, RE5, MI5,
RE5, DO5, DO5
};
float duree[] =
{
NOIRE, NOIRE, NOIRE, NOIRE,
NOIRE, NOIRE, NOIRE, NOIRE,
NOIRE, NOIRE, NOIRE, NOIRE,
NOIRE_POINTEE, CROCHE, BLANCHE,
NOIRE, NOIRE, NOIRE, NOIRE,
NOIRE, NOIRE, NOIRE, NOIRE,
NOIRE, NOIRE, NOIRE, NOIRE,
NOIRE_POINTEE, CROCHE, BLANCHE,
NOIRE, NOIRE, NOIRE, NOIRE,
NOIRE, CROCHE, CROCHE, NOIRE, NOIRE,
NOIRE, CROCHE, CROCHE, NOIRE, NOIRE,
NOIRE, NOIRE, NOIRE, NOIRE,
NOIRE, NOIRE, NOIRE, NOIRE,
NOIRE, NOIRE, NOIRE, CROCHE, CROCHE,
NOIRE, NOIRE, NOIRE, NOIRE,
NOIRE_POINTEE, CROCHE, BLANCHE
};
/* -----------------------------------------------------------------
4) VARIABLES ET BROCHE UTILISEE
----------------------------------------------------------------- */
const int brocheSignal = 3; // entree du module amplificateur
int nombreDeNotes; // calcule automatiquement au demarrage
/* -----------------------------------------------------------------
5) INITIALISATION
-----------------------------------------------------------------
setup() n'est execute qu'une seule fois, a la mise sous tension
ou apres un appui sur le bouton reset de la carte.
----------------------------------------------------------------- */
void setup()
{
// La broche reliee au module devient une sortie.
pinMode(brocheSignal, OUTPUT);
// On compte les notes sans avoir a les denombrer a la main :
// taille totale du tableau divisee par la taille d'un element.
// Ajoutez ou retirez des notes, le programme s'adapte tout seul.
nombreDeNotes = sizeof(melodie) / sizeof(melodie[0]);
}
/* -----------------------------------------------------------------
6) PROGRAMME PRINCIPAL
-----------------------------------------------------------------
loop() est repete indefiniment : la melodie tourne donc en boucle.
----------------------------------------------------------------- */
void loop()
{
// On parcourt la partition, note apres note.
for (int i = 0; i < nombreDeNotes; i++)
{
if (melodie[i] == SILENCE)
{
// Cas particulier du silence : on n'emet aucun son,
// mais on respecte tout de meme la duree prevue.
noTone(brocheSignal);
}
else
{
// tone() genere sur la broche un signal carre a la frequence
// demandee. C'est ce signal que le module amplifie avant de
// l'envoyer vers son haut-parleur.
tone(brocheSignal, melodie[i]);
}
// On tient la note pendant sa duree : duree du temps multipliee
// par la valeur rythmique de la note (0,5 / 1 / 1,5 / 2).
delay(DUREE_DU_TEMPS * duree[i]);
// On coupe le son, puis on marque un tres court silence afin
// que la note suivante soit bien percue comme une note distincte.
noTone(brocheSignal);
delay(BLANC_ENTRE_NOTES);
}
// Pause de 2 secondes avant de rejouer le morceau depuis le debut.
delay(2000);
}
Quatre points méritent d'être commentés en classe, car ils dépassent largement le cadre de cette petite démonstration.
D'abord, la fonction tone() travaille en arrière-plan : une fois appelée, elle génère le signal carré sans bloquer le programme, qui continue à s'exécuter. C'est le delay() qui suit, et lui seul, qui détermine la durée réellement entendue. Retirer ce delay() ferait défiler toute la partition en une fraction de seconde, sans que l'on entende autre chose que la dernière note.
Ensuite, le calcul sizeof(melodie) / sizeof(melodie[0]) mérite qu'on s'y arrête. Il divise la taille totale du tableau en octets par la taille d'un seul élément, et retourne donc le nombre d'éléments. L'intérêt est pratique : vous pouvez ajouter ou supprimer des notes sans jamais avoir à mettre à jour un compteur ailleurs dans le programme. C'est une bonne habitude de programmation à faire prendre tôt.
Le court silence entre deux notes est le troisième point. Sans lui, deux notes de même hauteur qui se suivent — et l'Hymne à la joie en contient plusieurs — se fondraient en une seule note deux fois plus longue. Trente millisecondes suffisent à les séparer à l'oreille sans altérer le tempo de façon perceptible. C'est une excellente illustration de la différence entre ce que dit le code et ce que perçoit l'auditeur.
Enfin, le traitement du silence montre l'utilité d'un test conditionnel bien placé. Une valeur de fréquence négative n'a aucun sens pour tone() : on la réserve donc à un usage conventionnel, le silence, que le programme intercepte avant d'appeler la fonction. La durée, elle, est respectée dans les deux cas, ce qui garantit que le rythme ne se décale pas.
Pour aller plus loin, quelques modifications à proposer aux élèves : changer la valeur de DUREE_DU_TEMPS pour jouer le morceau plus vite ou plus lentement, transposer toute la mélodie d'une octave en remplaçant les notes de l'octave 5 par celles de l'octave 6, ou écrire sa propre partition dans les deux tableaux.
Générer des notes avec tone() est le cas d'usage le plus simple, mais le module amplifie tout signal audio de faible niveau présenté sur son entrée. Il trouve donc naturellement sa place derrière un module lecteur de fichiers audio, derrière un convertisseur numérique-analogique, ou en sortie d'un petit appareil dont le niveau sonore est insuffisant, pour lequel il fait office d'amplification externe.
Dans un projet à microcontrôleur, il apporte la couche sonore qui manque souvent : signalisation d'alarme réellement audible, retour sonore d'une interface, annonce d'un événement dans un montage domotique, ou habillage sonore d'un projet d'exposition. Le potentiomètre embarqué permet d'ajuster une bonne fois pour toutes le niveau à l'environnement, sans rien modifier dans le programme.
Trois recommandations, toutes issues de la documentation du fabricant, conditionnent la durée de vie du module.
Réglez toujours le volume au minimum avant la mise sous tension, puis augmentez-le lentement jusqu'au niveau souhaité. C'est la précaution la plus importante : le haut-parleur intégré est donné pour 0,15 W quand le circuit amplificateur peut en délivrer bien davantage, et rien n'empêche mécaniquement de dépasser ce que le transducteur supporte.
Alimentez le module correctement. Sous 5 Vcc, prévoyez une source capable de fournir au moins 500 mA. Une alimentation trop juste se traduit par un son qui se dégrade dans les passages forts, et peut perturber le fonctionnement du microcontrôleur lui-même.
Un buzzer est directement piloté par une sortie du microcontrôleur et se limite donc à la puissance que celle-ci peut fournir, soit un niveau sonore faible et un timbre pauvre. Ce module intercale un étage d'amplification entre le microcontrôleur et un vrai haut-parleur : le signal est amplifié d'environ 8,5 fois avant d'être restitué, pour un niveau annoncé à 80 dB, et le volume est réglable par potentiomètre.
Non. Le circuit amplificateur, le haut-parleur et le potentiomètre sont déjà montés sur la platine, et le cordon de raccordement est fourni. Il suffit de relier trois fils à votre carte : alimentation 5 V, masse et entrée du signal.
C'est possible pour des essais à volume modéré, mais ce n'est pas l'idéal. Prévoyez une source capable de fournir au moins 500 mA : une alimentation trop juste se manifeste par un son qui se dégrade dans les passages forts et peut perturber la carte elle-même.
En ramenant systématiquement le potentiomètre au minimum avant la mise sous tension, puis en montant le volume progressivement. Le haut-parleur intégré est donné pour 0,15 W alors que le circuit amplificateur admet jusqu'à 2 W : c'est donc le haut-parleur qui fixe la limite réelle, et il faut résister à la tentation de pousser le réglage à fond dès le premier essai.
Un signal audio de faible niveau. Pour des essais avec un microcontrôleur, le plus simple est un signal carré de fréquence variable, tel que le produit la fonction tone() d'Arduino : c'est ce que fait le programme de démonstration fourni plus haut. Le module accepte tout aussi bien le signal issu d'un module lecteur audio ou d'un convertisseur numérique-analogique.
Oui. Le module ne demande qu'une alimentation 5 V et un signal audio sur son entrée : il s'accommode donc de n'importe quel microcontrôleur ou de n'importe quelle source de faible niveau, dès lors que l'alimentation disponible est suffisante.
Le réglage se fait par le potentiomètre monté sur la carte, une fois pour toutes, en fonction de l'environnement d'utilisation. Rien n'empêche toutefois d'agir en amont sur le signal envoyé par le microcontrôleur si votre application demande une variation de niveau pilotée par logiciel.
Ce module s'adresse à tous ceux qui butent sur la même limite : un montage à microcontrôleur qui devrait se faire entendre et qui n'y parvient pas. Les enseignants de technologie et de sciences de l'ingénieur y trouveront un support court et concret pour introduire la notion d'amplification, sur un montage que l'on câble en trois fils et dont le résultat s'entend à l'oreille sans instrument de mesure. Les makers et les électroniciens amateurs l'utiliseront comme brique sonore prête à l'emploi dans un projet domotique, un automate, une installation d'exposition ou un objet interactif. Dans tous les cas, gardez la même discipline au premier branchement : potentiomètre au minimum, puis on monte doucement.
La carte Arduino UNO Rev 3 A000066 est très certainement le plus modèle le plus populaire et le plus utilisé de la gamme Arduino. Conçue sur la base d'un microcontrôleur ATmega328 avec bootloader intégré, cette version est le modèle officiel fabriqué en Italie.
Cette carte à microcontrôleur basée sur un ATmega2560 est compatible avec la Mega2560. Livrée avec son câble USB, elle dispose de 54 broches d'entrée/sortie numériques (dont 15 peuvent être utilisées comme sorties MLI) et 16 en entrées analogiques.
Basée sur un microcontrôleur ATmega328, la carte OPENLEX001 est entièrement compatible avec la carte Uno. Livrée avec son câble USB, cette dernière dispose de 14 broches d'entrée/sortie numériques (dont 6 peuvent être utilisées comme sorties MLI) et 6 en entrées analogiques.