UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?

[marcuskl]

@HomeZecke sagte in [Tutorial] PZEM-004T 3 Phasen Überwachung:

Ist es eigentlich möglich die Kabel an den Stromwandlern zu verlängern? Ich möchte das ganze in einem Extra Kasten installieren. Und wie wird aus den drei Messgeräten der Gesamtwert berechnet, (Leistung und Stromstärke) Einfach addiert?

Grüße...

Ja kannste verlängern, hab ich auch, halt net übertreiben mit dem verlängern.
Ich habe die vielleicht um 10 cm verlängert.

Kannste einfach addieren.

[HomeZecke]

So...

für alle die auch an einer Realisierung interessiert sind möchte ich meine Erfahrung nach erfolgreicher Umsetzung mitteilen.

• Ich rate zu PZEM-Modulen mit Split-Core-Messwandlern. Die haben den Vorteil, dass die Hauptdrähte der Verteileung nicht abgeklemmt werden müssen. Außerdem verhindert man dadurch, dass gefährliche Spannungen (@marcuskl - Danke für diesen wichtigen Hinweis!) an den Messwandlern wenn diese erst bei fertiger Installation um die Drähte gelegt werden. Einen Nachteil gibt es jedoch. Die Rastnase und das Gelenk brechen leicht ab. Bei mir ist bei einem die Rastnase und bei einem das Gelenk abgerissen. Das ist jedoch mit einem Kabelbinder in Sekunden gefixt! Im Gegenteil, ein Messwandler konnte ich sogar nur so um den doch sehr starken Draht kriegen. Die PZEM-Modulen mit Split-Core-Messwandlern kriegt man im Moment für unter 10 Euro sogar bei den "Wilden Weibern"

• Die Drähte an den Messwandlern habe ich test-weise auf 100 cm verlängert. Ich konnte keine Messabweichungen feststellen. Das sollte für die meisten Anwendungsfälle reichen.

• Ich habe für die Befestigung der Module auf der Hutschiene Feuchtraum-Installationsdosen aus dem Baumarkt "bei dem es immer was tun gibt" genommen. Es gibt dort welche da passt der PZEM rein als ob es dafür gemacht wurde! Und kosten nur ein paar cent das Stück. Zwei Löcher hinten reingebohrt und mit Kabelbinder an die Hutschiene- Fertig!

• Wie im Tutorial beschrieben, ist jedes PZEM-Modul an die zu messende Phase anzuschließen. Aber auch der zur Phase gehörende Nullleiter ist zu nutzen. Ich weiß nicht ob es sonst zu Messfehlern kommen kann, aber der FI-Schalter könnte auslösen, wenn ein "falscher" nicht zur jeweiligen Phase gehörender Nullleiter benutzt wird.

• Ich habe mir eine eigene Firmware für den Wemos geschrieben, da ich bis jetzt ohne Tasmota-Adapter in IOBroker ausgekommen bin und jetzt nur für die Strommessung keinen installieren wollte. Der Wemos mini hat genug Pin-Eingänge um 3 PZEM's zu betreiben. Das ganze geht bei mir über SoftwareSeriel. Damit kann jeder Serielle Ausgang der PZEM's direkt an den Wemos angeschlossen und ausgewertet werden.
  Mir missfiel das Master/Slave-system und das damit nötige Port-Ändern in der Tasmota-Version. Außerdem brauche ich dadurch keine zus. Dioden und Widerstände.

• DAS WICHTIGSTE! Hochspannung! Ich weiß es nervt. Aber im Installationsschrank sind 3Phasen Wechselstrom. Zwischen den Phasen liegen 400 V Spannung! Wenn man nicht weiß, was man da tut, oder sich auch nur ein wenig unsicher ist. Unbedingt sein lassen! Auch der Hinweis ist nötig, dass man das als Leihe gar nicht darf. Und zugelassen ist der Eibau der PZEM's in den Verteilerkasten sicher auch nicht.

Wen das dann alles nicht abhalten kann, so kann es dann in Vis aussehen:

Grüße...

[swobx]

Hallo,

