Rotex-Daikin-CAN.yaml

############################### Version 1.3.8 #####################################
substitutions:
  rx_pin: GPIO48
  tx_pin: GPIO47
  interval_time: 20s

esphome:
  name: rotex
  friendly_name: Rotex

esp32:
  board: esp32-s3-devkitc-1
  framework:
    type: arduino

globals:
  - id: backup_dhw
    type: int

  - id: interval_active
    type: bool
    restore_value: yes
    initial_value: 'true'


# Enable logging
logger:
  #level: VERBOSE

# Enable Home Assistant API
api:
  encryption:
    key: !secret api_encryption_key

ota:
  platform: esphome
  password: !secret ota_password


web_server:  

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Rotex Fallback Hotspot"
    password: "H3jGqANSa7aL"


captive_portal:

 
############################## Text Sensoren ########################################
text_sensor:
  - platform: template
    name: "Betriebsmodus"
    id: text_betriebsmodus
    lambda: |-
      if(id(Betriebsmodus).state == 0){
        return {"Notbetrieb"};
      } else if (id(Betriebsmodus).state == 1){
        return {"Bereitschaft"};
      } else if (id(Betriebsmodus).state == 3){
        return {"Heizen"};
      } else if (id(Betriebsmodus).state == 4){
        return {"Absenken"};
      } else if (id(Betriebsmodus).state == 5){
        return {"Sommer"}; 
      } else if (id(Betriebsmodus).state == 11){
        return {"Automatik 1"};
      } else if (id(Betriebsmodus).state == 12){
        return {"Automatik 2"};    
      } else if (id(Betriebsmodus).state == 17){
        return {"Kühlen"};       
      } else {
        return {"Unknown"};
      }


  - platform: template
    name: "SG-Modus"
    id: text_sg_modus
    lambda: |-
      if(id(SGModus).state == 0){
        return {"Aus"};
      } else if (id(SGModus).state == 1){
        return {"SG Modus 1"};
      } else if (id(SGModus).state == 2){
        return {"SG Modus 2"};
      } else {
        return {"Unknown"};
      }

  - platform: template
    name: "Smart-Grid"
    id: text_smartgrid
    lambda: |-
      if(id(Smartgrid).state == 0){
        return {"Aus"};
      } else if (id(Smartgrid).state == 1){
        return {"An"};
      } else {
        return {"Unknown"};
      }

  - platform: template
    name: "Betriebart"
    id: text_betriebsart
    lambda: |-
      if(id(Betriebsart).state == 0){
        return {"Standby"};
      } else if (id(Betriebsart).state == 1){
        return {"Heizen"};
      } else if (id(Betriebsart).state == 2){
        return {"Kühlen"};
      } else if (id(Betriebsart).state == 3){
        return {"Abtauen"};
      } else if (id(Betriebsart).state == 4){
        return {"Warmwasserbereitung"}; 
      } else {
        return {"Unknown"};
      }


  - platform: template
    name: "Fehlercode"
    id: text_fehler
    lambda: |-
      if(id(Fehlercode).state == 0){
        return {"kein Fehler"};
      } else if (id(Fehlercode).state == 9001){
        return {" Fehler E9001 Fehler Rücklauffühler Handbuch S.60"};
      } else if (id(Fehlercode).state == 9002){
        return {"Fehler E9002 Fehler Vorlauffühler Handbuch S.60"};
      } else if (id(Fehlercode).state == 9003){
        return {"Fehler E9003 Fehler Frostschutzfunktion Handbuch S.60"};
      } else if (id(Fehlercode).state == 9004){
        return {"Fehler E9004Fehler Durchfluss Handbuch S.61"};
      } else if (id(Fehlercode).state == 9005){
        return {"9005 Vorlauftemperaturfühler Handbuch S.60"};
      } else if (id(Fehlercode).state == 9006){
        return {"9006 Vorlauftemperaturfühler Handbuch S.60"};
      } else if (id(Fehlercode).state == 9007){
        return {"9007 Platine IG defekt Handbuch S.60"}; 
      } else if (id(Fehlercode).state == 9008){
        return {"9008 Kältemitteltemperatur außerhalb des Bereiches Handbuch S.60"};
      } else if (id(Fehlercode).state == 9009){
        return {"9009 STB Fehler Handbuch S.60"};
      } else if (id(Fehlercode).state == 9010){
        return {"9010 STB Fehler Handbuch S.60"};
      } else if (id(Fehlercode).state == 9011){
        return {"9011 Fehler Flowsensor Handbuch S.60"};
      } else if (id(Fehlercode).state == 9012){
        return {"9012 Fehler Vorlauffühler Handbuch S.60"};
      } else if (id(Fehlercode).state == 9013){
        return {"9013 Platine AG defekt Handbuch S.60"};
      } else if (id(Fehlercode).state == 9014){
        return {"9014 P-Kältemittel hoch Handbuch S.61"};
      } else if (id(Fehlercode).state == 9015){
        return {"9015 P-Kältemittel niedrig Handbuch S.61"};
      } else if (id(Fehlercode).state == 9016){
        return {"9016 Lastschutz Verdichter Handbuch S.61"};
      } else if (id(Fehlercode).state == 9017){
        return {"9017 Ventilator blockiert Handbuch S.61"};
      } else if (id(Fehlercode).state == 9018){
        return {"9018 Expansionsventil Handbuch S.61"};
      } else if (id(Fehlercode).state == 9019){
        return {"9019 Warmwassertemperatur > 85°C Handbuch S.61"};
      } else if (id(Fehlercode).state == 9020){
        return {"9020 T-Verdampfer hoch Handbuch S.61"};
      } else if (id(Fehlercode).state == 9021){
        return {"9021 HPS-System Handbuch S.61"};
      } else if (id(Fehlercode).state == 9022){
        return {"9022 Fehler AT-Fühler Handbuch S.62"};     
      } else if (id(Fehlercode).state == 9023){
        return {"9023 Fehler WW-Fühler Handbuch S.62"};     
      } else if (id(Fehlercode).state == 9024){
        return {"9024 Drucksensor Handbuch S.62"};     
      } else if (id(Fehlercode).state == 9025){
        return {"9025 Fehler Rücklauffühler Handbuch S.62"};     
      } else if (id(Fehlercode).state == 9026){
        return {"9026 Drucksensor Handbuch S.62"};
      } else if (id(Fehlercode).state == 9027){
        return {"9027 Aircoil-Fühler Defrost Handbuch S.62"};  
      } else if (id(Fehlercode).state == 9028){
        return {"9028 Aircoil-Fühler temp Handbuch S.62"};     
      } else if (id(Fehlercode).state == 9029){
        return {"9029 Fehler Kältefühler AG handbuch S.62"};     
      } else if (id(Fehlercode).state == 9030){
        return {"9030 Defekt elektrisch Handbuch S.63"};     
      } else if (id(Fehlercode).state == 9031){
        return {"9031 Defekt elektrisch Handbuch S.63"};
      } else if (id(Fehlercode).state == 9032){
        return {"9032 Defekt elektrisch Handbuch S.63"};     
      } else if (id(Fehlercode).state == 9033){
        return {"9033 Defekt elektrisch Handbuch S.63"};     
      } else if (id(Fehlercode).state == 9034){
        return {"9034 Defekt elektrisch Handbuch S.63"};     
      } else if (id(Fehlercode).state == 9035){
        return {"9035 Platine AG defekt Handbuch S.63"};     
      } else if (id(Fehlercode).state == 9036){
        return {"9036 Defekt elektrisch Handbuch S.63"};     
      } else if (id(Fehlercode).state == 9037){
        return {"9037 Einstellung Leistung Handbuch S.63"};     
      } else if (id(Fehlercode).state == 9038){
        return {"9038 Kältemittel Leck Handbuch S.64"}; 
      } else if (id(Fehlercode).state == 9039){
        return {"9039 Unter/Überspannung Handbuch S.64"};     
      } else if (id(Fehlercode).state == 9041){
        return {"9041 Übertragungsfehler Handbuch S.64"};     
      } else if (id(Fehlercode).state == 9042){
        return {"9042 Übertragungsfehler Handbuch S.64"};     
      } else if (id(Fehlercode).state == 9043){
        return {"9043 Übertragungsfehler Handbuch S.64"}; 
      } else if (id(Fehlercode).state == 9044){
        return {"9044 Übertragungsfehler Handbuch S.64"};     
      } else if (id(Fehlercode).state == 75){
        return {"75 Fehler Außentemperaturfühler Handbuch S.64"};     
      } else if (id(Fehlercode).state == 76){
        return {"76 Fehler Speichertemperaturfühler Handbuch S.64"};
      } else if (id(Fehlercode).state == 81){
        return {"81 Kommunikationsfehler Rocon Handbuch S.64"};     
      } else if (id(Fehlercode).state == 88){
        return {"88 Kommunikationsfehler Rocon Handbuch S.6"};     
      } else if (id(Fehlercode).state == 91){
        return {"91 Kommunikationsfehler Rocon Handbuch S.6"};     
      } else if (id(Fehlercode).state == 128){
        return {"128 Fehler Rücklauftemperaturfühler Handbuch S.64"};     
      } else if (id(Fehlercode).state == 129){
        return {"129 Fehler Drucksensor Handbuch S.64"};     
      } else if (id(Fehlercode).state == 198){
        return {"198 Durchflussmessung nicht plausibel Handbuch S.65"};     
      } else if (id(Fehlercode).state == 200){
        return {"200 Kommunikationsfehler Handbuch S.65"};     
      } else if (id(Fehlercode).state == 8005){
        return {"8005 Wasserdruck in Heizungsanlage zu gering Handbuch S.65"}; 
      } else if (id(Fehlercode).state == 8100){
        return {"8100 Kommunikation Handbuch S.65"};     
      } else if (id(Fehlercode).state == 9000){
        return {"9000 Interne vorübergehende Meldung Handbuch S65"};     
      } else if (id(Fehlercode).state == 8006){
        return {"8006 Warnung Druckverlust Handbuch S.65"};     
      } else if (id(Fehlercode).state == 8007){
        return {"8007 wasserdruck in Anlage zu hoch Handbuch S.65"};                                                                                                                                               
      } else {
        return {"Unknown"};
      }

  - platform: template
    name: "Status Kompressor"
    id: text_status2
    lambda: |-
      if(id(status_kessel).state == 0){
        return {"Aus"};
      } else if (id(status_kessel).state == 1){
        return {"An"};
       } else {
        return {"Unknown"};
      }

  - platform: template
    name: "HK-Funktion"
    id: text_hk_funktion
    lambda: |-
      if(id(hk_funktion).state == 0){
        return {"Witterungsgeführt"};
      } else if (id(hk_funktion).state == 1){
        return {"Fest"};
       } else {
        return {"Unknown"};
      }
  
  - platform: wifi_info
    ip_address:
      name: ESP IP Address
    ssid:
      name: ESP Connected SSID





    


