boneio 1.5.0.dev2__tar.gz → 1.5.0.dev4__tar.gz

{boneio-1.5.0.dev2/boneio.egg-info → boneio-1.5.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.5.0.dev2
+Version: 1.5.0.dev4
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.5.0.dev2 → boneio-1.5.0.dev4}/boneio/components/cover/cover.py

@@ -386,8 +386,8 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             **json_position,
         )
         self._event_bus.trigger_event(CoverEvent(entity_id=self.id, state=event))
-        self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=state)
-        self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload=json.dumps(json_position))
+        self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=state, retain=True)
+        self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload=json.dumps(json_position), retain=True)
 
     @property
     def saved_position(self) -> SavedPositionDict:

{boneio-1.5.0.dev2 → boneio-1.5.0.dev4}/boneio/components/input/detectors.py

@@ -109,6 +109,7 @@ class MultiClickDetector:
         self._pin = pin
         self._max_long_press_seconds = max_long_press_seconds
         self._state = ClickState()
+        self._boot_press_suppressed = False  # Set by GpioManager._seed_initial_states
         
         # Pre-compute which click types should be delayed in exclusive mode
         # based on enabled sequences
@@ -491,6 +492,21 @@ class MultiClickDetector:
                 )
                 return
 
+            # Boot-press suppression: if GpioManager detected this pin was
+            # LOW at startup, the first FALLING_EDGE is a phantom boot event.
+            # Record the timestamp (for debounce) but do NOT schedule timers.
+            if self._boot_press_suppressed:
+                _LOGGER.info(
+                    "Suppressing phantom boot press on %s (%s) — recording timestamp only",
+                    self._name,
+                    self._pin,
+                )
+                self._state.last_press_ts = timestamp_s
+                self._state.last_press_loop_ts = None
+                self._state.last_release_ts = None
+                self._boot_press_suppressed = False
+                return
+
             _LOGGER.debug("PRESSED: %s (%s)", self._name, self._pin)
             self._state.last_press_ts = timestamp_s
             self._state.last_press_loop_ts = self._loop.time()  # Store loop time for duration calc
@@ -552,6 +568,35 @@ class MultiClickDetector:
 
             press_duration_ms = (timestamp_s - self._state.last_press_ts) * 1000 if self._state.last_press_ts else 0
             _LOGGER.debug("RELEASED: %s (%s) after %.1f ms", self._name, self._pin, press_duration_ms)
+
+            # Guard: stale release from phantom press at boot.
+            # If time since press exceeds max_long_press_seconds, the press
+            # was a startup artifact (GPIO settling at boot), not a real user
+            # action.  Reset the detector so the next real press is accepted.
+            if self._state.last_press_ts and press_duration_ms > self._max_long_press_seconds * 1000:
+                _LOGGER.warning(
+                    "Stale release on %s (%s): %.1fs since press exceeds max %.0fs. "
+                    "Likely phantom press from boot. Resetting detector.",
+                    self._name,
+                    self._pin,
+                    press_duration_ms / 1000,
+                    self._max_long_press_seconds,
+                )
+                self._state.last_press_ts = None
+                self._state.last_press_loop_ts = None
+                self._state.last_release_ts = timestamp_s
+                self._state.click_count = 0
+                if self._state.long_press_timer:
+                    self._state.long_press_timer.cancel()
+                    self._state.long_press_timer = None
+                    self._state.long_press_scheduled_loop_ts = None
+                if self._state.long_hold_periodic_timer:
+                    self._state.long_hold_periodic_timer.cancel()
+                    self._state.long_hold_periodic_timer = None
+                self._state.executed_long_actions = set()
+                self._state.last_repeat_times = {}
+                return
+
             self._state.last_release_ts = timestamp_s
             
             _LOGGER.debug(

{boneio-1.5.0.dev2 → boneio-1.5.0.dev4}/boneio/components/irrigation/controller.py

@@ -419,6 +419,12 @@ class IrrigationController:
         )
 
     async def shutdown(self) -> None:
