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

shepherd_core/data_models/base/calibration.py

@@ -51,7 +51,7 @@ class CalibrationPair(ShpModel):
 
     gain: PositiveFloat
     offset: float = 0
-    # TODO: add unit
+    unit: Optional[str] = None  # TODO: add units when used
 
     def raw_to_si(self, values_raw: Calc_t, *, allow_negative: bool = True) -> Calc_t:
         """Convert between physical units and raw unsigned integers."""
@@ -78,14 +78,11 @@ class CalibrationPair(ShpModel):
         return values_raw
 
     @classmethod
-    def from_fn(cls, fn: Callable) -> Self:
+    def from_fn(cls, fn: Callable, unit: Optional[str] = None) -> Self:
         """Probe linear function to determine scaling values."""
         offset = fn(0, limited=False)
         gain_inv = fn(1.0, limited=False) - offset
-        return cls(
-            gain=1.0 / float(gain_inv),
-            offset=-float(offset) / gain_inv,
-        )
+        return cls(gain=1.0 / float(gain_inv), offset=-float(offset) / gain_inv, unit=unit)
 
 
 cal_hrv_legacy = {  # legacy translator
@@ -99,10 +96,10 @@ cal_hrv_legacy = {  # legacy translator
 class CalibrationHarvester(ShpModel):
     """Container for all calibration-pairs for that device."""
 
-    dac_V_Hrv: CalibrationPair = CalibrationPair.from_fn(dac_voltage_to_raw)
-    dac_V_Sim: CalibrationPair = CalibrationPair.from_fn(dac_voltage_to_raw)
-    adc_V_Sense: CalibrationPair = CalibrationPair.from_fn(adc_voltage_to_raw)
-    adc_C_Hrv: CalibrationPair = CalibrationPair.from_fn(adc_current_to_raw)
+    dac_V_Hrv: CalibrationPair = CalibrationPair.from_fn(dac_voltage_to_raw, unit="V")
+    dac_V_Sim: CalibrationPair = CalibrationPair.from_fn(dac_voltage_to_raw, unit="V")
+    adc_V_Sense: CalibrationPair = CalibrationPair.from_fn(adc_voltage_to_raw, unit="V")
+    adc_C_Hrv: CalibrationPair = CalibrationPair.from_fn(adc_current_to_raw, unit="A")
 
     def export_for_sysfs(self) -> dict:
         """Convert and write the essential data.
@@ -143,10 +140,10 @@ class CalibrationEmulator(ShpModel):
     Differentiates between both target-ports A/B.
     """
 
-    dac_V_A: CalibrationPair = CalibrationPair.from_fn(dac_voltage_to_raw)
-    dac_V_B: CalibrationPair = CalibrationPair.from_fn(dac_voltage_to_raw)
-    adc_C_A: CalibrationPair = CalibrationPair.from_fn(adc_current_to_raw)
-    adc_C_B: CalibrationPair = CalibrationPair.from_fn(adc_current_to_raw)
+    dac_V_A: CalibrationPair = CalibrationPair.from_fn(dac_voltage_to_raw, unit="V")
+    dac_V_B: CalibrationPair = CalibrationPair.from_fn(dac_voltage_to_raw, unit="V")
+    adc_C_A: CalibrationPair = CalibrationPair.from_fn(adc_current_to_raw, unit="A")
+    adc_C_B: CalibrationPair = CalibrationPair.from_fn(adc_current_to_raw, unit="A")
 
     def export_for_sysfs(self) -> dict:
         """Convert and write the essential data.
@@ -233,10 +230,11 @@ class CalibrationCape(ShpModel):
 
         """
         dv = cls().model_dump(include={"harvester", "emulator"})
-        lw = list(dict_generator(dv))
-        values = struct.unpack(">" + len(lw) * "d", data)
+        lw1 = list(dict_generator(dv))
+        lw2 = [elem for elem in lw1 if isinstance(elem[-1], float)]
+        values = struct.unpack(">" + len(lw2) * "d", data)
         # ⤷ X => double float, big endian
-        for _i, walk in enumerate(lw):
+        for _i, walk in enumerate(lw2):
             # hardcoded fixed depth ... bad but easy
             dv[walk[0]][walk[1]][walk[2]] = float(values[_i])
         dv["cape"] = cape
@@ -252,18 +250,18 @@ class CalibrationCape(ShpModel):
 
         """
         lw = list(dict_generator(self.model_dump(include={"harvester", "emulator"})))
-        values = [walk[-1] for walk in lw]
-        return struct.pack(">" + len(lw) * "d", *values)
+        values = [walk[-1] for walk in lw if isinstance(walk[-1], float)]
+        return struct.pack(">" + len(values) * "d", *values)
 
 
 class CalibrationSeries(ShpModel):
     """Cal-Data for a typical recording of a testbed experiment."""
 
-    voltage: CalibrationPair = CalibrationPair(gain=3 * 1e-9)
+    voltage: CalibrationPair = CalibrationPair(gain=3 * 1e-9, unit="V")
     # ⤷ default allows 0 - 12 V in 3 nV-Steps
-    current: CalibrationPair = CalibrationPair(gain=250 * 1e-12)
+    current: CalibrationPair = CalibrationPair(gain=250 * 1e-12, unit="A")
     # ⤷ default allows 0 - 1 A in 250 pA - Steps
-    time: CalibrationPair = CalibrationPair(gain=1e-9)
+    time: CalibrationPair = CalibrationPair(gain=1e-9, unit="s")
     # ⤷ default = nanoseconds
 
     @classmethod

shepherd_core/data_models/content/virtual_harvester.py

@@ -149,20 +149,27 @@ class VirtualHarvesterConfig(ContentModel, title="Config for the Harvester"):
 
     def calc_window_size(
         self,
-        dtype_in: Optional[EnergyDType] = EnergyDType.ivsample,
+        dtype_in: Optional[EnergyDType] = None,
         *,
         for_emu: bool,
     ) -> int:
-        if for_emu:
-            if dtype_in == EnergyDType.ivcurve:
-                return self.samples_n * (1 + self.wait_cycles)
-            if dtype_in == EnergyDType.ivsample:
-                return 0
-            # isc_voc: 2 * (1 + wait_cycles), noqa
-            raise NotImplementedError
+        if not for_emu:
+            # TODO: should be named 'for_ivcurve_recording'
+            # TODO: add extra variable to distinguish step_count
+            #       and window_size (currently mixed together)
+            # only used by ivcurve algo (in ADC-Mode)
+            return self.samples_n
 
-        # only used by ivcurve algo (in ADC-Mode)
-        return self.samples_n
+        if dtype_in is None:
+            dtype_in = self.get_datatype()
+
+        if dtype_in == EnergyDType.ivcurve:
+            return self.samples_n * (1 + self.wait_cycles)
+        if dtype_in == EnergyDType.ivsample:
+            return 0
+        if dtype_in == EnergyDType.isc_voc:
+            return 2 * (1 + self.wait_cycles)
+        raise NotImplementedError
 
 
 u32 = Annotated[int, Field(ge=0, lt=2**32)]
@@ -234,7 +241,7 @@ class HarvesterPRUConfig(ShpModel):
             dtype_in = EnergyDType[dtype_in]
         if for_emu and dtype_in not in {EnergyDType.ivsample, EnergyDType.ivcurve}:
             raise NotImplementedError
-        # TODO: use dtype properly in shepherd
+
         interval_ms, duration_ms = data.calc_timings_ms(for_emu=for_emu)
         return cls(
             algorithm=data.calc_algorithm_num(for_emu=for_emu),

shepherd_core/data_models/content/virtual_harvester_fixture.yaml

@@ -19,13 +19,13 @@
     id: 1010
     name: ivcurve
     description: Postpone harvesting by sampling ivcurves (voltage stepped as sawtooth-wave)
-    comment: ~200 Hz
+    comment: ~110 Hz, Between 50 & 60 Hz line-frequency to avoid standing waves
     inherit_from: neutral
     algorithm: ivcurve
-    samples_n: 250
+    samples_n: 909
     voltage_min_mV: 0
     voltage_max_mV: 5000
-    wait_cycles: 1  # results in 200 Hz (= 100kHz /(2*250))
+    wait_cycles: 0
     rising: false # downward sawtooth seems to have advantages for solar cells
     # todo: also add switch for sawtooth- vs triangle-wave?
     # todo: could also include a version with dynamic upper-boundary, varied if voc is reached very early
@@ -38,20 +38,17 @@
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1012
-    name: iv1000
-    comment: Name relates to curves per second
+    id: 1013
+    name: iv110 # synonym
     inherit_from: ivcurve
-    samples_n: 100
-    wait_cycles: 0
 
 - datatype: VirtualHarvesterConfig
   parameters:
-    id: 1013
-    name: iv110
-    comment: Between 50 & 60 Hz line-frequency to avoid standing waves
+    id: 1012
+    name: iv1000
+    comment: Name relates to curves per second
     inherit_from: ivcurve
-    samples_n: 909
+    samples_n: 100
     wait_cycles: 0
 
 - datatype: VirtualHarvesterConfig
@@ -61,7 +58,7 @@
     description: Postpone harvesting by sampling short circuit current & open circuit voltage
     inherit_from: neutral
     algorithm: isc_voc
-    wait_cycles: 1  # results in 25 kHz (isc, wait, voc, wait)
+    wait_cycles: 4  # results in 10 kHz (isc, wait, voc, wait)
 
 - datatype: VirtualHarvesterConfig
   parameters:

shepherd_core/data_models/content/virtual_source.py

@@ -76,6 +76,8 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
     # final (always last) stage to compensate undetectable current spikes
     # when enabling power for target
     C_output_uF: Annotated[float, Field(ge=0, le=4.29e6)] = 1.0
+    # TODO: C_output is handled internally as delta-V, but should be a I_transient
+    #       that makes it visible in simulation as additional i_out_drain
 
     # Extra
     V_output_log_gpio_threshold_mV: Annotated[float, Field(ge=0, le=4.29e6)] = 1_400
@@ -93,7 +95,7 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
     # influence of cap-voltage is not implemented
     LUT_input_V_min_log2_uV: Annotated[int, Field(ge=0, le=20)] = 0
     # ⤷ 2^7 = 128 uV -> LUT[0][:] is for inputs < 128 uV
-    LUT_input_I_min_log2_nA: Annotated[int, Field(ge=0, le=20)] = 0
+    LUT_input_I_min_log2_nA: Annotated[int, Field(ge=1, le=20)] = 1
     # ⤷ 2^8 = 256 nA -> LUT[:][0] is for inputs < 256 nA
 
     # Buck Converter
@@ -103,7 +105,7 @@ class VirtualSourceConfig(ContentModel, title="Config for the virtual Source"):
 
     LUT_output_efficiency: LUT1D = 12 * [1.00]
     # ⤷ array[12] depending on output_current
-    LUT_output_I_min_log2_nA: Annotated[int, Field(ge=0, le=20)] = 0
+    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
 
     @model_validator(mode="before")
@@ -318,8 +320,8 @@ class ConverterPRUConfig(ShpModel):
             V_buck_drop_uV=round(data.V_buck_drop_mV * 1e3),
             # LUTs
             LUT_input_V_min_log2_uV=data.LUT_input_V_min_log2_uV,
-            LUT_input_I_min_log2_nA=data.LUT_input_I_min_log2_nA,
-            LUT_output_I_min_log2_nA=data.LUT_output_I_min_log2_nA,
+            LUT_input_I_min_log2_nA=data.LUT_input_I_min_log2_nA - 1,  # sub-1 due to later log2-op
+            LUT_output_I_min_log2_nA=data.LUT_output_I_min_log2_nA - 1,  # sub-1 due to later log2
             LUT_inp_efficiency_n8=[
                 [min(255, round(256 * ival)) for ival in il] for il in data.LUT_input_efficiency
             ],

shepherd_core/data_models/content/virtual_source_fixture.yaml

@@ -15,7 +15,7 @@
     interval_startup_delay_drain_ms: 0
 
     harvester:
-      name: mppt_opt # harvester only active if input is "ivcurves"
+      name: mppt_opt # harvester only active if input is "ivcurve"
 
     V_input_max_mV: 10000
     I_input_max_mA: 4200
@@ -56,16 +56,18 @@
       [ 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00 ],
       [ 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00 ],
       [ 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00 ],
-    ] # input-array[12][12] depending on array[inp_voltage][log(inp_current)], influence of cap-voltage is not implemented
+    ]
+    # input-array[12][12] depending on array[inp_voltage][log(inp_current)],
+    # influence of cap-voltage is not implemented
     LUT_input_V_min_log2_uV: 0 # 2^7 = 128 uV -> array[0] is for inputs < 128 uV
-    LUT_input_I_min_log2_nA: 0 # 2^8 = 256 nA -> array[0] is for inputs < 256 nA
+    LUT_input_I_min_log2_nA: 1 # 2^8 = 256 nA -> array[0] is for inputs < 256 nA
 
     # Buck-converter
     V_output_mV: 2400
     V_buck_drop_mV: 0.0  # simulate LDO min voltage differential or output-diode
 
     LUT_output_efficiency: [ 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00 ] # array[12] depending on output_current
-    LUT_output_I_min_log2_nA: 0  # 2^8 = 256 nA -> array[0] is for inputs < 256 nA, see notes on LUT_input for explanation
+    LUT_output_I_min_log2_nA: 1  # 2^8 = 256 nA -> array[0] is for inputs < 256 nA, see notes on LUT_input for explanation
 
     owner: Ingmar
     group: NES Lab
@@ -114,7 +116,7 @@
   parameters:
     id: 1020
     name: BQ25504
-    description: TI BQ25504 with integrated boost-converter
+    description: TI BQ25504 with integrated boost-converter. Values are taken from the DK-Board.
     inherit_from: neutral # to complete undefined vars
     enable_boost: true # if false -> v_intermediate = v_input, output-switch-hysteresis is still usable
 
@@ -124,16 +126,16 @@
     V_input_max_mV: 3000
     I_input_max_mA: 100
 
-    C_intermediate_uF: 22.0  # primary storage-Cap
+    C_intermediate_uF: 100.0  # primary storage-Cap
     V_intermediate_init_mV: 3000 # allow a proper / fast startup
     I_intermediate_leak_nA: 330
 
-    V_intermediate_enable_threshold_mV: 2600 # -> target gets connected (hysteresis-combo with next value)
-    V_intermediate_disable_threshold_mV: 2300 # -> target gets disconnected
+    V_intermediate_enable_threshold_mV: 1000 # -> target gets connected (hysteresis-combo with next value)
+    V_intermediate_disable_threshold_mV: 0 # -> target gets disconnected
     interval_check_thresholds_ms: 64.0  # some BQs check every 64 ms if output should be disconnected
 
     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: 2400
+    V_pwr_good_disable_threshold_mV: 2340
     immediate_pwr_good_signal: false  # 1: activate instant schmitt-trigger, 0: stay in interval for checking thresholds
 
     # Boost Converter

shepherd_core/reader.py

@@ -84,6 +84,7 @@ class Reader:
 
         # init stats
         self.runtime_s: float = 0
+        self.buffers_n: int = 0
         self.file_size: int = 0
         self.data_rate: float = 0
 
@@ -170,12 +171,16 @@ class Reader:
     def _refresh_file_stats(self) -> None:
         """Update internal states, helpful after resampling or other changes in data-group."""
         self.h5file.flush()
-        if (self.ds_time.shape[0] > 1) and (self.ds_time[1] != self.ds_time[0]):
-            # this assumes isochronal sampling
-            self.sample_interval_s = self._cal.time.raw_to_si(self.ds_time[1] - self.ds_time[0])
+        sample_count = self.ds_time.shape[0]
+        duration_raw = self.ds_time[sample_count - 1] - self.ds_time[0] if sample_count > 0 else 0
+        if (sample_count > 0) and (duration_raw > 0):
+            # 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(10**9 // self.sample_interval_ns), 1)
+            self.samplerate_sps = max(int((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):
             self.file_size = self.file_path.stat().st_size
         else:

shepherd_core/version.py

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

shepherd_core/vsource/__init__.py

@@ -1,13 +1,23 @@
 """Simulation model of the virtual source."""
 
+from .target_model import ConstantCurrentTarget
+from .target_model import ConstantPowerTarget
+from .target_model import ResistiveTarget
 from .virtual_converter_model import PruCalibration
 from .virtual_converter_model import VirtualConverterModel
 from .virtual_harvester_model import VirtualHarvesterModel
+from .virtual_harvester_simulation import simulate_harvester
 from .virtual_source_model import VirtualSourceModel
+from .virtual_source_simulation import simulate_source
 
 __all__ = [
     "PruCalibration",
     "VirtualConverterModel",
     "VirtualHarvesterModel",
     "VirtualSourceModel",
+    "simulate_harvester",
+    "simulate_source",
+    "ResistiveTarget",
+    "ConstantCurrentTarget",
+    "ConstantPowerTarget",
 ]

shepherd_core/vsource/target_model.py

@@ -0,0 +1,62 @@
+"""Virtual targets with different characteristics.
+
+TODO: add more targets
+  - diode
+  - constant power
+  - constant current
+  - msp430 (const I)
+  - nRF (constant power due to regulator)
+  - riotee
+"""
+
+from abc import ABC
+from abc import abstractmethod
+
+
+class TargetABC(ABC):
+    """Abstract base class for all targets."""
+
+    @abstractmethod
+    def step(self, voltage_uV: int, *, pwr_good: bool) -> float:
+        """Calculate one time step and return drawn current in nA."""
+
+
+class ResistiveTarget(TargetABC):
+    """Predictable target for matching the real world."""
+
+    def __init__(self, resistance_Ohm: float, *, controlled: bool = False) -> None:
+        if resistance_Ohm <= 1e-3:
+            raise ValueError("Resistance must be greater than 1 mOhm.")
+        self.r_kOhm = 1e-3 * resistance_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 0
+
+
+class ConstantCurrentTarget(TargetABC):
+    """Recreate simple MCU without integrated regulator."""
+
+    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
+
+    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
+
+
+class ConstantPowerTarget(TargetABC):
+    """Recreate MCU with integrated regulator."""
+
+    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
+
+    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

shepherd_core/vsource/virtual_converter_model.py

@@ -25,12 +25,28 @@ from ..data_models.content.virtual_source import ConverterPRUConfig
 class PruCalibration:
     """part of calibration.h."""
 
+    # negative residue compensation - compensate for noise around 0
+    # -> current uint-design cuts away negative part and leads to biased mean()
+    NOISE_ESTIMATE_nA: int = 2000
+    RESIDUE_SIZE_FACTOR: int = 30
+    RESIDUE_MAX_nA: int = NOISE_ESTIMATE_nA * RESIDUE_SIZE_FACTOR
+    negative_residue_nA = 0
+
     def __init__(self, cal_emu: Optional[CalibrationEmulator] = None) -> None:
         self.cal = cal_emu if cal_emu else CalibrationEmulator()
 
     def conv_adc_raw_to_nA(self, current_raw: int) -> float:
-        return self.cal.adc_C_A.raw_to_si(current_raw) * (10**9)
-        # TODO: add feature "negative residue compensation" to here
+        I_nA = self.cal.adc_C_A.raw_to_si(current_raw) * (10**9)
+        if self.cal.adc_C_A.offset < 0:
+            if I_nA > self.negative_residue_nA:
+                I_nA -= self.negative_residue_nA
+                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
+                I_nA = 0
+        return I_nA
 
     @staticmethod
     def conv_adc_raw_to_uV(voltage_raw: int) -> float:
@@ -88,10 +104,11 @@ class VirtualConverterModel:
         self.vsource_skip_gpio_logging: bool = False
 
     def calc_inp_power(self, input_voltage_uV: float, input_current_nA: float) -> int:
-        # Next 2 lines are Python-specific
+        # Next 2 lines are Python-specific (model unsigned int)
         input_voltage_uV = max(0.0, input_voltage_uV)
         input_current_nA = max(0.0, input_current_nA)
 
+        # Input diode
         if input_voltage_uV > self._cfg.V_input_drop_uV:
             input_voltage_uV -= self._cfg.V_input_drop_uV
         else:
@@ -108,8 +125,6 @@ class VirtualConverterModel:
         if self.enable_boost:
             if input_voltage_uV < self._cfg.V_input_boost_threshold_uV:
                 input_voltage_uV = 0.0
-            if input_voltage_uV > self.V_mid_uV:
-                input_voltage_uV = self.V_mid_uV
         elif not self.enable_storage:
             # direct connection
             self.V_mid_uV = input_voltage_uV
@@ -134,7 +149,7 @@ class VirtualConverterModel:
         return round(self.P_inp_fW)  # Python-specific, added for easier testing
 
     def calc_out_power(self, current_adc_raw: int) -> int:
-        # Next 2 lines are Python-specific
+        # Next 2 lines are Python-specific (model unsigned int)
         current_adc_raw = max(0, current_adc_raw)
         current_adc_raw = min((2**18) - 1, current_adc_raw)
 

shepherd_core/vsource/virtual_harvester_model.py

@@ -35,7 +35,11 @@ class VirtualHarvesterModel:
 
         # INIT global vars: shared states
         self.voltage_set_uV: int = self._cfg.voltage_uV + 1
-        self.interval_step: int = 2**30
+        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
 
         # PO-Relevant, iv & adc
@@ -51,6 +55,7 @@ class VirtualHarvesterModel:
         self.voltage_hold: int = 0
         self.current_hold: int = 0
         self.voltage_step_x4_uV: int = self._cfg.voltage_step_uV * 4
+        self.age_max: int = 2 * self._cfg.window_size
 
         # INIT static vars: CV
         self.voltage_last: int = 0
@@ -59,9 +64,10 @@ class VirtualHarvesterModel:
 
         # INIT static vars: VOC
         self.age_now: int = 0
-        self.voc_now: int = 0
+        self.voc_now: int = self._cfg.voltage_max_uV
         self.age_nxt: int = 0
-        self.voc_nxt: int = 0
+        self.voc_nxt: int = self._cfg.voltage_max_uV
+        self.voc_min: int = max(1000, self._cfg.voltage_min_uV)
 
         # INIT static vars: PO
         # already done: interval step
@@ -110,20 +116,22 @@ class VirtualHarvesterModel:
         return self.voltage_hold, self.current_hold
 
     def ivcurve_2_mppt_voc(self, _voltage_uV: int, _current_nA: int) -> Tuple[int, int]:
-        self.interval_step = (self.interval_step + 1) % self._cfg.interval_n
+        self.interval_step = self.interval_step + 1
+        if self.interval_step >= self._cfg.interval_n:
+            self.interval_step = 0
         self.age_nxt += 1
         self.age_now += 1
 
         if (
             (_current_nA < self._cfg.current_limit_nA)
             and (_voltage_uV < self.voc_nxt)
-            and (_voltage_uV >= self._cfg.voltage_min_uV)
+            and (_voltage_uV >= self.voc_min)
             and (_voltage_uV <= self._cfg.voltage_max_uV)
         ):
             self.voc_nxt = _voltage_uV
             self.age_nxt = 0
 
-        if (self.age_now > self._cfg.window_size) or (self.voc_nxt <= self.voc_now):
+        if (self.age_now > self.age_max) or (self.voc_nxt <= self.voc_now):
             self.age_now = self.age_nxt
             self.voc_now = self.voc_nxt
             self.age_nxt = 0
@@ -137,7 +145,9 @@ class VirtualHarvesterModel:
         return _voltage_uV, _current_nA
 
     def ivcurve_2_mppt_po(self, _voltage_uV: int, _current_nA: int) -> Tuple[int, int]:
-        self.interval_step = (self.interval_step + 1) % self._cfg.interval_n
+        self.interval_step = self.interval_step + 1
+        if self.interval_step >= self._cfg.interval_n:
+            self.interval_step = 0
 
         _voltage_uV, _current_nA = self.ivcurve_2_cv(_voltage_uV, _current_nA)
 
@@ -193,7 +203,7 @@ class VirtualHarvesterModel:
             self.voltage_nxt = _voltage_uV
             self.current_nxt = _current_nA
 
-        if (self.age_now > self._cfg.window_size) or (self.power_nxt >= self.power_now):
+        if (self.age_now > self.age_max) or (self.power_nxt >= self.power_now):
             self.age_now = self.age_nxt
             self.power_now = self.power_nxt
             self.voltage_now = self.voltage_nxt

shepherd_core/vsource/virtual_harvester_simulation.py

@@ -0,0 +1,71 @@
+"""Simulate behavior of virtual harvester algorithms.
+
+The simulation recreates an observer-cape and the virtual harvester
+- input = hdf5-file with an ivcurve
+- output = optional as hdf5-file
+
+The output file can be analyzed and plotted with shepherds tool suite.
+"""
+
+from contextlib import ExitStack
+from pathlib import Path
+from typing import Optional
+
+from tqdm import tqdm
+
+from .. import CalibrationHarvester
+from .. import Reader
+from .. import Writer
+from ..data_models.content.virtual_harvester import HarvesterPRUConfig
+from ..data_models.content.virtual_harvester import VirtualHarvesterConfig
+from .virtual_harvester_model import VirtualHarvesterModel
+
+
+def simulate_harvester(
+    config: VirtualHarvesterConfig, path_input: Path, path_output: Optional[Path] = None
+) -> float:
+    """Simulate behavior of virtual harvester algorithms.
+
+    Fn return the harvested energy.
+    """
+    stack = ExitStack()
+    file_inp = Reader(path_input, verbose=False)
+    stack.enter_context(file_inp)
+    cal_inp = file_inp.get_calibration_data()
+
+    if path_output:
+        cal_hrv = CalibrationHarvester()
+        file_out = Writer(
+            path_output, cal_data=cal_hrv, mode="harvester", verbose=False, force_overwrite=True
+        )
+        stack.enter_context(file_out)
+        cal_out = file_out.get_calibration_data()
+        file_out.store_hostname("hrv_sim_" + config.name)
+
+    hrv_pru = HarvesterPRUConfig.from_vhrv(
+        config,
+        for_emu=True,
+        dtype_in=file_inp.get_datatype(),
+        window_size=file_inp.get_window_samples(),
+    )
+    hrv = VirtualHarvesterModel(hrv_pru)
+    e_out_Ws = 0.0
+
+    for _t, v_inp, i_inp in tqdm(
+        file_inp.read_buffers(is_raw=True), total=file_inp.buffers_n, desc="Buffers", leave=False
+    ):
+        v_uV = cal_inp.voltage.raw_to_si(v_inp) * 1e6
+        i_nA = cal_inp.current.raw_to_si(i_inp) * 1e9
+        length = min(v_uV.size, i_nA.size)
+        for _n in range(length):
+            v_uV[_n], i_nA[_n] = hrv.ivcurve_sample(
+                _voltage_uV=int(v_uV[_n]), _current_nA=int(i_nA[_n])
+            )
+        e_out_Ws += (v_uV * i_nA).sum() * 1e-15 * file_inp.sample_interval_s
+        if path_output:
+            v_out = cal_out.voltage.si_to_raw(v_uV / 1e6)
+            i_out = cal_out.current.si_to_raw(i_nA / 1e9)
+            file_out.append_iv_data_raw(_t, v_out, i_out)
+
+    stack.close()
+    return e_out_Ws

shepherd_core/vsource/virtual_source_simulation.py

@@ -0,0 +1,78 @@
+"""Simulate behavior of virtual source algorithms.
+
+The simulation recreates an observer-cape, the virtual Source and a virtual target
+- input = hdf5-file with a harvest-recording
+- output = optional as hdf5-file
+
+The output file can be analyzed and plotted with shepherds tool suite.
+"""
+
+from contextlib import ExitStack
+from pathlib import Path
+from typing import Optional
+
+from tqdm import tqdm
+
+from .. import CalibrationEmulator
+from .. import Reader
+from .. import Writer
+from ..data_models import VirtualSourceConfig
+from . import VirtualSourceModel
+from .target_model import TargetABC
+
+
+def simulate_source(
+    config: VirtualSourceConfig,
+    target: TargetABC,
+    path_input: Path,
+    path_output: Optional[Path] = None,
+) -> float:
+    """Simulate behavior of virtual source algorithms.
+
+    FN returns the consumed energy of the target.
+    """
+    stack = ExitStack()
+    file_inp = Reader(path_input, verbose=False)
+    stack.enter_context(file_inp)
+    cal_emu = CalibrationEmulator()
+    cal_inp = file_inp.get_calibration_data()
+
+    if path_output:
+        file_out = Writer(
+            path_output, cal_data=cal_emu, mode="emulator", verbose=False, force_overwrite=True
+        )
+        stack.enter_context(file_out)
+        file_out.store_hostname("emu_sim_" + config.name)
+        file_out.store_config(config.model_dump())
+        cal_out = file_out.get_calibration_data()
+
+    src = VirtualSourceModel(
+        config, cal_emu, log_intermediate=False, window_size=file_inp.get_window_samples()
+    )
+    i_out_nA = 0
+    e_out_Ws = 0.0
+
+    for _t, v_inp, i_inp in tqdm(
+        file_inp.read_buffers(is_raw=True), total=file_inp.buffers_n, desc="Buffers", leave=False
+    ):
+        v_uV = 1e6 * cal_inp.voltage.raw_to_si(v_inp)
+        i_nA = 1e9 * cal_inp.current.raw_to_si(i_inp)
+
+        for _n in range(len(_t)):
+            v_uV[_n] = src.iterate_sampling(
+                V_inp_uV=int(v_uV[_n]),
+                I_inp_nA=int(i_nA[_n]),
+                I_out_nA=i_out_nA,
+            )
+            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
+
+        e_out_Ws += (v_uV * i_nA).sum() * 1e-15 * file_inp.sample_interval_s
+        if path_output:
+            v_out = cal_out.voltage.si_to_raw(1e-6 * v_uV)
+            i_out = cal_out.current.si_to_raw(1e-9 * i_nA)
+            file_out.append_iv_data_raw(_t, v_out, i_out)
+
+    stack.close()
+    return e_out_Ws

shepherd_core/writer.py

@@ -149,9 +149,18 @@ class Writer(Reader):
             raise ValueError(msg)
 
         if self._modify:
-            self._mode = mode
-            self._datatype = datatype
-            self._window_samples = window_samples
+            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 = (
@@ -335,6 +344,7 @@ class Writer(Reader):
             current: ndarray in physical-unit A
 
         """
+        # TODO: make timestamp optional to add it raw, OR unify append with granular raw-switch
         timestamp = self._cal.time.si_to_raw(timestamp)
         voltage = self._cal.voltage.si_to_raw(voltage)
         current = self._cal.current.si_to_raw(current)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shepherd_core
-Version: 2024.7.4
+Version: 2024.8.2
 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>

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

@@ -2,15 +2,15 @@ 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=9BuArqou5pmPKUrJH9oiPYlU1DkMxUScL4nftDJuFIs,26790
-shepherd_core/version.py,sha256=nuk8f6h1RBadV7-koFp4yLk1jExaUHnFqMTtxlKZyCo,75
-shepherd_core/writer.py,sha256=xcLCw-YokKaN8TrkwD0IjRmn8xZU0Q8wwWp_1K8JFVY,14475
+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/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
 shepherd_core/data_models/base/__init__.py,sha256=PSJ6acWViqBm0Eiom8DIgKfFVrp5lzYr8OsDvP79vwI,94
 shepherd_core/data_models/base/cal_measurement.py,sha256=YScPG7QLynbUHdjcznYqU8O5KRh0XiROGxGSk9BETMk,3357
-shepherd_core/data_models/base/calibration.py,sha256=iy04ajChReqrRNLoNDEH01CM-iCvb5XepBIlyFSWeII,10466
+shepherd_core/data_models/base/calibration.py,sha256=k5VwAK_cwr0a6QY82Lw-9uHth5KUReFOakuOTzghoso,10725
 shepherd_core/data_models/base/content.py,sha256=13j7GSgT73xn27jgDP508thUEJR4U-nCb5n7CJ50c9Y,2463
 shepherd_core/data_models/base/shepherd.py,sha256=DNrx59o1VBuy_liJuUzZRzmTTYB73D_pUWiNyMQyjYY,6112
 shepherd_core/data_models/base/timezone.py,sha256=2T6E46hJ1DAvmqKfu6uIgCK3RSoAKjGXRyzYNaqKyjY,665
@@ -21,10 +21,10 @@ shepherd_core/data_models/content/energy_environment.py,sha256=bXInmHzlRjBAt7mit
 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=5eEHAZrgHPHZlTxDGaJrckDQgupFNC3Zax67EcCSqR8,9448
-shepherd_core/data_models/content/virtual_harvester_fixture.yaml,sha256=-IRyoQU0HXCEtIIcFmkFdz4snLB7bjFFqNcFVGSMiSA,4332
-shepherd_core/data_models/content/virtual_source.py,sha256=aoD8oam1POid0JG2ppttPA_Jl3y4ko5FNqzoaNKyBD8,14142
-shepherd_core/data_models/content/virtual_source_fixture.yaml,sha256=kx_lpBx0bLKqEHxS09GTnk8kuSbhuGhLgKHeaM6UviE,10481
+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/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
@@ -66,12 +66,15 @@ shepherd_core/testbed_client/client_abc_fix.py,sha256=BsSkpvJHURRejlS-YPF1f6QRPC
 shepherd_core/testbed_client/client_web.py,sha256=iMh5T91152uugbFsqr2vvxLser0KIo5g426dp_6QWUE,5774
 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=dS33KYLq5GQ9_D8HfdP8iWSocWTghCi2ZZG2AJWNfaM,391
-shepherd_core/vsource/virtual_converter_model.py,sha256=ZSoWVLfRmFEjeCNoQCg3BctzhdfayINUBDU_AJK1CR0,10404
-shepherd_core/vsource/virtual_harvester_model.py,sha256=wCbFfsqDRC5Rfu8qANkmkP9XGJOPHJY9-iSnI850JI4,7817
+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/virtual_harvester_simulation.py,sha256=EiBrvmc6D2N7Z0DqFBWPdRJK6hR8Q3iQaj7EYP9pLA0,2405
 shepherd_core/vsource/virtual_source_model.py,sha256=fjN8myTY3I_LpikF_aGAcxes3RGu1GP23P7XKC_UIyA,2737
-shepherd_core-2024.7.4.dist-info/METADATA,sha256=zFRCTLQEf-XN8Szx8fxb2JwCA6H0F26oUU5UMgWxVaA,7771
-shepherd_core-2024.7.4.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-shepherd_core-2024.7.4.dist-info/top_level.txt,sha256=wy-t7HRBrKARZxa-Y8_j8d49oVHnulh-95K9ikxVhew,14
-shepherd_core-2024.7.4.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-shepherd_core-2024.7.4.dist-info/RECORD,,
+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,,