################################ Button und Switch ##############################################


button:

  - platform: template
    name: Warmwasser bereiten
    id: ww_button
    icon: "mdi:water-boiler"
    on_press:
      then:
        - globals.set:
            id: backup_dhw
            value: !lambda return int(id(t_ww_soll).state * 10);
        - canbus.send:
            can_id: 0x680
            data: [0x30, 0x00, 0x13, 0x02, 0xBC, 0x00, 0x00] # 70 Grad Grundeinstellung
        - delay: 10s
        - canbus.send:
            can_id: 0x680
            data: !lambda |-
              uint16_t temperature = (uint16_t)id(backup_dhw); // Convert to int16be
              uint8_t high_byte = temperature >> 8;
              uint8_t low_byte = temperature & 0xFF;
              return {0x30, 0x00, 0x13, high_byte, low_byte, 0x00, 0x00};
        - logger.log: CAN Nachricht wurde gesendet

  - platform: restart
    name: "Rotex ESP Restart"


switch:
  - platform: template
    name: "Intervall Abfrage"
    optimistic: true
    turn_on_action:
      - globals.set:
          id: interval_active
          value: 'true'
    turn_off_action:
      - globals.set:
          id: interval_active
          value: 'false'

#switch:
 # - platform: gpio
  #  name: Heizen Thermostat
   # pin: GPIO36
    
 # - platform: gpio
  #  name: Kühlen Thermostat
   # pin: GPIO37
