ekfsm 1.4.0a42__tar.gz → 1.4.0a60__tar.gz

{ekfsm-1.4.0a42 → ekfsm-1.4.0a60}/PKG-INFO

@@ -1,20 +1,20 @@
 Metadata-Version: 2.4
 Name: ekfsm
-Version: 1.4.0a42
+Version: 1.4.0a60
 Summary: The EKF System Management Library (ekfsm) is a sensor monitoring suite for Compact PCI Serial devices.
 Author-email: Jan Jansen <jan@ekf.de>, Klaus Popp <klaus.popp@ci4rail.com>, Felix Päßler <fp@ekf.de>
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Requires-Dist: anytree
 Requires-Dist: click>=8.0.1
 Requires-Dist: crcmod
 Requires-Dist: gpiod>=2.1.0
 Requires-Dist: hexdump
-Requires-Dist: io4edge-client>=1.6.2
+Requires-Dist: io4edge-client>=2.0.3
 Requires-Dist: ipdb>=0.13.13
 Requires-Dist: more-itertools
 Requires-Dist: munch
 Requires-Dist: pillow
-Requires-Dist: protobuf
+Requires-Dist: protobuf>=6.32.1
 Requires-Dist: schema>=0.7.7
 Requires-Dist: smbus2
 Requires-Dist: termcolor>=3.0.1

{ekfsm-1.4.0a42 → ekfsm-1.4.0a60}/devenv.lock

