@bldgblocks/node-red-contrib-control 0.1.34 → 0.1.37

package/nodes/alarm-service.js

@@ -0,0 +1,142 @@
+module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
+    function AlarmServiceNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize configuration
+        node.name = config.name || "alarm-service";
+        node.filterTopic = config.filterTopic || "";  // Optional: only listen to alarms with this topic
+        node.filterPriority = config.filterPriority || "";  // Optional: only listen to this priority
+
+        // Runtime state
+        node.activeAlarms = new Map();  // Map of topic → { state, data, timestamp }
+        node.alarmListener = null;
+
+        utils.setStatusOK(node, "listening");
+
+        // ====================================================================
+        // Handle alarm events from collectors
+        // ====================================================================
+        node.alarmListener = function(eventData) {
+            // Filter by topic if configured
+            if (node.filterTopic && eventData.topic !== node.filterTopic) {
+                return;
+            }
+
+            // Filter by priority if configured
+            if (node.filterPriority && eventData.priority !== node.filterPriority) {
+                return;
+            }
+
+            // Use topic as the key (allows multiple alarms with different topics)
+            const key = eventData.topic || `alarm_${eventData.nodeId}`;
+
+            // Update active alarms map
+            if (eventData.state === true) {
+                // Alarm triggered
+                node.activeAlarms.set(key, {
+                    state: true,
+                    data: eventData,
+                    timestamp: new Date(eventData.timestamp)
+                });
+
+                // Update status to show active alarm count
+                const activeCount = node.activeAlarms.size;
+                utils.setStatusError(node, `${activeCount} active alarm(s)`);
+
+                // Send alarm message with status
+                const msg = {
+                    payload: eventData,
+                    status: { state: "triggered", transition: eventData.transition },
+                    activeAlarmCount: activeCount,
+                    alarmKey: key
+                };
+                node.send(msg);
+
+            } else if (eventData.state === false) {
+                // Alarm cleared
+                if (node.activeAlarms.has(key)) {
+                    const clearedAlarm = node.activeAlarms.get(key);
+                    node.activeAlarms.delete(key);
+
+                    // Update status
+                    const activeCount = node.activeAlarms.size;
+                    if (activeCount === 0) {
+                        utils.setStatusOK(node, "listening (no active alarms)");
+                    } else {
+                        utils.setStatusWarn(node, `${activeCount} active alarm(s)`);
+                    }
+
+                    // Send clear message with status
+                    const msg = {
+                        payload: eventData,
+                        status: { state: "cleared", transition: eventData.transition },
+                        activeAlarmCount: activeCount,
+                        alarmKey: key
+                    };
+                    node.send(msg);
+                }
+            }
+        };
+
+        // Listen to the fixed alarm event
+        RED.events.on("bldgblocks:alarms:state-change", node.alarmListener);
+
+        // Handle wired input messages (optional - can relay or query status)
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            if (!msg) {
+                utils.setStatusError(node, "invalid message");
+                if (done) done();
+                return;
+            }
+
+            // Handle control messages
+            if (msg.hasOwnProperty("context")) {
+                if (msg.context === "getStatus") {
+                    // Query current alarm status
+                    const alarmArray = Array.from(node.activeAlarms.values()).map(a => a.data);
+                    const statusMsg = {
+                        payload: alarmArray,
+                        activeCount: node.activeAlarms.size,
+                        timestamp: new Date().toISOString()
+                    };
+                    send(statusMsg);
+                    utils.setStatusOK(node, `status: ${node.activeAlarms.size} alarms`);
+                    if (done) done();
+                    return;
+                } else if (msg.context === "clearAll") {
+                    // Clear all active alarms from tracking (for reset scenarios)
+                    if (msg.payload === true) {
+                        node.activeAlarms.clear();
+                        utils.setStatusOK(node, "listening (cleared)");
+                        if (done) done();
+                        return;
+                    }
+                }
+            }
+
+            // Pass-through: relay incoming message downstream
+            send(msg);
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            // Remove alarm listener
+            if (node.alarmListener) {
+                RED.events.off("bldgblocks:alarms:state-change", node.alarmListener);
+                node.alarmListener = null;
+            }
+
+            // Clear active alarms map
+            node.activeAlarms.clear();
+
+            done();
+        });
+    }
+
+    RED.nodes.registerType("alarm-service", AlarmServiceNode);
+};

