@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/sma-read/sma-read.js

@@ -0,0 +1,458 @@
+module.exports = function (RED) {
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+    const ModbusRTU = require("modbus-serial");
+    const RUNTIME_VERSION = require("../package.json").version;
+    const { atLeast } = require("../lib/numbers");
+    const {
+        findBase,
+        scanModelDescriptors,
+        readModelsByDescriptors
+    } = require("./lib/sunspec-core");
+    const { buildSummary } = require("./lib/sunspec-model-parsers");
+
+    const DEFAULT_FIELDS = [
+        "summary.ac.power_w",
+        "summary.dc.power_w",
+        "summary.ac.voltage_l1_v",
+        "summary.ac.voltage_l2_v",
+        "summary.ac.voltage_l3_v",
+        "summary.ac.frequency_hz"
+    ];
+    const DEFAULT_MULTI_GRID_FIELDS = [
+        "summary.meter.power_w",
+        "summary.meter.power_l1_w",
+        "summary.meter.power_l2_w",
+        "summary.meter.power_l3_w"
+    ];
+    const DEFAULT_METER_FIELDS = DEFAULT_MULTI_GRID_FIELDS.concat([
+        "summary.meter.current_total_a",
+        "summary.meter.current_l1_a",
+        "summary.meter.current_l2_a",
+        "summary.meter.current_l3_a",
+        "summary.meter.voltage_ln_avg_v",
+        "summary.meter.voltage_l1_v",
+        "summary.meter.voltage_l2_v",
+        "summary.meter.voltage_l3_v",
+        "summary.meter.frequency_hz",
+        "summary.meter.reactive_power_var",
+        "summary.meter.apparent_power_va",
+        "summary.meter.power_factor"
+    ]);
+    const SUPPORTED_MODEL_IDS = new Set([
+        1,
+        101, 102, 103, 111, 112, 113,
+        120, 121, 122, 123, 160,
+        201, 202, 203, 204, 211, 212, 213, 214
+    ]);
+    const nodeRuntimeState = new Map();
+
+    function supportedDescriptors(descriptors) {
+        return descriptors.filter(function (descriptor) {
+            return SUPPORTED_MODEL_IDS.has(Number(descriptor.model_id));
+        });
+    }
+
+    function pollInterval(value) {
+        const text = String(value === undefined ? "5000" : value).trim().toLowerCase();
+        if (text === "off" || text === "0") return 0;
+        const number = Math.round(Number(text));
+        return Number.isFinite(number) && number > 0 ? Math.max(1000, number) : 5000;
+    }
+
+    function normalizeFields(value) {
+        let fields = value;
+        if (typeof fields === "string") {
+            try { fields = JSON.parse(fields); } catch (error) { fields = [fields]; }
+        }
+        if (!Array.isArray(fields) || !fields.length) return ["full"];
+        const unique = Array.from(new Set(fields.map(function (item) { return String(item || "").trim(); }).filter(Boolean)));
+        return unique.includes("full") ? ["full"] : (unique.length ? unique : ["full"]);
+    }
+
+    function getByPath(source, path) {
+        return String(path || "").split(".").filter(Boolean).reduce(function (current, key) {
+            return current === null || current === undefined ? undefined : current[key];
+        }, source);
+    }
+
+    function setByPath(target, path, value) {
+        const parts = String(path || "").split(".").filter(Boolean);
+        let current = target;
+        parts.forEach(function (part, index) {
+            if (index === parts.length - 1) current[part] = value;
+            else {
+                if (!current[part] || typeof current[part] !== "object") current[part] = {};
+                current = current[part];
+            }
+        });
+    }
+
+    function compactKey(path) {
+        const mappings = {
+            "summary.ac.power_w": "power_w",
+            "summary.meter.power_w": "power_w",
+            "summary.meter.power_l1_w": "power_l1_w",
+            "summary.meter.power_l2_w": "power_l2_w",
+            "summary.meter.power_l3_w": "power_l3_w"
+        };
+        return mappings[path] || String(path || "value").replace(/^summary\./, "").replace(/[^a-zA-Z0-9_]+/g, "_");
+    }
+
+    function flatten(source, prefix, target) {
+        if (!source || typeof source !== "object") return;
+        Object.keys(source).forEach(function (key) {
+            const value = source[key];
+            const path = prefix ? prefix + "_" + key : key;
+            if (typeof value === "number" && Number.isFinite(value)) target[path] = value;
+            else if (typeof value === "boolean" || (typeof value === "string" && value)) target[path] = value;
+            else if (value && typeof value === "object" && !Array.isArray(value)) flatten(value, path, target);
+        });
+    }
+
+    function fieldLabel(path, definitions) {
+        const definition = definitions.find(function (item) { return item.path === path; });
+        const labels = {
+            "summary.ac.power_w": "Putere activa AC",
+            "summary.ac.frequency_hz": "Frecventa",
+            "summary.ac.reactive_power_var": "Putere reactiva",
+            "summary.ac.apparent_power_va": "Putere aparenta",
+            "summary.dc.dc_total_power_w": "Putere DC totala",
+            "summary.common.manufacturer": "Producator",
+            "summary.common.model": "Model",
+            "summary.common.serial": "Numar serial"
+        };
+        return definition ? definition.label : (labels[path] || path);
+    }
+
+    async function connect(client, host, port, unitId, timeout) {
+        if (!client.isOpen) await client.connectTCP(host, { port: port });
+        client.setID(unitId);
+        client.setTimeout(timeout);
+    }
+
+    async function close(client) {
+        try { if (client && client.isOpen) await client.close(); } catch (error) { /* ignore */ }
+    }
+
+    function detectDeviceType(summary) {
+        if (summary && summary.meter) return "smart_meter";
+        if (summary && (summary.ac || summary.dc)) return "inverter";
+        return "unknown";
+    }
+
+    function phaseModeFromDescriptors(descriptors) {
+        const inverterModel = descriptors.find(function (item) {
+            return [101, 102, 103, 111, 112, 113].includes(item.model_id);
+        });
+        if (!inverterModel) return "unknown";
+        if ([101, 111].includes(inverterModel.model_id)) return "single_phase";
+        if ([103, 113].includes(inverterModel.model_id)) return "three_phase";
+        return "split_phase";
+    }
+
+    RED.httpAdmin.get("/sma-read/probe", async function (req, res) {
+        const host = String(req.query.host || "").trim();
+        const port = atLeast(req.query.port, 1, 502);
+        const configuredUnitId = Math.min(247, atLeast(req.query.unitId, 1, 1));
+        const unitIds = Array.from(new Set([configuredUnitId, 126, 3, 1]));
+        const client = new ModbusRTU();
+        if (!host) {
+            res.json({ ok: false, error: "IP lipsa" });
+            return;
+        }
+        try {
+            await connect(client, host, port, configuredUnitId, 3000);
+            const failures = [];
+            for (const unitId of unitIds) {
+                try {
+                    client.setID(unitId);
+                    const base = await findBase(client);
+                    const descriptors = await scanModelDescriptors(client, base);
+                    const readableDescriptors = supportedDescriptors(descriptors);
+                    const models = await readModelsByDescriptors(client, readableDescriptors);
+                    const summary = buildSummary(models);
+                    const deviceType = detectDeviceType(summary);
+                    if (deviceType === "unknown") throw new Error("modele SunSpec neacceptate");
+                    res.json({
+                        ok: true,
+                        host: host,
+                        unit_id: unitId,
+                        configured_unit_id: configuredUnitId,
+                        unit_id_changed: unitId !== configuredUnitId,
+                        device_type: deviceType,
+                        sunspec_base: base,
+                        model_ids: descriptors.map(function (item) { return item.model_id; }),
+                        mppt_count: summary && summary.dc && Array.isArray(summary.dc.mppts) ? summary.dc.mppts.length : 0,
+                        phase_mode: phaseModeFromDescriptors(descriptors),
+                        common: summary.common || null,
+                        meter_model: summary.meter && summary.meter.meter_model || null
+                    });
+                    return;
+                } catch (error) {
+                    failures.push("ID " + unitId + ": " + (error.message || String(error)));
+                }
+            }
+            res.json({ ok: false, error: failures.join("; "), tested_unit_ids: unitIds });
+        } catch (error) {
+            res.json({ ok: false, error: error.message || String(error) });
+        } finally {
+            await close(client);
+        }
+    });
+
+    RED.httpAdmin.get("/sma-read/state/:id", function (req, res) {
+        const state = nodeRuntimeState.get(req.params.id);
+        res.json(state ? { ok: true, state: state } : { ok: false, error: "No cached state" });
+    });
+
+    function SmaReadNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+        node.host = String(config.host || "").trim();
+        node.port = atLeast(config.port, 1, 502);
+        node.unitId = atLeast(config.unitId, 1, 126);
+        node.pollInterval = pollInterval(config.pollInterval);
+        node.timeout = Math.max(500, Number(config.timeout) || 3000);
+        node.payloadFields = normalizeFields(config.payloadFields);
+        node.debugMode = !!config.debugMode;
+        node.multiInverter = !!config.multiInverter;
+        node.controlExport = !!config.controlExport;
+        node.multiGrid = !!config.multiGrid;
+        node.multiInverterExpertMode = !!config.multiInverterExpertMode;
+        node.multiInverterUseSelectedFields = config.multiInverterUseSelectedFields !== undefined
+            ? !!config.multiInverterUseSelectedFields
+            : node.multiInverterExpertMode;
+        node.multiGridUseSelectedFields = !!config.multiGridUseSelectedFields;
+        node.influxDb = !!config.influxDb;
+        if (node.multiGrid) {
+            node.multiInverter = false;
+            node.controlExport = false;
+        } else if (node.controlExport) {
+            node.multiInverter = false;
+        }
+        node.inverterId = String(config.inverterId || "").trim();
+        node.influxMeasurement = String(config.influxMeasurement || "").trim() || "sma_inverter";
+        node.influxNode = String(config.influxNode || "").trim();
+
+        const selectedFields = node.payloadFields;
+        const compactMode = node.multiInverter || node.controlExport || node.multiGrid || node.influxDb;
+        const primaryOutputs = compactMode || selectedFields.includes("full") ? 1 : Math.max(1, selectedFields.length);
+        node.outputs = primaryOutputs + (node.debugMode ? 1 : 0);
+
+        let client = new ModbusRTU();
+        let timer = null;
+        let busy = false;
+        let closing = false;
+        let sunspecBase = null;
+        let sunspecDescriptors = null;
+
+        function makeInfluxFields(envelope, fieldsToEmit) {
+            const fields = {};
+            fieldsToEmit.forEach(function (path) {
+                const value = getByPath(envelope, path);
+                if (value !== null && value !== undefined && ["number", "string", "boolean"].includes(typeof value)) fields[compactKey(path)] = value;
+            });
+            return fields;
+        }
+
+        async function resetClient() {
+            await close(client);
+            client = new ModbusRTU();
+            sunspecBase = null;
+            sunspecDescriptors = null;
+        }
+
+        async function pollOnce() {
+            if (busy || closing) return;
+            busy = true;
+            const readStartedAt = Date.now();
+            try {
+                if (compactMode && !node.inverterId) throw new Error("Inverter ID este obligatoriu pentru modul de integrare selectat.");
+                await connect(client, node.host, node.port, node.unitId, node.timeout);
+                if (sunspecBase === null) sunspecBase = await findBase(client);
+                if (!sunspecDescriptors) sunspecDescriptors = await scanModelDescriptors(client, sunspecBase);
+                const models = await readModelsByDescriptors(client, supportedDescriptors(sunspecDescriptors));
+                const summary = buildSummary(models);
+                const rawData = models;
+                const modelList = sunspecDescriptors.map(function (item) { return { model_id: item.model_id, addr: item.addr, len: item.len }; });
+                const deviceType = detectDeviceType(summary);
+                const customFields = selectedFields.filter(function (field) { return field !== "full"; });
+                const effectiveFields = node.multiGrid
+                    ? (node.multiGridUseSelectedFields && customFields.length ? customFields.slice() : DEFAULT_MULTI_GRID_FIELDS.slice())
+                    : (node.multiInverter || node.controlExport)
+                        ? (node.multiInverterUseSelectedFields && customFields.length
+                            ? customFields.slice()
+                            : [deviceType === "smart_meter" ? "summary.meter.power_w" : "summary.ac.power_w"])
+                        : node.influxDb && selectedFields.includes("full")
+                            ? (deviceType === "smart_meter" ? DEFAULT_METER_FIELDS.slice() : DEFAULT_FIELDS.slice())
+                            : node.influxDb && !node.multiInverterUseSelectedFields
+                                ? (deviceType === "smart_meter" ? DEFAULT_METER_FIELDS.slice() : DEFAULT_FIELDS.slice())
+                                : selectedFields.slice();
+                const now = new Date().toISOString();
+                const readDurationMs = Date.now() - readStartedAt;
+                nodeRuntimeState.set(node.id, {
+                    status: "ok",
+                    host: node.host,
+                    port: node.port,
+                    unit_id: node.unitId,
+                    device_type: deviceType,
+                    sunspec_base: sunspecBase,
+                    model_ids: sunspecDescriptors.map(function (item) { return item.model_id; }),
+                    mppt_count: summary && summary.dc && Array.isArray(summary.dc.mppts) ? summary.dc.mppts.length : 0,
+                    phase_mode: phaseModeFromDescriptors(sunspecDescriptors),
+                    common: summary.common || null,
+                    meter_model: summary.meter && summary.meter.meter_model || null,
+                    payload_fields: selectedFields.slice(),
+                    updated_at: now,
+                    runtime_version: RUNTIME_VERSION,
+                    read_duration_ms: readDurationMs
+                });
+                const envelope = {
+                    status: "ok",
+                    ip: node.host,
+                    unit_id: node.unitId,
+                    profile: "sunspec",
+                    device_type: deviceType,
+                    sunspec_base: sunspecBase,
+                    models: modelList,
+                    summary: summary,
+                    ts: now,
+                    runtime_version: RUNTIME_VERSION,
+                    read_duration_ms: readDurationMs
+                };
+                const power = getByPath(envelope, "summary.ac.power_w");
+                node.status({ fill: "green", shape: "dot", text: power === null || power === undefined ? "online" : String(power) + " W" });
+
+                const debugMessage = node.debugMode ? {
+                    topic: "sma/raw",
+                    payload: { ...envelope, raw_models: rawData },
+                    payload_field: "raw_models"
+                } : null;
+
+                let primary;
+                const secondaryInflux = node.influxDb && !!(node.multiGrid || node.multiInverter || node.controlExport);
+                let influxData = null;
+                if (node.influxDb) {
+                    const fields = makeInfluxFields(envelope, effectiveFields);
+                    influxData = {
+                        measurement: node.influxMeasurement,
+                        tags: { device_type: deviceType === "smart_meter" ? "sma_smart_meter" : "sma_inverter", inverter_id: node.inverterId, host: node.host, unit_id: String(node.unitId) },
+                        fields: fields,
+                        timestamp: now
+                    };
+                    if (!secondaryInflux) primary = {
+                        topic: node.inverterId,
+                        payload: fields,
+                        payload_fields: effectiveFields.slice(),
+                        inverter_id: node.inverterId,
+                        device_type: deviceType,
+                        summary_fragment: envelope.summary,
+                        influx: influxData
+                    };
+                    if (!secondaryInflux) node.send(debugMessage ? [primary, debugMessage] : primary);
+                }
+                if (node.multiGrid) {
+                    const compact = {};
+                    effectiveFields.forEach(function (path) { compact[compactKey(path)] = getByPath(envelope, path); });
+                    primary = {
+                        topic: node.inverterId,
+                        meter_id: node.inverterId,
+                        device_type: deviceType,
+                        ip: node.host,
+                        host: node.host,
+                        port: node.port,
+                        unit_id: node.unitId,
+                        model: envelope.meter_model || "",
+                        payload: compact,
+                        payload_field: "multi",
+                        payload_fields: effectiveFields,
+                        summary_fragment: envelope.summary
+                    };
+                    if (influxData) {
+                        const target = RED.nodes.getNode(node.influxNode);
+                        if (target && typeof target.receive === "function") target.receive({ topic: node.inverterId, payload: influxData.fields, influx: influxData });
+                        else node.warn("SMA Read: selecteaza un nod adt-influxdb pentru integrarea secundara.");
+                    }
+                    node.send(debugMessage ? [primary, debugMessage] : primary);
+                } else if (node.multiInverter || node.controlExport) {
+                    const controlField = deviceType === "smart_meter" ? "summary.meter.power_w" : "summary.ac.power_w";
+                    const compact = {};
+                    effectiveFields.forEach(function (path) { compact[compactKey(path)] = getByPath(envelope, path); });
+                    primary = {
+                        topic: node.inverterId,
+                        inverter_id: node.inverterId,
+                        device_type: deviceType,
+                        payload: node.multiInverterUseSelectedFields ? compact : { power_w: getByPath(envelope, controlField) },
+                        payload_field: node.multiInverterUseSelectedFields ? (effectiveFields[0] || controlField) : controlField,
+                        payload_fields: effectiveFields,
+                        summary_fragment: envelope.summary
+                    };
+                    if (influxData) {
+                        const target = RED.nodes.getNode(node.influxNode);
+                        if (target && typeof target.receive === "function") target.receive({ topic: node.inverterId, payload: influxData.fields, influx: influxData });
+                        else node.warn("SMA Read: selecteaza un nod adt-influxdb pentru integrarea secundara.");
+                    }
+                    node.send(debugMessage ? [primary, debugMessage] : primary);
+                } else if (selectedFields.includes("full")) {
+                    primary = { topic: "full", payload: envelope, payload_field: "full", payload_fields: ["full"], full_payload: envelope };
+                    node.send(debugMessage ? [primary, debugMessage] : primary);
+                } else if (selectedFields.length === 1) {
+                    const path = selectedFields[0];
+                    primary = { topic: fieldLabel(path, []), payload: getByPath(envelope, path), payload_field: path, payload_fields: selectedFields, summary_fragment: envelope.summary };
+                    node.send(debugMessage ? [primary, debugMessage] : primary);
+                } else {
+                    const output = new Array(selectedFields.length + (debugMessage ? 1 : 0)).fill(null);
+                    selectedFields.forEach(function (path, index) {
+                        output[index] = { topic: fieldLabel(path, []), payload: getByPath(envelope, path), payload_field: path, payload_fields: selectedFields, output_index: index, summary_fragment: envelope.summary };
+                    });
+                    if (debugMessage) output[selectedFields.length] = debugMessage;
+                    node.send(output);
+                }
+            } catch (error) {
+                nodeRuntimeState.set(node.id, {
+                    status: "error",
+                    host: node.host,
+                    port: node.port,
+                    unit_id: node.unitId,
+                    error: error.message || String(error),
+                    updated_at: new Date().toISOString()
+                });
+                node.status({ fill: "red", shape: "ring", text: "error" });
+                const message = { topic: "sma/error", payload: { status: "error", ip: node.host, unit_id: node.unitId, runtime_version: RUNTIME_VERSION, read_duration_ms: Date.now() - readStartedAt, error: error.message || String(error), ts: new Date().toISOString() } };
+                if (node.outputs > 1) {
+                    const output = new Array(node.outputs).fill(null);
+                    output[0] = message;
+                    node.send(output);
+                } else node.send(message);
+                await resetClient();
+            } finally {
+                busy = false;
+            }
+        }
+
+        async function loop() {
+            if (closing) return;
+            await pollOnce();
+            if (!closing && node.pollInterval > 0) timer = setTimeout(loop, node.pollInterval);
+        }
+
+        if (node.pollInterval > 0) loop();
+        node.on("input", function () { pollOnce(); });
+        node.on("close", async function (done) {
+            closing = true;
+            nodeRuntimeState.delete(node.id);
+            if (timer) clearTimeout(timer);
+            await close(client);
+            done();
+        });
+    
+        });
+    }
+
+    RED.nodes.registerType("sma-read", SmaReadNode);
+};

