@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/fronius-emulator/lib/virtual-meter.js

@@ -0,0 +1,132 @@
+"use strict";
+
+const METER_ROLES = Object.freeze(["grid", "pv", "battery"]);
+
+function normalizeMeterRole(value) {
+    return METER_ROLES.includes(value) ? value : "grid";
+}
+
+function finitePositive(value) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) && numeric > 0 ? numeric : null;
+}
+
+function gridReferenceFromSnapshot(snapshot) {
+    const source = snapshot && snapshot.measurements;
+    if (!source || !snapshot.lastUpdate || snapshot.stale) return null;
+    const voltageL1 = finitePositive(source.voltageL1);
+    const voltageL2 = finitePositive(source.voltageL2);
+    const voltageL3 = finitePositive(source.voltageL3);
+    const frequency = finitePositive(source.frequency);
+    if (voltageL1 === null || voltageL2 === null || voltageL3 === null || frequency === null) return null;
+    return {
+        voltageL1,
+        voltageL2,
+        voltageL3,
+        frequency,
+        timestamp: snapshot.lastUpdate
+    };
+}
+
+function deriveSecondaryMeasurements(role, sourcePower, gridReference, invertSourceSign) {
+    const meterRole = normalizeMeterRole(role);
+    if (meterRole === "grid") throw new Error("secondary meter role must be pv or battery");
+    let source = Number(sourcePower);
+    if (!Number.isFinite(source)) throw new RangeError("global power must be a finite number");
+    if (!gridReference) throw new Error("Grid Meter Unit ID 1 reference is not available");
+    if (invertSourceSign) source = -source;
+
+    // Composite mode exposes the context value without an implicit sign change:
+    // PV production stays positive; battery charge is positive and discharge negative.
+    const power = source;
+    const phasePower = power / 3;
+    const voltageL1 = finitePositive(gridReference.voltageL1);
+    const voltageL2 = finitePositive(gridReference.voltageL2);
+    const voltageL3 = finitePositive(gridReference.voltageL3);
+    const frequency = finitePositive(gridReference.frequency);
+    if (voltageL1 === null || voltageL2 === null || voltageL3 === null || frequency === null) {
+        throw new Error("Grid Meter Unit ID 1 reference contains invalid voltage or frequency");
+    }
+
+    return {
+        power,
+        powerL1: phasePower,
+        powerL2: phasePower,
+        powerL3: phasePower,
+        voltageL1,
+        voltageL2,
+        voltageL3,
+        currentL1: Math.abs(phasePower) / voltageL1,
+        currentL2: Math.abs(phasePower) / voltageL2,
+        currentL3: Math.abs(phasePower) / voltageL3,
+        frequency,
+        reactivePower: 0,
+        reactivePowerL1: 0,
+        reactivePowerL2: 0,
+        reactivePowerL3: 0,
+        apparentPower: Math.abs(power),
+        apparentPowerL1: Math.abs(phasePower),
+        apparentPowerL2: Math.abs(phasePower),
+        apparentPowerL3: Math.abs(phasePower),
+        powerFactor: 1,
+        powerFactorL1: 1,
+        powerFactorL2: 1,
+        powerFactorL3: 1
+    };
+}
+
+function normalizedEnergyState(value) {
+    const source = value && typeof value === "object" ? value : {};
+    return {
+        importEnergy: Number.isFinite(Number(source.importEnergy)) && Number(source.importEnergy) >= 0 ? Number(source.importEnergy) : 0,
+        exportEnergy: Number.isFinite(Number(source.exportEnergy)) && Number(source.exportEnergy) >= 0 ? Number(source.exportEnergy) : 0,
+        lastTimestampMs: Number.isFinite(Number(source.lastTimestampMs)) ? Number(source.lastTimestampMs) : null,
+        lastPower: Number.isFinite(Number(source.lastPower)) ? Number(source.lastPower) : null
+    };
+}
+
+function integrateDirectionalEnergy(previous, power, timestampMs, maxGapMs) {
+    const state = normalizedEnergyState(previous);
+    const currentPower = Number(power);
+    const now = Number(timestampMs);
+    const maximumGap = Number(maxGapMs);
+    if (!Number.isFinite(currentPower) || !Number.isFinite(now)) throw new RangeError("power and timestamp must be finite");
+
+    if (state.lastTimestampMs !== null && state.lastPower !== null) {
+        const elapsedMs = now - state.lastTimestampMs;
+        if (elapsedMs > 0 && (!Number.isFinite(maximumGap) || maximumGap <= 0 || elapsedMs <= maximumGap)) {
+            const elapsedHours = elapsedMs / 3600000;
+            const previousPower = state.lastPower;
+            if (previousPower >= 0 && currentPower >= 0) {
+                state.importEnergy += ((previousPower + currentPower) / 2) * elapsedHours;
+            } else if (previousPower <= 0 && currentPower <= 0) {
+                state.exportEnergy += ((Math.abs(previousPower) + Math.abs(currentPower)) / 2) * elapsedHours;
+            } else {
+                const totalMagnitude = Math.abs(previousPower) + Math.abs(currentPower);
+                const crossingFraction = totalMagnitude > 0 ? Math.abs(previousPower) / totalMagnitude : 0;
+                const firstHours = elapsedHours * crossingFraction;
+                const secondHours = elapsedHours - firstHours;
+                if (previousPower > 0) {
+                    state.importEnergy += previousPower * firstHours / 2;
+                    state.exportEnergy += Math.abs(currentPower) * secondHours / 2;
+                } else {
+                    state.exportEnergy += Math.abs(previousPower) * firstHours / 2;
+                    state.importEnergy += currentPower * secondHours / 2;
+                }
+            }
+        }
+    }
+
+    state.lastTimestampMs = now;
+    state.lastPower = currentPower;
+    return state;
+}
+
+module.exports = {
+    METER_ROLES,
+    normalizeMeterRole,
+    gridReferenceFromSnapshot,
+    deriveSecondaryMeasurements,
+    normalizedEnergyState,
+    integrateDirectionalEnergy
+};