+        """Stop the active irrigation cycle without killing schedule tasks.
+
+        This method is safe to call from within a schedule task — it does NOT
+        cancel schedule loops.  Use :meth:`full_stop` to tear down the
+        controller completely (including schedule tasks).
+        """
         _LOGGER.debug(
             "Irrigation %s shutdown called (state=%s, active_zone=%s). Caller: %s",
             self.id,
@@ -426,7 +432,6 @@ class IrrigationController:
             self._active_zone_idx,
             "".join(traceback.format_stack(limit=5)),
         )
-        self.stop_schedules()
         self._cancel_pause_timer()
         await self._stop_current_zone()
         await self._handle_pump_stop_sequence()
@@ -437,6 +442,16 @@ class IrrigationController:
         self._single_zone_target_idx = None
         await self.publish_all_states()
 
+    async def full_stop(self) -> None:
+        """Fully stop the controller including schedule tasks.
+
+        Should only be called by the IrrigationManager when stopping
+        or reloading controllers — never from within a schedule task.
+        """
+        _LOGGER.info("Irrigation %s full_stop: stopping schedules and active cycle", self.id)
+        self.stop_schedules()
+        await self.shutdown()
+
     async def pause(self) -> None:
         if self._state != ControllerState.RUNNING or self._active_zone_idx is None:
             return

{boneio-1.5.0.dev2 → boneio-1.5.0.dev4}/boneio/core/config/schema_converter.py

@@ -271,7 +271,31 @@ def main():
     # Load the schema
     with open(schema_file) as f:
         schema = yaml.load(f, Loader=BoneIOLoader)
-    
+
+    # Dynamically inject modbus device models into the schema.
+    # NOTE: This is a standalone copy of the logic from yaml_util.py.
+    # We cannot import yaml_util here because it pulls in the full boneIO
+    # dependency graph (cerberus, pymodbus, smbus2 …) which is NOT installed
+    # in the CI environment that runs this converter script.
+    devices_dir = os.path.normpath(
+        os.path.join(script_dir, "..", "..", "modbus", "devices")
+    )
+    models: list[str] = []
+    if os.path.isdir(devices_dir):
+        for root, dirs, files in os.walk(devices_dir):
+            dirs[:] = [d for d in dirs if d != "__pycache__"]
+            for fname in files:
+                if fname.endswith(".json"):
+                    models.append(fname[:-5])
+    models.sort()
+
+    try:
+        model_field = schema["modbus_devices"]["schema"]["schema"]["model"]
+        model_field["allowed"] = models
+        print(f"Injected {len(models)} modbus models into schema")
+    except (KeyError, TypeError):
+        print("WARNING: Could not inject modbus models into schema")
+
     # Convert and save the main schema
     json_schema = convert_cerberus_to_json_schema(schema)
     main_schema_file = os.path.join(output_dir, "config.schema.json")

{boneio-1.5.0.dev2 → boneio-1.5.0.dev4}/boneio/core/config/yaml_util.py

@@ -26,12 +26,39 @@ _SCHEMA_CACHE = None
 _BOARD_CONFIG_CACHE = {}
 
 
+def _get_modbus_device_models() -> list[str]:
+    """Scan modbus/devices/ directory and return filenames as model keys.
+
+    Only does os.walk (no JSON parsing) — <1ms even on BeagleBone.
+    """
+    devices_dir = os.path.normpath(os.path.join(os.path.dirname(__file__), "../../modbus/devices"))
+    models = []
+    if os.path.isdir(devices_dir):
+        for root, dirs, files in os.walk(devices_dir):
+            dirs[:] = [d for d in dirs if d != "__pycache__"]
+            for fname in files:
+                if fname.endswith(".json"):
+                    models.append(fname[:-5])
+    return sorted(models)
+
+
+def _inject_modbus_models(schema: dict) -> None:
+    """Dynamically set allowed modbus model values from device files."""
+    try:
+        model_field = schema["modbus_devices"]["schema"]["schema"]["model"]
+        model_field["allowed"] = _get_modbus_device_models()
+        _LOGGER.debug("Injected %d modbus models into schema", len(model_field["allowed"]))
+    except (KeyError, TypeError):
+        _LOGGER.warning("Could not inject modbus models into schema")
+
+
 def _get_schema():
     """Get schema from cache or load it if not cached."""
     global _SCHEMA_CACHE
     if _SCHEMA_CACHE is None:
         _LOGGER.debug("Loading schema from file (first time)")
         _SCHEMA_CACHE = load_yaml_file(schema_file)