package/nodes/analog-switch-block.js

@@ -1,82 +1,75 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function AnalogSwitchBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            slots: parseInt(config.slots, 10),
-            inputs: Array(parseInt(config.slots, 10) || 2).fill(0),
-            switch: 1
-        };
+        // Initialize state
+        node.name = config.name;
+        node.slots = parseInt(config.slots, 10);
+        node.inputs = Array(parseInt(config.slots, 10) || 2).fill(0);
+        node.switch = 1;
 
         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" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }
 
             // Validate context
             if (!msg.hasOwnProperty("context") || typeof msg.context !== "string") {
-                node.status({ fill: "red", shape: "ring", text: "missing context" });
+                utils.setStatusError(node, "missing context");
                 if (done) done();
                 return;
             }
 
             // Validate payload
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
                 if (done) done();
                 return;
             }
 
             let shouldOutput = false;
-            const prevSwitch = node.runtime.switch;
+            const prevSwitch = node.switch;
 
             switch (msg.context) {
                 case "switch":
                     const switchValue = parseInt(msg.payload, 10);
-                    if (isNaN(switchValue) || switchValue < 1 || switchValue > node.runtime.slots) {
-                        node.status({ fill: "red", shape: "ring", text: "invalid switch" });
+                    if (isNaN(switchValue) || switchValue < 1 || switchValue > node.slots) {
+                        utils.setStatusError(node, "invalid switch");
                         if (done) done();
                         return;
                     }
-                    node.runtime.switch = switchValue;
-                    shouldOutput = prevSwitch !== node.runtime.switch;
-                    node.status({
-                        fill: "green",
-                        shape: "dot",
-                        text: `switch: ${node.runtime.switch}`
-                    });
+                    node.switch = switchValue;
+                    shouldOutput = prevSwitch !== node.switch;
+                    utils.setStatusOK(node, `switch: ${node.switch}`);
                     break;
                 default:
                     if (msg.context.startsWith("in")) {
                         const index = parseInt(msg.context.slice(2), 10);
-                        if (isNaN(index) || index < 1 || index > node.runtime.slots) {
-                            node.status({ fill: "red", shape: "ring", text: `invalid input index ${index}` });
+                        if (isNaN(index) || index < 1 || index > node.slots) {
+                            utils.setStatusError(node, `invalid input index ${index}`);
                             if (done) done();
                             return;
                         }
                         const value = parseFloat(msg.payload);
                         if (isNaN(value)) {
-                            node.status({ fill: "red", shape: "ring", text: `invalid in${index}` });
+                            utils.setStatusError(node, `invalid in${index}`);
                             if (done) done();
                             return;
                         }
-                        node.runtime.inputs[index - 1] = value;
-                        shouldOutput = index === node.runtime.switch;
-                        node.status({
-                            fill: "green",
-                            shape: "dot",
-                            text: `in${index}: ${value.toFixed(2)}`
-                        });
+                        node.inputs[index - 1] = value;
+                        shouldOutput = index === node.switch;
+                        utils.setStatusOK(node, `in${index}: ${value.toFixed(2)}`);
                     } else {
-                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        utils.setStatusWarn(node, "unknown context");
                         if (done) done("Unknown context");
                         return;
                     }
@@ -85,12 +78,8 @@ module.exports = function(RED) {
 
             // Output new message if the active slot is updated or switch/slots change affects output
             if (shouldOutput) {
-                const out = node.runtime.inputs[node.runtime.switch - 1] ?? node.runtime.inputs[0];
-                node.status({
-                    fill: "blue",
-                    shape: "dot",
-                    text: `slots: ${node.runtime.slots}, switch: ${node.runtime.switch}, out: ${out.toFixed(2)}`
-                });
+                const out = node.inputs[node.switch - 1] ?? node.inputs[0];
+                utils.setStatusChanged(node, `slots: ${node.slots}, switch: ${node.switch}, out: ${out.toFixed(2)}`);
                 send({ payload: out });
             }
 

package/nodes/and-block.js

@@ -1,4 +1,6 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function AndBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
@@ -7,60 +9,87 @@ module.exports = function(RED) {
         node.inputs = Array(parseInt(config.slots) || 2).fill(false);
         node.slots = parseInt(config.slots);
 
-        node.status({ fill: "green", shape: "dot", text: `slots: ${node.slots}` });
+        utils.setStatusOK(node, `slots: ${node.slots}`);
 
         // Initialize fields
         let lastResult = null;
         let lastInputs = node.inputs.slice();
+        let lastOutputTime = 0;           // Track last output timestamp for debounce
+        let lastOutputValue = undefined;  // Track last output value for duplicate suppression
+        const DEBOUNCE_MS = 500;          // Debounce period in milliseconds
 
         node.on("input", function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
 
             // Guard against invalid msg
             if (!msg) {
-                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }
 
             // Check required properties
             if (!msg.hasOwnProperty("context")) {
-                node.status({ fill: "red", shape: "ring", text: "missing context" });
+                utils.setStatusError(node, "missing context");
                 if (done) done();
                 return;
             }
 
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
                 if (done) done();
                 return;
             }
 
             // Process input slot
             if (msg.context.startsWith("in")) {
-                let index = parseInt(msg.context.slice(2), 10);
-                if (!isNaN(index) && index >= 1 && index <= node.slots) {
-                    node.inputs[index - 1] = Boolean(msg.payload);
+                const slotVal = utils.validateSlotIndex(msg.context, node.slots);
+                if (slotVal.valid) {
+                    node.inputs[slotVal.index - 1] = Boolean(msg.payload);
                     const result = node.inputs.every(v => v === true);
                     const isUnchanged = result === lastResult && node.inputs.every((v, i) => v === lastInputs[i]);
-                    node.status({
-                        fill: "blue",
-                        shape: isUnchanged ? "ring" : "dot",
-                        text: `in: [${node.inputs.join(", ")}], out: ${result}`
-                    });
+                    const statusText = `in: [${node.inputs.join(", ")}], out: ${result}`;
+                    
+                    // ================================================================
+                    // Debounce: Suppress consecutive same outputs within 500ms
+                    // But always output if value is different or debounce time expired
+                    // ================================================================
+                    const now = Date.now();
+                    const timeSinceLastOutput = now - lastOutputTime;
+                    const isSameOutput = result === lastOutputValue;
+                    const shouldSuppress = isSameOutput && timeSinceLastOutput < DEBOUNCE_MS;
+                    
+                    if (shouldSuppress) {
+                        // Same output within debounce window - don't send, just update status
+                        utils.setStatusUnchanged(node, statusText);
+                    } else {
+                        // Different output or debounce period expired - send it
+                        if (isUnchanged) {
+                            utils.setStatusUnchanged(node, statusText);
+                        } else {
+                            utils.setStatusChanged(node, statusText);
+                        }
+                        
+                        // Record output for next debounce comparison
+                        lastOutputTime = now;
+                        lastOutputValue = result;
+                        
+                        // Send output to allow all downstream branches to update
+                        send({ payload: result });
+                    }
+                    
                     lastResult = result;
                     lastInputs = node.inputs.slice();
-                    send({ payload: result });
                     if (done) done();
                     return;
                 } else {
-                    node.status({ fill: "red", shape: "ring", text: `invalid input index ${index || "NaN"}` });
+                    utils.setStatusError(node, slotVal.error);
                     if (done) done();
                     return;
                 }
             }
 
-            node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+            utils.setStatusWarn(node, "unknown context");
             if (done) done();
         });
 

package/nodes/average-block.js

@@ -6,13 +6,12 @@ module.exports = function(RED) {
         const node = this;
         
         // Initialize runtime state
-        node.runtime = {
-            maxValues: parseInt(config.sampleSize),
-            values: [], // Queue for rolling window
-            lastAvg: null,
-            minValid: parseFloat(config.minValid),
-            maxValid: parseFloat(config.maxValid)
-        };
+        // Initialize state
+        node.maxValues = parseInt(config.sampleSize);
+        node.values = [], // Queue for rolling window;
+        node.lastAvg = null;
+        node.minValid = parseFloat(config.minValid);
+        node.maxValid = parseFloat(config.maxValid);
 
         node.isBusy = false;
 
@@ -21,7 +20,7 @@ module.exports = function(RED) {
 
             // Guard against invalid msg
             if (!msg) {
-                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }    
@@ -32,7 +31,7 @@ module.exports = function(RED) {
                 // Check busy lock
                 if (node.isBusy) {
                     // Update status to let user know they are pushing too fast
-                    node.status({ fill: "yellow", shape: "ring", text: "busy - dropped msg" });
+                    utils.setStatusBusy(node, "busy - dropped msg");
                     if (done) done(); 
                     return;
                 }
@@ -47,21 +46,21 @@ module.exports = function(RED) {
                     utils.requiresEvaluation(config.minValidType) 
                         ? utils.evaluateNodeProperty(config.minValid, config.minValidType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.runtime.minValid),
+                        : Promise.resolve(node.minValid),
                 );
                 
                 evaluations.push(
                     utils.requiresEvaluation(config.maxValidType) 
                         ? utils.evaluateNodeProperty(config.maxValid, config.maxValidType, node, msg)
                             .then(val => parseFloat(val))
-                        : Promise.resolve(node.runtime.maxValid),
+                        : Promise.resolve(node.maxValid),
                 );
 
                 const results = await Promise.all(evaluations);   
 
                 // Update runtime with evaluated values
-                if (!isNaN(results[0])) node.runtime.minValid = results[0];
-                if (!isNaN(results[1])) node.runtime.maxValid = results[1];         
+                if (!isNaN(results[0])) node.minValid = results[0];
+                if (!isNaN(results[1])) node.maxValid = results[1];         
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();
@@ -72,8 +71,8 @@ module.exports = function(RED) {
             }
 
             // Validate values
-            if (isNaN(node.runtime.maxValid) || isNaN(node.runtime.minValid) || node.runtime.maxValid <= node.runtime.minValid ) {
-                node.status({ fill: "red", shape: "ring", text: `invalid evaluated values ${node.runtime.minValid}, ${node.runtime.maxValid}` });
+            if (isNaN(node.maxValid) || isNaN(node.minValid) || node.maxValid <= node.minValid ) {
+                utils.setStatusError(node, `invalid evaluated values ${node.minValid}, ${node.maxValid}`);
                 if (done) done();
                 return;
             }
@@ -81,42 +80,43 @@ module.exports = function(RED) {
             // Handle configuration messages
             if (msg.hasOwnProperty("context")) {
                 if (!msg.hasOwnProperty("payload")) {
-                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    utils.setStatusError(node, "missing payload");
                     if (done) done();
                     return;
                 }
                 
                 switch (msg.context) {
                     case "reset":
-                        if (typeof msg.payload !== "boolean") {
-                            node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                        const boolVal = utils.validateBoolean(msg.payload);
+                        if (!boolVal.valid) {
+                            utils.setStatusError(node, boolVal.error);
                             if (done) done();
                             return;
                         }
-                        if (msg.payload === true) {
-                            node.runtime.values = [];
-                            node.runtime.lastAvg = null;
-                            node.status({ fill: "green", shape: "dot", text: "state reset" });
+                        if (boolVal.value === true) {
+                            node.values = [];
+                            node.lastAvg = null;
+                            utils.setStatusOK(node, "state reset");
                         }
                         break;
                         
                     case "sampleSize":
-                        let newMaxValues = parseInt(msg.payload);
-                        if (isNaN(newMaxValues) || newMaxValues < 1) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid window size" });
+                        const sizeVal = utils.validateIntRange(msg.payload, { min: 1 });
+                        if (!sizeVal.valid) {
+                            utils.setStatusError(node, sizeVal.error);
                             if (done) done();
                             return;
                         }
-                        node.runtime.maxValues = newMaxValues;
+                        node.maxValues = sizeVal.value;
                         // Trim values if new window is smaller
-                        if (node.runtime.values.length > newMaxValues) {
-                            node.runtime.values = node.runtime.values.slice(-newMaxValues);
+                        if (node.values.length > sizeVal.value) {
+                            node.values = node.values.slice(-sizeVal.value);
                         }
-                        node.status({ fill: "green", shape: "dot", text: `window: ${newMaxValues}` });
+                        utils.setStatusOK(node, `window: ${sizeVal.value}`);
                         break;
                         
                     default:
-                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        utils.setStatusWarn(node, "unknown context");
                         break;
                 }                
                 if (done) done();
@@ -125,32 +125,37 @@ module.exports = function(RED) {
 
             // Check for missing payload
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
                 if (done) done();
                 return;
             }
 
             // Process input
-            const inputValue = parseFloat(msg.payload);
-            if (isNaN(inputValue) || inputValue < node.runtime.minValid || inputValue > node.runtime.maxValid) {
-                node.status({ fill: "yellow", shape: "ring", text: "out of range" });
+            const numVal = utils.validateNumericPayload(msg.payload, { min: node.minValid, max: node.maxValid });
+            if (!numVal.valid) {
+                utils.setStatusWarn(node, "out of range");
                 if (done) done();
                 return;
             }
+            const inputValue = numVal.value;
 
             // Update rolling window
-            node.runtime.values.push(inputValue);
-            if (node.runtime.values.length > node.runtime.maxValues) {
-                node.runtime.values.shift();
+            node.values.push(inputValue);
+            if (node.values.length > node.maxValues) {
+                node.values.shift();
             }
 
             // Calculate average
-            const avg = node.runtime.values.length ? node.runtime.values.reduce((a, b) => a + b, 0) / node.runtime.values.length : null;
-            const isUnchanged = avg === node.runtime.lastAvg;
+            const avg = node.values.length ? node.values.reduce((a, b) => a + b, 0) / node.values.length : null;
+            const isUnchanged = avg === node.lastAvg;
 
             // Send new message
-            node.status({ fill: "blue", shape: isUnchanged ? "ring" : "dot", text: `out: ${avg !== null ? avg.toFixed(3) : "null"}` });
-            node.runtime.lastAvg = avg;
+            if (isUnchanged) {
+                utils.setStatusUnchanged(node, `out: ${avg !== null ? avg.toFixed(3) : "null"}`);
+            } else {
+                utils.setStatusChanged(node, `out: ${avg !== null ? avg.toFixed(3) : "null"}`);
+            }
+            node.lastAvg = avg;
             send({ payload: avg });
 
             if (done) done();

package/nodes/boolean-switch-block.js

@@ -1,4 +1,6 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function BooleanSwitchBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
@@ -7,25 +9,21 @@ module.exports = function(RED) {
         node.state = config.state;
 
         // Set initial status
-        node.status({
-            fill: "green",
-            shape: "dot",
-            text: `state: ${node.state}`
-        });
+        utils.setStatusOK(node, `state: ${node.state}`);
 
         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" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }
 
             // Validate context
             if (!msg.hasOwnProperty("context") || typeof msg.context !== "string") {
-                node.status({ fill: "red", shape: "ring", text: "missing or invalid context" });
+                utils.setStatusError(node, "missing or invalid context");
                 if (done) done();
                 return;
             }
@@ -34,44 +32,28 @@ module.exports = function(RED) {
             switch (msg.context) {
                 case "toggle":
                     node.state = !node.state;
-                    node.status({
-                        fill: "green",
-                        shape: "dot",
-                        text: `state: ${node.state}`
-                    });
+                    utils.setStatusChanged(node, `state: ${node.state}`);
                     send([null, null, { payload: node.state }]);
                     break;
                 case "switch":
                     node.state = !!msg.payload;
-                    node.status({
-                        fill: "green",
-                        shape: "dot",
-                        text: `state: ${node.state}`
-                    });
+                    utils.setStatusChanged(node, `state: ${node.state}`);
                     send([null, null, { payload: node.state }]);
                     break;
                 case "inTrue":
                     if (node.state) {
-                        node.status({
-                            fill: "blue",
-                            shape: "dot",
-                            text: `out: ${msg.payload}`
-                        });
+                        utils.setStatusOK(node, `out: ${msg.payload}`);
                         send([msg, null, { payload: node.state }]);
                     }
                     break;
                 case "inFalse":
                     if (!node.state) {
-                        node.status({
-                            fill: "blue",
-                            shape: "dot",
-                            text: `out: ${msg.payload}`
-                        });
+                        utils.setStatusOK(node, `out: ${msg.payload}`);
                         send([null, msg, { payload: node.state }]);
                     }
                     break;
                 default:
-                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    utils.setStatusWarn(node, "unknown context");
                     if (done) done("Unknown context");
                     return;
             }