boneIO 1.2.0.dev14__py3-none-any.whl → 1.2.0.dev17__py3-none-any.whl

boneio/components/cover/cover.py

@@ -171,6 +171,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._position = position
         self._initial_position = None
         self._current_operation = IDLE
+        self._last_operation = CLOSING
         _LOGGER.debug(
             "BaseCover %s initialized: open_time=%dms, close_time=%dms, initial_position=%d%%",
             id, self._open_time, self._close_time, position
@@ -207,6 +208,8 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             # Send relay states to WebSocket (not MQTT - that's handled by output_type check)
             asyncio.create_task(self._open_relay.async_send_state())
             asyncio.create_task(self._close_relay.async_send_state())
+            if self._current_operation in (OPENING, CLOSING):
+                self._last_operation = self._current_operation
             self._current_operation = IDLE
             if not on_exit:
                 self.send_state(self.state, self.json_position)
@@ -219,6 +222,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             "Opening cover %s from position %d%%. Estimated time: %.1fs (open_time=%dms)",
             self._id, self._position, estimated_time_s, self._open_time
         )
+        self._last_operation = OPENING
         await self.run_cover(current_operation=OPENING)
         self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=OPENING)
 
@@ -230,6 +234,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             "Closing cover %s from position %d%%. Estimated time: %.1fs (close_time=%dms)",
             self._id, self._position, estimated_time_s, self._close_time
         )
+        self._last_operation = CLOSING
         await self.run_cover(current_operation=CLOSING)
         self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=CLOSING)
 
@@ -258,10 +263,12 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
     async def toggle(self) -> None:
         _LOGGER.debug("Toggle cover %s from input.", self._id)
-        if self._position > 50:
-            await self.close()
-        else:
+        if self._current_operation != IDLE:
+            await self.stop()
+        elif self._last_operation == CLOSING:
             await self.open()
+        else:
+            await self.close()
 
     async def toggle_open(self) -> None:
         _LOGGER.debug("Toggle open cover %s from input.", self._id)

boneio/core/config/migrations/v2_transition.py

@@ -32,6 +32,14 @@ def _persist_transition(config_file: str) -> None:
     for line in lines:
         m = transition_re.match(line)
         if m:
+            num_val = float(m.group(2))
+            if num_val == 0:
+                # Remove transition: 0 entirely — not meaningful
+                _LOGGER.info(
+                    "Removing from config file: %s", line.rstrip(),
+                )
+                updated = True
+                continue  # skip this line
             new_line = f"{m.group(1)}{m.group(2)}s\n"
             updated_lines.append(new_line)
             updated = True
@@ -82,13 +90,20 @@ def migrate(doc: dict) -> dict:
                     if "transition" in action_def:
                         val = action_def["transition"]
                         if isinstance(val, (int, float)):
-                            new_val = f"{val}s"
-                            _LOGGER.info(
-                                "Migrating transition: %s -> '%s' in %s action",
-                                val,
-                                new_val,
-                                section_name,
-                            )
-                            action_def["transition"] = new_val
+                            if val == 0:
+                                _LOGGER.info(
+                                    "Removing transition: 0 from %s action (not meaningful)",
+                                    section_name,
+                                )
+                                del action_def["transition"]
+                            else:
+                                new_val = f"{val}s"
+                                _LOGGER.info(
+                                    "Migrating transition: %s -> '%s' in %s action",
+                                    val,
+                                    new_val,
+                                    section_name,
+                                )
+                                action_def["transition"] = new_val
 
     return doc

boneio/core/config/yaml_util.py

@@ -6,7 +6,7 @@ from collections import OrderedDict
 from typing import Any
 
 from cerberus import TypeDefinition, Validator
-from yaml import MarkedYAMLError, SafeLoader, YAMLError, dump, load
+from yaml import MarkedYAMLError, SafeLoader, SafeDumper, YAMLError, dump, load
 
 from boneio.const import OUTPUT
 from boneio.core.utils import TimePeriod
@@ -56,6 +56,15 @@ def clear_config_cache():
     _LOGGER.info("Config cache cleared")
 
 
+class TimePeriodDumper(SafeDumper):
+    """Custom dumper that cleanly serializes TimePeriod objects as strings."""
+    pass
+
+def represent_time_period(dumper, data):
+    return dumper.represent_scalar('tag:yaml.org,2002:str', str(data))
+
+TimePeriodDumper.add_representer(TimePeriod, represent_time_period)
+
 class BoneIOLoader(SafeLoader):
     """Loader which support for include in yaml files."""
 
