DFPlayer Mini Arduino: MP3 abspielen, SD-Karte und Lautsprecher

Der DFPlayer Mini ist der günstigste und einfachste Weg, mit dem Arduino MP3s abzuspielen: Er dekodiert die Audiodateien auf einer microSD-Karte selbstständig, treibt mit seinem kleinen eingebauten Verstärker direkt einen Lautsprecher an und bekommt seine Befehle vom Arduino über eine serielle Verbindung mit nur zwei Leitungen. Anders als die Pieptöne eines Buzzers spielt er Lieder, Sprache, Türklingel-Melodien oder gesprochene Warnungen wie "Die Tür steht noch offen". Fast alle, die ihn zum ersten Mal anschließen, stoßen auf dieselben Probleme: Es kommt kein Ton, der Lautsprecher rauscht, die Dateien laufen in falscher Reihenfolge oder im seriellen Monitor steht "Unable to begin". Diese Anleitung löst jedes dieser Probleme und erklärt, woher es kommt.

Zuerst lernst du die Pins des Moduls kennen und erfährst, warum an die RX-Leitung ein 1-kΩ-Widerstand gehört. Danach siehst du, wie du die SD-Karte in FAT32 vorbereitest, die Dateien nach dem Schema 0001.mp3 und Ordner 01 benennst, mit der Bibliothek DFRobotDFPlayerMini den ersten Ton abspielst, Lautstärke und EQ einstellst, Titel per Taster wechselst und den passenden Lautsprecher oder externen Verstärker auswählst. Die letzten Abschnitte zeigen die schrittweise Lösung für den Fehler "Unable to begin", einen MP3-Player mit dem ESP32, der sich über eine Webseite steuern lässt, und ein MicroPython-Beispiel ohne Bibliothek für den Raspberry Pi Pico. Wenn dir ein Piepton oder eine einfache Melodie reicht, ist ein Buzzer die einfachere Wahl.

Was ist der DFPlayer Mini und wie funktioniert er?

Der DFPlayer Mini ist ein eigenständiger MP3-Player aus einem MP3-Decoder-Chip, einem 24-Bit-DAC, einem microSD-Kartensteckplatz und einem kleinen Mono-Verstärker. Der Arduino muss nur kurze Befehle wie "spiele Titel 3" oder "stelle die Lautstärke auf 20" schicken; die Datei von der Karte lesen, den komprimierten Ton dekodieren und den Lautsprecher antreiben erledigt das Modul. Deshalb kann sogar ein Arduino Uno mit 2 KB RAM mühelos Musik abspielen. Die Befehle werden mit 9600 Baud in Paketen zu je 10 Byte übertragen, und das Modul meldet sich im gleichen Format, wenn ein Titel endet, eine Karte eingesteckt oder entfernt wird oder ein Fehler auftritt. Der Chip auf der Platine hängt vom Hersteller ab (YX5200-24SS, MH2024K-24SS, GD3200B und andere). Alle verstehen dieselben Befehle, antworten aber unterschiedlich schnell; dieses Detail wird später beim Fehler "Unable to begin" wichtig. Steuern lässt sich das Modul auf drei Arten: über die serielle Schnittstelle (UART), mit den IO-Tastern oder über eine ADKEY-Widerstandskette.

DFPlayer Mini Pinbelegung

Bei Steuerung über die serielle Schnittstelle brauchst du nur VCC, GND, RX, TX und die Lautsprecherpins. Der BUSY-Pin verrät dir ohne serielle Kommunikation, ob ein Titel zu Ende ist, und auch die kleine LED auf der Platine leuchtet während der Wiedergabe. Die Pins IO_1 und IO_2 machen das Modul sogar ohne Arduino nutzbar: Mit je einem Taster zwischen Pin und GND wechselt ein kurzer Druck den Titel und ein langer Druck ändert die Lautstärke. Taster, die über Widerstände mit unterschiedlichen Werten an den ADKEY-Pins hängen, können außerdem bestimmte Titel starten. So genügen eine Batterie, ein Lautsprecher und zwei Taster für eine Türklingel oder ein sprechendes Spielzeug ganz ohne Mikrocontroller. Die Pins USB+ und USB− dienen zum Abspielen von einem USB-Stick statt der SD-Karte und bleiben in den meisten Projekten frei.

