@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/carlo-gavazzi/carlo-gavazzi.html

@@ -0,0 +1,4327 @@
+<style>
+
+
+    .carlo-gavazzi-editor {
+
+
+        --pr-border: #d7dde5;
+
+
+        --pr-muted: #667085;
+
+
+        --pr-surface: #f8fafc;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-section {
+
+
+        margin: 0 0 18px;
+
+
+        padding: 14px 16px 16px;
+
+
+        border: 1px solid var(--pr-border);
+
+
+        border-radius: 10px;
+
+
+        background: var(--pr-surface);
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-section-title {
+
+
+        display: flex;
+
+
+        align-items: center;
+
+
+        gap: 8px;
+
+
+        margin: 0 0 4px;
+
+
+        font-size: 15px;
+
+
+        font-weight: 600;
+
+
+        color: #243447;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-section-note {
+
+
+        margin: 0 0 14px;
+
+
+        color: var(--pr-muted);
+
+
+        font-size: 12px;
+
+
+        line-height: 1.45;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-grid {
+
+
+        display: grid;
+
+
+        grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+
+
+        gap: 12px 16px;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-grid-2 {
+
+
+        grid-template-columns: repeat(2, minmax(320px, 1fr));
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-span-2 {
+
+
+        grid-column: 1 / -1;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .form-row {
+
+
+        margin-bottom: 12px;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-grid .form-row,
+
+
+    .carlo-gavazzi-editor .form-row:last-child {
+
+
+        margin-bottom: 0;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .form-row > label {
+
+
+        width: 150px;
+
+
+        font-weight: 600;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .form-row > input[type="text"],
+
+
+    .carlo-gavazzi-editor .form-row > input[type="number"],
+
+
+    .carlo-gavazzi-editor .form-row > select {
+
+
+        width: calc(100% - 160px);
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-grid-2 .form-row > label {
+
+
+        width: 130px;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-grid-2 .form-row > input[type="text"],
+
+
+    .carlo-gavazzi-editor .pr-grid-2 .form-row > input[type="number"],
+
+
+    .carlo-gavazzi-editor .pr-grid-2 .form-row > select {
+
+
+        width: calc(100% - 140px);
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-checkbox-row > input[type="checkbox"] {
+
+
+        display: inline-block;
+
+
+        width: auto;
+
+
+        vertical-align: top;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-inline-note {
+
+
+        margin-left: 8px;
+
+
+        color: var(--pr-muted);
+
+
+        line-height: 1.4;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-field-list {
+
+
+        max-height: 320px;
+
+
+        overflow: auto;
+
+
+        padding: 12px;
+
+
+        border: 1px solid var(--pr-border);
+
+
+        border-radius: 10px;
+
+
+        background: #fff;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-field-group {
+
+
+        margin-bottom: 14px;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-field-group:last-child {
+
+
+        margin-bottom: 0;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-field-group-title {
+
+
+        margin: 0 0 8px;
+
+
+        font-size: 12px;
+
+
+        font-weight: 700;
+
+
+        text-transform: uppercase;
+
+
+        letter-spacing: 0.03em;
+
+
+        color: #344054;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-field-group-grid {
+
+
+        display: grid;
+
+
+        grid-template-columns: repeat(auto-fit, minmax(230px, 1fr));
+
+
+        gap: 8px 16px;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-field-item {
+
+
+        display: flex;
+
+
+        align-items: center;
+
+
+        gap: 8px;
+
+
+        margin: 0;
+
+
+        line-height: 1.35;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-toolbar {
+
+
+        display: flex;
+
+
+        flex-wrap: wrap;
+
+
+        gap: 8px;
+
+
+        margin-bottom: 10px;
+
+
+    }
+
+
+
+    .carlo-gavazzi-editor .pr-inline-control {
+
+
+        width: calc(100% - 160px);
+
+
+    }
+
+
+
+    @media (max-width: 1100px) {
+
+
+        .carlo-gavazzi-editor .pr-grid-2 {
+
+
+            grid-template-columns: 1fr;
+
+
+        }
+
+
+    }
+
+
+
+</style>
+
+
+
+<script type="text/javascript">
+
+
+    (function () {
+
+
+
+        const FIELD_GROUPS = [
+
+
+            {
+
+
+                label: "General",
+
+
+                fields: [
+
+
+                    "summary.power.total_w",
+
+
+                    "summary.frequency_hz",
+
+
+                    "summary.phase_sequence"
+
+
+                ]
+
+
+            },
+
+
+            {
+
+
+                label: "Voltage",
+
+
+                fields: [
+
+
+                    "summary.voltage.l1_n_v",
+
+
+                    "summary.voltage.l2_n_v",
+
+
+                    "summary.voltage.l3_n_v",
+
+
+                    "summary.voltage.l1_l2_v",
+
+
+                    "summary.voltage.l2_l3_v",
+
+
+                    "summary.voltage.l3_l1_v"
+
+
+                ]
+
+
+            },
+
+
+            {
+
+
+                label: "Current",
+
+
+                fields: [
+
+
+                    "summary.current.l1_a",
+
+
+                    "summary.current.l2_a",
+
+
+                    "summary.current.l3_a"
+
+
+                ]
+
+
+            },
+
+
+            {
+
+
+                label: "Active Power",
+
+
+                fields: [
+
+
+                    "summary.power.l1_w",
+
+
+                    "summary.power.l2_w",
+
+
+                    "summary.power.l3_w"
+
+
+                ]
+
+
+            },
+
+
+            {
+
+
+                label: "Apparent Power",
+
+
+                fields: [
+
+
+                    "summary.apparent.l1_va",
+
+
+                    "summary.apparent.l2_va",
+
+
+                    "summary.apparent.l3_va",
+
+
+                    "summary.apparent.total_va"
+
+
+                ]
+
+
+            },
+
+
+            {
+
+
+                label: "Reactive Power",
+
+
+                fields: [
+
+
+                    "summary.reactive.l1_var",
+
+
+                    "summary.reactive.l2_var",
+
+
+                    "summary.reactive.l3_var",
+
+
+                    "summary.reactive.total_var"
+
+
+                ]
+
+
+            },
+
+
+            {
+
+
+                label: "Power Factor",
+
+
+                fields: [
+
+
+                    "summary.power_factor.l1",
+
+
+                    "summary.power_factor.l2",
+
+
+                    "summary.power_factor.l3"
+
+
+                ]
+
+
+            },
+
+
+            {
+
+
+                label: "Energy",
+
+
+                fields: [
+
+
+                    "summary.energy.import_kwh",
+
+
+                    "summary.energy.reactive_import_kvarh",
+
+
+                    "summary.energy.export_kwh",
+
+
+                    "summary.energy.export_reactive_kvarh",
+
+
+                    "summary.energy.l1_kwh",
+
+
+                    "summary.energy.l2_kwh",
+
+
+                    "summary.energy.l3_kwh"
+
+
+                ]
+
+
+            },
+
+
+            {
+
+
+                label: "Tariff Energy",
+
+
+                fields: [
+
+
+                    "summary.energy.tariff.t1_kwh",
+
+
+                    "summary.energy.tariff.t2_kwh",
+
+
+                    "summary.energy.tariff.t3_kwh",
+
+
+                    "summary.energy.tariff.t4_kwh",
+
+
+                    "summary.energy.reactive_tariff.t1_kvarh",
+
+
+                    "summary.energy.reactive_tariff.t2_kvarh",
+
+
+                    "summary.energy.reactive_tariff.t3_kvarh",
+
+
+                    "summary.energy.reactive_tariff.t4_kvarh"
+
+
+                ]
+
+
+            }
+
+
+        ];
+
+
+
+        const MULTI_GRID_DEFAULT_FIELDS = [
+
+
+            "summary.power.total_w",
+
+
+            "summary.power.l1_w",
+
+
+            "summary.power.l2_w",
+
+
+            "summary.power.l3_w"
+
+
+        ];
+
+
+        const BESS_CONTROL_DEFAULT_FIELDS = [
+
+
+            "summary.power.total_w",
+
+
+            "summary.power.l1_w",
+
+
+            "summary.power.l2_w",
+
+
+            "summary.power.l3_w"
+
+
+        ];
+
+
+        const CONTROL_EXPORT_REACTIVE_DEFAULT_FIELDS = [
+
+
+            "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"
+
+
+        ];
+
+
+        const SCADA_DEFAULT_FIELDS = [
+
+
+            "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"
+
+
+        ];
+
+
+
+        let payloadSelectionState = ["full"];
+
+
+        let customModeSelections = {
+
+
+            multiGrid: [],
+
+
+            bessControl: [],
+
+
+            controlExportReactive: [],
+
+
+            scadaServer: [],
+
+
+            influxDb: []
+
+
+        };
+
+
+        let customModeEnabledState = {
+
+
+            multiGrid: false,
+
+
+            bessControl: false,
+
+
+            controlExportReactive: false,
+
+
+            scadaServer: false,
+
+
+            influxDb: false
+
+
+        };
+
+
+        let specialExpertUnlockedState = {
+
+
+            multiGrid: false,
+
+
+            bessControl: false,
+
+
+            controlExportReactive: false,
+
+
+            scadaServer: false,
+
+
+            influxDb: false
+
+
+        };
+
+
+        let specialLongPressTimer = null;
+
+
+        let specialLongPressTriggeredMode = "";
+
+
+        let specialLongPressStartChecked = false;
+
+
+        let specialLongPressActivationMode = "";
+
+
+        const SPECIAL_EXPERT_LONG_PRESS_MS = 5000;
+
+
+
+        function getSelectedOutputCount(nodeLike) {
+
+
+            if (nodeLike && nodeLike.multiGrid) {
+
+
+                return 1;
+
+
+            }
+
+
+
+            if (nodeLike && nodeLike.bessControl) {
+
+
+                return 1;
+
+
+            }
+
+
+            if (nodeLike && nodeLike.controlExportReactive) {
+
+
+                return 1;
+
+
+            }
+
+
+
+            if (nodeLike && nodeLike.scadaServer) {
+
+
+                return 1;
+
+
+            }
+
+
+
+            if (nodeLike && nodeLike.influxDb) {
+
+
+                return 1;
+
+
+            }
+
+
+
+            const fields = Array.isArray(nodeLike && nodeLike.payloadFields)
+
+
+                ? nodeLike.payloadFields.filter(Boolean)
+
+
+                : ["full"];
+
+
+
+            if (!fields.length || fields.includes("full")) {
+
+
+                return 1;
+
+
+            }
+
+
+
+            return Math.max(1, fields.length);
+
+
+        }
+
+
+
+        function normalizeSelectedValues(value, allowEmpty) {
+
+
+            const keepEmpty = !!allowEmpty;
+
+
+
+            if (Array.isArray(value)) {
+
+
+                const filtered = value.map(function (v) {
+
+
+                    return String(v || "").trim();
+
+
+                }).filter(Boolean);
+
+
+
+                return filtered.length ? filtered : (keepEmpty ? [] : ["full"]);
+
+
+            }
+
+
+
+            if (typeof value === "string") {
+
+
+                const trimmed = value.trim();
+
+
+
+                if (!trimmed) {
+
+
+                    return keepEmpty ? [] : ["full"];
+
+
+                }
+
+
+
+                if (trimmed[0] === "[") {
+
+
+                    try {
+
+
+                        const parsed = JSON.parse(trimmed);
+
+
+                        if (Array.isArray(parsed)) {
+
+
+                            return normalizeSelectedValues(parsed, keepEmpty);
+
+
+                        }
+
+
+                    } catch (e) {
+
+
+                        // ignore
+
+
+                    }
+
+
+                }
+
+
+
+                return [trimmed];
+
+
+            }
+
+
+
+            return keepEmpty ? [] : ["full"];
+
+
+        }
+
+
+
+        function dedupeSelectedValues(values, allowEmpty) {
+
+
+            return Array.from(new Set(normalizeSelectedValues(values, allowEmpty)));
+
+
+        }
+
+
+
+        function sanitizeSelectedValues(values, allowEmpty) {
+
+
+            const keepEmpty = !!allowEmpty;
+
+
+            const normalized = dedupeSelectedValues(values, keepEmpty).filter(Boolean);
+
+
+
+            if (normalized.includes("full") && normalized.length > 1) {
+
+
+                return normalized.filter(function (v) {
+
+
+                    return v !== "full";
+
+
+                });
+
+
+            }
+
+
+
+            return normalized.length ? normalized : (keepEmpty ? [] : ["full"]);
+
+
+        }
+
+
+
+        function getActiveSpecialMode(multiGrid, bessControl, controlExportReactive, scadaServer, influxDb) {
+
+
+            if (multiGrid) {
+
+
+                return "multiGrid";
+
+
+            }
+
+
+            if (bessControl) {
+
+
+                return "bessControl";
+
+
+            }
+
+
+            if (controlExportReactive) {
+
+
+                return "controlExportReactive";
+
+
+            }
+
+
+            if (scadaServer) {
+
+
+                return "scadaServer";
+
+
+            }
+
+
+            if (influxDb) {
+
+
+                return "influxDb";
+
+
+            }
+
+
+            return "";
+
+
+        }
+
+
+
+        function getDefaultFieldsForMode(mode) {
+
+
+            if (mode === "multiGrid") {
+
+
+                return MULTI_GRID_DEFAULT_FIELDS.slice();
+
+
+            }
+
+
+            if (mode === "bessControl") {
+
+
+                return BESS_CONTROL_DEFAULT_FIELDS.slice();
+
+
+            }
+
+
+            if (mode === "controlExportReactive") {
+
+
+                return CONTROL_EXPORT_REACTIVE_DEFAULT_FIELDS.slice();
+
+
+            }
+
+
+            if (mode === "scadaServer") {
+
+
+                return SCADA_DEFAULT_FIELDS.slice();
+
+
+            }
+
+
+            if (mode === "influxDb") {
+
+
+                const allSelectable = getAllSelectableFields();
+                const filtered = allSelectable.filter(function (field) {
+                    return String(field || "").indexOf("summary.energy.") !== 0;
+                });
+
+                return filtered.length ? filtered : allSelectable;
+
+
+            }
+
+
+            return ["full"];
+
+
+        }
+
+
+
+        function isSpecialModeEnabled(mode) {
+
+
+            return mode === "multiGrid" || mode === "bessControl" || mode === "controlExportReactive" || mode === "scadaServer" || mode === "influxDb";
+
+
+        }
+
+
+
+        function getModeCheckbox(mode) {
+
+
+            if (mode === "multiGrid") {
+
+
+                return $("#node-input-multiGrid");
+
+
+            }
+
+
+            if (mode === "bessControl") {
+
+
+                return $("#node-input-bessControl");
+
+
+            }
+
+
+            if (mode === "controlExportReactive") {
+
+
+                return $("#node-input-controlExportReactive");
+
+
+            }
+
+
+            if (mode === "scadaServer") {
+
+
+                return $("#node-input-scadaServer");
+
+
+            }
+
+
+            if (mode === "influxDb") {
+
+
+                return $("#node-input-influxDb");
+
+
+            }
+
+
+            return $();
+
+
+        }
+
+
+
+        function arraysEqual(a, b) {
+
+
+            if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+
+
+                return false;
+
+
+            }
+
+
+
+            let i;
+
+
+            for (i = 0; i < a.length; i += 1) {
+
+
+                if (a[i] !== b[i]) {
+
+
+                    return false;
+
+
+                }
+
+
+            }
+
+
+
+            return true;
+
+
+        }
+
+
+
+        function sanitizeCustomModeSelection(values) {
+
+
+            return sanitizeSelectedValues(values, true).filter(function (v) {
+
+
+                return v !== "full";
+
+
+            });
+
+
+        }
+
+
+
+        function getAllSelectableFields() {
+
+
+            const allFields = [];
+
+
+            const seen = new Set();
+
+
+
+            FIELD_GROUPS.forEach(function (group) {
+
+
+                group.fields.forEach(function (field) {
+
+
+                    if (seen.has(field)) {
+
+
+                        return;
+
+
+                    }
+
+
+                    seen.add(field);
+
+
+                    allFields.push(field);
+
+
+                });
+
+
+            });
+
+
+
+            return allFields;
+
+
+        }
+
+
+
+        function sanitizeForMode(values, multiGrid, bessControl, controlExportReactive, scadaServer, influxDb, options) {
+
+
+            const mode = getActiveSpecialMode(multiGrid, bessControl, controlExportReactive, scadaServer, influxDb);
+
+
+            const allowEmptySpecial = !!(options && options.allowEmptySpecial && mode);
+
+
+            const normalized = sanitizeSelectedValues(values, allowEmptySpecial);
+
+
+
+            if (mode && normalized.includes("full")) {
+
+
+                return getDefaultFieldsForMode(mode);
+
+
+            }
+
+
+
+            return normalized;
+
+
+        }
+
+
+
+        function applyExclusiveSelectionRule(selected, changedValue, checked) {
+
+
+            let unique = Array.from(new Set((selected || []).filter(Boolean)));
+
+
+
+            if (changedValue === "full") {
+
+
+                if (checked) {
+
+
+                    return ["full"];
+
+
+                }
+
+
+                unique = unique.filter(function (v) {
+
+
+                    return v !== "full";
+
+
+                });
+
+
+                return unique.length ? unique : ["full"];
+
+
+            }
+
+
+
+            if (checked) {
+
+
+                unique = unique.filter(function (v) {
+
+
+                    return v !== "full";
+
+
+                });
+
+
+                return unique.length ? unique : ["full"];
+
+
+            }
+
+
+
+            unique = unique.filter(function (v) {
+
+
+                return v !== changedValue;
+
+
+            });
+
+
+
+            return unique.length ? unique : ["full"];
+
+
+        }
+
+
+
+        function getPayloadLabel(path) {
+
+
+            const labels = {
+
+
+                "full": "Toate valorile",
+
+
+                "summary.power.total_w": "Putere totala (W)",
+
+
+                "summary.frequency_hz": "Frecventa (Hz)",
+
+
+                "summary.phase_sequence": "Ordine faze",
+
+
+
+                "summary.voltage.l1_n_v": "Tensiune L1-N (V)",
+
+
+                "summary.voltage.l2_n_v": "Tensiune L2-N (V)",
+
+
+                "summary.voltage.l3_n_v": "Tensiune L3-N (V)",
+
+
+                "summary.voltage.l1_l2_v": "Tensiune L1-L2 (V)",
+
+
+                "summary.voltage.l2_l3_v": "Tensiune L2-L3 (V)",
+
+
+                "summary.voltage.l3_l1_v": "Tensiune L3-L1 (V)",
+
+
+
+                "summary.current.l1_a": "Curent L1 (A)",
+
+
+                "summary.current.l2_a": "Curent L2 (A)",
+
+
+                "summary.current.l3_a": "Curent L3 (A)",
+
+
+
+                "summary.power.l1_w": "Putere L1 (W)",
+
+
+                "summary.power.l2_w": "Putere L2 (W)",
+
+
+                "summary.power.l3_w": "Putere L3 (W)",
+
+
+
+                "summary.apparent.l1_va": "Putere aparenta L1 (VA)",
+
+
+                "summary.apparent.l2_va": "Putere aparenta L2 (VA)",
+
+
+                "summary.apparent.l3_va": "Putere aparenta L3 (VA)",
+
+
+                "summary.apparent.total_va": "Putere aparenta totala (VA)",
+
+
+
+                "summary.reactive.l1_var": "Putere reactiva L1 (var)",
+
+
+                "summary.reactive.l2_var": "Putere reactiva L2 (var)",
+
+
+                "summary.reactive.l3_var": "Putere reactiva L3 (var)",
+
+
+                "summary.reactive.total_var": "Putere reactiva totala (var)",
+
+
+
+                "summary.power_factor.l1": "Factor putere L1",
+
+
+                "summary.power_factor.l2": "Factor putere L2",
+
+
+                "summary.power_factor.l3": "Factor putere L3",
+
+
+
+                "summary.energy.import_kwh": "Energie importata (kWh)",
+
+
+                "summary.energy.reactive_import_kvarh": "Energie reactiva importata (kvarh)",
+
+
+                "summary.energy.export_kwh": "Energie exportata (kWh)",
+
+
+                "summary.energy.export_reactive_kvarh": "Energie reactiva exportata (kvarh)",
+
+
+                "summary.energy.l1_kwh": "Energie L1 (kWh)",
+
+
+                "summary.energy.l2_kwh": "Energie L2 (kWh)",
+
+
+                "summary.energy.l3_kwh": "Energie L3 (kWh)",
+
+
+                "summary.energy.tariff.t1_kwh": "Energie T1 (kWh)",
+
+
+                "summary.energy.tariff.t2_kwh": "Energie T2 (kWh)",
+
+
+                "summary.energy.tariff.t3_kwh": "Energie T3 (kWh)",
+
+
+                "summary.energy.tariff.t4_kwh": "Energie T4 (kWh)",
+
+
+                "summary.energy.reactive_tariff.t1_kvarh": "Energie reactiva T1 (kvarh)",
+
+
+                "summary.energy.reactive_tariff.t2_kvarh": "Energie reactiva T2 (kvarh)",
+
+
+                "summary.energy.reactive_tariff.t3_kvarh": "Energie reactiva T3 (kvarh)",
+
+
+                "summary.energy.reactive_tariff.t4_kvarh": "Energie reactiva T4 (kvarh)"
+
+
+            };
+
+
+
+            return labels[path] || path;
+
+
+        }
+
+
+
+        function renderFieldSelection(selectedValues) {
+
+
+            const specialMode = getActiveSpecialMode(
+
+
+                $("#node-input-multiGrid").is(":checked"),
+
+
+                $("#node-input-bessControl").is(":checked"),
+
+
+                $("#node-input-controlExportReactive").is(":checked"),
+
+
+                $("#node-input-scadaServer").is(":checked"),
+
+
+                $("#node-input-influxDb").is(":checked")
+
+
+            );
+
+
+            const expertMode = $("#node-input-expertMode").is(":checked");
+
+
+            const specialModeCustomEnabled = !!(specialMode && customModeEnabledState[specialMode]);
+
+
+            const normalized = sanitizeForMode(
+
+
+                selectedValues,
+
+
+                $("#node-input-multiGrid").is(":checked"),
+
+
+                $("#node-input-bessControl").is(":checked"),
+
+
+                $("#node-input-controlExportReactive").is(":checked"),
+
+
+                $("#node-input-scadaServer").is(":checked"),
+
+
+                $("#node-input-influxDb").is(":checked"),
+
+
+                { allowEmptySpecial: !!(specialMode && (expertMode || specialModeCustomEnabled)) }
+
+
+            );
+
+
+            const $container = $("#node-carlo-gavazzi-field-list-container");
+
+
+            const renderedFields = new Set();
+
+
+
+            $container.empty();
+
+
+
+            FIELD_GROUPS.forEach(function (group) {
+
+
+                const $group = $('<div class="pr-field-group"></div>');
+
+
+                const $title = $('<p class="pr-field-group-title"></p>').text(group.label);
+
+
+                const $grid = $('<div class="pr-field-group-grid"></div>');
+
+
+                let groupHasFields = false;
+
+
+
+                group.fields.forEach(function (field) {
+
+
+                    if (renderedFields.has(field)) {
+
+
+                        return;
+
+
+                    }
+
+
+                    renderedFields.add(field);
+
+
+                    groupHasFields = true;
+
+
+                    const checkboxId = "carlo-gavazzi-field-" + field.replace(/[^a-zA-Z0-9_]/g, "_");
+
+
+                    const $checkbox = $('<input type="checkbox" class="pr-field-checkbox">')
+
+
+                        .attr("id", checkboxId)
+
+
+                        .attr("data-field", field)
+
+
+                        .prop("checked", normalized.includes(field));
+
+
+                    const $label = $('<label class="pr-field-item"></label>')
+
+
+                        .attr("for", checkboxId)
+
+
+                        .append($checkbox)
+
+
+                        .append($('<span></span>').text(getPayloadLabel(field)));
+
+
+
+                    $grid.append($label);
+
+
+                });
+
+
+
+                if (groupHasFields) {
+
+
+                    $group.append($title).append($grid);
+
+
+                    $container.append($group);
+
+
+                }
+
+
+            });
+
+
+
+            $container.find(".pr-field-checkbox").off(".carloFields").on("change.carloFields", function () {
+
+
+                const selected = [];
+
+
+                $container.find(".pr-field-checkbox:checked").each(function () {
+
+
+                    selected.push($(this).attr("data-field"));
+
+
+                });
+
+
+
+                persistPayloadSelection(selected, { allowEmptySpecial: true });
+
+
+                syncPayloadModeUi();
+
+
+            });
+
+
+        }
+
+
+
+        function persistPayloadSelection(values, options) {
+
+
+            const multiGrid = $("#node-input-multiGrid").is(":checked");
+
+
+            const bessControl = $("#node-input-bessControl").is(":checked");
+
+
+            const controlExportReactive = $("#node-input-controlExportReactive").is(":checked");
+
+
+            const scadaServer = $("#node-input-scadaServer").is(":checked");
+
+
+            const influxDb = $("#node-input-influxDb").is(":checked");
+
+
+            const mode = getActiveSpecialMode(multiGrid, bessControl, controlExportReactive, scadaServer, influxDb);
+
+
+            const expertMode = $("#node-input-expertMode").is(":checked");
+
+
+            const modeCustomEnabled = !!(mode && customModeEnabledState[mode]);
+
+
+            const allowEmptySpecial = !!(options && options.allowEmptySpecial && mode && (expertMode || modeCustomEnabled));
+
+
+
+            payloadSelectionState = sanitizeForMode(
+
+
+                values,
+
+
+                multiGrid,
+
+
+                bessControl,
+
+
+                controlExportReactive,
+
+
+                scadaServer,
+
+
+                influxDb,
+
+
+                { allowEmptySpecial: allowEmptySpecial }
+
+
+            );
+
+
+            $("#node-input-payloadFields").val(JSON.stringify(payloadSelectionState));
+
+
+
+            if (mode && (expertMode || modeCustomEnabled)) {
+
+
+                customModeSelections[mode] = sanitizeCustomModeSelection(payloadSelectionState);
+
+
+            }
+
+
+
+            const isMultiGrid = multiGrid;
+
+
+            const isBessControl = bessControl;
+
+
+            const isControlExportReactive = controlExportReactive;
+
+
+            const isScadaServer = scadaServer;
+
+
+            const isInfluxDb = influxDb;
+
+
+            $("#node-input-outputs").val((isMultiGrid || isBessControl || isControlExportReactive || isScadaServer || isInfluxDb) ? 1 : (payloadSelectionState.includes("full") ? 1 : Math.max(1, payloadSelectionState.length)));
+
+
+        }
+
+
+
+        function syncPayloadModeUi() {
+
+
+            const multiGrid = $("#node-input-multiGrid").is(":checked");
+
+
+            const bessControl = $("#node-input-bessControl").is(":checked");
+
+
+            const controlExportReactive = $("#node-input-controlExportReactive").is(":checked");
+
+
+            const scadaServer = $("#node-input-scadaServer").is(":checked");
+
+
+            const influxDb = $("#node-input-influxDb").is(":checked");
+
+
+            const specialMode = getActiveSpecialMode(multiGrid, bessControl, controlExportReactive, scadaServer, influxDb);
+
+
+            if (!specialMode) {
+
+
+                $("#node-input-expertMode").prop("checked", false);
+
+
+            }
+
+
+            const expertMode = $("#node-input-expertMode").is(":checked");
+
+
+            const specialModeCustomEnabled = !!(specialMode && customModeEnabledState[specialMode]);
+
+
+            const selectedMode = specialMode ? "selected" : ($("#node-input-payloadMode").val() || "full");
+
+
+            const showSelectedFields = selectedMode === "selected" && (!specialMode || expertMode);
+
+
+            const showDefaultButton = showSelectedFields && !!specialMode;
+
+
+
+            $("#node-input-payloadMode").val(selectedMode);
+
+
+            $("#row-carlo-gavazzi-field-list").toggle(showSelectedFields);
+
+
+            $("#row-expert-mode").toggle(!!specialMode && !!specialExpertUnlockedState[specialMode]);
+
+
+            $("#node-carlo-gavazzi-default-values").toggle(showDefaultButton);
+
+
+
+            if (specialMode && !expertMode) {
+
+
+                payloadSelectionState = (specialModeCustomEnabled ? customModeSelections[specialMode] : getDefaultFieldsForMode(specialMode)).slice();
+
+
+                $("#node-input-payloadFields").val(JSON.stringify(payloadSelectionState));
+
+
+                $("#node-input-outputs").val(1);
+
+
+            } else if (!showSelectedFields) {
+
+
+                persistPayloadSelection(["full"]);
+
+
+            } else if (specialMode && expertMode) {
+
+
+                if (payloadSelectionState.includes("full")) {
+
+
+                    payloadSelectionState = customModeSelections[specialMode].slice();
+
+
+                }
+
+
+                persistPayloadSelection(payloadSelectionState, { allowEmptySpecial: true });
+
+
+            } else if (payloadSelectionState.includes("full")) {
+
+
+                persistPayloadSelection([]);
+
+
+            }
+
+
+
+            renderFieldSelection(payloadSelectionState);
+
+
+        }
+
+
+
+        function clearSpecialLongPressTimer() {
+
+
+            if (specialLongPressTimer) {
+
+
+                clearTimeout(specialLongPressTimer);
+
+
+                specialLongPressTimer = null;
+
+
+            }
+
+
+        }
+
+
+
+        function unlockSpecialExpertMode(mode) {
+
+
+            if (!isSpecialModeEnabled(mode)) {
+
+
+                return;
+
+
+            }
+
+
+
+            specialExpertUnlockedState[mode] = true;
+
+
+            $("#node-input-expertMode").prop("checked", true).trigger("change");
+
+
+            syncPayloadModeUi();
+
+
+            if (RED && RED.notify) {
+
+
+                RED.notify("Selectia custom a fost activata.", "success");
+
+
+            }
+
+
+        }
+
+
+
+        function setupSpecialModeLongPress() {
+
+
+            function startLongPress(mode) {
+
+
+                const $checkbox = getModeCheckbox(mode);
+
+
+                if (!$checkbox.length || specialExpertUnlockedState[mode]) {
+
+
+                    return;
+
+
+                }
+
+
+
+                specialLongPressTriggeredMode = "";
+
+
+                specialLongPressStartChecked = $checkbox.is(":checked");
+
+
+                clearSpecialLongPressTimer();
+
+
+
+                specialLongPressTimer = setTimeout(function () {
+
+
+                    if (specialLongPressStartChecked && $checkbox.is(":checked")) {
+
+
+                        specialLongPressTriggeredMode = mode;
+
+
+                        unlockSpecialExpertMode(mode);
+
+
+                    }
+
+
+                }, SPECIAL_EXPERT_LONG_PRESS_MS);
+
+
+            }
+
+
+
+            function stopLongPress() {
+
+
+                clearSpecialLongPressTimer();
+
+
+            }
+
+
+
+            ["multiGrid", "bessControl", "controlExportReactive", "scadaServer", "influxDb"].forEach(function (mode) {
+
+
+                const $checkbox = getModeCheckbox(mode);
+
+
+                $checkbox
+
+
+                    .off(".carloSpecialLongPress")
+
+
+                    .on("mousedown.carloSpecialLongPress touchstart.carloSpecialLongPress", function () {
+
+
+                        startLongPress(mode);
+
+
+                    })
+
+
+                    .on("mouseup.carloSpecialLongPress mouseleave.carloSpecialLongPress touchend.carloSpecialLongPress touchcancel.carloSpecialLongPress", function () {
+
+
+                        stopLongPress();
+
+
+                    })
+
+
+                    .on("click.carloSpecialLongPress", function (evt) {
+
+
+                        if (specialLongPressTriggeredMode !== mode) {
+
+
+                            return;
+
+
+                        }
+
+
+                        evt.preventDefault();
+
+
+                        evt.stopImmediatePropagation();
+
+
+                        specialLongPressActivationMode = mode;
+
+
+                        $checkbox.prop("checked", true).trigger("change");
+
+
+                        specialLongPressTriggeredMode = "";
+
+
+                    });
+
+
+            });
+
+
+        }
+
+
+
+        function toggleMultiGridFields() {
+
+
+            const multiGrid = $("#node-input-multiGrid").is(":checked");
+
+
+            const bessControl = $("#node-input-bessControl").is(":checked");
+
+
+            const controlExportReactive = $("#node-input-controlExportReactive").is(":checked");
+
+
+            const scadaServer = $("#node-input-scadaServer").is(":checked");
+
+
+            const influxDb = $("#node-input-influxDb").is(":checked");
+
+
+            const specialMode = multiGrid || bessControl || controlExportReactive || scadaServer || influxDb;
+
+
+
+            if (specialMode) {
+
+
+                $("#row-meter-id").show();
+
+
+            } else {
+
+
+                $("#row-meter-id").hide();
+
+
+            }
+
+
+
+            $("#node-input-payloadMode").prop("disabled", multiGrid || bessControl || controlExportReactive || scadaServer || influxDb);
+
+
+            $("#row-influx-measurement,#row-influx-node").toggle(influxDb);
+
+
+            syncPayloadModeUi();
+
+
+        }
+
+
+
+        RED.nodes.registerType("carlo-gavazzi", {
+
+
+            category: "Atelierul de Tehnologii",
+
+
+            color: "#c7e9c0",
+
+
+            defaults: {
+            license: { value: "", type: "atelier-license", required: true },
+
+
+                name: { value: "" },
+
+
+                host: { value: "", required: true },
+
+
+                port: { value: 502, required: true, validate: RED.validators.number() },
+
+
+                unitId: { value: 1, required: true, validate: RED.validators.number() },
+
+
+                timestep: {
+                    value: 1000,
+                    required: true,
+                    validate: function (v) {
+                        const text = String(v || "").trim().toLowerCase();
+                        const n = Number(text);
+                        return text === "off" || (Number.isFinite(n) && n >= 0);
+                    }
+                },
+
+
+                payloadFields: { value: ["full"] },
+
+
+                payloadMode: { value: "full" },
+
+
+                multiGrid: { value: false },
+
+
+                bessControl: { value: false },
+
+
+                controlExportReactive: { value: false },
+
+
+                scadaServer: { value: false },
+
+
+                influxDb: { value: false },
+
+
+                influxMeasurement: {
+
+
+                    value: "",
+
+
+                    validate: function (v) {
+
+
+                        const influxChecked = $("#node-input-influxDb").length
+
+
+                            ? $("#node-input-influxDb").is(":checked")
+
+
+                            : !!this.influxDb;
+
+
+
+                        return !influxChecked || !!String(v || "").trim();
+
+
+                    }
+
+
+                },
+
+
+                expertMode: { value: false },
+
+
+                multiGridCustomFields: { value: [] },
+
+
+                bessControlCustomFields: { value: [] },
+
+
+                controlExportReactiveCustomFields: { value: [] },
+
+
+                scadaServerCustomFields: { value: [] },
+
+
+                influxNode: { value: "" },
+                influxDbCustomFields: { value: [] },
+
+
+                multiGridUseSelectedFields: { value: false },
+
+
+                bessControlUseSelectedFields: { value: false },
+
+
+                controlExportReactiveUseSelectedFields: { value: false },
+
+
+                scadaServerUseSelectedFields: { value: false },
+
+
+                influxDbUseSelectedFields: { value: false },
+
+
+                meterId: {
+
+
+                    value: "",
+
+
+                    validate: function (v) {
+
+
+                        const isSpecial = (
+
+
+                            $("#node-input-multiGrid").is(":checked") ||
+
+
+                            $("#node-input-bessControl").is(":checked") ||
+
+
+                            $("#node-input-controlExportReactive").is(":checked") ||
+
+
+                            $("#node-input-scadaServer").is(":checked") ||
+
+
+                            $("#node-input-influxDb").is(":checked")
+
+
+                        );
+
+
+                        if (!isSpecial) {
+
+
+                            return true;
+
+
+                        }
+
+
+                        return !!String(v || "").trim();
+
+
+                    }
+
+
+                },
+
+
+                outputs: { value: 1 }
+
+
+            },
+
+
+            inputs: 0,
+
+
+            outputs: 1,
+
+
+            icon: "bridge.svg",
+
+
+            label: function () {
+
+
+                if (this.name && String(this.name).trim()) {
+
+
+                    return this.name;
+
+
+                }
+
+
+
+                if (this.host && String(this.host).trim()) {
+
+
+                    return String(this.host).trim();
+
+
+                }
+
+
+
+                return "carlo-gavazzi";
+
+
+            },
+
+
+            oneditprepare: function () {
+                const node = this;
+                const influxSelect = $("#node-input-influxNode").empty().append($("<option></option>").val("").text("Selecteaza adt-influxdb"));
+                RED.nodes.eachNode(function (candidate) {
+                    if (candidate.type === "adt-influxdb") influxSelect.append($("<option></option>").val(candidate.id).text(candidate.name || "adt-influxdb"));
+                });
+                influxSelect.val(node.influxNode || "");
+
+                function syncInputs() {
+                    const text = String($("#node-input-timestep").val() || "").trim().toLowerCase();
+                    node.inputs = text === "off" || text === "0" ? 1 : 0;
+                }
+
+                $("#node-input-timestep").off(".carloPoll").on("keyup.carloPoll change.carloPoll", syncInputs);
+                syncInputs();
+
+
+                const specialMode = getActiveSpecialMode(!!this.multiGrid, !!this.bessControl, !!this.controlExportReactive, !!this.scadaServer, !!this.influxDb);
+
+
+
+                customModeSelections = {
+
+
+                    multiGrid: sanitizeCustomModeSelection(this.multiGridCustomFields),
+
+
+                    bessControl: sanitizeCustomModeSelection(this.bessControlCustomFields),
+
+
+                    controlExportReactive: sanitizeCustomModeSelection(this.controlExportReactiveCustomFields),
+
+
+                    scadaServer: sanitizeCustomModeSelection(this.scadaServerCustomFields),
+
+
+                    influxDb: sanitizeCustomModeSelection(this.influxDbCustomFields)
+
+
+                };
+
+
+                customModeEnabledState = {
+
+
+                    multiGrid: !!this.multiGridUseSelectedFields,
+
+
+                    bessControl: !!this.bessControlUseSelectedFields,
+
+
+                    controlExportReactive: !!this.controlExportReactiveUseSelectedFields,
+
+
+                    scadaServer: !!this.scadaServerUseSelectedFields,
+
+
+                    influxDb: !!this.influxDbUseSelectedFields
+
+
+                };
+
+
+                if (specialMode && this.expertMode) {
+
+
+                    customModeEnabledState[specialMode] = true;
+
+
+                }
+
+
+                specialExpertUnlockedState = {
+
+
+                    multiGrid: false,
+
+
+                    bessControl: false,
+
+
+                    controlExportReactive: false,
+
+
+                    scadaServer: false,
+
+
+                    influxDb: false
+
+
+                };
+
+
+
+                const currentPayloadFields = sanitizeForMode(
+
+
+                    this.payloadFields || ["full"],
+
+
+                    !!this.multiGrid,
+
+
+                    !!this.bessControl,
+
+
+                    !!this.controlExportReactive,
+
+
+                    !!this.scadaServer,
+
+
+                    !!this.influxDb,
+
+
+                    { allowEmptySpecial: !!(specialMode && (this.expertMode || customModeEnabledState[specialMode])) }
+
+
+                );
+
+
+                const initialPayloadMode = (this.multiGrid || this.bessControl || this.controlExportReactive || this.scadaServer || this.influxDb) ? "selected" : ((currentPayloadFields.includes("full") || !currentPayloadFields.length) ? "full" : "selected");
+
+
+                const savedName = String(this.name || "").trim();
+                const savedHost = String(this.host || "").trim();
+                let nameManuallyEdited = !!savedName && savedName !== savedHost && savedName !== "carlo-gavazzi";
+
+
+
+                if (!this.name && this.host) {
+
+
+                    $("#node-input-name").val(this.host);
+
+
+                }
+
+
+
+                payloadSelectionState = (specialMode && (this.expertMode || customModeEnabledState[specialMode]))
+
+
+                    ? customModeSelections[specialMode].slice()
+
+
+                    : currentPayloadFields.slice();
+
+
+                $("#node-input-payloadMode").val(initialPayloadMode);
+
+
+                $("#node-input-expertMode").prop("checked", false);
+
+
+                $("#node-input-payloadFields").val(JSON.stringify(payloadSelectionState));
+
+
+                $("#node-input-outputs").val(getSelectedOutputCount({
+
+
+                    multiGrid: $("#node-input-multiGrid").is(":checked"),
+
+
+                    bessControl: $("#node-input-bessControl").is(":checked"),
+
+
+                    controlExportReactive: $("#node-input-controlExportReactive").is(":checked"),
+
+
+                    scadaServer: $("#node-input-scadaServer").is(":checked"),
+
+
+                    influxDb: $("#node-input-influxDb").is(":checked"),
+
+
+                    payloadFields: currentPayloadFields
+
+
+                }));
+
+
+
+                renderFieldSelection(currentPayloadFields);
+
+
+
+                $("#node-input-name")
+
+
+                    .off(".carloName")
+
+
+                    .on("input.carloName", function () {
+
+
+                        const currentName = String($(this).val() || "").trim();
+                        const currentHost = String($("#node-input-host").val() || "").trim();
+                        nameManuallyEdited = !!currentName && currentName !== currentHost;
+
+
+                    });
+
+
+
+                $("#node-input-host")
+
+
+                    .off(".carloHostSync")
+
+
+                    .on("input.carloHostSync change.carloHostSync", function () {
+
+
+                        const newHost = String($(this).val() || "").trim();
+
+
+                        if (newHost || !$("#node-input-name").val().trim()) {
+
+
+                            $("#node-input-name").val(newHost);
+
+
+                        }
+
+
+                    });
+
+
+                $("#node-input-payloadMode")
+
+
+                    .off(".carloPayloadMode")
+
+
+                    .on("change.carloPayloadMode", function () {
+
+
+                        syncPayloadModeUi();
+
+
+                    });
+
+
+                $("#node-input-expertMode")
+
+
+                    .off(".carloExpert")
+
+
+                    .on("change.carloExpert", function () {
+
+
+                        const activeMode = getActiveSpecialMode(
+
+
+                            $("#node-input-multiGrid").is(":checked"),
+
+
+                            $("#node-input-bessControl").is(":checked"),
+
+
+                            $("#node-input-controlExportReactive").is(":checked"),
+
+
+                            $("#node-input-scadaServer").is(":checked"),
+
+
+                            $("#node-input-influxDb").is(":checked")
+
+
+                        );
+
+
+
+                        if (activeMode) {
+
+
+                            if ($(this).is(":checked")) {
+
+
+                                customModeEnabledState[activeMode] = true;
+
+
+                                payloadSelectionState = customModeSelections[activeMode].slice();
+
+
+                            } else if (specialExpertUnlockedState[activeMode]) {
+
+
+                                customModeEnabledState[activeMode] = false;
+
+
+                                customModeSelections[activeMode] = sanitizeCustomModeSelection(payloadSelectionState);
+
+
+                            }
+
+
+                        }
+
+
+                        syncPayloadModeUi();
+
+
+                    });
+
+
+
+                $("#node-carlo-gavazzi-select-all")
+
+
+                    .off(".carloToolbar")
+
+
+                    .on("click.carloToolbar", function (evt) {
+
+
+                        evt.preventDefault();
+
+
+                        persistPayloadSelection(getAllSelectableFields(), { allowEmptySpecial: true });
+
+
+                        syncPayloadModeUi();
+
+
+                    });
+
+
+
+                $("#node-carlo-gavazzi-clear-all")
+
+
+                    .off(".carloToolbar")
+
+
+                    .on("click.carloToolbar", function (evt) {
+
+
+                        evt.preventDefault();
+
+
+                        persistPayloadSelection([], { allowEmptySpecial: true });
+
+
+                        syncPayloadModeUi();
+
+
+                    });
+
+
+
+                $("#node-carlo-gavazzi-default-values")
+
+
+                    .off(".carloToolbar")
+
+
+                    .on("click.carloToolbar", function (evt) {
+
+
+                        evt.preventDefault();
+
+
+                        const mode = getActiveSpecialMode(
+
+
+                            $("#node-input-multiGrid").is(":checked"),
+
+
+                            $("#node-input-bessControl").is(":checked"),
+
+
+                            $("#node-input-controlExportReactive").is(":checked"),
+
+
+                            $("#node-input-scadaServer").is(":checked"),
+
+
+                            $("#node-input-influxDb").is(":checked")
+
+
+                        );
+
+
+
+                        if (!mode) {
+
+
+                            return;
+
+
+                        }
+
+
+
+                        persistPayloadSelection(getDefaultFieldsForMode(mode), { allowEmptySpecial: true });
+
+
+                        syncPayloadModeUi();
+
+
+                    });
+
+
+
+                $("#node-input-multiGrid")
+
+
+                    .off(".carloMulti")
+
+
+                    .on("change.carloMulti", function () {
+
+
+                        const activatedByLongPress = specialLongPressActivationMode === "multiGrid";
+
+
+                        const previousMode = getActiveSpecialMode(
+
+
+                            !$(this).is(":checked"),
+
+
+                            $("#node-input-bessControl").is(":checked"),
+
+
+                            $("#node-input-controlExportReactive").is(":checked"),
+
+
+                            $("#node-input-scadaServer").is(":checked"),
+
+
+                            $("#node-input-influxDb").is(":checked")
+
+
+                        );
+
+
+                        if (previousMode && ($("#node-input-expertMode").is(":checked") || customModeEnabledState[previousMode])) {
+
+
+                            customModeSelections[previousMode] = sanitizeCustomModeSelection(payloadSelectionState);
+
+
+                        }
+
+
+                        if ($(this).is(":checked")) {
+
+
+                            $("#node-input-bessControl").prop("checked", false);
+
+
+                            $("#node-input-controlExportReactive").prop("checked", false);
+
+
+                            $("#node-input-scadaServer").prop("checked", false);
+
+
+                            // InfluxDB poate ramane activ impreuna cu integrarea principala.
+
+
+                            if (!activatedByLongPress) {
+
+
+                                $("#node-input-expertMode").prop("checked", false);
+
+
+                                specialExpertUnlockedState.multiGrid = false;
+
+
+                                specialExpertUnlockedState.bessControl = false;
+
+
+                                specialExpertUnlockedState.controlExportReactive = false;
+
+
+                                specialExpertUnlockedState.scadaServer = false;
+
+
+                                specialExpertUnlockedState.influxDb = false;
+
+
+                            } else {
+
+
+                                specialExpertUnlockedState.multiGrid = true;
+
+
+                            }
+
+
+                        } else {
+
+
+                            specialExpertUnlockedState.multiGrid = false;
+
+
+                        }
+
+
+                        specialLongPressActivationMode = "";
+
+
+                        toggleMultiGridFields();
+
+
+                        persistPayloadSelection(payloadSelectionState, { allowEmptySpecial: true });
+
+
+                    });
+
+
+                $("#node-input-bessControl")
+
+
+                    .off(".carloBess")
+
+
+                    .on("change.carloBess", function () {
+
+
+                        const activatedByLongPress = specialLongPressActivationMode === "bessControl";
+
+
+                        const previousMode = getActiveSpecialMode(
+
+
+                            $("#node-input-multiGrid").is(":checked"),
+
+
+                            !$(this).is(":checked"),
+
+
+                            $("#node-input-controlExportReactive").is(":checked"),
+
+
+                            $("#node-input-scadaServer").is(":checked"),
+
+
+                            $("#node-input-influxDb").is(":checked")
+
+
+                        );
+
+
+                        if (previousMode && ($("#node-input-expertMode").is(":checked") || customModeEnabledState[previousMode])) {
+
+
+                            customModeSelections[previousMode] = sanitizeCustomModeSelection(payloadSelectionState);
+
+
+                        }
+
+
+                        if ($(this).is(":checked")) {
+
+
+                            $("#node-input-multiGrid").prop("checked", false);
+
+
+                            $("#node-input-controlExportReactive").prop("checked", false);
+
+
+                            $("#node-input-scadaServer").prop("checked", false);
+
+
+                            // InfluxDB poate ramane activ impreuna cu integrarea principala.
+
+
+                            if (!activatedByLongPress) {
+
+
+                                $("#node-input-expertMode").prop("checked", false);
+
+
+                                specialExpertUnlockedState.multiGrid = false;
+
+
+                                specialExpertUnlockedState.bessControl = false;
+
+
+                                specialExpertUnlockedState.controlExportReactive = false;
+
+
+                                specialExpertUnlockedState.scadaServer = false;
+
+
+                                specialExpertUnlockedState.influxDb = false;
+
+
+                            } else {
+
+
+                                specialExpertUnlockedState.bessControl = true;
+
+
+                            }
+
+
+                        } else {
+
+
+                            specialExpertUnlockedState.bessControl = false;
+
+
+                        }
+
+
+                        specialLongPressActivationMode = "";
+
+
+                        toggleMultiGridFields();
+
+
+                        persistPayloadSelection(payloadSelectionState, { allowEmptySpecial: true });
+
+
+                    });
+
+
+
+                $("#node-input-controlExportReactive")
+
+
+                    .off(".carloCER")
+
+
+                    .on("change.carloCER", function () {
+
+
+                        const activatedByLongPress = specialLongPressActivationMode === "controlExportReactive";
+
+
+                        const previousMode = getActiveSpecialMode(
+
+
+                            $("#node-input-multiGrid").is(":checked"),
+
+
+                            $("#node-input-bessControl").is(":checked"),
+
+
+                            !$(this).is(":checked"),
+
+
+                            $("#node-input-scadaServer").is(":checked"),
+
+
+                            $("#node-input-influxDb").is(":checked")
+
+
+                        );
+
+
+                        if (previousMode && ($("#node-input-expertMode").is(":checked") || customModeEnabledState[previousMode])) {
+
+
+                            customModeSelections[previousMode] = sanitizeCustomModeSelection(payloadSelectionState);
+
+
+                        }
+
+
+                        if ($(this).is(":checked")) {
+
+
+                            $("#node-input-multiGrid").prop("checked", false);
+
+
+                            $("#node-input-bessControl").prop("checked", false);
+
+
+                            $("#node-input-scadaServer").prop("checked", false);
+
+
+                            // InfluxDB poate ramane activ impreuna cu integrarea principala.
+
+
+                            if (!activatedByLongPress) {
+
+
+                                $("#node-input-expertMode").prop("checked", false);
+
+
+                                specialExpertUnlockedState.multiGrid = false;
+
+
+                                specialExpertUnlockedState.bessControl = false;
+
+
+                                specialExpertUnlockedState.controlExportReactive = false;
+
+
+                                specialExpertUnlockedState.scadaServer = false;
+
+
+                                specialExpertUnlockedState.influxDb = false;
+
+
+                            } else {
+
+
+                                specialExpertUnlockedState.controlExportReactive = true;
+
+
+                            }
+
+
+                        } else {
+
+
+                            specialExpertUnlockedState.controlExportReactive = false;
+
+
+                        }
+
+
+                        specialLongPressActivationMode = "";
+
+
+                        toggleMultiGridFields();
+
+
+                        persistPayloadSelection(payloadSelectionState, { allowEmptySpecial: true });
+
+
+                    });
+
+
+
+                $("#node-input-scadaServer")
+
+
+                    .off(".carloScada")
+
+
+                    .on("change.carloScada", function () {
+
+
+                        const activatedByLongPress = specialLongPressActivationMode === "scadaServer";
+
+
+                        const previousMode = getActiveSpecialMode(
+
+
+                            $("#node-input-multiGrid").is(":checked"),
+
+
+                            $("#node-input-bessControl").is(":checked"),
+
+
+                            $("#node-input-controlExportReactive").is(":checked"),
+
+
+                            !$(this).is(":checked"),
+
+
+                            $("#node-input-influxDb").is(":checked")
+
+
+                        );
+
+
+                        if (previousMode && ($("#node-input-expertMode").is(":checked") || customModeEnabledState[previousMode])) {
+
+
+                            customModeSelections[previousMode] = sanitizeCustomModeSelection(payloadSelectionState);
+
+
+                        }
+
+
+                        if ($(this).is(":checked")) {
+
+
+                            $("#node-input-multiGrid").prop("checked", false);
+
+
+                            $("#node-input-bessControl").prop("checked", false);
+
+
+                            $("#node-input-controlExportReactive").prop("checked", false);
+
+
+                            // InfluxDB poate ramane activ impreuna cu integrarea principala.
+
+
+                            if (!activatedByLongPress) {
+
+
+                                $("#node-input-expertMode").prop("checked", false);
+
+
+                                specialExpertUnlockedState.multiGrid = false;
+
+
+                                specialExpertUnlockedState.bessControl = false;
+
+
+                                specialExpertUnlockedState.controlExportReactive = false;
+
+
+                                specialExpertUnlockedState.scadaServer = false;
+
+
+                                specialExpertUnlockedState.influxDb = false;
+
+
+                            } else {
+
+
+                                specialExpertUnlockedState.scadaServer = true;
+
+
+                            }
+
+
+                        } else {
+
+
+                            specialExpertUnlockedState.scadaServer = false;
+
+
+                        }
+
+
+                        specialLongPressActivationMode = "";
+
+
+                        toggleMultiGridFields();
+
+
+                        persistPayloadSelection(payloadSelectionState, { allowEmptySpecial: true });
+
+
+                    });
+
+
+
+                $("#node-input-influxDb")
+
+
+                    .off(".carloInflux")
+
+
+                    .on("change.carloInflux", function () {
+
+
+                        const activatedByLongPress = specialLongPressActivationMode === "influxDb";
+
+
+                        const previousMode = getActiveSpecialMode(
+
+
+                            $("#node-input-multiGrid").is(":checked"),
+
+
+                            $("#node-input-bessControl").is(":checked"),
+
+
+                            $("#node-input-controlExportReactive").is(":checked"),
+
+
+                            $("#node-input-scadaServer").is(":checked"),
+
+
+                            !$(this).is(":checked")
+
+
+                        );
+
+
+                        if (previousMode && ($("#node-input-expertMode").is(":checked") || customModeEnabledState[previousMode])) {
+
+
+                            customModeSelections[previousMode] = sanitizeCustomModeSelection(payloadSelectionState);
+
+
+                        }
+
+
+                        if ($(this).is(":checked")) {
+
+
+                            // Pastreaza cel mult integrarea principala deja activa.
+
+
+                            if (!activatedByLongPress) {
+
+
+                                $("#node-input-expertMode").prop("checked", false);
+
+
+                                specialExpertUnlockedState.multiGrid = false;
+
+
+                                specialExpertUnlockedState.bessControl = false;
+
+
+                                specialExpertUnlockedState.controlExportReactive = false;
+
+
+                                specialExpertUnlockedState.scadaServer = false;
+
+
+                                specialExpertUnlockedState.influxDb = false;
+
+
+                            } else {
+
+
+                                specialExpertUnlockedState.influxDb = true;
+
+
+                            }
+
+
+                        } else {
+
+
+                            specialExpertUnlockedState.influxDb = false;
+
+
+                        }
+
+
+                        specialLongPressActivationMode = "";
+
+
+                        toggleMultiGridFields();
+
+
+                        persistPayloadSelection(payloadSelectionState, { allowEmptySpecial: true });
+
+
+                    });
+
+
+
+                setupSpecialModeLongPress();
+
+
+                toggleMultiGridFields();
+
+
+            },
+
+
+            oneditsave: function () {
+
+
+                const multiGrid = $("#node-input-multiGrid").is(":checked");
+
+
+                const bessControl = $("#node-input-bessControl").is(":checked");
+
+
+                const controlExportReactive = $("#node-input-controlExportReactive").is(":checked");
+
+
+                const scadaServer = $("#node-input-scadaServer").is(":checked");
+
+
+                const influxDb = $("#node-input-influxDb").is(":checked");
+
+
+                const specialMode = getActiveSpecialMode(multiGrid, bessControl, controlExportReactive, scadaServer, influxDb);
+
+
+                const expertMode = $("#node-input-expertMode").is(":checked");
+
+
+                const modeCustomEnabled = !!(specialMode && (customModeEnabledState[specialMode] || expertMode));
+
+
+                let selected = sanitizeForMode(payloadSelectionState, multiGrid, bessControl, controlExportReactive, scadaServer, influxDb, { allowEmptySpecial: !!(specialMode && modeCustomEnabled) });
+
+
+
+                if (specialMode && expertMode) {
+
+
+                    customModeEnabledState[specialMode] = true;
+
+
+                    customModeSelections[specialMode] = sanitizeCustomModeSelection(selected);
+
+
+                }
+
+
+
+                if (specialMode && customModeEnabledState[specialMode]) {
+
+
+                    this.payloadFields = selected.slice();
+
+
+                } else if (specialMode) {
+
+
+                    this.payloadFields = getDefaultFieldsForMode(specialMode);
+
+
+                } else {
+
+
+                    this.payloadFields = selected.includes("full") ? ["full"] : selected.slice();
+
+
+                }
+
+
+
+                this.expertMode = false;
+
+
+                this.multiGridCustomFields = customModeSelections.multiGrid.slice();
+
+
+                this.bessControlCustomFields = customModeSelections.bessControl.slice();
+
+
+                this.controlExportReactiveCustomFields = customModeSelections.controlExportReactive.slice();
+
+
+                this.scadaServerCustomFields = customModeSelections.scadaServer.slice();
+
+
+                this.influxDbCustomFields = customModeSelections.influxDb.slice();
+
+
+                this.multiGridUseSelectedFields = !!customModeEnabledState.multiGrid;
+
+
+                this.bessControlUseSelectedFields = !!customModeEnabledState.bessControl;
+
+
+                this.controlExportReactiveUseSelectedFields = !!customModeEnabledState.controlExportReactive;
+
+
+                this.scadaServerUseSelectedFields = !!customModeEnabledState.scadaServer;
+
+
+                this.influxDbUseSelectedFields = !!customModeEnabledState.influxDb;
+
+
+                this.influxDb = influxDb;
+
+
+                this.influxMeasurement = String($("#node-input-influxMeasurement").val() || "").trim();
+                const timestepText = String($("#node-input-timestep").val() || "").trim().toLowerCase();
+                this.inputs = timestepText === "off" || timestepText === "0" ? 1 : 0;
+
+
+                this.outputs = getSelectedOutputCount({
+
+
+                    multiGrid: multiGrid,
+
+
+                    bessControl: bessControl,
+
+
+                    controlExportReactive: controlExportReactive,
+
+
+                    scadaServer: scadaServer,
+
+
+                    influxDb: influxDb,
+
+
+                    payloadFields: this.payloadFields
+
+
+                });
+
+
+
+                if (!this.name || !String(this.name).trim()) {
+
+
+                    this.name = String($("#node-input-host").val() || "").trim();
+
+
+                    $("#node-input-name").val(this.name);
+
+
+                }
+
+
+
+                $("#node-input-payloadFields").val(JSON.stringify(this.payloadFields));
+
+
+                $("#node-input-outputs").val(this.outputs);
+
+
+
+                $("#node-input-host").off(".carloHostSync");
+
+
+                $("#node-input-name").off(".carloName");
+
+
+                $("#node-input-payloadMode").off(".carloPayloadMode");
+
+
+                $("#node-input-expertMode").off(".carloExpert");
+
+
+                $("#node-carlo-gavazzi-select-all").off(".carloToolbar");
+
+
+                $("#node-carlo-gavazzi-clear-all").off(".carloToolbar");
+
+
+                $("#node-carlo-gavazzi-default-values").off(".carloToolbar");
+
+
+                $("#node-input-multiGrid").off(".carloMulti");
+
+
+                $("#node-input-bessControl").off(".carloBess");
+
+
+                $("#node-input-controlExportReactive").off(".carloCER");
+
+
+                $("#node-input-scadaServer").off(".carloScada");
+
+
+                $("#node-input-influxDb").off(".carloInflux");
+
+
+                $("#node-input-multiGrid").off(".carloSpecialLongPress");
+
+
+                $("#node-input-bessControl").off(".carloSpecialLongPress");
+
+
+                $("#node-input-controlExportReactive").off(".carloSpecialLongPress");
+
+
+                $("#node-input-scadaServer").off(".carloSpecialLongPress");
+
+
+                $("#node-input-influxDb").off(".carloSpecialLongPress");
+
+
+                clearSpecialLongPressTimer();
+
+
+            },
+
+
+            oneditcancel: function () {
+
+
+                $("#node-input-host").off(".carloHostSync");
+
+
+                $("#node-input-name").off(".carloName");
+
+
+                $("#node-input-payloadMode").off(".carloPayloadMode");
+
+
+                $("#node-input-expertMode").off(".carloExpert");
+
+
+                $("#node-carlo-gavazzi-select-all").off(".carloToolbar");
+
+
+                $("#node-carlo-gavazzi-clear-all").off(".carloToolbar");
+
+
+                $("#node-carlo-gavazzi-default-values").off(".carloToolbar");
+
+
+                $("#node-input-multiGrid").off(".carloMulti");
+
+
+                $("#node-input-bessControl").off(".carloBess");
+
+
+                $("#node-input-controlExportReactive").off(".carloCER");
+
+
+                $("#node-input-scadaServer").off(".carloScada");
+
+
+                $("#node-input-influxDb").off(".carloInflux");
+
+
+                $("#node-input-multiGrid").off(".carloSpecialLongPress");
+
+
+                $("#node-input-bessControl").off(".carloSpecialLongPress");
+
+
+                $("#node-input-controlExportReactive").off(".carloSpecialLongPress");
+
+
+                $("#node-input-scadaServer").off(".carloSpecialLongPress");
+
+
+                $("#node-input-influxDb").off(".carloSpecialLongPress");
+
+
+                clearSpecialLongPressTimer();
+
+
+            }
+
+
+        });
+
+
+
+    })();
+
+
+</script>
+
+
+
+<script type="text/html" data-template-name="carlo-gavazzi">
+    <div class="form-row"><label for="node-input-license"><i class="fa fa-key"></i> License</label><input type="text" id="node-input-license"></div>
+
+
+    <div class="carlo-gavazzi-editor">
+
+
+        <div class="pr-section">
+
+
+            <div class="pr-section-title"><i class="fa fa-plug"></i> Connection</div>
+
+
+            <p class="pr-section-note">Configuratia de citire Modbus TCP pentru meterul Carlo Gavazzi.</p>
+
+
+
+            <div class="pr-grid pr-grid-2">
+
+
+                <div class="form-row">
+
+
+                    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+
+
+                    <input type="text" id="node-input-name" placeholder="192.168.0.110">
+
+
+                </div>
+
+
+
+                <div class="form-row" id="row-meter-id" style="display:none;">
+
+
+                    <label for="node-input-meterId"><i class="fa fa-id-badge"></i> Meter ID</label>
+
+
+                    <input type="text" id="node-input-meterId" placeholder="meter1">
+
+
+                </div>
+
+
+
+                <div class="form-row">
+
+
+                    <label for="node-input-host"><i class="fa fa-globe"></i> Host</label>
+
+
+                    <input type="text" id="node-input-host" placeholder="192.168.0.110">
+
+
+                </div>
+
+
+
+                <div class="form-row">
+
+
+                    <label for="node-input-port"><i class="fa fa-ellipsis-h"></i> Port</label>
+
+
+                    <input type="text" id="node-input-port" placeholder="502">
+
+
+                </div>
+
+
+
+                <div class="form-row">
+
+
+                    <label for="node-input-unitId"><i class="fa fa-hashtag"></i> Unit ID</label>
+
+
+                    <input type="text" id="node-input-unitId" placeholder="1">
+
+
+                </div>
+
+
+
+                <div class="form-row">
+
+
+                    <label for="node-input-timestep"><i class="fa fa-refresh"></i> Poll interval</label>
+
+
+                    <input type="text" id="node-input-timestep" placeholder="1000 sau off">
+
+
+                </div>
+
+
+            </div>
+
+
+        </div>
+
+
+
+        <div class="pr-section">
+
+
+            <div class="pr-section-title"><i class="fa fa-filter"></i> Payload</div>
+
+
+            <p class="pr-section-note">Poti citi tot payload-ul sau doar campurile selectate.</p>
+
+
+
+            <div class="form-row">
+
+
+                <label for="node-input-payloadMode"><i class="fa fa-list"></i> Payload mode</label>
+
+
+                <select id="node-input-payloadMode">
+
+
+                    <option value="full">Full payload</option>
+
+
+                    <option value="selected">Selected fields</option>
+
+
+                </select>
+
+
+            </div>
+
+
+
+            <input type="hidden" id="node-input-payloadFields">
+
+
+            <input type="hidden" id="node-input-outputs">
+
+
+
+            <div class="form-row pr-checkbox-row">
+
+
+                <label for="node-input-multiGrid"><i class="fa fa-sitemap"></i> Multi-grid</label>
+
+
+                <input type="checkbox" id="node-input-multiGrid">
+
+
+                <span class="pr-inline-note">Transforma iesirea intr-un payload compact pentru agregare in <code>multi-grid</code>.</span>
+
+
+            </div>
+
+
+
+            <div class="form-row pr-checkbox-row">
+
+
+                <label for="node-input-bessControl"><i class="fa fa-link"></i> BESS control</label>
+
+
+                <input type="checkbox" id="node-input-bessControl">
+
+
+                <span class="pr-inline-note">Transforma iesirea intr-un payload compact pentru <code>bess-control</code>.</span>
+
+
+            </div>
+
+
+
+            <div class="form-row pr-checkbox-row">
+
+
+                <label for="node-input-controlExportReactive"><i class="fa fa-bolt"></i> Control export/reactive</label>
+
+
+                <input type="checkbox" id="node-input-controlExportReactive">
+
+
+                <span class="pr-inline-note">Transforma iesirea intr-un payload compact cu putere activa si reactiva pentru <code>control-export</code> si <code>control-reactive</code>.</span>
+
+
+            </div>
+
+
+
+            <div class="form-row pr-checkbox-row">
+
+
+                <label for="node-input-scadaServer"><i class="fa fa-server"></i> SCADA server</label>
+
+
+                <input type="checkbox" id="node-input-scadaServer">
+
+
+                <span class="pr-inline-note">Transforma iesirea intr-un payload compact pentru nodul <code>scada-server</code>.</span>
+
+
+            </div>
+
+
+
+            <div class="form-row pr-checkbox-row">
+
+
+                <label for="node-input-influxDb"><i class="fa fa-database"></i> InfluxDB</label>
+
+
+                <input type="checkbox" id="node-input-influxDb">
+
+
+                <span class="pr-inline-note">Grupeaza valorile meterului in <code>msg.influx</code> pentru nodul <code>adt-influxdb</code>.</span>
+
+
+            </div>
+
+
+
+            <div class="form-row" id="row-influx-measurement" style="display:none;">
+
+
+                <label for="node-input-influxMeasurement"><i class="fa fa-line-chart"></i> Measurement</label>
+
+
+                <input type="text" id="node-input-influxMeasurement" placeholder="Grid Meter">
+
+
+            </div>
+            <div class="form-row" id="row-influx-node" style="display:none;">
+                <label for="node-input-influxNode"><i class="fa fa-plug"></i> Nod InfluxDB</label>
+                <select id="node-input-influxNode"></select>
+            </div>
+
+
+
+            <div class="form-row pr-checkbox-row" id="row-expert-mode" style="display:none;">
+
+
+                <label for="node-input-expertMode"><i class="fa fa-wrench"></i> Custom fields</label>
+
+
+                <input type="checkbox" id="node-input-expertMode">
+
+
+                <span class="pr-inline-note">Activeaza editarea manuala a campurilor presetate.</span>
+
+
+            </div>
+
+
+
+            <div id="row-carlo-gavazzi-field-list" style="display:none;">
+
+
+                <div class="pr-toolbar">
+
+
+                    <a href="#" class="button" id="node-carlo-gavazzi-select-all"><i class="fa fa-check-square-o"></i> Select all</a>
+
+
+                    <a href="#" class="button" id="node-carlo-gavazzi-clear-all"><i class="fa fa-square-o"></i> Clear all</a>
+
+
+                    <a href="#" class="button" id="node-carlo-gavazzi-default-values" style="display:none;"><i class="fa fa-undo"></i> Default values</a>
+
+
+                </div>
+
+
+
+                <div id="node-carlo-gavazzi-field-list-container" class="pr-field-list"></div>
+
+
+            </div>
+
+
+
+        </div>
+
+
+    </div>
+
+
+</script>
+
+
+
+<script type="text/html" data-help-name="carlo-gavazzi">
+
+
+    <p>
+
+
+        Nodul <b>carlo-gavazzi</b> citeste un smart meter Carlo Gavazzi prin Modbus TCP si emite valorile
+
+
+        masurate in Node-RED. Citirea se face automat la intervalul setat in <b>Poll interval</b>. Valoarea <code>off</code> sau <code>0</code> opreste citirea periodica si activeaza citirea la trigger pe intrare.
+
+
+    </p>
+
+
+
+    <h3>Conexiune</h3>
+
+
+    <ul>
+
+
+        <li><b>Name</b> este numele afisat in flow. Daca ramane gol, nodul foloseste automat IP-ul.</li>
+
+
+        <li><b>Host</b> este adresa IP a meterului sau a gateway-ului Modbus TCP.</li>
+
+
+        <li><b>Port</b> este portul Modbus TCP, de obicei <code>502</code>.</li>
+
+
+        <li><b>Unit ID</b> este adresa Modbus a meterului.</li>
+
+
+        <li><b>Poll interval</b> este perioada dintre doua citiri succesive; <code>off</code> sau <code>0</code> activeaza citirea manuala pe intrare.</li>
+
+
+    </ul>
+
+
+
+    <h3>Valori citite</h3>
+
+
+    <p>
+
+
+        Nodul citeste tensiuni, curenti, putere activa, putere aparenta, putere reactiva,
+
+
+        factor de putere, frecventa, ordine faze si contoare de energie.
+
+
+    </p>
+
+
+
+    <ul>
+
+
+        <li><code>summary.power.total_w</code> si <code>summary.power.l1_w/l2_w/l3_w</code> pentru putere activa.</li>
+
+
+        <li><code>summary.reactive.total_var</code> si <code>summary.reactive.l1_var/l2_var/l3_var</code> pentru putere reactiva.</li>
+
+
+        <li><code>summary.voltage.*</code> pentru tensiuni faza-nul si faza-faza.</li>
+
+
+        <li><code>summary.current.*</code> pentru curenti.</li>
+
+
+        <li><code>summary.energy.*</code> pentru energii import/export si tarife.</li>
+
+
+    </ul>
+
+
+
+    <h3>Payload mode</h3>
+
+
+    <p>
+
+
+        In <b>Full payload</b>, nodul trimite tot obiectul citit de la meter.
+
+
+        In <b>Selected fields</b>, nodul trimite doar campurile selectate.
+
+
+    </p>
+
+
+
+    <p>
+
+
+        In modul normal, daca este selectat un singur camp, <code>msg.topic</code> contine numele valorii,
+
+
+        iar <code>msg.payload</code> contine valoarea. Daca sunt selectate mai multe campuri, nodul emite
+
+
+        cate un mesaj pentru fiecare camp selectat.
+
+
+    </p>
+
+
+
+    <pre>{
+
+
+  "topic": "Putere totala",
+
+
+  "payload": -850,
+
+
+  "payload_field": "summary.power.total_w"
+
+
+}</pre>
+
+
+
+    <p>
+
+
+        In fiecare mesaj, <code>msg.carloGavazzi</code> contine obiectul complet citit de la meter, util pentru
+
+
+        diagnostic sau pentru alte transformari.
+
+
+    </p>
+
+
+
+    <h3>Control export/reactive</h3>
+
+
+    <p>
+
+
+        Cand este activ <b>Control export/reactive</b>, nodul emite un singur payload compact compatibil cu
+
+
+        <code>control-export</code> si <code>control-reactive</code>. In acest mod, <code>msg.topic</code>
+
+
+        devine <b>Meter ID</b>.
+
+
+    </p>
+
+
+
+    <pre>{
+
+
+  "topic": "meter1",
+
+
+  "meter_id": "meter1",
+
+
+  "payload": {
+
+
+    "power_w": -850,
+
+
+    "power_l1_w": -300,
+
+
+    "power_l2_w": -280,
+
+
+    "power_l3_w": -270,
+
+
+    "reactive_total_var": 420,
+
+
+    "reactive_l1_var": 120,
+
+
+    "reactive_l2_var": 150,
+
+
+    "reactive_l3_var": 150
+
+
+  }
+
+
+}</pre>
+
+
+
+    <p>
+
+
+        <code>control-export</code> foloseste campurile active in W, iar <code>control-reactive</code> foloseste
+
+
+        campurile reactive in VAr. Pentru <code>control-reactive</code> sunt necesare totalul si valorile pe faze.
+
+
+    </p>
+
+
+
+    <h3>Multi-grid</h3>
+
+
+    <p>
+
+
+        Cand este activ <b>Multi-grid</b>, nodul emite un payload compact pentru agregare in <code>multi-grid</code>.
+
+
+        <code>msg.topic</code> si <code>msg.meter_id</code> contin ID-ul meterului.
+
+
+    </p>
+
+
+
+    <h3>BESS control</h3>
+
+
+    <p>
+
+
+        Cand este activ <b>BESS control</b>, nodul emite campurile active necesare pentru <code>bess-control</code>,
+
+
+        de exemplu <code>power_w</code> si puterile pe faze.
+
+
+    </p>
+
+
+
+    <h3>SCADA server</h3>
+
+
+    <p>
+
+
+        Cand este activ <b>SCADA server</b>, nodul foloseste chei compacte potrivite pentru maparea implicita din
+
+
+        <code>scada-server</code>, de exemplu <code>active_power_w</code>, <code>reactive_power_var</code>,
+
+
+        <code>frequency_hz</code> si tensiunile linie-la-linie.
+
+
+    </p>
+
+    <h3>InfluxDB</h3>
+
+
+    <p>
+
+
+        Cand este activ <b>InfluxDB</b>, nodul emite un singur mesaj agregat per citire, cu
+
+
+        <code>msg.influx.measurement</code>, <code>msg.influx.tags</code>, <code>msg.influx.fields</code> si
+
+
+        <code>msg.influx.timestamp</code>, compatibil direct cu nodul <code>adt-influxdb</code>.
+
+
+    </p>
+
+
+    <h3>Moduri speciale</h3>
+
+
+    <p>
+
+
+        Poti activa o singura integrare principala dintre <b>Multi-grid</b>, <b>BESS control</b>, <b>Control export/reactive</b> si <b>SCADA server</b>. <b>InfluxDB</b> poate fi activat simultan cu oricare dintre ele; maximum doua optiuni pot ramane active.
+
+
+        Activeaza un singur mod special pentru o iesire clara si compatibila cu nodul urmator.
+
+
+    </p>
+
+
+
+    <h3>Status</h3>
+
+
+    <ul>
+
+
+        <li><b>verde</b> inseamna citire reusita.</li>
+
+
+        <li><b>galben</b> inseamna citire in curs.</li>
+
+
+        <li><b>rosu</b> inseamna eroare de conexiune, raspuns Modbus invalid sau timeout.</li>
+
+
+    </ul>
+
+
+
+    <h3>Recomandari practice</h3>
+
+
+    <ul>
+
+
+        <li>Pentru <code>control-export</code> si <code>control-reactive</code>, foloseste modul <b>Control export/reactive</b>.</li>
+
+
+        <li>Foloseste un <b>Meter ID</b> stabil daca mai multe metere intra in acelasi flow.</li>
+
+
+        <li>Pastreaza poll intervalul suficient de rapid pentru control, dar nu mai rapid decat poate raspunde meterul.</li>
+
+
+        <li>Daca apar valori inversate, verifica sensul montajului transformatoarelor de curent si conventia de semn in nodurile de control.</li>
+
+
+    </ul>
+
+
+    <h3>Referinta completa parametri</h3>
+
+    <ul>
+
+        <li><code>host</code>, <code>port</code>, <code>unitId</code>: conexiunea Modbus TCP catre contor.</li>
+
+        <li><code>timestep</code>: intervalul de poll in milisecunde; <code>off</code> sau <code>0</code> opreste poll-ul automat si citeste doar la trigger pe intrare.</li>
+
+        <li><code>meterId</code>: identificator stabil emis in <code>msg.topic</code>, <code>msg.meter_id</code> si <code>msg.source_id</code>.</li>
+
+        <li><code>payloadMode</code>: <code>full</code> trimite toate valorile, <code>selected</code> trimite doar <code>payloadFields</code>.</li>
+
+        <li><code>payloadFields</code>: lista campurilor selectate pentru payload normal.</li>
+
+        <li><code>multiGrid</code>, <code>bessControl</code>, <code>controlExportReactive</code>, <code>scadaServer</code>, <code>influxDb</code>: o integrare principala, optional impreuna cu InfluxDB.</li>
+
+        <li><code>influxMeasurement</code>: measurement-ul folosit in <code>msg.influx.measurement</code>.</li>
+
+        <li><code>multiGridCustomFields</code>, <code>bessControlCustomFields</code>, <code>controlExportReactiveCustomFields</code>, <code>scadaServerCustomFields</code>, <code>influxDbCustomFields</code>: selectiile salvate pentru fiecare preset.</li>
+
+        <li><code>multiGridUseSelectedFields</code>, <code>bessControlUseSelectedFields</code>, <code>controlExportReactiveUseSelectedFields</code>, <code>scadaServerUseSelectedFields</code>, <code>influxDbUseSelectedFields</code>: forteaza presetul sa foloseasca lista custom in locul valorilor implicite.</li>
+
+        <li><code>outputs</code>: numarul de iesiri calculat de editor in functie de modul de payload/debug.</li>
+
+    </ul>
+
+
+    <h3>Exemplu pentru control-export/reactive</h3>
+
+    <pre>{
+  "topic": "grid-main",
+  "meter_id": "grid-main",
+  "source_id": "grid-main",
+  "payload": {
+    "power_w": -1200,
+    "power_l1_w": -350,
+    "power_l2_w": -420,
+    "power_l3_w": -430,
+    "reactive_total_var": 180
+  },
+  "timestamp_ms": 1776692400000
+}</pre>
+
+
+</script>
+
+
+
+<script type="text/html" data-help-name="carlo-gavazzi-legacy-disabled">
+
+
+    <p>Node pentru citirea unui smart meter Carlo Gavazzi prin Modbus TCP.</p>
+
+
+    <p>Nod legacy. Foloseste help-ul nodului carlo-gavazzi.</p>
+
+
+</script>
+