bin auch gerade dabei für eine Schneekanone eine Phasenüberwachung zu realisieren.

Habe jetzt mal angefangen mit einem Modul. Leide bekomme ich keine Verbindung zusammen.
Die 230V LED leuchtet, je nachdem auf welcher Seite ich RX/TX anschließe blinkt die linke oder rechte LED auf der anderen Seite.

Habe jetzt schon sämtliche Varianten probiert. Mit/Ohne Wiederstand, mit/ohne Diode in beide Richtungen gedreht. Spannungsversorgung über Wemos/externes Netzteil. Und trotzdem blinkt immer nur eine LED und es kommen keine Daten bei Tasmota an.

Wenn ich die Tasmota Vorlage verwende bekomme ich auch keine blinkende LED. Das funktioniert nur wenn ich RX/TX manuell in den Einstellungen eintrage. Aber eben auch nur auf einer Seite.

Habe sonst alles wie in der Anleitung gemacht.
Die Hersteller-Software kann ich leider nicht ausprobieren weil mir das Kabel fehlt.

Habt ihr evtl. noch eine Idee wo der Hund begraben sein könnte?

Danke für eure Hilfe
LG Fabian

[SBorg]

@swobx Im Grunde ist das mit/ohne Widerständen und Dioden etc. nur ein Gemurkse. Man kommt zwar iaR. damit auf ein funktionsfähiges Ergebnis, aber korrekt muss das noch lange nicht sein. Oft hat man einfach Glück, weil sich dann dank Toleranzen ein stabiler Zustand einstellt.
Schaut man sich die Spezifikationen an, so hat der RX/TX vom Modul 5 Volt, ein ESP "mag" nur 3.3 Volt. Ohne weiteres Gebastel würde ich daher einfach zu einem bidirektionalem Level Shifter raten. Damit funktioniert es zuverlässig und kostet zB. beim Ali <2,- €

[OpenSourceNomad]

@SBorg said in [Tutorial] PZEM-004T 3 Phasen Überwachung:

der RX/TX vom Modul 5 Volt, ein ESP "mag" nur 3.3 Volt

Ersteres ist korrekt, zweites nicht.

Quelle: CEO von espressif und ich kann das mit mehrjährigen Tests/Anwendungen zu 100% bestätigen

Betreibe alle meine pzem's direkt mit esp's ohne irgendwelchen Quark und die Ergebnisse korrelieren zu 100% mit meinem Energieversorger. Soviel dazu ;)

@swobx said in [Tutorial] PZEM-004T 3 Phasen Überwachung:

Habe jetzt mal angefangen mit einem Modul. Leide bekomme ich keine Verbindung zusammen.

Welche Version des pzem004t hast du denn? Es gibt mindestens drei verschiedene (v1, v2, v3). Kannst ja mal esphome anwerfen, da hast du dann auch gleich ein aussagekräftiges logging. Für v1+v2 ist es die pzem004t Komponente, für die v3 die pzemac.

[swobx]

Hallo,

danke für die Tipps, werde das mit ESP Home probieren, habe die V3 der PZEMs.
Das heißt den Widerstand und die Diode kann ich weglassen uns direkt mit dem Wemos verbinden?

[OpenSourceNomad]

@swobx said in [Tutorial] PZEM-004T 3 Phasen Überwachung:

Das heißt den Widerstand und die Diode kann ich weglassen uns direkt mit dem Wemos verbinden?

Wenn du einen pzem verbindest brauchst du nichts. Willst du mehrere verbinden ist mindestens der Widerstand auf TX nötig (siehe Zeichnung im ersten Post).

[manrum1]

Hallo, ich habe mir bis auf die Widerstände und Dioden alles besorgt und mal Testweise einen PZEM angeschlossen. Leider bekomme ich keine Werte und noch schlimmer: Der WEMOS setzt sich nach ca. einer Minute komplett zurück.
Das Ganze passiert nur dann, wenn ich die Template Konfiguration {"NAME":"Pzem-004t Gate","GPIO":[255,62,56,98,255,255,255,255,255,255,122,255,255],"FLAG":15,"BASE":18} vorgenommen habe. Auch ohne angeschlossenen PZEM setzt er sich nach Übernahme der Template Konfiguration nach ca. 1 min zurück.

