conson-xp 2.0.1__tar.gz → 2.0.3__tar.gz

{conson_xp-2.0.1 → conson_xp-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 2.0.1
+Version: 2.0.3
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License

{conson_xp-2.0.1 → conson_xp-2.0.3}/pyproject.toml

@@ -22,7 +22,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "2.0.1"
+version = "2.0.3"
 
 [project.license]
 file = "LICENSE"

{conson_xp-2.0.1 → conson_xp-2.0.3}/src/xp/__init__.py

@@ -4,7 +4,7 @@ XP CLI tool for remote console bus operations.
 conson-xp package.
 """
 
-__version__ = "2.0.1"
+__version__ = "2.0.3"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-2.0.1 → conson_xp-2.0.3}/src/xp/models/homekit/homekit_config.py

@@ -66,6 +66,10 @@ class HomekitAccessoryConfig(BaseModel):
         on_action: on code for the accessory.
         off_action: off code for the accessory.
         toggle_action: Optional toggle action code for the accessory.
+        dimup_action: Optional dim up action code for the dimmable accessory.
+        dimdown_action: Optional dim down action code for the dimmable accessory.
+        levelup_action: Optional level up action code for the dimmable accessory.
+        leveldown_action: Optional level down action code for the dimmable accessory.
         hap_accessory: Optional HAP accessory identifier.
     """
 
@@ -78,6 +82,10 @@ class HomekitAccessoryConfig(BaseModel):
     on_action: str
     off_action: str
     toggle_action: Optional[str] = None
+    dimup_action: Optional[str] = None
+    dimdown_action: Optional[str] = None
+    levelup_action: Optional[str] = None
+    leveldown_action: Optional[str] = None
     hap_accessory: Optional[int] = None
 
 

{conson_xp-2.0.1 → conson_xp-2.0.3}/src/xp/services/actiontable/actiontable_serializer.py

@@ -65,8 +65,8 @@ class ActionTableSerializer(ActionTableSerializerProtocol):
             link_number = de_bcd(data[i + 1])
             module_input = de_bcd(data[i + 2])
 
-            # Extract output and command from byte 3
-            module_output = lower3(data[i + 3])
+            # Extract output (0-indexed in wire format, convert to 1-indexed) and command
+            module_output = lower3(data[i + 3]) + 1
             command_raw = upper5(data[i + 3])
 
             parameter_raw = byte_to_unsigned(data[i + 4])
@@ -125,8 +125,8 @@ class ActionTableSerializer(ActionTableSerializerProtocol):
             link_byte = to_bcd(entry.link_number)
             input_byte = to_bcd(entry.module_input)
 
-            # Combine output (lower 3 bits) and command (upper 5 bits)
-            output_command_byte = (entry.module_output & 0x07) | (
+            # Combine output (lower 3 bits, 0-indexed) and command (upper 5 bits)
+            output_command_byte = ((entry.module_output - 1) & 0x07) | (
                 (entry.command.value & 0x1F) << 3
             )
 

{conson_xp-2.0.1 → conson_xp-2.0.3}/src/xp/services/conbus/actiontable/actiontable_upload_service.py

@@ -81,6 +81,7 @@ class ActionTableUploadService:
         # Upload state
         self.upload_data_chunks: list[str] = []
         self.current_chunk_index: int = 0
+        self._eof_sent: bool = False
 
         # Set up logging
         self.logger = logging.getLogger(__name__)
@@ -173,7 +174,7 @@ class ActionTableUploadService:
                 )
                 self.current_chunk_index += 1
                 self.on_progress.emit(".")
-            else:
+            elif not self._eof_sent:
                 # All chunks sent, send EOF
                 self.logger.debug("All chunks sent, sending EOF")
                 self.conbus_protocol.send_telegram(
@@ -182,7 +183,13 @@ class ActionTableUploadService:
                     system_function=SystemFunction.EOF,
                     data_value="00",
                 )
+                self.on_progress.emit("END")
+                self.logger.debug("EOF sent, waiting for last ACK")
+                self._eof_sent = True
+            else:
+                self.logger.debug("Last ACK received, closing connection")
                 self.on_finish.emit(True)
+
         elif reply_telegram.system_function == SystemFunction.NAK:
             self.logger.debug("Received NAK during upload")
             self.failed("Upload failed: NAK received")

{conson_xp-2.0.1 → conson_xp-2.0.3}/src/xp/services/term/homekit_accessory_driver.py

@@ -10,9 +10,18 @@ from pyhap.const import CATEGORY_LIGHTBULB, CATEGORY_OUTLET
 
 from xp.models.homekit.homekit_config import HomekitConfig
 
+# Callback type: (accessory_name, is_on, brightness_or_none)
+OnSetCallback = Callable[[str, bool, Optional[int]], None]
+
 
 class XPAccessory(Accessory):
-    """Single accessory wrapping a Conbus output."""
+    """
+    Single accessory wrapping a Conbus output.
+
+    Attributes:
+        logger: Logger instance for this accessory.
+        current_brightness: Current brightness value 0-100.
+    """
 
     def __init__(
         self,
@@ -35,12 +44,19 @@ class XPAccessory(Accessory):
         super().__init__(driver._driver, display_name, aid=aid)
         self._hk_driver = driver
         self._accessory_id = name
+        self._is_dimmable = service_type == "dimminglight"
+        self._char_brightness: Optional[object] = None
+        self._current_brightness: int = 100
         self.logger = logging.getLogger(__name__)
 
-        if service_type == "dimminglight":
+        if self._is_dimmable:
             self.category = CATEGORY_LIGHTBULB
             serv = self.add_preload_service("Lightbulb", chars=["On", "Brightness"])
-            # Note: Brightness setter_callback deferred to future update
+            self._char_brightness = serv.configure_char(
+                "Brightness",
+                setter_callback=self._set_brightness,
+                value=self._current_brightness,
+            )
         elif service_type == "outlet":
             self.category = CATEGORY_OUTLET
             serv = self.add_preload_service("Outlet")
@@ -58,16 +74,36 @@ class XPAccessory(Accessory):
             value: True for on, False for off.
         """
         if self._hk_driver._on_set:
-            self._hk_driver._on_set(self._accessory_id, value)
+            self._hk_driver._on_set(self._accessory_id, value, None)
+
+    def _set_brightness(self, value: int) -> None:
+        """
+        Handle HomeKit set brightness request.
+
+        Args:
+            value: Brightness value 0-100.
+        """
+        if self._hk_driver._on_set:
+            self._hk_driver._on_set(self._accessory_id, True, value)
+        self._current_brightness = value
 
-    def update_state(self, is_on: bool) -> None:
+    def update_state(self, is_on: bool, brightness: Optional[int] = None) -> None:
         """
         Update accessory state from Conbus event.
 
         Args:
             is_on: True if accessory is on, False otherwise.
+            brightness: Optional brightness value 0-100.
         """
         self._char_on.set_value(is_on)
+        if brightness is not None and self._char_brightness:
+            self._char_brightness.set_value(brightness)  # type: ignore[attr-defined]
+            self._current_brightness = brightness
+
+    @property
+    def current_brightness(self) -> int:
+        """Get current brightness value."""
+        return self._current_brightness
 
 
 class HomekitAccessoryDriver:
@@ -84,14 +120,15 @@ class HomekitAccessoryDriver:
         self._homekit_config = homekit_config
         self._driver: Optional[AccessoryDriver] = None
         self._accessories: Dict[str, XPAccessory] = {}
-        self._on_set: Optional[Callable[[str, bool], None]] = None
+        self._on_set: Optional[OnSetCallback] = None
 
-    def set_callback(self, on_set: Callable[[str, bool], None]) -> None:
+    def set_callback(self, on_set: OnSetCallback) -> None:
         """
         Set callback for HomeKit set events.
 
         Args:
-            on_set: Callback(accessory_name, is_on) called when HomeKit app toggles.
+            on_set: Callback(accessory_name, is_on, brightness) called when HomeKit app changes state.
+                    brightness is None for on/off only, or 0-100 for dimming.
         """
         self._on_set = on_set
 
@@ -157,15 +194,34 @@ class HomekitAccessoryDriver:
         except Exception as e:
             self.logger.error(f"Error stopping AccessoryDriver: {e}", exc_info=True)
 
-    def update_state(self, accessory_name: str, is_on: bool) -> None:
+    def update_state(
+        self, accessory_name: str, is_on: bool, brightness: Optional[int] = None
+    ) -> None:
         """
         Update accessory state from Conbus event.
 
         Args:
             accessory_name: Accessory name to update.
             is_on: True if accessory is on, False otherwise.
+            brightness: Optional brightness value 0-100.
         """
-        if acc := self._accessories.get(accessory_name):
-            acc.update_state(is_on)
+        acc = self._accessories.get(accessory_name)
+        if acc:
+            acc.update_state(is_on, brightness)
         else:
             self.logger.warning(f"Unknown accessory name: {accessory_name}")
+
+    def get_brightness(self, accessory_name: str) -> int:
+        """
+        Get current brightness for an accessory.
+
+        Args:
+            accessory_name: Accessory name.
+
+        Returns:
+            Current brightness 0-100, defaults to 100 if not found.
+        """
+        acc = self._accessories.get(accessory_name)
+        if acc:
+            return acc.current_brightness
+        return 100

{conson_xp-2.0.1 → conson_xp-2.0.3}/src/xp/services/term/homekit_service.py

@@ -81,6 +81,9 @@ class HomekitService:
         # Set up HomeKit callback
         self._accessory_driver.set_callback(self._on_homekit_set)
 
+        # Track active level action: (accessory_id, action_type) or None
+        self._active_level_action: Optional[tuple[str, str]] = None
+
         # Connect to protocol signals
         self._connect_signals()
 
@@ -297,23 +300,82 @@ class HomekitService:
         await self._accessory_driver.stop()
         self.cleanup()
 
-    def _on_homekit_set(self, accessory_name: str, is_on: bool) -> None:
+    def _on_homekit_set(
+        self, accessory_name: str, is_on: bool, brightness: Optional[int]
+    ) -> None:
         """
-        Handle HomeKit app toggle request.
+        Handle HomeKit app set request (on/off or brightness).
 
         Args:
             accessory_name: Accessory name from HomeKit.
             is_on: True for on, False for off.
+            brightness: Brightness value 0-100, or None for on/off only.
         """
         config = self._find_accessory_config(accessory_name)
-        if config:
+        if not config:
+            self.logger.warning(f"No config found for accessory: {accessory_name}")
+            return
+
+        if brightness is not None:
+            # Handle brightness change
+            self._handle_brightness_change(accessory_name, config, brightness)
+        else:
+            # Handle on/off toggle
             action = config.on_action if is_on else config.off_action
             self.send_action(action)
             self.on_status_message.emit(
                 f"HomeKit: {accessory_name} {'ON' if is_on else 'OFF'}"
             )
+
+    def _handle_brightness_change(
+        self,
+        accessory_name: str,
+        config: "HomekitAccessoryConfig",
+        target_brightness: int,
+    ) -> None:
+        """
+        Handle brightness change by sending dimup/dimdown actions.
+
+        Calculates delta from current brightness and sends appropriate
+        number of LEVELINC or LEVELDEC commands (step = 10%).
+
+        Args:
+            accessory_name: Accessory name.
+            config: Accessory configuration.
+            target_brightness: Target brightness 0-100.
+        """
+        current = self._accessory_driver.get_brightness(accessory_name)
+        delta = target_brightness - current
+
+        if delta == 0:
+            return
+
+        # Determine action and steps (10% per step)
+        step_size = 10
+        steps = abs(delta) // step_size
+
+        if delta > 0:
+            # Increase brightness
+            if not config.dimup_action:
+                self.logger.warning(f"No dimup_action for {accessory_name}")
+                return
+            action = config.dimup_action
+            direction = "+"
         else:
-            self.logger.warning(f"No config found for accessory: {accessory_name}")
+            # Decrease brightness
+            if not config.dimdown_action:
+                self.logger.warning(f"No dimdown_action for {accessory_name}")
+                return
+            action = config.dimdown_action
+            direction = "-"
+
+        # Send action for each step
+        for _ in range(steps):
+            self.send_action(action)
+
+        self.on_status_message.emit(
+            f"HomeKit: {accessory_name} {current}% → {target_brightness}% ({direction}{steps * step_size}%)"
+        )
 
     def send_action(self, action: str) -> None:
         """
@@ -421,12 +483,15 @@ class HomekitService:
         Returns:
             True if command was sent, False otherwise.
         """
+        config = self._find_accessory_config_by_id(accessory_id)
         state = self._accessory_states.get(accessory_id)
-        if not state:
+        if not config or not state or not config.dimup_action:
+            self.logger.warning(f"No config for accessory {accessory_id}")
             return False
-        # TODO: Implement dimmer control
-        self.on_status_message.emit(f"Dimmer+ {state.accessory_name} (not implemented)")
-        return False
+
+        self.send_action(config.dimup_action)
+        self.on_status_message.emit(f"Dim+ {state.accessory_name}")
+        return True
 
     def decrease_dimmer(self, accessory_id: str) -> bool:
         """
@@ -438,12 +503,103 @@ class HomekitService:
         Returns:
             True if command was sent, False otherwise.
         """
+        config = self._find_accessory_config_by_id(accessory_id)
         state = self._accessory_states.get(accessory_id)
-        if not state:
+        if not config or not state or not config.dimdown_action:
+            self.logger.warning(f"No config for accessory {accessory_id}")
             return False
-        # TODO: Implement dimmer control
-        self.on_status_message.emit(f"Dimmer- {state.accessory_name} (not implemented)")
-        return False
+
+        self.send_action(config.dimdown_action)
+        self.on_status_message.emit(f"Dim- {state.accessory_name}")
+        return True
+
+    def levelup_selected(self, accessory_id: str) -> bool:
+        """
+        Increase level for accessory (toggle Make/Break).
+
+        First press sends Make (M), second press sends Break (B).
+
+        Args:
+            accessory_id: Accessory ID (e.g., "A12_1").
+
+        Returns:
+            True if command was sent, False otherwise.
+        """
+        config = self._find_accessory_config_by_id(accessory_id)
+        state = self._accessory_states.get(accessory_id)
+        if not config or not state or not config.levelup_action:
+            self.logger.warning(f"No config for accessory {accessory_id}")
+            return False
+
+        return self._send_level_action(
+            accessory_id, "levelup", config.levelup_action, state.accessory_name
+        )
+
+    def leveldown_selected(self, accessory_id: str) -> bool:
+        """
+        Decrease level for accessory (toggle Make/Break).
+
+        First press sends Make (M), second press sends Break (B).
+
+        Args:
+            accessory_id: Accessory ID (e.g., "A12_1").
+
+        Returns:
+            True if command was sent, False otherwise.
+        """
+        config = self._find_accessory_config_by_id(accessory_id)
+        state = self._accessory_states.get(accessory_id)
+        if not config or not state or not config.leveldown_action:
+            self.logger.warning(f"No config for accessory {accessory_id}")
+            return False
+
+        return self._send_level_action(
+            accessory_id, "leveldown", config.leveldown_action, state.accessory_name
+        )
+
+    def _send_level_action(
+        self, accessory_id: str, action_type: str, action: str, name: str
+    ) -> bool:
+        """
+        Send level action with Make/Break toggle.
+
+        Args:
+            accessory_id: Accessory ID.
+            action_type: "levelup" or "leveldown".
+            action: Action code (e.g., "E02L13I15").
+            name: Accessory name for status message.
+
+        Returns:
+            True if command was sent.
+        """
+        current = self._active_level_action
+
+        # If same action is active, send Break and clear
+        if current and current[0] == accessory_id and current[1] == action_type:
+            self._conbus_protocol.send_raw_telegram(f"{action}B")
+            self._active_level_action = None
+            direction = "+" if action_type == "levelup" else "-"
+            self.on_status_message.emit(f"Level{direction} {name} [B]")
+            return True
+
+        # If different action is active, send Break for it first
+        if current:
+            old_config = self._find_accessory_config_by_id(current[0])
+            if old_config:
+                old_action = (
+                    old_config.levelup_action
+                    if current[1] == "levelup"
+                    else old_config.leveldown_action
+                )
+                if old_action:
+                    self._conbus_protocol.send_raw_telegram(f"{old_action}B")
+
+        # Send Make for new action
+        self._conbus_protocol.send_raw_telegram(f"{action}M")
+        self._active_level_action = (accessory_id, action_type)
+        direction = "+" if action_type == "levelup" else "-"
+        self.on_status_message.emit(f"Level{direction} {name} [M]")
+        return True
 
     def refresh_all(self) -> None:
         """

{conson_xp-2.0.1 → conson_xp-2.0.3}/src/xp/term/homekit.py

@@ -41,6 +41,8 @@ class HomekitApp(App[None]):
         ("minus", "turn_off_selected", "Off"),
         ("plus", "dim_up", "Dim+"),
         ("quotation_mark", "dim_down", "Dim-"),
+        ("asterisk", "level_up", "Level+"),
+        ("ç", "level_down", "Level-"),
     ]
 
     def __init__(self, homekit_service: HomekitService) -> None:
@@ -106,12 +108,17 @@ class HomekitApp(App[None]):
         - - : Turn OFF
         - + : Dim up
         - " : Dim down
+        - * : Level up
+        - ç : Level down
 
         Args:
             event: Key press event.
         """
         key = event.key
 
+        # Debug: show received key
+        self.homekit_service.on_status_message.emit(f"Key: {key}")
+
         # Selection keys (a-z0-9)
         if len(key) == 1 and (("a" <= key <= "z") or ("0" <= key <= "9")):
             accessory_id = self.homekit_service.select_accessory(key)
@@ -140,6 +147,12 @@ class HomekitApp(App[None]):
         elif key in ("quotation_mark", '"'):
             self.homekit_service.decrease_dimmer(self.selected_accessory_id)
             event.prevent_default()
+        elif key in ("asterisk", "star", "*"):
+            self.homekit_service.levelup_selected(self.selected_accessory_id)
+            event.prevent_default()
+        elif key in ("cedille", "ç"):
+            self.homekit_service.leveldown_selected(self.selected_accessory_id)
+            event.prevent_default()
 
     def _select_row(self, action_key: str) -> None:
         """
@@ -243,6 +256,16 @@ class HomekitApp(App[None]):
         if self.selected_accessory_id:
             self.homekit_service.decrease_dimmer(self.selected_accessory_id)
 
+    def action_level_up(self) -> None:
+        """Increase level on selected accessory."""
+        if self.selected_accessory_id:
+            self.homekit_service.levelup_selected(self.selected_accessory_id)
+
+    def action_level_down(self) -> None:
+        """Decrease level on selected accessory."""
+        if self.selected_accessory_id:
+            self.homekit_service.leveldown_selected(self.selected_accessory_id)
+
     async def on_unmount(self) -> None:
         """Stop AccessoryDriver and clean up service when app unmounts."""
         await self.homekit_service.stop()

{conson_xp-2.0.1 → conson_xp-2.0.3}/tests/unit/test_services/test_actiontable_serializer.py

@@ -398,7 +398,7 @@ class TestActionTableSerializerPadding:
         assert result[0] == 0x02  # CP20 (value=2) in BCD
         assert result[1] == 0x01  # link_number
         assert result[2] == 0x02  # module_input
-        assert result[3] == 0x0B  # output (3) | command (1 << 3)
+        assert result[3] == 0x0A  # output 0-indexed: (3-1) | (ON << 3) = 2 | 8 = 10
         assert result[4] == 0x04  # parameter
 
         # Rest should be padding
@@ -414,3 +414,113 @@ class TestActionTableSerializerPadding:
         # Should still be 480 bytes, all zeros
         assert len(result) == 480
         assert result == b"\x00" * 480
+
+    def test_to_encoded_string_cp20_link4_input0_output1_on(self):
+        """
+        Test encoding CP20 4 0 > 1 ON produces expected BCD string.
+
+        ActionTable: CP20 4 0 > 1 ON;
+        Serialized BCD (first 8 chars): ACAEAAAI
+        """
+        action_table = ActionTable(
+            entries=[
+                ActionTableEntry(
+                    module_type=ModuleTypeCode.CP20,
+                    link_number=4,
+                    module_input=0,
+                    module_output=1,
+                    command=InputActionType.ON,
+                    parameter=TimeParam.NONE,
+                    inverted=False,
+                )
+            ]
+        )
+
+        encoded_string = ActionTableSerializer.to_encoded_string(action_table)
+
+        # First 8 characters (4 bytes in BCD, high-nibble first):
+        # AC = 0x02 (CP20, value=2)
+        # AE = 0x04 (link_number=4)
+        # AA = 0x00 (module_input=0)
+        # AI = 0x08 (output 0-indexed: (1-1) | (ON<<3) = 0 | 8 = 8)
+        assert encoded_string[:8] == "ACAEAAAI"
+
+    def test_from_encoded_string_cp20_link4_input0_output1_on(self):
+        """
+        Test decoding BCD string ACAEAAAI produces expected ActionTable.
+
+        Serialized BCD: ACAEAAAI (+ padding)
+        ActionTable: CP20 4 0 > 1 ON;
+        """
+        # Build full 960-char encoded string (96 entries × 5 bytes × 2 nibbles)
+        # First entry: ACAEAAAI, rest is padding (AA = 0x00)
+        encoded_string = "ACAEAAAI" + "AA" * 476
+
+        action_table = ActionTableSerializer.from_encoded_string(encoded_string)
+
+        # Should have exactly 1 entry (padding entries with NOMOD are filtered out)
+        assert len(action_table.entries) == 1
+
+        entry = action_table.entries[0]
+        assert entry.module_type == ModuleTypeCode.CP20
+        assert entry.link_number == 4
+        assert entry.module_input == 0
+        assert entry.module_output == 1  # 0-indexed in wire format, converted to 1
+        assert entry.command == InputActionType.ON
+        assert entry.parameter == TimeParam.NONE
+        assert entry.inverted is False
+
+    def test_to_encoded_string_cp20_link13_input9_output1_levelinc(self):
+        """
+        Test encoding CP20 13 9 > 1 LEVELINC produces expected BCD string.
+
+        ActionTable: CP20 13 9 > 1 LEVELINC;
+        Serialized BCD (first 8 chars): ACBDAJEI
+        """
+        action_table = ActionTable(
+            entries=[
+                ActionTableEntry(
+                    module_type=ModuleTypeCode.CP20,
+                    link_number=13,
+                    module_input=9,
+                    module_output=1,
+                    command=InputActionType.LEVELINC,
+                    parameter=TimeParam.NONE,
+                    inverted=False,
+                )
+            ]
+        )
+
+        encoded_string = ActionTableSerializer.to_encoded_string(action_table)
+
+        # First 8 characters (4 bytes in BCD, high-nibble first):
+        # AC = 0x02 (CP20, value=2)
+        # BD = 0x13 (link_number=13 in BCD)
+        # AJ = 0x09 (module_input=9)
+        # EI = 0x48 (output 0-indexed: (1-1) | (LEVELINC<<3) = 0 | 72 = 0x48)
+        assert encoded_string[:8] == "ACBDAJEI"
+
+    def test_from_encoded_string_cp20_link13_input9_output1_levelinc(self):
+        """
+        Test decoding BCD string ACBDAJEIAA produces expected ActionTable.
+
+        Serialized BCD: ACBDAJEIAA (+ padding)
+        ActionTable: CP20 13 9 > 1 LEVELINC;
+        """
+        # Build full 960-char encoded string (96 entries × 5 bytes × 2 nibbles)
+        # First entry: ACBDAJEIAA, rest is padding (AA = 0x00)
+        encoded_string = "ACBDAJEIAA" + "AA" * 475
+
+        action_table = ActionTableSerializer.from_encoded_string(encoded_string)
+
+        # Should have exactly 1 entry (padding entries with NOMOD are filtered out)
+        assert len(action_table.entries) == 1
+
+        entry = action_table.entries[0]
+        assert entry.module_type == ModuleTypeCode.CP20
+        assert entry.link_number == 13
+        assert entry.module_input == 9
+        assert entry.module_output == 1  # 0-indexed in wire format, converted to 1
+        assert entry.command == InputActionType.LEVELINC
+        assert entry.parameter == TimeParam.NONE
+        assert entry.inverted is False

{conson_xp-2.0.1 → conson_xp-2.0.3}/tests/unit/test_services/test_actiontable_upload_service.py

@@ -408,6 +408,7 @@ class TestActionTableUploadChunkPrefix:
         mock_reply = Mock()
         mock_reply.system_function = SystemFunction.ACK
 
+        # First ACK after all chunks sent triggers EOF
         service._handle_upload_response(mock_reply)
 
         # Should send EOF
@@ -418,6 +419,9 @@ class TestActionTableUploadChunkPrefix:
             data_value="00",
         )
 
+        # Second ACK (after EOF) triggers finish signal
+        service._handle_upload_response(mock_reply)
+
         # Should call finish signal with True
         mock_finish.assert_called_once_with(True)
 
@@ -580,11 +584,11 @@ class TestActionTableUploadFullSequence:
         # Simulate connection made
         service.connection_made()
 
-        # Simulate ACK responses for each chunk + final ACK to trigger EOF
+        # Simulate ACK responses for each chunk + ACK to trigger EOF + ACK after EOF
         mock_ack = Mock()
         mock_ack.system_function = SystemFunction.ACK
 
-        for _ in range(16):  # 15 chunks + 1 final ACK to trigger EOF
+        for _ in range(17):  # 15 chunks + 1 ACK to trigger EOF + 1 ACK after EOF
             service._handle_upload_response(mock_ack)
 
         # Verify: Exactly 17 telegrams sent (1 UPLOAD_ACTIONTABLE + 15 ACTIONTABLE + 1 EOF)