DFPlayer Mini am Arduino anschließen: der 1-k-Widerstand an RX

Die Datenleitungen werden gekreuzt: TX des Moduls geht an RX des Boards und RX des Moduls an TX des Boards. Die Hardware-Schnittstelle des Uno an D0 und D1 wird für den Upload per USB und den seriellen Monitor gebraucht, deshalb schließen wir das Modul mit SoftwareSerial an D10 (RX) und D11 (TX) an. Der 1-kΩ-Widerstand in Reihe mit dem RX-Eingang des Moduls ist kein unwichtiges Detail. Der Chip des DFPlayer arbeitet mit 3,3-V-Logik, der TX-Pin des Uno liefert dagegen 5 V. Ohne Widerstand fließt wegen der Differenz Strom durch die Schutzdioden am Eingang des Chips; dieser Strom belastet den Chip und verursacht das Rauschen und Knacken, das du während der seriellen Kommunikation im Lautsprecher hörst. Rechnest du mit dem ohmschen Gesetz nach, siehst du, dass 1 kΩ diesen Strom auf etwa 1–2 mA begrenzt, während das 9600-Baud-Signal davon unberührt bleibt. Ein viel größerer Widerstand wie 10 kΩ kann das Signal so schwächen, dass die Kommunikation abbricht. Den TX-Ausgang des Moduls verbindest du direkt mit dem Uno, denn der Uno erkennt 3,3 V als HIGH (die Schwelle liegt bei etwa 3,0 V).

SD-Karte vorbereiten: FAT32, Ordner und 0001.mp3-Benennung

Der DFPlayer Mini liest microSD-Karten bis 32 GB mit dem Dateisystem FAT16 oder FAT32. Karten ab 64 GB sind ab Werk mit exFAT formatiert, und das kann das Modul nicht lesen; für ein paar hundert Titel reicht eine Karte mit 1–16 GB völlig aus. MP3s mit 128–192 kbit/s und 44,1 kHz sind die sicherste Wahl für Kompatibilität und Lesegeschwindigkeit. Das Modul erkennt Dateien an ihrer Nummer, nicht am Namen; je nachdem, mit welcher Funktion du abspielst, müssen Ordner- und Dateinamen einem bestimmten Schema folgen:

1. Formatiere die Karte am Computer mit FAT32 (unter Windows: Rechtsklick > Formatieren; unter macOS: Festplattendienstprogramm > Löschen > MS-DOS (FAT)).
2. Lege im Hauptverzeichnis einen Ordner namens mp3 und bei Bedarf nummerierte Ordner wie 01 und 02 an.
3. Benenne die Dateien in 0001.mp3, 0002.mp3 um (in nummerierten Ordnern 001.mp3). Hinter der Nummer darfst du eine Beschreibung anhängen, etwa 0001_hallo.mp3; das Modul achtet nur auf die Ziffern am Anfang.
4. Wenn du die Dateien im Hauptverzeichnis mit play() abspielen willst, kopiere sie einzeln und der Reihe nach; beim Kopieren aller Dateien auf einmal kann die Reihenfolge durcheinandergeraten.
5. Wirf die Karte sicher aus und stecke sie im stromlosen Zustand ins Modul; Ein- und Ausstecken im Betrieb kann Dateien beschädigen.

Die Bibliothek DFRobotDFPlayerMini und ein erster Test-Sketch

1. Öffne in der Arduino IDE den Bibliotheksverwalter, gib DFRobotDFPlayerMini ein und installiere die Bibliothek von DFRobot. Die Installation im Detail erklärt der Artikel Bibliothek in Arduino hinzufügen.
2. Kopiere mindestens eine MP3 ins Hauptverzeichnis der SD-Karte, stecke die Karte ins Modul und baue die Schaltung wie in der Tabelle auf.
3. Lade den folgenden Sketch hoch und öffne den seriellen Monitor mit 115200 Baud.
4. Nach wenigen Sekunden solltest du "DFPlayer Mini online." und die Anzahl der Dateien auf der Karte sehen und dann den ersten Titel hören.

