Intro

Dans un article précédent https://domo.rem81.com/ha-teleinformation-linky-mode-historique/ , je décrivais la mis en oeuvre d’une communication entre un Linky et Home Assistant en mode Historique.

Après avoir fonctionné un temps en mode « Historique », je suis passé au mode « Standard ». Celui ci offre un plus grand nombre de données.

Raccordement de la télé information de mon compteur Linky. Rien de bien méchant il suffit de se raccorder aux bornes i1/i2 du linky, le plus délicat fut le passage du câble de 60 ml entre le compteur Linky et mon tableau électrique.

Mises à jour

du 23/11/2023:

Ajout d’une version EDF « Tempo »

du 16/08/2022

Ajout du « filter out » dans les HP,HC permettant de rejeter les valeurs nulles si besoin.

du 12/04/2022

Suite à passage Home Assistant 2022.4.0, modification du changement de tarif des utility meter https://www.home-assistant.io/integrations/utility_meter

Pré requis

Mes fichiers « .yaml » sont regroupés dans un dossier « config/packages ». J’utilise la directive « !include_dir_named packages » dans mon « configuration.yaml » très pratique pour organiser son HA.

homeassistant:
  name: Crochon
  latitude: !secret latitude
  longitude: !secret longitude
  unit_system: metric
  packages: !include_dir_named packages
  external_url: !secret external-url
  internal_url: !secret internal-url

Choix du matériel

Les informations transmises par le Linky ne sont pas directement exploitables par un ESP, elles nécessitent un adaptateur, vous trouverez beaucoup de modèles sur le Net, perso j’ai choisi la facilité en achetant un module Wemos Teleinfo.

C’est un module pas très cher, correctement étudié et bien fini, compatible avec les esp8266 et ESP32 Mini, qui dispose également d’une Led WS2812 RGB programmable, d’un connecteur I2C disponible pour un afficheur OLED ou autres capteurs compatibles, et d’une led indiquant l’état de la connexion avec le Linky qui se raccorde sur le bornier vert.

Perso j’utilise un L’ESP32 Mini, en effet l’ESP8266 est trop juste en puissance de calcul si on utilise l’intégration ESPHOME plus un afficheur, j’ai galéré avec, je ne le recommande pas, le constructeur du wemos téléinfo non plus d’ailleurs.

L’ESP32 Mini est un ESP32 au format ESP8266 D1, pratique si l’on souhaite utiliser des cartes d’extension, mais avec une puissance de calcul et de traitement bien supérieure.

Descriptif fonctionnel

Les compteurs Linky disposent de 2 modes de téléinformation :
• Le mode Historique, qui correspond à l’ancien mode des compteurs électroniques.
• Le mode Standard, qui est le nouveau format et qui comporte plus d’informations.

Vous trouverez les informations détaillées dans le document Enedis suivant:

Le module WEMOS Teleinfo est compatible, le changement de mode passe obligatoirement par une demande auprès de votre fournisseur d’énergie qui relaye vers Enedis.

Concernant l’intégration dans HA, pas de problème particulier grâce à « teleinfo » disponible sur ESP Home, il est compatible avec les deux modes, les différences étant dans la vitesse de transmission et la validation du mode historique ou pas:

Informations collectées

J’utilise le W et non le VA pour l’entité « SINSTS » afin d’exploiter les « Statistiques Longues Durée » qui ne reconnait pas les « Volt Ampéres ». Pour mémoire, en monophasé P en W= P en VA multiplie cos phi, mais come le Linky ne remonte pas le cos phi on se contentera d’un cos phi de 1, les puristes ne m’en voudront pas.

Je divise par 1000 le total de l’énergie active soutirée « EAST » pour obtenir des kWh. C’est cette entité que j’utilise dans les « utility meter » de HA pour calculer mes consommations journalière, semaine, mois, année.

Je calcul en % dans un « template » « Linky P/Pcoup » le ratio entre la puissance instantanée « SINST » et la puissance de coupure « PCOUP », ce qui donne une idée de la réserve de puissance disponible et plus tard, s’en servir pour vérifier si l’abonnement peut être revue à la baisse.

« UMOY1 » nous donne la tension moyenne du secteur.

« IRMS1 » nous donne l’intensité efficace de la phase 1.

« NTARF » nous indique si le tarif est en heure creuse (=1) ou heure pleine (=2), variable utilisée dans l’automatisme de comptabilisation de l’énergie avec les « utility_meter ». J’en profite pour afficher en clair dans un « template », le tarif en cours.

Je remonte la consommation journalière depuis HA vers l’ESP afin de l’afficher en local.

Tableau des informations disponibles

Certaines sont dispo uniquement en tri-phasé et/ou en tant que producteur d’énergie.

Code ESP

Si vous avez des difficultés de flashage avec ESPHome, parcourez mon article https://domo.rem81.com/home-assistant_esp-home/ cela devrait vous aider.

L’afficheur utilise une police de caractère « Arial », vous pouvez télécharger le fichier arial.ttf ici puis le transférer dans un dossier « fonts » de votre « /config/esphome ». Bien entendu vous pouvez utiliser une autre police de caractères, « size » détermine la taille des caractères.

Version « Tempo »

les filtres « filter_out: 0.0 » sont à mettre en action si et seulement si les index sont supérieurs à 0 sinon vous afficherez « indisponible ».

Le filtre « Lambda » permet d’éviter des incohérences dans l’évolution des index, il m’est arrivé de lire des valeurs très faibles mais supérieure à 0 pour des raisons que j’ignore.

L’écart se regle dans la variable « globals » ecart_max.

substitutions:
  device_name: esp124-tic
  adress_ip: "192.168.0.124"
  friendly_name: esp124
  time_timezone: "Europe/Paris"
  
esphome:
  name: ${device_name}
  platform: ESP32
  board: mhetesp32minikit
  project:
    name: "rem81.esp124-TIC"
    version: "1.0.1"
  platformio_options:
    lib_deps: NeoPixelBus@2.6.0
  on_boot:
    then:
      - light.control:
          id: led1
          brightness: 0.25
          state: on
wifi:
  networks:
    - ssid: !secret wifi_esp
      password: !secret mdpwifi_esp
      priority: 1
    - ssid: !secret wifi
      password: !secret mdpwifi
      priority: 0
  reboot_timeout: 5min

  manual_ip:
    static_ip: ${adress_ip}
    gateway: 192.168.0.254
    subnet: 255.255.255.0

# Enable logging
logger:
#  baud_rate: 0
# Enable Home Assistant API
api:

ota:

web_server:
  port: 80

font:
  - file: "fonts/arial.ttf"
    id: arial
    size: 15

i2c:
  sda: GPIO21 #D2=pin 19
  scl: GPIO22 #D1=pin 20
  scan: True
  id: bus_a
  
# 
uart:
  id: uart_a
  rx_pin: GPIO23
#  tx_pin: GPIO1
  baud_rate: 9600
  parity: EVEN
  data_bits: 7

teleinfo:
  id: myteleinfo
  uart_id: uart_a
  update_interval: 10s
  historical_mode: false
  
# Led WS2812 RGB  
light:
  - platform: partition
    name: led1
    id: led1
    default_transition_length: 0s
    segments:
      - id: rgb_led
        from: 0
        to: 0

  - platform: neopixelbus
    num_leds: 1
    pin: GPIO18
    name: "RGB strip"
    variant: ws2812
    id: rgb_led
    default_transition_length: 0s  

globals:
  # Ecart maximum admissible entre deux lectures
   - id: ecart_max
     type: float
     restore_value: no
     initial_value: '50'


sensor:
# Energie Active soutirée totale
  - platform: teleinfo
    id: hc_hp
    tag_name: "EAST"
    name: "Linky HPHC KWH"
    unit_of_measurement: "kWh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    device_class: "energy"
    state_class: "total_increasing"  
    filters:
      - filter_out: 0.0
      - lambda: |-
          return x/1000;
      - lambda: |-
          float MAX_DIFFERENCE = id(ecart_max);  // Difference max entre de lecture, à ajuster selon votre cas de figure.
          static float last_value = NAN;
          if (isnan(last_value) || std::abs(x - last_value) < MAX_DIFFERENCE)
            return last_value = x;
          else
            return {};          
          

