@bldgblocks/node-red-contrib-control 0.1.4

package/nodes/priority-block.js

@@ -0,0 +1,239 @@
+module.exports = function(RED) {
+    function PriorityBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        const context = this.context();
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name
+        };
+
+        // Initialize state from context or defaults
+        let priorities = context.get("priorities") || {
+            priority1: null, priority2: null, priority3: null, priority4: null,
+            priority5: null, priority6: null, priority7: null, priority8: null,
+            priority9: null, priority10: null, priority11: null, priority12: null,
+            priority13: null, priority14: null, priority15: null, priority16: null
+        };
+        let defaultValue = context.get("defaultValue") || null;
+        let fallbackValue = context.get("fallbackValue") || null;
+        let messages = context.get("messages") || {
+            priority1: null, priority2: null, priority3: null, priority4: null,
+            priority5: null, priority6: null, priority7: null, priority8: null,
+            priority9: null, priority10: null, priority11: null, priority12: null,
+            priority13: null, priority14: null, priority15: null, priority16: null,
+            default: null, fallback: null
+        };
+
+        // Save initial state to context
+        context.set("priorities", priorities);
+        context.set("defaultValue", defaultValue);
+        context.set("fallbackValue", fallbackValue);
+        context.set("messages", messages);
+
+        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;
+            }
+
+            // Validate payload
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            // Handle keyed object payload for clearing
+            if (typeof msg.payload === "object" && msg.payload !== null && msg.payload.hasOwnProperty("clear")) {
+                const clear = msg.payload.clear;
+                if (clear === "all") {
+                    priorities = {
+                        priority1: null, priority2: null, priority3: null, priority4: null,
+                        priority5: null, priority6: null, priority7: null, priority8: null,
+                        priority9: null, priority10: null, priority11: null, priority12: null,
+                        priority13: null, priority14: null, priority15: null, priority16: null
+                    };
+                    defaultValue = null;
+                    fallbackValue = null;
+                    messages = {
+                        priority1: null, priority2: null, priority3: null, priority4: null,
+                        priority5: null, priority6: null, priority7: null, priority8: null,
+                        priority9: null, priority10: null, priority11: null, priority12: null,
+                        priority13: null, priority14: null, priority15: null, priority16: null,
+                        default: null, fallback: null
+                    };
+                    context.set("priorities", priorities);
+                    context.set("defaultValue", defaultValue);
+                    context.set("fallbackValue", fallbackValue);
+                    context.set("messages", messages);
+                    node.status({ fill: "green", shape: "dot", text: "all slots cleared" });
+                } else if (typeof clear === "string" && isValidSlot(clear)) {
+                    if (clear.startsWith("priority")) priorities[clear] = null;
+                    else if (clear === "default") defaultValue = null;
+                    else if (clear === "fallback") fallbackValue = null;
+                    messages[clear] = null;
+                    context.set("priorities", priorities);
+                    context.set("defaultValue", defaultValue);
+                    context.set("fallbackValue", fallbackValue);
+                    context.set("messages", messages);
+                    node.status({ fill: "green", shape: "dot", text: `${clear} cleared` });
+                } else if (Array.isArray(clear) && clear.every(isValidSlot)) {
+                    clear.forEach(slot => {
+                        if (slot.startsWith("priority")) priorities[slot] = null;
+                        else if (slot === "default") defaultValue = null;
+                        else if (slot === "fallback") fallbackValue = null;
+                        messages[slot] = null;
+                    });
+                    context.set("priorities", priorities);
+                    context.set("defaultValue", defaultValue);
+                    context.set("fallbackValue", fallbackValue);
+                    context.set("messages", messages);
+                    node.status({ fill: "green", shape: "dot", text: `${clear.join(", ")} cleared` });
+                } else {
+                    node.status({ fill: "red", shape: "ring", text: "invalid clear" });
+                    if (done) done();
+                    return;
+                }
+            } else if (msg.payload === "clear") {
+                // Handle string "clear" with msg.context
+                if (!msg.hasOwnProperty("context") || typeof msg.context !== "string") {
+                    node.status({ fill: "red", shape: "ring", text: "missing or invalid context for clear" });
+                    if (done) done();
+                    return;
+                }
+                const contextMsg = msg.context;
+                if (isValidSlot(contextMsg)) {
+                    if (contextMsg.startsWith("priority")) priorities[contextMsg] = null;
+                    else if (contextMsg === "default") defaultValue = null;
+                    else if (contextMsg === "fallback") fallbackValue = null;
+                    messages[contextMsg] = null;
+                    context.set("priorities", priorities);
+                    context.set("defaultValue", defaultValue);
+                    context.set("fallbackValue", fallbackValue);
+                    context.set("messages", messages);
+                    node.status({ fill: "green", shape: "dot", text: `${contextMsg} cleared` });
+                } else {
+                    node.status({ fill: "red", shape: "ring", text: "invalid clear context" });
+                    if (done) done();
+                    return;
+                }
+            } else {
+                // Handle non-object, non-"clear" payloads
+                if (!msg.hasOwnProperty("context") || typeof msg.context !== "string") {
+                    node.status({ fill: "red", shape: "ring", text: "missing or invalid context" });
+                    if (done) done();
+                    return;
+                }
+
+                const contextMsg = msg.context;
+                const value = msg.payload === null ? null : typeof msg.payload === "number" ? parseFloat(msg.payload) : typeof msg.payload === "boolean" ? msg.payload : null;
+
+                if (value === null && msg.payload !== null) {
+                    node.status({ fill: "red", shape: "ring", text: `invalid ${contextMsg}` });
+                    if (done) done();
+                    return;
+                }
+
+                if (/^priority([1-9]|1[0-6])$/.test(contextMsg)) {
+                    priorities[contextMsg] = value;
+                    messages[contextMsg] = RED.util.cloneMessage(msg);
+                    context.set("priorities", priorities);
+                    context.set("messages", messages);
+                    node.status({
+                        fill: "green",
+                        shape: "dot",
+                        text: value === null ? `${contextMsg} relinquished` : `${contextMsg}: ${typeof value === "number" ? value.toFixed(2) : value}`
+                    });
+                } else if (contextMsg === "default") {
+                    defaultValue = value;
+                    messages[contextMsg] = RED.util.cloneMessage(msg);
+                    context.set("defaultValue", defaultValue);
+                    context.set("messages", messages);
+                    node.status({
+                        fill: "green",
+                        shape: "dot",
+                        text: value === null ? "default relinquished" : `default: ${typeof value === "number" ? value.toFixed(2) : value}`
+                    });
+                } else if (contextMsg === "fallback") {
+                    fallbackValue = value;
+                    messages[contextMsg] = RED.util.cloneMessage(msg);
+                    context.set("fallbackValue", fallbackValue);
+                    context.set("messages", messages);
+                    node.status({
+                        fill: "green",
+                        shape: "dot",
+                        text: value === null ? "fallback relinquished" : `fallback: ${typeof value === "number" ? value.toFixed(2) : value}`
+                    });
+                } else {
+                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    if (done) done("Unknown context");
+                    return;
+                }
+            }
+
+            // Output highest priority message
+            const currentOutput = evaluatePriority();
+            send(currentOutput);
+            const inDisplay = typeof msg.payload === "number" ? msg.payload.toFixed(2) : typeof msg.payload === "object" ? JSON.stringify(msg.payload).slice(0, 20) : msg.payload;
+            const outDisplay = currentOutput.payload === null ? "null" : typeof currentOutput.payload === "number" ? currentOutput.payload.toFixed(2) : currentOutput.payload;
+            node.status({
+                fill: "blue",
+                shape: "dot",
+                text: `in: ${inDisplay}, out: ${outDisplay}, slot: ${currentOutput.diagnostics.activePriority || "none"}`
+            });
+
+            if (done) done();
+
+            function isValidSlot(slot) {
+                return /^priority([1-9]|1[0-6])$/.test(slot) || slot === "default" || slot === "fallback";
+            }
+
+            function evaluatePriority() {
+                let selectedValue = null;
+                let activePriority = null;
+                let selectedMessage = null;
+
+                // Check priorities from 1 to 16
+                for (let i = 1; i <= 16; i++) {
+                    const key = `priority${i}`;
+                    if (priorities[key] !== null) {
+                        selectedValue = priorities[key];
+                        activePriority = key;
+                        selectedMessage = messages[key];
+                        break;
+                    }
+                }
+
+                // Fall back to default or fallback
+                if (selectedValue === null) {
+                    if (defaultValue !== null) {
+                        selectedValue = defaultValue;
+                        activePriority = "default";
+                        selectedMessage = messages.default;
+                    } else if (fallbackValue !== null) {
+                        selectedValue = fallbackValue;
+                        activePriority = "fallback";
+                        selectedMessage = messages.fallback;
+                    }
+                }
+
+                // Return the original message if available, otherwise a new message
+                const output = selectedMessage ? RED.util.cloneMessage(selectedMessage) : { payload: selectedValue };
+                output.diagnostics = { activePriority };
+                return output;
+            }
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("priority-block", PriorityBlockNode);
+};

