@bldgblocks/node-red-contrib-control 0.1.34 → 0.1.36

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

@@ -6,22 +6,21 @@ module.exports = function(RED) {
         const node = this;
         node.isBusy = false;
         
-        // 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,
-            minValid: parseFloat(config.minValid),
-            maxValid: parseFloat(config.maxValid)
-        };
+        // Initialize state
+        node.maxSamples = parseInt(config.sampleSize);
+        node.inputProperty = config.inputProperty || "payload";
+        node.samples = []; // Array of {timestamp: Date, value: number}
+        node.units = config.units || "minutes"; // minutes, seconds, hours
+        node.lastRate = null;
+        node.minValid = parseFloat(config.minValid);
+        node.maxValid = parseFloat(config.maxValid);
 
         node.on("input", async 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" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }    
@@ -32,7 +31,7 @@ module.exports = function(RED) {
                 // Check busy lock
                 if (node.isBusy) {
                     // Update status to let user know they are pushing too fast
-                    node.status({ fill: "yellow", shape: "ring", text: "busy - dropped msg" });
+                    utils.setStatusBusy(node, "busy - dropped msg");
                     if (done) done(); 
                     return;
                 }
@@ -47,21 +46,21 @@ module.exports = function(RED) {
                     utils.requiresEvaluation(config.minValidType) 
                         ? utils.evaluateNodeProperty(config.minValid, config.minValidType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.runtime.minValid),
+                        : Promise.resolve(node.minValid),
                 );
 
                 evaluations.push(
                     utils.requiresEvaluation(config.maxValidType) 
                         ? utils.evaluateNodeProperty(config.maxValid, config.maxValidType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.runtime.maxValid),
+                        : Promise.resolve(node.maxValid),
                 );
 
                 const results = await Promise.all(evaluations);   
 
                 // Update runtime with evaluated values
-                if (!isNaN(results[0])) node.runtime.minValid = results[0];
-                if (!isNaN(results[1])) node.runtime.maxValid = results[1];   
+                if (!isNaN(results[0])) node.minValid = results[0];
+                if (!isNaN(results[1])) node.maxValid = results[1];   
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();
@@ -72,14 +71,14 @@ module.exports = function(RED) {
             }
 
             // 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" });
+            if (isNaN(node.maxSamples) || node.maxSamples < 2) {
+                node.maxSamples = 10;
+                utils.setStatusError(node, "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 (isNaN(node.maxValid) || isNaN(node.minValid) || node.maxValid <= node.minValid ) {
+                utils.setStatusError(node, `invalid evaluated values ${node.minValid}, ${node.maxValid}`);
                 if (done) done();
                 return;
             }
@@ -87,7 +86,7 @@ module.exports = function(RED) {
             // Handle configuration messages
             if (msg.hasOwnProperty("context")) {
                 if (!msg.hasOwnProperty("payload")) {
-                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    utils.setStatusError(node, "missing payload");
                     if (done) done();
                     return;
                 }
@@ -95,44 +94,44 @@ module.exports = function(RED) {
                 switch (msg.context) {
                     case "reset":
                         if (typeof msg.payload !== "boolean") {
-                            node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                            utils.setStatusError(node, "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" });
+                            node.samples = [];
+                            node.lastRate = null;
+                            utils.setStatusOK(node, "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" });
+                            utils.setStatusError(node, "sample size must be at least 2");
                             if (done) done();
                             return;
                         }
-                        node.runtime.maxSamples = newMaxSamples;
+                        node.maxSamples = newMaxSamples;
                         // Trim samples if new window is smaller
-                        if (node.runtime.samples.length > newMaxSamples) {
-                            node.runtime.samples = node.runtime.samples.slice(-newMaxSamples);
+                        if (node.samples.length > newMaxSamples) {
+                            node.samples = node.samples.slice(-newMaxSamples);
                         }
-                        node.status({ fill: "green", shape: "dot", text: `samples: ${newMaxSamples}` });
+                        utils.setStatusOK(node, `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}` });
+                            node.units = msg.payload.toLowerCase();
+                            utils.setStatusOK(node, `units: ${msg.payload}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid units" });
+                            utils.setStatusError(node, "invalid units");
                         }
                         break;
                         
                     default:
-                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        utils.setStatusWarn(node, "unknown context");
                         break;
                 }                
                 if (done) done();
@@ -141,44 +140,57 @@ module.exports = function(RED) {
 
             // Check for missing payload
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
+                if (done) done();
+                return;
+            }
+
+            // Get input from configured property
+            let input;
+            try {
+                input = RED.util.getMessageProperty(msg, node.inputProperty);
+            } catch (err) {
+                input = undefined;
+            }
+            if (input === undefined) {
+                utils.setStatusError(node, "missing or invalid input property");
                 if (done) done();
                 return;
             }
 
             // Process input
-            const inputValue = parseFloat(msg.payload);
+            const inputValue = parseFloat(input);
             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 (isNaN(inputValue) || inputValue < node.minValid || inputValue > node.maxValid) {
+                utils.setStatusWarn(node, "out of range");
                 if (done) done();
                 return;
             }
 
             // Add new sample
-            node.runtime.samples.push({ timestamp: timestamp, value: inputValue });
+            node.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();
+            if (node.samples.length > node.maxSamples + 1) {
+                node.samples = node.samples.slice(-node.maxSamples);
+            } else if (node.samples.length > node.maxSamples) {
+                node.samples.shift();
             }
 
             // Calculate rate of change (temperature per time unit)
             let rate = null;
             // Require at least 20% of samples for calculation
-            if (node.runtime.samples.length >= node.runtime.maxSamples * 0.20) { 
+            if (node.samples.length >= node.maxSamples * 0.20) { 
                 // Use linear regression for more stable rate calculation
-                const n = node.runtime.samples.length;
+                const n = node.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;
+                const baseTime = node.samples[0].timestamp;
                 let timeScale; // Conversion factor from ms to selected units
                 
-                switch (node.runtime.units) {
+                switch (node.units) {
                     case "seconds":
                         timeScale = 1000; // ms to seconds
                         break;
@@ -193,7 +205,7 @@ module.exports = function(RED) {
                 }
                 
                 // Calculate regression sums
-                node.runtime.samples.forEach((sample, i) => {
+                node.samples.forEach((sample, i) => {
                     // Time in selected units
                     const x = (sample.timestamp - baseTime) / timeScale;
                     const y = sample.value;
@@ -212,14 +224,14 @@ module.exports = function(RED) {
                     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 firstSample = node.samples[0];
+                    const lastSample = node.samples[node.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;
+            const isUnchanged = rate === node.lastRate;
 
             // Send new message
             const unitsDisplay = {
@@ -228,25 +240,25 @@ module.exports = function(RED) {
                 hours: "/hr"
             };
 
-            node.status({ 
-                fill: "blue", 
-                shape: isUnchanged ? "ring" : "dot", 
-                text: `rate: ${rate !== null ? rate.toFixed(2) : "not ready"} ${unitsDisplay[node.runtime.units] || "/min"}`
-            });
+            if (isUnchanged) {
+                utils.setStatusUnchanged(node, `rate: ${rate !== null ? rate.toFixed(2) : "not ready"} ${unitsDisplay[node.units] || "/min"}`);
+            } else {
+                utils.setStatusChanged(node, `rate: ${rate !== null ? rate.toFixed(2) : "not ready"} ${unitsDisplay[node.units] || "/min"}`);
+            }
             
-            node.runtime.lastRate = rate;
+            node.lastRate = rate;
             
             // Enhanced output with metadata
             const outputMsg = {
                 payload: rate,
-                samples: node.runtime.samples.length,
-                units: `${unitsDisplay[node.runtime.units] || "/min"}`,
+                samples: node.samples.length,
+                units: `${unitsDisplay[node.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
+                timeSpan: node.samples.length >= 2 ? 
+                    (node.samples[node.samples.length - 1].timestamp - node.samples[0].timestamp) / 1000 : 0
             };
             
-            if (node.runtime.samples.length >= node.runtime.maxSamples) {
+            if (node.samples.length >= node.maxSamples) {
                 send(outputMsg);
             }
 

package/nodes/round-block.html

@@ -4,6 +4,10 @@
         <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-inputProperty" title="Message property to read input from"><i class="fa fa-folder-open"></i> Input Property</label>
+        <input type="text" id="node-input-inputProperty" placeholder="payload">
+    </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">
@@ -22,6 +26,7 @@
         color: "#301934",
         defaults: {
             name: { value: "" },
+            inputProperty: { value: "payload" },
             precision: { value: "0.01", required: true }
         },
         inputs: 1,
@@ -38,10 +43,10 @@
 
 <!-- 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).
+Rounds a float to the nearest configurable precision (tenth, half, or whole number).
 
 ### Inputs
-: payload (number) : Float to round.
+: input-property (number) : Float to round, read from the configured Input Property.
 : context (string, optional) : Action (`"precision"` to set precision). Unknown `msg.context` values are ignored.
 : payload (string, for `"precision"`) : Precision value
 
@@ -50,16 +55,16 @@ Rounds a float in `msg.payload` to the nearest configurable precision (tenth, ha
 
 ### Properties
 : name (string) : Display name in editor.
+: inputProperty (string) : Message property to read input from (default: `payload`). Supports nested properties (e.g., `data.value`).
 : precision (string) : Rounding precision
 
 ### Details
-Rounds a float in `msg.payload` to the nearest hundreth (0.01), 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.
+Rounds a float to the nearest hundreth (0.01), tenth (0.1), half (0.5), or whole number (1.0), set via editor or `msg.context = "precision"`.
+- Reads input from the message property specified in the **Input Property** field (default: `msg.payload`)
+- Output is always written to `msg.payload`
+- Operates as a passthrough node, modifying `msg.payload` and forwarding the original message
+- If input is not a finite number, the message is passed unchanged
+- Unknown `msg.context` values are ignored
 
 ### Status
 - Green (dot): Configuration update

package/nodes/round-block.js

@@ -1,21 +1,21 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function RoundBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
-        // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            precision: config.precision
-        };
+        // Initialize state
+        node.inputProperty = config.inputProperty || "payload";
+        node.precision = config.precision;
 
         // Validate initial config
         const validPrecisions = ["0.01", "0.1", "0.5", "1.0"];
-        if (!validPrecisions.includes(node.runtime.precision)) {
-            node.runtime.precision = "1.0";
-            node.status({ fill: "red", shape: "ring", text: "invalid precision, using 1.0" });
+        if (!validPrecisions.includes(node.precision)) {
+            node.precision = "1.0";
+            utils.setStatusError(node, "invalid precision, using 1.0");
         } else {
-            node.status({ fill: "green", shape: "dot", text: `name: ${node.runtime.name || "round"}, precision: ${node.runtime.precision}` });
+            utils.setStatusOK(node, `name: ${config.name || "round"}, precision: ${node.precision}`);
         }
 
         node.on("input", function(msg, send, done) {
@@ -23,7 +23,7 @@ module.exports = function(RED) {
 
             // Guard against invalid message
             if (!msg) {
-                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }
@@ -31,53 +31,60 @@ module.exports = function(RED) {
             // Handle precision configuration
             if (msg.hasOwnProperty("context") && msg.context === "precision") {
                 if (!msg.hasOwnProperty("payload")) {
-                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    utils.setStatusError(node, "missing payload");
                     if (done) done();
                     return;
                 }
                 const newPrecision = String(msg.payload);
                 if (!validPrecisions.includes(newPrecision)) {
-                    node.status({ fill: "red", shape: "ring", text: "invalid precision" });
+                    utils.setStatusError(node, "invalid precision");
                     if (done) done();
                     return;
                 }
-                node.runtime.precision = newPrecision;
-                node.status({ fill: "green", shape: "dot", text: `precision: ${newPrecision}` });
+                node.precision = newPrecision;
+                utils.setStatusOK(node, `precision: ${newPrecision}`);
                 if (done) done();
                 return;
             }
 
             // Passthrough: Process payload if numeric, else pass unchanged
-            if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+            let input;
+            try {
+                input = RED.util.getMessageProperty(msg, node.inputProperty);
+            } catch (err) {
+                input = undefined;
+            }
+            if (input === undefined) {
+                utils.setStatusError(node, "missing or invalid input property");
                 send(msg);
                 if (done) done();
                 return;
             }
 
-            const input = parseFloat(msg.payload);
-            if (isNaN(input) || !isFinite(input)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+            const numVal = utils.validateNumericPayload(input);
+            if (!numVal.valid) {
+                utils.setStatusError(node, numVal.error);
                 send(msg);
                 if (done) done();
                 return;
             }
+            const inputValue = numVal.value;
 
             // Round based on precision
             let result;
-            const precision = parseFloat(node.runtime.precision);
+            const precision = parseFloat(node.precision);
             if (precision === 0.01) {
-                result = Math.round(input * 100) / 100;
+                result = Math.round(inputValue * 100) / 100;
             } else if (precision === 0.1) {
-                result = Math.round(input * 10) / 10;
+                result = Math.round(inputValue * 10) / 10;
             } else if (precision === 0.5) {
-                result = Math.round(input / 0.5) * 0.5;
+                result = Math.round(inputValue / 0.5) * 0.5;
             } else {
-                result = Math.round(input);
+                result = Math.round(inputValue);
             }
 
             msg.payload = result;
-            node.status({ fill: "blue", shape: "dot", text: `in: ${input.toFixed(2)}, out: ${result}` });
+            utils.setStatusOK(node, `in: ${inputValue.toFixed(3)}, out: ${result}`);
             send(msg);
             if (done) done();
         });