shepherd-core 2024.8.2__py3-none-any.whl → 2024.11.1__py3-none-any.whl

shepherd_core/data_models/content/energy_environment.py

@@ -34,6 +34,9 @@ class EnergyEnvironment(ContentModel):
     valid: bool = False
 
     # TODO: scale up/down voltage/current
+    # TODO: multiple files for one env
+    # TODO: mean power as energy/duration
+    # TODO: harvester, transducer
 
     # additional descriptive metadata, TODO: these are very solar-centered -> generalize
     light_source: Optional[str] = None

shepherd_core/data_models/content/virtual_harvester.py

@@ -21,6 +21,7 @@ from .energy_environment import EnergyDType
 class AlgorithmDType(str, Enum):
     """Options for choosing a harvesting algorithm."""
 
+    direct = disable = neutral = "neutral"
     isc_voc = "isc_voc"
     ivcurve = ivcurves = ("ivcurve",)
     constant = cv = "cv"
@@ -62,6 +63,9 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
     # ⤷ of (open voltage) measurement
     rising: bool = True
     # ⤷ direction of sawtooth
+    enable_linear_extrapolation: bool = True
+    # ⤷ improves slow cv-algo that is base of most ivcurve-harvesters
+    #   (update-freq dependent on window-size)
 
     # Underlying recorder
     wait_cycles: Annotated[int, Field(ge=0, le=100)] = 1
@@ -107,7 +111,7 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
         return self
 
     def calc_hrv_mode(self, *, for_emu: bool) -> int:
-        return 1 * int(for_emu) + 2 * self.rising
+        return 1 * int(for_emu) + 2 * self.rising + 4 * self.enable_linear_extrapolation
 
     def calc_algorithm_num(self, *, for_emu: bool) -> int:
         num = algo_to_num.get(self.algorithm)
@@ -117,7 +121,7 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
                 f"current usage = {self.algorithm}"
             )
             raise ValueError(msg)
