@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/fronius-read/lib/sunspec-model-parsers.js

@@ -0,0 +1,845 @@
+function toSigned16(v) {
+
+    return v > 32767 ? v - 65536 : v;
+
+}
+
+
+function round2(v) {
+
+    if (v === null || v === undefined || Number.isNaN(v)) return null;
+
+    return Math.round(v * 100) / 100;
+
+}
+
+
+function scaleValue(raw, sf) {
+
+    if (raw === null || raw === undefined || sf === null || sf === undefined) return null;
+
+    if (sf === -32768) return null;
+
+    return raw * Math.pow(10, sf);
+
+}
+
+
+function decodeSunSpecString(registers) {
+
+    let out = "";
+
+
+    for (const reg of registers) {
+
+        out += String.fromCharCode((reg >> 8) & 0xff);
+
+        out += String.fromCharCode(reg & 0xff);
+
+    }
+
+
+    return out.replace(/\0/g, "").trim();
+
+}
+
+
+function safeGet(arr, idx, def = null) {
+
+    return idx >= 0 && idx < arr.length ? arr[idx] : def;
+
+}
+
+
+function u16ToFloat(regHi, regLo) {
+
+    const buf = Buffer.allocUnsafe(4);
+
+    buf.writeUInt16BE(regHi >>> 0, 0);
+
+    buf.writeUInt16BE(regLo >>> 0, 2);
+
+    return buf.readFloatBE(0);
+
+}
+
+function u32(hi, lo) {
+
+    return (((hi || 0) << 16) | (lo || 0)) >>> 0;
+
+}
+
+
+function readScaledS16(d, index, sf) {
+
+    const raw = safeGet(d, index, null);
+
+    if (raw === null || raw === 0x8000 || raw === 0xFFFF) return null;
+
+    return round2(scaleValue(toSigned16(raw), sf));
+
+}
+
+
+function readScaledU32(d, index, sf) {
+
+    if (index + 1 >= d.length) return null;
+
+    const raw = u32(safeGet(d, index, 0), safeGet(d, index + 1, 0));
+
+    if (raw === 0xFFFFFFFF) return null;
+
+    return round2(scaleValue(raw, sf));
+
+}
+
+
+function readFloat32(d, index) {
+
+    if (index + 1 >= d.length) return null;
+
+    const hi = safeGet(d, index, null);
+
+    const lo = safeGet(d, index + 1, null);
+
+    if (hi === null || lo === null || (hi === 0xFFFF && lo === 0xFFFF)) return null;
+
+    const value = u16ToFloat(hi, lo);
+
+    return Number.isFinite(value) ? round2(value) : null;
+
+}
+
+
+function parseCommon(model) {
+
+    const d = model.raw;
+
+
+    return {
+
+        manufacturer: decodeSunSpecString(d.slice(0, 16)),
+
+        model: decodeSunSpecString(d.slice(16, 32)),
+
+        options: decodeSunSpecString(d.slice(32, 40)),
+
+        version: decodeSunSpecString(d.slice(40, 48)),
+
+        serial: decodeSunSpecString(d.slice(48, 64)),
+
+        device_address: safeGet(d, 64, null)
+
+    };
+
+}
+
+
+function parseInverterInt(model) {
+
+    const d = model.raw;
+
+
+    const A_SF = toSigned16(safeGet(d, 4, 0));
+
+    const V_SF = toSigned16(safeGet(d, 11, 0));
+
+    const W_SF = toSigned16(safeGet(d, 13, 0));
+
+    const HZ_SF = toSigned16(safeGet(d, 15, 0));
+
+    const VA_SF = toSigned16(safeGet(d, 17, 0));
+
+    const VAR_SF = toSigned16(safeGet(d, 19, 0));
+
+
+    return {
+
+        model_id: model.model_id,
+
+
+        current_total_a: round2(scaleValue(safeGet(d, 0, 0), A_SF)),
+
+        current_l1_a: round2(scaleValue(toSigned16(safeGet(d, 1, 0)), A_SF)),
+
+        current_l2_a: round2(scaleValue(toSigned16(safeGet(d, 2, 0)), A_SF)),
+
+        current_l3_a: round2(scaleValue(toSigned16(safeGet(d, 3, 0)), A_SF)),
+
+
+        voltage_ll_ab_v: round2(scaleValue(toSigned16(safeGet(d, 5, 0)), V_SF)),
+
+        voltage_ll_bc_v: round2(scaleValue(toSigned16(safeGet(d, 6, 0)), V_SF)),
+
+        voltage_ll_ca_v: round2(scaleValue(toSigned16(safeGet(d, 7, 0)), V_SF)),
+
+
+        voltage_l1_v: round2(scaleValue(toSigned16(safeGet(d, 8, 0)), V_SF)),
+
+        voltage_l2_v: round2(scaleValue(toSigned16(safeGet(d, 9, 0)), V_SF)),
+
+        voltage_l3_v: round2(scaleValue(toSigned16(safeGet(d, 10, 0)), V_SF)),
+
+
+        power_w: round2(scaleValue(toSigned16(safeGet(d, 12, 0)), W_SF)),
+
+        frequency_hz: round2(scaleValue(toSigned16(safeGet(d, 14, 0)), HZ_SF)),
+
+        apparent_power_va: round2(scaleValue(toSigned16(safeGet(d, 16, 0)), VA_SF)),
+
+        reactive_power_var: round2(scaleValue(toSigned16(safeGet(d, 18, 0)), VAR_SF)),
+
+
+        raw_sf: {
+
+            A_SF,
+
+            V_SF,
+
+            W_SF,
+
+            HZ_SF,
+
+            VA_SF,
+
+            VAR_SF
+
+        }
+
+    };
+
+}
+
+
+function parseInverterFloat(model) {
+
+    const d = model.raw;
+
+
+    function f(idx) {
+
+        if (idx + 1 >= d.length) return null;
+
+        return round2(u16ToFloat(d[idx], d[idx + 1]));
+
+    }
+
+
+    return {
+
+        model_id: model.model_id,
+
+
+        current_total_a: f(0),
+
+        current_l1_a: f(2),
+
+        current_l2_a: f(4),
+
+        current_l3_a: f(6),
+
+
+        voltage_ll_ab_v: f(8),
+
+        voltage_ll_bc_v: f(10),
+
+        voltage_ll_ca_v: f(12),
+
+
+        voltage_l1_v: f(14),
+
+        voltage_l2_v: f(16),
+
+        voltage_l3_v: f(18),
+
+
+        power_w: f(20),
+
+        frequency_hz: f(22),
+
+        apparent_power_va: f(24),
+
+        reactive_power_var: f(26)
+
+    };
+
+}
+
+
+function parseMeterInt(model) {
+
+    const d = model.raw;
+
+    const A_SF = toSigned16(safeGet(d, 4, 0));
+
+    const V_SF = toSigned16(safeGet(d, 13, 0));
+
+    const HZ_SF = toSigned16(safeGet(d, 15, 0));
+
+    const W_SF = toSigned16(safeGet(d, 20, 0));
+
+    const VA_SF = toSigned16(safeGet(d, 25, 0));
+
+    const VAR_SF = toSigned16(safeGet(d, 30, 0));
+
+    const PF_SF = toSigned16(safeGet(d, 35, 0));
+
+    const WH_SF = toSigned16(safeGet(d, 52, 0));
+
+    const VAH_SF = toSigned16(safeGet(d, 69, 0));
+
+    const VARH_SF = toSigned16(safeGet(d, 102, 0));
+
+
+    return {
+
+        model_id: model.model_id,
+
+        meter_model: getMeterModelName(model.model_id),
+
+        current_total_a: readScaledS16(d, 0, A_SF),
+
+        current_l1_a: readScaledS16(d, 1, A_SF),
+
+        current_l2_a: readScaledS16(d, 2, A_SF),
+
+        current_l3_a: readScaledS16(d, 3, A_SF),
+
+        voltage_ln_avg_v: readScaledS16(d, 5, V_SF),
+
+        voltage_l1_v: readScaledS16(d, 6, V_SF),
+
+        voltage_l2_v: readScaledS16(d, 7, V_SF),
+
+        voltage_l3_v: readScaledS16(d, 8, V_SF),
+
+        voltage_ll_avg_v: readScaledS16(d, 9, V_SF),
+
+        voltage_ll_ab_v: readScaledS16(d, 10, V_SF),
+
+        voltage_ll_bc_v: readScaledS16(d, 11, V_SF),
+
+        voltage_ll_ca_v: readScaledS16(d, 12, V_SF),
+
+        frequency_hz: readScaledS16(d, 14, HZ_SF),
+
+        power_w: readScaledS16(d, 16, W_SF),
+
+        power_l1_w: readScaledS16(d, 17, W_SF),
+
+        power_l2_w: readScaledS16(d, 18, W_SF),
+
+        power_l3_w: readScaledS16(d, 19, W_SF),
+
+        apparent_power_va: readScaledS16(d, 21, VA_SF),
+
+        apparent_power_l1_va: readScaledS16(d, 22, VA_SF),
+
+        apparent_power_l2_va: readScaledS16(d, 23, VA_SF),
+
+        apparent_power_l3_va: readScaledS16(d, 24, VA_SF),
+
+        reactive_power_var: readScaledS16(d, 26, VAR_SF),
+
+        reactive_power_l1_var: readScaledS16(d, 27, VAR_SF),
+
+        reactive_power_l2_var: readScaledS16(d, 28, VAR_SF),
+
+        reactive_power_l3_var: readScaledS16(d, 29, VAR_SF),
+
+        power_factor: readScaledS16(d, 31, PF_SF),
+
+        power_factor_l1: readScaledS16(d, 32, PF_SF),
+
+        power_factor_l2: readScaledS16(d, 33, PF_SF),
+
+        power_factor_l3: readScaledS16(d, 34, PF_SF),
+
+        energy_export_wh: readScaledU32(d, 36, WH_SF),
+
+        energy_export_l1_wh: readScaledU32(d, 38, WH_SF),
+
+        energy_export_l2_wh: readScaledU32(d, 40, WH_SF),
+
+        energy_export_l3_wh: readScaledU32(d, 42, WH_SF),
+
+        energy_import_wh: readScaledU32(d, 44, WH_SF),
+
+        energy_import_l1_wh: readScaledU32(d, 46, WH_SF),
+
+        energy_import_l2_wh: readScaledU32(d, 48, WH_SF),
+
+        energy_import_l3_wh: readScaledU32(d, 50, WH_SF),
+
+        apparent_energy_export_vah: readScaledU32(d, 53, VAH_SF),
+
+        apparent_energy_import_vah: readScaledU32(d, 61, VAH_SF),
+
+        reactive_energy_import_q1_varh: readScaledU32(d, 70, VARH_SF),
+
+        reactive_energy_import_q2_varh: readScaledU32(d, 78, VARH_SF),
+
+        reactive_energy_export_q3_varh: readScaledU32(d, 86, VARH_SF),
+
+        reactive_energy_export_q4_varh: readScaledU32(d, 94, VARH_SF),
+
+        event_flags: u32(safeGet(d, 103, 0), safeGet(d, 104, 0)),
+
+        raw_sf: {
+
+            A_SF,
+
+            V_SF,
+
+            HZ_SF,
+
+            W_SF,
+
+            VA_SF,
+
+            VAR_SF,
+
+            PF_SF,
+
+            WH_SF,
+
+            VAH_SF,
+
+            VARH_SF
+
+        }
+
+    };
+
+}
+
+
+function parseMeterFloat(model) {
+
+    const d = model.raw;
+
+    return {
+
+        model_id: model.model_id,
+
+        meter_model: getMeterModelName(model.model_id),
+
+        current_total_a: readFloat32(d, 0),
+
+        current_l1_a: readFloat32(d, 2),
+
+        current_l2_a: readFloat32(d, 4),
+
+        current_l3_a: readFloat32(d, 6),
+
+        voltage_ln_avg_v: readFloat32(d, 8),
+
+        voltage_l1_v: readFloat32(d, 10),
+
+        voltage_l2_v: readFloat32(d, 12),
+
+        voltage_l3_v: readFloat32(d, 14),
+
+        voltage_ll_avg_v: readFloat32(d, 16),
+
+        voltage_ll_ab_v: readFloat32(d, 18),
+
+        voltage_ll_bc_v: readFloat32(d, 20),
+
+        voltage_ll_ca_v: readFloat32(d, 22),
+
+        frequency_hz: readFloat32(d, 24),
+
+        power_w: readFloat32(d, 26),
+
+        power_l1_w: readFloat32(d, 28),
+
+        power_l2_w: readFloat32(d, 30),
+
+        power_l3_w: readFloat32(d, 32),
+
+        apparent_power_va: readFloat32(d, 34),
+
+        apparent_power_l1_va: readFloat32(d, 36),
+
+        apparent_power_l2_va: readFloat32(d, 38),
+
+        apparent_power_l3_va: readFloat32(d, 40),
+
+        reactive_power_var: readFloat32(d, 42),
+
+        reactive_power_l1_var: readFloat32(d, 44),
+
+        reactive_power_l2_var: readFloat32(d, 46),
+
+        reactive_power_l3_var: readFloat32(d, 48),
+
+        power_factor: readFloat32(d, 50),
+
+        power_factor_l1: readFloat32(d, 52),
+
+        power_factor_l2: readFloat32(d, 54),
+
+        power_factor_l3: readFloat32(d, 56),
+
+        energy_export_wh: readFloat32(d, 58),
+
+        energy_export_l1_wh: readFloat32(d, 60),
+
+        energy_export_l2_wh: readFloat32(d, 62),
+
+        energy_export_l3_wh: readFloat32(d, 64),
+
+        energy_import_wh: readFloat32(d, 66),
+
+        energy_import_l1_wh: readFloat32(d, 68),
+
+        energy_import_l2_wh: readFloat32(d, 70),
+
+        energy_import_l3_wh: readFloat32(d, 72),
+
+        apparent_energy_export_vah: readFloat32(d, 74),
+
+        apparent_energy_import_vah: readFloat32(d, 82),
+
+        reactive_energy_import_q1_varh: readFloat32(d, 90),
+
+        reactive_energy_import_q2_varh: readFloat32(d, 98),
+
+        reactive_energy_export_q3_varh: readFloat32(d, 106),
+
+        reactive_energy_export_q4_varh: readFloat32(d, 114),
+
+        event_flags: u32(safeGet(d, 122, 0), safeGet(d, 123, 0))
+
+    };
+
+}
+
+
+function getMeterModelName(modelId) {
+
+    if (modelId === 201 || modelId === 211) return "single_phase";
+
+    if (modelId === 202 || modelId === 212) return "split_phase";
+
+    if (modelId === 203 || modelId === 213) return "three_phase_wye";
+
+    if (modelId === 204 || modelId === 214) return "three_phase_delta";
+
+    return "unknown";
+
+}
+
+
+function parseControlRaw(model) {
+
+    return {
+
+        model_id: model.model_id,
+
+        len: model.len,
+
+        raw: model.raw
+
+    };
+
+}
+
+
+function parseMppt160(model) {
+
+    const d = model.raw;
+
+
+    const DCA_SF = toSigned16(safeGet(d, 0, 0));
+
+    const DCV_SF = toSigned16(safeGet(d, 1, 0));
+
+    const DCW_SF = toSigned16(safeGet(d, 2, 0));
+
+    const DCWH_SF = toSigned16(safeGet(d, 3, 0));
+
+
+    const global_evt =
+
+        ((safeGet(d, 4, 0) << 16) | safeGet(d, 5, 0)) >>> 0;
+
+
+    const moduleCount = safeGet(d, 6, 0);
+
+    const tmsPer = safeGet(d, 7, null);
+
+
+    const blocks = [];
+
+    const blockSize = 20;
+
+    const start = 8;
+
+
+    function notImplU16(v) {
+
+        return v === 0xFFFF;
+
+    }
+
+
+    function notImplS16(v) {
+
+        return v === 0x8000 || v === 0xFFFF;
+
+    }
+
+
+    function u32(hi, lo) {
+
+        return (((hi || 0) << 16) | (lo || 0)) >>> 0;
+
+    }
+
+
+    for (let i = 0; i < moduleCount; i++) {
+
+        const base = start + i * blockSize;
+
+        const block = d.slice(base, base + blockSize);
+
+
+        if (block.length < blockSize) {
+
+            break;
+
+        }
+
+
+        const mpptId = safeGet(block, 0, null);
+
+        const name = decodeSunSpecString(block.slice(1, 9)) || null;
+
+
+        const dcaRaw = safeGet(block, 9, null);
+
+        const dcvRaw = safeGet(block, 10, null);
+
+        const dcwRaw = safeGet(block, 11, null);
+
+
+        const dcwhRaw = u32(safeGet(block, 12, 0), safeGet(block, 13, 0));
+
+        const tmsRaw = u32(safeGet(block, 14, 0), safeGet(block, 15, 0));
+
+
+        const tmpRaw = safeGet(block, 16, null);
+
+        const dcStRaw = safeGet(block, 17, null);
+
+        const dcEvtRaw = u32(safeGet(block, 18, 0), safeGet(block, 19, 0));
+
+
+        const entry = {
+
+            mppt_id: mpptId,
+
+            name: name,
+
+            dc_current_a: notImplU16(dcaRaw) ? null : round2(scaleValue(dcaRaw, DCA_SF)),
+
+            dc_voltage_v: notImplU16(dcvRaw) ? null : round2(scaleValue(dcvRaw, DCV_SF)),
+
+            dc_power_w: notImplU16(dcwRaw) ? null : round2(scaleValue(dcwRaw, DCW_SF)),
+
+            dc_energy_wh: dcwhRaw === 0xFFFFFFFF ? null : round2(scaleValue(dcwhRaw, DCWH_SF)),
+
+            timestamp_s: tmsRaw === 0xFFFFFFFF ? null : tmsRaw,
+
+            temperature_c: notImplS16(tmpRaw) ? null : tmpRaw,
+
+            dc_state: dcStRaw === 0xFFFF ? null : dcStRaw,
+
+            dc_event: dcEvtRaw === 0xFFFFFFFF ? null : dcEvtRaw,
+
+            raw: block
+
+        };
+
+
+        blocks.push(entry);
+
+    }
+
+
+    const dcTotalPower = round2(
+
+        blocks.reduce((sum, b) => sum + (b.dc_power_w || 0), 0)
+
+    );
+
+
+    return {
+
+        model_id: model.model_id,
+
+        module_count: moduleCount,
+
+        tms_per: tmsPer === 0xFFFF ? null : tmsPer,
+
+        global_event: global_evt === 0xFFFFFFFF ? null : global_evt,
+
+        scale_factors: {
+
+            DCA_SF,
+
+            DCV_SF,
+
+            DCW_SF,
+
+            DCWH_SF
+
+        },
+
+        mppts: blocks,
+
+        dc_total_power_w: dcTotalPower
+
+    };
+
+}
+
+
+const MODEL_PARSERS = {
+
+    1: parseCommon,
+
+    101: parseInverterInt,
+
+    102: parseInverterInt,
+
+    103: parseInverterInt,
+
+    111: parseInverterFloat,
+
+    112: parseInverterFloat,
+
+    113: parseInverterFloat,
+
+    120: parseControlRaw,
+
+    121: parseControlRaw,
+
+    122: parseControlRaw,
+
+    123: parseControlRaw,
+
+    160: parseMppt160,
+
+    201: parseMeterInt,
+
+    202: parseMeterInt,
+
+    203: parseMeterInt,
+
+    204: parseMeterInt,
+
+    211: parseMeterFloat,
+
+    212: parseMeterFloat,
+
+    213: parseMeterFloat,
+
+    214: parseMeterFloat
+
+};
+
+
+function buildSummary(models) {
+
+    const summary = {
+
+        common: null,
+
+        ac: null,
+
+        dc: null,
+
+        meter: null,
+
+        controls: [],
+
+        unknown_models: []
+
+    };
+
+
+    for (const model of models) {
+
+        const parser = MODEL_PARSERS[model.model_id];
+
+
+        if (!parser) {
+
+            summary.unknown_models.push({
+
+                model_id: model.model_id,
+
+                addr: model.addr,
+
+                len: model.len
+
+            });
+
+            continue;
+
+        }
+
+
+        const parsed = parser(model);
+
+
+        if (model.model_id === 1) {
+
+            summary.common = parsed;
+
+        } else if ([101, 102, 103, 111, 112, 113].includes(model.model_id)) {
+
+            summary.ac = parsed;
+
+        } else if ([120, 121, 122, 123].includes(model.model_id)) {
+
+            summary.controls.push(parsed);
+
+        } else if (model.model_id === 160) {
+
+            summary.dc = parsed;
+
+        } else if ([201, 202, 203, 204, 211, 212, 213, 214].includes(model.model_id)) {
+
+            summary.meter = parsed;
+
+        }
+
+    }
+
+
+    return summary;
+
+}
+
+
+module.exports = {
+
+    MODEL_PARSERS,
+
+    buildSummary,
+
+    toSigned16,
+
+    round2,
+
+    scaleValue,
+
+    decodeSunSpecString,
+
+    safeGet
+
+};