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

[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...

[OpenSourceNomad]

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

Levelshifter zwischen ESP und PZEM

Alle esp8266 haben eine eingebaute Sicherung welche auf allen GPIO Pins aktiv ist. Die snap back current beträgt um die 6V, sprich 5V Signale sind kein Problem.

Wer jetzt noch level shiftet hat nichts verstanden oder benutzt einen esp32

[spaceduck]

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

Wer jetzt noch level shiftet hat nichts verstanden...

Naja, ganz so pauschal würde ich das mit dem verstehen jetzt nicht sehen, denn es gibt auch noch die Gegenrichtung. Das die PZEM empfangsseitig mit 3,3V Pegel klarkommen ist schön, von daher kann man sich den Levelshifter dann natürlich sparen.

[-cs-]

Hallo,

da ich hier diejenigen am besten antreffe, welche es evtl. am meisten Interessiert:

Leider ergeben sich viele Sachen anders als gedacht, deshalb möchte ich mein Set
bestehend aus 3x PZEM-004T, D1Mini und weitere Kleinteile, welches noch nie im Einsatz war abgeben. Der D1Mini wurde mit Tasmota geflasht und ist nicht weiter eingerichtet.

Ebay Kleinanzeigen Anzeigennr.: 1537920068

Falls Interesse besteht, kurze PN hier mach ich 25.-€ inkl. Versand DLH innerhalb D.

Chris

[Basti97]

Nun bin ich auch beim Planen des Projektes Pzem004 Messung.
Nun sind mir ein paar Fragen aufgetreten.

1. Braucht man die Diode unbedingt wenn ja für was.
2. Für was ist der Widerstand an TX.
3. Die Gpios des ESP sind ja nur 3V Tolerant und der pzem hat ja eine Spannung von 5V dadurch müsste ich doch ein Levelshifter dazwischen geschalten werden oder?
   Gruß Basti

[OpenSourceNomad]

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

Braucht man die Diode unbedingt wenn ja für was.

Kannst auch einfach mal ohne probieren, kaputt wird nichts dabei gehen...

Für was ist der Widerstand an TX.

Damit du mehr als einen pzem004t auf dem gleichen Bus benutzen kannst..

Die Gpios des ESP sind ja nur 3V Tolerant und der pzem hat ja eine Spannung von 5V dadurch müsste ich doch ein Levelshifter dazwischen geschalten werden oder?

Nur bei wenn du einen esp32 benutzen willst.

Die esp82xx sind schon wie zigfach erwähnt (z.B. drei posts über deinem ) in der Lage 5V Signale auf den gpio's ohne Einschränkungen zu verarbeiten.

[Johannes Bauerstatter]

@Basti97 Ich nutze einen Wemos D1 Mini und habe die Dioden eingebaut. Den Widerstand habe ich nicht und es funktioniert in 3 Verteiler. Adressierung habe ich mittels PZEM - Tool gemacht. Ohne Diode hatte ich komische Werte.