das MAKE Internet-UKW-Radio

[saarfranzose]

in der MAKE Ausgabe 2/2023 wird die Bauanleitung eines ESP32-Radio gezeigt welches neben Internet auch UWK empfangen kann.

Das Radio ist insgesamt etwas spartanisch gehalten, hat aber auch seine Vorzüge. Schauen wir uns erst mal den Internet-Teil an:

Die Basis bildet die ESP32-audioI2S Library von Schreibfaul1. WiFi und Internetstationen sind hardcodiert. Es gibt keinen AP-Mode und kein Webinterface. Nach Kontrolle der LCD-Adresse (Vorgabe ist 0x3F, manche LCD liegen aber auf 0x27) und Eingabe der WiFi-Daten kann der mehrteilige Sketch mit der Arduino-IDE aufgespielt werden. Der WiFi-Mode ist nach dem Einschalten des Radio vorrangig aktiv. Die Radiostationen wählt man mit dem Encoder vor und hat dann 10 Sekunden Zeit um sie mit einem Druck auf den Switch zu übernehmen. Als Codec wird der interne DAC benutzt, dessen Klangqualität eher bescheiden ist. Hier setzte durch einen externen I2S-Baustein meine erste Änderung an. Da sich UKW und WiFi den NF-Verstärker teilen müssen und noch ein Lautstärkepoti mit eingebaut werden muss entschied ich mich für einen PCM5102, welcher per Klinkenausgang die NF bereitstellt.

Den UKW-Empfang liefert ein Baustein SI4703 mit der Radio-Library von mathertel und zeigt auch die Senderkennung an. In dem Artikel ist die SparkFun-Variante eingesetzt, die momentan aber schwer erhältlich und auch kostspielig ist. Das normale Breakout-Board ist aber genauso gut einsetzbar. Nur wenn man sich mit den bereitgestellten STL-Dateien das Gehäuse ausdruckt ist wegen der anderen Bauform der Platine eine Änderung notwendig. UKW hat keinen Suchlauf und keinen Senderspeicher. Beim Umschalten auf UKW beginnt man also immer bei 87,5MHz und muss dann mühsam bis zur gewünschten Station den Encoder in 100KHz-Schritten durchdrehen.
Der UKW-Empfang wird aktiviert indem man die letzte Internetstation mit dem Namen "UKW" anwählt. Dreht man den Encoder nach links ist es natürlich die nächste Station. Zurück zum WiFi-Radio geht es durch nochmaligen Druck auf den Encoder.

Meinen Test-Aufbau baute ich auf eine Vorversion meiner ESP-Platine. Bis auf 2 fehlende Verbindungen konnte ich sie direkt benutzen. Auf die Ladeschaltung und damit einen Akku-Betrieb verzichtete ich, ebenso auf die Relais-Karte, welche die NF zwischen WiFi und UKW umschalten sollte. Ich hatte gehofft ich könnte die Signale einfach mit Widerständen zusammenmischen. Weil der UKW Baustein aber nicht stumm schaltet muss auf irgendeine Art umgeschaltet werden. Hier ist aber auch eine weitere Änderung in der Software denkbar.

Im Deklarationsteil des Sketches gibt es einen MODE_PIN:

#define MODE_PIN 21

hier dachte ich zuerst an einen Konflikt mit der SDA-Leitung des I2C-Busses zum Display. Ein Umlegen auf einen freien GPIO hatte aber den Effekt dass der SI4703 nur noch Rauschen empfing. Auf der git-Seite von Schreibfaul1 fand ich dann den Hinweis:

#define MODE_PIN 18  // same as SDA

Damit ist klar dass es sich nicht um einen Fehler handelt. MODE-PIN wird im UKW_Setup an die Bibliothek übergeben. Mehr kann ich zu diesem mysteriösen Pin nicht sagen.

   

   

   

   

   

[Siegfried55]

Man kann im Heft nur lesen, wenn man ein Abo hat ?.