@@ -518,6 +527,8 @@ class CustomValidator(Validator):
     def _normalize_coerce_positive_time_period(self, value) -> TimePeriod:
         """Validate and transform time period with time unit and integer value."""
         if isinstance(value, int):
+            if value == 0:
+                return TimePeriod(seconds=0)
             raise ConfigurationException(
                 f"Don't know what '{value}' means as it has no time *unit*! Did you mean '{value}s'?"
             )
@@ -876,8 +887,12 @@ def strip_default_values(data: Any, schema: dict | None = None, section: str | N
                                 action_defaults = {
                                     'action_cover': 'TOGGLE',
                                     'action_output': 'TOGGLE',
-                                    'data': {}
+                                    'data': {},
                                 }
+                                # Remove transition if 0 or '0s' — not meaningful
+                                t_val = action_item.get('transition')
+                                if t_val is not None and (t_val == 0 or t_val == 0.0 or str(t_val) in ('0s', '0ms', '0')):
+                                    action_item = {k: v for k, v in action_item.items() if k != 'transition'}
                                 cleaned_action = clean_dict(action_item, action_defaults)
                                 # Only add if action field exists (required)
                                 if 'action' in cleaned_action or cleaned_action:
@@ -1006,7 +1021,7 @@ def update_config_section(config_file: str, section: str, data: dict | list) ->
                 _LOGGER.info(f"Section '{section}' uses !include '{include_filename}', updating {include_file_path}")
                 
                 # Save cleaned data to the included file
-                content = dump(cleaned_data, default_flow_style=False, allow_unicode=True, sort_keys=False)
+                content = dump(cleaned_data, Dumper=TimePeriodDumper, default_flow_style=False, allow_unicode=True, sort_keys=False)
                 with open(include_file_path, 'w', encoding='utf-8') as f:
                     f.write(content)
                     
@@ -1035,7 +1050,7 @@ def update_config_section(config_file: str, section: str, data: dict | list) ->
                         in_section = True
                         section_indent = len(line) - len(line.lstrip())
                         # Add the complete new section (header + data)
-                        section_yaml = dump({section: cleaned_data}, default_flow_style=False, allow_unicode=True, sort_keys=False)
+                        section_yaml = dump({section: cleaned_data}, Dumper=TimePeriodDumper, default_flow_style=False, allow_unicode=True, sort_keys=False)
                         # Add proper indentation if section was indented
                         if section_indent > 0:
                             indented_lines = []
@@ -1065,7 +1080,7 @@ def update_config_section(config_file: str, section: str, data: dict | list) ->
             _LOGGER.info(f"Section '{section}' doesn't exist, adding to config.yaml")
             
             # Append new section to the end of the file
-            section_yaml = dump({section: cleaned_data}, default_flow_style=False, allow_unicode=True, sort_keys=False)
+            section_yaml = dump({section: cleaned_data}, Dumper=TimePeriodDumper, default_flow_style=False, allow_unicode=True, sort_keys=False)
             with open(config_file, 'a', encoding='utf-8') as f:
                 f.write('\n' + section_yaml)
                 

boneio/core/events/bus.py

@@ -97,6 +97,7 @@ class EventBus:
             "output": {},
             "cover": {},
             "modbus_device": {},
+            "modbus_temperature": {},
             "sensor": {},
             "host": {},
             "group": {},

boneio/core/manager/inputs.py

@@ -695,7 +695,12 @@ class InputManager:
         """
         
         if not event.entity_id or not event.click_type:
-            _LOGGER.warning("Entity ID or click type not found in event data")
+            # State-sync events (e.g. from _broadcast_all_input_states after reload)
+            # have click_type=None — this is expected, not an error.
+            _LOGGER.debug(
+                "Ignoring input event without click_type (state sync): entity_id=%s",
+                event.entity_id,
+            )
             return
         # Get the input instance and retrieve actions for this click type
         input_instance = self._inputs.get(event.entity_id)

boneio/core/manager/modbus.py

@@ -10,7 +10,7 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 from boneio.const import ADDRESS, ID, MODEL, NAME, UART, UARTS, UPDATE_INTERVAL
-from boneio.core.utils.timeperiod import TimePeriod
+from boneio.core.utils.timeperiod import TimePeriod, parse_time_to_seconds, parse_time_to_ms
 from boneio.exceptions import ModbusUartException
 
 if TYPE_CHECKING:
@@ -83,10 +83,20 @@ class ModbusManager:
                     f"UART {uart} is not available. Available UARTs: {UARTS}"
                 )
             
+            # Convert TimePeriod values to numeric before passing to client
+            timeout = parse_time_to_seconds(
+                config.pop("timeout", None), default=1.5
+            )
+            inter_device_delay = parse_time_to_ms(
+                config.pop("inter_device_delay", None), default=5
+            ) or 5
+            
             # Initialize Modbus client
             self._modbus = Modbus(
                 uart=UARTS[uart],
                 baudrate=config.pop("baudrate", 9600),
+                timeout=timeout,
+                inter_device_delay=inter_device_delay,
                 **config
             )
             

boneio/core/manager/templates/__init__.py

@@ -93,7 +93,15 @@ class TemplateManager:
         except (ValueError, TypeError, AttributeError):
             return
 
-        for thermostat in self._thermostats.sensor_map.get(sensor_id, []):
+        matched = self._thermostats.sensor_map.get(sensor_id, [])
+        if not matched:
+            _LOGGER.debug(
+                "SensorEvent '%s' (%.1f°C) has no matching thermostat. "
+                "Registered sensor_ids: %s",
+                sensor_id, temperature,
+                list(self._thermostats.sensor_map.keys()),
+            )
+        for thermostat in matched:
             thermostat.update_sensor_temperature(sensor_id, temperature)
 
     def on_input_event(self, input_id: str, event_type: str) -> None:
@@ -260,7 +268,7 @@ class TemplateManager:
                 listener_id=f"template_mgr_{sensor_id}",
             )
 
-        # Re-register for current mappings
+        # Re-register for current mappings (native SensorEvent sources)
         for sensor_id in self._thermostats.sensor_map:
             event_bus.add_event_listener(
                 event_type="sensor",
@@ -268,3 +276,8 @@ class TemplateManager:
                 listener_id=f"template_mgr_{sensor_id}",
                 target=self._on_sensor_event,
             )
+
+        _LOGGER.info(
+            "Registered sensor listeners for thermostat sensor_ids: %s",
+            list(self._thermostats.sensor_map.keys()),
+        )

boneio/core/remote/esphome.py

@@ -351,10 +351,18 @@ class ESPHomeRemoteDevice(RemoteDevice):
                 for cover in self._covers_list:
                     if cover.get("key") == state.key:
                         cover_id = cover.get("id", "")
+                        
+                        # Store last known operation if moving
+                        current_op = getattr(state, 'current_operation', 0)
+                        last_op = self._cover_states.get(cover_id, {}).get("last_known_operation", 2) # Default to CLOSING (2)
+                        if current_op != 0:
+                            last_op = current_op
+                            
                         self._cover_states[cover_id] = {
                             "position": state.position,
                             "tilt": getattr(state, 'tilt', None),
-                            "current_operation": getattr(state, 'current_operation', None),
+                            "current_operation": current_op,
+                            "last_known_operation": last_op,
                         }
                         _LOGGER.debug("Cover '%s' position: %.2f", cover_id, state.position)
                         break
@@ -847,12 +855,40 @@ class ESPHomeRemoteDevice(RemoteDevice):
             elif action_upper == "STOP":
                 self._client.cover_command(cover_key, stop=True)
             elif action_upper == "TOGGLE":
-                # Get current state and toggle
-                current_pos = self._cover_states.get(cover_id, {}).get("position", 0.5)
-                if current_pos > 0.5:
+                # Toggle based on current operation or last known operation
+                state = self._cover_states.get(cover_id, {})
+                current_op = state.get("current_operation", 0) # 0=IDLE, 1=OPENING, 2=CLOSING
+                last_op = state.get("last_known_operation", 2)
+                cover_pos = state.get("position")
+                _LOGGER.debug(
+                    "TOGGLE cover '%s': key=%s, state=%s, current_op=%s, last_op=%s, position=%s, all_states=%s",
+                    cover_id, cover_key, state, current_op, last_op, cover_pos,
+                    {k: v for k, v in self._cover_states.items()},
+                )
+                
+                if current_op != 0: # If moving, stop it
+                    _LOGGER.debug("TOGGLE -> STOP (cover is moving, current_op=%s)", current_op)
+                    self._client.cover_command(cover_key, stop=True)
+                elif last_op == 2: # If last operation was CLOSING, open it
+                    _LOGGER.debug("TOGGLE -> OPEN (last_op=CLOSING)")
+                    self._client.cover_command(cover_key, position=1.0)
+                else: # Otherwise close it
+                    _LOGGER.debug("TOGGLE -> CLOSE (last_op=%s)", last_op)
                     self._client.cover_command(cover_key, position=0.0)
+            elif action_upper == "TOGGLE_OPEN":
+                state = self._cover_states.get(cover_id, {})
+                current_op = state.get("current_operation", 0)
+                if current_op != 0:
+                    self._client.cover_command(cover_key, stop=True)
                 else:
                     self._client.cover_command(cover_key, position=1.0)
+            elif action_upper == "TOGGLE_CLOSE":
+                state = self._cover_states.get(cover_id, {})
+                current_op = state.get("current_operation", 0)
+                if current_op != 0:
+                    self._client.cover_command(cover_key, stop=True)
+                else:
+                    self._client.cover_command(cover_key, position=0.0)
             else:
                 _LOGGER.error("Invalid cover action: %s", action)
                 return False

boneio/modbus/client.py

@@ -103,8 +103,21 @@ class Modbus:
         bytesize: int = 8,
         parity: str = "N",
         timeout: float = 1.5,
+        inter_device_delay: int = 5,
     ) -> None:
-        """Initialize the Modbus hub."""
+        """Initialize the Modbus hub.
+
+        Args:
+            uart: UART configuration dict with RX/TX pins.
+            baudrate: Serial baudrate (default 9600).
+            stopbits: Number of stop bits (default 1).
+            bytesize: Number of data bits (default 8).
+            parity: Parity mode N/E/O (default N).
+            timeout: Response timeout in seconds (default 1.5).
+            inter_device_delay: Delay in ms between transactions (default 5).
+                Helps with star topology wiring where signal reflections
+                on branch stubs need time to settle.
+        """
         rx = uart.get(RX)
         tx = uart.get(TX)
         if not tx or not rx:
@@ -115,15 +128,24 @@ class Modbus:
         self._uart = uart
         self._loop = asyncio.get_event_loop()
         self._lock = asyncio.Lock()
+        # Clamp inter_device_delay to 0-200ms, timeout to 0.1-10s
+        clamped_delay = max(0, min(200, inter_device_delay))
+        if clamped_delay != inter_device_delay:
+            _LOGGER.warning(
+                "inter_device_delay %dms out of range (0-200), clamped to %dms",
+                inter_device_delay, clamped_delay,
+            )
+        self._inter_device_delay = clamped_delay / 1000.0  # ms -> seconds
+        clamped_timeout = max(0.1, min(10.0, timeout))
+        if clamped_timeout != timeout:
+            _LOGGER.warning(
+                "timeout %.2fs out of range (0.1-10), clamped to %.2fs",
+                timeout, clamped_timeout,
+            )
+        timeout = clamped_timeout
         self._executor = ThreadPoolExecutor(max_workers=MAX_WORKERS, thread_name_prefix="modbus_worker")
 
         _LOGGER.debug(f"Creating ModbusSerialClient for port: {self._uart[ID]}")
-        # Calculate inter-character timeout based on baudrate (3.5 characters)
-        # At 9600 baud: 1 char = 11 bits (start + 8 data + parity + stop) = ~1.15ms
-        # 3.5 chars = ~4ms, we use slightly more for safety
-        char_time_ms = (11 * 1000) / baudrate  # Time for 1 character in ms
-        inter_char_timeout = (char_time_ms * 3.5) / 1000  # Convert to seconds
-        
         self._client = ModbusSerialClient(
             port=self._uart[ID],
             framer=FramerType.RTU,
@@ -134,7 +156,10 @@ class Modbus:
             timeout=timeout,
             retries=2,  # Reduced from 3 to speed up detection of offline devices
         )
-        _LOGGER.debug("ModbusSerialClient created successfully with timeout=%.2fs, retries=2", timeout)
+        _LOGGER.debug(
+            "ModbusSerialClient created successfully with timeout=%.2fs, retries=2, inter_device_delay=%dms",
+            timeout, inter_device_delay,
+        )
 
     @property
     def client(self) -> ModbusSerialClient | None:
@@ -341,7 +366,10 @@ class Modbus:
     ):
         """Call async pymodbus."""
         async with self._lock:
-            return await self._loop.run_in_executor(self._executor, self.read_registers_blocking, unit, address, count, method)
+            result = await self._loop.run_in_executor(self._executor, self.read_registers_blocking, unit, address, count, method)
+            if self._inter_device_delay > 0:
+                await asyncio.sleep(self._inter_device_delay)
+            return result
 
     def scan_device_blocking(self, unit: int, address: int = 1, method: str = "input", timeout: float = 0.3) -> bool:
         """Quick scan to check if device exists at address.
@@ -426,4 +454,7 @@ class Modbus:
     async def write_register(self, unit: int | str, address: int, value: int | float):
         """Write register async."""
         async with self._lock:
-            return await self._loop.run_in_executor(self._executor, self.write_register_blocking, unit, address, value)
+            result = await self._loop.run_in_executor(self._executor, self.write_register_blocking, unit, address, value)
+            if self._inter_device_delay > 0:
+                await asyncio.sleep(self._inter_device_delay)
+            return result

boneio/modbus/coordinator.py

@@ -49,7 +49,8 @@ from boneio.modbus.entities.writeable.numeric import (
     ModbusNumericWriteableEntity,
     ModbusNumericWriteableEntityDiscrete,
 )
-from boneio.models.events import ModbusDeviceEvent
+from boneio.models.events import ModbusDeviceEvent, SensorEvent
+from boneio.models.state import SensorState
 
 from .client import VALUE_TYPES, Modbus
 
@@ -686,27 +687,50 @@ class ModbusCoordinator(BasicMqtt, AsyncUpdater, Filter):
     ) -> None:
         """Trigger events for entity updates.
         
+        Emits ModbusDeviceEvent for all entities. Additionally emits
+        SensorEvent for any entity that acts as a sensor, so standard
+        components (like thermostats) can listen to sensor updates natively.
+        
         Args:
             entity: Entity that was updated
-            output: Output dictionary with states
         """
         type_info = self._get_entity_type_info(entity)
         