1#include <SoftwareSerial.h>
2#include <DFRobotDFPlayerMini.h>
3
4SoftwareSerial dfSerial(10, 11);   // RX = D10 ← DFPlayer TX, TX = D11 → 1 kΩ → DFPlayer RX
5DFRobotDFPlayerMini player;
6
7void setup() {
8  Serial.begin(115200);
9  dfSerial.begin(9600);                       // DFPlayer her zaman 9600 baud / DFPlayer always uses 9600 baud
10  Serial.println(F("DFPlayer baslatiliyor / Starting DFPlayer..."));
11
12  if (!player.begin(dfSerial)) {              // reset gönderir, kartı bekler / sends a reset, waits for the card
13    Serial.println(F("Unable to begin: kablolari ve SD karti kontrol et / check wiring and SD card"));
14    while (true) {}                           // burada dur / stop here
15  }
16  Serial.println(F("DFPlayer Mini online."));
17  Serial.print(F("Karttaki dosya / Files on card: "));
18  Serial.println(player.readFileCounts());    // gizli dosyalar da sayılır / hidden files are counted too
19
20  player.volume(20);                          // ses seviyesi 0-30 / volume 0-30
21  player.EQ(DFPLAYER_EQ_NORMAL);              // ekolayzır: normal / equalizer: normal
22  player.play(1);                             // kökteki ilk dosya / first file in the root
23}
24
25void loop() {
26  if (player.available()) {                   // modülden bildirim geldi / a message arrived from the module
27    uint8_t type = player.readType();
28    int value = player.read();
29    if (type == DFPlayerPlayFinished) {
30      Serial.print(F("Parca bitti / Track finished: "));
31      Serial.println(value);
32    } else if (type == DFPlayerError) {
33      Serial.print(F("Hata kodu / Error code: "));
34      Serial.println(value);                  // kodların anlamı tabloda / meanings are in the table
35    } else if (type == DFPlayerCardRemoved) {
36      Serial.println(F("SD kart cikarildi / SD card removed"));
37    }
38  }
39}
40

Lautstärke, EQ und Ansagen nacheinander mit dem BUSY-Pin

Die Lautstärke reicht von 0 bis 30. Mit einem kleinen Lautsprecher genügt 15–20 für die meisten Räume; über 25 kann der Ton, besonders bei schwacher Versorgung, verzerren (Clipping) und das Modul neu starten. Der EQ verändert das Verhältnis von Bässen und Höhen; bei kleinen Lautsprechern klingt der BASS-Modus schnell dumpf, fang daher mit NORMAL an. Nummerierte Ordner sind für sprechende Projekte sehr praktisch: Legst du die Wörter "Temperatur" und "Grad" in Ordner 01 und die Zahlen von 001.mp3 bis 100.mp3 in Ordner 02, kann der Arduino Zahlen als ganzen Satz sprechen. Am zuverlässigsten erkennst du das Ende einer Datei am BUSY-Pin: Er ist LOW, solange das Modul spielt, und HIGH im Leerlauf. Der folgende Sketch liest BUSY an D5 und spielt die Dateien nacheinander ab, ohne dass sie sich überlagern:

1#include <SoftwareSerial.h>
2#include <DFRobotDFPlayerMini.h>
3
4SoftwareSerial dfSerial(10, 11);            // RX = D10 ← DFPlayer TX, TX = D11 → 1 kΩ → DFPlayer RX
5DFRobotDFPlayerMini player;
6const byte BUSY_PIN = 5;                    // DFPlayer BUSY: çalarken LOW / LOW while playing
7
8// Klasör 01: 001.mp3 "Sıcaklık", 002.mp3 "derece" / folder 01: 001.mp3 "Temperature", 002.mp3 "degrees"
9// Klasör 02: 001.mp3 ... 100.mp3 = 1 ... 100 sayıları / folder 02: 001.mp3 ... 100.mp3 = numbers 1 ... 100
10
11void playAndWait(uint8_t folder, uint8_t file) {
12  player.playFolder(folder, file);          // /01/001.mp3 gibi / e.g. /01/001.mp3
13  unsigned long start = millis();
14  while (digitalRead(BUSY_PIN) == HIGH && millis() - start < 1000) {}  // çalma başlasın / wait for playback to start
15  while (digitalRead(BUSY_PIN) == LOW) {}                              // parça bitsin / wait for the track to end
16  delay(50);
17}
18
19void sayTemperature(int degrees) {
20  playAndWait(1, 1);                        // "Sıcaklık" / "Temperature"
21  if (degrees >= 1 && degrees <= 100) {
22    playAndWait(2, degrees);                // sayıyı söyle / say the number
23  }
24  playAndWait(1, 2);                        // "derece" / "degrees"
25}
26
27void setup() {
28  pinMode(BUSY_PIN, INPUT);
29  Serial.begin(115200);
30  dfSerial.begin(9600);
31  if (!player.begin(dfSerial)) {
32    Serial.println(F("Unable to begin"));
33    while (true) {}
34  }
35  player.volume(22);
36  sayTemperature(23);                       // değer bir sensörden de gelebilir / the value can come from a sensor
37}
38
39void loop() {
40}
41

