@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/janitza/lib/janitza-profiles.js

@@ -0,0 +1,371 @@
+
+"use strict";
+
+
+const DEFAULT_PROFILE_ID = "umg604pro";
+
+
+const UMG604_PRO = {
+
+    id: "umg604pro",
+
+    label: "UMG 604 Pro",
+
+    deviceName: "Janitza UMG 604 Pro",
+
+    startAddress: 19000,
+
+    registerCount: 122,
+
+    extendedRegisterFields: {
+
+        "summary.power_quality.k_factor.l1": { address: 1309, type: "float" },
+
+        "summary.power_quality.k_factor.l2": { address: 1311, type: "float" },
+
+        "summary.power_quality.k_factor.l3": { address: 1313, type: "float" },
+
+        "summary.power_quality.k_factor.l4": { address: 1315, type: "float" },
+
+        "summary.extended.voltage.l4_n_v": { address: 1323, type: "float" },
+
+        "summary.extended.current.l4_a": { address: 1331, type: "float" },
+
+        "summary.extended.power.l4_w": { address: 1339, type: "float" },
+
+        "summary.extended.reactive.l4_var": { address: 1347, type: "float" },
+
+        "summary.extended.apparent.l4_va": { address: 1355, type: "float" },
+
+        "summary.extended.current.sum_l1_l4_a": { address: 1365, type: "float" },
+
+        "summary.extended.apparent.total_l1_l4_va": { address: 1375, type: "float" },
+
+        "summary.extended.power.total_l1_l4_w": { address: 1377, type: "float" },
+
+        "summary.extended.reactive.total_l1_l4_var": { address: 1379, type: "float" },
+
+        "summary.extended.power_factor.total_l1_l4": { address: 1381, type: "float" },
+
+        "summary.power_quality.voltage.avg_l_n_v": { address: 19630, type: "float" },
+
+        "summary.power_quality.voltage.avg_l_l_v": { address: 19632, type: "float" },
+
+        "summary.power_quality.current.avg_a": { address: 19634, type: "float" },
+
+        "summary.power_quality.power_factor.avg": { address: 19636, type: "float" },
+
+        "summary.power_quality.current.tdd_l1_pct": { address: 19638, type: "float" },
+
+        "summary.power_quality.current.tdd_l2_pct": { address: 19640, type: "float" },
+
+        "summary.power_quality.current.tdd_l3_pct": { address: 19642, type: "float" },
+
+        "summary.power_quality.current.tdd_l4_pct": { address: 19644, type: "float" },
+
+        "summary.power_quality.current.unsymmetry_pct": { address: 19646, type: "float" },
+
+        "summary.power_quality.crest_factor.voltage_l1": { address: 19648, type: "float" },
+
+        "summary.power_quality.crest_factor.voltage_l2": { address: 19650, type: "float" },
+
+        "summary.power_quality.crest_factor.voltage_l3": { address: 19652, type: "float" },
+
+        "summary.power_quality.crest_factor.current_l1": { address: 19660, type: "float" },
+
+        "summary.power_quality.crest_factor.current_l2": { address: 19662, type: "float" },
+
+        "summary.power_quality.crest_factor.current_l3": { address: 19664, type: "float" },
+
+        "summary.power_quality.distortion_reactive.l1_var": { address: 19668, type: "float" },
+
+        "summary.power_quality.distortion_reactive.l2_var": { address: 19670, type: "float" },
+
+        "summary.power_quality.distortion_reactive.l3_var": { address: 19672, type: "float" },
+
+        "summary.max.voltage.l1_n_v": { address: 4509, type: "float" },
+
+        "summary.max.voltage.l2_n_v": { address: 4511, type: "float" },
+
+        "summary.max.voltage.l3_n_v": { address: 4513, type: "float" },
+
+        "summary.max.current.l1_a": { address: 4517, type: "float" },
+
+        "summary.max.current.l2_a": { address: 4519, type: "float" },
+
+        "summary.max.current.l3_a": { address: 4521, type: "float" },
+
+        "summary.max.power.total_w": { address: 4561, type: "float" },
+
+        "summary.max.reactive.total_var": { address: 4563, type: "float" },
+
+        "summary.max.frequency_hz": { address: 4571, type: "float" },
+
+        "summary.energy.tariff.active": { address: 9805, type: "short" },
+
+        "summary.energy.tariff.reactive": { address: 9806, type: "short" },
+
+        "summary.energy.detail.apparent_l1_kvah": { address: 9807, type: "float", scale: 0.001 },
+
+        "summary.energy.detail.apparent_l2_kvah": { address: 9809, type: "float", scale: 0.001 },
+
+        "summary.energy.detail.apparent_l3_kvah": { address: 9811, type: "float", scale: 0.001 },
+
+        "summary.energy.detail.active_l1_kwh": { address: 9819, type: "float", scale: 0.001 },
+
+        "summary.energy.detail.active_l2_kwh": { address: 9821, type: "float", scale: 0.001 },
+
+        "summary.energy.detail.active_l3_kwh": { address: 9823, type: "float", scale: 0.001 },
+
+        "summary.energy.detail.active_total_kwh": { address: 9827, type: "float", scale: 0.001 },
+
+        "summary.energy.detail.consumed_total_kwh": { address: 9851, type: "float", scale: 0.001 },
+
+        "summary.energy.detail.supplied_total_kwh": { address: 9863, type: "float", scale: 0.001 },
+
+        "summary.energy.detail.reactive_inductive_total_kvarh": { address: 9923, type: "float", scale: 0.001 },
+
+        "summary.energy.detail.reactive_capacitive_total_kvarh": { address: 9935, type: "float", scale: 0.001 },
+
+        "summary.digital_inputs.pulse_counter_1": { address: 9963, type: "float" },
+
+        "summary.digital_inputs.pulse_counter_2": { address: 9965, type: "float" },
+
+        "summary.device.current_transformer.primary_l1_a": { address: 10032, type: "float" },
+
+        "summary.device.current_transformer.primary_l2_a": { address: 10034, type: "float" },
+
+        "summary.device.current_transformer.primary_l3_a": { address: 10036, type: "float" },
+
+        "summary.device.current_transformer.secondary_l1_a": { address: 10040, type: "float" },
+
+        "summary.device.voltage_transformer.primary_l1_v": { address: 10048, type: "float" },
+
+        "summary.device.voltage_transformer.secondary_l1_v": { address: 10056, type: "float" },
+
+        "summary.device.serial_number": { address: 10176, type: "uint" },
+
+        "summary.device.production_number": { address: 10178, type: "uint" },
+
+        "summary.device.modbus_address": { address: 10180, type: "int" },
+
+        "summary.device.ip_address": { address: 10190, type: "ip" },
+
+        "summary.device.ip_mask": { address: 10192, type: "ip" },
+
+        "summary.device.ip_gateway": { address: 10194, type: "ip" },
+
+        "summary.device.temperature_sensor_type": { address: 10200, type: "int" },
+
+        "summary.events.current_threshold_l1_pct": { address: 10268, type: "float" },
+
+        "summary.events.voltage_max_l1_pct": { address: 10276, type: "float" },
+
+        "summary.events.voltage_min_l1_pct": { address: 10284, type: "float" },
+
+        "summary.digital_outputs.event_mask_1": { address: 10426, type: "int" },
+
+        "summary.digital_outputs.event_mask_2": { address: 10428, type: "int" },
+
+        "summary.temperature.offset_c": { address: 12411, type: "float" },
+
+        "summary.quick.frequency_hz": { address: 14131, type: "float" },
+
+        "summary.quick.voltage.l1_n_v": { address: 14133, type: "float" },
+
+        "summary.quick.voltage.l2_n_v": { address: 14135, type: "float" },
+
+        "summary.quick.voltage.l3_n_v": { address: 14137, type: "float" },
+
+        "summary.quick.current.l1_a": { address: 14141, type: "float" },
+
+        "summary.quick.current.l2_a": { address: 14143, type: "float" },
+
+        "summary.quick.current.l3_a": { address: 14145, type: "float" },
+
+        "summary.quick.power.l1_w": { address: 14149, type: "float" },
+
+        "summary.quick.power.l2_w": { address: 14151, type: "float" },
+
+        "summary.quick.power.l3_w": { address: 14153, type: "float" },
+
+        "summary.quick.reactive.l1_var": { address: 14157, type: "float" },
+
+        "summary.quick.reactive.l2_var": { address: 14159, type: "float" },
+
+        "summary.quick.reactive.l3_var": { address: 14161, type: "float" }
+
+    }
+
+};
+
+
+const PROFILES = {
+
+    [UMG604_PRO.id]: UMG604_PRO
+
+};
+
+
+function getProfile(model) {
+
+    return PROFILES[model] || PROFILES[DEFAULT_PROFILE_ID];
+
+}
+
+
+function getRegisterSize(type) {
+
+    if (type === "float" || type === "int" || type === "uint" || type === "ip") {
+
+        return 2;
+
+    }
+
+    return 1;
+
+}
+
+
+function readValueFromRegisterData(data, blockStartAddress, definition) {
+
+    const offset = (definition.address - blockStartAddress) * 2;
+
+    let value;
+
+
+    if (definition.type === "float") {
+
+        value = data.readFloatBE(offset);
+
+    } else if (definition.type === "uint" || definition.type === "ip") {
+
+        value = data.readUInt32BE(offset);
+
+    } else if (definition.type === "int") {
+
+        value = data.readInt32BE(offset);
+
+    } else if (definition.type === "short") {
+
+        value = data.readInt16BE(offset);
+
+    } else {
+
+        value = data.readUInt16BE(offset);
+
+    }
+
+
+    if (definition.type === "ip") {
+
+        return [
+
+            (value >>> 24) & 255,
+
+            (value >>> 16) & 255,
+
+            (value >>> 8) & 255,
+
+            value & 255
+
+        ].join(".");
+
+    }
+
+
+    if (definition.scale) {
+
+        return value * definition.scale;
+
+    }
+
+
+    return value;
+
+}
+
+
+function buildExtendedReadRanges(fields, profile, normalizeFields) {
+
+    const extendedFields = profile.extendedRegisterFields || {};
+
+    const definitions = normalizeFields(fields, true)
+
+        .filter(function (field) { return !!extendedFields[field]; })
+
+        .map(function (field) {
+
+            const definition = extendedFields[field];
+
+            return {
+
+                field: field,
+
+                address: definition.address,
+
+                end: definition.address + getRegisterSize(definition.type),
+
+                definition: definition
+
+            };
+
+        })
+
+        .sort(function (a, b) { return a.address - b.address; });
+
+
+    const ranges = [];
+
+
+    definitions.forEach(function (item) {
+
+        let range = ranges.length ? ranges[ranges.length - 1] : null;
+
+        if (!range || item.end - range.start > 120) {
+
+            range = {
+
+                start: item.address,
+
+                end: item.end,
+
+                items: []
+
+            };
+
+            ranges.push(range);
+
+        }
+
+        range.end = Math.max(range.end, item.end);
+
+        range.items.push(item);
+
+    });
+
+
+    return ranges.map(function (range) {
+
+        range.count = range.end - range.start;
+
+        return range;
+
+    });
+
+}
+
+
+module.exports = {
+
+    DEFAULT_PROFILE_ID,
+
+    PROFILES,
+
+    getProfile,
+
+    buildExtendedReadRanges,
+
+    readValueFromRegisterData
+
+};