############################### Number (Slidermodus) ###############################################  
number:

##### Raumsoll 1
  - platform: template
    name: "Raumsoll 1 Einstellen"
    id: r_soll
    optimistic: true
    mode: box
    min_value: 15
    max_value: 25
    step: 0.1
    initial_value: 19
    unit_of_measurement: "°C"
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    set_action:
      - delay: 250ms
      - canbus.send:
          can_id: 0x680
          data: !lambda |-
            uint16_t temperature = (uint16_t)(x * 10); // Convert to int16be
            uint8_t high_byte = temperature >> 8;
            uint8_t low_byte = temperature & 0xFF;
            return { 0x30, 0x00, 0x05, high_byte, low_byte, 0x00, 0x00 };

#### Heizkurve                                                                                                                                                                                                                                                           

  - platform: template
    name: "Heizkurve Einstellen"
    id: set_heizkurve
    optimistic: true
    mode: box
    min_value: 0
    max_value: 2.55
    step: 0.01
    initial_value: 0.48
    set_action:
      - delay: 250ms
      - canbus.send:
          can_id: 0x680
          data: !lambda |-
            uint16_t hk = (uint16_t)(x * 100); // Convert to int16be
            uint8_t high_byte = hk >> 8;
            uint8_t low_byte = hk & 0xFF;
            return { 0x30, 0x00, 0xFA, 0x01, 0x0E, high_byte, low_byte };


