smart-nodes 0.1.0

package/shutter-control/shutter-control.js

@@ -0,0 +1,208 @@
+module.exports = function (RED)
+{
+    function ShutterControlNode(config)
+    {
+        const node = this;
+        RED.nodes.createNode(node, config);
+
+        const smartContext = require("../persistence.js")(RED);
+        const helper = require("../smart_helper.js");
+
+        // persistent values
+        var nodeSettings = Object.assign({}, {
+            last_position: 0,        // 0 = opened, 100 = closed
+            last_direction_up: true, // remember last direction for toggle action
+        }, smartContext.get(node.id));
+
+        // dynamic config
+
+        // runtime values
+        let is_running = false;         // remember if shutter is running, this is only recognized when starting within this control or position 0% or 100% is reached.
+        let max_time_on_timeout = null; // save timeout value to cancel auto timeout if needed
+
+        // central handling
+        var event = "node:" + config.id;
+        var handler = function (msg)
+        {
+            node.receive(msg);
+        }
+        RED.events.on(event, handler);
+
+        node.status({ fill: "red", shape: "dot", text: "Stopped at " + Math.round(nodeSettings.last_position) + "%" });
+
+        node.on("input", function (msg)
+        {
+            handleTopic(msg);
+
+            smartContext.set(node.id, nodeSettings);
+        });
+
+        node.on("close", function ()
+        {
+            stopAutoOff();
+            RED.events.off(event, handler);
+        });
+
+        let handleTopic = msg =>
+        {
+            var resultUpDown = null;
+            var resultStop = null;
+            var resultPosition = null;
+
+            var realTopic = helper.getTopicName(msg.topic);
+
+            // set default topic
+            if (!["status", "status_position", "up_down", "up", "up_stop", "down", "down_stop", "stop", "toggle", "position"].includes(realTopic))
+                realTopic = "toggle";
+
+            // skip if button is released
+            if (msg.payload === false && ["up", "up_stop", "down", "down_stop", "stop", "toggle"].includes(realTopic))
+                return;
+
+            // Correct next topic to avoid handling up_stop, down_stop or toggle separately.
+            if ((max_time_on_timeout != null || is_running) && (realTopic == "up_stop" || realTopic == "down_stop" || realTopic == "toggle"))
+            {
+                realTopic = "stop";
+            }
+            else if (max_time_on_timeout == null && !is_running)
+            {
+                // shutter is not running, set next command depending on topic
+                if (realTopic == "up_stop")
+                    realTopic = "up";
+                else if (realTopic == "down_stop")
+                    realTopic = "down";
+                else if (nodeSettings.last_direction_up && realTopic == "toggle")
+                    realTopic = "down";
+                else if (!nodeSettings.last_direction_up && realTopic == "toggle")
+                    realTopic = "up";
+            }
+
+
+            switch (realTopic)
+            {
+                case "status":
+                case "status_position":
+                    nodeSettings.last_direction_up = nodeSettings.last_position > msg.payload;
+                    nodeSettings.last_position = msg.payload;
+
+                    if (is_running && (msg.payload == 0 || msg.payload == 100))
+                        is_running = false;
+
+                    node.status({ fill: "yellow", shape: "ring", text: "Position status received: " + msg.payload + "%" });
+                    return;
+
+                // This is only used to track starting of the shutter
+                case "up_down":
+                    nodeSettings.last_direction_up = !msg.payload;
+                    is_running = true;
+
+                    if (nodeSettings.last_direction_up)
+                        node.status({ fill: "green", shape: "dot", text: "Up" });
+                    else
+                        node.status({ fill: "green", shape: "dot", text: "Down" });
+                    return;
+
+                case "up":
+                    nodeSettings.last_direction_up = true;
+                    is_running = true;
+                    resultUpDown = false;
+                    node.status({ fill: "green", shape: "dot", text: "Up" });
+                    startAutoOffIfNeeded(msg);
+                    break;
+
+                case "stop":
+                    is_running = false;
+                    resultStop = true;
+                    stopAutoOff();
+                    node.status({ fill: "green", shape: "dot", text: "Stopped" });
+                    break;
+
+                case "down":
+                    nodeSettings.last_direction_up = false;
+                    is_running = true;
+                    resultUpDown = true;
+                    node.status({ fill: "green", shape: "dot", text: "Down" });
+                    startAutoOffIfNeeded(msg);
+                    break;
+
+                case "position":
+                    let value = parseFloat(msg.payload);
+
+                    if (value < 0) value = 0;
+                    if (value > 100) value = 100;
+                    // is_running = true; // Not guaranteed that the shutter starts running.
+                    resultPosition = value;
+                    node.status({ fill: "green", shape: "dot", text: "Set position to " + value + "%" });
+                    break;
+            }
+
+            if (resultUpDown != null)
+            {
+                node.send([{ payload: resultUpDown, topic: "up_down" }, null, null]);
+                notifyCentral(true);
+            }
+            else if (resultStop != null)
+            {
+                node.send([null, { payload: resultStop, topic: "stop" }, null]);
+                notifyCentral(false);
+            }
+            else if (resultPosition != null)
+            {
+                node.send([null, null, { payload: resultPosition, topic: "position" }]);
+            }
+        };
+
+        let startAutoOffIfNeeded = msg =>
+        {
+            if (!msg.time_on)
+                return;
+
+            let timeMs = helper.getTimeInMsFromString(msg.time_on);
+            if (isNaN(timeMs))
+            {
+                node.status({ fill: "red", shape: "dot", text: "Invalid time_on value send: " + msg.time_on });
+                return;
+            }
+
+            if (timeMs <= 0)
+            {
+                node.status({ fill: "red", shape: "dot", text: "time_on value has to be greater than 0" });
+                return;
+            }
+
+            // Stop if any timeout is set
+            stopAutoOff();
+
+            node.status({ fill: "yellow", shape: "ring", text: "Wait " + (timeMs / 1000).toFixed(1) + " sec for auto off" });
+            max_time_on_timeout = setTimeout(() =>
+            {
+                node.status({ fill: "green", shape: "dot", text: "Stopped" });
+                is_running = false;
+                node.send([null, { payload: true }, null]);
+                notifyCentral(false);
+            }, timeMs);
+        };
+
+        let stopAutoOff = () =>
+        {
+            if (max_time_on_timeout != null)
+            {
+                node.status({});
+                clearTimeout(max_time_on_timeout);
+                max_time_on_timeout = null;
+            }
+        };
+
+        let notifyCentral = state =>
+        {
+            if (!config.links)
+                return;
+
+            config.links.forEach(link =>
+            {
+                RED.events.emit("node:" + link, { source: node.id, state: state });
+            });
+        };
+    }
+    RED.nodes.registerType("smart_shutter-control", ShutterControlNode);
+};

