Multiple slaves in one device

custom_components/protocol_wizard/config_flow.py

@@ -77,6 +77,9 @@ async def async_step_user(self, user_input: dict[str, Any] | None = None) -> Flo
 
         if user_input is not None:
             self._protocol = user_input.get(CONF_PROTOCOL, CONF_PROTOCOL_MODBUS)
+            unique_id = f"{DOMAIN}_{user_input.get('device_id', 'default')}_{self._protocol}"
+            await self.async_set_unique_id(unique_id)
+            self._abort_if_unique_id_configured()
 
             if self._protocol == CONF_PROTOCOL_MODBUS:
                 return await self.async_step_modbus_common()

custom_components/protocol_wizard/const.py

@@ -50,6 +50,7 @@
 CONF_PROTOCOL_KNX = "knx"
 CONF_PROTOCOL = "protocol"
 CONF_IP = "IP"
+CONF_SLAVES = "slaves"
 
 # Defaults
 DEFAULT_SLAVE_ID = 1

custom_components/protocol_wizard/entity_base.py

@@ -26,6 +26,7 @@
     CONF_PROTOCOL_MQTT,
     CONF_PROTOCOL_BACNET,
     CONF_PROTOCOL,
+    CONF_SLAVES,
 )
 from .protocols.base import BaseProtocolCoordinator
 
@@ -187,10 +188,40 @@ def _unique_id(self, entity_config: dict) -> str:
     async def sync_entities(self) -> None:
         """Create, update, and remove entities based on current config."""
         config_key = self._get_entities_config_key()
-        current_configs = self.entry.options.get(config_key, [])
+
+        # For Modbus, check if we have the new CONF_SLAVES structure
+        protocol = self.entry.data.get(CONF_PROTOCOL, CONF_PROTOCOL_MODBUS)
+        if protocol == CONF_PROTOCOL_MODBUS:
+            slaves = self.entry.options.get(CONF_SLAVES, [])
+            if slaves:
+                # Multi-slave mode: get entities from coordinator's slave
+                # The coordinator has slave_id and slave_index attributes set
+                if hasattr(self.coordinator, 'slave_index'):
+                    slave_index = self.coordinator.slave_index
+                    if slave_index < len(slaves):
+                        current_configs = slaves[slave_index].get('registers', [])
+                        _LOGGER.debug("Reading entities from slave %d (index %d): %d entities",
+                                     self.coordinator.slave_id, slave_index, len(current_configs))
+                    else:
+                        _LOGGER.warning("Slave index %d out of range (total slaves: %d)",
+                                       slave_index, len(slaves))
+                        current_configs = []
+                else:
+                    # Single slave mode (backward compatibility)
+                    current_configs = slaves[0].get('registers', [])
+                    _LOGGER.debug("Reading entities from single slave: %d entities", len(current_configs))
+            else:
+                # Old structure fallback
+                current_configs = self.entry.options.get(config_key, [])
+                _LOGGER.debug("Reading entities from old structure (%s): %d entities",
+                             config_key, len(current_configs))
+        else:
+            # Non-Modbus protocols use the config key directly
+            current_configs = self.entry.options.get(config_key, [])
+
         desired_ids = set()
         new_entities: list[Entity] = []
-        
+
         for config in current_configs:
             if not self._should_create_entity(config):
                 continue

custom_components/protocol_wizard/number.py

@@ -55,9 +55,12 @@ async def async_setup_entry(
 ):
     """Set up number entities for any protocol."""
     coordinator = hass.data[DOMAIN]["coordinators"][entry.entry_id]
-
+
+    # Use coordinator_key if available (multi-slave), otherwise use entry.entry_id
+    device_identifier = getattr(coordinator, 'coordinator_key', entry.entry_id)
+
     device_info = DeviceInfo(
-        identifiers={(DOMAIN, entry.entry_id)},
+        identifiers={(DOMAIN, device_identifier)},
         name=entry.title or f"{coordinator.protocol_name.title()} Device",
         manufacturer=coordinator.protocol_name.title(),
         model="Protocol Wizard",