MAX98357A: reproducir un WAV desde la microSD
En este ejemplo la placa reproduce un archivo de audio WAV guardado en la tarjeta microSD. El programa analiza el archivo, comprueba que el formato sea compatible y lo envía al altavoz a través del amplificador MAX98357A. Mientras suena, la pantalla muestra el nombre, el formato y una barra de progreso.
Une los tres módulos de salida de la placa: microSD, pantalla y audio.
Qué vas a aprender:
- Cómo está organizado por dentro un archivo WAV (chunks RIFF).
- Leer números little-endian desde un archivo.
- Configurar el bus I2S y enviar audio al MAX98357A.
- Convertir audio estéreo en mono y ajustar el volumen por software.
- Mostrar el progreso de la reproducción en la pantalla.
Antes de empezar
Este ejemplo combina LCD y microSD con el amplificador de Texto a voz. Si alguno de los módulos falla, pruébalo primero por separado.
1. Mapa de pines
Cada módulo va en su propio bus: la pantalla en FSPI, la microSD en HSPI y el amplificador en I2S.
Pantalla ST7789 (FSPI)
| Pin de la pantalla | GPIO | Constante | Función |
|---|---|---|---|
| SDA | 11 | TFT_MOSI |
Datos hacia la pantalla |
| SCL / SCK | 12 | TFT_SCLK |
Reloj SPI |
| CS | 10 | TFT_CS |
Selecciona la pantalla |
| DC | 15 | TFT_DC |
Comando (LOW) o datos (HIGH) |
| RES / RST | 9 | TFT_RST |
Reinicio |
Módulo microSD (HSPI)
| Pin del módulo | GPIO | Constante | Función |
|---|---|---|---|
| MISO | 1 | SD_MISO |
Datos de la tarjeta hacia el ESP32 |
| MOSI | 2 | SD_MOSI |
Datos del ESP32 hacia la tarjeta |
| CS | 41 | SD_CS |
Selecciona la tarjeta |
| SCK / CLK | 42 | SD_SCLK |
Reloj SPI |
Amplificador MAX98357A (I2S)
| Pin del módulo | GPIO | Constante | Función |
|---|---|---|---|
| BCLK | 16 | I2S_BCLK |
Reloj de bits |
| LRC | 17 | I2S_LRC |
Reloj de palabra (canal izquierdo/derecho) |
| DIN | 18 | I2S_DOUT |
Datos de audio hacia el amplificador |
| VIN | 5 V | — | Alimentación |
| SD | Al aire | — | Amplificador activo, mezcla ambos canales |
| GAIN | Al aire | — | Ganancia de 9 dB |
2. Preparar el entorno
El archivo de audio
El programa reproduce /m1.wav, en la raíz de la tarjeta. Tiene que cumplir:
| Propiedad | Valor admitido |
|---|---|
| Formato | WAV PCM sin comprimir |
| Bits | 16 bits |
| Canales | Mono o estéreo |
| Frecuencia | Cualquiera: 16 000, 22 050, 44 100 Hz… |
Para convertir cualquier audio (MP3, OGG, etc.) puedes usar Audacity: Archivo → Exportar audio, formato WAV, codificación Signed 16-bit PCM. Desde la terminal, con FFmpeg:
Tamaño del archivo
Un WAV ocupa mucho porque no está comprimido: un minuto en mono a 22 050 Hz ocupa unos 2,6 MB, y en estéreo a 44 100 Hz unos 10 MB. Para audios largos conviene bajar la frecuencia y usar mono.
Librerías y placa
| Librería | Para qué sirve |
|---|---|
| Adafruit ST7735 and ST7789 | Controlador de la pantalla |
| Adafruit GFX Library | Funciones de dibujo y texto |
SPI.h, SD.h, ESP_I2S.h |
Incluidas con el soporte del ESP32 (core 3.x) |
Usa la misma configuración de placa que en LCD 240x240.
3. Código
#include <Arduino.h>
#include <SPI.h>
#include <SD.h>
#include <ESP_I2S.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>
// =====================================================
// Pantalla ST7789 (FSPI)
// =====================================================
#define TFT_MOSI 11
#define TFT_SCLK 12
#define TFT_CS 10
#define TFT_DC 15
#define TFT_RST 9
Adafruit_ST7789 tft(TFT_CS, TFT_DC, TFT_RST);
// =====================================================
// microSD (HSPI)
// =====================================================
#define SD_MISO 1
#define SD_MOSI 2
#define SD_CS 41
#define SD_SCLK 42
SPIClass spiSD(HSPI);
// =====================================================
// MAX98357A (I2S)
// =====================================================
#define I2S_BCLK 16
#define I2S_LRC 17
#define I2S_DOUT 18
I2SClass i2s;
// =====================================================
// Configuración
// =====================================================
const char *ARCHIVO = "/m1.wav";
const float VOLUMEN = 0.8; // 0.0 = silencio, 1.0 = volumen original
// =====================================================
// Datos del WAV
// =====================================================
struct InfoWav {
uint16_t formato;
uint16_t canales;
uint32_t frecuencia;
uint16_t bits;
uint32_t inicioDatos;
uint32_t tamDatos;
};
InfoWav wavInfo;
// =====================================================
// Pantalla
// =====================================================
void pantalla(const String &linea1, const String &linea2 = "", uint16_t color = ST77XX_WHITE) {
tft.fillScreen(ST77XX_BLACK);
tft.setTextColor(color);
tft.setTextSize(2);
tft.setCursor(5, 80);
tft.println(linea1);
if (linea2.length() > 0) {
tft.setCursor(5, 115);
tft.println(linea2);
}
}
void dibujarProgreso(int porcentaje) {
int ancho = map(porcentaje, 0, 100, 0, 226);
tft.drawRect(5, 145, 230, 20, ST77XX_BLUE);
tft.fillRect(7 + ancho, 147, 226 - ancho, 16, ST77XX_BLACK);
tft.fillRect(7, 147, ancho, 16, ST77XX_GREEN);
tft.setTextSize(2);
tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);
tft.setCursor(95, 175);
tft.printf("%3d%%", porcentaje);
}
// =====================================================
// Lectura little-endian
// =====================================================
uint16_t leer16(File &f) {
uint8_t b[2];
if (f.read(b, 2) != 2) return 0;
return b[0] | (b[1] << 8);
}
uint32_t leer32(File &f) {
uint8_t b[4];
if (f.read(b, 4) != 4) return 0;
return (uint32_t)b[0] | ((uint32_t)b[1] << 8) | ((uint32_t)b[2] << 16) | ((uint32_t)b[3] << 24);
}
// =====================================================
// Analiza la cabecera del WAV
// =====================================================
bool analizarWav(const char *ruta, InfoWav &info) {
File wav = SD.open(ruta);
if (!wav) {
Serial.println("ERROR: No se pudo abrir el WAV");
return false;
}
char id[4];
// Cabecera: "RIFF" <tamaño> "WAVE"
wav.read((uint8_t *)id, 4);
leer32(wav);
bool esRiff = memcmp(id, "RIFF", 4) == 0;
wav.read((uint8_t *)id, 4);
if (!esRiff || memcmp(id, "WAVE", 4) != 0) {
Serial.println("ERROR: No es un archivo WAV");
wav.close();
return false;
}
bool encontroFmt = false;
bool encontroData = false;
// Recorre los chunks hasta encontrar "data"
while (wav.available() >= 8) {
wav.read((uint8_t *)id, 4);
uint32_t tam = leer32(wav);
uint32_t inicioChunk = wav.position();
if (memcmp(id, "fmt ", 4) == 0) {
info.formato = leer16(wav);
info.canales = leer16(wav);
info.frecuencia = leer32(wav);
leer32(wav); // byte rate
leer16(wav); // block align
info.bits = leer16(wav);
encontroFmt = true;
} else if (memcmp(id, "data", 4) == 0) {
info.inicioDatos = inicioChunk;
info.tamDatos = min(tam, (uint32_t)(wav.size() - inicioChunk));
encontroData = true;
break;
}
// Salta al siguiente chunk (los de tamaño impar llevan un byte de relleno)
wav.seek(inicioChunk + tam + (tam & 1));
}
wav.close();
if (!encontroFmt || !encontroData) {
Serial.println("ERROR: Faltan los bloques fmt o data");
return false;
}
Serial.printf("Formato: %u | Canales: %u | Frecuencia: %lu Hz | Bits: %u | Datos: %lu bytes\n",
info.formato, info.canales, info.frecuencia, info.bits, info.tamDatos);
if (info.formato != 1) {
Serial.println("ERROR: El WAV no es PCM sin comprimir");
return false;
}
if (info.bits != 16) {
Serial.println("ERROR: El WAV debe ser de 16 bits");
return false;
}
if (info.canales != 1 && info.canales != 2) {
Serial.println("ERROR: El WAV debe ser mono o estereo");
return false;
}
return true;
}
// =====================================================
// Reproduce el WAV
// =====================================================
int16_t limitar(int32_t valor) {
if (valor > 32767) return 32767;
if (valor < -32768) return -32768;
return valor;
}
bool reproducirWav(const char *ruta, const InfoWav &info) {
File wav = SD.open(ruta);
if (!wav) {
Serial.println("ERROR: No se pudo abrir el WAV para reproducir");
return false;
}
wav.seek(info.inicioDatos);
// ---------- Configurar I2S ----------
i2s.setPins(I2S_BCLK, I2S_LRC, I2S_DOUT);
if (!i2s.begin(I2S_MODE_STD, info.frecuencia, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO)) {
Serial.println("ERROR: No se pudo iniciar I2S");
wav.close();
return false;
}
// ---------- Pantalla ----------
tft.fillScreen(ST77XX_BLACK);
tft.setTextSize(2);
tft.setTextColor(ST77XX_CYAN);
tft.setCursor(5, 20);
tft.print("REPRODUCIENDO");
tft.setTextColor(ST77XX_GREEN);
tft.setCursor(5, 55);
tft.print(ruta + 1); // nombre sin la "/" inicial
tft.setTextSize(1);
tft.setTextColor(ST77XX_WHITE);
tft.setCursor(5, 90);
tft.printf("%lu Hz | 16 bits | %s", info.frecuencia, info.canales == 1 ? "MONO" : "ESTEREO");
Serial.printf("\nReproduciendo %s...\n", ruta);
// ---------- Bucle de reproducción ----------
const int MUESTRAS = 512;
int16_t entrada[MUESTRAS * 2]; // espacio para estéreo
int16_t salida[MUESTRAS];
uint32_t bytesPorMuestra = info.canales * 2;
uint32_t restantes = info.tamDatos;
int ultimoPorcentaje = -1;
while (restantes > 0) {
uint32_t aLeer = min(restantes, (uint32_t)(MUESTRAS * bytesPorMuestra));
int leidos = wav.read((uint8_t *)entrada, aLeer);
if (leidos <= 0) break;
int muestras = leidos / bytesPorMuestra;
for (int i = 0; i < muestras; i++) {
int32_t valor;
if (info.canales == 1) {
valor = entrada[i];
} else {
valor = (entrada[i * 2] + entrada[i * 2 + 1]) / 2; // estéreo → mono
}
salida[i] = limitar(valor * VOLUMEN);
}
i2s.write((uint8_t *)salida, muestras * sizeof(int16_t));
restantes -= leidos;
// Progreso: solo redibuja cuando cambia el porcentaje
int porcentaje = (uint64_t)(info.tamDatos - restantes) * 100 / info.tamDatos;
if (porcentaje != ultimoPorcentaje) {
ultimoPorcentaje = porcentaje;
Serial.printf("\rProgreso: %3d%%", porcentaje);
dibujarProgreso(porcentaje);
}
}
Serial.println("\nReproduccion terminada");
i2s.end();
wav.close();
pantalla("FIN", ruta + 1, ST77XX_YELLOW);
return true;
}
// =====================================================
// SETUP
// =====================================================
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("\n=== Reproductor WAV: ST7789 + microSD + MAX98357A ===");
// ---------- Pantalla ----------
SPI.begin(TFT_SCLK, -1, TFT_MOSI, TFT_CS);
tft.init(240, 240);
tft.setRotation(0);
pantalla("ESP32-S3", "Audio Test", ST77XX_CYAN);
// ---------- microSD ----------
spiSD.begin(SD_SCLK, SD_MISO, SD_MOSI, SD_CS);
if (!SD.begin(SD_CS, spiSD)) {
Serial.println("ERROR: No se pudo montar la SD");
pantalla("ERROR SD", "No detectada", ST77XX_RED);
return;
}
Serial.println("SD OK");
// ---------- Archivo ----------
if (!SD.exists(ARCHIVO)) {
Serial.printf("ERROR: No existe %s\n", ARCHIVO);
pantalla("NO ENCONTRADO", ARCHIVO + 1, ST77XX_RED);
return;
}
if (!analizarWav(ARCHIVO, wavInfo)) {
pantalla("WAV INVALIDO", ARCHIVO + 1, ST77XX_RED);
return;
}
reproducirWav(ARCHIVO, wavInfo);
}
// =====================================================
// LOOP
// =====================================================
void loop() {
// El WAV se reproduce una vez durante setup()
}
4. Cómo funciona
Flujo general
microSD ──► analizarWav() ──► ¿PCM 16 bits? ──► reproducirWav()
│
Pantalla ◄── progreso ◄─────────┤
▼
Altavoz ◄── MAX98357A ◄── I2S ◄── volumen y mezcla a mono
El trabajo se reparte en dos funciones: analizarWav() lee la cabecera y comprueba el formato, y reproducirWav() envía el audio al amplificador.
Estructura de un archivo WAV
Un WAV es un archivo RIFF: una cabecera seguida de bloques llamados chunks. Cada chunk empieza con un identificador de 4 letras y su tamaño en bytes.
┌──────────────────────────────┐
│ "RIFF" tamaño "WAVE" │ Cabecera (12 bytes)
├──────────────────────────────┤
│ "fmt " tamaño │ Formato del audio
│ formato, canales, │
│ frecuencia, bits... │
├──────────────────────────────┤
│ "LIST" tamaño ... │ Opcional: metadatos (título, artista)
├──────────────────────────────┤
│ "data" tamaño │ Las muestras de audio
│ muestra, muestra, ... │
└──────────────────────────────┘
Muchos ejemplos suponen que la cabecera mide siempre 44 bytes, pero no siempre es así: programas como Audacity agregan chunks LIST con metadatos. Por eso analizarWav() recorre los chunks uno por uno: lee el identificador y el tamaño, procesa fmt, salta los que no conoce y se detiene al encontrar data.
Del chunk fmt se leen estos campos:
| Campo | Bytes | Valor esperado |
|---|---|---|
| Formato | 2 | 1 = PCM sin comprimir |
| Canales | 2 | 1 = mono, 2 = estéreo |
| Frecuencia | 4 | Muestras por segundo, ej. 22 050 |
| Byte rate | 4 | No se usa |
| Block align | 2 | No se usa |
| Bits | 2 | 16 |
Little-endian
Los números del WAV se guardan con el byte menos significativo primero. leer16() y leer32() leen los bytes y los combinan con desplazamientos:
Configurar el I2S
i2s.setPins(I2S_BCLK, I2S_LRC, I2S_DOUT);
i2s.begin(I2S_MODE_STD, info.frecuencia, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO);
La frecuencia del I2S se toma del archivo, así que cada WAV suena a su velocidad correcta. Se usa modo mono, porque el MAX98357A tiene un solo altavoz.
Reproducción por bloques
La placa no carga el archivo entero en memoria: lee 512 muestras, las procesa, las envía al I2S y repite. i2s.write() espera a que haya espacio en la memoria de transmisión, así que el propio I2S marca el ritmo de lectura.
Cada bloque pasa por dos ajustes:
- Estéreo a mono: si el archivo tiene dos canales, las muestras van intercaladas (izquierda, derecha, izquierda…). Se suman de dos en dos y se dividen entre 2.
- Volumen: cada muestra se multiplica por
VOLUMEN.limitar()recorta el resultado al rango de 16 bits (−32 768 a 32 767) para evitar distorsión siVOLUMENes mayor que 1.
Barra de progreso
El porcentaje se calcula con los bytes ya leídos. La pantalla solo se redibuja cuando el porcentaje cambia: como mucho 100 veces en toda la canción. Así el SPI de la pantalla no le roba tiempo a la lectura de la tarjeta y el audio no se corta.
5. Resultado esperado
La pantalla muestra REPRODUCIENDO, el nombre m1.wav, el formato y una barra verde que avanza con el porcentaje. Al terminar aparece FIN en amarillo.
En el monitor serie, a 115200 baudios:
=== Reproductor WAV: ST7789 + microSD + MAX98357A ===
SD OK
Formato: 1 | Canales: 1 | Frecuencia: 22050 Hz | Bits: 16 | Datos: 2646000 bytes
Reproduciendo /m1.wav...
Progreso: 100%
Reproduccion terminada
6. Solución de problemas
| Síntoma | Causa probable y solución |
|---|---|
| ERROR SD – No detectada | La tarjeta no está en FAT32 o hay un problema de conexión. Prueba LCD y microSD. |
| NO ENCONTRADO | El archivo debe llamarse exactamente m1.wav y estar en la raíz, fuera de cualquier carpeta. |
WAV INVALIDO con Formato: 65534 |
Es un WAV extensible. Expórtalo de nuevo como Signed 16-bit PCM o conviértelo con FFmpeg. |
WAV INVALIDO con Bits: 24 o 32 |
Exporta el archivo en 16 bits. |
| Suena acelerado o grave | La frecuencia del I2S no coincide con la del archivo. Revisa la línea Frecuencia del monitor serie. |
| Se oye entrecortado | La tarjeta es lenta. Usa una de clase 10 o baja la frecuencia del WAV a 22 050 Hz. |
| Ruido fuerte o chasquidos al final | El archivo podría tener datos que no son audio después del chunk data. Conviértelo de nuevo. |
| La placa se reinicia al sonar | Caída de tensión: pon un condensador de 100 µF cerca de VIN y baja VOLUMEN. |
7. Retos
- Reproduce todos los WAV de la tarjeta uno detrás de otro.
- Usa los botones LEFT y RIGHT para cambiar de canción y A para pausar.
- Controla el volumen con UP y DOWN y muéstralo en la pantalla.
- Dibuja la forma de onda del audio en la pantalla mientras suena.