ESP32 - Lecteur MP3
Ce guide vous apprend comment construire un lecteur MP3 utilisant un microcontrôleur ESP32 avec MicroPython, un module de lecteur MP3, une carte MicroSD et un haut-parleur. Le lecteur MP3 lit des chansons ou des fichiers audio stockés sur la carte MicroSD. L'ESP32 contrôle le module lecteur MP3 pour choisir et lire des morceaux depuis la carte SD, les transformer en son et envoyer l'audio au haut-parleur. En détail, nous allons apprendre :
- Comment connecter un lecteur MP3 et un haut-parleur à l'ESP32
- Comment écrire le code MicroPython pour l'ESP32 afin de jouer de la musique à partir d'une carte microSD
- Comment inclure des boutons pour les fonctions jouer, pause, suivant et précédent
Ensuite, vous pouvez modifier le code pour ajouter un potentiomètre ou un encodeur rotatif afin de contrôler le volume.
Préparation du matériel
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables ESP32 (ESP32 inclus) | |
| 1 | × | Kit de Capteurs DIYables (30 capteurs/écrans) | |
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
À propos du module lecteur MP3 série et du haut-parleur
Brochage du module lecteur MP3 série
Un module lecteur MP3 série dispose de trois interfaces principales :
- Interface ESP32:
- Broche RX: Utilisée pour recevoir des données. Connectez-la à la broche TX de votre ESP32 via une connexion série.
- Broche TX: Utilisée pour envoyer des données. Connectez-la à la broche RX de votre ESP32 via une connexion série.
- Broche VCC: Fournit l'alimentation. Connectez-la à la broche 3,3 V de votre ESP32.
- Broche GND: Broche de masse. Connectez-la à une source de masse (0 V).
- Interface haut-parleur:
- Est équipée d'une prise femelle de sortie auxiliaire de 3,5 mm.
- Interface Carte Micro SD:
- L'emplacement de la carte Micro SD est situé à l'arrière du module MP3.
- Connexion audio : Il dispose d'un connecteur auxiliaire mâle de 3,5 mm pour se connecter à un lecteur MP3.
- Connexion d'alimentation : Il peut se connecter par USB, par un adaptateur secteur de 5 V, ou par d'autres sources d'alimentation.
image source: diyables.io
Schéma des broches du haut-parleur
Un haut-parleur a généralement deux points de connexion :
Comment ça marche
Voici ce que vous devez faire :
- Chargez une liste de chansons ou d'enregistrements sur une carte microSD.
- Insérez la carte microSD dans le module lecteur MP3.
- Connectez le module lecteur MP3 à l'ESP32.
- Branchez le module lecteur MP3 à un haut-parleur.
- Branchez le haut-parleur à une source d'alimentation. Si vous utilisez des écouteurs ou un casque, vous n'avez pas besoin de faire cette étape.
Chaque fichier MP3 sur la carte Micro SD est numéroté, à partir de 0, ce qui détermine l'ordre des chansons. Nous allons écrire le script MicroPython pour l'ESP32 afin d'envoyer différentes commandes au module lecteur MP3. Il prend en charge les commandes suivantes :
- Démarrer la lecture
- Arrêter
- Lire le morceau suivant
- Lire le morceau précédent
- Régler le volume
Une fois la commande reçue, le module lecteur MP3 lit les fichiers stockés sur la carte microSD, les transforme en signaux audio et envoie ces signaux au haut-parleur par la prise jack auxiliaire de 3,5 mm.
Diagramme de câblage
- Comment connecter l'ESP32 et un lecteur MP3 en utilisant breadboard
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
- Comment connecter l'ESP32 et le lecteur MP3 en utilisant une carte breakout avec un bornier à vis
ESP32 MicroPython Code - Jouer de la musique
Le code ci-dessous commence à jouer la première chanson stockée sur la carte microSD.
/*
* Ce code ESP32 MicroPython a été développé par newbiely.fr
* Ce code ESP32 MicroPython est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp32-micropython/esp32-micropython-mp3-player
*/
from machine import UART, Pin
import time
# Define constants
CMD_PLAY_NEXT = 0x01
CMD_PLAY_PREV = 0x02
CMD_PLAY_W_INDEX = 0x03
CMD_SET_VOLUME = 0x06
CMD_SEL_DEV = 0x09
CMD_PLAY_W_VOL = 0x22
CMD_PLAY = 0x0D
CMD_PAUSE = 0x0E
CMD_SINGLE_CYCLE = 0x19
DEV_TF = 0x02
SINGLE_CYCLE_ON = 0x00
SINGLE_CYCLE_OFF = 0x01
ESP32_RX = 16 # The ESP32 pin GPIO16 connected to the TX of the Serial MP3 Player module
ESP32_TX = 17 # The ESP32 pin GPIO17 connected to the RX of the Serial MP3 Player module
# Initialize UART with the correct pins and baud rate
mp3 = UART(1, baudrate=9600, tx=Pin(ESP32_TX), rx=Pin(ESP32_RX))
def mp3_command(command, dat):
frame = bytearray(8)
frame[0] = 0x7e # starting byte
frame[1] = 0xff # version
frame[2] = 0x06 # the number of bytes of the command without starting byte and ending byte
frame[3] = command #
frame[4] = 0x00 # 0x00 = no feedback, 0x01 = feedback
frame[5] = (dat >> 8) & 0xFF # data high byte
frame[6] = dat & 0xFF # data low byte
frame[7] = 0xef # ending byte
mp3.write(frame)
# Wait for the chip initialization to complete
time.sleep(0.5)
# Select the TF card
mp3_command(CMD_SEL_DEV, DEV_TF)
time.sleep(0.2) # wait for 200ms
# Play MP3
mp3_command(CMD_PLAY, 0x0000)
# mp3_command(CMD_PAUSE, 0x0000) # Pause mp3
# mp3_command(CMD_PLAY_NEXT, 0x0000) # Play next mp3
# mp3_command(CMD_PLAY_PREV, 0x0000) # Play previous mp3
# mp3_command(CMD_SET_VOLUME, 30) # Change volume to 30
# Main loop to keep the script running
while True:
time.sleep(0.1) # Prevent tight loop
Étapes rapides
Voici les instructions pour configurer et exécuter votre code MicroPython sur l'ESP32 à l'aide de l'IDE Thonny :
- Assurez-vous que l’IDE Thonny est installé sur votre ordinateur.
- Confirmez que le firmware MicroPython est chargé sur votre carte ESP32.
- Si c’est la première fois que vous utilisez une ESP32 avec MicroPython, consultez le guide ESP32 - Premiers pas. pour des instructions étape par étape.
- Connectez la carte ESP32 au module lecteur MP3 selon le diagramme fourni.
- Connectez la carte ESP32 à votre ordinateur avec un câble USB.
- Ouvrez l’IDE Thonny sur votre ordinateur.
- Dans l’IDE Thonny, allez dans Outils Options.
- Sous l’onglet Interpréteur, choisissez MicroPython (ESP32) dans le menu déroulant.
- Assurez-vous que le bon port est sélectionné. Thonny IDE le détecte généralement automatiquement, mais vous devrez peut-être le sélectionner manuellement (comme COM12 sous Windows ou /dev/ttyACM0 sous Linux).
- Copiez le code MicroPython fourni et collez-le dans l’éditeur de Thonny.
- Enregistrez le code sur votre ESP32 en:
- En cliquant sur le bouton Enregistrer ou en appuyant sur Ctrl+S.
- Dans la boîte de dialogue d’enregistrement, choisissez périphérique MicroPython.
- Nommez le fichier main.py.
- Cliquez sur le bouton vert Exécuter (ou appuyez sur F5) pour exécuter le script.
- Profitez de la musique
Code MicroPython ESP32 - Jouer de la musique avec des boutons de commande
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Le code qui suit est une version mise à jour de celui qui le précède. Il comprend quatre boutons qui vous permettent de gérer le lecteur MP3.
/*
* Ce code ESP32 MicroPython a été développé par newbiely.fr
* Ce code ESP32 MicroPython est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp32-micropython/esp32-micropython-mp3-player
*/
from machine import UART, Pin
import time
from DIYables_MicroPython_Button import Button
# Define constants
CMD_PLAY_NEXT = 0x01
CMD_PLAY_PREV = 0x02
CMD_PLAY_W_INDEX = 0x03
CMD_SET_VOLUME = 0x06
CMD_SEL_DEV = 0x09
CMD_PLAY_W_VOL = 0x22
CMD_PLAY = 0x0D
CMD_PAUSE = 0x0E
CMD_SINGLE_CYCLE = 0x19
DEV_TF = 0x02
SINGLE_CYCLE_ON = 0x00
SINGLE_CYCLE_OFF = 0x01
ESP32_RX = 16 # The ESP32 pin GPIO16 connected to the TX of the Serial MP3 Player module
ESP32_TX = 17 # The ESP32 pin GPIO17 connected to the RX of the Serial MP3 Player module
# Initialize UART with the correct pins and baud rate
mp3 = UART(1, baudrate=9600, tx=Pin(ESP32_TX), rx=Pin(ESP32_RX))
# Initialize buttons using the Button library
button_play = Button(32) # The ESP32 pin GPIO32 for play
button_pause = Button(33) # The ESP32 pin GPIO33 for pause
button_next = Button(25) # The ESP32 pin GPIO25 for next
button_prev = Button(26) # The ESP32 pin GPIO26 for previous
# Set debounce time to 50 milliseconds for each button
button_play.set_debounce_time(50)
button_pause.set_debounce_time(50)
button_next.set_debounce_time(50)
button_prev.set_debounce_time(50)
def mp3_command(command, dat):
frame = bytearray(8)
frame[0] = 0x7e # starting byte
frame[1] = 0xff # version
frame[2] = 0x06 # the number of bytes of the command without starting byte and ending byte
frame[3] = command #
frame[4] = 0x00 # 0x00 = no feedback, 0x01 = feedback
frame[5] = (dat >> 8) & 0xFF # data high byte
frame[6] = dat & 0xFF # data low byte
frame[7] = 0xef # ending byte
mp3.write(frame)
# Wait for the chip initialization to complete
time.sleep(0.5)
# Select the TF card
mp3_command(CMD_SEL_DEV, DEV_TF)
time.sleep(0.2) # wait for 200ms
# Main loop to check buttons and send commands
while True:
# Update the state of each button
button_play.loop()
button_pause.loop()
button_next.loop()
button_prev.loop()
# Handle play button press
if button_play.is_pressed():
print("Play mp3")
mp3_command(CMD_PLAY, 0x0000)
# Handle pause button press
if button_pause.is_pressed():
print("Pause mp3")
mp3_command(CMD_PAUSE, 0x0000)
# Handle next button press
if button_next.is_pressed():
print("Play next mp3")
mp3_command(CMD_PLAY_NEXT, 0x0000)
# Handle previous button press
if button_prev.is_pressed():
print("Play previous mp3")
mp3_command(CMD_PLAY_PREV, 0x0000)
time.sleep(0.01) # Small delay to be gentle on the CPU
Étapes rapides
- Dans l'IDE Thonny, accédez à Outils Gérer les paquets sur l'IDE Thonny.
- Rechercher “DIYables-MicroPython-Button”, puis trouvez la bibliothèque Button créée par DIYables.
- Cliquez sur DIYables-MicroPython-Button, puis cliquez sur le bouton Install pour installer la bibliothèque Button.
- Copiez le code ci-dessus et collez-le dans l'éditeur de l'IDE Thonny.
- Enregistrez le script sur votre carte ESP32.
- Cliquez sur le bouton vert Exécuter (ou appuyez sur F5) pour exécuter le script. Le script s'exécutera.
- Appuyez sur les boutons un par un.
- Profitez de la musique.