smart-nodes 0.1.0

package/shutter-complex-control/shutter-complex-control.js

@@ -0,0 +1,399 @@
+module.exports = function (RED)
+{
+    function ShutterComplexControlNode(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
+        let max_time = parseInt(config.max_time || 60);
+        let revert_time_ms = parseInt(config.revert_time_ms || 100);
+        let alarm_action = config.alarm_action || "NOTHING";
+
+        // runtime values
+        let max_time_timeout = null;
+        let on_time = null;
+        let off_time = null;
+        let wait_for_up = false;
+        let wait_for_down = false;
+        let wait_timeout = null;
+        let alarm_active = false;
+
+        // central handling
+        var event = "node:" + config.id;
+        var handler = function (msg)
+        {
+            node.receive(msg);
+        }
+        RED.events.on(event, handler);
+
+
+        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 resultUp = false;
+            var resultDown = false;
+            var resultStop = false;
+
+            let realTopic = helper.getTopicName(msg.topic);
+
+            // set default topic if invalid value is send
+            if (!["up", "up_stop", "down", "down_stop", "stop", "toggle", "up_down", "position", "alarm"].includes(realTopic))
+                realTopic = "toggle";
+
+            // skip if button is released
+            if (msg.payload === false && ["up", "up_stop", "down", "down_stop", "stop", "toggle"].includes(realTopic))
+                return;
+
+            // Convert up_down from HA UI to next command
+            if (realTopic == "up_down")
+            {
+                if (msg.payload)
+                    realTopic = "down";
+                else
+                    realTopic = "up";
+            }
+
+            // Correct next topic to avoid handling up_stop, down_stop or toggle separately.
+            if (max_time_timeout != null && (realTopic == "up_stop" || realTopic == "down_stop" || realTopic == "toggle"))
+            {
+                realTopic = "stop";
+            }
+            else if (max_time_timeout == null)
+            {
+                // 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";
+            }
+
+            // console.log("Convert topic to: " + realTopic);
+
+            switch (realTopic)
+            {
+                case "up":
+                    if (max_time_timeout != null)
+                    {
+                        // Nothing todo
+                        if (nodeSettings.last_direction_up)
+                            return;
+
+                        // Runs down at the moment, so stop first
+                        if (nodeSettings.last_direction_up == false)
+                        {
+                            // console.log("--- Sub topic ---");
+                            handleTopic({ topic: "stop" });
+                            // console.log("-----------------");
+                        }
+                    }
+
+                    on_time = Date.now();
+                    resultUp = true;
+                    startAutoOff(false, helper.getTimeInMsFromString(msg.time_on) || null);
+                    if (!alarm_active)
+                        node.status({ fill: "green", shape: "dot", text: "Up" });
+                    break;
+
+                case "stop":
+                    if (alarm_active)
+                        break;
+
+                    resultStop = true;
+                    if (max_time_timeout != null)
+                    {
+                        const change_percentage = (Date.now() - on_time) / 1000 / max_time * 100;
+                        if (nodeSettings.last_direction_up)
+                            nodeSettings.last_position = Math.max(0, nodeSettings.last_position - change_percentage);
+                        else
+                            nodeSettings.last_position = Math.min(100, nodeSettings.last_position + change_percentage);
+                    }
+                    off_time = Date.now();
+                    stopAutoOff();
+                    node.status({ fill: "red", shape: "dot", text: "Stopped at " + Math.round(nodeSettings.last_position) + "%" });
+                    break;
+
+                case "down":
+                    if (max_time_timeout != null)
+                    {
+                        // Nothing todo
+                        if (nodeSettings.last_direction_up == false)
+                            return;
+
+                        // Runs up at the moment, so stop first
+                        if (nodeSettings.last_direction_up)
+                        {
+                            // console.log("--- Sub topic ---");
+                            handleTopic({ topic: "stop" });
+                            // console.log("-----------------");
+                        }
+                    }
+
+                    on_time = Date.now();
+                    resultDown = true;
+                    startAutoOff(true, helper.getTimeInMsFromString(msg.time_on) || null);
+                    if (!alarm_active)
+                        node.status({ fill: "green", shape: "dot", text: "Down" });
+                    break;
+
+                case "position":
+                    if (alarm_active)
+                        break;
+
+                    let value = parseFloat(msg.payload);
+
+                    if (value < 0) value = 0;
+                    if (value > 100) value = 100;
+
+                    const now = Date.now();
+
+                    if (max_time_timeout != null)
+                    {
+                        // Change position while running,
+                        // Calculate current position first
+                        const change_percentage = (now - on_time) / 1000 / max_time * 100;
+                        if (nodeSettings.last_direction_up)
+                            nodeSettings.last_position = Math.max(0, nodeSettings.last_position - change_percentage);
+                        else
+                            nodeSettings.last_position = Math.min(100, nodeSettings.last_position + change_percentage);
+
+                        node.status({ fill: "gray", shape: "dot", text: "Update current position to " + nodeSettings.last_position + "%" });
+
+                        // Runs in the wrong direction at the moment, so stop first
+                        if (nodeSettings.last_direction_up && value > nodeSettings.last_position)
+                        {
+                            // console.log("--- Sub topic ---");
+                            handleTopic({ topic: "stop" });
+                            // console.log("-----------------");
+                        }
+                        else if (nodeSettings.last_direction_up == false && value < nodeSettings.last_position)
+                        {
+                            // console.log("--- Sub topic ---");
+                            handleTopic({ topic: "stop" });
+                            // console.log("-----------------");
+                        }
+                    }
+
+                    on_time = now;
+
+                    if (value < nodeSettings.last_position)
+                    {
+                        // Go up
+                        resultUp = true;
+                        startAutoOff(false, (nodeSettings.last_position - value) / 100 * max_time * 1000, value);
+                    }
+                    else if (value > nodeSettings.last_position)
+                    {
+                        // Go down
+                        resultDown = true;
+                        startAutoOff(true, (value - nodeSettings.last_position) / 100 * max_time * 1000, value);
+                    }
+                    else
+                    {
+                        // Really an exact match
+                        handleTopic({ topic: "stop" });
+                        return;
+                    }
+
+                    node.status({ fill: "green", shape: "dot", text: "Set position from " + nodeSettings.last_position + "%  to " + value + "%" });
+                    break;
+
+                case "alarm":
+                    alarm_active = msg.payload;
+
+                    if (alarm_active)
+                    {
+                        node.status({ fill: "red", shape: "dot", text: "ALARM is active" });
+
+                        switch (alarm_action)
+                        {
+                            case "UP":
+                                handleTopic({ topic: "up" });
+                                break;
+
+                            case "DOWN":
+                                handleTopic({ topic: "down" });
+                                break;
+                        }
+                    }
+                    break;
+            }
+
+            sendResult(resultUp, resultDown, resultStop);
+        };
+
+        let startAutoOff = (down, wait_time_ms = null, new_position = null) =>
+        {
+            // console.log("startAutoOff (" + down + ", " + wait_time_ms + ", " + new_position + ");");
+
+            // Stop if any timeout is set
+            stopAutoOff();
+
+            if (new_position != null)
+            {
+                // use normal times for top or bottom position
+                if (new_position == 0)
+                {
+                    new_position = null;
+                    down = false;
+                }
+                else if (new_position == 100)
+                {
+                    new_position = null;
+                    down = true;
+                }
+            }
+            if (wait_time_ms == null)
+            {
+                if (down)
+                    wait_time_ms = (100 - nodeSettings.last_position) * max_time / 100 * 1000;
+                else
+                    wait_time_ms = nodeSettings.last_position * max_time / 100 * 1000;
+
+                // Run at least for 5 seconds
+                if (wait_time_ms < 5000)
+                    wait_time_ms = 5000;
+            }
+
+            max_time_on = parseInt(wait_time_ms / 1000);
+
+            if (wait_time_ms < 0)
+            {
+                node.status({ fill: "red", shape: "dot", text: "time_on value has to be greater than 0" });
+                return;
+            }
+
+            if (!alarm_active)
+                node.status({ fill: "yellow", shape: "ring", text: (down ? "Down" : "Up") + ", wait " + helper.formatMsToStatus(max_time_on, "until") + " for auto off" });
+
+            max_time_timeout = setTimeout(() =>
+            {
+                handleTopic({ topic: "stop" });
+                if (new_position != null)
+                    nodeSettings.last_position = new_position;
+                smartContext.set(node.id, nodeSettings);
+            }, wait_time_ms);
+        };
+
+        let stopAutoOff = () =>
+        {
+            if (max_time_timeout != null)
+            {
+                // console.log("stopAutoOff");
+                if (!alarm_active)
+                    node.status({ fill: "green", shape: "dot", text: "Stopped at " + Math.round(nodeSettings.last_position) + "%" });
+                clearTimeout(max_time_timeout);
+                off_time = Date.now();
+                max_time_timeout = null;
+            }
+        };
+
+        let sendResult = (up, down, stop) =>
+        {
+            // console.log("sendResult(" + up + ", " + down + ", " + stop + ");");
+            if ((up && wait_for_down) || (down && wait_for_up))
+            {
+                // console.log("Stop wait timeout");
+                clearTimeout(wait_timeout);
+                wait_timeout = null;
+            }
+
+            let now = Date.now();
+            if (off_time + revert_time_ms > now)
+            {
+                // Output has to possibly wait until the revert time has passed
+                if ((nodeSettings.last_direction_up && down) || (nodeSettings.last_direction_up == false && up))
+                {
+                    // console.log("Start wait timeout for " + (off_time + revert_time_ms - now) + "ms");
+
+                    if (off_time + revert_time_ms - now > revert_time_ms)
+                        return;
+
+                    wait_timeout = setTimeout(() =>
+                    {
+                        wait_timeout = null;
+                        sendResult(up, down, stop);
+                    }, off_time + revert_time_ms - now);
+                    return;
+                }
+            }
+
+            if (stop && wait_timeout != null)
+            {
+                clearTimeout(wait_timeout);
+                wait_timeout = null;
+            }
+
+            // console.log("really sendResult(" + up + ", " + down + ", " + stop + ");");
+            if (up)
+            {
+                if (!alarm_active || alarm_action === "UP")
+                {
+                    nodeSettings.last_direction_up = true;
+                    node.send([{ payload: true }, { payload: false }, { payload: nodeSettings.last_position }]);
+                    notifyCentral(true);
+                }
+            }
+            else if (down)
+            {
+                if (!alarm_active || alarm_action === "DOWN")
+                {
+                    nodeSettings.last_direction_up = false;
+                    node.send([{ payload: false }, { payload: true }, { payload: nodeSettings.last_position }]);
+                    notifyCentral(true);
+                }
+            }
+            else if (stop && !alarm_active)
+            {
+                node.send([{ payload: false }, { payload: false }, { payload: nodeSettings.last_position }]);
+                notifyCentral(false);
+            }
+        };
+
+        let notifyCentral = state =>
+        {
+            if (!config.links)
+                return;
+
+            config.links.forEach(link =>
+            {
+                RED.events.emit("node:" + link, { source: node.id, state: state });
+            });
+        };
+
+        // For security reason, stop shutter at node start
+        setTimeout(() =>
+        {
+            node.send([{ payload: false }, { payload: false }, { payload: nodeSettings.last_position }]);
+            node.status({ fill: "red", shape: "dot", text: "Stopped at " + Math.round(nodeSettings.last_position) + "%" });
+            notifyCentral(false);
+        }, 10000);
+    }
+
+    RED.nodes.registerType("smart_shutter-complex-control", ShutterComplexControlNode);
+};

