pqopen-lib 0.7.2__tar.gz → 0.7.4__tar.gz

{pqopen_lib-0.7.2 → pqopen_lib-0.7.4}/PKG-INFO

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

@@ -493,13 +493,13 @@ class PowerSystem(object):
         if "w_pos" in self._calc_channels["multi_period"]["energy"]:
             prev_w_pos_value = self._calc_channels["multi_period"]["energy"]["w_pos"].last_sample_value
             energy = (stop_sidx - start_sidx)/self._samplerate/3600*p_sum if p_sum > 0 else 0.0 # Energy in Wh
-            self._calc_channels["multi_period"]["energy"]["w_pos"].put_data_single(stop_sidx, prev_w_pos_value + energy)
+            self._calc_channels["multi_period"]["energy"]["w_pos"].put_data_single(stop_sidx, prev_w_pos_value + float(energy))
         
         # Calculate Negative Energy
         if "w_neg" in self._calc_channels["multi_period"]["energy"]:
             prev_w_neg_value = self._calc_channels["multi_period"]["energy"]["w_neg"].last_sample_value
             energy = -(stop_sidx - start_sidx)/self._samplerate/3600*p_sum if p_sum < 0 else 0.0 # Energy in Wh
-            self._calc_channels["multi_period"]["energy"]["w_neg"].put_data_single(stop_sidx, prev_w_neg_value + energy)
+            self._calc_channels["multi_period"]["energy"]["w_neg"].put_data_single(stop_sidx, prev_w_neg_value + float(energy))
 
         # Calculate unbalance (3-phase)
         if "unbal_0" in self._calc_channels["multi_period"]["voltage"]:

{pqopen_lib-0.7.2 → pqopen_lib-0.7.4}/pqopen/storagecontroller.py

@@ -342,6 +342,14 @@ class StorageController(object):
                                                             topic_prefix=ep_config.get("topic_prefix", "pqopen/data"),
                                                             qos=ep_config.get("qos", 0))
                 self._configured_eps["ha_mqtt"] = ha_mqtt_storage_endpoint
+            elif ep_type == "victron_mqtt":
+                victron_mqtt_storage_endpoint = VictronStorageEndpoint(name="victron_mqtt",
+                                                            device_id=device_id, 
+                                                            mqtt_host=ep_config.get("hostname", "localhost"), 
+                                                            client_id=ep_config.get("client_id", "pqopen-victron"),
+                                                            topic_prefix=ep_config.get("topic_prefix", "pqopen/meter"),
+                                                            qos=ep_config.get("qos", 0))
+                self._configured_eps["victron_mqtt"] = victron_mqtt_storage_endpoint
             else:
                 raise NotImplementedError(f"{ep_type:s} not implemented")
         for sp_name, sp_config in storage_plans.items():
@@ -572,7 +580,53 @@ class HomeAssistantStorageEndpoint(StorageEndpoint):
         self._client.publish(self._topic_prefix, json.dumps(data).encode("utf-8"), qos=self._qos)
         logger.debug("Published HA-MQTT Message")
             
