CAPTEURS/ACTIONNEURS

INTERNET OF THING (IoT)

Arduino Mega - Lecteur MP3

Bienvenue dans ce tutoriel complet sur le lecteur MP3 Arduino Mega ! Dans ce guide détaillé, vous découvrirez comment construire un lecteur MP3 entièrement fonctionnel en utilisant un Arduino Mega, un module lecteur MP3 série, une carte micro SD et un haut-parleur. Transformez votre Arduino en un système de lecture audio complet capable de jouer de la musique, des effets sonores, des enregistrements vocaux et des notifications audio !

Construire un lecteur MP3 Arduino Mega ouvre des possibilités passionnantes au-delà de la simple lecture musicale. Ce système audio polyvalent peut servir de base pour des expositions interactives de musée, des outils éducatifs avec retour audio, des annonces vocales pour maison intelligente, des carillons de porte avec sons personnalisés, des systèmes d'alarme avec avertissements parlés, des lecteurs de livres audio, des générateurs de sons d'ambiance et des guides audio automatisés. La combinaison de la programmabilité d'Arduino avec la lecture MP3 crée des opportunités créatives infinies !

Tout au long de ce tutoriel de lecteur MP3 Arduino Mega, nous explorerons tout ce dont vous avez besoin pour maîtriser la lecture audio :

Comprendre le module lecteur MP3 série et comment il décode les fichiers MP3 en signaux audio
Préparer votre carte micro SD avec des fichiers MP3 correctement formatés et numérotés
Connexions de câblage entre Arduino Mega, module MP3 et haut-parleur
Communication série UART entre Arduino et le module MP3
Contrôle de lecture de base - jouer des chansons automatiquement au démarrage
Contrôle interactif - ajouter des boutons lecture, pause, suivant et précédent
Contrôle du volume - ajuster les niveaux audio par programmation
Gestion des fichiers - organiser et accéder à plusieurs fichiers audio
Fonctionnalités avancées - ajouter des potentiomètres, télécommandes IR et contrôle RFID

Comment fonctionne le système :

Le module lecteur MP3 agit comme une puce de décodage audio dédiée. Il lit les fichiers MP3 depuis la carte micro SD, décode les données audio compressées, les convertit en signaux audio analogiques et les sort par sa prise audio 3,5 mm. L'Arduino Mega envoie des commandes série (via les broches TX/RX) pour contrôler la lecture - indiquant au module quel fichier jouer, quand mettre en pause, passer des pistes ou ajuster le volume. Cette répartition des tâches permet à l'Arduino de se concentrer sur l'interface utilisateur et la logique de contrôle tandis que le module MP3 gère le décodage audio complexe.

Ce projet de lecteur MP3 Arduino Mega est parfait pour les makers de tous niveaux ! Que vous construisiez votre premier projet audio ou que vous créiez une installation interactive sophistiquée, ce tutoriel fournit la base dont vous avez besoin.

Matériel requis

1	×	Arduino Mega
1	×	Câble USB 2.0 type A/B
1	×	Module lecteur MP3 série
1	×	Carte micro SD
1	×	Haut-parleur aux 3,5 mm
1	×	Fils de connexion
1	×	Recommandé: Screw Terminal Block Shield for Arduino Uno/Mega
1	×	Recommandé: Breadboard Shield for Arduino Mega
1	×	Recommandé: Enclosure for Arduino Mega

Ou vous pouvez acheter les kits suivants:

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

Le module lecteur MP3 série est une carte de décodage audio compacte et tout-en-un qui simplifie l'ajout de lecture MP3 aux projets Arduino. Ces modules (communément basés sur des puces comme YX5200, JQ6500 ou DFPlayer Mini) combinent un décodeur MP3, un lecteur de carte micro SD, un amplificateur audio et une interface de communication série dans un seul package.

Caractéristiques principales :