Warum hat man denn hier den Level Converter benutzt und beim AZ Radio mit Display hat es auch ohne
funktioniert?

Danke für Deine Vorarbeit ???

Gruß

Siegfried

[saarfranzose]

Hallo Siegfried,

für das Git-Repository mit dem Quellcode braucht man kein Abo. In meinem ersten Satz ist es verlinkt. Den Artikel in der Zeitschrift braucht man nur wenn man die  Ladeschaltung wie vorgesehen nachbauen will oder nicht weiß wie der interne DAC zu verdrahten ist und man diesen entgegen meiner Empfehlung benutzen will. Eine gpio-Liste sucht man vergeblich, und der Schaltplan in der Zeitschrift ist im Bereich des ESP kaum lesbar. Ich greife jetzt mal vor. Ich arbeite an dem nächsten Aufbau mit meiner aktuellen Platine und zeige dann auch einen eigenen Verdrahtungsplan.

Auf dieser Abbildung habe ich die von MAKE vorgesehenen gpio Zuweisungen mit weißem Text eingetragen. ENCBTN und Relais will ich ändern, dann erspare ich mir die beiden Drahtbrücken. Die Änderung auf externen DAC ist bereits eingeflossen. Die Ladeschaltung habe ich weggelassen und die NF-Umschaltung muss extern realisiert werden:

   

Ein Level-Changer ist wohl die sauberste Lösung um die 3,3V-Logik des ESP mit einem 5V-LCD zu verbinden. Ich hatte einen solchen allerdings nur in meiner Vorserie. Auf der späteren Platine habe ich ihn eingespart und hab ihn auch noch nie vermisst. Über die Notwendigkeit gibt es geteilte Ansichten.

[Siegfried55]

Danke Dir für die Ergänzung

Gruß

Siegfried

[saarfranzose]

hier gibt es ein paar neue Erkenntnisse/Erfahrungen, die ich dokumentieren will.

- bei meinem zweiten Aufbau (ohne level-changer) hatte das Display Aussetzer und sporadisch schalteten sich wild die Sender um. Bei UKW lief die Empangsfrequenz weg. Bei meiner Fehlersuche setzte ich nach der quick and dirty Methode einen level-changer dazu. Der Fehler aber blieb:


  levelchanger.jpg (Größe: 75,56 KB / Downloads: 559)

als Ursache stellte sich der Encoder heraus. Ich hatte meinen Lieblingstyp mit der runden Platine eingesetzt. Und das war das Problem. Durch die Entprell-Schaltung dieses Encoder-Typs hat der wirksame Pullup-Widerstand einen Wert von 20K. Das scheint zuviel für den ESP32 für einen sicheren Pegelbereich. Dieser Encoder ist also nicht geeignet.

   

- in der Software ist so einiges erweiterungswürdig. Ein Punkt ist der UKW-Bereich, der beim Einschalten immer mit 87,5 MHz startet. Durch die Ergänzung von 2 Codezeilen in der rotary.ino startet er jetzt direkt mit dem Ortssender.

if (Stationsnummer == STATIONS-1 && mode == "wlan") {
        mode = "ukw";
        //mode = "wlan";       
        Serial.println("Wechsel auf:");
        Serial.print(mode);
        lcd.clear();
        showText(0,0,"Wechsel auf UKW");
        delay(1000);
        Frequenz = 10170; //UKW-Start mit Ortssender
        radio.setFrequency(Frequenz);     
        UKW_loop();
    }

noch besser wäre es die zuletzt benutzte Frequenz im EEPROM zu hinterlegen und beim Umschalten auf UKW aufzugreifen. Oder die Abstimmung mittels Suchlauf, wie ich es auch schon bei meinen Arduino-Radios realisiert habe. Oder beides.

