Stiebel-Eltron mit CAN-Bus unter Verwendung eines C++-Wrappers

[Vincent82]

Hallo robob,

Fotos ist gerade schlecht, weil alles gut verbaut ist. Hier ist das aber gut dargestellt: https://elkement.wordpress.com/2016/08/24/hacking-my-heat-pump-part-2-logging-energy-values/
Aber das Einzige, was Du machen musst, ist CAN High und CAN Low vom MCP2515 anschließen. Ground habe ich entgegen des Beispiels nicht angeschlossen, sollte auch nicht nötig sein.
Vergesse, nicht den Jumper für den Abschlusswiderstand am MCP2515 zu entfernen.

Da ich die Komponenten eigentlich für was Anderes einsetzen wollte, wo kein Platz war für den Pegelwandler arbeite ich mit der Variante ohne Pegelwandler.

Du siehst die Adressen (welche bei dem Protokoll ja anscheinend die CAN ID´s sind), wenn Du den CAN Konfigurierst und Dir dann den Log Output anschaust. Es werden da scheinbar alle Nachrichten im Log ausgegeben.


Wie in der Config zu entnehmen ist, sende ich auf ID 0x680. Ob das immer richtig und gut ist weiß ich nicht.

[robob]

So mein ESP-WROOM-32 hängt jetzt via MCP2515 an meiner Heizung.
Hier ist das Pinout-Diagramm dazu:
http://esp32.net/images/Magic-Cauldron/ESP-WROOM-32-Breakout/Magic-Cauldron_ESP-WROOM-32-Breakout_V2.0a_DiagramPinout.png

Ursprünglich wollte ich über den DC-DC-Konverter die Spannung direkt bei meiner Heizung abgreifen. Aber dann fällt das Heizungsdisplay aus.
Also hab ich das jetzt doch via USB-Stecker gelöst.

Unten angehängt ein paar Bilder.
Und hier die Einstellungen die ich an der ESP-Home Config verwende - der Rest ist derzeit gleich wie bei Vincent und muss noch mit den CAN-IDs an meine Umgebung angepasst werden.

Code Auswählen Erweitern

spi:
  id: McpSpi
  clk_pin: GPIO23
  mosi_pin: GPIO22
  miso_pin: GPIO21

canbus:
  - platform: mcp2515
    id: my_mcp2515
    spi_id: McpSpi
    cs_pin: GPIO19
    can_id: 4
    bit_rate: 20kbps
    on_frame:


Was mich dazu vor allem interessiert: Ich erhalte offenbar Pakete von 6 verschiedenen CAN-IDs?!
100, 180, 301, 480, 514, 700
Woher kommt das und woher weiß ich, welche CAN-ID von der Heizung oder von der FEK-Fernbedienung kommt?
Weiters bekomme ich die falschen Werte für den Stromverbrauch.

Code Auswählen Erweitern

[12:47:11][D][canbus:066]: received can message std can_id=0x100 size=7
[12:47:11][D][canbus:066]: received can message std can_id=0x180 size=7
[12:47:11][D][canbus:066]: received can message std can_id=0x301 size=7
[12:47:12][D][sensor:121]: 'Stromverbrauch Heizung heute': Sending state 32800.76953 kWh with 3 decimals of accuracy
[12:47:12][D][canbus:032]: send extended id=0x680 size=7
[12:47:12][D][main:193]: EVU Sperre requested
[12:47:12][D][canbus:066]: received can message std can_id=0x514 size=7
[12:47:12][D][canbus:066]: received can message std can_id=0x480 size=7
[12:47:12][D][canbus:066]: received can message std can_id=0x700 size=7

[robob]

So,
ich hab jetzt an alle Adressen die im Log angezeigt werden eine Anfrage für einen Wert aus der Elster-Tabelle gesendet.
Ich bekomme eine Antwort von id514 bzw. id 51e. Aber der Wert stimmt nicht mit der am Display gezeigten Leistung an der Heizung überein.

Code Auswählen Erweitern

     
spi:
  id: McpSpi
  clk_pin: GPIO18
  mosi_pin: GPIO23
  miso_pin: GPIO19

canbus:
  - platform: mcp2515
    id: my_mcp2515
    spi_id: McpSpi
    cs_pin: GPIO15
    can_id: 680
    use_extended_id: false
    bit_rate: 20kbps
    on_frame:

    - can_id: 0x100
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x09 and x[4]==0x1c) {
              float wert =float(float((int((x[4])+( (x[3])<<8))))/10);
              ESP_LOGD("main", "Antwort von ID100: %f", wert);
            }

    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x09 and x[4]==0x1c) {
              float wert =float(float((int((x[4])+( (x[3])<<8))))/10);
              ESP_LOGD("main", "Antwort von ID180: %f", wert);
            }


    - can_id: 0x301
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x09 and x[4]==0x1c) {
              float wert =float(float((int((x[4])+( (x[3])<<8))))/10);
              ESP_LOGD("main", "Antwort von ID301: %f", wert);
            }
           
    - can_id: 0x401
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x4e and x[4]==0xc7) {
              float wert =float(float((int((x[4])+( (x[3])<<8))))/10);
              ESP_LOGD("main", "Antwort von ID401 - Bedienteil: %f", wert);
            }
    - can_id: 0x402
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x4e and x[4]==0xc7) {
              float wert =float(float((int((x[4])+( (x[3])<<8))))/10);
              ESP_LOGD("main", "Antwort von ID401 - Bedienteil: %f", wert);
            }
           
    - can_id: 0x480
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x09 and x[4]==0x1c) {
              float wert =float(float((int((x[4])+( (x[3])<<8))))/10);
              ESP_LOGD("main", "Antwort von ID480: %f", wert);
            }


    - can_id: 0x504
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x09 and x[4]==0x1c) {
              float wert =float(float((int((x[4])+( (x[3])<<8))))/10);
              ESP_LOGD("main", "Antwort von ID504: %f", wert);
            }

    - can_id: 0x514
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x09 and x[4]==0x1c) {
              float wert =float(float((int((x[4])+( (x[3])<<8))))/10);
              ESP_LOGD("main", "Antwort von ID514: %f", wert);
            }

    - can_id: 0x700
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x09 and x[4]==0x1c) {
              float wert =float(float((int((x[4])+( (x[3])<<8))))/10);
              ESP_LOGD("main", "Antwort von ID301: %f", wert);
            }





[Vincent82]

Hmm ich weiß nicht ob es Dir bewusst ist aber die Stellen vor dem Komma und nach dem Komma kommen als eigene CAN Nachrichten als Signed 16 bit werte. Die baue ich dann im Nachgang zusammen wie das Display es macht. Läuft hier vielleicht was schief?

...und ich sehe in Deiner Konfig gar keine Anfragen. Schau in meinem Code wie ich Anfragen sende.

