@bldgblocks/node-red-contrib-control 0.1.4

package/nodes/convert-block.js

@@ -0,0 +1,289 @@
+const validConversions = [
+    "F to C", 
+    "C to F", 
+    "K to C",
+    "C to K", 
+    "K to F",
+    "F to K",
+    "R to F",
+    "F to R",
+    "decimal to %", 
+    "% to decimal", 
+    "Pa to inH₂O", 
+    "inH₂O to Pa", 
+    "Pa to inHg", 
+    "inHg to Pa", 
+    "Pa to bar", 
+    "bar to Pa", 
+    "Pa to psi", 
+    "psi to Pa",
+    "m to ft",
+    "ft to m",
+    "m to in",
+    "in to m",
+    "mm to in",
+    "in to mm",
+    "kg to lb",
+    "lb to kg",
+    "L to gal",
+    "gal to L",
+    "kW to hp",
+    "hp to kW",
+    "rad to deg",
+    "deg to rad",
+    "s to min",
+    "min to s"
+];
+
+module.exports = function(RED) {
+    function ConvertBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            conversion: validConversions.includes(config.conversion) ? config.conversion : "C to F"
+        };
+
+        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: "missing message" });
+                if (done) done();
+                return;
+            }
+
+            // Handle configuration messages
+            if (msg.hasOwnProperty("context")) {
+                if (typeof msg.context !== "string") {
+                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    if (done) done();
+                    return;
+                }
+                if (msg.context === "conversion") {
+                    if (!msg.hasOwnProperty("payload") || !validConversions.includes(msg.payload)) {
+                        node.status({ fill: "red", shape: "ring", text: "invalid conversion" });
+                        if (done) done();
+                        return;
+                    }
+                    node.runtime.conversion = msg.payload;
+                    node.status({ fill: "green", shape: "dot", text: `conversion: ${node.runtime.conversion}` });
+                    if (done) done();
+                    return;
+                }
+                
+                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) || !isFinite(inputValue)) {
+                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+                if (done) done();
+                return;
+            }
+
+            // Perform conversion
+            let output, inUnit, outUnit;
+            switch (node.runtime.conversion) {
+                case "F to C":
+                    output = (msg.payload - 32) * 5 / 9;
+                    inUnit = "°F";
+                    outUnit = "°C";
+                    break;
+                case "C to F":
+                    output = (msg.payload * 9 / 5) + 32;
+                    inUnit = "°C";
+                    outUnit = "°F";
+                    break;
+                case "decimal to %":
+                    output = msg.payload * 100;
+                    inUnit = "";
+                    outUnit = "%";
+                    break;
+                case "% to decimal":
+                    output = msg.payload / 100;
+                    inUnit = "%";
+                    outUnit = "";
+                    break;
+                case "Pa to inH₂O":
+                    output = msg.payload * 0.00401463;
+                    inUnit = "Pa";
+                    outUnit = "inH₂O";
+                    break;
+                case "inH₂O to Pa":
+                    output = msg.payload / 0.00401463;
+                    inUnit = "inH₂O";
+                    outUnit = "Pa";
+                    break;
+                case "Pa to inHg":
+                    output = msg.payload * 0.0002953;
+                    inUnit = "Pa";
+                    outUnit = "inHg";
+                    break;
+                case "inHg to Pa":
+                    output = msg.payload / 0.0002953;
+                    inUnit = "inHg";
+                    outUnit = "Pa";
+                    break;
+                case "Pa to bar":
+                    output = msg.payload * 0.00001;
+                    inUnit = "Pa";
+                    outUnit = "bar";
+                    break;
+                case "bar to Pa":
+                    output = msg.payload / 0.00001;
+                    inUnit = "bar";
+                    outUnit = "Pa";
+                    break;
+                case "Pa to psi":
+                    output = msg.payload * 0.000145038;
+                    inUnit = "Pa";
+                    outUnit = "psi";
+                    break;
+                case "psi to Pa":
+                    output = msg.payload / 0.000145038;
+                    inUnit = "psi";
+                    outUnit = "Pa";
+                    break;
+                case "K to C":
+                    output = inputValue - 273.15;
+                    inUnit = "K";
+                    outUnit = "°C";
+                    break;
+                case "C to K":
+                    output = inputValue + 273.15;
+                    inUnit = "°C";
+                    outUnit = "K";
+                    break;
+                case "K to F":
+                    output = (inputValue * 9/5) - 459.67;
+                    inUnit = "K";
+                    outUnit = "°F";
+                    break;
+                case "F to K":
+                    output = (inputValue + 459.67) * 5/9;
+                    inUnit = "°F";
+                    outUnit = "K";
+                    break;
+                case "R to F":
+                    output = inputValue - 459.67;
+                    inUnit = "°R";
+                    outUnit = "°F";
+                    break;
+                case "F to R":
+                    output = inputValue + 459.67;
+                    inUnit = "°F";
+                    outUnit = "°R";
+                    break;
+                case "m to ft":
+                    output = inputValue * 3.28084;
+                    inUnit = "m";
+                    outUnit = "ft";
+                    break;
+                case "ft to m":
+                    output = inputValue / 3.28084;
+                    inUnit = "ft";
+                    outUnit = "m";
+                    break;
+                case "m to in":
+                    output = inputValue * 39.3701;
+                    inUnit = "m";
+                    outUnit = "in";
+                    break;
+                case "in to m":
+                    output = inputValue / 39.3701;
+                    inUnit = "in";
+                    outUnit = "m";
+                    break;
+                case "mm to in":
+                    output = inputValue / 25.4;
+                    inUnit = "mm";
+                    outUnit = "in";
+                    break;
+                case "in to mm":
+                    output = inputValue * 25.4;
+                    inUnit = "in";
+                    outUnit = "mm";
+                    break;
+                case "kg to lb":
+                    output = inputValue * 2.20462;
+                    inUnit = "kg";
+                    outUnit = "lb";
+                    break;
+                case "lb to kg":
+                    output = inputValue / 2.20462;
+                    inUnit = "lb";
+                    outUnit = "kg";
+                    break;
+                case "L to gal":
+                    output = inputValue * 0.264172;
+                    inUnit = "L";
+                    outUnit = "gal";
+                    break;
+                case "gal to L":
+                    output = inputValue / 0.264172;
+                    inUnit = "gal";
+                    outUnit = "L";
+                    break;
+                case "kW to hp":
+                    output = inputValue * 1.34102;
+                    inUnit = "kW";
+                    outUnit = "hp";
+                    break;
+                case "hp to kW":
+                    output = inputValue / 1.34102;
+                    inUnit = "hp";
+                    outUnit = "kW";
+                    break;
+                case "rad to deg":
+                    output = inputValue * (180 / Math.PI);
+                    inUnit = "rad";
+                    outUnit = "°";
+                    break;
+                case "deg to rad":
+                    output = inputValue * (Math.PI / 180);
+                    inUnit = "°";
+                    outUnit = "rad";
+                    break;
+                case "s to min":
+                    output = inputValue / 60;
+                    inUnit = "s";
+                    outUnit = "min";
+                    break;
+                case "min to s":
+                    output = inputValue * 60;
+                    inUnit = "min";
+                    outUnit = "s";
+                    break;
+            }
+
+            // Format status numbers
+            const inDisplay = msg.payload % 1 === 0 ? msg.payload : msg.payload.toFixed(2);
+            const outDisplay = output % 1 === 0 ? output : output.toFixed(2);
+
+            // Update status and send output
+            node.status({ fill: "blue", shape: "dot", text: `${inDisplay} ${inUnit} → ${outDisplay} ${outUnit}` });
+
+            msg.payload = output;
+            send(msg);
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("convert-block", ConvertBlockNode);
+};

