HA-Teleinformation Linky-Mode Historique

Intro

C’est fait, j’ai enfin câblé 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.

Raccordement du Linky

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.

WeMos Teleinfo 2

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:

J’ai utilisé dans un premier temps le mode historique du Linky, puis je suis passé au mode standard, le nombre d’informations disponibles est plus élevés, voir mon article sur le sujet.

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:

Mode Historique

Mode Standard

Informations collectées

Je collecte les énergies Heures creuses « HCHC » et heures pleines »HPHC » en wh, je les additionne dans un « template » (Linky HPHC KWH) et divise par 1000 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 collecte également l’intensité instantanée « IINST » et l’intensité souscrite « ISOUSC », je calcule dans un « Template » « Linky I/Imax » le ratio entre les deux en %, ce qui me donne une idée de la réserve d’intensité disponible et plus tard, m’en servir pour vérifier si mon abonnement peut être revue à la baisse.

L’information PTEC nous indique si le tarif est en heure creuse ou heure pleine, variable utilisée dans l’automatisme de comptabilisation de l’énergie avec les « utility_meter ».

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.

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
  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.1
    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: 1200
  parity: EVEN
  data_bits: 7

teleinfo:
  id: myteleinfo
  uart_id: uart_a
  update_interval: 10s
  historical_mode: true
  
# 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  


sensor:
  - platform: teleinfo
    id: hchc
    tag_name: "HCHC"
    name: "Linky HC Wh"
    unit_of_measurement: "Wh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
    
  - platform: teleinfo
    id: hchp
    tag_name: "HCHP"
    name: "Linky HP Wh"
    unit_of_measurement: "Wh"
    icon: mdi:flash
    teleinfo_id: myteleinfo
 
  - platform: teleinfo
    id: papp
    tag_name: "PAPP"
    name: "Linky PAPP"
    unit_of_measurement: "VA"
    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%
           
    
  - platform: teleinfo
    id: isousc
    tag_name: "ISOUSC"
    name: "Linky I Sousc"
    unit_of_measurement: "A"
    icon: mdi:flash
    teleinfo_id: myteleinfo

  - platform: teleinfo
    id: iinst
    tag_name: "IINST"
    name: "Linky I Inst"
    unit_of_measurement: "A"
    icon: mdi:flash
    teleinfo_id: myteleinfo

  - platform: teleinfo
    id: imax
    tag_name: "IMAX"
    name: "linky I Max"
    unit_of_measurement: "A"
    icon: mdi:flash
    teleinfo_id: myteleinfo

  - platform: template
    name: "Linky I/Imax"
    id: i100
    icon: mdi:flash
    unit_of_measurement: "%"
    accuracy_decimals: 0
    lambda: |-
      return (id(iinst).state/id(isousc).state*100);

  - platform: template
    name: "Linky HPHC KWH"
    id: hphc_kwh
    icon: mdi:flash
    unit_of_measurement: "kWh"
    accuracy_decimals: 0
    lambda: |-
      return ((id(hchc).state+id(hchp).state)/1000);
      
  - platform: homeassistant
    name: "HCHP J"
    unit_of_measurement: "kWh"
    entity_id: sensor.energie_totale_linky_jour
    id: hphcj

  - platform: wifi_signal
    id: wif
    name: "${friendly_name} WiFi Signal Sensor"
    update_interval: 60s
    
  - 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:
  - platform: teleinfo
    tag_name: "OPTARIF"
    name: "Linky OPTARIF"
    teleinfo_id: myteleinfo
    
  - platform: teleinfo
    tag_name: "PTEC"
    name: "Linky PTEC"
    teleinfo_id: myteleinfo

  - 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"

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


display:
  - platform: ssd1306_i2c
    model: "SSD1306 128x64"
    address: 0x3C
    brightness: 100%
    lambda: |-
      it.printf(0,0,id(arial),"PuC=%.0f VA",id(papp).state);
      it.printf(0,0,id(arial),"PuC=%.0f VA",id(papp).state);
      it.printf(0,15,id(arial),"I Inst=%.0f A",id(iinst).state);
      it.printf(70,15,id(arial),"-%.0f %%",id(i100).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());  
      
   

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 I/imax et 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