Die Werte der Leistungsaufnahmen kommen alle an der CAN ID 0x514. Ich sehe nach einer Anfrage die ID´s aus der Elster Tabelle mehrfach auf dem CAN. Es scheint als reicht ein Teilnehmer die Anfrage immer weiter.

Es scheint also für angefragte Werte nur die Antwort der ID 0x514 relevant zu sein. Bitte schaue Dir noch mal meinen (zugegebenermaßen noch recht chaotischen) Code an.

Noch ein Thema. Hier wird die elektrische Leistungsaufnahme geloggt, nicht die erzeugte Wärmemenge. Vertauscht Du vielleicht die Werte?

[Vincent82]

...und noch was. Die Protokollbeschreibung angehängt am Ticket habe ich mal im Netz gefunden. Das Adressen stimmen nicht mit denen bei mir überein aber man bekommt eine Idee, welche Teilnehmer es so gibt.

[robob]

Hi,
danke für die Liste.
Hier der aktuelle Status:
Ich habe die Kontakte umgelötet auf Pins, die lt. einer Spezifikationstabelle empfohlen werden.
Das mit den Adressen verstehe ich inzwischen einigermaßen. Allerdings - wie errechnet sich z.B. die Adresse 69E bzw. 6A0 für das CAN-Bus Paket?
Und ich hab sowohl die Werte vom Stromverbrauch als auch die der Warmwasserleistung verglichen. Ich erhalte immer die gleiche Antwort.
Was ich noch nicht verstanden habe - ich habe zwar gesehen, dass du in deinem Code die Hex-Werte in der if-Anweisung vergleichst.
Aber ich hab noch nicht verstanden, wie sich die Werte berechnen. Mir fehlen da einige Basics beim Programmiercode.
Was bedeutet <<8?

Sorry wegen meinem Code oben - ich hab den einige Male bearbeitet. Da dürfte sich der falsche reingeschummelt haben.

Ich habe inzwischen den MCP2515 an ein NI USB-8473 in der Garage gehängt um mitzuprotokollieren.
Der funktioniert zwar nur mit 125kbs, aber ich sehe dann wenigstens was beim Sendevorgang passiert:
Beim Senden der folgenden Anfragen im Code sehe ich nur zwei Einträge in der Log-Ausgabe am NI Device. Nämlich den mit der Sende-ID 0x100 (4E C7) und den mit der Sende-ID 0x780 (09 20). Die anderen beiden Pakete werden nicht gelogged. Woran könnte das liegen?
Ich hab auch schon versucht ein Delay von 1000 ms dazwischen zu hängen - gleiches Resultat.
Und ich kann auch Pakete vom NI-Device an mein MCP2515 senden. Ich sehe dann die Pakete auch im Logscreen.

Code Auswählen Erweitern



time:
  - platform: homeassistant
    id: homeassistant_time
    on_time:
     
      - seconds: /10
        then:
          - canbus.send:
              data: [ 0x61, 0x11, 0xfa,0x4e,0x20,0x00,0x00 ]
              can_id: 0x100

          - canbus.send:
              data: [ 0x61, 0x12, 0xfa,0x4e,0xc7,0x00,0x00 ]
              can_id: 0x100

         
         

          - canbus.send:
              data: [ 0xa1, 0x1e, 0xfa,0x09,0x1c,0x00,0x00 ]
              can_id: 0x780


          - canbus.send:
              data: [ 0xa1, 0x1e, 0xfa,0x09,0x20,0x00,0x00 ]
              can_id: 0x780




Ich hab jetzt die Config so angepasst, dass ich alle Pakete von den Adressen die so herumschwirren als HEX-Wert ausgebe.
Ich frage die Werte 0126 (=Uhrzeit - Minute), 092d (= WM WW Summe) sowie 0931 (=WM Heizen Summe) ab.
Zumindest die Minuten müssten sich nach einiger Zeit ändern.
Unten die Config und ein Auszug aus dem Logfile.
Auffallend ist vor allem, dass ich als Antwort immer 80 00 als Antwort-Wert empfange.

Code Auswählen Erweitern

captive_portal:



time:
  - platform: homeassistant
    id: homeassistant_time
    on_time:
     
      - seconds: /10
        then:

          - canbus.send:
              data: [ 0xa1, 0x1e, 0xfa,0x09,0x31,0x00,0x00 ]
              can_id: 0x780
          - delay: 200ms


          - canbus.send:
              data: [ 0xa1, 0x1e, 0xfa,0x09,0x2d,0x00,0x00 ]
              can_id: 0x780
          - delay: 200ms

          - canbus.send:
              data: [ 0xa1, 0x1e, 0xfa,0x01,0x26,0x00,0x00 ]
              can_id: 0x780
          - delay: 200ms



       
spi:
  id: McpSpi
  clk_pin: GPIO18
  mosi_pin: GPIO23
  miso_pin: GPIO19

