ekfsm 0.11.0b1.post3__py3-none-any.whl

ekfsm/devices/gpio.py

@@ -0,0 +1,340 @@
+from abc import ABC, abstractmethod
+import os
+import re
+from pathlib import Path
+
+import gpiod
+from gpiod.chip import LineSettings
+from gpiod.line import Direction, Value
+from more_itertools import first_true
+
+from ekfsm.core.components import SystemComponent
+from ekfsm.exceptions import GPIOError
+from ekfsm.log import ekfsm_logger
+
+from .generic import Device
+from ..core.probe import ProbeableDevice
+
+gpio_pat = re.compile(r"gpiochip\d+")
+
+
+def get_gpio_major_minor(path: Path) -> tuple[int, int]:
+    for d in path.iterdir():
+        if gpio_pat.match(d.name):
+            dev = d / "dev"
+            if dev.exists():
+                content = dev.read_text().strip()
+                major, minor = map(int, content.split(":"))
+                return major, minor
+
+    raise GPIOError(
+        GPIOError.ErrorType.NO_MAJOR_MINOR,
+        f"No minor/major number found for GPIO device at {path}",
+    )
+
+
+def find_gpio_dev_with_major_minor(major: int, minor: int) -> Path | None:
+    for dev in Path("/dev").iterdir():
+        if gpio_pat.match(dev.name):
+            stat_info = dev.stat()
+
+            cmaj = os.major(stat_info.st_rdev)
+            cmin = os.minor(stat_info.st_rdev)
+
+            if cmaj == major and cmin == minor:
+                return dev
+
+    raise GPIOError(
+        GPIOError.ErrorType.NO_MATCHING_DEVICE,
+        f"Failed to find GPIO device with major {major} and minor {minor}",
+    )
+
+
+class GPIO(Device):
+
+    def __init__(
+        self,
+        name: str,
+        parent: SystemComponent | None = None,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(
+            name,
+            parent,
+            None,
+            *args,
+            **kwargs,
+        )
+        self.logger = ekfsm_logger("GPIODevice" + name)
+        major, minor = self._find_gpio_dev(parent, *args, **kwargs)
+        self.gpio = find_gpio_dev_with_major_minor(major, minor)
+
+        assert self.gpio is not None
+        match = re.search(r"\d+", self.gpio.name)
+        if match:
+            self.number: int = int(match.group().strip())
+        else:
+            raise GPIOError(
+                GPIOError.ErrorType.NO_MATCHING_DEVICE, "Failed to find matching device"
+            )
+
+        self.init_dev()
+
+    def _find_gpio_dev(
+        self,
+        parent: SystemComponent | None = None,
+        *args,
+        **kwargs,
+    ) -> tuple[int, int]:
+        self.addr = self.get_i2c_chip_addr()
+        self.logger.debug(f"GPIO: {self.addr}")
+        self.sysfs_device = self.get_i2c_sysfs_device(self.addr)
+        return get_gpio_major_minor(self.sysfs_device.path)
+
+    def init_dev(self):
+        if self.gpio:
+            try:
+                self.dev = gpiod.Chip(str(self.gpio))
+                self.initialized = True
+            except FileNotFoundError:
+                raise FileNotFoundError(f"{self.gpio} does not exist")
+
+    def num_lines(self) -> int:
+        """
+        Get number of GPIO lines available on the device.
+        """
+        return self.dev.get_info().num_lines
+
+    def set_pin(self, pin: int, value: bool) -> None:
+        """
+        Set the value of a GPIO pin.
+
+        Parameters
+        ----------
+        pin : int
+            The pin number.
+        value : bool
+            The value to set.
+        """
+        v = Value.ACTIVE if value else Value.INACTIVE
+        with self.dev.request_lines(
+            consumer="set-pin",
+            config={pin: gpiod.LineSettings()},
+        ) as request:
+            request.set_value(pin, v)
+
+    def get_pin(self, pin: int) -> bool:
+        """
+        Get the value of a GPIO pin.
+
+        Parameters
+        ----------
+        pin : int
+            The pin number.
+
+        Returns
+        -------
+        bool
+            The value of the pin.
+        """
+        with self.dev.request_lines(
+            consumer="get-pin",
+            config={pin: gpiod.LineSettings()},
+        ) as req:
+            value = req.get_value(pin)
+            return value == Value.ACTIVE
+
+    def get_lines(self, lines: list[int]):
+        if (
+            invalid_pin := first_true(
+                lines,
+                pred=lambda line: line < 0 or line >= self.num_lines(),
+                default=None,
+            )
+        ) is not None:
+            raise GPIOError(
+                GPIOError.ErrorType.INVALID_PIN, f"GPIO {invalid_pin} is invalid."
+            )
+
+    def set_direction(self, pin: int, direction: bool) -> None:
+        """
+        Set the direction of a GPIO pin.
+
+        Parameters
+        ----------
+        pin : int
+            The pin number.
+        direction : bool
+            The direction to set. True for output, False for input.
+        """
+        dir = Direction.OUTPUT if direction else Direction.INPUT
+        self.dev.request_lines(
+            consumer="set-direction",
+            config={pin: LineSettings(direction=dir)},
+        )
+
+    def __str__(self) -> str:
+        return (
+            f"GPIO - Number: {self.number}; "
+            f"sysfs_path: {self.sysfs_device.path if self.sysfs_device else ''} "
+            f"(dev: {self.gpio if self.gpio else 'No matching device found'})"
+        )
+
+
+class GPIOExpander(GPIO):
+    def __init__(
+        self,
+        name: str,
+        parent: SystemComponent | None,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(name, parent, None, *args, **kwargs)
+
+    def __str__(self) -> str:
+        return (
+            f"GPIOExpander - Number: {self.number}; "
+            f"sysfs_path: {self.sysfs_device.path if self.sysfs_device else ''}"
+        )
+
+
+class EKFIdentificationIOExpander(GPIOExpander, ProbeableDevice):
+    def __init__(
+        self,
+        name: str,
+        parent: SystemComponent | None,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(name, parent, None, *args, **kwargs)
+
+    def probe(self, *args, **kwargs) -> bool:
+        from ekfsm.core import HwModule
+
+        assert isinstance(self.root, HwModule)
+        id, _ = self.read_board_id_rev()
+
+        return self.root.id == id
+
+    def read_board_id_rev(self) -> tuple[int, int]:
+        for pin in range(6, 8):
+            self.set_direction(pin, True)
+            self.set_pin(pin, False)
+        for pin in range(0, 6):
+            self.set_direction(pin, False)
+
+        v_gnd = self.read_id_gpio_inputs()
+        self.set_pin(7, True)
+        v_7h = self.read_id_gpio_inputs()
+        self.set_pin(6, True)
+        v_6h = self.read_id_gpio_inputs()
+
+        readings = [v_gnd, v_7h, v_6h]
+        bit_sums = []
+        for bit in range(5, -1, -1):
+            s = 0
+            for reading in readings:
+                s += (reading >> bit) & 1
+            bit_sums.append(s)
+
+        return (
+            sum(val * (4**i) for i, val in enumerate(reversed(bit_sums[2:]))),
+            self._get_board_rev(bit_sums[:2]),  # board_rev
+        )
+
+    def revision(self) -> str:
+        id, rev = self.read_board_id_rev()
+        return str(rev)
+
+    def read_id_gpio_inputs(self) -> int:
+        value = 0
+        for pin in range(6):
+            if self.get_pin(pin):
+                value |= 1 << pin
+
+        return value
+
+    @staticmethod
+    def _get_board_rev(bits: list[int]) -> int:
+        """Convert 2-bit sum values to board revision number."""
+        rev_map = {
+            (0, 0): 0,
+            (0, 1): 1,
+            (0, 2): 2,
+            (1, 0): 3,
+            (1, 1): 4,
+            (1, 2): 5,
+            (2, 0): 6,
+            (2, 1): 7,
+            (2, 2): 8,
+        }
+        return rev_map.get((bits[0], bits[1]), -1)
+
+    def __str__(self) -> str:
+        return (
+            f"EKFIdentificationIOExpander - Number: {self.number}; "
+            f'sysfs_path: {self.sysfs_device.path if self.sysfs_device else ""}'
+        )
+
+
+class SimGpio(ABC):
+    @abstractmethod
+    def num_lines(self) -> int:
+        pass
+
+    @abstractmethod
+    def set_pin(self, pin: int, value: bool) -> None:
+        pass
+
+    @abstractmethod
+    def get_pin(self, pin: int) -> bool:
+        pass
+
+    @abstractmethod
+    def set_direction(self, pin: int, direction: bool) -> None:
+        pass
+
+
+class EKFIdSimGpio(SimGpio):
+    def __init__(self, coding_gnd, coding_vcc, coding_6, coding_7) -> None:
+        self._coding_gnd = coding_gnd
+        self._coding_vcc = coding_vcc
+        self._coding_6 = coding_6
+        self._coding_7 = coding_7
+        self._dir = 0
+        self._out = 0
+        self._in = 0
+
+    def num_lines(self) -> int:
+        return 8
+
+    def set_pin(self, pin: int, value: bool) -> None:
+        mask = 1 << pin
+        if value not in [0, 1]:
+            raise RuntimeError("value must be 0 or 1")
+        if self._dir & mask:
+            self._out = (self._out & ~mask) | (value << pin)
+        else:
+            raise RuntimeError("pin not set as output")
+
+    def get_pin(self, pin: int) -> bool:
+        mask = 1 << pin
+        if self._coding_gnd & mask:
+            return False
+        if self._coding_vcc & mask:
+            return True
+        if self._coding_6 & mask:
+            return True if self._out & (1 << 6) else False
+        if self._coding_7 & mask:
+            return True if self._out & (1 << 7) else False
+        return False
+
+    def set_direction(self, pin: int, direction: bool) -> None:
+        if direction == 1 and (pin != 6 and pin != 7):
+            raise RuntimeError("only pins 6 and 7 supported as output")
+        mask = 1 << pin
+        if direction:
+            self._dir |= mask
+        else:
+            self._dir &= ~mask

ekfsm/devices/hwmon.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+import os
+import glob
+from pathlib import Path
+
+from ekfsm.core.sysfs import SYSFS_ROOT
+from ekfsm.devices.generic import Device
+
+# Path to the root of the HWMON sysfs filesystem
+HWMON_ROOT = SYSFS_ROOT / Path('class/hwmon')
+
+
+def find_core_temp_dir(hwmon_dir) -> Path:
+    """
+    Find the directory containing the coretemp hwmon device.
+
+    Args:
+        hwmon_dir: Path to the hwmon directory
+
+    Returns:
+        Path to the directory containing the coretemp hwmon device
+
+    Raises:
+        FileNotFoundError: If no coretemp directory is found
+    """
+    # List all 'name' files in each subdirectory of hwmon_dir
+    name_files = glob.glob(os.path.join(hwmon_dir, '*', 'name'))
+
+    # Search for the file containing "coretemp"
+    for name_file in name_files:
+        with open(name_file, 'r') as file:
+            if file.readline().strip() == 'coretemp':
+                # Return the directory containing this file
+                return Path(os.path.dirname(name_file))
+
+    raise FileNotFoundError("No coretemp directory found")
+
+
+class HWMON(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.
+
+    Note:
+    Currently, only the CPU temperature is read from the HWMON device.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        parent: Device,
+        *args,
+        **kwargs,
+    ):
+        from ekfsm.core.sysfs import SysFSDevice, SYSFS_ROOT
+
+        self.sysfs_device: SysFSDevice = SysFSDevice(find_core_temp_dir(SYSFS_ROOT / Path('class/hwmon')))
+
+        super().__init__(name, parent, None, *args, **kwargs)
+
+    def cputemp(self):
+        """
+        Get the CPU temperature from the HWMON device.
+
+        Returns
+        -------
+        int
+            The CPU temperature in degrees Celsius.
+        """
+        return int(self.sysfs_device.read_attr_utf8("temp1_input").strip()) / 1000

ekfsm/devices/iio.py

@@ -0,0 +1,58 @@
+from .generic import SysFSDevice
+
+
+def iio_get_in_value(dev: SysFSDevice, attrset: str) -> float:
+    """
+    Calculate a value from an IIO in_* attribute set, using the _raw, _scale and _offset attributes (if present).
+    Typical name of attrset are "in_temp" or "in_voltage0".
+
+    Formula according to https://wiki.st.com/stm32mpu/wiki/How_to_use_the_IIO_user_space_interface
+
+    Parameters
+    ----------
+    dev
+        sysfs device object pointing to the iio directory
+    attrset
+        name of the attribute set to read from (e.g. "in_temp")
+
+    Returns
+    -------
+    float
+        calculated value from the attribute set (no unit conversion)
+
+    Raises
+    ------
+    FileNotFoundError
+        if the neiter _input nor _raw attribute is found
+
+    """
+    # check if _input exists
+    try:
+        content = dev.read_attr_utf8(f"{attrset}_input")
+        return float(content)
+    except StopIteration:
+        pass
+
+    # check if _raw exists
+    try:
+        content = dev.read_attr_utf8(f"{attrset}_raw")
+    except StopIteration:
+        raise FileNotFoundError(f"{attrset}_raw not found")
+
+    raw = float(content)
+
+    # use offset if present
+    try:
+        content = dev.read_attr_utf8(f"{attrset}_offset")
+        raw += float(content)
+    except StopIteration:
+        pass
+
+    # use scale if present
+    try:
+        content = dev.read_attr_utf8(f"{attrset}_scale")
+        raw *= float(content)
+    except StopIteration:
+        pass
+
+    return raw

ekfsm/devices/iio_thermal_humidity.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+
+from ekfsm.core.components import SystemComponent
+from ekfsm.log import ekfsm_logger
+
+from ..core.sysfs import SysFSDevice
+
+from .generic import Device
+from .iio import iio_get_in_value
+
+
+class IIOThermalHumidity(Device):
+    """
+    Device for IIO thermal and/or humidity sensors.
+
+    """
+
+    def __init__(
+        self,
+        name: str,
+        parent: SystemComponent | None = None,
+        children: list[Device] | None = None,
+        *args,
+        **kwargs,
+    ):
+        self.logger = ekfsm_logger("IIOThermalHumidity:" + name)
+        super().__init__(name, parent, children, **kwargs)
+        self.addr = self.get_i2c_chip_addr()
+        self.sysfs_device = self.get_i2c_sysfs_device(self.addr)
+
+        dir = list(Path(self.sysfs_device.path).glob("iio:device*"))
+        if len(dir) == 0:
+            raise FileNotFoundError("iio entry not found")
+        self.iio_sysfs = SysFSDevice(dir[0])
+        self.logger.debug(f"iio: {self.iio_sysfs.path}")
+
+    def temperature(self) -> float:
+        return iio_get_in_value(self.iio_sysfs, "in_temp") / 1000.0
+
+    def humidity(self) -> float:
+        return iio_get_in_value(self.iio_sysfs, "in_humidityrelative") / 1000.0

ekfsm/devices/mux.py

@@ -0,0 +1,39 @@
+from ekfsm.core.components import SystemComponent
+
+from ..core.sysfs import SysFSDevice
+from .generic import Device
+
+
+class MuxChannel(Device):
+    def __init__(
+        self,
+        name: str,
+        channel_id: int,
+        parent: 'I2CMux',
+        children: list[Device] | None = None,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__(name=name, parent=parent, children=children)
+        self.channel_id = channel_id
+
+        assert parent.sysfs_device is not None
+        assert isinstance(self.parent, I2CMux)
+
+        path = parent.sysfs_device.path / f"channel-{self.channel_id}"
+        self.sysfs_device = SysFSDevice(path)
+
+
+class I2CMux(Device):
+    def __init__(
+        self,
+        name: str,
+        parent: SystemComponent | None = None,
+        children: list[MuxChannel] | None = None,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(name, parent, children, **kwargs)
+
+        self.addr = self.get_i2c_chip_addr()
+        self.sysfs_device = self.get_i2c_sysfs_device(self.addr)

ekfsm/devices/pmbus.py

@@ -0,0 +1,65 @@
+from pathlib import Path
+
+from ekfsm.core.components import SystemComponent
+
+from ..core.sysfs import SysFSDevice
+
+from .generic import Device
+from ..core.probe import ProbeableDevice
+
+
+class PmBus(Device, ProbeableDevice):
+    def __init__(
+        self,
+        name: str,
+        parent: SystemComponent | None = None,
+        children: list[Device] | None = None,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(name, parent, children, **kwargs)
+        self.addr = self.get_i2c_chip_addr()
+        self.sysfs_device = self.get_i2c_sysfs_device(self.addr)
+
+        files = list(Path(self.sysfs_device.path).rglob("hwmon/*/in1_input"))
+        if len(files) == 0:
+            raise FileNotFoundError("No HWMON entries found")
+        self.hwmon_sysfs = SysFSDevice(files[0].parent)
+
+    def probe(self, *args, **kwargs) -> bool:
+        from ekfsm.core import HwModule
+
+        assert isinstance(self.root, HwModule)
+        return self.root.id == self.model()
+
+    # Voltage and Current Interfaces
+    def _in_conversion(self, in_file: str) -> float:
+        return float(self.hwmon_sysfs.read_attr_utf8(in_file)) / 1000.0
+
+    def _current_conversion(self, in_file: str) -> float:
+        return float(self.hwmon_sysfs.read_attr_utf8(in_file)) / 1000.0
+
+    def in1_input(self) -> float:
+        return self._in_conversion("in1_input")
+
+    def in2_input(self) -> float:
+        return self._in_conversion("in2_input")
+
+    def curr1_input(self) -> float:
+        return self._current_conversion("curr1_input")
+
+    def curr2_input(self) -> float:
+        return self._current_conversion("curr2_input")
+
+    # Inventory Interface
+    def vendor(self) -> str:
+        return self.hwmon_sysfs.read_attr_utf8("vendor").strip()
+
+    def model(self) -> str:
+        return self.hwmon_sysfs.read_attr_utf8("model").strip()
+
+    def serial(self) -> str:
+        return self.hwmon_sysfs.read_attr_utf8("serial").strip()
+
+    def revision(self) -> str:
+        return self.hwmon_sysfs.read_attr_utf8("revision").strip()

ekfsm/devices/smbios.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+from ekfsm.core.components import HwModule
+from ekfsm.core.sysfs import SysFSDevice, SYSFS_ROOT
+from .generic import Device
+
+
+class SMBIOS(Device):
+    """
+    A class to represent the SMBIOS device.
+
+    A SMBIOS device is a virtual device that is used to read system
+    configuration values from the DMI table.
+
+    Note:
+    Currently, only the board version / revision is read from the DMI table.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        parent: HwModule | None = None,
+        *args,
+        **kwargs,
+    ):
+        self.sysfs_device: SysFSDevice = SysFSDevice(SYSFS_ROOT / Path("devices/virtual/dmi/id"))
+
+        super().__init__(name, parent, None, *args, **kwargs)
+
+    def revision(self) -> str:
+        """
+        Get the board revision from the DMI table.
+
+        Returns
+        -------
+        str
+            The board revision.
+        """
+        return self.sysfs_device.read_attr_utf8("board_version").strip()

ekfsm/devices/utils.py

@@ -0,0 +1,16 @@
+from crcmod.predefined import Crc
+from typing import Sequence
+
+
+def compute_int_from_bytes(data: Sequence[int]) -> int:
+    # Combine the bytes into a single integer
+    result = 0
+    for num in data:
+        result = (result << 8) | num
+    return result
+
+
+def get_crc16_xmodem(data: bytes) -> int:
+    crc16_xmodem = Crc("xmodem")
+    crc16_xmodem.update(data)
+    return crc16_xmodem.crcValue