@bldgblocks/node-red-contrib-control 0.2.2 → 0.2.3

package/nodes/rate-limit-block.js

@@ -35,7 +35,7 @@ module.exports = function(RED) {
         }
 
         // Set initial status
-        utils.setStatusOK(node, `mode: ${node.mode}, out: ${node.currentValue.toFixed(2)}`);
+        utils.setStatusOK(node, `${node.currentValue.toFixed(2)}`);
 
         let updateTimer = null;
 
@@ -58,7 +58,7 @@ module.exports = function(RED) {
                 node.lastUpdate = now;
                 const msg = RED.util.cloneMessage(node.lastInputMsg);
                 msg.payload = node.currentValue;
-                utils.setStatusOK(node, `mode: rate-limit, out: ${node.currentValue.toFixed(2)}`);
+                utils.setStatusOK(node, `${node.currentValue.toFixed(2)}`);
                 node.send(msg);
             }
         }
@@ -151,7 +151,7 @@ module.exports = function(RED) {
 
             if (node.mode === "rate-limit") {
                 node.targetValue = inputValue;
-                utils.setStatusOK(node, `mode: rate-limit, target: ${node.targetValue.toFixed(2)}`);
+                utils.setStatusOK(node, `target: ${node.targetValue.toFixed(2)}`);
                 updateRateLimitOutput();
                 startTimer();
             } else if (node.mode === "threshold") {
@@ -159,15 +159,15 @@ module.exports = function(RED) {
                 if (diff > node.threshold) {
                     msg.payload = inputValue;
                     node.currentValue = inputValue;
-                    utils.setStatusChanged(node, `mode: threshold, out: ${node.currentValue.toFixed(2)}`);
+                    utils.setStatusChanged(node, `${node.currentValue.toFixed(2)}`);
                     send(msg);
                 } else {
-                    utils.setStatusUnchanged(node, `mode: threshold, out: ${node.currentValue.toFixed(2)}`);
+                    utils.setStatusUnchanged(node, `${node.currentValue.toFixed(2)}`);
                 }
             } else if (node.mode === "full-value") {
                 node.currentValue = inputValue;
                 msg.payload = inputValue;
-                utils.setStatusChanged(node, `mode: full-value, out: ${node.currentValue.toFixed(2)}`);
+                utils.setStatusChanged(node, `${node.currentValue.toFixed(2)}`);
                 send(msg);
             }
 

package/nodes/round-block.js

@@ -84,7 +84,7 @@ module.exports = function(RED) {
             }
 
             msg.payload = result;
-            utils.setStatusOK(node, `in: ${inputValue.toFixed(3)}, out: ${result}`);
+            utils.setStatusOK(node, `${result}`);
             send(msg);
             if (done) done();
         });

package/nodes/scale-range-block.js

@@ -122,7 +122,7 @@ module.exports = function(RED) {
             node.lastInput = inputValue;
             const out = calculate(inputValue, node.inMin, node.inMax, node.outMin, node.outMax, node.clamp);
             msg.payload = out;
-            utils.setStatusOK(node, `in: ${inputValue.toFixed(2)}, out: ${out.toFixed(2)}`);
+            utils.setStatusOK(node, `${out.toFixed(2)}`);
             send(msg);
 
             if (done) done();

package/nodes/tstat-block.html

@@ -129,76 +129,84 @@
                         ]
                     }, "msg", "flow", "global"],
                     typeField: "#node-input-algorithmType"
-                }).typedInput("type", node.algorithmType).typedInput("value", node.algorithm);
+                });
 
                 $("#node-input-setpoint").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-setpointType"
-                }).typedInput("type", node.setpointType || "num").typedInput("value", node.setpoint);
+                });
 
                 $("#node-input-heatingSetpoint").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-heatingSetpointType"
-                }).typedInput("type", node.heatingSetpointType || "num").typedInput("value", node.heatingSetpoint);
+                });
 
                 $("#node-input-coolingSetpoint").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
                     typeField: "#node-input-coolingSetpointType"