canbus:
  - platform: mcp2515
    id: my_mcp2515
    spi_id: McpSpi
    cs_pin: GPIO15
    can_id: 780
    use_extended_id: false
    bit_rate: 20kbps
    on_frame:


    - can_id: 0x100
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              ESP_LOGD("main", "Antwort von 100 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);

    - can_id: 0x180
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              ESP_LOGD("main", "Antwort von 180 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);

    - can_id: 0x301
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              ESP_LOGD("main", "Antwort von 301 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);

    - can_id: 0x480
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              ESP_LOGD("main", "Antwort von 480 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);

    - can_id: 0x514
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              ESP_LOGD("main", "Antwort von 514 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);

    - can_id: 0x51e
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              ESP_LOGI("main", "Antwort von 51e Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);

    - can_id: 0x700
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              ESP_LOGD("main", "Antwort von 700 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);

Code Auswählen Erweitern



[18:56:28][D][main:158]: Antwort von 700 Hex: 92 0 fa fe 4c 0 12
[18:56:30][D][canbus:032]: send extended id=0x780 size=7
[18:56:30][D][canbus:066]: received can message std can_id=0x51e size=7
[18:56:30][I][main:146]: Antwort von 51e Hex: f2 0 fa 9 31 80 0
[18:56:30][D][canbus:032]: send extended id=0x780 size=7
[18:56:30][D][canbus:066]: received can message std can_id=0x51e size=7
[18:56:30][I][main:146]: Antwort von 51e Hex: f2 0 fa 9 2d 80 0
[18:56:30][D][canbus:032]: send extended id=0x780 size=7
[18:56:30][D][canbus:066]: received can message std can_id=0x51e size=7
[18:56:30][I][main:146]: Antwort von 51e Hex: f2 0 fa 1 26 80 0
[18:56:31][D][canbus:066]: received can message std can_id=0x480 size=7
[18:56:31][D][main:122]: Antwort von 480 Hex: e0 0 fa fe 1e 0 0
[18:56:31][D][canbus:066]: received can message std can_id=0x700 size=7
[18:56:31][D][main:158]: Antwort von 700 Hex: 92 0 fa fe 1e 0 0
[18:56:33][D][canbus:066]: received can message std can_id=0x480 size=7
[18:56:33][D][main:122]: Antwort von 480 Hex: e1 0 fa fe 4c 0 0
[18:56:33][D][canbus:066]: received can message std can_id=0x480 size=7
[18:56:33][D][main:122]: Antwort von 480 Hex: e1 0 fa fd f3 0 0
[18:56:33][D][canbus:066]: received can message std can_id=0x480 size=7
[18:56:33][D][main:122]: Antwort von 480 Hex: e1 0 fa fe 7 0 0


[robob]

In diesem Forum https://community.symcon.de/t/stiebel-eltron-waermepumpe-wpl13-und-canbus-abfrage/37485/7
wird erklärt dass häufig auch die Adresse 180 zum Auslesen verwendet wird.

Ich konnte jetzt mit Hilfe Anpassung des obigen Codes via Anfrage an Adresse 180 (0x31, 0x00, 0xfa,0x01,0x26,0x00,0x00) die Uhrzeit-Minuten ablesen. Außerdem sind die Werte für Wärmemenge VD Heizen Summe auf die MWh genau übereinstimmend mit den Werten aus der Heizung.
Langsam komme ich der Sache näher.

[Vincent82]

Ok, dann gibt es wohl andere Versionen der Steuerung, wo man mit 0x180 statt 0x680 anfragen muss.

Zur Frage was bedeutet <<8? Die ESPHhome lib gibt den Payload der Nachricht ja als C++ Vektor mit einem Element pro Byte zurück. Den Payload muss ich ja dann zu den Signed Int 16 (=2Byte) Variablen umwandeln. Mit <<8 sagt man, dass man die Variable ab bit 8 beschreiben will.

[robob]

Danke, die Erklärung hat mehr als geholfen.

Ich hab deine Config ein bisschen erweitert auf die anderen fehlenden Wärme-Ertragsdaten.
Auskommentiert hab ich darin noch u.a. die Anfragen für die Verdichter-Laufzeiten.
Da kommt bei mir von der ID 180 keine passende Antwort. Und ich konnte auch sonst keine ID finden die ein Antwortpaket sendet.

Die Luftfeuchtigkeit und Raumtemperatur brauche ich nicht aktiv von der FEK abzufragen - die kommt bei mir alle paar Minuten von der ID 301 und wird an ID 601 als Änderung gesendet.
(Paket C0 01 75 xx xx bzw. C0 01 11 xx xx)
Etwas sorgen macht mir noch, dass im Homeassistant der Aufruf des Sensor-Zustandsverlaufs - z.B. Temperaturverlauf - mehrere Minuten dauert bis alles angezeigt wird.
Ich weiß nicht woran das liegt. Hast du auch das Problem beim Zustandsverlauf?
Hier der Code:

Code Auswählen Erweitern



captive_portal:

globals:
  - id: el_aufnahmeleistung_ww_tag_wh_float
    type: float
    restore_value: yes
  - id: el_aufnahmeleistung_ww_tag_wh_flag
    type: bool
    restore_value: yes
  - id: el_aufnahmeleistung_ww_tag_kwh
    type: float
    restore_value: yes
  - id: el_aufnahmeleistung_ww_tag_kwh_flag
    type: bool
    restore_value: yes
  - id: el_aufnahmeleistung_heiz_tag_wh_float
    type: float
    restore_value: yes
  - id: el_aufnahmeleistung_heiz_tag_wh_flag
    type: bool
    restore_value: yes
  - id: el_aufnahmeleistung_heiz_tag_kwh
    type: float
    restore_value: yes
  - id: el_aufnahmeleistung_heiz_tag_kwh_flag
    type: bool
    restore_value: yes
  - id: el_aufnahmeleistung_ww_total_kWh_float
    type: float
    restore_value: yes
  - id: el_aufnahmeleistung_ww_total_kWh_flag
    type: bool
    restore_value: yes
  - id: el_aufnahmeleistung_ww_total_mWh
    type: float
    restore_value: yes
  - id: el_aufnahmeleistung_ww_total_mWh_flag
    type: bool
    restore_value: yes
  - id: el_aufnahmeleistung_heiz_total_kWh_float
    type: float
    restore_value: yes
  - id: el_aufnahmeleistung_heiz_total_kWh_flag
    type: bool
    restore_value: yes
  - id: el_aufnahmeleistung_heiz_total_mWh
    type: float
    restore_value: yes
  - id: el_aufnahmeleistung_heiz_total_mWh_flag
    type: bool
    restore_value: yes


  - id: waermemertrag_ww_tag_wh_float
    type: float
    restore_value: yes
  - id: waermemertrag_ww_tag_wh_flag
    type: bool
    restore_value: yes
  - id: waermemertrag_ww_tag_kwh
    type: float
    restore_value: yes
  - id: waermemertrag_ww_tag_kwh_flag
    type: bool
   
  - id: waermemertrag_electr_ww_tag_wh_float
    type: float
    restore_value: yes
  - id: waermemertrag_electr_ww_tag_wh_flag
    type: bool
    restore_value: yes
  - id: waermemertrag_electr_ww_tag_kwh
    type: float
    restore_value: yes
  - id: waermemertrag_electr_ww_tag_kwh_flag
    type: bool   
    restore_value: yes

  - id: waermemertrag_heiz_tag_wh_float
    type: float
    restore_value: yes
  - id: waermemertrag_heiz_tag_wh_flag
    type: bool
    restore_value: yes
  - id: waermemertrag_heiz_tag_kwh
    type: float
    restore_value: yes
  - id: waermemertrag_heiz_tag_kwh_flag
    type: bool
    restore_value: yes

  - id: waermemertrag_electr_heiz_tag_wh_float
    type: float
    restore_value: yes
  - id: waermemertrag_electr_heiz_tag_wh_flag
    type: bool
    restore_value: yes
  - id: waermemertrag_electr_heiz_tag_kwh
    type: float
    restore_value: yes
  - id: waermemertrag_electr_heiz_tag_kwh_flag
    type: bool
    restore_value: yes

  - id: waermemertrag_ww_total_kWh_float
    type: float
    restore_value: yes
  - id: waermemertrag_ww_total_kWh_flag
    type: bool
    restore_value: yes
  - id: waermemertrag_ww_total_mWh
    type: float
    restore_value: yes
  - id: waermemertrag_ww_total_mWh_flag
    type: bool
    restore_value: yes

  - id: waermemertrag_heiz_total_kWh_float
    type: float
    restore_value: yes
  - id: waermemertrag_heiz_total_kWh_flag
    type: bool
    restore_value: yes
  - id: waermemertrag_heiz_total_mWh
    type: float
    restore_value: yes
  - id: waermemertrag_heiz_total_mWh_flag
    type: bool
    restore_value: yes

  - id: waermemertrag_electr_heiz_total_kWh_float
    type: float
    restore_value: yes
  - id: waermemertrag_electr_heiz_total_kWh_flag
    type: bool
    restore_value: yes
  - id: waermemertrag_electr_heiz_total_mWh
    type: float
    restore_value: yes
  - id: waermemertrag_electr_heiz_total_mWh_flag
    type: bool
    restore_value: yes

  - id: waermemertrag_electr_ww_total_kWh_float
    type: float
    restore_value: yes
  - id: waermemertrag_electr_ww_total_kWh_flag
    type: bool
    restore_value: yes
  - id: waermemertrag_electr_ww_total_mWh
    type: float
    restore_value: yes
  - id: waermemertrag_electr_ww_total_mWh_flag
    type: bool
    restore_value: yes




sensor:
  - platform: template
    name: "Außentemperatur"
    id: temperature_outside
    unit_of_measurement: "°C"
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 1

  - platform: template
    name: "Quellentemperatur"
    id: temperature_source
    unit_of_measurement: "°C"
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 1

  - platform: template
    name: "Warmwassertemperatur"
    id: temperature_water
    unit_of_measurement: "°C"
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 1

  - platform: template
    name: "Vorlauftemperatur Heizung"
    id: temperature_forerun
    unit_of_measurement: "°C"
    icon: "mdi:waves-arrow-right"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 1
  - platform: template
    name: "Heizkreis Vorlauf"
    id: temperature_forerun_heating
    unit_of_measurement: "°C"
    icon: "mdi:waves-arrow-right"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 1


  - platform: template
    name: "Rücklauftemperatur Heizung"
    id: temperature_return
    unit_of_measurement: "°C"
    icon: "mdi:waves-arrow-left"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 1

  - platform: template
    name: "Luftfeuchtigkeit Wohnraum"
    id: humidity_inside
    unit_of_measurement: "%rH"
    icon: "mdi:water-percent"
    device_class: "humidity"
    state_class: "measurement"
    accuracy_decimals: 1
  - platform: template
    name: "Temperatur Wohnraum"
    id: temperature_inside
    unit_of_measurement: "°C"
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 1
  - platform: template
    name: "Stromverbrauch Warmwasser heute"
    id: daily_electric_energy_water
    unit_of_measurement: "kWh"
    device_class: "energy"
    state_class: "measurement"
    accuracy_decimals: 3
    icon: "mdi:transmission-tower"
  - platform: template
    name: "Stromverbrauch Heizung heute"
    id: daily_electric_energy_heating
    unit_of_measurement: "kWh"
    device_class: "energy"
    state_class: "measurement"
    icon: "mdi:transmission-tower"
    accuracy_decimals: 3   
  - platform: template
    name: "Stromverbrauch Warmwasser total"
    id: total_electric_energy_water
    unit_of_measurement: "MWh"
    device_class: "energy"
    state_class: "measurement"
    icon: "mdi:transmission-tower"
    accuracy_decimals: 3
  - platform: template
    name: "Stromverbrauch Heizung total"
    id: total_electric_energy_heating
    unit_of_measurement: "MWh"
    device_class: "energy"
    icon: "mdi:transmission-tower"
    state_class: "measurement"
    accuracy_decimals: 3

  - platform: template
    name: "WM Heizung heute"
    id: daily_heating_energy
    unit_of_measurement: "kWh"
    device_class: "energy"
    icon: "mdi:water-boiler"
    state_class: "measurement"
    accuracy_decimals: 3
   
  - platform: template
    name: "WM Heizen total"
    id: total_heating_energy
    unit_of_measurement: "MWh"
    device_class: "energy"
    icon: "mdi:water-boiler"
    state_class: "measurement"
    accuracy_decimals: 3

  - platform: template
    name: "WM Warmwasser heute"
    id: daily_heating_energy_water
    unit_of_measurement: "kWh"
    device_class: "energy"
    icon: "mdi:water-boiler"
    state_class: "measurement"
    accuracy_decimals: 3

  - platform: template
    name: "WM Warmwasser total"
    id: total_heating_energy_water
    unit_of_measurement: "MWh"
    device_class: "energy"
    icon: "mdi:water-boiler"
    state_class: "measurement"
    accuracy_decimals: 3

   
  - platform: template
    name: "WM elektr. Warmwasser total"
    id: total_electric_heating_energy_water
    unit_of_measurement: "MWh"
    device_class: "energy"
    icon: "mdi:water-boiler"
    state_class: "measurement"
    accuracy_decimals: 3


  - platform: template
    name: "WM elektr. heizen total"
    id: total_electric_heating_energy
    unit_of_measurement: "MWh"
    device_class: "energy"
    icon: "mdi:water-boiler"
    state_class: "measurement"
    accuracy_decimals: 3


binary_sensor:
  - platform: template
    name: "EVU Sperre"
    id: "evu_lock"



time:
  - platform: homeassistant
    id: homeassistant_time
    on_time:
     
      - seconds: /180
        then:


#WM NE WW Summe wh  - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x22,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms
#WM NE WW Summe kwh  - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x23,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms


#WM NE Heizen Summe wh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x26,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms
#WM NE Heizen Summe kwh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x27,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms


#WM WW Tag wh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x2a,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms

#WM WW Tag kwh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x2b,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms
#WM WW Summe kwh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x2c,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms

#WM WW Summe Mwh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x2d,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms

#WM Heizen Tag wh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x2e,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms

#WM Heizen Tag kwh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x2f,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms

#WM Heizen Summe kwh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x30,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms
#WM Heizen Summe Mwh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x31,0x00,0x00 ]
              can_id: 0x680
          - delay: 10s

          - lambda: |-
              if (id(waermemertrag_electr_ww_total_mWh_flag) and id(waermemertrag_electr_ww_total_kWh_flag)){
              id(waermemertrag_electr_ww_total_mWh) += id(waermemertrag_electr_ww_total_kWh_float);
              id(total_electric_heating_energy_water).publish_state(id(waermemertrag_electr_ww_total_mWh));
              };
              id(waermemertrag_electr_ww_total_mWh_flag)=false;
              id(waermemertrag_electr_ww_total_kWh_flag)=false;
          - lambda: |-
              if (id(waermemertrag_electr_heiz_total_kWh_flag) and id(waermemertrag_electr_heiz_total_mWh_flag)){
              id(waermemertrag_electr_heiz_total_mWh) += id(waermemertrag_electr_heiz_total_kWh_float);
              id(total_electric_heating_energy).publish_state(id(waermemertrag_electr_heiz_total_mWh));
              };
              id(waermemertrag_electr_heiz_total_kWh_flag)=false;
              id(waermemertrag_electr_heiz_total_mWh_flag)=false;       

          - lambda: |-
              if (id(waermemertrag_ww_total_mWh_flag) and id(waermemertrag_ww_total_kWh_flag)){
              id(waermemertrag_ww_total_mWh) += id(waermemertrag_ww_total_kWh_float);
              id(total_heating_energy_water).publish_state(id(waermemertrag_ww_total_mWh));
              };
              id(waermemertrag_ww_total_mWh_flag)=false;
              id(waermemertrag_ww_total_kWh_flag)=false;
          - lambda: |-
              if (id(waermemertrag_heiz_total_kWh_flag) and id(waermemertrag_heiz_total_mWh_flag)){
              id(waermemertrag_heiz_total_mWh) += id(waermemertrag_heiz_total_kWh_float);
              id(total_heating_energy).publish_state(id(waermemertrag_heiz_total_mWh));
              };
              id(waermemertrag_heiz_total_kWh_flag)=false;
              id(waermemertrag_heiz_total_mWh_flag)=false;       
          - lambda: |-
              if (id(waermemertrag_heiz_tag_kwh_flag) and id(waermemertrag_heiz_tag_wh_flag)){
              id(waermemertrag_heiz_tag_kwh) += id(waermemertrag_heiz_tag_wh_float);
              id(daily_heating_energy).publish_state(id(waermemertrag_heiz_tag_kwh));
              };
              id(waermemertrag_heiz_tag_kwh_flag)=false;
              id(waermemertrag_heiz_tag_wh_flag)=false;
          - lambda: |-
              if (id(waermemertrag_ww_tag_kwh_flag) and id(waermemertrag_ww_tag_wh_flag)){
              id(waermemertrag_ww_tag_kwh) += id(waermemertrag_ww_tag_wh_float);
              id(daily_heating_energy_water).publish_state(id(waermemertrag_ww_tag_kwh));
              };
              id(waermemertrag_ww_tag_kwh_flag)=false;
              id(waermemertrag_ww_tag_wh_flag)=false;










#el. Leistungsaufnahme WW Tag Wh -  ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x1a,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms
#el. Leistungsaufnahme WW Tag kWh -  ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x1b,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms


#el. Leistungsaufnahme WW Summe kwh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x1c,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms
#el. Leistungsaufnahme WW Summe Mwh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x1d,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms


#el. Leistungsaufnahme Heizen Tag Wh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x1e,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms
#el. Leistungsaufnahme Heizen Tag Wh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x1f,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms


#el. Leistungsaufnahme Heizen Summe kwh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x20,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms
#el. Leistungsaufnahme Heizen Summe Mwh - ok
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x09,0x21,0x00,0x00 ]
              can_id: 0x680
          - delay: 10s

          - lambda: |-
              if (id(el_aufnahmeleistung_ww_total_mWh_flag) and id(el_aufnahmeleistung_ww_total_kWh_flag)){
              id(el_aufnahmeleistung_ww_total_mWh) += id(el_aufnahmeleistung_ww_total_kWh_float);
              id(total_electric_energy_water).publish_state(id(el_aufnahmeleistung_ww_total_mWh));
              };
              id(el_aufnahmeleistung_ww_total_mWh_flag)=false;
              id(el_aufnahmeleistung_ww_total_kWh_flag)=false;
          - lambda: |-
              if (id(el_aufnahmeleistung_heiz_total_mWh_flag) and id(el_aufnahmeleistung_heiz_total_kWh_flag)){
              id(el_aufnahmeleistung_heiz_total_mWh) += id(el_aufnahmeleistung_heiz_total_kWh_float);
              id(total_electric_energy_heating).publish_state(id(el_aufnahmeleistung_heiz_total_mWh));
              };
              id(el_aufnahmeleistung_heiz_total_mWh_flag)=false;
              id(el_aufnahmeleistung_heiz_total_mWh_flag)=false;       
          - lambda: |-
              if (id(el_aufnahmeleistung_ww_tag_kwh_flag) and id(el_aufnahmeleistung_ww_tag_wh_flag)){
              id(el_aufnahmeleistung_ww_tag_kwh) += id(el_aufnahmeleistung_ww_tag_wh_float);
              id(daily_electric_energy_water).publish_state(id(el_aufnahmeleistung_ww_tag_kwh));
              };
              id(el_aufnahmeleistung_ww_tag_kwh_flag)=false;
              id(el_aufnahmeleistung_ww_tag_wh_flag)=false;
          - lambda: |-
              if (id(el_aufnahmeleistung_heiz_tag_kwh_flag) and id(el_aufnahmeleistung_heiz_tag_wh_flag)){
              id(el_aufnahmeleistung_heiz_tag_kwh) += id(el_aufnahmeleistung_heiz_tag_wh_float);
              id(daily_electric_energy_heating).publish_state(id(el_aufnahmeleistung_heiz_tag_kwh));
              };
              id(el_aufnahmeleistung_heiz_tag_kwh_flag)=false;
              id(el_aufnahmeleistung_heiz_tag_wh_flag)=false;
             
          - lambda: |-
              ESP_LOGD("main", "EVU Sperre requested");



#Außentemperatur 1/10 °C et dec value - ok /10
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x00,0x0c,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms

#Vorlauftemperatur  - ok 1/10
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x00,0x0d,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms
#Vorlauftemperatur Hzg - ok 1/10
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x00,0x0f,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms

#Rücklauftemperatur Hzg - ok 1/10
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x00,0x16,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms

#WW Temperatur - ok + offset
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x00,0x0e,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms

#Quelle IST: - ok 1/10
          - canbus.send:
              data: [ 0x31, 0x00, 0xfa,0x01,0xd4,0x00,0x00 ]
              can_id: 0x680
          - delay: 200ms




#Laufzeit VD Heizen - nok 180 - nok 301 - nok 480 - nok 500
#          - canbus.send:
#              data: [ 0x31, 0x00, 0xfa,0x05,0xa5,0x00,0x00 ]
#              can_id: 0x680
#          - delay: 200ms
#Laufzeit VD Kühlen - nok 180 - nok 301 - nok 480
#          - canbus.send:
#              data: [ 0xa1, 0x00, 0xfa,0x05,0xa6,0x00,0x00 ]
#              can_id: 0x680
#          - delay: 200ms
#Laufzeit VD WW - nok 180 - nok 301 - nok 480
#          - canbus.send:
#              data: [ 0xa1, 0x00, 0xfa,0x05,0xa7,0x00,0x00 ]
#              can_id: 0x680
#          - delay: 200ms
#Laufzeit VD NHZ WW - nok 180 - nok 301 - nok 480
#          - canbus.send:
#              data: [ 0xa1, 0x00, 0xfa,0x05,0xa8,0x00,0x00 ]
#              can_id: 0x680
#          - delay: 200ms
#Laufzeit VD NHZ Heizen - nok 180  - nok 301 - nok 480
#          - canbus.send:
#              data: [ 0xa1, 0x00, 0xfa,0x05,0xa9,0x00,0x00 ]
#              can_id: 0x680
#          - delay: 200ms

#Laufzeit VD NHZ Heizen - nok 180  - nok 301 - nok 480
#          - canbus.send:
#              data: [ 0xa1, 0x00, 0xfa,0x05,0xa9,0x00,0x00 ]
#              can_id: 0x680
#          - delay: 200ms


#Volumenstrom 1/10 l/min: - nok 180 - nok 301 - nok 480 - nok 514
#          - canbus.send:
#              data: [ 0xa1, 0x00, 0xfa,0x01,0xda,0x00,0x00 ]
#              can_id: 0x680
#          - delay: 200ms
#Heißgastemperatur 1/10 °C: - ok 1/10
#          - canbus.send:
#              data: [ 0xa1, 0x00, 0xfa,0x02,0x65,0x00,0x00 ]
#              can_id: 0x680
#          - delay: 200ms
#Volumenstrom HZK 1/10 l/min: - nok 180 - nok 301 - nok 480
#          - canbus.send:
#              data: [ 0xa1, 0x00, 0xfa,0x02,0xe3,0x00,0x00 ]
#              can_id: 0x680
#          - delay: 200ms
#Volumenstrom Pumpe WW Pri 1/10 l/min: - nok 180 - nok 301 - nok 480
#          - canbus.send:
#              data: [ 0xa1, 0x00, 0xfa,0x02,0xe5,0x00,0x00 ]
#              can_id: 0x680
#          - delay: 200ms
       
spi:
  id: McpSpi
  clk_pin: GPIO18
  mosi_pin: GPIO23
  miso_pin: GPIO19

canbus:
  - platform: mcp2515
    id: my_mcp2515
    spi_id: McpSpi
    cs_pin: GPIO15
    can_id: 680
    use_extended_id: false
    bit_rate: 20kbps
    on_frame:



#Warmwasser-Temperaturabfrage + Offset 3.9 °C
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[3]==0x00 and x[4] == 0x0e) {
              float temperature =float((float((int((x[6])+( (x[5])<<8))))/10)+3.9);
              id(temperature_water).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }
#Quellen-Temperaturabfrage
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[3]==0x01 and x[4] == 0xd4) {
              float temperature =float(float((int((x[6])+( (x[5])<<8))))/10);
              id(temperature_source).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#Vorlauftemperaturabfrage
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[3]==0x00 and x[4] == 0x0d) {
              float temperature =float(float((int((x[6])+( (x[5])<<8))))/1000);
              id(temperature_forerun).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }
           
#Vorlauftemperaturabfrage Heizkreis
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[3]==0x00 and x[4] == 0x0f) {
              float temperature =float(float((int((x[6])+( (x[5])<<8))))/1000);
              id(temperature_forerun_heating).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }
#Rücklauftemperaturabfrage
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[3]==0x00 and x[4] == 0x16) {
              float temperature =float(float((int((x[6])+( (x[5])<<8))))/10);
              id(temperature_return).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }


#Außentemperaturabfrage
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[3]==0x00 and x[4] == 0x0c) {
              float temperature =float(float((int((x[6])+( (x[5])<<8))))/10);
              id(temperature_outside).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#Luftfeuchtigkeit FEK mitlesen
    - can_id: 0x301
      then:
        - lambda: |-
            if(x[0]==0xc0 and x[1]==0x01 and x[2]==0x75) {
              float humidity =float(float((int((x[4])+( (x[3])<<8))))/10);
              id(humidity_inside).publish_state(humidity);
              ESP_LOGD("main", "Humidity received over can is %f", humidity);
            }
#Raumtemperatur FEK mitlesen
    - can_id: 0x301
      then:
        - lambda: |-
            if(x[0]==0xc0 and x[1]==0x01 and x[2]==0x11) {
              float temperature =float(float((int((x[4])+( (x[3])<<8))))/10);
              id(temperature_inside).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }



#Elektrische Leistungsaufnahme Wh /kWh
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x09) {
              if (x[4]==0x1a){
                id(el_aufnahmeleistung_ww_tag_wh_float) = (float((int((x[6])+( (x[5])<<8))))/1000);
                id(el_aufnahmeleistung_ww_tag_wh_flag)=true;
                ESP_LOGD("main", "el_aufnahmeleistung_ww_tag_kwh received over can is %f", id(el_aufnahmeleistung_ww_tag_wh_float));}
              else if (x[4]==0x1e){
                id(el_aufnahmeleistung_heiz_tag_wh_float) = (float((int((x[6])+( (x[5])<<8))))/1000);
                id(el_aufnahmeleistung_heiz_tag_wh_flag) = true;
                ESP_LOGD("main", "el_aufnahmeleistung_heiz_tag_wh received over can is %f", id(el_aufnahmeleistung_heiz_tag_wh_float));}
              else if (x[4]==0x1c){
                id(el_aufnahmeleistung_ww_total_kWh_float) = (float((int((x[6])+( (x[5])<<8))))/1000);
                id(el_aufnahmeleistung_ww_total_kWh_flag)=true;
                ESP_LOGD("main", "el_aufnahmeleistung_ww_total_kkWh received over can is %f", id(el_aufnahmeleistung_ww_total_kWh_float));}
              else if (x[4]==0x20){
                id(el_aufnahmeleistung_heiz_total_kWh_float) = (float((int((x[6])+( (x[5])<<8))))/1000);
                id(el_aufnahmeleistung_heiz_total_kWh_flag) = true;
                ESP_LOGD("main", "el_aufnahmeleistung_heiz_total_kWh received over can is %f", id(el_aufnahmeleistung_heiz_total_kWh_float));}
              }
              if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x00 and x[4]==0x74){
              if(x[5]==0x80 and x[6]==0x00){
                id(evu_lock).publish_state(false);
                }
              else{
                id(evu_lock).publish_state(true);
              };
            };

