Heidelberg Energy Control Modbus RTU

Vinzlo · 29. April 2024 um 21:19

Hallo liebe Community,

ich besitze eine Wallbox die Heidelberg Energy Control in Verbindung mit einem Rasberry PI und dem Home Assistant.
Da ich jetzt auch ein Elektrofahrzeug bestitze, würde ich meine Wallbox in den Home Assistant einbinden, und mit den Daten “arbeiten”. Ich habe die Anbindung mit einer Cat 7 Leitung S/FTP und einen RS485 RTU Adapter auf den HA realisiert.
Den Abschlusswiderstand von 120 Ohm auf meinen Adapter geklemmt, die DIP Schalter entsprechend Anleitung eingestellt.
Jetzt probiere ich seit Wochen mit der Integration “Modbus Adapter” Daten aus der Heidelberg abzufragen, leider ist die Frustration akutell groß, bis riesig. Ich kann machen was ich will, habe jetzt die Verkabelung kontrolliert, auf Paarität, auf Klemmfehler etc. alles richtig. Die Entität zum abfragen der Spannung L1-N will einfach nicht funktionieren, probiere aktuell auch nur input register, da ich mit meinem Halbwissen nichts schreiben möchten.
Hat jemand von euch vielleicht eine Lösung oder Erfahrungen? Ich schreibe meine Konfiguration mal unten dazu.

Liebe Grüße

Vinzent

modbus:
  - name: Modbus_Wallbox
    type: serial
    port: /dev/ttyUSB0
    baudrate: 19200
    bytesize: 8
    method: rtu
    parity: E
    stopbits: 1

    delay: 0
    message_wait_milliseconds: 30
    timeout: 5

    sensors:
    - name: SpannungL1N
      slave: 1
      address: 10
      input_type: input
      unit_of_measurement: V
      state_class: measurement
      scale: 0.01
      data_type: uint16

dago · 1. Juli 2024 um 18:21

Hallo Vinzent,
ich kann dir zwar nicht mit dem Modbus helfen, aber vielleicht hilft dir meine Lösung. Ich habe die Ladeleistung an der Heidelberger fest auf 4 KW eingestellt (passt so am Besten zu meiner Solaranlage von 10 KW). Dann hab ich statt der Brücke für den Schlüsselschalter einen potentialfreien Shelly-Kontakt dazwischen gehängt (Anleitung Wallbox Seite A.1.6 Abb 6). Nun schalte ich mit HA die Wallbox über das Shelly-Relais an und aus entsprechend meinem Stromüberschuss. Das funktioniert super, ist einfach und ob das Auto nun 2 oder 6 Stunden lädt ist mir egal.
Grüsse
Jochen

didzo · 13. Juli 2024 um 19:17

Hallo,

ich habe eine Heidelberg Amperfied connect.home Wallbox mit Modbus/tcp.
Nach Anleitung habe ich den Modbus Part in eine modbus.yml Datei ausgelagert.
Der Teil mit Spannung_L1N sieht bei mir genauso aus:

  - name: wallbox010    # Voltage 01 
    address: 10
    input_type: input
    state_class: measurement
    unit_of_measurement: V
    slave: 1
    data_type: uint16

ich habe keine Probleme beim Auslesen der Sensoren. Evtl. kannst du mal “scale: 0.01” weglassen. Es hat etwas gedauert bis ich heraus gefunden habe, das nur eine Modbus Verbindung zur WB geht. Ich hatte noch ein Test Tool “ModbusTcpClient” zum Testen. Der hat die Verbindung immer dicht gemacht.
Evtl. hilft das ja …

Wenn du eine Idee hast, wie man Register schreiben kann. Wäre ich für einen Tip dankbar. Ich kämpfe gerade damit mein Auto automatisch via Modbus zu laden … leider bisher ohne Erfolg, ggf. mach ich dazu noch einen Thread auf.
Viel Erfolg.

MelleD · 14. Juli 2024 um 08:02

Benutz doch einfach EVCC damit kannst dann alles steuern

https://github.com/evcc-io/hassio-addon

EiCapo · 29. September 2024 um 19:40

@didzo
wenn’s noch aktuell ist,
Hier meine ESP32 Datei, mit der ich die Daten der Wallbox abrufen, und den Ladestrom einstellen kann.

esphome:
  name: esp32-21
  friendly_name: Wallbox1

esp32:
  board: esp32dev
  framework:
    type: arduino

# Enable logging
logger:

# Enable Home Assistant API
api:
  encryption:
    key: "xxxxxxxxxxxxxxxxxxx"

ota:
  - platform: esphome
    password: "xxxxxxxxxxxxxxxxxxxxx"

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

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Esp32-21 Fallback Hotspot"
    password: "xxxxxxxxxxxxxxxx"

captive_portal:

uart:
  id: mod_bus
  rx_pin: GPIO16
  tx_pin: GPIO17
  baud_rate: 19200
  stop_bits: 1
  parity: even

modbus:
  id: modbus_heidelberg_wallbox
  flow_control_pin: 32
  uart_id: mod_bus
  send_wait_time: 200ms
  
modbus_controller:
  - id: heidelberg_wallbox_id01
    address: 0x1
    modbus_id: modbus_heidelberg_wallbox
    command_throttle: 200ms
    setup_priority: -10
    update_interval: 3s