- der nächste Punkt betrifft den DAC. Ich hatte ja erwähnt dass MAKE den krächzenden internen DAC benutzt. Die Schreibfaul-Library kann aber auch eine Reihe externer Bausteine bedienen. Neben dem PCM5102-Baustein, den ich am Anfang benutzte, hab ich jetzt den wesentlich günstigeren Baustein CS4344 für mich entdeckt. Wie man die einzelnen Bausteine beschaltet und anspricht kann man natürlich in der ESP32-audioI2S-Library nachschauen, allerdings etwas mühselig. Deshalb will ich die Unterschiede der einzelnen Konfigurationen im Sketch zusammenfassen:

Interner DAC:

Die Instanz wird gebildet mit:

Audio audio(true, I2S_DAC_CHANNEL_BOTH_EN);

Bei den externen Bausteinen kommen einige Deklarationen dazu.

Für den PCM5102:


#define I2S_DOUT    25
#define I2S_BCLK   27
#define I2S_LRC    26


die Änderung bei der Instanz:

Audio audio;

und im Setup:

audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);

Für den CS4344:

Die Verdrahtung faßt Schreibfaul in diesem Bild zusammen:


  DAC CS4344.jpg (Größe: 58,12 KB / Downloads: 559)

Diese Deklarationen sind notwendig:

#define I2S_DOUT   25
#define I2S_BCLK   27
#define I2S_LRC     26
#define I2S_MCLK             3


Die Instanz:

Audio audio;

Im Setup:

audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT, -1, I2S_MCLK);

Hierzu noch einen Hinweis: Der auf dem ESP32 NodeMCU Development Board mit D3 gekennzeichnete Pin ist nicht GPIO3 sondern GPIO10! GPIO3 liegt auf RXD0!

[saarfranzose]

Meine weiteren Erfahrungen mit dem MAKE-Radio sind sehr ernüchternd. Die Besonderheit, nämlich Internetradio mit alternativem UKW-Empfang, empfinde ich als nicht praxistauglich. Ein externer I2S-Baustein beeinflußt den FM-Baustein SI4703 derart dass kein UKW-Empfang mehr möglich ist. Ich baute dazu extra eine neue Hardware mit einer ESP32 NodeMCU, plazierte die Module räumlich großzügiger, und benutzte unterschiedliche I2S-Bausteine. Also neben dem CS4344 auch einen PCM5102. Immer mit dem gleichen Effekt, dass der UKW Empfang verschwindet sobald an den GPIO 25, 26 oder 27 und auch an dem für den CS4344 benutzten GPIO3 eine Verbindungsleitung angeschlossen ist. Der Baustein muss noch nicht mal angeklemmt sein. Sobald man ein Verbindungskabel an der Isolierung berührt ist der UKW-Empfang weg. Evtl. verwendet MAKE aus diesem Grund den internen DAC. Diese Konstellation habe ich nicht mehr ausprobiert da der interne DAC für mich qualitativ nicht in Frage kommt.

   

auf diesem Bild ist zu sehen wie ich mit einer zweiten Klinkenbuchse die NF-Masse isoliere, um einen Einfluss der Antenne auf das Empfangsproblem auszuschliessen:

   

Schade, die Software hätte noch Potential gehabt zum weiteren Ausbau, und durch die benutzten Bibliotheken wäre der Ausbau relativ leicht zu bewerkstelligen. Aber unter den Umständen macht es keinen Sinn.

[OttoBerger]

Moin Jupp.
Deine Erfahrung mit I2S DAC oder ClassD Amps in Verbindung mit solchen Verkabelungen bei UKW kann ich bestätigen. Über diese Leitungen läuft der Ton mit Takt im MHz HF Bereich. Diese HF wird über Jumperleitungen und ungünstige Leiterbahnen abgestahlt. Das muss peinlichst in Länge und Verlauf der Verdrahtung beachtet werden. Hier hast Du aber Glück. Du kannst im Quelltext bestimmen wann du auf UKW bist und wann auf Internet. Bei UKW schaltest du die störende I2S Schnittstelle zum DAC in der Software einfach ab. Ich würde zusätzlich die zum DAC laufenden Leitungen unter die Platine legen und den UKW Chip oben. Zwischen den Datenleitungen auf der Platine würde ich eine breitere Masseleitung legen.

