[Tutorial] PZEM-004T 3 Phasen Überwachung

backfisch88

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.

alt text

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.

Braucht man die Diode unbedingt wenn ja für was.
Für was ist der Widerstand an TX.
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.

homecineplexx

@OpenSourceNomad hi
sag mal, wie hast du das mit der Unterteilung gemacht?

OpenSourceNomad

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

sag mal, wie hast du das mit der Unterteilung gemacht?

Das sind teilweise Erfassungen von einzelnen Geräten, meist Großverbrauchern (z.B mittels Pow R2 oder anderen esphomatized Zwischensteckern) sowie auch von pzem004t's welche an bestimmten Stromkreisen hängen.

Dadurch habe ich genau im Blick wo und wie viel Strom läuft. Quasi so etwas wie sense versucht, nur mit dem kleinen Unterschied das es auch funktioniert und trotz mehr Hardware deutlich günstiger ist als diese teure, unnütze Box in diesem schönen Orange:

da.phreak

Ist es wirklich nötig, zum Setzen der Adresse 230V anzuschließen? Sprich die 5V vom USB/TTL Wandler reichen nicht? Ich versuche es grad und bekommen einfach keine Verbindung, auf dem Wandler ist ein CH340. Der nächste Schritt wäre dann, 230V anzuklemmen. Wäre natürlich schöner, wenn man zum probieren ohne gefährlich Spannung testen kann.

homecineplexx

@OpenSourceNomad ja das ist mir schon klar, was das aussagen soll und ich hab ja auch einige dieser Pow, aber ich schaff es nicht die Balken in Grafana zu erstellen, wo quasi ein Teil anzeigt was verbraucht wird, und der andere quasi zeigt wieviel erzeugt wird (zb)

OpenSourceNomad

@homecineplexx dann guck mal hier vorbei. Das ist die Vorlage die ich verwendet habe, sollte alles drin sein soweit um das in wenigen Minuten nachzubauen.

da.phreak

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

Ist es wirklich nötig, zum Setzen der Adresse 230V anzuschließen? Sprich die 5V vom USB/TTL Wandler reichen nicht? Ich versuche es grad und bekommen einfach keine Verbindung, auf dem Wandler ist ein CH340. Der nächste Schritt wäre dann, 230V anzuklemmen. Wäre natürlich schöner, wenn man zum probieren ohne gefährlich Spannung testen kann.

Ich beantworte mir die Frage mal selbst: Ja muß man. Ich denke mal ein Teil der Elektronik wird über die anliegenden 230V versorgt. Es heißt ja auch, daß nur die USB-Schnittstelle galvanisch getrennt ist, also macht das schon Sinn.

NEWS

[Tutorial] PZEM-004T 3 Phasen Überwachung

Support us

742
Online

31.6k
Users

79.5k
Topics

1.3m
Posts

NEWS

[Tutorial] PZEM-004T 3 Phasen Überwachung

Support us

742Online

31.6kUsers

79.5kTopics

1.3mPosts

742
Online

31.6k
Users

79.5k
Topics

1.3m
Posts