Compatibilité compteur connecté EM06P (Meross, Refoss)

Code :
//*********************************************************************

// Variante EM06P                                                    *

// Adaptation basée sur un exemple réel de réponse JSON de l'EM06P :  *

//                                                                     *

// {"status":[                                                        *

//   {"id":1,"current":2.319,"voltage":228.614,"power":-155.988,      *

//    "pf":-0.29,"year_energy":294.99,"year_ret_energy":-259.035,     *

//    "month_energy":...,"week_energy":...,"day_energy":...},         *

//   {"id":2, ...}, ... jusqu'à {"id":6, ...}                         *

// ]}                                                                  *

//                                                                     *

// L'EM06P ne fournit PAS de compteur d'énergie cumulé depuis          *

// toujours (pas de "total_act_energy" façon Shelly). Le champ le     *

// plus proche est "year_energy" (kWh, flottant) mais il repart à     *

// zéro chaque 1er janvier.                                           *

// ********************************************************************

// * Paramétrage des voies pour le EM06P :                             *

// *   - EnphaseSerial (0 à 5) = numéro de la voie/pince du routeur   *

// *     (voie "M"). L'EM06P a 6 voies, mais leurs "id" JSON vont     *

// *     de 1 à 6 -> conversion +1 faite dans le code.                 *

// *   - VOIE_SECONDAIRE_EM06P_ID (constante ci-dessous) = voie "T"   *

// *     (ex: production PV). Fixée en dur à l'id 4 : adaptez cette   *

// *     valeur si votre câblage change.                               *

// *                                                                    *

// * IMPORTANT : contrairement au Shelly (qui nécessitait une requête *

// * HTTP séparée par voie, d'où l'ancienne logique d'alternance sur  *

// * plusieurs cycles), l'EM06P renvoie TOUTES les voies en une seule *

// * requête. On extrait donc M et T à CHAQUE appel, pour une         *

// * régulation plus réactive (plus d'alternance qui ne rafraîchissait*

// * la voie du routeur qu'une fois sur 5 cycles environ).            *

// ********************************************************************



// id JSON (1 à 6) de la voie secondaire T - à adapter si besoin

const int VOIE_SECONDAIRE_EM06P_ID = 4;



// Extrait le sous-objet JSON {"id":N, ...} d'une chaîne "status":[...]

// Hypothèse : les objets de voie ne contiennent que des champs scalaires

// (pas de sous-objet imbriqué), donc la première "}" après le "id":N

// correspond bien à la fin de l'objet de cette voie.

String ExtraitVoieEM06P(int id, String &data) {

  String cle = "\"id\":" + String(id) + ",";

  int debut = data.indexOf(cle);

  if (debut < 0) return "";

  debut = data.lastIndexOf("{", debut);

  int fin = data.indexOf("}", debut);

  if (fin < 0) return "";

  return data.substring(debut, fin + 1);

}



// Extrait les grandeurs (Pw, voltage, pf, énergies jour/année) d'un

// sous-objet de voie déjà isolé (résultat de ExtraitVoieEM06P).

void LectureVoieEM06P(String &tmp, float &Pw, float &voltage, float &pf,

                       long &energieSoutireeWh, long &energieInjecteeWh,

                       long &jourSoutireeWh, long &jourInjecteeWh) {

  // Convention confirmée par observation terrain : power négatif = injection

  // réelle, power positif = soutirage réel. Pas d'inversion nécessaire.

  Pw = ValJson("power", tmp);

  voltage = ValJson("voltage", tmp);

  pf = abs(ValJson("pf", tmp));

  if (pf > 1) pf = 1;



  // Compteur d'énergie "année" en kWh -> converti en Wh (cf. limitation

  // en tête de fichier : ce compteur repart à zéro chaque année).

  float yearEnergy = ValJson("year_energy", tmp);

  float yearRetEnergy = ValJson("year_ret_energy", tmp);

  energieSoutireeWh = (long)(abs(yearEnergy) * 1000.0);

  energieInjecteeWh = (long)(abs(yearRetEnergy) * 1000.0);



  // Compteur d'énergie "jour" (kWh -> Wh), fourni directement par l'EM06P,

  // remis à zéro chaque minuit par l'appareil lui-même : utilisé tel quel,

  // sans calcul de delta (voir EnergieQuotidienne() dans le sketch principal).

  float dayEnergy = ValJson("day_energy", tmp);

  float dayRetEnergy = ValJson("day_ret_energy", tmp);

  jourSoutireeWh = (long)(abs(dayEnergy) * 1000.0);

  jourInjecteeWh = (long)(abs(dayRetEnergy) * 1000.0);

}