# Energie Active soutirée Index01 HC Bleu
  - platform: teleinfo
    id: hcbleu
    tag_name: "EASF01"
    name: "Linky HC Bleu kWh"
    unit_of_measurement: "kWh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    device_class: "energy"
    state_class: "total_increasing"      
    filters:
      - lambda: return x / 1000;
      - filter_out: 0.0
      - lambda: |-
          float MAX_DIFFERENCE = id(ecart_max);  // Difference max entre de lecture, à ajuster selon votre cas de figure.
          static float last_value = NAN;
          if (isnan(last_value) || std::abs(x - last_value) < MAX_DIFFERENCE)
            return last_value = x;
          else
            return {};      

# Energie Active soutirée Index02 HP Bleu
  - platform: teleinfo
    id: hpbleu
    tag_name: "EASF02"
    name: "Linky HP Bleu kWh"
    unit_of_measurement: "kWh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    device_class: "energy"
    state_class: "total_increasing"      
    filters:
      - lambda: return x / 1000;      
      - filter_out: 0.0
      - lambda: |-
          float MAX_DIFFERENCE = id(ecart_max);  // Difference max entre de lecture, à ajuster selon votre cas de figure.
          static float last_value = NAN;
          if (isnan(last_value) || std::abs(x - last_value) < MAX_DIFFERENCE)
            return last_value = x;
          else
            return {};      

# Energie Active soutirée Index03 HC Blanc
  - platform: teleinfo
    id: hcblanc
    tag_name: "EASF03"
    name: "Linky HC Blanc kWh"
    unit_of_measurement: "kWh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    device_class: "energy"
    state_class: "total_increasing"      
    filters:
      - lambda: return x / 1000;
      - filter_out: 0.0
      - lambda: |-
          float MAX_DIFFERENCE = id(ecart_max);  // Difference max entre de lecture, à ajuster selon votre cas de figure.
          static float last_value = NAN;
          if (isnan(last_value) || std::abs(x - last_value) < MAX_DIFFERENCE)
            return last_value = x;
          else
            return {};      

# Energie Active soutirée Index04 HP Blanc
  - platform: teleinfo
    id: hpblanc
    tag_name: "EASF04"
    name: "Linky HP Blanc kWh"
    unit_of_measurement: "kWh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    device_class: "energy"
    state_class: "total_increasing"      
    filters:
      - lambda: return x / 1000;
      - filter_out: 0.0   
      - lambda: |-
          float MAX_DIFFERENCE = id(ecart_max);  // Difference max entre de lecture, à ajuster selon votre cas de figure.
          static float last_value = NAN;
          if (isnan(last_value) || std::abs(x - last_value) < MAX_DIFFERENCE)
            return last_value = x;
          else
            return {};       

# Energie Active soutirée Index05 HC Rouge
  - platform: teleinfo
    id: hcrouge
    tag_name: "EASF05"
    name: "Linky HC Rouge kWh"
    unit_of_measurement: "kWh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    device_class: "energy"
    state_class: "total_increasing"      
    filters:
      - multiply: 0.001
      - filter_out: 0.0
      - lambda: |-
          float MAX_DIFFERENCE = id(ecart_max);  // Difference max entre de lecture, à ajuster selon votre cas de figure.
          static float last_value = NAN;
          if (isnan(last_value) || std::abs(x - last_value) < MAX_DIFFERENCE)
            return last_value = x;
          else
            return {};
# Energie Active soutirée Index06 HP Rouge
  - platform: teleinfo
    id: hprouge
    tag_name: "EASF06"
    name: "Linky HP Rouge kWh"
    unit_of_measurement: "kWh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    device_class: "energy"
    state_class: "total_increasing"  
    filters:
      - lambda: return x / 1000;
      - filter_out: 0.0   
      - lambda: |-
          float MAX_DIFFERENCE = id(ecart_max);  // Difference max entre de lecture, à ajuster selon votre cas de figure.
          static float last_value = NAN;
          if (isnan(last_value) || std::abs(x - last_value) < MAX_DIFFERENCE)
            return last_value = x;
          else
            return {};       

#Puissance apparente de coupure
  - platform: teleinfo
    id: pcoup
    tag_name: "PCOUP"
    name: "Linky PCOUP"
    unit_of_measurement: "kVA"
    icon: mdi:flash
    teleinfo_id: myteleinfo

#Puissance apparente instantanée ph1 

  - platform: teleinfo
    id: papp
    tag_name: "SINSTS"
    name: "Linky PAPP"
    unit_of_measurement: "VA"
    device_class: "power"
    state_class: "measurement"  
    icon: mdi:flash
    teleinfo_id: myteleinfo


#Tension moyenne ph1
  - platform: teleinfo
    id: umoy1
    tag_name: "UMOY1"
    name: "Linky Umoy"
    unit_of_measurement: "V"
    icon: mdi:flash
    teleinfo_id: myteleinfo

#Courant efficace ph1
  - platform: teleinfo
    id: iinst
    tag_name: "IRMS1"
    name: "Linky I Inst"
    unit_of_measurement: "A"
    icon: mdi:flash
    teleinfo_id: myteleinfo

# Numero du Tarif en cours
  - platform: teleinfo
    id: ntarif
    tag_name: "NTARF"
    name: "linky N Tarif"
    unit_of_measurement: ""
    icon: mdi:flash
    teleinfo_id: myteleinfo

############### TEMPLATE  ######################"
# Calcul du ratio de la puissance apparente utilisée en % par rapport au contrat
  - platform: template
    name: "Linky P/PCoup"
    id: p100
    icon: mdi:flash
    unit_of_measurement: "%"
    accuracy_decimals: 0
    lambda: |-
      return ((id(papp).state/1000)/id(pcoup).state*100);

# Lecture dans HA de la conso du jour
  - platform: homeassistant
    name: "HCHP J"
    unit_of_measurement: "kWh"
    entity_id: sensor.compteur_energie_total_jour_tous_tarifs
    id: hphcj

    
#######################################
text_sensor:
# Registre de statuts
  - platform: teleinfo
    id: stge
    tag_name: "STGE"
    name: "linky Statuts"
    icon: mdi:flash
    teleinfo_id: myteleinfo

# nom du calendrier tarifaire
  - platform: teleinfo
    id: ngtf
    tag_name: "NGTF"
    name: "linky Nom calendrier tarifaire"
    icon: mdi:flash
    teleinfo_id: myteleinfo

# Libellé tarif fournisseur en cours
  - platform: teleinfo
    id: ltarf
    tag_name: "LTARF"
    name: "linky Libelle tarif fournisseur en cours"
    icon: mdi:flash
    teleinfo_id: myteleinfo

# Convertion du tarif en cours
  - platform: template
    id: tarif
    name: "Linky PTEC"
    lambda: |-
      if ( id(ntarif).state == 1 || id(ntarif).state == 3 || id(ntarif).state == 5){
        return { "HC.." };
      } else {
        return { "HP.." };
      }

#Etat de la connection
binary_sensor:
  - platform: status
    name: "${friendly_name} Status"

switch:
  - platform: restart
    name: "${friendly_name} Restart"

# Affichage
display:
  - platform: ssd1306_i2c
    model: "SSD1306 128x64"
    address: 0x3C
    brightness: 100%
    lambda: |-
      it.printf(0,0,id(arial),"P=%.0f VA",id(papp).state);
      it.printf(75,0,id(arial),"-%.0f %%",id(p100).state);
      it.printf(0,15,id(arial),"I Inst=%.0f A",id(iinst).state);
      it.printf(0,30,id(arial),"ConsoJ=%.0f kWh",id(hphcj).state);
      std::string tarif_ = id(ltarf).state;
      it.printf(0,45,id(arial), tarif_.c_str());      