Du kannst auch den Externen DAC weglassen und die Ton vom ESP32 in guter Qualität erzeugen lassen.
Es gibt bekanntlich mindestens 3 Wege für die Tonerzeugung:

- 8 Bit DAC , hierauf beziehst du deine Erfahrung mit der schlechten Qualität denke ich
- PWM DAC, fast wie 8 Bit DAC
- I2S PDM DAC mit RC-Filter für 16 Bit Samples/16 Bit Registerbreite mit anschließendem Oversampling.  Das ist dann  ein 1 BIT DAC wie in CD oder SACD Spielern genutzt. Bei SACD das Standardtonformat.  Sehr gute Ton-Qualität. Ich benutze den Modus mit direkter RC-Filterung am GPIO25/26 beim iRadioMini und gehe damit auf Line-In einer HiFi-Anlage. Top Tonqualität.

Viele Grüße
Otto

[saarfranzose]

Hallo Otto,

den externen DAC im UKW-Betrieb abzuschalten wäre ein guter Lösungsvorschlag! Ich bin allerdings auf die Möglichkeiten der ESP32-audioI2S Library von Schreibfaul angewiesen. Hinweise für eine Deaktivierung im laufenden Betrieb konnte ich dort nicht finden.

[OttoBerger]

Moin Jupp. 

Auf deine Frage wie man das mit der Schreibfaul Audio Lib machen könnte habe ich mir Gedanken gemacht. Im ESP-IDF kann man den I2S DAC durch die Installation des I2S Treibers zur Laufzeit hinzuschalten und durch Deinstallation des I2S Treibers wieder ausschalten.

Einschalten https://docs.espressif.com/projects/esp-...l-overview
Ausschalten https://docs.espressif.com/projects/esp-...l-overview

In der Schreibfaul Audio Lib findet man genau diese vom ESP-IDF genannte Vorgehensweise im Construktor der Audio-Klasse.

Code:

Audio::Audio(bool internalDAC /* = false */, uint8_t channelEnabled /* = I2S_DAC_CHANNEL_BOTH_EN */, uint8_t i2sPort) {

    mutex_audio = xSemaphoreCreateMutex();

    //    build-in-DAC works only with ESP32 (ESP32-S3 has no build-in-DAC)
    //    build-in-DAC last working Arduino Version: 2.0.0-RC2
    //    possible values for channelEnabled are:
    //    I2S_DAC_CHANNEL_DISABLE  = 0,     Disable I2S built-in DAC signals
    //    I2S_DAC_CHANNEL_RIGHT_EN = 1,     Enable I2S built-in DAC right channel, maps to DAC channel 1 on GPIO25
    //    I2S_DAC_CHANNEL_LEFT_EN  = 2,     Enable I2S built-in DAC left  channel, maps to DAC channel 2 on GPIO26
    //    I2S_DAC_CHANNEL_BOTH_EN  = 0x3,   Enable both of the I2S built-in DAC channels.
    //    I2S_DAC_CHANNEL_MAX      = 0x4,   I2S built-in DAC mode max index
#ifdef AUDIO_LOG
    m_f_Log = true;
#endif

    #define __malloc_heap_psram(size) \
        heap_caps_malloc_prefer(size, 2, MALLOC_CAP_DEFAULT|MALLOC_CAP_SPIRAM, MALLOC_CAP_DEFAULT|MALLOC_CAP_INTERNAL)

    if(psramInit()) m_chbufSize = 4096; else m_chbufSize = 512 + 64;
    m_ibuff    = (char*)    __malloc_heap_psram(512 + 64);
    m_lastHost = (char*)    __malloc_heap_psram(512);
    m_outBuff  = (int16_t*) __malloc_heap_psram(2048 * 2 * sizeof(int16_t));
    m_chbuf    = (char*)    __malloc_heap_psram(m_chbufSize);

    if(!m_chbuf || !m_lastHost || !m_outBuff || !m_ibuff) log_e("oom");

    #define AUDIO_INFO(...) {sprintf(m_ibuff, __VA_ARGS__); if(audio_info) audio_info(m_ibuff);}

    clientsecure.setInsecure();  // if that can't be resolved update to ESP32 Arduino version 1.0.5-rc05 or higher
    m_f_channelEnabled = channelEnabled;
    m_f_internalDAC = internalDAC;
    //i2s configuration
    m_i2s_num = i2sPort; // i2s port number
    m_i2s_config.sample_rate          = 16000;
    m_i2s_config.bits_per_sample      = I2S_BITS_PER_SAMPLE_16BIT;
    m_i2s_config.channel_format       = I2S_CHANNEL_FMT_RIGHT_LEFT;
    m_i2s_config.intr_alloc_flags     = ESP_INTR_FLAG_LEVEL1; // interrupt priority
    m_i2s_config.dma_buf_count        = 16;
    m_i2s_config.dma_buf_len          = 512;
    m_i2s_config.use_apll             = APLL_DISABLE; // must be disabled in V2.0.1-RC1
    m_i2s_config.tx_desc_auto_clear   = true;   // new in V1.0.1
    m_i2s_config.fixed_mclk           = I2S_PIN_NO_CHANGE;


    if (internalDAC)  {

        #ifdef CONFIG_IDF_TARGET_ESP32  // ESP32S3 has no DAC

            log_i("internal DAC");
            m_i2s_config.mode             = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX | I2S_MODE_DAC_BUILT_IN );

            #if ESP_ARDUINO_VERSION_MAJOR >= 2
                #if ESP_ARDUINO_VERSION_PATCH  == 0
                    m_i2s_config.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_STAND_I2S); // vers == 2.0.0
                #else
                    // V2.0.1 ... V2.0.4 will not work
                    m_i2s_config.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_STAND_MSB); // vers >= 2.0.5
                #endif
            #else
                m_i2s_config.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S_MSB);
            #endif

            i2s_driver_install((i2s_port_t)m_i2s_num, &m_i2s_config, 0, NULL);
            i2s_set_dac_mode((i2s_dac_mode_t)m_f_channelEnabled);
            if(m_f_channelEnabled != I2S_DAC_CHANNEL_BOTH_EN) {
                m_f_forceMono = true;
            }

        #endif

    }
    else {
        m_i2s_config.mode             = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX);

        #if ESP_ARDUINO_VERSION_MAJOR >= 2
            m_i2s_config.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_STAND_I2S); // Arduino vers. > 2.0.0
        #else
            m_i2s_config.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB);
        #endif

        i2s_driver_install((i2s_port_t)m_i2s_num, &m_i2s_config, 0, NULL);
        m_f_forceMono = false;
    }

    i2s_zero_dma_buffer((i2s_port_t) m_i2s_num);

    for(int i = 0; i <3; i++) {
        m_filter[i].a0  = 1;
        m_filter[i].a1  = 0;
        m_filter[i].a2  = 0;
        m_filter[i].b1  = 0;
        m_filter[i].b2  = 0;
    }

Das Ausschalten im Destructor der Audio Klasse.

Code:

Audio::~Audio() {
    //I2Sstop(m_i2s_num);
    //InBuff.~AudioBuffer(); #215 the AudioBuffer is automatically destroyed by the destructor
    setDefaults();
    if(m_playlistBuff) {free(m_playlistBuff); m_playlistBuff = NULL;}
    i2s_driver_uninstall((i2s_port_t)m_i2s_num); // #215 free I2S buffer
    if(m_chbuf)    {free(m_chbuf);    m_chbuf    = NULL;}
    if(m_lastHost) {free(m_lastHost); m_lastHost = NULL;}
    if(m_outBuff)  {free(m_outBuff);  m_outBuff  = NULL;}
    if(m_ibuff)    {free(m_ibuff);    m_ibuff    = NULL;}
    vSemaphoreDelete(mutex_audio);
}