On y retrouve:

  • les « utility meter » qui comptabilisent les energies consommées HC/HP par jour, semaine, mois, année
  • un « input boolean » HP/HC et un « input boolean » forcage du HP/HC qui servent dans les automatismes
  • deux « input_number » cout d’un kWh HC et HP
  • quatre « input_datetime », horaires des HC et HP qui me servent de secours en cas de défaillance de communication avec le Linky
  • 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
####################################################
#                                                  #
#                       LINKY                      #
#                                                  #
####################################################


utility_meter:
# usage jour  
  energy_total_linky_usage_daily:
    source: sensor.linky_conso_totale_hphc
    cycle: daily
    tariffs:
      - hp
      - hc
# usage semaine
  energy_total_linky_usage_weekly:
    source: sensor.linky_conso_totale_hphc
    cycle: weekly
    tariffs:
      - hp
      - hc
# usage mois
  energy_total_linky_usage_monthly:
    source: sensor.linky_conso_totale_hphc
    cycle: monthly
    tariffs:
      - hp
      - hc
#usage an
  energy_total_linky_usage_yearly:
    source: sensor.linky_conso_totale_hphc
    cycle: yearly
    tariffs:
      - hp
      - hc

input_boolean:
  # H pleine/creuse
  hc_hp:
    name: Tarif HC-HP
    icon: mdi:power-settings

  forcage_hc_hp:
    name: Forcage HC
    icon: mdi:power-settings

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_datetime:
  # Horaire HC/HP
  horaire_hc_debut_1:
    name: Horaire HC Début 1
    has_date: false
    has_time: true
  horaire_hc_debut_2:
    name: Horaire HC Début 2
    has_date: false
    has_time: true

  horaire_hp_debut_1:
    name: Horaire HP Début 1
    has_date: false
    has_time: true
  horaire_hp_debut_2:
    name: Horaire HP Début 2
    has_date: false
    has_time: true

# Utilisé dans l'affichage des graphiques de puissance permettant de materialiser la zone HC
binary_sensor:
  - platform: template # = true si HC
    sensors:
      display_hp_hc:
        friendly_name: "HC"
        value_template: "{{ (states.input_boolean.hc_hp.state == 'off') }}"

