pqopen-lib 0.7.8__tar.gz → 0.8.0__tar.gz

{pqopen_lib-0.7.8 → pqopen_lib-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pqopen-lib
-Version: 0.7.8
+Version: 0.8.0
 Summary: A power quality processing library for calculating parameters from waveform data
 Project-URL: Homepage, https://github.com/DaqOpen/pqopen-lib
 Project-URL: Issues, https://github.com/DaqOpen/pqopen-lib/issues

{pqopen_lib-0.7.8 → pqopen_lib-0.8.0}/pqopen/powersystem.py

@@ -88,7 +88,9 @@ class PowerSystem(object):
                           "mains_signaling_tracer": {},
                           "debug_channels": False,
                           "energy_channels": {},
-                          "one_period_fundamental": False}
+                          "one_period_fundamental": 0,
+                          "rms_trapz_rule": False,
+                          "pmu_calculation": False}
         self._prepare_calc_channels()
         self.output_channels: Dict[str, DataChannelBuffer] = {}
         self._last_processed_sidx = 0
@@ -100,6 +102,7 @@ class PowerSystem(object):
         self._last_zc_frac = 0.0
         self._calculation_mode = "NORMAL"
         self._last_known_freq = self.nominal_frequency
+        self._fund_freq_list = np.zeros(1)
         self._channel_update_needed = False
 
 
