nD-enerserve Forums

Hallo,

hier ist ein kleines Projekt, bei dem ich den SmartPi mit einem ESP32 NodeMCU auslese und diese Daten dann über MQTT verteile. Es werden keine Daten gespeichert.

Als Grundlage wird das Projekt Basecamp von der Zeitschrift ct genommen. Bei diesen Projekt hat man bereits eine Weboberfläche für die W-LAN und für die MQTT Einstellungen.

https://github.com/merlinschumacher/Basecamp

Benötigte Hardware

1 x SmartPi: https://shop.enerserve.eu/smartpi/262/smartpi-2.0
1 x ESP32 NodeMCU (oder ähnliches) https://www.amazon.de
2 x 3 kOhm Widerstand

IDE

Als IDE wird die Arduino IDE benutzt: https://www.arduino.cc/en/Main/Software
Die Desktop Version runterladen und installieren.

Im nächsten Schritt muss noch die Informationen für den ESP32 ins Arduino geladen werden. Dazu folgen Sie bitte diese Anleitung: https://github.com/espressif/arduino-esp32

Nun können Sie in der Arduino IDE unter "Werkzeuge" => "Board" das "ESP32 Dev Module" auswählen.

Bibliotheken laden

Es gibt die Möglichkeit die Bibliotheken direkt über die Arduino IDE runter zu laden. Allerdings sind diese nicht immer auf den aktuellsten Stand. Daher empfehle ich die Bibliotheken von Hand runter zu laden und dann in die Arduino IDE hinzuzufügen.

Dazu bitte bei folgenden Bibliotheken wir folgt vorgehen:
- Bei GitHub auf "Clone or download" klicken und als ZIP Datei runter laden
- In der Arduino IDE "Sketch" => "Bibliotheken einbinden" => ".ZIP Bibliothek hinzufügen .." und die Datei auswählen

https://github.com/merlinschumacher/Basecamp
https://github.com/me-no-dev/ESPAsyncWebServer
https://github.com/bblanchon/ArduinoJson
https://github.com/marvinroger/async-mqtt-client
https://github.com/me-no-dev/AsyncTCP

SmartPi mit dem ESP32 verbinden

Die PINs +5V, GND, SCL und SDA müssen mit verbunden werden.
[attachment=60]

Zusätzlich benötigen die I2C Leitungen jeweils noch einen 3 kOhm PullUp Widerstand zu 3,3V da die PullUp Widerstände auf dem SmartPi zu groß sind für den ESP32.
[attachment=61]

Software

Erstelle ein neues Arduino Projekt und füge den Code ein.

Hier kann man den Topic Namen für MQTT anpassen
#define TOPIC "SmartESP"

Intervall zum Auslesen des SmartPi. Angabe in ms
#define DELAY 5000

Überprüfen und Hochladen:

Code:
#include <Basecamp.hpp>

#include <Wire.h>

Basecamp iot;

#define TOPIC "SmartESP"

#define DELAY 5000

#define ADE_ADDRESS  0x38

#define BUFSIZE 4

#define PI 3.141592654

#define ADE7878_CLOCK   256000

#define FACTOR_CIRCLE   360

#define   FACTOR_1   256

#define   FACTOR_2   65536

#define   FACTOR_3   16777216

#define   RMS_FACTOR_VOLTAGE   2427873

#define   CURRENT_RESISTOR_A   7.07107

#define   CURRENT_RESISTOR_B   7.07107

#define   CURRENT_RESISTOR_C   7.07107

#define   CURRENT_RESISTOR_N   7.07107

#define   CURRENT_CLAMP_FACTOR_A   0.05

#define   CURRENT_CLAMP_FACTOR_B   0.05

#define   CURRENT_CLAMP_FACTOR_C   0.05

#define   CURRENT_CLAMP_FACTOR_N   0.05

#define   OFFSET_CURRENT_A   0.97129167

#define   OFFSET_CURRENT_B   0.97129167

