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

ekfsm/devices/buttons.py

@@ -0,0 +1,251 @@
+import threading
+from typing import Callable
+from ekfsm.devices.utils import retry
+from io4edge_client.binaryiotypeb import Pb
+from ekfsm.devices.generic import Device
+from ekfsm.devices.io4edge import GPIOArray
+from ekfsm.log import ekfsm_logger
+import io4edge_client.functionblock as fb
+
+logger = ekfsm_logger(__name__)
+
+
+class Button(Device):
+    """
+    Device class for handling a single button as part on array.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        parent: Device,
+        children: list[Device] | None = None,
+        abort: bool = False,
+        channel_id: int = 0,
+        *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):
+        """
+        Handle button events with a callback function.
+        """
+        return self._handler
+
+    @handler.setter
+    def handler(self, func: Callable | None, *args, **kwargs):
+        """
+        Handle button events with a callback function.
+
+        Parameters
+        ----------
+        func : Callable | None
+            The function to call on button events. If None, no function is called.
+        """
+        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}"
+
+
+class ButtonArray(Device):
+    """
+    Device class for handling an io4edge gpio based 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: GPIOArray,
+        children: list[Device] | None = None,
+        abort: bool = False,
+        keepaliveInterval: int = 10000,
+        *args,
+        **kwargs,
+    ):
+        logger.debug(
+            f"Initializing ButtonArray '{name}' with parent device {parent.deviceId}"
+        )
+
+        super().__init__(name, parent, children, abort, *args, **kwargs)
+
+        self.name = name
+
+        self.service_addr = parent.service_addr
+        self.client = parent.client
+
+        logger.info(
+            f"ButtonArray '{name}' configured with service address: {self.service_addr}"
+        )
+
+        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}"
+        )
+        # 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]
+
+        try:
+            self._button_event_handling(
+                stop_event,
+                timeout,
+                subscribe_channels,
+                button_channels,
+                channel_ids,
+            )
+        except Exception as e:
+            logger.error(
+                f"Failed to establish connection or start stream for ButtonArray '{self.name}': {e}"
+            )
+            raise
+
+    @retry()
+    def _button_event_handling(
+        self,
+        stop_event: threading.Event | None,
+        timeout: float,
+        subscribe_channels: tuple,
+        button_channels: list,
+        channel_ids: list,
+    ):
+        with self.client as client:
+            logger.debug(f"IO4Edge client connected to service: {self.service_addr}")
+
+            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")
+
+    def __repr__(self):
+        return f"{self.name}; Service Address: {self.service_addr}"

ekfsm/devices/colorLed.py

@@ -0,0 +1,110 @@
+from ekfsm.devices.generic import Device
+from ekfsm.devices.ledArray import LEDArray
+from ekfsm.devices.utils import retry
+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"
+        )
+
+    @retry()
+    def describe(self):
+        pass
+
+    @retry()
+    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.info(
+            "Getting color LED state for '%s' on channel %s", self.name, self.channel_id
+        )
+        try:
+            result = self.client.get(self.channel_id)
+            color, blink = result
+            logger.info(
+                "ColorLED '%s' state: color=%s, blink=%s", self.name, color, blink
+            )
+            return result
+        except Exception as e:
+            logger.error(
+                "Failed to get ColorLED '%s' state on channel %s: %s",
+                self.name,
+                self.channel_id,
+                e,
+            )
+            raise
+
+    @retry()
+    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

@@ -1,13 +1,18 @@
 from __future__ import annotations
-import os
+
 import glob
+import os
 from pathlib import Path
 
-from ekfsm.core.sysfs import SYSFS_ROOT
+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")
+HWMON_ROOT = sysfs_root() / Path("class/hwmon")
 
 
 def find_core_temp_dir(hwmon_dir) -> Path:
@@ -38,28 +43,33 @@ def find_core_temp_dir(hwmon_dir) -> Path:
 
 class CoreTemp(Device):
     """
-    A class to represent the HWMON device.
-
-    A HWMON device is a virtual device that is used to read hardware monitoring values from the sysfs filesystem.
+    This class provides an interface to read the CPU core temperature from the HWMON device.
 
     Note:
-    Currently, only the CPU temperature is read from the HWMON device.
+    Currently, only the average temperature over all cores is read from the HWMON device.
     """
 
     def __init__(
         self,
         name: str,
         parent: Device,
+        children: list["Device"] | None = None,
+        abort: bool = False,
         *args,
         **kwargs,
     ):
-        from ekfsm.core.sysfs import SysFSDevice, SYSFS_ROOT
+        logger.debug(f"Initializing CoreTemp device '{name}'")
 