##      it.printf(0,45,id(arial), "Tarif:%s", tarif_.c_str());      


interval:
  - interval: 1s
    then:
      - script.execute: calcul_led_jour

# ------------------------  Scripts
script:
# 
# Couleur du Jour en cours
  - id: calcul_led_jour
    mode: single
    then:
      - logger.log:
          format: "Ltarf= %f"
          args: [ 'id(ntarif).state']

      - if: 
          condition:
            - lambda: |-
                return ( id(ntarif).state == 1 || id(ntarif).state == 2);

          then:
            - light.control:
                id: led1
                red: 0% 
                green: 0%
                blue: 100%    

      - if: 
          condition:
            - lambda: |-
                return ( id(ntarif).state == 3 || id(ntarif).state == 4);
          then:
            - light.control:
                id: led1
                red: 100% 
                green: 100%
                blue: 100%    
          
      - if: 
          condition:
            - lambda: |-
                return ( id(ntarif).state == 5 || id(ntarif).state == 6);
          then:
            - light.control:
                id: led1
                red: 100% 
                green: 0%
                blue: 0%    

Version HC/HP

les filtres « filter_out: 0.0 » sont à mettre en action si et seulement si les index sont supérieurs à 0 sinon vous afficherez « indisponible ».

Le filtre « Lambda » permet d’éviter des incohérences dans l’évolution des index, il m’est arrivé de lire des valeurs très faibles mais supérieure à 0 pour des raisons que j’ignore.

L’écart se regle dans la variable « globals » ecart_max

substitutions:
  device_name: esp124-tic
  adress_ip: "192.168.0.124"
  friendly_name: esp124
  time_timezone: "Europe/Paris"
  
esphome:
  name: ${device_name}
  platform: ESP32
  board: mhetesp32minikit
  project:
    name: "rem81.esp124-TIC"
    version: "1.0.1"
  platformio_options:
    lib_deps: NeoPixelBus@2.6.0
  on_boot:
    then:
      - light.control:
          id: led1
          brightness: 0.25
          state: on
wifi:
  networks:
    - ssid: !secret wifi_mi4
      password: !secret mdpwifi_mi4
      priority: 2  
    - ssid: !secret wifi_esp
      password: !secret mdpwifi_esp
      priority: 1
    - ssid: !secret wifi
      password: !secret mdpwifi
      priority: 0
  reboot_timeout: 5min

  manual_ip:
    static_ip: ${adress_ip}
    gateway: 192.168.0.254
    subnet: 255.255.255.0


# Enable logging
logger:
#  baud_rate: 0
# Enable Home Assistant API
api:

ota:

web_server:
  port: 80

font:
  - file: "fonts/arial.ttf"
    id: arial
    size: 15

i2c:
  sda: GPIO21 #D2=pin 19
  scl: GPIO22 #D1=pin 20
  scan: True
  id: bus_a
  
# 
uart:
  id: uart_a
  rx_pin: GPIO23
#  tx_pin: GPIO1
  baud_rate: 9600
  parity: EVEN
  data_bits: 7

teleinfo:
  id: myteleinfo
  uart_id: uart_a
  update_interval: 10s
  historical_mode: false
  
# Led WS2812 RGB  
light:
  - platform: partition
    name: led1
    id: led1
    default_transition_length: 0s
    segments:
      - id: rgb_led
        from: 0
        to: 0

  - platform: neopixelbus
    num_leds: 1
    pin: GPIO18
    name: "RGB strip"
    variant: ws2812
    id: rgb_led
    default_transition_length: 0s  

globals:
  # Ecart maximum admissible entre deux lectures
   - id: ecart_max
     type: float
     restore_value: no
     initial_value: '50'

sensor:
# Energie Active soutirée totale
  - platform: teleinfo
    id: hc_hp
    tag_name: "EAST"
    name: "Linky HPHC KWH"
    unit_of_measurement: "kWh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    device_class: "energy"
    state_class: "total_increasing"  
    filters:
      - filter_out: 0.0
      - lambda: |-
          return x/1000;


# Energie Active soutirée Index01
  - platform: teleinfo
    id: hchc
    tag_name: "EASF01"
    name: "Linky HC Wh"
    unit_of_measurement: "Wh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    filters:
      - filter_out: 0.0
      - lambda: |-
          float MAX_DIFFERENCE = id(ecart_max);  // Difference max entre de lecture, à ajuster selon votre cas de figure.
          static float last_value = NAN;
          if (isnan(last_value) || std::abs(x - last_value) < MAX_DIFFERENCE)
            return last_value = x;
          else
            return {};    
    
# Energie Active soutirée Index02    
  - platform: teleinfo
    id: hchp
    tag_name: "EASF02"
    name: "Linky HP Wh"
    unit_of_measurement: "Wh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    filters:
      - filter_out: 0.0    
      - lambda: |-
          float MAX_DIFFERENCE = id(ecart_max);  // Difference max entre de lecture, à ajuster selon votre cas de figure.
          static float last_value = NAN;
          if (isnan(last_value) || std::abs(x - last_value) < MAX_DIFFERENCE)
            return last_value = x;
          else
            return {};    

#Puissance apparente de coupure
  - platform: teleinfo
    id: pcoup
    tag_name: "PCOUP"
    name: "Linky PCOUP"
    unit_of_measurement: "kVA"
    icon: mdi:flash
    teleinfo_id: myteleinfo

#Puissance apparente instantanée ph1 

  - platform: teleinfo
    id: papp
    tag_name: "SINSTS"
    name: "Linky PAPP"
    unit_of_measurement: "VA"
    device_class: "power"
    state_class: "measurement"  
    icon: mdi:flash
    teleinfo_id: myteleinfo
    on_value:
      - if:
          condition:
            sensor.in_range:
              id: papp
              below: 1000
          then: 
            - light.control:
                id: led1
                red: 0%
                green: 100% # vert
                blue: 0%
      - if:
          condition:
            sensor.in_range:
              id: papp
              above: 1000
              below: 3000
          then: 
            - light.control:
                id: led1
                red: 0%
                green: 0% # bleu
                blue: 100%
      - if:
          condition:
            sensor.in_range:
              id: papp
              above: 3000
          then: 
            - light.control:
                id: led1
                red: 100% #rouge
                green: 0%
                blue: 0%    

#Tension moyenne ph1
  - platform: teleinfo
    id: umoy1
    tag_name: "UMOY1"
    name: "Linky Umoy"
    unit_of_measurement: "V"
    icon: mdi:flash
    teleinfo_id: myteleinfo

#Courant efficace ph1
  - platform: teleinfo
    id: iinst
    tag_name: "IRMS1"
    name: "Linky I Inst"
    unit_of_measurement: "A"
    icon: mdi:flash
    teleinfo_id: myteleinfo

# Numero du Tarif en cours
  - platform: teleinfo
    id: ntarif
    tag_name: "NTARF"
    name: "linky N Tarif"
    unit_of_measurement: ""
    icon: mdi:flash
    teleinfo_id: myteleinfo

############### TEMPLATE  ######################"
# Calcul du ratio de la puissance apparente utilisée en % par rapport au contrat
  - platform: template
    name: "Linky P/PCoup"
    id: p100
    icon: mdi:flash
    unit_of_measurement: "%"
    accuracy_decimals: 0
    lambda: |-
      return ((id(papp).state/1000)/id(pcoup).state*100);

# Lecture dans HA de la conso du jour
  - platform: homeassistant
    name: "HCHP J"
    unit_of_measurement: "kWh"
    entity_id: sensor.energie_totale_jour
    id: hphcj

# Puissance du signal WIFI
  - platform: wifi_signal
    id: wif
    name: "${friendly_name} WiFi Signal Sensor"
    update_interval: 60s