package/smart_helper.js

@@ -0,0 +1,156 @@
+module.exports = {
+    evaluateNodeProperty(RED, value, type)
+    {
+        try
+        {
+            switch (type)
+            {
+                case "null":
+                    return null;
+
+                default:
+                    return RED.util.evaluateNodeProperty(value, type);
+            }
+        }
+        catch (error)
+        {
+            console.error(error);
+            return null;
+        }
+    },
+    getTopicName(topic)
+    {
+        if (typeof topic == "undefined" || topic == null || topic == "" || typeof topic != "string")
+            return null;
+
+        if (topic.indexOf("#") == -1)
+            return topic;
+
+        return topic.substring(0, topic.indexOf("#"));
+    },
+    getTopicNumber(topic)
+    {
+        if (typeof topic == "undefined" || topic == null || topic == "")
+            return null;
+
+        if (typeof topic == "string")
+        {
+            if (topic.indexOf("#") != -1)
+                return parseInt(topic.substring(topic.indexOf("#") + 1), 10);
+        }
+
+        let result = parseInt(topic, 10);
+        if (isNaN(result) || !isFinite(result))
+            return null;
+
+        return result;
+    },
+    getTimeInMs(value, unit)
+    {
+        value = parseInt(value, 10);
+        if (isNaN(value) || value == 0)
+            return 0;
+
+        switch (unit)
+        {
+            case "ms":
+                return value;
+
+            case "s":
+            case "sec":
+                return value * 1000;
+
+            case "min":
+                return value * 60 * 1000;
+
+            case "h":
+                return value * 3600 * 1000;
+        }
+    },
+    getTimeInS(value, unit)
+    {
+        value = parseInt(value, 10);
+        if (isNaN(value) || value == 0)
+            return 0;
+
+        switch (unit)
+        {
+            case "ms":
+                return value / 1000;
+
+            case "s":
+                return value;
+
+            case "min":
+                return value * 60;
+
+            case "h":
+                return value * 3600;
+        }
+    },
+    getTimeInMsFromString(value)
+    {
+        // default in ms
+        if (typeof value == "number")
+            return value;
+
+        if (typeof value != "string")
+            return 0;
+
+        // Split 123min into ["123", "min"]
+        let values = value.match(/^([0-9]+)(ms|s|sec|m|min|h)?$/)
+
+        // string doesn't match
+        if (values == null)
+            return 0;
+
+        // default is ms
+        if (values.length == 2)
+            return this.getTimeInMs(values[1], "ms");
+
+        // default is ms
+        if (values.length == 3)
+            return this.getTimeInMs(values[1], values[2]);
+
+        // Something went wrong
+        return 0;
+    },
+    formatMsToStatus(value, timeConcatWord = null)
+    {
+        let result = "";
+
+        if (timeConcatWord)
+        {
+            let date = (new Date(Date.now() + value));
+            result = " " + timeConcatWord + " " + date.getHours() + ":" + ("" + date.getMinutes()).padStart(2, "0") + ":" + ("" + date.getSeconds()).padStart(2, "0");
+        }
+
+        if (value == 0)
+            return "0:00" + result;
+
+        // value in sec
+        value = parseInt(value / 1000, 10);
+        result = (value % 60) + result;
+        if (value % 60 < 10)
+            result = "0" + result;
+
+        // value in min
+        value = parseInt(value / 60, 10);
+        result = (value % 60) + ":" + result;
+        if (value % 60 < 10)
+            result = "0" + result;
+
+        // value in hour
+        value = parseInt(value / 60, 10);
+        result = (value % 24) + ":" + result;
+        if (value % 24 < 10)
+            result = "0" + result;
+
+        // value in days
+        value = parseInt(value / 24, 10);
+        if (value > 0)
+            result = value + "." + result;
+
+        return result;
+    }
+};

