Erfahrungen mit ESP32 und WLAN/MQTT oder was ich beobachtet habe...

[Arduino4Fun]

Ich möchte zu meinen Erfahrungen zum ESP32 mit WLAN/MQTT berichten.

Ich habe seit einiger Zeit Applikationen mit 8266 und WLAN/MQTT am Laufen. Diese basieren weitestgehend auf dem Beispiel von PubSubClient und laufen seit einiger Zeit ziemlich stabil. Die Verwendung eines ESP32 mit dieser SW hatte immer wieder Probleme bereitet.

Nachdem ich nun für eine WLAN/MQTT Applikation mit mehreren PWM Kanälen, sowie mehreren AD-Kanälen (Erfahrung dazu im eigenen Thread) benötige, war der ESP32 die erste Wahl. Im speziellen ein verfügbarer Lolin32.

Die Beobachtung zeigt, dass der ESP32 immer mal wieder WLAN oder MQTT Synchronisation verliert und z.B. Reconnect erneut durchführt. Im Demo blockiert hier ein delay(5000) den Rest der Anwendung.
Andere Anwendungen im Internet starten den Rechner bei verlorener Synchronisation des WLAN oder MQTT über ESP.restart() neu.

Da beides für mich keine Option waren, habe ich WLAN/MQTT in eine Klasse gepackt und synchronisiere bei Verlust WLAN und/oder MQTT blockadefrei, so dass die restliche Applikation ungestört weiterläuft bzw. Zugriff per OTA jederzeit möglich ist.

Doch leider läuft die SW ebenfalls nicht auf dem ESP32 stabil. Der ESP32 bleibt ab und zu (nach Minuten oder auch erst Stunden) „hängen“, so dass ich anschließend den internen Watchdog aktiviert habe, welcher auch immer wieder zuschlägt.
Zwischendurch schmiert der Rechner aber auch mal mit „Guru Meditation Error: Core 0 panic'ed (LoadProhibited). Exception was unhandled“ ab.

Die Suche nach der Ursache stellt sich als nicht so einfach dar. Erste Vermutung war der gemischte Einsatz bei der String-Verarbeitung von „char“ und „String“. (hier erfolgt immer der Hinweis von Tommy) Nach Umbau zu konsequenter Nutzung von „char“ jedoch keine deutliche Verbesserung.

Aus Verzweiflung kam mir dann die Idee, die „neue“ Klasse mal mit einem 8266 zu testen (Wemos D1 mini). Dann die erstaunliche Erkenntnis: SW läuft komplett ohne Ausstiege robust.

Der nun offensichtlichste Unterschied zwischen ESP32 und 8266 sind die Anzahl Core – Double und Single Core. Auf dem ESP32 läuft die Arduino Applikation in Core 0, die Systemfunktionen inkl. WLAN in Core 0.

Nun kam mir eine Vermutung, dass es evtl. konkurrierende Zugriffe beim ESP32 zwischen Arduino-Applikation und System im speziellen WLAN Zugriff kommen kann (loop() in Core 1 und System in Core 2).

Nun ein weiterer Ansatz für meine SW: Einführung/Einsatz „FreeRTOS“:
Ich habe nun in der Arduino-Applikation den Aufruf der Klasse „WLAN/MQTT“ komplett in den Core 0 verschoben und der Rest der Applikation läuft in der Arduino loop(), bei mit im Test-System Anzeige über I2C LCD Display.
Austausch der Daten zwischen der Task Core 0, sprich „MQTT“ liefert Daten und „Arduino-loop“ zeigt im Display an erfolgt über nicht speziell geschützte globale Variable -> Hier ist sicher noch eine Absicherung bzw. Schutz gegen „zeitgleichen“ Zugriff notwendig

Ich bin mir noch gar nicht sicher, ob ich die tatsächliche Ursache gefunden habe – oder ob es weitere Unsauberkeiten oder „bugs“ in meinem Code gibt. Evtl. bin ich ja auf dem Holzweg. Aber aktueller Stand mit einem Demo-Aufbau zeigt folgenden Status (jeweils 2..3 Stunden getestet, LOG über Serial)