# Temps de fonctionnement de l'ESP    
  - platform: uptime
    id: uptime_seconds
    name: "${friendly_name} Uptime"
    update_interval: 60s
    unit_of_measurement: s
    accuracy_decimals: 0
    force_update: false
    icon: mdi:timer
    
#######################################
text_sensor:
# Registre de statuts
  - platform: teleinfo
    id: stge
    tag_name: "STGE"
    name: "linky Statuts"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    
# Convertion du tarif en cours
  - platform: template
    id: tarif
    name: "Linky PTEC"
    lambda: |-
      if ( id(ntarif).state == 1 ) {
        return { "HC.." };
      } else {
        return { "HP.." };
      }
# Affichage du temps de fonctionnement
  - platform: template
    name: "${friendly_name} Uptime"
    update_interval: 60s
    icon: mdi:clock-start
    lambda: |-
      int seconds = (id(uptime_seconds).state);
      int days = seconds / (24 * 3600);
      seconds = seconds % (24 * 3600);
      int hours = seconds / 3600;
      seconds = seconds % 3600;
      int minutes = seconds /  60;
      seconds = seconds % 60;
      if ( days ) {
        return { (String(days) +"d " + String(hours) +"h " + String(minutes) +"m "+ String(seconds) +"s").c_str() };
      } else if ( hours ) {
        return { (String(hours) +"h " + String(minutes) +"m "+ String(seconds) +"s").c_str() };
      } else if ( minutes ) {
        return { (String(minutes) +"m "+ String(seconds) +"s").c_str() };
      } else {
        return { (String(seconds) +"s").c_str() };
      }

#Etat de la connection
binary_sensor:
  - platform: status
    name: "${friendly_name} Status"
# Restart de l'ESP
switch:   
  - platform: restart
    name: "${friendly_name} Restart"

# Affichage
display:
  - platform: ssd1306_i2c
    model: "SSD1306 128x64"
    address: 0x3C
    brightness: 100%
    lambda: |-
      it.printf(0,0,id(arial),"P=%.0f VA",id(papp).state);
      it.printf(75,0,id(arial),"-%.0f %%",id(p100).state);
      it.printf(0,15,id(arial),"I Inst=%.0f A",id(iinst).state);
      it.printf(0,30,id(arial),"ConsoJ=%.0f kWh",id(hphcj).state);
      std::string tarif_ = id(tarif).state;
      it.printf(0,45,id(arial), "Tarif: %s", tarif_.c_str());      


      
   

Registre de Statuts

Le registre de statuts « STGE » (uniquement dispo en mode standard) nous donne un état du Linky en général. Il remonte dans un format de huit caractères ascii. Chaque caractères est codés sur 4 bits qui correspondent à une ou plusieurs informations. Le détail est donné au chapitre 6.2.3.14 du document Enedis ci dessous:

J’ai écrit une routine qui décode les caractères du registre de statuts permettent de l’exploiter dans HA via l’Addon AppDaemon.

Celle ci convertit les 8 caractères du registre Statuts de l’ASCII vers du Binaire.

Addon Appdaemon

Cet Addon, pour ceux qui ne connaissent pas, permet d’écrire des programmes en Python très élaborés.

Je décrit son installation dans cet article cet article.

Vous trouverez ci après les fichiers « .yaml » et « .py » à installer dans « votre AppDaemon. »

Code de « linky_status.yaml »

Linky:
  class: LinkyStatuts
  module: linky_statuts
  registre: input_text.linky_test_status
#  registre: sensor.linky_statuts

Vous pouvez faire des tests en de-commentant le « registre: input_text.linky_test_status » et en commentant le « registre: input_text.linky_test_status » (il faut un seul « registre » actif à la fois).

Code de « linky_status.py »

import hassapi as hass

# Conversion ASCII vers binaire codé décimal
def repr_bin2(str):
    caract = 0
    decod=""        
    for caract in str:
        decod += bin(int(caract,16))[2::].zfill(4)
    return decod

class LinkyStatuts(hass.Hass):
    def initialize(self):
        self.listen_state(self.statuts_change, self.args["registre"])
        self.log("Initialisation Linky..", log="linky_log")

    def statuts_change(self, entity, attribute, old, new, kwargs):
        statuts = new
        if len(statuts)!=8:
            self.log(f"Erreur format registre de statuts= {statuts}", log="linky_log")
        else:
            self.convertion_status(kwargs)

