ekfsm 1.3.0a26__py3-none-any.whl → 1.4.0__py3-none-any.whl

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

@@ -0,0 +1,101 @@
+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):
+    """
+    Device class for handling a color LED.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        parent: LEDArray,
+        children: list[Device] | None = None,
+        abort: bool = False,
+        channel_id: int = 0,
+        *args,
+        **kwargs,
+    ):
+        logger.debug(f"Initializing ColorLED '{name}' on channel {channel_id}")
+
+        super().__init__(name, parent, children, abort, *args, **kwargs)
+
+        self.name = name
+        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
+
+    def get(self) -> tuple[Color, bool]:
+        """
+        Get color LED state.
+
+        Returns
+        -------
+            Current color and blink state.
+
+        Raises
+        ------
+        RuntimeError
+            if the command fails
+        TimeoutError
+            if the command times out
+        """
+        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:
+        """
+        Set the color of the color LED.
+
+        Parameters
+        ----------
+        color : Color
+            The color to set the LED to.
+        blink : bool
+            Whether to blink the LED.
+
+        Raises
+        ------
+        RuntimeError
+            if the command fails
+        TimeoutError
+            if the command times out
+        """
+        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

@@ -0,0 +1,110 @@
+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):
+    """
+    Device class for handling IO4Edge devices.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        parent: HWModule | None = None,
+        children: list[Device] | None = None,
+        abort: bool = False,
+        *args,
+        **kwargs,
+    ):
+        logger.debug(f"Initializing IO4Edge device '{name}'")
+
+        super().__init__(name, parent, children, abort, *args, **kwargs)
+
+        attr = self.hw_module.slot.attributes
+        if (
+            attr is None
+            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
+        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:
+        """
+        Returns the device ID for the IO4Edge device.
+        The device ID is a combination of the module name and the geo address.
+        """
+        return f"{self._module_name}-geo_addr{self._geoaddr:02d}"
+
+    def identify_firmware(self) -> tuple[str, str]:
+        response = self.client.identify_firmware()
+        return (
+            response.title,
+            response.version,
+        )
+
+    def load_firmware(
+        self, cfg: bytes, progress_callback: Optional[Callable[[float], None]] = None
+    ) -> None:
+        """
+        Load firmware onto the IO4Edge device.
+
+        cfg
+            Firmware configuration bytes.
+        progress_callback
+            Optional callback for progress updates.
+        """
+        self.client.load_firmware(cfg, progress_callback)
+
+    def restart(self) -> None:
+        self.client.restart()
+
+    def load_parameter(self, name: str, value: str) -> None:
+        """
+        Set a parameter onto the IO4Edge device.
+
+        cfg
+            The name of the parameter to load.
+        value
+            The value to set for the parameter.
+        """
+        self.client.set_persistent_parameter(name, value)
+
+    def get_parameter(self, name: str) -> str:
+        """
+        Get a parameter value from the IO4Edge device.
+
+        Returns
+            The value of the requested parameter.
+        """
+        return self.client.get_persistent_parameter(name)
+
+    def __repr__(self):
+        return f"{self.name}; DeviceId: {self.deviceId}"

ekfsm/devices/ledArray.py

@@ -0,0 +1,54 @@
+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):
+    """
+    Device class for handling a LED array.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        parent: IO4Edge,
+        children: list[Device] | None = None,
+        abort: bool = False,
+        service_suffix: str | None = None,
+        *args,
+        **kwargs,
+    ):
+        logger.debug(
+            f"Initializing LEDArray '{name}' with parent device {parent.deviceId}"
+        )
+
+        super().__init__(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}"
+        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}"