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

package/nodes/tstat-block.js

@@ -10,24 +10,20 @@ module.exports = function(RED) {
         node.algorithm = config.algorithm;
         node.name = config.name;
 
-        function shouldEvaluate(type) { return type === "flow" || type === "global" || type === "msg"; }
-
-        const typedProperties = ['setpoint', 'heatingSetpoint', 'coolingSetpoint', 'coolingOn', 'coolingOff', 
-            'heatingOff', 'heatingOn', 'diff', 'anticipator', 'ignoreAnticipatorCycles'];
-
         // Evaluate typed-input properties    
         try {            
-            const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, null, true);
-            node.setpoint = parseFloat(evaluatedValues.setpoint);
-            node.heatingSetpoint = parseFloat(evaluatedValues.heatingSetpoint);
-            node.coolingSetpoint = parseFloat(evaluatedValues.coolingSetpoint);
-            node.coolingOn = parseFloat(evaluatedValues.coolingOn);
-            node.coolingOff = parseFloat(evaluatedValues.coolingOff);
-            node.heatingOff = parseFloat(evaluatedValues.heatingOff);
-            node.heatingOn = parseFloat(evaluatedValues.heatingOn);
-            node.diff = parseFloat(evaluatedValues.diff);
-            node.anticipator = parseFloat(evaluatedValues.anticipator);
-            node.ignoreAnticipatorCycles = Math.floor(evaluatedValues.ignoreAnticipatorCycles);
+            node.setpoint = parseFloat(RED.util.evaluateNodeProperty( config.setpoint, config.setpointType, node ));
+            node.heatingSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.heatingSetpoint, config.heatingSetpointType, node ));
+            node.coolingSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.coolingSetpoint, config.coolingSetpointType, node ));
+            node.coolingOn = parseFloat(RED.util.evaluateNodeProperty( config.coolingOn, config.coolingOnType, node ));
+            node.coolingOff = parseFloat(RED.util.evaluateNodeProperty( config.coolingOff, config.coolingOffType, node ));
+            node.heatingOff = parseFloat(RED.util.evaluateNodeProperty( config.heatingOff, config.heatingOffType, node ));
+            node.heatingOn = parseFloat(RED.util.evaluateNodeProperty( config.heatingOn, config.heatingOnType, node ));
+            node.diff = parseFloat(RED.util.evaluateNodeProperty( config.diff, config.diffType, node ));
+            node.anticipator = parseFloat(RED.util.evaluateNodeProperty( config.anticipator, config.anticipatorType, node ));
+            node.ignoreAnticipatorCycles = Math.floor(RED.util.evaluateNodeProperty( config.ignoreAnticipatorCycles, config.ignoreAnticipatorCyclesType, node )); 
+            node.isHeating = RED.util.evaluateNodeProperty( config.isHeating, config.isHeatingType, node ) === true;       
+            node.algorithm = RED.util.evaluateNodeProperty( config.algorithm, config.algorithmType, node );
         } catch (err) {
             node.error(`Error evaluating properties: ${err.message}`);
         }