-        self.sysfs_device: SysFSDevice = SysFSDevice(
-            find_core_temp_dir(SYSFS_ROOT / Path("class/hwmon"))
-        )
+        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, *args, **kwargs)
+        super().__init__(name, parent, None, abort, *args, **kwargs)
 
     def cputemp(self):
         """
@@ -70,4 +80,16 @@ class CoreTemp(Device):
         int
             The CPU temperature in degrees Celsius.
         """
-        return int(self.sysfs_device.read_attr_utf8("temp1_input").strip()) / 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

@@ -11,20 +11,18 @@ Routine Listings
 
 from abc import ABC, abstractmethod
 from datetime import date
-from typing import Any, Callable, Literal, Sequence
 from functools import wraps
+from typing import Any, Callable, Literal, Sequence
 
-from ekfsm.core.components import SysTree
-from ekfsm.core.probe import ProbeableDevice
-
-from .generic import Device
-from .utils import compute_int_from_bytes, get_crc16_xmodem
-from ekfsm.exceptions import DataCorruptionError
 from hexdump import hexdump
 
+from ekfsm.core.components import SysTree
+from ekfsm.core.probe import ProbeableDevice
+from ekfsm.exceptions import DataCorruptionError, DriverError, SysFSError
 from ekfsm.log import ekfsm_logger
 
-__all__ = ["EEPROM", "Validatable_EEPROM", "EKF_EEPROM", "validated"]
+from .generic import Device
+from .utils import get_crc16_xmodem
 
 logger = ekfsm_logger(__name__)
 
@@ -82,13 +80,19 @@ class EEPROM(Device):
         self,
         name: str,
         parent: SysTree | None = None,
+        children: list[Device] | None = None,
+        abort: bool = False,
         *args,
         **kwargs,
     ):
-        super().__init__(name, parent, None, *args, **kwargs)
+        super().__init__(name, parent, None, abort, *args, **kwargs)
 
         self.addr = self.get_i2c_chip_addr()
         self.sysfs_device = self.get_i2c_sysfs_device(self.addr)
+
+        if not self.sysfs_device.get_driver():
+            raise DriverError("No driver attached to device {self.name}")
+
         self._update_content()
 
     def _update_content(self) -> None:
@@ -119,20 +123,10 @@ class EEPROM(Device):
 
         Raises
         ------
-        FileNotFoundError
-            If the EEPROM sysfs file is not found.
-        RuntimeError
-            If the sysfs device is not found.
+        SysFSError
+            No sysfs device found for EEPROM or `eeprom` attribute does not exist
         """
-        try:
-            if self.sysfs_device:
-                cnt = self.sysfs_device.read_attr_bytes("eeprom")
-            else:
-                raise RuntimeError("No sysfs device for EEPROM")
-        except FileNotFoundError:
-            raise FileNotFoundError("EEPROM not found")
-
-        return cnt
+        return self.read_sysfs_bytes("eeprom")
 
     def write(self, data: bytes, offset: int = 0) -> None:
         """
@@ -157,15 +151,27 @@ class EEPROM(Device):
         Note
         ----
         Operation is checked for data corruption by reading back the written data.
+
+        Important
+        ---------
+        The offset parameter is only supported if the EEPROM driver is bin_attribute enabled.
+
+        For almost any other native sysfs attribute, this is NOT the case!
         """
-        try:
-            if self.sysfs_device:
-                logger.info(f"Writing {len(data)} bytes to EEPROM at offset {offset}")
-                self.sysfs_device.write_attr("eeprom", data, offset)
-            else:
-                raise RuntimeError("No sysfs device for EEPROM")
-        except FileNotFoundError:
-            raise FileNotFoundError("EEPROM not found")
+
+        if self.sysfs_device:
+            attr = next(x for x in self.sysfs_device.attributes if x.name == "eeprom")
+            logger.info(f"Writing {len(data)} bytes to EEPROM at offset {offset}")
+            if attr.is_sysfs_attr() and data is not None:
+                mode = "r+" if isinstance(data, str) else "rb+"
+            try:
+                with open(attr.path, mode) as f:
+                    f.seek(offset)
+                    f.write(data)
+            except OSError as e:
+                raise SysFSError("Error accessing SysFS attribute") from e
+        else:
+            raise RuntimeError("No sysfs device for EEPROM")
 
         self._update_content()
         written = self._content[offset : offset + len(data)]
@@ -204,6 +210,10 @@ class Validatable_EEPROM(EEPROM, ABC):
 
     def __init__(
         self,
+        name: str,
+        parent: SysTree | None = None,
+        children: list[Device] | None = None,
+        abort: bool = False,
         crc_pos: Literal["start", "end"] = "end",
         crc_length: int = 2,
         *args,
@@ -212,7 +222,7 @@ class Validatable_EEPROM(EEPROM, ABC):
         self._crc_length: int = crc_length
         self._crc_pos: str = crc_pos
 
-        super().__init__(*args, **kwargs)
+        super().__init__(name, parent, children, abort, *args, **kwargs)
 
         self._crc_pos_start = len(self._data) if self._crc_pos == "end" else 0
         self._crc_pos_end = self._crc_pos_start + self._crc_length
@@ -390,13 +400,16 @@ class EKF_EEPROM(Validatable_EEPROM, ProbeableDevice):
 
     def __init__(
         self,
+        name: str,
+        parent: SysTree | None = None,
+        children: list[Device] | None = None,
+        abort: bool = False,
         *args,
         **kwargs,
     ) -> None:
-        super().__init__(*args, **kwargs)
+        super().__init__(name, parent, children, abort, *args, **kwargs)
 
     def _update_content(self) -> None:
-
         super()._update_content()
 
         # EKF EEPROM content is restricted to 128 bytes, so strip the rest!
@@ -426,7 +439,7 @@ class EKF_EEPROM(Validatable_EEPROM, ProbeableDevice):
             The serial number of the root device.
         """
         area = self._content[self._sernum_index_start : self._sernum_index_end]