##### Warmwasser
  - platform: template
    name: "WW Einstellen"
    id: ww_soll
    optimistic: true
    mode: box
    min_value: 35
    max_value: 70
    step: 1
    initial_value: 45
    unit_of_measurement: "°C"
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    set_action:
      - delay: 250ms
      - canbus.send:
          can_id: 0x680
          data: !lambda |-
            uint16_t temperature = (uint16_t)(x * 10); // Convert to int16be
            uint8_t high_byte = temperature >> 8;
            uint8_t low_byte = temperature & 0xFF;
            return { 0x30, 0x00, 0x13, high_byte, low_byte, 0x00, 0x00 };
            
##### Min VL
  - platform: template
    name: "Min VL Einstellen"
    id: min_vl_set
    optimistic: true
    mode: box
    min_value: 25
    max_value: 40
    step: 1
    initial_value: 25
    unit_of_measurement: "°C"
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    set_action:
      - delay: 250ms
      - canbus.send:
          can_id: 0x680
          data: !lambda |-
            uint16_t temperature = (uint16_t)(x * 10); // Convert to int16be
            uint8_t high_byte = temperature >> 8;
            uint8_t low_byte = temperature & 0xFF;
            return { 0x30, 0x00, 0xFA, 0x01, 0x2B, high_byte, low_byte };

##### Max VL Set
  - platform: template
    name: "Max VL Einstellen"
    id: max_vl_set
    optimistic: true
    mode: box
    min_value: 25
    max_value: 60
    step: 1
    initial_value: 35
    unit_of_measurement: "°C"
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    set_action:
      - delay: 250ms
      - canbus.send:
          can_id: 0x680
          data: !lambda |-
            uint16_t temperature = (uint16_t)(x * 10); // Convert to int16be
            uint8_t high_byte = temperature >> 8;
            uint8_t low_byte = temperature & 0xFF;
            return { 0x30, 0x00, 0x28, high_byte, low_byte, 0x00, 0x00, };

##### T Vorlauf Tag Set
  - platform: template
    name: "T Vorlauf Tag Einstellen"
    id: t_vorlauf_tag_set
    optimistic: true
    mode: box
    min_value: 25
    max_value: 60
    step: 1
    initial_value: 35
    unit_of_measurement: "°C"
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    set_action:
      - delay: 250ms
      - canbus.send:
          can_id: 0x680
          data: !lambda |-
            uint16_t temperature = (uint16_t)(x * 10); // Convert to int16be
            uint8_t high_byte = temperature >> 8;
            uint8_t low_byte = temperature & 0xFF;
            return { 0x30, 0x00, 0xFA,  0x01, 0x29, high_byte, low_byte, };

####################### Select Tasten ###############################

  

#Set Betriebsmodus
select:
  - platform: template
    name: "Betriebsmodus setzen"
    id: betrieb
    optimistic: true
    options:
      - "Heizen"
      - "Bereitschaft"
      - "Absenken"
      - "Sommer"
      - "Kühlen"
      - "Automatik 1"
      - "Automatik 2"
    initial_option: Heizen
    set_action:
      then:
        - delay: 250ms
        - canbus.send:
            can_id: 0x680
            data: !lambda |-
              static const std::map<std::string, uint8_t> mode_map = {
                {"Heizen", 3},
                {"Bereitschaft", 1},
                {"Absenken", 4},
                {"Sommer", 5},
                {"Kühlen", 17},
                {"Automatik 1", 11},
                {"Automatik 2", 12}
              };
              return {0x30, 0x00, 0xFA, 0x01, 0x12, mode_map.at(x), 0x00};

#Set HK Funktion

  - platform: template
    name: "HK Funktion"
    id: hk
    optimistic: true
    options:
      - "Witterungsgeführt"
      - "Fest"
    initial_option: Witterungsgeführt
    set_action:
      then:
        - delay: 250ms
        - canbus.send:
            can_id: 0x680
            data: !lambda |-
              static const std::map<std::string, uint8_t> mode_map = {
                {"Witterungsgeführt", 0},
                {"Fest", 1}
              };
              return {0x30, 0x00, 0xFA, 0x01, 0x41, 0x00, mode_map.at(x)};

