ESP32 con YX5300: reproduce audio MP3 y WAV desde una microSD

¿Quieres que tu proyecto con ESP32 hable, reproduzca efectos de sonido o suene con música real? La mayoría de los makers cae en el error de pensar que el ESP32 necesita un DAC externo enorme o librerías pesadas para tocar audio. La verdad es mucho más simple: con un módulo reproductor serial YX5300 y solo dos cables de datos, puedes disparar archivos .mp3 o .wav guardados en una tarjeta microSD enviando comandos por puerto serie.

En este tutorial vas a armar un reproductor de audio controlado por un ESP32 usando el módulo YX5300 (también conocido como YX6300, son intercambiables). Al terminar vas a tener una placa que reproduce la primera pista de tu microSD apenas la enciendas, vas a entender cómo se conecta el módulo por UART y vas a saber cómo organizar tus archivos para que el módulo los encuentre. Es la base perfecta para timbres personalizados, juguetes parlantes, asistentes de voz caseros o alarmas con tu propia música.

Qué es el módulo YX5300 / YX6300

El YX5300 es un reproductor de música MP3 serial de bajo costo que se comunica por UART. La gracia es que toda la parte pesada (decodificar el MP3, leer la microSD, amplificar la señal hacia los audífonos) la hace el propio módulo. Tu ESP32 solo se encarga de mandarle órdenes cortas por el puerto serie: reproduce la pista 1, sube el volumen, pasa a la siguiente. Esto descarga al microcontrolador, que queda libre para el resto de tu proyecto.

Soporta tarjetas microSD de hasta 32 GB formateadas en FAT16 o FAT32, y reproduce archivos .mp3 o .wav con frecuencias entre 8 y 48 kHz. Trae además un conector jack donde puedes enchufar audífonos o un parlante.

Materiales

Para este proyecto necesitas lo siguiente:

• Un ESP32 (cualquier modelo de placa de desarrollo sirve).
• El módulo reproductor MP3 serial YX5300 o YX6300.
• Una tarjeta microSD de 32 GB o menos.
• Audífonos o un parlante con conector jack de 3.5 mm.
• Cables dupont hembra a hembra para el conexionado.
• Un cable para programar y alimentar el ESP32.

Más abajo, en la sección de Chile, te dejo cada componente con su precio y stock real en MechatronicStore.

Conexiones: el YX5300 al ESP32

Cablear el módulo es de lo más simple, porque solo usa dos pines de datos serie (RX y TX) más alimentación. Acá viene el detalle clave que confunde a muchos: en comunicación serie, el pin TX de un dispositivo va siempre al RX del otro, y viceversa. Si conectas TX con TX, el módulo no recibe nada.

Vamos a usar el segundo puerto serie por hardware del ESP32 (UART 2). La tabla de conexiones queda así:

Dos cosas importantes sobre la alimentación y el cableado:

• Alimenta con 5V. Según el manual, el VCC funciona entre 3.2V y 5.2V, pero en la práctica el módulo es mucho más estable conectado a 5V (el pin VIN del ESP32). Con 3.3V a veces falla o no responde.
• Si no suena, invierte RX y TX. Algunos módulos vienen con las etiquetas RX y TX impresas al revés de fábrica. Si cargas el código y no pasa nada, prueba conectar TX con TX y RX con RX. Es un clásico de estos módulos chinos y no significa que el tuyo esté malo.

Puedes usar cualquier otro par de pines GPIO si lo prefieres, solo tienes que ajustar los números en el código. Si dudas de qué pines son seguros, conviene revisar la guía de pinout del ESP32.

Preparar el Arduino IDE y la librería

Vamos a programar el ESP32 desde el Arduino IDE, así que asegúrate de tener instalado el complemento de placas ESP32. Si todavía no lo tienes, hay que agregar la URL de Espressif en las preferencias y descargar el paquete desde el gestor de tarjetas.

Para hablar con el YX5300 existen varias librerías, pero acá usamos la librería YX5300_ESP32 creada por bluejunimo. Aunque su nombre dice ESP32, es totalmente compatible con el módulo YX6300 sin ningún cambio extra. La instalas directo desde el gestor de librerías del Arduino IDE: busca "YX5300 for ESP32" e instala la de bluejunimo.

Preparar la tarjeta microSD

El módulo lee los archivos desde la microSD, pero es muy exigente con cómo están nombrados y organizados. Si no respetas la estructura, simplemente no los encuentra. Estas son las reglas:

• La tarjeta debe estar formateada en FAT32 (o FAT16) y ser de 32 GB o menos.
• Las carpetas tienen que llamarse con 2 dígitos: 01, 02, 03.
• Cada archivo tiene que empezar con 3 dígitos secuenciales: 001, 002, 003. Después del número puedes ponerle el nombre que quieras.
• Hay un máximo de 99 carpetas y 255 canciones por carpeta.

Un ejemplo de estructura válida sería:

01/
  001cancion.mp3
  002cancion.mp3
  003cancion.mp3
02/
  004cancion.mp3
  005cancion.mp3

Una vez copiados los archivos con esa nomenclatura, saca la microSD del computador y métela en la ranura del módulo YX5300.

Por último, enchufa tus audífonos o parlante en el conector jack del módulo. El YX5300 no trae parlante incorporado, así que esta parte es obligatoria para escuchar algo.

El código: reproducir audio con el YX5300

El siguiente código viene del ejemplo de la propia librería y reproduce la primera pista guardada en la microSD a través del audífono o parlante conectado. Cárgalo tal cual al ESP32:

/*********
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete project details at https://RandomNerdTutorials.com/esp32-yx5300-yx6300-mp3-player-arduino/
  Example based on the library example by bluejunimo https://github.com/bluejunimo/YX5300_ESP32/
*********/
#include <YX5300_ESP32.h>