#define   OFFSET_CURRENT_C   0.97129167

#define   OFFSET_CURRENT_N   0.97129167

#define   OFFSET_VOLTAGE_A   1.0

#define   OFFSET_VOLTAGE_B   1.0

#define   OFFSET_VOLTAGE_C   1.0

#define  POWER_CORRECTION_FACTOR_A   0.019413

#define   POWER_CORRECTION_FACTOR_B   0.019413

#define   POWER_CORRECTION_FACTOR_C   0.019413

int write_i2c(char data[],unsigned char length)

{

   unsigned char i;

   Wire.beginTransmission(ADE_ADDRESS);

   for(i=0;i<length;i++)

   {

     Wire.write(data[i]);

   }

   Wire.endTransmission();

   return i;

}

int read_i2c(char * data, int length)

{

  unsigned char i;

  unsigned char ret;

  Wire.requestFrom(ADE_ADDRESS,length);

  ret=Wire.available();

  if(ret!=length) return -1; 

  for(i=0;i<ret;i++)

    data[i] = Wire.read(); 

  return ret;

}

void mqtt_publish(char name[],double data)

{

    char string[20];

    char topic[100];

    sprintf(string,"%.4f",data);

    sprintf(topic,"%s/%s",TOPIC,name);

    iot.mqtt.publish(topic, 1, true, string);

}

int init_ade7878()

{

  Wire.begin();

  Serial.println("init");

  char data[10];

  int i;

  data[0] = 0xEC;//0xEC01 (CONFIG2-REGISTER)

  data[1] = 0x01;

  data[2] = 0x02;//00000010 --> Bedeutet I2C-Lock (I2C ist nun die gewählte Übertragungsart)

  if(write_i2c( data, 3) != 3)  return -1;

  data[0] = 0xEC;//0xEC01 (CONFIG2-REGISTER)

  if(write_i2c( data, 1) != 1) return -1;

  data[0] = 0xE7;//0xE7FE writeprotection

  data[1] = 0xFE;

  data[2] = 0xAD;

  if(write_i2c( data, 3) != 3) return -1;

  data[0] = 0xE7;//0xE7E3 writeprotection OFF

  data[1] = 0xE3;

  data[2] = 0x00;

  if(write_i2c( data, 3) != 3) return -1;

  data[0] = 0xE6;//0xE60E (COMPMODE-REGISTER)

  data[1] = 0x0E;

  data[2] = 0x01;//50HZ 0x60 60HZ

  data[3] = 0xFF;

  if(write_i2c( data, 4) != 4) return -1;

  data[0] = 0x43;//0x43B5 (DICOEFF-REGISTER)

  data[1] = 0xB5;

  data[2] = 0xFF;

  data[3] = 0x80;

  data[4] = 0x00;

  if(write_i2c( data, 5) != 5) return -1;

  data[0] = 0x43;//0x43AB (WTHR1-REGISTER)

  data[1] = 0xAB;

  data[2] = 0x00;

  data[3] = 0x00;

  data[4] = 0x00;

  data[5] = 0x17;

  if(write_i2c( data, 6) != 6) return -1;

  data[0] = 0x43;//0x43AC (WTHR0-REGISTER)

  data[1] = 0xAC;

  data[2] = 0x00;

  data[3] = 0x85;

  data[4] = 0x60;

  data[5] = 0x16;

  if(write_i2c( data, 6) != 6) return -1;

  data[0] = 0x43;//0x43B3 (VLEVEL-REGISTER)

  data[1] = 0xB3;

  data[2] = 0x00;

  data[3] = 0x0C;

  data[4] = 0xEC;

  data[5] = 0x85;

  if(write_i2c( data, 6) != 6) return -1;

  delay(875);

  data[0] = 0x43;//0x4381 (AVGAIN-REGISTER)

  data[1] = 0x81;

  data[2] = 0xFF;

  data[3] = 0xFC;

  data[4] = 0x1C;

  data[5] = 0xC2;

  if(write_i2c( data, 6) != 6) return -1;

  data[0] = 0x43;//0x4383 (BVGAIN-REGISTER)

  data[1] = 0x83;

  data[2] = 0xFF;

  data[3] = 0xFC;

  data[4] = 0x1C;

  data[5] = 0xC2;

  if(write_i2c( data, 6) != 6) return -1;

  data[0] = 0x43;//0x4385 (CVGAIN-REGISTER)

  data[1] = 0x85;

  data[2] = 0xFF;

  data[3] = 0xFC;

  data[4] = 0x1C;

  data[5] = 0xC2;

  if(write_i2c( data, 6) != 6) return -1;

  data[0] = 0xE7;//0xE702 LCYCMODE

  data[1] = 0x02;

  data[2] = 0x0F;

  if(write_i2c( data, 3) != 3) return -1;

  data[0] = 0xE6;//0xE60C LINECYC

  data[1] = 0x0C;

  data[2] = 0xC8;

  if(write_i2c( data, 3) != 3) return -1;

  data[0] = 0xE7;//0xE7FE writeprotection

  data[1] = 0xFE;

  data[2] = 0xAD;

  if(write_i2c( data, 3) != 3) return -1;

  data[0] = 0xE7;//0xE7E3 writeprotection

  data[1] = 0xE3;

  data[2] = 0x80;

  if(write_i2c( data, 3) != 3) return -1;

  data[0] = 0xE2;//0xE228 (RUN-Register)

  data[1] = 0x28;

  data[2] = 0x00;

  data[3] = 0x01;

  if(write_i2c( data, 4) != 4) return -1;

  return 0;

}

