WifiInfo + MQTT + Home Assistant

Schmurtz

Hello, je souhaite intégrer les informations de teleinfo de mon compteur linky à home assistant.
Je pense donc que bénéficier une communication MQTT serait intéressant car elle offrirait un mode de communication ouvert à toutes les plateformes domotiques.

Ce qui m’intéresse c'est notamment la consommation en live (je crois que ça correspond à "Intensité Instantanée" = IINST si j'ai bien suivi) car le reste des informations est (consommation journalière et mensuelle) déjà fournies via l'API d'Enedis et facilement remontables dans Home Assistant.

J'ai pas mal écumé les infos qui découlent du fabuleux travail de @Charles et en cherchant ça et là j'ai pensé que le boulot coté MQTT avait certainement déjà été fait.

Trois sources distinctes je pense mais aucune ne me semble utilisable en l'état :

Un fork ici de LibTeleinfo intégrant MQTT dans l'exemple de "Wifinfo". Impeccable me direz-vous mais un commentaire de @Arnaud-D ici m'inquiète un peu : "je n'ai pas terminé, j'ai un kwak avec la validation crc de la configuration et mes tailles (qui dépendent de l'abonnement".... Et ce commentaire est postérieur au dernier commit sur github
@Seb3d aurait également modifié pour y ajouter MQTT, il affiche même un exemple sur home assistant sur ce post ! Mais impossible de trouver ses sources sur Github ou autre...
@Arly avait également l'intention d'ajouter MQTT (cf. ce post ) mais les sources mises à dispo sur son Google drive datent du 25/5/19 et le même jour il disait : "Cette version est stable mais ne gère pas encore le MQTT."

Ensuite en dehors de la partie MQTT, il y'a probablement des codes plus à jours, gérant par exemple les étiquettes du mode standard du Linky (car à vrai dire je ne sais pas si mon Linky est en mode historique ou standard donc si ça tombe ça ne marchera pas). Les sources d' @Arly Semble gérer le mode standard, je suppose que ce sont celles du Google drive.