1. Zielsystem: ESP32 mit Arduino SW, WLAN+MQTT in Klasse
ESP32 mit SW läuft komplett in Arduino-loop (Core 1) und System (Core 0) -> Immer wieder Ausstiege nach Minuten bis Stunden mit WDT oder Guru

2. Zielsystem: 8266 mit Arduino SW, WLAN+MQTT in Klasse
Identische SW wie (1.) mit 8266 -> läuft stabil ohne Ausstieg

3. Zielsystem: ESP32 mit „RTOS“+Arduino SW, WLAN+MQTT in Klasse auf Core 0
Verlagerung der „WLAN/MQTT“ Funktion in Core 0 zeigt keine Ausstiege.

Ich werde bei neuen Erkenntnissen weiter berichten. Für Tips, Hinweise oder Korrekturen bin ich ebenfalls dankbar. Ziel ist eine stabile, blockadefreie WLAN/MQTT Applikation mit ESP32 und Nutzung der entsprechenden Peripherie.

Ergänzung:
Ich habe nun eine bestehende Applikation analog (3.) portiert. Bis jetzt keine Auffälligkeit seit ca. 30min. Weitere Anmerkung. Beim Einlesen eines DS18B20 im 1 sek Zyklus und setWaitForConversion( false ); … hatte ich auch sporadisch das Ergebnis -127. Scheint ebenfalls weg zu sein.

Mal sehen wie es weiter läuft…

Gruß Arduino4Fun

[Tommy56]

(30.12.2020 21:35)Arduino4Fun schrieb:  2. Zielsystem: ESP32 mit Arduino SW, WLAN+MQTT in Klasse
Identische SW wie (1.) mit 8266 -> läuft stabil ohne Ausstieg

Da ist ein Widerspruch zwischen Überschrift und Inhalt

Ansonsten danke für die Analyse. Ich bleibe beim ESP8266.
Ich habe den Eindruck, die bekommen beim ESP32 das 2-Kerne-System nicht gebacken.

Gruß Tommy

[Arduino4Fun]

Hi Tommy,

danke für den Hinweis, war natürlich mit 8266 (Wemos D1 mini)

Beim 8266 "gefällt" mir die Peripherie nicht - ADC ... (Anzahl+Bereich), Verhalten der Posts beim StartUp etc. Für vieles recht dieser auch bei mir. Der ESP32 hat da schon einiges zu bieten.

Wenn die Verlagerung der WLAN/MQTT Funktionalität in Core 0 die notwendige Stabilität bringt wäre das für mich o.k. Portiere gerade zwei weitere Applikationen.

Gruß Arduino4Fun

[nbk83]

Schöne Aufstellung, die Du da gemacht hast!
Ich habe ähnliche (nicht so detaillierte) Erfahrungen mit dem ESP32 in Verbindung mit WLAN/MQTT: Mal keine MQTT-Daten mehr, lässt sich aber noch anpingen, mal komplett weg.
Jetzt ne Frage in die Runde: Hat schonmal jemand Stabilitätsprobleme beim ESP32 ohne WLAN-Betrieb festgestellt? Sonst wäre ja evtl eine stabile Lösung, dass man das WLAN im ESP32 nicht nutzt, sondern stattdessen einen 8266, der die Kommunikation übernimmt?
Grüße Jan

[Arduino4Fun]

Hallo Jan,

ich bin da nicht so pessimistisch. Meine nun "WLAN/MQTT nach Core 0" portierte Applikation nutzt regen MQTT Datenverkehr mit einem iOBroker und hat von anderen Teilnehmern Daten abonniert. Sie läuft jetzt seit ca. 90 min ohne jede Auffälligkeit. Lücken im Datenstrom sowie Disconnect WLAN oder MQTT logge ich mit.