@@ -107,7 +110,8 @@ class PowerSystem(object):
         self._calc_channels = {"half_period":      {"voltage": {}, "current": {}, "power": {}, "_debug": {}}, 
                                 "one_period":       {"voltage": {}, "current": {}, "power": {}, "_debug": {}}, 
                                 "one_period_ovlp":  {"voltage": {}, "current": {}, "power": {}, "_debug": {}}, 
-                                "multi_period":     {"voltage": {}, "current": {}, "power": {}, "energy": {}, "_debug": {}}}
+                                "multi_period":     {"voltage": {}, "current": {}, "power": {}, "energy": {}, "_debug": {}},
+                                "pmu":  {"voltage": {}, "current": {}, "power": {}, "_debug": {}}}
 
     def add_phase(self, u_channel: AcqBuffer, i_channel: AcqBuffer = None, name: str = ""):
         """
@@ -214,13 +218,33 @@ class PowerSystem(object):
         self._features["energy_channels"] = {"persist_file": persist_file, "energy_counters": energy_counters}
         self._channel_update_needed = True
 
-    def enable_one_period_fundamental(self):
+    def enable_one_period_fundamental(self, freq_agg_cycles: int = 50):
         """
         Enables the calculation of one (single) period fundamental values
         """
-        self._features["one_period_fundamental"] = True
+        self._features["one_period_fundamental"] = freq_agg_cycles
+        self._fund_freq_list = np.zeros(freq_agg_cycles)
         self._channel_update_needed = True
 
+    def enable_rms_trapz_rule(self):
+        """
+        Enables the trapezoidal integration rule for rms calculation
+        """
+        self._features["rms_trapz_rule"] = True
+
+    def enable_pmu_calculation(self):
+        """
+        Enables the calculation of equidistant PMU values
+        """
+        if not self._features["nper_abs_time_sync"]:
+            logger.warning("To enable pmu_calculation, nper_abs_time_sync must be enabled first.")
+            return False
+        self._features["pmu_calculation"] = True
+        self._channel_update_needed = True
+        self._pmu_last_processed_sidx = 0
+        self._pmu_last_processed_ts_us = 0
+        self._pmu_time_increment_us = int(1_000_000 / self.nominal_frequency)
+
     def _resync_nper_abs_time(self, zc_idx: int):
         if not self._features["nper_abs_time_sync"]:
             return None
@@ -269,6 +293,8 @@ class PowerSystem(object):
                 self._calc_channels["multi_period"]["energy"]["w_pos"].last_sample_value = self._features["energy_channels"]["energy_counters"].get("W_pos", 0.0)
                 self._calc_channels["multi_period"]["energy"]["w_neg"] = DataChannelBuffer('W_neg', agg_type='max', unit="Wh", dtype=np.float64)
                 self._calc_channels["multi_period"]["energy"]["w_neg"].last_sample_value = self._features["energy_channels"]["energy_counters"].get("W_neg", 0.0)
+            if self._features["pmu_calculation"]:
+                self._calc_channels["pmu"]["power"]["freq"] = DataChannelBuffer('Freq_pmu', agg_type='mean', unit="Hz")
 
             for agg_interval, phys_types in self._calc_channels.items():
                 for phys_type, calc_type in phys_types.items():
@@ -320,30 +346,34 @@ class PowerSystem(object):
             self._zero_crossings.append(actual_zc)
             if self._zero_cross_counter <= 1:
                 continue
-            # Calculate Frequency
-            frequency = self._samplerate/(self._zero_crossings[-1] + actual_zc_frac - self._zero_crossings[-2] - self._last_zc_frac)
-            self._last_zc_frac = actual_zc_frac
             # Add actual zero cross counter to debug channel if enabled
             if "pidx" in self._calc_channels["one_period"]['_debug']:
                 self._calc_channels["one_period"]['_debug']['pidx'].put_data_single(self._zero_crossings[-1], self._zero_cross_counter)
             # Process one period calculation, start with second zc
-            self._process_one_period(self._zero_crossings[-2], self._zero_crossings[-1], frequency)
+            self._process_one_period(self._zero_crossings[-2], self._zero_crossings[-1], actual_zc_frac)
+            self._last_zc_frac = actual_zc_frac
             if ((self._zero_cross_counter-1) % self.nper) == 0 and (self._zero_cross_counter > self.nper):
                 # Process multi-period
                 self._process_multi_period(self._zero_crossings[-self.nper - 1], self._zero_crossings[-1])
                 self._resync_nper_abs_time(-1)
                 self._process_fluctuation_calc(self._zero_crossings[-self.nper - 1], self._zero_crossings[-1])
+
+        # Process fixed-time (PMU) channels
+        self._process_pmu_calc(self._zero_crossings[-1])
         
         self._last_processed_sidx = stop_acq_sidx
 
-    def _process_one_period(self, period_start_sidx: int, period_stop_sidx: int, frequency: float):
+    def _process_one_period(self, period_start_sidx: int, period_stop_sidx: int, actual_zc_frac: float= 0):
         """
         Processes data for a single period, calculating voltage, current, and power.
 
         Parameters:
             period_start_sidx: Start sample index of the period.
             period_stop_sidx: Stop sample index of the period.