+        _inject_modbus_models(_SCHEMA_CACHE)
     return _SCHEMA_CACHE
 
 
@@ -653,29 +680,14 @@ class CustomValidator(Validator):
             raise ValueError(f"Could not parse power value: {value}")
         num = float(match.group(1))
         unit = match.group(2) or "w"
-        if unit in ("w", ""):
+        if unit in ("w", "", "wh"):
             multiplier = 1.0
-        elif unit == "kw":
-            multiplier = 1000.0
-        elif unit == "mw":
-            multiplier = 1_000_000.0
-        elif unit == "gw":
-            multiplier = 1_000_000_000.0
-        elif unit == "mw":
-            multiplier = 1_000_000.0
-        elif unit == "kwh":
-            # 1 kWh = 1000 W (for 1h). For config, treat as 1000W average.
+        elif unit in ("kw", "kwh"):
             multiplier = 1000.0
-        elif unit == "mwh":
+        elif unit in ("mw", "mwh"):
             multiplier = 1_000_000.0
-        elif unit == "gwh":
+        elif unit in ("gw", "gwh"):
             multiplier = 1_000_000_000.0
-        elif unit == "mw":
-            multiplier = 1_000_000.0
-        elif unit == "wh":
-            multiplier = 1.0
-        elif unit == "mw" or unit == "mw" or unit == "mw" or unit == "mw" or unit == "mw" or unit == "mw":
-            multiplier = 1_000_000.0
         else:
             _LOGGER.warning(f"Unknown unit for power value: {unit}")
             raise ValueError(f"Unknown unit for power value: {unit}")

{boneio-1.5.0.dev2 → boneio-1.5.0.dev4}/boneio/core/manager/irrigation.py

@@ -226,7 +226,7 @@ class IrrigationManager:
         self._subscribed_topics.clear()
 
         for ctrl in self._controllers.values():
-            await ctrl.shutdown()
+            await ctrl.full_stop()
 
     async def reload_irrigation(self) -> None:
         """Reload irrigation configuration from file.
@@ -256,7 +256,7 @@ class IrrigationManager:
             ctrl = self._controllers[ctrl_id]
             _LOGGER.info("Removing irrigation controller '%s'", ctrl_id)
             ctrl.stop_schedules()
-            await ctrl.shutdown()
+            await ctrl.full_stop()
             # Remove HA discovery for this controller
             self._remove_discovery(ctrl)
             del self._controllers[ctrl_id]
@@ -271,7 +271,7 @@ class IrrigationManager:
             if ctrl_id in self._controllers:
                 old_ctrl = self._controllers[ctrl_id]
                 old_ctrl.stop_schedules()
-                await old_ctrl.shutdown()
+                await old_ctrl.full_stop()
                 del self._controllers[ctrl_id]
 
             # Build new controller

{boneio-1.5.0.dev2 → boneio-1.5.0.dev4}/boneio/core/manager/manager.py

@@ -1692,7 +1692,9 @@ class Manager:
     async def reconnect_callback(self) -> None:
         """Function to invoke when connection to MQTT is (re-)established.
 
