ekfsm 1.1.0a15.post1__py3-none-any.whl → 1.3.0__py3-none-any.whl

ekfsm/devices/coretemp.py

@@ -1,13 +1,15 @@
 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
 
 # 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:
@@ -48,16 +50,15 @@ class CoreTemp(Device):
         self,
         name: str,
         parent: Device,
+        children: list["Device"] | None = None,
+        abort: bool = False,
         *args,
         **kwargs,
     ):
-        from ekfsm.core.sysfs import SysFSDevice, SYSFS_ROOT
-
-        self.sysfs_device: SysFSDevice = SysFSDevice(
-            find_core_temp_dir(SYSFS_ROOT / Path("class/hwmon"))
-        )
+        dir = find_core_temp_dir(sysfs_root() / Path("class/hwmon"))
+        self.sysfs_device = ekfsm.core.sysfs.SysfsDevice(dir, False)
 
-        super().__init__(name, parent, None, *args, **kwargs)
+        super().__init__(name, parent, None, abort, *args, **kwargs)
 
     def cputemp(self):
         """
@@ -68,4 +69,4 @@ class CoreTemp(Device):
         int
             The CPU temperature in degrees Celsius.
         """
-        return int(self.sysfs_device.read_attr_utf8("temp1_input").strip()) / 1000
+        return self.sysfs.read_int("temp1_input") / 1000

ekfsm/devices/eeprom.py

@@ -11,18 +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 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
 
 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.log import ekfsm_logger
+from .utils import get_crc16_xmodem
 
 logger = ekfsm_logger(__name__)
 
@@ -80,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:
@@ -117,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:
         """
@@ -155,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)]
@@ -202,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,
@@ -210,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
@@ -388,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!
@@ -424,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:
@@ -461,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:
@@ -690,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)
@@ -713,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.
 
@@ -772,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
@@ -933,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:
@@ -998,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
@@ -1067,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")

ekfsm/devices/ekf_ccu_uc.py

@@ -1,12 +1,15 @@
-from .generic import Device
-from smbus2 import SMBus
+import struct
 from enum import Enum
-from typing import Tuple
+from typing import Any, Tuple
+
+from smbus2 import SMBus
+
 from ekfsm.core.components import SysTree
+
 from ..exceptions import AcquisitionError
 from ..lock import Locker
+from .generic import Device
 from .imu import ImuSample
-import struct
 
 
 class CcuCommands(Enum):
@@ -37,10 +40,13 @@ class EKFCcuUc(Device):
         self,
         name: str,
         parent: SysTree | None,
+        children: list["Device"] | None = None,
+        abort: bool = False,
+        debug: Any = None,  # XXX: What is this?
         *args,
         **kwargs,
     ):
-        super().__init__(name, parent, None, *args, **kwargs)
+        super().__init__(name, parent, None, abort, *args, **kwargs)
         self._i2c_addr = self.get_i2c_chip_addr()
         self._i2c_bus = self.get_i2c_bus_number()
         self._smbus = SMBus(self._i2c_bus)
@@ -54,7 +60,10 @@ class EKFCcuUc(Device):
     def temperature(self) -> float:
         """
         Get the temperature from the CCU thermal/humidity sensor.
-        The temperature is read once per second.
+
+        Note
+        ----
+        The CCU reads the temperature once per second.
 
         Returns
         -------
@@ -66,10 +75,7 @@ class EKFCcuUc(Device):
         AcquisitionError
             If the temperature cannot be read, for example, because the sensor is not working.
         """
-        return (
-            self._get_signed_word_data(CcuCommands.CCU_TEMPERATURE.value, "temperature")
-            / 10.0
-        )
+        return self._get_signed_word_data(CcuCommands.CCU_TEMPERATURE.value, "temperature") / 10.0
 
     def humidity(self) -> float:
         """
@@ -86,10 +92,7 @@ class EKFCcuUc(Device):
         AcquisitionError
             If the humidity cannot be read, for example, because the sensor is not working.
         """
-        return (
-            self._get_signed_word_data(CcuCommands.CCU_HUMIDITY.value, "humidity")
-            / 10.0
-        )
+        return self._get_signed_word_data(CcuCommands.CCU_HUMIDITY.value, "humidity") / 10.0
 
     def vin_voltage(self) -> float:
         """
