@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/bess-control/lib/batteries.js

@@ -0,0 +1,86 @@
+"use strict";
+
+
+function normalizeBatteries(batteries, batteryCount) {
+
+    const list = Array.isArray(batteries) ? batteries : [];
+
+    const count = Math.max(1, Number(batteryCount || list.length || 1));
+
+    const defaultShare = 100 / count;
+
+    const normalized = [];
+
+
+    for (let index = 0; index < count; index += 1) {
+
+        const battery = list[index] || {};
+
+        const socMin = Number.isFinite(Number(battery.socMin)) ? Number(battery.socMin) : 30;
+        const rawSocHyst = Number.isFinite(Number(battery.socHystPct))
+            ? Number(battery.socHystPct)
+            : (Number.isFinite(Number(battery.socHyst)) ? Number(battery.socHyst) : 5);
+        const socHyst = Math.max(0, rawSocHyst > socMin ? (rawSocHyst - socMin) : rawSocHyst);
+
+        normalized.push({
+
+            index: index,
+
+            id: String(battery.id || ("bat" + (index + 1))).trim(),
+
+            shareChargePct: Number.isFinite(Number(battery.shareChargePct)) ? Number(battery.shareChargePct) : defaultShare,
+
+            shareDischargePct: Number.isFinite(Number(battery.shareDischargePct)) ? Number(battery.shareDischargePct) : defaultShare,
+
+            maxChargeW: Math.max(0, Number(battery.maxChargeW || 150000)),
+
+            maxDischargeW: Math.max(0, Number(battery.maxDischargeW || 150000)),
+
+            socMin: socMin,
+
+            socHyst: socHyst,
+
+            rampUpW: Math.max(0, Number(battery.rampUpW || 1000)),
+
+            rampDownW: Math.max(0, Number(battery.rampDownW || 25000)),
+
+            priorityWeight: Number.isFinite(Number(battery.priorityWeight)) ? Math.max(0, Number(battery.priorityWeight)) : 1
+
+        });
+
+    }
+
+
+    return normalized;
+
+}
+
+
+function distributionIsValid(batteries) {
+
+    const chargeTotal = (Array.isArray(batteries) ? batteries : []).reduce(function (sum, battery) {
+
+        return sum + Number((battery && battery.shareChargePct) || 0);
+
+    }, 0);
+
+
+    const dischargeTotal = (Array.isArray(batteries) ? batteries : []).reduce(function (sum, battery) {
+
+        return sum + Number((battery && battery.shareDischargePct) || 0);
+
+    }, 0);
+
+
+    return Math.abs(chargeTotal - 100) <= 0.01 && Math.abs(dischargeTotal - 100) <= 0.01;
+
+}
+
+
+module.exports = {
+
+    distributionIsValid,
+
+    normalizeBatteries
+
+};

package/bess-control/lib/helpers.js