-                }).typedInput("type", node.coolingSetpointType || "num").typedInput("value", node.coolingSetpoint);
+                });
 
                 $("#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();
+                    const type = $("#node-input-algorithm").typedInput("type");
+                    if (type !== "dropdown") {
+                        // Dynamic source — hide all, resolved at runtime
+                        $singleFields.hide();
+                        $splitFields.hide();
+                        $specifiedFields.hide();
+                        return;
+                    }
+                    const algorithm = $("#node-input-algorithm").typedInput("value");
                     if (algorithm === "single") {
                         $singleFields.show();
                         $splitFields.hide();

package/nodes/tstat-block.js

@@ -287,6 +287,13 @@ module.exports = function(RED) {
             // ----------------------------------------------------------------
             // 6. Startup suppression
             // ----------------------------------------------------------------
+            // Prevent call state from accumulating during startup.
+            // Without this, above/below can latch ON while output is
+            // suppressed, then emit a false call the moment startup ends.
+            if (!node.startupComplete) {
+                above = false;
+                below = false;
+            }
             const outputAbove = node.startupComplete ? above : false;
             const outputBelow = node.startupComplete ? below : false;
 
@@ -324,7 +331,31 @@ module.exports = function(RED) {
                 ? `<${onThreshold.toFixed(1)}`
                 : `>${onThreshold.toFixed(1)}`;
             const suffix = !node.startupComplete ? " [startup]" : "";
-            const text = `${input.toFixed(1)}° ${threshold} [${mode}] call:${call}${suffix}`;
+            let thresholdText, hysteresisText;
+            if (node.isHeating) {
+                thresholdText = `<${onThreshold.toFixed(1)}`;
+                if (outputBelow && input > onThreshold && input <= offThreshold) {
+                    hysteresisText = ` (holding, off at >${offThreshold.toFixed(1)})`;
+                } else if (outputBelow && input < onThreshold) {
+                    hysteresisText = " (on)";
+                } else if (!outputBelow && input > offThreshold) {
+                    hysteresisText = " (off)";
+                } else {
+                    hysteresisText = "";
+                }
+            } else {
+                thresholdText = `>${onThreshold.toFixed(1)}`;
+                if (outputAbove && input < onThreshold && input >= offThreshold) {
+                    hysteresisText = ` (holding, off at <${offThreshold.toFixed(1)})`;
+                } else if (outputAbove && input > onThreshold) {
+                    hysteresisText = " (on)";
+                } else if (!outputAbove && input < offThreshold) {
+                    hysteresisText = " (off)";
+                } else {
+                    hysteresisText = "";
+                }
+            }
+            const text = `${input.toFixed(1)}° ${thresholdText} [${mode}] call:${call}${hysteresisText}${suffix}`;
 
             if (outputAbove === lastAbove && outputBelow === lastBelow) {
                 utils.setStatusUnchanged(node, text);

package/nodes/units-block.js

@@ -38,7 +38,7 @@ module.exports = function(RED) {
                 
                 const payloadPreview = input !== null ? (typeof input === "number" ? input.toFixed(2) : JSON.stringify(input).slice(0, 20)) : "none";
 
-                utils.setStatusOK(node, `in: ${payloadPreview} unit: ${node.unit !== "" ? node.unit : "none"}`);
+                utils.setStatusOK(node, `${node.unit !== "" ? node.unit : "none"}`);
 
                 msg.units = node.unit;
                 send(msg);

package/nodes/utils.js

@@ -93,14 +93,24 @@ module.exports = function(RED) {
         let value = state.defaultValue;
         let priority = 'default';
 
+        // Check priorities 1-16 first (highest)
         for (let i = 1; i <= 16; i++) {
             // Check strictly for undefined/null, allow 0 or false
             if (state.priority[i] !== undefined && state.priority[i] !== null) {
                 value = state.priority[i];
                 priority = String(i);
-                break;
+                return { value, priority };
             }
         }
+
+        // Fall through to fallback slot if no priority is set
+        if (state.fallback !== undefined && state.fallback !== null) {
+            value = state.fallback;
+            priority = 'fallback';
+            return { value, priority };
+        }
+
+        // Finally fall back to default
         return { value, priority };
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bldgblocks/node-red-contrib-control",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Sedona-inspired control nodes for Node-RED",
   "keywords": [
     "node-red",