pqopen-lib 0.8.3__tar.gz → 0.8.5__tar.gz

{pqopen_lib-0.8.3 → pqopen_lib-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pqopen-lib
-Version: 0.8.3
+Version: 0.8.5
 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.8.3 → pqopen_lib-0.8.5}/pqopen/powersystem.py

@@ -659,7 +659,7 @@ class PowerSystem(object):
             List[int]: Detected zero-crossing indices.
         """
         zcd_data = self._zcd_channel.read_data_by_index(start_idx=start_acq_sidx, stop_idx=stop_acq_sidx)
-        zero_crossings = self._zero_cross_detector.process(zcd_data)
+        zero_crossings = self._zero_cross_detector.process(zcd_data, self._zero_crossings[-1] - start_acq_sidx)
         if not zero_crossings:
             if (self._zero_crossings[-1] + self._samplerate/self._zcd_minimum_frequency - self._zero_cross_detector.filter_delay_samples) < stop_acq_sidx:
                 zero_crossings.append(self._zero_crossings[-1] + self._samplerate/self._last_known_freq - start_acq_sidx)
@@ -675,9 +675,18 @@ class PowerSystem(object):
                         if self._last_known_freq < self._zcd_minimum_frequency:
                             self._last_known_freq = self.nominal_frequency
                 self._calculation_mode = "FALLBACK"
+        elif self._calculation_mode == "FALLBACK":
+            remaining_virtual_zc = []
+            last_rel_zc = self._zero_crossings[-1] - start_acq_sidx 
+            zc_gap = zero_crossings[0] - last_rel_zc
+            num_zc_to_fill = int(zc_gap / (self._samplerate/self._last_known_freq)) + 1
+            virtual_zc_interval = int(zc_gap / num_zc_to_fill)
+            remaining_virtual_zc = [last_rel_zc + i*virtual_zc_interval for i in range(1,num_zc_to_fill)]
+            logger.debug("Finishing Fallback: Added virtual zero crossing: idx=" + ",".join([f"{virtual_zc:.1f}" for virtual_zc in remaining_virtual_zc]))
+            zero_crossings = remaining_virtual_zc + zero_crossings
+            self._calculation_mode = "NORMAL"
         else:
             self._calculation_mode = "NORMAL"
-
         return zero_crossings
 
     def get_aggregated_data(self, start_acq_sidx: int, stop_acq_sidx: int) -> dict:
@@ -697,6 +706,21 @@ class PowerSystem(object):
             output_values[ch_name] = ch_data
         return output_values
     
+    def get_channel_info(self) -> dict:
+        channel_info = {}
+        for phase in self._phases:
+            for calc_interval, interval_group in phase._calc_channels.items():
+                for derived_type, phys_group in interval_group.items():
+                    for phys_type, channel in phys_group.items():
+                        channel_info[channel.name] = {
+                            "unit": channel.unit,
+                            "phys_type": phys_type,
+                            "derived_type": derived_type,
+                            "calc_interval": calc_interval,
+                            "phase": phase.name
+                        }
+        return channel_info
+    
     def __del__(self):
         if self._features["energy_channels"]:
             w_pos_value = float(self._calc_channels["multi_period"]["energy"]["w_pos"].last_sample_value)

{pqopen_lib-0.8.3 → pqopen_lib-0.8.5}/pqopen/storagecontroller.py

@@ -57,11 +57,13 @@ import numpy as np
 from pqopen.helper import floor_timestamp, JsonDecimalLimiter
 from pqopen.eventdetector import Event
 from daqopen.channelbuffer import DataChannelBuffer, AcqBuffer
+from daqopen.daqinfo import DaqInfo
 from pathlib import Path
 from typing import List, Dict
 import logging
 import json
 import gzip
+import time
 import paho.mqtt.client as mqtt
 
 
@@ -91,7 +93,7 @@ class StorageEndpoint(object):
         """
         Writes aggregated data to the storage endpoint.
 
-        Args:
+        Parameters:
             data: The aggregated data to store.
             timestamp_us: The timestamp in microseconds for the aggregated data.
             interval_seconds: The aggregation interval in seconds.
@@ -101,6 +103,17 @@ class StorageEndpoint(object):
     def write_event(self, event: Event):
         pass
 
+    def write_measurement_config(self, m_config: dict, daq_info: DaqInfo, channe_info: dict, **kwargs):
+        """
+        Writes measurement config to the storage endpoint.
+
+        Parameters:
+            m_config: The measurement config to store.
+            daq_info: The daq info to store.
+            channel_info: The channel's specific infos
+        """
+        pass
+
 class StoragePlan(object):
     """Defines a plan for storing data with specified intervals and channels."""
 
@@ -190,6 +203,9 @@ class StoragePlan(object):
         if self._store_events_enabled:
             self.storage_endpoint.write_event(event, **self._additional_config)
 
+    def store_measurement_config(self, m_config: dict, daq_info: DaqInfo, channel_info: dict):
+        self.storage_endpoint.write_measurement_config(m_config, daq_info, channel_info, **self._additional_config)
+
 class StorageController(object):
     """Manages multiple storage plans and processes data for storage."""
 
@@ -304,7 +320,10 @@ class StorageController(object):
                                          available_channels: dict, 
                                          measurement_id: str, 
                                          device_id: str,
-                                         start_timestamp_us: int):
+                                         start_timestamp_us: int,
+                                         m_config: dict | None = None,
+                                         daq_info: DaqInfo | None = None,
+                                         channel_info: dict| None = None):
         """
         Setup endpoints and storage plans from config
 
@@ -319,7 +338,7 @@ class StorageController(object):
         Raises:
             NotImplementedError: If a not implemented endpoint will be configured
         """