package/nodes/count-block.html

@@ -0,0 +1,57 @@
+<!-- UI Template Section: Defines the edit dialog -->
+<script type="text/html" data-template-name="count-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>
+</script>
+
+<!-- JavaScript Section: Registers the node and handles editor logic -->
+<script type="text/javascript">
+    RED.nodes.registerType("count-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["count"],
+        icon: "font-awesome/fa-tally",
+        paletteLabel: "count",
+        label: function() {
+            return this.name || "count";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="count-block">
+Counts boolean rising edges in the input.
+
+### Inputs
+: context (string) : Resets count (`"reset"`). Unmatched values trigger error.
+: payload (boolean) : Input boolean to detect rising edges.
+
+### Outputs
+: payload (number) : Current count of rising edges.
+
+### Properties
+: name (string) : Display name in editor.
+
+### Details
+Counts rising edges (false-to-true transitions) in `msg.payload` (boolean), incrementing the count on each transition. 
+Resets count to 0 via `msg.context = "reset"` with `msg.payload = true`. 
+
+### Status
+- Green (dot): Configuration
+- Blue (dot): Output, no alarm
+- Red (dot): Output with alarm
+- Red (ring): Errors
+- Yellow (ring): Unknown context
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/count-block.js

@@ -0,0 +1,92 @@
+module.exports = function(RED) {
+    function CountBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            count: 0,
+            prevState: false
+        };
+
+        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 reset" });
+                    if (done) done();
+                    return;
+                }
+                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.count = 0;
+                        node.runtime.prevState = false;
+                        node.status({ fill: "green", shape: "dot", text: "state reset" });
+                        send({ payload: node.runtime.count });
+                    }
+                    if (done) done();
+                    return;
+                } else {
+                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    if (done) done("Unknown context");
+                    return;
+                }
+            }
+
+            // Validate input
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing input" });
+                if (done) done();
+                return;
+            }
+
+            const inputValue = msg.payload;
+            if (typeof inputValue !== "boolean") {
+                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                if (done) done();
+                return;
+            }
+
+            // Prevent integer overflow
+            if (node.runtime.count > Number.MAX_SAFE_INTEGER - 100000) {
+                node.runtime.count = 0;
+                node.status({ fill: "yellow", shape: "ring", text: "count overflow reset" });
+            }
+
+            // Increment on false → true transition
+            if (!node.runtime.prevState && inputValue === true) {
+                node.runtime.count++;
+                node.status({ fill: "blue", shape: "dot", text: `count: ${node.runtime.count}` });
+                send({ payload: node.runtime.count });
+            } else {
+                node.status({ fill: "blue", shape: "ring", text: `count: ${node.runtime.count}` });
+            }
+
+            // Update prevState
+            node.runtime.prevState = inputValue;
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("count-block", CountBlockNode);
+};

