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

package/README.md

@@ -24,7 +24,7 @@ There are TONS of fantastic node libraries out there but usually focusing on one
 - Node commands, such as 'reset' or 'mode' or changing setpoints via messages.
 
 ## How To Use
-Pictures to come.
+<img width="1049" height="131" alt="Screenshot_20251204_194633" src="https://github.com/user-attachments/assets/d29fb46d-c23d-4185-a9e7-f01ff1efdb81" />
 
 The help section of every node describes the expected msg.context (data tag) for the intended msg.payload incoming. You can of course do this as you process data through a 'change' block, or use the provided 'contextual label' block which makes it easier to add and remove tags, more compact (especially if label hidden), and more transparent of the data flowing (ALL nodes contain complete status usage). Most nodes use a simple in1, in2, and so on. 
 

package/nodes/average-block.js

@@ -47,7 +47,7 @@ module.exports = function(RED) {
             // Acceptable fallbacks
             if (isNaN(node.runtime.maxValues) || node.runtime.maxValues < 1) {
                 node.runtime.maxValues = 10;
-                node.status({ fill: "red", shape: "ring", text: "invalid window size, using 10" });
+                node.status({ fill: "yellow", shape: "ring", text: "invalid window size, using 10" });
             }
 
             // Validate values

package/nodes/boolean-switch-block.html

@@ -12,7 +12,8 @@
         category: "control",
         color: "#301934",
         defaults: {
-            name: { value: "" }
+            name: { value: "" },
+            state: { value: false }
         },
         inputs: 1,
         outputs: 3,

package/nodes/boolean-switch-block.js

@@ -4,7 +4,7 @@ module.exports = function(RED) {
         const node = this;
 
         // Initialize state from config
-        node.state = config.state !== undefined ? Boolean(config.state) : false;
+        node.state = config.state;
 
         // Set initial status
         node.status({
@@ -79,7 +79,6 @@ module.exports = function(RED) {
         });
 
         node.on("close", function(done) {
-            node.status({});
             done();
         });
     }

package/nodes/call-status-block.html

@@ -13,15 +13,7 @@
         <input type="number" id="node-input-clearDelay" placeholder="10" min="0.01" step="any">
     </div>
     <div class="form-row">
-        <label for="node-input-normalOff" title="Expected status when call is off (boolean)"><i class="fa fa-power-off"></i> Normal Off</label>
-        <input type="checkbox" id="node-input-normalOff" style="width: auto; vertical-align: middle;">
-    </div>
-    <div class="form-row">
-        <label for="node-input-normalOn" title="Expected status when call is on (boolean)"><i class="fa fa-power-off"></i> Normal On</label>
-        <input type="checkbox" id="node-input-normalOn" style="width: auto; vertical-align: middle;">
-    </div>
-    <div class="form-row">
-        <label for="node-input-runLostStatus" title="Alarm if status doesn't match normalOn during call (boolean)"><i class="fa fa-exclamation-triangle"></i> Run Lost Status</label>
+        <label for="node-input-runLostStatus" title="Alarm if status is lost during call (boolean)"><i class="fa fa-exclamation-triangle"></i> Run Lost Status</label>
         <input type="checkbox" id="node-input-runLostStatus" style="width: auto; vertical-align: middle;">
     </div>
     <div class="form-row">
@@ -47,17 +39,15 @@
             name: { value: "" },
             statusTimeout: { value: 30, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) > 0; } },
             clearDelay: { value: 10, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) > 0; } },
-            normalOff: { value: false },
-            normalOn: { value: true },
             runLostStatus: { value: false },
             noStatusOnRun: { value: true },
             runLostStatusMessage: { value: "Status lost during run" },
             noStatusOnRunMessage: { value: "No status received during run" }
         },
         inputs: 1,
-        outputs: 2,
+        outputs: 1,
         inputLabels: ["input"],