@@ -75,10 +75,10 @@
         ]
       },
       "locked": {
-        "lastModified": 1757588530,
+        "lastModified": 1759523803,
         "owner": "cachix",
         "repo": "pre-commit-hooks.nix",
-        "rev": "b084b2c2b6bc23e83bbfe583b03664eb0b18c411",
+        "rev": "cfc9f7bb163ad8542029d303e599c0f7eee09835",
         "type": "github"
       },
       "original": {

{ekfsm-1.4.0a42 → ekfsm-1.4.0a60}/docs/source/reference/ekfsm.rst

@@ -82,6 +82,17 @@ SMBIOS
 ~~~~~~
 .. automodule:: ekfsm.devices.smbios
 
+IO4Edge Devices
+---------------
+
+.. automodule:: ekfsm.devices.io4edge
+.. automodule:: ekfsm.devices.ledArray
+.. automodule:: ekfsm.devices.colorLed
+.. automodule:: ekfsm.devices.buttonArray
+.. automodule:: ekfsm.devices.button
+.. automodule:: ekfsm.devices.thermal_humidity
+.. automodule:: ekfsm.devices.watchdog
+
 Base Classes and Utilities
 --------------------------
 

{ekfsm-1.4.0a42 → ekfsm-1.4.0a60}/ekfsm/boards/oem/ekf/z1010.yaml

@@ -42,7 +42,7 @@ children:
               #   - write: write_customer_area
               #   - read: customer_area
   - device_type: IO4Edge
-    name: "SMC"
+    name: "I4E"
     provides:
       management:
         - identify_firmware
@@ -85,3 +85,10 @@ children:
             - kick
       - device_type: ThermalHumidity
         name: "th"
+      - device_type: ButtonArray
+        name: "buttons"
+        service_suffix: "gpios"
+        children:
+          - device_type: Button
+            name: "eject"
+            channel_id: 2

ekfsm-1.4.0a60/ekfsm/core/connections.py

@@ -0,0 +1,19 @@
+from contextlib import contextmanager
+
+
+class Connectable:
+
+    def __init__(self, client=None):
+        self._client = client
+        self._connected = False
+
+    @contextmanager
+    def connect(self):
+        if not self._connected:
+            client = self._client(self.service_addr, command_timeout=self.timeout)
+            self._connected = True
+        try:
+            yield client
+        finally:
+            client.close()
+            del client

{ekfsm-1.4.0a42 → ekfsm-1.4.0a60}/ekfsm/core/sysfs.py

@@ -166,7 +166,7 @@ class SysfsDevice(MutableMapping):
 
     def read_int(self, attr) -> int:
         """
-        Read a sysfs attribute as an integer
+        Read a sysfs attribute stored as a string as an integer
 
         Parameters
         ----------
@@ -186,7 +186,7 @@ class SysfsDevice(MutableMapping):
         """
         try:
             value = self.read_attr_utf8(attr).strip()
-            return int(value, 16)
+            return int(value)
         except StopIteration as e:
             raise SysFSError(f"'{attr}' sysfs attribute does not exist") from e
         except SysFSError:
@@ -194,6 +194,36 @@ class SysfsDevice(MutableMapping):
         except ValueError as e:
             raise ConversionError("Failed to convert sysfs value to int") from e
 
+    def read_hex(self, attr) -> int:
+        """
+        Read a sysfs attribute stored as a hexadecimal integer as integer
+
+        Parameters
+        ----------
+        attr: str
+            The sysfs attribute to read
+
+        Returns
+        -------
+        The sysfs attribute as a hexadecimal integer
+
+        Raises
+        ------
+        SysFSError
+            If the sysfs attribute does not exist
+        ConversionError
+            If the sysfs attribute could not be converted to a hexadecimal integer
+        """
+        try:
+            value = self.read_attr_utf8(attr).strip()
+            return int(value, 16)
+        except StopIteration as e:
+            raise SysFSError(f"'{attr}' sysfs attribute does not exist") from e
+        except SysFSError:
+            raise
+        except ValueError as e:
+            raise ConversionError("Failed to convert sysfs value to hex int") from e
+
     def read_utf8(self, attr, strip=True) -> str:
         """
         Read a sysfs attribute as a UTF-8 encoded string

{ekfsm-1.4.0a42 → ekfsm-1.4.0a60}/ekfsm/devices/button.py

@@ -1,5 +1,8 @@
 from typing import Callable
 from ekfsm.devices.generic import Device
+from ekfsm.log import ekfsm_logger
+
+logger = ekfsm_logger(__name__)
 
 
 class Button(Device):
@@ -17,12 +20,15 @@ class Button(Device):
         *args,
         **kwargs,
     ):
+        logger.debug(f"Initializing Button '{name}' on channel {channel_id}")
 
         super().__init__(name, parent, children, abort, *args, **kwargs)
 
         self.channel_id = channel_id
+        logger.debug(f"Button '{name}' assigned to channel {channel_id}")
 
         self._handler: Callable | None = None
+        logger.info(f"Button '{name}' initialized on channel {channel_id}")
 
     @property
     def handler(self):
@@ -43,8 +49,17 @@ class Button(Device):
         """
         if callable(func):
             self._handler = func
+            logger.info(
+                f"Handler set for button '{self.name}' on channel {self.channel_id}"
+            )
+            logger.debug(
+                f"Handler function: {func.__name__ if hasattr(func, '__name__') else str(func)}"
+            )
         else:
             self._handler = None
+            logger.debug(
+                f"Handler cleared for button '{self.name}' on channel {self.channel_id}"
+            )
 
     def __repr__(self):
         return f"{self.name}; Channel ID: {self.channel_id}"

ekfsm-1.4.0a60/ekfsm/devices/buttonArray.py

@@ -0,0 +1,206 @@
+import threading
+from ekfsm.devices.button import Button
+from ekfsm.devices.generic import Device
+from ekfsm.devices.io4edge import IO4Edge
+from ekfsm.log import ekfsm_logger
+from io4edge_client.binaryiotypeb import Client, Pb
+import io4edge_client.functionblock as fb
+
+logger = ekfsm_logger(__name__)
+
+
+class ButtonArray(Device):
+    """
+    Device class for handling an io4edge button array.
+
+    To read button events, call the `read` method in a separate thread.
+
+    Note
+    ----
+        Button handlers are called in the context of the `read` method's thread and need to be set in the Button instances.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        parent: IO4Edge,
+        children: list[Device] | None = None,
+        abort: bool = False,
+        service_suffix: str | None = None,
+        keepaliveInterval: int = 10000,
+        *args,
+        **kwargs,
+    ):
+        logger.debug(
+            f"Initializing ButtonArray '{name}' with parent device {parent.deviceId}"
+        )
+
+        Device.__init__(self, name, parent, children, abort, *args, **kwargs)
+
+        self.name = name
+
+        if service_suffix is not None:
+            self.service_suffix = service_suffix
+            logger.debug(f"Using custom service suffix: {service_suffix}")
+        else:
+            self.service_suffix = name
+            logger.debug(f"Using default service suffix: {name}")
+
+        self.service_addr = f"{parent.deviceId}-{self.service_suffix}"
+        self.timeout = keepaliveInterval / 1000 + 5
+
+        logger.info(
+            f"ButtonArray '{name}' configured with service address: {self.service_addr}"
+        )
+        logger.debug(
+            f"Keepalive interval: {keepaliveInterval}ms, timeout: {self.timeout}s"
+        )
+
+        try:
+            self.client = Client(
+                self.service_addr, command_timeout=self.timeout, connect=False
+            )
+            logger.debug(f"IO4Edge client created for service: {self.service_addr}")
+        except Exception as e:
+            logger.error(
+                f"Failed to create IO4Edge client for {self.service_addr}: {e}"
+            )
+            raise
+
+        self.subscriptionType = Pb.SubscriptionType.BINARYIOTYPEB_ON_RISING_EDGE
+        self.stream_cfg = fb.Pb.StreamControlStart(
+            bucketSamples=1,  # 1 sample per bucket, also ein event pro bucket
+            keepaliveInterval=keepaliveInterval,
+            bufferedSamples=2,  # 2 samples werden gepuffert
+            low_latency_mode=True,  # schickt soweit moeglich sofort die Events
+        )
+        logger.debug(
+            "Stream configuration initialized with rising edge subscription and low latency mode"
+        )
+
+        # Log button children count
+        button_count = sum(1 for child in (children or []) if isinstance(child, Button))
+        logger.info(f"ButtonArray '{name}' initialized with {button_count} button(s)")
+
+    def read(self, stop_event: threading.Event | None = None, timeout: float = 1):
+        """
+        Read all button events and dispatch to handlers.
+
+        Parameters
+        ----------
+        stop_event : threading.Event, optional
+            Event to signal stopping the reading loop. If None, the loop will run indefinitely.
+        timeout : float, optional
+            Timeout for reading from the stream in seconds. Default is 0.1 seconds.
+
+        Note
+        ----
+            This method blocks and should be run in a separate thread.
+        """
+        button_channels = [
+            button for button in self.children if isinstance(button, Button)
+        ]
+
+        if not button_channels:
+            logger.warning(
+                f"No button children found in ButtonArray '{self.name}', read operation will have no effect"
+            )
+            return
+
+        logger.info(
+            f"Starting button event reading for {len(button_channels)} buttons on '{self.name}'"
+        )
+        logger.debug(
+            f"Read timeout: {timeout}s, stop_event provided: {stop_event is not None}"
+        )
+
+        try:
+            with self.client as client:
+                logger.debug(
+                    f"IO4Edge client connected to service: {self.service_addr}"
+                )
+
+                # Prepare subscription channels
+                subscribe_channels = tuple(
+                    Pb.SubscribeChannel(
+                        channel=button.channel_id,
+                        subscriptionType=self.subscriptionType,
+                    )
+                    for button in button_channels
+                )
+
+                channel_ids = [button.channel_id for button in button_channels]
+                logger.debug(
+                    f"Subscribing to {len(subscribe_channels)} button channels: {channel_ids}"
+                )
+
+                client.start_stream(
+                    Pb.StreamControlStart(subscribeChannel=subscribe_channels),
+                    self.stream_cfg,
+                )
+                logger.info(
+                    f"Button event stream started for ButtonArray '{self.name}'"
+                )
+
+                event_count = 0
+                try:
+                    while not (stop_event and stop_event.is_set()):
+                        try:
+                            _, samples = client.read_stream(timeout=timeout)
+
+                            for sample in samples.samples:
+                                for button in button_channels:
+                                    pressed = bool(
+                                        sample.inputs & (1 << button.channel_id)
+                                    )
+                                    if pressed:
+                                        event_count += 1
+                                        button_name = getattr(button, "name", "unnamed")
+                                        logger.debug(
+                                            f"Button press on channel {button.channel_id} ({button_name})"
+                                        )
+
+                                        if button.handler:
+                                            try:
+                                                logger.debug(
+                                                    f"Calling handler for button on channel {button.channel_id}"
+                                                )
+                                                button.handler()
+                                            except Exception as e:
+                                                logger.error(
+                                                    f"Error in button handler for channel {button.channel_id}: {e}"
+                                                )
+                                        else:
+                                            logger.debug(
+                                                f"No handler set for button on channel {button.channel_id}"
+                                            )
+
+                        except TimeoutError:
+                            # Timeout is expected during normal operation
+                            continue
+                        except Exception as e:
+                            logger.error(
+                                f"Error reading button events from stream: {e}"
+                            )
+                            break
+
+                except KeyboardInterrupt:
+                    logger.info(
+                        f"Button reading interrupted for ButtonArray '{self.name}'"
+                    )
+                finally:
+                    logger.info(
+                        f"Button event reading stopped for '{self.name}' after processing {event_count} events"
+                    )
+                    if stop_event:
+                        stop_event.clear()
+                        logger.debug("Stop event cleared")
+
+        except Exception as e:
+            logger.error(
+                f"Failed to establish connection or start stream for ButtonArray '{self.name}': {e}"
+            )
+            raise
+
+    def __repr__(self):
+        return f"{self.name}; Service Address: {self.service_addr}"

{ekfsm-1.4.0a42 → ekfsm-1.4.0a60}/ekfsm/devices/colorLed.py

@@ -1,7 +1,10 @@
 from ekfsm.devices.generic import Device
 from ekfsm.devices.ledArray import LEDArray
+from ekfsm.log import ekfsm_logger
 from io4edge_client.api.colorLED.python.colorLED.v1alpha1.colorLED_pb2 import Color
 
+logger = ekfsm_logger(__name__)
+
 
 class ColorLED(Device):
     """
@@ -18,6 +21,7 @@ class ColorLED(Device):
         *args,
         **kwargs,
     ):
