ekfsm 1.4.0a43__py3-none-any.whl → 1.4.0a60__py3-none-any.whl

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/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/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/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/devices/buttonArray.py

@@ -2,9 +2,12 @@ import threading
 from ekfsm.devices.button import Button
 from ekfsm.devices.generic import Device
 from ekfsm.devices.io4edge import IO4Edge
-import io4edge_client.binaryiotypeb as binio
+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):
     """
@@ -28,31 +31,58 @@ class ButtonArray(Device):
         *args,
         **kwargs,
     ):
+        logger.debug(
+            f"Initializing ButtonArray '{name}' with parent device {parent.deviceId}"
+        )
 
-        super().__init__(name, parent, children, abort, *args, **kwargs)
+        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
 
-        self.client = binio.Client(
-            self.service_addr, command_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 = binio.Pb.SubscriptionType.BINARYIOTYPEB_ON_RISING_EDGE
+        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"
+        )
 
-    def read(self, stop_event: threading.Event | None = None, timeout: float = 0.1):
+        # 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.
 
@@ -67,38 +97,110 @@ class ButtonArray(Device):
         ----
             This method blocks and should be run in a separate thread.
         """
-        self.client.start_stream(
-            binio.Pb.StreamControlStart(
-                subscribeChannel=tuple(
-                    binio.Pb.SubscribeChannel(
+        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 self.children
-                    if isinstance(button, Button)
+                    for button in button_channels
                 )
-            ),
-            self.stream_cfg,
-        )
-        try:
-            while not (stop_event and stop_event.is_set()):
+
+                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:
-                    _, samples = self.client.read_stream(timeout=timeout)
-                    for sample in samples.samples:
-                        for button in self.children:
-                            if isinstance(button, Button):
-                                pressed = bool(sample.inputs & (1 << button.channel_id))
-                                if pressed and button.handler:
-                                    button.handler()
-                except TimeoutError:
-                    continue
-        finally:
-            try:
-                if stop_event:
-                    stop_event.clear()
-                self.client.stop_stream()
-            except TimeoutError:
-                pass
+                    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/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/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/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/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

ekfsm/devices/io4edge.py

@@ -1,10 +1,13 @@
 from typing import Callable, Optional
 from ekfsm.core.components import HWModule
 from ekfsm.devices.generic import Device
+from ekfsm.log import ekfsm_logger
 import io4edge_client.core.coreclient as Client
 
 from re import sub
 
+logger = ekfsm_logger(__name__)
+
 
 class IO4Edge(Device):
     """
@@ -20,6 +23,7 @@ class IO4Edge(Device):
         *args,
         **kwargs,
     ):
+        logger.debug(f"Initializing IO4Edge device '{name}'")
 
         super().__init__(name, parent, children, abort, *args, **kwargs)
 
@@ -29,16 +33,27 @@ class IO4Edge(Device):
             or not hasattr(attr, "slot_coding")
             or getattr(attr, "slot_coding") is None
         ):
+            logger.error(
+                f"Slot attributes for {self.hw_module.slot.name} are not set or do not contain 'slot_coding'"
+            )
             raise ValueError(
                 f"Slot attributes for {self.hw_module.slot.name} are not set or do not contain 'slot_coding'."
             )
         else:
             geoaddr = int(attr.slot_coding)
             self._geoaddr = geoaddr
+            logger.debug(f"IO4Edge '{name}' geo address: {geoaddr}")
 
         _, module_name = sub(r"-.*$", "", self.hw_module.board_type).split(maxsplit=1)
         self._module_name = module_name
-        self.client = Client.new_core_client(self.deviceId)
+        logger.debug(f"IO4Edge '{name}' module name: {module_name}")
+
+        try:
+            self.client = Client.new_core_client(self.deviceId)
+            logger.info(f"IO4Edge '{name}' initialized with device ID: {self.deviceId}")
+        except Exception as e:
+            logger.error(f"Failed to create IO4Edge core client for '{name}': {e}")
+            raise
 
     @property
     def deviceId(self) -> str:
@@ -49,9 +64,10 @@ class IO4Edge(Device):
         return f"{self._module_name}-geo_addr{self._geoaddr:02d}"
 
     def identify_firmware(self) -> tuple[str, str]:
+        response = self.client.identify_firmware()
         return (
-            self.client.identify_firmware().title,
-            self.client.identify_firmware().version,
+            response.title,
+            response.version,
         )
 
     def load_firmware(

ekfsm/devices/ledArray.py

@@ -1,7 +1,10 @@
 from ekfsm.devices.generic import Device
 from ekfsm.devices.io4edge import IO4Edge
+from ekfsm.log import ekfsm_logger
 from io4edge_client.colorLED import Client
 
+logger = ekfsm_logger(__name__)
+
 
 class LEDArray(Device):
     """
@@ -18,6 +21,9 @@ class LEDArray(Device):
         *args,
         **kwargs,
     ):
