shepherd-core 2024.7.3__tar.gz → 2024.8.1__tar.gz

{shepherd_core-2024.7.3 → shepherd_core-2024.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shepherd_core
-Version: 2024.7.3
+Version: 2024.8.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>
@@ -136,28 +136,30 @@ Notes:
 The Library is available via PyPI and can be installed with
 
 ```shell
-  pip install shepherd-core -U
+pip install shepherd-core -U
 
-  # or for the full experience (includes core)
-  pip install shepherd-data -U
+# or for the full experience (includes core)
+pip install shepherd-data -U
 ```
 
 For bleeding-edge-features or dev-work it is possible to install directly from GitHub-Sources (here `dev`-branch):
 
 ```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
 ```
 
 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.
 
 ```shell
-  sudo apt install build-essential
+sudo apt install build-essential
 ```
 
 For more advanced work with ``.elf``-files (modify value of symbols / target-ID) you should install
 
 ```shell
-  pip install shepherd-core[elf]
+pip install shepherd-core[elf]
 ```
 
 and also make sure the prereqs for the [pwntools](https://docs.pwntools.com/en/stable/install.html) are met.
@@ -165,7 +167,7 @@ and also make sure the prereqs for the [pwntools](https://docs.pwntools.com/en/s
 For creating an inventory of the host-system you should install
 
 ```shell
-  pip install shepherd-core[inventory]
+pip install shepherd-core[inventory]
 ```
 
 ## Unittests

{shepherd_core-2024.7.3 → shepherd_core-2024.8.1}/README.md

@@ -80,28 +80,30 @@ Notes:
 The Library is available via PyPI and can be installed with
 
 ```shell
-  pip install shepherd-core -U
+pip install shepherd-core -U
 
-  # or for the full experience (includes core)
-  pip install shepherd-data -U
+# or for the full experience (includes core)
+pip install shepherd-data -U
 ```
 
 For bleeding-edge-features or dev-work it is possible to install directly from GitHub-Sources (here `dev`-branch):
 
 ```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
 ```
 
 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.
 
 ```shell
-  sudo apt install build-essential
+sudo apt install build-essential
 ```
 
 For more advanced work with ``.elf``-files (modify value of symbols / target-ID) you should install
 
 ```shell
-  pip install shepherd-core[elf]
+pip install shepherd-core[elf]
 ```
 
 and also make sure the prereqs for the [pwntools](https://docs.pwntools.com/en/stable/install.html) are met.
@@ -109,7 +111,7 @@ and also make sure the prereqs for the [pwntools](https://docs.pwntools.com/en/s
 For creating an inventory of the host-system you should install
 
 ```shell
-  pip install shepherd-core[inventory]
+pip install shepherd-core[inventory]
 ```
 
 ## Unittests

shepherd_core-2024.8.1/examples/eenv_generator.py

@@ -0,0 +1,43 @@
+"""Create a set of static artificial energy environments."""
+
+from itertools import product
+from pathlib import Path
+
+import numpy as np
+from tqdm import trange
+
+from shepherd_core import Reader as ShpReader
+from shepherd_core import Writer as ShpWriter
+from shepherd_core import logger
+
+# Config
+voltages_V = [4.0, 2.0]
+currents_A = [2e-3, 1e-3]
+duration_s = 10
+repetitions = 1
+
+path_here = Path(__file__).parent.absolute()
+
+for _v, _c in product(voltages_V, currents_A):
+    v_str = f"{round(_v * 1000)}mV"
+    c_str = f"{round(_c * 1000)}mA"
+    t_str = f"{round(duration_s * repetitions)}s"
+    name = f"eenv_static_{v_str}_{c_str}_{t_str}"
+    file_path = path_here / f"{name}.h5"
+
+    if file_path.exists():
+        logger.info("File exists, will skip: %s", file_path.name)
+    else:
+        with ShpWriter(file_path) as file:
+            file.store_hostname("artificial")
+            # values in SI units
+            timestamp_vector = np.arange(0.0, duration_s, file.sample_interval_ns / 1e9)
+            voltage_vector = np.linspace(_v, _v, int(file.samplerate_sps * duration_s))
+            current_vector = np.linspace(_c, _c, int(file.samplerate_sps * duration_s))
+
+            for idx in trange(repetitions, desc="generate"):
+                timestamps = idx * duration_s + timestamp_vector
+                file.append_iv_data_si(timestamps, voltage_vector, current_vector)
+
+    with ShpReader(file_path) as file:
+        file.save_metadata()

{shepherd_core-2024.7.3 → shepherd_core-2024.8.1}/examples/vharvester_simulation.py

@@ -6,9 +6,12 @@
 
 """
 
+from contextlib import ExitStack
 from pathlib import Path
 
+from shepherd_core import CalibrationHarvester
 from shepherd_core import Reader
+from shepherd_core import Writer
 from shepherd_core.data_models import VirtualHarvesterConfig
 from shepherd_core.data_models.content.virtual_harvester import HarvesterPRUConfig
 from shepherd_core.vsource import VirtualHarvesterModel
@@ -32,6 +35,8 @@ hrv_list = [
     "mppt_opt",
 ]
 
+save_files: bool = True
+
 # convert IVonne to IVCurve
 if not file_ivcurve.exists():
     with ivonne.Reader(file_ivonne) as db:
@@ -45,7 +50,7 @@ with Reader(file_ivcurve, verbose=False) as file:
         I_in_max = max(I_in_max, _i.max())
     print(
         f"Input-file: \n"
-        f"\tE_in = {file.energy() * 1e3:.3f} mWs\n"
+        f"\tE_in = {file.energy() * 1e3:.3f} mWs (not representative)\n"
         f"\tI_in_max = {I_in_max * 1e3:.3f} mA\n"
         f"\twindow_size = {window_size} n\n",
     )
@@ -53,21 +58,39 @@ with Reader(file_ivcurve, verbose=False) as file:
 # Simulation
 for hrv_name in hrv_list:
     E_out_Ws = 0.0
+    _cal = CalibrationHarvester()
+    if save_files:
+        stack = ExitStack()
+        file_output = file_ivcurve.with_name(
+            file_ivcurve.stem + "_" + hrv_name + file_ivcurve.suffix
+        )
+        fh_output = Writer(
+            file_output, cal_data=_cal, mode="harvester", verbose=False, force_overwrite=True
+        )
+        stack.enter_context(fh_output)
+        fh_output.store_hostname("hrv_sim_" + hrv_name)
+
     with Reader(file_ivcurve, verbose=False) as file:
         hrv_config = VirtualHarvesterConfig(name=hrv_name)
         hrv_pru = HarvesterPRUConfig.from_vhrv(
             hrv_config,
             for_emu=True,
             dtype_in=file.get_datatype(),
-            window_size=file.get_window_samples(),
+            window_size=4 * file.get_window_samples(),
         )
         hrv = VirtualHarvesterModel(hrv_pru)
         for _t, _v, _i in file.read_buffers():
+            # TODO: _t should be handed to new file without conversions
             length = max(_v.size, _i.size)
             for _n in range(length):
                 _v[_n], _i[_n] = hrv.ivcurve_sample(
                     _voltage_uV=_v[_n] * 10**6, _current_nA=_i[_n] * 10**9
                 )
             E_out_Ws += (_v * _i).sum() * 1e-15 * file.sample_interval_s
-
+            if save_files:
+                fh_output.append_iv_data_si(_t, _v / 1e6, _i / 1e9)
+        if save_files:
+            stack.close()
+            with Reader(file_output) as fh_output:
+                fh_output.save_metadata()
         print(f"E_out = {E_out_Ws * 1e3:.3f} mWs -> {hrv_name}")

shepherd_core-2024.8.1/examples/vsource_emulation.py

@@ -0,0 +1,86 @@
+"""Demonstrate behavior of Virtual Source Algorithms.
+
+The emulation recreates an observer-cape, the virtual Source and a virtual target
+- input = hdf5-file with a harvest-recording
+- output = hdf5-file
+- config is currently hardcoded, but it could be an emulation-task
+- target is currently a simple resistor
+
+The output file can be analyzed and plotted with shepherds tool suite.
+"""
+# TODO: `shepherd-data emulate config.yaml`
+
+from pathlib import Path
+
+import numpy as np
+from tqdm import tqdm
+
+from shepherd_core import CalibrationEmulator
+from shepherd_core import Reader
+from shepherd_core import Writer
+from shepherd_core.data_models import VirtualHarvesterConfig
+from shepherd_core.data_models import VirtualSourceConfig
+from shepherd_core.vsource import VirtualSourceModel
+
+# config simulation
+file_input = Path(__file__).parent / "jogging_ivcurve.h5"
+
+src_list = ["BQ25504"]
+
+I_mcu_sleep_A = 3e-3
+I_mcu_active_A = 3e-3
+R_Ohm = 1000
+
+for vs_name in src_list:
+    file_output = file_input.with_name(file_input.stem + "_emu_" + vs_name + file_input.suffix)
+
+    cal_emu = CalibrationEmulator()
+    src_config = VirtualSourceConfig(
+        inherit_from=vs_name,
+        V_intermediate_init_mV=3000,
+        harvester=VirtualHarvesterConfig(name="mppt_bq_solar"),
+        C_intermediate_uF=50,
+    )
+
+    with Reader(file_input, verbose=False) as f_inp, Writer(
+        file_output, cal_data=cal_emu, mode="emulator", verbose=False
+    ) as f_out:
+        window_size = f_inp.get_window_samples()
+        f_out.store_hostname("emu_sim_" + vs_name)
+        f_out.store_config(src_config.model_dump())
+        src = VirtualSourceModel(
+            src_config, cal_emu, log_intermediate=False, window_size=window_size
+        )
+
+        I_out_nA = 0
+
+        for _t, _V_inp, _I_inp in tqdm(f_inp.read_buffers(), total=f_inp.buffers_n):
+            V_out = np.empty(_V_inp.shape)
+            I_out = np.empty(_I_inp.shape)
+
+            for _iter in range(len(_t)):
+                V_out_uV = src.iterate_sampling(
+                    V_inp_uV=_V_inp[_iter] * 10**6,
+                    I_inp_nA=_I_inp[_iter] * 10**9,
+                    I_out_nA=I_out_nA,
+                )
+                I_out_nA = 1e3 * V_out_uV / R_Ohm
+
+                V_out[_iter] = V_out_uV / 1e6
+                I_out[_iter] = I_out_nA / 1e9
+
+                # TODO: src.cnv.get_I_mod_out_nA() has more internal drains
+
+            f_out.append_iv_data_si(_t, V_out, I_out)
+
+            # listen to power-good signal
+            """
+            if src.cnv.get_power_good():
+                I_out_nA = int(I_mcu_active_A * 10 ** 9)
+                N_good += 1
+            else:
+                I_out_nA = int(I_mcu_sleep_A * 10 ** 9)
+            """
+
+    with Reader(file_output, verbose=False) as f_out:
+        f_out.save_metadata()

{shepherd_core-2024.7.3 → shepherd_core-2024.8.1}/shepherd_core/calibration_hw_def.py

@@ -32,45 +32,48 @@ RAW_MAX_ADC = 2**M_ADC - 1
 RAW_MAX_DAC = 2**M_DAC - 1
 
 
-def adc_current_to_raw(current: float) -> int:
+def adc_current_to_raw(current: float, *, limited: bool = True) -> int:
     """Convert back a current [A] to raw ADC value."""
     # voltage on input of adc
     val_adc = G_INST_AMP * R_SHT * current
     # digital value according to ADC gain
     val_raw = int(val_adc * (2**M_ADC) / (G_ADC_I * V_REF_ADC))
-    return min(max(val_raw, 0), 2**M_ADC - 1)
+    return min(max(val_raw, 0), 2**M_ADC - 1) if limited else val_raw
 
 
-def adc_raw_to_current(value: int) -> float:
+def adc_raw_to_current(value: int, *, limited: bool = True) -> float:
     """Convert a raw ADC value to a current [A]."""
-    value = min(max(value, 0), 2**M_ADC - 1)
+    if limited:
+        value = min(max(value, 0), 2**M_ADC - 1)
     # voltage on input of adc
     val_adc = float(value) * (G_ADC_I * V_REF_ADC) / (2**M_ADC)
     # current according to adc value
     return val_adc / (R_SHT * G_INST_AMP)
 
 
-def adc_voltage_to_raw(voltage: float) -> int:
+def adc_voltage_to_raw(voltage: float, *, limited: bool = True) -> int:
     """Convert back a voltage [V] to raw ADC value."""
     # digital value according to ADC gain
     val_raw = int(voltage * (2**M_ADC) / (G_ADC_V * V_REF_ADC))
-    return min(max(val_raw, 0), 2**M_ADC - 1)
+    return min(max(val_raw, 0), 2**M_ADC - 1) if limited else val_raw
 
 
-def adc_raw_to_voltage(value: int) -> float:
+def adc_raw_to_voltage(value: int, *, limited: bool = True) -> float:
     """Convert a raw ADC value to a voltage [V]."""
-    value = min(max(value, 0), 2**M_ADC - 1)
+    if limited:
+        value = min(max(value, 0), 2**M_ADC - 1)
     # voltage according to ADC value
     return float(value) * (G_ADC_V * V_REF_ADC) / (2**M_ADC)
 
 
-def dac_raw_to_voltage(value: int) -> float:
+def dac_raw_to_voltage(value: int, *, limited: bool = True) -> float:
     """Convert back a raw DAC value to a voltage [V]."""
-    value = min(max(value, 0), 2**M_DAC - 1)
+    if limited:
+        value = min(max(value, 0), 2**M_DAC - 1)
     return float(value) * (V_REF_DAC * G_DAC) / (2**M_DAC)
 
 
-def dac_voltage_to_raw(voltage: float) -> int:
+def dac_voltage_to_raw(voltage: float, *, limited: bool = True) -> int:
     """Convert a voltage [V] to raw DAC value."""
     val_raw = int(voltage * (2**M_DAC) / (V_REF_DAC * G_DAC))
-    return min(max(val_raw, 0), 2**M_DAC - 1)
+    return min(max(val_raw, 0), 2**M_DAC - 1) if limited else val_raw

{shepherd_core-2024.7.3 → shepherd_core-2024.8.1}/shepherd_core/data_models/base/calibration.py

@@ -51,6 +51,7 @@ class CalibrationPair(ShpModel):
 
     gain: PositiveFloat
     offset: float = 0
+    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."""
@@ -77,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)
-        gain_inv = fn(1.0) - offset
-        return cls(
-            gain=1.0 / float(gain_inv),
-            offset=-float(offset) / gain_inv,
-        )
+        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, unit=unit)
 
 
 cal_hrv_legacy = {  # legacy translator
@@ -98,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.
@@ -142,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.
@@ -232,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
@@ -251,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
@@ -274,7 +273,7 @@ class CalibrationSeries(ShpModel):
         emu_port_a: bool = True,
     ) -> Self:
         if isinstance(cal, CalibrationHarvester):
-            return cls(voltage=cal.adc_V_Sense, current=cal.dac_V_Hrv)
+            return cls(voltage=cal.adc_V_Sense, current=cal.adc_C_Hrv)
         if emu_port_a:
             return cls(voltage=cal.dac_V_A, current=cal.adc_C_A)
         return cls(voltage=cal.dac_V_B, current=cal.adc_C_B)

{shepherd_core-2024.7.3 → shepherd_core-2024.8.1}/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-2024.7.3 → shepherd_core-2024.8.1}/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-2024.7.3 → shepherd_core-2024.8.1}/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-2024.7.3 → shepherd_core-2024.8.1}/shepherd_core/data_models/content/virtual_source_fixture.yaml

@@ -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