Décodage MP3 : Décodage matériel des fichiers audio MP3 et parfois WAV
Support carte micro SD : Lit les fichiers audio depuis les cartes micro SD (généralement jusqu'à 32 Go)
Communication UART : Commandes série simples contrôlent toutes les fonctions de lecture
Amplificateur intégré : Peut alimenter de petits haut-parleurs (sortie typique 3W)
Prise audio 3,5 mm : Sortie aux standard pour connecter haut-parleurs ou casques
Formats audio multiples : Beaucoup de modules supportent les formats MP3, WAV et WMA
Navigation par dossiers : Organisez les chansons en dossiers pour une gestion plus facile
Paramètres EQ : Certains modules offrent des préréglages d'égaliseur intégrés

Comment fonctionne le module :

Quand l'Arduino envoie une commande série (par ex., "jouer piste 3"), le module MP3 :

Lit le fichier MP3 spécifié depuis la carte micro SD
Décode les données MP3 compressées en utilisant sa puce de décodage dédiée
Convertit l'audio numérique en signal analogique via son DAC intégré
Amplifie le signal à travers l'amplificateur embarqué
Sort l'audio par la prise 3,5 mm vers le haut-parleur connecté

Ce décodage basé matériel est crucial car l'Arduino Mega n'a pas assez de puissance de traitement pour décoder les fichiers MP3 en logiciel. Le module gère tout le traitement audio complexe tandis que l'Arduino envoie simplement des commandes série simples.

Brochage du module lecteur MP3 série

Le module lecteur MP3 série présente trois interfaces de connexion, chacune servant un objectif spécifique dans le système de lecture audio :

1. Connexion Arduino - Interface série UART (4 broches) :

Broche RX (Receive) : Reçoit les données série DE l'Arduino. Connectez cette broche à la broche TX de l'Arduino Mega. Cette broche reçoit des commandes comme "lecture", "pause", "piste suivante", etc. Vous pouvez utiliser Hardware Serial (Serial1, Serial2, Serial3 sur Mega) ou Software Serial.
Broche TX (Transmit) : Envoie les données série VERS l'Arduino. Connectez cette broche à la broche RX de l'Arduino Mega. Cette broche envoie des informations de statut vers l'Arduino (comme la piste en cours de lecture, lecture terminée, etc.). Optionnel dans les applications simples.
Broche VCC : Entrée d'alimentation. Connectez à la broche 5V de l'Arduino Mega. Le module consomme typiquement 20-50mA pendant la lecture, plus pendant les passages forts.
Broche GND : Référence de masse. Connectez à la broche GND de l'Arduino Mega pour compléter le circuit et établir une masse commune.

Communication série UART :

Le module utilise la communication UART (Universal Asynchronous Receiver-Transmitter) à 9600 bauds. Les commandes sont envoyées comme des séquences d'octets spécifiques. Par exemple, pour jouer la piste 1, l'Arduino envoie : 0x7E 0xFF 0x06 0x03 0x00 0x00 0x01 0xEF. Heureusement, les bibliothèques Arduino (comme DFRobotDFPlayerMini) gèrent ces structures de commandes complexes pour vous !

2. Connexion haut-parleur - Prise audio 3,5 mm :

Prise aux femelle 3,5 mm : Connecteur de sortie audio standard. Connectez n'importe quel haut-parleur ou casque avec une fiche mâle 3,5 mm. Le module sort un audio de niveau ligne ou amplifié selon le modèle spécifique.

3. Connexion carte micro SD - Socket de carte :

Socket de carte micro SD : Situé au dos du module. Insérez votre carte micro SD ici (formatée en FAT32 avec fichiers MP3). La carte doit s'enclencher. La plupart des modules supportent des cartes jusqu'à 32 Go.

image source: diyables.io

Options Serial matériel Arduino Mega :

L'Arduino Mega a 4 ports série UART matériel :

Serial (broches 0/1) - Utilisé pour communication USB, évitez pour le module MP3
Serial1 (broches 19/18) - TX1=19, RX1=18
Serial2 (broches 17/16) - TX2=17, RX2=16
Serial3 (broches 15/14) - TX3=15, RX3=14

L'utilisation du serial matériel est recommandée par rapport au software serial pour une communication plus fiable !

Brochage du haut-parleur

La plupart des haut-parleurs actifs (alimentés) conçus pour les lecteurs MP3 ont deux connexions essentielles :

1. Connexion d'entrée audio :

Fiche mâle aux 3,5 mm : Ce connecteur audio standard se branche dans la prise femelle 3,5 mm du module MP3. La connexion transporte le signal audio stéréo (canal gauche, canal droit et masse). C'est le même type de connexion utilisé pour les casques et haut-parleurs d'ordinateur.

2. Connexion d'alimentation :

Les haut-parleurs actifs nécessitent leur propre source d'alimentation car la sortie du module MP3 n'est généralement pas assez puissante pour alimenter directement les bobines des haut-parleurs. Options d'alimentation communes :

Alimentation USB (5V) : Beaucoup de haut-parleurs portables modernes utilisent l'alimentation USB. Peut être alimenté depuis une batterie USB portable, un adaptateur mural ou même le port USB de l'ordinateur (si le courant est suffisant).
Adaptateur AC (5V/12V) : Certains haut-parleurs plus grands utilisent des adaptateurs muraux qui se branchent sur le secteur. Vérifiez la tension nominale (généralement 5V, 9V ou 12V).
Alimentation par batterie : Les haut-parleurs Bluetooth portables peuvent être réutilisés en se connectant à l'entrée aux.
Alimentation dédiée : Pour les installations permanentes, utilisez une alimentation régulée 5V.

Conseils de sélection de haut-parleur :

Impédance : Cherchez des haut-parleurs 4-8 ohms pour une meilleure compatibilité
Puissance nominale : Les haut-parleurs 3W-5W fonctionnent bien avec la plupart des modules MP3
Actif vs Passif : Les haut-parleurs actifs (amplifiés) sont recommandés car ils ont des amplificateurs intégrés
Taille : Les haut-parleurs plus grands offrent une meilleure réponse des basses et du volume
Qualité : De meilleurs haut-parleurs améliorent significativement la qualité audio de votre lecteur MP3

Alternative : Haut-parleurs passifs

Si vous utilisez des haut-parleurs passifs (sans amplificateur intégré), vous devrez ajouter un module amplificateur externe entre le lecteur MP3 et le haut-parleur, comme une carte amplificateur PAM8403 ou LM386.

Comment ça marche

Décomposons le flux de travail complet du système lecteur MP3 Arduino Mega, de la préparation des fichiers à la lecture audio via votre haut-parleur.

Étapes de préparation du système

Étape 1 : Préparer la carte micro SD

Formater la carte : Formatez votre carte micro SD en FAT32 (requis pour la plupart des modules MP3). Utilisez l'outil de formatage de disque de votre ordinateur.
Organiser les fichiers MP3 : Copiez vos fichiers MP3 dans le répertoire racine de la carte SD. Le module MP3 assigne à chaque fichier un numéro basé sur l'ordre dans lequel ils sont stockés :

Premier fichier : Piste 0001 ou Piste 1 (selon le module)
Deuxième fichier : Piste 0002 ou Piste 2
Troisième fichier : Piste 0003 ou Piste 3
Et ainsi de suite...

Nommage des fichiers (Optionnel mais recommandé) : Nommez les fichiers systématiquement :

001_nom_chanson.mp3
002_nom_chanson.mp3
003_nom_chanson.mp3

Cela facilite la correspondance entre numéro et chanson.

Créer des dossiers (Avancé) : Certains modules supportent l'organisation par dossiers :

Dossier "01" avec chansons 001.mp3, 002.mp3, etc.
Dossier "02" avec plus de chansons
Accéder aux fichiers par numéro de dossier et de piste

Étape 2 : Assemblage physique

Insérez la carte micro SD préparée dans le socket de carte du module lecteur MP3 (arrière du module)
Connectez le module lecteur MP3 à l'Arduino Mega en utilisant des fils de connexion (RX, TX, VCC, GND)
Connectez le haut-parleur à la prise audio 3,5 mm du module MP3
Connectez le haut-parleur à sa source d'alimentation (USB, adaptateur mural ou batterie)

Protocole de communication

L'Arduino Mega communique avec le module MP3 en utilisant des commandes série UART. Chaque commande consiste en une séquence d'octets spécifique qui indique au module quoi faire.

Commandes communes supportées :

Lecture : Commencer la lecture de la piste actuelle ou reprendre depuis une pause
Arrêt : Arrêter complètement la lecture
Pause : Mettre temporairement en pause la lecture (peut être reprise)
Suivant : Passer à la piste suivante dans la séquence
Précédent : Revenir à la piste précédente
Jouer piste spécifique : Jouer la piste numéro N (par ex., piste 5)
Volume Haut/Bas : Augmenter ou diminuer le niveau de volume
Régler volume : Définir le volume à un niveau spécifique (0-30 typiquement)
Interroger statut : Demander au module son état actuel (lecture, arrêt, etc.)
Obtenir nombre de pistes : Demander combien de fichiers sont sur la carte SD

Processus de lecture audio

Quand vous commandez au module de jouer une piste, voici ce qui se passe en coulisse :

Arduino envoie commande : Arduino transmet les octets de commande série via la broche TX vers la broche RX du module
Module reçoit commande : Le microcontrôleur du module MP3 reçoit et interprète la commande
Accès fichier : Le module accède à la carte micro SD et localise le fichier MP3 demandé
Décodage MP3 : La puce de décodage dédiée lit et décompresse les données MP3
Conversion numérique-analogique : L'audio numérique décodé est converti en signaux de tension analogique
Amplification : L'amplificateur intégré amplifie le signal pour alimenter les haut-parleurs
Sortie audio : Le signal audio amplifié est envoyé via la prise 3,5 mm vers le haut-parleur
Production sonore : L'électroaimant du haut-parleur fait vibrer le cône du haut-parleur, produisant un son audible

Retour de statut (Optionnel) :

Le module MP3 peut renvoyer des informations de statut vers l'Arduino via sa broche TX (connectée à la broche RX de l'Arduino). Cela permet à l'Arduino de savoir :

