Arduino Uno R4 - Mini-MP3-Player
In diesem Tutorial erfahren Sie, wie Sie das DIYables Mini-MP3-Player-Modul mit dem Arduino Uno R4 (sowohl WiFi- als auch Minima-Varianten) verwenden. Wir werden Folgendes behandeln:
- Verdrahtung des Mini-MP3-Players zum Arduino Uno R4.
- Wiedergabe von MP3-Titeln, die auf einer SD-Karte gespeichert sind.
- Lautstärkeanpassung, einschließlich Lautstärke erhöhen und Lautstärke verringern.
- Anhalten, Fortsetzen und Beenden der Wiedergabe.
- Navigation zwischen Titeln (nächster und vorheriger Titel).
- Schleifen eines einzelnen Titels, Schleifen aller Titel und Zufallswiedergabe.
- Wiedergabe bestimmter Titel aus nummerierten Ordnern.
- Abfrage des Wiedergabestatus.
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables STEM V4 IoT Starter-Kit (Arduino enthalten) | |
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Über das Mini-MP3-Player-Modul
Das DIYables Mini-MP3-Player ist ein kompaktes MP3-Decoder-Modul, das auf dem YX5200-24SS-Chip basiert. Es spielt MP3-Dateien direkt von einer Micro-SD-Karte ab und kann einen Lautsprecher (bis zu 3 W) über seinen integrierten Verstärker antreiben oder Audio auf Zeilenpegel über DAC-Pins für die Verwendung mit einem externen Verstärker ausgeben.
Die Kommunikation erfolgt über UART bei 9600 Baud und ist daher einfach von jeder Arduino-Platine aus zu steuern. Wichtige Funktionen umfassen:
- Wiedergabe, Pause, Fortsetzen und Stoppen
- Lautstärkeanpassung von 0 bis 30
- Sechs Equalizer-Voreinstellungen: Normal, Pop, Rock, Jazz, Klassik, Bass
- Titelschleifen, Ordnerschleifen, vollständige Zufallswiedergabe
- Ordnerbasierte Wiedergabe mit nummerierten Verzeichnissen
- Unterbrechbare Wiedergabe mit Werbung
- Abfrage des aktuellen Titels, der Lautstärke, des Wiedergabestatus und mehr
Modul-Anschlussplan
| Anschluss | Beschreibung |
|---|---|
| VCC | Stromeingang (3,2 V bis 5,0 V) |
| GND | Masse |
| RX | Serieller Dateneingabe — mit Arduino TX über einen 1-kΩ-Widerstand verbinden |
| TX | Serieller Datenausgang — mit Arduino RX verbinden |
| SPK_1 | Lautsprecherpositives Terminal (direkte Ansteuerung, max. 3 W) |
| SPK_2 | Lautsprechernegatives Terminal (direkte Ansteuerung, max. 3 W) |
| DAC_R | Ausgang rechter Kanal (für externen Verstärker) |
| DAC_L | Ausgang linker Kanal (für externen Verstärker) |
| BUSY | LOW während der Wiedergabe, HIGH im Leerlauf |
| IO_1 | Kurzer Druck = vorheriger Titel, langer Druck = Lautstärke verringern |
| IO_2 | Kurzer Druck = nächster Titel, langer Druck = Lautstärke erhöhen |
Verdrahtungsdiagramm
Der Arduino Uno R4 arbeitet mit 5-V-Logik, daher ist ein 1-kΩ-Widerstand auf der RX-Leitung des Moduls erforderlich, um seinen 3,3-V-Eingang zu schützen.
| Mini-MP3-Player-Anschluss | Arduino Uno R4-Anschluss | Hinweis |
|---|---|---|
| VCC | 5V | |
| GND | GND | |
| RX | Pin 11 | Über 1-kΩ-Widerstand (erforderlich für 5-V-Platinen) |
| TX | Pin 10 | |
| SPK_1 | Lautsprecher + | |
| SPK_2 | Lautsprecher − |
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Siehe Der beste Weg, den Arduino Uno R4 und andere Komponenten mit Strom zu versorgen.
Tipp: Der Uno R4 hat einen Hardware-Seriell-Port (Serial1 auf den Pins 0 und 1), aber da die Pins 0/1 mit USB gemeinsam genutzt werden, ist die Verwendung von SoftwareSerial auf den Pins 10/11 der sicherere Ansatz.
Vorbereitung der SD-Karte
- Formatieren Sie die Micro-SD-Karte als FAT16 oder FAT32.
- Kopieren Sie Ihre MP3-Dateien in das Stammverzeichnis mit nullgepolsterten Namen:
/001.mp3
/002.mp3
/003.mp3
- Für ordnerbasierte Wiedergabe erstellen Sie nummerierte Ordner mit nummerierten Dateien:
/01/001.mp3
/01/002.mp3
/02/001.mp3
Wichtige Punkte:
- Die Titelnummerierung beginnt bei 1, nicht 0.
- Das Modul bestimmt die Titelreihenfolge nach der Reihenfolge, in der Dateien kopiert werden, nicht nach dem Dateinamen. Formatieren Sie die Karte immer zuerst und kopieren Sie die Dateien dann einzeln in der gewünschten Reihenfolge.
- Ordnernamen: 2-stellig, nullgepolstert (01 bis 99).
- Dateinamen in Ordnern: 3-stellig, nullgepolstert (001 bis 255).
Installation der Bibliothek
- Verbinden Sie den Arduino Uno R4 über ein USB-C-Kabel mit Ihrem Computer.
- Öffnen Sie die Arduino-IDE und wählen Sie die korrekte Platine und den richtigen Port aus.
- Klicken Sie auf das Bibliotheken-Symbol in der linken Seitenleiste.
- Geben Sie "DIYables_MiniMp3" in das Suchfeld ein und suchen Sie die Bibliothek von DIYables.
- Klicken Sie auf Installieren, um die neueste Version der Bibliothek hinzuzufügen.
Diese Bibliothek hat keine externen Abhängigkeiten.
Arduino Uno R4 Code - Einen einzelnen Titel wiedergeben
Der folgende Sketch spielt einen MP3-Titel von der SD-Karte ab.
/*
* DIYables Mini Mp3 Player - Play One Track
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Plays track 001 once, then stops.
*
* Wiring (Arduino Uno R4):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000); // Wait for the module to initialize
mp3.setVolume(25); // Set volume (0 to 30)
Serial.println("Playing track 1...");
mp3.play(1); // Play track 001.mp3
}
void loop()
{
// Nothing to do here
}
Ausführung
- Bereiten Sie eine SD-Karte mit MP3-Dateien (001.mp3, 002.mp3 usw.) vor und legen Sie sie in das Modul ein.
- Verdrahten Sie den Mini-MP3-Player gemäß dem obigen Verdrahtungsdiagramm mit dem Uno R4.
- Verbinden Sie den Uno R4 über ein USB-C-Kabel mit Ihrem Computer.
- Öffnen Sie die Arduino-IDE, wählen Sie Arduino Uno R4 WiFi (oder Minima) als Platine aus und wählen Sie den richtigen Port.
- Fügen Sie den obigen Code in den IDE-Editor ein.
- Klicken Sie auf Hochladen.
Sie sollten den Titel 001.mp3 durch den Lautsprecher hören.
Wiedergabefunktionen auf einen Blick
| Funktion | Was es tut | Verwendung |
|---|---|---|
| play(trackNum) | Startet einen bestimmten Titel | mp3.play(1) |
| playNext() | Springt zum nächsten Titel | mp3.playNext() |
| playPrevious() | Geht zum vorherigen Titel zurück | mp3.playPrevious() |
| pause() | Pausiert den aktuellen Titel | mp3.pause() |
| resume() | Setzt einen unterbrochenen Titel fort | mp3.resume() |
| stop() | Beendet die Wiedergabe vollständig | mp3.stop() |
Arduino Uno R4 Code - Mehrere Titel hintereinander wiedergeben
Dieser Sketch spielt mehrere Titel hintereinander mit einer konfigurierbaren Verzögerung zwischen jedem ab.
/*
* DIYables Mini Mp3 Player - Play Multiple Tracks
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Plays tracks one after another with a delay between them.
*
* Wiring (Arduino Uno R4):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, 003.mp3
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // RX, TX
DIYables_MiniMp3 mp3;
int currentTrack = 1;
int totalTracks = 3; // Change this to match your SD card
unsigned long lastTrackTime = 0;
unsigned long trackDuration = 5000; // Wait 5 seconds between tracks (adjust as needed)
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
Serial.println("Playing track 1...");
mp3.play(currentTrack);
lastTrackTime = millis();
}
void loop()
{
// After trackDuration, play the next track
if (millis() - lastTrackTime >= trackDuration)
{
currentTrack++;
if (currentTrack > totalTracks)
currentTrack = 1; // Loop back to first track
Serial.print("Playing track ");
Serial.println(currentTrack);
mp3.play(currentTrack);
lastTrackTime = millis();
}
}
Ausführung
- Stellen Sie sicher, dass die SD-Karte mindestens 3 Titel enthält (001.mp3, 002.mp3, 003.mp3).
- Laden Sie den Code auf den Uno R4 hoch.
Die Titel 1 bis 3 werden in einem wiederholten Zyklus mit einer 5-Sekunden-Pause abgespielt.
Arduino Uno R4 Code - Lautstärkeregelung mit Tasten
Verdrahten Sie zwei Drucktasten, um die Lautstärke in Echtzeit anzupassen.
/*
* DIYables Mini Mp3 Player - Volume Control
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Use two buttons to increase/decrease the volume.
* Press button on pin 2 to volume up, pin 3 to volume down.
*
* Wiring (Arduino Uno R4):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button UP -> Pin 2 (other leg to GND)
* Button DOWN -> Pin 3 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_VOL_UP = 2;
const int BUTTON_VOL_DOWN = 3;
int volume = 15; // Start at half volume
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
pinMode(BUTTON_VOL_UP, INPUT_PULLUP);
pinMode(BUTTON_VOL_DOWN, INPUT_PULLUP);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(volume);
mp3.loopTrack(1); // Play track 1 on repeat
Serial.print("Volume: ");
Serial.println(volume);
}
void loop()
{
// Volume Up button (pressed = LOW because of INPUT_PULLUP)
if (digitalRead(BUTTON_VOL_UP) == LOW)
{
if (volume < 30)
{
volume++;
mp3.setVolume(volume);
Serial.print("Volume: ");
Serial.println(volume);
}
delay(200); // Simple debounce
}
// Volume Down button
if (digitalRead(BUTTON_VOL_DOWN) == LOW)
{
if (volume > 0)
{
volume--;
mp3.setVolume(volume);
Serial.print("Volume: ");
Serial.println(volume);
}
delay(200); // Simple debounce
}
}
Ausführung
- Verbinden Sie zwei Tasten wie in den Code-Kommentaren beschrieben und laden Sie sie hoch.
- Drücken Sie die Tasten während der Musikwiedergabe, um die Lautstärke zu erhöhen oder zu verringern. Der Serial Monitor zeigt das aktuelle Niveau an.
Lautstärkefunktionen
| Funktion | Was es tut | Verwendung |
|---|---|---|
| setVolume(level) | Lautstärke direkt einstellen (0–30) | mp3.setVolume(25) |
| volumeUp() | Lautstärke um 1 erhöhen | mp3.volumeUp() |
| volumeDown() | Lautstärke um 1 verringern | mp3.volumeDown() |
| getVolume() | Gibt die aktuelle Lautstärke zurück | mp3.getVolume() |
Arduino Uno R4 Code - Schaltflächen für nächsten und vorherigen Titel
Zwei Tasten ermöglichen es Ihnen, vorwärts oder rückwärts durch Ihre Wiedergabeliste zu springen.
/*
* DIYables Mini Mp3 Player - Next/Previous with Buttons
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Use two buttons to play next/previous tracks.
* Displays the current track number on the Serial Monitor.
*
* Wiring (Arduino Uno R4):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button NEXT -> Pin 2 (other leg to GND)
* Button PREV -> Pin 3 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_NEXT = 2;
const int BUTTON_PREV = 3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
pinMode(BUTTON_NEXT, INPUT_PULLUP);
pinMode(BUTTON_PREV, INPUT_PULLUP);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
mp3.play(1); // Start with track 1
Serial.println("Press NEXT or PREV button to change track");
}
void loop()
{
if (digitalRead(BUTTON_NEXT) == LOW)
{
Serial.println("Next track");
mp3.playNext();
delay(300); // Simple debounce
}
if (digitalRead(BUTTON_PREV) == LOW)
{
Serial.println("Previous track");
mp3.playPrevious();
delay(300); // Simple debounce
}
}
Ausführung
- Verdrahten Sie die Tasten NEXT und PREV mit den Pins 2 und 3.
- Laden Sie den Sketch hoch und drücken Sie die Tasten, um zwischen den Titeln zu navigieren.
Arduino Uno R4 Code - Pause und Fortsetzen umschalten
Eine einzelne Taste schaltet die Wiedergabe zwischen Pause und Wiedergabe um.
/*
* DIYables Mini Mp3 Player - Pause and Resume
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Demonstrates pausing and resuming playback using a single button.
* Press the button to toggle between pause and resume.
*
* Wiring (Arduino Uno R4):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button -> Pin 2 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_PIN = 2;
bool paused = false;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
mp3.play(1);
Serial.println("Playing. Press button to pause/resume.");
}
void loop()
{
if (digitalRead(BUTTON_PIN) == LOW)
{
if (paused)
{
mp3.resume();
Serial.println("Resumed");
}
else
{
mp3.pause();
Serial.println("Paused");
}
paused = !paused;
delay(300); // Simple debounce
}
}
Ausführung
- Verdrahten Sie eine Taste mit Pin 2 und laden Sie sie hoch.
- Drücken Sie die Taste einmal zum Anhalten, drücken Sie erneut zum Fortsetzen.
Arduino Uno R4 Code - Einen Titel schleifen
Dieser Sketch wiederholt einen einzelnen Titel endlos.
/*
* DIYables Mini Mp3 Player - Loop Track
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Loops (repeats) a track continuously with EQ setting.
*
* Wiring (Arduino Uno R4):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card file structure:
* /001.mp3
* /002.mp3
* ...
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000); // Wait for the module to initialize
mp3.setVolume(25); // Volume: 0 to 30
mp3.setEQ(DIYables_MiniMp3::EQ_NORMAL);
Serial.println("Playing track 1 on loop...");
mp3.loopTrack(1);
}
void loop()
{
// Your code here
}
Ausführung
- Laden Sie den Code hoch. Der Titel 001.mp3 wird sich kontinuierlich wiederholen.
Wiederholungs- und Zufallsfunktionen
| Funktion | Was es tut | Verwendung |
|---|---|---|
| loopTrack(trackNum) | Wiederholt einen Titel endlos | mp3.loopTrack(1) |
| loopFolder(folder) | Wiederholt jeden Titel in einem Ordner | mp3.loopFolder(1) |
| loopAll() | Wiederholt alle Titel auf der Karte | mp3.loopAll() |
| stopLoop() | Bricht eine aktive Schleife ab | mp3.stopLoop() |
| shuffle() | Spielt alle Titel in zufälliger Reihenfolge ab | mp3.shuffle() |
Arduino Uno R4 Code - Aus einem Ordner wiedergeben
Spielen Sie Titel aus spezifischen nummerierten Ordnern auf der SD-Karte ab.
/*
* DIYables Mini Mp3 Player - Play from Folder
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Plays tracks from specific folders on the SD card.
*
* Wiring (Arduino Uno R4):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card file structure:
* /01/001.mp3 <- playFolder(1, 1)
* /01/002.mp3 <- playFolder(1, 2)
* /02/001.mp3 <- playFolder(2, 1)
* /02/002.mp3 <- playFolder(2, 2)
*
* IMPORTANT:
* - Numbering starts from 1, NOT 0
* - Folder names must be 2-digit zero-padded (01-99)
* - Track names must be 3-digit zero-padded (001-255)
* - Format SD card as FAT32, then copy files one by one in order
* - Track order is determined by the order files were copied,
* NOT by filename. So copy them in the correct sequence.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
// Play track 1 from folder 01
Serial.println("Playing folder 01, track 001...");
mp3.playFolder(1, 1);
delay(5000);
// Play track 2 from folder 01
Serial.println("Playing folder 01, track 002...");
mp3.playFolder(1, 2);
delay(5000);
// Play track 1 from folder 02
Serial.println("Playing folder 02, track 001...");
mp3.playFolder(2, 1);
}
void loop()
{
// Nothing to do here
}
Ausführung
- Richten Sie die SD-Karte mit Ordnern (01, 02) ein, die nummerierte Dateien (001.mp3, 002.mp3) enthalten.
- Laden Sie den Sketch hoch. Er spielt Titel aus dem Ordner 01 und dann aus dem Ordner 02 ab.
Ordner-Wiedergabefunktionen
| Funktion | Was es tut | Verwendung |
|---|---|---|
| playFolder(folder, track) | Spielt einen Titel aus einem Ordner ab (bis zu 99 Ordner, 255 Titel) | mp3.playFolder(1, 1) |
| playLargeFolder(folder, track) | Spielt aus einem Ordner ab (bis zu 15 Ordner, 3000 Titel) | mp3.playLargeFolder(1, 1500) |
| playFromMP3Folder(trackNum) | Spielt aus dem Ordner /mp3 ab | mp3.playFromMP3Folder(1) |
Arduino Uno R4 Code - Serial Monitor-Steuerung
Geben Sie im Serial Monitor Befehle mit einzelnen Zeichen ein, um alle Aspekte der Wiedergabe zu steuern. Keine zusätzliche Hardware erforderlich.
/*
* DIYables Mini Mp3 Player - Serial Command Control
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Control the Mp3 player by typing commands in the Serial Monitor.
* Great for testing all functions without extra hardware.
*
* Commands (type in Serial Monitor, then press Enter):
* 1-9 Play track 1 to 9
* + Volume up
* - Volume down
* p Pause
* r Resume
* s Stop
* n Next track
* b Previous track (back)
* ? Show current status
*
* Wiring (Arduino Uno R4):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
Serial.println("=== DIYables Mini Mp3 Player ===");
Serial.println("Commands:");
Serial.println(" 1-9 Play track number");
Serial.println(" + Volume up");
Serial.println(" - Volume down");
Serial.println(" p Pause");
Serial.println(" r Resume");
Serial.println(" s Stop");
Serial.println(" n Next track");
Serial.println(" b Previous track");
Serial.println(" ? Show status");
Serial.println("================================");
}
void loop()
{
if (Serial.available())
{
char cmd = Serial.read();
switch (cmd)
{
case '1': case '2': case '3':
case '4': case '5': case '6':
case '7': case '8': case '9':
Serial.print("Playing track ");
Serial.println(cmd - '0');
mp3.play(cmd - '0');
break;
case '+':
Serial.println("Volume up");
mp3.volumeUp();
break;
case '-':
Serial.println("Volume down");
mp3.volumeDown();
break;
case 'p':
Serial.println("Paused");
mp3.pause();
break;
case 'r':
Serial.println("Resumed");
mp3.resume();
break;
case 's':
Serial.println("Stopped");
mp3.stop();
break;
case 'n':
Serial.println("Next track");
mp3.playNext();
break;
case 'b':
Serial.println("Previous track");
mp3.playPrevious();
break;
case '?':
{
Serial.println("--- Status ---");
int16_t vol = mp3.getVolume();
Serial.print("Volume: ");
Serial.println(vol);
int16_t track = mp3.getCurrentTrack();
Serial.print("Current track: ");
Serial.println(track);
bool playing = mp3.isPlaying();
Serial.print("Playing: ");
Serial.println(playing ? "Yes" : "No");
int16_t total = mp3.getTrackCount();
Serial.print("Total tracks: ");
Serial.println(total);
Serial.println("--------------");
break;
}
default:
break;
}
}
}
Ausführung
- Laden Sie den Code hoch und öffnen Sie dann den Serial Monitor bei 9600 Baud.
- Geben Sie einen beliebigen Befehl aus der folgenden Tabelle ein:
| Taste | Aktion |
|---|---|
| 1–9 | Titel Nummer 1 bis 9 abspielen |
| + | Lautstärke erhöhen |
| − | Lautstärke verringern |
| p | Wiedergabe anhalten |
| r | Wiedergabe fortsetzen |
| s | Wiedergabe beenden |
| n | Zum nächsten Titel springen |
| b | Zum vorherigen Titel gehen |
| ? | Aktuellen Status ausgeben |
Equalizer-Modi
Sechs integrierte EQ-Voreinstellungen sind verfügbar:
| Konstante | ID | Soundprofil |
|---|---|---|
| DIYables_MiniMp3::EQ_NORMAL | 0 | Flach / neutral |
| DIYables_MiniMp3::EQ_POP | 1 | Pop |
| DIYables_MiniMp3::EQ_ROCK | 2 | Rock |
| DIYables_MiniMp3::EQ_JAZZ | 3 | Jazz |
| DIYables_MiniMp3::EQ_CLASSIC | 4 | Klassik |
| DIYables_MiniMp3::EQ_BASS | 5 | Bass-Betonung |
mp3.setEQ(DIYables_MiniMp3::EQ_ROCK);
Abfrage des Wiedergabestatus
Die folgenden Funktionen ermöglichen es Ihnen, den Status des Moduls zur Laufzeit zu lesen. Jeder Aufruf blockiert bis zu 100 ms, während auf eine Antwort gewartet wird. Ein Rückgabewert von −1 zeigt einen Fehler oder eine Zeitüberschreitung an.
| Funktion | Rückgabetyp | Beschreibung |
|---|---|---|
| isPlaying() | bool | true während ein Titel aktiv abgespielt wird |
| getVolume() | int16_t | Aktuelle Lautstärkestufe (0–30) |
| getEQ() | int16_t | Aktive EQ-Voreinstellung (0–5) |
| getTrackCount() | int16_t | Anzahl der Titel auf der SD-Karte |
| getCurrentTrack() | int16_t | Derzeit abgespielter Titelnummer |
| getFolderCount() | int16_t | Anzahl der Ordner auf der SD-Karte |
| getTrackCountInFolder(folder) | int16_t | Titel in einem bestimmten Ordner |