@bldgblocks/node-red-contrib-control 0.1.27 → 0.1.28

package/nodes/rate-of-change-block.html

@@ -0,0 +1,110 @@
+<script type="text/html" data-template-name="rate-of-change-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-sampleSize" title="Number of samples to track (minimum 2)"><i class="fa fa-list-ol"></i> Sample Size</label>
+        <input type="number" id="node-input-sampleSize" placeholder="10" min="2" step="1">
+    </div>
+    <div class="form-row">
+        <label for="node-input-units" title="Time units for rate calculation"><i class="fa fa-clock-o"></i> Rate Units</label>
+        <select id="node-input-units">
+            <option value="seconds">Seconds</option>
+            <option value="minutes" selected>Minutes</option>
+            <option value="hours">Hours</option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-minValid"><i class="fa fa-arrow-down"></i> Minimum Valid Temp</label>
+        <input type="text" id="node-input-minValid" placeholder="-40">
+        <input type="hidden" id="node-input-minValidType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-maxValid"><i class="fa fa-arrow-up"></i> Maximum Valid Temp</label>
+        <input type="text" id="node-input-maxValid" placeholder="150">
+        <input type="hidden" id="node-input-maxValidType">
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("rate-of-change-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            sampleSize: {
+                value: 10,
+                required: true,
+                validate: function(v) { return !isNaN(parseInt(v)) && parseInt(v) >= 2; }
+            },
+            units: { value: "minutes" },
+            minValid: { value: -40, required: true },
+            minValidType: { value: "num" },
+            maxValid: { value: 150, required: true },
+            maxValidType: { value: "num" }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["rate"],
+        icon: "font-awesome/fa-bar-chart",
+        paletteLabel: "rate of change",
+        label: function() {
+            return this.name ? `${this.name} (${this.sampleSize} samples)` : `RoC (${this.sampleSize})`;
+        },
+        oneditprepare: function() {
+            const node = this;
+
+            try {
+                // Initialize typed inputs
+                $("#node-input-minValid").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-minValidType"
+                }).typedInput("type", node.minValidType || "num").typedInput("value", node.minValid || "-40");
+
+                $("#node-input-maxValid").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-maxValidType"
+                }).typedInput("type", node.maxValidType || "num").typedInput("value", node.maxValid || "150");
+                
+                // Set units dropdown
+                $("#node-input-units").val(node.units || "minutes");
+            } catch (err) {
+                console.error("Error in oneditprepare:", err);
+            }
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="rate-of-change-block">
+Calculates the rate of temperature change over time for HVAC applications.
+
+### Inputs
+: context (string) : Configures reset (`"reset"`), sample size (`"sampleSize"`), or units (`"units"`).
+: payload (number) : Temperature value for rate calculation.
+: timestamp (optional) : Custom timestamp for the reading.
+
+### Outputs
+: payload (number | null) : Rate of change in temperature per time unit.
+: samples (number) : Current number of samples in buffer.
+: units (string) : Rate units ("°/s", "°/min", "°/hr").
+: currentValue (number) : Most recent temperature value.
+: timeSpan (number) : Time span of sample buffer in seconds.
+
+### Details
+Tracks temperature changes over a rolling window of samples. Calculates rate as (last_value - first_value) / time_difference.
+
+Useful for detecting HVAC issues like temperature droop, defrost cycles, or rapid changes.
+
+### Configuration
+- Reset via `msg.context = "reset"` with `msg.payload = true`
+- Change sample size via `msg.context = "sampleSize"` with numeric payload
+- Change units via `msg.context = "units"` with "seconds", "minutes", or "hours"
+
+### Status
+- Shows current rate with units
+- Color indicates state change
+</script>

package/nodes/rate-of-change-block.js