#Set SG Funktion

  - platform: template
    name: "SG Modus"
    id: sg
    optimistic: true
    options:
      - "Aus"
      - "SG Modus 1"
      - "SG Modus 2"
    initial_option: Aus
    set_action:
      then:
        - delay: 250ms
        - canbus.send:
            can_id: 0x680
            data: !lambda |-
              static const std::map<std::string, uint8_t> mode_map = {
                {"Aus", 0},
                {"SG Modus 1", 1},
                {"SG Modus 2", 2}
              };
              return {0x30, 0x00, 0xFA, 0x06, 0x94, 0x00, mode_map.at(x)};


#Set Smart Grid

  - platform: template
    name: "Smart Grid"
    id: smartgrid
    optimistic: true
    options:
      - "Aus"
      - "An"
    initial_option: Aus
    set_action:
      then:
        - delay: 250ms
        - canbus.send:
            can_id: 0x680
            data: !lambda |-
              static const std::map<std::string, uint8_t> mode_map = {
                {"Aus", 0},
                {"An", 1}
              };
              return {0x30, 0x00, 0xFA, 0x06, 0x93, 0x00, mode_map.at(x)};


################################# Alle Sensoren #####################################
sensor:



  - platform: wifi_signal
    name: "WiFi Signal Sensor"
    update_interval: 60s


  - platform: template
    name: "Fehlercode"
    id: Fehlercode
    internal: true
    unit_of_measurement: ""
    icon: "mdi:thermometer-lines"
    state_class: "measurement"
    accuracy_decimals: 0

  - platform: template
    name: "SG Modus"
    id: SGModus
    internal: true
    unit_of_measurement: ""
    icon: "mdi:thermometer-lines"
    state_class: "measurement"
    accuracy_decimals: 0
  
  - platform: template
    name: "Smart Grid"
    id: Smartgrid
    internal: true
    unit_of_measurement: ""
    icon: "mdi:thermometer-lines"
    state_class: "measurement"
    accuracy_decimals: 0

  - platform: template
    name: "Heizkurve"
    id: heizkurve
    unit_of_measurement: ""
    device_class: "temperature"
    icon: "mdi:thermometer-lines"
    state_class: "measurement"
    accuracy_decimals: 2


  - platform: template
    name: "Thermische Leistung"
    device_class: "power"
    unit_of_measurement: "kW"
    accuracy_decimals: 2
    update_interval: 10s
    lambda: |-
      if (id(text_betriebsart).state == "Warmwasserbereitung") {
        return ((id(TV).state - id(ruecklauf).state) * (4.19 * id(durchfluss).state)) / 3600;
      } else if (id(text_betriebsart).state == "Heizen") {
        return ((id(TVBH).state - id(ruecklauf).state) * (4.19 * id(durchfluss).state)) / 3600;
      } else {
        return 0.0;
      }






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

  - platform: template
    name: "Status Kessel"
    id: status_kessel
    internal: true
    icon: "mdi:thermometer-lines"
    accuracy_decimals: 0
    

  - platform: template
    name: "Wasserdruck"
    id: Wasserdruck
    unit_of_measurement: "bar"
    icon: "mdi:thermometer-lines"
    device_class: "pressure"
    state_class: "measurement"
    accuracy_decimals: 2

  - platform: template
    name: "Erzeugte Energie Gesamt"
    id: Erzeugte_Energie_Gesamt
    unit_of_measurement: "kWh"
    icon: "mdi:thermometer-lines"
    device_class: "ENERGY_STORAGE"
    state_class: "measurement"
    accuracy_decimals: 0

  - platform: template
    name: "EHS fuer CH"
    id: Qchhp
    unit_of_measurement: "kWh"
    icon: "mdi:thermometer-lines"
    device_class: "ENERGY_STORAGE"
    state_class: "measurement"
    accuracy_decimals: 0

  - platform: template
    name: "Umwaelzpumpe"
    id: Umwaelzpumpe
    unit_of_measurement: "%"
    icon: "mdi:thermometer-lines"
    device_class: "battery"
    state_class: "measurement"
    accuracy_decimals: 0

  - platform: template
    name: "Betriebsmodus"
    internal: true
    id: Betriebsmodus
    unit_of_measurement: ""
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 0
   
  - platform: template
    name: "Betriebsart"
    id: Betriebsart
    internal: true
    unit_of_measurement: ""
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 0
    
  - platform: template
    name: "T-WW-Soll1"
    id: t_ww_soll
    unit_of_measurement: "°C"
    icon: "mdi:thermometer-lines"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 1

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

  - platform: template
    name: "Aussentemperatur"
    id: temperature_outside
    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 (TVBH)"
    id: TVBH
    unit_of_measurement: "°C"
    icon: "mdi:waves-arrow-right"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 1

  - platform: template
    name: "Heizkreis Vorlauf (TV)"
    id: TV
    unit_of_measurement: "°C"
    icon: "mdi:waves-arrow-right"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 1
  
  - platform: template
    name: "Ruecklauftemperatur Heizung"
    id: ruecklauf
    unit_of_measurement: "°C"
    icon: "mdi:waves-arrow-left"
    device_class: "temperature"
    state_class: "measurement"
    accuracy_decimals: 1

  - platform: template
    name: "Durchfluss"
    id: durchfluss
    unit_of_measurement: "ltr/h"
    icon: "mdi:waves-arrow-left"
    state_class: "measurement"
    accuracy_decimals: 0

  - platform: template
    name: "Laufzeit Compressor"
    id: rt_compressor
    unit_of_measurement: "h"
    icon: "mdi:icon-time"
    state_class: "measurement"
    accuracy_decimals: 0

  - platform: template
    name: "Laufzeit Pump"
    id: rt_pump
    unit_of_measurement: "h"
    icon: "mdi:icon-time"
    state_class: "measurement"
    accuracy_decimals: 0

  - platform: template
    name: "BPV"
    id: BPV
    unit_of_measurement: "%"
    icon: "mdi:waves-arrow-left"
    accuracy_decimals: 0

  - platform: template
    name: "Min VL Soll"
    internal: false
    id: min_vl_soll
    unit_of_measurement: "°C"
    icon: "mdi:waves-arrow-left"
    state_class: "measurement"
    accuracy_decimals: 0  

  - platform: template
    name: "Max VL Soll"
    internal: false
    id: max_vl_soll
    unit_of_measurement: "°C"
    icon: "mdi:waves-arrow-left"
    state_class: "measurement"
    accuracy_decimals: 0    

  - platform: template
    name: "HK-Funktion"
    internal: true
    id: hk_funktion
    unit_of_measurement: ""
    icon: "mdi:waves-arrow-left"
    state_class: "measurement"
    accuracy_decimals: 0      

  - platform: template
    name: "Spreizung MOD HZ"
    internal: false
    id: spreizung_mod_hz
    unit_of_measurement: "K"
    icon: "mdi:waves-arrow-left"
    state_class: "measurement"
    accuracy_decimals: 0  

  - platform: template
    name: "Spreizung MOD WW"
    internal: false
    id: spreizung_mod_ww
    unit_of_measurement: "K"
    icon: "mdi:waves-arrow-left"
    state_class: "measurement"
    accuracy_decimals: 0        


  - platform: template
    name: "T Vorlauf Tag"
    internal: false
    id: t_vorlauf_tag
    unit_of_measurement: "°C"
    icon: "mdi:waves-arrow-left"
    state_class: "measurement"
    accuracy_decimals: 0 

  