playAndWait() sendet zuerst den Befehl, wartet bis zu 1 Sekunde, bis BUSY auf LOW geht (das Modul braucht ein paar hundert Millisekunden, bis die Wiedergabe startet), und wartet dann, bis der Titel zu Ende ist. Die Audiodateien kannst du mit deiner eigenen Stimme aufnehmen oder mit einem Text-to-Speech-Werkzeug (TTS) erzeugen; schneidest du die Stille am Anfang und Ende jeder Datei ab, klingt die Ansage flüssiger. Willst du die Musik für einen kurzen Hinweis unterbrechen, nimm advertise(n): Das Modul spielt die Durchsage aus dem Ordner /advert und setzt die Musik danach an derselben Stelle fort. Dieser Befehl funktioniert nur, während ein Titel läuft; im Leerlauf aufgerufen, liefert er einen Fehler.

Titel per Taster wechseln und Lautstärke mit einem Potentiometer einstellen

Jetzt bauen wir unseren eigenen MP3-Player: Drei Taster übernehmen vorheriger Titel, Wiedergabe/Pause und nächster Titel, und ein Potentiometer regelt die Lautstärke. Schließe die Taster zwischen D2, D3 bzw. D4 und GND an; da wir die internen Pull-up-Widerstände nutzen, brauchst du keine externen Widerstände (warum, erklärt der Artikel Taster am Arduino anschließen). Die äußeren Anschlüsse des Potentiometers kommen an 5V und GND, der mittlere an A0. Wenn ein Titel endet, springt der Sketch automatisch zum nächsten.

1#include <SoftwareSerial.h>
2#include <DFRobotDFPlayerMini.h>
3
4SoftwareSerial dfSerial(10, 11);            // RX = D10 ← DFPlayer TX, TX = D11 → 1 kΩ → DFPlayer RX
5DFRobotDFPlayerMini player;
6
7const byte BTN[3] = {2, 3, 4};              // önceki, oynat/duraklat, sonraki / previous, play/pause, next
8const byte POT_PIN = A0;                    // ses ayarı potu / volume potentiometer
9bool lastState[3] = {HIGH, HIGH, HIGH};
10unsigned long lastChange[3] = {0, 0, 0};
11bool paused = false;
12int lastRaw = -100;                         // ilk turda sesi mutlaka ayarla / always set the volume on the first pass
13unsigned long lastPotRead = 0;
14unsigned long lastFinish = 0;
15
16// Butona yeni basıldıysa true döner (50 ms sıçrama filtresi) / true on a new press (50 ms debounce)
17bool pressed(byte i) {
18  bool s = digitalRead(BTN[i]);
19  if (s != lastState[i] && millis() - lastChange[i] > 50) {
20    lastState[i] = s;
21    lastChange[i] = millis();
22    return s == LOW;                        // INPUT_PULLUP: basınca LOW / LOW when pressed
23  }
24  return false;
25}
26
27void setup() {
28  for (byte i = 0; i < 3; i++) pinMode(BTN[i], INPUT_PULLUP);
29  Serial.begin(115200);
30  dfSerial.begin(9600);
31  if (!player.begin(dfSerial)) {
32    Serial.println(F("Unable to begin"));
33    while (true) {}
34  }
35  player.play(1);
36}
37
38void loop() {
39  if (pressed(0)) { player.previous(); paused = false; }
40  if (pressed(2)) { player.next(); paused = false; }
41  if (pressed(1)) {
42    if (paused) player.start();             // kaldığı yerden devam / resume
43    else player.pause();                    // duraklat / pause
44    paused = !paused;
45  }
46
47  if (millis() - lastPotRead > 100) {       // potu saniyede 10 kez oku / read the pot 10 times per second
48    lastPotRead = millis();
49    int raw = analogRead(POT_PIN);
50    if (abs(raw - lastRaw) > 20) {          // titremeyi yok say / ignore jitter
51      lastRaw = raw;
52      player.volume(map(raw, 0, 1023, 0, 30));
53    }
54  }
55
56  if (player.available() && player.readType() == DFPlayerPlayFinished) {
57    if (millis() - lastFinish > 1000) player.next();   // parça bitince sonrakine geç / go to the next track
58    lastFinish = millis();                  // bazı modüller bitişi iki kez bildirir / some modules report the end twice
59  }
60}
61

