@bldgblocks/node-red-contrib-control 0.1.4

package/nodes/load-sequence-block.html

@@ -0,0 +1,134 @@
+<!-- UI Template Section: Defines the edit dialog -->
+<script type="text/html" data-template-name="load-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-enable" title="Enable sequencing (boolean)"><i class="fa fa-power-off"></i> Enable</label>
+        <input type="checkbox" id="node-input-enable" style="width: auto; vertical-align: middle;">
+    </div>
+    <div class="form-row">
+        <label for="node-input-hysteresis" title="Hysteresis for threshold switching (non-negative number)"><i class="fa fa-exchange"></i> Hysteresis</label>
+        <input type="number" id="node-input-hysteresis" placeholder="0.5" min="0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-threshold1" title="Threshold for load 1 (number)"><i class="fa fa-arrow-up"></i> Threshold 1</label>
+        <input type="number" id="node-input-threshold1" placeholder="10.0" min="0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-threshold2" title="Threshold for load 2 (number, > threshold1)"><i class="fa fa-arrow-up"></i> Threshold 2</label>
+        <input type="number" id="node-input-threshold2" placeholder="20.0" min="0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-threshold3" title="Threshold for load 3 (number, > threshold2)"><i class="fa fa-arrow-up"></i> Threshold 3</label>
+        <input type="number" id="node-input-threshold3" placeholder="30.0" min="0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-threshold4" title="Threshold for load 4 (number, > threshold3)"><i class="fa fa-arrow-up"></i> Threshold 4</label>
+        <input type="number" id="node-input-threshold4" placeholder="40.0" min="0" step="any">
+    </div>
+    <div class="form-row">
+        <label for="node-input-feedback1" title="Feedback for load 1 (boolean)"><i class="fa fa-refresh"></i> Feedback 1</label>
+        <input type="checkbox" id="node-input-feedback1" style="width: auto; vertical-align: middle;">
+    </div>
+    <div class="form-row">
+        <label for="node-input-feedback2" title="Feedback for load 2 (boolean)"><i class="fa fa-refresh"></i> Feedback 2</label>
+        <input type="checkbox" id="node-input-feedback2" style="width: auto; vertical-align: middle;">
+    </div>
+    <div class="form-row">
+        <label for="node-input-feedback3" title="Feedback for load 3 (boolean)"><i class="fa fa-refresh"></i> Feedback 3</label>
+        <input type="checkbox" id="node-input-feedback3" style="width: auto; vertical-align: middle;">
+    </div>
+    <div class="form-row">
+        <label for="node-input-feedback4" title="Feedback for load 4 (boolean)"><i class="fa fa-refresh"></i> Feedback 4</label>
+        <input type="checkbox" id="node-input-feedback4" style="width: auto; vertical-align: middle;">
+    </div>
+</script>
+
+<!-- JavaScript Section: Registers the node and handles editor logic -->
+<script type="text/javascript">
+    RED.nodes.registerType("load-sequence-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            enable: { value: true },
+            hysteresis: { value: 0.5, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) >= 0; } },
+            threshold1: { value: 10.0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) >= 0; } },
+            threshold2: { value: 20.0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) >= 0; } },
+            threshold3: { value: 30.0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) >= 0; } },
+            threshold4: { value: 40.0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) >= 0; } },
+            feedback1: { value: true },
+            feedback2: { value: true },
+            feedback3: { value: true },
+            feedback4: { value: true }
+        },
+        inputs: 1,
+        outputs: 4,
+        inputLabels: ["input"],
+        outputLabels: ["load1", "load2", "load3", "load4"],
+        icon: "font-awesome/fa-list-ol",
+        paletteLabel: "load sequence",
+        label: function() {
+            return this.name || "load sequence";
+        },
+        oneditprepare: function() {
+            const node = this;
+            $("#node-input-enable").prop("checked", node.enable !== false);
+            $("#node-input-feedback1").prop("checked", node.feedback1 !== false);
+            $("#node-input-feedback2").prop("checked", node.feedback2 !== false);
+            $("#node-input-feedback3").prop("checked", node.feedback3 !== false);
+            $("#node-input-feedback4").prop("checked", node.feedback4 !== false);
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="load-sequence-block">
+Sequences four boolean outputs based on input thresholds with feedback and hysteresis.
+
+### Inputs
+: context (string) : Configures settings (`"enable"`, `"hysteresis"`, `"threshold1-4"`, `"feedback1-4"`). Unmatched values trigger error.
+: payload (number | string | boolean) : Number for input, `"kill"` to shut down, boolean for `enable`/`feedback1-4`, number for `hysteresis`/`threshold1-4`.
+
+### Outputs
+: load1 (boolean) : `true` when active, else `false` or `null`.
+: load2 (boolean) : `true` when active, else `false` or `null`.
+: load3 (boolean) : `true` when active, else `false` or `null`.
+: load4 (boolean) : `true` when active, else `false` or `null`.
+
+### Properties
+: name (string) : Display name in editor.
+: enable (boolean) : Enables sequencing.
+: hysteresis (number) : Hysteresis for threshold switching (≥ 0).
+: threshold1 (number) : Threshold for load 1 (≥ 0).
+: threshold2 (number) : Threshold for load 2 (≥ 0, > threshold1).
+: threshold3 (number) : Threshold for load 3 (≥ 0, > threshold2).
+: threshold4 (number) : Threshold for load 4 (≥ 0, > threshold3).
+: feedback1 (boolean) : Feedback for load 1.
+: feedback2 (boolean) : Feedback for load 2.
+: feedback3 (boolean) : Feedback for load 3.
+: feedback4 (boolean) : Feedback for load 4.
+
+### Details
+Sequences four boolean outputs (`load1` to `load4`) based on `msg.payload` (number) crossing `threshold1` to `threshold4` with `hysteresis` 
+and `feedback1-4`. Outputs turn on when input exceeds a threshold and prior feedback is `true` (e.g., `load2` requires `feedback1`). 
+
+Outputs turn off when input falls below `thresholdX - hysteresis` and higher-stage feedback allows. Configurable via editor or `msg.context`. 
+
+`msg.payload = "kill"` shuts down all outputs. `enable = false` disables outputs sequentially (highest to lowest). 
+
+Tracks active stages (`dOn`). Outputs new messages only when a state changes, sending a single non-null message for the lowest stage that changed. 
+
+### 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/load-sequence-block.js

@@ -0,0 +1,272 @@
+module.exports = function(RED) {
+    function LoadSequenceBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name || "",
+            enable: config.enable,
+            hysteresis: parseFloat(config.hysteresis),
+            threshold1: parseFloat(config.threshold1),
+            threshold2: parseFloat(config.threshold2),
+            threshold3: parseFloat(config.threshold3),
+            threshold4: parseFloat(config.threshold4),
+            feedback1: config.feedback1,
+            feedback2: config.feedback2,
+            feedback3: config.feedback3,
+            feedback4: config.feedback4,
+            out1: false,
+            out2: false,
+            out3: false,
+            out4: false,
+            dOn: 0,
+            lastInput: 0,
+            lastOutputs: [false, false, false, false]
+        };
+
+        // Validate initial config
+        if (isNaN(node.runtime.hysteresis) || node.runtime.hysteresis < 0) {
+            node.runtime.hysteresis = 0.5;
+            node.status({ fill: "red", shape: "ring", text: "invalid hysteresis" });
+        }
+        if (isNaN(node.runtime.threshold1) || isNaN(node.runtime.threshold2) || isNaN(node.runtime.threshold3) || isNaN(node.runtime.threshold4) ||
+            node.runtime.threshold1 < 0 || node.runtime.threshold2 < 0 || node.runtime.threshold3 < 0 || node.runtime.threshold4 < 0 ||
+            node.runtime.threshold1 >= node.runtime.threshold2 || node.runtime.threshold2 >= node.runtime.threshold3 || node.runtime.threshold3 >= node.runtime.threshold4) {
+            node.runtime.threshold1 = 10.0;
+            node.runtime.threshold2 = 20.0;
+            node.runtime.threshold3 = 30.0;
+            node.runtime.threshold4 = 40.0;
+            node.status({ fill: "red", shape: "ring", text: "invalid threshold order" });
+        }
+
+        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 configuration 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;
+                }
+                switch (msg.context) {
+                    case "enable":
+                        if (typeof msg.payload !== "boolean") {
+                            node.status({ fill: "red", shape: "ring", text: "invalid enable" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.enable = msg.payload;
+                        node.status({ fill: "green", shape: "dot", text: `enable: ${node.runtime.enable}` });
+                        break;
+                    case "hysteresis":
+                        const hystValue = parseFloat(msg.payload);
+                        if (isNaN(hystValue) || hystValue < 0) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid hysteresis" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.hysteresis = hystValue;
+                        node.status({ fill: "green", shape: "dot", text: `hysteresis: ${node.runtime.hysteresis}` });
+                        break;
+                    case "threshold1":
+                    case "threshold2":
+                    case "threshold3":
+                    case "threshold4":
+                        const threshValue = parseFloat(msg.payload);
+                        if (isNaN(threshValue) || threshValue < 0) {
+                            node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
+                            if (done) done();
+                            return;
+                        }
+                        const prevThresholds = [node.runtime.threshold1, node.runtime.threshold2, node.runtime.threshold3, node.runtime.threshold4];
+                        const index = parseInt(msg.context.replace("threshold", "")) - 1;
+                        const newThresholds = [...prevThresholds];
+                        newThresholds[index] = threshValue;
+                        if (newThresholds[0] >= newThresholds[1] || newThresholds[1] >= newThresholds[2] || newThresholds[2] >= newThresholds[3]) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid threshold order" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime[`threshold${index + 1}`] = threshValue;
+                        node.status({ fill: "green", shape: "dot", text: `${msg.context}: ${threshValue}` });
+                        break;
+                    case "feedback1":
+                    case "feedback2":
+                    case "feedback3":
+                    case "feedback4":
+                        if (typeof msg.payload !== "boolean") {
+                            node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime[msg.context] = msg.payload;
+                        node.status({ fill: "green", shape: "dot", text: `${msg.context}: ${msg.payload}` });
+                        break;
+                    default:
+                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        if (done) done("Unknown context");
+                        return;
+                }
+            }
+
+            // Handle input
+            let inputValue;
+            if (msg.hasOwnProperty("context")) {
+                inputValue = node.runtime.lastInput;
+            } else {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    if (done) done();
+                    return;
+                }
+                if (msg.payload === "kill") {
+                    inputValue = node.runtime.lastInput;
+                } else {
+                    inputValue = parseFloat(msg.payload);
+                    if (isNaN(inputValue)) {
+                        node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+                        if (done) done();
+                        return;
+                    }
+                    node.runtime.lastInput = inputValue;
+                }
+            }
+
+            // Kill switch
+            if (msg.payload === "kill") {
+                node.runtime.out1 = node.runtime.out2 = node.runtime.out3 = node.runtime.out4 = false;
+                node.runtime.dOn = 0;
+                node.runtime.lastOutputs = [false, false, false, false];
+                node.status({ fill: "red", shape: "dot", text: "kill: all off" });
+                send([{ payload: false }, { payload: false }, { payload: false }, { payload: false }]);
+                if (done) done();
+                return;
+            }
+
+            // Validate thresholds
+            if (node.runtime.threshold1 >= node.runtime.threshold2 || node.runtime.threshold2 >= node.runtime.threshold3 || node.runtime.threshold3 >= node.runtime.threshold4) {
+                node.status({ fill: "red", shape: "ring", text: "invalid threshold order" });
+                if (done) done();
+                return;
+            }
+
+            // Process logic
+            let newMsg = [null, null, null, null];
+            let numStagesOn = 0;
+
+            if (!node.runtime.enable) {
+                if (node.runtime.out4) {
+                    node.runtime.out4 = false;
+                    newMsg[3] = { payload: false };
+                } else if (node.runtime.out3) {
+                    node.runtime.out3 = false;
+                    newMsg[2] = { payload: false };
+                } else if (node.runtime.out2) {
+                    node.runtime.out2 = false;
+                    newMsg[1] = { payload: false };
+                } else if (node.runtime.out1) {
+                    node.runtime.out1 = false;
+                    newMsg[0] = { payload: false };
+                }
+                numStagesOn = 0;
+            } else {
+                let newOut1 = node.runtime.out1;
+                let newOut2 = node.runtime.out2;
+                let newOut3 = node.runtime.out3;
+                let newOut4 = node.runtime.out4;
+
+                // Output 1
+                if (node.runtime.out1) {
+                    if (inputValue < (node.runtime.threshold1 - node.runtime.hysteresis) && (node.runtime.feedback1 && !node.runtime.out2)) {
+                        newOut1 = false;
+                    }
+                } else if (inputValue >= node.runtime.threshold1) {
+                    newOut1 = true;
+                }
+
+                // Output 2
+                if (node.runtime.out2) {
+                    if (inputValue < (node.runtime.threshold2 - node.runtime.hysteresis) && (node.runtime.feedback2 && !node.runtime.out3)) {
+                        newOut2 = false;
+                    }
+                } else if (inputValue >= node.runtime.threshold2 && node.runtime.feedback1) {
+                    newOut2 = true;
+                }
+
+                // Output 3
+                if (node.runtime.out3) {
+                    if (inputValue < (node.runtime.threshold3 - node.runtime.hysteresis) && (node.runtime.feedback3 && !node.runtime.out4)) {
+                        newOut3 = false;
+                    }
+                } else if (inputValue >= node.runtime.threshold3 && node.runtime.feedback2) {
+                    newOut3 = true;
+                }
+
+                // Output 4
+                if (node.runtime.out4) {
+                    if (inputValue < (node.runtime.threshold4 - node.runtime.hysteresis) && node.runtime.feedback4) {
+                        newOut4 = false;
+                    }
+                } else if (inputValue >= node.runtime.threshold4 && node.runtime.feedback3) {
+                    newOut4 = true;
+                }
+
+                // Prioritize lowest stage change
+                if (newOut1 !== node.runtime.out1) {
+                    node.runtime.out1 = newOut1;
+                    newMsg = [{ payload: node.runtime.out1 }, null, null, null];
+                } else if (newOut2 !== node.runtime.out2) {
+                    node.runtime.out2 = newOut2;
+                    newMsg = [null, { payload: node.runtime.out2 }, null, null];
+                } else if (newOut3 !== node.runtime.out3) {
+                    node.runtime.out3 = newOut3;
+                    newMsg = [null, null, { payload: node.runtime.out3 }, null];
+                } else if (newOut4 !== node.runtime.out4) {
+                    node.runtime.out4 = newOut4;
+                    newMsg = [null, null, null, { payload: node.runtime.out4 }];
+                }
+
+                numStagesOn = (node.runtime.out1 ? 1 : 0) + (node.runtime.out2 ? 1 : 0) + (node.runtime.out3 ? 1 : 0) + (node.runtime.out4 ? 1 : 0);
+            }
+
+            // Update state
+            node.runtime.dOn = numStagesOn;
+
+            // Check if outputs changed
+            const outputsChanged = newMsg.some((msg, i) => msg !== null && msg.payload !== node.runtime.lastOutputs[i]);
+            node.runtime.lastOutputs = [node.runtime.out1, node.runtime.out2, node.runtime.out3, node.runtime.out4];
+
+            if (outputsChanged) {
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: `in: ${inputValue.toFixed(2)}, out: [${node.runtime.out1}, ${node.runtime.out2}, ${node.runtime.out3}, ${node.runtime.out4}]`
+                });
+                send(newMsg);
+            } else {
+                node.status({
+                    fill: "blue",
+                    shape: "ring",
+                    text: `in: ${inputValue.toFixed(2)}, out: [${node.runtime.out1}, ${node.runtime.out2}, ${node.runtime.out3}, ${node.runtime.out4}]`
+                });
+            }
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("load-sequence-block", LoadSequenceBlockNode);
+};

