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

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);
-};
+};