@bldgblocks/node-red-contrib-control 0.1.4

package/nodes/sine-wave-block.js

@@ -0,0 +1,142 @@
+module.exports = function(RED) {
+    function SineWaveBlockNode(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;
+
+            // Sine wave calculation
+            const sineValue = Math.sin(2 * Math.PI * node.runtime.phase);
+            const amplitude = (node.runtime.upperLimit - node.runtime.lowerLimit) / 2;
+            const value = node.runtime.lowerLimit + amplitude * (sineValue + 1);
+
+            // 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("sine-wave-block", SineWaveBlockNode);
+};

package/nodes/subtract-block.html

@@ -0,0 +1,64 @@
+<script type="text/html" data-template-name="subtract-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-slots" title="Number of input slots (positive integer, e.g., 2)"><i class="fa fa-list-ol"></i> Slots</label>
+        <input type="number" id="node-input-slots" placeholder="2" min="1" step="1">
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("subtract-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            slots: {
+                value: 2,
+                required: true,
+                validate: function(v) { return !isNaN(parseInt(v)) && parseInt(v) >= 1; }
+            }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["difference"],
+        icon: "font-awesome/fa-minus",
+        paletteLabel: "subtract",
+        label: function() {
+            return this.name ? `${this.name} (${this.slots})` : `subtract (${this.slots})`;
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="subtract-block">
+Subtracts numeric inputs from multiple slots in sequence, preserving the input message.
+
+### Inputs
+: context (string) : Configures reset (`"reset"`), slots (`"slots"`), or identifies input slot (e.g., `"in1"`, `"in2"`).
+: payload (number | boolean) : Number for slot input or slots configuration, boolean for reset.
+
+### Outputs
+: payload (number) : Result of subtracting slots in sequence (in1 - in2 - ...).
+: *other* (any) : Other input message properties (e.g., `msg.context`, `msg.topic`) preserved.
+
+### Details
+Subtracts numeric `msg.payload` values from slots identified by `msg.context` (e.g., `"in1"`, `"in2"`) in sequence. 
+
+Inputs default to 0, updated via `msg.context = "inX"`. 
+
+Resets inputs to 0 via `msg.context = "reset"` with `msg.payload = true`. 
+
+### 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/subtract-block.js

@@ -0,0 +1,103 @@
+module.exports = function(RED) {
+    function SubtractBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        
+        const node = this;
+        
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            slots: parseInt(config.slots),
+            inputs: Array(parseInt(config.slots)).fill(0),
+            lastResult: null
+        };
+
+        // Validate initial config
+        if (isNaN(node.runtime.slots) || node.runtime.slots < 1) {
+            node.runtime.slots = 2;
+            node.runtime.inputs = Array(2).fill(0);
+            node.status({ fill: "red", shape: "ring", text: "invalid slots, using 2" });
+        } else {
+            node.status({
+                fill: "green",
+                shape: "dot",
+                text: `name: ${node.runtime.name}, slots: ${node.runtime.slots}`
+            });
+        }
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Guard against invalid msg
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Check for missing context or payload
+            if (!msg.hasOwnProperty("context")) {
+                node.status({ fill: "red", shape: "ring", text: "missing context" });
+                if (done) done();
+                return;
+            }
+
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            // Handle configuration messages
+            if (msg.context === "reset") {
+                if (typeof msg.payload !== "boolean") {
+                    node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                    if (done) done();
+                    return;
+                }
+                if (msg.payload === true) {
+                    node.runtime.inputs = Array(node.runtime.slots).fill(0);
+                    node.runtime.lastResult = null;
+                    node.status({ fill: "green", shape: "dot", text: "state reset" });
+                    if (done) done();
+                    return;
+                }
+            } else if (msg.context.startsWith("in")) {
+                let slotIndex = parseInt(msg.context.slice(2)) - 1;
+                if (isNaN(slotIndex) || slotIndex < 0 || slotIndex >= node.runtime.slots) {
+                    node.status({ fill: "red", shape: "ring", text: `invalid input slot ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+                let newValue = parseFloat(msg.payload);
+                if (isNaN(newValue)) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                    if (done) done();
+                    return;
+                }
+                node.runtime.inputs[slotIndex] = newValue;
+                
+                // Calculate subtraction
+                const result = node.runtime.inputs.reduce((acc, val, idx) => idx === 0 ? val : acc - val, 0);
+                const isUnchanged = result === node.runtime.lastResult;
+                node.status({ fill: "blue", shape: isUnchanged ? "ring" : "dot", text: `${msg.context}: ${newValue.toFixed(2)}, diff: ${result.toFixed(2)}` });
+
+                node.runtime.lastResult = result;
+                send({ payload: result });
+
+                if (done) done();
+                return;
+            } else {
+                node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                if (done) done();
+                return;
+            }
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("subtract-block", SubtractBlockNode);
+};

package/nodes/thermistor-block.html

@@ -0,0 +1,81 @@
+<script type="text/html" data-template-name="thermistor-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-R_fixed" title="Fixed resistor value in ohms for thermistor circuit"><i class="fa fa-wrench"></i> R_fixed (ohms)</label>
+        <input type="number" id="node-input-R_fixed" placeholder="23500" min="0.01" step="0.001">
+    </div>
+    <div class="form-row">
+        <label for="node-input-Vsupply" title="Supply voltage in volts for the thermistor circuit"><i class="fa fa-bolt"></i> Vsupply (volts)</label>
+        <input type="number" id="node-input-Vsupply" placeholder="5.08" min="0.01" step="0.001">
+    </div>
+    <div class="form-row">
+        <label for="node-input-Vref" title="Reference voltage in volts for ADC conversion"><i class="fa fa-bolt"></i> Vref (volts)</label>
+        <input type="number" id="node-input-Vref" placeholder="4.096" min="0.01" step="0.001">
+    </div>
+    <div class="form-row">
+        <label for="node-input-ADC_max" title="Maximum ADC value for raw data conversion"><i class="fa fa-microchip"></i> ADC_max</label>
+        <input type="number" id="node-input-ADC_max" placeholder="32768" min="1" step="1">
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("thermistor-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            R_fixed: { value: 23500, required: true, validate: function(v) { return Number(v) > 0; } },
+            Vsupply: { value: 5.08, required: true, validate: function(v) { return Number(v) > 0; } },
+            Vref: { value: 4.096, required: true, validate: function(v) { return Number(v) > 0; } },
+            ADC_max: { value: 32768, required: true, validate: function(v) { return Number(v) > 0; } }
+        },
+        inputs: 1,
+        outputs: 2,
+        inputLabels: ["raw data"],
+        outputLabels: ["voltage", "resistance"],
+        icon: "font-awesome/fa-thermometer",
+        paletteLabel: "thermistor",
+        label: function() {
+            return this.name || "thermistor";
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="thermistor-block">
+Converts a 16-bit raw sensor value into voltage and thermistor resistance.
+
+### Inputs
+: payload (array | buffer | object) : Two-byte array `[highByte, lowByte]`, 2-byte buffer, or object `type "Buffer", data [highByte, lowByte]` representing a 16-bit raw value.
+
+### Outputs
+: payload (number) : Output 1 -> Calculated voltage in volts.
+: payload (number) : Output 2 -> Calculated thermistor resistance in ohms.
+
+### Details
+Converts raw ADC data from a thermistor circuit into voltage and resistance. Calculates
+- Voltage: `(raw * Vref) / ADC_max`, where `raw = (highByte << 8) | lowByte`.
+- Resistance: `R_fixed * (voltage / (Vsupply - voltage))`.
+
+Configuration (set in editor, no runtime changes):
+: R_fixed (number) : Fixed resistor value in ohms
+: Vsupply (number) : Supply voltage in volts
+: Vref (number) : Reference voltage in volts for ADC conversion
+: ADC_max (number) : Maximum ADC value
+: name (string) : Optional display name.
+
+Outputs new messages for both outputs when values change. Stores `lastVoltage` and `lastResistance` in context for persistence.
+
+### 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/thermistor-block.js

@@ -0,0 +1,146 @@
+module.exports = function(RED) {
+    function ThermistorBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        const context = this.context();
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            R_fixed: parseFloat(config.R_fixed),
+            Vsupply: parseFloat(config.Vsupply),
+            Vref: parseFloat(config.Vref),
+            ADC_max: parseFloat(config.ADC_max),
+            lastVoltage: context.get("lastVoltage"),
+            lastResistance: context.get("lastResistance")
+        };
+
+        // Validate configuration
+        if (isNaN(node.runtime.R_fixed) || node.runtime.R_fixed <= 0) {
+            node.status({ fill: "red", shape: "ring", text: "invalid r_fixed" });
+            node.warn(`Invalid configuration: r_fixed=${node.runtime.R_fixed}`);
+            return;
+        }
+        if (isNaN(node.runtime.Vsupply) || node.runtime.Vsupply <= 0) {
+            node.status({ fill: "red", shape: "ring", text: "invalid vsupply" });
+            node.warn(`Invalid configuration: vsupply=${node.runtime.Vsupply}`);
+            return;
+        }
+        if (isNaN(node.runtime.Vref) || node.runtime.Vref <= 0) {
+            node.status({ fill: "red", shape: "ring", text: "invalid vref" });
+            node.warn(`Invalid configuration: vref=${node.runtime.Vref}`);
+            return;
+        }
+        if (isNaN(node.runtime.ADC_max) || node.runtime.ADC_max <= 0) {
+            node.status({ fill: "red", shape: "ring", text: "invalid adc_max" });
+            node.warn(`Invalid configuration: adc_max=${node.runtime.ADC_max}`);
+            return;
+        }
+
+        // Set initial status
+        node.status({ fill: "green", shape: "dot", text: `r_fixed: ${node.runtime.R_fixed}, vsupply: ${node.runtime.Vsupply}` });
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Validate input
+            if (!msg || typeof msg !== "object") {
+                node.status({ fill: "red", shape: "ring", text: "missing message" });
+                node.warn(`Missing message`);
+                if (done) done();
+                return;
+            }
+
+            let inputArray;
+            if (Buffer.isBuffer(msg.payload)) {
+                if (msg.payload.length !== 2) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid input: expected 2-byte buffer" });
+                    node.warn(`Invalid input: expected 2-byte buffer, got ${JSON.stringify(msg.payload)}`);
+                    if (done) done();
+                    return;
+                }
+                inputArray = [msg.payload[0], msg.payload[1]];
+            } else if (typeof msg.payload === "object" && msg.payload.type === "Buffer" && Array.isArray(msg.payload.data) && msg.payload.data.length === 2) {
+                inputArray = msg.payload.data;
+                if (typeof inputArray[0] !== "number" || typeof inputArray[1] !== "number") {
+                    node.status({ fill: "red", shape: "ring", text: "invalid input: expected numeric [highByte, lowByte]" });
+                    node.warn(`Invalid input: expected numeric [highByte, lowByte], got ${JSON.stringify(msg.payload)}`);
+                    if (done) done();
+                    return;
+                }
+            } else if (Array.isArray(msg.payload) && msg.payload.length === 2 && typeof msg.payload[0] === "number" && typeof msg.payload[1] === "number") {
+                inputArray = msg.payload;
+            } else {
+                node.status({ fill: "red", shape: "ring", text: "invalid input: expected [highByte, lowByte] or 2-byte buffer" });
+                node.warn(`Invalid input: expected [highByte, lowByte] or 2-byte buffer, got ${JSON.stringify(msg.payload)}`);
+                if (done) done();
+                return;
+            }
+
+            try {
+                // Calculate raw 16-bit value
+                const raw = (inputArray[0] << 8) | inputArray[1];
+                if (raw < 0 || raw > node.runtime.ADC_max) {
+                    node.status({ fill: "red", shape: "ring", text: "raw value out of range" });
+                    node.warn(`Raw value ${raw} out of range [0, ${node.runtime.ADC_max}]`);
+                    if (done) done();
+                    return;
+                }
+
+                // Calculate voltage
+                const voltage = (raw * node.runtime.Vref) / node.runtime.ADC_max;
+                if (voltage >= node.runtime.Vsupply || voltage <= 0) {
+                    node.status({ fill: "red", shape: "ring", text: "voltage out of range" });
+                    node.warn(`Voltage ${voltage} out of range (0, ${node.runtime.Vsupply})`);
+                    if (done) done();
+                    return;
+                }
+
+                // Calculate thermistor resistance
+                const R_thermistor = node.runtime.R_fixed * (voltage / (node.runtime.Vsupply - voltage));
+                if (isNaN(R_thermistor) || R_thermistor < 0) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid resistance" });
+                    node.warn(`Invalid resistance ${R_thermistor}`);
+                    if (done) done();
+                    return;
+                }
+
+                // Check if outputs have changed
+                const isUnchanged = voltage === node.runtime.lastVoltage && R_thermistor === node.runtime.lastResistance;
+                node.status({
+                    fill: "blue",
+                    shape: isUnchanged ? "ring" : "dot",
+                    text: `in: ${raw}, out: ${voltage.toFixed(2)}, ${R_thermistor.toFixed(2)}`
+                });
+
+                if (!isUnchanged) {
+                    // Update context and runtime
+                    node.runtime.lastVoltage = voltage;
+                    node.runtime.lastResistance = R_thermistor;
+                    context.set("lastVoltage", voltage);
+                    context.set("lastResistance", R_thermistor);
+
+                    // Send outputs
+                    send([
+                        { payload: voltage },
+                        { payload: R_thermistor }
+                    ]);
+                }
+
+            } catch (error) {
+                node.status({ fill: "red", shape: "ring", text: "calculation error" });
+                node.warn(`Calculation error: ${error.message}`);
+                if (done) done(error);
+                return;
+            }
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("thermistor-block", ThermistorBlockNode);
+};

package/nodes/tick-tock-block.html

@@ -0,0 +1,66 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="tick-tock-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-period" title="Period in seconds (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">
+    </div>
+</script>
+
+<!-- JavaScript Section -->
+<script type="text/javascript">
+    RED.nodes.registerType("tick-tock-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            period: { value: 10, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) > 0 && isFinite(parseFloat(v)); } }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-wave-square",
+        paletteLabel: "tick tock",
+        label: function() {
+            return this.name || "tick tock";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="tick-tock-block">
+Generates a square wave output toggling between true and false.
+
+### Inputs
+: context (string) : Configures settings (`"period"`, `"command"`). Unmatched values trigger error.
+: payload (number | string) : Numeric value for period, string (`"start"`, `"stop"`) for command.
+
+### Outputs
+: payload (boolean) : Square wave value (`true` or `false`).
+
+### Properties
+: period (number) : Full wave period (seconds, positive).
+
+### Details
+Generates a square wave output toggling between `true` and `false` every half `period` (seconds), started via `msg.context = "command"` with 
+`msg.payload = "start"`. Stops with `"stop"`.
+
+Outputs `msg.payload for each state change when running.
+
+Ignores redundant `start`/`stop` commands.
+
+### 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>