-        self._configured_eps = {}
+        self._configured_eps: dict[str, StorageEndpoint] = {}
         for ep_type, ep_config in endpoints.items():
             if ep_type == "csv":
                 csv_storage_endpoint = CsvStorageEndpoint("csv", measurement_id, ep_config.get("data_dir", "/tmp/"))
@@ -375,8 +394,11 @@ class StorageController(object):
                     else:      
                         logger.warning(f"Channel {channel} not available for storing")
             self.add_storage_plan(storage_plan)
-
-            
+            # Initially store the measurement config if configured
+            if sp_config.get("store_config", False) and m_config and daq_info and channel_info:
+                storage_plan.store_measurement_config(m_config=m_config,
+                                                      daq_info=daq_info,
+                                                      channel_info=channel_info)
 
 class TestStorageEndpoint(StorageEndpoint):
     """A implementation of StorageEndpoint for testing purposes."""
@@ -499,6 +521,27 @@ class MqttStorageEndpoint(StorageEndpoint):
             self._client.publish(topic_prefix + f"/{self._device_id:s}/event/json",
                             json_item.encode('utf-8'), qos=2)
             
+    def write_measurement_config(self, m_config: dict, daq_info: DaqInfo, channel_info: dict, **kwargs):
+        """
+        Write measurement config
+        """
+        m_config_object = {
+            "type": "m_config",
+            "measurement_uuid": self.measurement_id,
+            "timestamp": time.time(),
+            "m_config": m_config,
+            "daq_info": daq_info.to_dict(),
+            "channel_info": channel_info
+        }
+        json_item = json.dumps(m_config_object)
+        topic_prefix = kwargs.get("mqtt_topic_prefix", self._topic_prefix)
+        if self._compression:
+            self._client.publish(topic_prefix + f"/{self._device_id:s}/m_config/gjson",
+                            gzip.compress(json_item.encode('utf-8')), qos=2)
+        else:
+            self._client.publish(topic_prefix + f"/{self._device_id:s}/m_config/json",
+                            json_item.encode('utf-8'), qos=2)
+            
 class HomeAssistantStorageEndpoint(StorageEndpoint):
     """Represents a MQTT endpoint (MQTT) for HomeAssistant."""
     def __init__(self, 

{pqopen_lib-0.8.3 → pqopen_lib-0.8.5}/pqopen/zcd.py

@@ -55,7 +55,7 @@ class ZeroCrossDetector:
         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:
+    def process(self, data: np.ndarray, abs_last_zc: int = None)-> list:
         """
         Processes a block of input data and detect zero-crossings.
 
@@ -117,6 +117,8 @@ class ZeroCrossDetector:
             else:
                 if self._last_zc  and (real_zc <= self._last_zc):
                     logger.warning("Detected ZC before last one, ignoring")
+                elif (abs_last_zc is not None) and (self._last_zc  and (real_zc <= abs_last_zc)):
+                    logger.warning("Detected ZC before last one, ignoring")
                 else:    
                     zero_crossings.append(real_zc + self.filter_delay_samples)
                     last_used_p_idx = p_idx

{pqopen_lib-0.8.3 → pqopen_lib-0.8.5}/pyproject.toml

@@ -12,7 +12,7 @@ packages = ["pqopen"]
 
 [project]
 name = "pqopen-lib"
-version = "0.8.3"
+version = "0.8.5"
 dependencies = [
     "numpy",
     "daqopen-lib >= 0.7.4",

{pqopen_lib-0.8.3 → pqopen_lib-0.8.5}/test/powersystem-test.py

@@ -52,6 +52,12 @@ class TestPowerSystemChannelConfig(unittest.TestCase):
         # Assuming process is to be implemented, we just check its existence
         self.assertTrue(callable(self.power_system.process))
 
+    def test_get_channel_info(self):
+        self.power_system.add_phase(u_channel=self.mock_acq_buffer)
+        self.power_system._update_calc_channels()
+        channel_info = self.power_system.get_channel_info()
+        self.assertTrue(isinstance(channel_info, dict))
+
 class TestPowerPhaseChannelConfig(unittest.TestCase):
     def setUp(self):
         # Mock AcqBuffer
@@ -143,6 +149,22 @@ class TestPowerSystemZcd(unittest.TestCase):
         u_rms, _ = self.power_system.output_channels["U1_1p_rms"].read_data_by_acq_sidx(0, values.size)
         self.assertIsNone(np.testing.assert_array_almost_equal(u_rms[-10:], expected_u_rms[-10:], 3))
 
+    def test_one_period_calc_temp_fallback(self):
+        t = np.linspace(0, 10, int(self.power_system._samplerate)*10, endpoint=False)
+        values = np.sqrt(2)*np.sin(2*np.pi*50*t)
+
+        values[int(self.power_system._samplerate*3):int(self.power_system._samplerate*7)] *= 0
+        
+        expected_u_rms = np.array(np.zeros(48)) + 1.0
+
+        calc_blocksize = 50
+        for i in range(values.size//calc_blocksize):
+            self.u_channel.put_data(values[i*calc_blocksize:(i+1)*calc_blocksize])
+            self.power_system.process()
+        # Check Voltage
+        u_rms, _ = self.power_system.output_channels["U1_1p_rms"].read_data_by_acq_sidx(values.size-self.power_system._samplerate, values.size)
+        self.assertIsNone(np.testing.assert_array_almost_equal(u_rms[-10:], expected_u_rms[-10:], 3))
+
 class TestPowerSystemCalculation(unittest.TestCase):
     def setUp(self):
         self.u_channel = AcqBuffer()