+        logger.debug(f"Initializing ColorLED '{name}' on channel {channel_id}")
 
         super().__init__(name, parent, children, abort, *args, **kwargs)
 
@@ -25,6 +29,9 @@ class ColorLED(Device):
         self.channel_id = channel_id
 
         self.client = parent.client
+        logger.info(
+            f"ColorLED '{name}' initialized on channel {channel_id} with parent LEDArray"
+        )
 
     def describe(self):
         pass
@@ -44,7 +51,19 @@ class ColorLED(Device):
         TimeoutError
             if the command times out
         """
-        return self.client.get(self.channel_id)
+        logger.debug(
+            f"Getting color LED state for '{self.name}' on channel {self.channel_id}"
+        )
+        try:
+            result = self.client.get(self.channel_id)
+            color, blink = result
+            logger.debug(f"ColorLED '{self.name}' state: color={color}, blink={blink}")
+            return result
+        except Exception as e:
+            logger.error(
+                f"Failed to get ColorLED '{self.name}' state on channel {self.channel_id}: {e}"
+            )
+            raise
 
     def set(self, color: Color, blink: bool) -> None:
         """
@@ -64,7 +83,19 @@ class ColorLED(Device):
         TimeoutError
             if the command times out
         """
-        self.client.set(self.channel_id, color, blink)
+        logger.info(
+            f"Setting ColorLED '{self.name}' on channel {self.channel_id}: color={color}, blink={blink}"
+        )
+        try:
+            self.client.set(self.channel_id, color, blink)
+            logger.debug(
+                f"ColorLED '{self.name}' successfully set to color={color}, blink={blink}"
+            )
+        except Exception as e:
+            logger.error(
+                f"Failed to set ColorLED '{self.name}' on channel {self.channel_id}: {e}"
+            )
+            raise
 
         def __repr__(self):
             return f"{self.name}; Channel ID: {self.channel_id}"

{ekfsm-1.4.0a42 → ekfsm-1.4.0a60}/ekfsm/devices/coretemp.py

@@ -7,6 +7,9 @@ from pathlib import Path
 import ekfsm.core
 from ekfsm.core.sysfs import sysfs_root
 from ekfsm.devices.generic import Device
+from ekfsm.log import ekfsm_logger
+
+logger = ekfsm_logger(__name__)
 
 # Path to the root of the HWMON sysfs filesystem
 HWMON_ROOT = sysfs_root() / Path("class/hwmon")
@@ -55,8 +58,16 @@ class CoreTemp(Device):
         *args,
         **kwargs,
     ):
-        dir = find_core_temp_dir(sysfs_root() / Path("class/hwmon"))
-        self.sysfs_device = ekfsm.core.sysfs.SysfsDevice(dir, False)
+        logger.debug(f"Initializing CoreTemp device '{name}'")
+
+        try:
+            dir = find_core_temp_dir(sysfs_root() / Path("class/hwmon"))
+            logger.debug(f"Found coretemp directory: {dir}")
+            self.sysfs_device = ekfsm.core.sysfs.SysfsDevice(dir, False)
+            logger.info(f"CoreTemp '{name}' initialized with sysfs device at {dir}")
+        except FileNotFoundError as e:
+            logger.error(f"Failed to initialize CoreTemp '{name}': {e}")
+            raise
 
         super().__init__(name, parent, None, abort, *args, **kwargs)
 
@@ -69,4 +80,16 @@ class CoreTemp(Device):
         int
             The CPU temperature in degrees Celsius.
         """
