@bldgblocks/node-red-contrib-control 0.1.4

package/nodes/tick-tock-block.js

@@ -0,0 +1,110 @@
+module.exports = function(RED) {
+    function TickTockBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            period: parseFloat(config.period),
+            state: true
+        };
+
+        // Validate initial config
+        if (isNaN(node.runtime.period) || node.runtime.period <= 0 || !isFinite(node.runtime.period)) {
+            node.runtime.period = 10;
+            node.status({ fill: "red", shape: "ring", text: "invalid period" });
+        }
+
+        let intervalId = null;
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Guard against invalid message
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Handle context updates
+            if (msg.hasOwnProperty("context")) {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+                if (typeof msg.context !== "string") {
+                    node.status({ fill: "red", shape: "ring", text: "invalid context" });
+                    if (done) done();
+                    return;
+                }
+                switch (msg.context) {
+                    case "period":
+                        const value = parseFloat(msg.payload);
+                        if (isNaN(value) || value <= 0 || !isFinite(value)) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid period" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.period = value;
+                        node.status({ fill: "green", shape: "dot", text: `period: ${node.runtime.period.toFixed(2)}` });
+                        if (intervalId) {
+                            clearInterval(intervalId);
+                            node.runtime.state = true;
+                            const halfPeriodMs = (node.runtime.period * 1000) / 2;
+                            send({ payload: node.runtime.state });
+                            node.status({ fill: "blue", shape: "dot", text: `out: ${node.runtime.state}` });
+                            intervalId = setInterval(() => {
+                                node.runtime.state = !node.runtime.state;
+                                send({ payload: node.runtime.state });
+                                node.status({ fill: "blue", shape: "dot", text: `out: ${node.runtime.state}` });
+                            }, halfPeriodMs);
+                        }
+                        break;
+                    case "command":
+                        if (typeof msg.payload !== "string" || !["start", "stop"].includes(msg.payload)) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid command" });
+                            if (done) done();
+                            return;
+                        }
+                        if (msg.payload === "start" && !intervalId) {
+                            node.runtime.state = true;
+                            const halfPeriodMs = (node.runtime.period * 1000) / 2;
+                            send({ payload: node.runtime.state });
+                            node.status({ fill: "blue", shape: "dot", text: `out: ${node.runtime.state}` });
+                            intervalId = setInterval(() => {
+                                node.runtime.state = !node.runtime.state;
+                                send({ payload: node.runtime.state });
+                                node.status({ fill: "blue", shape: "dot", text: `out: ${node.runtime.state}` });
+                            }, halfPeriodMs);
+                            node.status({ fill: "green", shape: "dot", text: `started, period: ${node.runtime.period.toFixed(2)}` });
+                        } else if (msg.payload === "stop" && intervalId) {
+                            clearInterval(intervalId);
+                            intervalId = null;
+                            node.status({ fill: "yellow", shape: "dot", text: "stopped" });
+                        }
+                        break;
+                    default:
+                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        if (done) done("Unknown context");
+                        return;
+                }
+                if (done) done();
+                return;
+            }
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            if (intervalId) {
+                clearInterval(intervalId);
+                intervalId = null;
+            }
+            done();
+        });
+    }
+
+    RED.nodes.registerType("tick-tock-block", TickTockBlockNode);
+};

package/nodes/time-sequence-block.html