Lautsprecher auswählen (3 W) und externer Verstärker

Der eingebaute Verstärker des DFPlayer (auf den meisten Platinen ein Chip vom Typ 8002) treibt einen Lautsprecher unter 3 W mit 4 Ω oder 8 Ω Impedanz direkt an. Am ausgewogensten klingt ein 8-Ω-Lautsprecher mit 1–3 W; kleine 0,5-W-Lautsprecher funktionieren auch, kommen bei hoher Lautstärke aber an ihre Grenzen. Die 3 W sind die Obergrenze des Verstärkers bei 5 V und 4 Ω Last, an der die Verzerrung deutlich wird; die saubere Leistung im Alltag liegt darunter. Baust du den Lautsprecher in ein Gehäuse oder wenigstens in eine Platte ein, werden die Bässe spürbar kräftiger, weil sich der Schall von Vorder- und Rückseite der Membran nicht mehr gegenseitig auslöscht. Bei hoher Lautstärke kann das Modul kurzzeitig einige hundert Milliampere ziehen; bei einem Arduino am USB-Anschluss des Computers führt das zu Spannungseinbrüchen, Rauschen und Neustarts. Für mehr Leistung oder Stereoton verbindest du die Line-Ausgänge DAC_L und DAC_R mit einem externen Verstärker:

Rauschen, Störgeräusche und Knacken beseitigen

• Rauschen und Knacken beim Senden von Befehlen: Der 1-kΩ-Widerstand an der RX-Leitung fehlt. Setze ihn zwischen den TX-Pin des Arduino und den RX-Pin des Moduls.
• Dauerhaftes Rauschen oder Brummen: Die Versorgung ist verrauscht oder zu schwach. Versorge den DFPlayer aus einer separaten 5-V-Quelle, setze einen Kondensator zwischen VCC und GND und verbinde alle Massen.
• Ein "Plopp" beim Einschalten: Er kommt vom Reset-Befehl, den begin() sendet. Stört er dich, überspringe den Reset mit player.begin(dfSerial, true, false).
• Summen am ESP32: Die Stromimpulse beim WLAN-Senden gelangen in die Versorgung und von dort in den Ton. Setze einen Kondensator in die Versorgung des DFPlayer und nutze wenn möglich eine eigene Quelle.
• Kratziger, verzerrter Ton bei hoher Lautstärke: Lautsprecher oder Verstärker arbeiten am Limit. Senke die Lautstärke auf etwa 20–25, wähle einen effizienteren Lautsprecher oder wechsle zu einem externen Verstärker.
• Leichtes Rauschen ohne Wiedergabe: Das ist das Eigenrauschen des Verstärkers auf der Platine und verschwindet bei kleinen Modulen nie ganz. Wo Stille wichtig ist, erreichst du das beste Ergebnis, wenn du den DAC-Ausgang an einen guten externen Verstärker anschließt.

Der Fehler "Unable to begin" und seine Lösung

