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

package/nodes/load-sequence-block.js

@@ -1,43 +1,43 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
     function LoadSequenceBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name || "",
-            enable: config.enable,
-            hysteresis: parseFloat(config.hysteresis),
-            threshold1: parseFloat(config.threshold1),
-            threshold2: parseFloat(config.threshold2),
-            threshold3: parseFloat(config.threshold3),
-            threshold4: parseFloat(config.threshold4),
-            feedback1: config.feedback1,
-            feedback2: config.feedback2,
-            feedback3: config.feedback3,
-            feedback4: config.feedback4,
-            out1: false,
-            out2: false,
-            out3: false,
-            out4: false,
-            dOn: 0,
-            lastInput: 0,
-            lastOutputs: [false, false, false, false]
-        };
+        // Initialize state
+        node.name = config.name || "";
+        node.enable = config.enable;
+        node.hysteresis = parseFloat(config.hysteresis);
+        node.threshold1 = parseFloat(config.threshold1);
+        node.threshold2 = parseFloat(config.threshold2);
+        node.threshold3 = parseFloat(config.threshold3);
+        node.threshold4 = parseFloat(config.threshold4);
+        node.feedback1 = config.feedback1;
+        node.feedback2 = config.feedback2;
+        node.feedback3 = config.feedback3;
+        node.feedback4 = config.feedback4;
+        node.out1 = false;
+        node.out2 = false;
+        node.out3 = false;
+        node.out4 = false;
+        node.dOn = 0;
+        node.lastInput = 0;
+        node.lastOutputs = [false, false, false, false];
 
         // Validate initial config
