Radio übers Internet zu hören, ist heute natürlich nichts Besonderes mehr – mit einem selbstgebauten ESP32 Internetradio allerdings schon! In diesem Tutorial baust du dir deinen eigenen Empfänger, mit dem du deine Lieblingssender hören kannst. Das Projekt ist mehrstufig aufgebaut – du erweiterst dein Internetradio nach und nach um weitere Bauteile und Funktionen, bis du ein vollwertiges Gerät mit Senderwahl, Display und Lautstärkeregelung hast.
Höre dir vorab die Projekt-Vorstellung an:
Diese Bauteile benötigst du:
- 1x ESP32-S3 Zero oder optional auch ein anderer Dual-Core ESP32
- 1x Adafruit I2S Verstärkermodul
- 1x Lautsprecher nach Wahl (max. 3 Watt)
- 1x Akku 3,7 Volt (optional)
- 1x Akku-Lademodul (optional)
- 1x Potentiometer mit Schalter
Update: In diesem Tutorial lernst du zunächst, wie du ein Radio baust, das „nur“ einen Sender empfängt und abspielt. Weiter unten findest du die Erweiterung für ein ESP32 Internetradio mit Senderwahl und Display.
Aufbau des ESP32 Internetradios
Zunächst, wie angekündigt, die einfachste Schaltung für dein Internetradio. Hierbei benötigst du nur den ESP32-S3 Zero (z.B. von Waveshare), das Verstärkermodul und einen Lautsprecher. Orientiere dich beim Aufbau an folgender Skizze:
Hier noch einmal als Tabelle:
| Verstärkermodul | ESP32-S3 |
| VIN | 3,3V |
| GND | GND |
| GAIN | GND |
| DIN | GPIO 2 |
| BCLK | GPIO 3 |
| LRC | GPIO 4 |
Für deinen Lautsprecher hat das Verstärkermodul eine Buchse, in der du mit einer Schraube die Kabel fixieren kannst. Aufgebaut könnte dein Radio so aussehen:
Der Sketch für das Radio
Zentral für dein Internetradio ist eine Bibliothek, die du nicht im Bibliotheksmanager der Arduino IDE findest – dafür jedoch auf GitHub. Lade dir die Bibliothek als ZIP-Datei hier herunter. Erstelle nun in der Arduino IDE einen neuen Sketch und binde die sie im Menü über Sketch > Bibliothek einbinden > ZIP-Datei hinzufügen ein.
Kopiere nun den folgenden Sketch, ergänze die Zugangsdaten für dein WLAN-Netz und lade ihn auf deinen ESP32 hoch. Solltest du hierbei Probleme mit dem ESP32-S3 Zero haben, prüfe, ob du das richtige Board ausgewählt hast. Funktionieren sollte es mit ESP32 S3 Dev Module. Schaue auch nach, ob du im Menü Tools den Eintrag USB CDC On Boot: „Enabled“ siehst. Falls dieser auf Disabled steht, ändere ihn entsprechend.
Falls du noch nie einen ESP32 mit der Arduino IDE programmiert hast, wirf zunächst einen Blick dieses Tutorial.
#ESP32 Internetradio
#https://polluxlabs.net
#include "Arduino.h"
#include "WiFi.h"
#include "Audio.h"
// Verbindungen ESP32 <-> Verstärkermodul
#define I2S_DOUT 2
#define I2S_BCLK 3
#define I2S_LRC 4
Audio audio;
// WLAN Zugangsdaten
String ssid = "DEIN NETZWERK";
String password = "DEIN PASSWORT";
void setup() {
Serial.begin(115200);
WiFi.disconnect();
WiFi.mode(WIFI_STA);
WiFi.begin(ssid.c_str(), password.c_str());
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
Serial.println("");
audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
// Lautstärke (0-100)
audio.setVolume(10);
// Verbindung zum gewünschten Stream, z.B. Byte.fm
audio.connecttohost("http://www.byte.fm/stream/bytefm.m3u");
}
void loop()
{
audio.loop();
}
// Print der Senderinfos
void audio_info(const char *info) {
Serial.print("info "); Serial.println(info);
}
void audio_id3data(const char *info) { //id3 metadata
Serial.print("id3data "); Serial.println(info);
}
void audio_eof_mp3(const char *info) { //end of file
Serial.print("eof_mp3 "); Serial.println(info);
}
void audio_showstation(const char *info) {
Serial.print("station "); Serial.println(info);
}
void audio_showstreaminfo(const char *info) {
Serial.print("streaminfo "); Serial.println(info);
}
void audio_showstreamtitle(const char *info) {
Serial.print("streamtitle "); Serial.println(info);
}
void audio_bitrate(const char *info) {
Serial.print("bitrate "); Serial.println(info);
}
void audio_commercial(const char *info) { //duration in sec
Serial.print("commercial "); Serial.println(info);
}
void audio_icyurl(const char *info) { //homepage
Serial.print("icyurl "); Serial.println(info);
}
void audio_lasthost(const char *info) { //stream URL played
Serial.print("lasthost "); Serial.println(info);
}
void audio_eof_speech(const char *info) {
Serial.print("eof_speech "); Serial.println(info);
}Wenn alles funktioniert, solltest du nach dem Start des ESP32 Internetradios den Sender Byte.fm hören – ein mitgliederfinanzierter Sender aus Hamburg, der abseits des Mainstreams Programmradio macht – ohne Werbung.
So funktioniert der Sketch
Zunächst bindest du wie immer einige Bibliotheken ein. Die ersten beiden sind hierbei bereits in deiner Arduino IDE verfügbar, die Bibliothek Audio.h hast du wie oben beschrieben heruntergeladen und in der IDE eingebunden.
Anschließend definierst du, an welchen Pins das Verstärkermodul am ESP32 angeschlossene ist. Diese kannst du natürlich frei wählen, vergiss nur nicht, sie entsprechend im Sketch zu hinterlegen:
#define I2S_DOUT 2
#define I2S_BCLK 3
#define I2S_LRC 4Anschließend erstellst du ein Objekt der Audio-Bibliothek und hinterlegst die Zugangsdaten zu deinem WLAN-Netzwerk. In der Setup-Funktion startest du dann den Seriellen Monitor und verbindest den ESP32 mit dem WLAN. Wichtig sind die beiden Zeilen
audio.setVolume(10);
audio.connecttohost("http://www.byte.fm/stream/bytefm.m3u");In der ersten stellst du die Lautstärke des Streams ein – mit einer Zahl zwischen 0 und 100. Anschließend hinterlegst du die Adresse des Streams, hier also jener von Byte.fm. Wenn du einen anderen Stream abspielen möchtest, wirst du meist recht einfach über eine Suche fündig.
Im Loop gibt es nur eine Funktion: Das Abspielen des Streams. Zuletzt folgen noch einige sogenannte Callback-Funktionen, die aufgerufen werden, wenn ich bestimmtes Ereignis auftritt oder um Informationen auszugeben. Hier sind das z.B. Infos zum Sender oder zum aktuell gespielten Titel, die dann in deinem Seriellen Monitor erscheinen.
erweiterung der Stromversorgung
Aktuell bezieht dein Internetradio bzw. dein ESP32 den Strom von deinem Computer oder vielleicht auch einer Powerbank. In diesem Abschnitt passen wir die Stromversorgung etwas an – entweder mit einem Akku oder zumindest mit dem dazugehörigen Lademodul. An diesem Modul wirst du später ein Poti mit integriertem Schalter anschließen, um damit deinen ESP32 und damit das Radio ein- und ausschalten zu können.
Einen Akku anschließen
Um dein ESP32 Internetradio unabhänging von Kabeln zur Stromversorgung zu machen, kannst du einen Akku samt Lademodul installieren. Ein wichtiger Hinweis jedoch vorab: Falls du keine Erfahrung mit Akkus für Arduino, ESP32 und Co. hast, bleibe bitte doch beim Kabel zu einer externen Stromquelle. Beachte auch auf jeden Fall die Sicherheitshinweise des Herstellers, da bei unsachgemäßem Gebrauch Feuer und sogar Explosionen drohen – für etwaige Schäden übernehme ich keine Gewähr und Haftung.
Falls du jedoch erfahren genug bist, orientiere dich beim Aufbau des ESP32 Internetradios an der folgenden Skizze:
Mit diesem Lademodul kannst du den Akku laden während das Radio läuft. Möchtest du den Akku laden ohne Musik zu hören, installiere noch einen Schalter zwischen dem Lademodul und dem ESP32 – dazu später mehr. Am Sketch ändert sich durch diese Erweiterung nichts.
Nur das Lademodul verwenden
Du wirst dich vielleicht fragen, wozu es gut sein soll, nur das Lademodul für die Stromversorgung zu nutzen – du könntest das benötigte USB-Kabel ja auch weiterhin direkt im ESP32 unterbringen. Das stimmt – aber die abschließende Erweiterung soll ja ein Poti zum Ein- und Ausschalten sowie zur Lautstärkeregelung sein. Damit das am ESP32-S3 funktioniert benötigst du ein Verbindung, die du mit dem Schalter des Potis unterbrechen kannst – und das wird jene zwischen Lademodul und ESP32 sein.
Das in der obigen und in der folgenden Skizze verwendete Lademodul hat für Plus und Minus je zwei Anschlüsse. Einen (das mittlere Paar) für den Akku und einen (das äußere) für die dauerhafte Speisung eines Geräts, in unserem Fall also den ESP32.
Verbinde deinen ESP32 also wie folgt mit dem Lademodul:
Wenn du nun das Lademodul über USB mit Strom versorgst, erhält auch dein ESP32 hierüber Energie und das Internetradio springt an.
Fehlt noch der letzte Schritt – das Potentiometer.
Das Potentiometer installieren
Hierfür benötigst du kein „Standard“-Poti mit seinen drei Anschlüssen, sondern eines mit fünf Polen. Die äußersten zwei sind hierbei mit einem Schalter auf der Unterseite des Potis verbunden und können einen Stromkreis unterbrechen. In der Praxis drehst du das Poti nach rechts, bis ein Klicken des Schalters ertönt – nun fließt Strom (in unserem Fall springt der ESP32 an).
Drehst du nun weiter, übernimmt das Poti seine übliche Funktion und regelt den Widerstand, den du als Wert im ESP32 auslesen kannst. Orientiere dich beim Aufbau an der folgenden Skizze, wobei dort die oberen zwei Anschlüsse am Poti in der Realität oft die äußeren sind.
Wie du siehst, führt der Pluspol des Lademoduls zum Poti und von dort aus wieder zurück aufs Breadboard zu einem Kabel, das mit dem ESP32 verbunden ist. Sobald du das Poti anschaltest, fließt also Strom vom Lademodul zum ESP32.
Erweiterung des Sketchs
Nun ist das Poti zwar installiert und der Ein- und Ausschaltmechanismus funktioniert auch schon. Was jedoch deinem ESP32 Internetradio noch fehlt, ist die Lautstärkeregelung. Hierfür muss der bestehende Sketch um eine Funktion erweitert werden, die den aktuellen Wert des Potis ausliest und auf die Lautstärke des Radio-Streams „mappt“.
Das erreichst du mit dem folgenden Code:
void loop() {
audio.loop();
int volumeValue = analogRead(VOLUME_PIN);
int volume = map(volumeValue, 0, 4095, 0, 21);
audio.setVolume(volume);Hier liest du das Poti aus, und verwendest die Funktion map(), um dessen Werte von 0 bis 4095 auf eine Lautstärke von 0 bis 21 zu „mappen“. Je weiter du also das Poti aufdrehst, desto lauter wird das Radio – bis ganz rechts der Wert 21 erreicht ist. Hier kannst du auch eine höhere Zahl eintragen, die zu deinem Lautsprecher passt – wie du oben gelesen hast, reicht die Spanne bis 100. Zuletzt übergibst du den gefunden Wert in der Variable volume an die Funktion audio.setVolume().
Das Problem an dieser Methode ist jedoch, dass die Funktion audio.loop(), also der Stream, immer wieder kurz unterbrochen wird. Dies führt zu unangenehmen Rucklern. Deshalb benötigen wir eine etwas ausgefeiltere Methode, um die Lautstärke (mehr oder weniger) unterbrechungsfrei zu gestalten.
Zum einen liest du nur noch alle 500ms den Werte des Potis aus und führst eine Anpassung in audio.setVolume() nur dann aus, wenn sich etwas geändert, du also am Poti gedreht hast. Außerdem glättest du die die Messwerte des Potis rechnerisch, was zu einer etwas sanfteren Anpassung führt.
Wenn du bereits das Poti installiert hast, lade den folgenden Sketch auf deinen ESP32:
#ESP32 Internetradio
#https://polluxlabs.net
#include "Arduino.h"
#include "WiFi.h"
#include "Audio.h"
#define I2S_DOUT 2
#define I2S_BCLK 3
#define I2S_LRC 4
#define VOLUME_PIN 5
Audio audio;
const char* ssid = "DEIN NETZWERK";
const char* password = "DEIN PASSWORT";
const int SAMPLES = 5;
int volumeReadings[SAMPLES];
int readIndex = 0;
int total = 0;
int average = 0;
unsigned long lastVolumeCheck = 0;
const unsigned long VOLUME_CHECK_INTERVAL = 500; // Check alle 500ms
void setup() {
Serial.begin(115200);
pinMode(VOLUME_PIN, INPUT);
WiFi.disconnect();
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nWiFi connected");
Serial.println("IP address: " + WiFi.localIP().toString());
audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
audio.setVolume(10);
audio.connecttohost("http://www.byte.fm/stream/bytefm.m3u");
// Erste Auswertung des Potis
for (int i = 0; i < SAMPLES; i++) {
volumeReadings[i] = 0;
}
}
void loop() {
audio.loop();
unsigned long currentMillis = millis();
if (currentMillis - lastVolumeCheck >= VOLUME_CHECK_INTERVAL) {
lastVolumeCheck = currentMillis;
// Letzten Wert entfernen
total = total - volumeReadings[readIndex];
// Werte des Potis auslesen
volumeReadings[readIndex] = analogRead(VOLUME_PIN);
// Wert hinzufügen
total = total + volumeReadings[readIndex];
// Zum nächsten Wert im Array wechseln
readIndex = (readIndex + 1) % SAMPLES;
// Durchschnitt berechnen
average = total / SAMPLES;
// Geglätteten Wert auf die Lautstärke mappen
int volume = map(average, 0, 4095, 0, 31);
// NUR wenn am Poti gedreht wurde, die Lautstärke anpassen
static int lastVolume = -1;
if (volume != lastVolume) {
audio.setVolume(volume);
lastVolume = volume;
Serial.println("Volume set to: " + String(volume));
}
}
}
void audio_info(const char *info) {
Serial.print("info "); Serial.println(info);
}
void audio_id3data(const char *info) { //id3 metadata
Serial.print("id3data "); Serial.println(info);
}
void audio_eof_mp3(const char *info) { //end of file
Serial.print("eof_mp3 "); Serial.println(info);
}
void audio_showstation(const char *info) {
Serial.print("station "); Serial.println(info);
}
void audio_showstreaminfo(const char *info) {
Serial.print("streaminfo "); Serial.println(info);
}
void audio_showstreamtitle(const char *info) {
Serial.print("streamtitle "); Serial.println(info);
}
void audio_bitrate(const char *info) {
Serial.print("bitrate "); Serial.println(info);
}
void audio_commercial(const char *info) { //duration in sec
Serial.print("commercial "); Serial.println(info);
}
void audio_icyurl(const char *info) { //homepage
Serial.print("icyurl "); Serial.println(info);
}
void audio_lasthost(const char *info) { //stream URL played
Serial.print("lasthost "); Serial.println(info);
}
void audio_eof_speech(const char *info) {
Serial.print("eof_speech "); Serial.println(info);
}Nun solltest du dein ESP32 Internetradio mit dem Poti einschalten und kurz darauf – unterbrechungsfrei – Byte.fm hören können.
Umzug auf eine Lochplatine und in das passende Gehäuse
Bis jetzt hast du die Komponenten deines ESP32 Internetradios auf einem Breadboard montiert. Wenn du es jedoch dauerhaft nutzen und es auch optisch etwas aufwerten möchtest, benötigst du ein Gehäuse – und vermutlich auch eine platzsparendere Methode für die Bauteile.
Als Gehäuse bietet sich eine alte Kassettenhülle an, in der du die Technik unterbringen kannst. Mit einer Säge oder Feile kannst du darin Löcher für das Potentiometer und das Ladekabel (falls du keinen Akku benutzt) bohren. Den Lautsprecher kannst du an der Außenseite oder innen anbringen – ganz wie es seine Maße dir ermöglichen.
So könnte anschließend dein ESP32 Internetradio aussehen:
Das Anbringen der Bauteile auf einer Lochplatine erfordert etwas Planung und durchaus fortgeschrittene Kenntnisse im Löten. Überlege dir vorher, wie du den ESP32, den Verstärker etc. anbringen möchtest, sodass du Platz hast für das Poti oder um auf die USB-Buchse zugreifen zu können. Auch die Platzierung des Lautsprechers spielt eine Rolle.
Eine gute Anleitung für das Löten auf einer Lochplatine findest du hier.
Und das war es mit dem „Einsender-Radio“. Aber was, wenn gerade Werbung kommt oder ein Song, den du nicht mehr hören kannst? Dann muss ein Radio mit Senderwahl her. Wie du dein aktuelles Radio damit erweiterst, erfährst du im folgenden Teil dieses Tutorials.
ESP32 Internetradio mit Senderwahl
Damit du an deinem Radio verschiedene Sender einstellen kannst, benötigst du eine geeignete Eingabemöglichkeit. Hierfür eignet sich ein Rotary Encoder* (oder auch Drehgeber). Dieser rastet, anders als ein stufenloses Poti, an festen Positionen ein und sendet einen entsprechenden Impuls an deinen ESP32. Mit jeder Drehung wechselst du dann zum nächsten Radiosender.
Auf deinem Breadboard ist hierfür nur ein kleiner Umbau nötig:
Wie du siehst, wird der Rotary Encoder (rechts unten) auch vom Lademodul mit Strom versorgt. Die beiden Pins CLK und DT schließt du an die Pins 12 und 13 an.
Die bibliothek für den Rotary Encoder
Damit du die Signale des Rotary Encoders unkompliziert verarbeiten kannst, eignet sich die Bibliothek AiEsp32RotaryEncoder, die du einfach über den Bibliotheksmanager deiner Arduino IDE installieren kannst:
Finde deine Lieblingssender
Als nächstes benötigst du eine Liste von Sendern, die dein ESP32 Internetradio abspielen können soll. Hierfür benötigst du die entsprechenden URLs der Streams. Die URL des Senders Byte.fm hast du ja bereits oben kennengelernt. Zusätzliche oder andere Adressen findest du oft ganz einfach über eine Suchmaschine. Suche hierfür zum Beispiel nach dem [Sendername] + Stream URL.
Ich habe in meinem Radio die folgenden vier Sender hinterlegt (als Array, das du gleich im vollständigen Sketch wiedersehen wirst):
const char* stations[] = {
"http://www.byte.fm/stream/320.m3u", //Byte.fm
"https://st01.sslstream.dlf.de/dlf/01/128/mp3/stream.mp3", //Deutschlandfunk
"https://frontend.streamonkey.net/fho-schwarzwaldradiolive/mp3-stream.m3u", //Schwarzwaldradio
"https://kexp-mp3-128.streamguys1.com/kexp128.mp3" //KEXP
};Der vollständige Sketch des ESP32 Internetradios mit Senderwahl
Und hier nun der gesamte Sketch zum Herauskopieren und Anpassen:
#ESP32 Internetradio
#https://polluxlabs.net
#include "Arduino.h"
#include "WiFi.h"
#include "Audio.h"
#include "AiEsp32RotaryEncoder.h"
#define I2S_DOUT 2
#define I2S_BCLK 3
#define I2S_LRC 4
#define VOLUME_PIN 6
#define ROTARY_ENCODER_A_PIN 12
#define ROTARY_ENCODER_B_PIN 13
#define ROTARY_ENCODER_BUTTON_PIN 14
#define ROTARY_ENCODER_STEPS 4
AiEsp32RotaryEncoder rotaryEncoder = AiEsp32RotaryEncoder(ROTARY_ENCODER_A_PIN, ROTARY_ENCODER_B_PIN, ROTARY_ENCODER_BUTTON_PIN, -1, ROTARY_ENCODER_STEPS);
Audio audio;
// WiFi credentials
const char* ssid = "DEIN NETZWERK";
const char* password = "DEIN PASSWORT";
// Radio stations
const char* stations[] = {
"http://www.byte.fm/stream/bytefm.m3u",
"https://st01.sslstream.dlf.de/dlf/01/128/mp3/stream.mp3",
"https://frontend.streamonkey.net/fho-schwarzwaldradiolive/mp3-stream.m3u",
"https://kexp-mp3-128.streamguys1.com/kexp128.mp3"
};
const int NUM_STATIONS = sizeof(stations) / sizeof(stations[0]);
int currentStation = 0;
// Volume control variables
const int SAMPLES = 5;
int volumeReadings[SAMPLES];
int readIndex = 0;
int total = 0;
int average = 0;
unsigned long lastVolumeCheck = 0;
const unsigned long VOLUME_CHECK_INTERVAL = 500; // Check every 500ms
void IRAM_ATTR readEncoderISR() {
rotaryEncoder.readEncoder_ISR();
}
void setup() {
Serial.begin(115200);
pinMode(VOLUME_PIN, INPUT);
// Rotary Encoder setup
rotaryEncoder.begin();
rotaryEncoder.setup(readEncoderISR);
rotaryEncoder.setBoundaries(0, NUM_STATIONS - 1, true); // circular behavior
rotaryEncoder.setAcceleration(0); // no acceleration
WiFi.disconnect();
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nWiFi connected");
Serial.println("IP address: " + WiFi.localIP().toString());
audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
audio.setVolume(10);
connectToStation(currentStation);
// Initialize volume readings
for (int i = 0; i < SAMPLES; i++) {
volumeReadings[i] = 0;
}
}
void loop() {
audio.loop();
checkVolumeControl();
checkStationChange();
}
void checkVolumeControl() {
unsigned long currentMillis = millis();
if (currentMillis - lastVolumeCheck >= VOLUME_CHECK_INTERVAL) {
lastVolumeCheck = currentMillis;
total = total - volumeReadings[readIndex];
volumeReadings[readIndex] = analogRead(VOLUME_PIN);
total = total + volumeReadings[readIndex];
readIndex = (readIndex + 1) % SAMPLES;
average = total / SAMPLES;
int volume = map(average, 0, 4095, 5, 23);
static int lastVolume = -1;
if (volume != lastVolume) {
audio.setVolume(volume);
lastVolume = volume;
Serial.println("Volume set to: " + String(volume));
}
}
}
void checkStationChange() {
if (rotaryEncoder.encoderChanged()) {
int newStation = rotaryEncoder.readEncoder();
if (newStation != currentStation) {
currentStation = newStation;
Serial.println("Changing to station: " + String(currentStation));
connectToStation(currentStation);
}
}
if (rotaryEncoder.isEncoderButtonClicked()) {
Serial.println("Encoder button clicked");
// You can add functionality here for when the encoder button is pressed
}
}
void connectToStation(int stationIndex) {
audio.stopSong();
audio.connecttohost(stations[stationIndex]);
Serial.println("Connected to: " + String(stations[stationIndex]));
}
// Audio status functions
void audio_info(const char *info) {
Serial.print("info "); Serial.println(info);
}
void audio_id3data(const char *info) {
Serial.print("id3data "); Serial.println(info);
}
void audio_eof_mp3(const char *info) {
Serial.print("eof_mp3 "); Serial.println(info);
}
void audio_showstation(const char *info) {
Serial.print("station "); Serial.println(info);
}
void audio_showstreaminfo(const char *info) {
Serial.print("streaminfo "); Serial.println(info);
}
void audio_showstreamtitle(const char *info) {
Serial.print("streamtitle "); Serial.println(info);
}
void audio_bitrate(const char *info) {
Serial.print("bitrate "); Serial.println(info);
}
void audio_commercial(const char *info) {
Serial.print("commercial "); Serial.println(info);
}
void audio_icyurl(const char *info) {
Serial.print("icyurl "); Serial.println(info);
}
void audio_lasthost(const char *info) {
Serial.print("lasthost "); Serial.println(info);
}
void audio_eof_speech(const char *info) {
Serial.print("eof_speech "); Serial.println(info);
}Passe vor dem Upload zunächst wieder die Zugangsdaten für dein WLAN an und trage deine Lieblingssender ein. Wenn du den Sketch auf deinen ESP32 hochgeladen und gestartet hast, solltest du mit dem Rotary Encoder die einzelnen Sender auswählen können. Bei meinen Tests war es beim ersten Umschalten nötig, zweimal zu drehen. Anschließend reichte eine Drehung in die nächste Stellung.
Noch ein Hinweis: Im Sketch oben, ist auch der Button des Rotary Encoders (auf dem Modul oft SW benannt) an Pin 14 hinterlegt. Falls du deinen Drehgeber auch drücken kannst, hast du die Möglichkeit, darüber eine weitere Funktion deiner Wahl in deinem ESP32 Internetradio zu implementieren.
Auf deinem Breadboard könnte das Radio dann so aussehen:
Wie geht es weiter? Zwar erkennst du deine Radiosender vielleicht an der Musik, die dort läuft – ein Display wäre aber sicherlich hilfreich. Darüber könntest du nicht nur den Sendernamen, sondern auch den Song anzeigen, der gerade gespielt wird. Hierfür hilfreiche Funktionen findest du bereits im Sketch oben: void audio_showstreaminfo() zeigt dir den Sendernamen und void audio_showstreamtitle() den aktuellen Song oder den Namen der aktuellen Sendung.
Das Radio um ein OLED-Display erweitern
Nun also zum letzten Baustein deines ESP32 Internetradios – ein kleines Display, auf dem du den abgespielten Sender sowie den aktuellen Musiktitel ablesen kannst. Hierfür eignet sich ein OLED-Display mit 128×32 Pixeln*. Schließe dieses wie folgt an:
Da sich auf deinem Breadboard (und auf der Skizze oben) mittlerweile eine Menge Kabel tummeln, hier noch mal die Anschlüsse im Detail:
| OLED-Display | ESP32-S3 Zero |
| VCC (3,3V) | 3,3V |
| GND | GND |
| SDA | 8 |
| SCK/SCL | 9 |
Hardwareseitig war es das schon – kommen wir zum Sketch. Hier musst du vor dem Upload allerdings noch eine Kleinigkeit in der Arduino IDE einstellen. Und zwar würde der folgende Sketch den standardmäßig vorgesehenen Speicherplatz auf deinem ESP32 sprengen, wenn du nicht vorab etwas mehr freigeben würdest. Das geht glücklicherweise ganz einfach:
Klicke im Menü Werkzeuge (Tools) auf den Menüpunkt Partition Scheme und wähle die Einstellung Huge APP. Damit hast du nun statt den üblichen 1,2 MB ganze 3 MB zur Verfügung.
Nun, wo du genug Speicherplatz auf dem ESP32 hast, kann es mit dem Upload des Sketchs weitergehen. Ein Hinweis noch vorab: Dein ESP32 hat mit all der angeschlossenen Peripherie ganz schön zu tun, weswegen es passieren kann, dass er nicht zuverlässig bootet. Um das zu verhindern, werden im folgenden Sketch das Display, die Verbindung zum WLAN und der Verstärker schrittweise initialisiert. Die Setup-Funktion hingegen ist nun aufgeräumter.
Damit dein Display den richtigen Sendernamen zum jeweiligen Stream anzeigen kann, benötigst du ein Array mit den Namen. Trage dort die Sendernamen in der gleichen Reihenfolge wie im Stream-Array ein:
const char* stationNames[] = {
"Byte.fm",
"Deutschlandfunk",
"Schwarzwaldradio",
"KEXP",
"Psychedelic Jukebox"
};Hier nun der vollständige Sketch:
#ESP32 Internetradio
#https://polluxlabs.net
#include <Arduino.h>
#include <WiFi.h>
#include <Audio.h>
#include <AiEsp32RotaryEncoder.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define I2S_DOUT 2
#define I2S_BCLK 3
#define I2S_LRC 4
#define VOLUME_PIN 6
#define ROTARY_ENCODER_A_PIN 12
#define ROTARY_ENCODER_B_PIN 13
#define ROTARY_ENCODER_BUTTON_PIN 14
#define ROTARY_ENCODER_STEPS 4
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C
#define I2C_SDA 8
#define I2C_SCL 9
AiEsp32RotaryEncoder rotaryEncoder(ROTARY_ENCODER_A_PIN, ROTARY_ENCODER_B_PIN, ROTARY_ENCODER_BUTTON_PIN, -1, ROTARY_ENCODER_STEPS);
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
Audio audio;
// WiFi credentials
const char* ssid = "DEIN NETZWERK";
const char* password = "DEIN PASSWORT";
// Radio stations
const char* stations[] = {
"http://www.byte.fm/stream/bytefm.m3u",
"https://st01.sslstream.dlf.de/dlf/01/128/mp3/stream.mp3",
"https://frontend.streamonkey.net/fho-schwarzwaldradiolive/mp3-stream.m3u",
"https://kexp-mp3-128.streamguys1.com/kexp128.mp3",
"https://eagle.streemlion.com:2199/tunein/psychedelicj.asx"
};
const char* stationNames[] = {
"Byte.fm",
"Deutschlandfunk",
"Schwarzwaldradio",
"KEXP",
"Psychedelic Jukebox"
};
const int NUM_STATIONS = sizeof(stations) / sizeof(stations[0]);
int currentStation = 0;
char streamTitle[64] = ""; // Buffer to store the current stream title
// Volume control variables
const int SAMPLES = 5;
int volumeReadings[SAMPLES];
int readIndex = 0;
int total = 0;
int average = 0;
unsigned long lastVolumeCheck = 0;
const unsigned long VOLUME_CHECK_INTERVAL = 500; // Check every 500ms
// Flags für verzögerte Initialisierung
bool isWiFiConnected = false;
bool isDisplayInitialized = false;
bool isAudioInitialized = false;
void IRAM_ATTR readEncoderISR() {
rotaryEncoder.readEncoder_ISR();
}
String replaceSpecialChars(String input) {
input.replace("ä", "ae");
input.replace("ö", "oe");
input.replace("ü", "ue");
input.replace("Ä", "AE");
input.replace("Ö", "OE");
input.replace("Ü", "UE");
input.replace("ß", "ss");
return input;
}
void setup() {
delay(1000); // Kurze Pause für stabilen Start
Serial.begin(115200);
while(!Serial) { delay(10); } // Warte auf Serial-Verbindung
Serial.println(F("ESP32-S3 Internet Radio startet..."));
pinMode(VOLUME_PIN, INPUT);
rotaryEncoder.begin();
rotaryEncoder.setup(readEncoderISR);
rotaryEncoder.setBoundaries(0, NUM_STATIONS - 1, true);
rotaryEncoder.setAcceleration(0);
Serial.println(F("Initialisiere I2C..."));
Wire.begin(I2C_SDA, I2C_SCL);
// Initialisiere Volumen-Readings
for (int i = 0; i < SAMPLES; i++) {
volumeReadings[i] = 0;
}
}
void loop() {
static unsigned long lastInitAttempt = 0;
const unsigned long initInterval = 5000; // 5 Sekunden zwischen Initialisierungsversuchen
// Verzögerte Initialisierung
if (!isDisplayInitialized && millis() - lastInitAttempt > initInterval) {
initializeDisplay();
lastInitAttempt = millis();
}
if (!isWiFiConnected && millis() - lastInitAttempt > initInterval) {
connectToWiFi();
lastInitAttempt = millis();
}
if (isWiFiConnected && !isAudioInitialized && millis() - lastInitAttempt > initInterval) {
initializeAudio();
lastInitAttempt = millis();
}
// Normale Loop-Funktionalität
if (isDisplayInitialized && isWiFiConnected && isAudioInitialized) {
audio.loop();
checkEncoder();
checkVolumeControl();
}
yield(); // Watchdog füttern
delay(10); // Kurze Pause für Stabilität
}
void initializeDisplay() {
Serial.println(F("Initialisiere OLED Display..."));
if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
Serial.println(F("SSD1306 Initialisierung fehlgeschlagen"));
return;
}
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0,0);
display.println(F("Initialisierung..."));
display.display();
isDisplayInitialized = true;
Serial.println(F("OLED Display initialisiert"));
}
void connectToWiFi() {
Serial.println(F("Verbinde mit WiFi..."));
WiFi.begin(ssid, password);
int attempts = 0;
while (WiFi.status() != WL_CONNECTED && attempts < 20) {
delay(500);
Serial.print(".");
attempts++;
}
if (WiFi.status() == WL_CONNECTED) {
Serial.println(F("\nWiFi verbunden"));
isWiFiConnected = true;
if (isDisplayInitialized) {
display.clearDisplay();
display.setCursor(0,0);
display.println(F("WiFi verbunden"));
display.display();
}
} else {
Serial.println(F("\nWiFi-Verbindung fehlgeschlagen"));
}
}
void initializeAudio() {
audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
audio.setVolume(10);
connectToStation(currentStation);
isAudioInitialized = true;
Serial.println(F("Audio initialisiert"));
}
void checkEncoder() {
if (rotaryEncoder.encoderChanged()) {
currentStation = rotaryEncoder.readEncoder();
connectToStation(currentStation);
}
if (rotaryEncoder.isEncoderButtonClicked()) {
Serial.println(F("Encoder-Taste gedrückt"));
// Hier könnte eine Aktion für den Tastendruck implementiert werden
}
}
void connectToStation(int stationIndex) {
audio.stopSong();
audio.connecttohost(stations[stationIndex]);
updateDisplay();
}
void checkVolumeControl() {
unsigned long currentMillis = millis();
if (currentMillis - lastVolumeCheck >= VOLUME_CHECK_INTERVAL) {
lastVolumeCheck = currentMillis;
total = total - volumeReadings[readIndex];
volumeReadings[readIndex] = analogRead(VOLUME_PIN);
total = total + volumeReadings[readIndex];
readIndex = (readIndex + 1) % SAMPLES;
average = total / SAMPLES;
int volume = map(average, 0, 4095, 5, 23);
static int lastVolume = -1;
if (volume != lastVolume) {
audio.setVolume(volume);
lastVolume = volume;
Serial.println("Lautstärke eingestellt auf: " + String(volume));
updateDisplay();
}
}
}
void updateDisplay() {
if (!isDisplayInitialized) return;
display.clearDisplay();
display.setCursor(0,0);
display.println(replaceSpecialChars(String(stationNames[currentStation])));
display.println();
display.println(replaceSpecialChars(String(streamTitle)));
display.display();
Serial.println(F("Display aktualisiert"));
}
// Audio callback functions
void audio_info(const char *info) {
Serial.print("info "); Serial.println(info);
}
void audio_id3data(const char *info) {
Serial.print("id3data "); Serial.println(info);
}
void audio_eof_mp3(const char *info) {
Serial.print("eof_mp3 "); Serial.println(info);
}
void audio_showstation(const char *info) {
Serial.print("station "); Serial.println(info);
}
void audio_showstreaminfo(const char *info) {
Serial.print("streaminfo "); Serial.println(info);
}
void audio_showstreamtitle(const char *info) {
Serial.print("streamtitle: "); Serial.println(info);
strncpy(streamTitle, info, sizeof(streamTitle) - 1);
streamTitle[sizeof(streamTitle) - 1] = '\0'; // Ensure null-termination
updateDisplay();
}
void audio_bitrate(const char *info) {
Serial.print("bitrate "); Serial.println(info);
}
void audio_commercial(const char *info) {
Serial.print("commercial "); Serial.println(info);
}
void audio_icyurl(const char *info) {
Serial.print("icyurl "); Serial.println(info);
}
void audio_lasthost(const char *info) {
Serial.print("lasthost "); Serial.println(info);
}
void audio_eof_speech(const char *info) {
Serial.print("eof_speech "); Serial.println(info);
}Nach dem Upload sollte dein ESP32 Internetradio starten (was nun etwas länger dauert) und den ersten Sender in deiner Liste spielen. Auf dem Display erscheint der von dir hinterlegte Sendername und – sofern verfügbar – der Name des Songs oder der Sendung, der oder die gerade läuft.
Und das war es an dieser Stelle. Viel Spaß beim Tüfteln! 🙂