Zeigt der serielle Monitor Unable to begin: und danach die Zeilen 1.Please recheck the connection! und 2.Please insert the SD card!, ist die Prüfung von begin() im Beispiel-Sketch der Bibliothek fehlgeschlagen. begin() schickt dem Modul einen Reset-Befehl und wartet 2 Sekunden auf die Meldung "Karte bereit" (card online); kommt sie nicht, liefert die Funktion false. Die Ursache kann also die Verdrahtung, die SD-Karte, die Versorgung oder das Antwortverhalten des Moduls sein. Geh die Punkte in dieser Reihenfolge durch:

DFPlayer Mini mit dem ESP32: MP3s über eine Webseite steuern

Beim ESP32 brauchst du kein SoftwareSerial; jede seiner drei Hardware-UARTs lässt sich auf die Pins deiner Wahl legen. Im folgenden Sketch läuft UART2 an GPIO 16 (RX) und GPIO 17 (TX), und der DFPlayer wird über den 5V-Pin (VIN) des ESP32-Boards versorgt. Das 3,3-V-TX-Signal des ESP32 passt direkt zum Modul, den 1-kΩ-Widerstand solltest du als Schutz vor Störungen aber trotzdem einsetzen. In der Gegenrichtung gibt DFRobot einen Logikpegel von 3,3 V für das Modul an; bei manchen Klon-Platinen wurde an der TX-Leitung bei 5-V-Versorgung jedoch eine höhere Spannung gemessen. Miss vor dem Anschließen zwischen TX und GND mit dem Multimeter; liegt der Wert über 3,6 V, setze einen Spannungsteiler aus 1 kΩ und 2 kΩ dazwischen. Der Sketch verbindet sich mit deinem Heimnetz und stellt eine Seite bereit, die du am Handy öffnen kannst; ihre Schaltflächen wechseln den Titel, pausieren und regeln die Lautstärke.

1#include <WiFi.h>
2#include <WebServer.h>
3#include <DFRobotDFPlayerMini.h>
4
5const char *WIFI_SSID = "WIFI_ADI";         // kendi ağ adın / your network name
6const char *WIFI_PASS = "WIFI_SIFRESI";     // kendi şifren / your password
7
8HardwareSerial dfSerial(2);                 // UART2
9DFRobotDFPlayerMini player;
10WebServer server(80);
11int volumeLevel = 15;
12
13const char PAGE[] = R"rawliteral(<!DOCTYPE html><html><head>
14<meta name="viewport" content="width=device-width,initial-scale=1"><title>ESP32 MP3</title>
15<style>body{font-family:sans-serif;text-align:center}button{font-size:22px;margin:6px;padding:10px 18px}</style>
16</head><body><h2>DFPlayer Mini</h2>
17<button onclick="c('prev')">Prev</button><button onclick="c('pause')">Pause</button>
18<button onclick="c('play')">Play</button><button onclick="c('next')">Next</button><br>
19<button onclick="c('down')">Vol -</button><button onclick="c('up')">Vol +</button>
20<p id="s"></p>
21<script>function c(x){fetch('/cmd?c='+x).then(r=>r.text()).then(t=>document.getElementById('s').innerText=t)}</script>
22</body></html>)rawliteral";
23
24void handleCmd() {
25  String c = server.arg("c");
26  if (c == "next") player.next();
27  else if (c == "prev") player.previous();
28  else if (c == "pause") player.pause();
29  else if (c == "play") player.start();
30  else if (c == "up" && volumeLevel < 30) player.volume(++volumeLevel);
31  else if (c == "down" && volumeLevel > 0) player.volume(--volumeLevel);
32  server.send(200, "text/plain", "Ses / Volume: " + String(volumeLevel));
33}
34
35void setup() {
36  Serial.begin(115200);
37  dfSerial.begin(9600, SERIAL_8N1, 16, 17); // RX = GPIO16 ← DFPlayer TX, TX = GPIO17 → 1 kΩ → DFPlayer RX
38  delay(1000);                              // modül kartı okusun / let the module read the card
39  if (!player.begin(dfSerial)) {
40    Serial.println("Unable to begin");
41    while (true) delay(10);
42  }
43  player.volume(volumeLevel);
44
45  WiFi.begin(WIFI_SSID, WIFI_PASS);
46  while (WiFi.status() != WL_CONNECTED) {   // ağa bağlanana kadar bekle / wait for the network
47    delay(500);
48    Serial.print(".");
49  }
50  Serial.print("\nAdres / Address: http://");
51  Serial.println(WiFi.localIP());
52
53  server.on("/", []() { server.send(200, "text/html", PAGE); });
54  server.on("/cmd", handleCmd);
55  server.begin();
56  player.play(1);
57}
58
59void loop() {
60  server.handleClient();                    // tarayıcı isteklerini işle / handle browser requests
61}
62

