shepherd-core 2025.8.1__py3-none-any.whl → 2026.2.1__py3-none-any.whl

shepherd_core/data_models/content/firmware.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from typing import Annotated
 from typing import Any
 from typing import TypedDict
+from typing import final
 
 from pydantic import StringConstraints
 from pydantic import model_validator
@@ -20,7 +21,7 @@ from shepherd_core.data_models.testbed.mcu import MCU
 from shepherd_core.logger import log
 from shepherd_core.testbed_client import tb_client
 
-from .firmware_datatype import FirmwareDType
+from .enum_datatypes import FirmwareDType
 
 suffix_to_DType: dict = {
     # derived from wikipedia
@@ -49,17 +50,18 @@ arch_to_mcu: dict = {
 FirmwareStr = Annotated[str, StringConstraints(min_length=3, max_length=8_000_000)]
 
 
+@final
 class Firmware(ContentModel, title="Firmware of Target"):
     """meta-data representation of a data-component."""
 
-    # General Metadata & Ownership -> ContentModel
+    # General Metadata & Ownership -> see ContentModel
 
     mcu: MCU
 
     data: FirmwareStr | Path
     data_type: FirmwareDType
     data_hash: str | None = None
-    data_local: bool = True
+    data_2_copy: bool = True
     """ ⤷ signals that file has to be copied to testbed"""
 
     @model_validator(mode="before")
@@ -67,18 +69,18 @@ class Firmware(ContentModel, title="Firmware of Target"):
     def query_database(cls, values: dict[str, Any]) -> dict[str, Any]:
         values, _ = tb_client.try_completing_model(cls.__name__, values)
         # crosscheck type with actual data
-        _type = values.get("data_type")
-        if _type in {
+        dtype = values.get("data_type")
+        if dtype in {
             FirmwareDType.base64_hex,
             FirmwareDType.base64_elf,
         }:
             try:
-                _hash = fw_tools.base64_to_hash(values.get("data"))
+                dhash = fw_tools.base64_to_hash(values.get("data"))
             except ValueError:
                 raise ValueError("Embedded Firmware seems to be faulty") from None
-            if values.get("data_hash") is not None and _hash != values.get("data_hash"):
+            if values.get("data_hash") is not None and dhash != values.get("data_hash"):
                 raise ValueError("Embedded Firmware and Hash do not match!")
-        elif _type in {
+        elif dtype in {
             FirmwareDType.path_hex,
             FirmwareDType.path_elf,
         }:
@@ -105,10 +107,10 @@ class Firmware(ContentModel, title="Firmware of Target"):
         kwargs["data_hash"] = fw_tools.file_to_hash(file)
         if embed:
             kwargs["data"] = fw_tools.file_to_base64(file)
-            kwargs["data_local"] = False
+            kwargs["data_2_copy"] = False
         else:
             kwargs["data"] = Path(file).as_posix()
-            kwargs["data_local"] = True
+            kwargs["data_2_copy"] = True
 
         if "data_type" not in kwargs:
             kwargs["data_type"] = suffix_to_DType[file.suffix.lower()]
@@ -145,16 +147,22 @@ class Firmware(ContentModel, title="Firmware of Target"):
             kwargs["name"] = file.name
         return cls(**kwargs)
 
-    def compare_hash(self, path: Path | None = None) -> bool:
+    def compare_hash(self, data: Path | str | None = None) -> bool:
         if self.data_hash is None:
             return True
 
-        if path is not None and path.is_file():
-            hash_new = fw_tools.file_to_hash(path)
+        if data is None:
+            # use included data if nothing is provided
+            data = self.data
+
+        if isinstance(data, Path) and data.is_file():
+            hash_new = fw_tools.file_to_hash(data)
             match = self.data_hash == hash_new
-        else:
-            hash_new = fw_tools.base64_to_hash(self.data)
+        elif isinstance(data, str):
+            hash_new = fw_tools.base64_to_hash(data)
             match = self.data_hash == hash_new
+        else:
+            match = False
 
         if not match:
             log.warning("FW-Hash does not match with stored value!")
@@ -169,7 +177,27 @@ class Firmware(ContentModel, title="Firmware of Target"):
         - if provided path is a directory, the firmware-name is used
         """
         if file.is_dir():
-            file = file / self.name
+            file /= self.name
         file_new = fw_tools.extract_firmware(self.data, self.data_type, file)
         self.compare_hash(file_new)
         return file_new
+
+    def exists(self) -> bool:
+        """Check if embedded file exists."""
+        if self.data_type in [FirmwareDType.path_hex, FirmwareDType.path_elf]:
+            if not isinstance(self.data, Path):
+                raise ValueError("Firmware.data is not a Path (but type-property claims so)")
+            return self.data.exists()
+        return True
+
+    def check(self) -> bool:
+        """Check if embedded file is still valid or unchanged."""
+        valid = True
+        if self.data_type in [FirmwareDType.path_hex, FirmwareDType.path_elf]:
+            valid &= isinstance(self.data, Path) and self.data.exists()
+        if self.data_type in [FirmwareDType.base64_elf, FirmwareDType.base64_hex]:
+            valid &= isinstance(self.data, str)
+            # TODO: could also begin unpacking base64
+            # TODO: could also verify hex, elf
+
+        return valid & self.compare_hash()

shepherd_core/data_models/content/{virtual_harvester.py → virtual_harvester_config.py}

@@ -1,9 +1,9 @@
 """Generalized energy harvester data models."""
 
 from collections.abc import Mapping
-from enum import Enum
 from typing import Annotated
 from typing import Any
+from typing import final
 
 from pydantic import Field
 from pydantic import model_validator
@@ -16,95 +16,11 @@ from shepherd_core.data_models.base.shepherd import ShpModel
 from shepherd_core.logger import log
 from shepherd_core.testbed_client import tb_client
 
-from .energy_environment import EnergyDType
-
-
-class AlgorithmDType(str, Enum):
-    """Options for choosing a harvesting algorithm."""
-
-    direct = disable = neutral = "neutral"
-    """
-    Reads an energy environment as is without selecting a harvesting
-    voltage.
-
-    Used to play "constant-power" energy environments or simple
-    "on-off-patterns". Generally, not useful for virtual source
-    emulation.
-
-    Not applicable to real harvesting, only emulation with IVTrace / samples.
-    """
-
-    isc_voc = "isc_voc"
-    """
-    Short Circuit Current, Open Circuit Voltage.
-
-    This is not relevant for emulation, but used to configure recording of
-    energy environments.
-
-    This mode samples the two extremes of an IV curve, which may be
-    interesting to characterize a transducer/energy environment.
-
-    Not applicable to emulation - only recordable during harvest-recording ATM.
-    """
-
-    ivcurve = ivcurves = ivsurface = "ivcurve"
-    """
-    Used during harvesting to record the full IV surface.
-
-    When configuring the energy environment recording, this algorithm
-    records the IV surface by repeatedly recording voltage and current
-    while ramping the voltage.
-
-    Cannot be used as output of emulation.
-    """
-
-    constant = cv = "cv"
-    """
-    Harvest energy at a fixed predefined voltage ('voltage_mV').
-
-    For harvesting, this records the IV samples at the specified voltage.
-    For emulation, this virtually harvests the IV surface at the specified voltage.
-
-    In addition to constant voltage harvesting, this can be used together
-    with the 'feedback_to_hrv' flag to implement a "Capacitor and Diode"
-    topology, where the harvesting voltage depends dynamically on the
-    capacitor voltage.
-    """
-
-    # ci .. constant current -> is this desired?
-
-    mppt_voc = "mppt_voc"
-    """
-    Emulate a harvester with maximum power point (MPP) tracking based on
-    open circuit voltage measurements.
-
-    This MPPT heuristic estimates the MPP as a constant ratio of the open
-    circuit voltage.
-
-    Used in conjunction with 'setpoint_n', 'interval_ms', and 'duration_ms'.
-    """
-
-    mppt_po = perturb_observe = "mppt_po"
-    """
-    Emulate a harvester with perturb and observe maximum power point
-    tracking.
-
-    This MPPT heuristic adjusts the harvesting voltage by small amounts and
-    checks if the power increases. Eventually, the tracking changes the
-    direction of adjustments and oscillates around the MPP.
-    """
-
-    mppt_opt = optimal = "mppt_opt"
-    """
-    A theoretical harvester that identifies the MPP by reading it from the
-    IV curve during emulation.
-
-    Note that this is not possible for real-world harvesting as the system would
-    not know the entire IV curve. In that case a very fast and detailed mppt_po is
-    used.
-    """
+from .enum_datatypes import EnergyDType
+from .enum_datatypes import HarvestAlgorithmDType
 
 
+@final
 class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
     """The virtual harvester configuration characterizes usage of an energy environment.
 
@@ -150,9 +66,9 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
     storage.
     """
 
-    # General Metadata & Ownership -> ContentModel
+    # General Metadata & Ownership -> see ContentModel
 
-    algorithm: AlgorithmDType
+    algorithm: HarvestAlgorithmDType
     """The algorithm determines how the harvester chooses the harvesting voltage.
     """
 
@@ -332,11 +248,11 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
     @model_validator(mode="after")
     def post_validation(self) -> Self:
         if self.voltage_min_mV > self.voltage_max_mV:
-            raise ValueError("Voltage min > max")
+            raise ValueError("Voltage minimum > max")
         if self.voltage_mV < self.voltage_min_mV:
-            raise ValueError("Voltage below min")
+            raise ValueError("Voltage below minimum")
         if self.voltage_mV > self.voltage_max_mV:
-            raise ValueError("Voltage above max")
+            raise ValueError("Voltage above maximum")
 
         return self
 
@@ -369,12 +285,12 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
 
         interval_ms = min(max(self.interval_ms, time_min_ms), 1_000_000)
         duration_ms = min(max(self.duration_ms, time_min_ms), interval_ms)
-        _ratio = (duration_ms / interval_ms) / (self.duration_ms / self.interval_ms)
-        if (_ratio - 1) > 0.1:
+        ratio = (duration_ms / interval_ms) / (self.duration_ms / self.interval_ms)
+        if (ratio - 1) > 0.1:
             log.debug(
                 "Ratio between interval & duration has changed "
                 "more than 10%% due to constraints (%.4f)",
-                _ratio,
+                ratio,
             )
         return interval_ms, duration_ms
 
@@ -436,6 +352,7 @@ ALGO_TO_DTYPE: Mapping[str, EnergyDType] = {
 }
 
 
+@final
 class HarvesterPRUConfig(ShpModel):
     """Map settings-list to internal state-vars struct HarvesterConfig for PRU.
 

shepherd_core/data_models/content/{virtual_source.py → virtual_source_config.py}

@@ -2,6 +2,7 @@
 
 from typing import Annotated
 from typing import Any
+from typing import final
 
 from pydantic import Field
 from pydantic import model_validator
@@ -13,9 +14,10 @@ from shepherd_core.data_models.base.shepherd import ShpModel
 from shepherd_core.logger import log
 from shepherd_core.testbed_client import tb_client
 
-from .energy_environment import EnergyDType
-from .virtual_harvester import HarvesterPRUConfig
-from .virtual_harvester import VirtualHarvesterConfig
+from .enum_datatypes import EnergyDType
+from .virtual_harvester_config import HarvesterPRUConfig
+from .virtual_harvester_config import VirtualHarvesterConfig
+from .virtual_storage_config import VirtualStorageConfig
 
 # Custom Types
 LUT_SIZE: int = 12
@@ -27,6 +29,7 @@ LUT2D = Annotated[list[LUT1D], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]
 vhrv_mppt_opt = VirtualHarvesterConfig(name="mppt_opt")
 
 
+@final
 class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
     """The vSrc uses the energy environment (file) for supplying the Target Node.
 
@@ -41,42 +44,49 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
 
     # TODO: I,V,R should be in regular unit (V, A, Ohm)
 
-    # General Metadata & Ownership -> ContentModel
+    # General Metadata & Ownership -> see ContentModel
 
     enable_boost: bool = False
     """ ⤷ if false -> v_intermediate = v_input, output-switch-hysteresis is still usable"""
     enable_buck: bool = False
     """ ⤷ if false -> v_output = v_intermediate"""
     enable_feedback_to_hrv: bool = False
-    """ src can control a cv-harvester for ivcurve"""
+    """ Source can control a cv-harvester for ivsurface.
+     Feedback is essential for some harvesters, i.e. diode-circuitry.
+    """
 
     interval_startup_delay_drain_ms: Annotated[float, Field(ge=0, le=10_000)] = 0
+    """ ⤷ Model begins running, but Target is not draining the storage capacitor
+    until this delay is over.
+    """
 
     harvester: VirtualHarvesterConfig = vhrv_mppt_opt
+    """ ⤷ Only active / needed if input is ivsurface. """
 
     V_input_max_mV: Annotated[float, Field(ge=0, le=10_000)] = 10_000
+    """ ⤷ Maximum input Voltage [mV] -> will be clipped."""
     I_input_max_mA: Annotated[float, Field(ge=0, le=4.29e3)] = 4_200
+    """ ⤷ Maximum input Current [mA] -> will be clipped."""
     V_input_drop_mV: Annotated[float, Field(ge=0, le=4.29e6)] = 0
-    """ ⤷ simulate input-diode"""
+    """ ⤷ simulate voltage drop for input-diode or LDO."""
     R_input_mOhm: Annotated[float, Field(ge=0, le=4.29e6)] = 0
     """ ⤷ resistance only active with disabled boost, range [1 mOhm; 1MOhm]"""
 
-    # primary storage-Cap
-    C_intermediate_uF: Annotated[float, Field(ge=0, le=100_000)] = 0
-    V_intermediate_init_mV: Annotated[float, Field(ge=0, le=10_000)] = 3_000
-    """ ⤷ allow a proper / fast startup"""
-    I_intermediate_leak_nA: Annotated[float, Field(ge=0, le=4.29e9)] = 0
-
-    V_intermediate_enable_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 1
+    storage: VirtualStorageConfig | None = None
+    """ ⤷ primary intermediate energy storage between boost- and buck-converter stage.
+    Selecting "None" disables the storage and directly connects input to output.
+    """
+    V_intermediate_enable_output_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 1
     """ ⤷ target gets connected (hysteresis-combo with next value)"""
-    V_intermediate_disable_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 0
+    V_intermediate_disable_output_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 0
     """ ⤷ target gets disconnected"""
     interval_check_thresholds_ms: Annotated[float, Field(ge=0, le=4.29e3)] = 0
     """ ⤷ some ICs (BQ) check every 64 ms if output should be disconnected"""
     # TODO: add intervals for input-disable, output-disable & power-good-signal
 
-    # pwr-good: target is informed on output-pin (hysteresis) -> for intermediate voltage
     V_pwr_good_enable_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 2_800
+    """ pwr-good: target is informed on output-pin (hysteresis)
+     -> reference is the intermediate voltage """
     V_pwr_good_disable_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 2200
     immediate_pwr_good_signal: bool = True
     """ ⤷ 1: activate instant schmitt-trigger, 0: stay in interval for checking thresholds"""
@@ -93,13 +103,13 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
 
     # Extra
     V_output_log_gpio_threshold_mV: Annotated[float, Field(ge=0, le=4.29e6)] = 1_400
-    """ ⤷ min voltage needed to enable recording changes in gpio-bank"""
+    """ ⤷ minimum voltage threshold needed to enable recording changes in gpio-bank"""
 
     # Boost Converter
     V_input_boost_threshold_mV: Annotated[float, Field(ge=0, le=10_000)] = 0
-    """ ⤷ min input-voltage for the boost converter to work"""
+    """ ⤷ minimum input-voltage for the boost converter to work"""
     V_intermediate_max_mV: Annotated[float, Field(ge=0, le=10_000)] = 10_000
-    """ ⤷ boost converter shuts off"""
+    """ ⤷ threshold for shutting off boost converter """
 
     LUT_input_efficiency: LUT2D = 12 * [12 * [1.00]]
     """ ⤷ rows are current -> first row a[V=0][:]
@@ -115,13 +125,18 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
 
     # Buck Converter
     V_output_mV: Annotated[float, Field(ge=0, le=5_000)] = 2_400
+    """ Fixed Voltage of Buck-Converter.
+    (as long as Input is > Output + Drop-Voltage)
+    """
     V_buck_drop_mV: Annotated[float, Field(ge=0, le=5_000)] = 0
-    """ ⤷ simulate LDO / diode min voltage differential or output-diode"""
+    """ ⤷ simulate LDO / diode minimum voltage differential or output-diode"""
 
     LUT_output_efficiency: LUT1D = 12 * [1.00]
-    """ ⤷ array[12] depending on output_current"""
+    """ ⤷ array[12] depending on output_current, In- & Output is linear."""
     LUT_output_I_min_log2_nA: Annotated[int, Field(ge=1, le=20)] = 1
-    """ ⤷ 2^8 = 256 nA -> LUT[0] is for inputs < 256 nA, see notes on LUT_input for explanation"""
+    """ ⤷ i.e. 2^8 = 256 nA -> LUT[0] is for inputs < 256 nA,
+    see notes on LUT_input for explanation
+    """
 
     @model_validator(mode="before")
     @classmethod
@@ -129,12 +144,16 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
         values, chain = tb_client.try_completing_model(cls.__name__, values)
         values = tb_client.fill_in_user_data(values)
         log.debug("VSrc-Inheritances: %s", chain)
+        # TODO: most "internal states" should be corrected here
+
         return values
 
     @model_validator(mode="after")
     def post_validation(self) -> Self:
         # trigger stricter test of harv-parameters
         HarvesterPRUConfig.from_vhrv(self.harvester, for_emu=True)
+        # TODO: enable threshold < mid_max
+        # TODO: mid_max < mid_soc1
         return self
 
     def calc_internal_states(self) -> dict:
@@ -148,6 +167,7 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
         - the converter always turns on with "V_storage_enable_threshold_uV".
 
         TODO: currently neglecting delay after disabling converter, boost
+        TODO: warn and explain when altering config due to boundaries (transparency)
         only has simpler formula, second enabling when V_Cap >= V_out
 
         Math behind this calculation:
@@ -164,11 +184,11 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
         Note: dV values will be reversed (negated), because dV is always negative (Voltage drop)
         """
         values = {}
-        if self.C_intermediate_uF > 0 and self.C_output_uF > 0:
+        if (self.storage is not None) and self.C_output_uF > 0:
             # first case: storage cap outside of en/dis-thresholds
-            v_old = self.V_intermediate_enable_threshold_mV
+            v_old = self.V_intermediate_enable_output_threshold_mV
             v_out = self.V_output_mV
-            c_store = self.C_intermediate_uF
+            c_store = self.storage.capacity_in_uF
             c_out = self.C_output_uF
             dV_output_en_thrs_mV = v_old - pow(
                 pow(v_old, 2) - (c_out / c_store) * pow(v_out, 2),
@@ -183,6 +203,16 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
             dV_output_en_thrs_mV = 0
             dV_output_imed_low_mV = 0
 
+        if self.enable_boost and self.storage is not None:
+            # TODO: storage could have maximum at a different SoC, is this needed at all?
+            values["V_mid_max_mV"] = min(
+                self.V_intermediate_max_mV,
+                1e3 * self.storage.calc_V_OC(SoC=1.0),
+                10_000,
+            )
+        else:
+            values["V_mid_max_mV"] = self.V_intermediate_max_mV
+
         # protect from complex solutions (non valid input combinations)
         if not (isinstance(dV_output_en_thrs_mV, (int, float)) and (dV_output_en_thrs_mV >= 0)):
             dV_output_en_thrs_mV = 0
@@ -194,25 +224,33 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
         if self.enable_buck > 0:
             V_pre_output_mV = self.V_output_mV + self.V_buck_drop_mV
 
-            if self.V_intermediate_enable_threshold_mV > V_pre_output_mV:
-                values["dV_enable_output_mV"] = dV_output_en_thrs_mV
-                values["V_enable_output_threshold_mV"] = self.V_intermediate_enable_threshold_mV
+            if self.V_intermediate_enable_output_threshold_mV > V_pre_output_mV:
+                values["dV_mid_enable_output_mV"] = dV_output_en_thrs_mV
+                values["V_mid_enable_output_threshold_mV"] = (
+                    self.V_intermediate_enable_output_threshold_mV
+                )
 
             else:
-                values["dV_enable_output_mV"] = dV_output_imed_low_mV
-                values["V_enable_output_threshold_mV"] = (
-                    V_pre_output_mV + values["dV_enable_output_mV"]
+                values["dV_mid_enable_output_mV"] = dV_output_imed_low_mV
+                values["V_mid_enable_output_threshold_mV"] = (
+                    V_pre_output_mV + values["dV_mid_enable_output_mV"]
                 )
 
-            if self.V_intermediate_disable_threshold_mV > V_pre_output_mV:
-                values["V_disable_output_threshold_mV"] = self.V_intermediate_disable_threshold_mV
+            if self.V_intermediate_disable_output_threshold_mV > V_pre_output_mV:
+                values["V_mid_disable_output_threshold_mV"] = (
+                    self.V_intermediate_disable_output_threshold_mV
+                )
             else:
-                values["V_disable_output_threshold_mV"] = V_pre_output_mV
+                values["V_mid_disable_output_threshold_mV"] = V_pre_output_mV
 
         else:
-            values["dV_enable_output_mV"] = dV_output_en_thrs_mV
-            values["V_enable_output_threshold_mV"] = self.V_intermediate_enable_threshold_mV
-            values["V_disable_output_threshold_mV"] = self.V_intermediate_disable_threshold_mV
+            values["dV_mid_enable_output_mV"] = dV_output_en_thrs_mV
+            values["V_mid_enable_output_threshold_mV"] = (
+                self.V_intermediate_enable_output_threshold_mV
+            )
+            values["V_mid_disable_output_threshold_mV"] = (
+                self.V_intermediate_disable_output_threshold_mV
+            )
         return values
 
     def calc_converter_mode(self, dtype_in: EnergyDType, *, log_intermediate_node: bool) -> int:
@@ -221,7 +259,7 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
         log_intermediate_node: record / log virtual intermediate (cap-)voltage and
         -current (out) instead of output-voltage and -current
         """
-        enable_storage = self.C_intermediate_uF > 0
+        enable_storage = self.storage is not None
         enable_boost = self.enable_boost and enable_storage
         if enable_boost != self.enable_boost:
             log.warning("VSrc - boost was disabled due to missing storage capacitor!")
@@ -244,14 +282,6 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
             + 16 * int(enable_feedback)
         )
 
-    def calc_cap_constant_us_per_nF_n28(self) -> int:
-        """Calc constant to convert capacitor-current to Voltage-delta.
-
-        dV[uV] = constant[us/nF] * current[nA] = constant[us*V/nAs] * current[nA]
-        """
-        C_cap_uF = max(self.C_intermediate_uF, 0.001)
-        return int((10**3 * (2**28)) // (C_cap_uF * config.SAMPLERATE_SPS))
-
 
 u32 = Annotated[int, Field(ge=0, lt=2**32)]
 u8 = Annotated[int, Field(ge=0, lt=2**8)]
@@ -265,6 +295,7 @@ lut_i = Annotated[
 lut_o = Annotated[list[u32], Field(min_length=LUT_SIZE, max_length=LUT_SIZE)]
 
 
+@final
 class ConverterPRUConfig(ShpModel):
     """Map settings-list to internal state-vars struct ConverterConfig.
 
@@ -283,13 +314,9 @@ class ConverterPRUConfig(ShpModel):
     R_input_kOhm_n22: u32
     # ⤷ TODO: possible optimization: n32 (range 1uOhm to 1 kOhm) is easier to calc in pru
 
-    Constant_us_per_nF_n28: u32
-    V_intermediate_init_uV: u32
-    I_intermediate_leak_nA: u32
-
-    V_enable_output_threshold_uV: u32
-    V_disable_output_threshold_uV: u32
-    dV_enable_output_uV: u32
+    V_mid_enable_output_threshold_uV: u32
+    V_mid_disable_output_threshold_uV: u32
+    dV_mid_enable_output_uV: u32
     interval_check_thresholds_n: u32
 
     V_pwr_good_enable_threshold_uV: u32
@@ -299,7 +326,7 @@ class ConverterPRUConfig(ShpModel):
     V_output_log_gpio_threshold_uV: u32
 
     V_input_boost_threshold_uV: u32
-    V_intermediate_max_uV: u32
+    V_mid_max_uV: u32
 
     V_output_uV: u32
     V_buck_drop_uV: u32
@@ -331,12 +358,13 @@ class ConverterPRUConfig(ShpModel):
             I_input_max_nA=round(data.I_input_max_mA * 1e6),
             V_input_drop_uV=round(data.V_input_drop_mV * 1e3),
             R_input_kOhm_n22=round(data.R_input_mOhm * (1e-6 * 2**22)),
-            Constant_us_per_nF_n28=data.calc_cap_constant_us_per_nF_n28(),
-            V_intermediate_init_uV=round(data.V_intermediate_init_mV * 1e3),
-            I_intermediate_leak_nA=round(data.I_intermediate_leak_nA),
-            V_enable_output_threshold_uV=round(states["V_enable_output_threshold_mV"] * 1e3),
-            V_disable_output_threshold_uV=round(states["V_disable_output_threshold_mV"] * 1e3),
-            dV_enable_output_uV=round(states["dV_enable_output_mV"] * 1e3),
+            V_mid_enable_output_threshold_uV=round(
+                states["V_mid_enable_output_threshold_mV"] * 1e3
+            ),
+            V_mid_disable_output_threshold_uV=round(
+                states["V_mid_disable_output_threshold_mV"] * 1e3
+            ),
+            dV_mid_enable_output_uV=round(states["dV_mid_enable_output_mV"] * 1e3),
             interval_check_thresholds_n=round(
                 data.interval_check_thresholds_ms * config.SAMPLERATE_SPS * 1e-3
             ),
@@ -346,7 +374,7 @@ class ConverterPRUConfig(ShpModel):
             V_output_log_gpio_threshold_uV=round(data.V_output_log_gpio_threshold_mV * 1e3),
             # Boost-Converter
             V_input_boost_threshold_uV=round(data.V_input_boost_threshold_mV * 1e3),
-            V_intermediate_max_uV=round(data.V_intermediate_max_mV * 1e3),
+            V_mid_max_uV=round(states["V_mid_max_mV"] * 1e3),
             # Buck-Converter
             V_output_uV=round(data.V_output_mV * 1e3),
             V_buck_drop_uV=round(data.V_buck_drop_mV * 1e3),
@@ -362,3 +390,18 @@ class ConverterPRUConfig(ShpModel):
                 for value in data.LUT_output_efficiency
             ],
         )
+
+    def storage_is_enabled(self) -> bool:
+        return bool(self.converter_mode & 1)
+
+    def boost_is_enabled(self) -> bool:
+        return bool(self.converter_mode & 2)
+
+    def buck_is_enabled(self) -> bool:
+        return bool(self.converter_mode & 4)
+
+    def logging_intermediate_node_is_enabled(self) -> bool:
+        return bool(self.converter_mode & 8)
+
+    def feedback_is_enabled(self) -> bool:
+        return bool(self.converter_mode & 16)