Arduino Nano - Mini-MP3-Player
Dieser Leitfaden zeigt Ihnen alles, was Sie benötigen, um das DIYables Mini Mp3 Player-Modul mit einem Arduino Nano zum Laufen zu bringen. Am Ende werden Sie wissen, wie man:
- Das Mini Mp3 Player-Modul mit einem Arduino Nano auf einem Breadboard verkabelt.
- MP3-Titel abspielen, pausieren, fortsetzen und stoppen.
- Die Lautstärke mit physischen Tasten oder seriellen Befehlen steuert.
- Vorwärts und rückwärts durch Titel springt.
- Einzelne Titel in Schleife, alle Titel in Schleife oder Zufallswiedergabe.
- Titel aus nummerierten Ordnern organisiert und abspielt.
- Die aktuelle Lautstärke, Titelnummer und den Wiedergabestatus zurückliest.
Was Sie benötigen
Oder Sie können die folgenden Kits kaufen:
| 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.
Kennenlernen des Mini Mp3 Player-Moduls
Das DIYables Mini Mp3 Player-Modul integriert den YX5200-24SS-Decoder-Chip auf eine kleine Platine. Schieben Sie eine Micro-SD-Karte mit MP3-Dateien ein, schließen Sie einen Lautsprecher an, und Sie haben einen eigenständigen Audio-Player, den Ihr Nano über eine einfache serielle Verbindung steuert.
Hier ist, was das Modul kann:
- Wiedergabesteuerbefehle: abspielen, pausieren, fortsetzen, stoppen, nächster, vorheriger
- Lautstärke: einstellbar von 0 (Stille) bis 30 (Maximum)
- EQ-Voreinstellungen: Normal, Pop, Rock, Jazz, Classic, Bass
- Wiederholungsmodi: einen Titel in Schleife, einen Ordner in Schleife, alle in Schleife, Zufallswiedergabe
- Ordner: Organise Sie Titel in nummerierten Ordnern zur einfachen Auswahl
- Werbespots: Unterbrechen Sie den aktuellen Titel und fahren dann fort, wo Sie stehen geblieben sind
- Statusabfragen: Fragen Sie das Modul, welcher Titel gerade abgespielt wird, die aktuelle Lautstärke usw.
Die gesamte Kommunikation läuft über UART mit 9600 Baud — nur zwei Drähte (TX und RX) plus Strom.
Pinbelegung Referenz
| Pin | Wofür es verwendet wird | |
|---|---|---|
| VCC | Stromversorgung (3,2 V – 5,0 V) | |
| GND | Masseverbindung | |
| RX | Empfängt serielle Befehle vom Nano (über 1-kΩ-Widerstand) | |
| TX | Sendet serielle Daten zurück an den Nano | |
| SPK_1 | Positive Lautsprecherklemme (eingebauter 3-W-Verstärker) | |
| SPK_2 | Negative Lautsprecherklemme | |
| DAC_R | Rechte Audio-Ausgangsleitung (für externen Verstärker) | |
| DAC_L | Linke Audio-Ausgangsleitung (für externen Verstärker) | |
| BUSY | Wird während der Titelwiedergabe LOW | |
| IO_1 | Auslöser | kurzes Drücken = Zurück, langes Drücken = Lautstärke runter |
| IO_2 | Auslöser | kurzes Drücken = Weiter, langes Drücken = Lautstärke rauf |
Wie man es verkabelt
Da der Arduino Nano mit 5V läuft, muss ein 1-kΩ-Widerstand zwischen dem TX-Pin des Nano und dem RX-Pin des Moduls platziert werden. Dies senkt die Spannung auf einen sicheren Pegel für die 3,3-V-Logik des Moduls.
| Mini MP3-Player | Arduino Nano | Notizen |
|---|---|---|
| VCC | 5V | |
| GND | GND | |
| RX | D11 | Verwenden Sie einen 1-kΩ-Widerstand in Serie! |
| TX | D10 | |
| SPK_1 | Lautsprecher + | |
| SPK_2 | Lautsprecher − |
Sowohl der Nano als auch der Mini Mp3 Player passen bequem auf ein Standard-Breadboard, was dies zu einem sehr kompakten Aufbau macht.
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Siehe Der beste Weg, den Arduino Nano und andere Komponenten mit Strom zu versorgen.
Einrichten der SD-Karte
Bevor Sie die Karte in das Modul einsetzen:
- Formatieren Sie sie als FAT16 oder FAT32.
- Kopieren Sie MP3-Dateien in das Stammverzeichnis mit nullgefüllten Zahlen:
/001.mp3
/002.mp3
/003.mp3
- Für die Ordnerwiedergabe erstellen Sie nummerierte Ordner:
/01/001.mp3
/01/002.mp3
/02/001.mp3
Achtung: Das Modul nummeriert Titel nach der Reihenfolge, in der sie auf die Karte kopiert wurden, nicht nach dem Dateinamen. Formatieren Sie zuerst die Karte und kopieren Sie dann jede Datei einzeln nacheinander in der richtigen Reihenfolge.
- Ordnernamen: 01 bis 99 (zwei Ziffern, nullgefüllt)
- Dateinamen in Ordnern: 001 bis 255 (drei Ziffern, nullgefüllt)
- Die Titelnummerierung beginnt bei 1, nicht bei 0
Bibliotheksinstallation
- Verbinden Sie den Nano über das Mini-B-USB-Kabel mit Ihrem Computer.
- Öffnen Sie die Arduino IDE, wählen Sie Arduino Nano als Platine und wählen Sie den richtigen COM-Anschluss.
- Klicken Sie auf das Bibliotheken-Symbol in der linken Seitenleiste der Arduino IDE.
- Suchen Sie nach "DIYables_MiniMp3" und finden Sie die Bibliothek von DIYables.
- Klicken Sie auf Installieren.
Es sind keine zusätzlichen Abhängigkeiten erforderlich — die Bibliothek ist vollständig in sich geschlossen.
Starter-Vorlage
Hier ist die minimale Code-Struktur, die Sie für jeden Sketch mit diesem Modul benötigen:
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // RX on D10, TX on D11
DIYables_MiniMp3 mp3;
void setup() {
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000); // Let the module boot up
mp3.setVolume(25); // Range: 0 to 30
}
void loop() {
// Your playback logic here
}
Das delay(1000) nach begin() ist wichtig — das Modul benötigt etwa eine Sekunde zum Initialisieren nach dem Hochfahren. Stellen Sie die Lautstärke immer explizit ein, da die Standardeinstellung möglicherweise 0 (Stille) ist.
Code-Beispiel — Einen Titel abspielen
Spielt Titel 001.mp3 einmal ab und stoppt.
/*
* 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):
* 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
}
Schritte zum Ausprobieren
- Laden Sie Ihre SD-Karte mit mindestens einer MP3-Datei (001.mp3).
- Setzen Sie die SD-Karte in das Modul ein und verkabeln Sie alles wie oben gezeigt.
- Verbinden Sie den Nano über USB mit Ihrem PC.
- Wählen Sie in der Arduino IDE Arduino Nano und den richtigen Anschluss.
- Fügen Sie den Code ein und klicken Sie auf Hochladen.
Titel 1 wird über den Lautsprecher abgespielt.
Wiedergabe Schnellreferenz
| Funktion | Beschreibung | Beispielcode |
|---|---|---|
| play(track) | Einen bestimmten Titel abspielen | mp3.play(1) |
| playNext() | Zum nächsten Titel springen | mp3.playNext() |
| playPrevious() | Zum vorherigen Titel springen | mp3.playPrevious() |
| pause() | Aktuellen Titel pausieren | mp3.pause() |
| resume() | Pausierter Titel fortsetzen | mp3.resume() |
| stop() | Wiedergabe stoppen | mp3.stop() |
Code-Beispiel — Mehrere Titel abspielen
Durchläuft mehrere Titel nacheinander.
/*
* 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):
* 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();
}
}
Schritte zum Ausprobieren
- Speichern Sie mindestens 3 MP3-Dateien auf der SD-Karte.
- Laden Sie den Code hoch. Titel werden in einer Schleife mit 5-Sekunden-Intervall abgespielt.
Code-Beispiel — Tasten für Lautstärke Auf/Ab
Zwei physische Tasten erhöhen und senken die Lautstärke in Echtzeit.
/*
* 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):
* 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
}
}
Schritte zum Ausprobieren
- Verkabeln Sie zwei Tasten wie im Code beschrieben, dann laden Sie hoch.
- Drücken Sie die Tasten, während ein Titel abgespielt wird. Beobachten Sie den Seriellen Monitor auf den Lautstärkepegel.
Lautstärke Schnellreferenz
| Funktion | Beschreibung | Beispielcode |
|---|---|---|
| setVolume(val) | Lautstärke einstellen (0 = stumm, 30 = max) | mp3.setVolume(20) |
| volumeUp() | Lautstärke um 1 erhöhen | mp3.volumeUp() |
| volumeDown() | Lautstärke um 1 senken | mp3.volumeDown() |
| getVolume() | Aktuellen Lautstärkepegel auslesen | mp3.getVolume() |
Code-Beispiel — Tasten für Nächster / Vorheriger
Titel mit zwei Tasten überspringen.
/*
* 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):
* 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
}
}
Schritte zum Ausprobieren
- Verkabeln Sie Tasten mit den Pins 2 und 3, laden Sie hoch und drücken Sie zum Überspringen.
Code-Beispiel — Pausierungs- / Fortsetzen-Taste
Eine Taste wechselt zwischen Pausieren und Fortsetzen.
/*
* 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):
* 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
}
}
Schritte zum Ausprobieren
- Verkabeln Sie eine Taste mit Pin 2. Laden Sie hoch und drücken Sie, um zwischen Pausieren und Fortsetzen zu wechseln.
Code-Beispiel — Einen Titel für immer in Schleife
Wiederholt einen einzelnen Titel in einer Endlosschleife.
/*
* 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):
* 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
}
Schritte zum Ausprobieren
- Laden Sie den Code hoch. Titel 1 wiederholt sich unbegrenzt.
Wiederholung & Zufallswiedergabe Schnellreferenz
| Funktion | Beschreibung | Beispielcode |
|---|---|---|
| loopTrack(track) | Einen Titel nonstop wiederholen | mp3.loopTrack(1) |
| loopFolder(folder) | Alle Titel in einem Ordner wiederholen | mp3.loopFolder(1) |
| loopAll() | Jeden Titel auf der Karte wiederholen | mp3.loopAll() |
| stopLoop() | Aktuelle Schleife abbrechen | mp3.stopLoop() |
| shuffle() | Zufällige Wiedergabe aller Titel | mp3.shuffle() |
Code-Beispiel — Ordnerwiedergabe
Wählen Sie Titel aus bestimmten nummerierten Ordnern auf der SD-Karte aus und spielen Sie sie 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):
* 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
}
Schritte zum Ausprobieren
- Erstellen Sie Ordner (01, 02) auf der SD-Karte mit nummerierten MP3-Dateien darin.
- Laden Sie den Code hoch. Er spielt aus Ordner 01 und dann aus Ordner 02 ab.
Ordnerwiedergabe Schnellreferenz
| Funktion | Beschreibung | Beispielcode |
|---|---|---|
| playFolder(f, t) | Titel t aus Ordner f abspielen (max. 99 Ordner, 255 Titel) | mp3.playFolder(1, 1) |
| playLargeFolder(f, t) | Aus Ordner abspielen (max. 15 Ordner, 3000 Titel) | mp3.playLargeFolder(1, 500) |
| playFromMP3Folder(t) | Aus dem speziellen Ordner /mp3 abspielen | mp3.playFromMP3Folder(1) |
Code-Beispiel — Serieller Monitor Remote
Steuern Sie die Wiedergabe vollständig vom Seriellen Monitor aus — ideal zum Testen.
/*
* 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):
* 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;
}
}
}
Schritte zum Ausprobieren
- Laden Sie den Code hoch, öffnen Sie den Seriellen Monitor bei 9600 Baud und geben Sie Befehle ein.
Befehlsreferenz
| Typ | Was passiert |
|---|---|
| 1–9 | Spielt diese Titelnummer ab |
| + | Lautstärke erhöhen |
| − | Lautstärke senken |
| p | Pausieren |
| r | Fortsetzen |
| s | Stoppen |
| n | Nächster Titel |
| b | Zurück (vorheriger Titel) |
| ? | Statusinformationen anzeigen |
EQ-Voreinstellungen
| Konstante | Wert | Stil |
|---|---|---|
| DIYables_MiniMp3::EQ_NORMAL | 0 | Flach |
| DIYables_MiniMp3::EQ_POP | 1 | Pop |
| DIYables_MiniMp3::EQ_ROCK | 2 | Rock |
| DIYables_MiniMp3::EQ_JAZZ | 3 | Jazz |
| DIYables_MiniMp3::EQ_CLASSIC | 4 | Klassisch |
| DIYables_MiniMp3::EQ_BASS | 5 | Bass betont |
mp3.setEQ(DIYables_MiniMp3::EQ_JAZZ);
Modulspeicherstatus lesen
Diese Aufrufe ermöglichen es Ihnen, zu überprüfen, was das Modul tut. Jeder blockiert kurz (bis zu 100 ms) während auf die Antwort gewartet wird. Gibt −1 zurück, wenn das Modul nicht antwortet.
| Funktion | Rückgabe | Was Sie erhalten |
|---|---|---|
| isPlaying() | bool | wahr, wenn Audio gerade abgespielt wird |
| getVolume() | int16_t | Lautstärkepegel (0–30) |
| getEQ() | int16_t | Aktive Equalizer-Voreinstellung (0–5) |
| getTrackCount() | int16_t | Gesamtzahl der Titel auf der Karte |
| getCurrentTrack() | int16_t | Titelnummer, die gerade abgespielt wird |
| getFolderCount() | int16_t | Wie viele Ordner sich auf der Karte befinden |
| getTrackCountInFolder(f) | int16_t | Wie viele Titel sich in Ordner f befinden |