Skip to content
  • Aktuell
  • Tags
  • 0 Ungelesen 0
  • Kategorien
  • Unreplied
  • Beliebt
  • GitHub
  • Docu
  • Hilfe
Skins
  • Light
  • Brite
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • Standard: (Kein Skin)
  • Kein Skin
Einklappen
ioBroker Logo
  1. ioBroker Community Home
  2. Deutsch
  3. Praktische Anwendungen (Showcase)
  4. [Tutorial] PZEM-004T 3 Phasen Überwachung

NEWS

  • UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?
    apollon77A
    apollon77
    48
    3
    8.1k

  • Monatsrückblick – September 2025
    BluefoxB
    Bluefox
    13
    1
    1.8k

  • Neues Video "KI im Smart Home" - ioBroker plus n8n
    BluefoxB
    Bluefox
    15
    1
    2.1k

[Tutorial] PZEM-004T 3 Phasen Überwachung

Geplant Angeheftet Gesperrt Verschoben Praktische Anwendungen (Showcase)
pzem-004t-v30monitoringüberwachungmessunghow-totutorial
283 Beiträge 37 Kommentatoren 78.9k Aufrufe 41 Watching
  • Älteste zuerst
  • Neuste zuerst
  • Meiste Stimmen
Antworten
  • In einem neuen Thema antworten
