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

package/nodes/tstat-block.html

@@ -5,15 +5,12 @@
     </div>
     <div class="form-row">
         <label for="node-input-algorithm" title="Algorithm: single setpoint with diff, split setpoints, or specified setpoints"><i class="fa fa-cog"></i> Algorithm</label>
-        <select id="node-input-algorithm">
-            <option value="single">Single Setpoint</option>
-            <option value="split">Split Setpoint</option>
-            <option value="specified">Specified Setpoint</option>
-        </select>
+        <input type="text" id="node-input-algorithm" placeholder="single">
+        <input type="hidden" id="node-input-algorithmType">
     </div>
     <div class="form-row single-setpoint">
         <label for="node-input-setpoint" title="Target temperature setpoint (number from num, msg, flow, or global)"><i class="fa fa-crosshairs"></i> Setpoint</label>
-        <input type="text" id="node-input-setpoint" laceholder="70">
+        <input type="text" id="node-input-setpoint" placeholder="70">
         <input type="hidden" id="node-input-setpointType">
     </div>
     <div class="form-row split-setpoint" style="display: none;">
@@ -63,7 +60,8 @@
     </div>
     <div class="form-row">
         <label for="node-input-isHeating" title="Heating mode (true) or cooling mode (false)"><i class="fa fa-fire"></i> Heating Mode</label>
-        <input type="checkbox" id="node-input-isHeating" style="width: auto; vertical-align: middle;">
+        <input type="text" id="node-input-isHeating" style="width: auto; vertical-align: middle;">
+        <input type="hidden" id="node-input-isHeatingType">
     </div>
 </script>
 
@@ -74,6 +72,7 @@
         defaults: {
             name: { value: "" },
             algorithm: { value: "single" },
+            algorithmType: { value: "dropdown" },
             setpoint: { value: "70" },
             setpointType: { value: "num" },
             heatingSetpoint: { value: "68" },
@@ -94,7 +93,8 @@
             anticipatorType: { value: "num" },
             ignoreAnticipatorCycles: { value: "1" },
             ignoreAnticipatorCyclesType: { value: "num" },
-            isHeating: { value: false }
+            isHeating: { value: false },
+            isHeatingType: { value: "bool" }
         },
         inputs: 1,
         outputs: 3,
@@ -112,41 +112,85 @@
                 const $singleFields = $(".single-setpoint");
                 const $splitFields = $(".split-setpoint");
                 const $specifiedFields = $(".specified-setpoint");
+                
+                $("#node-input-algorithm").typedInput({
+                    default: "dropdown",
+                    types: [{
+                        value: "dropdown",
+                        options: [
+                            { value: "single", label: "Single"},
+                            { value: "split", label: "Split"},
+                            { value: "specified", label: "Specified"},
+                        ]
+                    }, "msg", "flow", "global"],
+                    typeField: "#node-input-algorithmType"
+                }).typedInput("type", node.algorithmType).typedInput("value", node.algorithm);
 
-                $("#node-input-name").val(node.name || "");
-                $("#node-input-algorithm").val(node.algorithm || "single");
-                $("#node-input-isHeating").prop("checked", node.isHeating === true);
+                $("#node-input-setpoint").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-setpointType"
+                }).typedInput("type", node.setpointType || "num").typedInput("value", node.setpoint);
 
-                const typedInputs = [
-                    { id: "node-input-setpoint", typeId: "node-input-setpointType", defaultValue: "70", defaultType: "num" },
-                    { id: "node-input-heatingSetpoint", typeId: "node-input-heatingSetpointType", defaultValue: "68", defaultType: "num" },
-                    { id: "node-input-coolingSetpoint", typeId: "node-input-coolingSetpointType", defaultValue: "74", defaultType: "num" },
-                    { id: "node-input-coolingOn", typeId: "node-input-coolingOnType", defaultValue: "74", defaultType: "num" },
-                    { id: "node-input-coolingOff", typeId: "node-input-coolingOffType", defaultValue: "72", defaultType: "num" },
-                    { id: "node-input-heatingOff", typeId: "node-input-heatingOffType", defaultValue: "68", defaultType: "num" },
-                    { id: "node-input-heatingOn", typeId: "node-input-heatingOnType", defaultValue: "66", defaultType: "num" },
-                    { id: "node-input-diff", typeId: "node-input-diffType", defaultValue: "2", defaultType: "num" },
-                    { id: "node-input-anticipator", typeId: "node-input-anticipatorType", defaultValue: "0.5", defaultType: "num" },
-                    { id: "node-input-ignoreAnticipatorCycles", typeId: "node-input-ignoreAnticipatorCyclesType", defaultValue: "1", defaultType: "num" }
-                ];
+                $("#node-input-heatingSetpoint").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-heatingSetpointType"
+                }).typedInput("type", node.heatingSetpointType || "num").typedInput("value", node.heatingSetpoint);
 
