Lecture audio avec ESP32 et MAX98357

Dans cet article, vous allez apprendre à utiliser le module amplificateur MAX98357A avec l’ESP32 pour lire de l’audio.

Le MAX98357A est un convertisseur numérique-analogique (DAC) compact avec amplificateur intégré. Il reçoit les données audio numériques via le protocole I2S et délivre un son amplifié directement à un haut-parleur. Cette combinaison simplifie votre montage matériel et améliore la qualité sonore.

Tout au long de ce tutoriel, vous apprendrez à générer des signaux audio, convertir du texte en parole, diffuser la radio internet, lire des fichiers MP3 depuis une carte SD et utiliser l’audio Bluetooth.

Matériel nécessaire

Vous aurez besoin d’au moins un module MAX98357A. Si vous souhaitez lire du son en stéréo, il vous faudra deux modules MAX98357A. De même, il vous faudra deux haut-parleurs de 4-8 Ω et d’au moins 3 Watts.

Pour lire des fichiers MP3 depuis une carte SD, il vous faudra également une carte SD d’au moins 1 Go et un module lecteur de carte SD.

Enfin, il vous faut un ESP32, une breadboard et quelques câbles. J’ai utilisé un ESP32 lite mais la plupart des autres cartes ESP32 devraient aussi fonctionner. Idéalement, choisissez un ESP32-S3 avec PSRAM si vous prévoyez de stocker et lire de la musique depuis la mémoire.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Le protocole audio I2S

Commençons par une brève introduction au protocole I2S utilisé pour transférer les données audio numériquement d’un ESP32 vers un module amplificateur comme le MAX98357.

I2S, ou Inter-IC Sound, est une norme d’interface de bus série utilisée pour connecter des dispositifs audio numériques. Il a été introduit par Philips dans les années 1980 pour simplifier la transmission des données audio entre circuits intégrés. Contrairement à des protocoles comme SPI ou I2C, I2S est spécialement conçu pour les applications audio, garantissant un timing précis et la synchronisation des flux audio.

Au cœur du protocole, I2S transfère des données audio en modulation par impulsions codées (PCM) de manière synchrone. Le protocole utilise trois signaux principaux : l’horloge série (SCK), la sélection de mot (WS) et les données série (SD). L’horloge série pulse au rythme des bits, indiquant quand les bits sont envoyés. Le signal de sélection de mot bascule pour indiquer si les données actuelles correspondent au canal audio gauche ou droit. Enfin, la ligne de données série transporte les bits audio réels, en transmettant d’abord le bit de poids fort (MSB).

En général, les données audio sont envoyées sous forme de mots de 16 ou 24 bits, mais le protocole peut supporter d’autres profondeurs de bits selon le matériel.

Le périphérique I2S de l’ESP32 prend en charge la communication full-duplex, permettant une entrée et une sortie audio simultanées. Il peut être configuré en mode maître ou esclave. En mode maître, l’ESP32 génère les signaux d’horloge et de sélection de mot. C’est la configuration la plus courante avec le MAX98357A, qui agit comme un périphérique esclave I2S. Dans la section suivante, nous allons examiner de plus près le MAX98357A.

Caractéristiques techniques du module MAX98357A

Le module MAX98357A est un amplificateur numérique qui accepte directement une entrée I2S. Il convertit le flux audio numérique entrant en un signal analogique et l’amplifie pour alimenter des haut-parleurs. Il intègre un amplificateur Classe D de 3,2W avec un convertisseur numérique-analogique (DAC) intégré. L’interface audio numérique reconnaît jusqu’à 35 schémas d’horloge PCM et TDM différents, ce qui élimine le besoin de programmation I2C.

Le MAX98357A prend en charge des échantillons audio de 16, 24 et 32 bits à des fréquences d’échantillonnage allant de 8 kHz à 96 kHz. Cette flexibilité permet une lecture audio de haute qualité adaptée à la voix, à la musique et à d’autres applications sonores.

Le module fonctionne avec une alimentation unique de 3,3V ou 5V, ce qui le rend compatible avec la plupart des microcontrôleurs, y compris l’ESP32. Il dispose d’un régulateur intégré à faible chute de tension et d’une protection contre la surchauffe. L’image ci-dessous montre l’avant et l’arrière d’un module MAX98357A typique :

Côté entrée, le MAX98357A attend trois signaux principaux : horloge de bits (BCLK), sélection de mot (LRC) et données série (SD). L’horloge de bits synchronise les bits de données, tandis que la sélection de mot indique si les données actuelles correspondent au canal gauche ou droit. La ligne de données série transporte les échantillons audio réels en continu.

En interne, le module convertit les données audio numériques entrantes en un signal analogique grâce à son DAC intégré. Ce signal analogique est ensuite amplifié par l’étage amplificateur Classe D, qui alimente un haut-parleur de 4 ou 8 Ω avec 3 Watts.

Le MAX98357A inclut un contrôle de gain et peut être configuré pour produire un canal gauche, droit ou un mixage des deux à partir de l’entrée stéréo via la broche SD. Dans la section suivante, nous détaillerons ces broches.

Brochage du module MAX98357A

Un module MAX98357A typique possède des broches pour l’alimentation (Vin, GND), pour l’interface I2S (LRC, BCLK, DIN), pour le contrôle du gain (GAIN) et pour la sélection du canal et l’arrêt (SD). L’image ci-dessous montre le brochage :

Alimentation

La broche VIN accepte de 3,3V à 5V. La broche GND est la référence de masse et doit être reliée à la masse de l’ESP32.

La consommation du MAX98357A pour une lecture audio à volume modéré est généralement comprise entre 200mA et 400mA. Le régulateur de tension d’une carte ESP32 classique fournit environ 800mA, mais l’ESP32 lite utilise un ME6211 limité à 500mA.

Cela signifie que vous pouvez alimenter un MAX98357A depuis la broche 3,3V d’un ESP32, mais c’est risqué, car à volume élevé et gain maximum, le courant peut monter jusqu’à 1,5A (sous 5V). Il est donc préférable d’alimenter le MAX98357A avec une source externe.

Notez que le MAX98357A intègre une limitation de courant de sortie pour le haut-parleur à 2,8A. Si le courant dépasse cette valeur, la puce s’arrête temporairement et redémarre pour se protéger.

Interface I2S

La broche LRC signifie Left-Right Clock ou Word Select. Elle indique si les données audio actuelles appartiennent au canal gauche ou droit. L’ESP32 génère ce signal dans le cadre du protocole I2S.

La broche BCLK est l’horloge de bits. Elle synchronise les bits de données envoyés sur la ligne DIN. L’ESP32 fournit également ce signal d’horloge.

La broche DIN est la ligne d’entrée des données. Cette broche reçoit les données audio de l’ESP32.

Contrôle du gain

Vous pouvez contrôler le gain du MAX98357A en connectant la broche gain à VCC ou GND directement ou via une résistance de 100K. Le tableau suivant indique quelle connexion donne quel gain.

Gain	Connexion
15dB	GAIN — 100K — GND
12dB	GAIN — GND
9dB	Aucune
6dB	GAIN — VCC
3dB	GAIN — 100K — VCC