-    
+class VictronStorageEndpoint(StorageEndpoint):
+    """Represents a MQTT endpoint (MQTT) for Victron Power Meter Emulation.
+       https://github.com/mr-manuel/venus-os_dbus-mqtt-grid
+    """
+    def __init__(self, 
+                 name: str, 
+                 device_id: str, 
+                 mqtt_host: str, 
+                 client_id: str, 
+                 topic_prefix: str = "pqopen/victron",
+                 qos: int = 0):
+        """ Create an endpoint for Victron via MQTT
+
+        Parameters:
+            name: The name of the endpoint
+            device_id: The device Id
+            mqtt_host: hostname of the MQTT broker.
+            client_id: name to be used for mqtt client identification
+            topic_prefix: topic prefix before device-id, no trailing /
+            qos: mqtt quality of service. valid values 0, 1, 2
+        """
+        super().__init__(name, measurement_id=None)
+        self._device_id = device_id
+        self._topic_prefix = topic_prefix
+        self._qos = qos
+        self._client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=client_id, clean_session=True)
+        self._client.on_connect = self._on_connect
+        self._client.connect_async(host=mqtt_host)
+        self._client.loop_start()
+
+    def _on_connect(self, client, userdata, flags, reason_code, properties):
+            logger.debug("Victron-MQTT Connected")
+
+    def write_aggregated_data(self, data: dict, timestamp_us: int, interval_seconds: int, **kwargs):
+        """ Write an aggregated data message
+
+        Parameters:
+            data: The data object to be sent
+            timestamp_us: Timestamp (in µs) of the data set
+            interval_seconds: Aggregation intervall, used as data tag
+        """
+        if "P" in data:
+            payload = {"grid": {"power": data["P"]}}
+            self._client.publish(self._topic_prefix, json.dumps(payload).encode("utf-8"), qos=self._qos)
+            logger.debug("Published Victron MQTT Message")
+        else:
+            logger.debug("Can't publish Victron MQTT Message, P not found")
 
 class CsvStorageEndpoint(StorageEndpoint):
     """Represents a csv storage endpoint"""

{pqopen_lib-0.7.2 → pqopen_lib-0.7.4}/pyproject.toml

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

{pqopen_lib-0.7.2 → pqopen_lib-0.7.4}/test/powersystem-test.py

@@ -451,6 +451,37 @@ class TestPowerSystemCalculationThreePhase(unittest.TestCase):
         p_neg, sidx = self.power_system.output_channels["P_neg"].read_data_by_acq_sidx(0, u1_values.size)
         self.assertIsNone(np.testing.assert_allclose(p_neg, expected_p_neg, rtol=0.01))
 
+    def test_energy_calc_pos_highoffset(self):
+        t = np.linspace(0, 1, int(self.power_system._samplerate), endpoint=False)
+        u1_values = 1.0*np.sqrt(2)*np.sin(2*np.pi*50*t)
+        u2_values = 1.0*np.sqrt(2)*np.sin(2*np.pi*50*t - 120*np.pi/180)
+        u3_values = 1.0*np.sqrt(2)*np.sin(2*np.pi*50*t + 120*np.pi/180)
+        i1_values = 1.0*np.sqrt(2)*np.sin(2*np.pi*50*t)
+        i2_values = 1.0*np.sqrt(2)*np.sin(2*np.pi*50*t -120*np.pi/180) 
+        i3_values = 1.0*np.sqrt(2)*np.sin(2*np.pi*50*t+ 120*np.pi/180)
+
+        Path(SCRIPT_DIR+"/data_files/energy.json").write_text(json.dumps({"W_pos": 1_000_000.1, "W_neg": 10}))
+
+        expected_w_pos = np.array([1, 2, 3, 4])*3*0.2/3600 + 1_000_000.1
+        expected_w_neg = np.array([1, 2, 3, 4])*0.0/3600 + 10
+
+        self.power_system.enable_energy_channels(Path(SCRIPT_DIR+"/data_files/energy.json"))
+        self.u1_channel.put_data(u1_values)
+        self.u2_channel.put_data(u2_values)
+        self.u3_channel.put_data(u3_values)
+
+        self.i1_channel.put_data(i1_values)
+        self.i2_channel.put_data(i2_values)
+        self.i3_channel.put_data(i3_values)
+
+        self.power_system.process()
+
+        # Check Energy W_pos
+        w_pos, sidx = self.power_system.output_channels["W_pos"].read_data_by_acq_sidx(0, u1_values.size)
+        self.assertIsNone(np.testing.assert_array_almost_equal(w_pos, expected_w_pos))
+        w_neg, sidx = self.power_system.output_channels["W_neg"].read_data_by_acq_sidx(0, u1_values.size)
+        self.assertIsNone(np.testing.assert_array_almost_equal(w_neg, expected_w_neg))
+
 class TestPowerSystemNperSync(unittest.TestCase):
     def setUp(self):
         self.u_channel = AcqBuffer()