ekfsm 0.13.0a183__py3-none-any.whl → 1.5.0__py3-none-any.whl

ekfsm/devices/imu.py

@@ -2,10 +2,14 @@ class ImuSample:
     """
     Class to store IMU data sample
 
-    * accel: list[float] - Accelerometer data in m/s^2, [x, y, z]
-    * gyro: list[float] - Gyroscope data in degrees/s, [x, y, z]
-    * lost: bool - True if data was lost before that sample
-
+    Parameters
+    ----------
+    accel
+        Accelerometer data in m/s^2, [x, y, z]
+    gyro
+        Gyroscope data in degrees/s, [x, y, z]
+    lost
+        True if data was lost before that sample
     """
 
     def __init__(self, accel: list[float], gyro: list[float], lost: bool):

ekfsm/devices/io4edge.py

@@ -0,0 +1,185 @@
+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 CClient
+from io4edge_client.binaryiotypeb import Client
+
+from re import sub
+
+logger = ekfsm_logger(__name__)
+
+
+class IO4Edge(Device):
+    """
+    Device class for handling IO4Edge devices.
+
+    See https://docs.ci4rail.com/user-docs/io4edge/ for more information.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        parent: HWModule | None = None,
+        children: list[Device] | None = None,
+        abort: bool = False,
+        *args,
+        **kwargs,
+    ):
+        logger.debug("Initializing IO4Edge device '%s'", 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(
+                "Slot attributes for %s are not set or do not contain 'slot_coding'",
+                self.hw_module.slot.name,
+            )
+            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("IO4Edge '%s' geo address: %s", name, geoaddr)
+
+        _, module_name = sub(r"-.*$", "", self.hw_module.board_type).split(maxsplit=1)
+        self._module_name = module_name
+        logger.debug("IO4Edge '%s' module name: %s", name, module_name)
+
+        try:
+            self.client = CClient.new_core_client(self.deviceId)
+            logger.info(
+                "IO4Edge '%s' initialized with device ID: %s", name, self.deviceId
+            )
+        except Exception as e:
+            logger.error("Failed to create IO4Edge core client for '%s': %s", 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]:
+        """
+        Identify the firmware on the IO4Edge device.
+
+        Returns
+        -------
+            A tuple containing the firmware title and version.
+        """
+        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:
+        """
+        Restart the IO4Edge device.
+
+        Important
+        ---------
+            This will disconnect the client from the device.
+        """
+        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}"
+
+
+class GPIOArray(Device):
+    """
+    Device class for handling an io4edge GPIO array.
+    """
+
+    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(
+            "Initializing GPIOArray '%s' with parent device %s", name, 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("Using custom service suffix: %s", service_suffix)
+        else:
+            self.service_suffix = name
+            logger.debug("Using default service suffix: %s", name)
+
+        self.deviceId = parent.deviceId
+        self.service_addr = f"{self.deviceId}-{self.service_suffix}"
+        self.timeout = int(keepaliveInterval / 1000 + 5)
+
+        logger.info(
+            "GPIOArray '%s' configured with service address: %s",
+            name,
+            self.service_addr,
+        )
+
+        try:
+            self.client = Client(
+                self.service_addr, command_timeout=self.timeout, connect=False
+            )
+            logger.debug("IO4Edge client created for service: %s", self.service_addr)
+        except Exception as e:
+            logger.error(
+                "Failed to create IO4Edge client for %s: %s", self.service_addr, e
+            )
+            raise
+
+    def __repr__(self):
+        return f"{self.name}; Service Address: {self.service_addr}"

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}"

ekfsm/devices/mux.py

@@ -1,39 +1,77 @@
 from ekfsm.core.components import SysTree
+from ekfsm.exceptions import ConfigError
+from ekfsm.log import ekfsm_logger
 
-from ..core.sysfs import SysFSDevice
+from ..core.sysfs import SysfsDevice
 from .generic import Device
 
+logger = ekfsm_logger(__name__)
+
 
 class MuxChannel(Device):
+    """
+    A MuxChannel is a device that represents a channel on an I2C multiplexer.
+    It is a child of the I2CMux device.
+    The MuxChannel device is used to access the I2C bus on the channel.
+
+    Parameters
+    ----------
+    name
+        The name of the device.
+    channel_id
+        The channel ID of the device.
+    parent
+        The parent device of the MuxChannel.
+    children
+        The children of the MuxChannel device. If None, no children are created.
+    """
+
     def __init__(
         self,
         name: str,
-        channel_id: int,
         parent: "I2CMux",
         children: list[Device] | None = None,
+        abort=False,
+        channel_id: int | None = None,
         *args,
         **kwargs,
     ) -> None:
-        super().__init__(name=name, parent=parent, children=children)
+        super().__init__(name, parent, children, abort, *args, **kwargs)
         self.channel_id = channel_id
 
-        assert parent.sysfs_device is not None
-        assert isinstance(self.parent, I2CMux)
+        if parent.sysfs_device is None:
+            raise ConfigError(f"{self.name}: Parent I2CMux must have a sysfs_device")
+        if not isinstance(self.parent, I2CMux):
+            raise ConfigError(f"{self.name}: Parent must be an I2CMux instance")
 
         path = parent.sysfs_device.path / f"channel-{self.channel_id}"
-        self.sysfs_device = SysFSDevice(path)
+        self.sysfs_device = SysfsDevice(path, False)
 
 
 class I2CMux(Device):
+    """
+    This class represents an I2C multiplexer device.
+
+    Parameters
+    ----------
+    name
+        The name of the device.
+    parent
+        The parent device of the I2CMux device. If None, no parent is created.
+    children
+        The children of the I2CMux device. If None, no children are created.
+    """
+
     def __init__(
         self,
         name: str,
         parent: SysTree | None = None,
-        children: list[MuxChannel] | None = None,
+        children: list[Device] | None = None,
+        abort=False,
         *args,
         **kwargs,
     ):
-        super().__init__(name, parent, children, **kwargs)
+        super().__init__(name, parent, children, abort, *args, **kwargs)
 
         self.addr = self.get_i2c_chip_addr()
         self.sysfs_device = self.get_i2c_sysfs_device(self.addr)

ekfsm/devices/pixelDisplay.py

@@ -0,0 +1,141 @@
+from ekfsm.devices.generic import Device
+from ekfsm.devices.io4edge import IO4Edge
+from ekfsm.devices.utils import retry
+from ekfsm.log import ekfsm_logger
+from io4edge_client.pixelDisplay import Client
+from PIL import Image
+
+logger = ekfsm_logger(__name__)
+
+
+class PixelDisplay(Device):
+    """
+    Device class for handling a pixel display.
+    """
+
+    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 PixelDisplay '{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"PixelDisplay '{name}' configured with service address: {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
+
+    @retry()
+    def describe(self) -> dict:
+        """
+        Returns a description of the pixel display.
+        """
+        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:
+        """
+        Returns the height of the pixel display in pixels.
+        """
+        return self.describe()["height"]
+
+    @property
+    def width(self) -> int:
+        """
+        Returns the width of the pixel display in pixels.
+        """
+        return self.describe()["width"]
+
+    @retry()
+    def off(self) -> None:
+        """
+        Turn off the pixel display.
+        @raises RuntimeError: if the command fails
+        @raises TimeoutError: if the command times out
+        """
+        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
+
+    @retry()
+    def display_image(self, path: str) -> None:
+        """
+        Display an image on the pixel display.
+        @raises RuntimeError: if the command fails
+        @raises TimeoutError: if the command times out
+        """
+        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}"