Le gain de 9dB est la configuration par défaut et aucune connexion n’est alors nécessaire.

Contrôle du canal

La broche SD (Shutdown) du MAX98357A permet d’éteindre l’amplificateur ou de sélectionner la sortie droite, gauche ou mixte à partir de l’entrée stéréo. L’image ci-dessous montre le schéma du module MAX98357A avec la broche SD Mode et les informations pour sélectionner un canal :

Si la broche SD n’est pas connectée (par défaut), l’amplificateur génère une sortie mixte des canaux gauche et droit ((L+R)/2). Si la broche SD est reliée à la masse, l’amplificateur est éteint. Sinon, la tension sur SD détermine si le canal gauche ou droit est amplifié. Le tableau suivant indique les tensions requises sur la broche SD pour activer les différentes fonctions :

Tension @ SD	Fonction
< 0.16V	Amplificateur éteint
0.16 … 0.77V	Canaux gauche et droit mixés ((L+R)/2)
0.77 … 1.4V	Canal droit (370KΩ @ 5V, 210KΩ @ 3V3)
> 1.4V	Canal gauche uniquement (100kΩ)

Pour obtenir la tension requise sur la broche SD afin de sélectionner le canal droit, il faut connecter la broche SD à VCC via une résistance adaptée. Le schéma indique la formule suivante :

R = (94 * VDD – 100) KΩ

Cela signifie qu’à 5V il faut une résistance de 370KΩ entre SD et 5V, et à 3,3V une résistance de 210KΩ.

Pour sélectionner le canal gauche, vous pouvez utiliser une résistance de 100kΩ à 5V ou 3,3V. Et si vous souhaitez une sortie mixte (mono sommée), laissez simplement la broche SD non connectée.

Datasheet

Le bouton suivant mène à la datasheet du MAX98357A, où vous trouverez plus de détails techniques :

Connecter le MAX98357A à l’ESP32

Dans cette section, vous allez découvrir les différentes façons de connecter le MAX98357A et les haut-parleurs à un ESP32.

Mono mixé

On commence par la configuration la plus simple. On utilise un seul MAX98357A et un seul haut-parleur pour lire un signal stéréo mixé (50% canal gauche, 50% canal droit).

Commencez par connecter Vin du MAX98357A au 3,3V de l’ESP32 et GND à G. Ensuite, connectez les broches I2S comme indiqué dans le tableau suivant :

MAX98357A	ESP32
Vin	3V3
GND	G
LRC	32
BCLK	25
DIN	33

Laissez les broches GAIN et SD du MAX98357A non connectées. Cela produira un mixage des canaux gauche et droit avec un gain de 9dB.

Lors du branchement du haut-parleur, faites attention à la polarité et utilisez un haut-parleur de 4Ω ou 8Ω d’au moins 3W. Vous pouvez utiliser des haut-parleurs de puissance supérieure mais pas inférieure.

L’image suivante montre le câblage complet d’un MAX98357A avec un ESP32 lite pour un son mono mixé, alimenté via la broche 3,3V :

Comme mentionné précédemment, le MAX98357A peut consommer jusqu’à 1,5A lorsqu’il joue du son fort avec gain maximum. La broche 3,3V de l’ESP32 ne peut pas fournir autant de courant, il faut donc utiliser une alimentation externe. L’image ci-dessous montre comment connecter une alimentation externe 5V au circuit :

Stéréo

Si vous souhaitez lire du son en stéréo, il vous faut deux haut-parleurs, deux MAX98357A (un par canal) et des résistances pour sélectionner le canal gauche ou droit. L’image ci-dessous montre le câblage complet :

Les deux MAX98357A sont câblés en parallèle, utilisant la même alimentation et les mêmes broches I2S que précédemment. La seule différence est que le MAX98357A pour le canal gauche a une résistance de 100KΩ entre SD et 3,3V, et celui pour le canal droit a une résistance de 210KΩ.

Notez que l’ESP32 doit produire un signal stéréo et que le MAX98357A sélectionne simplement le canal gauche ou droit de l’entrée stéréo selon la tension sur la broche SD.

Comme précédemment, au lieu d’alimenter le MAX98357A via la broche 3,3V de l’ESP32, il est plus sûr d’utiliser une alimentation externe. Le schéma de câblage montre comment utiliser une alimentation externe 5V :

Notez que la broche SD du MAX98357A est toujours reliée à 3,3V via une résistance de 100KΩ ou 210KΩ. Vous pouvez aussi connecter les résistances à l’alimentation externe 5V, mais il faudra alors utiliser une résistance de 370KΩ pour le canal droit au lieu de 210KΩ. La résistance de 100KΩ pour le canal gauche reste inchangée.

Carte SD

Si vous souhaitez lire des fichiers audio, il faut connecter un lecteur de carte SD qui stocke les fichiers audio sur une carte SD. Le schéma ci-dessous montre comment connecter un lecteur de carte SD et le MAX98357A à un ESP32 :

Le lecteur de carte SD communique via SPI et les broches SPI par défaut de l’ESP32 sont CS=5, MOSI=23, CLK=18 et MISO=19. Le tableau ci-dessous résume les connexions à réaliser entre le lecteur de carte SD et l’ESP32 :

Lecteur de carte SD	ESP32
3V3	3V
GND	G
CS/SS	5
MOSI	23
CLK/SCK	18
MISO	19

Si vous n’êtes pas sûr des broches SPI par défaut de votre ESP32, consultez le Find I2C and SPI default pins tutoriel.

Si vous souhaitez lire du son en stéréo, il faut connecter deux modules MAX98357A. Le schéma suivant montre comment faire :

Si vous avez besoin d’aide pour connecter le lecteur de carte SD, consultez notre SD Card Module with ESP32 tutoriel.

Installation des bibliothèques

Il existe plusieurs bibliothèques Arduino que vous pouvez utiliser pour générer de l’audio pour un périphérique I2S comme le MAX98357A. Ci-dessous, je présente rapidement les trois plus utilisées.

Tout d’abord, il y a la bibliothèque ESP8266Audio d’Earle F. Philhower, qui prend en charge les cartes ESP8266, ESP32, Raspberry Pi Pico RP2040 et Pico 2 RP2350.

Ensuite, il y a la bibliothèque ESP32-audioI2S de schreibfaul1. Notez que cette bibliothèque ne fonctionne que sur les puces multi-cœurs comme ESP32, ESP32-S3, ESP32-P4 et votre carte doit avoir de la PSRAM. Elle ne fonctionne pas sur les cartes ESP32-S2, ESP32-C3.

Enfin, il y a la bibliothèque arduino-audio-tools de Phil Schatzmann, qui est la bibliothèque la plus puissante avec énormément de fonctions. C’est celle que nous allons utiliser dans ce tutoriel, mais les autres valent aussi le détour.

Installer le core ESP32

En janvier 2026, je n’ai pas réussi à faire fonctionner la bibliothèque arduino-audio-tools avec le core ESP32 actuel (Version 3.3.6). Pour les exemples de ce tutoriel, il faut rétrograder le core ESP32 à la version 2.0.17.