+        device_state = ModbusDeviceState(
+            id=entity.id,
+            name=entity.name,
+            state=entity.state or 0.0,
+            unit=getattr(entity, 'unit_of_measurement', None),
+            timestamp=entity.last_timestamp,
+            device_group=self.name,
+            coordinator_id=self._id,
+            entity_type=entity.entity_type,
+            **type_info
+        )
+
         self._event_bus.trigger_event(ModbusDeviceEvent(
             entity_id=entity.id,
-            state=ModbusDeviceState(
-                id=entity.id,
-                name=entity.name,
-                state=entity.state or 0.0,
-                unit=getattr(entity, 'unit_of_measurement', None),
-                timestamp=entity.last_timestamp,
-                device_group=self.name,
-                coordinator_id=self._id,
-                entity_type=entity.entity_type,
-                **type_info
-            ),
+            state=device_state,
         ))
 
+        # Also emit dedicated SensorEvent for generic sensor integration 
+        # (thermostats, rules, etc. shouldn't care about transport type)
+        if entity.entity_type in (SENSOR, TEXT_SENSOR):
+            _LOGGER.debug(
+                "Emitting SensorEvent: entity_id='%s', name='%s', state=%s",
+                entity.id, entity.name, entity.state,
+            )
+            self._event_bus.trigger_event(SensorEvent(
+                entity_id=entity.id,
+                state=SensorState(
+                    id=entity.id,
+                    name=entity.name,
+                    state=entity.state or 0.0,
+                    unit=getattr(entity, 'unit_of_measurement', None),
+                    timestamp=entity.last_timestamp,
+                )
+            ))
+
     async def write_register(
         self, 
         value: str | float | int, 

boneio/modbus/devices/sensors/boneio-edge-temp.json

@@ -0,0 +1,50 @@
+{
+    "model": "boneIO Edge Temp and Humidity sensor",
+    "set_base": {
+        "set_address_address": 100,
+        "set_baudrate": {
+            "address": 101,
+            "possible_baudrates": {
+                "2400": 0,
+                "4800": 1,
+                "9600": 2,
+                "19200": 3
+            }
+        }
+    },
+    "registers_base": [
+        {
+            "base": 0,
+            "length": 2,
+            "register_type": "holding",
+            "registers": [
+                {
+                    "name": "Humidity",
+                    "address": 0,
+                    "unit_of_measurement": "%",
+                    "state_class": "measurement",
+                    "device_class": "humidity",
+                    "value_type": "S_WORD",
+                    "filters": [
+                        {
+                            "multiply": 0.1
+                        }
+                    ]
+                },
+                {
+                    "name": "Temperature",
+                    "address": 1,
+                    "unit_of_measurement": "°C",
+                    "state_class": "measurement",
+                    "device_class": "temperature",
+                    "value_type": "S_WORD",
+                    "filters": [
+                        {
+                            "multiply": 0.1
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

boneio/modbus/devices/sensors/gdfs.json

@@ -0,0 +1,35 @@
+{
+  "model": "WIND_SPEED_GD_FS",
+  "registers_base": [
+    {
+      "base": 0,
+      "length": 1,
+      "register_type": "holding",
+      "registers": [
+        {
+          "name": "wind_speed",
+          "address": 0,
+          "unit_of_measurement": "m/s",
+          "state_class": "measurement",
+          "value_type": "U_WORD",
+          "device_class": "speed"
+        }
+      ]
+    }
+  ],
+  "set_base": {
+    "set_address_address": 10,
+    "set_baudrate": {
+      "address": 100,
+      "possible_baudrates": {
+        "2400": 0,
+        "4800": 1,
+        "9600": 2,
+        "19200": 3,
+        "38400": 4,
+        "57600": 5,
+        "115200": 6
+      }
+    }
+  }
+}

boneio/modbus/devices/sensors/gdfx.json

@@ -0,0 +1,41 @@
+{
+  "model": "WIND_DIRECTION_GD_FX",
+  "registers_base": [
+    {
+      "base": 0,
+      "length": 2,
+      "register_type": "holding",
+      "registers": [
+        {
+          "name": "wind_direction_gear",
+          "address": 0,
+          "unit_of_measurement": "sector",
+          "state_class": "measurement",
+          "value_type": "U_WORD"
+        },
+        {
+          "name": "wind_direction_degree",
+          "address": 1,
+          "unit_of_measurement": "°",
+          "state_class": "measurement",
+          "value_type": "U_WORD"
+        }
+      ]
+    }
+  ],
+  "set_base": {
+    "set_address_address": 10,
+    "set_baudrate": {
+      "address": 100,
+      "possible_baudrates": {
+        "2400": 0,
+        "4800": 1,
+        "9600": 2,
+        "19200": 3,
+        "38400": 4,
+        "57600": 5,
+        "115200": 6
+      }
+    }
+  }
+}

boneio/schema/actions.yaml

@@ -166,6 +166,8 @@ schema:
     type: timeperiod
     coerce: positive_time_period
     required: False
+    forbidden_if:
+      action: ['output', 'cover', 'mqtt', 'output_over_mqtt', 'cover_over_mqtt', 'remote_cover']
     meta:
       label: Transition Time
       description: "Time to transition to the new state. Only for ESPHome/WLED lights. Example: 500ms, 1s"

boneio/schema/schema.yaml

@@ -291,6 +291,16 @@ modbus:
       type: string
       allowed: ['N', 'E', 'O']
       default: 'N'
+    timeout:
+      coerce: timeperiod
+      default: 1500ms
+      meta:
+        label: Response timeout. Increase for slow devices or long cables.
+    inter_device_delay:
+      coerce: timeperiod
+      default: 5ms
+      meta:
+        label: Delay between Modbus transactions. Helps with star topology wiring where signal reflections need time to settle. Recommended 5-50ms for star, 0 for daisy-chain.
 
 modbus_devices:
   type: list
@@ -340,6 +350,10 @@ modbus_devices:
           [
             'cwt',
             'dts1964_3f',
+            'dyp-a12-ultrasonic',
+            'gdfs',
+            'gdfx',
+            'boneio-edge-temp',
             'liquid-sensor',
             'orno-or-we-517',
             'pt100',

boneio/version.py

@@ -1,2 +1,2 @@
 # flake8: noqa
-__version__ = "1.2.0dev14"
+__version__ = "1.2.0dev17"