+        logger.debug(
+            f"Initializing LEDArray '{name}' with parent device {parent.deviceId}"
+        )
 
         super().__init__(name, parent, children, abort, *args, **kwargs)
 
@@ -25,12 +31,24 @@ class LEDArray(Device):
 
         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.client = Client(self.service_addr)
+        logger.info(
+            f"LEDArray '{name}' configured with service address: {self.service_addr}"
+        )
+
+        try:
+            self.client = Client(self.service_addr)
+            logger.debug(f"LEDArray client created for service: {self.service_addr}")
+        except Exception as e:
+            logger.error(
+                f"Failed to create LEDArray client for {self.service_addr}: {e}"
+            )
+            raise
 
     def __repr__(self):
         return f"{self.name}; Service Address: {self.service_addr}"

ekfsm/devices/pixelDisplay.py

@@ -1,8 +1,11 @@
 from ekfsm.devices.generic import Device
 from ekfsm.devices.io4edge import IO4Edge
+from ekfsm.log import ekfsm_logger
 from io4edge_client.pixelDisplay import Client
 from PIL import Image
 
+logger = ekfsm_logger(__name__)
+
 
 class PixelDisplay(Device):
     """
@@ -19,6 +22,9 @@ class PixelDisplay(Device):
         *args,
         **kwargs,
     ):
+        logger.debug(
+            f"Initializing PixelDisplay '{name}' with parent device {parent.deviceId}"
+        )
 
         super().__init__(name, parent, children, abort, *args, **kwargs)
 
@@ -26,24 +32,46 @@ class PixelDisplay(Device):
 
         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}"
+        logger.info(
+            f"PixelDisplay '{name}' configured with service address: {self.service_addr}"
+        )
 
-        self.client = Client(self.service_addr)
+        try:
+            self.client = Client(self.service_addr, connect=False)
+            logger.debug(
+                f"PixelDisplay client created for service: {self.service_addr}"
+            )
+        except Exception as e:
+            logger.error(
+                f"Failed to create PixelDisplay client for {self.service_addr}: {e}"
+            )
+            raise
 
     def describe(self) -> dict:
         """
         Returns a description of the pixel display.
         """
-        describe = self.client.describe()
-        desc = {
-            "height": describe.height_pixel,
-            "width": describe.width_pixel,
-            "max_num_of_pixel": describe.max_num_of_pixel,
-        }
-        return desc
+        logger.debug(f"Getting PixelDisplay description for '{self.name}'")
+        try:
+            describe = self.client.describe()
+            desc = {
+                "height": describe.height_pixel,
+                "width": describe.width_pixel,
+                "max_num_of_pixel": describe.max_num_of_pixel,
+            }
+            logger.debug(f"PixelDisplay '{self.name}' description: {desc}")
+            return desc
+        except Exception as e:
+            logger.error(
+                f"Failed to get PixelDisplay description for '{self.name}': {e}"
+            )
+            raise
 
     @property
     def height(self) -> int:
@@ -65,7 +93,13 @@ class PixelDisplay(Device):
         @raises RuntimeError: if the command fails
         @raises TimeoutError: if the command times out
         """