package/statistic/statistic.html

@@ -0,0 +1,107 @@
+<script type="text/javascript">
+    RED.nodes.registerType("smart_statistic", {
+        category: "Smart Nodes",
+        paletteLabel: "Statistic",
+        color: "#E2D96E",
+        defaults: {
+            name: { value: "" },
+            operation: { value: "MIN" }, // MIN, MAX, SUM, DIFF, ABS, ABS_DIFF, AVG, MOV_AVG
+            count: { value: 10 },
+            save_state: { value: true },
+            resend_on_start: { value: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "function.svg",
+        label: function ()
+        {
+            return this.name || this.operation || "Statistic";
+        },
+        oneditprepare: function ()
+        {
+            $("#node-input-operation")
+                .typedInput({
+                    types: [
+                        {
+                            default: "MIN",
+                            options: [
+                                { value: "MIN", label: "Minimum" },
+                                { value: "MAX", label: "Maximum" },
+                                { value: "SUM", label: "Summe" },
+                                { value: "DIFF", label: "Differenz" },
+                                { value: "ABS", label: "Absoluter Wert" },
+                                { value: "ABS_DIFF", label: "Absolute Differenz" },
+                                { value: "AVG", label: "Durchschnitt" },
+                                { value: "MOV_AVG", label: "Gleitender Mittelwert" }
+                            ],
+                        },
+                    ],
+                });
+
+            $("#node-input-count").css("max-width", "4rem").spinner({
+                min: 2,
+                change: function (event, ui)
+                {
+                    var value = parseInt(this.value);
+                    value = isNaN(value) ? 0 : value;
+                    value = Math.max(value, parseInt($(this).attr("aria-valuemin")));
+                    // value = Math.min(value, parseInt($(this).attr("aria-valuemax")));
+                    if (value !== this.value) $(this).spinner("value", value);
+                },
+            });
+
+            $("#node-input-operation").on("change", function (event, type, value)
+            {
+                if (value === "MOV_AVG")
+                    $(".statistic-moving-average-row").show();
+                else
+                    $(".statistic-moving-average-row").hide();
+            });
+
+            $("#node-input-save_state").on("change", ev =>
+            {
+                if (ev.target.checked)
+                    $("#resend_on_start_row").show();
+                else
+                    $("#resend_on_start_row").hide();
+            });
+            $("#node-input-save_state").trigger("change");
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="smart_statistic">
+    <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-operation"><i class="fa fa-sort"></i> Operation</label>
+        <input id="node-input-operation" />
+    </div>
+    <div class="form-row statistic-moving-average-row" style="display: none;">
+        <label for="node-input-count"><i class="fa fa-hashtag"></i> Anzahl</label>
+        <input id="node-input-count" />
+    </div>
+    <hr/>
+    <h4 style="margin: 0.5rem 0;">Systemstart</h4>
+    <div class="form-row">
+        <input type="checkbox" id="node-input-save_state" style="width: 20px;" />
+        <label for="node-input-save_state" style="width: calc(100% - 30px);">Zustand speichern</label>
+    </div>
+    <div class="form-row" id="resend_on_start_row">
+        <input type="checkbox" id="node-input-resend_on_start" style="width: 20px;" />
+        <label for="node-input-resend_on_start" style="width: calc(100% - 30px);">Letze Nachricht 10 Sekunden nach dem Start senden</label>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="smart_statistic">
+    <p>Dieser Knoten berechnet das Minimum, Maximum, die Summe, die Differenz, den absoluten Wert, die absolute Differenz, den Durchschnitt sowie den gleitenden Mittelwert verschiedener Werte.</p>
+    <p>Jeder Wert muss mit einem eigenen Topic gesendet werden. Kommt ein zweiter Wert mit dem gleichen Topic, wird der entsprechende Wert überschrieben.</p>
+    <p>Im Falle von MIN, MAX und ABS wird das entsprechende Topic, welches mit den Werten kam, mit ausgegeben. Bei SUM, DIFF, AVG und MOV_AVG handelt es sich um kombinierte Ergebnisse, weshalb Topic hier immer nicht gesetzt ist.</p>
+    <p>Für den absoluten Wert sowie den gleitenden Mittelwert spielt das Topic keine Rolle, jeder Wert der empfangen wird, wird für die Berechnung verwendet.</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>nummer</code>. <code>name</code> und <code>#</code> sind dabei optional.
+    </p>
+</script>

package/statistic/statistic.js

@@ -0,0 +1,196 @@
+module.exports = function (RED)
+{
+    function StatisticNode(config)
+    {
+        const node = this;
+        RED.nodes.createNode(node, config);
+
+        const smartContext = require("../persistence.js")(RED);
+        const helper = require("../smart_helper.js");
+
+        var nodeSettings = {
+            values: [],
+            lastMessage: null,
+        };
+
+        if (config.save_state)
+        {
+            // load old saved values
+            nodeSettings = Object.assign(nodeSettings, smartContext.get(node.id));
+        }
+        else
+        {
+            // delete old saved values
+            smartContext.del(node.id);
+        }
+
+        // dynamic config
+        let operation = config.operation
+        let count = config.count;
+
+        // runtime values
+
+
+        node.on("input", function (msg)
+        {
+            if (isNaN(parseFloat(msg.payload)))
+            {
+                // node.error("Invalid payload: " + msg.payload);
+                return;
+            }
+
+            let realTopic = helper.getTopicNumber(msg.topic) || 0;
+            // realTopic should be sended with 1-based, but internally 0-based is needed
+            realTopic--;
+
+            if (operation === "MOV_AVG")
+            {
+                nodeSettings.values.push(parseFloat(msg.payload));
+                if (nodeSettings.values.length > count)
+                    nodeSettings.values.splice(0, 1);
+            }
+            else if (operation != "ABS")
+            {
+                if (typeof msg.topic === "undefined")
+                {
+                    node.error("Topic not set");
+                    return;
+                }
+                nodeSettings.values[realTopic] = parseFloat(msg.payload);
+            }
+
+            msg = getResult(msg);
+            setStatus(msg);
+
+            if (msg)
+            {
+                nodeSettings.lastMessage = msg;
+                node.send(msg);
+            }
+
+            if (config.save_state)
+                smartContext.set(node.id, nodeSettings);
+        });
+
+        node.on("close", function ()
+        {
+        });
+
+        let getResult = (msg) =>
+        {
+            let length;
+            if (operation !== "MOV_AVG" && operation !== "ABS") 
+            {
+                length = Object.entries(nodeSettings.values).length;
+                if (length == 0)
+                    return null;
+            }
+
+            let result = null;
+            switch (operation)
+            {
+                case "MIN":
+                    result = Object.entries(nodeSettings.values).reduce((v1, v2) =>
+                    {
+                        if (v1[1] <= v2[1])
+                            return v1;
+                        return v2;
+                    });
+                    break;
+
+                case "MAX":
+                    result = Object.entries(nodeSettings.values).reduce((v1, v2) =>
+                    {
+                        if (v1[1] >= v2[1])
+                            return v1;
+                        return v2;
+                    });
+                    break;
+
+                case "SUM":
+                    result = Object.entries(nodeSettings.values).reduce((v1, v2) =>
+                    {
+                        return [null, v1[1] + v2[1]];
+                    });
+                    break;
+
+                case "DIFF":
+                    if (nodeSettings.values.length >= 2)
+                    {
+                        result = [
+                            null,
+                            nodeSettings.values[0] - nodeSettings.values[1]
+                        ];
+                    }
+                    break;
+
+                case "ABS":
+                    msg.payload = Math.abs(msg.payload);
+                    return msg;
+
+                case "ABS_DIFF":
+                    if (nodeSettings.values.length >= 2)
+                    {
+                        result = [
+                            null,
+                            Math.abs(nodeSettings.values[0] - nodeSettings.values[1])
+                        ];
+                    }
+                    break;
+
+                case "AVG":
+                    let value = Object.entries(nodeSettings.values).reduce((v1, v2) =>
+                    {
+                        return [null, v1[1] + v2[1]];
+                    });
+
+                    return {
+                        payload: value[1] / length
+                    };
+
+                case "MOV_AVG":
+                    msg.payload = nodeSettings.values.reduce((v1, v2) => v1 + v2) / nodeSettings.values.length;
+                    return msg;
+            }
+
+            if (result != null)
+            {
+                if (Number.isNaN(result[1]) || !Number.isFinite(result[1]))
+                    return null;
+
+                if (result[0] == null)
+                    return { payload: result[1] };
+
+                return {
+                    topic: result[0],
+                    payload: result[1]
+                };
+            }
+
+            return null;
+        }
+
+        let setStatus = (msg) =>
+        {
+            if (msg == null)
+                return;
+
+            if (operation === "ABS")
+                node.status({ fill: "yellow", shape: "ring", text: operation + " => " + msg.payload });
+            else
+                node.status({ fill: "yellow", shape: "ring", text: operation + "(" + Object.entries(nodeSettings.values).map(v => v[1]).join(",") + ") => " + msg.payload });
+        }
+
+        if (config.save_state && config.resend_on_start && nodeSettings.lastMessage != null)
+        {
+            setTimeout(() =>
+            {
+                node.send(nodeSettings.lastMessage);
+            }, 10000);
+        }
+
+        setStatus(nodeSettings.lastMessage);
+    }
+
+    RED.nodes.registerType("smart_statistic", StatisticNode);
+}