package/nodes/max-block.html

@@ -0,0 +1,76 @@
+<!-- UI Template Section: Defines the edit dialog -->
+<script type="text/html" data-template-name="max-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-max" title="Maximum value for capping the input number"><i class="fa fa-arrow-up"></i> Max</label>
+        <input type="text" id="node-input-max" placeholder="50" min="0" step="any">
+        <input type="hidden" id="node-input-maxType">
+    </div>
+</script>
+
+<!-- JavaScript Section: Registers the node and handles editor logic -->
+<script type="text/javascript">
+    RED.nodes.registerType("max-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            max: { value: 50, required: true },
+            maxType: { value: "num" },
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-arrow-circle-up",
+        paletteLabel: "max",
+        label: function() {
+            return this.name || "max";
+        },
+        oneditprepare: function() {
+            const node = this;
+            
+            // Initialize typed inputs
+            $("#node-input-max").typedInput({
+                default: "num",
+                types: ["num", "msg", "flow", "global"],
+                typeField: "#node-input-maxType"
+            }).typedInput("type", node.maxType || "num").typedInput("value", node.max);
+
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="max-block">
+Caps a numeric input at a configurable maximum value.
+
+### Inputs
+: context (string) : Configures maximum value (`"max"`, `"setpoint"`). Unmatched values trigger warning.
+: payload (number) : Input number to cap or new maximum value with `msg.context`.
+
+### Outputs
+: payload (number) : Input number capped at the maximum value.
+
+### Properties
+: max (number) : Maximum value for capping.
+
+### Details
+Caps `msg.payload` (a number) to the maximum value, forwarding the input message with updated `msg.payload`.
+
+Configurable via editor (`name`, `max`) or `msg.context` (`"max"`, `"setpoint"`) with numeric `msg.payload`.
+
+### 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/max-block.js

@@ -0,0 +1,103 @@
+module.exports = function(RED) {
+    function MaxBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name
+        };
+
+        // Store last output value for status
+        let lastOutput = null;
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Evaluate typed-inputs
+            try {
+                node.runtime.max = RED.util.evaluateNodeProperty(
+                    config.max, config.maxType, node, msg
+                );
+                
+                // Validate values
+                if (isNaN(node.runtime.max)) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid evaluated values" });
+                    if (done) done();
+                    return;
+                }
+            } catch(err) {
+                node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });
+                if (done) done(err);
+                return;
+            }
+
+            // 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 max" });
+                    if (done) done();
+                    return;
+                }
+                if (msg.context === "max" || msg.context === "setpoint") {
+                    const maxValue = parseFloat(msg.payload);
+                    if (!isNaN(maxValue) && maxValue >= 0) {
+                        node.runtime.max = maxValue;
+                        node.status({ fill: "green", shape: "dot", text: `max: ${maxValue}`
+                        });
+                    } else {
+                        node.status({ fill: "red", shape: "ring", text: "invalid max" });
+                    }
+                    if (done) done();
+                    return;
+                } else {
+                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    if (done) done();
+                    return;
+                }
+            }
+
+            // Validate input payload
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            const inputValue = parseFloat(msg.payload);
+            if (isNaN(inputValue)) {
+                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+                if (done) done();
+                return;
+            }
+
+            // Cap input at max
+            const outputValue = Math.min(inputValue, node.runtime.max);
+
+            // Update status and send output
+            msg.payload = outputValue;
+            node.status({
+                fill: "blue",
+                shape: lastOutput === outputValue ? "ring" : "dot",
+                text: `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`
+            });
+            lastOutput = outputValue;
+            send(msg);
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("max-block", MaxBlockNode);
+};