-        self.client.set_display_off()
+        logger.info(f"Turning off PixelDisplay '{self.name}'")
+        try:
+            self.client.set_display_off()
+            logger.debug(f"PixelDisplay '{self.name}' successfully turned off")
+        except Exception as e:
+            logger.error(f"Failed to turn off PixelDisplay '{self.name}': {e}")
+            raise
 
     def display_image(self, path: str) -> None:
         """
@@ -73,16 +107,31 @@ class PixelDisplay(Device):
         @raises RuntimeError: if the command fails
         @raises TimeoutError: if the command times out
         """
-        with Image.open(path) as img:
-            img = img.convert("RGB")
-            pix = img.load()
-
-        for i in range(0, 320, 16):
-            pix_area = []
-            for k in range(0, 16):
-                for j in range(0, 240):
-                    pix_area.append(pix[j, i + k])
-            self.client.set_pixel_area(0, i, 239, pix_area)
+        logger.info(f"Displaying image '{path}' on PixelDisplay '{self.name}'")
+        try:
+            with Image.open(path) as img:
+                img = img.convert("RGB")
+                pix = img.load()
+                logger.debug(
+                    f"Image '{path}' loaded and converted to RGB for PixelDisplay '{self.name}'"
+                )
+
+            with self.client as client:
+                logger.debug(f"Sending pixel data to PixelDisplay '{self.name}'")
+                for i in range(0, 320, 16):
+                    pix_area = []
+                    for k in range(0, 16):
+                        for j in range(0, 240):
+                            pix_area.append(pix[j, i + k])
+                    client.set_pixel_area(0, i, 239, pix_area)
+                logger.debug(
+                    f"Image successfully displayed on PixelDisplay '{self.name}'"
+                )
+        except Exception as e:
+            logger.error(
+                f"Failed to display image '{path}' on PixelDisplay '{self.name}': {e}"
+            )
+            raise
 
     def __repr__(self):
         return f"{self.name}; Service Address: {self.service_addr}"

ekfsm/devices/pmbus.py

@@ -52,7 +52,9 @@ def retry(max_attempts=5, delay=0.5):
                 except Exception as e:
                     attempts += 1
                     if attempts == max_attempts:
-                        logger.exception(f"Failed to execute {func.__name__} after {max_attempts} attempts: {e}")
+                        logger.exception(
+                            f"Failed to execute {func.__name__} after {max_attempts} attempts: {e}"
+                        )
                         raise e
                     logger.info(f"Retrying execution of {func.__name__} in {delay}s...")
                 sleep(delay)
@@ -121,7 +123,9 @@ class PMBus(Device, ProbeableDevice):
                     attrs = list_sysfs_attributes(entry)
                     self.sysfs_device.extend_attributes(attrs)
 
-                    debug_attrs_path = sysfs_root().joinpath(f"kernel/debug/pmbus/{entry.name}")
+                    debug_attrs_path = sysfs_root().joinpath(
+                        f"kernel/debug/pmbus/{entry.name}"
+                    )
                     debug_attrs = list_sysfs_attributes(debug_attrs_path)
                     self.sysfs_device.extend_attributes(debug_attrs)
         except FileNotFoundError:
@@ -194,7 +198,7 @@ class PMBus(Device, ProbeableDevice):
         -------
             PSU status as defined in PSUStatus
         """
-        status = self.sysfs.read_int("status0_input")
+        status = self.sysfs.read_hex("status0_input")
         return PSUStatus(status)
 
     @retry()
@@ -206,7 +210,7 @@ class PMBus(Device, ProbeableDevice):
         -------
             PSU status as defined in PSUStatus
         """
