smart-nodes 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 BergenSoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LICENSE.md

@@ -0,0 +1,21 @@
+# The MIT License (MIT)
+
+Copyright (c) 2023 Samuel Bergen
+
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# General information
+
+The smart nodes was created to control smart home devices like lights, power outlets shutter and some more.
+This controls are designed to work with the [node-red-contrib-knx-ultimate](https://github.com/Supergiovane/node-red-contrib-knx-ultimate) but it could also work with other smart technologies.
+
+Sometimes one source node should be connected to multiple smart nodes which requires different topics.
+To avoid requiring many change nodes, the smart node are using a special `msg.topic` notation. You can always send topics in the format `name#number`, e.g. `toggle#1`.
+Smart nodes that requires a name are using only the name part. the # and the number are optional. Smart nodes that requries a number will only use the number, the name and # is also optional.
+
+This is usefull when one node provide information to e.g. a light control node, as well as to a logic node.
+
+This file only describes the general function of the node. See the documentation shown in NodeRed to find out how to use them, or see the included example flows.
+As I'm german, the internal documentation is only available in german. If you need another language, feel free to add localizations and adding more languages via a pull request.
+
+# Nodes
+## 1. Light control  
+This node is able to control a light or a power outlet.
+
+### **Features:**
+* Auto turn off the light after a fixed time.
+* Auto turn off the light with a custom time which is part of the message object.
+* Toggle light between on and off.
+* Can be triggered by motion sensors.
+* Has an alarm function to go to a specific state (on or off) when the alarm is activated.
+
+## 2. Shutter control
+This node is able to control a shutter.
+There is no support for slats and it is also not planned as I don't need them, but feel free to send a pull request.
+
+### **Features:**
+* One button control which switch between `up`, `stop`, `down`, `stop`.
+* One button control for each direction `up and stop` or `down and stop`.
+* Send direct position the shutter should be.
+* Stop shutter immediately.
+* Has an alarm function to go to a specific state (Open or close) when the alarm is activated.
+
+## 3. Scene control
+This node is tracking the state of multiple outputs and controls them by switching to multiple defined scenes.
+
+### **Features:**
+* An input message could name multiple scenes that should be iterated one by one by receiving the same message multiple times
+
+## 4. Central control
+This node can control multiple light/scene controls or shutter controls at the same time
+
+### **Features:**
+* Take care that multiple light/scene controls are turned of if any of them is one before executing a toggle command. This is helpful to avoid turning one light on and the other off.
+* The same is used for shutters with the up_stop or down_stop commands. A toggle is not supported, it will only be forwarded.
+
+## 5. Long press control
+This control is used to detect a short or a long press.
+The time can be configured in this control.
+
+### **Features:**
+* Imediately send a message to the long press output when the time is reached. It is not waiting until the button is released.
+
+## 6. Multi press control
+This control is used to detect multiple presses on a button.
+The max wait time between presses can be configured in this control.
+You can also choose 2-4 press detection.
+
+### **Features:**
+* Imediately send a message to the last output when the max presses are reached. It is not waiting until the button is released.
+
+## 7. Hysteresis
+This control is checking if the input value reachs a defined value until the upper message is send. When the lower level is reached, the lower masssage will be send
+
+### **Features:**
+* The state can be saved between NodeRed restarts.
+* The last message can automatically be sent 10 seconds after a deployment.
+
+## 8. Logic
+This control can be used for AND, OR and XOR logics.
+
+### **Features:**
+* All input values could be individual converted as well as the output messsage.
+* A NOT logic is possible when selecting 1 input and convert the output.
+* The setpoint and hysteresis value can be changed in runtime.
+* The state can be saved between NodeRed restarts.
+* The last message can automatically be sent 10 seconds after a deployment.
+
+## 9. Statistic
+This control can be used for getting the following types of values: Minimum, Maximum, Sum, Difference, Absolute Value, Absolute Difference, Average and Running average.
+
+### **Features:**
+* All input values could be individual converted as well as the output messsage.
+* A NOT logic is possible when selecting 1 input and convert the output.
+* The state can be saved between NodeRed restarts.
+* The last message can automatically be sent 10 seconds after a deployment.
+
+## 10. Compare
+This control can compare 2 values with the following operators: < <= == >= > !=
+
+### **Features:**
+* Can compare also texts like js would do.
+* The state can be saved between NodeRed restarts.
+* The last message can automatically be sent 10 seconds after a deployment.
+
+## 11. Delay
+This control can delay incomming messages.
+
+### **Features:**
+* Different times for `msg.payload = true` and `msg.payload = false`.
+* Delays can be changed in runtime.
+* The state can be saved between NodeRed restarts.
+* The last message can automatically be sent 10 seconds after a deployment.
+
+## 12. Forwarder
+This control can control if an incomming message should be forwarded or not.
+
+### **Features:**
+* The forwarding can be enabled or disabled in runtime.
+* The state can be saved between NodeRed restarts.
+* The last message can automatically be sent 10 seconds after a deployment.
+
+## 13. Scheduler
+This control can send a defined message on defined times.
+
+### **Features:**
+* The weekdays and the time can be selected as a trigger.
+* Multiple trigger and messages can be defined in one node.
+* The scheduler can be activated or deactivated in runtime.
+* The state can be saved between NodeRed restarts.
+* The last message can automatically be sent 10 seconds after a deployment.
+
+# Create node package
+run `node pack` to create a new *.tgz node module.

package/central/central.html

@@ -0,0 +1,328 @@
+<script type="text/javascript">
+    (function ()
+    {
+        let treeList;                // The tree control itself
+        let candidateNodesCount = 0; // The total entries shown in the list, used for the search box as info
+        let flows = [];              // A List with all flow maps
+        let flowMap = {};            // A key value list with all flow id => flow details and children
+
+        function onEditPrepare(node, targetTypes)
+        {
+            if (!node.links)
+                node.links = [];
+
+            node.oldLinks = [];
+
+            const activeSubflow = RED.nodes.subflow(node.z);
+
+            // init tree list control
+            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();
+                    }
+                });
+
+            // init search box
+            const search = $("#node-input-link-target-filter").searchBox({
+                style: "compact",
+                delay: 300,
+                change: function ()
+                {
+                    var val = $(this).val().trim().toLowerCase();
+                    if (val === "")
+                    {
+                        treeList.treeList("filter", null);
+                        search.searchBox("count", "");
+                    }
+                    else
+                    {
+                        const count = treeList.treeList("filter", function (item)
+                        {
+                            return item.label.toLowerCase().indexOf(val) > -1 || (item.parent && item.parent.label.toLowerCase().indexOf(val) > -1) || (item.node && item.node.type.toLowerCase().indexOf(val) > -1);
+                        });
+                        search.searchBox("count", count + " / " + candidateNodesCount);
+                    }
+                },
+            });
+
+            // clear shown tree data
+            flows = [];
+            flowMap = {};
+
+            // Add all existing flows
+            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 }));
+            });
+
+            // Add all nodes, matching the given types
+            candidateNodes.forEach(function (n)
+            {
+                if (flowMap[n.z])
+                {
+                    const isChecked = node.links.indexOf(n.id) !== -1 || (n.links || []).indexOf(node.id) !== -1;
+                    if (isChecked) node.oldLinks.push(n.id);
+
+                    flowMap[n.z].children.push({
+                        id: n.id,
+                        node: n,
+                        label: n.name || n.id,
+                        selected: isChecked,
+                        checkbox: true,
+                        radio: false,
+                    });
+                    candidateNodesCount++;
+                }
+            });
+
+            // Sort nodes by name
+            for (const key in flowMap)
+            {
+                flowMap[key].children.sort((a, b) => a.label.localeCompare(b.label));
+            }
+
+            // filter empty flows
+            const flowsFiltered = flows.filter(function (f)
+            {
+                return f.children.length > 0;
+            });
+
+            // clear list and refill it
+            treeList.treeList("empty");
+            treeList.treeList("data", flowsFiltered);
+        }
+
+        function resizeNodeList()
+        {
+            // calculate new heigt if browser is beeing resized
+            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");
+        }
+
+        function onEditSave(node)
+        {
+            var flows = treeList.treeList("data");
+            node.links = [];
+
+            // Set own links for selected nodes
+            flows.forEach(function (f)
+            {
+                f.children.forEach(function (n)
+                {
+                    if (n.selected)
+                        node.links.push(n.id);
+                });
+            });
+
+            node.oldLinks.sort();
+            node.links.sort();
+
+            // Mark new and old links
+            var nodeMap = {};
+            var length = Math.max(node.oldLinks.length, node.links.length);
+            for (var i = 0; i < length; i++)
+            {
+                if (i < node.oldLinks.length)
+                {
+                    nodeMap[node.oldLinks[i]] = nodeMap[node.oldLinks[i]] || {};
+                    nodeMap[node.oldLinks[i]].old = true;
+                }
+                if (i < node.links.length)
+                {
+                    nodeMap[node.links[i]] = nodeMap[node.links[i]] || {};
+                    nodeMap[node.links[i]].new = true;
+                }
+            }
+
+            // Remove own node from old linked nodes
+            // Add own node to new linked nodes
+            var n;
+            for (var id in nodeMap)
+            {
+                if (nodeMap.hasOwnProperty(id))
+                {
+                    n = RED.nodes.node(id);
+                    if (n)
+                    {
+                        // init links and remove duplicate links
+                        if (!n.links)
+                            n.links = [];
+                        else
+                            n.links = n.links.filter((value, index, array) => array.indexOf(value) === index);
+
+
+                        if (nodeMap[id].old && !nodeMap[id].new)
+                        {
+                            // Removed id
+                            i = n.links.indexOf(node.id);
+                            if (i > -1) n.links.splice(i, 1);
+                        }
+                        else if (nodeMap[id].new)
+                        {
+                            // Added id
+                            i = n.links.indexOf(node.id);
+                            if (i === -1) n.links.push(node.id);
+                        }
+                    }
+                }
+            }
+        }
+
+        // This function is called, when copying and pasting central node
+        function onAdd()
+        {
+            for (var i = 0; i < this.links.length; i++)
+            {
+                var n = RED.nodes.node(this.links[i]);
+                if (n && n.links.indexOf(this.id) === -1)
+                {
+                    n.links.push(this.id);
+                }
+            }
+        }
+
+        RED.nodes.registerType("smart_central-control", {
+            category: "Smart Nodes",
+            paletteLabel: "Central control",
+            color: "#6EE2D9",
+            defaults: {
+                name: { value: "" },
+                mode: { value: "shutter" }, // shutter | light
+                links: { value: [], type: "smart_shutter-complex-control[]" },
+            },
+            inputs: 1,
+            outputs: 0,
+            icon: function ()
+            {
+                if (this.mode === "shutter")
+                    return "font-awesome/fa-align-justify";
+
+                return "font-awesome/fa-lightbulb-o";
+            },
+            label: function ()
+            {
+                return this.name || "Central control";
+            },
+            oneditprepare: function ()
+            {
+                let node = this;
+
+                onEditPrepare(this, ["smart_shutter-complex-control", "smart_shutter-control"]);
+                $("#node-input-mode").on("change", function ()
+                {
+                    if (this.value == "shutter") initTreeList(node, ["smart_shutter-complex-control", "smart_shutter-control"]);
+                    else initTreeList(node, ["smart_light-control", "smart_scene-control"]);
+                });
+
+                if (!this.mode)
+                {
+                    $("#node-input-mode").val("shutter").trigger("change");
+                }
+            },
+            oneditsave: function ()
+            {
+                onEditSave(this);
+            },
+            onadd: onAdd,
+            oneditresize: resizeNodeList,
+        });
+    })();
+</script>
+
+<script type="text/html" data-template-name="smart_central-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" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-mode">Typ</label>
+        <select id="node-input-mode" style="width: 70%">
+            <option value="shutter" selected>Rollladen</option>
+            <option value="light">Licht/Steckdose</option>
+        </select>
+    </div>
+    <div class="node-input-link-rows" style="position:relative; height: 30px; text-align: right;"
+        ><div style="display:inline-block"><input type="text" id="node-input-link-target-filter" /></div
+    ></div>
+    <div class="form-row node-input-link-row node-input-link-rows"></div>
+</script>
+
+<script type="text/html" data-help-name="smart_central-control">
+    <p>
+        Der Zentralbaustein leitet einkommende Nachrichten an alle verlinkten Unterbausteine weiter.
+        Dabei beachtet der Baustein, die Funktion der Unterbausteine synchron zu halten.
+    </p>
+    <p>
+        D.h. Wird ein <code>toggle</code> an mehrere Lichtbausteine geschickt, so werden diese zuerst ausgeschaltet, falls mindestens eines eingeschaltet war.<br />
+        Rollladen werden ebenfalls erst gestoppt, falls einer gerade aktiv ist. Ein <code>toggle</code> an mehrere Rollladen wird derzeit nicht unterstützt.
+    </p>
+</script>