Als Generic läuft der WEMOS ohne Probleme.

Ich hoffe mir kann jemand helfen - was tun?

[manrum1]

[Basti97]

Cool Danke werde es demnächst auch mal ausprobieren. Welche Größe hast du beim Widerstand genommen?

[manrum1]

@manrum1 Gelöst: Button rausgenommen, warum auch immer aber hat wohl den Reset ausgelöst.

[manrum1]

Template: {"NAME":"PZEM-004T","GPIO":[255,62,56,98,255,255,255,255,255,255,255,255,255],"FLAG":15,"BASE":18}

[manrum1]

oder per Generic (18):

[elektrickser.de]

@HomeZecke

Tolle Arbeit mit deiner Visu. Könntest du diese zur Verfügung stellen? Ich würde diese gerne in meiner Visu nutzen.

Gruß Elektrickser

[NinjaTurtle85]

Kann ich die PZEM-004T nicht ohne wiederstände einzeln an eine NodeMCU anschließen ohne das ganze in Reihe zu schalten?
Wenn ja was muss ich bei Generic (18) einstellen? Es gibt dort 3x Rx und nur 1x Tx.

[manrum1]

@NinjaTurtle85 Nein, das geht leider nicht. Schau die folgendes mal an: https://forum.iobroker.net/topic/28453/tutorial-pzem-004t-3-phasen-überwachung

[OpenSourceNomad]

@NinjaTurtle85 said in [Tutorial] PZEM-004T 3 Phasen Überwachung:

Kann ich die PZEM-004T nicht ohne wiederstände einzeln an eine NodeMCU anschließen ohne das ganze in Reihe zu schalten?

Sollte problemlos an einem ESP32 NodeMCU funktionieren, da dieser drei paar hardware UARTs hat

The ESP32 has three UARTs. Any pair of GPIO pins can be used, as long as they support the proper output/input modes.

https://esphome.io/components/uart.html#hardware-uarts

Und mittels software UART sollte das eigentlich auch einem esp8266 (z.B. dem klassischen NodeMCU) funktionieren wenn du genügen pins frei hast.

[HomeZecke]

@elektrickser-de sagte in [Tutorial] PZEM-004T 3 Phasen Überwachung:

@HomeZecke

Tolle Arbeit mit deiner Visu. Könntest du diese zur Verfügung stellen? Ich würde diese gerne in meiner Visu nutzen.

Gruß Elektrickser

Klar, gerne.

strom_view.txt

Grüße...

[HomeZecke]

Hallo,

da es Nachfragen wegen der von mir erstellten Firmware gab, habe ich sie hier veröffentlicht. Folgendes gibt es zu beachten:

1. Ich hafte nicht für Schäden die durch Benutzung meiner Software entstehen könnten! Nutzung auf eigene Gefahr!
2. Ich biete nur bedingt support! (Je nach Laune und Zeit:grin: )
3. Veränderungen am Quellcode können gerne vorgenommen und hier veröffentlicht werden

Kurzanleitung:

Es gibt keine Konfigurationsmöglichkeit. Die Daten für das eigene Netzwerk müssen im Quellcode angegeben werden. Benötigt werden die SSID das Passwort und die IP des MQTT Brokers. Eine neue Firmware kann über OTA geflasht werden, um den Wemos nicht immer wieder ausbauen zu müssen. Über "http://pzem-webupdate.local/update" sollte das gehen.
Angeschlossen werden die RX und TX Anschlüsse der PZEMs an folgende Pins (Wemos mini!):
PZEM 1 D1,D2
PZEM 2 D4,D3
PZEM 3 D5,D6
An D7 kann eine Status LED angeschlossen werden. Die signalisiert den Verbindungsaufbau zum Wlan und bzw Broker.

Nach dem Flashen und Starten gibt es unter IOBroker MQTT den neuen Datenpunkt "ENERGIE" Dort gibt es dann alle Daten zu jeder Phase und die Gesamtwerte. Die einzigen Werte die man ändern kann sind "PZEM-Reset" und "Verbrauchs-Startwert"