-        status = self.sysfs.read_int("status1_input")
+        status = self.sysfs.read_hex("status1_input")
         return PSUStatus(status)
 
     # Temperature Interface

ekfsm/devices/smbios.py

@@ -2,9 +2,12 @@ from pathlib import Path
 
 from ekfsm.core.components import HWModule
 from ekfsm.core.sysfs import SysfsDevice, sysfs_root
+from ekfsm.log import ekfsm_logger
 
 from .generic import Device
 
+logger = ekfsm_logger(__name__)
+
 
 class SMBIOS(Device):
     """
@@ -26,7 +29,15 @@ class SMBIOS(Device):
         *args,
         **kwargs,
     ):
-        self.sysfs_device: SysfsDevice | None = SysfsDevice(sysfs_root() / Path("devices/virtual/dmi/id"), False)
+        logger.debug(f"Initializing SMBIOS device '{name}'")
+
+        try:
+            dmi_path = sysfs_root() / Path("devices/virtual/dmi/id")
+            self.sysfs_device: SysfsDevice | None = SysfsDevice(dmi_path, False)
+            logger.info(f"SMBIOS '{name}' initialized with DMI table at {dmi_path}")
+        except Exception as e:
+            logger.error(f"Failed to initialize SMBIOS '{name}' with DMI table: {e}")
+            raise
 
         super().__init__(name, parent, None, abort, *args, **kwargs)
 
@@ -39,4 +50,11 @@ class SMBIOS(Device):
         str
             The board revision.
         """
-        return self.sysfs.read_utf8("board_version")
+        logger.debug(f"Reading board revision for SMBIOS '{self.name}'")
+        try:
+            revision = self.sysfs.read_utf8("board_version")
+            logger.debug(f"SMBIOS '{self.name}' board revision: {revision}")
+            return revision
+        except Exception as e:
+            logger.error(f"Failed to read board revision for SMBIOS '{self.name}': {e}")
+            raise

ekfsm/devices/thermal_humidity.py

@@ -1,6 +1,9 @@
 from ekfsm.devices.generic import Device
 from ekfsm.devices.io4edge import IO4Edge
-from io4edge_client.analogintypea import Client
+from ekfsm.log import ekfsm_logger
+from io4edge_client.analogintypeb import Client
+
+logger = ekfsm_logger(__name__)
 
 
 class ThermalHumidity(Device):
@@ -18,6 +21,9 @@ class ThermalHumidity(Device):
         *args,
         **kwargs,
     ):
+        logger.debug(
+            f"Initializing ThermalHumidity sensor '{name}' with parent device {parent.deviceId}"
+        )
 
         super().__init__(name, parent, children, abort, *args, **kwargs)
 
@@ -25,12 +31,26 @@ class ThermalHumidity(Device):
 
         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}"
+        logger.info(
+            f"ThermalHumidity '{name}' configured with service address: {self.service_addr}"
+        )
 
-        self.client = Client(self.service_addr)
+        try:
+            self.client = Client(self.service_addr, connect=False)
+            logger.debug(
+                f"ThermalHumidity client created for service: {self.service_addr}"
+            )
+        except Exception as e:
+            logger.error(
+                f"Failed to create ThermalHumidity client for {self.service_addr}: {e}"
+            )
+            raise
 
     def temperature(self) -> float:
         """
@@ -43,7 +63,16 @@ class ThermalHumidity(Device):
         TimeoutError
             if the command times out
         """
-        return self.client.value()
+        logger.debug(f"Reading temperature from ThermalHumidity sensor '{self.name}'")
+        try:
+            temp = self.client.value()
+            logger.debug(f"ThermalHumidity '{self.name}' temperature: {temp}°C")
+            return temp
+        except Exception as e:
+            logger.error(
+                f"Failed to read temperature from ThermalHumidity '{self.name}': {e}"
+            )
+            raise
 
     def __repr__(self):
         return f"{self.name}; Service Address: {self.service_addr}"