template:
# Consommation journalière HP + HC - addition des utility meter
  - sensor:
    - name: "Energie Totale Linky Jour"
      unique_id: "energy_total_linky_daily"
      state: >-
        {% set hp = states('sensor.energy_total_linky_usage_daily_hp') | float(default=0) | round(2) %}
        {% set hc = states('sensor.energy_total_linky_usage_daily_hc') | float(default=0) | round(2) %}
        {{ (hp + hc) | round(2) }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"  

# Consommation semaine HP + HC
    - name: "Energie Totale Linky weekly"
      unique_id: "energy_total_linky_weekly"
      state: >-
        {% set hp = states('sensor.energy_total_linky_usage_weekly_hp') | float(default=0) | round(2) %}
        {% set hc = states('sensor.energy_total_linky_usage_weekly_hc') | float(default=0) | round(2) %}
        {{ (hp + hc) | round(2) }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"  


# Consommation mensuelle HP + HC
    - name: "Energie Totale Linky Mois"
      unique_id: "energy_total_linky_monthly"
      state: >-
        {% set hp = states('sensor.energy_total_linky_usage_monthly_hp') | float(default=0) | round(2) %}
        {% set hc = states('sensor.energy_total_linky_usage_monthly_hc') | float(default=0) | round(2) %}
        {{ (hp + hc) | round(2) }}
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"  

# Consommation annuelle HP + HC
    - name: "Energie Totale Linky An"
      unique_id: "energy_total_linky_yearly"
      state: >-
        {% set hp = states('sensor.energy_total_linky_usage_yearly_hp') | float(default=0) | round(2) %}
        {% set hc = states('sensor.energy_total_linky_usage_yearly_hc') | float(default=0) | round(2) %}
        {{ (hp + hc) | 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_linky_usage_daily_hp') | float(default=0) | round(2) %}
        {% set hc = states('sensor.energy_total_linky_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_linky_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_linky_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"

# Linky: Cumul HP+HC en kWh -> Utilisé dans utility meter
# sensor.linky_hphc_kwh est calculé dahns l'ESP
    - name: "Linky Conso Totale HPHC"
      unique_id: "linky_conso_totale_hphc"
      unit_of_measurement: "kWh"
      device_class: "energy"
      state_class: "total"  
      state: >-
        {% set hphc = states('sensor.linky_hphc_kwh') | float(default=0) | round(0) %}
        {% if (hphc)>10000 %}
          {{ (hphc) | round(0) }}
        {%endif%}          

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) mais aussi en cas de défaillance de la communication avec le Linky selon les horaires des input_datetime ou de forcage de l’input_boolean.

Je vous l’accorde, Il y a moyen de faire plus simple et de se passer du mode secours des input_datetime.

Descriptif fonctionnel

Code de l’automatisme:

- id: '1634706860525'
  alias: 6_1_1 Energie Changement HP<->HC
  description: ''
  trigger:
  - platform: time
    at: input_datetime.horaire_hc_debut_1
    id: hc1
  - platform: time
    at: input_datetime.horaire_hc_debut_2
    id: hc2
  - platform: time
    at: input_datetime.horaire_hp_debut_1
    id: hp1
  - platform: time
    at: input_datetime.horaire_hp_debut_2
    id: hp2
  - platform: state
    entity_id: input_boolean.forcage_hc_hp
    from: 'off'
    to: 'on'
    id: forcage hc
  - platform: state
    entity_id: input_boolean.forcage_hc_hp
    from: 'on'
    to: 'off'
    id: forcage hp
  - platform: state
    entity_id: sensor.linky_ptec
    id: tarif_hc
    from: HP..
    to: HC..
  - platform: state
    entity_id: sensor.linky_ptec
    from: HC..
    to: HP..
    id: tarif_hp
  condition: []
  action:
  - choose:
    - conditions:
      - condition: or
        conditions:
        - condition: and
          conditions:
          - condition: state
            entity_id: input_boolean.com_linky
            state: 'off'
          - condition: or
            conditions:
            - condition: trigger
              id: hc1
            - condition: trigger
              id: hc2
        - condition: and
          conditions:
          - condition: trigger
            id: tarif_hc
          - condition: state
            entity_id: input_boolean.com_linky
            state: 'on'
        - condition: trigger
          id: forcage hc
      sequence:
      - service: input_boolean.turn_off
        data: {}
        entity_id: input_boolean.hc_hp
      - service: utility_meter.select_tariff
        data:
          tariff: hc
        target:
          entity_id:
          - utility_meter.energy_total_linky_usage_daily
          - utility_meter.energy_total_linky_usage_monthly
          - utility_meter.energy_total_linky_usage_weekly
          - utility_meter.energy_total_linky_usage_yearly
    - conditions:
      - condition: or
        conditions:
        - condition: and
          conditions:
          - condition: state
            entity_id: input_boolean.com_linky
            state: 'off'
          - condition: or
            conditions:
            - condition: trigger
              id: hp1
            - condition: trigger
              id: hp2
        - condition: and
          conditions:
          - condition: state
            entity_id: input_boolean.com_linky
            state: 'on'
          - condition: trigger
            id: tarif_hp
        - condition: trigger
          id: forcage hp
      sequence:
      - service: input_boolean.turn_on
        data: {}
        entity_id: input_boolean.hc_hp
      - service: utility_meter.select_tariff
        data:
          tariff: hp
        target:
          entity_id:
          - utility_meter.energy_total_linky_usage_daily
          - utility_meter.energy_total_linky_usage_monthly
          - utility_meter.energy_total_linky_usage_weekly
          - utility_meter.energy_total_linky_usage_yearly
    default: []
  mode: single

Automatisme de contrôle de la communication du Linky

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é PAPP (puissance instantanée), 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 PAPP 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.

En mode standard, nous pourrions utiliser l’entité « DATE ».

Code de l’automatisme:

- id: '1638118858848'
  alias: 2_2_2 Alarme_Notification Time Out Linky
  description: ' '
  trigger:
  - platform: state
    entity_id: sensor.linky_papp
  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

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 ce blueprint dans d’autres cas de surveillance, portes, communication, etc..

- id: '1638119466260'
  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: persistent_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: persistent_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: Alert {{ entity_name }} resolved
      notify_message: Alert {{ entity_name }} triggered

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_linky_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_linky_usage_daily_hp
    name: HP
    color: green
  - entity: sensor.energy_total_linky_usage_daily_hc
    name: HC
    color: blue

Affichage du tableau Energie

Affichage dans Grafana

Vous trouverez ci-après le fichier Graphana correspondant (A renommer en .json)

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:

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée.

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.