-                typedInputs.forEach(input => {
-                    try {
-                        const fieldName = input.id.replace("node-input-", "");
-                        const storedValue = node[fieldName] !== undefined ? node[fieldName] : input.defaultValue;
-                        const storedType = node[`${fieldName}Type`] || input.defaultType;
+                $("#node-input-coolingSetpoint").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-coolingSetpointType"
+                }).typedInput("type", node.coolingSetpointType || "num").typedInput("value", node.coolingSetpoint);
 
-                        $(`#${input.id}`).typedInput({
-                            default: input.defaultType,
-                            types: ["num", "msg", "flow", "global"],
-                            typeField: `#${input.typeId}`
-                        }).typedInput("type", storedType)
-                        .typedInput("value", storedValue);
-                    } catch (err) {
-                        console.error(`Error initializing typedInput for ${input.id}:`, err);
-                    }
-                });
+                $("#node-input-coolingOn").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-coolingOnType"
+                }).typedInput("type", node.coolingOnType || "num").typedInput("value", node.coolingOn);
+
+                $("#node-input-coolingOff").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-coolingOffType"
+                }).typedInput("type", node.coolingOffType || "num").typedInput("value", node.coolingOff);
+
+                $("#node-input-heatingOff").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-heatingOffType"
+                }).typedInput("type", node.heatingOffType || "num").typedInput("value", node.heatingOff);
 
+                $("#node-input-heatingOn").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-heatingOnType"
+                }).typedInput("type", node.heatingOnType || "num").typedInput("value", node.heatingOn);
+
+                $("#node-input-diff").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-diffType"
+                }).typedInput("type", node.diffType || "num").typedInput("value", node.diff);
+                
+                $("#node-input-anticipator").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-anticipatorType"
+                }).typedInput("type", node.anticipatorType || "num").typedInput("value", node.anticipator);
+
+                $("#node-input-ignoreAnticipatorCycles").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-ignoreAnticipatorCyclesType"
+                }).typedInput("type", node.ignoreAnticipatorCyclesType || "num").typedInput("value", node.ignoreAnticipatorCycles);
+
+                $("#node-input-isHeating").typedInput({
+                    default: "bool",
+                    types: ["bool", "msg", "flow", "global"],
+                    typeField: "#node-input-isHeatingType"
+                }).typedInput("type", node.isHeatingType || "bool").typedInput("value", node.isHeating);
 
                 function toggleFields() {
                     const algorithm = $algorithm.val();
@@ -201,7 +245,7 @@ All output messages include a `msg.status` object containing runtime information
   - `effectiveAnticipator`: Current anticipator value after mode change adjustments
 
 ### Status Monitoring
-Instead of a dedicated status output, all outputs include comprehensive status information
+All outputs include comprehensive status information in `msg.status`. Example:
 ```json
 {
   "status": {
@@ -218,6 +262,8 @@ Instead of a dedicated status output, all outputs include comprehensive status i
     "effectiveAnticipator": 0.5
   }
 }
+```
+
 ### Algorithms
 - **Single Setpoint**:
   - Uses `setpoint`, `diff`, and `anticipator`.

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.28",
   "description": "Sedona-inspired control nodes for Node-RED",
   "keywords": [ "node-red", "sedona", "control", "hvac" ],
   "files": ["nodes/*.js", "nodes/*.html"],
@@ -33,6 +33,7 @@
         "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",
@@ -48,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",