PZEM-Reset : Wird dieser auf true gesetzt, wird der Energiezähler aller 3 PZEM-Module auf 0 gesetzt.
Verbrauchs-Startwert: Hier kann der aktuelle Zählerstand des "echten" Hausstromzählers angegeben werden. Damit kann man den Datenpunkt "PZEM-Verbrauch" mit dem Hauszähler synchronisieren.

Viel Spaß!

//####################################################################################
//####################################################################################
//
//    PZEM Energiemessgeräterfassung mit WEMOS  von HomeZecke   v1.1 stand 30.03.2020
//    --------------------------------------------------------------------------
//     v 1.0      Testphase first release 			          -05.03.2020
//     v 1.1      Zählerstartwert kann festgelegt werden 		  -30.03.2020			
//				 
//     ToDo:      Online Config für Wlan / MQTT usw. hinzuf.
//
//     	
//			  
//####################################################################################
//####################################################################################

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <ESP8266HTTPUpdateServer.h>
#include <Ticker.h>
#include <PubSubClient.h>
#include <PZEM004Tv30.h>

//Hier die persönlichen Daten eintragen!
//---------------------------------------------
const char* SSID = "WLAN-SSID";
const char* PSK =  "PASSWORT";
const char* MQTTserver = "192.168.0.0";
const uint16_t port = 1883;
//---------------------------------------------
const char* version = "Version 1.1";
const char* host = "PZEM-webupdate";
const int STATUS_LED = 13;  //D7 (Wemos D1 Mini)

float start_verbrauch = 0;
float diff_verbrauch = 0;
float old_spannung_pzem1;
float old_frequenz_pzem1;
float old_stromstaerke_pzem1;
float old_verbrauch_pzem1;
float old_leistung_pzem1;
float old_pf_pzem1;
float old_spannung_pzem2;
float old_frequenz_pzem2;
float old_stromstaerke_pzem2;
float old_verbrauch_pzem2;
float old_leistung_pzem2;
float old_pf_pzem2;
float old_spannung_pzem3;
float old_frequenz_pzem3;
float old_stromstaerke_pzem3;
float old_verbrauch_pzem3;
float old_leistung_pzem3;
float old_pf_pzem3;
float old_spannung_gesamt;
float old_stromstaerke_gesamt;
float old_leistung_gesamt;
float old_verbrauch_gesamt;
float old_frequenz_gesamt;
float old_pf_gesamt;
float old_PZEM_verbrauch;


//---functions / callbacks
void MQTTcallback(char* topic, byte* payload, unsigned int length);
void pzem_reset();
void pzem_read();
void set_counter(float counterStart);


//-Klassen definieren
ESP8266WebServer httpServer(80);
ESP8266HTTPUpdateServer httpUpdater;

WiFiClient MY_NETClient_1;
PubSubClient MQTTClient(MY_NETClient_1);

Ticker myTimer1(pzem_read,5000); //Wie oft sollen die Daten aktualisiert werden? (alle 5 Sek.)

PZEM004Tv30 pzem_1(5, 4);    //D1,D2  Wemos D1 Mini L1
PZEM004Tv30 pzem_2(2, 0);    //D4,D3                             L2
PZEM004Tv30 pzem_3(14, 12);  //D5,D6                             L3 