########################### CAN Nachrichten abfragen #################################################
interval:
  - interval:  ${interval_time}
    then:
      if:
        condition:
          - lambda: 'return id(interval_active);'
        then:
          #Status Kessel
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x0A, 0x8C, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          #Umwälzpumpe
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0xC0, 0xF7, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x01, 0x12, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0xC0, 0xF6, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0xC0, 0xFB, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x01, 0xDA, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x06, 0xA4, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0xC1, 0x02, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0xC0, 0xFC, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          #Rücklauftemperatur Hzg - ok 1/10
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0xC1, 0x00, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xfa, 0x00, 0x0e, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          #Warmwasser Temperatur  °C et dec value - ok /10
          - canbus.send:
              data: [0x31, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x06, 0xA5, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xfa, 0x01, 0x2B, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x01, 0x41, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x01, 0x29, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x13, 0x88, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms

 # - interval: 300s
  #  then:
   #   if:
    #    condition:
     #     - lambda: 'return id(interval_active);'
      #  then:
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x09, 0x30, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          #Qchhp
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x09, 0x20, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0xC0, 0xFF, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x01, 0x0E, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x06, 0x83, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms
          - canbus.send:
              data: [0x31, 0x00, 0xFA, 0x06, 0x84, 0x00, 0x00]
              can_id: 0x680
          - delay: 500ms

          - canbus.send:
              data: [ 0x31, 0x00, 0xFA, 0x06, 0x94, 0x00, 0x00 ]
              can_id: 0x680
          - delay: 500ms          


          - canbus.send:
              data: [ 0x31, 0x00, 0xFA, 0x06, 0x93, 0x00, 0x00 ]
              can_id: 0x680
          - delay: 500ms          



 

canbus:
  - platform: esp32_can
    id: can_bus
    can_id: 0x680
    tx_pin: ${tx_pin}
    rx_pin: ${rx_pin}
    bit_rate: 20kbps
    on_frame:

################################# CAN Nachrichten empfangen (Auswertung) #####################################





#Fehlercode
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0x13 and x[4] ==0x88) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))));
             id(Fehlercode).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }



#Heizkurve
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0x01 and x[4] ==0x0E) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))/100));
             id(heizkurve).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }



#Status Kessel
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0x0A and x[4] ==0x8C) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))));
             id(status_kessel).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#Wasserdruck
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[0]==0xd2 and x[2]==0x1C) {
             float temperature =float((float((int((x[4])+( (x[3])<<8))))/1000));
             id(Wasserdruck).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#Qchhp
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0x09 and x[4] ==0x20) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))));
             id(Qchhp).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#Erzeugte Energie gesamt
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0x09 and x[4] ==0x30) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))));
             id(Erzeugte_Energie_Gesamt).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }


#Umwälzpumpe
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0xC0 and x[4] ==0xF7) {
             float temperature =float((float((int((x[6])+( (x[5])))))));
             id(Umwaelzpumpe).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#Betriebsart
    - can_id: 0x180
      then:
        - lambda: |-
           if(x[2]==0xFA and x[3]==0xC0 and x[4] == 0xF6) {
             float temperature =float((float((int((x[6])+( (x[5])))))));
              id(Betriebsart).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }


#Betriebsmodus
    - can_id: 0x180
      then:
       - lambda: |-
           if(x[2]==0xFA and x[3]==0x01 and x[4] ==0x12) {
            float temperature =float((float((int((x[6])+( (x[5])))))));
             id(Betriebsmodus).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#VL Soll
    - can_id: 0x180
      then:
       - lambda: |-
          if(x[0]==0xd2 and x[2]==0x02) {
             float temperature =float((float((int((x[4])+( (x[3])<<8))))/10));
             id(vl_soll).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
           }

#BPV
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0xC0 and x[4]==0xFB) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))));
              id(BPV).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#Volumenstrom 
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0x01 and x[4] ==0xDA) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))));
              id(durchfluss).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#rt_pump
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0x06 and x[4] ==0xA4) {
              float temperature =float((float((int((x[6])+((x[5])<<8))))));
              id(rt_pump).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#rt_compressor
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0x06 and x[4] ==0xA5) {
              float temperature =float((float((int((x[6])+((x[5])<<8))))));
              id(rt_compressor).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#Warmwasser-Temperaturabfrage 
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0x00 and x[4] == 0x0E) {
              float temperature =float((float((int((x[6])+( (x[5])<<8))))/10));
              id(temperature_water).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }

#Vorlauftemperaturabfrage (TVBH)
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0xC1 and x[4] == 0x02) {
              float temperature =float(float((int((x[6])+( (x[5])<<8))))/10);
              id(TVBH).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            } 
            
#Vorlauftemperaturabfrage Heizkreis (TV)
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0xC0 and x[4] == 0xFC) {
              float temperature =float(float((int((x[6])+( (x[5])<<8))))/10);
              id(TV).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }
#Rücklauftemperaturabfrage
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0xC1 and x[4] == 0x00) {
              float temperature =float(float((int((x[6])+( (x[5])<<8))))/10);
              id(ruecklauf).publish_state(temperature);
              ESP_LOGD("main", "Temperature received over can is %f", temperature);
            }


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


#HK Funktion
    - can_id: 0x180
      then:
       - lambda: |-
          if(x[2]==0xFA and x[3]==0x01 and x[4]==0x41) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))));
             id(hk_funktion).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
           }

#Spreizung MOD HZ
    - can_id: 0x180
      then:
       - lambda: |-
          if(x[2]==0xFA and x[3]==0x06 and x[4]==0x83) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))/10));
             id(spreizung_mod_hz).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
           }           

#Spreizung MOD WW
    - can_id: 0x180
      then:
       - lambda: |-
          if(x[2]==0xFA and x[3]==0x06 and x[4]==0x84) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))/10));
             id(spreizung_mod_ww).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
           }                      