Anmelden zum Antworten
Dieses Thema wurde gelöscht. Nur Nutzer mit entsprechenden Rechten können es sehen.
  • HomeZeckeH 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😁 )
    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);
    
    
    
    }
    
    K Offline
    K Offline
    Kopterframe
    schrieb am zuletzt editiert von
    #183

    @homezecke
    Super Projekt, vielen Dank. Werde es auch nachbauen, mit nur einer Phase. Da nur eine vorhanden ist.
    Habe ich das richtig verstanden,
    PZEM1 RX - D1 Wemo und TX - D2 Wemo?
    Viele Grüße

    1 Antwort Letzte Antwort
    0
    • marcusklM Offline
      marcusklM Offline
      marcuskl
      schrieb am zuletzt editiert von
      #184

      Mir ist aufgefallen das die Werte Scheinleistung, Blindleistung und Wirkleistung nicht zusammen passen.
      Scheinleistung ist ja Blindleistung und Scheinleistung zusammen gerechnet und wenn ich mir die Messwerte anschaue ergibt des irgendwie kein Sinn?
      Bei eich auch so ?
      Screenshot_2021-08-04-18-38-20-466_com.android.chrome.jpg

      Host: Intel Nuc6cayh (16GB Ram, 240GB SSD) mit Proxmox.

      Iobroker VM, InfluxDB LXC, Pihole LXC, Tasmoadmin LXC, Easy2connect VM

      DolomitiD 1 Antwort Letzte Antwort
      0
      • marcusklM marcuskl

        Mir ist aufgefallen das die Werte Scheinleistung, Blindleistung und Wirkleistung nicht zusammen passen.
        Scheinleistung ist ja Blindleistung und Scheinleistung zusammen gerechnet und wenn ich mir die Messwerte anschaue ergibt des irgendwie kein Sinn?
        Bei eich auch so ?
        Screenshot_2021-08-04-18-38-20-466_com.android.chrome.jpg

        DolomitiD Offline
        DolomitiD Offline
        Dolomiti
        schrieb am zuletzt editiert von Dolomiti
        #185

        @marcuskl
        S ist nicht gleich P + Q, sondern 8fad4760-1aa7-4496-80b7-15285eb4734f-image.png

        Wikipedia

        Benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat.
        Intel N100 (32GB,256GB SSD), Proxmox -> Debian 12 in VM (Master) + Debian 12 in CT (Test) + Debmatic, HM-Aktoren, Wago 750-880, Shelly, Zigbee

        marcusklM 1 Antwort Letzte Antwort
        0
        • DolomitiD Dolomiti

          @marcuskl
          S ist nicht gleich P + Q, sondern 8fad4760-1aa7-4496-80b7-15285eb4734f-image.png

          Wikipedia

          marcusklM Offline
          marcusklM Offline
          marcuskl
          schrieb am zuletzt editiert von
          #186

          @dolomiti ok Danke, bin schon lange raus aus dieser Thematik, hatte nur noch in Erinnerung das sich die Scheinleistung aus der Wirk- und Blindleistung zusammensetzt.

          Host: Intel Nuc6cayh (16GB Ram, 240GB SSD) mit Proxmox.

          Iobroker VM, InfluxDB LXC, Pihole LXC, Tasmoadmin LXC, Easy2connect VM

          1 Antwort Letzte Antwort
          0
          • M Malaus

            @marcuskl
            ich habe es hinbekommen! Endlich! 😄
            Die 5V Spannungsversorgung der PZEM Module muss über den Wemo kommen. Nur dann erhalte ich eine Kommunikation. Ich vermute mal, dass liegt am Potenzial für Tx und Rx.
            Die Dioden habe ich im Tx Strang verbaut. Nur die zusätzliche Versorgung hab ich nicht drin. Es funktioniert auch ohne. Ist die einfach nur zur Unterstützung des Bus da?

            Lange Rede kurzer Sinn, hier ist eine Skizze (Hoffe man erkennt es):
            Scan 05.01.2020, 10.01.jpeg

            H Offline
            H Offline
            HelmutLinner
            schrieb am zuletzt editiert von
            #187

            @marcuskl meinst du den Widerstand im PZEM zwischen optocopler und vcc?

            Für was sind die Dioden?
            Ich hab es mit einem PZEM 004t und einem esp8266 probiert, ich hab die dioden in alle möglichen Richtungen eingebaut in RX oder TX und auch mit der separaten Versorgung über den Widerstand auf RX. Das hat aber alles nicht funktioniert.

            Ich hab dann den esp über 5v und ground Versorgung und den Pzem über die selbe Versorgung und RX auf TX, TX auf RX und es funktioniert, jetzt hab ich einen 2 ten PZEM mit Adresse 2 parallel dazu angeschlossen. Jetzt bekomme ich von beiden die Werte.

            Ich habe auch in der Tasmota Software auf PZEM016 RX gestellt obwohl ich einen PZEM04t habe, aber nur so funktioniert’s bei mir.

            Habt ihr in IObroker einzelne datenpunkte für Spannung Leistung Amper usw? Ich weiß gerade nicht wie ich den einen großen datenpunkt auseinander bekomme dass ich ihn in Grafana verwenden kann. Muss ich da was in tasmota machen damit schon mehrere datenpunkte erzeugt werden?

            {"Time":"2021-12-25T14:57:13","ENERGY":{"TotalStartTime":"2021-12-24T22:40:20","Total":0.000,"Yesterday":0.000,"Today":0.000,"Period":[ 0, 0],"Power":[ 0, 0],"ApparentPower":[ 0, 0],"ReactivePower":[ 0, 0],"Factor":[0.00,0.00],"Frequency":[50,50],"Voltage":[228,228],"Current":[0.000,0.000]}}

            D B M 3 Antworten Letzte Antwort
            0
            • H HelmutLinner

              @marcuskl meinst du den Widerstand im PZEM zwischen optocopler und vcc?

              Für was sind die Dioden?
              Ich hab es mit einem PZEM 004t und einem esp8266 probiert, ich hab die dioden in alle möglichen Richtungen eingebaut in RX oder TX und auch mit der separaten Versorgung über den Widerstand auf RX. Das hat aber alles nicht funktioniert.

              Ich hab dann den esp über 5v und ground Versorgung und den Pzem über die selbe Versorgung und RX auf TX, TX auf RX und es funktioniert, jetzt hab ich einen 2 ten PZEM mit Adresse 2 parallel dazu angeschlossen. Jetzt bekomme ich von beiden die Werte.

              Ich habe auch in der Tasmota Software auf PZEM016 RX gestellt obwohl ich einen PZEM04t habe, aber nur so funktioniert’s bei mir.

              Habt ihr in IObroker einzelne datenpunkte für Spannung Leistung Amper usw? Ich weiß gerade nicht wie ich den einen großen datenpunkt auseinander bekomme dass ich ihn in Grafana verwenden kann. Muss ich da was in tasmota machen damit schon mehrere datenpunkte erzeugt werden?

              {"Time":"2021-12-25T14:57:13","ENERGY":{"TotalStartTime":"2021-12-24T22:40:20","Total":0.000,"Yesterday":0.000,"Today":0.000,"Period":[ 0, 0],"Power":[ 0, 0],"ApparentPower":[ 0, 0],"ReactivePower":[ 0, 0],"Factor":[0.00,0.00],"Frequency":[50,50],"Voltage":[228,228],"Current":[0.000,0.000]}}

              D Offline
              D Offline
              da.phreak
              schrieb am zuletzt editiert von
              #188

              @helmutlinner Das ist JSON da wirst Du wohl ein script brauchen, um das auseinander zu nehmen. JSON.Parse macht das, etwa so :

              var dec = JSON.parse(getState("adresse_zum_knoten").val);

              Danach kannst Du über Properties von "dec" auf die Werte zugreifen, z. B.:

              log(dec.ENERGY.Voltage[0]);

              1 Antwort Letzte Antwort
              0
              • H HelmutLinner

                @marcuskl meinst du den Widerstand im PZEM zwischen optocopler und vcc?

                Für was sind die Dioden?
                Ich hab es mit einem PZEM 004t und einem esp8266 probiert, ich hab die dioden in alle möglichen Richtungen eingebaut in RX oder TX und auch mit der separaten Versorgung über den Widerstand auf RX. Das hat aber alles nicht funktioniert.

                Ich hab dann den esp über 5v und ground Versorgung und den Pzem über die selbe Versorgung und RX auf TX, TX auf RX und es funktioniert, jetzt hab ich einen 2 ten PZEM mit Adresse 2 parallel dazu angeschlossen. Jetzt bekomme ich von beiden die Werte.

                Ich habe auch in der Tasmota Software auf PZEM016 RX gestellt obwohl ich einen PZEM04t habe, aber nur so funktioniert’s bei mir.

                Habt ihr in IObroker einzelne datenpunkte für Spannung Leistung Amper usw? Ich weiß gerade nicht wie ich den einen großen datenpunkt auseinander bekomme dass ich ihn in Grafana verwenden kann. Muss ich da was in tasmota machen damit schon mehrere datenpunkte erzeugt werden?

                {"Time":"2021-12-25T14:57:13","ENERGY":{"TotalStartTime":"2021-12-24T22:40:20","Total":0.000,"Yesterday":0.000,"Today":0.000,"Period":[ 0, 0],"Power":[ 0, 0],"ApparentPower":[ 0, 0],"ReactivePower":[ 0, 0],"Factor":[0.00,0.00],"Frequency":[50,50],"Voltage":[228,228],"Current":[0.000,0.000]}}

                B Offline
                B Offline
                Beowolf
                schrieb am zuletzt editiert von
                #189

                @helmutlinner

                Warum nimmst Du nicht ESPeasy V2.0 ?

                Hatte ich hier schon mal beschrieben:

                https://forum.iobroker.net/topic/42261/pzem-004t-3-phasen-überwachung-mit-espeasy-v2-0

                ioBroker bekommt die Daten passend dann per mqtt.

                Alles einfach und läuft bei mir seit einem Jahr ohne Probleme.

                Ich hatte ja auch schon weiter oben mal etwas geschrieben.

                Ich habe das mit einem Wemos d1 Mini mit der ESPeasy gemacht. Alles drann ohne Widerstand und Diode. Läuft ohne Probleme.

                Grüße
                Manfred

                Die Natur braucht nicht unseren Schutz, sie braucht unsere Abwesenheit.

                1 Antwort Letzte Antwort
                0
                • H HelmutLinner

                  @marcuskl meinst du den Widerstand im PZEM zwischen optocopler und vcc?

                  Für was sind die Dioden?
                  Ich hab es mit einem PZEM 004t und einem esp8266 probiert, ich hab die dioden in alle möglichen Richtungen eingebaut in RX oder TX und auch mit der separaten Versorgung über den Widerstand auf RX. Das hat aber alles nicht funktioniert.

                  Ich hab dann den esp über 5v und ground Versorgung und den Pzem über die selbe Versorgung und RX auf TX, TX auf RX und es funktioniert, jetzt hab ich einen 2 ten PZEM mit Adresse 2 parallel dazu angeschlossen. Jetzt bekomme ich von beiden die Werte.

                  Ich habe auch in der Tasmota Software auf PZEM016 RX gestellt obwohl ich einen PZEM04t habe, aber nur so funktioniert’s bei mir.

                  Habt ihr in IObroker einzelne datenpunkte für Spannung Leistung Amper usw? Ich weiß gerade nicht wie ich den einen großen datenpunkt auseinander bekomme dass ich ihn in Grafana verwenden kann. Muss ich da was in tasmota machen damit schon mehrere datenpunkte erzeugt werden?

                  {"Time":"2021-12-25T14:57:13","ENERGY":{"TotalStartTime":"2021-12-24T22:40:20","Total":0.000,"Yesterday":0.000,"Today":0.000,"Period":[ 0, 0],"Power":[ 0, 0],"ApparentPower":[ 0, 0],"ReactivePower":[ 0, 0],"Factor":[0.00,0.00],"Frequency":[50,50],"Voltage":[228,228],"Current":[0.000,0.000]}}

                  M Offline
                  M Offline
                  manrum1
                  schrieb am zuletzt editiert von
                  #190

                  @helmutlinner Hallo, aller Anfang ist schwer, war bei mir auch so:

                  Zuerst richtest Du Dir im iobroker Datenpunkte ein, am besten unter dem Objektbaum 0_userdata.0... Dazu nimmst Du folgendes Script und lässt es einmal laufen, danach solltest Du die Datenpunkte sehen:

                  /* /* Strommessung
                  
                  
                  */
                  var pfad = '0_userdata.0.Strom.hb.Status.',
                      name_geraet = 'Pzem_hb', // zB Waschmaschine (Achtung keine Umlaute)
                      beschreibung = 'Strommessung Home Base'; // zB 
                  
                  // Energie
                  createState(pfad + name_geraet + '.Zaehler.Energy_TotalStartTime', 0, {
                      name: 'Energie Total StartTime',
                      desc: 'xx',
                      type: 'string',
                      unit: '',
                      role: '',
                      read: true,
                      write: true
                   });
                   
                  createState(pfad + name_geraet + '.Zaehler.Energy_Total', 0, {
                      name: 'Energie total',
                      desc: 'xx',
                      type: 'number',
                      unit: 'kWh',
                      role: 'value.power.consumption',
                      read: true,
                      write: true
                   });
                  
                   createState(pfad + name_geraet + '.Zaehler.Energy_Yesterday', 0, {
                      name: 'Energie gestern',
                      desc: 'xx',
                      type: 'number',
                      unit: 'kWh',
                      role: 'value.power.consumption',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Energy_Today', 0, {
                      name: 'Energie heute',
                      desc: 'xx',
                      type: 'number',
                      unit: 'kWh',
                      role: 'value.power.consumption',
                      read: true,
                      write: true
                   });
                  
                   createState(pfad + name_geraet + '.Zaehler.Period', 0, {
                      name: 'Periode',
                      desc: 'xx',
                      type: 'number',
                      unit: '',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  // Leistung
                  createState(pfad + name_geraet + '.Zaehler.Power_Ph1', 0, {
                      name: 'Leistung Phase 1',
                      desc: 'xx',
                      type: 'number',
                      unit: 'W',
                      role: 'value.power',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Power_Ph2', 0, {
                      name: 'Leistung Phase 2',
                      desc: 'xx',
                      type: 'number',
                      unit: 'W',
                      role: 'value.power',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Power_Ph3', 0, {
                      name: 'Leistung Phase 3',
                      desc: 'xx',
                      type: 'number',
                      unit: 'W',
                      role: 'value.power',
                      read: true,
                      write: true
                   });
                  
                  // Scheinleistung
                   createState(pfad + name_geraet + '.Zaehler.ApparentPower_Ph1', 0, {
                      name: 'Scheinleistung Phase 1',
                      desc: 'xx',
                      type: 'number',
                      unit: 'VA',
                      role: 'value.power',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.ApparentPower_Ph2', 0, {
                      name: 'Scheinleistung Phase 2',
                      desc: 'xx',
                      type: 'number',
                      unit: 'VA',
                      role: 'value.power',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.ApparentPower_Ph3', 0, {
                      name: 'Scheinleistung Phase 3',
                      desc: 'xx',
                      type: 'number',
                      unit: 'VA',
                      role: 'value.power',
                      read: true,
                      write: true
                   });
                  
                   // Blindleistung
                   createState(pfad + name_geraet + '.Zaehler.ReactivePower_Ph1', 0, {
                      name: 'Blindleistung Phase 1',
                      desc: 'xx',
                      type: 'number',
                      unit: 'VAr',
                      role: 'value.power',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.ReactivePower_Ph2', 0, {
                      name: 'Blindleistung Phase 2',
                      desc: 'xx',
                      type: 'number',
                      unit: 'VAr',
                      role: 'value.power',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.ReactivePower_Ph3', 0, {
                      name: 'Blindleistung Phase 3',
                      desc: 'xx',
                      type: 'number',
                      unit: 'VAr',
                      role: 'value.power',
                      read: true,
                      write: true
                   });
                  
                   // Leistungsfaktor
                   createState(pfad + name_geraet + '.Zaehler.Factor_Ph1', 0, {
                      name: 'Leistungsfaktor Phase 1',
                      desc: 'xx',
                      type: 'number',
                      unit: '',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Factor_Ph2', 0, {
                      name: 'Leistungsfaktor Phase 2',
                      desc: 'xx',
                      type: 'number',
                      unit: '',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Factor_Ph3', 0, {
                      name: 'Leistungsfaktor Phase 3',
                      desc: 'xx',
                      type: 'number',
                      unit: '',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                    // Frequenz
                   createState(pfad + name_geraet + '.Zaehler.Frequency_Ph1', 0, {
                      name: 'Frequenz Phase 1',
                      desc: 'xx',
                      type: 'number',
                      unit: 'Hz',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Frequency_Ph2', 0, {
                      name: 'Frequenz Phase 2',
                      desc: 'xx',
                      type: 'number',
                      unit: 'Hz',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Frequency_Ph3', 0, {
                      name: 'Frequenz Phase 3',
                      desc: 'xx',
                      type: 'number',
                      unit: 'Hz',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                    // Volt
                   createState(pfad + name_geraet + '.Zaehler.Voltage_Ph1', 0, {
                      name: 'Spannung Phase 1',
                      desc: 'xx',
                      type: 'number',
                      unit: 'V',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Voltage_Ph2', 0, {
                      name: 'Spannung Phase 2',
                      desc: 'xx',
                      type: 'number',
                      unit: 'V',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Voltage_Ph3', 0, {
                      name: 'Spannung Phase 3',
                      desc: 'xx',
                      type: 'number',
                      unit: 'V',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                   // Strom
                   createState(pfad + name_geraet + '.Zaehler.Current_Ph1', 0, {
                      name: 'Strom Phase 1',
                      desc: 'xx',
                      type: 'number',
                      unit: 'A',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Current_Ph2', 0, {
                      name: 'Strom Phase 2',
                      desc: 'xx',
                      type: 'number',
                      unit: 'A',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Current_Ph3', 0, {
                      name: 'Strom Phase 3',
                      desc: 'xx',
                      type: 'number',
                      unit: 'A',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                    // Berechnete
                  
                  createState(pfad + name_geraet + '.Zaehler.Current', 0, {
                      name: 'Strom gesamt',
                      desc: 'xx',
                      type: 'number',
                      unit: 'A',
                      role: 'value.power',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Power', 0, {
                      name: 'Leistung gesamt',
                      desc: 'xx',
                      type: 'number',
                      unit: 'W',
                      role: 'value.power.consumption',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.ApparentPower', 0, {
                      name: 'Scheinleistung gesamt',
                      desc: 'xx',
                      type: 'number',
                      unit: 'VA',
                      role: 'value.power.consumption',
                      read: true,
                      write: true
                   });
                  
                   createState(pfad + name_geraet + '.Zaehler.ReactivePower', 0, {
                      name: 'Blindleistung gesamt',
                      desc: 'xx',
                      type: 'number',
                      unit: 'VAr',
                      role: 'value.power.consumption',
                      read: true,
                      write: true
                   });
                  
                  
                   // Zähler
                  
                  createState(pfad + name_geraet + '.Zaehler.Zaehler_actual', 0, {
                      name: 'Zählerstand aktuell',
                      desc: 'xx',
                      type: 'number',
                      unit: 'kWh',
                      role: 'value.power.consumption',
                      read: true,
                      write: true
                   });
                  
                   createState(pfad + name_geraet + '.Zaehler.Zaehler_Korrektur', 0, {
                      name: 'Zähler Korrektur (setzen)',
                      desc: 'xx',
                      type: 'number',
                      unit: 'kWh',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                   createState(pfad + name_geraet + '.Zaehler.Zaehler_HT', 0, {
                      name: 'Zählerstand Basiswert HT (setzen)',
                      desc: 'xx',
                      type: 'number',
                      unit: 'kWh',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Zaehler_NT', 0, {
                      name: 'Zählerstand Basiswert NT (setzen)',
                      desc: 'xx',
                      type: 'number',
                      unit: 'kWh',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  
                  createState(pfad + name_geraet + '.Zaehler.Zaehler_Basiswert', 0, {
                      name: 'Zählerstand Basiswert (setzen oder Summe HT/NT)',
                      desc: 'xx',
                      type: 'number',
                      unit: 'kWh',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Zaehler_Basiswert_Datum', 0, {
                      name: 'Zählerstand Basiswert Datum/Uhrzeit (setzen)',
                      desc: 'xx',
                      type: 'string',
                      unit: '',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  createState(pfad + name_geraet + '.Zaehler.Zaehler_Pzem_Lastchanged', 0, {
                      name: 'Datum/Uhrzeit',
                      desc: 'xx',
                      type: 'string',
                      unit: '',
                      role: '',
                      read: true,
                      write: true
                   });
                  
                  
                  

                  Als nächstes brauchst Du ein Script, dass den MQTT-String parst (durchsucht) und die Daten auf einzlene Datenpunkte mapped, die wir vorher erzeugt haben.

                  on('mqtt.0.tele.stromhb.SENSOR', function(dp) {
                      let tstrom = JSON.parse(dp.state.val);
                      if(tstrom['Time']) {
                          let val = tstrom['Time'];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Zaehler_Pzem_Lastchanged', val, true);
                      }
                      let strom = JSON.parse(dp.state.val).ENERGY;
                      if(strom['TotalStartTime']) {
                          let val = strom['TotalStartTime'];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Energy_TotalStartTime', val, true);
                      } if(strom['Total']) {
                          let val = strom['Total'];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Energy_Total', val, true);
                      } if(strom['Yesterday']) {
                          let val = strom['Yesterday'];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Energy_Yesterday', val, true);
                      } if(strom['Today']) {
                          let val = strom['Today'];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Energy_Today', val, true);
                      } if(strom['Period']) {
                          let val = strom['Period'];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Period', val, true);
                      } if(strom['Power']) {
                          let val = strom['Power'][0];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Power_Ph1', val, true);
                      } if(strom['Power']) {
                          let val = strom['Power'][1];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Power_Ph2', val, true);
                      } if(strom['Power']) {
                          let val = strom['Power'][2];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Power_Ph3', val, true);
                      } if(strom['ApparentPower']) {
                          let val = strom['ApparentPower'][0];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ApparentPower_Ph1', val, true);
                      } if(strom['ApparentPower']) {
                          let val = strom['ApparentPower'][1];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ApparentPower_Ph2', val, true);
                      } if(strom['ApparentPower']) {
                          let val = strom['ApparentPower'][2];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ApparentPower_Ph3', val, true);
                      } if(strom['ReactivePower']) {
                          let val = strom['ReactivePower'][0];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ReactivePower_Ph1', val, true);
                      } if(strom['ReactivePower']) {
                          let val = strom['ReactivePower'][1];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ReactivePower_Ph2', val, true);
                      } if(strom['ReactivePower']) {
                          let val = strom['ReactivePower'][2];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ReactivePower_Ph3', val, true);
                      } if(strom['Factor']) {
                          let val = strom['Factor'][0];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Factor_Ph1', val, true);
                      } if(strom['Factor']) {
                          let val = strom['Factor'][1];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Factor_Ph2', val, true);
                      } if(strom['Factor']) {
                          let val = strom['Factor'][2];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Factor_Ph3', val, true);
                      } if(strom['Frequency']) {
                          let val = strom['Frequency'][0];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Frequency_Ph1', val, true);
                      } if(strom['Frequency']) {
                          let val = strom['Frequency'][1];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Frequency_Ph2', val, true);
                      } if(strom['Frequency']) {
                          let val = strom['Frequency'][2];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Frequency_Ph3', val, true);
                      } if(strom['Voltage']) {
                          let val = strom['Voltage'][0];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Voltage_Ph1', val, true);
                      } if(strom['Voltage']) {
                          let val = strom['Voltage'][1];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Voltage_Ph2', val, true);
                      } if(strom['Voltage']) {
                          let val = strom['Voltage'][2];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Voltage_Ph3', val, true);
                      } if(strom['Current']) {
                          let val = strom['Current'][0];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Current_Ph1', val, true);
                      } if(strom['Current']) {
                          let val = strom['Current'][1];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Current_Ph2', val, true);
                      } if(strom['Current']) {
                          let val = strom['Current'][2];
                          setState('0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Current_Ph3', val, true);
                      }
                      
                       setTimeout(function() {
                      // Code, der erst nach 5 Sekunden ausgeführt wird
                  
                      setState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Zaehler_Basiswert", (getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Zaehler_HT").val + getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Zaehler_NT").val), true);
                      setState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Current", (getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Current_Ph1").val + getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Current_Ph2").val + getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Current_Ph3").val), true);
                      setState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Power", (getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Power_Ph1").val + getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Power_Ph2").val + getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Power_Ph3").val), true);
                      setState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ReactivePower", (getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ReactivePower_Ph1").val + getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ReactivePower_Ph2").val + getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ReactivePower_Ph3").val), true);
                      setState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ApparentPower", (getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ApparentPower_Ph1").val + getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ApparentPower_Ph2").val + getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.ApparentPower_Ph3").val), true);
                      // setState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Zaehler_actual", (getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Zaehler_Basiswert").val + getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Zaehler_Korrektur").val), true);
                      setState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Zaehler_actual", (getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Zaehler_Basiswert").val + getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Energy_Total").val - getState("0_userdata.0.Strom.hb.Status.Pzem_hb.Zaehler.Zaehler_Korrektur").val), true);
                      }, 5000);
                  
                    });
                  
                  

                  Bei mir heißt der Knoten im MQTT-Adapter stromhb, das musst Du natürlich anpassen. Das Script muss dann dauernd laufen.
                  Am Ende werdne noch einige Berechnungen vorgenommen, ignoriere das erst mal.

                  Viel Erfolg

                  1 Antwort Letzte Antwort
                  1
                  • B Offline
                    B Offline
                    Berti69
                    schrieb am zuletzt editiert von
                    #191

                    Hallo
                    Kann mir mal jemand helfen. Irgendwie stecke ich fest. Habe alle drei Module laut Plan verdrahtet. Kann auch jedes Modul einzel auslesen. Leider gehen 3 zusammen nicht. Habe versucht über Tasmota die Adresse der Module zuschreiben. Ohne Erfolg. Die Software für Windows bekomme ich nicht zum laufen. Egal ob mit win 7 oder 10. Kommt immer ein Fehler wenn ich die run über Admin Starte. Gibt es noch ne andere Software für das schreiben der Adresse oder mach ich irgendwo einen Fehler. Danke
                    Gruß Bernd

                    OpenSourceNomadO ice77I 2 Antworten Letzte Antwort
                    0
                    • B Berti69

                      Hallo
                      Kann mir mal jemand helfen. Irgendwie stecke ich fest. Habe alle drei Module laut Plan verdrahtet. Kann auch jedes Modul einzel auslesen. Leider gehen 3 zusammen nicht. Habe versucht über Tasmota die Adresse der Module zuschreiben. Ohne Erfolg. Die Software für Windows bekomme ich nicht zum laufen. Egal ob mit win 7 oder 10. Kommt immer ein Fehler wenn ich die run über Admin Starte. Gibt es noch ne andere Software für das schreiben der Adresse oder mach ich irgendwo einen Fehler. Danke
                      Gruß Bernd

                      OpenSourceNomadO Offline
                      OpenSourceNomadO Offline
                      OpenSourceNomad
                      Most Active
                      schrieb am zuletzt editiert von OpenSourceNomad
                      #192

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

                      Gibt es noch ne andere Software für das schreiben der Adresse

                      Esphome 😉 Das passende snippet dafür steht in der Dokumentation der pzemac (für v3) Komponente.
                      Vielleicht hilft dir dann im Anschluss auch gleich (das meist sehr aussagekräftig) logging weiter um eventuelle Probleme mit dem pzem004t zu identifizieren 💡

                      „Das Widerlegen von Schwachsinn erfordert eine Größenordnung mehr Energie als dessen Produktion.“ - Alberto Brandolini (Bullshit-Asymmetrie-Prinzip)

                      1 Antwort Letzte Antwort
                      0
                      • B Berti69

                        Hallo
                        Kann mir mal jemand helfen. Irgendwie stecke ich fest. Habe alle drei Module laut Plan verdrahtet. Kann auch jedes Modul einzel auslesen. Leider gehen 3 zusammen nicht. Habe versucht über Tasmota die Adresse der Module zuschreiben. Ohne Erfolg. Die Software für Windows bekomme ich nicht zum laufen. Egal ob mit win 7 oder 10. Kommt immer ein Fehler wenn ich die run über Admin Starte. Gibt es noch ne andere Software für das schreiben der Adresse oder mach ich irgendwo einen Fehler. Danke
                        Gruß Bernd

                        ice77I Offline
                        ice77I Offline
                        ice77
                        schrieb am zuletzt editiert von ice77
                        #193

                        @berti69

                        Hallo Bernd

                        Ich kann Dir gerne sagen wie ich es ohne Kopfschmerzen gelöst habe:

                        Verkable immer nur ein einzelnes PZEM an den esp8266 und setze die ID. Gib jedem Gerät eine unterschiedliche ID. Ich habe dazu ESPeasy genutzt, welches ich hier auch anhängen kann, wenn ich das binary noch finde.

                        Wenn die unterschiedlichen IDs gesetzt wurden, kannst Du alle PZEMs an den ESP hängen und entsprechend konfigurieren.

                        Das funktioniert 100%. Die einzige Stolperstelle ist, dass immer nur ein einzelner PZEM angehängt sein darf, wenn die ID geschrieben wird.

                        Falls es nicht klappt... sag bescheid und ich helf dir gern.

                        LG

                        PS: ID setzten unter PZEM mode -> program adress

                        Hier das Binary welches sicher funktioniert:
                        ESP_Easy_mega_20210114_energy_ESP8266_4M1M.zip

                        PZEM.png

                        Hier kannst Du die ID setzen:
                        ProgramAdress.png

                        1 Antwort Letzte Antwort
                        0
                        • B Offline
                          B Offline
                          Berti69
                          schrieb am zuletzt editiert von
                          #194

                          Danke Euch beiden für die Hilfe. Habe es hinbekommen. Entweder habe ich das irgendwo überlesen oder es ist für Andere selbstverständlich. Ich mußte die isAnalogLibrary.ocx in die Windows Registry eintragen und installieren. Jetzt geht die Messung.
                          Danke

                          E 1 Antwort Letzte Antwort
                          0
                          • B Berti69

                            Danke Euch beiden für die Hilfe. Habe es hinbekommen. Entweder habe ich das irgendwo überlesen oder es ist für Andere selbstverständlich. Ich mußte die isAnalogLibrary.ocx in die Windows Registry eintragen und installieren. Jetzt geht die Messung.
                            Danke

                            E Offline
                            E Offline
                            Elektroschlumpf5
                            schrieb am zuletzt editiert von
                            #195

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

                            isAnalogLibrary.ocx in die Windows Registry eintragen und installieren

                            Hallo...
                            Hab so meine probleme hiermit. was meinst du damit in die registry eintragen und installieren. bekomme es nicht zum laufen...

                            1 Antwort Letzte Antwort
                            0
                            • guxtduG Offline
                              guxtduG Offline
                              guxtdu
                              schrieb am zuletzt editiert von
                              #196

                              Super Projekt

                              hat jemand eine Idee warum mein PZEM mir 250V anzeigt und nicht 230V

                              Danke

                              B 1 Antwort Letzte Antwort
                              0
                              • guxtduG guxtdu

                                Super Projekt

                                hat jemand eine Idee warum mein PZEM mir 250V anzeigt und nicht 230V

                                Danke

                                B Offline
                                B Offline
                                Beowolf
                                schrieb am zuletzt editiert von
                                #197

                                @guxtdu

                                Foto von Anschluß? Mal mit einem Multimeter gemessen? Hast Du nur den einen? Defekt?

                                So ist eine Aussage etwas schwierig.

                                Die Natur braucht nicht unseren Schutz, sie braucht unsere Abwesenheit.

                                1 Antwort Letzte Antwort
                                0
                                • Basti97B Offline
                                  Basti97B Offline
                                  Basti97
                                  Most Active
                                  schrieb am zuletzt editiert von
                                  #198

                                  Ich habe nochmal eine Frage hier zu welche Diode habt ihr genommen. Ich hoffe das ich das hier nicht überlesen habe .)

                                  Iobroker läuft als VM auf Proxmoxserver x folgende Hersteller im Einsatz Sonoff, Gosund, Siemens x Aofo über Tasmota x Zigbee x das Smarthome wächst und wächst

                                  1 Antwort Letzte Antwort
                                  0
                                  • E Offline
                                    E Offline
                                    edition
                                    schrieb am zuletzt editiert von
                                    #199

                                    Guten Tag

                                    Hat jemand eine Idee, warum mir nur die Spannung und die Frequenz angezeit wird? Die Werte für Strom, Leistung usw. bleiben bei Null, obwohl ein Heizlüfter mit 2000 Watt angeschlossen ist!

                                    Ich habe 2 PZEM-004T V3. Einen mit Gehäuse, der andere ohne. Dazu einen geschlossenen und einen geteilten Stromwandler. Ich habe es mit einem Arduino Uno, einem Arduino Nano, mit einem Wemos D1 mini und Tasmota und auch esp easy versucht. Beim Wemus mit und ohne Pegelwandler. Das Ergebniss ist immer gleich. Strom bleibt auf 0,00 A!
                                    Es können doch nicht beide PZEM defekt sein!

                                    edition

                                    B 1 Antwort Letzte Antwort
                                    0
                                    • E edition

                                      Guten Tag

                                      Hat jemand eine Idee, warum mir nur die Spannung und die Frequenz angezeit wird? Die Werte für Strom, Leistung usw. bleiben bei Null, obwohl ein Heizlüfter mit 2000 Watt angeschlossen ist!

                                      Ich habe 2 PZEM-004T V3. Einen mit Gehäuse, der andere ohne. Dazu einen geschlossenen und einen geteilten Stromwandler. Ich habe es mit einem Arduino Uno, einem Arduino Nano, mit einem Wemos D1 mini und Tasmota und auch esp easy versucht. Beim Wemus mit und ohne Pegelwandler. Das Ergebniss ist immer gleich. Strom bleibt auf 0,00 A!
                                      Es können doch nicht beide PZEM defekt sein!

                                      edition

                                      B Offline
                                      B Offline
                                      Beowolf
                                      schrieb am zuletzt editiert von
                                      #200

                                      @edition
                                      Ohne Anschlußplan oder ein Bild vom Anschluß ist das etwas schwer zu sagen.

                                      Die Natur braucht nicht unseren Schutz, sie braucht unsere Abwesenheit.

                                      1 Antwort Letzte Antwort
                                      0
                                      • E Offline
                                        E Offline
                                        edition
                                        schrieb am zuletzt editiert von
                                        #201

                                        Im Moment hängt der PZEM am Arduino Nano. +5V ist an 5V, Masse an GND, RX und TX an D12 bzw. D13. Der geteilte Stromwandler hängt am Netzkabel des Heizlüfters, Netzkabel des PZEM ist Phasenrichtig an der gleichen Steckdose eingesteckt. Alle 30 sec blinken die RX/TX LED´s des PZEM kurz auf. Dann wird im Seriellen Monitor der Arduino IDE ein neuer Wertesatz angezeigt.

                                        09:45:07.865 -> Custom Address:1
                                        09:45:07.985 -> Voltage: 234.30V
                                        09:45:07.985 -> Current: 0.00A
                                        09:45:07.985 -> Power: 0.00W
                                        09:45:07.985 -> Energy: 0.001kWh
                                        09:45:07.985 -> Frequency: 50.0Hz
                                        09:45:07.985 -> PF: 0.00
                                        
                                        

                                        Der Heizlüfter ist gerade aus. Wenn ich ihn einschalte, ändert sich an den Werten nichts!

                                        B 1 Antwort Letzte Antwort
                                        0
                                        • E edition

                                          Im Moment hängt der PZEM am Arduino Nano. +5V ist an 5V, Masse an GND, RX und TX an D12 bzw. D13. Der geteilte Stromwandler hängt am Netzkabel des Heizlüfters, Netzkabel des PZEM ist Phasenrichtig an der gleichen Steckdose eingesteckt. Alle 30 sec blinken die RX/TX LED´s des PZEM kurz auf. Dann wird im Seriellen Monitor der Arduino IDE ein neuer Wertesatz angezeigt.

                                          09:45:07.865 -> Custom Address:1
                                          09:45:07.985 -> Voltage: 234.30V
                                          09:45:07.985 -> Current: 0.00A
                                          09:45:07.985 -> Power: 0.00W
                                          09:45:07.985 -> Energy: 0.001kWh
                                          09:45:07.985 -> Frequency: 50.0Hz
                                          09:45:07.985 -> PF: 0.00
                                          
                                          

                                          Der Heizlüfter ist gerade aus. Wenn ich ihn einschalte, ändert sich an den Werten nichts!

                                          B Offline
                                          B Offline
                                          Beowolf
                                          schrieb am zuletzt editiert von
                                          #202

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

                                          Der geteilte Stromwandler hängt am Netzkabel des Heizlüfters

                                          Sitzt der Stromwandler um die komplette Leitung oder nur um eine Ader?

                                          Die Natur braucht nicht unseren Schutz, sie braucht unsere Abwesenheit.

                                          1 Antwort Letzte Antwort
                                          0
                                          Antworten
                                          • In einem neuen Thema antworten
                                          Anmelden zum Antworten
                                          • Älteste zuerst
                                          • Neuste zuerst
                                          • Meiste Stimmen


                                          Support us

                                          ioBroker
                                          Community Adapters
                                          Donate

                                          634

                                          Online

                                          32.4k

                                          Benutzer

                                          81.4k

                                          Themen

                                          1.3m

                                          Beiträge
                                          Community
                                          Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                                          ioBroker Community 2014-2025
                                          logo
                                          • Anmelden

                                          • Du hast noch kein Konto? Registrieren

                                          • Anmelden oder registrieren, um zu suchen
                                          • Erster Beitrag
                                            Letzter Beitrag
                                          0
                                          • Aktuell
                                          • Tags
                                          • Ungelesen 0
                                          • Kategorien
                                          • Unreplied
                                          • Beliebt
                                          • GitHub
                                          • Docu
                                          • Hilfe