@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/pv-generator/pv-generator.html

@@ -0,0 +1,284 @@
+<script type="text/javascript">
+
+    function parseEditorTimeHours(value) {
+        if (value === null || value === undefined) return NaN;
+        const text = String(value).trim();
+        if (!text) return NaN;
+
+        const m = text.match(/^(\d{1,2}):(\d{1,2})$/);
+        if (m) {
+            const hh = Number(m[1]);
+            const mm = Number(m[2]);
+            if (Number.isFinite(hh) && Number.isFinite(mm) && hh >= 0 && hh <= 23 && mm >= 0 && mm <= 59) {
+                return hh + (mm / 60);
+            }
+            return NaN;
+        }
+
+        const fallback = Number(text.replace(",", "."));
+        return Number.isFinite(fallback) ? fallback : NaN;
+    }
+
+    function hoursToHHMM(hours, fallback) {
+        const n = Number(hours);
+        if (!Number.isFinite(n)) return fallback;
+
+        const clamped = Math.min(Math.max(n, 0), 23.999);
+        let hh = Math.floor(clamped);
+        let mm = Math.round((clamped - hh) * 60);
+
+        if (mm >= 60) {
+            mm = 0;
+            hh += 1;
+        }
+
+        if (hh > 23) hh = 23;
+
+        return String(hh).padStart(2, "0") + ":" + String(mm).padStart(2, "0");
+    }
+
+    RED.nodes.registerType("pv-generator", {
+
+        category: "Atelierul de Tehnologii",
+
+        color: "#f4a261",
+
+        defaults: {
+            license: { value: "", type: "atelier-license", required: true },
+            name: { value: "" },
+            outputTopic: { value: "pv-simulator" },
+            ratedPowerW: {
+                value: 10000,
+                validate: function (v) {
+                    return Number(v) >= 0;
+                }
+            },
+            profile: { value: "sine" },
+            sunriseHour: {
+                value: "06:00",
+                validate: function (v) {
+                    const n = parseEditorTimeHours(v);
+                    if (!Number.isFinite(n) || n < 0 || n >= 24) return false;
+
+                    const sunsetRaw = $("#node-input-sunsetHour").val();
+                    if (sunsetRaw === undefined) return true;
+
+                    const sunset = parseEditorTimeHours(sunsetRaw);
+                    return !Number.isFinite(sunset) || sunset > n;
+                }
+            },
+            sunsetHour: {
+                value: "20:00",
+                validate: function (v) {
+                    const n = parseEditorTimeHours(v);
+                    if (!Number.isFinite(n) || n <= 0 || n > 24) return false;
+
+                    const sunriseRaw = $("#node-input-sunriseHour").val();
+                    if (sunriseRaw === undefined) return true;
+
+                    const sunrise = parseEditorTimeHours(sunriseRaw);
+                    return !Number.isFinite(sunrise) || n > sunrise;
+                }
+            },
+            cloudinessPct: {
+                value: 10,
+                validate: function (v) {
+                    const n = Number(v);
+                    return Number.isFinite(n) && n >= 0 && n <= 100;
+                }
+            },
+            randomNoisePct: {
+                value: 3,
+                validate: function (v) {
+                    const n = Number(v);
+                    return Number.isFinite(n) && n >= 0 && n <= 100;
+                }
+            },
+            limitW: {
+                value: "",
+                validate: function (v) {
+                    if (v === "" || v === null || v === undefined) return true;
+                    const n = Number(v);
+                    return Number.isFinite(n) && n >= 0;
+                }
+            },
+            sampleIntervalSec: {
+                value: 5,
+                validate: function (v) {
+                    const n = Number(v);
+                    return Number.isFinite(n) && n >= 0.25;
+                }
+            },
+            enabled: { value: true },
+            autostart: { value: true }
+        },
+
+        inputs: 1,
+
+        outputs: 1,
+
+        icon: "font-awesome/fa-sun-o",
+
+        label: function () {
+            return this.name || "pv-generator";
+        },
+
+        oneditprepare: function () {
+            const sunriseCurrent = parseEditorTimeHours($("#node-input-sunriseHour").val());
+            const sunsetCurrent = parseEditorTimeHours($("#node-input-sunsetHour").val());
+
+            if (Number.isFinite(sunriseCurrent)) {
+                $("#node-input-sunriseHour").val(hoursToHHMM(sunriseCurrent, "06:00"));
+            }
+            if (Number.isFinite(sunsetCurrent)) {
+                $("#node-input-sunsetHour").val(hoursToHHMM(sunsetCurrent, "20:00"));
+            }
+
+            function showHint() {
+                const sunrise = parseEditorTimeHours($("#node-input-sunriseHour").val());
+                const sunset = parseEditorTimeHours($("#node-input-sunsetHour").val());
+
+                if (Number.isFinite(sunrise) && Number.isFinite(sunset) && sunset <= sunrise) {
+                    $("#pv-generator-validation")
+                        .text("Sunset Hour trebuie sa fie mai mare decat Sunrise Hour.")
+                        .show();
+                    return;
+                }
+
+                $("#pv-generator-validation").hide().text("");
+            }
+
+            $("#node-input-sunriseHour, #node-input-sunsetHour")
+                .off(".pvgen")
+                .on("change.pvgen keyup.pvgen", showHint);
+
+            showHint();
+        },
+
+        oneditsave: function () {
+            const limitRaw = String($("#node-input-limitW").val() || "").trim();
+            if (!limitRaw) {
+                $("#node-input-limitW").val("");
+            }
+
+            const sunrise = parseEditorTimeHours($("#node-input-sunriseHour").val());
+            const sunset = parseEditorTimeHours($("#node-input-sunsetHour").val());
+
+            $("#node-input-sunriseHour").val(hoursToHHMM(sunrise, "06:00"));
+            $("#node-input-sunsetHour").val(hoursToHHMM(sunset, "20:00"));
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="pv-generator">
+    <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="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="PV Generator">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-outputTopic"><i class="fa fa-bookmark"></i> Output Topic</label>
+        <input type="text" id="node-input-outputTopic" placeholder="pv-simulator">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-ratedPowerW"><i class="fa fa-bolt"></i> Rated Power (W)</label>
+        <input type="number" id="node-input-ratedPowerW" min="0" step="1">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-profile"><i class="fa fa-line-chart"></i> Profile</label>
+        <select id="node-input-profile">
+            <option value="sine">Sine (clasic)</option>
+            <option value="bell">Bell (nor variabil)</option>
+            <option value="plateau">Plateau (pranz stabil)</option>
+        </select>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-sunriseHour"><i class="fa fa-sun-o"></i> Sunrise (hh:mm)</label>
+        <input type="time" id="node-input-sunriseHour" step="60">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-sunsetHour"><i class="fa fa-moon-o"></i> Sunset (hh:mm)</label>
+        <input type="time" id="node-input-sunsetHour" step="60">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-cloudinessPct"><i class="fa fa-cloud"></i> Cloudiness (%)</label>
+        <input type="number" id="node-input-cloudinessPct" min="0" max="100" step="1">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-randomNoisePct"><i class="fa fa-random"></i> Noise (%)</label>
+        <input type="number" id="node-input-randomNoisePct" min="0" max="100" step="0.1">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-limitW"><i class="fa fa-sliders"></i> Limit (W)</label>
+        <input type="number" id="node-input-limitW" min="0" step="1" placeholder="gol = fara limitare">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-sampleIntervalSec"><i class="fa fa-clock-o"></i> Sample Interval (s)</label>
+        <input type="number" id="node-input-sampleIntervalSec" min="0.25" step="0.25">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-enabled"><i class="fa fa-power-off"></i> Enabled</label>
+        <input type="checkbox" id="node-input-enabled" style="width:auto; margin-left:8px;">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-autostart"><i class="fa fa-play"></i> Auto Start Timer</label>
+        <input type="checkbox" id="node-input-autostart" style="width:auto; margin-left:8px;">
+    </div>
+
+    <div class="form-row" id="pv-generator-validation" style="display:none; color:#c0392b; font-weight:600;"></div>
+
+</script>
+
+<script type="text/html" data-help-name="pv-generator">
+    <p>Simulator invertor PV care genereaza productie in W, cu posibilitate de limitare.</p>
+    <p>Output:</p>
+    <ul>
+        <li><code>msg.payload</code>: productie PV efectiva (W)</li>
+        <li><code>msg.pv</code>: detalii complete (raw power, limit, curtailment, profil)</li>
+    </ul>
+    <p>Control dinamic prin input (object in <code>msg.payload</code> sau campuri in <code>msg</code>):</p>
+    <ul>
+        <li><code>limit_w</code> / <code>limitW</code>: limiteaza puterea la o valoare in W</li>
+        <li><code>rated_power_w</code>: schimba puterea nominala a invertorului</li>
+        <li><code>sunrise_hour</code>, <code>sunset_hour</code>: accepta <code>hh:mm</code> (ex: <code>06:15</code>) sau numeric</li>
+        <li><code>cloudiness_pct</code>: modifica gradul de innorare (0-100)</li>
+        <li><code>profile</code>: <code>sine</code>, <code>bell</code> sau <code>plateau</code></li>
+        <li><code>sample_interval_sec</code>: modifica perioada de esantionare</li>
+        <li><code>enabled</code>: porneste/opreste simularea</li>
+    </ul>
+    <p>Comenzi rapide in <code>msg.command</code> sau <code>msg.topic</code>: <code>start</code>, <code>stop</code>, <code>tick</code>.</p>
+
+    <h3>Referinta completa parametri</h3>
+    <ul>
+        <li><code>outputTopic</code>: topic-ul mesajelor emise.</li>
+        <li><code>ratedPowerW</code>: puterea nominala maxima a simulatorului.</li>
+        <li><code>profile</code>: forma curbei de productie: <code>sine</code>, <code>bell</code> sau <code>plateau</code>.</li>
+        <li><code>sunriseHour</code> si <code>sunsetHour</code>: intervalul zilnic in care se genereaza productie.</li>
+        <li><code>cloudinessPct</code>: reducerea determinista a productiei, 0..100%.</li>
+        <li><code>randomNoisePct</code>: variatie aleatoare aplicata productiei.</li>
+        <li><code>limitW</code>: limitare optionala a productiei simulate.</li>
+        <li><code>sampleIntervalSec</code>: perioada timerului intern.</li>
+        <li><code>enabled</code>: permite sau blocheaza generarea.</li>
+        <li><code>autostart</code>: porneste timerul automat dupa deploy.</li>
+    </ul>
+
+    <h3>Exemplu limitare dinamica</h3>
+    <pre>{
+  "payload": {
+    "limit_w": 5000,
+    "cloudiness_pct": 20
+  }
+}</pre>
+</script>

package/pv-generator/pv-generator.js

@@ -0,0 +1,387 @@
+module.exports = function (RED) {
+
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+
+    function clamp(value, min, max) {
+        const n = Number(value);
+        if (!Number.isFinite(n)) return min;
+        return Math.min(Math.max(n, min), max);
+    }
+
+
+    function toFiniteOr(value, fallback) {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : fallback;
+    }
+
+    function parseHourValue(value, fallback) {
+        if (typeof value === "string") {
+            const text = value.trim();
+            const match = text.match(/^(\d{1,2}):(\d{1,2})$/);
+            if (match) {
+                const hh = Number(match[1]);
+                const mm = Number(match[2]);
+                if (Number.isFinite(hh) && Number.isFinite(mm) && hh >= 0 && hh <= 23 && mm >= 0 && mm <= 59) {
+                    return hh + (mm / 60);
+                }
+            }
+        }
+
+        const n = Number(value);
+        if (Number.isFinite(n)) return n;
+        return fallback;
+    }
+
+
+    function toOptionalLimit(value) {
+        if (value === null || value === undefined || value === "") {
+            return null;
+        }
+
+        const n = Number(value);
+        if (!Number.isFinite(n) || n < 0) {
+            return null;
+        }
+
+        return n;
+    }
+
+
+    function parseBool(value, fallback) {
+        if (value === true || value === false) return value;
+        if (value === "true") return true;
+        if (value === "false") return false;
+        return fallback;
+    }
+
+
+    function smoothstep(x) {
+        const t = clamp(x, 0, 1);
+        return t * t * (3 - 2 * t);
+    }
+
+
+    function normalizeProfile(name) {
+        const value = String(name || "").trim().toLowerCase();
+        if (value === "sine" || value === "bell" || value === "plateau") {
+            return value;
+        }
+        return "sine";
+    }
+
+
+    function computeProfileFactor(profile, progress) {
+        const x = clamp(progress, 0, 1);
+
+        if (profile === "bell") {
+            const sigma = 0.22;
+            const exponent = -Math.pow(x - 0.5, 2) / (2 * sigma * sigma);
+            return Math.exp(exponent);
+        }
+
+        if (profile === "plateau") {
+            const rampIn = smoothstep(x / 0.2);
+            const rampOut = smoothstep((1 - x) / 0.2);
+            return Math.min(rampIn, rampOut);
+        }
+
+        return Math.sin(Math.PI * x);
+    }
+
+    function applyLimiterDynamics(rawPowerW, limitW, state) {
+        if (!Number.isFinite(limitW) || limitW < 0) {
+            return {
+                productionW: rawPowerW,
+                nextStateW: rawPowerW
+            };
+        }
+
+        if (rawPowerW <= limitW) {
+            return {
+                productionW: rawPowerW,
+                nextStateW: rawPowerW
+            };
+        }
+
+        const controlAlpha = 0.35;
+        const jitterPct = 0.8;
+        const minJitterW = 15;
+        const jitterAmplitudeW = Math.max(minJitterW, limitW * (jitterPct / 100));
+
+        const prev = Number.isFinite(state) ? state : limitW;
+        const tracked = prev + ((limitW - prev) * controlAlpha);
+
+        const hunt = (Math.random() * 2 - 1) * jitterAmplitudeW;
+        const biasUnderLimit = Math.random() * jitterAmplitudeW * 0.35;
+
+        const maxAllowed = Math.min(rawPowerW, limitW * 1.01);
+        const minAllowed = Math.max(0, limitW - jitterAmplitudeW * 2.2);
+        const productionW = clamp(tracked + hunt - biasUnderLimit, minAllowed, maxAllowed);
+
+        return {
+            productionW: productionW,
+            nextStateW: tracked
+        };
+    }
+
+
+    function PvGeneratorNode(config) {
+
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+
+        node.name = config.name || "";
+        node.outputTopic = String(config.outputTopic || "pv-simulator").trim() || "pv-simulator";
+
+        let ratedPowerW = Math.max(0, toFiniteOr(config.ratedPowerW, 10000));
+        let sunriseHour = clamp(parseHourValue(config.sunriseHour, 6), 0, 23.99);
+        let sunsetHour = clamp(parseHourValue(config.sunsetHour, 20), 0.01, 24);
+        let cloudinessPct = clamp(toFiniteOr(config.cloudinessPct, 10), 0, 100);
+        let randomNoisePct = clamp(toFiniteOr(config.randomNoisePct, 3), 0, 100);
+        let profile = normalizeProfile(config.profile);
+        let sampleIntervalMs = Math.max(250, Math.round(toFiniteOr(config.sampleIntervalSec, 5) * 1000));
+
+        let limitW = toOptionalLimit(config.limitW);
+
+        let enabled = parseBool(config.enabled, true);
+        let autostart = parseBool(config.autostart, true);
+
+        let timer = null;
+        let limiterStateW = null;
+
+        if (sunsetHour <= sunriseHour) {
+            sunsetHour = Math.min(24, sunriseHour + 0.5);
+        }
+
+
+        function setStatus(color, shape, text) {
+            node.status({ fill: color, shape: shape, text: text });
+        }
+
+
+        function daytimeProgress(hoursDecimal) {
+            if (hoursDecimal < sunriseHour || hoursDecimal > sunsetHour) {
+                return null;
+            }
+
+            const daySpan = sunsetHour - sunriseHour;
+            if (daySpan <= 0) return null;
+
+            return (hoursDecimal - sunriseHour) / daySpan;
+        }
+
+
+        function getHoursDecimal(dateObj) {
+            return dateObj.getHours() + (dateObj.getMinutes() / 60) + (dateObj.getSeconds() / 3600);
+        }
+
+
+        function generateProduction(nowMs) {
+            const now = new Date(nowMs);
+            const hours = getHoursDecimal(now);
+            const progress = daytimeProgress(hours);
+
+            let rawPowerW = 0;
+            let isDaylight = false;
+
+            if (progress !== null) {
+                isDaylight = true;
+                const profileFactor = clamp(computeProfileFactor(profile, progress), 0, 1);
+                const cloudsFactor = clamp(1 - (cloudinessPct / 100), 0, 1);
+                const noNoisePower = ratedPowerW * profileFactor * cloudsFactor;
+
+                const noiseFactor = 1 + ((Math.random() * 2 - 1) * (randomNoisePct / 100));
+                rawPowerW = clamp(noNoisePower * noiseFactor, 0, ratedPowerW);
+            }
+
+            const appliedLimitW = Number.isFinite(limitW) ? Math.max(0, limitW) : null;
+            let productionW = rawPowerW;
+
+            if (appliedLimitW !== null) {
+                const limited = applyLimiterDynamics(rawPowerW, appliedLimitW, limiterStateW);
+                productionW = limited.productionW;
+                limiterStateW = limited.nextStateW;
+            } else {
+                limiterStateW = rawPowerW;
+            }
+
+            const curtailedW = Math.max(0, rawPowerW - productionW);
+
+            return {
+                timestamp: new Date(nowMs).toISOString(),
+                production_w: Math.round(productionW),
+                raw_power_w: Math.round(rawPowerW),
+                curtailed_w: Math.round(curtailedW),
+                limit_w: appliedLimitW === null ? null : Math.round(appliedLimitW),
+                inverter_rated_w: Math.round(ratedPowerW),
+                profile: profile,
+                cloudiness_pct: Number(cloudinessPct.toFixed(2)),
+                random_noise_pct: Number(randomNoisePct.toFixed(2)),
+                daylight: isDaylight,
+                day_window: {
+                    sunrise_hour: Number(sunriseHour.toFixed(2)),
+                    sunset_hour: Number(sunsetHour.toFixed(2))
+                }
+            };
+        }
+
+
+        function emitSample(baseMsg) {
+            const data = generateProduction(Date.now());
+
+            const msg = Object.assign({}, baseMsg || {});
+            msg.topic = node.outputTopic;
+            msg.payload = data.production_w;
+            msg.pv = data;
+
+            node.send(msg);
+
+            const limitText = data.limit_w === null ? "fara limit" : ("limita " + data.limit_w + "W");
+            setStatus(enabled ? "green" : "grey", "dot", data.production_w + "W | " + limitText);
+        }
+
+
+        function startTimer() {
+            if (timer) return;
+
+            timer = setInterval(function () {
+                if (!enabled) return;
+                emitSample();
+            }, sampleIntervalMs);
+        }
+
+
+        function stopTimer() {
+            if (!timer) return;
+            clearInterval(timer);
+            timer = null;
+        }
+
+
+        function applyRuntimeUpdate(source) {
+            if (!source || typeof source !== "object") return;
+
+            if (source.limit_w !== undefined || source.limitW !== undefined || source.max_power_w !== undefined) {
+                const candidate = source.limit_w !== undefined
+                    ? source.limit_w
+                    : (source.limitW !== undefined ? source.limitW : source.max_power_w);
+                limitW = toOptionalLimit(candidate);
+            }
+
+            if (source.rated_power_w !== undefined || source.ratedPowerW !== undefined) {
+                const candidate = source.rated_power_w !== undefined ? source.rated_power_w : source.ratedPowerW;
+                ratedPowerW = Math.max(0, toFiniteOr(candidate, ratedPowerW));
+            }
+
+            if (source.cloudiness_pct !== undefined || source.cloudinessPct !== undefined) {
+                const candidate = source.cloudiness_pct !== undefined ? source.cloudiness_pct : source.cloudinessPct;
+                cloudinessPct = clamp(toFiniteOr(candidate, cloudinessPct), 0, 100);
+            }
+
+            if (source.random_noise_pct !== undefined || source.randomNoisePct !== undefined) {
+                const candidate = source.random_noise_pct !== undefined ? source.random_noise_pct : source.randomNoisePct;
+                randomNoisePct = clamp(toFiniteOr(candidate, randomNoisePct), 0, 100);
+            }
+
+            if (source.profile !== undefined) {
+                profile = normalizeProfile(source.profile);
+            }
+
+            if (source.sunrise_hour !== undefined || source.sunriseHour !== undefined) {
+                const candidate = source.sunrise_hour !== undefined ? source.sunrise_hour : source.sunriseHour;
+                sunriseHour = clamp(parseHourValue(candidate, sunriseHour), 0, 23.99);
+            }
+
+            if (source.sunset_hour !== undefined || source.sunsetHour !== undefined) {
+                const candidate = source.sunset_hour !== undefined ? source.sunset_hour : source.sunsetHour;
+                sunsetHour = clamp(parseHourValue(candidate, sunsetHour), 0.01, 24);
+            }
+
+            if (sunsetHour <= sunriseHour) {
+                sunsetHour = Math.min(24, sunriseHour + 0.5);
+            }
+
+            if (source.sample_interval_sec !== undefined || source.sampleIntervalSec !== undefined) {
+                const candidate = source.sample_interval_sec !== undefined
+                    ? source.sample_interval_sec
+                    : source.sampleIntervalSec;
+
+                sampleIntervalMs = Math.max(250, Math.round(toFiniteOr(candidate, sampleIntervalMs / 1000) * 1000));
+
+                if (timer) {
+                    stopTimer();
+                    startTimer();
+                }
+            }
+
+            if (source.enabled !== undefined) {
+                enabled = parseBool(source.enabled, enabled);
+            }
+
+            if (source.autostart !== undefined) {
+                autostart = parseBool(source.autostart, autostart);
+            }
+        }
+
+
+        node.on("input", function (msg, send, done) {
+            try {
+                const command = String((msg && msg.command) || (msg && msg.topic) || "").toLowerCase().trim();
+
+                if (msg && typeof msg.payload === "object" && msg.payload !== null) {
+                    applyRuntimeUpdate(msg.payload);
+                }
+
+                applyRuntimeUpdate(msg);
+
+                if (typeof msg.payload === "number" && (command === "set-limit" || command === "limit")) {
+                    limitW = toOptionalLimit(msg.payload);
+                }
+
+                if (command === "stop") {
+                    enabled = false;
+                    setStatus("grey", "ring", "simulator oprit");
+                } else if (command === "start") {
+                    enabled = true;
+                    setStatus("green", "dot", "simulator pornit");
+                } else if (command === "tick" || command === "sample" || command === "emit") {
+                    emitSample(msg);
+                } else {
+                    emitSample(msg);
+                }
+
+                if (done) done();
+            } catch (err) {
+                node.error(err, msg);
+                if (done) done(err);
+            }
+        });
+
+
+        node.on("close", function () {
+            stopTimer();
+            node.status({});
+        });
+
+
+        if (autostart) {
+            startTimer();
+        }
+
+        setStatus(enabled ? "green" : "grey", enabled ? "dot" : "ring", enabled ? "simulator activ" : "simulator inactiv");
+
+        if (enabled && autostart) {
+            emitSample();
+        }
+    
+        });
+    }
+
+
+    RED.nodes.registerType("pv-generator", PvGeneratorNode);
+};