[Tutorial] PZEM-004T 3 Phasen Überwachung

Lenny.CB

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

@Lenny-CB es wird für jede Phase ein eigener Datenpunkt erstellt

na das passt ja schon mal. Wollte auch grad mit nem ESP32 probieren, da ich kein BAT43 Diosen da habe... Müsste ja dann bei dem auch so sein.

EDIT: offensichtlich funktioniert das mit dem ESP32 noch nicht. Fehlt sicher noch etwas, weil Alpha.
Die Module (RxTx) kann ich den GPIOs zuordnen, die Kommunikation stimmt nicht. Alle Werte bleiben 0.
Hmmm...

backfisch88

Also ich habe jetzt das ganze auch gebaut. Mit dem esp8266 und den pzem mit Gehäuse.

Klappt auch „okay“

Ich hab immer wieder das Problem, dass nacheinander die Module ausfallen. Also zeigen einfach 0 an. Und dann gehts im Wechsel reihum jeder darf mal 0 anziehen.

Jemand ne Idee warum?
Wenn man neu startet gehts wieder ein paar Minuten. Aber so richtig die Lösung ist das nicht

OpenSourceNomad

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

Und dann gehts im Wechsel reihum jeder darf mal 0 anziehen.

Klassische Null Nummer

Zwei Dinge:

1.) Wie sieht dein Hardwareaufbau aus?
2.) Schon mal mit einer anderen Firmware probiert/getestet? Esphome, Espurna, ...

Am besten gleich ein esphome drauf werfen und den logger bereits auf debug stellen. Wenn das Verhalten reproduzierbar ist, solltest du gleich den Grund dafür im Log (mqtt, web_server oder serial) lesen können.

backfisch88

@OpenSourceNomad

Hardwareaufbau so wie oben beschrieben

Also 5V dran tx rx mit Diode und Widerstand.

Auf 230V Seite jeweils mit 2A abgesichert

backfisch88

@OpenSourceNomad

Und jetzt ist er wieder ganz ausgestiegen... also nicht mehr erreichbar

OpenSourceNomad

@backfisch88

Dann bitte weiter mit Punkt 2

backfisch88

@OpenSourceNomad
Haha alles klar. Schaff ich erst Montag

Werde es mal mit esphome probieren

OpenSourceNomad

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

Werde es mal mit esphome probieren

Mit esphome backst du dir deine eigene maßgeschneiderte firmware (gibt also keine general.bin) anhand einer yaml Datei in der du alles definierst was du benötigst.

Folgende Komponenten sind in deinem Fall wohl von Bedeutung: logger + pzem004t v3 + mqtt + web_server (neben den basics wie wifi usw.)

backfisch88

@OpenSourceNomad

Danke!
Da muss ich mich erst mal rein fuchsen.

Also der esp ist jetzt vollkommen abgeschmiert. Der hat keine Lust mehr werde ihn gleich nochmal neu starten

backfisch88

@OpenSourceNomad

Ich denke das Problem am ausstiegen ist die WIFI Verbindung. Hab jetzt mal die Schrank Tür raus (Metall)

backfisch88

@OpenSourceNomad

Also ich hab jetzt die Schrank Tür raus.
Alles nochmal neu gestartet aktuell geht alles. Sogar der Tagesstand 🤨 mal abwarten

OpenSourceNomad

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

Ich denke das Problem am ausstiegen ist die WIFI Verbindung.

da hilft der natürlich die Wifi Signal Component von esphome

Oder natürlich auch einfach der Status

Wobei du im Logger natürlich den wifi loss/reconnect auch sehen würdest.

Alles allerdings kein Grund "0" zu reportieren wie in deinem Fall

backfisch88

@OpenSourceNomad

Also habe das jetzt nochmal so laufen lassen. Werte kommen ohne Schrank Tür hervorragend.