@@ -0,0 +1,157 @@
+"use strict";
+
+
+function firstFinite() {
+
+    for (let i = 0; i < arguments.length; i += 1) {
+
+        const value = Number(arguments[i]);
+
+        if (Number.isFinite(value)) {
+
+            return value;
+
+        }
+
+    }
+
+    return null;
+
+}
+
+
+function getByPath(source, path) {
+
+    if (!source || !path) return undefined;
+
+
+    return String(path).split(".").reduce(function (acc, key) {
+
+        return acc != null ? acc[key] : undefined;
+
+    }, source);
+
+}
+
+
+function clamp(value, min, max) {
+
+    return Math.min(Math.max(value, min), max);
+
+}
+
+
+function normalizeByConvention(value, signConvention) {
+
+    return Number.isFinite(value)
+
+        ? (signConvention === "positive_export" ? -value : value)
+
+        : value;
+
+}
+
+
+function denormalizeByConvention(value, signConvention) {
+
+    return Number.isFinite(value)
+
+        ? (signConvention === "positive_export" ? -value : value)
+
+        : value;
+
+}
+
+
+function parseBooleanLike(value) {
+
+    if (typeof value === "boolean") return value;
+
+
+    if (typeof value === "number") {
+
+        if (value === 85 || value === 1) return true;
+
+        if (value === 170 || value === 0) return false;
+
+    }
+
+
+    if (typeof value === "string") {
+
+        const normalized = value.trim().toLowerCase();
+
+
+        if (["1", "true", "on", "enable", "enabled", "activ", "active", "auto"].includes(normalized)) {
+
+            return true;
+
+        }
+
+
+        if (["0", "false", "off", "disable", "disabled", "dezactiv", "inactive", "manual"].includes(normalized)) {
+
+            return false;
+
+        }
+
+
+        if (normalized === "85") return true;
+
+        if (normalized === "170") return false;
+
+    }
+
+
+    return null;
+
+}
+
+
+function extractTimestampMs(msg) {
+
+    const ts = firstFinite(
+
+        msg && msg.timestamp_ms,
+
+        msg && msg.timestamp,
+
+        msg && msg.ts,
+
+        msg && msg.time,
+
+        msg && msg.payload && msg.payload.timestamp_ms,
+
+        msg && msg.payload && msg.payload.timestamp,
+
+        msg && msg.payload && msg.payload.ts,
+
+        msg && msg.payload && msg.payload.time
+
+    );
+
+
+    if (ts === null) return Date.now();
+
+    return ts < 1e11 ? Math.round(ts * 1000) : Math.round(ts);
+
+}
+
+
+module.exports = {
+
+    clamp,
+
+    denormalizeByConvention,
+
+    extractTimestampMs,
+
+    firstFinite,
+
+    getByPath,
+
+    normalizeByConvention,
+
+    parseBooleanLike
+
+};

package/bess-control/lib/messages.js

@@ -0,0 +1,131 @@
+"use strict";
+
+
+function isFeedbackMessage(msg) {
+
+    const status = msg && msg.payload && typeof msg.payload === "object" ? msg.payload.status : null;
+
+    return Boolean(status && (msg.topic === "pylontech/write" || msg.topic === "pylontech/error"));
+
+}
+
+
+function extractGridReference(msg, options) {
+
+    if (typeof msg.payload === "number") {
+
+        return Number(msg.payload);
+
+    }
+
+
+    if (typeof msg.payload === "string" && msg.payload.trim() !== "") {
+
+        const direct = Number(msg.payload);
+
+        if (Number.isFinite(direct)) return direct;
+
+    }
+
+
+    const payload = msg.payload;
+
+    if (!payload || typeof payload !== "object") {
+
+        return null;
+
+    }
+
+
+    const byPath = Number(options.getByPath(msg, options.gridPowerPath));
+
+    if (Number.isFinite(byPath)) {
+
+        return byPath;
+
+    }
+
+
+    return options.firstFinite(
+
+        payload.grid_reference_w,
+
+        payload.power_w,
+
+        payload.pcc_power,
+
+        payload.grid_power,
+
+        payload.power,
+
+        payload.value
+
+    );
+
+}
+
+
+function extractBatteryId(msg) {
+
+    return String(
+
+        msg.batteryId !== undefined
+
+            ? msg.batteryId
+
+            : (msg.payload && (msg.payload.batteryId !== undefined ? msg.payload.batteryId : msg.payload.battery_id)) || ""
+
+    ).trim();
+
+}
+
+
+function extractBatteryTelemetry(msg, options) {
+
+    const soc = Number(options.getByPath(msg, options.batterySocPath));
+
+    const externalControlStatus = options.parseBooleanLike(options.getByPath(msg, options.externalControlStatusPath));
+
+    const alarmLevel = options.getByPath(msg, options.alarmLevelPath);
+
+    const operatingStatus = options.getByPath(msg, options.operatingStatusPath);
+
+    const deratingReason = options.getByPath(msg, options.deratingReasonPath);
+
+    const availableChargeW = options.availableChargePath ? Number(options.getByPath(msg, options.availableChargePath)) : null;
+
+    const availableDischargeW = options.availableDischargePath ? Number(options.getByPath(msg, options.availableDischargePath)) : null;
+
+
+    return {
+
+        soc: Number.isFinite(soc) ? soc : null,
+
+        externalControlStatus: externalControlStatus,
+
+        alarmLevel: alarmLevel,
+
+        operatingStatus: operatingStatus,
+
+        deratingReason: deratingReason,
+
+        availableChargeW: Number.isFinite(availableChargeW) ? availableChargeW : null,
+
+        availableDischargeW: Number.isFinite(availableDischargeW) ? availableDischargeW : null
+
+    };
+
+}
+
+
+module.exports = {
+
+    extractBatteryId,
+
+    extractBatteryTelemetry,
+
+    extractGridReference,
+
+    isFeedbackMessage
+
+};