#Elektrische Leistungsaufnahme kWh / MWH
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x09) {
              if(x[4]==0x1b){
              id(el_aufnahmeleistung_ww_tag_kwh) =float(int((x[6])+( (x[5])<<8)));
              id(el_aufnahmeleistung_ww_tag_kwh_flag)=true;
              ESP_LOGD("main", "el_aufnahmeleistung_ww_tag_kwh received over can is %f", id(el_aufnahmeleistung_ww_tag_kwh));}
              else if(x[4]==0x1f){
                id(el_aufnahmeleistung_heiz_tag_kwh) =float(int((x[6])+( (x[5])<<8)));
                id(el_aufnahmeleistung_heiz_tag_kwh_flag)=true;
                ESP_LOGD("main", "el_aufnahmeleistung_heiz_tag_kwh received over can is %f", id(el_aufnahmeleistung_heiz_tag_kwh));}
              else if(x[4]==0x1d){
              id(el_aufnahmeleistung_ww_total_mWh) =float(int((x[6])+( (x[5])<<8)));
              id(el_aufnahmeleistung_ww_total_mWh_flag)=true;
              ESP_LOGD("main", "el_aufnahmeleistung_ww_total_mWh received over can is %f", id(el_aufnahmeleistung_ww_total_mWh));}
              else if(x[4]==0x21){
                id(el_aufnahmeleistung_heiz_total_mWh) =float(int((x[6])+( (x[5])<<8)));
                id(el_aufnahmeleistung_heiz_total_mWh_flag)=true;
                ESP_LOGD("main", "el_aufnahmeleistung_heiz_total_mWh received over can is %f", id(el_aufnahmeleistung_heiz_total_mWh));}
            }