// Connect to YX5300 Serial pins (RX and TX)
#define RX 16
#define TX 17

// mp3 object
YX5300_ESP32 mp3;

void setup() {
  // Initialize connection with the YX5300/YX6300 module
  mp3 = YX5300_ESP32(Serial2, RX, TX);

  // Shows the hex commands being sent to the mp3 device (includes helpful errors)
  Serial.begin(115200);
  mp3.enableDebugging();

  // Plays the first track stored on the microSD Card (Track Formats .mp3/.wav | Frequencies 8-48 kHz)
  // MicroSD Card folder and file structure, example folder name 01 and file name 001xxx.mp3:
  // 01/001xxx.mp3   01/002xxx.mp3   01/003xxx.mp3   02/004xxx.mp3
  mp3.playTrack(1);
}

void loop() {
  // put your main code here, to run repeatedly:
}

Cómo funciona el código

Vamos por partes. Primero se incluye la librería de bluejunimo, que es la que hace fácil hablar con el módulo:

#include <YX5300_ESP32.h>

Después se definen los pines RX y TX y se crea el objeto mp3 que representa al módulo:

#define RX 16
#define TX 17

YX5300_ESP32 mp3;

Dentro de setup(), se inicializa el módulo indicándole qué canal serie usar. Acá pasamos Serial2 (el UART 2 del ESP32) junto con los pines que definimos:

mp3 = YX5300_ESP32(Serial2, RX, TX);

Luego se habilita la comunicación serie y el modo de depuración. Esto es muy útil: con el debugging activado vas a ver en el monitor serie los comandos en hexadecimal que se le envían al módulo, además de mensajes de error que ayudan a diagnosticar problemas:

Serial.begin(115200);
mp3.enableDebugging();

Y finalmente, con una sola línea, se reproduce la primera pista de la microSD:

mp3.playTrack(1);

El loop() queda vacío porque en este ejemplo básico la reproducción se dispara una sola vez al encender. A partir de acá puedes agregar tu propia lógica.

Probarlo

Sube el código al ESP32 y abre el monitor serie a 115200 baudios. Apenas arranque, el módulo debería empezar a reproducir la primera pista guardada en la tarjeta. En el monitor vas a ver los comandos hexadecimales que confirma el debugging.

Si tienes los audífonos o el parlante conectados al jack, vas a escuchar el primer tema de tu microSD.

Si algo no funciona

Si subiste el código pero no se escucha nada, casi siempre es uno de estos cuatro motivos:

• Cableado invertido. Recuerda: TX va a RX y RX va a TX. Pero si tu módulo trae las etiquetas al revés de fábrica, prueba TX con TX y RX con RX.
• Alimentación insuficiente. Conecta el VCC a 5V (VIN), no a 3.3V. Es la causa número uno de fallas.
• Problema con la microSD. Tiene que ser de 32 GB o menos y estar en FAT16 o FAT32. Los archivos deben ser .mp3 o .wav entre 8 y 48 kHz.
• Carpetas o nombres mal puestos. Revisa que las carpetas sean 01, 02 y los archivos empiecen con 001, 002, etc. Si el nombre no sigue el formato, el módulo no lo lee.
• Audífonos o parlante. Pruébalos en otro equipo para descartar que estén malos.

Variantes y mejoras

Una vez que tienes la base andando, este proyecto se puede estirar muchísimo. Algunas ideas que no están en el tutorial original:

• Control con botones físicos. Agrega dos o tres pulsadores al ESP32 para tener play, siguiente y anterior. Con mp3.playTrack(n) puedes saltar a cualquier pista según el botón que presiones, ideal para un timbre o una rocola casera.
• Reproducción por WiFi. Como el ESP32 tiene WiFi, puedes montar un pequeño servidor web y disparar sonidos desde el celular. Perfecto para un timbre inteligente que suene distinto según quién toca, o para integrarlo a tu domótica.
• Sonidos según un sensor. Combínalo con un sensor PIR de movimiento o un sensor ultrasónico HC SR04 para que reproduzca un audio cuando alguien se acerca. Un disfraz de Halloween que grita, una mascota que ladra, o una alarma con tu propia voz.
• Amplificar para más volumen. El jack del módulo da poca potencia. Si quieres llenar una pieza de sonido, pasa la salida por un módulo amplificador de audio antes del parlante.

Personalización para Chile

En Chile puedes conseguir todo lo necesario para este proyecto en MechatronicStore, con stock real y a precio local:

• Reproductor MP3/WAV YX5300 Micro SD (SKU M-128): $3.990. Es exactamente el módulo del tutorial, compatible con YX5300 y YX6300.
• ESP32 DOIT 38 pines (variante Micro USB): $8.990. Cualquier placa de desarrollo ESP32 sirve para este proyecto.
• Micro SD de 32 GB Kingston Clase 10 (también hay versión de 8 GB): la de 8 GB queda perfecta, ya que el módulo soporta hasta 32 GB. Desde $7.990.
• Cables DuPont Hembra a Hembra de 4 pines, 20 cm: $1.190. Justo los que necesitas para conectar el módulo al ESP32.
• Cable USB a Micro USB: $1.290, para programar y alimentar la placa ESP32 con entrada Micro USB.

Los audífonos o parlante con jack de 3.5 mm los puedes reutilizar de cualquier equipo viejo que tengas en casa.

Recursos

• Tutorial original (inglés): ESP32: Play Sound or Audio .mp3/.wav Files using YX5300 (Arduino IDE) por Rui Santos y Sara Santos en Random Nerd Tutorials.
• Repositorio GitHub de la librería: YX5300_ESP32 de bluejunimo

Versión chilena con componentes en stock local en MechatronicStore.