Gib nach dem Hochladen die im seriellen Monitor angezeigte Adresse (zum Beispiel 192.168.1.42) im Browser deines Handys ein; Handy und ESP32 müssen im selben WLAN sein. Klappt die Verbindung nicht, hilft der Artikel ESP32 verbindet sich nicht mit dem WLAN. Auf Boards mit ESP32-WROVER-Modul sind GPIO 16 und 17 für den internen PSRAM reserviert; leg die UART dann auf andere Pins wie 26 und 27, indem du einfach die Pinnummern in der Zeile dfSerial.begin() änderst. Startet der ESP32 von selbst neu, während der Lautsprecher laut spielt, liegt es an der Versorgung; Details findest du im Artikel ESP32 Brownout.

DFPlayer Mini mit dem Raspberry Pi Pico und MicroPython (UART)

Beim Raspberry Pi Pico ist es einfach und lehrreich zugleich, das serielle Protokoll des Moduls direkt zu nutzen, statt nach einer fertigen Bibliothek zu suchen. Jeder Befehl ist ein 10-Byte-Paket: Startbyte 0x7E, Version 0xFF, Länge 0x06, Befehlscode, Rückmeldung (0 = keine Bestätigung), zwei Byte Parameter, zwei Byte Prüfsumme und Endbyte 0xEF. Die Prüfsumme ist der 16-Bit-Negativwert der Summe der sechs Bytes von der Version bis zum letzten Parameterbyte. Das Paket, das den ersten Titel im Hauptverzeichnis spielt, lautet zum Beispiel 7E FF 06 03 00 00 01 FE F7 EF. Das Modul sendet seinerseits Meldungen mit dem Code 0x3D, wenn ein Titel endet, 0x3F, wenn die Karte bereit ist, und 0x40 bei einem Fehler. Die 3,3-V-UART des Pico passt direkt zum Modul; der Hinweis zur TX-Spannung aus dem ESP32-Abschnitt gilt auch hier, denn auch die Pins des Pico sind nicht 5-V-tolerant. Versorge das Modul über den VBUS-Pin (USB 5 V) des Pico.

1from machine import UART, Pin
2import time
3
4# GP0 (UART0 TX) → 1 kΩ → DFPlayer RX, GP1 (UART0 RX) ← DFPlayer TX
5uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))
6btn_next = Pin(14, Pin.IN, Pin.PULL_UP)     # sonraki parça / next track
7btn_play = Pin(15, Pin.IN, Pin.PULL_UP)     # oynat-duraklat / play-pause
8TRACKS = 5                                  # /mp3 klasöründeki dosya sayısı / number of files in /mp3
9
10def send(cmd, param=0):
11    # 10 baytlık komut paketi, onay istemeden / 10-byte command frame without ACK
12    frame = bytearray([0x7E, 0xFF, 0x06, cmd, 0x00, param >> 8, param & 0xFF, 0, 0, 0xEF])
13    checksum = -sum(frame[1:7]) & 0xFFFF    # sağlama toplamı / checksum
14    frame[7] = checksum >> 8
15    frame[8] = checksum & 0xFF
16    uart.write(frame)
17    time.sleep_ms(30)
18
19buf = b""
20
21def events():
22    # gelen 10 baytlık bildirimlerin komut kodlarını döndür / return command codes of incoming messages
23    global buf
24    if uart.any():
25        buf += uart.read()
26    codes = []
27    while True:
28        start = buf.find(b"\x7e")
29        if start < 0:
30            buf = b""
31            break
32        if len(buf) - start < 10:
33            buf = buf[start:]
34            break
35        frame = buf[start:start + 10]
36        if frame[9] == 0xEF:
37            codes.append(frame[3])
38            buf = buf[start + 10:]
39        else:
40            buf = buf[start + 1:]
41    return codes
42
43def play_track(n):
44    send(0x12, n)                           # /mp3/000n.mp3 dosyasını çal / play /mp3/000n.mp3
45
46time.sleep(2)                               # modül kartı okusun / let the module read the card
47send(0x06, 18)                              # ses 18/30 / volume 18 of 30
48track = 1
49play_track(track)
50playing = True
51last_end = 0
52
53while True:
54    if btn_next.value() == 0:
55        track = track % TRACKS + 1          # son parçadan sonra başa dön / wrap after the last track
56        play_track(track)
57        playing = True
58        time.sleep_ms(300)                  # basit sıçrama önleme / simple debounce
59    if btn_play.value() == 0:
60        send(0x0E if playing else 0x0D)     # 0x0E duraklat, 0x0D devam / 0x0E pause, 0x0D resume
61        playing = not playing
62        time.sleep_ms(300)
63    for code in events():
64        # 0x3D: SD karttaki parça bitti / 0x3D: track on the SD card finished
65        if code == 0x3D and time.ticks_diff(time.ticks_ms(), last_end) > 1000:
66            last_end = time.ticks_ms()      # çift bildirimi yok say / ignore the duplicate message
67            track = track % TRACKS + 1
68            play_track(track)
69