package/nodes/debounce-block.html

@@ -0,0 +1,64 @@
+<script type="text/html" data-template-name="debounce-block">
+    <div class="form-row">
+        <label for="node-input-period" title="Filter period in milliseconds (positive number, e.g., 1000)"><i class="fa fa-clock-o"></i> Filter Period (ms)</label>
+        <input type="text" id="node-input-period" placeholder="1000" min="0.001" step="any">
+        <input type="hidden" id="node-input-periodType">
+
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("debounce-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            period: {
+                value: 1000,
+                required: true,
+                validate: function() { return true; }
+            },
+            periodType: { value: "num" }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-hourglass-half",
+        paletteLabel: "debounce",
+        label: function() {
+            return this.name || "debounce";
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="debounce-block">
+Debounces consecutive `true` payloads and passes `false` payloads immediately with a configurable filter period.
+
+### Inputs
+: context (string) : Configures filter period (`"period"`).
+: payload (boolean | number) : `true` for debounced output, `false` for immediate output.
+
+### Outputs
+: payload (boolean) : `true` after filter period elapses without new `true` payloads, `false` immediately. `msg.context` is consumed.
+
+### Details
+Filters consecutive `true` `msg.payload` inputs, outputting `true` after the filter period elapses without new `true` payloads. 
+
+Consecutive `true` payloads within the period reset the timer, delaying output. Outputs `false` `msg.payload` inputs immediately without debouncing. 
+
+Non-boolean payloads (e.g., strings, numbers) are ignored with an error status. 
+
+Tracks ignored `true` payloads, which increments for each `true` payload resetting an active timer, capped at 9999, resetting to 0 if exceeded or on redeployment. 
+
+### Status
+- Green (dot): Configuration
+- Blue (dot): Output, no alarm
+- Red (dot): Output with alarm
+- Red (ring): Errors
+- Yellow (ring): Unknown context
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/debounce-block.js

@@ -0,0 +1,140 @@
+module.exports = function(RED) {
+    function DebounceBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime for editor display
+        node.runtime = {
+            debounceCount: 0
+        };
+
+        // Initialize state
+        let debounceTimer = null;
+        let lastOutput = null;
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Evaluate all properties
+            try {
+                node.runtime.period = RED.util.evaluateNodeProperty(
+                    config.period, config.periodType, node, msg
+                );
+                node.runtime.period = parseFloat(node.runtime.period);
+
+                node.period = parseFloat(node.period);
+                if (isNaN(node.period) || node.period <= 0 || !isFinite(node.period)) {
+                    node.period = 1000;
+                    node.status({ fill: "yellow", shape: "ring", text: "invalid period, using 1000ms" });
+                }
+            } catch(err) {
+                node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });
+                if (done) done(err);
+                return;
+            }
+
+            // Guard against invalid msg
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Handle msg.context
+            if (msg.hasOwnProperty("context")) {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    if (done) done();
+                    return;
+                }
+
+                if (msg.context === "period") {
+                    const newPeriod = parseFloat(msg.payload);
+                    if (isNaN(newPeriod) || newPeriod <= 0) {
+                        node.status({ fill: "red", shape: "ring", text: "invalid period" });
+                        if (done) done();
+                        return;
+                    }
+                    node.runtime.period = newPeriod;
+                    node.status({
+                        fill: "green",
+                        shape: "dot",
+                        text: `period: ${newPeriod.toFixed(0)} ms, bounced: ${node.runtime.debounceCount}`
+                    });
+                    if (done) done();
+                    return;
+                }
+
+                node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                if (done) done();
+                return;
+            }
+
+            // Check for missing payload
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            // Process false payloads immediately
+            if (msg.payload === false) {
+                const statusText = `in: false, out: false, bounced: ${node.runtime.debounceCount}`;
+                if (lastOutput === false) {
+                    node.status({ fill: "blue", shape: "ring", text: statusText });
+                } else {
+                    node.status({ fill: "blue", shape: "dot", text: statusText });
+                }
+                lastOutput = false;
+                delete msg.context;
+                send(msg);
+                if (done) done();
+                return;
+            }
+
+            // Process true payloads with debouncing
+            if (msg.payload === true) {
+                // Increment debounce counter if resetting an active timer
+                if (debounceTimer) {
+                    node.runtime.debounceCount++;
+                    if (node.runtime.debounceCount > 9999) {
+                        node.runtime.debounceCount = 0;
+                    }
+                }
+
+                // Clear existing timer
+                if (debounceTimer) {
+                    clearTimeout(debounceTimer);
+                }
+
+                // Set new debounce timer
+                debounceTimer = setTimeout(() => {
+                    debounceTimer = null;
+                    const statusText = `in: true, out: true, bounced: ${node.runtime.debounceCount}`;
+                    node.status({ fill: "blue", shape: "dot", text: statusText });
+                    lastOutput = true;
+                    delete msg.context;
+                    send(msg);
+                }, node.runtime.period);
+
+                if (done) done();
+                return;
+            }
+
+            // Ignore non-boolean payloads
+            node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+                debounceTimer = null;
+            }
+            
+            done();
+        });
+    }
+
+    RED.nodes.registerType("debounce-block", DebounceBlockNode);
+};