-        sernum = compute_int_from_bytes(area[::-1])
+        sernum = int.from_bytes(area, byteorder="little")
         return str(sernum)
 
     def write_serial(self, serial: int) -> None:
@@ -463,7 +476,7 @@ class EKF_EEPROM(Validatable_EEPROM, ProbeableDevice):
         area = self._content[
             self._customer_serial_index_start : self._customer_serial_index_end
         ]
-        sernum = compute_int_from_bytes(area[::-1])
+        sernum = int.from_bytes(area, byteorder="little")
         return str(sernum)
 
     def write_custom_serial(self, serial: int) -> None:
@@ -507,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:
@@ -520,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:
@@ -692,8 +705,7 @@ class EKF_EEPROM(Validatable_EEPROM, ProbeableDevice):
         date
             The decoded date.
         """
-        encoded_date = encoded_date[::-1]
-        bdate = compute_int_from_bytes(encoded_date)
+        bdate = int.from_bytes(encoded_date, byteorder="little")
 
         # Extract the day (bit 0-4)
         day = bdate & 0x1F  # 0x1F is 00011111 in binary (5 bits)
@@ -715,7 +727,7 @@ class EKF_EEPROM(Validatable_EEPROM, ProbeableDevice):
             )  # Handle invalid dates, e.g., 30th Feb
 
     @classmethod
-    def _encode_date(self, date: date) -> bytes:
+    def _encode_date(cls, date: date) -> bytes:
         """
         Encode a date into a proprietary 2-byte format.
 
@@ -774,7 +786,6 @@ class EKF_CCU_EEPROM(EKF_EEPROM):
         super().__init__(*args, **kwargs)
 
     def _update_content(self) -> None:
-
         super()._update_content()
 
         # CCU content is the raw content area of the EEPROM
@@ -935,7 +946,7 @@ class EKF_CCU_EEPROM(EKF_EEPROM):
         area = self._content[
             self._cserial_index_start : self._cserial_index_start + self._cserial_length
         ]
-        cserial = compute_int_from_bytes(area[::-1])
+        cserial = int.from_bytes(area, byteorder="little")
         return cserial
 
     def write_cserial(self, serial: int) -> None:
@@ -1000,7 +1011,7 @@ class EKF_CCU_EEPROM(EKF_EEPROM):
             The unit number of the subsystem.
         """
         area = self._content[self._unit_index_start]
-        unit = compute_int_from_bytes([area])
+        unit = int.from_bytes([area], byteorder="little")
         return unit
 
     @validated
@@ -1069,6 +1080,23 @@ class EKF_CCU_EEPROM(EKF_EEPROM):
     def write_customer_area(self, data: bytes) -> None:
         """
         Write data to CCU EEPROM customer area.
+
+        Parameters
+        ----------
+        data
+            The data to write to the customer area of the CCU EEPROM.
+
+        Raises
+        ------
+        ValueError
+            If the data exceeds the customer area length.
+
+        Example
+        -------
+        >>> eeprom = EKF_CCU_EEPROM()
+        >>> eeprom.write_customer_area(b"Hello, World!")
+        >>> eeprom.customer_area()
+        b'Hello, World!'
         """
         if len(data) > self._customer_area_length:
             raise ValueError("Data exceeds customer area length")