Die Pflege eine zwei Rechner System ist aus meiner Sicht fehlerbehaftet und mühsam. Habe ein „Kombi“-System am Laufen – 8266+Mirco Pro, da ich bei dem einen die Maus/Keyboard Emulation und beim anderen WLAN/MQTT benötige, gekoppelt über I2C.

All in one im ESP32 hätte da schon Vorteile

Gruß Arduino4Fun

[Arduino4Fun]

Hallo,

anbei mein WLAN/MQTT Test Code für ESP32 zur Diskussion - bisher keine Auffälligkeiten. Verwende kein Delay, Synchronisierung von WLAN und MQTT bei Bedarf. Der eigentliche Applikations-Code läuft im Ziel nur in den "Loop_Taskxxx" Routinen. Weiterhin sind die Sende/Empfangsbotschaften in den MQTT Routinen anzupassen. Serial.print im loop() und Core_x sollte im Ziel nicht drin bleiben. Bin auf Rückmeldung gespannt

Gruß Arduino4Fun

Code:

// -----------------------------------------
// WLAN/MQTT Framework, 31.12.2020 für ESP32
// -----------------------------------------

#include <WiFi.h>
#include <WiFiClient.h>
#include <PubSubClient.h>

#define LCD_DISPLAY_AVAIL 1

#if ( LCD_DISPLAY_AVAIL == 1 )
  #include <LiquidCrystal_I2C.h>
  LiquidCrystal_I2C LCD_Display( 0x27,16,2 );
#endif

int16_t iPressure = 0;
float   fTemp     = 0.0;
int16_t iTime     = 0;

// ----- BEGIN ERROR Handling -----
uint16_t  uiSYS_Error = 0x00;

#define SYS_ERROR_BIT_WLAN      13      // Reserviertes Fehler Bit für WLAN
#define SYS_ERROR_BIT_MQTT      12      // Reserviertes Fehler Bit für MQTT

#define SYS_ERROR_GET_WLAN      bitRead( uiSYS_Error,SYS_ERROR_BIT_WLAN )
#define SYS_ERROR_GET_MQTT      bitRead( uiSYS_Error,SYS_ERROR_BIT_MQTT )

#define SYS_ERROR_SET_WLAN      bitSet( uiSYS_Error,SYS_ERROR_BIT_WLAN )
#define SYS_ERROR_SET_MQTT      bitSet( uiSYS_Error,SYS_ERROR_BIT_MQTT )

#define SYS_ERROR_CLEAR_WLAN    bitClear( uiSYS_Error,SYS_ERROR_BIT_WLAN )
#define SYS_ERROR_CLEAR_MQTT    bitClear( uiSYS_Error,SYS_ERROR_BIT_MQTT )
// ----- END   ERROR Handling -----

// ----- BEGIN PINS / Hardware -----
const int PIN_LED_INT =  LED_BUILTIN;
// ----- END   PINS / Hardware -----

// ----- BEGIN WLAN/MQTT Dekalaration -----
IPAddress WLAN_gateway( 192,168,178,1 );          // IP-Adresse des WLAN-Gateways
IPAddress WLAN_subnet( 255,255,255,0 );           // Subnetzmaske
IPAddress WLAN_ip( 192,168,178,245 );             // feste IP-Adresse für den WeMos

const char* WLAN_ssid   = "xxx";              // WLAN SSID
const char* WLAN_pw     = "xxx";      // WLAN Passwort
const char* MQTT_Server = "192.168.178.10";       // IP vom MQTT Server

const char* PRG_Id      = "MQTT-Framework";       // Applikationsname für WLAN und MQTT

WiFiClient      ESP_Client;
PubSubClient    MQTT_Client( ESP_Client );
// ----- END   WLAN/MQTT Dekalaration -----

// ----- BEGIN FreeRTOS einrichten ------------------------------------------
TaskHandle_t  Core_0_TaskHnd;  
TaskHandle_t  Core_1_TaskHnd;
// ----- END   FreeRTOS einrichten ------------------------------------------

