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

ekfsm/boards/oem/ekf/sq3-quartet.yaml

@@ -2,40 +2,54 @@ id: 69
 name: "EKF SQ3-QUARTET"
 slot_type: CPCI_S0_PER
 children:
-    - device_type: I2CMux
-      name: "MUX"
-      addr: 0x70
-      slot_coding_mask: 0x07
-      children:
-        - device_type: MuxChannel
-          name: "CH00"
-          channel_id: 0
-          children:
-            - device_type: EKFIdentificationIOExpander
-              name: "GPIO"
-              addr: 0x3D
-              provides:
-                inventory:
-                  - revision
-            - device_type: EKF_EEPROM
-              name: "EEPROM"
-              addr: 0x55
-              provides:
-                inventory:
-                  - vendor
-                  - serial
-                  - model
-                  - repaired_at
-                  - manufactured_at
-        - device_type: MuxChannel
-          name: "CH01"
-          channel_id: 1
-          children:
-        - device_type: MuxChannel
-          name: "CH02"
-          channel_id: 2
-          children:
-        - device_type: MuxChannel
-          name: "CH03"
-          channel_id: 3
-          children:
+  - device_type: IO4Edge
+    name: "BMC"
+    children:
+      - device_type: PixelDisplay
+        name: "display"
+      - device_type: ButtonArray
+        name: "buttons"
+        children:
+          - device_type: Button
+            name: "up"
+            channel_id: 0
+          - device_type: Button
+            name: "down"
+            channel_id: 1
+  - device_type: I2CMux
+    name: "MUX"
+    addr: 0x70
+    slot_coding_mask: 0x07
+    children:
+      - device_type: MuxChannel
+        name: "CH00"
+        channel_id: 0
+        children:
+          - device_type: EKFIdentificationIOExpander
+            name: "GPIO"
+            addr: 0x3D
+            provides:
+              inventory:
+                - revision
+          - device_type: EKF_EEPROM
+            name: "EEPROM"
+            addr: 0x55
+            provides:
+              inventory:
+                - vendor
+                - serial
+                - model
+                - repaired_at
+                - manufactured_at
+      - device_type: MuxChannel
+        name: "CH01"
+        channel_id: 1
+        children:
+      - device_type: MuxChannel
+        name: "CH02"
+        channel_id: 2
+        children:
+      - device_type: MuxChannel
+        name: "CH03"
+        channel_id: 3
+        children:

ekfsm/boards/oem/ekf/z1010.yaml

@@ -0,0 +1,94 @@
+id: 112
+name: "EKF Z1010"
+slot_type: CPCI_S0_UTILITY
+children:
+  - device_type: I2CMux
+    name: "MUX"
+    addr: 0x70
+    slot_coding_mask: 0x0
+    children:
+      - device_type: MuxChannel
+        name: "CH00"
+        channel_id: 0
+        children:
+          - device_type: EKFIdentificationIOExpander
+            name: "GPIO"
+            addr: 0x3D
+            provides:
+              inventory:
+                - revision
+          - device_type: EKF_EEPROM
+            name: "EEPROM"
+            addr: 0x55
+            provides:
+              inventory:
+                - vendor
+                - serial
+                - model
+                - repaired_at
+                - manufactured_at
+              # chassis_inventory:
+              #   - revision: crevision
+              #   - write_revision: write_crevision
+              #   - vendor: cvendor
+              #   - write_vendor: write_cvendor
+              #   - serial: cserial
+              #   - write_serial: write_cserial
+              #   - model: cmodel
+              #   - write_model: write_cmodel
+              #   - unit
+              #   - write_unit
+              # custom_eeprom:
+              #   - write: write_customer_area
+              #   - read: customer_area
+  - device_type: IO4Edge
+    name: "I4E"
+    provides:
+      management:
+        - identify_firmware
+        - load_firmware
+        - load_parameter
+        - get_parameter
+        - restart
+    children:
+      - device_type: LEDArray
+        name: "leds"
+        children:
+          - device_type: ColorLED
+            name: "led0"
+            channel_id: 0
+          - device_type: ColorLED
+            name: "led1"
+            channel_id: 1
+          - device_type: ColorLED
+            name: "led2"
+            channel_id: 2
+          - device_type: ColorLED
+            name: "led3"
+            channel_id: 3
+          - device_type: ColorLED
+            name: "led4"
+            channel_id: 4
+          - device_type: ColorLED
+            name: "led5"
+            channel_id: 5
+          - device_type: ColorLED
+            name: "led6"
+            channel_id: 6
+          - device_type: ColorLED
+            name: "led7"
+            channel_id: 7
+      - device_type: Watchdog
+        name: "watchdog"
+        provides:
+          sysstate:
+            - 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/components.py

@@ -51,7 +51,7 @@ class HWModule(SysTree):
         *args,
         **kwargs,
     ) -> None:
-        from ekfsm.core.utils import deserialize_hardware_tree
+        from ekfsm.core.utils import deserialize_hardware_tree, deserialize_module
 
         from .slots import SlotType
 
@@ -59,9 +59,8 @@ class HWModule(SysTree):
         self._slot: Slot = slot
         self.config = config
 
-        self.id, self.board_type, slot_type, self.children = deserialize_hardware_tree(
-            self.logger, self.config, parent=self
-        )
+        self.id, self.board_type, slot_type = deserialize_module(self.logger, config)
+        self.children = deserialize_hardware_tree(self.logger, self.config, parent=self)
 
         self.slot_type = SlotType.from_string(slot_type)
 

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/slots.py