Quand une piste finit de jouer
Numéro de piste actuel
Niveau de volume actuel
Si la carte SD est correctement insérée
S'il y a des erreurs

Cette communication bidirectionnelle permet de créer des interfaces audio sophistiquées avec retour et affichage de statut !

Schéma de câblage

Le câblage pour le lecteur MP3 Arduino Mega est simple, nécessitant seulement 4 connexions entre l'Arduino et le module MP3, plus la sortie audio vers le haut-parleur.

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Résumé des connexions :

Broche module MP3	Broche Arduino Mega	Objectif
VCC	5V	Alimentation
GND	GND	Référence de masse
RX	TX1 (Broche 18)	Arduino envoie commandes au module
TX	RX1 (Broche 19)	Module envoie statut à Arduino (optionnel)

Connexions haut-parleur :

Prise 3,5 mm module MP3 → Entrée aux 3,5 mm haut-parleur
Alimentation haut-parleur → Batterie USB portable ou adaptateur mural

Notes de câblage :

Choix de port série : Ce schéma utilise Serial1 (broches 18/19). Vous pouvez utiliser Serial2 (16/17) ou Serial3 (14/15) si nécessaire pour votre projet.
Croisement TX/RX : Rappelez-vous que TX sur un appareil se connecte à RX sur l'autre appareil. Cela permet aux données de circuler : Arduino TX → Module RX (commandes) et Module TX → Arduino RX (statut).
Considérations d'alimentation : Le module MP3 consomme environ 20-50mA pendant la lecture. La broche 5V de l'Arduino peut facilement fournir ce courant.
Connexion TX optionnelle : Si vous devez seulement envoyer des commandes (lecture, arrêt, volume) et n'avez pas besoin de retour de statut, vous pouvez omettre de connecter la broche TX du module. Connectez juste RX, VCC et GND.
La masse est critique : Assurez-vous toujours d'une connexion GND solide entre Arduino et module MP3. De mauvaises connexions de masse causent du bruit, de la distorsion ou des échecs de communication.