-        Sends online status to MQTT and starts template MQTT subscriptions.
+        Sends online status to MQTT, resends all entity states with retain
+        so that Home Assistant immediately knows device positions after a
+        broker restart, and starts template MQTT subscriptions.
 
         IMPORTANT: This is called on every MQTT reconnect, not just the first
         connection.  Schedule tasks must NOT be restarted here — they are
@@ -1708,10 +1710,41 @@ class Manager:
         # Immediately refresh OLED MQTT status (event-driven, no polling delay)
         self.display.notify_mqtt_state_changed()
 
+        # Resend all entity states with retain so HA has correct state
+        # after a broker restart (retained messages may have been lost).
+        _LOGGER.info("Resending all entity states after MQTT reconnect.")
+        await self._resend_all_states()
+
         # Start template entities (subscribe to MQTT command topics)
         await self.templates.start()
         await self.irrigation.reconnect()
 
+    async def _resend_all_states(self) -> None:
+        """Resend current state of all entities via MQTT with retain.
+
+        Called on MQTT reconnect to ensure the broker has up-to-date
+        retained messages after a broker restart.  Each entity's
+        ``send_state`` / ``async_send_state`` already publishes with
+        ``retain=True``, so calling them here refreshes the broker's
+        retained store.
+        """
+        # Resend output states
+        for output in self.outputs.get_all_outputs().values():
+            try:
+                if output.output_type not in ("cover", "none"):
+                    await output.async_send_state()
+            except Exception as e:
+                _LOGGER.debug("Error resending output state %s: %s", output.id, e)
+
+        # Resend cover states (send_state now uses retain=True)
+        self.covers._broadcast_all_states()
+
+        _LOGGER.info(
+            "Resent states: %d outputs, %d covers.",
+            len([o for o in self.outputs.get_all_outputs().values() if o.output_type not in ("cover", "none")]),
+            len(self.covers.get_all_covers()),
+        )
+
     async def receive_message(self, topic: str, message: str) -> None:
         """Callback for receiving MQTT messages.
 

{boneio-1.5.0.dev2 → boneio-1.5.0.dev4}/boneio/hardware/gpio/input/manager.py

@@ -302,6 +302,58 @@ class GpioManager:
                     _LOGGER.error("Error in on-start callback: %s", e)
             self._on_start_callbacks.clear()
 
+        # Seed detectors with current GPIO state to prevent phantom events
+        # at boot.  Must run after on-start callbacks so detectors are ready.
+        self._seed_initial_states()
+
+    def _seed_initial_states(self) -> None:
+        """Read current GPIO states and seed detectors to prevent phantom presses.
+
+        At boot, some GPIO pins may already be LOW (e.g. button circuits pulling
+        down through pull-up resistors).  gpiod generates a FALLING_EDGE for
+        this initial state, which the detector interprets as a real button
+        press — scheduling a long press timer that fires 400ms later and
+        triggers an action.
+
+        By setting ``_boot_press_suppressed`` on the detector, the first
+        FALLING_EDGE records the kernel timestamp (for debounce) but does
+        NOT schedule the long press timer.  The subsequent RISING_EDGE
+        (when the user actually presses) is caught by the stale-release
+        guard and handled correctly.
+        """
+        from boneio.components.input.detectors import MultiClickDetector
+
+        seeded = 0
+        for chip, request in self._requests.items():
+            for (c, line), detector in self._detectors.items():
+                if c != chip:
+                    continue
+                if not isinstance(detector, MultiClickDetector):
+                    continue
+                try:
+                    values = request.get_values([line])
+                    pin_is_low = not bool(values[0])
+                except Exception as exc:
+                    _LOGGER.debug(
+                        "Could not read initial state for chip%d/line%d: %s",
+                        chip, line, exc,
+                    )
+                    continue
+
+                if pin_is_low:
+                    alias = self._aliases.get((chip, line), f"chip{chip}/line{line}")
+                    _LOGGER.info(
+                        "GPIO %s is LOW at startup — arming boot press suppression",
+                        alias,
+                    )
+                    detector._boot_press_suppressed = True
+                    seeded += 1
+
+        if seeded:
+            _LOGGER.info(
+                "Armed boot press suppression on %d GPIO detector(s)", seeded
+            )
+
     def _handle_gpiod_events(self, chip: int, request: gpiod.LineRequest) -> None:
         """Handle GPIO events from libgpiod.
 