// ----- BEGIN Setup, WLAN-Setup, MQTT-Setup -----
void setup()
{
  Serial.begin(115200);

  Serial.println( "" );
  Serial.println( "" );
  Serial.println( "==========================================================================" );
  Serial.println( "= My MQTT Framework                                                      =" );
  Serial.println( "==========================================================================" );
  Serial.println( "" );

  pinMode( PIN_LED_INT,OUTPUT );                  // LED auf Rechnermodul als Ausgang  

  #if ( LCD_DISPLAY_AVAIL == 1 )                  // Falls I2C LCD Display 2 zeilig, 16 Zeichen evrfügbar
    LCD_Display.begin();
    LCD_Display.backlight();
    LCD_Display.setCursor( 0,0 );
  #endif

  xTaskCreatePinnedToCore( CoreTask0,"CPU_0",10000,NULL,5,&Core_0_TaskHnd,0 );
  xTaskCreatePinnedToCore( CoreTask1,"CPU_1",10000,NULL,5,&Core_1_TaskHnd,1 );
}

// ===== BEGIN - CODE wird nur im Core 0 aufgerufen =====
void WLAN_setup( void )
{
  Serial.println( "WLAN setup" );

    // ----- BEGIN WLAN-Verbindung herstellen -----
  WiFi.mode( WIFI_STA );
  WiFi.persistent( false );                               // Verhindern, dass SSID und PW im Flash abgelegt werden
  WiFi.config( WLAN_ip,WLAN_gateway,WLAN_subnet );        // auskommentieren, falls eine dynamische IP bezogen werden soll
  WiFi.setHostname( PRG_Id );                             // Name für Netzwerk
  WiFi.begin( WLAN_ssid,WLAN_pw );                        // SSID und Passwort setzen
  // ----- END   WLAN-Verbindung herstellen -----
}

void MQTT_setup( void )
{
  Serial.println( "MQTT setup" );

  // ----- BEGIN MQTT einrichten -----
  MQTT_Client.setServer( MQTT_Server,1883 );              // MQTT Server/Port setzen
  MQTT_Client.setCallback( MQTT_Callback );               // MQTT Callback für Empfang einrichten
  // ----- END   MQTT einrichten -----
}
// ----- END   Setup, WLAN-Setup, MQTT-Setup -----

// ----- BEGIN MQTT Reconnect(), Callback(), SendData() -----
void MQTT_Reconnect( void )
{
  if( MQTT_Client.connect( PRG_Id )==false ){ SYS_ERROR_SET_MQTT; }else{ SYS_ERROR_CLEAR_MQTT; }
  
  if( SYS_ERROR_GET_MQTT==0 )
  {
    Serial.println( "MQTT connected" );

    MQTT_Client.subscribe( "HM/GardenSensorActuator/Sensor/+" );

    MQTT_SendData();                                      // Beim Reconnect gleich die Daten senden
  }
}

void MQTT_Callback( char* topic, byte* payload, unsigned int length )
{
  char    rtopic[256];
  char    rpayload[256];
  int8_t  i;
  
  strcpy( rtopic, topic);
  for( i=0;i<length; i++ )
  {
    rpayload[i] = payload[i];
  }
  rpayload[i] = '\0';

  if( strcmp( "HM/GardenSensorActuator/Sensor/iAirPressure",rtopic )==0 )
  {
    iPressure = atoi( rpayload );
  }
  if( strcmp( "HM/GardenSensorActuator/Sensor/fExternalTemperature",rtopic )==0 )
  {
    fTemp = atof( rpayload );
  }
}

void MQTT_SendData( void )
{
  char              cstr[16];
  
  if( SYS_ERROR_GET_MQTT==0 )
  {
    sprintf( cstr,"%d",iTime );
    MQTT_Client.publish( "HM/Test/Actuator/Test",cstr );

    Serial.println( "Send Data via MQTT" );         // Anzeige zum Testen
  }  
}
// ----- END   MQTT Reconnect(), Callback(), SendData() -----