package/central/central.js

@@ -0,0 +1,95 @@
+module.exports = function (RED)
+{
+    function CentralControlNode(config)
+    {
+        const node = this;
+        RED.nodes.createNode(node, config);
+
+        // runtime values
+        let states = new Map();
+
+        // listen to all events sended directly to this node
+        let event = "node:" + config.id;
+        let handler = function (msg)
+        {
+            if (typeof msg.source == "undefined" || typeof msg.state == "undefined")
+            {
+                console.warn("Unknown message received in smart_node central", msg);
+                return;
+            }
+
+            // Save feedback from linked node
+            states.set(msg.source, msg.state);
+
+            if (isAllOff())
+                node.status({ fill: "red", shape: "dot", text: "All off" });
+            else
+                node.status({ fill: "green", shape: "dot", text: "Something is on" });
+        }
+        RED.events.on(event, handler);
+
+        node.status({});
+
+        node.on("input", function (msg)
+        {
+            // copy message, so original message stays unchanged
+            let newMsg = Object.assign({}, msg);
+
+            // make connected nodes behavior homogenous
+            switch (config.mode)
+            {
+                case "shutter":
+                    if (msg.topic == "up_stop")
+                    {
+                        if (isAllOff())
+                            newMsg.topic = "up";
+                        else
+                            newMsg.topic = "stop";
+                    }
+                    else if (msg.topic == "down_stop")
+                    {
+                        if (isAllOff())
+                            newMsg.topic = "down";
+                        else
+                            newMsg.topic = "stop";
+                    }
+                    break;
+
+                case "light":
+                    if (msg.topic == "toggle")
+                    {
+                        if (isAllOff())
+                            newMsg.topic = "on";
+                        else
+                            newMsg.topic = "off";
+                    }
+                    break;
+            }
+
+            // Send cloned message to all linked nodes
+            config.links.forEach(link =>
+            {
+                RED.events.emit("node:" + link, newMsg);
+            });
+        });
+
+        node.on("close", function ()
+        {
+            // Cleanup event listener
+            RED.events.removeListener(event, handler);
+        });
+
+        // This functions return true if all lights are off or all shutter are stopped
+        let isAllOff = () =>
+        {
+            for (let [key, state] of states)
+            {
+                if (state)
+                    return false;
+            }
+
+            return true;
+        }
+    }
+    RED.nodes.registerType("smart_central-control", CentralControlNode);
+};