Par ailleurs une autre mystérieuse version (qui a l'air vraiment pas mal) de @Charles offre un unique screenshot ici.

Il existe aussi une version sur github qui gère l'OTA et pas mal d'étiquettes supplémentaires.

Vous l'aurez compris je rêve d'une version qui gère MQTT, le mode standard du Linky, l'OTA, etc. Mais ma prio est bien entendu MQTT.

Donc Voici mes questions :

1 - Quelqu'un possède-t-il une source fonctionnelle et compatible ESP8266/wemos qui supporte MQTT ?
2 - Y-a-t-il une ame charitable qui partagerait le fruit de son travail ?

@Seb3d -> Pour ta version MQTT testée avec home assistant.
@Arnaud-D -> Si tu as résolu test "kwak avec la validation crc de la configuration et mes tailles" ce serait top de le publier sur ton github
@Arly -> si tu as fini ta partie MQTT ça peut-être intéressant également !
@Charles -> tu ne parles pas d'intégrer MQTT mais les sondes et le graphique de la nouvelle version ont l'air vraiment cool, une publication est prévue ?

En attendant, merci à tous pour tous ces articles et codes sources, c'est vraiment top de voir ces projets brillants partagés à la communauté qui passionnée par la domotique !
++ !

Schmurtz.

Schmurtz

Hello, bon il n'y a pas foule sur ce forum...

Je suis parvenu à joindre Arnaud, qui je vous le rappelle, a entamé un fork ici visant à être compatible MQTT. Vraiment sympa, il m'a confirmé n'avait pas terminé sa modification pour une raison simple : il est parvenu à faire remonter les informations dans Home Assistant sans modifier le code original de WifInfo. Je cite: "home assistant fait un get vers le endpoint json pour récupérer les données régulièrement. C'était encore plus simple "

En plus Arnaud a partagé sa config Home Assistant sur Github, je vous fait donc profiter de son travail pour remonter les infos de WifInfo facilement dans home assistant, ça se passe là :
https://github.com/Nono31/Home-Assistant-Configuration/blob/master/sensors/rest.yaml

Merci @Arnaud-D pour ces informations !

----------------------------------------------------------------

Je persiste cependant à penser qu'une communication MQTT peut-être utile. Pour info Arnaud a fait l'essentiel du boulot, "il reste un problème surement le stockage de la configuration qui déconne à cause de la taille réservée". Je m'y attèlerai peut-être plus tard

Je ne désespère pas d'arriver à joindre @Seb3d ou @Arly un de ces 4 pour discuter de leurs modifications, si l'admin de ce forum (@Charles ?? :-p) peut me donner un pti coup de pouce en leur envoyant une notification c'est le bienvenu !

admin

Bonjour à tous
Remy avait commencé à travailler sur une version privée nommée NRJMeter, c'est celle avec les graphes et la totale et même avec un simulateur de téléinfo

Comme ni Rémy (maintenant Papa) ni moi même n'avons le temps j'ai décidé d'ouvrir le repository au public
https://github.com/hallard/NRJMeter
Attention Rémy avait mis la béta du framework bootstrap 4 certainement à upgrader, y'a pas mal de boulot de fait mais il en reste encore à faire et certainement que depuis le temps pas mal d'API ont changées.

Voilà perso je n'ai plus du tout le temps de gérer ça peut être un jour si un client me demande un truc dans le genre je reprendrais mais pour le moment je n'ai physiquement pas le temps.

N'hésitez pas à forker et je publierais les Pull Request avec plaisir. Je peux même vous ajouter en collab pour que vous puissiez directement travailler sur le repo sans avoir a gérer des fork dans tous les sens.

Ce serait bien aussi maintenant que c'est libéré de mettre un petit readme histoire de savoir ou on en est et ajouter une license open source.

Voilà, bon courage a vous si vous voulez contribuer et merci poiur votre soutient.

Charles

JG

Bonjour,

j'ai écrit une version avec MQTT, LibTeleinfo.h (merci Charles) , WiFi et OTA pour ESP8266 qui fonctionne correctement, si je peux aider, c'est avec plaisir.
Par contre je n'utilise pas Home Assistant.

JG

Schmurtz

@admin Super, un grand merci Charles !
Je vais regarder tout ça. Je suis certain que ce repo va prendre de l'interet pour la communauté DIY
A bientôt !

Schmurtz

@JG Salut JG, oui, je suis intéressé. J'ai trouvé une solution temporaire mais comme je le disais plus haut je pense qu'une version MQTT pourrait-être bien utile ! Aurais-tu un repo quelque-part sur Github ?

JG

@Schmurtz Bonjour, ne n'ai pas mis ça sur Github, car mon programme ne fait que copier et mettre au point des bouts de code trouvé sur Internet, mais je peux te transmettre des parties de code qui fonctionnent par mail ou ici si tu as besoin de quelque chose de précis.

Schmurtz

@JG Hello, Oui ! si tu peux partager tes sources ici je suis preneur. Dans la mesure du possible l'ensemble du projet ce serait top. Je suis sur que ça rendra service à plus d'une personne

A vrai dire j'avais récupéré les sources d'arnaud et , comme lui, je me suis cassé les dents sur le check CRC réalisé avant de sauvegarder les nouvelles infos MQTT. Bon après une solution aurait été de les sauvegarder autrement... mais voulant faire propre, on est parfois obstiné

Merci en tous cas c'est sympa

JG

Bonjour, ci-après mon programme, il y a certainement plein de choses qui ne serviront pas à d'autres, et des choses à améliorer (je suis dessus!), mais il fonctionne très bien depuis quelques jours déjà. Pour info, j'ai un compteur Linky avec tarif Heures pleines et Heures creuses.
Si cela peut inspirer ou servir à d'autres...

// V1.1 du 15 au 27/03/2020 (confinement!!)
// par Pierre avec les infos et la Lib de Charles pour la Téléinfo,
// et d'autres pour les autres librairies

/* Ce programme reçoit les infos de téléinfo (TIC) d'un compteur électrique
 * et les renvoie par WiFi après traitement à un brocker MQTT.
 * Il se connecte aussi à un serveur NTP afin d'avoir la date et l'heure.
 * Il sauvegarde, au changement de jour, les index des compteurs HC et HP dans la mémoire SPIFFS
 * afin de pouvoir les retrouver si reset ou coupure de courant. Ces index servent à calculer la 
 * consommation du jour en cours.
 * Il calcule la conso du jour HC et HP, le cumul HP+HC et envoie le tout par MQTT.
 */

#include <SoftwareSerial.h>
#include <LibTeleinfo.h>
#include <PubSubClient.h>
#include <ArduinoOTA.h>
#include <NtpClientLib.h>  // attention, version 2.5.1, les supérieures ne fonctionnent pas!
#include <TimeLib.h>
#include <ESP8266WiFi.h>
#include <FS.h>

//*********************** Déclaration des constantes et variables globales utilisées *********************
//********************************************************************************************************
const char* ssid = "freeP";
const char* password = "3493493493";

//NTP config
String ServeurNTP = "ntp.unice.fr";

// MQTT Configuration
IPAddress serverIPAddress(xxx,xxx,xxx,xxx);
const int PortMQTT = xxxx;
WiFiClient espClient;
PubSubClient client(espClient);
String clientId = "Linky"; //Nom du client MQTT
const char *TopicConso = "/Exterieur/Maison/Conso";     // consommation instantanée (PAPP)
const char *TopicHCHP = "/Exterieur/Maison/HCHP";       // Index heures pleines (HCHP)
const char *TopicHCHC = "/Exterieur/Maison/HCHC";       // index heures creuse  (HCHC)
const char *TopicHPJ = "/Exterieur/Maison/HPJ";         // Conso actuelle du jour heures pleines
const char *TopicHCJ = "/Exterieur/Maison/HCJ";         // Conso actuelle du jour heures creuses
const char *TopicHJTotal= "/Exterieur/Maison/HJTotal";  // Conso du jour total (HC + HP)
const char *TopicHPJT = "/Exterieur/Maison/HPJT";       // Total du jour heures pleines
const char *TopicHCJT = "/Exterieur/Maison/HCJT";       // Total du jour heures creuses


// WIFI Configuration
IPAddress MonIP(192,168,xxx,xxx);
IPAddress gateway(192, 168, xxx, xxx);
IPAddress subnet(255, 255, 255, 0);
IPAddress dns(192, 168, xxx, xxx);
 
//On défini un deuxième port serie (entrée RX GPIO 13, Sortie TX GPIO 15)
// seule l'entrée sert à recevoir la trame Linky
SoftwareSerial Serie2(13,15);

TInfo tinfo; 

int NbLoop = 0;             //compteur pour reset si perte Wifi en MQTT
String Conso="";
String JourActuel="";
char *LastHCHP="";
char *LastHCHC="";
char *DebJourHP="005614000";    // au 27/03/20
char *DebJourHC="003488000";    // idem
long HCHPj;
long HCHCj;

//********************************************* SETUP ****************************************************
//********************************************************************************************************
void setup()
{
   //On arrete le serveur Wifi qui fonctionne souvent par défaut!!
  WiFi.softAPdisconnect (true);

  // On passe en mode station, et on se connecte au réseau existant.
  // en mode DHCP afin de pouvoir se connecter au serveur NTP
  WiFi.mode(WIFI_STA); 
  WiFi.begin(ssid, password);

  delay(5000); // attente pour l'établissement des connexions WIFI
  
  Serial.begin(9600); // configure la sortie série "normale" à 9600 Bauds
  Serial.println("début");

  // config et init NTP et jour
  NTP.begin (ServeurNTP,1,true);    // Pour NTP
  NTP.setInterval(86400);           // on interroge le serveur NTP toutes les 24h (86400 s)
  delay(3000);                      // attente pour réponse serveur NTP
  Serial.println (NTP.getTimeDateString ());
  JourActuel = NTP.getDateStr ();
  if (JourActuel=="01/01/1970"){    // il arrive parfois que le serveur NTP ne réponde pas,
    Serial.print ("Reset par soft");// dans ce cas, la date s'initialise au 01/01/1970,
    ESP.restart();                  // donc, on recommence (un peu brutal, mais cela fonctionne!!)
                                    // on pourrait aussi re-interroger le serveur, ou augmenter le delai...
  } 

  // Config SPIFFS
  SPIFFS.begin();
  File f = SPIFFS.open("/config.txt", "r");       // ouverture du fichier en mémoire pour y lire les valeurs 
  if (!f) {                                       // sauvegardées (DebJourHP et DebJourHC)
      Serial.println("file open failed");      
  }
  else{
    while(f.available()) {
      //lecture ligne par ligne du fichier
        f.readStringUntil('\n').toCharArray(DebJourHP,10);
        Serial.print("DebJourHP lu en mémoire = ");Serial.println(DebJourHP);
        f.readStringUntil('\n').toCharArray(DebJourHC,10);
        //String DebJourHCs = f.readStringUntil('\n');
        Serial.print("DebJourHC lu en mémoire = ");Serial.println(DebJourHC);      
    f.close();
    }
  }
  
  // reconfig WIFI pour IP fixe si besoin
  // mais si on passe en IP fixe, le NTP ne fonctionne plus! 
  //WiFi.config(MonIP,gateway,subnet,dns);
  //WiFi.begin(ssid, password);
  //delay(5000); // attente pour l'établissement des connexions WIFI

   //préparation du mode OTA pour pouvoir modifier le programme par WIFI
  ArduinoOTA.setHostname("Un Nom");
  ArduinoOTA.setPassword("Un Mot de passe");
  ArduinoOTA.begin();
   // reset à la fin de l'OTA :
  ArduinoOTA.onEnd([]() {
    ESP.restart();
  });

   // connect to the MQTT server 
  client.setServer(serverIPAddress, PortMQTT);
  
  // Configure Teleinfo Soft serial pour Linky
  Serie2.begin(1200);
 
  // Init teleinfo
  tinfo.init();
 
  // Attache la procédure de callback 
  tinfo.attachData(DataCallback);
  
} // Fin de setup

 //*************************************** Boucle principale **********************************************
//********************************************************************************************************
void loop()
{
  //gestion de l'OTA
  ArduinoOTA.handle();
  
  if ( Serie2.available() )
    tinfo.process(Serie2.read());
    
} // fin de loop

//*************************************** Fonctions et procédures ****************************************
//********************************************************************************************************
//procédure appelée suite à une interruption:
void DataCallback(ValueList * me, uint8_t  flags)
{
  
  // Display values
  String Nom="";
  Nom = me->name;
  Conso = me->value;
  
   //  si le jour à changé, on publie la valeur calculée de la conso totale du jour passé
   //  puis on réactualise la valeur de début de journée qui sert à remettre à zéro l'index du jour,
   //  et on sauvegarde cette valeur en mémoire SPIFFS, pour pouvoir la retrouver en cas de reset.
   //  on remet les HC du jour à 0 
   
   String J = NTP.getDateStr ();
   if (J != JourActuel) {
     JourActuel = J;                                    // on remet le jour à la valeur actuelle
     publie(TopicHPJT,atol(LastHCHP)- atol(DebJourHP)); // Publie la conso HP totale du jour (Wh)
     DebJourHP = LastHCHP;
     publie(TopicHCJT,atol(LastHCHC)- atol(DebJourHC)); // Publie la conso HC totale du jour (Wh)
     DebJourHC = LastHCHC;
      // les 4 lignes suivantes sont nécessaires car chez moi, lorsqu'on change de jour, on est en 
      // Heures Pleines, donc il faut remettre à 0 les heures creuses du jour, sinon elles ne se remettent à 0
      // que vers 1 h du matin, lorsqu'on passe en Heures Creuses
     long valeur =  atol(LastHCHC)- atol(DebJourHC);  // Calcule la conso HC actuelle du jour (mise à 0)
     HCHCj = valeur;                                  // Conserve la conso du jour pour la conso totale
     publie(TopicHCJ,valeur);                         // publie la conso actuelle HC du jour (Wh)
     publie (TopicHJTotal,HCHPj+HCHCj);               // publie la somme HC+HP (Wh)
     
     //Sauvegarde (dans un fichier qui a été crée auparavant):
     File f = SPIFFS.open("/config.txt", "w");
       if (!f) {
        Serial.println("Echec d'ouverture du fichier");
        }
     else{
      f.println(DebJourHP);
      f.println(DebJourHC);
      f.close();
      Serial.print("DebJourHP = ");Serial.println(DebJourHP);
      Serial.print("DebJourHC = ");Serial.println(DebJourHC);
      Serial.println("Valeurs sauvegardées");
     } 
   } 

  // si PAPP a changé, on publie
  if (Nom=="PAPP"){
    Serial.print(me->name);Serial.print(" = "); Serial.print(me->value);
   
    if (client.connect("clientId")) {
      Serial.print(" Publié à "); Serial.println (NTP.getTimeStr ());    
      client.publish(TopicConso, me->value); //publie la conso instantanée (en Watt,ou plus exactement en VA)
    }                                        // on peut publier directement, car me->value retourne un Char array
    else {
      connectMQTT(me->value);
    } 
  }
  // si HCHP a changé, on publie
  if (Nom=="HCHP"){
    Serial.print(me->name);Serial.print(" : ");Serial.println(me->value);
    if (client.connect("clientId") ) {  
      client.publish(TopicHCHP,me->value);              // publie l'index HP
      LastHCHP = me->value;                             // conserve la valeur
      
      long valeur =  atol(me->value)- atol(DebJourHP);  // Calcule la conso actuelle du jour
      HCHPj = valeur;                                   // Conserve la conso du jour pour la conso totale
      publie(TopicHPJ,valeur);                          // publie la conso actuelle HP du jour (Wh)
      
      publie (TopicHJTotal,HCHPj+HCHCj);                // publie la somme HC+HP (Wh)
    }
  }
      
  // idem pour HCHC
  if (Nom=="HCHC"){
    Serial.print(me->name);Serial.print(" : ");Serial.println(me->value);
    
    if (client.connect("clientId") ) {  
      client.publish(TopicHCHC,me->value);             // publie l'index HC
      LastHCHC = me->value;                            // conserve la valeur
      //Calcule la conso du jour
      long valeur =  atol(me->value)- atol(DebJourHC); // Calcule la conso actuelle du jour
      HCHCj = valeur;                                  // Conserve la conso du jour pour la conso totale
      publie(TopicHCJ,valeur);                         // publie la conso actuelle HC du jour (Wh)
      publie (TopicHJTotal,HCHPj+HCHCj);               // publie la somme HC+HP (Wh)
    } 
  }
} // fin de DataCallback

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

// connect to MQTT server si besoin

void connectMQTT(char *PAPP) {
  // Wait until we're connected
  while (!client.connected()) {
    if (client.connect("clientId")) {
      Serial.println("  Linky reconnecté");
      client.publish(TopicConso, PAPP);  
    } 
    else {
      Serial.printf("MQTT failed, state %s, retrying...\n", client.state());
      // Wait before retrying
      delay(2000);
      
      // reset soft car perte wifi parfois
      ++NbLoop ;
      if (NbLoop > 10){
        Serial.print ("Reset par soft");
        ESP.restart();
      }
    }
  }
  //client.disconnect();
  
} // fin de connectMQTT

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

//transforme la valeur en Char array et publie
// les valeurs qui sont déjà en Char array sont publiées sans passer par cette procédure

void publie(const char *Topic, long valeur ){
  String ValeurP = String(valeur);
  Serial.print(ValeurP); Serial.print(Topic);
  char PourPublier[ValeurP.length()+1];
  ValeurP.toCharArray(PourPublier, ValeurP.length()+1); 
  client.publish(Topic, PourPublier);
  Serial.print("   Publié à ");
  Serial.println (NTP.getTimeDateString());
} // fin de publie

JG

Une vue de l'écran de contrôle, pas encore bien fini, mais opérationnel...
J'utilise Grafana, influxDB et Telegraf pour la visualisation
Graf exemple.JPG

Aurelien Perard

@Schmurtz Slt, pour le mqtt tu as cette version qui fonctionne très bien.

https://github.com/Domochip/WirelessTeleInfo

Charles

Guys,

Pour info maintenant c'est supporté par Tasmota, donc MQTT natif, en revanche je ne sais pas ce qu'il y a faire du coté de HA mais de mémoire Tasmota est natif avec.

https://community.ch2i.eu/topic/342/ré-écriture-de-wifinfo-pour-traiter-le-mode-standard-du-linky/34
https://community.ch2i.eu/topic/676/tasmota/14