#Spreizung MOD WW
    - can_id: 0x180
      then:
       - lambda: |-
          if(x[2]==0xFA and x[3]==0x01 and x[4]==0x29) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))/10));
             id(t_vorlauf_tag).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
           }                      


#SG Modus
    - can_id: 0x180
      then:
       - lambda: |-
          if(x[2]==0xFA and x[3]==0x06 and x[4]==0x94) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))));
             id(SGModus).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
           }                                 


#Smart Grid
    - can_id: 0x180
      then:
       - lambda: |-
          if(x[2]==0xFA and x[3]==0x06 and x[4]==0x93) {
             float temperature =float((float((int((x[6])+( (x[5])<<8))))));
             id(Smartgrid).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
           }                                 

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

#Warmwasser
    - can_id: 0x180
      then:
       - lambda: |-
          if(x[0] == 0xd2 && x[1] == 0x00 && x[2] == 0x13 && x[5] == 0x00 && x[6] == 0x00) {
              uint16_t temperature_raw = (x[3] << 8) | x[4]; // Convert to int16be
              float temperature = static_cast<float>(temperature_raw) / 10.0;
              id(t_ww_soll).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
           }                                            

#Min Vl Soll
    - can_id: 0x180
      then:
       - lambda: |-
          if(x[2]==0xFA and x[3]==0x01 and x[4]==0x2B) {
              float temperature =float(float((int((x[6])+( (x[5])<<8))))/10);
              id(min_vl_soll).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
           }                                 

#Max Vl Soll
    - can_id: 0x180
      then:
       - lambda: |-
          if(x[2]==0x28) {
             float temperature =float((float((int((x[4])+( (x[3])<<8))))/10));
             id(max_vl_soll).publish_state(temperature);
             ESP_LOGD("main", "Temperature received over can is %f", temperature);
           }                                            

#Betriebsmodus (Automatik bei jeglicher Änderung)0x31, 0x00, 0xFA, 0x01, 0x12, 0x00, 0x00
    - can_id: 0x180
      then:
        - lambda: |-
            if(x[2]==0xFA and x[3]==0x01 and x[4]==0x12) {
              if (x[5]==0x01){
                auto call = id(betrieb).make_call();
                call.set_option("Bereitschaft");
                call.perform();}
              else if (x[5]==0x03){
                auto call = id(betrieb).make_call();
                call.set_option("Heizen");
                call.perform();}
              else if (x[5]==0x04){
                auto call = id(betrieb).make_call();
                call.set_option("Absenken");
                call.perform();}
              else if (x[5]==0x05){
                auto call = id(betrieb).make_call();
                call.set_option("Sommer");
                call.perform();}
              else if (x[5]==0x17){
                auto call = id(betrieb).make_call();
                call.set_option("Kühlen");
                call.perform();}
              else if (x[5]==0x0B){
                auto call = id(betrieb).make_call();
                call.set_option("Automatik 1");
                call.perform();}
              else if (x[5]==0x0C){
                auto call = id(betrieb).make_call();
                call.set_option("Automatik 2");
                call.perform();}
              }




#Show data in raw form as hex-values
    - 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_LOGD("main", "Antwort von 180 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
            ESP_LOGD("main", "Antwort von 180 Float: %f", wert7);
            ESP_LOGI("main", "Antwort von 180 Dez.: %i %i", wert5, wert6);

#Show data in raw form as hex-values
    - can_id: 0x300
      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 300 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
            ESP_LOGD("main", "Antwort von 300 Float: %f", wert7);
            ESP_LOGI("main", "Antwort von 300 Dez.: %i %i", wert5, wert6);

#Show data in raw form as hex-values
    - 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]);
            float wert7 = float(int((x[6])+((x[5])<<8)));
            ESP_LOGD("main", "Antwort von 301 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
            ESP_LOGD("main", "Antwort von 301 Float: %f", wert7);
            ESP_LOGI("main", "Antwort von 301 Dez.: %i %i", wert5, wert6);

#Show data in raw form as hex-values
    - 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_LOGD("main", "Antwort von 301 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
            ESP_LOGD("main", "Antwort von 301 Float: %f", wert7);
            ESP_LOGI("main", "Antwort von 301 Dez.: %i %i", wert5, wert6);

#Show data in raw form as hex-values
    - can_id: 0x680
      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 301 Hex: %x %x %x %x %x %x %x", wert0, wert1, wert2, wert3, wert4, wert5, wert6);
            ESP_LOGD("main", "Antwort von 301 Float: %f", wert7);
            ESP_LOGI("main", "Antwort von 301 Dez.: %i %i", wert5, wert6);