@@ -0,0 +1,67 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="time-sequence-block">
+    <div class="form-row">
+        <label for="node-input-name" title="Display name shown on the canvas"><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-delay" title="Delay between sequence stages (milliseconds, non-negative number)"><i class="fa fa-clock-o"></i> Delay (ms)</label>
+        <input type="number" id="node-input-delay" placeholder="5000" min="0" step="any">
+    </div>
+</script>
+
+<!-- JavaScript Section -->
+<script type="text/javascript">
+    RED.nodes.registerType("time-sequence-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            delay: { value: 5000, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) >= 0 && isFinite(parseFloat(v)); } }
+        },
+        inputs: 1,
+        outputs: 4,
+        inputLabels: ["input"],
+        outputLabels: ["stage1", "stage2", "stage3", "stage4"],
+        icon: "font-awesome/fa-hourglass-half",
+        paletteLabel: "time sequence",
+        label: function() {
+            return this.name || "time sequence";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="time-sequence-block">
+Triggers a sequence of outputs with configurable delays, ignoring inputs during active sequence.
+
+### Inputs
+: context (string) : Configures settings (`"delay"`, `"reset"`). Unmatched values trigger error.
+: payload (any | number | boolean) : Value to pass through outputs, number for delay, boolean (true) for reset.
+
+### Outputs
+: stage1 (any) : The input message with `msg.stage = 1` (immediate).
+: stage2 (any) : The input message with `msg.stage = 2` (after delay).
+: stage3 (any) : The input message with `msg.stage = 3` (after 2x delay).
+: stage4 (any) : The input message with `msg.stage = 4` (after 2x delay).
+: Other properties (e.g., `msg.topic`) from the input message are preserved.
+
+### Details
+Triggers a sequence of four outputs (`stage1`, `stage2`, `stage3`, `reset`) with the input message, adding `msg.stage` 
+(1 to 4). Outputs are delayed by `delay` (ms), configurable via editor or `msg.context = "delay"` with numeric `msg.payload`. 
+
+Resets sequence via `msg.context = "reset"` with `msg.payload = true`, outputting `{ payload false }` to all ports. 
+
+Ignores inputs during active sequence.
+
+### Status
+- Green (dot): Configuration update
+- Blue (dot): State changed
+- Blue (ring): State unchanged
+- Red (ring): Error
+- Yellow (ring): Warning
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/time-sequence-block.js

@@ -0,0 +1,144 @@
+module.exports = function(RED) {
+    function TimeSequenceBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            delay: parseFloat(config.delay),
+            stage: 0
+        };
+
+        // Validate initial config
+        if (isNaN(node.runtime.delay) || node.runtime.delay < 0 || !isFinite(node.runtime.delay)) {
+            node.runtime.delay = 5000;
+            node.status({ fill: "red", shape: "ring", text: "invalid delay" });
+        }
+
+        let timer = null;
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Guard against invalid message
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Handle context updates
+            if (msg.hasOwnProperty("context")) {
+                if (typeof msg.context !== "string") {
+                    node.status({ fill: "red", shape: "ring", text: "invalid context" });
+                    if (done) done();
+                    return;
+                }
+                switch (msg.context) {
+                    case "delay":
+                        if (!msg.hasOwnProperty("payload")) {
+                            node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+                            if (done) done();
+                            return;
+                        }
+                        const delayValue = parseFloat(msg.payload);
+                        if (isNaN(delayValue) || delayValue < 0 || !isFinite(delayValue)) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid delay" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.delay = delayValue;
+                        node.status({
+                            fill: "green",
+                            shape: "dot",
+                            text: `delay: ${node.runtime.delay.toFixed(2)} ms`
+                        });
+                        if (done) done();
+                        return;
+                    case "reset":
+                        if (!msg.hasOwnProperty("payload")) {
+                            node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+                            if (done) done();
+                            return;
+                        }
+                        if (typeof msg.payload !== "boolean" || !msg.payload) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                            if (done) done();
+                            return;
+                        }
+                        if (timer) {
+                            clearTimeout(timer);
+                            timer = null;
+                        }
+                        node.runtime.stage = 0;
+                        const resetMsg = { payload: false };
+                        node.status({
+                            fill: "green",
+                            shape: "dot",
+                            text: "state reset"
+                        });
+                        send([resetMsg, resetMsg, resetMsg, resetMsg]);
+                        if (done) done();
+                        return;
+                    default:
+                        break;
+                }
+            }
+
+            // Validate input
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing input" });
+                if (done) done();
+                return;
+            }
+
+            // Process input
+            if (node.runtime.stage !== 0) {
+                node.status({ fill: "yellow", shape: "ring", text: "sequence already running" });
+                if (done) done();
+                return;
+            }
+
+            // Start new sequence
+            node.runtime.stage = 1;
+            const cloneMsg = RED.util.cloneMessage(msg);
+
+            // Output sequence
+            const sendNextOutput = () => {
+                if (node.runtime.stage === 0) return;
+                const stageLabels = ["stage 1", "stage 2", "stage 3", "stage 4"];
+                const outputs = [null, null, null, null];
+                cloneMsg.stage = node.runtime.stage;
+                outputs[node.runtime.stage - 1] = cloneMsg;
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: `stage: ${stageLabels[node.runtime.stage - 1]}, in: ${JSON.stringify(cloneMsg.payload).slice(0, 20)}`
+                });
+                send(outputs);
+
+                node.runtime.stage++;
+                if (node.runtime.stage <= 4) {
+                    timer = setTimeout(sendNextOutput, node.runtime.delay);
+                } else {
+                    node.runtime.stage = 0;
+                    timer = null;
+                }
+            };
+
+            // Start sequence
+            sendNextOutput();
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            if (timer) clearTimeout(timer);
+            timer = null;
+            done();
+        });
+    }
+
+    RED.nodes.registerType("time-sequence-block", TimeSequenceBlockNode);
+};

