boneio 1.5.0.dev3__tar.gz → 1.5.0.dev5__tar.gz

{boneio-1.5.0.dev3/boneio.egg-info → boneio-1.5.0.dev5}/PKG-INFO

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

{boneio-1.5.0.dev3 → boneio-1.5.0.dev5}/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.dev3 → boneio-1.5.0.dev5}/boneio/components/output/basic.py

@@ -186,7 +186,13 @@ class BasicOutput(BasicMqtt):
         """
         can_turn_on = self.check_interlock()
         if can_turn_on:
-            await self._loop.run_in_executor(None, self.turn_on, timestamp)
+            try:
+                await self._loop.run_in_executor(None, self.turn_on, timestamp)
+            except RuntimeError as err:
+                if "Executor shutdown" in str(err):
+                    self.turn_on(timestamp)  # Fall back to sync during shutdown
+                else:
+                    raise
         else:
             _LOGGER.warning("Interlock active: cannot turn on %s.", self.id)
             # Workaround for HA is sendind state ON/OFF without physically changing the relay.
@@ -197,7 +203,13 @@ class BasicOutput(BasicMqtt):
 
     async def async_turn_off(self, timestamp=None) -> None:
         """Turn off the relay asynchronously."""
-        await self._loop.run_in_executor(None, self.turn_off, timestamp)
+        try:
+            await self._loop.run_in_executor(None, self.turn_off, timestamp)
+        except RuntimeError as err:
+            if "Executor shutdown" in str(err):
+                self.turn_off(timestamp)  # Fall back to sync during shutdown
+            else:
+                raise
         await self.async_send_state()
 
     async def async_toggle(self, timestamp=None) -> None:

{boneio-1.5.0.dev3 → boneio-1.5.0.dev5}/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.dev3 → boneio-1.5.0.dev5}/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.dev3 → boneio-1.5.0.dev5}/boneio/core/state/manager.py

@@ -25,6 +25,7 @@ class StateManager:
         _LOGGER.info("Loaded state file from %s", self._file)
         self._file_uptodate = False
         self._save_attributes_callback = None
+        self._shutting_down = False
 
     def load_states(self) -> dict:
         """Load state file.
@@ -105,6 +106,8 @@ class StateManager:
         if attr_type not in self._state:
             self._state[attr_type] = {}
         self._state[attr_type][attribute] = value
+        if self._shutting_down:
+            return
         if self._save_attributes_callback is not None:
             self._save_attributes_callback.cancel()
             self._save_attributes_callback = None
@@ -182,4 +185,26 @@ class StateManager:
             # Let's not save state if something happens same time.
             return False
         async with self._lock:
-            return await self._loop.run_in_executor(None, self._save_state)
+            try:
+                return await self._loop.run_in_executor(None, self._save_state)
+            except RuntimeError as err:
+                if "Executor shutdown" in str(err):
+                    # Python 3.13+: executor already closed, fall back to sync
+                    _LOGGER.debug("Executor shutdown, saving state synchronously")
+                    return self._save_state()
+                raise
+
+    def cancel_pending_and_save(self) -> None:
+        """Cancel any pending deferred save and do a final synchronous write.
+
+        Must be called during application shutdown BEFORE the event loop
+        closes the default executor. This prevents the RuntimeError:
+        'Executor shutdown has been called' on Python 3.13+.
+        """
+        self._shutting_down = True
+        if self._save_attributes_callback is not None:
+            self._save_attributes_callback.cancel()
+            self._save_attributes_callback = None
+        # Final synchronous save to persist any in-memory changes
+        self._save_state()
+        _LOGGER.debug("StateManager: pending save cancelled, final state written")

{boneio-1.5.0.dev3 → boneio-1.5.0.dev5}/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.dev5/boneio/modbus/devices/energy_meters/dts1964_3f.json