package/lib/a3-test-server.js

@@ -0,0 +1,199 @@
+"use strict";
+
+const RAMP_TYPE_BY_CODE = {
+    0: "none",
+    1: "time",
+    2: "gradient_pct",
+    3: "gradient_w"
+};
+
+const RAMP_CODE_BY_TYPE = {
+    none: 0,
+    time: 1,
+    gradient_pct: 2,
+    gradient_w: 3
+};
+
+function clamp(value, min, max) {
+    if (!Number.isFinite(value)) return min;
+    return Math.min(Math.max(value, min), max);
+}
+
+function toSigned16(word) {
+    const n = Number(word) & 0xFFFF;
+    return n > 0x7FFF ? n - 0x10000 : n;
+}
+
+function toSigned32(high, low) {
+    const unsigned = (((Number(high) & 0xFFFF) * 0x10000) + (Number(low) & 0xFFFF)) >>> 0;
+    return unsigned > 0x7FFFFFFF ? unsigned - 0x100000000 : unsigned;
+}
+
+function fromSigned32(value) {
+    const n = Math.round(Number(value) || 0);
+    const unsigned = n < 0 ? (0x100000000 + n) : n;
+    return [
+        (unsigned >>> 16) & 0xFFFF,
+        unsigned & 0xFFFF
+    ];
+}
+
+function normalizeAddress(address) {
+    const n = Number(address);
+    if (!Number.isFinite(n)) return -1;
+    if (n >= 40001) return n - 40001;
+    return n;
+}
+
+function normalizeRampType(value) {
+    if (typeof value === "number") {
+        return RAMP_TYPE_BY_CODE[value] || "none";
+    }
+
+    const key = String(value || "").trim().toLowerCase();
+    if (key === "gradient_watts" || key === "gradient_vars" || key === "gradient_var") {
+        return "gradient_w";
+    }
+
+    return RAMP_CODE_BY_TYPE[key] !== undefined ? key : "none";
+}
+
+function createA3TestServer(options) {
+    const { createModbusServer } = require("../scada-server/lib/modbus-server");
+    const opts = options || {};
+    const minNominal = Number.isFinite(opts.minNominal) ? opts.minNominal : 0;
+    const maxNominal = Number.isFinite(opts.maxNominal) ? opts.maxNominal : 125000;
+    const host = String(opts.host || "0.0.0.0").trim() || "0.0.0.0";
+    const port = Math.max(1, Math.round(Number(opts.port) || 1502));
+    const unitId = Math.max(0, Math.round(Number(opts.unitId) || 1));
+    const state = {
+        nominalPower: clamp(Math.round(Number(opts.nominalPower) || 0), minNominal, maxNominal),
+        rampType: normalizeRampType(opts.rampType || "none"),
+        rampValue: Math.max(0, Math.round(Number(opts.rampValue) || 0)),
+        sequence: 0,
+        lastWriteTimestampMs: 0
+    };
+
+    function getRegister(address) {
+        const nominalWords = fromSigned32(state.nominalPower);
+        const rampWords = fromSigned32(state.rampValue);
+
+        switch (address) {
+        case 0:
+            return 1;
+        case 1:
+            return 1;
+        case 2:
+            return nominalWords[0];
+        case 3:
+            return nominalWords[1];
+        case 4:
+            return RAMP_CODE_BY_TYPE[state.rampType] || 0;
+        case 5:
+            return rampWords[0];
+        case 6:
+            return rampWords[1];
+        case 7:
+            return state.sequence & 0xFFFF;
+        case 8:
+            return Math.floor((state.lastWriteTimestampMs || 0) / 1000) & 0xFFFF;
+        default:
+            return null;
+        }
+    }
+
+    function applyWritableRegisters(registers) {
+        if (registers[2] !== undefined || registers[3] !== undefined) {
+            const high = registers[2] !== undefined ? registers[2] : getRegister(2);
+            const low = registers[3] !== undefined ? registers[3] : getRegister(3);
+            state.nominalPower = clamp(toSigned32(high, low), minNominal, maxNominal);
+        }
+
+        if (registers[4] !== undefined) {
+            state.rampType = normalizeRampType(Number(registers[4]));
+        }
+
+        if (registers[5] !== undefined || registers[6] !== undefined) {
+            const high = registers[5] !== undefined ? registers[5] : getRegister(5);
+            const low = registers[6] !== undefined ? registers[6] : getRegister(6);
+            state.rampValue = Math.max(0, toSigned32(high, low));
+        }
+
+        state.sequence = (state.sequence + 1) & 0xFFFF;
+        state.lastWriteTimestampMs = Date.now();
+
+        if (typeof opts.onCommand === "function") {
+            opts.onCommand(getCommand());
+        }
+    }
+
+    function writeRegisters(startAddress, values) {
+        const start = normalizeAddress(startAddress);
+        if (start < 2 || start > 6 || (start + values.length - 1) > 6) {
+            return { exceptionCode: 2, issueCode: "a3_illegal_write_address" };
+        }
+
+        const registers = {};
+        values.forEach(function (value, index) {
+            registers[start + index] = Number(value) & 0xFFFF;
+        });
+        applyWritableRegisters(registers);
+        return { ok: true };
+    }
+
+    function getCommand() {
+        return {
+            nominalPower: state.nominalPower,
+            rampType: state.rampType,
+            rampValue: state.rampValue,
+            sequence: state.sequence,
+            timestampMs: state.lastWriteTimestampMs || Date.now()
+        };
+    }
+
+    const server = createModbusServer({
+        host: host,
+        port: port,
+        unitId: unitId,
+        readHoldingRegisters: function (startAddress, quantity) {
+            const start = normalizeAddress(startAddress);
+            const words = [];
+
+            for (let i = 0; i < quantity; i++) {
+                const word = getRegister(start + i);
+                if (word === null) {
+                    return { exceptionCode: 2, issueCode: "a3_illegal_read_address" };
+                }
+                words.push(word);
+            }
+
+            return words;
+        },
+        writeSingleRegister: function (address, value) {
+            return writeRegisters(address, [value]);
+        },
+        writeHoldingRegisters: writeRegisters,
+        onError: opts.onError,
+        onProtocolIssue: opts.onProtocolIssue,
+        onClientChange: opts.onClientChange,
+        onWrite: opts.onWrite
+    });
+
+    return {
+        start: server.start,
+        stop: server.stop,
+        address: server.address,
+        getCommand: getCommand,
+        getState: function () {
+            return Object.assign({}, state);
+        }
+    };
+}
+
+module.exports = {
+    createA3TestServer,
+    normalizeRampType,
+    toSigned16,
+    toSigned32,
+    fromSigned32
+};