@@ -102,7 +102,9 @@ class Slot:
         }
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(name={self._name}, slot_type={self.slot_type})"
+        return (
+            f"{self.__class__.__name__}(name={self._name}, slot_type={self.slot_type})"
+        )
 
     @property
     def name(self) -> str:
@@ -123,7 +125,10 @@ class Slot:
         """
         Return True if the slot is populated with the desired hardware module type, False otherwise.
         """
-        return self.hwmodule is not None and self.hwmodule.board_type.lower() == self._desired_hwmodule_type.lower()
+        return (
+            self.hwmodule is not None
+            and self.hwmodule.board_type.lower() == self._desired_hwmodule_type.lower()
+        )
 
 
 class Slots(Munch):

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/core/utils.py

@@ -55,10 +55,14 @@ def import_board(logger: logging.Logger, data, parent=None, abort: bool = False)
                 import_board(logger, data=child, parent=node, abort=abort)
             except Exception as e:
                 if abort:
-                    logger.error(f"Failed to import sub device {pformat(child)}: {e}. Aborting.")
+                    logger.error(
+                        f"Failed to import sub device {pformat(child)}: {e}. Aborting."
+                    )
                     raise e
                 else:
-                    logger.error(f"Failed to import sub device {pformat(child)}: {e}. Continuing anyway.")
+                    logger.error(
+                        f"Failed to import sub device {pformat(child)}: {e}. Continuing anyway."
+                    )
     return node
 
 
@@ -69,7 +73,9 @@ def provides_validator(x: Any) -> Any:
         key, value = next(iter(x.items()))
         if isinstance(key, str) and isinstance(value, str):
             return x
-    raise SchemaError("Each provides item must be either a string or a dictionary with one string key/value pair")
+    raise SchemaError(
+        "Each provides item must be either a string or a dictionary with one string key/value pair"
+    )
 
 
 device_schema = Schema({})
@@ -81,6 +87,8 @@ _device_structure = Schema(
         Optional("addr"): int,
         Optional("slot_coding_mask"): int,
         Optional("channel_id"): int,
+        Optional("service_suffix"): str,
+        Optional("keepaliveInterval"): int,
         Optional("provides"): {
             Optional(str): [Use(provides_validator)],
         },
@@ -103,30 +111,46 @@ module_schema = Schema(
 )
 
 
+def deserialize_module(logger: logging.Logger, data: dict) -> tuple[str, str, str]:
+    """
+    docstring
+    """
+    module_schema.validate(data)
+
+    id, name, slot_type = (data[key] for key in ["id", "name", "slot_type"])
+    logger.debug(colored(f"Importing top level module {pformat(name)}", "green"))
+
+    return id, name, slot_type
+
+
 def deserialize_hardware_tree(
     logger: logging.Logger, data: dict, parent: "HWModule"
-) -> tuple[str, str, str, list["Device"]]:
+) -> list["Device"]:
     abort = parent.abort
 
     module_schema.validate(data)
 
-    id, name, slot_type = (data.pop(key) for key in ["id", "name", "slot_type"])
-
     children = data.pop("children", None)
     if not children:
-        return id, name, slot_type, []
+        return []
 
     devices = []
     for child in children:
         try:
-            logger.debug(colored(f"Importing top level device {pformat(child)}", "green"))
+            logger.debug(
+                colored(f"Importing top level device {pformat(child)}", "green")
+            )
 
             node = import_board(logger, child, parent=parent, abort=abort)
             devices.append(node)
         except Exception as e:
-            logger.error(colored(f"Failed to import top-level device {pformat(child)}: {e}", "red"))
+            logger.error(
+                colored(
+                    f"Failed to import top-level device {pformat(child)}: {e}", "red"
+                )
+            )
             logger.error(colored("Aborting." if abort else "Continuing anyway", "red"))
             if abort:
                 raise
 
-    return id, name, slot_type, devices
+    return devices

ekfsm/devices/__init__.py

@@ -1,6 +1,7 @@
 from ekfsm.devices.coretemp import CoreTemp
 from ekfsm.devices.generic import Device
 from ekfsm.devices.smbios import SMBIOS
+from ekfsm.devices.thermal_humidity import ThermalHumidity
 
 from .eeprom import EEPROM, EKF_CCU_EEPROM, EKF_EEPROM
 from .ekf_ccu_uc import EKFCcuUc
@@ -9,6 +10,13 @@ from .gpio import GPIO, EKFIdentificationIOExpander, GPIOExpander
 from .iio_thermal_humidity import IIOThermalHumidity
 from .mux import I2CMux, MuxChannel
 from .pmbus import PMBus, PSUStatus
+from .io4edge import IO4Edge
+from .pixelDisplay import PixelDisplay
+from .buttonArray import ButtonArray
+from .button import Button
+from .colorLed import ColorLED
+from .ledArray import LEDArray
+from .watchdog import Watchdog
 
 CLASS_MAP = {
     "GenericDevice": Device,
@@ -27,4 +35,12 @@ CLASS_MAP = {
     "HWMON": CoreTemp,
     "EKFSurLed": EKFSurLed,
     "IIOThermalHumidity": IIOThermalHumidity,
+    "ThermalHumidity": ThermalHumidity,
+    "IO4Edge": IO4Edge,
+    "PixelDisplay": PixelDisplay,
+    "ButtonArray": ButtonArray,
+    "Button": Button,
+    "ColorLED": ColorLED,
+    "LEDArray": LEDArray,
+    "Watchdog": Watchdog,
 }

ekfsm/devices/button.py

@@ -0,0 +1,65 @@
+from typing import Callable
+from ekfsm.devices.generic import Device
+from ekfsm.log import ekfsm_logger
+
+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}"