En supposant que vous avez déjà installé le core ESP32, le rétrograder est facile. Ouvrez le BOARDS MANAGER, tapez “esp32” dans la barre de recherche puis sélectionnez la version 2.0.17 pour le core “esp32 by Espressif” et cliquez sur “UPDATE” comme ci-dessous :

Si vous avez besoin d’aide pour rétrograder ou installer le core ESP, consultez le Install ESP32 core in Arduino IDE tutoriel.

Installer la bibliothèque arduino-audio-tools

Pour installer la bibliothèque arduino-audio-tools, allez sur le arduino-audio-tools repo, cliquez sur le bouton vert « <> Code » puis sur « Download ZIP » pour télécharger la bibliothèque au format ZIP comme ci-dessous :

Ensuite, ouvrez un Sketch, allez dans Sketch -> Include Library -> Add .ZIP Library … pour installer la bibliothèque ZIP téléchargée (arduino-audio-tools-main.zip) :

Pour certains exemples de code, il nous faut deux autres bibliothèques de Phil Schatzmann : à savoir la bibliothèque arduino-libhelix et la bibliothèque ESP32-A2DP. Vous pouvez les installer de la même façon. Cliquez sur le lien pour accéder au repo github, cliquez sur le bouton vert « <> Code » pour télécharger les bibliothèques (arduino-libhelix-main.zip, ESP32-A2DP-main.zip) puis installez-les.

Lire un son de test

Avant d’essayer quelque chose de plus complexe, essayons d’abord de lire un son de test. Cela permettra de vérifier le câblage du MAX98357A avec l’ESP32 et que les canaux gauche et droit sont correctement sélectionnés en stéréo. Ce code ne dépend d’aucune bibliothèque et fonctionne avec le core ESP32 actuel (3.x) et l’ancien (2.x).

#include <driver/i2s.h>
#include <math.h>

#define I2S_PORT I2S_NUM_0

// MAX98357
#define MAX_DIN 33   
#define MAX_LRC 32   
#define MAX_BCLK 25  

// Audio parameters
#define SAMPLE_RATE 44100
#define TONE_FREQ 500
#define AMPLITUDE 1000  // Max 32767

// Channels
#define LEFT false
#define RIGHT true

// Buffer size (frames, not samples)
#define BUFFER_LEN 256

// Stereo buffer: Left, Right
int16_t samples[BUFFER_LEN * 2];

void setup() {
  i2s_config_t i2s_config = {
    .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX),
    .sample_rate = SAMPLE_RATE,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
    .communication_format = I2S_COMM_FORMAT_I2S,
    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
    .dma_buf_count = 8,
    .dma_buf_len = BUFFER_LEN,
    .use_apll = false,
    .tx_desc_auto_clear = true,
    .fixed_mclk = 0
  };

  i2s_pin_config_t pin_config = {
    .bck_io_num = MAX_BCLK,
    .ws_io_num = MAX_LRC,
    .data_out_num = MAX_DIN,
    .data_in_num = I2S_PIN_NO_CHANGE
  };

  i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
  i2s_set_pin(I2S_PORT, &pin_config);
}

void loop() {
  static float phase = 0.0;
  const float phaseIncrement = 2.0 * PI * TONE_FREQ / SAMPLE_RATE;

  for (int i = 0; i < BUFFER_LEN; i++) {
    int16_t sound = (int16_t)(AMPLITUDE * sin(phase));
    int16_t silence = 0;

    samples[2 * i] = (LEFT) ? sound : silence;       // Left channel
    samples[2 * i + 1] = (RIGHT) ? sound : silence;  // Right channel

    phase += phaseIncrement;
    if (phase >= 2.0 * PI) phase -= 2.0 * PI;
  }

  size_t bytes_written;
  i2s_write(I2S_PORT, samples, sizeof(samples), &bytes_written, portMAX_DELAY);
}

Le code configure l’ESP32 comme émetteur maître I2S, génère un signal audio sinusoïdal en temps réel et l’envoie à l’amplificateur pour produire du son sur le canal gauche, droit ou les deux.

Imports

Le code inclut la bibliothèque driver/i2s.h, qui fournit les fonctions du driver I2S de l’ESP32 pour la communication audio. Il inclut aussi la bibliothèque mathématique standard math.h pour utiliser des fonctions mathématiques comme sin() pour générer la forme d’onde audio.

#include <driver/i2s.h>;
#include <math.h>;

Constantes

Plusieurs constantes sont définies pour configurer l’interface I2S et les paramètres audio. I2S_PORT sélectionne le périphérique I2S numéro 0 sur l’ESP32. Les broches MAX_DIN, MAX_LRC et MAX_BCLK correspondent aux lignes de données, de sélection de mot (horloge gauche-droite) et d’horloge de bits connectées à l’amplificateur MAX98357.

Les paramètres audio incluent une fréquence d’échantillonnage de 44 100 Hz, une fréquence de tonalité de 500 Hz et une amplitude de 1000 (sur la plage d’un entier signé 16 bits). Le code définit aussi des indicateurs booléens LEFT et RIGHT pour contrôler quels canaux audio produisent du son.

Enfin, BUFFER_LEN définit le nombre d’échantillons audio par tampon, et un tableau stéréo samples contient les échantillons audio intercalés des canaux gauche et droit.

#define I2S_PORT I2S_NUM_0

// MAX98357
#define MAX_DIN 33   
#define MAX_LRC 32   
#define MAX_BCLK 25  

// Audio parameters
#define SAMPLE_RATE 44100
#define TONE_FREQ 500
#define AMPLITUDE 1000  // Max 32767

// Channels
#define LEFT false
#define RIGHT true

// Buffer size (frames, not samples)
#define BUFFER_LEN 256

// Stereo buffer: Left, Right
int16_t samples[BUFFER_LEN * 2];

Fonction setup

La fonction setup() initialise le driver I2S et configure les broches pour la communication avec l’amplificateur MAX98357.

Une structure i2s_config_t est créée pour spécifier le mode I2S comme émetteur maître, échantillons 16 bits, format stéréo (droit et gauche) et fréquence d’échantillonnage de 44,1 kHz. Elle définit aussi les paramètres du tampon DMA pour un transfert efficace des données.

Ensuite, une structure i2s_pin_config_t assigne les broches GPIO pour l’horloge de bits (bck_io_num), la sélection de mot (ws_io_num) et la sortie de données (data_out_num). La broche d’entrée de données n’est pas utilisée et est définie sur I2S_PIN_NO_CHANGE.

Enfin, le driver I2S est installé avec i2s_driver_install() et la configuration des broches appliquée avec i2s_set_pin().