@@ -106,15 +109,14 @@ class EKFCcuUc(Device):
         AcquisitionError
             If the voltage cannot be read, for example, because the ADC is not working.
         """
-        return (
-            self._get_signed_word_data(CcuCommands.VIN_VOLTAGE.value, "VIN voltage")
-            / 10.0
-        )
+        return self._get_signed_word_data(CcuCommands.VIN_VOLTAGE.value, "VIN voltage") / 10.0
 
     def _get_signed_word_data(self, cmd: int, what: str) -> int:
         v = self._smbus.read_word_data(self._i2c_addr, cmd)
+
         if v == 0x8000:
-            raise AcquisitionError(f"cannot read {what}")
+            raise AcquisitionError(f"Cannot read {what}")
+
         return struct.unpack("<h", struct.pack("<H", v))[0]
 
     def fan_status(self, fan: int) -> Tuple[float, float, int]:
@@ -168,9 +170,7 @@ class EKFCcuUc(Device):
         if fan == -1:
             fan = 0xFF
         data = struct.pack("<Bh", fan, int(temp * 10))
-        self._smbus.write_block_data(
-            self._i2c_addr, CcuCommands.PUSH_TEMPERATURE.value, list(data)
-        )
+        self._smbus.write_block_data(self._i2c_addr, CcuCommands.PUSH_TEMPERATURE.value, list(data))
 
     def imu_sample(self) -> Tuple[ImuSample | None, bool]:
         """
@@ -197,15 +197,11 @@ class EKFCcuUc(Device):
             True if more samples are available in the FIFO, False otherwise.
         """
         more_samples = False
-        _data = self._smbus.read_block_data(
-            self._i2c_addr, CcuCommands.IMU_SAMPLES.value
-        )
+        _data = self._smbus.read_block_data(self._i2c_addr, CcuCommands.IMU_SAMPLES.value)
         data = bytes(_data)
         if len(data) < 14:
             return None, False  # No data available
-        diag, fsr, acc_x, acc_y, acc_z, gyro_x, gyro_y, gyro_z = struct.unpack(
-            "<BBhhhhhh", data
-        )
+        diag, fsr, acc_x, acc_y, acc_z, gyro_x, gyro_y, gyro_z = struct.unpack("<BBhhhhhh", data)
         imu_data = ImuSample(
             [
                 self._scale_imu_accel(acc_x, fsr),
@@ -271,15 +267,11 @@ class EKFCcuUc(Device):
         version: str
             The firmware version.
         """
-        title = bytes(
-            self._smbus.read_block_data(
-                self._i2c_addr, CcuCommands.IDENTIFY_FIRMWARE_TITLE.value
-            )
-        ).decode("utf-8")
+        title = bytes(self._smbus.read_block_data(self._i2c_addr, CcuCommands.IDENTIFY_FIRMWARE_TITLE.value)).decode(
+            "utf-8"
+        )
         version = bytes(
-            self._smbus.read_block_data(
-                self._i2c_addr, CcuCommands.IDENTIFY_FIRMWARE_VERSION.value
-            )
+            self._smbus.read_block_data(self._i2c_addr, CcuCommands.IDENTIFY_FIRMWARE_VERSION.value)
         ).decode("utf-8")
         return title, version
 
@@ -304,27 +296,37 @@ class EKFCcuUc(Device):
         progress_callback
             A callback function that is called with the current progress in bytes.
 
