smart-nodes 0.1.0

package/compare/compare.html

@@ -0,0 +1,137 @@
+<script type="text/javascript">
+    RED.nodes.registerType("smart_compare", {
+        category: "Smart Nodes",
+        paletteLabel: "Compare",
+        color: "#E2D96E",
+        defaults: {
+            name: { value: "" },
+            comparator: { value: "EQUAL" }, // EQUAL, GREATER, GREATER_EQUAL, SMALLER, SMALLER_EQUAL, UNEQUAL
+            value1: { value: "" },
+            value1_type: { value: "null" },
+            value2: { value: "" },
+            value2_type: { value: "null" },
+            save_state: { value: true },
+            resend_on_start: { value: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-sort",
+        label: function ()
+        {
+            return this.name || this.comparator || "Compare";
+        },
+        oneditprepare: function ()
+        {
+            $("#node-input-comparator").typedInput({
+                types: [
+                    {
+                        default: "EQUAL",
+                        options: [
+                            { value: "SMALLER", label: "< Kleiner" },
+                            { value: "SMALLER_EQUAL", label: "<= Kleiner oder gleich" },
+                            { value: "EQUAL", label: "== Gleich" },
+                            { value: "UNEQUAL", label: "!= Ungleich" },
+                            { value: "GREATER_EQUAL", label: ">= Größer oder gleich" },
+                            { value: "GREATER", label: "> Größer" }
+                        ],
+                    },
+                ],
+            });
+
+            $("#node-input-value1").typedInput({
+                type: "num",
+                types: ["str", "num", "bool", {
+                    value: "null",
+                    label: "Kein Wert",
+                    icon: "fa fa-times",
+                    hasValue: false,
+                }],
+                typeField: "#node-input-value1_type"
+            });
+
+            $("#node-input-value2").typedInput({
+                type: "num",
+                types: ["str", "num", "bool", {
+                    value: "null",
+                    label: "Kein Wert",
+                    icon: "fa fa-times",
+                    hasValue: false,
+                }],
+                typeField: "#node-input-value2_type"
+            });
+
+            $("#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_compare">
+    <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-comparator"><i class="fa fa-sort"></i> Vergleich</label>
+        <input id="node-input-comparator" />
+    </div>
+    <div class="form-row">
+        <div>Defaultwerte werden hier gesetzt und können durch die einkommenden Nachrichten überschrieben werden.</div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-value1"><i class="fa fa-hashtag"></i> Wert 1</label>
+        <input type="text" id="node-input-value1">
+        <input type="hidden" id="node-input-value1_type">
+    </div>
+    <div class="form-row">
+        <label for="node-input-value2"><i class="fa fa-hashtag"></i> Wert 2</label>
+        <input type="text" id="node-input-value2"/>
+        <input type="hidden" id="node-input-value2_type">
+    </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_compare">
+    <p>Diese Node führt verschiedene Vergleiche aus. Dabei können nicht nur Zahlen, sondern auch Texte verglichen werden.</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>
+    <p>
+        Folgende topics werden akzeptiert:
+        <table>
+            <thead>
+                <tr>
+                    <th>Topic</th>
+                    <th>Beschreibung</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td><code>1</code></td>
+                    <td>Setzt den linken zu vergleichenden Wert</td>
+                </tr>
+                <tr>
+                    <td><code>2</code></td>
+                    <td>Setzt den rechten zu vergleichenden Wert</td>
+                </tr>
+            </tbody>
+        </table>
+    </p>
+    <p>Texte werden anhand ihres Ascii-Codes verglichen.<code>"c" &lt; "b"</code> ergibt <code>false</code><code>"C" &lt; "b"</code> ergibt <code>true</code>.</p>
+</script>

package/compare/compare.js

@@ -0,0 +1,151 @@
+module.exports = function (RED)
+{
+    function CompareNode(config)
+    {
+        const node = this;
+        RED.nodes.createNode(node, config);
+
+        const smartContext = require("../persistence.js")(RED);
+        const helper = require("../smart_helper.js");
+
+        var nodeSettings = {
+            values: [
+                helper.evaluateNodeProperty(RED, config.value1, config.value1_type),
+                helper.evaluateNodeProperty(RED, config.value2, config.value2_type)
+            ],
+            lastResult: 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 comparator = config.comparator;
+
+        // runtime values
+
+        node.on("input", function (msg)
+        {
+            // Check if topic has a valid value
+            let input = helper.getTopicNumber(msg.topic);
+            if (input == null || input < 1 || input > 2)    
+            {
+                node.error("Topic has to be 1 or 2, send: " + msg.topic);
+                return;
+            }
+
+            // check if payload has a valid value
+            let num = parseFloat(msg.payload);
+            if (Number.isNaN(num))
+            {
+                node.error("Payload has to be numeric");
+                return;
+            }
+
+            // Save new value
+            nodeSettings.values[input - 1] = num;
+
+            let result = getResult();
+            setStatus(result);
+
+            if (result != null)
+            {
+                nodeSettings.lastResult = result;
+
+                if (config.save_state)
+                    smartContext.set(node.id, nodeSettings);
+
+                node.send({ payload: result, comparator: comparator });
+            }
+        });
+
+        let getResult = () =>
+        {
+            // Wait until both values are set
+            if (nodeSettings.values[0] == null || nodeSettings.values[1] == null)
+                return null;
+
+            switch (comparator)
+            {
+                case "SMALLER":
+                    return nodeSettings.values[0] < nodeSettings.values[1];
+
+                case "SMALLER_EQUAL":
+                    return nodeSettings.values[0] <= nodeSettings.values[1];
+
+                case "EQUAL":
+                    return nodeSettings.values[0] === nodeSettings.values[1];
+
+                case "UNEQUAL":
+                    return nodeSettings.values[0] !== nodeSettings.values[1];
+
+                case "GREATER_EQUAL":
+                    return nodeSettings.values[0] >= nodeSettings.values[1];
+
+                case "GREATER":
+                    return nodeSettings.values[0] > nodeSettings.values[1];
+            }
+
+            return null;
+        }
+
+        // This is only used for status message
+        let getComparatorSign = () =>
+        {
+            switch (comparator)
+            {
+                case "SMALLER":
+                    return "<";
+
+                case "SMALLER_EQUAL":
+                    return "<=";
+
+                case "EQUAL":
+                    return "==";
+
+                case "UNEQUAL":
+                    return "!=";
+
+                case "GREATER_EQUAL":
+                    return ">=";
+
+                case "GREATER":
+                    return ">";
+            }
+            return "???";
+        }
+
+        // updates the status
+        let setStatus = (result) =>
+        {
+            if (result == null)
+                node.status({});
+            else
+                node.status({ fill: "yellow", shape: "ring", text: nodeSettings.values.join(" " + getComparatorSign() + " ") + " => " + result });
+        }
+
+        node.on("close", function ()
+        {
+        });
+
+        if (config.save_state && config.resend_on_start && nodeSettings.lastResult != null)
+        {
+            setTimeout(() =>
+            {
+                node.send({ payload: nodeSettings.lastResult, comparator: comparator });
+            }, 10000);
+        }
+
+        setStatus(nodeSettings.lastResult);
+    }
+
+    RED.nodes.registerType("smart_compare", CompareNode);
+}

package/delay/delay.html

@@ -0,0 +1,192 @@
+<script type="text/javascript">
+    RED.nodes.registerType("smart_delay", {
+        category: "Smart Nodes",
+        paletteLabel: "delay",
+        color: "#6EE2D9",
+        defaults: {
+            name: { value: "" },
+            on_delay: { value: 10 },
+            on_delay_unit: { value: "s" },
+            off_delay: { value: 10 },
+            off_delay_unit: { value: "s" },
+            delay_only_on_change: { value: true },
+            save_state: { value: true },
+            resend_on_start: { value: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "timer.png",
+        label: function ()
+        {
+            return this.name || "Delay";
+        },
+        oneditprepare: function ()
+        {
+            $("#node-input-on_delay").spinner({
+                min: 0,
+                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-on_delay_unit").css("max-width", "10rem").typedInput({
+                types: [
+                    {
+                        default: "s",
+                        options: [
+                            { value: "ms", label: "Millisekunden" },
+                            { value: "s", label: "Sekunden" },
+                            { value: "min", label: "Minuten" },
+                            { value: "h", label: "Stunden" },
+                        ]
+                    }
+                ]
+            });
+
+            $("#node-input-off_delay").spinner({
+                min: 0,
+                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-off_delay_unit").css("max-width", "10rem").typedInput({
+                types: [
+                    {
+                        default: "s",
+                        options: [
+                            { value: "ms", label: "Millisekunden" },
+                            { value: "s", label: "Sekunden" },
+                            { value: "min", label: "Minuten" },
+                            { value: "h", label: "Stunden" },
+                        ]
+                    }
+                ]
+            });
+
+            $("#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_delay">
+    <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-on_delay"><i class="fa fa-clock-o"></i> Einschalt- verzögerung</label>
+        <input id="node-input-on_delay" value="0" />
+        <input id="node-input-on_delay_unit" />
+    </div>
+    <div class="form-row">
+        <label for="node-input-off_delay"><i class="fa fa-clock-o"></i> Ausschalt- verzögerung</label>
+        <input id="node-input-off_delay" value="0" />
+        <input id="node-input-off_delay_unit" />
+    </div>
+    <div class="form-row">
+        <input id="node-input-delay_only_on_change" type="checkbox" style="display: inline-block; width: auto; vertical-align: top;"/>
+        <span>Nur verzögern, wenn sich <code>msg.payload</code> verändert hat.</span>
+    </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_delay">
+    <p>Diese Node kann dazu verwendet werden ein Ein- oder Ausschaltsignal zu verzögern.</p>
+    <p>Die Zeit 0 bedeutet keine Verögerung.</p>
+    <p>
+        <b>Hinweis:</b> Smart Nodes verwenden Topics im Format <code>name#nummer</code>, damit können verschiedene Smart Nodes mit dem gleichen Topic angesteuert werden.<br/>
+        Diese Node verwendet nur den Teil <code>name</code>. <code>#</code> und <code>nummer</code> sind dabei optional.
+    </p>
+    <p>
+        Folgende topics werden akzeptiert:
+        <table>
+            <thead>
+                <tr>
+                    <th>Topic</th>
+                    <th>Beschreibung</th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td><code>set_delay_on</code></td>
+                    <td>Setzt die Einschaltverzögerung auf die in <code>msg.payload</code> angegebene Zeit.</td>
+                </tr>
+                <tr>
+                    <td><code>set_delay_off</code></td>
+                    <td>Setzt die Ausschaltverzögerung auf die in <code>msg.payload</code> angegebene Zeit.</td>
+                </tr>
+                <tr>
+                    <td><code>set_delays</code></td>
+                    <td>Setzt die Ein- und Ausschaltverzögerung auf die in <code>msg.payload</code> angegebene Zeit.</td>
+                </tr>
+            </tbody>
+        </table>
+    </p>
+    <p>
+        Beispiel: <code>msg = { "topic": "set_delay_on", "payload": 5000 }</code> oder <code>msg = { "topic": "set_delay_on", "payload": "5s" }</code><br/>
+        Diese Nachricht setzt die Einschaltverzögerung auf 5000 Millisekunden / 5 Sekunden.
+        Ist die Zeit auf 0 eingestellt, wird die Nachricht sofort weitergeleitet.<br/>
+        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>
+        Wenn die Checkbox <b>Nur verzögern, wenn sich <code>msg.payload</code> verändert hat.</b> aktiviert ist
+        und während dem Warten um ein Einschaltsignal weiterzuleiten ein Ausschaltsignal empfangen wird,
+        so wird das Senden des Einschaltsignals abgebrochen. Dies gilt auch für den umgekehrten Fall.<br/>
+        Ist die Checkbox nicht aktiviert, wird jede Nachricht verzögert, sofern nicht bereits eine Verzögerung für den gleichen <code>payload</code> aktiv ist.
+    </p>
+</script>

package/delay/delay.js

@@ -0,0 +1,175 @@
+module.exports = function (RED)
+{
+    function DelayNode(config)
+    {
+        const node = this;
+        RED.nodes.createNode(node, config);
+
+        const smartContext = require("../persistence.js")(RED);
+        const helper = require("../smart_helper.js");
+
+        var nodeSettings = {
+            on_delay_ms: helper.getTimeInMs(config.on_delay, config.on_delay_unit),
+            off_delay_ms: helper.getTimeInMs(config.off_delay, config.off_delay_unit),
+            lastMessage: null,
+        };
+
+        if (config.save_state)
+        {
+            // load old saved values
+            nodeSettings = Object.assign(nodeSettings, smartContext.get(node.id));
+
+            switch (nodeSettings.lastMessage?.payload)
+            {
+                case true:
+                    node.status({ fill: "yellow", shape: "ring", text: "Load last state: On" });
+                    break;
+
+                case false:
+                    node.status({ fill: "yellow", shape: "ring", text: "Load last state: Off" });
+                    break;
+
+                default:
+                    node.status({ fill: "yellow", shape: "ring", text: "No last state available" });
+                    break;
+            }
+        }
+        else
+        {
+            // delete old saved values
+            node.status({});
+            smartContext.del(node.id);
+        }
+
+        // dynamic config
+        let delay_only_on_change = config.delay_only_on_change;
+
+        // runtime values
+        let timeout = null;
+        let next_payload = null;
+
+        node.on("input", function (msg)
+        {
+            switch (msg.topic)
+            {
+                case "set_delay_on":
+                    nodeSettings.on_delay_ms = helper.getTimeInMsFromString(msg.payload);
+                    node.status({ fill: "yellow", shape: "ring", text: "New on delay: " + helper.formatMsToStatus(nodeSettings.on_delay_ms) });
+
+                    if (config.save_state)
+                        smartContext.set(node.id, nodeSettings);
+                    break;
+
+                case "set_delay_off":
+                    nodeSettings.off_delay_ms = helper.getTimeInMsFromString(msg.payload);
+                    node.status({ fill: "yellow", shape: "ring", text: "New off delay: " + helper.formatMsToStatus(nodeSettings.on_delay_ms) });
+
+                    if (config.save_state)
+                        smartContext.set(node.id, nodeSettings);
+                    break;
+
+                case "set_delays":
+                    nodeSettings.on_delay_ms = helper.getTimeInMsFromString(msg.payload);
+                    nodeSettings.off_delay_ms = nodeSettings.on_delay_ms;
+                    node.status({ fill: "yellow", shape: "ring", text: "New delays: " + helper.formatMsToStatus(nodeSettings.on_delay_ms) });
+
+                    if (config.save_state)
+                        smartContext.set(node.id, nodeSettings);
+                    break;
+
+                default:
+                    send(msg);
+                    break;
+            }
+        });
+
+        node.on("close", function ()
+        {
+            if (timeout != null)
+            {
+                clearTimeout(timeout);
+                timeout = null;
+            }
+        });
+
+        let send = (msg) =>
+        {
+            let delayMs = 0;
+
+            if (msg.payload)
+                delayMs = nodeSettings.on_delay_ms;
+            else
+                delayMs = nodeSettings.off_delay_ms;
+
+            if (delay_only_on_change)
+            {
+                if (timeout)
+                {
+                    // current delay runs already for the same payload, so don't start a new one.
+                    if (next_payload == msg.payload)
+                        return;
+
+                    // payload changed back to last value => stop current delay
+                    if (nodeSettings.lastMessage?.payload == msg.payload)
+                    {
+                        node.status({});
+                        clearTimeout(timeout);
+                        timeout = null;
+
+                        return;
+                    }
+                }
+                // payload hasn't changed
+                else if (nodeSettings.lastMessage?.payload == msg.payload)
+                {
+                    return;
+                }
+            }
+
+            // stop timeout if any
+            if (timeout != null)
+            {
+                node.status({});
+                clearTimeout(timeout);
+                timeout = null;
+            }
+
+            // No delay if 0 or smaller
+            if (delayMs <= 0)
+            {
+                node.status({});
+                nodeSettings.lastMessage = msg
+
+                if (config.save_state)
+                    smartContext.set(node.id, nodeSettings);
+
+                node.send(msg);
+                return;
+            }
+
+            // start new timeout
+            node.status({ fill: "yellow", shape: "ring", text: "Forward msg.topic = '" + (msg.topic ?? "null") + "' msg.payload = '" + (msg.payload ?? "null") + "' in " + helper.formatMsToStatus(delayMs, "at") });
+            timeout = setTimeout(() =>
+            {
+                node.status({});
+                nodeSettings.lastMessage = msg
+
+                if (config.save_state)
+                    smartContext.set(node.id, nodeSettings);
+
+                node.send(msg);
+            }, delayMs);
+        }
+
+        if (config.save_state && config.resend_on_start && nodeSettings.lastMessage != null)
+        {
+            setTimeout(() =>
+            {
+                node.status({});
+                node.send(nodeSettings.lastMessage);
+            }, 10000);
+        }
+    }
+
+    RED.nodes.registerType("smart_delay", DelayNode);
+}