@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/fronius-read/lib/sunspec-core.js

@@ -0,0 +1,303 @@
+const ModbusRTU = require("modbus-serial");
+
+
+const {
+
+    buildSummary
+
+} = require("./sunspec-model-parsers");
+
+
+const {
+
+    detectInverterProfile
+
+} = require("./inverter-profiles");
+
+
+async function connectClient(client, host, port, unitId) {
+
+    if (!client.isOpen) {
+
+        await client.connectTCP(host, { port: Number(port || 502) });
+
+        client.setID(Number(unitId || 1));
+
+        client.setTimeout(2500);
+
+        return;
+
+    }
+
+
+    client.setID(Number(unitId || 1));
+
+    client.setTimeout(2500);
+
+}
+
+
+async function createConnectedClient(host, port, unitId) {
+
+    const client = new ModbusRTU();
+
+    await connectClient(client, host, port, unitId);
+
+    return client;
+
+}
+
+
+async function closeClient(client) {
+
+    try {
+
+        if (client && client.isOpen) {
+
+            await client.close();
+
+        }
+
+    } catch (e) {
+
+        // ignore
+
+    }
+
+}
+
+
+async function readHolding(client, addr, len) {
+
+    return client.readHoldingRegisters(addr, len);
+
+}
+
+
+async function readModelHeader(client, addr) {
+
+    const r = await readHolding(client, addr, 2);
+
+    return { id: r.data[0], len: r.data[1] };
+
+}
+
+
+async function findBase(client) {
+
+    const bases = [39999, 40000, 40001, 40002, 40199, 40200, 40201, 40202];
+
+
+    for (const b of bases) {
+
+        try {
+
+            const r = await readHolding(client, b, 2);
+
+
+            const txt =
+
+                String.fromCharCode((r.data[0] >> 8) & 0xff) +
+
+                String.fromCharCode(r.data[0] & 0xff) +
+
+                String.fromCharCode((r.data[1] >> 8) & 0xff) +
+
+                String.fromCharCode(r.data[1] & 0xff);
+
+
+            if (txt.includes("SunS")) {
+
+                return b;
+
+            }
+
+        } catch (e) {
+
+            // ignore
+
+        }
+
+    }
+
+
+    throw new Error("SunSpec not found");
+
+}
+
+
+async function scanModelDescriptors(client, base) {
+
+    const descriptors = [];
+
+    let addr = base + 2;
+
+
+    while (true) {
+
+        const header = await readModelHeader(client, addr);
+
+
+        if (header.id === 0xFFFF) {
+
+            break;
+
+        }
+
+
+        descriptors.push({
+
+            model_id: header.id,
+
+            addr: addr,
+
+            len: header.len
+
+        });
+
+
+        addr += 2 + header.len;
+
+    }
+
+
+    return descriptors;
+
+}
+
+
+async function readModelByDescriptor(client, descriptor) {
+
+    const payloadRes = await readHolding(client, descriptor.addr + 2, descriptor.len);
+
+
+    return {
+
+        model_id: descriptor.model_id,
+
+        addr: descriptor.addr,
+
+        len: descriptor.len,
+
+        raw: payloadRes.data
+
+    };
+
+}
+
+
+async function readModelsByDescriptors(client, descriptors) {
+
+    const models = [];
+
+
+    for (const descriptor of descriptors) {
+
+        models.push(await readModelByDescriptor(client, descriptor));
+
+    }
+
+
+    return models;
+
+}
+
+
+async function scanModels(client, base) {
+
+    const descriptors = await scanModelDescriptors(client, base);
+
+    return readModelsByDescriptors(client, descriptors);
+
+}
+
+
+async function probeInverterProfile(host, port, unitId) {
+
+    const client = await createConnectedClient(host, port, unitId);
+
+
+    try {
+
+        const base = await findBase(client);
+
+        const models = await scanModels(client, base);
+
+        const summary = buildSummary(models);
+
+        const detection = detectInverterProfile(summary);
+        const deviceType = summary && summary.meter
+            ? "smart_meter"
+            : (summary && (summary.ac || summary.dc) ? "inverter" : "unknown");
+
+
+        return {
+
+            ok: true,
+
+            base: base,
+
+            device_type: deviceType,
+
+            manufacturer: summary && summary.common ? summary.common.manufacturer : null,
+
+            model: summary && summary.common ? summary.common.model : null,
+
+            options: summary && summary.common ? summary.common.options : null,
+
+            inverter_profile: detection.profile_key,
+
+            inverter_profile_label: detection.profile_label,
+
+            manufacturer_key: detection.manufacturer,
+
+            family: detection.family,
+
+            phase_mode: detection.phase_mode,
+
+            mppt_count: detection.mppt_count,
+
+            meter_model: summary && summary.meter ? summary.meter.meter_model : null,
+
+            meter_model_id: summary && summary.meter ? summary.meter.model_id : null,
+
+            detection_source: detection.detection_source
+
+        };
+
+    } finally {
+
+        await closeClient(client);
+
+    }
+
+}
+
+
+module.exports = {
+
+    ModbusRTU,
+
+    connectClient,
+
+    createConnectedClient,
+
+    closeClient,
+
+    readHolding,
+
+    readModelHeader,
+
+    findBase,
+
+    scanModelDescriptors,
+
+    readModelByDescriptor,
+
+    readModelsByDescriptors,
+
+    scanModels,
+
+    probeInverterProfile
+
+};