ABER nach (heute jetzt) 18 Stunden ist er ausgestiegen. Blinkt im Sekundentakt und nicht mal mehr die PZEM machen irgendwas. Wenn ich die 5V vom ESP nehme und wieder neu starte geht alles wieder.

Ich werde nochmal den ESP tauschen

OpenSourceNomad

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

Ich werde nochmal den ESP tauschen

Netzteil ist auch ausreichend definiert (und nicht zu zappelig) für deinen ESP und die drei pzem's?

backfisch88

@OpenSourceNomad

Alles ausreichend. Funktioniert mittlerweile auch
Lösung war das WLAN
Hab den ESP In n alten Treppenhaus Automat gebaut. Passt auch alles ganz toll. Hab dann extra schon die Metall Tür draußen gelassen vom Schrank.
Hab ihn jetzt provisorisch außerhalb der Verteilung geht seit über 24 Stunden

Trotzdem vielen Dank!

OpenSourceNomad

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

Alles ausreichend. Funktioniert mittlerweile auch
Lösung war das WLAN

Wirklich komisch das Tastmota hier eine 0 anzeigt (was ja ein valider Wert sein könnte). Hier sollte vielmehr eine Fehler oder zumindest ein NaN (Not a Number) angezeigt werden.

Wie auch immer: Problem erkannt, Problem gebannt!

PS.: Ist übrigens mal wieder Zeit alle ESP's upzudaten: CVE-2020-12638 WiFi WPA Downgrade in Espressif microprocessors

backfisch88

@OpenSourceNomad
Ja finde das auch seltsam. Aber wenn’s so funktioniert ist es auch ok. 2,5 Tage schon am Stück

HomeZecke

Hallo,

mal ein kleines Update meiner Firmware.

Wifi optimiert und hostname auf "PZEM-Powermeter" gesetzt. Updates dann über: "http://pzem-powermeter.local/update"
Zählerstand wird jetzt erhalten nach einem reset oder Wlan bzw Strom Ausfall.
Neuer Datenpunkt "Befehl". Dort können Steuerbefehle an den Wemos gesendet werden. Im Moment sind das:
"sys-reset" : Wemos resetten
"pzem-reset" : resetten der PZEM Zählerstände
Der Datenpunkt "PZEM-Reset" fällt damit weg.
MQTT user und passwort hinzugefügt. Wenn nicht benötigt einfach leer lassen. (Danke @spaceduck)

Alles weitere bitte weiter oben nachlesen

//####################################################################################
//####################################################################################
//
//    PZEM Energiemessgeräterfassung mit WEMOS von HomeZecke     v1.2 stand 04.08.2020
//    --------------------------------------------------------------------------
//     v 1.0      Testphase first release 			     -05.03.2020
//
//     v 1.1      Zählerstartwert kann festgelegt werden 	     -30.03.2020
//
//     v 1.2      Wifi optimiert, hostname auf "PZEM-Powermeter"     -04.08.2020
//                gesetzt. Updates jetzt über:
//                "http://pzem-powermeter.local/update"
//                Zählerstand wird jetzt erhalten nach     
//                reset oder Wlan Ausfall.
//                Neuer Datenpunkt "Befehl". Dort können Steuer-
//                befehle an den Wemos gesendet werden:
//                "sys-reset"  : Wemos resetten
//                "pzem-reset" : resetten der PZEM Zählerstände
//                Der Datenpunkt "PZEM-Reset" fällt damit weg.
//                MQTT user und passwort -Abfrage hinzugef. Wenn nicht
//                benötigt leer lassen. (Danke @spaceduck)
//                
//				 
//     ToDo:      Online Config für Wlan / MQTT usw. hinzuf.
//
//     	
//			  
//####################################################################################
//####################################################################################

#include <Arduino.h>
#include <EEPROM.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* mqttUser = "";
const char* mqttPassword = "";
//---------------------------------------------
const char* Hostname = "PZEM-Powermeter";
const int STATUS_LED = 13;  //D7 (Wemos D1 Mini)

