@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "@atelieruldetehnologii/node-red-custome-solutions",
+  "version": "0.62.22",
+  "description": "Proprietary Node-RED nodes developed by Atelierul de Tehnologii for energy, Modbus, BESS, MQTT, SCADA and industrial integrations",
+  "private": false,
+  "license": "SEE LICENSE IN PROPRIETARY-LICENSE.txt",
+  "keywords": [
+    "node-red",
+    "node-red-node",
+    "modbus",
+    "mqtt",
+    "energy",
+    "bess",
+    "photovoltaic",
+    "scada"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "advantech-read/**/*",
+    "advantech-write/**/*",
+    "bess-control/**/*",
+    "carlo-gavazzi/**/*",
+    "control-export/**/*",
+    "control-reactive/**/*",
+    "fronius-emulator/**/*",
+    "fronius-read/**/*",
+    "fronius-write/**/*",
+    "influxdb/**/*",
+    "janitza/**/*",
+    "lib/**/*",
+    "license/**/*",
+    "modbus-tcp-discover/**/*",
+    "multi-battery/**/*",
+    "multi-grid/**/*",
+    "multi-inverter/**/*",
+    "phoenix-contact/**/*",
+    "pv-generator/**/*",
+    "pylontech-read/**/*",
+    "pylontech-write/**/*",
+    "scada-aggregator/**/*",
+    "scada-server/**/*",
+    "scripts/**/*",
+    "sma-read/**/*",
+    "sma-write/**/*",
+    "victron-read/**/*",
+    "README.md",
+    "PROPRIETARY-LICENSE.txt",
+    "TERMS-AND-CONDITIONS.md",
+    "NOTICE",
+    "package.json"
+  ],
+  "dependencies": {
+    "modbus-serial": "^8.0.25",
+    "mqtt": "^5.10.4"
+  },
+  "node-red": {
+    "version": ">=3.1.1",
+    "nodes": {
+      "atelier-license": "license/atelier-license.js",
+      "fronius-read": "fronius-read/fronius-read.js",
+      "sma-read": "sma-read/sma-read.js",
+      "fronius-write": "fronius-write/fronius-write.js",
+      "sma-write": "sma-write/sma-write.js",
+      "control-export": "control-export/control-export.js",
+      "multi-inverter": "multi-inverter/multi-inverter.js",
+      "carlo-gavazzi": "carlo-gavazzi/carlo-gavazzi.js",
+      "phoenix-contact": "phoenix-contact/phoenix-contact.js",
+      "advantech-read": "advantech-read/advantech-read.js",
+      "advantech-write": "advantech-write/advantech-write.js",
+      "control-reactive": "control-reactive/control-reactive.js",
+      "multi-grid": "multi-grid/multi-grid.js",
+      "pylontech-read": "pylontech-read/pylontech-read.js",
+      "pylontech-write": "pylontech-write/pylontech-write.js",
+      "bess-control": "bess-control/bess-control.js",
+      "scada-server": "scada-server/scada-server.js",
+      "scada-aggregator": "scada-aggregator/scada-aggregator.js",
+      "multi-battery": "multi-battery/multi-battery.js",
+      "pv-generator": "pv-generator/pv-generator.js",
+      "janitza": "janitza/janitza.js",
+      "adt-influxdb": "influxdb/influxdb.js",
+      "victron-read": "victron-read/victron-read.js",
+      "modbus-tcp-discover": "modbus-tcp-discover/modbus-tcp-discover.js",
+      "fronius-emulator": "fronius-emulator/fronius-emulator.js"
+    }
+  },
+  "scripts": {
+    "check:syntax": "node scripts/check-syntax.js",
+    "lint": "node scripts/check-syntax.js",
+    "test": "node scripts/run-tests.js && node --test test/editor-ip-name-sync.test.js test/licensing-control.test.js test/package-integrity.test.js test/scada-aggregator-zero-average.test.js",
+    "check": "npm run lint && npm test",
+    "package:release": "node scripts/package-release.js"
+  },
+  "author": {
+    "name": "Atelierul de Tehnologii",
+    "url": "https://www.atelieruldetehnologii.ro/"
+  },
+  "homepage": "https://www.atelieruldetehnologii.ro/",
+  "publishConfig": {
+    "access": "public"
+  },
+  "atelierCommunity": {
+    "company": "Atelierul de Tehnologii",
+    "website": "https://www.atelieruldetehnologii.ro/",
+    "allNodes": true,
+    "nodeCount": 25
+  }
+}