{boneio-1.5.0.dev2 → boneio-1.5.0.dev4}/boneio/modbus/client.py

@@ -578,3 +578,103 @@ class Modbus:
             if self._inter_device_delay > 0:
                 await asyncio.sleep(self._inter_device_delay)
             return result
+
+    def write_registers_blocking(self, unit: int | str, address: int, values: list[int]):
+        """Write multiple registers blocking (synchronous) - FC16.
+
+        Sends a Modbus FC16 (Write Multiple Registers) request to write
+        a list of 16-bit values starting at the given register address.
+
+        Args:
+            unit: Device address (1-247).
+            address: Starting register address.
+            values: List of 16-bit integer values to write.
+
+        Returns:
+            Pymodbus response object on success, None on failure.
+        """
+        start_time = time.perf_counter()
+        result = None
+        try:
+            connected = self._pymodbus_connect()
+            if not connected:
+                _LOGGER.error("Can't connect to Modbus.")
+                return None
+
+            _LOGGER.debug(
+                "Writing %d registers starting at %s with values %s to device %s (FC16).",
+                len(values),
+                address,
+                values,
+                unit,
+            )
+
+            assert self._client is not None
+            result = self._client.write_registers(
+                address=address, values=values, device_id=int(unit)
+            )
+
+            if isinstance(result, ExceptionResponse):
+                _LOGGER.error("FC16 write operation failed: %s", result)
+                result = None
+
+        except ValueError as exception_error:
+            _LOGGER.error("ValueError: Error writing multiple registers: %s", exception_error)
+        except (ModbusException, struct.error) as exception_error:
+            _LOGGER.error("ModbusException: Error writing multiple registers: %s", exception_error)
+        except TimeoutError:
+            _LOGGER.error("Timeout writing multiple registers to device %s", unit)
+        except asyncio.CancelledError as err:
+            _LOGGER.error("Operation cancelled writing multiple registers to device %s: %s", unit, err)
+        except Exception as e:
+            _LOGGER.error("Unexpected error writing multiple registers: %s - %s", type(e).__name__, e)
+        finally:
+            end_time = time.perf_counter()
+            _LOGGER.debug(
+                "FC16 write completed in %.3f seconds.",
+                end_time - start_time,
+            )
+        return result
+
+    async def write_registers(self, unit: int | str, address: int, values: list[int]):
+        """Write multiple registers async (FC16).
+
+        Returns None immediately when suspended.
+
+        Args:
+            unit: Device address (1-247).
+            address: Starting register address.
+            values: List of 16-bit integer values to write.
+        """
+        if self._suspended:
+            return None
+        async with self._lock:
+            result = await self._loop.run_in_executor(
+                self._executor, self.write_registers_blocking, unit, address, values
+            )
+            if self._inter_device_delay > 0:
+                await asyncio.sleep(self._inter_device_delay)
+            return result
+
+    async def write_registers_direct(self, unit: int | str, address: int, values: list[int]):
+        """Write multiple registers bypassing the suspend check (FC16).
+
+        Used by Tools API for manual writes while coordinators are
+        suspended.  Still acquires the UART lock to serialize access.
+
+        Args:
+            unit: Device address (1-247).
+            address: Starting register address.
+            values: List of 16-bit integer values to write.
+        """
+        async with self._lock:
+            result = await self._loop.run_in_executor(
+                self._executor,
+                self.write_registers_blocking,
+                unit,
+                address,
+                values,
+            )
+            if self._inter_device_delay > 0:
+                await asyncio.sleep(self._inter_device_delay)
+            return result