int read_ade7878()

{

    Serial.println("read");

    double ua=230,ub=230,uc=230,ia=0,ib=0,ic=0,pa=0,pb=0,pc=0,pac=0,cosa=1,cosb=1,cosc=1,hza=50,hzb=50,hzc=50,pfa,pfb,pfc;

    double awatt,ava,avar,bwatt,bva,bvar,cwatt,cva,cvar;

    char data[30],data_out[20];

    float ergebnis;

    double VAL = PI / 180.0;

    double rms_factor_current = 4191910;

    double ia_corr=1,ib_corr=1,ic_corr=1;

    char ua_gemessen=1,ub_gemessen=1,uc_gemessen=1;

    char string[100];

    ua_gemessen=1;

    ub_gemessen=1;

    uc_gemessen=1;

    //0 current phase a

    data_out[0] = 0x43;//0x43C0 (AIRMS; Current rms an A)

    data_out[1] = 0xC0;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, 4) != 4) return -1;

    ergebnis=(double) (FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    ia=((((ergebnis * 0.3535) / rms_factor_current) / CURRENT_RESISTOR_A) / CURRENT_CLAMP_FACTOR_A) * 100.0 * OFFSET_CURRENT_A;

    //1 current phase b

    data_out[0] = 0x43;//0x43C2 (BIRMS; Current rms an B)

    data_out[1] = 0xC2;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(double) (FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    ib=((((ergebnis * 0.3535) / rms_factor_current) / CURRENT_RESISTOR_B) / CURRENT_CLAMP_FACTOR_B) * 100.0 * OFFSET_CURRENT_B;

    //2 current phase c

    data_out[0] = 0x43;//0x43C4 (CIRMS; Current rms an C)

    data_out[1] = 0xC4;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(double) (FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    ic=((((ergebnis * 0.3535) / rms_factor_current) / CURRENT_RESISTOR_C) / CURRENT_CLAMP_FACTOR_C) * 100.0 * OFFSET_CURRENT_C;

    //3 current phase n

    //4 voltage phase a

    data_out[0] = 0x43;//0x43C1 (AVRMS; Voltage rms an A)

    data_out[1] = 0xC1;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    if( ergebnis/10000 > 100) ua=ergebnis/10000;

    else ua_gemessen=0;

    //5 voltage phase b

    data_out[0] = 0x43;//0x43C3 (BVRMS; Voltage rms an B)

    data_out[1] = 0xC3;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    if( ergebnis/10000 > 100) ub=ergebnis/10000;

    else ub_gemessen=0;

    //6 voltage phase c

    data_out[0] = 0x43;//0x43C5 (CVRMS; Voltage rms an C)

    data_out[1] = 0xC5;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    if( ergebnis/10000 > 100) uc=ergebnis/10000;

    else uc_gemessen=0;

    //7  Phase A total active power.

    data_out[0] = 0xE5;//0xE513 (AWATT total active power an A)

    data_out[1] = 0x13;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_3*data[0])+(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    if( ua_gemessen) awatt=(ergebnis*POWER_CORRECTION_FACTOR_A);

    else awatt=ia*ua;

    //8  Phase B total active power.

    data_out[0] = 0xE5;//0xE514 (BWATT total active power an B)

    data_out[1] = 0x14;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_3*data[0])+(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    if( ub_gemessen) bwatt=(ergebnis*POWER_CORRECTION_FACTOR_B);

    else bwatt=ib*ub;

    //9  Phase C total active power.

    data_out[0] = 0xE5;//0xE515 (CWATT total active power an C)

    data_out[1] = 0x15;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_3*data[0])+(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    if( uc_gemessen) cwatt=(ergebnis*POWER_CORRECTION_FACTOR_C);

    else cwatt=ic*uc;

    //10 cosphi phase a

    data_out[0] = 0xE6;//0xE601 (ANGLE0 cosphi an A)

    data_out[1] = 0x01;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, 2) != 2) return -1;

    ergebnis=(FACTOR_1*data[0])+data[1];

    if( ua_gemessen) cosa=cos(ergebnis * FACTOR_CIRCLE * 50 / ADE7878_CLOCK * VAL);

    else cosa=1;

    //11 cosphi phase b

    data_out[0] = 0xE6;//0xE601 (ANGLE1 cosphi an B)

    data_out[1] = 0x02;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, 2) != 2) return -1;

    ergebnis=(FACTOR_1*data[0])+data[1];

    if( ub_gemessen) cosb=cos(ergebnis * FACTOR_CIRCLE * 50 / ADE7878_CLOCK * VAL);

    else cosb=1;

    //12 cosphi phase c

    data_out[0] = 0xE6;//0xE601 (ANGLE2 cosphi an C)

    data_out[1] = 0x03;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, 2) != 2) return -1;

    ergebnis=(FACTOR_1*data[0])+data[1];

    if( uc_gemessen) cosc=cos(ergebnis * FACTOR_CIRCLE * 50 / ADE7878_CLOCK * VAL);

    else cosc=1;

    //13 frequency phase a

    data_out[0] = 0xE7;//MMODE-Register measure frequency at VA

    data_out[1] = 0x00;

    data_out[2] = 0x1C;

    if(write_i2c(data_out, 3) != 3) return -1;

    delay(50);

    data_out[0] = 0xE6;//0xE607 (PERIOD)

    data_out[1] = 0x07;

    if(write_i2c(data_out, 2) != 2) return -1;

    if (read_i2c(data, 2) != 2) return -1;

    ergebnis=(FACTOR_1*data[0])+data[1];

    hza=(double) ADE7878_CLOCK / (ergebnis +1 );

    //14 frequency phase b

    data_out[0] = 0xE7;//MMODE-Register measure frequency at VB

    data_out[1] = 0x00;

    data_out[2] = 0x1D;

    if(write_i2c(data_out, 3) != 3) return -1;

    delay(50);

    data_out[0] = 0xE6;//0xE607 (PERIOD)

    data_out[1] = 0x07;

    if(write_i2c(data_out, 2) != 2) return -1;

    if (read_i2c(data, 2) != 2) return -1;

    ergebnis=(FACTOR_1*data[0])+data[1];

    hzb=(double) ADE7878_CLOCK / (ergebnis +1 );

    //15 frequency phase c

    data_out[0] = 0xE7;//MMODE-Register measure frequency at VC

    data_out[1] = 0x00;

    data_out[2] = 0x1E;

    if(write_i2c(data_out, 3) != 3) return -1;

    delay(50);

    data_out[0] = 0xE6;//0xE607 (PERIOD)

    data_out[1] = 0x07;

    if(write_i2c(data_out, 2) != 2) return -1;

    if (read_i2c(data, 2) != 2) return -1;

    ergebnis=(FACTOR_1*data[0])+data[1];

    hzc=(double) ADE7878_CLOCK / (ergebnis +1 );

    //16 Phase A total apparent power.

    data_out[0] = 0xE5;//0xE519 (AVA total apparent power an A)

    data_out[1] = 0x19;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_3*data[0])+(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    ava=ergebnis;

    //17 Phase B total apparent power.

    data_out[0] = 0xE5;//0xE519 (BVA total apparent power an B)

    data_out[1] = 0x1A;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_3*data[0])+(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    bva=ergebnis;

    //18 Phase C total apparent power.

    data_out[0] = 0xE5;//0xE519 (CVA total apparent power an C)

    data_out[1] = 0x1B;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_3*data[0])+(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    cva=ergebnis;

    //19 Phase A total reactive power.

    data_out[0] = 0xE5;//0xE516 (AVAR total reactive power an A)

    data_out[1] = 0x16;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_3*data[0])+(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    avar=ergebnis;

    //20 Phase A total reactive power.

    data_out[0] = 0xE5;//0xE516 (AVAR total reactive power an B)

    data_out[1] = 0x17;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_3*data[0])+(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    bvar=ergebnis;

    //21 Phase A total reactive power.

    data_out[0] = 0xE5;//0xE516 (AVAR total reactive power an C)

    data_out[1] = 0x18;

    if(write_i2c(data_out, 2) != 2) return -1;

    if(read_i2c(data, BUFSIZE) != BUFSIZE) return -1;

    ergebnis=(FACTOR_3*data[0])+(FACTOR_2*data[1])+(FACTOR_1*data[2])+data[3];

    cvar=ergebnis;

    pa=awatt*(-1.0);

    pb=bwatt*(-1.0);

    pc=cwatt*(-1.0);

    if( ua_gemessen)

    {

      if(avar<0)

        pfa=awatt/POWER_CORRECTION_FACTOR_A/ava;

      else

        pfa=awatt/POWER_CORRECTION_FACTOR_A/ava*(-1.0);

      ia=ia*fabs(pfa);

    }

    if( ub_gemessen)

    {

      if(bvar<0)

        pfb=bwatt/POWER_CORRECTION_FACTOR_B/bva;

      else

        pfb=bwatt/POWER_CORRECTION_FACTOR_B/bva*(-1.0);

      ib=ib*fabs(pfb);

    }

    if( uc_gemessen)

    {

      if(cvar<0)

        pfc=cwatt/POWER_CORRECTION_FACTOR_C/cva;

      else

        pfc=cwatt/POWER_CORRECTION_FACTOR_C/cva*(-1.0);

      ic=ic*fabs(pfc);

    }

    pac=pa+pb+pc;

    if(pac>=0)

    {

      sprintf(string,"BEZUG: %f",pac);

      Serial.println(string);

    }

    else

    {

      sprintf(string,"EINSPEISUNG: %f",pac);

      Serial.println(string);

    }

    mqtt_publish("P0",pac);

    mqtt_publish("P1",pa);

    mqtt_publish("P2",pb);

    mqtt_publish("P3",pc);

    mqtt_publish("COS1",cosa);

    mqtt_publish("COS2",cosb);

    mqtt_publish("COS3",cosc);

    mqtt_publish("I1",ia);

    mqtt_publish("I2",ib);

    mqtt_publish("I3",ic);

    mqtt_publish("U1",ua);

    mqtt_publish("U2",ub);

    mqtt_publish("U3",uc);

    mqtt_publish("HZ1",hza);

    mqtt_publish("HZ2",hzb);

    mqtt_publish("HZ3",hzc);

    mqtt_publish("PF1",pfa);

    mqtt_publish("PF2",pfb);

    mqtt_publish("PF3",pfc);

    mqtt_publish("VAR1",avar);

    mqtt_publish("VAR2",bvar);

    mqtt_publish("VAR3",cvar);

    mqtt_publish("VA1",ava);

    mqtt_publish("VA2",bva);

    mqtt_publish("VA3",cva);

    sprintf(string,"Leistung : %.4f %.4f %.4f = %.4f W",pa,pb,pc,pac);

    Serial.println(string);

    sprintf(string,"Cos Phi  : %.4f %.4f %.4f",cosa,cosb,cosc);

    Serial.println(string);

    sprintf(string,"PF     : %.4f %.4f %.4f",pfa,pfb,pfc);

    Serial.println(string);

    sprintf(string,"VAR    : %.4f %.4f %.4f",avar,bvar,cvar);

    Serial.println(string);

    sprintf(string,"VA     : %.4f %.4f %.4f",ava,bva,cva);

    Serial.println(string);

    sprintf(string,"Strom    : %.4f %.4f %.4f A",ia,ib,ic);

    Serial.println(string);

    sprintf(string,"Spannung : %.4f %.4f %.4f V",ua,ub,uc);

    Serial.println(string);

    sprintf(string,"Frequenz : %.4f %.4f %.4f Hz",hza,hzb,hzc);

    Serial.println(string);

    delay(DELAY);

}