-        return self.sysfs.read_int("temp1_input") / 1000
+        logger.debug(f"Reading CPU temperature for CoreTemp '{self.name}'")
+        try:
+            temp_raw = self.sysfs.read_float("temp1_input")
+            temp_celsius = temp_raw / 1000
+            logger.debug(
+                f"CoreTemp '{self.name}' raw reading: {temp_raw}, temperature: {temp_celsius}°C"
+            )
+            return temp_celsius
+        except Exception as e:
+            logger.error(
+                f"Failed to read CPU temperature for CoreTemp '{self.name}': {e}"
+            )
+            raise

{ekfsm-1.4.0a42 → ekfsm-1.4.0a60}/ekfsm/devices/eeprom.py

@@ -520,8 +520,8 @@ class EKF_EEPROM(Validatable_EEPROM, ProbeableDevice):
             The date the device was manufactured.
         """
         area = self._content[self._date_mft_index_start : self._date_mft_index_end]
-        encoded_mft_date = area[::-1]
-        return self._decode_date(encoded_mft_date)
+        # encoded_mft_date = area[::-1]
+        return self._decode_date(area)
 
     @validated
     def repaired_at(self) -> date:
@@ -533,8 +533,8 @@ class EKF_EEPROM(Validatable_EEPROM, ProbeableDevice):
             The most recent date the device was repaired.
         """
         area = self._content[self._date_rep_index_start : self._date_rep_index_end]