#  Lecture et conversion du registre de statuts du Linky 
    def convertion_status(self, kwargs):
        statuts = self.get_state(self.args["registre"])
        statuts_binaire=(repr_bin2(statuts))

        # Exploitation des 32 bits du statuts poids forts en tête #
        # Bit 0:Contact Sec#
        bit_0= statuts_binaire[31]
        if bit_0 == "0":
            contact_sec = "Ferme"
        else:
            contact_sec = "Ouvert"

        # Bits 1 à 3: Organe de coupure #
        bit_1_3= statuts_binaire[28:31]
        if bit_1_3 == "000":
            organe_de_coupure = "Ferme"
        elif bit_1_3 == "001":
            organe_de_coupure = "Ouvert sur Surpuissance"
        elif bit_1_3 == "010":
            organe_de_coupure = "Ouvert sur Surtension"
        elif bit_1_3 == "011":
            organe_de_coupure = "Ouvert sur Delestage"
        elif bit_1_3 == "100":
            organe_de_coupure = "Ouvert sur Ordre CPL ou Euridis"
        elif bit_1_3 == "101":
            organe_de_coupure = "Ouvert sur Surchauffe avec I>Imax"
        elif bit_1_3 == "110":
            organe_de_coupure = "Ouvert sur Surchauffe avec I<Imax"
        else:
            organe_de_coupure = "??"

        # Bit 4: Etat du cache borne #
        bit_4= statuts_binaire[27]
        if bit_4 == "0":
            cache_borne = "Ferme"
        else:
            cache_borne = "Ouvert"

        # Bit 5: Non utilisé toujours à 0 #

        # Bit 6: Surtension sur une des phases #
        bit_6= statuts_binaire[25]
        if bit_6 == "0":
            surtension = "Pas de Surtension"
        else:
            surtension = "Surtension"

        # Bit 7: Dépassement Puissance de Référence #
        bit_7= statuts_binaire[24]
        if bit_7 == "0":
            dep_pref = "Pas de Depassement"
        else:
            dep_pref = "Depassement en Cours"

        # Bit 8: Producteur ou Consommateur #
        bit_8= statuts_binaire[23]
        if bit_8 == "0":
            fonct_prod_conso = "Consommateur"
        else:
            fonct_prod_conso = "Producteur"

        # Bit 9: Sens de L'énergie active #
        bit_9= statuts_binaire[22]
        if bit_9 == "0":
            sens_energie_act = "Energie active positive"
        else:
            sens_energie_act = "Energie active negative"

        # Bits 10 à 13: Tarif en cours contrat fourniture #
        bit_10_13= statuts_binaire[18:22]
        if bit_10_13 == "0000":
            tarif_fourniture = "Energie ventilee sur index 1"
        elif bit_10_13 == "0001":
            tarif_fourniture = "Energie ventilee sur index 2"
        elif bit_10_13 == "0010":
            tarif_fourniture = "Energie ventilee sur index 3"
        elif bit_10_13 == "0011":
            tarif_fourniture = "Energie ventilee sur index 4"
        elif bit_10_13 == "0100":
            tarif_fourniture = "Energie ventilee sur index 5"
        elif bit_10_13 == "0101":
            tarif_fourniture = "Energie ventilee sur index 6"
        elif bit_10_13 == "0110":
            tarif_fourniture = "Energie ventilee sur index 7"
        elif bit_10_13 == "0111":
            tarif_fourniture = "Energie ventilee sur index 8"
        elif bit_10_13 == "1000":
            tarif_fourniture = "Energie ventilee sur index 9"
        elif bit_10_13 == "1001":
            tarif_fourniture = "Energie ventilee sur index 10"
        else:
            tarif_fourniture = "??"

        # Bits 14 à 15: Tarif en cours contrat fourniture #
        bit_14_15= statuts_binaire[16:18]
        if bit_14_15 == "00":
            tarif_distributeur = "Energie ventilee sur index 1"
        elif bit_14_15 == "01":
            tarif_distributeur = "Energie ventilee sur index 2"
        elif bit_14_15 == "10":
            tarif_distributeur = "Energie ventilee sur index 3"
        elif bit_14_15 == "11":
            tarif_distributeur = "Energie ventilee sur index 4"

        # Bit 16: Mode dégradé horloge #
        bit_16= statuts_binaire[15]
        if bit_16 == "0":
            mode_horloge = "Horloge correcte"
        else:
            mode_horloge = "Horloge mode degrade"

        # Bit 17: Etat TIC #
        bit_17= statuts_binaire[14]
        if bit_17 == "0":
            etat_tic = "Mode Historique"
        else:
            etat_tic = "Mode Standard"

        # Bit 18: Non utilisé #

        # Bits 19 à 20: Etat de la com Euridis #
        bit_19_20= statuts_binaire[11:13]
        if bit_19_20 == "00":
            com_euridis = "Com desactivee"
        elif bit_19_20 == "01":
            com_euridis = "Com Active sans securite"
        elif bit_19_20 == "11":
            com_euridis = "Com Active avec securite"
        else:
            com_euridis = "Com ??"

        # Bits 21 à 22: Statut du CPL #
        bit_21_22= statuts_binaire[9:11]
        if bit_21_22 == "00":
            statut_cpl = "New/unlock"
        elif bit_21_22 == "01":
            statut_cpl = "New/Lock"
        elif bit_21_22 == "11":
            statut_cpl = "Registered"
        else:
            statut_cpl = "Com ??"

        # Bit 23: Synchro CPL #
        bit_23= statuts_binaire[8]
        if bit_23 == "0":
            synchro_cpl = "Compteur non synchronise"
        else:
            synchro_cpl = "Compteur synchronise"

        # Bits 24_25: Couleur du jour contrat historique Tempo #
        bit_24_25= statuts_binaire[6:8]
        if bit_24_25 == "00":
            couleur_j_tempo = "Contrat non Tempo"
        elif bit_24_25 == "01":
            couleur_j_tempo = "Bleu"
        elif bit_24_25 == "10":
            couleur_j_tempo = "Blanc"
        elif bit_24_25 == "11":
            couleur_j_tempo = "Rouge"
        else:
            couleur_j_tempo = "Couleur J tempo indefinie"

        # Bits 26_27: Couleur du J+1 contrat historique Tempo #
        bit_26_27= statuts_binaire[4:6]
        if bit_26_27 == "00":
            couleur_j1_tempo = "Contrat non Tempo"
        elif bit_26_27 == "01":
            couleur_j1_tempo = "Bleu"
        elif bit_26_27 == "10":
            couleur_j1_tempo = "Blanc"
        elif bit_26_27 == "11":
            couleur_j1_tempo = "Rouge"
        else:
            couleur_j1_tempo = "Couleur J+1 tempo indefinie"

        # Bits 28_29: Préavis Pointes mobiles #
        bit_28_29= statuts_binaire[2:4]
        if bit_28_29 == "00":
            préavis_p_mobiles = "pas de preavis en cours"
        elif bit_28_29 == "01":
            préavis_p_mobiles = "Preavis PM1 en cours"
        elif bit_28_29 == "10":
            préavis_p_mobiles = "Preavis PM2 en cours"
        elif bit_28_29 == "11":
            préavis_p_mobiles = "Preavis PM3 en cours"
        else:
            préavis_p_mobiles = "Preavis en cours indéfini"
            
        # Bits 30_31: Préavis Pointes mobiles #
        bit_30_31= statuts_binaire[2:4]
        if bit_30_31 == "00":
            pointe_mobile = "Pas de pointe mobile"
        elif bit_30_31 == "01":
            pointe_mobile = "PM1 en cours"
        elif bit_30_31 == "10":
            pointe_mobile = "PM2 en cours"
        elif bit_30_31 == "11":
            pointe_mobile = "PM3 en cours"
        else:
            pointe_mobile = "Pointe mobile indefinie"

        #### Creation et Mise à jour des entités HA  ####

        # Etat du contact Sec (= 1 = fermé en Heure Creuse) #
        if bit_0 == "0":
            self.set_state("binary_sensor.linky_contact_sec", state="on", replace=True, attributes= {"icon": "mdi:flash"})  
        else:
            self.set_state("binary_sensor.linky_contact_sec", state="off", replace=True, attributes= {"icon": "mdi:flash"})  
        
        # Etat de l'organe de coupure #
        self.set_state("sensor.linky_organe_de_coupure", state=organe_de_coupure, replace=True, attributes= {"icon": "mdi:flash"})

        #  Sens de l'énergie #
        if bit_9 == "0":
            self.set_state("binary_sensor.linky_sens_energie_active", state="on", replace=True, attributes= {"icon": "mdi:flash"})   
        else:
            self.set_state("binary_sensor.linky_sens_energie_active", state="off", replace=True, attributes= {"icon": "mdi:flash"})   
        self.set_state("sensor.linky_sens_energie_active", state=sens_energie_act, replace=True, attributes= {"icon": "mdi:flash"})           


        ####   Log de Déboggage   
        #    A commenter ou supprimer si inutile #
        self.log(f"Statuts={statuts}", log="linky_log")
        self.log(f"Statuts Binaire={statuts_binaire}", log="linky_log")
        self.log(f"bit_0={bit_0} / Contact Sec={contact_sec}", log="linky_log")
        self.log(f"bit_1_3={bit_1_3} / Organe de coupure={organe_de_coupure}", log="linky_log")
        self.log(f"bit_4={bit_4} / Cache_borne={cache_borne}", log="linky_log")
        self.log(f"bit_6={bit_6} / Surtension={surtension}", log="linky_log")
        self.log(f"bit_7={bit_7} / Depassement Pref={dep_pref}", log="linky_log")
        self.log(f"bit_8={bit_8} / Fonctionnement={fonct_prod_conso}", log="linky_log")
        self.log(f"bit_9={bit_9} / Sens Energie Active={sens_energie_act}", log="linky_log")
        self.log(f"bit_10_13={bit_10_13} / Tarif fourniture={tarif_fourniture}", log="linky_log")
        self.log(f"bit_14_15={bit_14_15} / Tarif distributeur={tarif_distributeur}", log="linky_log")
        self.log(f"bit_16={bit_16} / Mode degrade horloge={mode_horloge}", log="linky_log")
        self.log(f"bit_17={bit_17} / Etat TIC={etat_tic}", log="linky_log")
        self.log(f"bit_19_20={bit_19_20} / Com Euridis={com_euridis}", log="linky_log")
        self.log(f"bit_21_22={bit_21_22} / Statut CPL={statut_cpl}", log="linky_log")
        self.log(f"bit_23={bit_23} / Synchro CPL={synchro_cpl}", log="linky_log")
        self.log(f"bit_24_25={bit_24_25} / Couleur Jour tempo={couleur_j_tempo}", log="linky_log")
        self.log(f"bit_26_27={bit_26_27} / Couleur J+1 tempo={couleur_j1_tempo}", log="linky_log")
        self.log(f"bit_28_29={bit_28_29} / Preavis Pointes Mobiles={préavis_p_mobiles}", log="linky_log")
        self.log(f"bit_30_31={bit_30_31} / Pointe Mobile={pointe_mobile}", log="linky_log")        
        self.log(f"Statuts Linky:{statuts}", log="linky_log")
        self.log(f"Statuts Binaire: {statuts_binaire}", log="linky_log")
        self.log(f"Sens Energie Active: {sens_energie_act}", log="linky_log")
    
