Hallo,
ich benötige Hilfe oder einen Denkanstoß:
ich bekomme keine stabile Verbindung zwischen Raspberry (iobroker) und der Wallbox.
Die Leitung ist < 10m CAT5, Busabschlüsse sind drin.
Daten kommen, aber im iobroker geht ständig die rote Lampe der Modbus-Instanz an.
Die Wallbox meldet Busfehler.
Hat jemand das am Laufen in dieser oder ähnlicher Konfiguration?
Es ist auch möglich, das der USP-Seriell-Adapter nicht richtig mitspielt. Könnte dann einen Link auf ein funktionierendes Teil brauchen.
Vorweihnachtliche Grüße
Olfi
sicher, dass die Litzen alle richtig angeklemmt sind? Also guten Kontakt haben (hast Du mal einen Netzwerktester angeschlossen?) + richtige Reihenfolge / Farbkodierung?
Guten Morgen,
es ist nur ein RS485 mit 2 Adern. Da gibt es nur A und B als Anschlüsse.
Ich habe an einer Seite die beiden Litzen zum Test getauscht.
Klappt auch nicht.
Für einen RS485 habe ich keinen Netzwerktester, bei der Leitungslänge von <10m sollte da auch kein Problem kommen.
Hallo Olfi,
was passiert wenn du den PI direkt neben deine Wallbox packst? Ist dann die Verbindung möglich?
Hallo Olfi,Da müsste ich erstmal mächtig umbauen, der Raspi sitzt ja im Schaltschrank und bedient den Akku.
was passiert wenn du den PI direkt neben deine Wallbox packst? Ist dann die Verbindung möglich?
Ist eher die letzte Rille, wie geschrieben sind es nur wenige Meter bis zur Wallbox.
Es muss ja nicht “dauerhaft” sein, sondern nur zum Testen ob die Kommunikation zwischen Wallbox und Raspi überhaupt funktioniert.
Erstmal danke für die Gedanken.
Am Raspi ist recht viel angeklemmt, schon fast einfacher, die Walbox zum Raspi zu bringen.
Ich probier heute noch weiter und fasse es ins Auge.
Es ist auch möglich, das der USP-Seriell-Adapter nicht richtig mitspielt. Könnte dann einen Link auf ein funktionierendes Teil brauchen.seriell ist ja nicht gleich Modbus. Du musst am USB-Adapter exakt die Werte (Baudrate, Bitlänge etc.) eingeben, die die Wallbox erwartet sonst sind die Datenpakete inkompatibel
...Der Adapter ist ein USB zu RS485 Converter https://www.ebay.de/itm/353520705718, der macht die Baudrate alleine.
seriell ist ja nicht gleich Modbus. Du musst am USB-Adapter exakt die Werte (Baudrate, Bitlänge etc.) eingeben, die die Wallbox erwartet sonst sind die Datenpakete inkompatibel
Im iobroker habe ich die Parameter 19200 Baud , Parität even, Stopbit entsprechend gesetzt.
Da ich ja hin und wieder Werte aus den Input-Registern der Wallbox bekomme (Spannungen der Aussenleiter, Temperatur), müssen die Einstellungen stimmen, sonst käme ausschließlich Datenmüll?
Die Wallbox zeigt jetzt keinen Kommunikatiosfehler durch Blinken mehr an.
Ich sende nun parmanent jede Sekunde ein Datum an die Wallbox, die Wallbox setzt dieses immer wieder auf NULL. Recht brutal, aber immerhin könnte die Vermutung des hardwareseitigen Busfehlers ausgeräumt sein.
Der Bus steht also grundsätzlich.
Die Blinkerei und Bedienungsanleitung von der Heidelberg Wallbox ist recht irreführend. Im iobroker tickert der Datenpunkt “Connection” immer zwischen true und false. Etwas zickig die Kleine!
Nun also mal schauen, was die Wallbox softwareseitig erfordert. Wenn das Auto angeklemmt ist probiere ich weiter und gebe das Ergebnis bekannt.
Danke euch für das betreute Basteln!
Habe den Raspberry zur Wallbox geschleppt und über 0,5m Leitung angeschlossen.
Ändert nichts.
Daten sind zu lesen, einige seltsame Fehler sind immer noch da. Beim Senden von Daten zickt die Wallbox aber noch immer.
Ich habe nun einen anderen USB zu RS485 Converter (mit dem ich derzeit einen SDM 630 auslese) für die Wallbox genommen. Und siehe da, Fehler weg.
Nun treten die Fehler bei der Verbindung mit dem SDM630 und dem verdächtigen Converter auf.
Also liegt der Fehler an diesem schäbigen Converter oder dieser will nicht mit dem Raspberry richtig spielen.
Ärgerlich, aber es geht voran.
Ich habe ein Problem mit der Datenanbindung an der Heidlberg Wallbox.
Ich lese die Daten mit einem MAX RS485 Converter und einem ESP32 mit ESPHome aus.
Die Daten kommen zwar alle an, und der Ladestrom lässt sich auch einstellen.
Leider kommen die Daten der Ladeleistung mit einer Verzögerung von 3-5min. Das ist für eine sinnvolle Regelung zu langsam.
Die Einstellung des Ladestrom reagiert schon nach 3Sekunden.
Das 2. Problem ist der text_sensor (ganz am Ende des Programm)
hier bekomme ich immer nur den default Wert “fehler” zurück.
uart:
id: mod_bus
rx_pin: GPIO16
tx_pin: GPIO17
baud_rate: 19200
data_bits: 8
stop_bits: 1
parity: even
modbus:
id: modbus_heidelberg_wallbox
flow_control_pin: 32
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: "Signal %"
entity_category: "diagnostic"
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: version
name: "Version"
address: 0x0004
register_type: read
value_type: U_WORD
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: charg_state
name: "charging state"
address: 0x0005
register_type: read
value_type: U_WORD
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: l1_a_rms
name: "L1 A"
address: 0x0006
unit_of_measurement: "A"
register_type: read
value_type: U_WORD
accuracy_decimals: 1
filters:
- multiply: 0.1
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: l2_a_rms
name: "L2 A"
address: 0x0007
unit_of_measurement: "A"
register_type: read
value_type: U_WORD
accuracy_decimals: 1
filters:
- multiply: 0.1
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: l3_a_rms
name: "L3 A"
address: 0x0008
unit_of_measurement: "A"
register_type: read
value_type: U_WORD
accuracy_decimals: 1
filters:
- multiply: 0.1
- 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: S_WORD
skip_updates: 300
accuracy_decimals: 1
filters:
- multiply: 0.1
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: l1_v_rms
name: "L1 V"
address: 0x000A
unit_of_measurement: "V"
register_type: read
value_type: U_WORD
skip_updates: 60
accuracy_decimals: 1
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: l2_v_rms
name: "L2 V"
address: 0x000B
unit_of_measurement: "V"
register_type: read
value_type: U_WORD
skip_updates: 60
accuracy_decimals: 1
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: l3_v_rms
name: "L3 V"
address: 0x000C
unit_of_measurement: "V"
register_type: read
value_type: U_WORD
skip_updates: 60
accuracy_decimals: 1
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: extern_lock_state
name: "extern lock state"
address: 0x000D
register_type: read
value_type: U_WORD
- 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_power_on
name: "KWH Power On"
address: 0x000F
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: kwh_total
name: "KWH Total"
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: fix_max_current
name: "fix max current"
address: 0x0064
unit_of_measurement: "A"
register_type: read
value_type: U_WORD
accuracy_decimals: 1
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: fix_min_current
name: "fix min current"
address: 0x0065
unit_of_measurement: "A"
register_type: read
value_type: U_WORD
accuracy_decimals: 1
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: watchdog
name: "watchdog"
address: 0x0101
unit_of_measurement: "ms"
register_type: holding
value_type: U_WORD
skip_updates: 0
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: stand_by_control
name: "stand by control"
address: 0x0102
register_type: holding
value_type: U_WORD
skip_updates: 0
- 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: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: failsafe_current
name: "failsafe current"
address: 0x0106
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);
- platform: homeassistant
entity_id: input_number.wb_watchdog_timeout
id: wb_watchdog_timeout
internal: true
on_value:
then:
- lambda: |-
uint16_t payload = id(wb_watchdog_timeout).state;
ESP_LOGI("main", "set watchdog_timeout %d", payload);
esphome::modbus_controller::ModbusCommandItem set_payload_command = esphome::modbus_controller::ModbusCommandItem::create_write_single_command(heidelberg_wallbox_id01, 0x0101, payload);
heidelberg_wallbox_id01->queue_command(set_payload_command);
- platform: homeassistant
entity_id: input_number.wb_max_failsafe_current
id: wb_max_failssafe_current
internal: true
on_value:
then:
- lambda: |-
uint16_t payload = id(wb_max_failssafe_current).state * 10;
ESP_LOGI("main", "set max failssafe current %d", payload);
esphome::modbus_controller::ModbusCommandItem set_payload_command = esphome::modbus_controller::ModbusCommandItem::create_write_single_command(heidelberg_wallbox_id01, 0x0106, payload);
heidelberg_wallbox_id01->queue_command(set_payload_command);
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);
- platform: homeassistant
entity_id: input_boolean.wb_standby_control
id: wb_standby_control
internal: true
on_state:
then:
- lambda: |-
uint16_t payload = 4;
if ( id(wb_standby_control).state == true ) {
payload = 0;
}
ESP_LOGI("main", "set standby control %d", payload);
esphome::modbus_controller::ModbusCommandItem set_payload_command = esphome::modbus_controller::ModbusCommandItem::create_write_single_command(heidelberg_wallbox_id01, 0x0102, payload);
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
register_type: read
lambda: |-
uint16_t value = modbus_controller::word_from_hex_str(x, 0);
switch (value) {
case 1: return std::string("getrennt-Laden verboten");
case 2: return std::string("getrennt-Laden möglich");
case 3: return std::string("angeschlossen-Laden verboten");
case 4: return std::string("angeschlossen-Laden erlaubt");
case 5: return std::string("aktiv-Laden verboten");
case 6: return std::string("aktiv-Laden erlaubt");
default: return std::string("fehler");
}
return x;
So sieht der Aufbau aus.
Hi,
meinst du diesen Schnipsel aus deinem Code:
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
Das wäre die richtige Stelle für die Leistung.
Warum U_WORD?
In meinen Modbus-Einstellungen sind alle Werte im selben Format. Bei dir nicht.
Gruß, olfi
Hi nochmal, habe von Home-Assistent zwar keine Ahnung....
text_sensor:
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: ladezustand
name: "ladezustand"
address: 0x0005
register_type: read
lambda: |-
uint16_t value = modbus_controller::word_from_hex_str(x, 0);
switch (value) {
case 1: return std::string("getrennt-Laden verboten");
case 2: return std::string("getrennt-Laden möglich");
case 3: return std::string("angeschlossen-Laden verboten");
case 4: return std::string("angeschlossen-Laden erlaubt");
case 5: return std::string("aktiv-Laden verboten");
case 6: return std::string("aktiv-Laden erlaubt");
default: return std::string("fehler");
-> probiere mal address: 0x0006 oder lese mal den Wert von 0x0005 aus und poste das Ergebnis.
Du fragst in case 1 bis 6 anscheinend die falschen Werte ab, 7 wäre z.B. Ladeanforderung / Laden erlaubt.
Gruß, olfi
@olfi Problem 1 ist gelößt. Ich weiß zwar nicht genau wie, hab einfach alle nicht benötigten Abfragen deaktiviert.
Jetzt werden nur noch die Register 0005, 0009, 000E, 0011 und 0105 abgerufen und 0105 hochgeladen.
Die Reaktionszeit ist jetzt bei 3Sekunden.
Der Ladezustand wird als Zahl unter 0005 zurückgegeben.
Meine Code
text_sensor:
- platform:
- platform: modbus_controller
modbus_controller_id: heidelberg_wallbox_id01
id: ladezustand
name: "ladezustand"
address: 0x0005
register_type: read
lambda: |-
uint16_t value = modbus_controller::word_from_hex_str(x, 0);
switch (value) {
case 2: return std::string("getrennt-Laden verboten");
case 3: return std::string("getrennt-Laden möglich");
case 4: return std::string("angeschlossen-Laden verboten");
case 5: return std::string("angeschlossen-Laden erlaubt");
case 6: return std::string("aktiv-Laden verboten");
case 7: return std::string("aktiv-Laden erlaubt");
default: return std::string("unbekannt");
}
return x;
liefert nur den defaultwert "unbekannt"
Ich habe die Lösung gefunden.
Falls jemand auch die Heidelberg Wallbox auslesen will,
Hier die Lösung:
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;
Moin,
Ich lese und schreibe die Daten von der Wallbox mit dem RS485-zu-USB-Adapter, das funktioniert, solange die Wallbox nicht für längere Zeit im Standby-Modus ist.
Nach längerem Standby, z.B. über Nacht, tritt ein Problem auf. Die Daten der Wallbox können zwar gelesen, aber keine Register geschrieben werden. Nach dem erneuten Starten der HA funktioniert alles wie es sollte. Ich vermutete, dass das Problem ein billiger RS485 zu USB Konverter war und kaufte einen von Waveshare.
WAVESHARE USB to RS485 Industrial Converter Adapter SKU: 17286 FT232R Blitzfest.
Ich habe eine Automatisierung in Home Assistant erstellt, die StandBy an der Wallbox deaktiviert, die Automatisierung wird ausgeführt, wenn das Auto an der Wallbox angeschlossen ist. Ich habe die Funktion der Automatisierung getestet und war froh, dass die Automatisierung funktioniert hat. Leider ist das Problem wieder aufgetreten. Wenn das Fahrzeug längere Zeit nicht an die Wallbox angeschlossen war, funktioniert die Automatisierung nicht mehr. Wie gehabt, die Daten werden aus der Wallbox ausgelesen, aber es werden keine Daten an die Wallbox gesendet. Die beiden LEDs für Senden und Empfangen am Waveshare leuchten dauerhaft. Trennen und Wiederanschließen des USB-Adapters hilft nicht, nur ein Neustart des Home Assistant behebt das Problem.
Hat jemand eine Idee, woran das liegen könnte?