package/sma-write/sma-write.html

@@ -0,0 +1,105 @@
+<script type="text/javascript">
+    RED.nodes.registerType("sma-write", {
+        category: "Atelierul de Tehnologii",
+        color: "#b5a2c8",
+        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: 126, required: true, validate: RED.validators.number() },
+            maxPower: { value: 125000, required: true, validate: RED.validators.number() },
+            nominalPower: { value: 125000, required: true, validate: RED.validators.number() },
+            multiInverter: { value: false },
+            inverterId: { value: "" }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-pencil-square-o",
+        paletteLabel: "sma-write",
+        label: function () { return this.name || this.host || "sma-write"; },
+        oneditprepare: function () {
+            const node = this;
+            const savedAutoName = node.host && node.inverterId ? node.host + " [" + node.inverterId + "]" : "";
+            let autoNameEnabled = !node.name || node.name === node.host || node.name === savedAutoName || node.name === "sma-write";
+            function autoName() {
+                const host = String($("#node-input-host").val() || "").trim();
+                const id = String($("#node-input-inverterId").val() || "").trim();
+                return $("#node-input-multiInverter").is(":checked") && id ? host + " [" + id + "]" : host;
+            }
+            function refreshAutoName() {
+                if (autoNameEnabled) $("#node-input-name").val(autoName());
+            }
+            function toggleMulti() {
+                $("#row-inverter-id").toggle($("#node-input-multiInverter").is(":checked"));
+                refreshAutoName();
+            }
+            $("#node-input-multiInverter").on("change.smaWrite", toggleMulti);
+            $("#node-input-host").on("input.smaWrite change.smaWrite", function () {
+                autoNameEnabled = true;
+                refreshAutoName();
+            });
+            $("#node-input-inverterId").on("input.smaWrite change.smaWrite", refreshAutoName);
+            $("#node-input-name").on("input.smaWrite", function () {
+                const value = String($(this).val() || "").trim();
+                autoNameEnabled = !value || value === autoName();
+            });
+            toggleMulti();
+        },
+        oneditsave: function () {
+            const host = String($("#node-input-host").val() || "").trim();
+            const id = String($("#node-input-inverterId").val() || "").trim();
+            if (!String($("#node-input-name").val() || "").trim()) {
+                $("#node-input-name").val($("#node-input-multiInverter").is(":checked") && id ? host + " [" + id + "]" : host);
+            }
+            this.nominalPower = Number($("#node-input-maxPower").val() || 125000);
+            $("#node-input-host, #node-input-inverterId, #node-input-name, #node-input-multiInverter").off(".smaWrite");
+        },
+        oneditcancel: function () {
+            $("#node-input-host, #node-input-inverterId, #node-input-name, #node-input-multiInverter").off(".smaWrite");
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="sma-write">
+    <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="sma-write-editor">
+        <input type="hidden" id="node-input-nominalPower">
+        <div class="pr-section">
+            <div class="pr-section-title"><i class="fa fa-plug"></i> Connection</div>
+            <p class="pr-section-note">Configuratia de scriere SunSpec (Modbus TCP) pentru invertor SMA.</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"></div>
+                <div class="form-row"><label for="node-input-host"><i class="fa fa-globe"></i> IP</label><input type="text" id="node-input-host" placeholder="192.168.0.100"></div>
+                <div class="form-row"><label for="node-input-port"><i class="fa fa-plug"></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="126"></div>
+                <div class="form-row pr-checkbox-row"><label for="node-input-multiInverter"><i class="fa fa-sitemap"></i> Multi-inverter</label><input type="checkbox" id="node-input-multiInverter"></div>
+                <div class="form-row" id="row-inverter-id"><label for="node-input-inverterId"><i class="fa fa-id-badge"></i> Inverter ID</label><input type="text" id="node-input-inverterId"></div>
+            </div>
+        </div>
+        <div class="pr-section">
+            <div class="pr-section-title"><i class="fa fa-bolt"></i> Power Control</div>
+            <p class="pr-section-note">Limitare activa prin SunSpec Model 123. Sunt scrise numai WMaxLimPct si WMaxLimPct_Ena.</p>
+            <div class="form-row"><label for="node-input-maxPower"><i class="fa fa-line-chart"></i> Max Power (W)</label><input type="text" id="node-input-maxPower" placeholder="125000"></div>
+        </div>
+    </div>
+    <style>
+        .sma-write-editor{--pr-border:#d7dde5;--pr-muted:#667085;--pr-surface:#f8fafc}
+        .sma-write-editor .pr-section{margin:0 0 18px;padding:14px 16px 16px;border:1px solid var(--pr-border);border-radius:10px;background:var(--pr-surface)}
+        .sma-write-editor .pr-section-title{display:flex;align-items:center;gap:8px;margin:0 0 4px;font-size:15px;font-weight:600;color:#243447}
+        .sma-write-editor .pr-section-note{margin:0 0 14px;color:var(--pr-muted);font-size:12px;line-height:1.45}
+        .sma-write-editor .pr-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:12px 16px}.sma-write-editor .pr-grid-2{grid-template-columns:repeat(2,minmax(320px,1fr))}
+        .sma-write-editor .form-row{margin-bottom:12px}.sma-write-editor .pr-grid .form-row,.sma-write-editor .form-row:last-child{margin-bottom:0}
+        .sma-write-editor .form-row>label{width:150px;font-weight:600}.sma-write-editor .form-row>input[type=text],.sma-write-editor .form-row>input[type=number],.sma-write-editor .form-row>select{width:calc(100% - 160px)}
+        .sma-write-editor .pr-grid-2 .form-row>label{width:130px}.sma-write-editor .pr-grid-2 .form-row>input[type=text],.sma-write-editor .pr-grid-2 .form-row>input[type=number],.sma-write-editor .pr-grid-2 .form-row>select{width:calc(100% - 140px)}
+        .sma-write-editor .pr-checkbox-row>input[type=checkbox]{width:auto;display:inline-block}
+        @media(max-width:1100px){.sma-write-editor .pr-grid-2{grid-template-columns:1fr}}
+    </style>
+</script>
+
+<script type="text/html" data-help-name="sma-write">
+    <p><b>sma-write</b> limiteaza puterea activa a invertorului prin SunSpec Model 123.</p>
+    <p>Nodul detecteaza baza SunSpec si scrie exclusiv <code>WMaxLimPct</code> si <code>WMaxLimPct_Ena</code> folosind Modbus Function 16. Nu modifica registre SMA native, putere reactiva, rampa, window sau revert.</p>
+    <p>Intrarea poate fi un numar in W sau un obiect cu <code>value</code>, <code>limit_w</code>, <code>power_w</code>, <code>site_limit_w</code> ori <code>percent</code>. Comenzile identice consecutive nu sunt rescrise.</p>
+    <p>Rezultatul are topic <code>sma/write</code> si include procentul, adresele, durata, versiunea runtime si <code>accepted_unverified=true</code>. Erorile folosesc topic <code>sma/error</code>.</p>
+</script>