Dazu habe ich ein Testsketch geschrieben das zeigt wie man so eine Instanz der Audioklasse zur Laufzeit erzeugen kann (DAC ein) und wieder zerstört (DAC aus).

Code:

#include "Arduino.h"
#include "WiFi.h"
#include "Audio.h"

#define I2S_DOUT      26  // connect to DAC pin DIN
#define I2S_BCLK      27  // connect to DAC pin BCK
#define I2S_LRC       25  // connect to DAC pin LCK

//Audio audio;
Audio *zeiger_auf_audio = NULL;

const char* ssid =     "SSID";
const char* password = "password";

void schreibfaul_DAC_ein() {
    // existiert noch keine Audio?
    if (zeiger_auf_audio == NULL) {
       Serial.println("schalte DAC ein");
       zeiger_auf_audio = new Audio(/* hier ggf. weitere Parameter*/); // rufe Constructor auf und erstelle Audio, I2S DAC einschalten

       // zusätzliche Spielereien mit schreibfaul DAC lib
       zeiger_auf_audio->setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
       zeiger_auf_audio->setVolume(21);

       // zusätzliches Demo, hole Internetradiostream
       zeiger_auf_audio->connecttohost("http://s1.knixx.fm/dein_webradio_64.aac"); // 64 kbp/s aac+
    }
}


void schreibfaul_DAC_aus() {
    // exisitert schon ein Audio?
    if (zeiger_auf_audio != NULL) {
      Serial.println("schalte DAC aus");
      delete zeiger_auf_audio; // rufe Destructor auf und zerstöre Audio, I2S DAC ausschalten
      zeiger_auf_audio = NULL;
    }
}

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) delay(1500);
    schreibfaul_DAC_ein(); // starte mit Internetradio und DAC ein
 
}

void loop() {

    // hier Internetradiomodus
    if (zeiger_auf_audio != NULL) {
       zeiger_auf_audio->loop();  // verarbeite die Daten vom Internetstream -> Decoder -> DAC
    }


    // hier UKW : vorher schreibfaul_DAC_aus()


}

void audio_info(const char *info){
    Serial.print("info        "); Serial.println(info);
}

Ich habe das Testsketch erfolgreich getestet. Schaltet ich den externen I2S-DAC ein, dann stört ein Jumperkabel  am Taktpin den UKW-Empfang mehrere Meter! Auf einem Spektrumanalyzer konnte ich die Oberwellen noch im 70cm Band sehen. Schalte ich den DAC mit schreibfaul_DAC_aus() aus ist Stille!

Im Constructor der Audio-Klasse kann man noch weitere DAC-Einstellungen vornehmen wie Intern / Extern , Mono, Stereo und so weiter. Kennst du aus deinem Sketch. Die Softwaredecoder für AAC, MP3 in der Schreibfaul-Klasse finde ich gut weil sie open sind. Die liefern auch mehr Streaminfos als die Softwaredecoder die Espressif im ESP-ADF hat, welche closed source sind. Ich werde das der iRadioMini-Gruppe als Zusatzoption vorschlagen. Schlecht an der Schreibfaul-Klasse finde ich das beim internen DAC nur der 8 Bit Hardware DAC genutzt wird oder ich habe die Option übersehen. Der 8 Bit HardwareDAC klingt nicht so gut und reicht nur für einfachste Miniradios. Dabei wäre es kein Problem und mit wenig Änderung an der Schreibfaulklasse möglich den I2S Bus auf PDM Modus zu schalten. https://docs.espressif.com/projects/esp-...dm-mode-tx   Mit einem Filter direkt an den GPIIO des ESP32 bekommt man durch Pulsedichtemodulation einen SACD-Klang. Ein zusätzlicher externer DAC wäre nicht mehr nötig. Benutze ich in der PDM-Konfiguration mit iRadioMini an einer HiFi-Anlage.

Viele Grüße aus HH
Otto