ekfsm/devices/watchdog.py

@@ -1,7 +1,10 @@
 from ekfsm.devices.generic import Device
 from ekfsm.devices.io4edge import IO4Edge
+from ekfsm.log import ekfsm_logger
 from io4edge_client.watchdog import Client
 
+logger = ekfsm_logger(__name__)
+
 
 class Watchdog(Device):
     """
@@ -18,6 +21,9 @@ class Watchdog(Device):
         *args,
         **kwargs,
     ):
+        logger.debug(
+            f"Initializing Watchdog '{name}' with parent device {parent.deviceId}"
+        )
 
         super().__init__(name, parent, children, abort, *args, **kwargs)
 
@@ -25,12 +31,24 @@ class Watchdog(Device):
 
         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}"
+        logger.info(
+            f"Watchdog '{name}' configured with service address: {self.service_addr}"
+        )
 
-        self.client = Client(self.service_addr)
+        try:
+            self.client = Client(self.service_addr, connect=False)
+            logger.debug(f"Watchdog client created for service: {self.service_addr}")
+        except Exception as e:
+            logger.error(
+                f"Failed to create Watchdog client for {self.service_addr}: {e}"
+            )
+            raise
 
     def describe(self):
         pass
@@ -46,7 +64,13 @@ class Watchdog(Device):
         TimeoutError
             if the command times out
         """
-        self.client.kick()
+        logger.debug(f"Kicking watchdog '{self.name}' on service {self.service_addr}")
+        try:
+            self.client.kick()
+            logger.debug(f"Watchdog '{self.name}' kick successful")
+        except Exception as e:
+            logger.error(f"Failed to kick watchdog '{self.name}': {e}")
+            raise
 
     def __repr__(self):
         return f"{self.name}; Service Address: {self.service_addr}"

{ekfsm-1.4.0a43.dist-info → ekfsm-1.4.0a60.dist-info}/METADATA

@@ -1,20 +1,20 @@
 Metadata-Version: 2.4
 Name: ekfsm
-Version: 1.4.0a43
+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.0a43.dist-info → ekfsm-1.4.0a60.dist-info}/RECORD

@@ -18,38 +18,39 @@ ekfsm/boards/oem/ekf/sq1-track.yaml,sha256=YU83BQjGu-4ejirwnGxd38sJme859kdRovkZy
 ekfsm/boards/oem/ekf/sq3-quartet.yaml,sha256=JaHJn_lph2iwLz6cwXu0bjRMgj33OXt1-VBNGFu0U3s,1330
 ekfsm/boards/oem/ekf/srf-fan.yaml,sha256=Mcu1Q8B1Ih10hoc_hbkGlppBmbOFcufsVUR42iW4Rwc,1368
 ekfsm/boards/oem/ekf/sur-uart.yaml,sha256=VaNP2BSlNTi1lDco16Ma9smPEAMaVKvx-ZNDcm3QptM,1890
-ekfsm/boards/oem/ekf/z1010.yaml,sha256=Z0m0AaRnBFL3QYvSnzHVauXm3laN4lrVv6ewccyY6Hk,2369
+ekfsm/boards/oem/ekf/z1010.yaml,sha256=oz1BI2dGlk3vn0g58-QGC1k35-V0Svh4ESpwHlneJBs,2560
 ekfsm/boards/oem/hitron/hdrc-300s.yaml,sha256=SwBHTWVqENBun_iZattPbvA9koc-LOI_MIXjLahKyyI,548
 ekfsm/core/__init__.py,sha256=xfuU072JY_--561hfSS8ToBM-wgswY4Z-YwDMZkVA6c,348
 ekfsm/core/components.py,sha256=iTetqtzNjEEj6FDJNfvXxW_cNNRlLX5_WgB5z3g3zqg,3883