@@ -51,17 +47,42 @@ module.exports = function(RED) {
             
             // Update typed-input properties if needed
             try {      
-                const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, msg);
-                node.setpoint = parseFloat(evaluatedValues.setpoint);
-                node.heatingSetpoint = parseFloat(evaluatedValues.heatingSetpoint);
-                node.coolingSetpoint = parseFloat(evaluatedValues.coolingSetpoint);
-                node.coolingOn = parseFloat(evaluatedValues.coolingOn);
-                node.coolingOff = parseFloat(evaluatedValues.coolingOff);
-                node.heatingOff = parseFloat(evaluatedValues.heatingOff);
-                node.heatingOn = parseFloat(evaluatedValues.heatingOn);
-                node.diff = parseFloat(evaluatedValues.diff);
-                node.anticipator = parseFloat(evaluatedValues.anticipator);
-                node.ignoreAnticipatorCycles = Math.floor(evaluatedValues.ignoreAnticipatorCycles);
+                if (utils.requiresEvaluation(config.setpointType)) {
+                    node.setpoint = parseFloat(RED.util.evaluateNodeProperty( config.setpoint, config.setpointType, node, msg ));                    
+                }
+                if (utils.requiresEvaluation(config.heatingSetpointType)) {
+                    node.heatingSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.heatingSetpoint, config.heatingSetpointType, node, msg ));                    
+                }
+                if (utils.requiresEvaluation(config.coolingSetpointType)) {
+                    node.coolingSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.coolingSetpoint, config.coolingSetpointType, node, msg ));                    
+                }
+                if (utils.requiresEvaluation(config.coolingOnType)) {
+                    node.coolingOn = parseFloat(RED.util.evaluateNodeProperty( config.coolingOn, config.coolingOnType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.coolingOffType)) {
+                    node.coolingOff = parseFloat(RED.util.evaluateNodeProperty( config.coolingOff, config.coolingOffType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.heatingOffType)) {
+                    node.heatingOff = parseFloat(RED.util.evaluateNodeProperty( config.heatingOff, config.heatingOffType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.heatingOnType)) {
+                    node.heatingOn = parseFloat(RED.util.evaluateNodeProperty( config.heatingOn, config.heatingOnType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.diffType)) {
+                    node.diff = parseFloat(RED.util.evaluateNodeProperty( config.diff, config.diffType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.anticipatorType)) {
+                    node.anticipator = parseFloat(RED.util.evaluateNodeProperty( config.anticipator, config.anticipatorType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.ignoreAnticipatorCyclesType)) {
+                    node.ignoreAnticipatorCycles = Math.floor(RED.util.evaluateNodeProperty( config.ignoreAnticipatorCycles, config.ignoreAnticipatorCyclesType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.isHeatingType)) {
+                    node.isHeating = RED.util.evaluateNodeProperty( config.isHeating, config.isHeatingType, node, msg ) === true;       
+                }
+                if (utils.requiresEvaluation(config.algorithmType)) {
+                    node.algorithm = RED.util.evaluateNodeProperty( config.algorithm, config.algorithmType, node, msg );
+                }
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();
@@ -184,14 +205,14 @@ module.exports = function(RED) {
             }
 
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing input" });
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
                 if (done) done();
                 return;
             }
 
             const input = parseFloat(msg.payload);
             if (isNaN(input)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
                 if (done) done();
                 return;
             }
@@ -223,31 +244,52 @@ module.exports = function(RED) {
 
             lastAbove = above;
             lastBelow = below;
+            let delta = 0;
+            let hiValue = 0;
+            let loValue = 0;
+            let hiOffValue = 0;
+            let loOffValue = 0;
+            let activeHeatingSetpoint = 0;
+            let activeCoolingSetpoint = 0;
 
             // Main thermostat logic
+            // The Tstat node does not control heating/cooling mode, only operates heating or cooling according to the mode set and respective setpoints.
             if (node.algorithm === "single") {
-                const delta = node.diff / 2;
-                const hiValue = node.setpoint + delta;
-                const loValue = node.setpoint - delta;
-                const hiOffValue = node.setpoint + effectiveAnticipator;
-                const loOffValue = node.setpoint - effectiveAnticipator;
+                // Note:
+                // Make sure your mode selection is handled upstream and does not osciallate modes.
+                // This was changed to allow for broader anticipator authority, or even negative (overshoot) so duty cycle can be better managed.
+                // So the same setpoint can be used year round and maintain tight control. 
+                // Alternatively, you would need a larger diff value to prevent oscillation.
+                delta = node.diff / 2;
+                hiValue = node.setpoint + delta;
+                loValue = node.setpoint - delta;
+                hiOffValue = node.setpoint + effectiveAnticipator;
+                loOffValue = node.setpoint - effectiveAnticipator;
+                activeHeatingSetpoint = node.setpoint;
+                activeCoolingSetpoint = node.setpoint;
 
-                if (input > hiValue) {
-                    above = true;
-                    below = false;
-                } else if (input < loValue) {
-                    above = false;
-                    below = true;
-                } else if (above && input < hiOffValue) {
+                if (isHeating) {
+                    if (input < loValue) {
+                        below = true;
+                    } else if (below && input > loOffValue) {
+                        below = false;
+                    }
                     above = false;
-                } else if (below && input > loOffValue) {
+                } else {
+                    if (input > hiValue) {
+                        above = true;
+                    } else if (above && input < hiOffValue) {
+                        above = false;
+                    }
                     below = false;
                 }
             } else if (node.algorithm === "split") {
+                    activeHeatingSetpoint = node.heatingSetpoint;
+                    activeCoolingSetpoint = node.coolingSetpoint;
                 if (node.isHeating) {
-                    const delta = node.diff / 2;
-                    const loValue = node.heatingSetpoint - delta;
-                    const loOffValue = node.heatingSetpoint - effectiveAnticipator;
+                    delta = node.diff / 2;
+                    loValue = node.heatingSetpoint - delta;
+                    loOffValue = node.heatingSetpoint - effectiveAnticipator;
 
                     if (input < loValue) {
                         below = true;
@@ -256,9 +298,9 @@ module.exports = function(RED) {
                     }
                     above = false;
                 } else {
-                    const delta = node.diff / 2;
-                    const hiValue = node.coolingSetpoint + delta;
-                    const hiOffValue = node.coolingSetpoint + effectiveAnticipator;
+                    delta = node.diff / 2;
+                    hiValue = node.coolingSetpoint + delta;
+                    hiOffValue = node.coolingSetpoint + effectiveAnticipator;
 
                     if (input > hiValue) {
                         above = true;
@@ -268,6 +310,8 @@ module.exports = function(RED) {
                     below = false;
                 }
             } else if (node.algorithm === "specified") {
+                activeHeatingSetpoint = node.heatingOn;
+                activeCoolingSetpoint = node.coolingOn;
                 if (node.isHeating) {
                     if (input < node.heatingOn) {
                         below = true;
@@ -298,20 +342,25 @@ module.exports = function(RED) {
             };
 
             // Add algorithm-specific status
+            statusInfo.activeHeatingSetpoint = activeHeatingSetpoint;
+            statusInfo.activeCoolingSetpoint = activeCoolingSetpoint;
+            statusInfo.diff = node.diff;
+            statusInfo.anticipator = node.anticipator;
+            statusInfo.loValue = loValue;
+            statusInfo.hiValue = hiValue;
+            statusInfo.loOffValue = loOffValue;
+            statusInfo.hiOffValue = hiOffValue;
+
             if (node.algorithm === "single") {
                 statusInfo.setpoint = node.setpoint;
-                statusInfo.diff = node.diff;
-                statusInfo.anticipator = node.anticipator;
             } else if (node.algorithm === "split") {
                 statusInfo.heatingSetpoint = node.heatingSetpoint;
                 statusInfo.coolingSetpoint = node.coolingSetpoint;
-                statusInfo.diff = node.diff;
-                statusInfo.anticipator = node.anticipator;
             } else {
-                statusInfo.coolingOn = node.coolingOn;
-                statusInfo.coolingOff = node.coolingOff;
-                statusInfo.heatingOff = node.heatingOff;
-                statusInfo.heatingOn = node.heatingOn;
+                statusInfo.hiValue = node.coolingOn;
+                statusInfo.hiOffValue = node.coolingOff;
+                statusInfo.loOffValue = node.heatingOff;
+                statusInfo.loValue = node.heatingOn;
                 statusInfo.anticipator = node.anticipator;
             }
 

package/nodes/utils.js

@@ -2,30 +2,9 @@ module.exports = function(RED) {
     function requiresEvaluation(type) { return type === "flow" || type === "global" || type === "msg"; }
 
     
-    function evaluateProperties(node, config, properties, msg = null, initialize = true) {
-        const results = {};
-        
-        properties.forEach(prop => {
-            const type = config[`${prop}Type`];
-            let value;            
-
-            if (type === "msg" && msg === null) {
-                value = null;
-            } else if (initialize || requiresEvaluation(type)) {
-                value = RED.util.evaluateNodeProperty(config[prop], type, node, msg);
-            } else {
-                value = config[prop];
-            }
-            results[prop] = value;
-        });
-        
-        return results;
-    }
-
     // const utils = require('./utils')(RED);
 
     return {
-        requiresEvaluation,
-        evaluateProperties
+        requiresEvaluation
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bldgblocks/node-red-contrib-control",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "Sedona-inspired control nodes for Node-RED",
   "keywords": [ "node-red", "sedona", "control", "hvac" ],
   "files": ["nodes/*.js", "nodes/*.html"],
@@ -29,9 +29,11 @@
         "delay-block": "nodes/delay-block.js",
         "divide-block": "nodes/divide-block.js",
         "edge-block": "nodes/edge-block.js",
+        "enum-switch-block": "nodes/enum-switch-block.js",
         "frequency-block": "nodes/frequency-block.js",
         "hysteresis-block": "nodes/hysteresis-block.js",
         "interpolate-block": "nodes/interpolate-block.js",
+        "latch-block": "nodes/latch-block.js",
         "load-sequence-block": "nodes/load-sequence-block.js",
         "max-block": "nodes/max-block.js",
         "memory-block": "nodes/memory-block.js",
@@ -47,10 +49,12 @@
         "pid-block": "nodes/pid-block.js",
         "priority-block": "nodes/priority-block.js",
         "rate-limit-block": "nodes/rate-limit-block.js",
+        "rate-of-change-block": "nodes/rate-of-change-block.js",
         "round-block": "nodes/round-block.js",
         "saw-tooth-wave-block": "nodes/saw-tooth-wave-block.js",
         "scale-range-block": "nodes/scale-range-block.js",
         "sine-wave-block": "nodes/sine-wave-block.js",
+        "string-builder-block": "nodes/string-builder-block.js",
         "subtract-block": "nodes/subtract-block.js",
         "thermistor-block": "nodes/thermistor-block.js",
         "tick-tock-block": "nodes/tick-tock-block.js",