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

package/nodes/tstat-block.js

@@ -21,7 +21,9 @@ module.exports = function(RED) {
             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.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}`);
         }
@@ -75,6 +77,12 @@ module.exports = function(RED) {
                 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();
@@ -197,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;
             }
@@ -236,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;
@@ -269,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;
@@ -281,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;
@@ -311,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bldgblocks/node-red-contrib-control",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "Sedona-inspired control nodes for Node-RED",
   "keywords": [ "node-red", "sedona", "control", "hvac" ],
   "files": ["nodes/*.js", "nodes/*.html"],
@@ -31,8 +31,11 @@
         "edge-block": "nodes/edge-block.js",
         "enum-switch-block": "nodes/enum-switch-block.js",
         "frequency-block": "nodes/frequency-block.js",
+        "global-getter": "nodes/global-getter.js",
+        "global-setter": "nodes/global-setter.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",
@@ -48,10 +51,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",