void LectureEM06P() {

  String EM06P_Data = "";

  String tmp;



  WiFiClient clientESP_RMS;

  String host = IP2String(RMSextIP);



  const int NB_VOIES = 6;  // EM06P : 6 voies monophasées indépendantes

  int idM = (EnphaseSerial.toInt() % NB_VOIES) + 1;  // id JSON de la voie routeur (1 à 6)

  int p;

  unsigned long timeout = millis();



  // id=65535 = id spécial qui renvoie le statut des 6 voies en une requête

  String url = "/rpc/Em.Status.Get?id=65535";



  if (!clientESP_RMS.connect(host.c_str(), 80, 3000)) {

    delay(500);

    if (!clientESP_RMS.connect(host.c_str(), 80, 3000)) {

      delay(100);

      clientESP_RMS.stop();

      StockMessage("connection to EM06P failed : " + host);

      delay(200);

      return;

    }

  }



  clientESP_RMS.print(String("GET ") + url + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");



  // Lecture robuste : on attend la fermeture de la connexion par le serveur

  // (Connection: close) plutôt que de s'arrêter dès qu'il n'y a momentanément

  // plus de données disponibles - la réponse peut arriver en plusieurs paquets.

  bool gotData = false;

  timeout = millis();

  while (millis() - timeout < 5000) {

    while (clientESP_RMS.available()) {

      EM06P_Data += (char)clientESP_RMS.read();

      timeout = millis();  // on relance le délai tant que des données arrivent

      gotData = true;

    }

    if (!clientESP_RMS.connected() && !clientESP_RMS.available()) {

      break;  // le serveur a fermé la connexion et il n'y a plus rien à lire

    }

  }

  clientESP_RMS.stop();

  if (!gotData) {

    StockMessage("client EM06P Timeout ! : " + host);

    return;

  }

  p = EM06P_Data.indexOf("{");

  if (p < 0) {

    StockMessage("EM06P : aucune accolade '{' trouvée dans la réponse");

    filtre_puissance();

    PuissanceRecue = true;

    return;

  }

  EM06P_Data = EM06P_Data.substring(p);



  String brute = "";



  // --- Voie M (routeur) --- lue à chaque appel

  tmp = ExtraitVoieEM06P(idM, EM06P_Data);

  if (tmp != "") {

    brute += "<strong>EM06P voie M (id " + String(idM) + ")</strong><br>" + tmp + "<br>";



    float Pw, voltage, pf;

    long energieSoutireeWh, energieInjecteeWh, jourSoutireeWh, jourInjecteeWh;

    LectureVoieEM06P(tmp, Pw, voltage, pf, energieSoutireeWh, energieInjecteeWh, jourSoutireeWh, jourInjecteeWh);



    if (Pw >= 0) {

      PuissanceS_M_inst = Pw;

      PuissanceI_M_inst = 0;

      PVAS_M_inst = (pf > 0.01) ? PfloatMax(Pw / pf) : 0;

      PVAI_M_inst = 0;

    } else {

      PuissanceS_M_inst = 0;

      PuissanceI_M_inst = -Pw;

      PVAI_M_inst = (pf > 0.01) ? PfloatMax(-Pw / pf) : 0;

      PVAS_M_inst = 0;

    }

    Energie_M_Soutiree = energieSoutireeWh;

    Energie_M_Injectee = energieInjecteeWh;

    EnergieJour_M_Soutiree = jourSoutireeWh;

    EnergieJour_M_Injectee = jourInjecteeWh;

    PowerFactor_M = pf;

    Tension_M = voltage;

    Pva_valide = true;

  } else {

    StockMessage("EM06P : voie M (id " + String(idM) + ") introuvable dans la réponse JSON");

  }



  // --- Voie T (secondaire, ex: PV) --- lue à chaque appel elle aussi

  tmp = ExtraitVoieEM06P(VOIE_SECONDAIRE_EM06P_ID, EM06P_Data);

  if (tmp != "") {

    brute += "<strong>EM06P voie T (id " + String(VOIE_SECONDAIRE_EM06P_ID) + ")</strong><br>" + tmp;



    float Pw, voltage, pf;

    long energieSoutireeWh, energieInjecteeWh, jourSoutireeWh, jourInjecteeWh;

    LectureVoieEM06P(tmp, Pw, voltage, pf, energieSoutireeWh, energieInjecteeWh, jourSoutireeWh, jourInjecteeWh);



    if (LissageLong) {

      PwMoy2 = 0.2 * Pw + 0.8 * PwMoy2;

      pfMoy2 = 0.2 * pf + 0.8 * pfMoy2;

      Pw = PwMoy2;

      pf = pfMoy2;

    }

    if (Pw >= 0) {

      PuissanceS_T_inst = Pw;

      PuissanceI_T_inst = 0;

      PVAS_T_inst = (pf > 0.01) ? PfloatMax(Pw / pf) : 0;

      PVAI_T_inst = 0;

    } else {

      PuissanceS_T_inst = 0;

      PuissanceI_T_inst = -Pw;

      PVAI_T_inst = (pf > 0.01) ? PfloatMax(-Pw / pf) : 0;

      PVAS_T_inst = 0;

    }

    Energie_T_Soutiree = energieSoutireeWh;

    Energie_T_Injectee = energieInjecteeWh;

    EnergieJour_T_Soutiree = jourSoutireeWh;

    EnergieJour_T_Injectee = jourInjecteeWh;

    PowerFactor_T = pf;

    Tension_T = voltage;

  } else {

    StockMessage("EM06P : voie T (id " + String(VOIE_SECONDAIRE_EM06P_ID) + ") introuvable dans la réponse JSON");

  }



  ShEm_dataBrute = brute;



  filtre_puissance();

  PuissanceRecue = true;

  EnergieActiveValide = true;  // les deux voies sont lues à chaque appel, plus besoin d'alternance

  if (cptLEDyellow > 30) {

    cptLEDyellow = 4;

  }

}