void setup() {
  i2s_config_t i2s_config = {
    .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX),
    .sample_rate = SAMPLE_RATE,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
    .communication_format = I2S_COMM_FORMAT_I2S,
    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
    .dma_buf_count = 8,
    .dma_buf_len = BUFFER_LEN,
    .use_apll = false,
    .tx_desc_auto_clear = true,
    .fixed_mclk = 0
  };

  i2s_pin_config_t pin_config = {
    .bck_io_num = MAX_BCLK,
    .ws_io_num = MAX_LRC,
    .data_out_num = MAX_DIN,
    .data_in_num = I2S_PIN_NO_CHANGE
  };

  i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
  i2s_set_pin(I2S_PORT, &pin_config);
}

Fonction loop

La fonction loop() génère en continu des échantillons audio et les envoie au périphérique I2S pour la lecture.

Une variable statique phase garde la position actuelle dans le cycle de la sinusoïde. Le phaseIncrement est calculé selon la fréquence de la tonalité et la fréquence d’échantillonnage, déterminant l’avance de phase par échantillon.

Dans la boucle, le code remplit le tampon samples avec les données audio stéréo intercalées. Pour chaque trame, il calcule le sinus de la phase actuelle, le multiplie par l’amplitude et le convertit en entier 16 bits. Selon les indicateurs LEFT et RIGHT, le son est affecté au canal gauche et/ou droit, l’autre canal étant mis à zéro (silence).

La phase est incrémentée et remise à zéro pour rester dans la plage de 0 à 2π radians, assurant une onde continue.

Après avoir rempli le tampon, la fonction i2s_write() envoie les données audio au driver I2S, qui les transmet à l’amplificateur. La fonction attend que tous les octets soient écrits, assurant une lecture audio fluide.

void loop() {
  static float phase = 0.0;
  const float phaseIncrement = 2.0 * PI * TONE_FREQ / SAMPLE_RATE;

  for (int i = 0; i < BUFFER_LEN; i++) {
    int16_t sound = (int16_t)(AMPLITUDE * sin(phase));
    int16_t silence = 0;

    samples[2 * i] = (LEFT) ? sound : silence;       // Left channel
    samples[2 * i + 1] = (RIGHT) ? sound : silence;  // Right channel

    phase += phaseIncrement;
    if (phase >= 2.0 * PI) phase -= 2.0 * PI;
  }

  size_t bytes_written;
  i2s_write(I2S_PORT, samples, sizeof(samples), &bytes_written, portMAX_DELAY);
}

Vous pouvez utiliser ce code pour vérifier que le son stéréo est correctement joué avec deux modules MAX98357 et deux haut-parleurs. Si vous mettez la constante LEFT à true et RIGHT à false, seul le haut-parleur gauche doit jouer. De même, vérifiez que le canal droit fonctionne. Sinon, vérifiez la tension et les résistances sur la broche SD du MAX98357, qui contrôle le canal.

Pour les exemples suivants, nous utiliserons la bibliothèque arduino-audio-tools, qui masquera tous les détails de la communication I2S et simplifiera le code.

Texte en parole

Cet exemple montre comment convertir du texte en parole via l’interface I2S avec un amplificateur MAX98357. Il se connecte au WiFi, envoie le texte à l’API Text-to-Speech (TTS) d’OpenAI, reçoit un flux audio MP3, le décode et le joue via l’amplificateur. Le code utilise la bibliothèque arduino-audio-tools pour gérer le streaming et le décodage audio.

/*
www.makerguides.com

Libraries:
- ESP32 Core 2.0.17
- [arduino-audio-tools](https://github.com/pschatzmann/arduino-audio-tools) 
  Version: 1.2.2
- [arduino-libhelix](https://github.com/pschatzmann/arduino-libhelix)
  Version: 0.9.2
*/

#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include "AudioTools.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"

// MAX98357 I2S pins
#define MAX_DIN   33
#define MAX_LRC   32
#define MAX_BCLK  25

// Text to Speech
#define TTS_MODEL "gpt-4o-mini-tts"
#define TTS_VOICE "marin"
#define TTS_VOLUME 0.6

// WiFi credentials
const char* ssid     = "ssid";
const char* password = "pwd";

// OpenAI configuration
const char* openaiHost = "api.openai.com";
const int   openaiPort = 443;
const char* openaiApiKey = "apikey";


WiFiClientSecure client;
I2SStream i2s;
VolumeStream volume(i2s);
EncodedAudioStream mp3decode(&volume, new MP3DecoderHelix());
StreamCopy copier(mp3decode, client);

void text2speech(const char* text) {
  client.setInsecure(); 

  if (!client.connect("api.openai.com", 443)) {
    Serial.println("Connection failed");
    return;
  }

  String body = String("{") +
    "\"model\":\"" + TTS_MODEL + "\"," +
    "\"voice\":\"" + TTS_VOICE +  "\"," +
    "\"format\":\"mp3\"," +
    "\"input\":\"" + text + "\"" +
  "}";

  client.println("POST /v1/audio/speech HTTP/1.1");
  client.println("Host: api.openai.com");
  client.println("Authorization: Bearer " + String(openaiApiKey));
  client.println("Content-Type: application/json");
  client.print("Content-Length: ");
  client.println(body.length());
  client.println();
  client.print(body);

  // ---- Skip HTTP headers ----
  while (client.connected()) {
    String line = client.readStringUntil('\n');
    if (line == "\r") break;
  }
}

void setup() {
  Serial.begin(115200);
  AudioLogger::instance().begin(Serial, AudioLogger::Warning);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }

  auto config = i2s.defaultConfig(TX_MODE);
  config.pin_bck  = MAX_BCLK;
  config.pin_ws   = MAX_LRC;
  config.pin_data = MAX_DIN;
  i2s.begin(config);

  mp3decode.begin();
  volume.begin(config);
  volume.setVolume(TTS_VOLUME);

  text2speech("Hello, this a test for text to speech.");
}

void loop() {
  copier.copy();
}

Imports

Le code commence par inclure plusieurs bibliothèques. Arduino.h est la bibliothèque Arduino principale. WiFi.h et WiFiClientSecure.h fournissent la connectivité WiFi et le client HTTPS sécurisé. La bibliothèque AudioTools et son codec MP3 CodecMP3Helix sont utilisés pour le streaming et le décodage audio.

#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include "AudioTools.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"

Constantes et définition des broches

Ensuite, les broches utilisées pour l’interface I2S vers l’amplificateur MAX98357 sont définies. Ces broches correspondent à l’entrée de données (MAX_DIN), la sélection de mot ou horloge gauche-droite (MAX_LRC) et l’horloge de bits (MAX_BCLK).

// MAX98357 I2S pins
#define MAX_DIN   33
#define MAX_LRC   32
#define MAX_BCLK  25

Des constantes pour le modèle TTS, la voix et le niveau de volume sont également définies.

// Text to Speech
#define TTS_MODEL "gpt-4o-mini-tts"
#define TTS_VOICE "marin"
#define TTS_VOLUME 0.6

Vous pouvez essayer d’autres modèles TTS comme « tts-1 » et d’autres voix comme « alloy », « ash », « coral », « echo », « fable », « onyx », « nova », « sage », « shimmer », « marin », « cedar ». Pour plus de détails, consultez platform.openai.com/docs/guides/text-to-speech.