package/phoenix-contact/lib/eem-ma370-advanced.js

@@ -0,0 +1,175 @@
+"use strict";
+
+const { decodeFloat32, EEM_MA370_ENCODING } = require("./eem-ma370");
+
+function floatField(path, address, scale) {
+    return { path, address, type: "float32", scale: scale === undefined ? 1 : scale };
+}
+
+function uint32Field(path, address, scale) {
+    return { path, address, type: "uint32", scale: scale === undefined ? 1 : scale };
+}
+
+function sint16Field(path, address, scale) {
+    return { path, address, type: "sint16", scale: scale === undefined ? 1 : scale };
+}
+
+const BLOCKS = [
+    {
+        id: "tariffs", start: 0x8200, count: 49, fields: (function () {
+            const fields = [];
+            for (let tariff = 1; tariff <= 4; tariff++) {
+                const base = 0x8201 + ((tariff - 1) * 12);
+                const prefix = "summary.energy.tariff.t" + tariff;
+                fields.push(floatField(prefix + "_import_kwh", base, 0.001));
+                fields.push(floatField(prefix + "_export_kwh", base + 2, 0.001));
+                fields.push(floatField(prefix + "_reactive_import_kvarh", base + 4, 0.001));
+                fields.push(floatField(prefix + "_reactive_export_kvarh", base + 6, 0.001));
+                fields.push(floatField(prefix + "_apparent_kvah", base + 8, 0.001));
+                fields.push(floatField(prefix + "_reactive_total_kvarh", base + 10, 0.001));
+            }
+            return fields;
+        })()
+    },
+    {
+        id: "hours", start: 0x8300, count: 22, fields: [
+            uint32Field("summary.runtime.operating_hours", 0x8300),
+            uint32Field("summary.runtime.load_operating_hours", 0x8302),
+            uint32Field("summary.runtime.total_energy_seconds", 0x8308),
+            uint32Field("summary.runtime.load_energy_seconds", 0x830A),
+            uint32Field("summary.runtime.resettable_energy_seconds", 0x830C),
+            uint32Field("summary.runtime.tariff_1_seconds", 0x830E),
+            uint32Field("summary.runtime.tariff_2_seconds", 0x8310),
+            uint32Field("summary.runtime.tariff_3_seconds", 0x8312),
+            uint32Field("summary.runtime.tariff_4_seconds", 0x8314)
+        ]
+    },
+    {
+        id: "process_energy", start: 0x8360, count: 46, fields: [
+            uint32Field("summary.process_energy.current.runtime_s", 0x8361, 0.1),
+            floatField("summary.process_energy.current.import_kwh", 0x8363, 0.001),
+            floatField("summary.process_energy.current.export_kwh", 0x8365, 0.001),
+            floatField("summary.process_energy.current.reactive_import_kvarh", 0x8367, 0.001),
+            floatField("summary.process_energy.current.reactive_export_kvarh", 0x8369, 0.001),
+            floatField("summary.process_energy.current.apparent_kvah", 0x836B, 0.001),
+            floatField("summary.process_energy.current.reactive_total_kvarh", 0x836D, 0.001),
+            uint32Field("summary.process_energy.previous.runtime_s", 0x8380, 0.1),
+            floatField("summary.process_energy.previous.import_kwh", 0x8382, 0.001),
+            floatField("summary.process_energy.previous.export_kwh", 0x8384, 0.001),
+            floatField("summary.process_energy.previous.reactive_import_kvarh", 0x8386, 0.001),
+            floatField("summary.process_energy.previous.reactive_export_kvarh", 0x8388, 0.001),
+            floatField("summary.process_energy.previous.apparent_kvah", 0x838A, 0.001),
+            floatField("summary.process_energy.previous.reactive_total_kvarh", 0x838C, 0.001)
+        ]
+    },
+    {
+        id: "trend", start: 0x8500, count: 16, fields: [
+            floatField("summary.statistics.trend.active_power_w", 0x8500),
+            floatField("summary.statistics.trend.reactive_power_var", 0x8502),
+            floatField("summary.statistics.trend.apparent_power_va", 0x8504),
+            floatField("summary.statistics.interval.active_import_wh", 0x8506),
+            floatField("summary.statistics.interval.active_export_wh", 0x8508),
+            floatField("summary.statistics.interval.reactive_import_varh", 0x850A),
+            floatField("summary.statistics.interval.reactive_export_varh", 0x850C),
+            floatField("summary.statistics.interval.apparent_vah", 0x850E)
+        ]
+    },
+    {
+        id: "averages", start: 0x8540, count: 32, fields: [
+            floatField("summary.statistics.average.voltage_l1_l2_v", 0x8540),
+            floatField("summary.statistics.average.voltage_l2_l3_v", 0x8542),
+            floatField("summary.statistics.average.voltage_l3_l1_v", 0x8544),
+            floatField("summary.statistics.average.voltage_l1_n_v", 0x8546),
+            floatField("summary.statistics.average.voltage_l2_n_v", 0x8548),
+            floatField("summary.statistics.average.voltage_l3_n_v", 0x854A),
+            floatField("summary.statistics.average.frequency_hz", 0x854C),
+            floatField("summary.statistics.average.current_l1_a", 0x854E),
+            floatField("summary.statistics.average.current_l2_a", 0x8550),
+            floatField("summary.statistics.average.current_l3_a", 0x8552),
+            floatField("summary.statistics.average.current_neutral_a", 0x8554),
+            floatField("summary.statistics.average.active_import_w", 0x8556),
+            floatField("summary.statistics.average.active_export_w", 0x8558),
+            floatField("summary.statistics.average.reactive_import_var", 0x855A),
+            floatField("summary.statistics.average.reactive_export_var", 0x855C),
+            floatField("summary.statistics.average.apparent_va", 0x855E)
+        ]
+    },
+    {
+        id: "minmax", start: 0x8700, count: 64, fields: (function () {
+            const metrics = [
+                ["voltage_l1_l2_v", 0], ["voltage_l2_l3_v", 2], ["voltage_l3_l1_v", 4],
+                ["voltage_l1_n_v", 6], ["voltage_l2_n_v", 8], ["voltage_l3_n_v", 10],
+                ["frequency_hz", 12], ["current_l1_a", 14], ["current_l2_a", 16],
+                ["current_l3_a", 18], ["current_neutral_a", 20], ["active_import_w", 22],
+                ["active_export_w", 24], ["reactive_import_var", 26], ["reactive_export_var", 28],
+                ["apparent_va", 30]
+            ];
+            const fields = [];
+            metrics.forEach(function (metric) {
+                fields.push(floatField("summary.statistics.maximum." + metric[0], 0x8700 + metric[1]));
+                fields.push(floatField("summary.statistics.minimum." + metric[0], 0x8720 + metric[1]));
+            });
+            return fields;
+        })()
+    },
+    {
+        id: "thd", start: 0x8800, count: 10, fields: [
+            sint16Field("summary.thd.voltage_l1_l2_pct", 0x8800, 0.1),
+            sint16Field("summary.thd.voltage_l2_l3_pct", 0x8801, 0.1),
+            sint16Field("summary.thd.voltage_l3_l1_pct", 0x8802, 0.1),
+            sint16Field("summary.thd.voltage_l1_n_pct", 0x8803, 0.1),
+            sint16Field("summary.thd.voltage_l2_n_pct", 0x8804, 0.1),
+            sint16Field("summary.thd.voltage_l3_n_pct", 0x8805, 0.1),
+            sint16Field("summary.thd.current_l1_pct", 0x8806, 0.1),
+            sint16Field("summary.thd.current_l2_pct", 0x8807, 0.1),
+            sint16Field("summary.thd.current_l3_pct", 0x8808, 0.1),
+            sint16Field("summary.thd.current_neutral_pct", 0x8809, 0.1)
+        ]
+    }
+];
+
+function setByPath(target, path, value) {
+    const parts = path.split(".");
+    let cursor = target;
+    parts.forEach(function (part, index) {
+        if (index === parts.length - 1) cursor[part] = value;
+        else cursor = cursor[part] || (cursor[part] = {});
+    });
+}
+
+function uint32(registers, offset) {
+    if (!Number.isInteger(registers[offset]) || !Number.isInteger(registers[offset + 1])) return null;
+    return ((registers[offset] * 0x10000) + registers[offset + 1]) >>> 0;
+}
+
+function sint16(value) {
+    if (!Number.isInteger(value)) return null;
+    return value > 0x7FFF ? value - 0x10000 : value;
+}
+
+function requiredBlocks(paths) {
+    const selected = new Set(Array.isArray(paths) ? paths : []);
+    return BLOCKS.filter(function (block) {
+        return block.fields.some(function (field) { return selected.has(field.path); });
+    });
+}
+
+function parseAdvancedBlocks(blockValues) {
+    const result = {};
+    BLOCKS.forEach(function (block) {
+        const registers = blockValues && blockValues[block.id];
+        if (!Array.isArray(registers)) return;
+        block.fields.forEach(function (field) {
+            const offset = field.address - block.start;
+            let value = null;
+            if (field.type === "float32") value = decodeFloat32(registers, offset, EEM_MA370_ENCODING);
+            else if (field.type === "uint32") value = uint32(registers, offset);
+            else if (field.type === "sint16") value = sint16(registers[offset]);
+            if (value !== null) value *= field.scale;
+            setByPath(result, field.path.replace(/^summary\./, ""), value);
+        });
+    });
+    return result;
+}
+
+module.exports = { BLOCKS, parseAdvancedBlocks, requiredBlocks };