+            frequency: Fundamental frequency
         """
+        # Calculate Frequency
+        frequency = self._samplerate/(period_stop_sidx + actual_zc_frac - period_start_sidx - self._last_zc_frac)
         self._calc_channels["one_period"]['power']['freq'].put_data_single(period_stop_sidx, frequency)
         if "sidx" in self._calc_channels["one_period"]['_debug']:
             self._calc_channels["one_period"]['_debug']['sidx'].put_data_single(period_stop_sidx, period_stop_sidx)
@@ -363,9 +393,30 @@ class PowerSystem(object):
             u_values = phase._u_channel.read_data_by_index(phase_period_start_sidx, phase_period_stop_sidx)
             if self._features["mains_signaling_tracer"]:
                 msv_edge, msv_value = phase._mains_signaling_tracer.process(u_values[::10])
+            if self._features["one_period_fundamental"]:
+                # Use sample-discrete frequency, not the exact one for full cycle
+                u_values_sync = phase._u_channel.read_data_by_index(period_start_sidx, period_stop_sidx)
+                self._fund_freq_list = np.roll(self._fund_freq_list,-1)
+                self._fund_freq_list[-1] = self._samplerate/len(u_values_sync)
+                mean_freq = self._fund_freq_list[self._fund_freq_list>0].mean()
+                fund_amp, fund_phase = calc_single_freq(u_values_sync, mean_freq, self._samplerate)
             for phys_type, output_channel in phase._calc_channels["one_period"]["voltage"].items():
                 if phys_type == "trms":
-                    u_rms = np.sqrt(np.mean(np.power(u_values, 2)))
+                    if self._features["rms_trapz_rule"]:
+                        add_start_idx_sample = 1 if self._last_zc_frac < 0 else 0
+                        add_stop_idx_sample = 1 if actual_zc_frac > 0 else 0
+                        u_trapz_values = phase._u_channel.read_data_by_index(phase_period_start_sidx-add_start_idx_sample, phase_period_stop_sidx+add_stop_idx_sample)
+                        sample_points = np.arange(len(u_values), dtype=np.float64)
+                        if add_start_idx_sample:
+                            u_trapz_values[0] = (u_trapz_values[1] - u_trapz_values[0])*(1+self._last_zc_frac) + u_trapz_values[0]
+                            sample_points = np.insert(sample_points,0,self._last_zc_frac)
+                        if add_stop_idx_sample:
+                            u_trapz_values[-1] = (u_trapz_values[-1] - u_trapz_values[-2])*self._last_zc_frac + u_trapz_values[-2]
+                            sample_points = np.insert(sample_points,len(sample_points),sample_points[-1]+actual_zc_frac)
+                        integral = np.trapezoid(np.power(u_trapz_values,2), sample_points)
+                        u_rms = np.sqrt(integral * frequency / self._samplerate)
+                    else:
+                        u_rms = np.sqrt(np.mean(np.power(u_values, 2)))
                     output_channel.put_data_single(phase_period_stop_sidx, u_rms)
                 if phys_type == "msv_bit":
                     if msv_edge is not None:
@@ -375,9 +426,10 @@ class PowerSystem(object):
                 if phys_type == "slope":
                     output_channel.put_data_single(phase_period_stop_sidx, np.abs(np.diff(u_values)).max())
                 if phys_type == "fund_rms":
-                    # Use sample-discrete frequency, not the exact one for full cycle
-                    fund_amp, fund_phase = calc_single_freq(u_values, self._samplerate/len(u_values), self._samplerate)
-                    output_channel.put_data_single(phase_period_stop_sidx, fund_amp)
+                    output_channel.put_data_single(period_stop_sidx, fund_amp)
+                if phys_type == "fund_phi":
+                    output_channel.put_data_single(period_stop_sidx, pq.normalize_phi(np.rad2deg(fund_phase+np.pi/2)))
+
             for phys_type, output_channel in phase._calc_channels["half_period"]["voltage"].items():
                 if phys_type == "trms":
                     # First half period
@@ -544,6 +596,52 @@ class PowerSystem(object):
             self._pst_last_calc_sidx = stop_sidx
             self._pst_next_round_ts = floor_timestamp(stop_ts, self._pst_interval_sec, ts_resolution="us")+self._pst_interval_sec*1_000_000
 
+    def _process_pmu_calc(self, stop_sidx: int):
+        """
+        Process data to calculate PMU (Phasor Measurement Unit) parameters.
+
+        Parameters:
+            stop_sidx: Stop sample index for calculation
+
+        Returns:
+            None
+        """
+        if not self._features["pmu_calculation"]:
+            return None
+        # Read timestamps
+        start_sidx = int(self._pmu_last_processed_sidx - 1.5*self._samplerate / self.nominal_frequency)
+        start_sidx = max(0, start_sidx)
+        ts_us = self._time_channel.read_data_by_index(start_sidx, stop_sidx)
+        first_pmu_ts = (self._pmu_last_processed_ts_us + self._pmu_time_increment_us) if self._pmu_last_processed_ts_us > 0 else ts_us[0] - ts_us[0] % self._pmu_time_increment_us + self._pmu_time_increment_us
+        last_pmu_ts = ts_us[-1] - (ts_us[-1] % self._pmu_time_increment_us) - self._pmu_time_increment_us # convert until n-1
+        logger.debug(f"first_pmu_ts: {first_pmu_ts:d}, last_pmu_ts: {last_pmu_ts:d}, self._pmu_time_increment_us: {self._pmu_time_increment_us:d}")
+        wanted_pmu_ts = np.arange(first_pmu_ts, last_pmu_ts+1, self._pmu_time_increment_us, dtype=np.int64)
+        wanted_pmu_sidx = [int(np.searchsorted(ts_us, pmu_ts)+start_sidx) for pmu_ts in wanted_pmu_ts]
+        wanted_pmu_ts_map = dict(zip(wanted_pmu_sidx, wanted_pmu_ts))
+        real_pmu_ts_map = {pmu_sidx: int(ts_us[pmu_sidx - start_sidx]) for pmu_sidx in wanted_pmu_sidx}
+        ovlp_window_start = max(0, int(wanted_pmu_sidx[0] - 1.5*self._samplerate / self.nominal_frequency))
+        freq, sample_indices = self._calc_channels["one_period"]["power"]["freq"].read_data_by_acq_sidx(ovlp_window_start, stop_sidx)
+
+        if len(sample_indices) == 0:
+            return None
+        for phase in self._phases:
+            u_raw = phase._u_channel.read_data_by_index(ovlp_window_start, stop_sidx)
+            for pmu_sidx in wanted_pmu_sidx:
+                # Search for previous zc
+                zc_idx = np.searchsorted(sample_indices, pmu_sidx,side="left")
+                if zc_idx == len(sample_indices):
+                    zc_idx -= 1
+                local_stop_idx = max(0, pmu_sidx - ovlp_window_start)
+                local_start_idx = max(0, local_stop_idx - int(np.round(self._samplerate/freq[zc_idx])))
+                fund_amp, fund_phase = calc_single_freq(u_raw[local_start_idx:local_stop_idx], freq[zc_idx], self._samplerate)
+                frac_sidx_phi_offset = (wanted_pmu_ts_map[pmu_sidx] - real_pmu_ts_map[pmu_sidx])/1e6*2*np.pi*freq[zc_idx]
+                phase._calc_channels["pmu"]["voltage"]["rms"].put_data_single(pmu_sidx, fund_amp)
+                phase._calc_channels["pmu"]["voltage"]["phi"].put_data_single(pmu_sidx, pq.normalize_phi(np.rad2deg(fund_phase+np.pi/2+frac_sidx_phi_offset)))
+                # TODO: Add Frequency PMU Channel as well??
+                # TODO: Add current channels?
+        self._pmu_last_processed_sidx = stop_sidx
+        self._pmu_last_processed_ts_us = last_pmu_ts
+
     def _detect_zero_crossings(self, start_acq_sidx: int, stop_acq_sidx: int) -> List[float]:
         """
         Detects zero crossings in the signal.