Speicherst du den Code mit Thonny als main.py auf dem Pico, arbeitet er nach jedem Einschalten wie ein MP3-Player; bist du neu bei MicroPython, wirf einen Blick in den Artikel MicroPython-Grundlagen. Der Taster an GP14 springt zum nächsten Titel, der Taster an GP15 pausiert und setzt fort; der andere Anschluss jedes Tasters geht an GND. Die Funktion events() sammelt eingehende Bytes in einem Puffer und filtert die Pakete heraus, die mit 0x7E beginnen und mit 0xEF enden. Trifft die Meldung "Titel beendet" (0x3D) ein, wechselt der Code zur nächsten Datei und beginnt nach der letzten wieder von vorn. Vergiss nicht, die Variable TRACKS an die Anzahl der Dateien in deinem Ordner /mp3 anzupassen.

Projektideen mit dem DFPlayer Mini

• Melodie-Türklingel: Eine Klingel, die beim Drücken eine zufällige Melodie spielt und nachts leiser wird.
• Begrüßungssystem: Ein PIR-Bewegungsmelder löst eine Begrüßung aus, wenn jemand kommt.
• Musikbox mit Karten: Jede RFID-Karte spielt einen anderen Ordner ab; ein Musikplayer ohne Bildschirm für Kinder.
• Sprechende Uhr: Mit einem RTC-Uhrmodul eine Uhr, die die Zeit ansagt oder jede volle Stunde meldet.
• MP3-Player mit Fernbedienung: Titel und Lautstärke per IR-Empfänger und Fernbedienung steuern.
• Halloween-Deko oder Scherzkiste: Ein HC-SR04 spielt ein gruseliges Geräusch, sobald sich jemand nähert.
• Gesprochene Alarme und Hinweise: Verständliche Sätze wie "Gas in der Küche erkannt" statt eines Pieptons bei Gas, Wasser oder einer offenen Tür.
• MP3-Player mit Display: Zeige Titelnummer und Lautstärke auf einem OLED-Display an.

Mit einer richtig benannten SD-Karte, dem 1-kΩ-Widerstand an der RX-Leitung und einer stabilen 5-V-Versorgung bringt der DFPlayer Mini in wenigen Minuten echten Klang in deine Arduino-Projekte. Läuft etwas schief, prüfe zuerst Karte und Verdrahtung und dann die Versorgung; fast alle Fehler stecken in einem dieser drei Punkte. Wenn dich die Grundlagen der seriellen Kommunikation interessieren, ist der Artikel Serielle Kommunikation mit UART ein guter nächster Schritt. In der BlueGrays-App findest du Klangprojekte wie Melodien mit dem Buzzer, ein einfaches Klavier, eine Türklingel mit Bewegungsmelder und ESP32-Melodien, jeweils mit Schaltplan und Schritt-für-Schritt-Code, und kannst ihnen danach mit dem DFPlayer Mini echten Klang geben.