Carte micro SD :

Insérez votre carte micro SD préparée (formatée FAT32 avec fichiers MP3) dans le socket de carte à l'arrière du module MP3 avant de mettre sous tension.

Code Arduino Mega - Jouer de la musique

Le code ci-dessous commence à jouer la première chanson sauvegardée sur la carte micro SD.

Étapes rapides

Suivez ces étapes une par une.

Connectez les pièces comme montré dans le diagramme.
Connectez l'Arduino Mega à votre ordinateur avec un câble USB.
Ouvrez l'IDE Arduino sur votre ordinateur.
Choisissez la carte correcte (Arduino Mega) et le bon port COM.
Suivez les étapes dans la section Comment ça marche.
Copiez le code fourni et collez-le dans l'IDE Arduino.
Cliquez sur le bouton Téléverser dans l'IDE Arduino pour envoyer le code vers l'Arduino Mega.
Amusez-vous à faire de la musique.

Code Arduino Mega - Jouer de la musique avec boutons de contrôle

Le code ci-dessous est une meilleure version du code précédent. Il a quatre boutons qui vous permettent de contrôler le lecteur MP3.

/* * Ce code Arduino Mega a été développé par newbiely.fr * Ce code Arduino Mega 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/arduino-mega/arduino-mega-mp3-player */ #include <SoftwareSerial.h> #include <ezButton.h> #define CMD_PLAY_NEXT 0x01 #define CMD_PLAY_PREV 0x02 #define CMD_PLAY_W_INDEX 0x03 #define CMD_SET_VOLUME 0x06 #define CMD_SEL_DEV 0x09 #define CMD_PLAY_W_VOL 0x22 #define CMD_PLAY 0x0D #define CMD_PAUSE 0x0E #define CMD_SINGLE_CYCLE 0x19 #define DEV_TF 0x02 #define SINGLE_CYCLE_ON 0x00 #define SINGLE_CYCLE_OFF 0x01 ezButton button_play(2); // create ezButton object that attach to pin 2 ezButton button_pause(3); // create ezButton object that attach to pin 3 ezButton button_next(4); // create ezButton object that attach to pin 4 ezButton button_prev(5); // create ezButton object that attach to pin 5 void setup() { Serial.begin(9600); Serial3.begin(9600); delay(500); // wait chip initialization is complete mp3_command(CMD_SEL_DEV, DEV_TF); // select the TF card delay(200); // wait for 200ms button_play.setDebounceTime(50); // set debounce time to 50 milliseconds button_pause.setDebounceTime(50); // set debounce time to 50 milliseconds button_next.setDebounceTime(50); // set debounce time to 50 milliseconds button_prev.setDebounceTime(50); // set debounce time to 50 milliseconds } void loop() { button_play.loop(); // MUST call the loop() function first button_pause.loop(); // MUST call the loop() function first button_next.loop(); // MUST call the loop() function first button_prev.loop(); // MUST call the loop() function first if (button_play.isPressed()) { Serial.println("Play mp3"); mp3_command(CMD_PLAY, 0x0000); } if (button_pause.isPressed()) { Serial.println("Pause mp3"); mp3_command(CMD_PAUSE, 0x0000); } if (button_next.isPressed()) { Serial.println("Play next mp3"); mp3_command(CMD_PLAY_NEXT, 0x0000); } if (button_prev.isPressed()) { Serial.println("Play previous mp3"); mp3_command(CMD_PLAY_PREV, 0x0000); } } void mp3_command(int8_t command, int16_t dat) { int8_t frame[8] = { 0 }; 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] = (int8_t)(dat >> 8); // data high byte frame[6] = (int8_t)(dat); // data low byte frame[7] = 0xef; // ending byte for (uint8_t i = 0; i < 8; i++) { Serial3.write(frame[i]); } }

Le câblage pour le code mentionné :

Schéma de câblage haut-parleur lecteur MP3 Arduino Mega

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Maintenant vous pouvez modifier les projets pour ajouter plus de fonctionnalités, par exemple :

Ajouter un bouton de volume pour changer le niveau sonore. Voir le Arduino Mega - Potentiomètre.
Ajouter une télécommande IR pour le contrôler. Suivez le tutoriel Contrôleur télécommande IR Arduino Mega.
Ajouter un lecteur RFID et une carte pour faire un lecteur MP3 RFID. Pour plus de détails, consultez le tutoriel RFID Arduino Mega.

Vidéo

Références des fonctions

Tutoriels connexes

※ NOS MESSAGES

N'hésitez pas à partager le lien de ce tutoriel. Cependant, veuillez ne pas utiliser notre contenu sur d'autres sites web. Nous avons investi beaucoup d'efforts et de temps pour créer ce contenu, veuillez respecter notre travail !