#        self.call_service('notify/telegram', message="Statuts Linky:" + format(statuts))
#        self.call_service('notify/telegram', message="Sens Energie Active: " + format(sens_energie_act))
#        self.call_service('notify/telegram', message="Tarif Fourniture: " +format(tarif_fourniture))

Dans la rubrique « Mise à jour des entités HA » du code ci-dessus, vous personnalisez les entités que vous souhaitez exploiter. Elles sont crées et mise à jour dans HA. J’en ai quatre dans mon cas.

Les intitulés parlent d’eux-même. Si vous souhaitez en ajouter d’autre, il suffit de les ajouter dans le fichier ci-dessus.

Vous pouvez visualiser vos entités dans HA:

Dans un premier temps, utilisez le mode test et amusez vous, puis basculer sur la lecture du statuts et exploitez les infos via des automatismes ou autres.

Alternative manuelle d’exploitation du statut hors HA

Si vous ne voulez par utilisé « Appdaemon » vous pouvez toujours exploiter vote statut en utilisant le fichier tableur ci- après que j’ai récupéré sur un forum Jeedom (merci à l’auteur dont j’ai perdu le nom!). Je vous le propose en téléchargement, il suffit de saisir votre code du registre.

Affichage local

J’affiche quelques valeurs en local sur un oled SSD1306 128×64, pratique pour une visu rapide à la puissance et l’intensité instantanée, du ratio P/ Pref , la conso du jour.

Je joue également avec la Led WS2812 RGB connectée sur le GPIO18. En fonction de la puissance la led change de couleur:

• Verte de 0 à 1000 VA
• Bleu entre 1000 et 3000 VA
• Rouge si supérieure à 3000 VA
• Les combinaisons sont infinies et facilement programmables.

Codes du fichier linky.yaml Version HC/HP

On y retrouve:

• les « utility meter » qui comptabilisent les energies consommées HC/HP par jour, semaine, mois, année
• Un « input_boolean com_linky » indiquant l’état de la communication avec le Linky = 1 si com ok
• deux « input_number » cout d’un kWh aux HC et HP
• un ‘binary_sensor » HC utilisé dans l’affichage des graphiques de puissance permettant de matérialiser la zone HC
• les « templates » qui cumulent les HC/HP des utility meter et calculent en € les coûts de consommations
• Les entités du registre de statuts

####################################################
#                                                  #
#                       LINKY                      #
#                                                  #
####################################################


utility_meter:
# usage jour  
  energy_total_usage_daily:
    source: sensor.linky_hphc_kwh
    cycle: daily
    tariffs:
      - hp
      - hc
# usage semaine
  energy_total_usage_weekly:
    source: sensor.linky_hphc_kwh
    cycle: weekly
    tariffs:
      - hp
      - hc
# usage mois
  energy_total_usage_monthly:
    source: sensor.linky_hphc_kwh
    cycle: monthly
    tariffs:
      - hp
      - hc
#usage an
  energy_total_usage_yearly:
    source: sensor.linky_hphc_kwh
    cycle: yearly
    tariffs:
      - hp
      - hc
## 
input_boolean:
  com_linky:
    name: Comm Linky OK=On

input_number:
  # Calcul des coûts journaliers
  cout_kwh_hp:
    name: Cout du Kwh HP
    min: 0
    max: 10
    unit_of_measurement: €
    icon: mdi:currency-eur
    step: 0.00001
    mode: box

  cout_kwh_hc:
    name: Cout du Kwh HC
    min: 0
    max: 10
    unit_of_measurement: €
    icon: mdi:currency-eur
    step: 0.00001
    mode: box

input_text:
  # Permet de simuler des Statuts pour les tests unitaires
  linky_test_status:   
    name: Test statuts Linky

template:
  - binary_sensor:
    # Utilisé dans l'affichage des graphiques de puissance permettant de matérialiser la zone HC
    # = true si HC
    - name: "display_hp_hc"
      unique_id: "display_hp_hc"
      state: >-
        {{ (states.sensor.linky_n_tarif.state == '1') }}" # =1 si HC =2 si H