typedef struct //Datenstruktur für Eprom config
  {
    float counter_startwert;
    float diff_verbrauch;
  } configdata_typ;

configdata_typ config; //config variable deklarieren 


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);

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



// #####################################################################################################
// #####################################################################################################
// Funktionen
// #####################################################################################################
// #####################################################################################################



//=======================================================================================================================
//Config ins EPROM speichern
//=======================================================================================================================
void saveConfig() {
 
  EEPROM.begin(4095);
  EEPROM.put( 0, config );
  delay(200);
  EEPROM.commit();                    
  EEPROM.end();  

}


//=======================================================================================================================
//Config vom EPROM laden
//=======================================================================================================================
void loadConfig() {
 
  EEPROM.begin(4095);
  EEPROM.get( 0, config );
  EEPROM.end();
}


//=======================================================================================================================
//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 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;
              config.counter_startwert = start_verbrauch;
              saveConfig();
              set_counter(counter_start); // func set_couter zum setzen aufrufen
            }

         

        
      } 


// Topic Befehl------------------------------------------------------------------------------
  if (strcmp(topic,"Energie/Befehl") == 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 (strcmp(my_payload,"pzem-reset") == 0)
            {
                pzem_reset();                //Energie an den PZEM's resetten
            }

          if (strcmp(my_payload,"sys-reset") == 0)
            {
               MQTTClient.publish ( "Energie/Befehl", "");
               delay(1000);
               ESP.restart();                //Wemos resetten
            }


               
      MQTTClient.publish ( "Energie/Befehl", "");
         

        
      }                 

}

//=======================================================================================================================
//WLan -Verbindung aufbauen
//=======================================================================================================================
void initWiFi()
{
    static int wifiRetryCounter;

    Serial.println("");
    Serial.print("Wifi connect...");
    WiFi.persistent(false);
    WiFi.begin(SSID, PSK);
    WiFi.hostname(Hostname);
    WiFi.begin(SSID, PSK);

    while (WiFi.status() != WL_CONNECTED)
      {
        ++wifiRetryCounter;
        if (wifiRetryCounter > 90)
          {
            ESP.restart();
          }
        digitalWrite(STATUS_LED,!digitalRead(STATUS_LED));
        Serial.print(".");   
        delay(700);
      };

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

}



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

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

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

    //--Verbindungsloop
    while( !MQTTClient.connect("Energie_PZEM", mqttUser, mqttPassword))   
      {
        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"); 
      }; 

    if (MQTTClient.subscribe("Energie/Befehl"))
      {
            Serial.println("MQTT : Energie/Befehl 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);
 
  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;

  config.diff_verbrauch = diff_verbrauch; // ins eprom speichern
  saveConfig();

  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("");

  loadConfig();
  start_verbrauch = config.counter_startwert;
  diff_verbrauch  = config.diff_verbrauch;


  initWiFi();
  initMQTT();

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


  //--OTA Over the Air update einrichten
  MDNS.begin(Hostname);
  httpUpdater.setup(&httpServer);
  httpServer.begin();
  MDNS.addService("http", "tcp", 80);
  Serial.printf("HTTPUpdateServer ready! Open http://%s.local/update in your browser\n", Hostname);
  
 
  //--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

@HomeZecke

Im Code fehlt ein:

const char* version = "Version 1.2";

sonst meckert der Compiler. Danke für das Update!

spaceduck

@HomeZecke

Mal ne Frage: Hast Du in Deinem Aufbau Levelshifter zwischen ESP und PZEM drin? Stichwort 3,3V <-> 5V Signale...

NEWS

[Tutorial] PZEM-004T 3 Phasen Überwachung

Support us

607
Online

31.6k
Users

79.6k
Topics

1.3m
Posts

NEWS

[Tutorial] PZEM-004T 3 Phasen Überwachung

Support us

607Online

31.6kUsers

79.6kTopics

1.3mPosts

607
Online

31.6k
Users

79.6k
Topics

1.3m
Posts