//=======================================================================================================================
//MQTT CallBack
//=======================================================================================================================
void MQTTcallback(char* topic, byte* payload, unsigned int length)
{
 
  char my_payload[length+1];  // nen string machen, länge eins mehr wegen nullterminierung
  float counter_start;
  
  Serial.print(topic);
  Serial.print(" : ");
  
  // Topic PZEMreset----------------------------------------------------------------------------------------
  if (strcmp(topic,"Energie/PZEM-Reset") == 0 )
      {
        
          for (unsigned int i = 0; i < length; i++)  // jedes einzelne byte in einen buchstaben umwandeln
            {              
               my_payload[i] = (char)payload[i];   // (char)100 wäre zb ein "d"
            };

          my_payload[length] = '\0';              // nullterminierung
          Serial.println(my_payload);
          
          if (strcmp(my_payload,"true") == 0)
            {
                pzem_reset();                //Energie an den PZEM's resetten
            }
        
      }

  // Topic Verbrauchs-Startwert------------------------------------------------------------------------------
  if (strcmp(topic,"Energie/Verbrauchs-Startwert") == 0 )
      {
        
          for (unsigned int i = 0; i < length; i++)  // jedes einzelne byte in einen buchstaben umwandeln
            {              
               my_payload[i] = (char)payload[i];   // (char)100 wäre zb ein "d"
            };

          my_payload[length] = '\0';              // nullterminierung
          Serial.println(my_payload);
          counter_start = atof(my_payload);    // nen float aus der payload machen
          
          if (counter_start != start_verbrauch)
            {
              start_verbrauch = counter_start;
              set_counter(counter_start); // func set_couter zum setzen aufrufen
            }

         

        
      }      

}

//=======================================================================================================================
//WLan -Verbindung aufbauen
//=======================================================================================================================
void initWiFi()
{

    Serial.println("");
    Serial.print("Wifi connect...");
    WiFi.begin(SSID, PSK);

    while (WiFi.status() != WL_CONNECTED)
      {
        digitalWrite(STATUS_LED,!digitalRead(STATUS_LED));
        Serial.print(".");   
        delay(700);
      };

    Serial.print("Verbunden!");
    WiFi.mode(WIFI_STA);

}



//=======================================================================================================================
//MQTT -Verbindung aufbauen
//=======================================================================================================================
void initMQTT(){

   
    MQTTClient.setServer(MQTTserver,port);
    MQTTClient.setCallback(MQTTcallback);

    Serial.println("");
    Serial.print("MQTT verbinden...");

    //--Verbindungsloop
    while( !MQTTClient.connect("Energie_PZEM") ) 
      {
        digitalWrite(STATUS_LED,!digitalRead(STATUS_LED));
        Serial.print("*");  
        delay(100);
      };

    digitalWrite(STATUS_LED,false);   
    Serial.print("MQTT ist verbunden!"); 

    //--Topics abbonieren---------------------------------------------------- 
    if (MQTTClient.subscribe("Energie/PZEM-Reset"))
      {
            Serial.println("MQTT : Energie: Reset aboniert"); 
      };

    if (MQTTClient.subscribe("Energie/Verbrauchs-Startwert"))
      {
            Serial.println("MQTT : Energie/Verbrauchs-Startwert aboniert"); 
      }; 
}