@@ -0,0 +1,247 @@
+{
+  "model": "DTS1964 3-phase meter",
+  "manufacturer": "DTS",
+  "description": "DTS1964 3-phase power & energy meter",
+  "category": "energy_meters",
+  "default_address": 1,
+  "default_update_interval": "10s",
+  "registers_base": [
+    {
+      "base": 0,
+      "length": 60,
+      "register_type": "input",
+      "registers": [
+        {
+          "name": "Voltage_Phase1",
+          "address": 0,
+          "unit_of_measurement": "V",
+          "state_class": "measurement",
+          "device_class": "voltage",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Voltage_Phase2",
+          "address": 2,
+          "unit_of_measurement": "V",
+          "state_class": "measurement",
+          "device_class": "voltage",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Voltage_Phase3",
+          "address": 4,
+          "unit_of_measurement": "V",
+          "state_class": "measurement",
+          "device_class": "voltage",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Voltage_Phase1_to_Phase2",
+          "address": 6,
+          "unit_of_measurement": "V",
+          "state_class": "measurement",
+          "device_class": "voltage",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Voltage_Phase2_to_Phase3",
+          "address": 8,
+          "unit_of_measurement": "V",
+          "state_class": "measurement",
+          "device_class": "voltage",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Voltage_Phase3_to_Phase1",
+          "address": 10,
+          "unit_of_measurement": "V",
+          "state_class": "measurement",
+          "device_class": "voltage",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Current_Phase1",
+          "address": 12,
+          "unit_of_measurement": "A",
+          "state_class": "measurement",
+          "device_class": "current",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Current_Phase2",
+          "address": 14,
+          "unit_of_measurement": "A",
+          "state_class": "measurement",
+          "device_class": "current",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Current_Phase3",
+          "address": 16,
+          "unit_of_measurement": "A",
+          "state_class": "measurement",
+          "device_class": "current",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Power_Phase1",
+          "address": 18,
+          "unit_of_measurement": "kW",
+          "state_class": "measurement",
+          "device_class": "power",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Power_Phase2",
+          "address": 20,
+          "unit_of_measurement": "kW",
+          "state_class": "measurement",
+          "device_class": "power",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Power_Phase3",
+          "address": 22,
+          "unit_of_measurement": "kW",
+          "state_class": "measurement",
+          "device_class": "power",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Total_Power",
+          "address": 24,
+          "unit_of_measurement": "kW",
+          "state_class": "measurement",
+          "device_class": "power",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Reactive_Power_Phase1",
+          "address": 26,
+          "unit_of_measurement": "kvar",
+          "state_class": "measurement",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Reactive_Power_Phase2",
+          "address": 28,
+          "unit_of_measurement": "kvar",
+          "state_class": "measurement",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Reactive_Power_Phase3",
+          "address": 30,
+          "unit_of_measurement": "kvar",
+          "state_class": "measurement",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Total_Reactive_Power",
+          "address": 32,
+          "unit_of_measurement": "kvar",
+          "state_class": "measurement",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Apparent_Power_Phase1",
+          "address": 34,
+          "unit_of_measurement": "kVA",
+          "state_class": "measurement",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Apparent_Power_Phase2",
+          "address": 36,
+          "unit_of_measurement": "kVA",
+          "state_class": "measurement",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Apparent_Power_Phase3",
+          "address": 38,
+          "unit_of_measurement": "kVA",
+          "state_class": "measurement",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Total_Apparent_Power",
+          "address": 40,
+          "unit_of_measurement": "kVA",
+          "state_class": "measurement",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Power_Factor_Phase1",
+          "address": 42,
+          "unit_of_measurement": "",
+          "state_class": "measurement",
+          "device_class": "power_factor",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Power_Factor_Phase2",
+          "address": 44,
+          "unit_of_measurement": "",
+          "state_class": "measurement",
+          "device_class": "power_factor",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Power_Factor_Phase3",
+          "address": 46,
+          "unit_of_measurement": "",
+          "state_class": "measurement",
+          "device_class": "power_factor",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Power_Factor_Total",
+          "address": 48,
+          "unit_of_measurement": "",
+          "state_class": "measurement",
+          "device_class": "power_factor",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Frequency",
+          "address": 50,
+          "unit_of_measurement": "Hz",
+          "state_class": "measurement",
+          "device_class": "frequency",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Import_Energy_Total",
+          "address": 52,
+          "unit_of_measurement": "kWh",
+          "state_class": "total_increasing",
+          "device_class": "energy",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Export_Energy_Total",
+          "address": 54,
+          "unit_of_measurement": "kWh",
+          "state_class": "total_increasing",
+          "device_class": "energy",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Import_Reactive_Energy_Total",
+          "address": 56,
+          "unit_of_measurement": "kvarh",
+          "state_class": "total_increasing",
+          "value_type": "FP32"
+        },
+        {
+          "name": "Export_Reactive_Energy_Total",
+          "address": 58,
+          "unit_of_measurement": "kvarh",
+          "state_class": "total_increasing",
+          "value_type": "FP32"
+        }
+      ]
+    }
+  ]
+}