package/shutter-control/shutter-control.html

@@ -0,0 +1,283 @@
+<script type="text/javascript">
+    (function ()
+    {
+        let treeList;
+        let candidateNodesCount = 0;
+        let flows = [];
+        let flowMap = {};
+
+        function onEditPrepare(node, targetTypes)
+        {
+            if (!node.links)
+                node.links = [];
+
+            const activeSubflow = RED.nodes.subflow(node.z);
+
+            treeList = $("<div>")
+                .css({ width: "100%", height: "100%" })
+                .appendTo(".node-input-link-row")
+                .treeList({ autoSelect: false })
+                .on("treelistitemmouseover", function (e, item)
+                {
+                    if (item.node)
+                    {
+                        item.node.highlighted = true;
+                        item.node.dirty = true;
+                        RED.view.redraw();
+                    }
+                })
+                .on("treelistitemmouseout", function (e, item)
+                {
+                    if (item.node)
+                    {
+                        item.node.highlighted = false;
+                        item.node.dirty = true;
+                        RED.view.redraw();
+                    }
+                });
+
+            flows = [];
+            flowMap = {};
+
+            if (activeSubflow)
+            {
+                flowMap[activeSubflow.id] = {
+                    id: activeSubflow.id,
+                    class: "red-ui-palette-header",
+                    label: "Subflow : " + (activeSubflow.name || activeSubflow.id),
+                    expanded: true,
+                    children: []
+                };
+                flows.push(flowMap[activeSubflow.id]);
+            }
+            else
+            {
+                RED.nodes.eachWorkspace(function (ws)
+                {
+                    if (!ws.disabled)
+                    {
+                        flowMap[ws.id] = {
+                            id: ws.id,
+                            class: "red-ui-palette-header",
+                            label: (ws.label || ws.id) + (node.z === ws.id ? " *" : ""),
+                            expanded: true,
+                            children: []
+                        };
+                        flows.push(flowMap[ws.id]);
+                    }
+                });
+            }
+
+            setTimeout(function ()
+            {
+                treeList.treeList("show", node.z);
+            }, 100);
+        }
+
+        function initTreeList(node, targetTypes)
+        {
+            candidateNodesCount = 0;
+            for (const key in flowMap)
+            {
+                flowMap[key].children = [];
+            }
+
+            let candidateNodes = [];
+
+            targetTypes.forEach(function (targetType)
+            {
+                candidateNodes = candidateNodes.concat(RED.nodes.filterNodes({ type: targetType }));
+            });
+
+            candidateNodes.forEach(function (n)
+            {
+                if (flowMap[n.z])
+                {
+                    const isChecked = (node.links.indexOf(n.id) !== -1) || (n.links || []).indexOf(node.id) !== -1;
+                    if (isChecked)
+                    {
+                        flowMap[n.z].children.push({
+                            id: n.id,
+                            node: n,
+                            label: n.name || n.id,
+                            selected: false,
+                            checkbox: false,
+                            radio: false
+                        });
+                        candidateNodesCount++;
+                    }
+                }
+            });
+
+            for (const key in flowMap)
+            {
+                flowMap[key].children.sort((a, b) => a.label.localeCompare(b.label));
+            }
+
+            const flowsFiltered = flows.filter(function (f) { return f.children.length > 0 });
+            treeList.treeList("empty");
+            treeList.treeList("data", flowsFiltered);
+        }
+
+        function resizeNodeList()
+        {
+            var rows = $("#dialog-form>div:not(.node-input-link-row)");
+            var height = $("#dialog-form").height();
+            for (var i = 0; i < rows.length; i++)
+            {
+                height -= $(rows[i]).outerHeight(true);
+            }
+            var editorRow = $("#dialog-form>div.node-input-link-row");
+            height -= (parseInt(editorRow.css("marginTop")) + parseInt(editorRow.css("marginBottom")));
+            $(".node-input-link-row").css("height", height + "px");
+        }
+
+        RED.nodes.registerType("smart_shutter-control", {
+            category: "Smart Nodes",
+            paletteLabel: "Shutter control",
+            color: "#C882FF",
+            defaults: {
+                name: { value: "" },
+                links: { value: [], type: "smart_central-control[]" }
+            },
+            inputs: 1,
+            outputs: 3,
+            outputLabels: ["Up/Down", "Stop", "Position"],
+            icon: "font-awesome/fa-align-justify",
+            label: function ()
+            {
+                return this.name || "Shutter control";
+            },
+            oneditprepare: function ()
+            {
+                let node = this;
+                onEditPrepare(this, ["smart_central-control"]);
+                initTreeList(node, ["smart_central-control"]);
+            },
+            onadd: function ()
+            {
+                this.links = [];
+            },
+            oneditresize: resizeNodeList
+        });
+    })();
+</script>
+
+<script type="text/html" data-template-name="smart_shutter-control">
+    <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>
+    <span><i class="fa fa-link"></i>Dieser Baustein wird von folgenden Zentralbausteinen gesteuert:</span>
+    <div class="form-row node-input-link-row node-input-link-rows"></div>
+</script>
+
+<script type="text/html" data-help-name="smart_shutter-control">
+    <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>
+        Diese Node steuert Rollladen oder Jalousien.
+        Es gibt 3 Ausgänge die angesteuert werden können:
+        <ol>
+            <li><b>Auf/Ab:</b> <code>msg.payload = false</code> lässt den Rollladen nach oben fahren und <code>msg.payload = true</code> lässt den Rollladen nach unten fahren.</li>
+            <li><b>Stop:</b> <code>msg.payload = true</code> lässt den Rollladen stoppen.</li>
+            <li><b>Position:</b> <code>msg.payload = 42</code> Lässt den Rollladen auf 42% fahren.</li>
+        </ol>
+        Die Ausgänge sind den jeweiligen KNX Gruppenadressen zuzuordnen.
+    </p>
+    <p>
+        Diese Node erwartet folgende Topics als Eingang:<br/>
+        <table>
+            <thead>
+                <tr>
+                    <th>Topic</th>
+                    <th>Beschreibung</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td><code>status</code> oder <code>status_position</code></td>
+                    <td>
+                        Meldet der Node die aktuelle Position.
+                        Dadurch kann die Node feststellen in welche Richtung ein Rollladen als letztes gefahren ist.
+                        Dies wird für das topic <b>toggle</b> benötigt um die nächste Laufrichtung bei einer 1-Tasten Bedienung zu ermitteln.
+                    </td>
+                </tr>
+                <tr>
+                    <td><code>up_down</code></td>
+                    <td>
+                        Nimmt einen Befehl von Home Assistant entgegen um informiert zu werden ob der Rollladen läuft und in welche Richtung.<br/>
+                        <strong>Wichtig:</strong> Dieses Topic startet den Rollladen <u>nicht</u>, da die Gruppenadresse direkt mit dem Jalousiemodul verbunden sein muss.
+                    </td>
+                </tr>
+                <tr>
+                    <td><code>up</code></td>
+                    <td>Sendet einen Hochfahrbefehl, falls der Rollladen nicht bereits nach oben fährt. Ggf. wird vorher noch ein Stop-Befehl gesendet.</td>
+                </tr>
+                <tr>
+                    <td><code>up_stop</code></td>
+                    <td>Sendet abwechselnd einen Stop- und einen Hochfahrbefehl.</td>
+                </tr>
+                <tr>
+                    <td><code>down</code></td>
+                    <td>Sendet einen Runterfahrbefehl, falls der Rollladen nicht bereits nach unten fährt. Ggf. wird vorher noch ein Stop-Befehl gesendet.</td>
+                </tr>
+                <tr>
+                    <td><code>down_stop</code></td>
+                    <td>Sendet abwechselnd einen Stop- und einen Runterfahrbefehl.</td>
+                </tr>
+                <tr>
+                    <td><code>stop</code></td>
+                    <td>Sendet einen Stopbefehl.</td>
+                </tr>
+                <tr>
+                    <td><code>position</code></td>
+                    <td>Sendet einen Positionsbefehl. <code>msg.payload</code> sollte ein Wert zwischen 0 (offen) und 100 (geschlossen) haben.</td>
+                </tr>
+                <tr>
+                    <td><code>toggle</code> (default)</td>
+                    <td>Schaltet den Rollladen abwechselnd auf hoch, stop, runter, stop.</td>
+                </tr>
+            </tbody>
+        </table>
+    </p>
+    <p>
+        Diese Node verwaltet keine Laufzeit für den Rollladen selbst. Diese muss über ETS für den Ausgang konfiguriert werden.
+        Es ist jedoch möglich, den Rollladen nach einer definierten Zeit automatisch abzuschalten.
+        Es ist jedoch möglich, den Rollladen nach einer definierten Zeit automatisch abzuschalten.
+        Beispiel: <code>msg = { "topic": "up", "time_on": 5000 }</code> oder <code>msg = { "topic": "up", "time_on": "5s" }</code><br/>
+        Diese Nachricht lässt den Rollladen für 5000 Millisekunden / 5 Sekunden nach oben fahren. Sollte es sich um eine Jalousie halten, werden die Lamellen entsprechend gedreht.
+        Als Einheit für die Zeit können folgende Werte verwendet werden:
+        <table>
+            <thead>
+                <tr>
+                    <th>Einheit</th>
+                    <th>Beschreibung</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td><code>ms</code> (default)</td>
+                    <td>Millisekunden</td>
+                </tr>
+                <tr>
+                    <td><code>s</code> oder <code>sec</code></td>
+                    <td>Sekunden</td>
+                </tr>
+                <tr>
+                    <td><code>m</code> oder <code>min</code></td>
+                    <td>Mintun.</td>
+                </tr>
+                <tr>
+                    <td><code>h</code></td>
+                    <td>Stunden</td>
+                </tr>
+            </tbody>
+        </table>
+    </p>
+    <p>
+        Die Angabe einer Zeit funktioniert nicht mit dem topic <b>position</b>.
+    </p>
+</script>