//=======================================================================================================================
//PZEM Module auslesen und publishen
//=======================================================================================================================
void pzem_read(){

  float spannung_gesamt;
  float stromstaerke_gesamt;
  float leistung_gesamt;
  float verbrauch_gesamt;
  float frequenz_gesamt;
  float pf_gesamt;
  float PZEM_verbrauch = 0;

  float spannung_pzem1 = pzem_1.voltage();
	float stromstaerke_pzem1 = pzem_1.current();
	float leistung_pzem1 = pzem_1.power();
	float verbrauch_pzem1 = pzem_1.energy();
	float frequenz_pzem1 = pzem_1.frequency();
	float pf_pzem1 = pzem_1.pf();
	
	float spannung_pzem2 = pzem_2.voltage();
	float stromstaerke_pzem2 = pzem_2.current();
	float leistung_pzem2 = pzem_2.power();
	float verbrauch_pzem2 = pzem_2.energy();
	float frequenz_pzem2 = pzem_2.frequency();
	float pf_pzem2 = pzem_2.pf();
	
	float spannung_pzem3 = pzem_3.voltage();
	float stromstaerke_pzem3 = pzem_3.current();
	float leistung_pzem3 = pzem_3.power();
	float verbrauch_pzem3 = pzem_3.energy();
	float frequenz_pzem3 = pzem_3.frequency();
	float pf_pzem3 = pzem_3.pf();	

 // char* Temp_String = "           ";
  char Temp_String[12];

  if(!isnan(spannung_pzem1) && old_spannung_pzem1 != spannung_pzem1)
    { 
      dtostrf(spannung_pzem1,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L1/SpannungL1", Temp_String);
      old_spannung_pzem1 = spannung_pzem1;
    }

  if(!isnan(spannung_pzem2) && old_spannung_pzem2 != spannung_pzem2)
    { 
      dtostrf(spannung_pzem2,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L2/SpannungL2", Temp_String);
      old_spannung_pzem2 = spannung_pzem2;
    }

  if(!isnan(spannung_pzem3) && old_spannung_pzem3 != spannung_pzem3)
    { 
      dtostrf(spannung_pzem3,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L3/SpannungL3", Temp_String);
      old_spannung_pzem3 = spannung_pzem3;
    }

  if(!isnan(stromstaerke_pzem1) && old_stromstaerke_pzem1 != stromstaerke_pzem1)
    { 
      dtostrf(stromstaerke_pzem1,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L1/StromstaerkeL1", Temp_String);
      old_stromstaerke_pzem1 = stromstaerke_pzem1;
    }

  if(!isnan(stromstaerke_pzem2) && old_stromstaerke_pzem2 != stromstaerke_pzem2)
    { 
      dtostrf(stromstaerke_pzem2,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L2/StromstaerkeL2", Temp_String);
      old_stromstaerke_pzem2 = stromstaerke_pzem2;
    }

  if(!isnan(stromstaerke_pzem3) && old_stromstaerke_pzem3 != stromstaerke_pzem3)
    { 
      dtostrf(stromstaerke_pzem3,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L3/StromstaerkeL3", Temp_String);
      old_stromstaerke_pzem3 = stromstaerke_pzem3;
    }

  if(!isnan(leistung_pzem1) && old_leistung_pzem1 != leistung_pzem1)
    { 
      dtostrf(leistung_pzem1,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L1/LeistungL1", Temp_String);
      old_leistung_pzem1 = leistung_pzem1;
    }

  if(!isnan(leistung_pzem2) && old_leistung_pzem2 != leistung_pzem2)
    { 
      dtostrf(leistung_pzem2,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L2/LeistungL2", Temp_String);
      old_leistung_pzem2 = leistung_pzem2;
    }

  if(!isnan(leistung_pzem3) && old_leistung_pzem3 != leistung_pzem3)
    { 
      dtostrf(leistung_pzem3,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L3/LeistungL3", Temp_String);
      old_leistung_pzem3 = leistung_pzem3;
    }

  if(!isnan(verbrauch_pzem1) && old_verbrauch_pzem1 != verbrauch_pzem1)
    { 
      dtostrf(verbrauch_pzem1,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L1/VerbrauchL1", Temp_String);
      old_verbrauch_pzem1 = verbrauch_pzem1;
    }

  if(!isnan(verbrauch_pzem2) && old_verbrauch_pzem2 != verbrauch_pzem2)
    { 
      dtostrf(verbrauch_pzem2,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L2/VerbrauchL2", Temp_String);
      old_verbrauch_pzem2 = verbrauch_pzem2;
    }

  if(!isnan(verbrauch_pzem3) && old_verbrauch_pzem3 != verbrauch_pzem3)
    { 
      dtostrf(verbrauch_pzem3,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L3/VerbrauchL3", Temp_String);
      old_verbrauch_pzem3 = verbrauch_pzem3;
    }

  if(!isnan(frequenz_pzem1) && old_frequenz_pzem1 != frequenz_pzem1)
    { 
      dtostrf(frequenz_pzem1,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L1/FrequenzL1", Temp_String);
      old_frequenz_pzem1 = frequenz_pzem1;
    } 

  if(!isnan(frequenz_pzem2) && old_frequenz_pzem1 != frequenz_pzem2)
    { 
      dtostrf(frequenz_pzem2,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L2/FrequenzL2", Temp_String);
      old_frequenz_pzem2 = frequenz_pzem2;
    } 

  if(!isnan(frequenz_pzem3) && old_frequenz_pzem3 != frequenz_pzem3)
    { 
      dtostrf(frequenz_pzem3,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L3/FrequenzL3", Temp_String);
      old_frequenz_pzem3 = frequenz_pzem3;
    } 

 if(!isnan(pf_pzem1) && old_pf_pzem1 != pf_pzem1)
    { 
      dtostrf(pf_pzem1,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L1/PowerFactorL1", Temp_String);
      old_pf_pzem1 = pf_pzem1;
    }  

 if(!isnan(pf_pzem2) && old_pf_pzem2 != pf_pzem2)
    { 
      dtostrf(pf_pzem2,5 , 2, Temp_String);
      MQTTClient.publish ("Energie/L2/PowerFactorL2", Temp_String);
      old_pf_pzem2 = pf_pzem2;
    }   

 if(!isnan(pf_pzem3) && old_pf_pzem3 != pf_pzem3)
  { 
    dtostrf(pf_pzem3,5 , 2, Temp_String);
    MQTTClient.publish ("Energie/L3/PowerFactorL3", Temp_String);
    old_pf_pzem3 = pf_pzem3;
  }


 if(!isnan(spannung_pzem1) && !isnan(spannung_pzem2) && !isnan(spannung_pzem3))
  {
    spannung_gesamt = (spannung_pzem1 + spannung_pzem2 + spannung_pzem3) / 3   ;
  }
 else
  {
    spannung_gesamt = 0;
  }
     
 
 if(!isnan(stromstaerke_pzem1) && !isnan(stromstaerke_pzem2) && !isnan(stromstaerke_pzem3))
  {
    stromstaerke_gesamt = stromstaerke_pzem1 + stromstaerke_pzem2 + stromstaerke_pzem3 ;
  }
 else
  {
    stromstaerke_gesamt = 0;
  } 

 if(!isnan(leistung_pzem1) && !isnan(leistung_pzem2) && !isnan(leistung_pzem3))
  {
    leistung_gesamt = leistung_pzem1 + leistung_pzem2 + leistung_pzem3 ;
  }
 else
  {
    leistung_gesamt = 0;
  } 

 if(!isnan(verbrauch_pzem1) && !isnan(verbrauch_pzem2) && !isnan(verbrauch_pzem3))
  {
    verbrauch_gesamt = verbrauch_pzem1 + verbrauch_pzem2 + verbrauch_pzem3 ;
    PZEM_verbrauch   = verbrauch_gesamt;
    verbrauch_gesamt = start_verbrauch + verbrauch_gesamt - diff_verbrauch;
  }
 else
  {
    verbrauch_gesamt = 0;
  }

 if(!isnan(frequenz_pzem1) && !isnan(frequenz_pzem2) && !isnan(frequenz_pzem3))
  {
    frequenz_gesamt = (frequenz_pzem1 + frequenz_pzem2 + frequenz_pzem3) / 3;
  }
 else
  {
    frequenz_gesamt = 0;
  } 

 if(!isnan(pf_pzem1) && !isnan(pf_pzem2) && !isnan(pf_pzem3))
  {
    pf_gesamt = (pf_pzem1 + pf_pzem2 + pf_pzem3) / 3 ;
  }
 else
  {
    pf_gesamt = 0;
  }    

  if (old_spannung_gesamt != spannung_gesamt)
    {
      dtostrf(spannung_gesamt,5 , 2, Temp_String);
      MQTTClient.publish("Energie/Spannung",Temp_String);  
      old_spannung_gesamt = spannung_gesamt;
    }

  if (old_stromstaerke_gesamt != stromstaerke_gesamt)
    {
      dtostrf(stromstaerke_gesamt,5 , 2, Temp_String);
      MQTTClient.publish("Energie/Stromstaerke",Temp_String);
      old_stromstaerke_gesamt = stromstaerke_gesamt;  
    }
  
  if (old_leistung_gesamt != leistung_gesamt)
    {
      dtostrf(leistung_gesamt,5 , 2, Temp_String);
      MQTTClient.publish("Energie/Leistung",Temp_String);    
      old_leistung_gesamt = leistung_gesamt;  
    }

  if (old_verbrauch_gesamt != verbrauch_gesamt)
    {
      dtostrf(verbrauch_gesamt,5 , 2, Temp_String);
      MQTTClient.publish("Energie/Verbrauch",Temp_String); 
      old_verbrauch_gesamt = verbrauch_gesamt;     
    } 

  if (old_frequenz_gesamt != frequenz_gesamt)
    {
      dtostrf(frequenz_gesamt,5 , 2, Temp_String);
      MQTTClient.publish("Energie/Frequenz",Temp_String);
      old_frequenz_gesamt = frequenz_gesamt;      
    } 
 
  if (old_pf_gesamt != pf_gesamt)
    {
      dtostrf(pf_gesamt,5 , 2, Temp_String);
      MQTTClient.publish("Energie/PowerFactor",Temp_String); 
      old_pf_gesamt = pf_gesamt;     
    } 

  if (old_PZEM_verbrauch != PZEM_verbrauch)
  {
      dtostrf(PZEM_verbrauch,5 , 2, Temp_String);
      MQTTClient.publish("Energie/PZEM-Verbrauch",Temp_String); 
      old_PZEM_verbrauch = PZEM_verbrauch; 
  }
     

  digitalWrite(STATUS_LED,true);
  delay(50);
  digitalWrite(STATUS_LED,false);  

};



//=======================================================================================================================
//Energieverbrauch in pzem Modulen zurücksetzen
//=======================================================================================================================
void pzem_reset()
{

  myTimer1.pause();
  Serial.println("Energieverbrauch wird zurückgesetzt..!");
  
  pzem_1.resetEnergy();
	pzem_2.resetEnergy();
	pzem_3.resetEnergy();
  delay(1000);
  
  MQTTClient.publish("Energie/PZEM-Reset","false");
  myTimer1.resume();
	
}


//=======================================================================================================================
//Startwert für Verbrauchszähler setzen
//=======================================================================================================================
void set_counter(float counterStart){

  myTimer1.pause();
  
  float verbrauch_pzem1 = pzem_1.energy();
  float verbrauch_pzem2 = pzem_2.energy();
  float verbrauch_pzem3 = pzem_3.energy();

  float verbrauch_gesamt = verbrauch_pzem1 + verbrauch_pzem2 + verbrauch_pzem3;
  diff_verbrauch = verbrauch_gesamt;

  myTimer1.resume();



}

// #####################################################################################################
// #####################################################################################################
// Die SETUP Routine
// #####################################################################################################
// #####################################################################################################
void setup()
{

  pinMode(STATUS_LED,OUTPUT);
  digitalWrite(STATUS_LED,LOW);
  
  Serial.begin(9600);
  delay(100);
  Serial.println("");
  Serial.println("PZEM 3-Phasen-Reader");  
  
  Serial.println(version);
  Serial.println("");

  initWiFi();
  initMQTT();

  MQTTClient.publish("Energie/Info",version);


  //--OTA Over the Air update einrichten
  MDNS.begin(host);
  httpUpdater.setup(&httpServer);
  httpServer.begin();
  MDNS.addService("http", "tcp", 80);
  Serial.printf("HTTPUpdateServer ready! Open http://%s.local/update in your browser\n", host);
  
 
  //--Timer für PZEM lesen und senden starten
  myTimer1.start();
 
}


// #####################################################################################################
// #####################################################################################################
// Die Haupt-  LOOP Routine
// #####################################################################################################
// #####################################################################################################
void loop(){

  //--Wifi verloren? dann neu aufbauen
  if (WiFi.status() != WL_CONNECTED)
    {
      initWiFi();
    };

  //--MQTT Verbindung verloren? dann neu aufbauen
  if (MQTTClient.state() != MQTT_CONNECTED) 
    {
      initMQTT();
    };

  MQTTClient.loop();
  httpServer.handleClient();
  MDNS.update();
  myTimer1.update();


  delay(10);



}

[spaceduck]

Hallo,

bei mir wirft der Compiler einen Fehler bei: Ticker myTimer1(pzem_read,5000);
Frage: Welche ticker.h lib verwendest Du? Die mit dem ESP8266 Boardverwalter Paket mitkommt oder was anderes?

Danke...