smart-nodes 0.3.36 → 0.4.0

package/shutter-complex/shutter-complex.js

@@ -0,0 +1,578 @@
+module.exports = function (RED)
+{
+    "use strict";
+
+    function ShutterComplexControlNode(config)
+    {
+        const node = this;
+        RED.nodes.createNode(node, config);
+
+        // ###################
+        // # Class constants #
+        // ###################
+        const ACTION_UP = 0;
+        const ACTION_DOWN = 1;
+        const ACTION_STOP = 2;
+        const ACTION_POSITION = 3;
+
+        // #######################
+        // # Global help objects #
+        // #######################
+        const smart_context = require("../persistence.js")(RED);
+        const helper = require("../smart_helper.js");
+
+
+        // ############################
+        // # Used from text-exec node #
+        // ############################
+        if (typeof config.exec_text_names == "string")
+            node.exec_text_names = config.exec_text_names.split(",").map(n => n.trim().toLowerCase());
+        else
+            node.exec_text_names = [];
+
+
+        // #####################
+        // # persistent values #
+        // #####################
+        var node_settings = helper.cloneObject({
+            last_position: 0,              // 0 = opened, 100 = closed
+            last_direction_up: true,       // remember last direction for toggle action
+            last_position_before_alarm: 0, // remember position to restore on alarm off event
+            alarm_active: false,           // remember if alarm is on or off
+        }, smart_context.get(node.id));
+
+
+        // ##########################
+        // # Backward compatibility #
+        // ##########################
+        if (typeof config.max_time != "undefined")
+        {
+            config.max_time_up = config.max_time;
+            config.max_time_down = config.max_time;
+            delete config.max_time;
+        }
+
+
+        // ##################
+        // # Dynamic config #
+        // ##################
+        let max_time_up = parseInt(config.max_time_up || 60, 10);
+        let max_time_down = parseInt(config.max_time_down || 60, 10);
+        let revert_time_ms = parseInt(config.revert_time_ms || 100, 10);
+        let alarm_action = config.alarm_action || "NOTHING";
+        let alarm_off_action = config.alarm_off_action || "NOTHING";
+
+
+        // ##################
+        // # Runtime values #
+        // ##################
+
+        // Here the setTimeout return value is stored to stop the shutter.
+        // That means if it is null, the shutter is stopped.
+        let timeout = null;
+
+        // The local time when the shutter starts moving.
+        // This is needed to calc the new position of the shutter.
+        let on_time = null;
+
+        // The local time when the shutter was stopped last time.
+        // This is used to measure the revert time.
+        let off_time = null;
+
+        // This is the return value of setTimeout when the shutter has to wait until the reverse time is finished.
+        let wait_timeout = null;
+
+
+        // #########################
+        // # Central node handling #
+        // #########################
+        var event = "node:" + config.id;
+        var handler = function (msg)
+        {
+            node.receive(msg);
+        }
+        RED.events.on(event, handler);
+
+
+        // ###############
+        // # Node events #
+        // ###############
+        node.on("input", function (msg)
+        {
+            handleTopic(msg);
+
+            setStatus();
+            smart_context.set(node.id, node_settings);
+        });
+
+        node.on("close", function ()
+        {
+            startAction(ACTION_STOP);
+            RED.events.off(event, handler);
+        });
+
+
+        // #####################
+        // # Private functions #
+        // #####################
+
+        // This is the main function which handles all topics that was received.
+        let handleTopic = msg =>
+        {
+            helper.log("handle topic:");
+            helper.log(msg);
+
+            let real_topic = helper.getRealTopic(msg.topic, "toggle", ["up", "up_stop", "down", "down_stop", "stop", "toggle", "up_down", "position", "alarm"]);
+
+            // skip if button is released
+            if (msg.payload === false && ["up", "up_stop", "down", "down_stop", "stop", "toggle"].includes(real_topic))
+                return;
+
+            // Convert up_down from HA UI to next command
+            if (real_topic == "up_down")
+            {
+                if (msg.payload)
+                    real_topic = "down";
+                else
+                    real_topic = "up";
+
+                delete msg.payload;
+            }
+
+            // Correct next topic to avoid handling up_stop, down_stop or toggle separately.
+            if (timeout != null && ["up_stop", "down_stop", "toggle"].includes(real_topic))
+            {
+                real_topic = "stop";
+            }
+            else if (timeout == null)
+            {
+                // shutter is not running, set next command depending on topic
+                switch (real_topic)
+                {
+                    case "up_stop":
+                        real_topic = "up";
+                        break;
+
+                    case "down_stop":
+                        real_topic = "down";
+                        break;
+
+                    case "toggle":
+                        real_topic = node_settings.last_direction_up ? "down" : "up";
+                        break;
+                }
+            }
+
+            helper.log("handle real topic: " + real_topic);
+            switch (real_topic)
+            {
+                case "up":
+                    startAction(ACTION_UP, msg.time_on ?? null, msg.exact ?? null);
+                    break;
+
+                case "stop":
+                    startAction(ACTION_STOP);
+                    break;
+
+                case "down":
+                    startAction(ACTION_DOWN, msg.time_on ?? null, msg.exact ?? null);
+                    break;
+
+                case "position":
+                    startAction(ACTION_POSITION, msg.payload ?? null);
+                    break;
+
+                case "alarm":
+                    // Make sure it is bool
+                    msg.payload = !!msg.payload;
+
+                    // No alarm change, do nothing
+                    if (node_settings.alarm_active == msg.payload)
+                        return;
+
+                    node_settings.alarm_active = msg.payload;
+
+                    if (node_settings.alarm_active)
+                        handleAlarmOn();
+                    else
+                        handleAlarmOff();
+
+                    break;
+            }
+        };
+
+        /**
+         * This function is called when the alarm changes from off to on
+         */
+        let handleAlarmOn = () =>
+        {
+            switch (alarm_action)
+            {
+                case "UP":
+                    startAction(ACTION_UP, null, null, true);
+                    break;
+
+                case "DOWN":
+                    startAction(ACTION_DOWN, null, null, true);
+                    break;
+            }
+        }
+
+        /**
+         * This function is called when the alarm changes from on to off
+         */
+        let handleAlarmOff = () =>
+        {
+            switch (alarm_off_action)
+            {
+                case "NOTHING":
+                    break;
+
+                case "UP":
+                    startAction(ACTION_UP);
+                    break;
+
+                case "DOWN":
+                    startAction(ACTION_DOWN);
+                    break;
+
+                case "LAST":
+                    startAction(ACTION_POSITION, node_settings.last_position_before_alarm);
+                    break;
+            }
+        }
+
+        /**
+         * This functions stops the shutter if needed and starts the requested action.
+         * 
+         * @param {int} action One of ACTION_UP, ACTION_STOP, ACTION_DOWN or ACTION_POSITION.
+         * @param {string|float|null} data For ACTION_POSITION this is the position, for ACTION_UP and ACTION_DOWN it is the max run time.
+         * @param {boolean?} exact If true, the exact given time is used, otherwise some offset at 0% and 100% is used to ensure the shutter reach the end.
+         * @param {boolean?} ignoreAlarm If true, the action is performed even the alarm is activated. The default is false.
+         */
+        let startAction = (action, data = null, exact = false, ignoreAlarm = false) =>
+        {
+            helper.log("startAction");
+            helper.log({ action, data, exact, ignoreAlarm });
+
+            // Nothing allowed if alarm is on
+            if (ignoreAlarm === false && node_settings.alarm_active)
+                return;
+
+            // Variable declarations
+            let run_time_ms;
+            let needStop = false;
+            let now = Date.now();
+            let currentPosition = calcNewPosition();
+
+            // handle 0% and 100% as UP and DOWN command
+            if (action == ACTION_POSITION && data === 0)
+            {
+                action = ACTION_UP;
+                data = null;
+            }
+            else if (action == ACTION_POSITION && data === 100)
+            {
+                action = ACTION_DOWN;
+                data = null;
+            }
+
+            // Stop waiting for revert time, it will be restarted later with the correct following action
+            if (wait_timeout != null)
+            {
+                clearTimeout(wait_timeout);
+                wait_timeout = null;
+            }
+
+            // Shutter is running, check if it has to be stopped first
+            if (timeout != null)
+            {
+                switch (action)
+                {
+                    case ACTION_UP:
+                        if (node_settings.last_direction_up === false)
+                            needStop = true;
+                        break;
+
+                    case ACTION_DOWN:
+                        if (node_settings.last_direction_up === true)
+                            needStop = true;
+                        break;
+
+                    case ACTION_STOP:
+                        needStop = true;
+                        break;
+
+                    case ACTION_POSITION:
+                        // Wrong direction, do stop
+                        if (node_settings.last_direction_up === true && currentPosition < data)
+                            needStop = true;
+                        if (node_settings.last_direction_up === false && currentPosition > data)
+                            needStop = true;
+                        break;
+                }
+            }
+
+            // Stop shutter if needed and save new positions
+            if (needStop)
+            {
+                clearTimeout(timeout);
+                off_time = Date.now();
+                timeout = null;
+
+                if (!node_settings.alarm_active)
+                    node_settings.last_position_before_alarm = currentPosition;
+
+                node_settings.last_position = currentPosition;
+                sendToOutput(false, false);
+            }
+
+            // Determine needed runtime
+            switch (action)
+            {
+                case ACTION_STOP:
+                    // Already stopped, nothing more to do
+                    return;
+
+                case ACTION_UP:
+                    // data is the run time
+                    if (data == null)
+                        run_time_ms = node_settings.last_position * max_time_up / 100 * 1000;
+                    else
+                        run_time_ms = helper.getTimeInMsFromString(data);
+                    break;
+
+                case ACTION_DOWN:
+                    // data is the run time
+                    if (data == null)
+                        run_time_ms = (100 - node_settings.last_position) * max_time_down / 100 * 1000;
+                    else
+                        run_time_ms = helper.getTimeInMsFromString(data);
+                    break;
+
+                case ACTION_POSITION:
+                    // data is the position in percent
+                    if (data == null)
+                    {
+                        console.warn("WARN: Try to set position without giving a new position");
+                        return;
+                    }
+
+                    // Make sure it is in range 0-100
+                    data = Math.min(100, Math.max(0, data));
+
+                    // Convert to UP/DOWN with a specific time
+                    if (data < currentPosition)
+                    {
+                        run_time_ms = (currentPosition - data) / 100 * max_time_up * 1000;
+                        action = ACTION_UP;
+                    }
+                    else // if (data > currentPosition)
+                    {
+                        action = ACTION_DOWN;
+                        run_time_ms = (data - currentPosition) / 100 * max_time_down * 1000;
+                    }
+                    break;
+            }
+
+            if (exact !== true && data == null)
+            {
+                // Run at least for 5 seconds
+                if (run_time_ms < 5000)
+                    run_time_ms = 5000;
+            }
+
+            let dirChange = ((action == ACTION_UP && !node_settings.last_direction_up) || (action == ACTION_DOWN && node_settings.last_direction_up));
+
+            // Just to make sure there is no mistake
+            if (run_time_ms < 0)
+                run_time_ms = 0;
+
+            if (timeout != null)
+            {
+                // This happens if the time needs to be changed, but the direction is the same
+                clearTimeout(timeout);
+                helper.log("stop after " + run_time_ms + "ms");
+
+                off_time = Date.now();
+                on_time = off_time;
+                node_settings.last_position = currentPosition;
+
+                timeout = setTimeout(() =>
+                {
+                    // Just stop after the new time
+                    startAction(ACTION_STOP, null, null, ignoreAlarm);
+                    timeout = null;
+
+                    smart_context.set(node.id, node_settings);
+
+                    setStatus();
+                }, run_time_ms);
+            }
+            else if (off_time + revert_time_ms - now > 0 && dirChange)
+            {
+                // revert time is not fully passed
+                helper.log("revert time is not fully passed, wait for " + (off_time + revert_time_ms - now) + "ms");
+                wait_timeout = setTimeout(() =>
+                {
+                    wait_timeout = null;
+                    startAction(action, data, exact, ignoreAlarm);
+
+                    smart_context.set(node.id, node_settings);
+
+                    setStatus();
+                }, off_time + revert_time_ms - now);
+            }
+            else if (run_time_ms == 0)
+            {
+                // Do nothing.
+                // This can happen if exact = true but the shutter is already at the target position
+            }
+            else
+            {
+                // The shutter can finally be started.
+                switch (action)
+                {
+                    case ACTION_UP:
+                        helper.log("start ACTION_UP");
+                        sendToOutput(true, false);
+                        break;
+
+                    case ACTION_DOWN:
+                        helper.log("start ACTION_DOWN");
+                        sendToOutput(false, true);
+                        break;
+                }
+
+                if (!node_settings.alarm_active)
+                    node_settings.last_position_before_alarm = currentPosition;
+
+                on_time = Date.now();
+
+                helper.log("stop after " + run_time_ms + "ms");
+                timeout = setTimeout(() =>
+                {
+                    startAction(ACTION_STOP, null, null, ignoreAlarm);
+                    timeout = null;
+
+                    smart_context.set(node.id, node_settings);
+
+                    setStatus();
+                }, run_time_ms);
+            }
+        }
+
+        /**
+         * 
+         * @param {*} up 
+         * @param {*} down 
+         * @returns 
+         */
+        let sendToOutput = (up, down) =>
+        {
+            helper.log("sendToOutput");
+            helper.log({ up, down });
+
+            if (up && down)
+            {
+                console.error("Fatal exception, Cannot send up and down at the same time.");
+                return;
+            }
+
+            if (up)
+                node_settings.last_direction_up = true;
+            else if (down)
+                node_settings.last_direction_up = false;
+
+            node.send([{ payload: up }, { payload: down }, { payload: node_settings.last_position }]);
+
+            // Inform central nodes that shutter is running/stopped
+            notifyCentral(up || down);
+        }
+
+        /**
+         * 
+         * @returns 
+         */
+        let calcNewPosition = () =>
+        {
+            let now = Date.now();
+
+            if (timeout == null)
+                return node_settings.last_position;
+
+            // Change position while running,
+            // Calculate current position first
+            if (node_settings.last_direction_up)
+            {
+                let change_percentage = (now - on_time) / 1000 / max_time_up * 100;
+                return Math.max(0, node_settings.last_position - change_percentage);
+            }
+            else
+            {
+                let change_percentage = (now - on_time) / 1000 / max_time_down * 100;
+                return Math.min(100, node_settings.last_position + change_percentage);
+            }
+        }
+
+        /**
+         * Set the current node status
+         */
+        let setStatus = () =>
+        {
+            let fill = node_settings.alarm_active ? "red" : "green";
+            let shape = timeout != null ? "ring" : "dot";
+
+            // collect all texts and join later with a comma
+            let texts = [];
+
+            if (node_settings.alarm_active)
+                texts.push("ALARM");
+
+            if (timeout == null)
+                texts.push("Stopped");
+            else if (node_settings.last_direction_up)
+                texts.push("Up");
+            else
+                texts.push("Down");
+
+            texts.push("Position: " + node_settings.last_position?.toFixed(0) + "%");
+
+            node.status({ fill, shape, text: helper.getCurrentTimeForStatus() + ": " + texts.join(", ") });
+        }
+
+        /**
+         * Notify all connected central nodes
+         * @param {boolean} state The state if the shutter is running
+         * @returns 
+         */
+        let notifyCentral = state =>
+        {
+            if (!config.links)
+                return;
+
+            config.links.forEach(link =>
+            {
+                helper.log(node.id + " -> " + link);
+                helper.log({ source: node.id, state: state });
+                RED.events.emit("node:" + link, { source: node.id, state: state });
+            });
+        };
+
+        // For security reason, stop shutter at node start
+        wait_timeout = setTimeout(() =>
+        {
+            wait_timeout = null;
+
+            sendToOutput(false, false);
+            notifyCentral(false);
+
+            if (node_settings.alarm_active)
+                handleAlarmOn();
+
+            setStatus();
+        }, 10000);
+    }
+
+    RED.nodes.registerType("smart_shutter-complex-control", ShutterComplexControlNode);
+};