Les identifiants WiFi et les détails de l’API OpenAI sont aussi stockés en constantes. Vous devrez remplacer « ssid » et « pwd » par vos identifiants WiFi.

// WiFi credentials
const char* ssid     = "ssid";
const char* password = "pwd";

Vous devrez aussi obtenir une « apikey » auprès d’OpenAI. Rendez-vous sur https://platform.openai.com et inscrivez-vous avec une adresse email ou un compte Google ou Microsoft existant.

// OpenAI configuration
const char* openaiHost = "api.openai.com";
const int   openaiPort = 443;
const char* openaiApiKey = "apikey";

Après avoir vérifié votre email et terminé la configuration initiale, connectez-vous au tableau de bord OpenAI, platform.openai.com/api-keys et trouvez ou créez votre clé API (=SECRET KEY) comme ci-dessous :

La clé API est une longue chaîne unique commençant par « sk-proj- » qui sert à authentifier vos requêtes API (voir ci-dessous).

sk-proj-xcA.......................OtDu0U

C’est tout ce qu’il faut pour obtenir une clé API, mais je vous recommande aussi de définir une limite d’utilisation sur votre compte. Pour plus de détails, consultez le Vision Chatbot with DFRobot ESP32-S3 AI Camera and OpenAI tutoriel.

Objets audio et réseau

Plusieurs objets sont instanciés pour gérer le streaming audio et la communication réseau. WiFiClientSecure gère la connexion HTTPS à l’API OpenAI. I2SStream gère la sortie audio I2S. VolumeStream encapsule le flux I2S pour contrôler le volume audio. EncodedAudioStream décode les données audio MP3 avec le décodeur Helix MP3. Enfin, StreamCopy copie le flux audio décodé du client réseau vers la sortie audio.

WiFiClientSecure client;
I2SStream i2s;
VolumeStream volume(i2s);
EncodedAudioStream mp3decode(&volume, new MP3DecoderHelix());
StreamCopy copier(mp3decode, client);

Fonction Text-to-Speech

La fonction text2speech() envoie une chaîne de texte à l’API TTS d’OpenAI et prépare le flux audio pour la lecture. Elle configure d’abord le client pour accepter les certificats non sécurisés (pratique pour le développement). Ensuite, elle tente de se connecter au serveur OpenAI sur le port 443. Si la connexion échoue, elle affiche un message d’erreur et retourne.

La fonction construit un corps JSON spécifiant le modèle TTS, la voix, le format de sortie (MP3) et le texte d’entrée. Elle envoie une requête HTTP POST avec les bons en-têtes, y compris l’autorisation via la clé API. Après l’envoi du corps de la requête, elle lit et saute les en-têtes de réponse HTTP pour positionner le flux client au début des données audio MP3.

void text2speech(const char* text) {
  client.setInsecure(); 

  if (!client.connect("api.openai.com", 443)) {
    Serial.println("Connection failed");
    return;
  }

  String body = String("{") +
    "\"model\":\"" + TTS_MODEL + "\"," +
    "\"voice\":\"" + TTS_VOICE +  "\"," +
    "\"format\":\"mp3\"," +
    "\"input\":\"" + text + "\"" +
  "}";

  client.println("POST /v1/audio/speech HTTP/1.1");
  client.println("Host: api.openai.com");
  client.println("Authorization: Bearer " + String(openaiApiKey));
  client.println("Content-Type: application/json");
  client.print("Content-Length: ");
  client.println(body.length());
  client.println();
  client.print(body);

  // ---- Skip HTTP headers ----
  while (client.connected()) {
    String line = client.readStringUntil('\n');
    if (line == "\r") break;
  }
}

Fonction setup

La fonction setup() initialise la communication série pour le débogage et configure le logger audio pour afficher les avertissements. Elle se connecte ensuite au réseau WiFi spécifié, en attendant que la connexion soit établie.

Une fois le WiFi connecté, l’interface I2S est configurée en mode transmission avec les broches définies plus tôt. Le flux I2S, le décodeur MP3 et le contrôle du volume sont initialisés. Le volume est réglé au niveau prédéfini.

Enfin, la fonction text2speech() est appelée avec une chaîne de texte exemple pour lancer le streaming et la lecture de la synthèse vocale.

void setup() {
  Serial.begin(115200);
  AudioLogger::instance().begin(Serial, AudioLogger::Warning);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }

  auto config = i2s.defaultConfig(TX_MODE);
  config.pin_bck  = MAX_BCLK;
  config.pin_ws   = MAX_LRC;
  config.pin_data = MAX_DIN;
  i2s.begin(config);

  mp3decode.begin();
  volume.begin(config);
  volume.setVolume(TTS_VOLUME);

  text2speech("Hello, this a test for text to speech.");
}

Fonction loop

La fonction loop() copie en continu les données du flux décodeur MP3 vers la sortie audio I2S. Cela permet de lire l’audio tant qu’il y a des données disponibles depuis le client réseau.

void loop() {
  copier.copy();
}

Radio internet

Cet exemple montre comment réaliser une simple radio Web. Il se connecte à un réseau WiFi, diffuse une radio internet au format MP3, décode l’audio, ajuste le volume et sort le son via l’amplificateur numérique MAX98357.

/*
www.makerguides.com

Libraries:
- ESP32 Core 2.0.17
- [arduino-audio-tools](https://github.com/pschatzmann/arduino-audio-tools) 
  Version: 1.2.2
- [arduino-libhelix](https://github.com/pschatzmann/arduino-libhelix)
  Version: 0.9.2
*/

#include <Arduino.h>
#include <WiFi.h>
#include <Wire.h>
#include "AudioTools.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
#include "AudioTools/Communication/HTTP/ICYStream.h"

// MAX98357
#define MAX_DIN 33   // serial data
#define MAX_LRC 32   // word select
#define MAX_BCLK 25  // serial clock
#define MAX_VOL 0.5  // Volume

const char* ssid = "ssid";
const char* password = "pwd";
const char* url = "https://jazz.stream.laut.fm/jazz";

ICYStream icystream;
I2SStream i2s;
VolumeStream volume(i2s);
EncodedAudioStream mp3decode(&volume, new MP3DecoderHelix());
StreamCopy copier(mp3decode, icystream);

void callbackMetadata(MetaDataType type, const char* str, int len) {
  Serial.printf("%s: %s\n", toStr(type), str);
}

void setup() {
  Serial.begin(115200);
  AudioLogger::instance().begin(Serial, AudioLogger::Warning);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }

  auto config = i2s.defaultConfig(TX_MODE);
  config.pin_bck = MAX_BCLK;
  config.pin_ws = MAX_LRC;
  config.pin_data = MAX_DIN;

  i2s.begin(config);
  volume.begin(config);
  volume.setVolume(MAX_VOL);
  mp3decode.begin();
  icystream.begin(url);
  icystream.setMetadataCallback(callbackMetadata);
}

void loop() {
  copier.copy();
}

Imports

Le code commence par inclure les bibliothèques nécessaires à la connectivité WiFi, à la communication I2C et au traitement audio. Les bibliothèques Arduino.h et WiFi.h fournissent les fonctions de base Arduino et WiFi. La bibliothèque Wire.h est incluse pour la communication I2C, souvent utilisée pour contrôler des périphériques. La bibliothèque AudioTools et ses composants associés gèrent le streaming, le décodage et la lecture audio.