package/bess-control/lib/runtime.js

@@ -0,0 +1,156 @@
+"use strict";
+
+
+function healthFactor(alarmLevel, operatingStatus, deratingReason) {
+
+    let factor = 1;
+
+    const alarm = Number(alarmLevel);
+
+
+    if (Number.isFinite(alarm) && alarm > 0) {
+
+        factor *= Math.max(0.1, 1 - (alarm * 0.2));
+
+    }
+
+
+    if (deratingReason !== undefined && deratingReason !== null && String(deratingReason).trim() !== "" && String(deratingReason) !== "0") {
+
+        factor *= 0.5;
+
+    }
+
+
+    if (
+
+        operatingStatus !== undefined &&
+
+        operatingStatus !== null &&
+
+        ["fault", "error", "offline", "off", "disabled"].includes(String(operatingStatus).trim().toLowerCase())
+
+    ) {
+
+        factor = 0;
+
+    }
+
+
+    return factor;
+
+}
+
+
+function isStale(timestampMs, now, timeoutMs) {
+
+    const timeout = Number(timeoutMs || 0);
+
+    return Boolean(timeout) && (!Number.isFinite(timestampMs) || (now - timestampMs) > timeout);
+
+}
+
+
+function evaluateRuntimeBatteries(batteries, batteryState, options, now) {
+
+    return batteries.map(function (battery) {
+
+        const state = batteryState[battery.id] || {};
+
+        const telemetryStale = isStale(state.ts, now, options.staleTimeoutMs);
+
+        const feedbackStale = !state.writeFeedback || isStale(state.writeFeedback.ts, now, options.feedbackTimeoutMs);
+
+        const writeError = Boolean(state.writeFeedback && state.writeFeedback.status === "error" && !feedbackStale);
+
+        const health = healthFactor(state.alarmLevel, state.operatingStatus, state.deratingReason);
+
+
+        let dischargeAllowed = true;
+
+        if (Number.isFinite(state.soc)) {
+
+            const resumeSoc = Number(battery.socMin || 0) + Math.max(0, Number(battery.socHyst || 0));
+
+            if (state.soc <= battery.socMin) {
+
+                dischargeAllowed = false;
+
+            } else if (state.soc >= resumeSoc) {
+
+                dischargeAllowed = true;
+
+            } else if (state.dischargeAllowed !== undefined) {
+
+                dischargeAllowed = Boolean(state.dischargeAllowed);
+
+            }
+
+            state.dischargeAllowed = dischargeAllowed;
+
+        }
+
+
+        const excludedReasons = [];
+
+        if (!Number.isFinite(state.soc)) excludedReasons.push("missing_soc");
+
+        if (telemetryStale) excludedReasons.push("stale");
+
+        if (writeError) excludedReasons.push("write_error");
+
+        if (health <= 0) excludedReasons.push("health_block");
+
+
+        return {
+
+            config: battery,
+
+            state: state,
+
+            telemetryStale: telemetryStale,
+
+            feedbackStale: feedbackStale,
+
+            writeError: writeError,
+
+            healthFactor: health,
+
+            dischargeAllowed: dischargeAllowed,
+
+            availableChargeW: Math.min(
+
+                battery.maxChargeW,
+
+                Number.isFinite(state.availableChargeW) ? Math.max(0, state.availableChargeW) : battery.maxChargeW
+
+            ),
+
+            availableDischargeW: Math.min(
+
+                battery.maxDischargeW,
+
+                Number.isFinite(state.availableDischargeW) ? Math.max(0, state.availableDischargeW) : battery.maxDischargeW
+
+            ),
+
+            excluded: excludedReasons.length > 0,
+
+            excludedReasons: excludedReasons
+
+        };
+
+    });
+
+}
+
+
+module.exports = {
+
+    evaluateRuntimeBatteries,
+
+    healthFactor,
+
+    isStale
+
+};