-        encoded_rep_date = area[::-1]
-        return self._decode_date(encoded_rep_date)
+        # encoded_rep_date = area[::-1]
+        return self._decode_date(area)
 
     @validated
     def write_repaired_at(self, date: date) -> None:

{ekfsm-1.4.0a42 → ekfsm-1.4.0a60}/ekfsm/devices/generic.py

@@ -63,7 +63,9 @@ class Device(SysTree):
                         try:
                             func = list(interface.values())[0]
                         except IndexError:
-                            raise ConfigError(f"{self.name}: No function given for interface {name}.")
+                            raise ConfigError(
+                                f"{self.name}: No function given for interface {name}."
+                            )
 
                         if not hasattr(self, func):
                             if abort:
@@ -114,10 +116,14 @@ class Device(SysTree):
                 return self.sysfs.read_float(attr)
             case "int":
                 return self.sysfs.read_int(attr)
+            case "hex":
+                return self.sysfs.read_hex(attr)
             case _:
                 raise UnsupportedModeError(f"Mode {mode} is not supported")
 
-    def read_attr_or_default(self, attr: str, mode: str = "utf", strip: bool = True, default=None):
+    def read_attr_or_default(
+        self, attr: str, mode: str = "utf", strip: bool = True, default=None
+    ):
         try:
             return self.read_attr(attr, mode, strip)
         except UnsupportedModeError:
@@ -149,7 +155,11 @@ class Device(SysTree):
         None:
             If the sysfs device is not set or the attribute does not exist.
         """
-        if self.sysfs_device is not None and len(attr) != 0 and attr in [x.name for x in self.sysfs_device.attributes]:
+        if (
+            self.sysfs_device is not None
+            and len(attr) != 0
+            and attr in [x.name for x in self.sysfs_device.attributes]
+        ):
             return self.sysfs_device.read_attr_bytes(attr)
         return None
 
@@ -222,7 +232,9 @@ class Device(SysTree):
 
         chip_addr = self.device_args.get("addr")
         if chip_addr is None:
-            raise ConfigError(f"{self.name}: Chip address not provided in board definition")
+            raise ConfigError(
+                f"{self.name}: Chip address not provided in board definition"
+            )
 
         if not hasattr(self.parent, "sysfs_device") or self.parent.sysfs_device is None:
             # our device is the top level device of the slot
@@ -230,12 +242,16 @@ class Device(SysTree):
             slot_attributes = self.hw_module.slot.attributes
 
             if slot_attributes is None:
-                raise ConfigError(f"{self.name}: Slot attributes not provided in system configuration")
+                raise ConfigError(
+                    f"{self.name}: Slot attributes not provided in system configuration"
+                )
 
             if not self.hw_module.is_master:
                 # slot coding is only used for non-master devices
                 if not hasattr(slot_attributes, "slot_coding"):
-                    raise ConfigError(f"{self.name}: Slot coding not provided in slot attributes")
+                    raise ConfigError(
+                        f"{self.name}: Slot coding not provided in slot attributes"
+                    )
 
                 slot_coding_mask = 0xFF
 
@@ -246,7 +262,9 @@ class Device(SysTree):
 
         return chip_addr
 
-    def get_i2c_sysfs_device(self, addr: int, driver_required=True, find_driver: Callable | None = None) -> SysfsDevice:
+    def get_i2c_sysfs_device(
+        self, addr: int, driver_required=True, find_driver: Callable | None = None
+    ) -> SysfsDevice:
         from ekfsm.core.components import HWModule
 
         parent = self.parent
@@ -275,8 +293,12 @@ class Device(SysTree):
                 # regular I2C devices that follow the `${I2C_BUS}-${ADDR}` pattern. To address this issue, we
                 # initialize the ACPI _STR object for each PRP device with the necessary information, which is
                 # accessible in the `${DEVICE_SYSFS_PATH}/firmware_node/description` file.
-                if (entry / "firmware_node").exists() and (entry / "firmware_node" / "description").exists():
-                    description = (entry / "firmware_node/description").read_text().strip()
+                if (entry / "firmware_node").exists() and (
+                    entry / "firmware_node" / "description"
+                ).exists():
+                    description = (
+                        (entry / "firmware_node/description").read_text().strip()
+                    )
                     acpi_addr = int(description.split(" - ")[0], 16)
 
                     if acpi_addr == addr:
@@ -289,11 +311,16 @@ class Device(SysTree):
                     if acpi_addr == addr:
                         return SysfsDevice(entry, driver_required, find_driver)
 
-        raise FileNotFoundError(f"Device with address 0x{addr:x} not found in {i2c_bus_path}")
+        raise FileNotFoundError(
+            f"Device with address 0x{addr:x} not found in {i2c_bus_path}"
+        )
 
     @staticmethod
     def __master_i2c_get_config(master: "HWModule") -> dict:
-        if master.config.get("bus_masters") is not None and master.config["bus_masters"].get("i2c") is not None:
+        if (
+            master.config.get("bus_masters") is not None
+            and master.config["bus_masters"].get("i2c") is not None
+        ):
             return master.config["bus_masters"]["i2c"]
         else:
             raise ConfigError("Master definition incomplete")
@@ -310,7 +337,9 @@ class Device(SysTree):
         else:
             # another board is the master
             if self.hw_module.slot.master is None:
-                raise ConfigError(f"{self.name}: Master board not found in slot attributes")
+                raise ConfigError(
+                    f"{self.name}: Master board not found in slot attributes"
+                )
 
             master = self.hw_module.slot.master
             master_key = self.hw_module.slot.slot_type.name