# Consommation journalière HP + HC - addition des utility meter
  - sensor:
    - name: "Energie Totale Jour"
      unique_id: "energy_total_daily"
      state: >-
        {% set p = states('sensor.energy_total_usage_daily_hp') | float(default=0) | round(2) %}
        {% set o = states('sensor.energy_total_usage_daily_hc') | float(default=0) | round(2) %}
        {{ (o + p) | round(2) }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"

# Consommation semaine HP + HC
    - name: "energy_total_weekly"
      state: >-
        {% set p = states('sensor.energy_total_usage_weekly_hp') | float(default=0) | round(2) %}
        {% set o = states('sensor.energy_total_usage_weekly_hc') | float(default=0) | round(2) %}
        {{ (o + p) | round(2) }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"  

# Consommation mensuelle HP + HC
    - name: "energy_total_monthly"
      state: >-
        {% set p = states('sensor.energy_total_usage_monthly_hp') | float(default=0) | round(2) %}
        {% set o = states('sensor.energy_total_usage_monthly_hc') | float(default=0) | round(2) %}
        {{ (o + p) | round(2) }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"  

# Consommation annuelle HP + HC
    - name: "energy_total_yearly"
      state: >-
        {% set p = states('sensor.energy_total_usage_yearly_hp') | float(default=0) | round(2) %}
        {% set o = states('sensor.energy_total_usage_yearly_hc') | float(default=0) | round(2) %}
        {{ (o + p) | round(2) }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"  

# Cout de l'Energie
# les couts du kWh HP et HC sont calculés dans excel en fonction des factures recues
# et saisis manuellement dans HA

    - name: "Cout Energy Total Jour HPHC"
      state: >-
        {% set hp = states('sensor.energy_total_usage_daily_hp') | float(default=0) | round(2) %}
        {% set hc = states('sensor.energy_total_usage_daily_hc') | float(default=0) | round(2) %}
        {% set chp = states('input_number.cout_kwh_hp') | float(default=0) | round(5) %}
        {% set chc = states('input_number.cout_kwh_hc') | float(default=0) | round(5) %}
        {{((hc*chc) + (hp*chp)) | round(2) }}
      unit_of_measurement: "€"
      device_class: "monetary"
      state_class: "total"  
      unique_id: "cout_energy_total_jour_hphc"

    - name: "Cout Energy Total Jour HP"
      state: >-
        {% set hp = states('sensor.energy_total_usage_daily_hp') | float(default=0) | round(2) %}
        {% set chp = states('input_number.cout_kwh_hp') | float(default=0) | round(5) %}
        {{(hp*chp) | round(2) }}
      unit_of_measurement: "€"
      device_class: "monetary"
      state_class: "total"  
      unique_id: "cout_energy_total_jour_hp"
      
    - name: "Cout Energy Total Jour HC"
      state: >-
        {% set hc = states('sensor.energy_total_usage_daily_hc') | float(default=0) | round(2) %}
        {% set chc = states('input_number.cout_kwh_hc') | float(default=0) | round(5) %}
        {{(hc*chc) | round(2) }}
      unit_of_measurement: "€"
      device_class: "monetary"
      state_class: "total"  
      unique_id: "cout_energy_total_jour_hc"
      

Codes du fichier linky.yaml Version « Tempo »

####################################################
#                                                  #
#                       LINKY                      #
#                                                  #
####################################################

# Sensor à conserver l'historique dans le tableau Energy
# le sensor sensor.linky_hphc_kwh est mis à zero dans tic Linky 
# depuis le 3/12/2023
# Date à laquelle le comptage des tarifs tempo a été mis en place
#utility_meter:
# usage jour  
#  energy_total_usage_daily:
#    source: sensor.linky_hphc_kwh
#    cycle: daily
#    tariffs:
#      - hp
#      - hc

## 
input_boolean:
  com_linky:
    name: Comm Linky OK=On



input_text:
  # Permet de simuler des Statuts pour les tests unitaires
  linky_test_status:   
    name: Test statuts Linky

template:
  - binary_sensor:
    # Utilisé dans l'affichage des graphiques de puissance permettant de materialiser la zone HC
    # = true si HC
    - name: "display_hp_hc"
      unique_id: "display_hp_hc"
      state: >-
        {{ states('sensor.linky_ptec')|int(default=0) == "HC.." }} # =on si HC =off si HP

  - sensor:

# Template utilisés dans le tableau Energy, ils ont pris le relais des Utility Meter supprimés le 3/11/2023
# Donc NE PAS SUPPRIMER sinon perte de l'historique des consommations

    - name: "energy_total_usage_daily_hc"
      unique_id: "energy_total_usage_daily_hc"
      state: >-
        {{ 0 }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total_increasing"    

    - name: "energy_total_usage_daily_hp"
      unique_id: "energy_total_usage_daily_hp"
      state: >-
        {{ 0 }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total_increasing"

# Calcul du Cout Journalier de l'Energie en fonction du tarif en cours
# Apres passage en Tempo le 3/11/2023
    - name: "Cout Energie HC Bleu Jour"
      state: >-
        {% set en = states('sensor.compteur_energie_hc_bleu_jour') | float(default=0) | round(2) %}
        {% set ct = states('input_number.tarif_edf_tempo_bleu_hc') | float(default=0) | round(2) %}
        {{(en*ct) | round(2) }}
      unit_of_measurement: "€"
      device_class: "monetary"
      state_class: "total"  
      unique_id: "cout_energie_hc_bleu_jour"

    - name: "Cout Energie HP Bleu Jour"
      state: >-
        {% set en = states('sensor.compteur_energie_hp_bleu_jour') | float(default=0) | round(2) %}
        {% set ct = states('input_number.tarif_edf_tempo_bleu_hp') | float(default=0) | round(2) %}
        {{(en*ct) | round(2) }}
      unit_of_measurement: "€"
      device_class: "monetary"
      state_class: "total"  
      unique_id: "cout_energie_hp_bleu_jour"

    - name: "Cout Energie HC Blanc Jour"
      state: >-
        {% set en = states('sensor.compteur_energie_hc_blanc_jour') | float(default=0) | round(2) %}
        {% set ct = states('input_number.tarif_edf_tempo_blanc_hc') | float(default=0) | round(2) %}
        {{(en*ct) | round(2) }}
      unit_of_measurement: "€"
      device_class: "monetary"
      state_class: "total"  
      unique_id: "cout_energie_hc_blanc_jour"

    - name: "Cout Energie HP Blanc Jour"
      state: >-
        {% set en = states('sensor.compteur_energie_hp_blanc_jour') | float(default=0) | round(2) %}
        {% set ct = states('input_number.tarif_edf_tempo_blanc_hp') | float(default=0) | round(2) %}
        {{(en*ct) | round(2) }}
      unit_of_measurement: "€"
      device_class: "monetary"
      state_class: "total"  
      unique_id: "cout_energie_hp_blanc_jour"

    - name: "Cout Energie HC Rouge Jour"
      state: >-
        {% set en = states('sensor.compteur_energie_hc_rouge_jour') | float(default=0) | round(2) %}
        {% set ct = states('input_number.tarif_edf_tempo_rouge_hc') | float(default=0) | round(2) %}
        {{(en*ct) | round(2) }}
      unit_of_measurement: "€"
      device_class: "monetary"
      state_class: "total"  
      unique_id: "cout_energie_hc_rouge_jour"

    - name: "Cout Energie HP Rouge Jour"
      state: >-
        {% set en = states('sensor.compteur_energie_hp_rouge_jour') | float(default=0) | round(2) %}
        {% set ct = states('input_number.tarif_edf_tempo_rouge_hp') | float(default=0) | round(2) %}
        {{(en*ct) | round(2) }}
      unit_of_measurement: "€"
      device_class: "monetary"
      state_class: "total"  
      unique_id: "cout_energie_hp_rouge_jour"

Automatismes

Commutation de HP vers HC et Inversement

Il permet de permuter la tarification des utiliy meter en fonction du tarif récupéré dans le Linky (PTEC)

Code de l’automatisme Simplifié

N’oubliez pas de supprimer les « utility_meter » qui ne vous concerne pas.

alias: 6_1_0 Energie Changement HP<->HC
description: ''
trigger:
  - platform: state
    entity_id: sensor.linky_n_tarif
    id: tarif_hc
    from: '2'
    to: '1'
  - platform: state
    entity_id: sensor.linky_n_tarif
    from: '1'
    id: tarif_hp
    to: '2'
condition: []
action:
  - choose:
      - conditions:
          - condition: trigger
            id: tarif_hc
        sequence:
          - service: select.select_option
            data:
              option: hc
            target:
              entity_id:
                - select.energy_total_usage_daily
                - select.energy_total_usage_weekly
                - select.energy_total_usage_monthly
                - select.energy_total_usage_yearly
                - select.energy_pisc_usage_daily
                - select.energy_pisc_usage_weekly
                - select.energy_pisc_usage_monthly
                - select.energy_pisc_usage_yearly
                - select.energy_sdb_usage_daily
                - select.energy_sdb_usage_weekly
                - select.energy_sdb_usage_monthly
                - select.energy_sdb_usage_yearly
                - select.energy_ecs1_usage_daily
                - select.energy_ecs1_usage_weekly
                - select.energy_ecs1_usage_monthly
                - select.energy_ecs1_usage_yearly
                - select.energy_pac1_usage_daily
                - select.energy_pac1_usage_weekly
                - select.energy_pac1_usage_monthly
                - select.energy_pac1_usage_yearly
                - select.energy_mal_usage_daily
                - select.energy_mal_usage_monthly
                - select.energy_mal_usage_weekly
                - select.energy_mal_usage_yearly
                - select.energy_autres_usage_daily
                - select.energy_autres_usage_monthly
                - select.energy_autres_usage_weekly
                - select.energy_autres_usage_yearly
                - select.energy_vmc_usage_daily
      - conditions:
          - condition: trigger
            id: tarif_hp
        sequence:
          - service: select.select_option
            data:
              option: hp
            target:
              entity_id:
                - select.energy_total_usage_daily
                - select.energy_total_usage_weekly
                - select.energy_total_usage_monthly
                - select.energy_total_usage_yearly
                - select.energy_pisc_usage_daily
                - select.energy_pisc_usage_weekly
                - select.energy_pisc_usage_monthly
                - select.energy_pisc_usage_yearly
                - select.energy_sdb_usage_daily
                - select.energy_sdb_usage_weekly
                - select.energy_sdb_usage_monthly
                - select.energy_sdb_usage_yearly
                - select.energy_ecs1_usage_daily
                - select.energy_ecs1_usage_weekly
                - select.energy_ecs1_usage_monthly
                - select.energy_ecs1_usage_yearly
                - select.energy_pac1_usage_daily
                - select.energy_pac1_usage_weekly
                - select.energy_pac1_usage_monthly
                - select.energy_pac1_usage_yearly
                - select.energy_mal_usage_daily
                - select.energy_mal_usage_monthly
                - select.energy_mal_usage_weekly
                - select.energy_mal_usage_yearly
                - select.energy_autres_usage_daily
                - select.energy_autres_usage_monthly
                - select.energy_autres_usage_weekly
                - select.energy_autres_usage_yearly
                - select.energy_vmc_usage_daily
    default: []
mode: single

Automatisme de contrôle de la communication du Linky avec « Automation »

Descriptif fonctionnel

Le but est de surveiller si la communication entre le Linky et HA est établie.

A chaque changement d’état de l’entité « sensor.linky_umoy », l’automatisme est déclenché:

• l' »input_boolean.com_linky » signifiant que la communication entre le linky et HA est OK est forcé sur On
• Un délai d’une heure est déclenché,
• si durant ce délai U_MOY change d’état, l’automatisme est relancé (mode:restart) et « input_boolean.com_linky » reste sur On
• sinon, passé ce délai, l' »input_boolean.com_linky » est forcé sur Off, et la communication est considérée en défaut, il sera remis sur On au prochain changement d’état de PAPP

Je surveillance la puissance PAPP, c’est la valeur plus évolutive, mais il arrive que quelques fois, surtout de nuit que la puissance reste stable pas et déclare donc un défaut fantôme.

Code de l’automatisme avec le module « Automatisation » classique de HA:

Je surveille la tension moyenne car elle varie très souvent contrairement à la puissance ou l’intensité qui peuvent restés stables plus d’une heure la nuit notamment.

- id: '1638118858848'
  alias: 2_2_2 Alarme_Notification Time Out Linky
  description: ' '
  trigger:
  - platform: state
    entity_id: sensor.linky_umoy
  condition: []
  action:
  - service: input_boolean.turn_on
    target:
      entity_id: input_boolean.com_linky
  - delay:
      hours: 1
      minutes: 0
      seconds: 0
      milliseconds: 0
  - service: input_boolean.turn_off
    target:
      entity_id: input_boolean.com_linky
  mode: restart

Code de l’automatisme avec le module « AppDaemon »:

Ce module surveille l’évolution de « sensor.linky_umoy » pendant 1 h, si pas de changement on déclare la communication avec le Linky « KO ».

Cet Addon, pour ceux qui ne connaissent pas, permet d’écrire des programmes en Python très élaborés.

Je décrit son installation dans cet article cet article.

Vous trouverez ci après les fichiers « .yaml » et « .py » à installer dans « votre AppDaemon. »

Code de « surveille_activite.yaml »

surveille_com_linky:
  module: surveille_activite
  class: SurveilleActivite
  entite: sensor.linky_umoy #sensor.linky_i_inst # sensor.linky_papp #sensor.linky_umoy #
  #entite: input_text.linky_test_status
  tempo: 3600 # Tempo de surveillance en secondes
  activite_ok: input_boolean.com_linky #switch.test_com_out

  

Code de « surveille_activite.py »

Les services de notifications sont à adapter à votre configuration.

import hassapi as hass

class SurveilleActivite(hass.Hass):
    def initialize(self):
        self.listen_state(self.change,self.args["entite"])
        nom_entité = self.get_state(self.args["entite"],attribute="entity_id")
        duree_tempo=int(self.args["tempo"])
        self.turn_on(self.args["activite_ok"])
        self.tempo=self.run_in(self.notification, duree_tempo,entité=nom_entité,temps=duree_tempo)
        self.log(f'Initialisation de: {nom_entité} pour {duree_tempo}s et {self.tempo}.', log="surveille_log")

    def change(self, entity, attribute, old, new, kwargs):
        heure = str(self.time())[:8]
        duree_tempo=int(self.args["tempo"])
        tempo_on = str(entity)
        nom_entité = str(entity)
        nouvelle_valeur = new
        # Mise à on de Com_Ok
        self.turn_on(self.args["activite_ok"])
        self.log(f'Nouvelle valeur de {entity}: {nouvelle_valeur}-Tempo={duree_tempo}', log="surveille_log")
        cle_tempo = self.tempo
        if cle_tempo != None:
            self.tempo = self.cancel_timer(cle_tempo) 
            #self.log(f'Info tempo: {self.info_timer(cle_tempo)}', log="surveille_log")
            #self.log(f'Fin tempo {cle_tempo}', log="surveille_log")

        self.tempo = self.run_in(self.notification, duree_tempo,entité=nom_entité,temps=duree_tempo)

    def notification(self, kwargs):
        heure = str(self.time())[:8]
        nom_entité = kwargs["entité"]
        duree_temps= kwargs["temps"]
        # Mise à off de Com_Ok
        self.turn_off(self.args["activite_ok"])
        self.log(f'Alerte! {nom_entité} est out depuis {duree_temps} sec.', log="surveille_log")
        message_notification=format(heure)+"Alerte!"+ format(nom_entité)+"est out depuis: "+format(duree_temps)+" sec."
        self.call_service('notify/telegram', message_notification)
        self.call_service('dwains_dashboard/notification_create', message=message_notification)

Blueprint Notification défaut communication:

J’exploite le défaut avec un blueprint « Nagging Alerting Notification Automation » plus pratique que l’intégration « alert » qui nécessite un redémarrage de HA à chaque modification.

J’utilise également ce blueprint dans d’autres cas de surveillance, portes, température, communication, etc..

Ici aussi, les services de notification sont à adapter à votre configuration.

alias: 2_1_11 Alarme Blueprints Notification Def Com Linky
description: Blue Print
use_blueprint:
  path: pavax/nagging_alert_notification.yaml
  input:
    condition_entity_state: 'on'
    sensor_entity: input_boolean.com_linky
    alert_state: 'off'
    alert_action:
      - service: notify.telegram
        data:
          message: Com Linky off Line{{-"\n"-}}{{states("sensor.date_time") }}
          title: Etat Reseau !!!
      - service: dwains_dashboard.notification_create
        data:
          message: Com Linky Off Line {{-"\n"-}}{{states("sensor.date_time") }}
    resolved_action:
      - service: notify.telegram
        data:
          message: Com Linky On Line{{-"\n"-}} {{states("sensor.date_time") }}
          title: Etat RESEAU!!!
      - service: dwains_dashboard.notification_create
        data:
          message: Com Linky On Line{{-"\n"-}}{{states("sensor.date_time") }}
    notify_device: 62cdce054a9d3448484b4df8e44cc499
    repeat_delay: 300
    initial_delay: 1
    max_alerts: 100
    resolved_message: Alerte {{ entity_name }} Résolu
    notify_message: Alerte {{ entity_name }}Déclenché

Lovelace

Exemple d’affichage des données

Un autre exemple d’affichage utilisant « custom:mini-graph-card » de HACS

type: vertical-stack
cards:
  - type: custom:mini-graph-card
    entities:
      - entity: sensor.energie_totale_jour
    name: Conso Linky 7j
    hours_to_show: 168
    aggregate_func: max
    group_by: date
    show:
      graph: bar
    icon: mdi:flash
  - type: custom:mini-graph-card
    color_thresholds:
      - color: '#00FF00'
        value: 0
      - color: '#FF9900'
        value: 4000
      - color: '#EA9999'
        value: 6000
      - color: '#CC0000'
        value: 10000
    color_thresholds_transition: hard
    line_width: 2
    icon: mdi:flash
    show:
      extrema: true
      fill: true
      icon: true
      labels: false
      name: true
      state: true
    hour24: true
    points_per_hour: 4
    hours_to_show: 24
    group: false
    state_map:
      - label: hp
        value: 'off'
      - label: hc
        value: 'on'
    style: |
      ha-card {
        border: solid 2px var(--primary-color);
      }
    entities:
      - entity: sensor.linky_papp
        name: Totale
      - color: '#CCC0cCC'
        entity: binary_sensor.display_hp_hc
        name: HC
        show_line: false
        y_axis: secondary
    name: Puissance Linky 24h

Un autre exemple d’affichage utilisant « custom:apexcharts-card » de HACS

type: custom:apexcharts-card
chart_type: donut
header:
  show: true
  title: Conso du Jour
  show_states: false
  colorize_states: true
series:
  - entity: sensor.energy_total_usage_daily_hp
    name: HP
    color: green
  - entity: sensor.energy_total_usage_daily_hc
    name: HC
    color: blue

Affichage du tableau Energie

Affichage dans Grafana

Vous trouverez ci-après le fichier Graphana correspondant.

Conclusion

Pas grand chose d’autre à ajouter, c’est simple à mettre en oeuvre (si le Linky est accessible), fiable et peu onéreux, il ne reste plus qu’a exploiter les informations.

Publication en lien avec cet article:

https://domo.rem81.com/ha-teleinformation-linky-mode-historique/