smart-nodes 0.3.22 → 0.3.26

package/forwarder/forwarder.js

@@ -1,33 +1,35 @@
 module.exports = function (RED)
 {
+    "use strict";
+
     function ForwarderNode(config)
     {
         const node = this;
         RED.nodes.createNode(node, config);
 
-        const smartContext = require("../persistence.js")(RED);
+        const smart_context = require("../persistence.js")(RED);
         const helper = require("../smart_helper.js");
 
-        var nodeSettings = {
+        var node_settings = {
             enabled: config.enabled,
-            lastMessage: null,
+            last_message: null,
             last_msg_was_sended: true
         };
 
         if (config.save_state)
         {
             // load old saved values
-            nodeSettings = Object.assign(nodeSettings, smartContext.get(node.id));
+            node_settings = Object.assign(node_settings, smart_context.get(node.id));
         }
         else
         {
             // delete old saved values
-            smartContext.del(node.id);
+            smart_context.del(node.id);
         }
 
         // dynamic config
-        let forwardTrue = config.always_forward_true;
-        let forwardFalse = config.always_forward_false;
+        let forward_true = config.always_forward_true;
+        let forward_false = config.always_forward_false;
         let forward_last_on_enable = config.forward_last_on_enable;
 
         // runtime values
@@ -35,29 +37,29 @@ module.exports = function (RED)
 
         node.on("input", function (msg)
         {
-            let newState = null;
+            let new_state = null;
             if (msg.topic == "enable" || (msg.topic == "set_state" && msg.payload))
-                newState = true;
+                new_state = true;
             else if (msg.topic == "disable" || (msg.topic == "set_state" && !msg.payload))
-                newState = false;
+                new_state = false;
 
             // Already the correct state
-            if (newState != null && nodeSettings.enabled == newState)
+            if (new_state != null && node_settings.enabled == new_state)
                 return;
 
-            switch (newState)
+            switch (new_state)
             {
                 case true:
                 case false:
-                    nodeSettings.enabled = newState;
+                    node_settings.enabled = new_state;
 
                     if (config.save_state)
-                        smartContext.set(node.id, nodeSettings);
+                        smart_context.set(node.id, node_settings);
 
-                    if (nodeSettings.enabled && forward_last_on_enable && nodeSettings.lastMessage != null && !nodeSettings.last_msg_was_sended)
+                    if (node_settings.enabled && forward_last_on_enable && node_settings.last_message != null && !node_settings.last_msg_was_sended)
                     {
-                        node.send(nodeSettings.lastMessage);
-                        nodeSettings.last_msg_was_sended = true;
+                        node.send(node_settings.last_message);
+                        node_settings.last_msg_was_sended = true;
                     }
 
                     setStatus();
@@ -65,34 +67,34 @@ module.exports = function (RED)
 
                 default:
                     // Forward if enabled or forced
-                    if (nodeSettings.enabled || (forwardTrue && msg.payload) || (forwardFalse && !msg.payload))
+                    if (node_settings.enabled || (forward_true && msg.payload) || (forward_false && !msg.payload))
                     {
                         node.send(msg);
-                        nodeSettings.last_msg_was_sended = true;
+                        node_settings.last_msg_was_sended = true;
                     }
                     else
                     {
-                        nodeSettings.last_msg_was_sended = false;
+                        node_settings.last_msg_was_sended = false;
                     }
 
-                    nodeSettings.lastMessage = msg;
+                    node_settings.last_message = msg;
                     break;
             }
         });
 
         let setStatus = () =>
         {
-            if (nodeSettings.enabled)
-                node.status({ fill: "green", shape: "dot", text: (new Date()).toLocaleString() + ": Forwarding enabled" });
+            if (node_settings.enabled)
+                node.status({ fill: "green", shape: "dot", text: helper.getCurrentTimeForStatus() + ": Forwarding enabled" });
             else
-                node.status({ fill: "red", shape: "dot", text: (new Date()).toLocaleString() + ": Forwarding disabled" });
+                node.status({ fill: "red", shape: "dot", text: helper.getCurrentTimeForStatus() + ": Forwarding disabled" });
         }
 
-        if (config.save_state && config.resend_on_start && nodeSettings.lastMessage != null)
+        if (config.save_state && config.resend_on_start && node_settings.last_message != null)
         {
             setTimeout(() =>
             {
-                node.send(nodeSettings.lastMessage);
+                node.send(node_settings.last_message);
             }, 10000);
         }
 

package/heating-curve/heating-curve.html

@@ -0,0 +1,348 @@
+<script type="text/javascript">
+    (function ()
+    {
+        let node;
+
+        RED.nodes.registerType("smart_heating-curve", {
+            category: "Smart Nodes",
+            paletteLabel: "Heating Curve",
+            color: "#3FADB5",
+            defaults: {
+                name: { value: "" },
+                room_setpoint: { value: 20 },
+                slope: { value: 1.3 },
+                offset: { value: 0 },
+                flow_max: { value: 75 },
+                flow_min: { value: 20 },
+            },
+            inputs: 1,
+            outputs: 1,
+            icon: "font-awesome/fa-line-chart",
+            label: function ()
+            {
+                return this.name || "Heating Curve";
+            },
+            oneditprepare: function ()
+            {
+                node = this;
+
+                $("#node-input-room_setpoint")
+                    .spinner({
+                        min: 15,
+                        max: 25,
+                        step: 0.5,
+                        change: function (event, ui)
+                        {
+                            var value = parseFloat(this.value);
+                            value = isNaN(value) ? 0 : value;
+                            value = Math.max(value, parseFloat($(this).attr("aria-valuemin")));
+                            value = Math.min(value, parseFloat($(this).attr("aria-valuemax")));
+                            if (value !== this.value) $(this).spinner("value", value);
+                            drawCanvas();
+                        },
+                    }).css("max-width", "4rem");
+
+                $("#node-input-slope")
+                    .spinner({
+                        min: 0.05,
+                        max: 4,
+                        step: 0.05,
+                        change: function (event, ui)
+                        {
+                            var value = parseFloat(this.value);
+                            value = isNaN(value) ? 0 : value;
+                            value = Math.max(value, parseFloat($(this).attr("aria-valuemin")));
+                            value = Math.min(value, parseFloat($(this).attr("aria-valuemax")));
+                            if (value !== this.value) $(this).spinner("value", value);
+                            drawCanvas();
+                        },
+                    }).css("max-width", "4rem");
+
+                $("#node-input-offset")
+                    .spinner({
+                        min: -20,
+                        max: 20,
+                        step: 0.5,
+                        change: function (event, ui)
+                        {
+                            var value = parseFloat(this.value);
+                            value = isNaN(value) ? 0 : value;
+                            value = Math.max(value, parseFloat($(this).attr("aria-valuemin")));
+                            value = Math.min(value, parseFloat($(this).attr("aria-valuemax")));
+                            if (value !== this.value) $(this).spinner("value", value);
+                            drawCanvas();
+                        },
+                    }).css("max-width", "4rem");
+
+                $("#node-input-flow_max")
+                    .spinner({
+                        min: 50,
+                        max: 85,
+                        change: function (event, ui)
+                        {
+                            var value = parseFloat(this.value);
+                            value = isNaN(value) ? 0 : value;
+                            value = Math.max(value, parseFloat($(this).attr("aria-valuemin")));
+                            value = Math.min(value, parseFloat($(this).attr("aria-valuemax")));
+                            if (value !== this.value) $(this).spinner("value", value);
+                            drawCanvas();
+                        },
+                    }).css("max-width", "4rem");
+
+                $("#node-input-flow_min")
+                    .spinner({
+                        min: 5,
+                        max: 30,
+                        change: function (event, ui)
+                        {
+                            var value = parseFloat(this.value);
+                            value = isNaN(value) ? 0 : value;
+                            value = Math.max(value, parseFloat($(this).attr("aria-valuemin")));
+                            value = Math.min(value, parseFloat($(this).attr("aria-valuemax")));
+                            if (value !== this.value) $(this).spinner("value", value);
+                            drawCanvas();
+                        },
+                    }).css("max-width", "4rem");
+
+                drawCanvas();
+            },
+        });
+
+        let drawCanvas = () =>
+        {
+            const canvas = $("#heating-curve-diagram")[0];
+            const ctx = canvas.getContext("2d");
+            ctx.reset();
+
+            drawAxis(canvas, ctx);
+            drawGrid(canvas, ctx);
+            drawCurve(canvas, ctx, "#808080", 0.5, 0);
+            drawCurve(canvas, ctx, "#808080", 1, 0);
+            drawCurve(canvas, ctx, "#808080", 1.5, 0);
+            drawCurve(canvas, ctx, "#808080", 2, 0);
+            drawCurve(canvas, ctx, "#808080", 2.5, 0);
+            drawCurve(canvas, ctx, "#808080", 3, 0);
+            drawCurve(canvas, ctx, "#808080", 3.5, 0);
+            drawCurve(canvas, ctx, "#808080", 4, 0);
+
+            drawCurve(canvas, ctx, "#0000FF", parseFloat($("#node-input-slope").val()), parseFloat($("#node-input-offset").val()), true);
+        }
+
+        let mapPoint = (out, flow) =>
+        {
+            const canvas = $("#heating-curve-diagram")[0];
+            return [scale(out, -20, 25, canvas.width, 0), scale(flow, 10, 100, canvas.height, 0)];
+        }
+
+        let scale = (number, inMin, inMax, outMin, outMax) =>
+        {
+            return (number - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
+        }
+
+        let drawAxis = (canvas, ctx) =>
+        {
+            const arrow_length = 10;
+
+            ctx.strokeStyle = "#000000";
+
+            ctx.beginPath();
+
+            // draw axis
+            ctx.moveTo(...mapPoint(20, 100));
+            ctx.lineTo(...mapPoint(20, 10));
+
+            ctx.moveTo(...mapPoint(25, 20));
+            ctx.lineTo(...mapPoint(-20, 20));
+
+            // draw arrow up
+            let point = mapPoint(20, 100);
+            ctx.moveTo(...point);
+            ctx.lineTo(point[0] - arrow_length / 2, point[1] + arrow_length);
+            ctx.moveTo(...point);
+            ctx.lineTo(point[0] + arrow_length / 2, point[1] + arrow_length);
+
+            // draw arrow right
+            point = mapPoint(-20, 20);
+            ctx.moveTo(...point);
+            ctx.lineTo(point[0] - arrow_length, point[1] - arrow_length / 2);
+            ctx.moveTo(...point);
+            ctx.lineTo(point[0] - arrow_length, point[1] + arrow_length / 2);
+
+            ctx.stroke();
+        }
+
+        let drawGrid = (canvas, ctx) =>
+        {
+            ctx.fillStyle = "#000000";
+            ctx.font = "15px Arial";
+            ctx.strokeStyle = "#CCCCCC";
+
+            ctx.beginPath();
+
+            // horizontal lines
+            ctx.textAlign = "right";
+            ctx.textBaseline = "middle";
+            for (let i = 30; i <= 90; i += 10)
+            {
+                let [x, y] = mapPoint(20, i);
+
+                ctx.moveTo(x - 15, y);
+                ctx.lineTo(canvas.width - 15, y);
+
+                ctx.fillText(i.toString(), 25, y);
+            }
+
+            // vertical lines
+            ctx.textAlign = "center";
+            for (let i = -15; i <= 15; i += 5)
+            {
+                let [x, y] = mapPoint(i, 20);
+
+                ctx.moveTo(x, 15);
+                ctx.lineTo(x, y + 15);
+
+                ctx.fillText(i.toString(), x, canvas.height - 10);
+            }
+
+            ctx.stroke();
+        }
+
+        let drawCurve = (canvas, ctx, color, slope, offset, useMinMax = false) =>
+        {
+            console.log("Test");
+            const room_setpoint = parseFloat($("#node-input-room_setpoint").val());
+            const flow_min = parseFloat($("#node-input-flow_min").val());
+            const flow_max = parseFloat($("#node-input-flow_max").val());
+
+            ctx.textAlign = "center";
+            ctx.textBaseline = "middle";
+            ctx.font = "12px Arial";
+            ctx.strokeStyle = color;
+
+            ctx.beginPath();
+            let first = true;
+
+            let labels = [];
+            debugger;
+
+            for (let out = 20; out >= -20; out -= 1)
+            {
+                let dar = out - room_setpoint;
+                let flow = room_setpoint + offset - slope * dar * (1.4347 + 0.021 * dar + 247.9 * Math.pow(10, -6) * Math.pow(dar, 2));
+
+                if (useMinMax)
+                    flow = Math.min(Math.max(flow, flow_min), flow_max);
+
+                let point = mapPoint(out, flow);
+
+                if (first)
+                    ctx.moveTo(...point);
+                else
+                    ctx.lineTo(...point);
+                first = false;
+
+                if (point[0] >= canvas.width)
+                {
+                    let x = canvas.width - 20;
+                    let y = Math.max(point[1], 20);
+                    labels.push({ x, y, text: slope.toString() });
+                    break;
+                }
+                if (point[1] <= 0)
+                {
+                    let x = Math.min(point[0] - 20, canvas.width - 20);
+                    let y = 10;
+                    labels.push({ x, y, text: slope.toString() });
+                    break;
+                }
+            }
+            ctx.stroke();
+
+            ctx.beginPath();
+            for (let label of labels)
+            {
+                ctx.fillStyle = "#FFFFFF";
+
+                ctx.rect(label.x - 10.5, label.y - 8.5, 21, 16);
+                ctx.fillRect(label.x - 10, label.y - 8, 20, 15);
+
+                ctx.fillStyle = "#000000";
+                if (useMinMax)
+                    ctx.fillStyle = color;
+
+                ctx.fillText(label.text, label.x, label.y);
+            }
+            ctx.stroke();
+        }
+    })();
+
+</script>
+
+<script type="text/html" data-template-name="smart_heating-curve">
+    <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="Name" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-room_setpoint"><i class="fa fa-thermometer-three-quarters"></i> Raum Soll</label>
+        <input id="node-input-room_setpoint" value="0" /> °C [15 - 25]
+    </div>
+    <div class="form-row">
+        <label for="node-input-slope"><i class="fa fa-expand"></i> Steilheit</label>
+        <input id="node-input-slope" value="0" /> [0,05 - 4]
+    </div>
+    <div class="form-row">
+        <label for="node-input-offset"><i class="fa fa-arrows-v"></i> Verschiebung</label>
+        <input id="node-input-offset" value="0" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-flow_max"><i class="fa fa-arrow-up"></i> Max Soll</label>
+        <input id="node-input-flow_max" value="0" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-flow_min"><i class="fa fa-arrow-down"></i> Min Soll</label>
+        <input id="node-input-flow_min" value="0" />
+    </div>
+    <div class="form-row">
+        <canvas id="heating-curve-diagram" width="450" height="300"></canvas>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="smart_heating-curve">
+    <p>
+        Diese Node berechnet anhand den eingestellten Werten, die Vorlaufsolltemperatur. Diese kann verwendet werden um ein Mischventil anzusteuern.
+    </p>
+    <p>
+        <b>Hinweis:</b> Smart Nodes verwenden Topics im Format <code>name#nummer</code>, damit können verschiedene Smart Nodes mit dem gleichen Topic angesteuert werden.<br/>
+        Diese Node verwendet nur den Teil <code>name</code>. <code>#</code> und <code>nummer</code> sind dabei optional.
+    </p>
+    <p>
+        Folgende topics werden akzeptiert:
+        <table>
+            <thead>
+                <tr>
+                    <th>Topic</th>
+                    <th>Beschreibung</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td><code>room_setpoint</code></td>
+                    <td>Überschreibt die Raum-Solltemperatur.</td>
+                </tr>
+                <tr>
+                    <td><code>flow_min</code></td>
+                    <td>Überschreibt die minimale Vorlaufsolltemperatur.</td>
+                </tr>
+                <tr>
+                    <td><code>flow_max</code></td>
+                    <td>Überschreibt die maximale Vorlaufsolltemperatur.</td>
+                </tr>
+                <tr>
+                    <td><code>temperature_outside</code></td>
+                    <td>Setzt die aktuelle Außentemperatur.</td>
+                </tr>
+            </tbody>
+        </table>
+    </p>
+</script>

package/heating-curve/heating-curve.js

@@ -0,0 +1,134 @@
+module.exports = function (RED)
+{
+    "use strict";
+
+    function HeatingCurveNode(config)
+    {
+        const node = this;
+        RED.nodes.createNode(node, config);
+
+        const smart_context = require("../persistence.js")(RED);
+        const helper = require("../smart_helper.js");
+
+        // persistent values
+        var node_settings = Object.assign({}, {
+            room_setpoint: config.room_setpoint,
+            flow_min: config.flow_min,
+            flow_max: config.flow_max,
+            temperature_outside: 10,
+            last_flow_temperature: null
+        }, smart_context.get(node.id));
+
+        // dynamic config
+        let slope = config.slope;
+        let offset = config.offset;
+
+        // runtime values
+
+        node.on("input", function (msg)
+        {
+            handleTopic(msg);
+            sendResult();
+            setStatus();
+        });
+
+        node.on("close", function ()
+        {
+        });
+
+
+        let handleTopic = msg =>
+        {
+            let real_topic = helper.getTopicName(msg.topic);
+            switch (real_topic)
+            {
+                case "room_setpoint":
+                    let new_setpoint = parseFloat(msg.payload);
+                    if (isNaN(new_setpoint) && !isFinite(new_setpoint))
+                    {
+                        node.error("Invalid payload: " + msg.payload);
+                        return;
+                    }
+
+                    node_settings.room_setpoint = msg.payload;
+                    smart_context.set(node.id, node_settings);
+                    break;
+
+                case "temperature_outside":
+                    let new_temp = parseFloat(msg.payload);
+                    if (isNaN(new_temp) && !isFinite(new_temp))
+                    {
+                        node.error("Invalid payload: " + msg.payload);
+                        return;
+                    }
+
+                    node_settings.temperature_outside = msg.payload;
+                    smart_context.set(node.id, node_settings);
+                    break;
+
+                case "flow_min":
+                    let new_flow_min = parseFloat(msg.payload);
+                    if (isNaN(new_flow_min) && !isFinite(new_flow_min))
+                    {
+                        node.error("Invalid payload: " + msg.payload);
+                        return;
+                    }
+
+                    node_settings.flow_min = msg.payload;
+                    smart_context.set(node.id, node_settings);
+                    break;
+
+                case "flow_max":
+                    let new_flow_max = parseFloat(msg.payload);
+                    if (isNaN(new_flow_max) && !isFinite(new_flow_max))
+                    {
+                        node.error("Invalid payload: " + msg.payload);
+                        return;
+                    }
+
+                    node_settings.flow_max = msg.payload;
+                    smart_context.set(node.id, node_settings);
+                    break;
+
+                default:
+                    node.error("Invalid topic: " + real_topic);
+                    return;
+            }
+        }
+
+        let sendResult = () =>
+        {
+            // Formula used was found here:
+            // https://community.viessmann.de/t5/Gas/Mathematische-Formel-fuer-Vorlauftemperatur-aus-den-vier/td-p/68843
+
+            let dar = node_settings.temperature_outside - node_settings.room_setpoint;
+            node_settings.last_flow_temperature = node_settings.room_setpoint + offset - slope * dar * (1.4347 + 0.021 * dar + 247.9 * Math.pow(10, -6) * Math.pow(dar, 2));
+
+            // console.log({
+            //     set: node_settings.room_setpoint,
+            //     offset,
+            //     slope,
+            //     dar,
+            //     flow: node_settings.last_flow_temperature
+            // });
+
+            // Check borders
+            node_settings.last_flow_temperature = Math.min(Math.max(node_settings.last_flow_temperature, node_settings.flow_min), node_settings.flow_max);
+            smart_context.set(node.id, node_settings);
+
+            node.send({ payload: node_settings.last_flow_temperature });
+        }
+
+        let setStatus = () =>
+        {
+            node.status({ fill: "green", shape: "dot", text: helper.getCurrentTimeForStatus() + ": Out: " + node_settings.temperature_outside.toFixed(1) + "°C, Flow: " + node_settings.last_flow_temperature?.toFixed(1) + "°C" });
+        }
+
+        if (node_settings.last_flow_temperature !== null)
+            setTimeout(sendResult, 10 * 1000);
+
+        setStatus();
+    }
+
+    RED.nodes.registerType("smart_heating-curve", HeatingCurveNode);
+}