package/nodes/rate-limit-block.html

@@ -0,0 +1,99 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="rate-limit-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-mode" title="Processing mode"><i class="fa fa-cog"></i> Mode</label>
+        <select id="node-input-mode">
+            <option value="rate-limit">Rate Limit</option>
+            <option value="threshold">Threshold</option>
+            <option value="full-value">Full Value</option>
+        </select>
+    </div>
+    <div class="form-row rate-limit-field">
+        <label for="node-input-rate" title="Rate of change (units per second, > 0)"><i class="fa fa-tachometer"></i> Rate (units/s)</label>
+        <input type="number" id="node-input-rate" placeholder="1" min="0.01" step="0.01">
+    </div>
+    <div class="form-row rate-limit-field">
+        <label for="node-input-interval" title="Update interval (milliseconds, ≥ 10, integer)"><i class="fa fa-clock-o"></i> Interval (ms)</label>
+        <input type="number" id="node-input-interval" placeholder="100" min="10" step="10">
+    </div>
+    <div class="form-row threshold-field">
+        <label for="node-input-threshold" title="Threshold for output (units, ≥ 0)"><i class="fa fa-filter"></i> Threshold (units)</label>
+        <input type="number" id="node-input-threshold" placeholder="5" min="0" step="0.01">
+    </div>
+</script>
+
+<!-- JavaScript Section -->
+<script type="text/javascript">
+    RED.nodes.registerType("rate-limit-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            mode: { value: "rate-limit", required: true, validate: function(v) { return ["rate-limit", "threshold", "full-value"].includes(v); } },
+            rate: { value: 1, required: false, validate: function(v) { return !v || (!isNaN(parseFloat(v)) && parseFloat(v) > 0 && isFinite(parseFloat(v))); } },
+            interval: { value: 100, required: false, validate: function(v) { return !v || (Number.isInteger(parseInt(v)) && parseInt(v) >= 10); } },
+            threshold: { value: 5, required: false, validate: function(v) { return !v || (!isNaN(parseFloat(v)) && parseFloat(v) >= 0 && isFinite(parseFloat(v))); } }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["value"],
+        outputLabels: ["processed value"],
+        icon: "font-awesome/fa-tachometer-alt",
+        paletteLabel: "rate limit",
+        label: function() {
+            return this.name || this.mode || "rate limit";
+        },
+        oneditprepare: function() {
+            const node = this;
+
+            // Field visibility logic
+            function updateFieldVisibility() {
+                const mode = $("#node-input-mode").val();
+                $(".rate-limit-field").toggle(mode === "rate-limit");
+                $(".threshold-field").toggle(mode === "threshold");
+            }
+            $("#node-input-mode").on("change", updateFieldVisibility);
+            updateFieldVisibility();
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="rate-limit-block">
+Processes a numeric input value based on a selected mode and passes the original message.
+
+### Inputs
+: context (string) : Configures settings (`"mode"`, `"rate"`, `"interval"`, `"threshold"`). Unmatched values trigger error.
+: payload (number | string | number) : Number to process, or value for configuration (string for mode, number for others).
+
+### Outputs
+: payload (number) : Processed value, depending on mode.
+: Other properties (e.g., `msg.topic`) from the input message are preserved.
+
+### Properties
+: mode (string) : Processing mode.
+: rate (number) : Rate of change for rate-limit mode.
+: interval (number) : Update interval for rate-limit mode.
+: threshold (number) : Threshold for output in threshold mode.
+
+### Details
+Processes `msg.payload` (number) in one of three modes:
+- `Rate Limit` Limits rate of change to `rate` (units/s), updating every `interval` (ms) toward the input value.
+- `Threshold` Outputs when input differs from last output by more than `threshold` (units).
+- `Full Value` Passes input unchanged.
+
+### 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/rate-limit-block.js

@@ -0,0 +1,221 @@
+module.exports = function(RED) {
+    function RateLimitBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            mode: config.mode,
+            rate: parseFloat(config.rate),
+            interval: parseInt(config.interval),
+            threshold: parseFloat(config.threshold),
+            currentValue: 0,
+            targetValue: 0,
+            lastUpdate: Date.now(),
+            lastInputMsg: null
+        };
+
+        // Validate initial config
+        if (isNaN(node.runtime.rate) || node.runtime.rate <= 0 || !isFinite(node.runtime.rate)) {
+            node.runtime.rate = 1.0;
+            node.status({ fill: "red", shape: "ring", text: "invalid rate" });
+        }
+        if (isNaN(node.runtime.interval) || node.runtime.interval < 10 || !Number.isInteger(node.runtime.interval)) {
+            node.runtime.interval = 100;
+            node.status({ fill: "red", shape: "ring", text: "invalid interval" });
+        }
+        if (isNaN(node.runtime.threshold) || node.runtime.threshold < 0 || !isFinite(node.runtime.threshold)) {
+            node.runtime.threshold = 5.0;
+            node.status({ fill: "red", shape: "ring", text: "invalid threshold" });
+        }
+        if (!["rate-limit", "threshold", "full-value"].includes(node.runtime.mode)) {
+            node.runtime.mode = "rate-limit";
+            node.status({ fill: "red", shape: "ring", text: "invalid mode" });
+        }
+
+        // Set initial status
+        node.status({ fill: "blue", shape: "dot", text: `mode: ${node.runtime.mode}, out: ${node.runtime.currentValue.toFixed(2)}` });
+
+        let updateTimer = null;
+
+        // Function to update output for rate-limit mode
+        function updateRateLimitOutput() {
+            if (!node.runtime.lastInputMsg) return;
+            const now = Date.now();
+            const elapsed = (now - node.runtime.lastUpdate) / 1000; // Seconds
+            const maxChange = node.runtime.rate * elapsed;
+            let newValue = node.runtime.currentValue;
+
+            if (node.runtime.currentValue < node.runtime.targetValue) {
+                newValue = Math.min(node.runtime.currentValue + maxChange, node.runtime.targetValue);
+            } else if (node.runtime.currentValue > node.runtime.targetValue) {
+                newValue = Math.max(node.runtime.currentValue - maxChange, node.runtime.targetValue);
+            }
+
+            if (newValue !== node.runtime.currentValue) {
+                node.runtime.currentValue = newValue;
+                node.runtime.lastUpdate = now;
+                const msg = RED.util.cloneMessage(node.runtime.lastInputMsg);
+                msg.payload = node.runtime.currentValue;
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: `mode: rate-limit, out: ${node.runtime.currentValue.toFixed(2)}`
+                });
+                node.send(msg);
+            }
+        }
+
+        // Start update timer for rate-limit mode
+        function startTimer() {
+            if (updateTimer) clearInterval(updateTimer);
+            if (node.runtime.mode === "rate-limit") {
+                updateTimer = setInterval(updateRateLimitOutput, node.runtime.interval);
+            }
+        }
+
+        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;
+                }
+                switch (msg.context) {
+                    case "mode":
+                        if (!["rate-limit", "threshold", "full-value"].includes(msg.payload)) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid mode" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.mode = msg.payload;
+                        startTimer();
+                        node.status({
+                            fill: "green",
+                            shape: "dot",
+                            text: `mode: ${node.runtime.mode}`
+                        });
+                        break;
+                    case "rate":
+                        const rate = parseFloat(msg.payload);
+                        if (isNaN(rate) || rate <= 0 || !isFinite(rate)) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid rate" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.rate = rate;
+                        node.status({
+                            fill: "green",
+                            shape: "dot",
+                            text: `rate: ${node.runtime.rate.toFixed(2)}`
+                        });
+                        break;
+                    case "interval":
+                        const interval = parseInt(msg.payload);
+                        if (isNaN(interval) || interval < 10 || !Number.isInteger(interval)) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid interval" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.interval = interval;
+                        startTimer();
+                        node.status({
+                            fill: "green",
+                            shape: "dot",
+                            text: `interval: ${node.runtime.interval}`
+                        });
+                        break;
+                    case "threshold":
+                        const threshold = parseFloat(msg.payload);
+                        if (isNaN(threshold) || threshold < 0 || !isFinite(threshold)) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid threshold" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.threshold = threshold;
+                        node.status({
+                            fill: "green",
+                            shape: "dot",
+                            text: `threshold: ${node.runtime.threshold.toFixed(2)}`
+                        });
+                        break;
+                    default:
+                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        if (done) done("Unknown context");
+                        return;
+                }
+                if (done) done();
+                return;
+            }
+
+            // Validate input
+            if (typeof msg.payload !== "number" || isNaN(msg.payload) || !isFinite(msg.payload)) {
+                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                if (done) done();
+                return;
+            }
+
+            const inputValue = msg.payload;
+            node.runtime.lastInputMsg = RED.util.cloneMessage(msg);
+
+            if (node.runtime.mode === "rate-limit") {
+                node.runtime.targetValue = inputValue;
+                node.status({
+                    fill: "green",
+                    shape: "dot",
+                    text: `mode: rate-limit, target: ${node.runtime.targetValue.toFixed(2)}`
+                });
+                updateRateLimitOutput();
+                startTimer();
+            } else if (node.runtime.mode === "threshold") {
+                const diff = Math.abs(inputValue - node.runtime.currentValue);
+                node.runtime.currentValue = inputValue;
+                if (diff > node.runtime.threshold) {
+                    msg.payload = inputValue;
+                    node.status({
+                        fill: "blue",
+                        shape: "dot",
+                        text: `mode: threshold, out: ${node.runtime.currentValue.toFixed(2)}`
+                    });
+                    send(msg);
+                } else {
+                    node.status({
+                        fill: "blue",
+                        shape: "ring",
+                        text: `mode: threshold, out: ${node.runtime.currentValue.toFixed(2)}`
+                    });
+                }
+            } else if (node.runtime.mode === "full-value") {
+                node.runtime.currentValue = inputValue;
+                msg.payload = inputValue;
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: `mode: full-value, out: ${node.runtime.currentValue.toFixed(2)}`
+                });
+                send(msg);
+            }
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            if (updateTimer) clearInterval(updateTimer);
+            updateTimer = null;
+            done();
+        });
+    }
+
+    RED.nodes.registerType("rate-limit-block", RateLimitBlockNode);
+};