#include <Arduino.h>
#include <WiFi.h>
#include <Wire.h>
#include "AudioTools.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
#include "AudioTools/Communication/HTTP/ICYStream.h"

Constantes

Ensuite, les broches pour l’amplificateur MAX98357 sont définies. Ces broches correspondent aux signaux I2S : MAX_DIN pour l’entrée de données série, MAX_LRC pour la sélection de mot (horloge gauche-droite) et MAX_BCLK pour l’horloge série. Le volume est défini comme une valeur flottante entre 0 et 1, où MAX_VOL vaut 0,5, soit 50% du volume.

#define MAX_DIN 33   // serial data
#define MAX_LRC 32   // word select
#define MAX_BCLK 25  // serial clock
#define MAX_VOL 0.5  // Volume

Identifiants WiFi et URL du flux

Les identifiants du réseau WiFi sont stockés dans les constantes ssid et password. La constante url contient l’adresse du flux radio internet à lire, ici un flux jazz.

const char* ssid = "ssid";
const char* password = "pwd";
const char* url = "https://jazz.stream.laut.fm/jazz";

Voici quelques autres URLs de radios internet à essayer :

"https://jazz.stream.laut.fm/jazz"
"http://vis.media-ice.musicradio.com/CapitalMP3";
"http://stream.srg-ssr.ch/m/rsj/mp3_128"
"http://stream.live.vc.bbcmedia.co.uk/bbc_world_service"
"http://icecast.omroep.nl/radio1-bb-mp3"
"http://stream-02-eu.relaxingjazz.com/stream/1/"

Objets audio

Plusieurs objets sont instanciés pour gérer la chaîne audio. L’objet ICYStream gère le streaming HTTP de la radio internet et la sortie audio I2S. L’objet VolumeStream encapsule le flux I2S pour contrôler le volume. Et l’objet EncodedAudioStream décode les données MP3 avec le codec MP3DecoderHelix. Enfin, l’objet StreamCopy copie les données audio décodées du décodeur MP3 vers le flux ICY.

ICYStream icystream;
I2SStream i2s;
VolumeStream volume(i2s);
EncodedAudioStream mp3decode(&volume, new MP3DecoderHelix());
StreamCopy copier(mp3decode, icystream);

Fonction de rappel des métadonnées

La fonction callbackMetadata() est définie pour traiter les métadonnées reçues du flux radio internet, comme les titres de chansons ou les informations sur l’artiste. Elle affiche le type et le contenu des métadonnées sur le moniteur série pour le débogage ou l’information.

void callbackMetadata(MetaDataType type, const char* str, int len) {
  Serial.printf("%s: %s\n", toStr(type), str);
}

Fonction setup

Dans la fonction setup(), la communication série est initialisée à 115200 bauds pour permettre l’affichage des logs et du débogage. Le logger audio est configuré pour afficher les avertissements et plus sur le moniteur série.

L’ESP32 tente ensuite de se connecter au réseau WiFi spécifié, en vérifiant l’état de la connexion toutes les 500 millisecondes jusqu’à succès.

Après connexion, la configuration I2S est obtenue en mode transmission par défaut. Les broches I2S sont assignées aux constantes définies précédemment pour l’horloge de bits, la sélection de mot et l’entrée de données. L’interface I2S et le contrôle du volume sont initialisés avec cette configuration, et le volume est réglé à 50%.

Le décodeur MP3 est lancé et le flux radio internet est initialisé avec l’URL fournie. La fonction de rappel des métadonnées est enregistrée pour traiter les métadonnées reçues pendant la lecture.

void setup() {
  Serial.begin(115200);
  AudioLogger::instance().begin(Serial, AudioLogger::Warning);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }

  auto config = i2s.defaultConfig(TX_MODE);
  config.pin_bck = MAX_BCLK;
  config.pin_ws = MAX_LRC;
  config.pin_data = MAX_DIN;

  i2s.begin(config);
  volume.begin(config);
  volume.setVolume(MAX_VOL);
  mp3decode.begin();
  icystream.begin(url);
  icystream.setMetadataCallback(callbackMetadata);
}

Fonction loop

La fonction loop() copie en continu les données audio du flux radio internet via le décodeur MP3 et le contrôleur de volume vers la sortie I2S. Ce processus maintient la lecture audio en continu.

void loop() {
  copier.copy();
}

Si vous souhaitez ajouter plus de fonctionnalités comme un contrôleur de volume, consultez notre Playing Audio with ESP32 and PCM5102A tutoriel. Et si vous voulez ajouter un écran, voyez le Internet Radio with ESP32 and MAX 98357A tutoriel.

Lire un MP3 depuis une carte SD

Cet exemple montre comment lire des fichiers audio MP3 stockés sur une carte SD avec un ESP32, l’amplificateur I2S MAX98357 et la bibliothèque AudioTools. Le code initialise le matériel audio, configure le décodeur MP3 et diffuse en continu les données audio vers l’amplificateur.

/*
www.makerguides.com

Libraries:
- ESP32 Core 2.0.17
- [arduino-audio-tools](https://github.com/pschatzmann/arduino-audio-tools) 
  Version: 1.2.2
- [arduino-libhelix](https://github.com/pschatzmann/arduino-libhelix)
  Version: 0.9.2
*/

#include "AudioTools.h"
#include "AudioTools/Disk/AudioSourceSD.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"

// MAX98357
#define MAX_DIN 33   
#define MAX_LRC 32   
#define MAX_BCLK 25  

#define PATH "/"
#define EXT "mp3"

AudioSourceSD source(PATH, EXT);
I2SStream i2s;
MP3DecoderHelix decoder;
AudioPlayer player(source, i2s, decoder);

void printMetaData(MetaDataType type, const char* str, int len){
  Serial.printf("%s: %s\n", toStr(type), str);
}

void setup() {
  Serial.begin(115200);
  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Warning);

  auto cfg = i2s.defaultConfig(TX_MODE);
  cfg.pin_bck = MAX_BCLK;  
  cfg.pin_ws = MAX_LRC;    
  cfg.pin_data = MAX_DIN;    
  i2s.begin(cfg);

  //source.setFileFilter("*Bob Dylan*");
  player.setMetadataCallback(printMetaData);
  player.setVolume(0.4);
  player.begin();
}

void loop() {
  player.copy();
}

Imports

Le code commence par inclure les fichiers d’en-tête de la bibliothèque AudioTools. Ils fournissent les classes et fonctions nécessaires pour gérer les sources audio, décoder les fichiers MP3 et diffuser les données audio via I2S.

#include "AudioTools.h"
#include "AudioTools/Disk/AudioSourceSD.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"

Constantes

Ensuite, les broches connectées à l’amplificateur MAX98357 sont définies. Elles spécifient les broches d’entrée de données I2S (MAX_DIN), de sélection de mot ou horloge gauche-droite (MAX_LRC) et d’horloge de bits (MAX_BCLK) sur l’ESP32.