// ----- BEGIN Zeitscheiben für Core 0 -----
void Core_0_Task100ms()
{
  // BEGIN ----- WLAN Verbindung prüfen -----
  if( WiFi.status()!=WL_CONNECTED ){ SYS_ERROR_SET_WLAN; }else{ SYS_ERROR_CLEAR_WLAN; }
  // END   ----- WLAN Verbindung prüfen -----
  // BEGIN ----- MQTT Verbindung prüfen -----
  if( MQTT_Client.connected()==false ){ SYS_ERROR_SET_MQTT; }else{ SYS_ERROR_CLEAR_MQTT; }
  // END   ----- MQTT Verbindung prüfen -----
}

void Core_0_Task500ms()
{
  MQTT_SendData();
}

void Core_0_Task1000ms()
{
  const  int8_t   iWLAN_TimeOut_Max  = 4;                // Werte expermientell ermittelt mit 8266/ESP32
  static int8_t   iWLAN_TimeOut      = iWLAN_TimeOut_Max;
  const  int8_t   iMQTT_TimeOut_Max  = 2;                // Werte expermientell ermittelt mit 8266/ESP32
  static int8_t   iMQTT_TimeOut      = iMQTT_TimeOut_Max;
  
  static int8_t   iWLAN_ReConnect   = 0;
  static int8_t   iMQTT_ReConnect   = 0;

  // Kein WLAN, Timeout Zähler dekrementieren
  if( SYS_ERROR_GET_WLAN != 0 ){ iWLAN_TimeOut--; }

  // Alles Gut, WLAN connected
  if( SYS_ERROR_GET_WLAN==0 )
  {
    iWLAN_TimeOut = iWLAN_TimeOut_Max;
  }

  // Wenn WLAN Timeout erreicht, Reconnect
  if( iWLAN_TimeOut==0 )
  {
    Serial.println( "WLAN try to connected" );
    WLAN_setup();
    iWLAN_ReConnect++;
    iWLAN_TimeOut = iWLAN_TimeOut_Max;
  }

  // Kein MQTT, Timeout Zähler dekrementieren
  if( SYS_ERROR_GET_MQTT != 0 ){ iMQTT_TimeOut--; }
  
  // Alles Gut, MQTT connected
  if( SYS_ERROR_GET_MQTT==0 )
  {
    iMQTT_TimeOut = iMQTT_TimeOut_Max;
  }
  
  if( iMQTT_TimeOut==0 )
  {
    Serial.println( "MQTT try to connected" );
    MQTT_Reconnect();
    iMQTT_ReConnect++;
    iMQTT_TimeOut = iMQTT_TimeOut_Max;
  }
}
// ----- END   Zeitscheiben für Core 0 -----
// ===== END   - CODE wird nur im Core 0 aufgerufen =====

// ===== BEGIN - CODE für Applikation in loop() =====
// ----- BEGIN Zeitscheiben für Arduino loop() -----
void Loop_Task100ms()
{
  // Für Aktivitäten alle 100ms  
}

void Loop_Task500ms()
{
  // Für Aktivitäten alle 500ms  

  static bool boLED_blink = false;

  digitalWrite( PIN_LED_INT,boLED_blink );  // OnBoard LED blinken

  boLED_blink = !boLED_blink;
}

void Loop_Task1000ms()
{
  // Für Aktivitäten alle 1000ms  
  iTime++;
  
  if( SYS_ERROR_GET_MQTT==0 )
  {
    Serial.print( "Time : " );
    Serial.print( iTime );

    Serial.print( " | " );

    Serial.print( "Luftdruck : " );
    Serial.print( iPressure );
    Serial.print( " mbar" );

    Serial.print( " | " );

    Serial.print( "Temperatur : " );
    Serial.print( fTemp );
    Serial.println( " °C" );

    #if ( LCD_DISPLAY_AVAIL == 1 )
      LCD_Display.setCursor( 0,0 );
      LCD_Display.print( "Zeit:" );
      LCD_Display.print( iTime );
      LCD_Display.print( "sek" );
    #endif
  }
}
// ----- END   Zeitscheiben für Arduino loop() -----
// ===== END   - CODE für Applikation in loop() =====