package/phoenix-contact/lib/eem-ma370.js

@@ -0,0 +1,138 @@
+"use strict";
+
+const INSTANTANEOUS_START = 0x8000;
+const INSTANTANEOUS_COUNT = 88;
+const ENERGY_START = 0x8100;
+const ENERGY_COUNT = 24;
+const EEM_MA370_ENCODING = Object.freeze({
+    wordOrder: "msw_first",
+    byteOrder: "big_endian"
+});
+
+const FLOAT_FIELDS = [
+    ["voltage.l1_l2_v", 0x8000],
+    ["voltage.l2_l3_v", 0x8002],
+    ["voltage.l3_l1_v", 0x8004],
+    ["voltage.l1_n_v", 0x8006],
+    ["voltage.l2_n_v", 0x8008],
+    ["voltage.l3_n_v", 0x800A],
+    ["frequency_hz", 0x800C],
+    ["current.l1_a", 0x800E],
+    ["current.l2_a", 0x8010],
+    ["current.l3_a", 0x8012],
+    ["current.neutral_a", 0x8014],
+    ["power.total_w", 0x8016],
+    ["reactive.total_var", 0x8018],
+    ["apparent.total_va", 0x801A],
+    ["power_factor.total", 0x801C],
+    ["power.l1_w", 0x801E],
+    ["power.l2_w", 0x8020],
+    ["power.l3_w", 0x8022],
+    ["reactive.l1_var", 0x8024],
+    ["reactive.l2_var", 0x8026],
+    ["reactive.l3_var", 0x8028],
+    ["apparent.l1_va", 0x802A],
+    ["apparent.l2_va", 0x802C],
+    ["apparent.l3_va", 0x802E],
+    ["power_factor.l1", 0x8030],
+    ["power_factor.l2", 0x8032],
+    ["power_factor.l3", 0x8034],
+    ["system.current_a", 0x8039],
+    ["system.line_voltage_v", 0x803B],
+    ["system.phase_voltage_v", 0x803D],
+    ["reactive.total_arithmetic_var", 0x803F],
+    ["apparent.total_arithmetic_va", 0x8041],
+    ["power_factor.total_arithmetic", 0x8043],
+    ["phase_angle.l1_deg", 0x8045],
+    ["phase_angle.l2_deg", 0x8047],
+    ["phase_angle.l3_deg", 0x8049],
+    ["cos_phi.l1", 0x804B],
+    ["cos_phi.l2", 0x804D],
+    ["cos_phi.l3", 0x804F],
+    ["phase_angle_voltage.l1_deg", 0x8051],
+    ["phase_angle_voltage.l2_deg", 0x8053],
+    ["phase_angle_voltage.l3_deg", 0x8055]
+];
+
+const ENERGY_FIELDS = [
+    ["energy.import_kwh", 0x8100, 0.001],
+    ["energy.reactive_import_kvarh", 0x8102, 0.001],
+    ["energy.apparent_kvah", 0x8104, 0.001],
+    ["energy.export_kwh", 0x8106, 0.001],
+    ["energy.reactive_export_kvarh", 0x8108, 0.001],
+    ["energy.reactive_total_kvarh", 0x810A, 0.001],
+    ["energy.current_import_kwh", 0x810C, 0.001],
+    ["energy.current_reactive_import_kvarh", 0x810E, 0.001],
+    ["energy.current_apparent_kvah", 0x8110, 0.001],
+    ["energy.current_export_kwh", 0x8112, 0.001],
+    ["energy.current_reactive_export_kvarh", 0x8114, 0.001],
+    ["energy.current_reactive_total_kvarh", 0x8116, 0.001]
+];
+
+function setByPath(target, path, value) {
+    const parts = path.split(".");
+    let cursor = target;
+    parts.forEach(function (part, index) {
+        if (index === parts.length - 1) cursor[part] = value;
+        else cursor = cursor[part] || (cursor[part] = {});
+    });
+}
+
+function decodeFloat32(registers, offset, options) {
+    const opts = options || {};
+    let first = registers[offset];
+    let second = registers[offset + 1];
+    if (!Number.isInteger(first) || !Number.isInteger(second)) return null;
+    if (opts.wordOrder === "lsw_first") [first, second] = [second, first];
+
+    const buffer = Buffer.allocUnsafe(4);
+    buffer.writeUInt16BE(first & 0xFFFF, 0);
+    buffer.writeUInt16BE(second & 0xFFFF, 2);
+    if (opts.byteOrder === "little_endian") {
+        [buffer[0], buffer[1]] = [buffer[1], buffer[0]];
+        [buffer[2], buffer[3]] = [buffer[3], buffer[2]];
+    }
+    const value = buffer.readFloatBE(0);
+    return Number.isFinite(value) ? value : null;
+}
+
+function signed16(value) {
+    if (!Number.isInteger(value)) return null;
+    return value > 0x7FFF ? value - 0x10000 : value;
+}
+
+function parseEemMa370(instantaneous, energy) {
+    if (!Array.isArray(instantaneous) || instantaneous.length < INSTANTANEOUS_COUNT) {
+        throw new Error("Raspuns instantaneu incomplet pentru EEM-MA370");
+    }
+    if (!Array.isArray(energy) || energy.length < ENERGY_COUNT) {
+        throw new Error("Raspuns energie incomplet pentru EEM-MA370");
+    }
+
+    const summary = {};
+    FLOAT_FIELDS.forEach(function (field) {
+        setByPath(summary, field[0], decodeFloat32(instantaneous, field[1] - INSTANTANEOUS_START, EEM_MA370_ENCODING));
+    });
+    ENERGY_FIELDS.forEach(function (field) {
+        const raw = decodeFloat32(energy, field[1] - ENERGY_START, EEM_MA370_ENCODING);
+        setByPath(summary, field[0], raw === null ? null : raw * field[2]);
+    });
+
+    summary.load_type = {
+        l1: signed16(instantaneous[0x8036 - INSTANTANEOUS_START]),
+        l2: signed16(instantaneous[0x8037 - INSTANTANEOUS_START]),
+        l3: signed16(instantaneous[0x8038 - INSTANTANEOUS_START])
+    };
+    summary.phase_sequence = signed16(instantaneous[0x8057 - INSTANTANEOUS_START]);
+    return summary;
+}
+
+module.exports = {
+    ENERGY_COUNT,
+    ENERGY_START,
+    EEM_MA370_ENCODING,
+    INSTANTANEOUS_COUNT,
+    INSTANTANEOUS_START,
+    decodeFloat32,
+    parseEemMa370
+};