-        if (isNaN(node.runtime.hysteresis) || node.runtime.hysteresis < 0) {
-            node.runtime.hysteresis = 0.5;
-            node.status({ fill: "red", shape: "ring", text: "invalid hysteresis" });
+        if (isNaN(node.hysteresis) || node.hysteresis < 0) {
+            node.hysteresis = 0.5;
+            utils.setStatusError(node, "invalid hysteresis");
         }
-        if (isNaN(node.runtime.threshold1) || isNaN(node.runtime.threshold2) || isNaN(node.runtime.threshold3) || isNaN(node.runtime.threshold4) ||
-            node.runtime.threshold1 < 0 || node.runtime.threshold2 < 0 || node.runtime.threshold3 < 0 || node.runtime.threshold4 < 0 ||
-            node.runtime.threshold1 >= node.runtime.threshold2 || node.runtime.threshold2 >= node.runtime.threshold3 || node.runtime.threshold3 >= node.runtime.threshold4) {
-            node.runtime.threshold1 = 10.0;
-            node.runtime.threshold2 = 20.0;
-            node.runtime.threshold3 = 30.0;
-            node.runtime.threshold4 = 40.0;
-            node.status({ fill: "red", shape: "ring", text: "invalid threshold order" });
+        if (isNaN(node.threshold1) || isNaN(node.threshold2) || isNaN(node.threshold3) || isNaN(node.threshold4) ||
+            node.threshold1 < 0 || node.threshold2 < 0 || node.threshold3 < 0 || node.threshold4 < 0 ||
+            node.threshold1 >= node.threshold2 || node.threshold2 >= node.threshold3 || node.threshold3 >= node.threshold4) {
+            node.threshold1 = 10.0;
+            node.threshold2 = 20.0;
+            node.threshold3 = 30.0;
+            node.threshold4 = 40.0;
+            utils.setStatusError(node, "invalid threshold order");
         }
 
         node.on("input", function(msg, send, done) {
@@ -45,7 +45,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;
             }
@@ -53,29 +53,29 @@ module.exports = function(RED) {
             // Handle configuration updates
             if (msg.hasOwnProperty("context")) {
                 if (!msg.hasOwnProperty("payload")) {
-                    node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+                    utils.setStatusError(node, `missing payload for ${msg.context}`);
                     if (done) done();
                     return;
                 }
                 switch (msg.context) {
                     case "enable":
                         if (typeof msg.payload !== "boolean") {
-                            node.status({ fill: "red", shape: "ring", text: "invalid enable" });
+                            utils.setStatusError(node, "invalid enable");
                             if (done) done();
                             return;
                         }
-                        node.runtime.enable = msg.payload;
-                        node.status({ fill: "green", shape: "dot", text: `enable: ${node.runtime.enable}` });
+                        node.enable = msg.payload;
+                        utils.setStatusOK(node, `enable: ${node.enable}`);
                         break;
                     case "hysteresis":
                         const hystValue = parseFloat(msg.payload);
                         if (isNaN(hystValue) || hystValue < 0) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid hysteresis" });
+                            utils.setStatusError(node, "invalid hysteresis");
                             if (done) done();
                             return;
                         }
-                        node.runtime.hysteresis = hystValue;
-                        node.status({ fill: "green", shape: "dot", text: `hysteresis: ${node.runtime.hysteresis}` });
+                        node.hysteresis = hystValue;
+                        utils.setStatusOK(node, `hysteresis: ${node.hysteresis}`);
                         break;
                     case "threshold1":
                     case "threshold2":
@@ -83,36 +83,36 @@ module.exports = function(RED) {
                     case "threshold4":
                         const threshValue = parseFloat(msg.payload);
                         if (isNaN(threshValue) || threshValue < 0) {
-                            node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
+                            utils.setStatusError(node, `invalid ${msg.context}`);
                             if (done) done();
                             return;
                         }
-                        const prevThresholds = [node.runtime.threshold1, node.runtime.threshold2, node.runtime.threshold3, node.runtime.threshold4];
+                        const prevThresholds = [node.threshold1, node.threshold2, node.threshold3, node.threshold4];
                         const index = parseInt(msg.context.replace("threshold", "")) - 1;
                         const newThresholds = [...prevThresholds];
                         newThresholds[index] = threshValue;
                         if (newThresholds[0] >= newThresholds[1] || newThresholds[1] >= newThresholds[2] || newThresholds[2] >= newThresholds[3]) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid threshold order" });
+                            utils.setStatusError(node, "invalid threshold order");
                             if (done) done();
                             return;
                         }
-                        node.runtime[`threshold${index + 1}`] = threshValue;
-                        node.status({ fill: "green", shape: "dot", text: `${msg.context}: ${threshValue}` });
+                        node[`threshold${index + 1}`] = threshValue;
+                        utils.setStatusOK(node, `${msg.context}: ${threshValue}`);
                         break;
                     case "feedback1":
                     case "feedback2":
                     case "feedback3":
                     case "feedback4":
                         if (typeof msg.payload !== "boolean") {
-                            node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
+                            utils.setStatusError(node, `invalid ${msg.context}`);
                             if (done) done();
                             return;
                         }
-                        node.runtime[msg.context] = msg.payload;
-                        node.status({ fill: "green", shape: "dot", text: `${msg.context}: ${msg.payload}` });
+                        node[msg.context] = msg.payload;
+                        utils.setStatusOK(node, `${msg.context}: ${msg.payload}`);
                         break;
                     default:
-                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        utils.setStatusWarn(node, "unknown context");
                         if (done) done("Unknown context");
                         return;
                 }
@@ -121,40 +121,40 @@ module.exports = function(RED) {
             // Handle input
             let inputValue;
             if (msg.hasOwnProperty("context")) {
-                inputValue = node.runtime.lastInput;
+                inputValue = node.lastInput;
             } else {
                 if (!msg.hasOwnProperty("payload")) {
-                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    utils.setStatusError(node, "missing payload");
                     if (done) done();
                     return;
                 }
                 if (msg.payload === "kill") {
-                    inputValue = node.runtime.lastInput;
+                    inputValue = node.lastInput;
                 } else {
                     inputValue = parseFloat(msg.payload);
                     if (isNaN(inputValue)) {
-                        node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+                        utils.setStatusError(node, "invalid payload");
                         if (done) done();
                         return;
                     }
-                    node.runtime.lastInput = inputValue;
+                    node.lastInput = inputValue;
                 }
             }
 
             // Kill switch
             if (msg.payload === "kill") {
-                node.runtime.out1 = node.runtime.out2 = node.runtime.out3 = node.runtime.out4 = false;
-                node.runtime.dOn = 0;
-                node.runtime.lastOutputs = [false, false, false, false];
-                node.status({ fill: "red", shape: "dot", text: "kill: all off" });
+                node.out1 = node.out2 = node.out3 = node.out4 = false;
+                node.dOn = 0;
+                node.lastOutputs = [false, false, false, false];
+                utils.setStatusError(node, "kill: all off");
                 send([{ payload: false }, { payload: false }, { payload: false }, { payload: false }]);
                 if (done) done();
                 return;
             }
 
             // Validate thresholds
-            if (node.runtime.threshold1 >= node.runtime.threshold2 || node.runtime.threshold2 >= node.runtime.threshold3 || node.runtime.threshold3 >= node.runtime.threshold4) {
-                node.status({ fill: "red", shape: "ring", text: "invalid threshold order" });
+            if (node.threshold1 >= node.threshold2 || node.threshold2 >= node.threshold3 || node.threshold3 >= node.threshold4) {
+                utils.setStatusError(node, "invalid threshold order");
                 if (done) done();
                 return;
             }
@@ -163,101 +163,93 @@ module.exports = function(RED) {
             let newMsg = [null, null, null, null];
             let numStagesOn = 0;
 
-            if (!node.runtime.enable) {
-                if (node.runtime.out4) {
-                    node.runtime.out4 = false;
+            if (!node.enable) {
+                if (node.out4) {
+                    node.out4 = false;
                     newMsg[3] = { payload: false };
-                } else if (node.runtime.out3) {
-                    node.runtime.out3 = false;
+                } else if (node.out3) {
+                    node.out3 = false;
                     newMsg[2] = { payload: false };
-                } else if (node.runtime.out2) {
-                    node.runtime.out2 = false;
+                } else if (node.out2) {
+                    node.out2 = false;
                     newMsg[1] = { payload: false };
-                } else if (node.runtime.out1) {
-                    node.runtime.out1 = false;
+                } else if (node.out1) {
+                    node.out1 = false;
                     newMsg[0] = { payload: false };
                 }
                 numStagesOn = 0;
             } else {
-                let newOut1 = node.runtime.out1;
-                let newOut2 = node.runtime.out2;
-                let newOut3 = node.runtime.out3;
-                let newOut4 = node.runtime.out4;
+                let newOut1 = node.out1;
+                let newOut2 = node.out2;
+                let newOut3 = node.out3;
+                let newOut4 = node.out4;
 
                 // Output 1
-                if (node.runtime.out1) {
-                    if (inputValue < (node.runtime.threshold1 - node.runtime.hysteresis) && (node.runtime.feedback1 && !node.runtime.out2)) {
+                if (node.out1) {
+                    if (inputValue < (node.threshold1 - node.hysteresis) && (node.feedback1 && !node.out2)) {
                         newOut1 = false;
                     }
-                } else if (inputValue >= node.runtime.threshold1) {
+                } else if (inputValue >= node.threshold1) {
                     newOut1 = true;
                 }
 
                 // Output 2
-                if (node.runtime.out2) {
-                    if (inputValue < (node.runtime.threshold2 - node.runtime.hysteresis) && (node.runtime.feedback2 && !node.runtime.out3)) {
+                if (node.out2) {
+                    if (inputValue < (node.threshold2 - node.hysteresis) && (node.feedback2 && !node.out3)) {
                         newOut2 = false;
                     }
-                } else if (inputValue >= node.runtime.threshold2 && node.runtime.feedback1) {
+                } else if (inputValue >= node.threshold2 && node.feedback1) {
                     newOut2 = true;
                 }
 
                 // Output 3
-                if (node.runtime.out3) {
-                    if (inputValue < (node.runtime.threshold3 - node.runtime.hysteresis) && (node.runtime.feedback3 && !node.runtime.out4)) {
+                if (node.out3) {
+                    if (inputValue < (node.threshold3 - node.hysteresis) && (node.feedback3 && !node.out4)) {
                         newOut3 = false;
                     }
-                } else if (inputValue >= node.runtime.threshold3 && node.runtime.feedback2) {
+                } else if (inputValue >= node.threshold3 && node.feedback2) {
                     newOut3 = true;
                 }
 
                 // Output 4
-                if (node.runtime.out4) {
-                    if (inputValue < (node.runtime.threshold4 - node.runtime.hysteresis) && node.runtime.feedback4) {
+                if (node.out4) {
+                    if (inputValue < (node.threshold4 - node.hysteresis) && node.feedback4) {
                         newOut4 = false;
                     }
-                } else if (inputValue >= node.runtime.threshold4 && node.runtime.feedback3) {
+                } else if (inputValue >= node.threshold4 && node.feedback3) {
                     newOut4 = true;
                 }
 
                 // Prioritize lowest stage change
-                if (newOut1 !== node.runtime.out1) {
-                    node.runtime.out1 = newOut1;
-                    newMsg = [{ payload: node.runtime.out1 }, null, null, null];
-                } else if (newOut2 !== node.runtime.out2) {
-                    node.runtime.out2 = newOut2;
-                    newMsg = [null, { payload: node.runtime.out2 }, null, null];
-                } else if (newOut3 !== node.runtime.out3) {
-                    node.runtime.out3 = newOut3;
-                    newMsg = [null, null, { payload: node.runtime.out3 }, null];
-                } else if (newOut4 !== node.runtime.out4) {
-                    node.runtime.out4 = newOut4;
-                    newMsg = [null, null, null, { payload: node.runtime.out4 }];
+                if (newOut1 !== node.out1) {
+                    node.out1 = newOut1;
+                    newMsg = [{ payload: node.out1 }, null, null, null];
+                } else if (newOut2 !== node.out2) {
+                    node.out2 = newOut2;
+                    newMsg = [null, { payload: node.out2 }, null, null];
+                } else if (newOut3 !== node.out3) {
+                    node.out3 = newOut3;
+                    newMsg = [null, null, { payload: node.out3 }, null];
+                } else if (newOut4 !== node.out4) {
+                    node.out4 = newOut4;
+                    newMsg = [null, null, null, { payload: node.out4 }];
                 }
 
-                numStagesOn = (node.runtime.out1 ? 1 : 0) + (node.runtime.out2 ? 1 : 0) + (node.runtime.out3 ? 1 : 0) + (node.runtime.out4 ? 1 : 0);
+                numStagesOn = (node.out1 ? 1 : 0) + (node.out2 ? 1 : 0) + (node.out3 ? 1 : 0) + (node.out4 ? 1 : 0);
             }
 
             // Update state
-            node.runtime.dOn = numStagesOn;
+            node.dOn = numStagesOn;
 
             // Check if outputs changed
-            const outputsChanged = newMsg.some((msg, i) => msg !== null && msg.payload !== node.runtime.lastOutputs[i]);
-            node.runtime.lastOutputs = [node.runtime.out1, node.runtime.out2, node.runtime.out3, node.runtime.out4];
+            const outputsChanged = newMsg.some((msg, i) => msg !== null && msg.payload !== node.lastOutputs[i]);
+            node.lastOutputs = [node.out1, node.out2, node.out3, node.out4];
 
             if (outputsChanged) {
-                node.status({
-                    fill: "blue",
-                    shape: "dot",
-                    text: `in: ${inputValue.toFixed(2)}, out: [${node.runtime.out1}, ${node.runtime.out2}, ${node.runtime.out3}, ${node.runtime.out4}]`
-                });
+                utils.setStatusChanged(node, `in: ${inputValue.toFixed(2)}, out: [${node.out1}, ${node.out2}, ${node.out3}, ${node.out4}]`);
                 send(newMsg);
             } else {
-                node.status({
-                    fill: "blue",
-                    shape: "ring",
-                    text: `in: ${inputValue.toFixed(2)}, out: [${node.runtime.out1}, ${node.runtime.out2}, ${node.runtime.out3}, ${node.runtime.out4}]`
-                });
+                utils.setStatusUnchanged(node, `in: ${inputValue.toFixed(2)}, out: [${node.out1}, ${node.out2}, ${node.out3}, ${node.out4}]`);
             }
 
             if (done) done();

package/nodes/max-block.js

@@ -7,10 +7,9 @@ module.exports = function(RED) {
         node.isBusy = false;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            max: parseFloat(config.max)
-        };
+        // Initialize state
+        node.name = config.name;
+        node.max = parseFloat(config.max);
 
         // Store last output value for status
         let lastOutput = null;
@@ -20,7 +19,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,7 +30,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;
                 }
@@ -46,13 +45,13 @@ module.exports = function(RED) {
                     utils.requiresEvaluation(config.maxType) 
                         ? utils.evaluateNodeProperty(config.max, config.maxType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.runtime.max),
+                        : Promise.resolve(node.max),
                 );
 
                 const results = await Promise.all(evaluations);   
 
                 // Update runtime with evaluated values
-                if (!isNaN(results[0])) node.runtime.max = results[0];       
+                if (!isNaN(results[0])) node.max = results[0];       
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();
@@ -63,8 +62,8 @@ module.exports = function(RED) {
             }
 
             // Validate values
-            if (isNaN(node.runtime.max)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid evaluated values" });
+            if (isNaN(node.max)) {
+                utils.setStatusError(node, "invalid evaluated values");
                 if (done) done();
                 return;
             }
@@ -72,23 +71,22 @@ module.exports = function(RED) {
             // Handle context updates
             if (msg.hasOwnProperty("context")) {
                 if (!msg.hasOwnProperty("payload")) {
-                    node.status({ fill: "red", shape: "ring", text: "missing payload for max" });
+                    utils.setStatusError(node, "missing payload for max");
                     if (done) done();
                     return;
                 }
                 if (msg.context === "max" || msg.context === "setpoint") {
                     const maxValue = parseFloat(msg.payload);
                     if (!isNaN(maxValue) && maxValue >= 0) {
-                        node.runtime.max = maxValue;
-                        node.status({ fill: "green", shape: "dot", text: `max: ${maxValue}`
-                        });
+                        node.max = maxValue;
+                        utils.setStatusOK(node, `max: ${maxValue}`);
                     } else {
-                        node.status({ fill: "red", shape: "ring", text: "invalid max" });
+                        utils.setStatusError(node, "invalid max");
                     }
                     if (done) done();
                     return;
                 } else {
-                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    utils.setStatusWarn(node, "unknown context");
                     if (done) done();
                     return;
                 }
@@ -96,28 +94,30 @@ module.exports = function(RED) {
 
             // Validate input payload
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
                 if (done) done();
                 return;
             }
 
-            const inputValue = parseFloat(msg.payload);
-            if (isNaN(inputValue)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+            const numVal = utils.validateNumericPayload(msg.payload);
+            if (!numVal.valid) {
+                utils.setStatusError(node, numVal.error);
                 if (done) done();
                 return;
             }
+            const inputValue = numVal.value;
 
             // Cap input at max
-            const outputValue = Math.min(inputValue, node.runtime.max);
+            const outputValue = Math.min(inputValue, node.max);
 
             // Update status and send output
             msg.payload = outputValue;
-            node.status({
-                fill: "blue",
-                shape: lastOutput === outputValue ? "ring" : "dot",
-                text: `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`
-            });
+            const statusText = `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`;
+            if (lastOutput === outputValue) {
+                utils.setStatusUnchanged(node, statusText);
+            } else {
+                utils.setStatusChanged(node, statusText);
+            }
             lastOutput = outputValue;
             send(msg);