#define MAX_DIN 33   
#define MAX_LRC 32   
#define MAX_BCLK 25  

Des constantes pour le chemin source audio et l’extension de fichier sont aussi définies. Ici, PATH est le répertoire racine de la carte SD, et EXT indique que seuls les fichiers MP3 seront pris en compte.

#define PATH "/"
#define EXT "mp3"

Objets

Plusieurs objets sont instanciés pour gérer la lecture audio. AudioSourceSD représente la source audio de la carte SD, filtrant les fichiers selon le chemin et l’extension spécifiés. I2SStream gère le flux de sortie audio I2S. MP3DecoderHelix est le décodeur MP3 basé sur le codec Helix. Enfin, AudioPlayer relie ces composants pour gérer la lecture.

AudioSourceSD source(PATH, EXT);
I2SStream i2s;
MP3DecoderHelix decoder;
AudioPlayer player(source, i2s, decoder);

Fonction de rappel des métadonnées

La fonction printMetaData() est définie pour traiter les informations de métadonnées comme l’artiste ou le titre du morceau. Elle reçoit le type de métadonnée et la chaîne, puis l’affiche sur la console série pour le débogage ou l’information.

void printMetaData(MetaDataType type, const char* str, int len){
  Serial.printf("%s: %s\n", toStr(type), str);
}

Fonction setup

Dans la fonction setup(), la communication série est initialisée à 115200 bauds pour les logs. Le logger AudioTools est aussi démarré au niveau warning pour capturer les messages importants.

La configuration I2S est obtenue à partir des paramètres par défaut en mode transmission. Les broches pour l’horloge de bits, la sélection de mot et les données sont assignées aux constantes définies précédemment correspondant aux connexions MAX98357. Le flux I2S est alors initialisé avec cette configuration.

Optionnellement, un filtre de fichiers peut être appliqué à la source audio pour ne lire que les fichiers correspondant à un motif (commenté dans cet exemple). Le rappel des métadonnées est défini sur la fonction printMetaData() pour recevoir les métadonnées pendant la lecture. Le volume est réglé à 40% pour contrôler le niveau sonore. Enfin, le lecteur audio est lancé.

void setup() {
  Serial.begin(115200);
  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Warning);

  auto cfg = i2s.defaultConfig(TX_MODE);
  cfg.pin_bck = MAX_BCLK;  
  cfg.pin_ws = MAX_LRC;    
  cfg.pin_data = MAX_DIN;    
  i2s.begin(cfg);

  //source.setFileFilter("*Bob Dylan*");
  player.setMetadataCallback(printMetaData);
  player.setVolume(0.4);
  player.begin();
}

Fonction loop

La fonction loop() appelle en continu player.copy(), qui gère le streaming des données audio de la carte SD via le décodeur et la sortie I2S vers l’amplificateur. Cela permet une lecture audio fluide sans bloquer d’autres processus.

void loop() {
  player.copy();
}

Si vous souhaitez ajouter plus de fonctionnalités comme un contrôleur de volume et des boutons pour changer de piste, consultez le Playing Audio with ESP32 and PCM5102A tutoriel.

Lire de l’audio depuis Bluetooth

Cet exemple montre comment diffuser de l’audio Bluetooth. Le code configure l’interface I2S avec des broches spécifiques et initialise un récepteur Bluetooth A2DP, permettant à l’ESP32 de recevoir et lire de l’audio depuis des appareils Bluetooth.

/*
www.makerguides.com

Libraries:
- ESP32 Core 2.0.17
- [arduino-audio-tools](https://github.com/pschatzmann/arduino-audio-tools) 
  Version: 1.2.2
- [arduino-libhelix](https://github.com/pschatzmann/arduino-libhelix)
  Version: 0.9.2
- [ESP32-A2DP](https://github.com/pschatzmann/ESP32-A2DP)
  Version: 1.8.8
*/

#include "AudioTools.h"
#include "BluetoothA2DPSink.h"

#define MAX_DIN 33   // serial data
#define MAX_LRC 32   // word select
#define MAX_BCLK 25  // serial clock

I2SStream i2s;
BluetoothA2DPSink a2dp_sink(i2s);

void setup() {
  auto cfg = i2s.defaultConfig();
  cfg.pin_bck = MAX_BCLK;
  cfg.pin_ws = MAX_LRC;
  cfg.pin_data = MAX_DIN;
  i2s.begin(cfg);

  a2dp_sink.start("MyMusic");
}

void loop() { }

Imports

Le code commence par inclure deux bibliothèques importantes. La bibliothèque AudioTools.h fournit des outils pour gérer les flux audio et configurer l’interface I2S. La bibliothèque BluetoothA2DPSink.h permet à l’ESP32 d’agir comme récepteur Bluetooth A2DP, c’est-à-dire de recevoir des flux audio depuis des sources Bluetooth comme des smartphones.

#include "AudioTools.h"
#include "BluetoothA2DPSink.h"

Constantes

Ensuite, trois constantes sont définies pour spécifier les broches GPIO utilisées pour l’interface I2S. Ces broches relient l’ESP32 à l’amplificateur MAX98357. MAX_DIN est la broche d’entrée de données série, MAX_LRC est la broche de sélection de mot ou horloge gauche-droite, et MAX_BCLK est la broche d’horloge série.

#define MAX_DIN 33   // serial data
#define MAX_LRC 32   // word select
#define MAX_BCLK 25  // serial clock

Objets

Un objet I2SStream nommé i2s est créé pour gérer le flux audio I2S. Ensuite, un objet BluetoothA2DPSink appelé a2dp_sink est instancié, en lui passant l’objet i2s. Cette configuration relie directement l’entrée audio Bluetooth à la sortie I2S, permettant une lecture audio fluide via l’amplificateur.

I2SStream i2s;
BluetoothA2DPSink a2dp_sink(i2s);

Fonction setup

Dans la fonction setup(), l’interface I2S est configurée et démarrée. D’abord, la configuration I2S par défaut est obtenue en appelant i2s.defaultConfig(). Ensuite, les broches pour l’horloge de bits (pin_bck), la sélection de mot (pin_ws) et l’entrée de données (pin_data) sont définies selon les constantes précédemment définies. Enfin, l’interface I2S est initialisée avec cette configuration en appelant i2s.begin(cfg).

Après avoir configuré I2S, le récepteur Bluetooth A2DP est démarré avec le nom d’appareil "MyMusic". Ce nom apparaîtra lorsque d’autres appareils Bluetooth rechercheront des récepteurs audio disponibles.

void setup() {
  auto cfg = i2s.defaultConfig();
  cfg.pin_bck = MAX_BCLK;
  cfg.pin_ws = MAX_LRC;
  cfg.pin_data = MAX_DIN;
  i2s.begin(cfg);

  a2dp_sink.start("MyMusic");
}

Pour essayer, ouvrez votre téléphone, cherchez « appareils connectés » ou « appareils Bluetooth », recherchez le périphérique « MyMusic », connectez-vous, puis lancez de la musique. Vous devriez l’entendre jouer sur votre ESP32 et MAX98357.