void setup() {

  iot.begin();

  init_ade7878();

  Serial.println(WiFi.localIP());

}

void loop() {

   read_ade7878();

}

MQTT

Gesamtleistung [W]: P0
Leistung L1 [W]: P1
Leistung L2 [W]: P2
Leistung L3 [W]: P3

Cos L1 []: COS1
Cos L2 []: COS2
Cos L3 []: COS3

Strom L1 [A]: I1
Strom L2 [A]: I2
Strom L3 [A]: I3

Spannung L1 [V]: U1
Spannung L2 [V]: U2
Spannung L3 [V]: U3

Frequenz L1 [Hz]: HZ1
Frequenz L2 [Hz]: HZ2
Frequenz L3 [Hz]: HZ3

Power Faktor L1 [Hz]: PF1
Power Faktor L2 [Hz]: PF2
Power Faktor L3 [Hz]: PF3

Blindleistung L1 [Hz]: VAR1
Blindleistung L2 [Hz]: VAR2
Blindleistung L3 [Hz]: VAR3

Scheinleistung L1 [Hz]: VA1
Scheinleistung L2 [Hz]: VA2
Scheinleistung L3 [Hz]: VA3

Stromversorgung

Variante 1: Stromversorgung über den ESP32
Wenn man nur die Stromklemmen anschließen möchte, ohne die Spannung anschließen zu wollen, kann man das ganze über ein 5V Netzteil versorgen

Variante 2: Stromversorgung über den SmartPi
Man kann den ESP32 auch über den SmartPi mit 230V versorgen. Dazu müssen 230V an L und N angeschlossen werden. Siehe Handbuch: https://shop.enerserve.eu/media/pdf/8b/8...Pi-2-0.pdf

Inbetriebnahme

Nachdem der SmartPi und der ESP32 mit Strom versorgt sind, baut der ESP32 ein W-LAN Access Point auf.
Verbinden Sie sich z.B. mit Handy mit dem WLAN Netzwerk "ESP32".
Rufen Sie die Webseite "192.168.4.1" auf.
Hier können Sie die SSID und Passwort Ihres W-LAN Netzwerkes einstellen, sowie den MQTT Broker.
Nach dem Speichern wird der ESP32 neu gestartet und das System ist fertig eingerichtet.

clemens