#Wärmeertrag WW/Heizung MWh / kWH
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x09) {
              if(x[4]==0x23){
                id(waermemertrag_electr_ww_total_mWh) =float(int((x[6])+( (x[5])<<8)));
                id(waermemertrag_electr_ww_total_mWh_flag)=true;
                ESP_LOGD("main", "waermemertrag_electr_ww_tag_kwh received over can is %f", id(waermemertrag_electr_ww_total_mWh));}
              else if(x[4]==0x27){
                id(waermemertrag_electr_heiz_total_mWh) =float(int((x[6])+( (x[5])<<8)));
                id(waermemertrag_electr_heiz_total_mWh_flag)=true;
                ESP_LOGD("main", "waermemertrag_electr_heiz_tag_kwh received over can is %f", id(waermemertrag_electr_heiz_total_mWh));}
              else if(x[4]==0x2b){
              id(waermemertrag_ww_tag_kwh) =float(int((x[6])+( (x[5])<<8)));
              id(waermemertrag_ww_tag_kwh_flag)=true;
              ESP_LOGD("main", "waermemertrag_ww_tag_kwh received over can is %f", id(waermemertrag_ww_tag_kwh));}
              else if(x[4]==0x2d){
              id(waermemertrag_ww_total_mWh) =float(int((x[6])+( (x[5])<<8)));
              id(waermemertrag_ww_total_mWh_flag)=true;
              ESP_LOGD("main", "waermemertrag_ww_total_mWh received over can is %f", id(waermemertrag_ww_total_mWh));}
              else if(x[4]==0x2f){
                id(waermemertrag_heiz_tag_kwh) =float(int((x[6])+( (x[5])<<8)));
                id(waermemertrag_heiz_tag_kwh_flag)=true;
                ESP_LOGD("main", "waermemertrag_heiz_tag_kwh received over can is %f", id(waermemertrag_heiz_tag_kwh));}
              else if(x[4]==0x31){
                id(waermemertrag_heiz_total_mWh) =float(int((x[6])+( (x[5])<<8)));
                id(waermemertrag_heiz_total_mWh_flag)=true;
                ESP_LOGD("main", "waermemertrag_heiz_total_kWh_float received over can is %f", id(waermemertrag_heiz_total_mWh));}
            }