@@ -0,0 +1,233 @@
+module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
+    function RateOfChangeNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Initialize runtime state
+        node.runtime = {
+            maxSamples: parseInt(config.sampleSize),
+            samples: [], // Array of {timestamp: Date, value: number}
+            units: config.units || "minutes", // minutes, seconds, hours
+            lastRate: null
+        };
+
+        // Evaluate typed-input properties    
+        try {     
+            node.runtime.minValid = parseFloat(RED.util.evaluateNodeProperty( config.minValid, config.minValidType, node ));
+            node.runtime.maxValid = parseFloat(RED.util.evaluateNodeProperty( config.maxValid, config.maxValidType, node ));
+        } catch (err) {
+            node.error(`Error evaluating properties: ${err.message}`);
+        }
+
+        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;
+            }    
+
+            // Update typed-input properties if needed
+            try {                    
+                if (utils.requiresEvaluation(config.minValidType)) {
+                    node.runtime.minValid = parseFloat(RED.util.evaluateNodeProperty( config.minValid, config.minValidType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.maxValidType)) {
+                    node.runtime.maxValid = parseFloat(RED.util.evaluateNodeProperty( config.maxValid, config.maxValidType, node, msg ));
+                }
+            } catch (err) {
+                node.error(`Error evaluating properties: ${err.message}`);
+                if (done) done();
+                return;
+            }
+
+            // Acceptable fallbacks
+            if (isNaN(node.runtime.maxSamples) || node.runtime.maxSamples < 2) {
+                node.runtime.maxSamples = 10;
+                node.status({ fill: "red", shape: "ring", text: "invalid sample size, using 10" });
+            }
+
+            // Validate values
+            if (isNaN(node.runtime.maxValid) || isNaN(node.runtime.minValid) || node.runtime.maxValid <= node.runtime.minValid ) {
+                node.status({ fill: "red", shape: "ring", text: `invalid evaluated values ${node.runtime.minValid}, ${node.runtime.maxValid}` });
+                if (done) done();
+                return;
+            }
+
+            // Handle configuration messages
+            if (msg.hasOwnProperty("context")) {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    if (done) done();
+                    return;
+                }
+                
+                switch (msg.context) {
+                    case "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.samples = [];
+                            node.runtime.lastRate = null;
+                            node.status({ fill: "green", shape: "dot", text: "state reset" });
+                        }
+                        break;
+                        
+                    case "sampleSize":
+                        let newMaxSamples = parseInt(msg.payload);
+                        if (isNaN(newMaxSamples) || newMaxSamples < 2) {
+                            node.status({ fill: "red", shape: "ring", text: "sample size must be at least 2" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.maxSamples = newMaxSamples;
+                        // Trim samples if new window is smaller
+                        if (node.runtime.samples.length > newMaxSamples) {
+                            node.runtime.samples = node.runtime.samples.slice(-newMaxSamples);
+                        }
+                        node.status({ fill: "green", shape: "dot", text: `samples: ${newMaxSamples}` });
+                        break;
+                        
+                    case "units":
+                        const validUnits = ["seconds", "minutes", "hours"];
+                        if (typeof msg.payload === "string" && validUnits.includes(msg.payload.toLowerCase())) {
+                            node.runtime.units = msg.payload.toLowerCase();
+                            node.status({ fill: "green", shape: "dot", text: `units: ${msg.payload}` });
+                        } else {
+                            node.status({ fill: "red", shape: "ring", text: "invalid units" });
+                        }
+                        break;
+                        
+                    default:
+                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        break;
+                }                
+                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 input
+            const inputValue = parseFloat(msg.payload);
+            const timestamp = msg.timestamp ? new Date(msg.timestamp) : new Date();
+            
+            if (isNaN(inputValue) || inputValue < node.runtime.minValid || inputValue > node.runtime.maxValid) {
+                node.status({ fill: "yellow", shape: "ring", text: "out of range" });
+                if (done) done();
+                return;
+            }
+
+            // Add new sample
+            node.runtime.samples.push({ timestamp: timestamp, value: inputValue });
+            
+            // Maintain sample window
+            if (node.runtime.samples.length > node.runtime.maxSamples + 1) {
+                node.runtime.samples = node.runtime.samples.slice(-node.runtime.maxSamples);
+            } else if (node.runtime.samples.length > node.runtime.maxSamples) {
+                node.runtime.samples.shift();
+            }
+
+            // Calculate rate of change (temperature per time unit)
+            let rate = null;
+            if (node.runtime.samples.length >= node.runtime.maxSamples) { // Need at least 3 points for good regression
+                const n = node.runtime.samples.length;
+                let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
+                
+                // Convert timestamps to relative time in the selected units
+                const baseTime = node.runtime.samples[0].timestamp;
+                let timeScale; // Conversion factor from ms to selected units
+                
+                switch (node.runtime.units) {
+                    case "seconds":
+                        timeScale = 1000; // ms to seconds
+                        break;
+                    case "minutes":
+                        timeScale = 1000 * 60; // ms to minutes
+                        break;
+                    case "hours":
+                        timeScale = 1000 * 60 * 60; // ms to hours
+                        break;
+                    default:
+                        timeScale = 1000 * 60; // default to minutes
+                }
+                
+                // Calculate regression sums
+                node.runtime.samples.forEach((sample, i) => {
+                    const x = (sample.timestamp - baseTime) / timeScale; // time in selected units
+                    const y = sample.value;
+                    
+                    sumX += x;
+                    sumY += y;
+                    sumXY += x * y;
+                    sumXX += x * x;
+                });
+                
+                // Calculate slope (rate of change) using linear regression formula
+                const denominator = n * sumXX - sumX * sumX;
+                
+                // Avoid division by zero - use original endpoint method if regression fails
+                if (Math.abs(denominator) > 1e-10) { // Small tolerance for floating point
+                    rate = (n * sumXY - sumX * sumY) / denominator;
+                } else {
+                    // Fallback to original endpoint method if regression is unstable
+                    const firstSample = node.runtime.samples[0];
+                    const lastSample = node.runtime.samples[node.runtime.samples.length - 1];
+                    const timeDiff = (lastSample.timestamp - firstSample.timestamp) / timeScale;
+                    rate = timeDiff > 0 ? (lastSample.value - firstSample.value) / timeDiff : 0;
+                }
+            }
+
+            const isUnchanged = rate === node.runtime.lastRate;
+
+            // Send new message
+            const unitsDisplay = {
+                seconds: "/sec",
+                minutes: "/min",
+                hours: "/hr"
+            };
+
+            node.status({ 
+                fill: "blue", 
+                shape: isUnchanged ? "ring" : "dot", 
+                text: `rate: ${rate !== null ? rate.toFixed(2) : "not ready"} ${unitsDisplay[node.runtime.units] || "/min"}`
+            });
+            
+            node.runtime.lastRate = rate;
+            
+            // Enhanced output with metadata
+            const outputMsg = {
+                payload: rate,
+                samples: node.runtime.samples.length,
+                units: `${unitsDisplay[node.runtime.units] || "/min"}`,
+                currentValue: inputValue,
+                timeSpan: node.runtime.samples.length >= 2 ? 
+                    (node.runtime.samples[node.runtime.samples.length - 1].timestamp - node.runtime.samples[0].timestamp) / 1000 : 0
+            };
+            
+            if (node.runtime.samples.length >= node.runtime.maxSamples) {
+                send(outputMsg);
+            }
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("rate-of-change-block", RateOfChangeNode);
+};

package/nodes/string-builder-block.html

@@ -0,0 +1,112 @@
+<!-- UI Template Section: Defines the edit dialog -->
+<script type="text/html" data-template-name="string-builder-block">
+    <div class="form-row">
+        <label for="node-input-name"><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-in1"><i class="fa fa-bars"></i> in1</label>
+        <input type="text" id="node-input-in1" placeholder="">
+        <input type="hidden" id="node-input-in1Type">
+    </div>
+    <div class="form-row">
+        <label for="node-input-in2"><i class="fa fa-bars"></i> in2</label>
+        <input type="text" id="node-input-in2" placeholder="">
+        <input type="hidden" id="node-input-in2Type">
+    </div>
+    <div class="form-row">
+        <label for="node-input-in3"><i class="fa fa-bars"></i> in3</label>
+        <input type="text" id="node-input-in3" placeholder="">
+        <input type="hidden" id="node-input-in3Type">
+    </div>
+    <div class="form-row">
+        <label for="node-input-in4"><i class="fa fa-bars"></i> in4</label>
+        <input type="text" id="node-input-in4" placeholder="">
+        <input type="hidden" id="node-input-in4Type">
+    </div>
+</script>
+
+
+<!-- JavaScript Section: Registers the node and handles editor logic -->
+<script type="text/javascript">
+    RED.nodes.registerType("string-builder-block", {
+    category: "control",
+    color: "#301934",
+    defaults: {
+        name: { value: "" },
+        in1: { value: "", required: false },
+        in1Type: { value: "str" },
+        in2: { value: "", required: false },
+        in2Type: { value: "str" },
+        in3: { value: "", required: false },
+        in3Type: { value: "str" },
+        in4: { value: "", required: false },
+        in4Type: { value: "str" },
+    },
+    inputs: 1,
+    outputs: 1,
+    inputLabels: ["input"],
+    outputLabels: ["output"],
+    icon: "font-awesome/fa-bars",
+    paletteLabel: "string builder",
+    label: function() {
+        return this.name || "string builder";
+    },
+    oneditprepare: function() {
+        const node = this;
+
+        try {
+            // Initialize typed inputs
+            $("#node-input-in1").typedInput({
+                default: "str",
+                types: ["str", "msg", "flow", "global"],
+                typeField: "#node-input-in1Type"
+            }).typedInput("type", node.in1Type || "str").typedInput("value", node.in1);
+
+            $("#node-input-in2").typedInput({
+                default: "str",
+                types: ["str", "msg", "flow", "global"],
+                typeField: "#node-input-in2Type"
+            }).typedInput("type", node.in2Type || "str").typedInput("value", node.in2);
+
+            $("#node-input-in3").typedInput({
+                default: "str",
+                types: ["str", "msg", "flow", "global"],
+                typeField: "#node-input-in3Type"
+            }).typedInput("type", node.in3Type || "str").typedInput("value", node.in3);
+
+            $("#node-input-in4").typedInput({
+                default: "str",
+                types: ["str", "msg", "flow", "global"],
+                typeField: "#node-input-in4Type"
+            }).typedInput("type", node.in4Type || "str").typedInput("value", node.in4);
+
+        } catch (err) {
+            console.error("Error in oneditprepare:", err);
+        }
+    }
+});
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="string-builder-block">
+Concatenates multiple string inputs into a single output string on any input.
+
+### Inputs
+: payload (number) : Input value to evaluate
+: context (string) : Configure `inX` string inputs via context variables
+
+### Outputs
+: output (string) : Each string input concatenated in order
+
+### 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/string-builder-block.js

@@ -0,0 +1,89 @@
+module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
+    function StringBuilderBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        node.name = config.name;
+
+        // Evaluate typed-input properties    
+        try {      
+            node.in1 = RED.util.evaluateNodeProperty( config.in1, config.in1Type, node );
+            node.in2 = RED.util.evaluateNodeProperty( config.in2, config.in2Type, node );
+            node.in3 = RED.util.evaluateNodeProperty( config.in3, config.in3Type, node );
+            node.in4 = RED.util.evaluateNodeProperty( config.in4, config.in4Type, node );
+        } catch (err) {
+            node.error(`Error evaluating properties: ${err.message}`);
+        }
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+            
+            // Update typed-input properties if needed
+            try {           
+                if (utils.requiresEvaluation(config.in1Type)) {
+                    node.in1 = RED.util.evaluateNodeProperty( config.in1, config.in1Type, node, msg );
+                }
+                if (utils.requiresEvaluation(config.in2Type)) {
+                    node.in2 = RED.util.evaluateNodeProperty( config.in2, config.in2Type, node, msg );
+                }
+                if (utils.requiresEvaluation(config.in3Type)) {
+                    node.in3 = RED.util.evaluateNodeProperty( config.in3, config.in3Type, node, msg );
+                }
+                if (utils.requiresEvaluation(config.in4Type)) {
+                    node.in4 = RED.util.evaluateNodeProperty( config.in4, config.in4Type, node, msg );
+                }
+            } catch (err) {
+                node.error(`Error evaluating properties: ${err.message}`);
+                if (done) done();
+                return;
+            }
+
+            // Check required properties
+            if (msg.hasOwnProperty("context")) {
+
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    if (done) done();
+                    return;
+                }
+
+                // Process input slot
+                if (msg.context.startsWith("in")) {
+                    let index = parseInt(msg.context.slice(2), 10);
+                    if (!isNaN(index) && index >= 1 && index <= 4) {
+                        if (config[`in${index}Type`] === "str") {
+                            node[`in${index}`] = msg.payload;
+                        } else {
+                            node.status({ fill: "red", shape: "ring", text: `Field type is ${config[`in${index}Type`]}` });
+                            if (done) done();
+                            return;
+                        }
+                    } else {
+                        node.status({ fill: "red", shape: "ring", text: `invalid input index ${index || "NaN"}` });
+                        if (done) done();
+                        return;
+                    }
+                }                
+            }
+
+            const output = { payload: `${node.in1}${node.in2}${node.in3}${node.in4}` };
+            node.status({ fill: "blue", shape: "dot", text: `${ output.payload }` });
+            send(output);
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("string-builder-block", StringBuilderBlockNode);
+};