-        outputLabels: ["call", "diagnostics"],
+        outputLabels: ["output"],
         icon: "font-awesome/fa-phone",
         paletteLabel: "call status",
         label: function() {
@@ -68,44 +58,39 @@
 
 <!-- Help Section -->
 <script type="text/markdown" data-help-name="call-status-block">
-Issues calls to equipment with status and alarm diagnostics.
+Monitors call and status signals with alarm diagnostics.
 
 ### Inputs
-: context (string) : Configuration commands - (`"statusTimeout"`, `"clearDelay"`, `"normalOff"`, `"normalOn"`, `"runLostStatus"`, `"noStatusOnRun"`, `"runLostStatusMessage"`, `"noStatusOnRunMessage"`) or sets status (`"status"`). Unmatched values trigger error.
-: payload (boolean | number | string) : Boolean for call, status, or boolean configs; number for timeouts; string for messages.
+- payload (boolean): Call activation/deactivation signal
+- status (boolean): Status response from equipment (only processed when call is active)
 
 ### Outputs
-: call (boolean) : Current call state.
-: diagnostics (object) : `{ call; boolean, status; boolean, alarm; boolean, alarmMessage; string, timeout; boolean }`.
+- call (boolean): Current call state
+- status (object): `{ call: boolean, status: boolean, alarm: boolean, alarmMessage: string, timeout: boolean, neverReceivedStatus: boolean }`
 
 ### Properties
-: name (string) : Display name in editor.
-: statusTimeout (number) : Time to wait for status response (seconds, > 0).
-: clearDelay (number) : Delay before clearing status and alarm after call ends (seconds, > 0).
-: normalOff (boolean) : Expected status when call is off.
-: normalOn (boolean) : Expected status when call is on.
-: runLostStatus (boolean) : Alarm if status doesn't match `normalOn` during call.
-: noStatusOnRun (boolean) : Alarm if no status received during call.
-: runLostStatusMessage (string) : Message for run lost status alarm.
-: noStatusOnRunMessage (string) : Message for no status on run alarm.
+- name (string): Display name in editor
+- statusTimeout (number): Time to wait for status response (seconds, > 0)
+- clearDelay (number): Delay before clearing status and alarm after call ends (seconds, > 0)
+- runLostStatus (boolean): Alarm if status is lost during call
+- noStatusOnRun (boolean): Alarm if no status received during call
+- runLostStatusMessage (string): Message for status lost alarm
+- noStatusOnRunMessage (string): Message for no status alarm
 
-### Details
-Issues a call (`true`) to equipment via output 1 and expects a status response matching `normalOn` within `statusTimeout` seconds. 
+### Alarm Conditions
+1. Status without call: Status=true when call=false (immediate alarm)
+2. No status during call: No status received within timeout period (after statusTimeout)
+3. Lost status during call: Status=false when call=true and status was previously received (immediate alarm)
 
-Clears status and alarm after `clearDelay` seconds when call ends (`false`), checking against `normalOff`. 
+### Behavior
+- When call is activated: Expects status=true response
+- Status is only processed when call is active
+- Clears all state after clearDelay when call ends
+- Timer acts as a blocking gate for status reception
 
-Generates alarms for `runLostStatus` (status mismatch during call) or `noStatusOnRun` (no status within `statusTimeout`) with custom messages. 
-
-Ignores status inputs without an active call.
-
-### Status
-- Green (dot): Configuration
-- Blue (dot): Output, no alarm
-- Red (dot): Output with alarm
-- Red (ring): Errors
-- Yellow (ring): Unknown context
-
-### References
-- [Node-RED Documentation](https://nodered.org/docs/)
-- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
-</script>
+### Status Indicators
+- Green (ring): Configuration errors
+- Blue (dot): Normal operation, no alarms
+- Red (dot): Active alarm condition
+- Yellow (ring): Invalid input
+</script>

package/nodes/call-status-block.js

@@ -3,255 +3,140 @@ module.exports = function(RED) {
         RED.nodes.createNode(this, config);
         const node = this;
 
-        // Initialize runtime state
+        // Simplified runtime state
         node.runtime = {
-            name: config.name || "",
-            statusTimeout: parseFloat(config.statusTimeout),
-            clearDelay: parseFloat(config.clearDelay),
-            normalOff: config.normalOff === true,
-            normalOn: config.normalOn === true,
-            runLostStatus: config.runLostStatus === true,
-            noStatusOnRun: config.noStatusOnRun === true,
-            runLostStatusMessage: config.runLostStatusMessage,
-            noStatusOnRunMessage: config.noStatusOnRunMessage,
             call: false,
             status: false,
             alarm: false,
             alarmMessage: "",
             statusTimer: null,
-            clearTimer: null
+            neverReceivedStatus: true // Track if we've ever gotten status during this call
         };
 
-        // Validate initial config
-        if (isNaN(node.runtime.statusTimeout) || node.runtime.statusTimeout <= 0) {
-            node.runtime.statusTimeout = 30;
-            node.status({ fill: "red", shape: "ring", text: "invalid statusTimeout" });
-        }
-        if (isNaN(node.runtime.clearDelay) || node.runtime.clearDelay <= 0) {
-            node.runtime.clearDelay = 10;
-            node.status({ fill: "red", shape: "ring", text: "invalid clearDelay" });
-        }
+        // Configuration with validation
+        node.config = {
+            statusTimeout: Math.max(parseFloat(config.statusTimeout) || 30, 0.01),
+            runLostStatus: config.runLostStatus === true,
+            noStatusOnRun: config.noStatusOnRun === true,
+            runLostStatusMessage: config.runLostStatusMessage,
+            noStatusOnRunMessage: config.noStatusOnRunMessage
+        };
 
         node.on("input", function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
 
-            // Guard against invalid message
-            if (!msg) {
-                node.status({ fill: "red", shape: "ring", text: "invalid message" });
-                if (done) done();
-                return;
-            }
-
-            // Handle context updates
-            if (msg.hasOwnProperty("context")) {
-                if (!msg.hasOwnProperty("payload")) {
-                    node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+            // Handle status input
+            if (msg.hasOwnProperty("context") && msg.context === "status") {
+                if (typeof msg.payload !== "boolean") {
+                    node.status({ fill: "red", shape: "ring", text: "invalid status" });
                     if (done) done();
                     return;
                 }
 
-                switch (msg.context) {
-                    case "statusTimeout":
-                    case "clearDelay":
-                        const value = parseFloat(msg.payload);
-                        if (isNaN(value) || value <= 0) {
-                            node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
-                            if (done) done();
-                            return;
-                        }
-                        node.runtime[msg.context] = value;
-                        if (node.runtime.statusTimer) {
-                            clearTimeout(node.runtime.statusTimer);
-                            node.runtime.statusTimer = null;
-                            if (node.runtime.noStatusOnRun && node.runtime.call) {
-                                node.runtime.statusTimer = setTimeout(() => {
-                                    if (!node.runtime.status) {
-                                        node.runtime.alarm = true;
-                                        node.runtime.alarmMessage = node.runtime.noStatusOnRunMessage;
-                                        node.status({ fill: "red", shape: "dot", text: `no status on run, alarm: true` });
-                                        send(sendOutputs());
-                                    }
-                                    node.runtime.statusTimer = null;
-                                }, node.runtime.statusTimeout * 1000);
-                            }
-                        }
-                        node.status({
-                            fill: "green",
-                            shape: "dot",
-                            text: `${msg.context}: ${value.toFixed(2)}`
-                        });
-                        if (done) done();
-                        return;
-                    case "normalOff":
-                    case "normalOn":
-                    case "runLostStatus":
-                    case "noStatusOnRun":
-                        if (typeof msg.payload !== "boolean") {
-                            node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
-                            if (done) done();
-                            return;
-                        }
-                        node.runtime[msg.context] = msg.payload;
-                        if (msg.context === "noStatusOnRun" && !msg.payload && node.runtime.statusTimer) {
-                            clearTimeout(node.runtime.statusTimer);
-                            node.runtime.statusTimer = null;
-                        } else if (msg.context === "noStatusOnRun" && msg.payload && node.runtime.call && !node.runtime.status) {
-                            node.runtime.statusTimer = setTimeout(() => {
-                                if (!node.runtime.status) {
-                                    node.runtime.alarm = true;
-                                    node.runtime.alarmMessage = node.runtime.noStatusOnRunMessage;
-                                    node.status({ fill: "red", shape: "dot", text: `no status on run, alarm: true` });
-                                    send(sendOutputs());
-                                }
-                                node.runtime.statusTimer = null;
-                            }, node.runtime.statusTimeout * 1000);
-                        }
-                        node.status({
-                            fill: "green",
-                            shape: "dot",
-                            text: `${msg.context}: ${msg.payload}`
-                        });
-                        send(checkStatusConditions());
-                        if (done) done();
-                        return;
-                    case "runLostStatusMessage":
-                    case "noStatusOnRunMessage":
-                        if (typeof msg.payload !== "string") {
-                            node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
-                            if (done) done();
-                            return;
-                        }
-                        node.runtime[msg.context] = msg.payload;
-                        node.status({
-                            fill: "green",
-                            shape: "dot",
-                            text: `${msg.context} set`
-                        });
-                        if (node.runtime.alarm && node.runtime.alarmMessage === (msg.context === "runLostStatusMessage" ? node.runtime.noStatusOnRunMessage : node.runtime.runLostStatusMessage)) {
-                            node.runtime.alarmMessage = msg.payload;
-                            send(sendOutputs());
-                        }
-                        if (done) done();
-                        return;
-                    case "status":
-                        if (typeof msg.payload !== "boolean") {
-                            node.status({ fill: "red", shape: "ring", text: "invalid status" });
-                            if (done) done();
-                            return;
-                        }
-                        if (!node.runtime.call) {
-                            node.status({ fill: "red", shape: "ring", text: "status ignored" });
-                            if (done) done();
-                            return;
-                        }
-                        node.runtime.status = msg.payload;
-                        if (node.runtime.status && node.runtime.statusTimer) {
-                            clearTimeout(node.runtime.statusTimer);
-                            node.runtime.statusTimer = null;
-                            node.runtime.alarm = false;
-                            node.runtime.alarmMessage = "";
-                        }
-                        send(checkStatusConditions());
-                        if (done) done();
-                        return;
-                    default:
-                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
-                        if (done) done("Unknown context");
-                        return;
+                if (msg.context === node.runtime.status) {
+                    if (done) done();
+                    return;
                 }
+                
+                node.runtime.status = msg.payload;
+                node.runtime.neverReceivedStatus = false;
+                
+                // Clear any pending status timeout
+                if (node.runtime.statusTimer) {
+                    clearTimeout(node.runtime.statusTimer);
+                    node.runtime.statusTimer = null;
+                }
+                
+                // Check alarm conditions
+                checkAlarmConditions();
+                send(sendOutputs());
+                updateStatus();
+                
+                if (done) done();
+                return;
             }
 
-            // Validate call input
+            // Handle call input (must be boolean)
             if (typeof msg.payload !== "boolean") {
-                node.status({ fill: "red", shape: "ring", text: "invalid call" });
+                node.status({ fill: "red", shape: "ring", text: "invalid call payload" });
                 if (done) done();
                 return;
             }
 
-            // Process call change
+            // Process call state change
             if (msg.payload !== node.runtime.call) {
                 node.runtime.call = msg.payload;
 
-                // Clear existing timers
+                // Clear existing timer
                 if (node.runtime.statusTimer) {
                     clearTimeout(node.runtime.statusTimer);
                     node.runtime.statusTimer = null;
                 }
-                if (node.runtime.clearTimer) {
-                    clearTimeout(node.runtime.clearTimer);
-                    node.runtime.clearTimer = null;
-                }
 
                 if (node.runtime.call) {
-                    // Start call: reset status and alarm, set timeout
-                    node.runtime.status = false;
+                    // Call activated - reset tracking, set timeout if needed
+                    node.runtime.neverReceivedStatus = true;
                     node.runtime.alarm = false;
                     node.runtime.alarmMessage = "";
-                    if (node.runtime.noStatusOnRun) {
+                    
+                    if (node.config.noStatusOnRun) {
+                        // Set timer for "never got status" condition
                         node.runtime.statusTimer = setTimeout(() => {
-                            if (!node.runtime.status) {
+                            if (node.runtime.neverReceivedStatus) {
                                 node.runtime.alarm = true;
-                                node.runtime.alarmMessage = node.runtime.noStatusOnRunMessage;
-                                node.status({ fill: "red", shape: "dot", text: `no status on run, alarm: true` });
-                                send(sendOutputs());
+                                node.runtime.alarmMessage = node.config.noStatusOnRunMessage;
                             }
+                            send(sendOutputs());
+                            updateStatus();
                             node.runtime.statusTimer = null;
-                        }, node.runtime.statusTimeout * 1000);
+                        }, node.config.statusTimeout * 1000);
                     }
                 } else {
-                    // Stop call: schedule status and alarm clear
-                    node.runtime.clearTimer = setTimeout(() => {
-                        node.runtime.status = false;
-                        node.runtime.alarm = false;
-                        node.runtime.alarmMessage = "";
-                        send(sendOutputs());
-                        updateStatus();
-                        node.runtime.clearTimer = null;
-                    }, node.runtime.clearDelay * 1000);
+                    node.runtime.status = false;
+                    node.runtime.alarm = false;
+                    node.runtime.alarmMessage = "";
                 }
-                send(checkStatusConditions());
-            } else {
+                
+                // Check alarm conditions
+                checkAlarmConditions();
+                send(sendOutputs());
                 updateStatus();
             }
 
             if (done) done();
 
-            function checkStatusConditions() {
-                if (node.runtime.call && node.runtime.runLostStatus) {
-                    if (node.runtime.status !== node.runtime.normalOn) {
-                        node.runtime.alarm = true;
-                        node.runtime.alarmMessage = node.runtime.runLostStatusMessage;
-                        node.status({ fill: "red", shape: "dot", text: `run lost, alarm: true` });
-                        return sendOutputs();
-                    }
+            function checkAlarmConditions() {
+                if (node.runtime.status && !node.runtime.call) {
+                    node.runtime.alarm = true;
+                    node.runtime.alarmMessage = "Status active without call";
+                    return;
                 }
-                if (!node.runtime.call && node.runtime.status !== node.runtime.normalOff) {
+                
+                if (node.runtime.call && !node.runtime.status && !node.runtime.neverReceivedStatus && node.config.runLostStatus) {
                     node.runtime.alarm = true;
-                    node.runtime.alarmMessage = "Status mismatch when off";
-                    node.status({ fill: "red", shape: "dot", text: `off mismatch, alarm: true` });
-                    return sendOutputs();
+                    node.runtime.alarmMessage = node.config.runLostStatusMessage;
+                    return;
                 }
-                if (!node.runtime.alarm || (node.runtime.status === node.runtime.normalOn && node.runtime.call) || (node.runtime.status === node.runtime.normalOff && !node.runtime.call)) {
+                
+                // No alarm conditions met. Don't clear alarm if timer is still running
+                if (!node.runtime.statusTimer) { 
                     node.runtime.alarm = false;
                     node.runtime.alarmMessage = "";
                 }
-                updateStatus();
-                return sendOutputs();
             }
 
             function sendOutputs() {
-                return [
-                    { payload: node.runtime.call },
-                    {
-                        payload: {
-                            call: node.runtime.call,
-                            status: node.runtime.status,
-                            alarm: node.runtime.alarm,
-                            alarmMessage: node.runtime.alarmMessage,
-                            timeout: !!node.runtime.statusTimer
-                        }
+                return { 
+                    payload: node.runtime.call,
+                    status: {
+                        call: node.runtime.call,
+                        status: node.runtime.status,
+                        alarm: node.runtime.alarm,
+                        alarmMessage: node.runtime.alarmMessage,
+                        timeout: !!node.runtime.statusTimer,
+                        neverReceivedStatus: node.runtime.neverReceivedStatus
                     }
-                ];
+                };
             }
 
             function updateStatus() {
@@ -264,11 +149,12 @@ module.exports = function(RED) {
         });
 
         node.on("close", function(done) {
-            if (node.runtime.statusTimer) clearTimeout(node.runtime.statusTimer);
-            if (node.runtime.clearTimer) clearTimeout(node.runtime.clearTimer);
+            if (node.runtime.statusTimer) {
+                clearTimeout(node.runtime.statusTimer);
+            }
             done();
         });
     }
 
     RED.nodes.registerType("call-status-block", CallStatusBlockNode);
-};
+};