#Wärmeertrag WW/Heizung Wh / kWH
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[1]==0x00 and x[2]==0xfa and x[3]==0x09) {
              if(x[4]==0x22){
                id(waermemertrag_electr_ww_total_kWh_float) =float(int((x[6])+( (x[5])<<8)))/1000;
                id(waermemertrag_electr_ww_total_kWh_flag)=true;
                ESP_LOGD("main", "waermemertrag_electr_ww_tag_wh_float received over can is %f", id(waermemertrag_electr_ww_total_kWh_float));}
              else if(x[4]==0x26){
                id(waermemertrag_electr_heiz_total_kWh_float) =float(int((x[6])+( (x[5])<<8)))/1000;
                id(waermemertrag_electr_heiz_total_kWh_flag)=true;
                ESP_LOGD("main", "waermemertrag_electr_heiz_tag_wh_float received over can is %f", id(waermemertrag_electr_heiz_total_kWh_float));}
              else if(x[4]==0x2a){
              id(waermemertrag_ww_tag_wh_float) =float(int((x[6])+( (x[5])<<8)))/1000;
              id(waermemertrag_ww_tag_wh_flag)=true;
              ESP_LOGD("main", "waermemertrag_ww_tag_wh_float received over can is %f", id(waermemertrag_ww_tag_wh_float));}
              else if(x[4]==0x2c){
              id(waermemertrag_ww_total_kWh_float) =float(int((x[6])+( (x[5])<<8)))/1000;
              id(waermemertrag_ww_total_kWh_flag)=true;
              ESP_LOGD("main", "waermemertrag_ww_total_kWh_float received over can is %f", id(waermemertrag_ww_total_kWh_float));}
              else if(x[4]==0x2e){
                id(waermemertrag_heiz_tag_wh_float) =float(int((x[6])+( (x[5])<<8)))/1000;
                id(waermemertrag_heiz_tag_wh_flag)=true;
                ESP_LOGD("main", "waermemertrag_heiz_tag_wh_float received over can is %f", id(waermemertrag_heiz_tag_wh_float));}
              else if(x[4]==0x30){
                id(waermemertrag_heiz_total_kWh_float) =float(int((x[6])+( (x[5])<<8)))/1000;
                id(waermemertrag_heiz_total_kWh_flag)=true;
                ESP_LOGD("main", "waermemertrag_heiz_total_kWh_float received over can is %f", id(waermemertrag_heiz_total_kWh_float));}
            }



    - can_id: 0x100
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              float wert7 = float(int((x[6])+( (x[5])<<8)));
              ESP_LOGI("main", "Antwort von 100 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
              ESP_LOGI("main", "Antwort von 100 Float: %f", wert7);
              ESP_LOGI("main", "Antwort von 100 Dez.: %i %i", wert5, wert6);

    - can_id: 0x500
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              float wert7 = float(int((x[6])+( (x[5])<<8)));
              ESP_LOGI("main", "Antwort von 500 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
              ESP_LOGI("main", "Antwort von 500 Float: %f", wert7);
              ESP_LOGI("main", "Antwort von 500 Dez.: %i %i", wert5, wert6);



    - can_id: 0x514
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              float wert7 = float(int((x[6])+( (x[5])<<8)));
              ESP_LOGI("main", "Antwort von 514 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
              ESP_LOGI("main", "Antwort von 514 Float: %f", wert7);
              ESP_LOGI("main", "Antwort von 514 Dez.: %i %i", wert5, wert6);


    - can_id: 0x700
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              float wert7 = float(int((x[6])+( (x[5])<<8)));
              ESP_LOGI("main", "Antwort von 700 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
              ESP_LOGI("main", "Antwort von 700 Float: %f", wert7);
              ESP_LOGI("main", "Antwort von 700 Dez.: %i %i", wert5, wert6);

    - can_id: 0x402
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              float wert7 = float(int((x[6])+( (x[5])<<8)));
              ESP_LOGI("main", "Antwort von 402 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
              ESP_LOGI("main", "Antwort von 402 Float: %f", wert7);
              ESP_LOGI("main", "Antwort von 402 Dez.: %i %i", wert5, wert6);


    - can_id: 0x401
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              float wert7 = float(int((x[6])+( (x[5])<<8)));
              ESP_LOGI("main", "Antwort von 401 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
              ESP_LOGI("main", "Antwort von 401 Float: %f", wert7);
              ESP_LOGI("main", "Antwort von 401 Dez.: %i %i", wert5, wert6);
    - can_id: 0x69f
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              float wert7 = float(int((x[6])+( (x[5])<<8)));
              ESP_LOGI("main", "Antwort von 69f Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
              ESP_LOGI("main", "Antwort von 69f Float: %f", wert7);
              ESP_LOGI("main", "Antwort von 69f Dez.: %i %i", wert5, wert6);

    - can_id: 0x69e
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              float wert7 = float(int((x[6])+( (x[5])<<8)));
              ESP_LOGI("main", "Antwort von 69e Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
              ESP_LOGI("main", "Antwort von 69e Float: %f", wert7);
              ESP_LOGI("main", "Antwort von 69e Dez.: %i %i", wert5, wert6);



    - can_id: 0x480
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              float wert7 = float(int((x[6])+( (x[5])<<8)));
              ESP_LOGD("main", "Antwort von 480 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
              ESP_LOGD("main", "Antwort von 480 Float: %f", wert7);
              ESP_LOGD("main", "Antwort von 480 Dez.: %i %i", wert5, wert6);




[Vincent82]

Also das Problem, dass das Laden des Zustandsverlaufs so lange dauert, habe ich nicht.

Ich habe 2 Ideen zur Ursache:

1. Irgend etwas wird super hochfrequent aufgezeichnet. Zum Beispiel einer oder Mehrere der Werte, die ohne Anfragen am Bus liegen.

2. Die SD Karte hat Probleme. Ich arbeite mit SSD Festplatte und InfluxDB und Grafana. SD Karte ist für so einen Anwendungsfall ungeeignet.
Anleitungen wie man das macht, gibt es im Netz zu genüge.

[robob]

Hallo,

Ich hab noch ein Problem gelöst.
Die Temperatur wurde bei mir teilweise falsch ausgegeben.
Bsp.: Die Außentemperatur - es hat heute Minusgrade - zeigte 6549.2 °C
Die Lösung war, den Integer-Vektor als int16_t zu deklarieren

[Vincent82]

Jetzt habe ich ein Problem:

Ich möchte von W-Lan auf Ethernet umsteigen und habe mir dazu dieses Board zugelegt: https://www.olimex.com/Products/IoT/ESP32/ESP32-POE/open-source-hardware.

Leider bekomme ich mit dem Angeschlossenen MCP 2515 keine funktionierende CAN Kommunikation hin. Folgende GPIO´s nutze ich:

Code Auswählen Erweitern


spi:
  id: McpSpi
  clk_pin: GPIO14
  mosi_pin: GPIO13
  miso_pin: GPIO16

canbus:
  - platform: mcp2515
    id: my_mcp2515
    spi_id: McpSpi
    cs_pin: GPIO4
    can_id: 5
    bit_rate: 20kbps
    use_extended_id: false


@robob hast Du vielleicht eine Idee?

[robob]

Ich finde die Tatsache dass es PoE-Devices gibt cool.

Werden deine CAN-Anfragen lt. Log abgesetzt?
Wie ermittelst du, dass keine Daten empfangen werden - unten mein Codeschnipsel mit dem ich die Pakete mitlogge.
Ich nutze übrigens CAN-ID 680, aber ich glaube das hat keine echte Auswirkung.

Ich hab mit meinem ESP WROOM32 das Problem, dass nach einigen Tagen die Daten nicht aktualisiert werden. dH es sind immer die letztgültigen Temperaturen, Verbrauchswerte etc. gültig und ändern sich nicht mehr in Homeassistant. Es werden zwar lt. Log-Screen im ESP-Device CAN-Pakete abgesetzt, aber es fehlt der Hinweistext dass eine Antwort zurück kommt. Ich spiele dann die Firmware neu ein, danach gehts wieder. Obs auch ein simpler Reset tut weiß ich noch nicht - schätze aber ja.
Ausfallzeit einmal um ca. 23:00 Uhr, fünf Tage später um ca. 21:00 Uhr, vier Tage später um ca. 10:00 Uhr, zwei Tage später um ca. 20:00 Uhr.
Zuletzt habe ich die Delay-Zeit zwischen denen die CAN-Pakete abgesetzt werden auf 500 ms verdoppelt. k.A. ob dadurch die Zeit bis zum Ausfall auf zwei Tage gefallen ist.

Code Auswählen Erweitern


    - can_id: 0x180
      then:
        - lambda: |-
              int wert0 = int(x[0]);
              int wert1 =int(x[1]);
              int wert2 =int(x[2]);
              int wert3 =int(x[3]);
              int wert4 =int(x[4]);
              int wert5 =int(x[5]);
              int wert6 =int(x[6]);
              float wert7 = float(int((x[6])+( (x[5])<<8)));
              ESP_LOGI("main", "Antwort von 180 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
              ESP_LOGI("main", "Antwort von 180 Float: %f", wert7);
              ESP_LOGI("main", "Antwort von 180 Dez.: %i %i", wert5, wert6);


[Vincent82]

Ich habe zwei ESP8266 mit ebenso 2 MCP2515 auf dem CANBus. Der eine sendet, der Andere empfängt ohne Probleme, das sehe ich den Logs.

Ich schwenke jetzt um auf Rasperry PI mit Waveshare CAN Hat und programmiere das komplett selbst in Python dann weiß man was man hat

[robob]

Schade dass du keinen Erfolg mehr damit hattest.
Raspberry Pis sind derzeit ja leider auch Mangelware.

Ich habe inzwischen eine Automatisierung in HomeAssistant implementiert, die mein ESP-Device einmal täglich resettet.
Dadurch hatte ich seither keine Ausfälle mehr.
Mir gefällt die Lösung mit dem ESP32 ganz gut.
Ich schalte damit jetzt außerdem im Heizraum das Licht.

Ich hab aber gerade ein ähnliches Problem seit ich was an der Config geändert hab: Ich habe die Lambda-Funktionen im Code verschoben. Jetzt funktioniert der Code nicht mehr wie erwartet. Es wird nur der CAN-Befehl abgesendet und die Antworten nicht abgearbeitet.
Es ist aber gut möglich, dass sich das mit etwas anderem überschnitten hat und gar nichts mit der Änderung des Codes zu tun hat. Ein paar Stunden davor sehe ich im logging fehlerhafte Einträge.

Ich hab deshalb das ESP-Device mit neuem Namen integriert. So wie es aussieht ohne Erfolg

-Nachtrag - es war das Kabel