package/phoenix-contact/lib/integrations.js

@@ -0,0 +1,149 @@
+"use strict";
+
+const PRESETS = {
+    multiGrid: [
+        "summary.power.total_w",
+        "summary.power.l1_w",
+        "summary.power.l2_w",
+        "summary.power.l3_w"
+    ],
+    bessControl: [
+        "summary.power.total_w",
+        "summary.power.l1_w",
+        "summary.power.l2_w",
+        "summary.power.l3_w"
+    ],
+    controlExportReactive: [
+        "summary.power.total_w",
+        "summary.power.l1_w",
+        "summary.power.l2_w",
+        "summary.power.l3_w",
+        "summary.reactive.total_var",
+        "summary.reactive.l1_var",
+        "summary.reactive.l2_var",
+        "summary.reactive.l3_var"
+    ],
+    scadaServer: [
+        "summary.power.total_w",
+        "summary.reactive.total_var",
+        "summary.frequency_hz",
+        "summary.voltage.l1_l2_v",
+        "summary.voltage.l2_l3_v",
+        "summary.voltage.l3_l1_v"
+    ]
+};
+
+const COMPACT_KEYS = {
+    "summary.voltage.l1_n_v": "voltage_l1_n_v",
+    "summary.voltage.l2_n_v": "voltage_l2_n_v",
+    "summary.voltage.l3_n_v": "voltage_l3_n_v",
+    "summary.voltage.l1_l2_v": "voltage_l1_l2_v",
+    "summary.voltage.l2_l3_v": "voltage_l2_l3_v",
+    "summary.voltage.l3_l1_v": "voltage_l3_l1_v",
+    "summary.current.l1_a": "current_l1_a",
+    "summary.current.l2_a": "current_l2_a",
+    "summary.current.l3_a": "current_l3_a",
+    "summary.current.neutral_a": "current_neutral_a",
+    "summary.power.l1_w": "power_l1_w",
+    "summary.power.l2_w": "power_l2_w",
+    "summary.power.l3_w": "power_l3_w",
+    "summary.power.total_w": "power_w",
+    "summary.apparent.l1_va": "apparent_l1_va",
+    "summary.apparent.l2_va": "apparent_l2_va",
+    "summary.apparent.l3_va": "apparent_l3_va",
+    "summary.apparent.total_va": "apparent_total_va",
+    "summary.reactive.l1_var": "reactive_l1_var",
+    "summary.reactive.l2_var": "reactive_l2_var",
+    "summary.reactive.l3_var": "reactive_l3_var",
+    "summary.reactive.total_var": "reactive_total_var",
+    "summary.power_factor.l1": "power_factor_l1",
+    "summary.power_factor.l2": "power_factor_l2",
+    "summary.power_factor.l3": "power_factor_l3",
+    "summary.power_factor.total": "power_factor_total",
+    "summary.frequency_hz": "frequency_hz",
+    "summary.phase_sequence": "phase_sequence",
+    "summary.energy.import_kwh": "energy_import_kwh",
+    "summary.energy.reactive_import_kvarh": "energy_reactive_import_kvarh",
+    "summary.energy.export_kwh": "energy_export_kwh",
+    "summary.energy.reactive_export_kvarh": "energy_export_reactive_kvarh"
+};
+
+const SCADA_KEYS = Object.assign({}, COMPACT_KEYS, {
+    "summary.power.total_w": "active_power_w",
+    "summary.reactive.total_var": "reactive_power_var",
+    "summary.voltage.l3_l1_v": "voltage_l1_l3_v"
+});
+
+function getByPath(object, path) {
+    if (path === "full") return object;
+    return path.split(".").reduce(function (value, key) {
+        return value === null || value === undefined ? undefined : value[key];
+    }, object);
+}
+
+function compactKey(path) {
+    return COMPACT_KEYS[path] || path.replace(/^summary\./, "").replace(/\./g, "_");
+}
+
+function scadaKey(path) {
+    return SCADA_KEYS[path] || compactKey(path);
+}
+
+function selectFields(mode, expertMode, configuredFields) {
+    if (mode && !expertMode && PRESETS[mode]) return PRESETS[mode].slice();
+    const fields = Array.isArray(configuredFields) ? configuredFields.filter(Boolean) : [];
+    return fields.length ? Array.from(new Set(fields)) : ["full"];
+}
+
+function aggregate(envelope, fields, mode) {
+    const result = {};
+    fields.forEach(function (field) {
+        result[mode === "scadaServer" ? scadaKey(field) : compactKey(field)] = getByPath(envelope, field);
+    });
+    return result;
+}
+
+function flattenNumeric(source, prefix, target) {
+    Object.keys(source || {}).forEach(function (key) {
+        const value = source[key];
+        const next = prefix ? prefix + "_" + key : key;
+        if ((typeof value === "number" && Number.isFinite(value)) || typeof value === "boolean") target[next] = value;
+        else if (value && typeof value === "object" && !Array.isArray(value)) flattenNumeric(value, next, target);
+    });
+}
+
+function buildInfluxFields(envelope, fields) {
+    const result = {};
+    if (fields.includes("full")) {
+        function walkSummary(source, path) {
+            Object.keys(source || {}).forEach(function (key) {
+                const value = source[key];
+                const nextPath = path ? path + "." + key : key;
+                if ((typeof value === "number" && Number.isFinite(value)) || typeof value === "boolean") {
+                    result[compactKey("summary." + nextPath)] = value;
+                } else if (value && typeof value === "object" && !Array.isArray(value)) {
+                    walkSummary(value, nextPath);
+                }
+            });
+        }
+        walkSummary(envelope.summary || {}, "");
+        return result;
+    }
+    fields.forEach(function (field) {
+        const value = getByPath(envelope, field);
+        const key = compactKey(field);
+        if ((typeof value === "number" && Number.isFinite(value)) || typeof value === "boolean") result[key] = value;
+        else if (value && typeof value === "object" && !Array.isArray(value)) flattenNumeric(value, key, result);
+    });
+    return result;
+}
+
+module.exports = {
+    PRESETS,
+    aggregate,
+    buildInfluxFields,
+    compactKey,
+    getByPath,
+    scadaKey,
+    selectFields
+};