+ekfsm/core/connections.py,sha256=ffvqohwFxUnJTFeHG_O7SmXtNGOZqqTZ9cOfGvHC2P8,458
 ekfsm/core/probe.py,sha256=DgJvkvMjVk09n0Rzn13ybRvidrmFn_D2PD56XS-KgxU,262
 ekfsm/core/slots.py,sha256=qmxfssVitsMFZYbJRCpOOsvEGqh8JVYdRS-_5BliOF4,6580
-ekfsm/core/sysfs.py,sha256=CWH1BXlanHAFzK6KY23qLuFvBZ7Q9td3X6JLRwb3vu0,7309
+ekfsm/core/sysfs.py,sha256=1UJ19ZISCnQ4Zz3fwZmad7dle85mhNugF4beTVdapQE,8228
 ekfsm/core/utils.py,sha256=AjVj_QCb9umUmZZsGFPyCISdOKYlhRRSOTVjPu_gxyA,4678
 ekfsm/devices/__init__.py,sha256=EDFzBuUHt_3_6JD4cageHWZfoMn3WUIIDZk4yEOWgfg,1451
-ekfsm/devices/button.py,sha256=z3vzpTCY4ZweUd1M9_eJvepM7A-FchapdsaMz5RCUPE,1207
-ekfsm/devices/buttonArray.py,sha256=KOI7ycLY9RxXOpalCxJz4rOqSC7vp6dihIGkvl2BdXw,3603
-ekfsm/devices/colorLed.py,sha256=H0SFl0SkMHIV5Is31XQJfisDu2nmPh0TuWrtlhsi1bI,1622
-ekfsm/devices/coretemp.py,sha256=UEsPTMYm05qNCnqnPtbAoYdIfvVGkDl9rJg3tkAP748,1992
-ekfsm/devices/eeprom.py,sha256=cwcaM2YCKrw6du8d4zT_M3e4oFJh3XNQc5cQM2vqERE,33090
+ekfsm/devices/button.py,sha256=JZr9v8_z12GlVBQ-4b08AY40cqy4mErvZtxt_q4pbr8,1893
+ekfsm/devices/buttonArray.py,sha256=YwRRUY-7f2QEc5bE_qXWg4zulupn7mrcpco3pARf9N0,8141
+ekfsm/devices/colorLed.py,sha256=i6RXR8QZq3ukGPd3PszAHH_p5_JesDbm2EaLKIM-Yls,2824
+ekfsm/devices/coretemp.py,sha256=rurB6eq7yIdwupusla4DzAWOz4i4Xe1RgOoeuMlaJX8,2897
+ekfsm/devices/eeprom.py,sha256=p-ACUn1f9xH-Hjx4oLPmXGRHLbNf94q99EPLfWtV-2M,33070
 ekfsm/devices/ekf_ccu_uc.py,sha256=hjs5r7TKsrFhyyGKClgSFBpchQpFcE7fTZeuLrYiflY,15905
 ekfsm/devices/ekf_sur_led.py,sha256=qpCn7qj4v27QjxB5xTC5wIXKfefpveOd3FPK3JElyVk,1997
-ekfsm/devices/generic.py,sha256=LboZ7eanyC2xUnSX3-S7VCA87aTbJenlGtKsUk5JS2Q,12858
+ekfsm/devices/generic.py,sha256=4fwwnUyToQ7bvQ7U3tZ7Huynu7ruf2Fog_KAqkO3yN0,13365
 ekfsm/devices/gpio.py,sha256=37P7uu-ncg0TWf0Xs1iZM-PrX7F_09asd4IhWj6z21Y,10058
 ekfsm/devices/iio.py,sha256=1Jyh5wJ53DxvpWNBqYW07kkaAN9446ebWGCMk2UIuWM,1265
 ekfsm/devices/iio_thermal_humidity.py,sha256=KCeEqBlczroxp-hjsiRlXQdmmnJR9Ck3d3ztths5Vvc,1547
 ekfsm/devices/imu.py,sha256=GwJrnC-WztpE5oGnkIp-laFkSp3_gbSp9YpJ8jBsUOs,423