package/nodes/triangle-wave-block.html

@@ -0,0 +1,86 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="triangle-wave-block">
+    <div class="form-row">
+        <label for="node-input-name" title="Display name shown on the canvas"><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-lowerLimit" title="Minimum output value"><i class="fa fa-arrow-down"></i> Lower Limit</label>
+        <input type="number" id="node-input-lowerLimit" placeholder="0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-upperLimit" title="Maximum output value (≥ lowerLimit)"><i class="fa fa-arrow-up"></i> Upper Limit</label>
+        <input type="number" id="node-input-upperLimit" placeholder="100" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-period" title="Wave period (positive number, e.g., 10)"><i class="fa fa-clock-o"></i> Period</label>
+        <input type="number" id="node-input-period" placeholder="10" min="0.001" step="any">
+        <select id="node-input-periodUnits">
+            <option value="milliseconds">Milliseconds</option>
+            <option value="seconds">Seconds</option>
+            <option value="minutes">Minutes</option>
+        </select>
+    </div>
+</script>
+
+<!-- JavaScript Section -->
+<script type="text/javascript">
+    RED.nodes.registerType("triangle-wave-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            lowerLimit: { value: 0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
+            upperLimit: { value: 100, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
+            period: { value: 10, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) > 0 && isFinite(parseFloat(v)); } },
+            periodUnits: { value: "seconds" }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-wave-square",
+        paletteLabel: "triangle wave",
+        label: function() {
+            return this.name || "triangle wave";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="triangle-wave-block">
+Generates a triangle wave output scaled to a configurable range.
+
+### Inputs
+: context (string) : Configures settings (`"lowerLimit"`, `"upperLimit"`, `"period"`). Unmatched values trigger error.
+: payload (number) : Config value for lowerLimit, upperLimit, or period.
+: units (string, optional) : Units for period (`"milliseconds"`, `"seconds"`, `"minutes"`).
+: Any input triggers wave output.
+
+### Outputs
+: payload (number) : Triangle wave value scaled between lowerLimit and upperLimit.
+
+### Properties
+: lowerLimit (number) : Minimum output value.
+: upperLimit (number) : Maximum output value (≥ lowerLimit).
+: period (number) : Wave period (positive, in periodUnits).
+: periodUnits (string) : Units for period (`"milliseconds"`, `"seconds"`, `"minutes"`).
+
+### Details
+Generates a triangle wave output, linearly rising from `lowerLimit` to `upperLimit` and falling back over `period`, triggered by any input. 
+
+Tracks phase (0 to 1) for continuity. 
+
+Ensures `upperLimit ≥ lowerLimit` by adjusting limits. Outputs `msg.payload number` with wave value; if `period ≤ 0`, outputs `lowerLimit`.
+
+### Status
+- Green (dot): Configuration update
+- Blue (dot): State changed
+- Blue (ring): State unchanged
+- Red (ring): Error
+- Yellow (ring): Warning
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/triangle-wave-block.js

@@ -0,0 +1,154 @@
+module.exports = function(RED) {
+    function TriangleWaveBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name || "",
+            lowerLimit: parseFloat(config.lowerLimit),
+            upperLimit: parseFloat(config.upperLimit),
+            period: (parseFloat(config.period)) * (config.periodUnits === "minutes" ? 60000 : config.periodUnits === "seconds" ? 1000 : 1),
+            periodUnits: config.periodUnits,
+            lastExecution: Date.now(),
+            phase: 0
+        };
+
+        // Validate initial config
+        if (isNaN(node.runtime.lowerLimit) || isNaN(node.runtime.upperLimit) || !isFinite(node.runtime.lowerLimit) || !isFinite(node.runtime.upperLimit)) {
+            node.runtime.lowerLimit = 0;
+            node.runtime.upperLimit = 100;
+            node.status({ fill: "red", shape: "ring", text: "invalid limits" });
+        } else if (node.runtime.lowerLimit > node.runtime.upperLimit) {
+            node.runtime.upperLimit = node.runtime.lowerLimit;
+            node.status({ fill: "red", shape: "ring", text: "invalid limits" });
+        }
+        if (isNaN(node.runtime.period) || node.runtime.period <= 0 || !isFinite(node.runtime.period)) {
+            node.runtime.period = 10000;
+            node.runtime.periodUnits = "milliseconds";
+            node.status({ fill: "red", shape: "ring", text: "invalid period" });
+        }
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Guard against invalid message
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Handle context updates
+            if (msg.hasOwnProperty("context")) {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+                if (typeof msg.context !== "string") {
+                    node.status({ fill: "red", shape: "ring", text: "invalid context" });
+                    if (done) done();
+                    return;
+                }
+                let value = parseFloat(msg.payload);
+                if (isNaN(value) || !isFinite(value)) {
+                    node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+                switch (msg.context) {
+                    case "lowerLimit":
+                        node.runtime.lowerLimit = value;
+                        if (node.runtime.lowerLimit > node.runtime.upperLimit) {
+                            node.runtime.upperLimit = node.runtime.lowerLimit;
+                            node.status({
+                                fill: "green",
+                                shape: "dot",
+                                text: `lower: ${node.runtime.lowerLimit.toFixed(2)}, upper adjusted to ${node.runtime.upperLimit.toFixed(2)}`
+                            });
+                        } else {
+                            node.status({
+                                fill: "green",
+                                shape: "dot",
+                                text: `lower: ${node.runtime.lowerLimit.toFixed(2)}`
+                            });
+                        }
+                        break;
+                    case "upperLimit":
+                        node.runtime.upperLimit = value;
+                        if (node.runtime.upperLimit < node.runtime.lowerLimit) {
+                            node.runtime.lowerLimit = node.runtime.upperLimit;
+                            node.status({
+                                fill: "green",
+                                shape: "dot",
+                                text: `upper: ${node.runtime.upperLimit.toFixed(2)}, lower adjusted to ${node.runtime.lowerLimit.toFixed(2)}`
+                            });
+                        } else {
+                            node.status({
+                                fill: "green",
+                                shape: "dot",
+                                text: `upper: ${node.runtime.upperLimit.toFixed(2)}`
+                            });
+                        }
+                        break;
+                    case "period":
+                        const multiplier = msg.units === "minutes" ? 60000 : msg.units === "seconds" ? 1000 : 1;
+                        value *= multiplier;
+                        if (value <= 0) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid period" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.period = value;
+                        node.runtime.periodUnits = msg.units || "milliseconds";
+                        node.status({
+                            fill: "green",
+                            shape: "dot",
+                            text: `period: ${node.runtime.period.toFixed(2)} ms`
+                        });
+                        break;
+                    default:
+                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        if (done) done("Unknown context");
+                        return;
+                }
+                if (done) done();
+                return;
+            }
+
+            // Calculate time difference
+            const now = Date.now();
+            const deltaTime = (now - node.runtime.lastExecution) / 1000; // Seconds
+            node.runtime.lastExecution = now;
+
+            // Return lowerLimit if period is invalid
+            if (node.runtime.period <= 0) {
+                node.status({ fill: "blue", shape: "dot", text: `out: ${node.runtime.lowerLimit.toFixed(2)}, phase: ${node.runtime.phase.toFixed(2)}` });
+                send({ payload: node.runtime.lowerLimit });
+                if (done) done();
+                return;
+            }
+
+            // Update phase
+            node.runtime.phase = (node.runtime.phase + deltaTime / (node.runtime.period / 1000)) % 1;
+
+            // Triangle wave calculation
+            const triangleValue = node.runtime.phase < 0.5 ? 2 * node.runtime.phase : 2 * (1 - node.runtime.phase);
+            const amplitude = (node.runtime.upperLimit - node.runtime.lowerLimit) / 2;
+            const value = node.runtime.lowerLimit + amplitude * triangleValue;
+
+            // Output new message
+            node.status({ fill: "blue", shape: "dot", text: `out: ${value.toFixed(2)}, phase: ${node.runtime.phase.toFixed(2)}` });
+            send({ payload: value });
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("triangle-wave-block", TriangleWaveBlockNode);
+};