package/nodes/round-block.html

@@ -0,0 +1,73 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="round-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-precision" title="Rounding precision (0.1 for tenths, 0.5 for halves, 1.0 for whole numbers)"><i class="fa fa-ruler"></i> Precision</label>
+        <select id="node-input-precision">
+            <option value="0.1">0.1 (tenths)</option>
+            <option value="0.5">0.5 (halves)</option>
+            <option value="1.0">1.0 (whole)</option>
+        </select>
+    </div>
+</script>
+
+<!-- JavaScript Section -->
+<script type="text/javascript">
+    RED.nodes.registerType("round-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            precision: { value: "1.0", required: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["rounded"],
+        icon: "font-awesome/fa-circle-o-notch",
+        paletteLabel: "round",
+        label: function() {
+            return this.name || "";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="round-block">
+Rounds a float in `msg.payload` to the nearest configurable precision (tenth, half, or whole number).
+
+### Inputs
+: payload (number) : Float to round.
+: context (string, optional) : Action (`"precision"` to set precision). Unknown `msg.context` values are ignored.
+: payload (string, for `"precision"`) : Precision value (`"0.1"`, `"0.5"`, `"1.0"`).
+
+### Outputs
+: msg : Original message with `msg.payload` rounded to configured precision.
+
+### Properties
+: name (string) : Display name in editor.
+: precision (string) : Rounding precision (`"0.1"`, `"0.5"`, `"1.0"`).
+
+### Details
+Rounds a float in `msg.payload` to the nearest tenth (0.1), half (0.5), or whole number (1.0), set via editor or `msg.context = "precision"`. 
+
+Operates as a passthrough node, modifying `msg.payload` and forwarding the original message. 
+
+If `msg.payload` is not a finite number, the message is passed unchanged. 
+
+Unknown `msg.context` values are ignored.
+
+### 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>