sensor:
# WIFI Signal
  - platform: wifi_signal # Reports the WiFi signal strength/RSSI in dB
    name: "WiFi Signal dB"
    id: wifi_signal_db
    update_interval: 600s
    entity_category: "diagnostic"
  - platform: copy # Reports the WiFi signal strength in %
    source_id: wifi_signal_db
    name: "WiFi Signal Percent"
    filters:
      - lambda: return min(max(2 * (x + 100.0), 0.0), 100.0);
    unit_of_measurement: "%"
    entity_category: "diagnostic"

#Ladestatus
  - platform: modbus_controller
    modbus_controller_id: heidelberg_wallbox_id01  
    id: charg_state
    name: "charging state"
    address: 0x0005
    register_type: read
    value_type: U_WORD
    skip_updates: 0

  - platform: modbus_controller
    modbus_controller_id: heidelberg_wallbox_id01  
    id: pcb_temp
    name: "PCB-Temperatur"
    address: 0x0009
    unit_of_measurement: "°C"
    register_type: read
    value_type: U_WORD
    skip_updates: 30
    accuracy_decimals: 1
    filters:
      - multiply: 0.1

  - platform: modbus_controller
    modbus_controller_id: heidelberg_wallbox_id01  
    id: l1_l2_l3_power
    name: "L1 L2 L3 Power"
    address: 0x000E
    unit_of_measurement: "W"
    register_type: read
    value_type: U_WORD
    accuracy_decimals: 0

  - platform: modbus_controller
    modbus_controller_id: heidelberg_wallbox_id01  
    id: kwh_total_energie
    name: "KWH Total Energie"
    address: 0x0011
    unit_of_measurement: "kWh"
    register_type: read
    value_type: U_DWORD
    accuracy_decimals: 3
    filters:
      - multiply: 0.001

  - platform: modbus_controller
    modbus_controller_id: heidelberg_wallbox_id01  
    id: remote_lock
    name: "remote_lock"
    address: 0x0103
    register_type: holding
    value_type: U_WORD
    skip_updates: 0

  - platform: modbus_controller
    modbus_controller_id: heidelberg_wallbox_id01  
    id: max_current
    name: "max current"
    address: 0x0105
    unit_of_measurement: "A"
    register_type: holding
    value_type: U_WORD
    skip_updates: 0
    accuracy_decimals: 1
    filters:
      - multiply: 0.1
  

  - platform: homeassistant
    entity_id: input_number.wb_max_current #Slider from HASS, create as Helper
    id: wb_max_current
    internal: true
    on_value:
      then:
        - lambda: |-
            uint16_t payload = id(wb_max_current).state * 10;
            ESP_LOGI("main", "set max current %d", payload);
            // Create a modbus command item with the max current value as the payload
            esphome::modbus_controller::ModbusCommandItem set_payload_command = esphome::modbus_controller::ModbusCommandItem::create_write_single_command(heidelberg_wallbox_id01, 0x0105, payload);
            // Submit the command to the send queue
            heidelberg_wallbox_id01->queue_command(set_payload_command);



text_sensor:
  - platform: modbus_controller
    modbus_controller_id: heidelberg_wallbox_id01  
    id: ladezustand
    name: "ladezustand"
    address: 0x0005
    bitmask: 0
    raw_encode: HEXBYTES
    register_type: read
    lambda: |-
      uint16_t value = modbus_controller::word_from_hex_str(x, 0);
      switch (value) {   
        case 2: return std::string("nein");
        case 3: return std::string("ja");
        case 4: return std::string("nein");
        case 5: return std::string("ja");
        case 6: return std::string("nein");
        case 7: return std::string("ja");
        case 8: return std::string("reduziert");
        case 9: return std::string("Fehler");
        case 10: return std::string("gesperrt");
        default: return std::string("Fehler");
      }
      return x;

#        case 0: return std::string("0verboten");

  - platform: modbus_controller
    modbus_controller_id: heidelberg_wallbox_id01  
    id: Fahrzeug
    name: "fahrzeug"
    address: 0x0005
    bitmask: 0
    raw_encode: HEXBYTES
    register_type: read
    lambda: |-
      uint16_t value = modbus_controller::word_from_hex_str(x, 0);
      switch (value) {   
        case 2: return std::string("nicht angesteckt");
        case 3: return std::string("nicht angesteckt");
        case 4: return std::string("angesteckt");
        case 5: return std::string("angesteckt");
        case 6: return std::string("angesteckt");
        case 7: return std::string("angesteckt");
        case 8: return std::string("-");
        case 9: return std::string("Fehler");
        case 10: return std::string("-");
        default: return std::string("Fehler");
      }
      return x;

#binary_sensor:
#  - platform: homeassistant
#    entity_id: input_boolean.wb_remote_lock
#    id: wb_remote_lock
#    internal: true
#    on_state:
#      then:
#        - lambda: |-
#            uint16_t payload = 1;
#            if ( id(wb_remote_lock).state == true ) {
#              payload = 0;
#            }
#            ESP_LOGI("main", "set remote lock %d", payload);
#            esphome::modbus_controller::ModbusCommandItem set_payload_command = esphome::modbus_controller::ModbusCommandItem::create_write_single_command(heidelberg_wallbox_id01, 0x0103, payload);
#            heidelberg_wallbox_id01->queue_command(set_payload_command);