// ----- BEGIN Loop für Arduino/Core 0 und Core 1 -----
const uint32_t  TimeBase100   =   100UL;
const uint32_t  TimeBase500   =   500UL;
const uint32_t  TimeBase1000  =  1000UL;

void CoreTask0( void * parameter )
{
  SYS_ERROR_SET_WLAN;                             // Fehler setzen bis zur Gut-Prüfung
  SYS_ERROR_SET_MQTT;                             // Fehler setzen bis zur Gut-Prüfung
  
  WLAN_setup();                                   // WLAN erstmalig einrichten/aktivieren
  MQTT_setup();                                   // MQTT erstmalig einrichten/aktivieren

  for ( ;; )
  {
    static uint32_t TimeLastMillis100;
    static uint32_t TimeLastMillis500;
    static uint32_t TimeLastMillis1000;
  
    if( ( millis()-TimeLastMillis100 )  >TimeBase100 )   { TimeLastMillis100   += TimeBase100;   Core_0_Task100ms();   }
    if( ( millis()-TimeLastMillis500 )  >TimeBase500 )   { TimeLastMillis500   += TimeBase500;   Core_0_Task500ms();   }
    if( ( millis()-TimeLastMillis1000 ) >TimeBase1000 )  { TimeLastMillis1000  += TimeBase1000;  Core_0_Task1000ms();  }
  
    if( SYS_ERROR_GET_MQTT==0 )
    {
      MQTT_Client.loop();
    }
    
    vTaskDelay(1);
  }
}

void CoreTask1( void * parameter )
{
  for ( ;; )
  {
    vTaskDelay(1);
  }
}


void loop()
{
  static uint32_t TimeLastMillis100;
  static uint32_t TimeLastMillis500;
  static uint32_t TimeLastMillis1000;

  if( ( millis()-TimeLastMillis100 )  >TimeBase100 )   { TimeLastMillis100   += TimeBase100;   Loop_Task100ms();   }
  if( ( millis()-TimeLastMillis500 )  >TimeBase500 )   { TimeLastMillis500   += TimeBase500;   Loop_Task500ms();   }
  if( ( millis()-TimeLastMillis1000 ) >TimeBase1000 )  { TimeLastMillis1000  += TimeBase1000;  Loop_Task1000ms();  }
}
// ----- END   Loop für Arduino/Core 0 und Core 1 -----

[Arduino4Fun]

Hallo,

habe jetzt das Testprogramm, siehe oben ca. 4,5 Stunden fehlerfrei am laufen. Ohne Verschiebung des WLAN/MQTT Anteil in Core 0 blieb der Rechner nach ca. 5 min erstmalig hängen.
Meine beiden "portierten" Applikationen laufen nun auch komplett stabil. Scheint tatsächlich ein Problem der verteilten SW auf den Cores zu sein - Fokus WLAN.

Gruß Arduino4Fun

[nbk83]

(31.12.2020 14:17)Arduino4Fun schrieb:  Hallo,

anbei mein WLAN/MQTT Test Code für ESP32 zur Diskussion ...

Moin und Danke,
ich wollte schon fragen, ob Du das mal zur Verfügung stellen könntest
Ich werde das mal durchsehen, versuchen zu verstehen und dann mal meine Wetterstation auf Basis dieses Ansatzes aufbauen. Ich melde mich dann mit Ergebnissen.
Hab ich das jetzt richtig verstanden, dass der Trick an der Sache darin besteht, einen der beiden Kerne gar nicht zu nutzen?

Zitat:...die unabhängig voneinander z.T. auf unterschiedlichen CPU’s laufen, sich dennoch aber eine Ressource (den COM Port des ESP‘s) teilen. Da grundsätzlich die Tasks nichts voneinander „wissen“ und somit auch nicht, wann eine Ressource von einem anderen Task belegt oder verändert wird., kann es hier zu Kollisionen kommen...

Grüße und gleich einen guten Rutsch!
Jan