Saltar a contenido

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:

ffmpeg -i cancion.mp3 -ac 1 -ar 22050 -sample_fmt s16 m1.wav

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:

Bytes en el archivo:  22 56 00 00
Valor:                0x00005622 = 22 050

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 si VOLUMEN es 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

  1. Reproduce todos los WAV de la tarjeta uno detrás de otro.
  2. Usa los botones LEFT y RIGHT para cambiar de canción y A para pausar.
  3. Controla el volumen con UP y DOWN y muéstralo en la pantalla.
  4. Dibuja la forma de onda del audio en la pantalla mientras suena.