[saarfranzose]

Hallo Otto,

meine Versuche mit DAC_ein und DAC_aus sind ebenfalls positiv verlaufen! Die "on the fly" Funktion funktioniert bestens. Norbert war mir behilflich. Der UKW-Empfang ist sauber und störungsfrei wenn der externe DAC abgeschaltet ist. Ich mache noch etwas Ordnung im Sketch und werde ihn dann hier zeigen. Dann kann ich das Projekt ja dank deiner Vorarbeit wieder aufgreifen. Ich hatte es schon aufgegeben.

[saarfranzose]

hier geht es endlich weiter. Ich hatte folgende 3 Änderungen vorgesehen:

1.) im Betrieb Zu- und Abschalten des DAC

dank der Hilfe von Otto und Norbert konnte das realisiert werden.

2.) Die manuelle UKW-Senderabstimmung ersetzen durch einen Sendersuchlauf

das konnte ich mit wenigen Zeilen selbst erledigen.

3.) Speicherung der zuletzt eingestellten UKW Frequenz, so dass diese bei erneutem Umschalten auf UKW oder nach erneutem Einschalten des Radio wieder aufgegriffen wird.

hier brauchte ich ein paar Tage um mich durchzuarbeiten. Anders als ein Arduino hat der ESP32 kein EEPROM, sondern die Speicherung von Schlüsselpaaren geschieht in der NVS-Partition im normalen Flash mit Hilfe der Bibliothek preferences.h.

Um diese zumindest für mich etwas komplizierte Programmierung zu üben und zu testen suchte ich mir alle Informationen zusammen und schrieb einen kleinen Testcode. Mit dem Üben sollte man es nicht übertreiben, weil die Anzahl Schreibzyklen nicht endlos ist. Später im Programm führe ich die Schreibfunktion nur einmal bei jeder Frequenzänderung durch.

Hier erst mal der Testcode. Ich erhöhe alle 2 Sekunden die Frequenz in 10er Schritten. Nach Aus/Einschalten wird der letzte Stand wieder eingelesen und an der vorherigen Stelle weitergezählt.

Code:

#define SERIAL_BAUDRATE 115200
#include <Preferences.h>
Preferences prefs;
uint32_t Frequenz;


void setup() {
  Serial.begin(SERIAL_BAUDRATE);
  readPrefsData();
  delay(500);
}

void readPrefsData()
{
  prefs.begin("my_prefs", false);
  Frequenz = prefs.getUInt("Frequenz", 0);
  prefs.end();
}


void writePrefsData(char* address, unsigned int newData)      // Daten speichern
{
  prefs.begin("my_prefs", false);
  prefs.putUInt(address, newData);
  prefs.end();
}


void loop() {
Serial.println(Frequenz);
delay(2000);
Frequenz = (Frequenz+10);
writePrefsData("Frequenz", Frequenz);
}

und hier nun der komplette Sketch mit allen 3 aufgezählten Änderungen:


  MakeRadioNeuRBF.zip (Größe: 5,08 KB / Downloads: 5)

[Siegfried55]

Danke für Deine Vorarbeit Jupp,

ich werde nach Eingang der Teile das Make auch mal auf dem Experimetiertisch aufbauen

Grüße

Siegfried

[Siegfried55]

So, heute konnte ich auf den PCM5102 zurückgreifen und komplett, aber mit Relais, die Schaltung nach Deinen Hinweisen und Änderungen nachbauen und es läuft. Der UKW Empfang ist ein wenig abhängig von Lage und Form der Antenne.  Für die Variante auf dem Steckbrett mit Freiluftverkabelung ist das Ergebnis über meinen Erwartungen.
Und das Relais schaltet zuverlässig und sieht doch gar nicht so gewaltig aus ??

Grüße

Siegfried

[Siegfried55]

PS: vielen Dank an die Unterstützer! Gerade die Idee mit der Abschaltung des DAC ist ein Meilenstein zur herkömmlichen Lösung


Siegfried