package/smart_helper.js

@@ -5,16 +5,16 @@ module.exports = {
      * If a type is unknown the NodeRed function is used for conversation.
      * 
      * Known types are:
-     * - "null", which will return always null
+     * - "NOTHING", which will return always null
      */
     evaluateNodeProperty(RED, value, type)
     {
         try
         {
-            switch (type)
+            switch (type?.toUpperCase())
             {
                 case null:
-                case "null":
+                case "NOTHING":
                     return null;
 
                 default:
@@ -23,10 +23,7 @@ module.exports = {
         }
         catch (error)
         {
-            console.error(value);
-            console.error(type);
-            console.error(error);
-            console.error(msg);
+            console.error({ value, type, error });
             return null;
         }
     },
@@ -72,6 +69,23 @@ module.exports = {
         return result;
     },
 
+    /**
+     * This functions extracts the topic name out of the given topic and checks if it is a valid topic.
+     * If not, the default topic is returned.
+     * @param {string} topic 
+     * @param {string} defaultTopic 
+     * @param {string[]} possibleTopics 
+     * @returns The real topic that needs to be processes
+     */
+    getRealTopic(topic, defaultTopic, possibleTopics)
+    {
+        let realTopic = this.getTopicName(topic);
+        if (possibleTopics.includes(realTopic))
+            return realTopic;
+
+        return defaultTopic;
+    },
+
     /**
      * This function converts the given value with the given unit into milli seconds.
      * 
@@ -166,6 +180,26 @@ module.exports = {
         return this.getTimeInMs(values[1].replace(",", "."), values[2] || "ms");
     },
 
+    /**
+     * Formats a string by replacing {n} with the n-th argument.
+     * Example: format("Hello {0}. {1} {0}.", "world", "Bye") => "Hello world. Bye world."
+     * @param {string} str The string to format
+     * @param  {...string} args The arguments used for the replacement
+     * @returns The formatted string
+     */
+    format(str, ...args)
+    {
+        if (!args.length)
+            return str;
+
+        for (var a in args)
+        {
+            str = str.replace(new RegExp("\\{" + a + "\\}", "gi"), args[a]);
+        }
+
+        return str
+    },
+
     /**
      * This function returns a string that represents the remaining time given in time_ms.
      * If a timeConcatWord it set, it returns also this word including the target time.
@@ -302,8 +336,17 @@ module.exports = {
      * @param {*} obj The Object to copy
      * @returns A new Object
      */
-    cloneObject(obj)
+    cloneObject(...obj)
+    {
+        return Object.assign({}, ...obj);
+    },
+
+    /**
+     * Forward all arguments to the console if it is enabled
+     */
+    log()
     {
-        return Object.assign({}, obj);
+        // uncomment to see all log values
+        // console.log(...arguments);
     }
 };

package/statistic/locales/de-DE/statistic.html

@@ -0,0 +1,10 @@
+<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>