-        if num < algo_to_num["isc_voc"]:
+        if not for_emu and num < algo_to_num["isc_voc"]:
             msg = (
                 f"[{self.name}] Select valid harvest-algorithm for harvester, "
                 f"current usage = {self.algorithm}"
@@ -177,7 +181,7 @@ u32 = Annotated[int, Field(ge=0, lt=2**32)]
 
 # Currently implemented harvesters
 # NOTE: numbers have meaning and will be tested ->
-# - harvesting on "neutral" is not possible
+# - harvesting on "neutral" is not possible - direct pass-through
 # - emulation with "ivcurve" or lower is also resulting in Error
 # - "_opt" has its own algo for emulation, but is only a fast mppt_po for harvesting
 algo_to_num = {
@@ -192,6 +196,7 @@ algo_to_num = {
 }
 
 algo_to_dtype = {
+    "neutral": EnergyDType.ivsample,
     "isc_voc": EnergyDType.isc_voc,
     "ivcurve": EnergyDType.ivcurve,
     "cv": EnergyDType.ivsample,

shepherd_core/data_models/content/virtual_harvester_fixture.yaml

@@ -3,10 +3,13 @@
 # - look into the implementation to see which parameters are used
 # - base for neutral fallback values if provided yml is sparse
 # - -> it is encouraged to omit redundant parameters in your own implementation
+# - general rule: 0<id<2000 harvest from transducers, 2000<=id harvest from ivcurve
+
 - datatype: VirtualHarvesterConfig
   parameters:
     id: 1000
     name: neutral
+    enable_linear_extrapolation: true
     owner: Ingmar
     group: NES Lab
     visible2group: true
@@ -16,7 +19,7 @@
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1010
+    id: 1100
     name: ivcurve
     description: Postpone harvesting by sampling ivcurves (voltage stepped as sawtooth-wave)
     comment: ~110 Hz, Between 50 & 60 Hz line-frequency to avoid standing waves
@@ -32,19 +35,19 @@
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1011
+    id: 1101
     name: ivcurves  # synonym
     inherit_from: ivcurve
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1013
+    id: 1103
     name: iv110 # synonym
     inherit_from: ivcurve
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1012
+    id: 1102
     name: iv1000
     comment: Name relates to curves per second
     inherit_from: ivcurve
@@ -53,7 +56,7 @@
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1020
+    id: 1200
     name: isc_voc
     description: Postpone harvesting by sampling short circuit current & open circuit voltage
     inherit_from: neutral
@@ -62,7 +65,7 @@
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1030
+    id: 2100
     name: cv20
     description: Harvesting with constant Voltage
     inherit_from: neutral
@@ -71,28 +74,28 @@
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1031
+    id: 2101
     name: cv24
     inherit_from: cv20
     voltage_mV: 2400
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1032
+    id: 2102
     name: cv33
     inherit_from: cv20
     voltage_mV: 3300
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1032
+    id: 2102
     name: cv10
     inherit_from: cv20
     voltage_mV: 1000
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1040
+    id: 2200
     name: mppt_voc
     description: MPPT based on open circuit voltage for solar
     inherit_from: neutral
@@ -104,7 +107,7 @@
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1041
+    id: 2201
     name: mppt_bq
     description: MPPT of TI BQ-Converters for solar
     inherit_from: mppt_voc
@@ -114,7 +117,7 @@
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1042
+    id: 2202
     name: mppt_bqt
     description: MPPT of TI BQ-Converters for thermoelectric
     inherit_from: mppt_voc
@@ -124,19 +127,19 @@
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1043
+    id: 2203
     name: mppt_bq_solar # explicit naming
     inherit_from: mppt_bq
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1044
+    id: 2204
     name: mppt_bq_thermoelectric # explicit naming
     inherit_from: mppt_bqt
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1045
+    id: 2205
     name: mppt_po
     description: MPPT based on perturb & observe algorithm
     inherit_from: neutral
@@ -148,10 +151,18 @@
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1046
+    id: 2206
     name: mppt_opt
     description: Power-Optimum with very fast PO-Variant (harvesting) or special max-pwr-picker (emulator / ivcurve)
     inherit_from: mppt_po
     algorithm: mppt_opt
     voltage_step_mV: 1
     interval_ms: 0.01
+
+- datatype: VirtualHarvesterConfig
+  parameters:
+    id: 3000
+    name: direct
+    description: Disables harvesting, even for ivcurve-input
+    inherit_from: neutral
+    algorithm: neutral

shepherd_core/data_models/content/virtual_source.py

@@ -12,6 +12,7 @@ from ...logger import logger
 from ...testbed_client import tb_client
 from ..base.content import ContentModel
 from ..base.shepherd import ShpModel
+from .energy_environment import EnergyDType
 from .virtual_harvester import HarvesterPRUConfig
 from .virtual_harvester import VirtualHarvesterConfig
 
@@ -42,6 +43,8 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
     # ⤷ 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
 
     interval_startup_delay_drain_ms: Annotated[float, Field(ge=0, le=10_000)] = 0
 
@@ -200,7 +203,7 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
             values["V_disable_output_threshold_mV"] = self.V_intermediate_disable_threshold_mV
         return values
 
-    def calc_converter_mode(self, *, log_intermediate_node: bool) -> int:
+    def calc_converter_mode(self, dtype_in: EnergyDType, *, log_intermediate_node: bool) -> int:
         """Assembles bitmask from discrete values.
 
         log_intermediate_node: record / log virtual intermediate (cap-)voltage and
@@ -208,11 +211,25 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
         """
         enable_storage = self.C_intermediate_uF > 0
         enable_boost = self.enable_boost and enable_storage
+        if enable_boost != self.enable_boost:
+            logger.warning("VSrc - boost was disabled due to missing storage capacitor!")
+        enable_feedback = (
+            self.enable_feedback_to_hrv
+            and enable_storage
+            and not enable_boost
+            and dtype_in == EnergyDType.ivcurve
+        )
+        if enable_feedback != self.enable_feedback_to_hrv:
+            reason = "enabled boost, " if enable_boost else ""
+            reason += "" if dtype_in == EnergyDType.ivcurve else "input not ivcurve, "
+            reason += "" if enable_storage else "no storage capacitor"
+            logger.warning("VSRC - feedback to harvester was disabled! Reasons: %s", reason)
         return (
             1 * int(enable_storage)
             + 2 * int(enable_boost)
             + 4 * int(self.enable_buck)
             + 8 * int(log_intermediate_node)
+            + 16 * int(enable_feedback)
         )
 
     def calc_cap_constant_us_per_nF_n28(self) -> int:
@@ -285,13 +302,16 @@ class ConverterPRUConfig(ShpModel):
     def from_vsrc(
         cls,
         data: VirtualSourceConfig,
+        dtype_in: EnergyDType = EnergyDType.ivsample,
         *,
         log_intermediate_node: bool = False,
     ) -> Self:
         states = data.calc_internal_states()
         return cls(
             # General
-            converter_mode=data.calc_converter_mode(log_intermediate_node=log_intermediate_node),
+            converter_mode=data.calc_converter_mode(
+                dtype_in, log_intermediate_node=log_intermediate_node
+            ),
             interval_startup_delay_drain_n=round(
                 data.interval_startup_delay_drain_ms * samplerate_sps_default * 1e-3
             ),

shepherd_core/data_models/content/virtual_source_fixture.yaml

@@ -11,6 +11,7 @@
     # General Config
     enable_boost: false # if false -> v_intermediate = v_input, output-switch-hysteresis is still usable
     enable_buck: false # if false -> v_output = v_intermediate
+    enable_feedback_to_hrv: false  # src can control a cv-harvester for ivcurve
 
     interval_startup_delay_drain_ms: 0
 
@@ -26,18 +27,21 @@
     V_intermediate_init_mV: 3000 # allow a proper / fast startup
     I_intermediate_leak_nA: 0.0
 
+    # Output-Switch with comparator and hysteresis
     V_intermediate_enable_threshold_mV: 1 # -> target gets connected (hysteresis-combo with next value)
     V_intermediate_disable_threshold_mV: 0 # -> target gets disconnected
     interval_check_thresholds_ms: 0.0  # some BQs check every 64 ms if output should be disconnected
 
+    # Power-Good signal from comparator and hysteresis
     V_pwr_good_enable_threshold_mV: 2800 # target is informed by pwr-good on output-pin (hysteresis) -> for intermediate voltage
     V_pwr_good_disable_threshold_mV: 2200
     immediate_pwr_good_signal: true  # 1: activate instant schmitt-trigger, 0: stay in interval for checking thresholds
 
-    C_output_uF: 1.0   # final (always last) stage to compensate undetectable current spikes when enabling power for target
+    C_output_uF: 1.0   # final (always last) stage to compensate transient current spikes when enabling power for target
 
     # Extra
     V_output_log_gpio_threshold_mV: 1400  # min voltage needed to enable recording changes in gpio-bank
+    # TODO: actually disable gpio below that
 
     # Boost Converter
     V_input_boost_threshold_mV: 0.0 # min input-voltage for the boost converter to work
@@ -81,6 +85,8 @@
     id: 1010
     name: direct
     inherit_from: neutral
+    harvester:
+      name: direct  # even disables harvesting of ivcurve
     # Note: current input has no influence
 
 - datatype: VirtualSourceConfig
@@ -90,7 +96,13 @@
     description: Simple Converter based on diode and buffer capacitor
     inherit_from: neutral
     V_input_drop_mV: 300  # simulate input-diode
-    C_intermediate_uF: 10  # primary storage-Cap
+    C_intermediate_uF: 47  # primary storage-Cap
+    harvester:
+      name: cv20
+    enable_feedback_to_hrv: true  # src can control a cv-harvester for ivcurve
+    V_intermediate_enable_threshold_mV: 2000
+    V_intermediate_disable_threshold_mV: 1800  # nRF draw ~0.5 mA below that point
+    # TODO: put switch-output into special nRF Version
 
 - datatype: VirtualSourceConfig
   parameters:
@@ -230,3 +242,5 @@
     id: 1033
     name: default
     inherit_from: BQ25570s
+
+# TODO: add some generic boost-converters with mppt_po, _voc and more

shepherd_core/data_models/task/emulation.py

@@ -33,7 +33,8 @@ class Compression(str, Enum):
     lzf = default = "lzf"  # not native hdf5
     gzip1 = gzip = 1  # higher compr & load
     null = None
-    # NOTE: changed to lzf as BBB needs every straw it can get
+    # NOTE: lzf & external file-compression (xz or zstd) work better than gzip
+    #       -> even with additional compression
 
 
 compressions_allowed: list = [None, "lzf", 1]

shepherd_core/reader.py

@@ -76,7 +76,7 @@ class Reader:
 
         if not hasattr(self, "samplerate_sps"):
             self.samplerate_sps: int = samplerate_sps_default
-        self.sample_interval_ns: int = int(10**9 // self.samplerate_sps)
+        self.sample_interval_ns: int = round(10**9 // self.samplerate_sps)
         self.sample_interval_s: float = 1 / self.samplerate_sps
 
         self.max_elements: int = 40 * self.samplerate_sps
@@ -177,8 +177,8 @@ class Reader:
             # this assumes iso-chronous sampling
             duration_s = self._cal.time.raw_to_si(duration_raw)
             self.sample_interval_s = duration_s / sample_count
-            self.sample_interval_ns = int(10**9 * self.sample_interval_s)
-            self.samplerate_sps = max(int((sample_count - 1) / duration_s), 1)
+            self.sample_interval_ns = round(10**9 * self.sample_interval_s)
+            self.samplerate_sps = max(round((sample_count - 1) / duration_s), 1)
         self.runtime_s = round(self.ds_voltage.shape[0] / self.samplerate_sps, 1)
         self.buffers_n = int(self.ds_voltage.shape[0] // self.samples_per_buffer)
         if isinstance(self.file_path, Path):

shepherd_core/version.py

@@ -1,3 +1,3 @@
 """Separated string avoids circular imports."""
 
-version: str = "2024.8.2"
+version: str = "2024.11.1"

shepherd_core/vsource/target_model.py

@@ -9,8 +9,10 @@ TODO: add more targets
   - riotee
 """
 
+import math
 from abc import ABC
 from abc import abstractmethod
+from contextlib import suppress
 
 
 class TargetABC(ABC):
@@ -22,41 +24,118 @@ class TargetABC(ABC):
 
 
 class ResistiveTarget(TargetABC):
-    """Predictable target for matching the real world."""
+    """Predictable target with linear behavior."""
 
-    def __init__(self, resistance_Ohm: float, *, controlled: bool = False) -> None:
-        if resistance_Ohm <= 1e-3:
+    def __init__(self, R_Ohm: float, *, controlled: bool = False) -> None:
+        if R_Ohm <= 1e-3:
             raise ValueError("Resistance must be greater than 1 mOhm.")
-        self.r_kOhm = 1e-3 * resistance_Ohm
+        self.R_kOhm = 1e-3 * R_Ohm
         self.ctrl = controlled
 
     def step(self, voltage_uV: int, *, pwr_good: bool) -> float:
         if pwr_good or not self.ctrl:
-            return voltage_uV / self.r_kOhm  # = nA
+            return voltage_uV / self.R_kOhm  # = nA
+        return 0
+
+
+class DiodeTarget(TargetABC):
+    """Emulate a diode and current limiting resistor in series.
+
+    Good for modeling a debug-diode that burns energy.
+    It uses Shockley Diode Equation to estimate a model for diode
+    I_D = I_S * ( e ^ ( U_D / n*U_T ) - 1 )
+
+    diode of shepherd target:
+    d1 = DiodeTarget(V_forward_V = 2.0, I_forward_A = 20e-3, R_Ohm = 100)
+
+    """
+
+    def __init__(
+        self,
+        V_forward_V: float,
+        I_forward_A: float,
+        R_Ohm: float,
+        *,
+        controlled: bool = False,
+    ) -> None:
+        if R_Ohm <= 1e-3:
+            raise ValueError("Resistance must be greater than 1 mOhm.")
+        if V_forward_V <= 0.2:
+            raise ValueError("Forward-Voltage of diode must be greater than 200 mV.")
+        if I_forward_A <= 0:
+            raise ValueError("Forward-current of diode must be greater than 0 A.")
+
+        k = 1.380649e-23  # boltzmann
+        q = 1.6021766e-19  # elementary charge
+        TJ = 100 + 273.15  # junction temperature
+
+        V_T = k * TJ / q  # thermal voltage
+        n = 2  # ideality factor
+        self.c1 = V_T * n
+        # NOTE: math.expm1(x) = math.exp(x) - 1 = e^x -1
+        self.I_S = I_forward_A / math.expm1(V_forward_V / self.c1)  # scale current
+        self.R_Ohm = R_Ohm
+        self.ctrl = controlled
+
+    def step(self, voltage_uV: int, *, pwr_good: bool) -> float:
+        if pwr_good or not self.ctrl:
+            V_CC = voltage_uV * 1e-6
+            V_D = V_CC / 2
+            I_R = I_D = 0
+            # there is no direct formular, but this iteration converges fast
+            for _ in range(10):
+                # low voltages tend to produce log(x<0)=err
+                with suppress(ValueError):
+                    V_D = self.c1 * math.log(1 + (V_CC - V_D) / (self.R_Ohm * self.I_S))
+                # both currents are positive and should be identical
+                I_R = max(0.0, (V_CC - V_D) / self.R_Ohm)
+                I_D = max(0.0, self.I_S * math.expm1(V_D / self.c1))
+                with suppress(ZeroDivisionError):
+                    if abs(I_R / I_D - 1) < 1e-6:
+                        break
+                # take mean of both currents and determine a new V_D
+                V_D = V_CC - self.R_Ohm * (I_R + I_D) / 2
+            return 1e9 * (I_R + I_D) / 2  # = nA
         return 0
 
 
 class ConstantCurrentTarget(TargetABC):
-    """Recreate simple MCU without integrated regulator."""
+    """Recreate simple MCU without integrated regulator, i.e. msp430."""
 
-    def __init__(self, i_active_A: float, i_sleep_A: float = 0) -> None:
-        if i_active_A <= 0 or i_sleep_A <= 0:
+    def __init__(self, I_active_A: float, I_sleep_A: float = 0) -> None:
+        if I_active_A <= 0 or I_sleep_A < 0:
             raise ValueError("Current must be greater than 0.")
-        self.i_active_nA = 1e9 * i_active_A
-        self.i_sleep_nA = 1e9 * i_sleep_A
+        self.I_active_nA = 1e9 * I_active_A
+        self.I_sleep_nA = 1e9 * I_sleep_A
 
     def step(self, voltage_uV: int, *, pwr_good: bool) -> float:  # noqa: ARG002
-        return self.i_active_nA if pwr_good else self.i_sleep_nA
+        return self.I_active_nA if pwr_good else self.I_sleep_nA
 
 
 class ConstantPowerTarget(TargetABC):
-    """Recreate MCU with integrated regulator."""
+    """Recreate MCU with integrated regulator, i.e. nRF52."""
 
-    def __init__(self, p_active_W: float, p_sleep_W: float = 0) -> None:
-        if p_active_W <= 0 or p_sleep_W <= 0:
+    def __init__(self, P_active_W: float, P_sleep_W: float = 0) -> None:
+        if P_active_W <= 0 or P_sleep_W < 0:
             raise ValueError("Power must be greater than 0.")
-        self.p_active_fW = 1e15 * p_active_W
-        self.p_sleep_fW = 1e15 * p_sleep_W
+        self.P_active_fW = 1e15 * P_active_W
+        self.P_sleep_fW = 1e15 * P_sleep_W
 
     def step(self, voltage_uV: int, *, pwr_good: bool) -> float:
-        return (self.p_active_fW if pwr_good else self.p_sleep_fW) / voltage_uV  # = nA
+        return (self.P_active_fW if pwr_good else self.P_sleep_fW) / voltage_uV  # = nA
+
+
+# exemplary instantiations
+
+diode_target_burn = DiodeTarget(V_forward_V=2.0, I_forward_A=20e-3, R_Ohm=100)
+mcu_msp430fr = ConstantCurrentTarget(I_active_A=16 * 118e-6, I_sleep_A=350e-9)
+mcu_msp_deep_sleep = ConstantCurrentTarget(45e-9, 45e-9)
+# TODO: writing FRAM
+mcu_nrf52840 = ConstantPowerTarget(P_active_W=3 * 3e-3, P_sleep_W=3 * 0.97e-6)
+mcu_nrf_tx_8dBm = ConstantPowerTarget(P_active_W=3.0 * 16.40e-3)
+mcu_nrf_tx_0dBm = ConstantPowerTarget(P_active_W=3.0 * 6.40e-3)
+mcu_nrf_rx = ConstantPowerTarget(P_active_W=3.0 * 6.26e-3)
+# data based on PS1.10
+# - TX 8 dBm -> 6.31 mW -> DS shows 16.40 mA @ 3V (DC/DC)
+# - TX 0 dBm -> 1 mW ->              6.40 mA
+# - RX ->                            6.26 mA

shepherd_core/vsource/virtual_converter_model.py

@@ -43,21 +43,18 @@ class PruCalibration:
                 self.negative_residue_nA = 0
             else:
                 self.negative_residue_nA = self.negative_residue_nA - I_nA
-                if self.negative_residue_nA > self.RESIDUE_MAX_nA:
-                    self.negative_residue_nA = self.RESIDUE_MAX_nA
+                self.negative_residue_nA = min(self.negative_residue_nA, self.RESIDUE_MAX_nA)
                 I_nA = 0
         return I_nA
 
     @staticmethod
-    def conv_adc_raw_to_uV(voltage_raw: int) -> float:
+    def conv_adc_raw_to_uV(voltage_raw: int) -> None:
         msg = f"This Fn should not been used (val={voltage_raw})"
         raise RuntimeError(msg)
 
     def conv_uV_to_dac_raw(self, voltage_uV: float) -> int:
         dac_raw = self.cal.dac_V_A.si_to_raw(float(voltage_uV) / (10**6))
-        if dac_raw > (2**16) - 1:
-            dac_raw = (2**16) - 1
-        return dac_raw
+        return min(dac_raw, (2**16) - 1)
 
 
 class VirtualConverterModel:
@@ -85,6 +82,9 @@ class VirtualConverterModel:
         self.enable_boost: bool = (int(self._cfg.converter_mode) & 0b0010) > 0
         self.enable_buck: bool = (int(self._cfg.converter_mode) & 0b0100) > 0
         self.enable_log_mid: bool = (int(self._cfg.converter_mode) & 0b1000) > 0
+        # back-channel to hrv
+        self.feedback_to_hrv: bool = (int(self._cfg.converter_mode) & 0b1_0000) > 0
+        self.V_input_request_uV: int = self._cfg.V_intermediate_init_uV
 
         self.V_out_dac_uV: float = self._cfg.V_output_uV
         self.V_out_dac_raw: int = self._cal.conv_uV_to_dac_raw(self._cfg.V_output_uV)
@@ -95,12 +95,13 @@ class VirtualConverterModel:
         self.V_enable_output_threshold_uV: float = self._cfg.V_enable_output_threshold_uV
         self.V_disable_output_threshold_uV: float = self._cfg.V_disable_output_threshold_uV
 
-        if self.dV_enable_output_uV > self.V_enable_output_threshold_uV:
-            self.V_enable_output_threshold_uV = self.dV_enable_output_uV
+        self.V_enable_output_threshold_uV = max(
+            self.dV_enable_output_uV, self.V_enable_output_threshold_uV
+        )
 
         # pulled from update_states_and_output() due to easier static init
         self.sample_count: int = 0xFFFFFFF0
-        self.is_outputting: bool = True
+        self.is_outputting: bool = False
         self.vsource_skip_gpio_logging: bool = False
 
     def calc_inp_power(self, input_voltage_uV: float, input_current_nA: float) -> int:
@@ -114,31 +115,40 @@ class VirtualConverterModel:
         else:
             input_voltage_uV = 0.0
 
-        if input_voltage_uV > self._cfg.V_input_max_uV:
-            input_voltage_uV = self._cfg.V_input_max_uV
+        input_voltage_uV = min(input_voltage_uV, self._cfg.V_input_max_uV)
 
-        if input_current_nA > self._cfg.I_input_max_nA:
-            input_current_nA = self._cfg.I_input_max_nA
+        input_current_nA = min(input_current_nA, self._cfg.I_input_max_nA)
 
         self.V_input_uV = input_voltage_uV
 
         if self.enable_boost:
             if input_voltage_uV < self._cfg.V_input_boost_threshold_uV:
                 input_voltage_uV = 0.0
-        elif not self.enable_storage:
-            # direct connection
-            self.V_mid_uV = input_voltage_uV
-            input_voltage_uV = 0.0
-            # ⤷ input current (& power) is not evaluated
-        elif input_voltage_uV > self.V_mid_uV:
-            V_diff_uV = input_voltage_uV - self.V_mid_uV
-            V_drop_uV = input_current_nA * self.R_input_kOhm
-            if V_drop_uV > V_diff_uV:
+            # TODO: vdrop in case of v_input > v_storage (non-boost)
+        elif self.enable_storage:
+            # no boost, but cap, for ie. diode+cap (+resistor)
+            V_diff_uV = (
+                (input_voltage_uV - self.V_mid_uV) if (input_voltage_uV >= self.V_mid_uV) else 0
+            )
+            V_res_drop_uV = input_current_nA * self.R_input_kOhm
+            if V_res_drop_uV > V_diff_uV:
                 input_voltage_uV = self.V_mid_uV
             else:
-                input_voltage_uV -= V_drop_uV
+                input_voltage_uV -= V_res_drop_uV
+
+            # IF input==ivcurve request new CV
+            if self.feedback_to_hrv:
+                self.V_input_request_uV = self.V_mid_uV + V_res_drop_uV + self._cfg.V_input_drop_uV
+            elif input_voltage_uV < self.V_mid_uV:
+                # without feedback there is no usable energy here
+                input_voltage_uV = 0
         else:
+            # direct connection
+            # modifying V_mid here is not clean, but simpler
+            # -> V_mid is needed in calc_out, before cap is updated
+            self.V_mid_uV = input_voltage_uV
             input_voltage_uV = 0.0
+            # ⤷ input will not be evaluated
 
         if self.enable_boost:
             eta_inp = self.get_input_efficiency(input_voltage_uV, input_current_nA)
@@ -170,6 +180,7 @@ class VirtualConverterModel:
 
     # TODO: add range-checks for add, sub Ops
     def update_cap_storage(self) -> int:
+        # TODO: this calculation is wrong for everything beside boost-cnv
         if self.enable_storage:
             V_mid_prot_uV = max(1.0, self.V_mid_uV)
             P_sum_fW = self.P_inp_fW - self.P_out_fW
@@ -177,34 +188,31 @@ class VirtualConverterModel:
             dV_mid_uV = I_mid_nA * self.Constant_us_per_nF
             self.V_mid_uV += dV_mid_uV
 
-        if self.V_mid_uV > self._cfg.V_intermediate_max_uV:
-            self.V_mid_uV = self._cfg.V_intermediate_max_uV
-        if (not self.enable_boost) and (self.P_inp_fW > 0.0) and (self.V_mid_uV > self.V_input_uV):
-            # TODO: obfuscated - no "direct connection"?
-            self.V_mid_uV = self.V_input_uV
-        elif self.V_mid_uV < 1:
-            self.V_mid_uV = 1
+        self.V_mid_uV = min(self.V_mid_uV, self._cfg.V_intermediate_max_uV)
+        self.V_mid_uV = max(self.V_mid_uV, 1)
         return round(self.V_mid_uV)  # Python-specific, added for easier testing
 
     def update_states_and_output(self) -> int:
         self.sample_count += 1
         check_thresholds = self.sample_count >= self._cfg.interval_check_thresholds_n
+        V_mid_uV_now = self.V_mid_uV
+        # copy avoids not enabling pwr_good (due to large dV_enable_output_uV)
 
         if check_thresholds:
             self.sample_count = 0
             if self.is_outputting:
-                if self.V_mid_uV < self.V_disable_output_threshold_uV:
+                if V_mid_uV_now < self.V_disable_output_threshold_uV:
                     self.is_outputting = False
-            elif self.V_mid_uV >= self.V_enable_output_threshold_uV:
+            elif V_mid_uV_now >= self.V_enable_output_threshold_uV:
                 self.is_outputting = True
                 self.V_mid_uV -= self.dV_enable_output_uV
 
         if check_thresholds or self._cfg.immediate_pwr_good_signal:
             # generate power-good-signal
             if self.power_good:
-                if self.V_mid_uV <= self._cfg.V_pwr_good_disable_threshold_uV:
+                if V_mid_uV_now <= self._cfg.V_pwr_good_disable_threshold_uV:
                     self.power_good = False
-            elif self.V_mid_uV >= self._cfg.V_pwr_good_enable_threshold_uV:
+            elif V_mid_uV_now >= self._cfg.V_pwr_good_enable_threshold_uV:
                 self.power_good = self.is_outputting
             # set batok pin to state ... TODO?
 
@@ -270,7 +278,7 @@ class VirtualConverterModel:
     def get_power_good(self) -> bool:
         return self.power_good
 
-    def get_I_mod_out_nA(self) -> float:
+    def get_I_mid_out_nA(self) -> float:
         return self.P_out_fW / self.V_mid_uV
 
     def get_state_log_intermediate(self) -> bool:

shepherd_core/vsource/virtual_harvester_model.py

@@ -19,6 +19,7 @@ Compromises:
 from typing import Tuple
 
 from ..data_models.content.virtual_harvester import HarvesterPRUConfig
+from ..logger import logger
 
 
 class VirtualHarvesterModel:
@@ -35,12 +36,20 @@ class VirtualHarvesterModel:
 
         # INIT global vars: shared states
         self.voltage_set_uV: int = self._cfg.voltage_uV + 1
+
+        self.is_emu: bool = bool(self._cfg.hrv_mode & (2**0))
+        if not self.is_emu:
+            logger.warning(
+                "This VSrc-config is not meant for emulation-mode -> activate 'is_emu' flag."
+            )
+
         if self._cfg.interval_n > 2 * self._cfg.window_size:
             self.interval_step = self._cfg.interval_n - (2 * self._cfg.window_size)
         else:
             self.interval_step = 2**30
         # ⤷ intake two ivcurves before overflow / reset
-        self.is_rising: bool = (self._cfg.hrv_mode & (2**1)) != 0
+
+        self.is_rising: bool = bool(self._cfg.hrv_mode & (2**1))
 
         # PO-Relevant, iv & adc
         self.volt_step_uV: int = self._cfg.voltage_step_uV
@@ -54,13 +63,16 @@ class VirtualHarvesterModel:
         # globals for iv_cv
         self.voltage_hold: int = 0
         self.current_hold: int = 0
-        self.voltage_step_x4_uV: int = self._cfg.voltage_step_uV * 4
+        self.voltage_step_x4_uV: int = 4 * self._cfg.voltage_step_uV
         self.age_max: int = 2 * self._cfg.window_size
 
         # INIT static vars: CV
         self.voltage_last: int = 0
         self.current_last: int = 0
         self.compare_last: int = 0
+        self.lin_extrapolation: bool = bool(self._cfg.hrv_mode & (2**2))
+        self.current_delta: int = 0
+        self.voltage_delta: int = 0
 
         # INIT static vars: VOC
         self.age_now: int = 0
@@ -106,9 +118,28 @@ class VirtualHarvesterModel:
             if distance_now < distance_last and distance_now < self.voltage_step_x4_uV:
                 self.voltage_hold = _voltage_uV
                 self.current_hold = _current_nA
+                self.current_delta = _current_nA - self.current_last
+                self.voltage_delta = _voltage_uV - self.voltage_last
+                # TODO: voltage_delta is static
             elif distance_last < distance_now and distance_last < self.voltage_step_x4_uV:
                 self.voltage_hold = self.voltage_last
                 self.current_hold = self.current_last
+                self.current_delta = _current_nA - self.current_last
+                self.voltage_delta = _voltage_uV - self.voltage_last
+        elif self.lin_extrapolation:
+            # apply the proper delta if needed
+            if (self.voltage_hold < self.voltage_set_uV) == (self.voltage_delta > 0):
+                self.voltage_hold += self.voltage_delta
+                self.current_hold += self.current_delta
+            else:
+                if self.voltage_hold > self.voltage_delta:
+                    self.voltage_hold -= self.voltage_delta
+                else:
+                    self.voltage_hold = 0
+                if self.current_hold > self.current_delta:
+                    self.current_hold -= self.current_delta
+                else:
+                    self.current_hold = 0
 
         self.voltage_last = _voltage_uV
         self.current_last = _current_nA
@@ -139,8 +170,9 @@ class VirtualHarvesterModel:
 
         _voltage_uV, _current_nA = self.ivcurve_2_cv(_voltage_uV, _current_nA)
         if self.interval_step < self._cfg.duration_n:
+            self.voltage_set_uV = self.voc_now
+        elif self.interval_step == self._cfg.duration_n:
             self.voltage_set_uV = int(self.voc_now * self._cfg.setpoint_n8 / 256)
-            _current_nA = 0
 
         return _voltage_uV, _current_nA
 
@@ -194,7 +226,7 @@ class VirtualHarvesterModel:
 
         power_fW = _voltage_uV * _current_nA
         if (
-            (power_fW > self.power_nxt)
+            (power_fW >= self.power_nxt)
             and (_voltage_uV >= self._cfg.voltage_min_uV)
             and (_voltage_uV <= self._cfg.voltage_max_uV)
         ):

shepherd_core/vsource/virtual_source_model.py

@@ -39,7 +39,9 @@ class VirtualSourceModel:
 
         self.cfg_src = VirtualSourceConfig() if vsrc is None else vsrc
         cnv_config = ConverterPRUConfig.from_vsrc(
-            self.cfg_src, log_intermediate_node=log_intermediate
+            self.cfg_src,
+            dtype_in=dtype_in,
+            log_intermediate_node=log_intermediate,
         )
         self.cnv: VirtualConverterModel = VirtualConverterModel(cnv_config, self._cal_pru)
 
@@ -80,4 +82,8 @@ class VirtualSourceModel:
         self.W_inp_fWs += P_inp_fW
         self.W_out_fWs += P_out_fW
 
+        # feedback path - important for boost-less circuits
+        if self.cnv.feedback_to_hrv:
+            self.hrv.voltage_set_uV = self.cnv.V_input_request_uV
+
         return V_mid_uV if self.cnv.get_state_log_intermediate() else V_out_uV

shepherd_core/vsource/virtual_source_simulation.py

@@ -11,12 +11,14 @@ from contextlib import ExitStack
 from pathlib import Path
 from typing import Optional
 
+import numpy as np
 from tqdm import tqdm
 
 from .. import CalibrationEmulator
 from .. import Reader
 from .. import Writer
 from ..data_models import VirtualSourceConfig
+from ..logger import logger
 from . import VirtualSourceModel
 from .target_model import TargetABC
 
@@ -26,6 +28,8 @@ def simulate_source(
     target: TargetABC,
     path_input: Path,
     path_output: Optional[Path] = None,
+    *,
+    monitor_internals: bool = False,
 ) -> float:
     """Simulate behavior of virtual source algorithms.
 
@@ -47,10 +51,25 @@ def simulate_source(
         cal_out = file_out.get_calibration_data()
 
     src = VirtualSourceModel(
-        config, cal_emu, log_intermediate=False, window_size=file_inp.get_window_samples()
+        config,
+        cal_emu,
+        dtype_in=file_inp.get_datatype(),
+        log_intermediate=False,
+        window_size=file_inp.get_window_samples(),
     )
     i_out_nA = 0
     e_out_Ws = 0.0
+    if monitor_internals and path_output:
+        stats_sample = 0
+        stats_internal = np.empty((round(file_inp.runtime_s * file_inp.samplerate_sps), 11))
+        try:
+            # keep dependencies low
+            from matplotlib import pyplot as plt
+        except ImportError:
+            logger.warning("Matplotlib not installed, plotting of internals disabled")
+            stats_internal = None
+    else:
+        stats_internal = None
 
     for _t, v_inp, i_inp in tqdm(
         file_inp.read_buffers(is_raw=True), total=file_inp.buffers_n, desc="Buffers", leave=False
@@ -66,7 +85,22 @@ def simulate_source(
             )
             i_out_nA = target.step(int(v_uV[_n]), pwr_good=src.cnv.get_power_good())
             i_nA[_n] = i_out_nA
-            # TODO: src.cnv.get_I_mod_out_nA() has more internal drains
+
+            if stats_internal is not None:
+                stats_internal[stats_sample] = [
+                    _t[_n] * 1e-9,  # s
+                    src.hrv.voltage_hold * 1e-6,
+                    src.cnv.V_input_request_uV * 1e-6,  # V
+                    src.hrv.voltage_set_uV * 1e-6,
+                    src.cnv.V_mid_uV * 1e-6,
+                    src.hrv.current_hold * 1e-6,  # mA
+                    src.hrv.current_delta * 1e-6,
+                    i_out_nA * 1e-6,
+                    src.cnv.P_inp_fW * 1e-12,  # mW
+                    src.cnv.P_out_fW * 1e-12,
+                    src.cnv.get_power_good(),
+                ]
+                stats_sample += 1
 
         e_out_Ws += (v_uV * i_nA).sum() * 1e-15 * file_inp.sample_interval_s
         if path_output:
@@ -75,4 +109,36 @@ def simulate_source(
             file_out.append_iv_data_raw(_t, v_out, i_out)
 
     stack.close()
+
+    if stats_internal is not None:
+        stats_internal = stats_internal[:stats_sample, :]
+        fig, axs = plt.subplots(4, 1, sharex="all", figsize=(20, 4 * 6), layout="tight")
+        fig.suptitle(f"VSrc-Sim with {config.name}, Inp={path_input.name}, E={e_out_Ws} Ws")
+        axs[0].set_ylabel("Voltages [V]")
+        axs[0].plot(stats_internal[:, 0], stats_internal[:, 1:5])
+        axs[0].legend(["V_cv_hold", "V_inp_Req", "V_cv_set", "V_cap"], loc="upper right")
+
+        axs[1].set_ylabel("Current [mA]")
+        axs[1].plot(stats_internal[:, 0], stats_internal[:, 5:8])
+        axs[1].legend(["C_cv_hold", "C_cv_delta", "C_out"], loc="upper right")
+
+        axs[2].set_ylabel("Power [mW]")
+        axs[2].plot(stats_internal[:, 0:1], stats_internal[:, 8:10])
+        axs[2].legend(["P_inp", "P_out"], loc="upper right")
+
+        axs[3].set_ylabel("PwrGood [n]")
+        axs[3].plot(stats_internal[:, 0], stats_internal[:, 10])
+        axs[3].legend(["PwrGood"], loc="upper right")
+
+        axs[3].set_xlabel("Runtime [s]")
+
+        for ax in axs:
+            # deactivates offset-creation for ax-ticks
+            ax.get_yaxis().get_major_formatter().set_useOffset(False)
+            ax.get_xaxis().get_major_formatter().set_useOffset(False)
+
+        plt.savefig(path_output.with_suffix(".png"))
+        plt.close(fig)
+        plt.clf()
+
     return e_out_Ws

shepherd_core/writer.py

@@ -94,7 +94,7 @@ class Writer(Reader):
 
     comp_default: int = 1
     mode_default: str = "harvester"
-    datatype_default: str = EnergyDType.ivsample
+    datatype_default: EnergyDType = EnergyDType.ivsample
 
     _chunk_shape: tuple = (Reader.samples_per_buffer,)
 
@@ -137,79 +137,72 @@ class Writer(Reader):
                 self.file_path.name,
             )
 
+        # open file
+        if self._modify:
+            self.h5file = h5py.File(self.file_path, "r+")  # = rw
+        else:
+            if not self.file_path.parent.exists():
+                self.file_path.parent.mkdir(parents=True)
+            self.h5file = h5py.File(self.file_path, "w")
+            # ⤷ write, truncate if exist
+            self._create_skeleton()
+
+        # Handle Mode
         if isinstance(mode, str) and mode not in self.mode_dtype_dict:
             msg = f"Can't handle mode '{mode}' (choose one of {self.mode_dtype_dict})"
             raise ValueError(msg)
 
-        _dtypes = self.mode_dtype_dict[mode or self.mode_default]
+        if mode is not None:
+            self.h5file.attrs["mode"] = mode
+        if "mode" not in self.h5file.attrs:
+            self.h5file.attrs["mode"] = self.mode_default
+
+        _dtypes = self.mode_dtype_dict[self.get_mode()]
+
+        # Handle Datatype
         if isinstance(datatype, str):
             datatype = EnergyDType[datatype]
         if isinstance(datatype, EnergyDType) and datatype not in _dtypes:
             msg = f"Can't handle value '{datatype}' of datatype (choose one of {_dtypes})"
             raise ValueError(msg)
 
-        if self._modify:
-            if mode:
-                self._mode = mode
-            if not hasattr(self, "_mode"):
-                self._mode = self.mode_default
-            if datatype:
-                self._datatype = datatype
-            if not hasattr(self, "_datatype"):
-                self._datatype = self.datatype_default
-            if window_samples:
-                self._window_samples = window_samples
-            if not hasattr(self, "_window_samples"):
-                self._window_samples = 0
-        else:
-            self._mode = mode if isinstance(mode, str) else self.mode_default
-            self._datatype = (
-                datatype if isinstance(datatype, EnergyDType) else self.datatype_default
+        if isinstance(datatype, EnergyDType):
+            self.h5file["data"].attrs["datatype"] = datatype.name
+        if "datatype" not in self.h5file["data"].attrs:
+            self.h5file["data"].attrs["datatype"] = self.datatype_default.name
+        if self.get_datatype() not in _dtypes:
+            msg = (
+                f"Can't handle value '{self.get_datatype()}' of datatype (choose one of {_dtypes})"
             )
-            self._window_samples = window_samples if isinstance(window_samples, int) else 0
+            raise ValueError(msg)
 
+        # Handle Window_samples
+        if window_samples is not None:
+            self.h5file["data"].attrs["window_samples"] = window_samples
+        if "window_samples" not in self.h5file["data"].attrs:
+            self.h5file["data"].attrs["window_samples"] = 0
+
+        if datatype == EnergyDType.ivcurve and self.get_window_samples() < 1:
+            raise ValueError("Window Size argument needed for ivcurve-Datatype")
+
+        # Handle Cal
         if isinstance(cal_data, (CalEmu, CalHrv)):
-            self._cal = CalSeries.from_cal(cal_data)
-        elif isinstance(cal_data, CalSeries):
-            self._cal = cal_data
-        else:
-            self._cal = CalSeries()
+            cal_data = CalSeries.from_cal(cal_data)
 
-        # open file
-        if self._modify:
-            self.h5file = h5py.File(self.file_path, "r+")  # = rw
+        if isinstance(cal_data, CalSeries):
+            for ds, param in product(["current", "voltage", "time"], ["gain", "offset"]):
+                self.h5file["data"][ds].attrs[param] = cal_data[ds][param]
         else:
-            if not self.file_path.parent.exists():
-                self.file_path.parent.mkdir(parents=True)
-            self.h5file = h5py.File(self.file_path, "w")
-            # ⤷ write, truncate if exist
-            self._create_skeleton()
+            # check if there are unset cal-values and set them to default
+            cal_data = CalSeries()
+            for ds, param in product(["current", "voltage", "time"], ["gain", "offset"]):
+                if param not in self.h5file["data"][ds].attrs:
+                    self.h5file["data"][ds].attrs[param] = cal_data[ds][param]
 
         # show key parameters for h5-performance
         settings = list(self.h5file.id.get_access_plist().get_cache())
         self._logger.debug("H5Py Cache_setting=%s (_mdc, _nslots, _nbytes, _w0)", settings)
 
-        # Store the mode in order to allow user to differentiate harvesting vs emulation data
-        if isinstance(self._mode, str) and self._mode in self.mode_dtype_dict:
-            self.h5file.attrs["mode"] = self._mode
-
-        if (
-            isinstance(self._datatype, EnergyDType)
-            and self._datatype in self.mode_dtype_dict[self.get_mode()]
-        ):
-            self.h5file["data"].attrs["datatype"] = self._datatype.name
-        elif not self._modify:
-            self._logger.error("datatype invalid? '%s' not written", self._datatype)
-
-        if isinstance(self._window_samples, int):
-            self.h5file["data"].attrs["window_samples"] = self._window_samples
-        if datatype == EnergyDType.ivcurve and (self._window_samples in {None, 0}):
-            raise ValueError("Window Size argument needed for ivcurve-Datatype")
-
-        # include cal-data
-        for ds, param in product(["current", "voltage", "time"], ["gain", "offset"]):
-            self.h5file["data"][ds].attrs[param] = self._cal[ds][param]
-
         super().__init__(file_path=None, verbose=verbose)
 
     def __enter__(self) -> Self:

{shepherd_core-2024.8.2.dist-info → shepherd_core-2024.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shepherd_core
-Version: 2024.8.2
+Version: 2024.11.1
 Summary: Programming- and CLI-Interface for the h5-dataformat of the Shepherd-Testbed
 Author-email: Ingmar Splitt <ingmar.splitt@tu-dresden.de>
 Maintainer-email: Ingmar Splitt <ingmar.splitt@tu-dresden.de>
@@ -23,6 +23,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Natural Language :: English
@@ -119,11 +120,11 @@ These pydantic data-models are used throughout all shepherd interfaces. Users ca
 
 ## Compatibility
 
-| OS      |   PyVersion  | Comment                                    |
-|---------|--------------|--------------------------------------------|
-| Ubuntu  | 3.8 - 3.12   |                                            |
-| Windows | 3.8 - 3.12   | no support for elf and hex-conversions yet |
-| MacOS   | 3.8 - 3.12   | hex-conversion missing                     |
+| OS      | PyVersion  | Comment                                    |
+|---------|------------|--------------------------------------------|
+| Ubuntu  | 3.8 - 3.13 |                                            |
+| Windows | 3.8 - 3.13 | no support for elf and hex-conversions yet |
+| MacOS   | 3.8 - 3.13 | hex-conversion missing                     |
 
 Notes:
 - hex-conversion needs a working and accessible objcopy
@@ -147,7 +148,7 @@ For bleeding-edge-features or dev-work it is possible to install directly from G
 ```Shell
 pip install git+https://github.com/orgua/shepherd-datalib.git@dev#subdirectory=shepherd_core -U
 # and on sheep with newer debian
-pip install git+https://github.com/orgua/shepherd-datalib.git@dev#subdirectory=shepherd_core -U --break-system-packages
+sudo pip install git+https://github.com/orgua/shepherd-datalib.git@dev#subdirectory=shepherd_core -U --break-system-packages
 ```
 
 If you are working with ``.elf``-files (embedding into experiments) you make "objcopy" accessible to python. In Ubuntu, you can either install ``build-essential`` or ``binutils-$ARCH`` with arch being ``msp430`` or ``arm-none-eabi`` for the nRF52.

{shepherd_core-2024.8.2.dist-info → shepherd_core-2024.11.1.dist-info}/RECORD

@@ -2,9 +2,9 @@ shepherd_core/__init__.py,sha256=QyqENyf508XfZQ4vDU5o6UL9rmIqkf8kzwgTF9XU1-Y,127
 shepherd_core/calibration_hw_def.py,sha256=_nMzgNzSnYyqcLnVCGd4tfA2e0avUXbccjmNpFhiDgo,2830
 shepherd_core/commons.py,sha256=vymKXWcy_1bz7ChzzEATUkJ4p3czCzjIdsSehVjJOY8,218
 shepherd_core/logger.py,sha256=4Q4hTI-nccOZ1_A68fo4UEctfu3pJx3IeHfa9VuDDEo,1804
-shepherd_core/reader.py,sha256=xpzwt1JjubNat0PNwdzmBJltLPOmvCyQGwcC-bq83ZI,27052
-shepherd_core/version.py,sha256=2UChDgJ4n71vSZH0_L2ArDetMFRZd-5aZO5ppY2Yhrg,75
-shepherd_core/writer.py,sha256=t53fXkYUWHhYnOFnHCoMWwUADkgYydy9Dg66PiqPa68,14946
+shepherd_core/reader.py,sha256=Sg7s5UfV01CejI3_nolG7qrSDUBenmt1WPo2BPJee8o,27058
+shepherd_core/version.py,sha256=_cAEEjp9MalkLrnbibrPNp6zEr3U5KIC-gmZvPG5QqA,76
+shepherd_core/writer.py,sha256=GMR-7vkOgpTNPoknBWsRsC7-b7iGMtT60-KtSKunNe8,14636
 shepherd_core/data_models/__init__.py,sha256=IVjKbT2Ilz5bev325EvAuuhd9LfQgQ1u7qKo6dhVA2k,1866
 shepherd_core/data_models/readme.md,sha256=1bdfEypY_0NMhXLxOPRnLAsFca0HuHdq7_01yEWxvUs,2470
 shepherd_core/data_models/virtual_source_doc.txt,sha256=KizMcfGKj7BnHIbaJHT7KeTF01SV__UXv01qV_DGHSs,6057
@@ -17,20 +17,20 @@ shepherd_core/data_models/base/timezone.py,sha256=2T6E46hJ1DAvmqKfu6uIgCK3RSoAKj
 shepherd_core/data_models/base/wrapper.py,sha256=Izp17HFCKNAS3TnWcPn3MM9fWdc3A-F7eDyAsYlyWCw,755
 shepherd_core/data_models/content/__init__.py,sha256=wVa5lw6bS-fBgeo-SWydg6rw8AsScxqNgDo81dzteaE,537
 shepherd_core/data_models/content/_external_fixtures.yaml,sha256=0CH7YSWT_hzL-jcg4JjgN9ryQOzbS8S66_pd6GbMnHw,12259
-shepherd_core/data_models/content/energy_environment.py,sha256=bXInmHzlRjBAt7mitig35V-zCfj98ZvGEBio0miSxRg,1425
+shepherd_core/data_models/content/energy_environment.py,sha256=WuXMkKqnibGzM2WeW1_m2DAsc0fDqE9CkBYYPSw-7eA,1540
 shepherd_core/data_models/content/energy_environment_fixture.yaml,sha256=UBXTdGT7MK98zx5w_RBCu-f9uNCKxRgiFBQFbmDUxPc,1301
 shepherd_core/data_models/content/firmware.py,sha256=MyEiaP6bkOm7i_oihDXTxHC7ajc5aqiIDLn7mhap6YY,5722
 shepherd_core/data_models/content/firmware_datatype.py,sha256=XPU9LOoT3h5qFOlE8WU0vAkw-vymNxzor9kVFyEqsWg,255
-shepherd_core/data_models/content/virtual_harvester.py,sha256=52HNac5k_GBCAhT2jBgu8oIqnvwMN3WMVmsAJrrxVRo,9678
-shepherd_core/data_models/content/virtual_harvester_fixture.yaml,sha256=1u-V9RvFhbU74wEUv-BMQugh7OdzBE1SvhVe1v0DN-8,4251
-shepherd_core/data_models/content/virtual_source.py,sha256=2ebNI1CvZgcfY5nz9P9p-Vr26E9l9bli9YeEd6_7yBY,14364
-shepherd_core/data_models/content/virtual_source_fixture.yaml,sha256=8Y1HwGRUPKTA6xwI74MFXFYUT018aI7WRlkPIhODwcQ,10525
+shepherd_core/data_models/content/virtual_harvester.py,sha256=MXmSJ_nRp1mSzxfTNk60o9h5Yrp2lFMbLphUVSnNeNc,9999
+shepherd_core/data_models/content/virtual_harvester_fixture.yaml,sha256=LZe5ue1xYhXZwB3a32sva-L4uKhkQA5AtG9JzW4B2hQ,4564
+shepherd_core/data_models/content/virtual_source.py,sha256=PPAphxEXvgMM7OVZ2dBkYAvJQkmj5Kb2BYFogVUs7B8,15354
+shepherd_core/data_models/content/virtual_source_fixture.yaml,sha256=1o-31mGgn7eyCNidKoOUp9vZh3K4Al0kJgmz54Q2DAE,11191
 shepherd_core/data_models/experiment/__init__.py,sha256=9TE9_aSnCNRhagsIWLTE8XkyjyMGB7kEGdswl-296v0,645
 shepherd_core/data_models/experiment/experiment.py,sha256=wnn6T3czuh4rz6OSYtMltCTbRpPX55TLVAtQcKO7Uhg,4044
 shepherd_core/data_models/experiment/observer_features.py,sha256=qxnb7anuQz9ZW5IUlPdUXYPIl5U7O9uXkJqZtMnAb0Y,5156
 shepherd_core/data_models/experiment/target_config.py,sha256=XIsjbbo7yn_A4q3GMxWbiNzEGA0Kk5gH7-XfQQ7Kg0E,3674
 shepherd_core/data_models/task/__init__.py,sha256=rZLbgqX-dTWY4026-bqW-IWVHbA6C_xP9y0aeRze8FY,3374
-shepherd_core/data_models/task/emulation.py,sha256=z3BEqERy2m3_rxqKo6w89sSnBQhFwHDEdCgwJh2XUOQ,6376
+shepherd_core/data_models/task/emulation.py,sha256=tLb5auHOgdoG-e4hFljAYT49z7lMEaiimOy4UVZONi4,6440
 shepherd_core/data_models/task/firmware_mod.py,sha256=Rw_TA1ykQ7abUd_U0snqZlpZyrS8Nx6f4BEax1Xnji0,2818
 shepherd_core/data_models/task/harvest.py,sha256=HHnqWwRsJupaZJxuohs7NrK6VaDyoRzGOaG2h9y3s1Y,3360
 shepherd_core/data_models/task/observer_tasks.py,sha256=XlH_-EGRrdodTn0c2pjGvpcauc0a9NOnLhysKw8iRwk,3511
@@ -67,14 +67,14 @@ shepherd_core/testbed_client/client_web.py,sha256=iMh5T91152uugbFsqr2vvxLser0KIo
 shepherd_core/testbed_client/fixtures.py,sha256=4Uk583R4r6I5IB78HxOn-9UNH3sbFha7OPEdcSXvMCU,9939
 shepherd_core/testbed_client/user_model.py,sha256=5M3vWkAGBwdGDUYAanAjrZwpzMBlh3XLOVvNYWiLmms,2107
 shepherd_core/vsource/__init__.py,sha256=GVB-FwuO2mvM15mGX9EQC1lbUmHMLmUEFGYkGmIngPM,771
-shepherd_core/vsource/target_model.py,sha256=J_8-MHs_gIMcE3ZYTgoFsrO6VShR6SFJ5CA3lwuPC2U,2049
-shepherd_core/vsource/virtual_converter_model.py,sha256=sQkJSj-7CVabHvXqk6C3cbLmztSSsdrSU3WgYr4h30E,11067
-shepherd_core/vsource/virtual_harvester_model.py,sha256=ROR8vtKeM2WTnogV68TKBOu0zRVwOwQj_q67hW_qtpQ,8297
+shepherd_core/vsource/target_model.py,sha256=LaB5ppi2-IIpIepDqDvOliR-BupzccJl44yRxjlF-ms,5113
+shepherd_core/vsource/virtual_converter_model.py,sha256=3TyxphUMunoGhMda7AWCHZQU8pjRSvxB-9R8lfZFnok,11592
+shepherd_core/vsource/virtual_harvester_model.py,sha256=GyA0uGl3r42t5c4roYtEaj22b0-b5DAHUr2e9DuNn-c,9765
 shepherd_core/vsource/virtual_harvester_simulation.py,sha256=EiBrvmc6D2N7Z0DqFBWPdRJK6hR8Q3iQaj7EYP9pLA0,2405
-shepherd_core/vsource/virtual_source_model.py,sha256=fjN8myTY3I_LpikF_aGAcxes3RGu1GP23P7XKC_UIyA,2737
-shepherd_core/vsource/virtual_source_simulation.py,sha256=swopkXe60LozBkp_-e1WCla-eVCG2klTFB5bLAUj51I,2528
-shepherd_core-2024.8.2.dist-info/METADATA,sha256=oDQiB1H6NM3zW-SuQp0uZ1Ap366o5syvqE-5RLWrIws,7771
-shepherd_core-2024.8.2.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-shepherd_core-2024.8.2.dist-info/top_level.txt,sha256=wy-t7HRBrKARZxa-Y8_j8d49oVHnulh-95K9ikxVhew,14
-shepherd_core-2024.8.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-shepherd_core-2024.8.2.dist-info/RECORD,,
+shepherd_core/vsource/virtual_source_model.py,sha256=-JSYUfsnYlNo5RfPBhx2G33fo5AjSeFSf2O6unroyFw,2945
+shepherd_core/vsource/virtual_source_simulation.py,sha256=k1v2zpNdJTqiO9uY8TXaq-IUKK6m5l-LEWebYva0skk,5088
+shepherd_core-2024.11.1.dist-info/METADATA,sha256=TPLadz0PyPjY4RxradpDtestEq_6U2ILu9tVNIIG7q0,7818
+shepherd_core-2024.11.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+shepherd_core-2024.11.1.dist-info/top_level.txt,sha256=wy-t7HRBrKARZxa-Y8_j8d49oVHnulh-95K9ikxVhew,14
+shepherd_core-2024.11.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+shepherd_core-2024.11.1.dist-info/RECORD,,

{shepherd_core-2024.8.2.dist-info → shepherd_core-2024.11.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any