From 6c8e967c13fa5f5936a434e4a8f9d4d7743266e9 Mon Sep 17 00:00:00 2001 From: cr0i Date: Tue, 24 Feb 2026 23:23:38 +0100 Subject: [PATCH 01/10] Update bat.py --- packages/modules/devices/solaredge/solaredge/bat.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/packages/modules/devices/solaredge/solaredge/bat.py b/packages/modules/devices/solaredge/solaredge/bat.py index 5561bc98ce..517aaaded3 100644 --- a/packages/modules/devices/solaredge/solaredge/bat.py +++ b/packages/modules/devices/solaredge/solaredge/bat.py @@ -157,6 +157,8 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: log.error(f"Failed to read registers: {e}") self.fault_state.error(f"Modbus read error: {e}") return + if values["StorageControlMode"] != CONTROL_MODE_REMOTE: # Save StorageControlMode if not Remote + self.StorageControlMode_Read = values["StorageControlMode"] soc = values[f"Battery{battery_index}StateOfEnergy"] if soc == FLOAT32_UNSUPPORTED or not 0 <= soc <= 100: log.warning(f"Speicher{battery_index}: Invalid SoC: {soc}") @@ -189,11 +191,10 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: self._write_registers(values_to_write, unit) self.last_mode = 'discharge-mode' - else: # Remote Control not active. + else: # Remote Control Discharge Mode not active. if soc_reserve < soc: # Enable Remote Control if SoC above SoC-Reserve. log.debug(f"Discharge-Limit aktivieren, Speicher{battery_index}: {int(abs(power_limit))}W.") - self.StorageControlMode_Read = values["StorageControlMode"] values_to_write = { "StorageControlMode": CONTROL_MODE_REMOTE, "RemoteControlCommandModeDefault": REMOTE_CONTROL_COMMAND_MODE_MSC, @@ -215,7 +216,8 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: log.error(f"Failed to read registers: {e}") self.fault_state.error(f"Modbus read error: {e}") return - + if values["StorageControlMode"] != CONTROL_MODE_REMOTE: # Save StorageControlMode if not Remote + self.StorageControlMode_Read = values["StorageControlMode"] if (values["StorageControlMode"] == CONTROL_MODE_REMOTE and values["RemoteControlCommandMode"] == REMOTE_CONTROL_COMMAND_MODE_CHARGE): # Remote Control Charge Mode active. @@ -229,7 +231,6 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: else: # Remote Control Charge Mode inactive. log.debug(f"Aktivierung Laden Speicher{battery_index}: {int(abs(power_limit))}W.") - self.StorageControlMode_Read = values["StorageControlMode"] values_to_write = { "StorageControlMode": CONTROL_MODE_REMOTE, "RemoteControlCommandModeDefault": REMOTE_CONTROL_COMMAND_MODE_CHARGE, From 21db8cd5022dea1784cd5e404baa9cf99aa21ea7 Mon Sep 17 00:00:00 2001 From: cr0i Date: Wed, 25 Feb 2026 17:27:24 +0100 Subject: [PATCH 02/10] Update bat.py --- .../devices/solaredge/solaredge/bat.py | 56 +++++-------------- 1 file changed, 13 insertions(+), 43 deletions(-) diff --git a/packages/modules/devices/solaredge/solaredge/bat.py b/packages/modules/devices/solaredge/solaredge/bat.py index 517aaaded3..88c12daa6a 100644 --- a/packages/modules/devices/solaredge/solaredge/bat.py +++ b/packages/modules/devices/solaredge/solaredge/bat.py @@ -26,7 +26,7 @@ CONTROL_MODE_REMOTE = 4 # Control Mode Remotesteuerung REMOTE_CONTROL_COMMAND_MODE_DEFAULT = 0 # Default RC Command Mode ohne Steuerung REMOTE_CONTROL_COMMAND_MODE_CHARGE = 3 # RC Command Mode Charge from PV+AC -REMOTE_CONTROL_COMMAND_MODE_MSC = 7 # RC Command Mode Maximize Self Consumtion +REMOTE_CONTROL_COMMAND_MODE_MSC = 7 # RC Command Mode Maximize Self Consumtion used for Limit Discharge class KwargsDict(TypedDict): @@ -59,7 +59,6 @@ def initialize(self) -> None: self.sim_counter = SimCounter(self.__device_id, self.component_config.id, prefix="speicher") self.store = get_bat_value_store(self.component_config.id) self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config)) - self.min_soc = 13 self.StorageControlMode_Read = CONTROL_MODE_MSC # Default Control Mode Set to MSC if not Read self.last_mode = 'undefined' @@ -109,9 +108,6 @@ def get_values(self) -> Tuple[float, float]: power = 0 if soc == FLOAT32_UNSUPPORTED or not 0 <= soc <= 100: log.warning(f"Invalid SoC Speicher{battery_index}: {soc}") - else: - self.min_soc = min(int(soc), int(self.min_soc)) - log.debug(f"Min-SoC Speicher{battery_index}: {int(self.min_soc)}%.") return power, soc @@ -137,17 +133,11 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: self._write_registers(values_to_write, unit) self.last_mode = None else: - return + return elif power_limit <= 0: # Limit Discharge Mode should be used. - """ - SolarEdge discharges the battery only to SoC-Reserve. - Disable Remote Control if SoC of battery is lower than SoC-Reserve. - """ registers_to_read = [ - f"Battery{battery_index}StateOfEnergy", "StorageControlMode", - "StorageBackupReserved", "RemoteControlCommandMode", "RemoteControlDischargeLimit", ] @@ -159,30 +149,12 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: return if values["StorageControlMode"] != CONTROL_MODE_REMOTE: # Save StorageControlMode if not Remote self.StorageControlMode_Read = values["StorageControlMode"] - soc = values[f"Battery{battery_index}StateOfEnergy"] - if soc == FLOAT32_UNSUPPORTED or not 0 <= soc <= 100: - log.warning(f"Speicher{battery_index}: Invalid SoC: {soc}") - soc_reserve = max(int(self.min_soc + 2), int(values["StorageBackupReserved"])) - log.debug(f"SoC-Reserve Speicher{battery_index}: {int(soc_reserve)}%.") discharge_limit = int(values["RemoteControlDischargeLimit"]) if (values["StorageControlMode"] == CONTROL_MODE_REMOTE and values["RemoteControlCommandMode"] == REMOTE_CONTROL_COMMAND_MODE_MSC): # RC Discharge Mode active. - if soc_reserve > soc: - # Disable Remote Control if SOC is lower than SOC-RESERVE. - # toDo: Problem with 2 batteries is unsolved. - log.debug(f"Speicher{battery_index}: Steuerung deaktivieren. SoC-Reserve unterschritten") - values_to_write = { - "RemoteControlDischargeLimit": MAX_CHARGEDISCHARGE_LIMIT, - "RemoteControlCommandModeDefault": REMOTE_CONTROL_COMMAND_MODE_DEFAULT, - "RemoteControlCommandMode": REMOTE_CONTROL_COMMAND_MODE_DEFAULT, - "StorageControlMode": self.StorageControlMode_Read, - } - self._write_registers(values_to_write, unit) - self.last_mode = None - - elif discharge_limit not in range(int(abs(power_limit)) - 10, int(abs(power_limit)) + 10): + if discharge_limit not in range(int(abs(power_limit)) - 10, int(abs(power_limit)) + 10): # Limit only if difference is more than 10W, needed with more than 1 battery. log.debug(f"Discharge-Limit Speicher{battery_index}: {int(abs(power_limit))}W.") values_to_write = { @@ -191,18 +163,16 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: self._write_registers(values_to_write, unit) self.last_mode = 'discharge-mode' - else: # Remote Control Discharge Mode not active. - if soc_reserve < soc: - # Enable Remote Control if SoC above SoC-Reserve. - log.debug(f"Discharge-Limit aktivieren, Speicher{battery_index}: {int(abs(power_limit))}W.") - values_to_write = { - "StorageControlMode": CONTROL_MODE_REMOTE, - "RemoteControlCommandModeDefault": REMOTE_CONTROL_COMMAND_MODE_MSC, - "RemoteControlCommandMode": REMOTE_CONTROL_COMMAND_MODE_MSC, - "RemoteControlDischargeLimit": int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT)) - } - self._write_registers(values_to_write, unit) - self.last_mode = 'discharge-mode' + else: # Enable Remote Control Discharge Mode if not active. + log.debug(f"Discharge-Limit aktivieren, Speicher{battery_index}: {int(abs(power_limit))}W.") + values_to_write = { + "StorageControlMode": CONTROL_MODE_REMOTE, + "RemoteControlCommandModeDefault": REMOTE_CONTROL_COMMAND_MODE_MSC, + "RemoteControlCommandMode": REMOTE_CONTROL_COMMAND_MODE_MSC, + "RemoteControlDischargeLimit": int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT)) + } + self._write_registers(values_to_write, unit) + self.last_mode = 'discharge-mode' elif power_limit > 0: # Charge Mode should be used registers_to_read = [ From d1caf72175995d463b35d440dea1016d91272636 Mon Sep 17 00:00:00 2001 From: cr0i Date: Wed, 25 Feb 2026 17:30:50 +0100 Subject: [PATCH 03/10] Update bat.py --- packages/modules/devices/solaredge/solaredge/bat.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/packages/modules/devices/solaredge/solaredge/bat.py b/packages/modules/devices/solaredge/solaredge/bat.py index 88c12daa6a..d944c6944c 100644 --- a/packages/modules/devices/solaredge/solaredge/bat.py +++ b/packages/modules/devices/solaredge/solaredge/bat.py @@ -133,7 +133,8 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: self._write_registers(values_to_write, unit) self.last_mode = None else: - return + log.debug(f"Speicher{battery_index}:Power_Limit=None mehrfach geschrieben.") + return elif power_limit <= 0: # Limit Discharge Mode should be used. registers_to_read = [ From 5bee951a5df67d5ef4863d9ad4b5e87f5717ff4c Mon Sep 17 00:00:00 2001 From: cr0i Date: Thu, 26 Feb 2026 02:09:35 +0100 Subject: [PATCH 04/10] Update bat.py --- packages/modules/devices/solaredge/solaredge/bat.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/packages/modules/devices/solaredge/solaredge/bat.py b/packages/modules/devices/solaredge/solaredge/bat.py index d944c6944c..68b1dcddd5 100644 --- a/packages/modules/devices/solaredge/solaredge/bat.py +++ b/packages/modules/devices/solaredge/solaredge/bat.py @@ -134,6 +134,7 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: self.last_mode = None else: log.debug(f"Speicher{battery_index}:Power_Limit=None mehrfach geschrieben.") + log.debug(f"Speicher{battery_index}:Last_Mode={self.last_mode}") return elif power_limit <= 0: # Limit Discharge Mode should be used. @@ -163,6 +164,7 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: } self._write_registers(values_to_write, unit) self.last_mode = 'discharge-mode' + log.debug(f"Speicher{battery_index}:Last_Mode={self.last_mode}") else: # Enable Remote Control Discharge Mode if not active. log.debug(f"Discharge-Limit aktivieren, Speicher{battery_index}: {int(abs(power_limit))}W.") @@ -174,6 +176,7 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: } self._write_registers(values_to_write, unit) self.last_mode = 'discharge-mode' + log.debug(f"Speicher{battery_index}:Last_Mode={self.last_mode}") elif power_limit > 0: # Charge Mode should be used registers_to_read = [ @@ -199,6 +202,7 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: } self._write_registers(values_to_write, unit) self.last_mode = 'charge-mode' + log.debug(f"Speicher{battery_index}:Last_Mode={self.last_mode}") else: # Remote Control Charge Mode inactive. log.debug(f"Aktivierung Laden Speicher{battery_index}: {int(abs(power_limit))}W.") @@ -210,6 +214,7 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: } self._write_registers(values_to_write, unit) self.last_mode = 'charge-mode' + log.debug(f"Speicher{battery_index}:Last_Mode={self.last_mode}") def _read_registers(self, register_names: list, unit: int) -> Dict[str, Union[int, float]]: values = {} From 93cfde8d69498cd8eafa4a5fb552718fa12ea596 Mon Sep 17 00:00:00 2001 From: cr0i Date: Fri, 27 Feb 2026 00:49:38 +0100 Subject: [PATCH 05/10] Update bat.py --- .../devices/solaredge/solaredge/bat.py | 100 +++++++----------- 1 file changed, 37 insertions(+), 63 deletions(-) diff --git a/packages/modules/devices/solaredge/solaredge/bat.py b/packages/modules/devices/solaredge/solaredge/bat.py index 68b1dcddd5..f4fdcdf6ca 100644 --- a/packages/modules/devices/solaredge/solaredge/bat.py +++ b/packages/modules/devices/solaredge/solaredge/bat.py @@ -59,8 +59,6 @@ def initialize(self) -> None: self.sim_counter = SimCounter(self.__device_id, self.component_config.id, prefix="speicher") self.store = get_bat_value_store(self.component_config.id) self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config)) - self.StorageControlMode_Read = CONTROL_MODE_MSC # Default Control Mode Set to MSC if not Read - self.last_mode = 'undefined' def update(self) -> None: self.store.set(self.read_state()) @@ -119,55 +117,48 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: # Use 1 as fallback if battery_index is not set battery_index = getattr(self.component_config.configuration, "battery_index", 1) + registers_to_read = [ + "StorageControlMode", + "RemoteControlCommandMode", + "RemoteControlChargeLimit", + "RemoteControlDischargeLimit", + ] + try: + values = self._read_registers(registers_to_read, unit) + except pymodbus.exceptions.ModbusException as e: + log.error(f"Failed to read registers: {e}") + self.fault_state.error(f"Modbus read error: {e}") + return + if power_limit is None: # No Bat Control should be used. - if self.last_mode in ('discharge-mode', 'charge-mode'): - # Disable Bat Control - log.debug(f"Speicher{battery_index}:Keine Steuerung gefordert, Steuerung deaktivieren.") - values_to_write = { - "RemoteControlChargeLimit": MAX_CHARGEDISCHARGE_LIMIT, - "RemoteControlDischargeLimit": MAX_CHARGEDISCHARGE_LIMIT, - "RemoteControlCommandModeDefault": REMOTE_CONTROL_COMMAND_MODE_DEFAULT, - "RemoteControlCommandMode": REMOTE_CONTROL_COMMAND_MODE_DEFAULT, - "StorageControlMode": self.StorageControlMode_Read, - } - self._write_registers(values_to_write, unit) - self.last_mode = None - else: - log.debug(f"Speicher{battery_index}:Power_Limit=None mehrfach geschrieben.") - log.debug(f"Speicher{battery_index}:Last_Mode={self.last_mode}") - return + if values["StorageControlMode"] == CONTROL_MODE_MSC: + log.debug(f"Speicher{battery_index}:Keine Steuerung gefordert, bereits deaktiviert.") + # Disable Bat Control + log.debug(f"Speicher{battery_index}:Keine Steuerung gefordert, Steuerung deaktivieren.") + values_to_write = { + "RemoteControlChargeLimit": MAX_CHARGEDISCHARGE_LIMIT, + "RemoteControlDischargeLimit": MAX_CHARGEDISCHARGE_LIMIT, + "RemoteControlCommandModeDefault": REMOTE_CONTROL_COMMAND_MODE_DEFAULT, + "RemoteControlCommandMode": REMOTE_CONTROL_COMMAND_MODE_DEFAULT, + "StorageControlMode": CONTROL_MODE_MSC, + } + self._write_registers(values_to_write, unit) elif power_limit <= 0: # Limit Discharge Mode should be used. - registers_to_read = [ - "StorageControlMode", - "RemoteControlCommandMode", - "RemoteControlDischargeLimit", - ] - try: - values = self._read_registers(registers_to_read, unit) - except pymodbus.exceptions.ModbusException as e: - log.error(f"Failed to read registers: {e}") - self.fault_state.error(f"Modbus read error: {e}") - return - if values["StorageControlMode"] != CONTROL_MODE_REMOTE: # Save StorageControlMode if not Remote - self.StorageControlMode_Read = values["StorageControlMode"] - discharge_limit = int(values["RemoteControlDischargeLimit"]) - if (values["StorageControlMode"] == CONTROL_MODE_REMOTE and values["RemoteControlCommandMode"] == REMOTE_CONTROL_COMMAND_MODE_MSC): - # RC Discharge Mode active. + # Remote Control and Discharge Mode already active. + discharge_limit = int(values["RemoteControlDischargeLimit"]) if discharge_limit not in range(int(abs(power_limit)) - 10, int(abs(power_limit)) + 10): - # Limit only if difference is more than 10W, needed with more than 1 battery. - log.debug(f"Discharge-Limit Speicher{battery_index}: {int(abs(power_limit))}W.") + # Send Limit only if difference is more than 10W, needed with more than 1 battery. + log.debug(f"Entlade-Limit Speicher{battery_index}: {int(abs(power_limit))}W.") values_to_write = { "RemoteControlDischargeLimit": int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT)) } self._write_registers(values_to_write, unit) - self.last_mode = 'discharge-mode' - log.debug(f"Speicher{battery_index}:Last_Mode={self.last_mode}") - - else: # Enable Remote Control Discharge Mode if not active. - log.debug(f"Discharge-Limit aktivieren, Speicher{battery_index}: {int(abs(power_limit))}W.") + else: + log.debug(f"Entlade-Limit Speicher{battery_index}: Abweichung unter +/- 10W.") + else: # Enable Remote Control and Discharge Mode. values_to_write = { "StorageControlMode": CONTROL_MODE_REMOTE, "RemoteControlCommandModeDefault": REMOTE_CONTROL_COMMAND_MODE_MSC, @@ -175,37 +166,21 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: "RemoteControlDischargeLimit": int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT)) } self._write_registers(values_to_write, unit) - self.last_mode = 'discharge-mode' - log.debug(f"Speicher{battery_index}:Last_Mode={self.last_mode}") + log.debug(f"Entlade-Limit aktiviert, Speicher{battery_index}: {int(abs(power_limit))}W.") elif power_limit > 0: # Charge Mode should be used - registers_to_read = [ - "StorageControlMode", - "RemoteControlCommandMode", - "RemoteControlChargeLimit", - ] - try: - values = self._read_registers(registers_to_read, unit) - except pymodbus.exceptions.ModbusException as e: - log.error(f"Failed to read registers: {e}") - self.fault_state.error(f"Modbus read error: {e}") - return - if values["StorageControlMode"] != CONTROL_MODE_REMOTE: # Save StorageControlMode if not Remote - self.StorageControlMode_Read = values["StorageControlMode"] if (values["StorageControlMode"] == CONTROL_MODE_REMOTE and values["RemoteControlCommandMode"] == REMOTE_CONTROL_COMMAND_MODE_CHARGE): - # Remote Control Charge Mode active. + # Remote Control and Charge Mode already active. log.debug( - f"Ladung Speicher.{battery_index}: {int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT))}W.") + f"Ladung Speicher{battery_index}: {int(abs(power_limit))}W.") values_to_write = { "RemoteControlChargeLimit": int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT)) } self._write_registers(values_to_write, unit) self.last_mode = 'charge-mode' log.debug(f"Speicher{battery_index}:Last_Mode={self.last_mode}") - - else: # Remote Control Charge Mode inactive. - log.debug(f"Aktivierung Laden Speicher{battery_index}: {int(abs(power_limit))}W.") + else: # Enable Remote Control and Charge Mode. values_to_write = { "StorageControlMode": CONTROL_MODE_REMOTE, "RemoteControlCommandModeDefault": REMOTE_CONTROL_COMMAND_MODE_CHARGE, @@ -213,8 +188,7 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: "RemoteControlChargeLimit": int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT)) } self._write_registers(values_to_write, unit) - self.last_mode = 'charge-mode' - log.debug(f"Speicher{battery_index}:Last_Mode={self.last_mode}") + log.debug(f"Aktivierung Ladung Speicher{battery_index}: {int(abs(power_limit))}W.") def _read_registers(self, register_names: list, unit: int) -> Dict[str, Union[int, float]]: values = {} From 87c3301ba92c339a039f128a9c88488540df84e3 Mon Sep 17 00:00:00 2001 From: cr0i Date: Fri, 27 Feb 2026 01:00:24 +0100 Subject: [PATCH 06/10] Update bat.py --- packages/modules/devices/solaredge/solaredge/bat.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/packages/modules/devices/solaredge/solaredge/bat.py b/packages/modules/devices/solaredge/solaredge/bat.py index f4fdcdf6ca..3c4f0a74ef 100644 --- a/packages/modules/devices/solaredge/solaredge/bat.py +++ b/packages/modules/devices/solaredge/solaredge/bat.py @@ -178,8 +178,6 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: "RemoteControlChargeLimit": int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT)) } self._write_registers(values_to_write, unit) - self.last_mode = 'charge-mode' - log.debug(f"Speicher{battery_index}:Last_Mode={self.last_mode}") else: # Enable Remote Control and Charge Mode. values_to_write = { "StorageControlMode": CONTROL_MODE_REMOTE, From a10d4aac1cf482928c57b3d83ba4792e85b278f5 Mon Sep 17 00:00:00 2001 From: cr0i Date: Fri, 27 Feb 2026 01:10:02 +0100 Subject: [PATCH 07/10] Update bat.py --- .../devices/solaredge/solaredge/bat.py | 21 ++++++++++--------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/packages/modules/devices/solaredge/solaredge/bat.py b/packages/modules/devices/solaredge/solaredge/bat.py index 3c4f0a74ef..efc028b498 100644 --- a/packages/modules/devices/solaredge/solaredge/bat.py +++ b/packages/modules/devices/solaredge/solaredge/bat.py @@ -133,16 +133,17 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: if power_limit is None: # No Bat Control should be used. if values["StorageControlMode"] == CONTROL_MODE_MSC: log.debug(f"Speicher{battery_index}:Keine Steuerung gefordert, bereits deaktiviert.") - # Disable Bat Control - log.debug(f"Speicher{battery_index}:Keine Steuerung gefordert, Steuerung deaktivieren.") - values_to_write = { - "RemoteControlChargeLimit": MAX_CHARGEDISCHARGE_LIMIT, - "RemoteControlDischargeLimit": MAX_CHARGEDISCHARGE_LIMIT, - "RemoteControlCommandModeDefault": REMOTE_CONTROL_COMMAND_MODE_DEFAULT, - "RemoteControlCommandMode": REMOTE_CONTROL_COMMAND_MODE_DEFAULT, - "StorageControlMode": CONTROL_MODE_MSC, - } - self._write_registers(values_to_write, unit) + else: + # Disable Bat Control + values_to_write = { + "RemoteControlChargeLimit": MAX_CHARGEDISCHARGE_LIMIT, + "RemoteControlDischargeLimit": MAX_CHARGEDISCHARGE_LIMIT, + "RemoteControlCommandModeDefault": REMOTE_CONTROL_COMMAND_MODE_DEFAULT, + "RemoteControlCommandMode": REMOTE_CONTROL_COMMAND_MODE_DEFAULT, + "StorageControlMode": CONTROL_MODE_MSC, + } + self._write_registers(values_to_write, unit) + log.debug(f"Speicher{battery_index}:Keine Steuerung gefordert, Steuerung deaktiviert.") elif power_limit <= 0: # Limit Discharge Mode should be used. if (values["StorageControlMode"] == CONTROL_MODE_REMOTE and From 973ba958f4c3c2cfb90c0f676e11ad9c13188471 Mon Sep 17 00:00:00 2001 From: cr0i Date: Fri, 27 Feb 2026 01:25:06 +0100 Subject: [PATCH 08/10] Update bat.py --- .../modules/devices/solaredge/solaredge/bat.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/packages/modules/devices/solaredge/solaredge/bat.py b/packages/modules/devices/solaredge/solaredge/bat.py index efc028b498..263360277d 100644 --- a/packages/modules/devices/solaredge/solaredge/bat.py +++ b/packages/modules/devices/solaredge/solaredge/bat.py @@ -173,12 +173,16 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: if (values["StorageControlMode"] == CONTROL_MODE_REMOTE and values["RemoteControlCommandMode"] == REMOTE_CONTROL_COMMAND_MODE_CHARGE): # Remote Control and Charge Mode already active. - log.debug( - f"Ladung Speicher{battery_index}: {int(abs(power_limit))}W.") - values_to_write = { - "RemoteControlChargeLimit": int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT)) - } - self._write_registers(values_to_write, unit) + charge_limit = int(values["RemoteControlChargeLimit"]) + if charge_limit not in range(int(abs(power_limit)) - 10, int(abs(power_limit)) + 10): + # Send Limit only if difference is more than 10W, needed with more than 1 battery. + values_to_write = { + "RemoteControlChargeLimit": int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT)) + } + self._write_registers(values_to_write, unit) + log.debug(f"Ladung Speicher{battery_index}: {int(abs(power_limit))}W.") + else: + log.debug(f"Ladung Speicher{battery_index}: Abweichung unter +/- 10W.") else: # Enable Remote Control and Charge Mode. values_to_write = { "StorageControlMode": CONTROL_MODE_REMOTE, From d0d696ea1a8c7f25d2c70bbfeeade1b2c08c2f81 Mon Sep 17 00:00:00 2001 From: cr0i Date: Fri, 27 Feb 2026 01:27:58 +0100 Subject: [PATCH 09/10] Update bat.py --- packages/modules/devices/solaredge/solaredge/bat.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/modules/devices/solaredge/solaredge/bat.py b/packages/modules/devices/solaredge/solaredge/bat.py index 263360277d..b77fe91e82 100644 --- a/packages/modules/devices/solaredge/solaredge/bat.py +++ b/packages/modules/devices/solaredge/solaredge/bat.py @@ -152,11 +152,11 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: discharge_limit = int(values["RemoteControlDischargeLimit"]) if discharge_limit not in range(int(abs(power_limit)) - 10, int(abs(power_limit)) + 10): # Send Limit only if difference is more than 10W, needed with more than 1 battery. - log.debug(f"Entlade-Limit Speicher{battery_index}: {int(abs(power_limit))}W.") values_to_write = { "RemoteControlDischargeLimit": int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT)) } self._write_registers(values_to_write, unit) + log.debug(f"Entlade-Limit Speicher{battery_index}: {int(abs(power_limit))}W.") else: log.debug(f"Entlade-Limit Speicher{battery_index}: Abweichung unter +/- 10W.") else: # Enable Remote Control and Discharge Mode. From 54024f590a29060a87e71dfcd8b5c5d1145bebfb Mon Sep 17 00:00:00 2001 From: cr0i Date: Fri, 27 Feb 2026 02:21:05 +0100 Subject: [PATCH 10/10] Update bat.py --- packages/modules/devices/solaredge/solaredge/bat.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/modules/devices/solaredge/solaredge/bat.py b/packages/modules/devices/solaredge/solaredge/bat.py index b77fe91e82..e61897c877 100644 --- a/packages/modules/devices/solaredge/solaredge/bat.py +++ b/packages/modules/devices/solaredge/solaredge/bat.py @@ -175,7 +175,7 @@ def set_power_limit(self, power_limit: Optional[int]) -> None: # Remote Control and Charge Mode already active. charge_limit = int(values["RemoteControlChargeLimit"]) if charge_limit not in range(int(abs(power_limit)) - 10, int(abs(power_limit)) + 10): - # Send Limit only if difference is more than 10W, needed with more than 1 battery. + # Send Limit only if difference is more than 10W. values_to_write = { "RemoteControlChargeLimit": int(min(abs(power_limit), MAX_CHARGEDISCHARGE_LIMIT)) }