+        Example
+        -------
+        >>> from ekfsm.devices import EkfCcuUc
+        >>> ccu = EkfCcuUc("ccu")
+        >>> firmware = open("fw-ccu-1.0.0.bin", "rb").read()
+        >>> # Load firmware with progress callback
+        >>> ccu.load_firmware(firmware, progress_callback=lambda x: print(f"Progress: {x} bytes"))
         """
         with Locker(self.name + "-load_firmware").lock():
             offset = 0
             max_chunk_len = 28
+
             while len(firmware) > 0:
                 chunk, firmware = firmware[:max_chunk_len], firmware[max_chunk_len:]
                 self._load_firmware_chunk(offset, len(firmware) == 0, chunk)
                 offset += len(chunk)
+
                 if len(firmware) != 0:
                     self._nop()
+
                 if progress_callback is not None:
                     progress_callback(offset)
 
     def _load_firmware_chunk(self, offset: int, is_last: bool, data: bytes) -> None:
         if is_last:
             offset |= 0x80000000
+
         hdr = struct.pack("<I", offset)
         data = hdr + data
-        self._smbus.write_block_data(
-            self._i2c_addr, CcuCommands.LOAD_FIRMWARE_CHUNK.value, list(data)
-        )
+
+        self._smbus.write_block_data(self._i2c_addr, CcuCommands.LOAD_FIRMWARE_CHUNK.value, list(data))
 
     def get_parameterset(self) -> str:
         """
@@ -382,6 +384,7 @@ class EKFCcuUc(Device):
         with Locker(self.name + "-parameterset").lock():
             json = b""
             begin = True
+
             while True:
                 chunk = self._get_parameterset_chunk(begin)
                 if len(chunk) < 32:
@@ -391,16 +394,13 @@ class EKFCcuUc(Device):
                     chunk = chunk[:-1]
                 json += chunk
                 begin = False
+
             return json.decode("utf-8")
 
     def _get_parameterset_chunk(self, begin: bool) -> bytes:
         data = self._smbus.read_block_data(
             self._i2c_addr,
-            (
-                CcuCommands.GET_PARAMETERSET_BEGIN.value
-                if begin
-                else CcuCommands.GET_PARAMETERSET_FOLLOW.value
-            ),
+            (CcuCommands.GET_PARAMETERSET_BEGIN.value if begin else CcuCommands.GET_PARAMETERSET_FOLLOW.value),
         )
         return bytes(data)
 
@@ -423,6 +423,8 @@ class EKFCcuUc(Device):
         This would load a parameterset with just one parameter, the default fan speed. All other parameters will
         be set to their default values.
 
+        Important
+        ---------
         In order to apply the parameterset, the CCU must be restarted.
 
         Parameters
@@ -430,11 +432,20 @@ class EKFCcuUc(Device):
         _cfg
             The parameterset in JSON format.
 
+        Example
+        -------
+        >>> from ekfsm.devices import EkfCcuUc
+        >>> ccu = EkfCcuUc("ccu")
+        >>> # Load parameterset
+        >>> ccu.load_parameterset('{"version": "1.0.0", "parameters": {"fan-defrpm": "6000"}}')
+        >>> # Restart CCU to apply parameterset
+        >>> ccu.restart()
         """
         with Locker(self.name + "-parameterset").lock():
             cfg = _cfg.encode("utf-8")
             offset = 0
             max_chunk_len = 28
+
             while len(cfg) > 0:
                 chunk, cfg = cfg[:max_chunk_len], cfg[max_chunk_len:]
                 self._load_parameterset_chunk(offset, len(cfg) == 0, chunk)
@@ -444,11 +455,11 @@ class EKFCcuUc(Device):
     def _load_parameterset_chunk(self, offset: int, is_last: bool, data: bytes) -> None:
         if is_last:
             offset |= 0x80000000
+
         hdr = struct.pack("<I", offset)
         data = hdr + data
-        self._smbus.write_block_data(
-            self._i2c_addr, CcuCommands.LOAD_PARAMETERSET.value, list(data)
-        )
+
+        self._smbus.write_block_data(self._i2c_addr, CcuCommands.LOAD_PARAMETERSET.value, list(data))
 
     def restart(self) -> None:
         """

ekfsm/devices/ekf_sur_led.py

@@ -1,5 +1,7 @@
-from .gpio import GPIOExpander
 from ekfsm.core.components import SysTree
+from ekfsm.devices.generic import Device
+
+from .gpio import GPIOExpander
 
 
 class EKFSurLed(GPIOExpander):
@@ -11,10 +13,12 @@ class EKFSurLed(GPIOExpander):
         self,
         name: str,
         parent: SysTree | 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)
 
     def __str__(self) -> str:
         return (