Fonction loop

La fonction loop() est vide car tout le streaming et la lecture audio sont gérés de façon asynchrone par le récepteur Bluetooth A2DP et l’interface I2S. Une fois démarré, l’ESP32 écoute en continu les flux audio Bluetooth et les sort via I2S vers l’amplificateur sans nécessiter de code supplémentaire dans la boucle principale.

void loop() { }

Conclusions

Dans ce projet, vous avez appris à lire de l’audio avec l’ESP32 et l’amplificateur MAX98357. Nous avons exploré les détails techniques du module MAX98357A et comment le câbler à l’ESP32 pour un son mono ou stéréo. Vous avez aussi appris à convertir du texte en parole, diffuser la radio internet, lire des fichiers MP3 depuis une carte SD et lire de l’audio via Bluetooth.

Si vous souhaitez ajouter plus de fonctionnalités comme un contrôleur de volume et des boutons pour changer de piste, consultez notre Playing Audio with ESP32 and PCM5102A tutoriel. De même, si vous voulez plus d’informations sur le module lecteur de carte SD utilisé ici, consultez le SD Card Module with ESP32 tutoriel.

Pour un son plus puissant et de meilleure qualité, vous pouvez utiliser un DAC PCM5102A et ajouter un amplificateur. Consultez les tutoriels suivants pour plus d’informations :

• TDA7379 Class AB Audio Amplifier with ESP32
• High-Power ESP32 Audio with TPA3116D2 and PCM5102
• Audio with PAM8403, PCM5102 and ESP32
• Stereo Amplifier with TPA31110 XH-A232, PCM5102 and ESP32
• Playing Audio with ESP32 and MAX98357

Si vous avez des questions, n’hésitez pas à les poser en commentaire.

Bon bidouillage ; )

FAQ

Q : Qu’est-ce que le MAX98357A et pourquoi l’utiliser ?

Le MAX98357A est un amplificateur audio numérique avec DAC intégré, ce qui signifie qu’il prend l’audio numérique directement de l’ESP32 via I2S et délivre un signal déjà amplifié pouvant alimenter un haut-parleur sans amplificateur supplémentaire, simplifiant le circuit tout en améliorant la qualité sonore par rapport au DAC interne de l’ESP32.

Q : Comment connecter le MAX98357A à l’ESP32 ?

Le module utilise trois signaux I2S plus l’alimentation.

Câblage typique :

ESP32_3V3 or 5V ----> VIN
ESP32_GND ---------> GND

ESP32_GPIO25 -----> BCLK
ESP32_GPIO32 -----> LRC
ESP32_GPIO33 -----> DIN

L’ESP32 agit comme maître I2S et envoie les données audio, tandis que le MAX98357A les reçoit et les convertit en son.

Q : Puis-je connecter un haut-parleur directement au MAX98357A ?

Oui, car le MAX98357A intègre déjà un étage amplificateur, donc vous pouvez brancher un haut-parleur directement.

SPK+ ---- Speaker ---- SPK-

Les haut-parleurs typiques sont de 4Ω à 8Ω, 3W ou plus. L’amplificateur peut délivrer environ 3W, suffisant pour de petits haut-parleurs.

Q : Comment obtenir du son stéréo ?

Le MAX98357A est mono, donc pour la stéréo il faut deux modules.

ESP32 --> 2x MAX98357A --> 2x Speakers

Les deux modules partagent les mêmes signaux I2S, mais utilisent des résistances pour sélectionner les canaux gauche et droit.

SD -- 100kΩ -- 3.3V (left channel)
SD -- 210kΩ -- 3.3V (right channel)

Ainsi, chaque amplificateur joue un canal.

Q : Quelle alimentation utiliser ?

Le module fonctionne en 3,3V ou 5V, mais l’alimentation est importante pour un bon son. À volume élevé, le module peut consommer beaucoup de courant, donc l’alimenter via la broche 3,3V de l’ESP32 n’est souvent pas suffisant et peut causer des distorsions ou des redémarrages.

Q : Comment améliorer la qualité sonore avec un filtrage de l’alimentation ?

Une alimentation propre est essentielle, car le bruit affecte directement la sortie audio. Vous pouvez ajouter des condensateurs :

VIN -- 100nF -- GND
VIN -- 100µF -- GND

Le petit condensateur élimine les bruits de commutation rapides, tandis que le gros condensateur lisse les ondulations de tension et évite les chutes lors des pics audio forts.

En plus, vous pouvez utiliser un condensateur de filtrage :

5V -- 10Ω --+-- AMP_VIN
|
220µF
|
GND

Cela réduit le bruit provenant de l’USB ou des régulateurs à découpage.

Q : Dois-je utiliser une alimentation externe ?

Oui, surtout à volume élevé, car le MAX98357A peut consommer beaucoup de courant lors de la lecture de sons forts, et le régulateur de l’ESP32 peut ne pas suivre de façon fiable.

External 5V ----> MAX98357A
ESP32_GND ------> Shared GND

Cela améliore la stabilité et réduit la distorsion.

Q : Comment augmenter le volume ?

Le volume dépend de trois facteurs principaux : la tension d’alimentation, le gain de l’amplificateur et le type de haut-parleur. Pour augmenter le volume :

• Utilisez 5V au lieu de 3,3V
• Utilisez un haut-parleur à plus faible impédance (4Ω au lieu de 8Ω)

Un haut-parleur 4Ω consomme plus de puissance et produit un volume plus élevé, mais sollicite aussi plus l’amplificateur.

Q : À quoi sert la broche GAIN et quel est son effet sur le son ?

La broche GAIN règle le niveau de gain de l’amplificateur.

GAIN -- GND (lower gain)
GAIN -- VCC (higher gain)
GAIN -- FLOAT (default)

Un gain plus élevé augmente le volume mais peut aussi augmenter le bruit et la distorsion, il vaut donc mieux commencer avec un gain faible et ajuster par logiciel.

Q : Pourquoi j’entends du bruit ou un souffle même sans audio ?

Le bruit peut venir de plusieurs sources comme l’ondulation de l’alimentation, une mauvaise masse ou des interférences de l’ESP32. Solutions courantes :

• Ajoutez des condensateurs de découplage
• Utilisez une alimentation externe propre
• Gardez les fils courts

Q : Quelles pratiques de câblage améliorent la qualité sonore ?

Un bon câblage est très important, surtout pour l’audio numérique et les amplificateurs à découpage. Gardez les fils courts :

ESP32 --> MAX98357A (short lines)

et utilisez une masse en étoile :

ESP32_GND ----+---- AMP_GND
|
POWER_GND

Évitez de faire passer les fils du haut-parleur près des fils de signal, car les signaux de commutation à fort courant peuvent introduire du bruit.

Q : Quels formats audio et fonctionnalités sont pris en charge ?

Le MAX98357A prend en charge les formats audio numériques typiques utilisés avec l’ESP32.

• Audio 16, 24 ou 32 bits
• Fréquences d’échantillonnage de 8 kHz à 96 kHz