@@ -644,12 +742,13 @@ class PowerPhase(object):
         Parameters:
             features: Dict of features
         """
-        self._calc_channels = {"half_period": {}, "one_period": {}, "one_period_ovlp": {}, "multi_period": {}}
+        self._calc_channels = {"half_period": {}, "one_period": {}, "one_period_ovlp": {}, "multi_period": {}, "pmu": {}}
         # Create Voltage Channels
         self._calc_channels["half_period"]["voltage"] = {}
         self._calc_channels["one_period"]["voltage"] = {}
         self._calc_channels["one_period_ovlp"]["voltage"] = {}
         self._calc_channels["multi_period"]["voltage"] = {}
+        self._calc_channels["pmu"]["voltage"] = {}
         self._calc_channels["half_period"]["voltage"]["trms"] = DataChannelBuffer('U{:s}_hp_rms'.format(self.name), agg_type='rms', unit="V")
         self._calc_channels["one_period"]["voltage"]["trms"] = DataChannelBuffer('U{:s}_1p_rms'.format(self.name), agg_type='rms', unit="V")
         self._calc_channels["one_period"]["voltage"]["slope"] = DataChannelBuffer('U{:s}_1p_slope'.format(self.name), agg_type='max', unit="V/s")
@@ -677,8 +776,13 @@ class PowerPhase(object):
             self._calc_channels["one_period"]["voltage"]["msv_mag"] = DataChannelBuffer('U{:s}_1p_msv'.format(self.name), agg_type='max', unit="V")
             self._calc_channels["one_period"]["voltage"]["msv_bit"] = DataChannelBuffer('U{:s}_msv_bit'.format(self.name), unit="")
 
-        if "one_period_fundamental" in features and features["one_period_fundamental"]:
+        if "one_period_fundamental" in features and features["one_period_fundamental"] > 0:
             self._calc_channels["one_period"]["voltage"]["fund_rms"] = DataChannelBuffer('U{:s}_1p_H1_rms'.format(self.name), agg_type='rms', unit="V")
+            self._calc_channels["one_period"]["voltage"]["fund_phi"] = DataChannelBuffer('U{:s}_1p_H1_phi'.format(self.name), agg_type='phi', unit="°")
+
+        if "pmu_calculation" in features and features["pmu_calculation"]:
+            self._calc_channels["pmu"]["voltage"]["rms"] = DataChannelBuffer('U{:s}_pmu_rms'.format(self.name), agg_type='rms', unit="V")
+            self._calc_channels["pmu"]["voltage"]["phi"] = DataChannelBuffer('U{:s}_pmu_phi'.format(self.name), agg_type='phi', unit="°")
 
         # Create Current Channels
         if self._i_channel:
@@ -686,6 +790,7 @@ class PowerPhase(object):
             self._calc_channels["multi_period"]["current"] = {}
             self._calc_channels["one_period"]["current"]["trms"] = DataChannelBuffer('I{:s}_1p_rms'.format(self.name), agg_type='rms', unit="A")
             self._calc_channels["multi_period"]["current"]["trms"] = DataChannelBuffer('I{:s}_rms'.format(self.name), agg_type='rms', unit="A")
+            self._calc_channels["pmu"]["current"] = {}
             self._calc_channels["one_period"]["power"] = {}
             self._calc_channels["multi_period"]["power"] = {}
 
@@ -698,6 +803,10 @@ class PowerPhase(object):
                 self._calc_channels["multi_period"]["power"]['p_fund_mag'] = DataChannelBuffer('P{:s}_H1'.format(self.name), agg_type='mean', unit="W")
                 self._calc_channels["multi_period"]["power"]['q_fund_mag'] = DataChannelBuffer('Q{:s}_H1'.format(self.name), agg_type='mean', unit="var")
 
+            if "pmu_calculation" in features and features["pmu_calculation"]:
+                self._calc_channels["pmu"]["current"]["rms"] = DataChannelBuffer('I{:s}_pmu_rms'.format(self.name), agg_type='rms', unit="A")
+                self._calc_channels["pmu"]["current"]["phi"] = DataChannelBuffer('I{:s}_pmu_phi'.format(self.name), agg_type='phi', unit="°")
+
             # Create Power Channels
             self._calc_channels["one_period"]["power"]['p_avg'] = DataChannelBuffer('P{:s}_1p'.format(self.name), agg_type='mean', unit="W")
             self._calc_channels["multi_period"]["power"]['p_avg'] = DataChannelBuffer('P{:s}'.format(self.name), agg_type='mean', unit="W")

{pqopen_lib-0.7.8 → pqopen_lib-0.8.0}/pqopen/zcd.py

@@ -40,8 +40,7 @@ class ZeroCrossDetector:
         self.samplerate = samplerate
 
         # Design a Butterworth low-pass filter
-        normal_cutoff = self.f_cutoff / (0.5 * self.samplerate)
-        self._filter_coeff = signal.iirfilter(2, normal_cutoff, btype='lowpass', ftype='butter')
+        self._filter_coeff = signal.iirfilter(2, self.f_cutoff, btype='lowpass', ftype='butter', fs=self.samplerate)
         self._filter_zi = np.zeros(len(self._filter_coeff[0]) - 1)
 
         self._last_filtered_sample = 0
@@ -51,9 +50,8 @@ class ZeroCrossDetector:
         self._last_zc_n_val = None
 
         # Calculate the filter delay in samples
-        w, h = signal.freqz(self._filter_coeff[0], self._filter_coeff[1],
-                            [2 * np.pi * self.f_cutoff / self.samplerate])
-        self.filter_delay_samples = np.angle(h)[0] / (2 * np.pi) * self.samplerate / self.f_cutoff
+        w, h = signal.freqz(self._filter_coeff[0], self._filter_coeff[1], worN=[self.f_cutoff], fs=self.samplerate)
+        self.filter_delay_samples = np.angle(h)[0] / (2 * np.pi) * self.samplerate / self.f_cutoff - 1 # due to adding sample in front for continuity
         self.filtered_data = []
 
     def process(self, data: np.ndarray)-> list:

{pqopen_lib-0.7.8 → pqopen_lib-0.8.0}/pyproject.toml

@@ -12,7 +12,7 @@ packages = ["pqopen"]
 
 [project]
 name = "pqopen-lib"
-version = "0.7.8"
+version = "0.8.0"
 dependencies = [
     "numpy",
     "daqopen-lib",

{pqopen_lib-0.7.8 → pqopen_lib-0.8.0}/test/powersystem-test.py

@@ -229,7 +229,25 @@ class TestPowerSystemCalculation(unittest.TestCase):
         self.assertIsNone(np.testing.assert_allclose(u_h_rms[:,3], expected_u_h3_rms, rtol=0.01))
         u_msv_rms, _ = self.power_system.output_channels["U1_msv_rms"].read_data_by_acq_sidx(0, u_values.size)
         self.assertIsNone(np.testing.assert_allclose(u_msv_rms, expected_u_msv_rms, rtol=0.01))
+
+    def test_one_period_calc_trapz_rule(self):
+        t = np.linspace(0, 1, int(self.power_system._samplerate), endpoint=False)
+        u_values = np.sqrt(2)*np.sin(2*np.pi*50.02*t)
         
+        expected_u_rms = np.array(np.zeros(47)) + 1.0
+        expected_freq = np.array(np.zeros(47)) + 50.02
+
+        self.power_system.enable_rms_trapz_rule()
+        self.u_channel.put_data(u_values)
+        self.i_channel.put_data(u_values)
+        self.power_system.process()
+
+        # Check Voltage
+        u_rms, _ = self.power_system.output_channels["U1_1p_rms"].read_data_by_acq_sidx(0, u_values.size)
+        self.assertIsNone(np.testing.assert_array_almost_equal(u_rms[1:], expected_u_rms, 4))
+        # Check Frequency
+        freq, _ = self.power_system.output_channels["Freq"].read_data_by_acq_sidx(0, u_values.size)
+        self.assertIsNone(np.testing.assert_array_almost_equal(freq[1:], expected_freq, 3))
 
 class TestPowerSystemCalculationThreePhase(unittest.TestCase):
     def setUp(self):
@@ -509,7 +527,7 @@ class TestPowerSystemNperSync(unittest.TestCase):
         self.power_system.process()
 
         u_rms, sidx = self.power_system.output_channels["U1_rms"].read_data_by_acq_sidx(0, u_values.size)
-        self.assertAlmostEqual(sidx[5*5],5.2*self.power_system._samplerate, places=-1)
+        self.assertAlmostEqual(sidx[5*5],5.22*self.power_system._samplerate, places=-1)
 
     # def test_fractional_freq(self):
     #     abs_ts_start = datetime.datetime(2024,1,1,0,0,5, tzinfo=datetime.UTC).timestamp()
@@ -552,7 +570,7 @@ class TestPowerSystemFluctuation(unittest.TestCase):
             self.time_channel.put_data((t[blk_idx*blocksize:(blk_idx+1)*blocksize]+abs_ts_start)*1e6)
             self.power_system.process()
         self.assertAlmostEqual(self.power_system.output_channels["U1_pst"].last_sample_value, 0, places=1)
-        self.assertEqual(self.power_system.output_channels["U1_pst"].last_sample_acq_sidx, np.round(self.power_system._samplerate*(61+0.02)))
+        self.assertEqual(self.power_system.output_channels["U1_pst"].last_sample_acq_sidx, int(self.power_system._samplerate*(61+0.02)))
 
 def test_steady_state_600s(self):
         self.power_system.enable_fluctuation_calculation(nominal_voltage=230, pst_interval_sec=600)
@@ -568,6 +586,37 @@ def test_steady_state_600s(self):
         self.assertAlmostEqual(self.power_system.output_channels["U1_pst"].last_sample_value, 0, places=1)
         self.assertEqual(self.power_system.output_channels["U1_pst"].last_sample_acq_sidx, np.round(self.power_system._samplerate*621))
 
+class TestPowerSystemPMU(unittest.TestCase):
+    def setUp(self):
+        self.u_channel = AcqBuffer(name="U1")
+        self.time_channel = AcqBuffer(dtype=np.int64)
+
+        # Create PowerSystem instance
+        self.power_system = PowerSystem(
+            zcd_channel=self.u_channel,
+            input_samplerate=5555.555,
+            zcd_threshold=1
+        )
+        # Add Phase
+        self.power_system.add_phase(u_channel=self.u_channel)
+        self.power_system.enable_nper_abs_time_sync(self.time_channel)
+        self.power_system.enable_one_period_fundamental(1)
+        self.power_system.enable_pmu_calculation()
+
+    def test_simple(self):
+        abs_ts_start = datetime.datetime(2025,1,1,0,0,0, tzinfo=datetime.UTC).timestamp()
+        t = np.arange(0, 1, 1/self.power_system._samplerate)
+        u_values = 230*np.sqrt(2)*np.sin(2*np.pi*50*t)
+
+        blocksize = 1000
+        for blk_idx in range(t.size // blocksize):
+            self.u_channel.put_data(u_values[blk_idx*blocksize:(blk_idx+1)*blocksize])
+            self.time_channel.put_data((t[blk_idx*blocksize:(blk_idx+1)*blocksize]+abs_ts_start)*1e6)
+            self.power_system.process()
+        self.assertAlmostEqual(self.power_system.output_channels["U1_pmu_rms"].last_sample_value, 230, places=0)
+        self.assertAlmostEqual(self.power_system.output_channels["U1_pmu_phi"].last_sample_value, 0, places=0)
+        #self.assertEqual(self.power_system.output_channels["U1_pmu_rms"].last_sample_acq_sidx, np.round(self.power_system._samplerate*(61+0.02)))
+
 
 if __name__ == "__main__":
     unittest.main()

{pqopen_lib-0.7.8 → pqopen_lib-0.8.0}/test/zcd-test.py

@@ -44,7 +44,7 @@ class TestZeroCrossDetector(unittest.TestCase):
         sine_wave = self.generate_sine_wave(freq=freq, duration=duration)
 
         zero_crossings = self.detector.process(sine_wave)
-        self.assertAlmostEqual(self.detector.filter_delay_samples, -5)
+        self.assertAlmostEqual(self.detector.filter_delay_samples, -6)
 
         # Expected zero-crossings: 5 Hz * 1 positive crossing per cycle * 1 second
         expected_crossings = np.arange(start=1, stop=6)*self.samplerate/freq