-ekfsm/devices/io4edge.py,sha256=hk_EzcXVR0-sD2zn6pMuO2txYNnTDKmMaaXS2N__8E4,2743
-ekfsm/devices/ledArray.py,sha256=6DCHs1nJz12aHQNPytaM_KIasQYdB29ZN7GzPb_EcJ4,902
+ekfsm/devices/io4edge.py,sha256=PBjWygDWSUpB0prmYyjUi2cBxQsDyeeqiw3ykfIrdmQ,3406
+ekfsm/devices/ledArray.py,sha256=NdZ3zQpApL___-r_bv5YPBQsabo5qQxvXil2pfOZv6Y,1616
 ekfsm/devices/mux.py,sha256=QpVWsD43Mx1mtCDG_nOxtHeIeU2Cigc62UljJ_utSXQ,1974
-ekfsm/devices/pixelDisplay.py,sha256=68SANN4S15_NncuDvu0hyjjdqhpxYn14cmxjXwfGqgU,2425
-ekfsm/devices/pmbus.py,sha256=fi_kR7TlkcqYhHuB7PA2PjANCYmo3MSPeV-B5ZI_WrQ,7004
-ekfsm/devices/smbios.py,sha256=4P-sxOW27pkzIfVlvFNyVJOcZlYgk2KCTCEUvKf5D94,1067
+ekfsm/devices/pixelDisplay.py,sha256=Td-MhNYzJVcDrFzjTcnyrOYpXn2oz5w9YOttJqHZMD4,4573
+ekfsm/devices/pmbus.py,sha256=-3p-D0w4smzRCeqZWCure8I2Lx4y310kG1U0Rmr890c,7104
+ekfsm/devices/smbios.py,sha256=rH60ixqSGv_b5TgloJjH_kwZShefFnlCebQDpdQZx7M,1803
 ekfsm/devices/smbus.py,sha256=kbtjEnfrVI6lbfqAbojVqO5nnnpa6HanLf0X2iZjgCg,500
-ekfsm/devices/thermal_humidity.py,sha256=HnoiR3mZxwuE74KTFiRhG4Znq21vgcyMFJizSCnULzw,1207
+ekfsm/devices/thermal_humidity.py,sha256=t848kJArG0VAEX5nOnRKomdFdx4wxFflBGMsg_wgZKw,2386
 ekfsm/devices/utils.py,sha256=qeDNpTpQ3bLGYERAH5lMsifmOaEcQ32FOwEt8tvmjWU,174
-ekfsm/devices/watchdog.py,sha256=QjzvXrXV_XRvCYiy-sr6LOMJywb84aNThuDpsWGvxZk,1202
-ekfsm-1.4.0a43.dist-info/METADATA,sha256=VntlMZhuL2I0H21H89ri0KHMJqk8s9KF7QDcl1zslnw,6717
-ekfsm-1.4.0a43.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ekfsm-1.4.0a43.dist-info/entry_points.txt,sha256=WhUR4FzuxPoGrbTOKLsNJO7NAnk2qd4T30fqzN1yLw8,45
-ekfsm-1.4.0a43.dist-info/RECORD,,
+ekfsm/devices/watchdog.py,sha256=SEsF9dztlLfUSvD5r9yMWegXtsefwGXY3W1oJE63OMs,2224
+ekfsm-1.4.0a60.dist-info/METADATA,sha256=f2WxM9_C4gbDC_aYv2q5y8iHf8zmlqUg-H8Uz7E1hWw,6725
+ekfsm-1.4.0a60.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ekfsm-1.4.0a60.dist-info/entry_points.txt,sha256=WhUR4FzuxPoGrbTOKLsNJO7NAnk2qd4T30fqzN1yLw8,45
+ekfsm-1.4.0a60.dist-info/RECORD,,