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

package/nodes/changeover-block.html

@@ -5,10 +5,8 @@
     </div>
     <div class="form-row">
         <label for="node-input-algorithm" title="Control algorithm type"><i class="fa fa-cog"></i> Algorithm</label>
-        <select id="node-input-algorithm">
-            <option value="single">Single Setpoint</option>
-            <option value="split">Split Setpoints</option>
-        </select>
+        <input type="text" id="node-input-algorithm" class="node-input-typed" placeholder="single">
+        <input type="hidden" id="node-input-algorithmType">
     </div>
     <div class="form-row single-only">
         <label for="node-input-setpoint" title="Target temperature setpoint (number from num, msg, flow, or global)"><i class="fa fa-thermometer-half"></i> Setpoint</label>
@@ -50,6 +48,18 @@
             Invalid
         </div>
     </div>
+
+    <div class="form-row specified-only" style="display: none;">
+        <label for="node-input-coolingOn" title="Temperature to turn cooling on (number from num, msg, flow, or global)"><i class="fa fa-snowflake-o"></i> Cooling On</label>
+        <input type="text" id="node-input-coolingOn" placeholder="74">
+        <input type="hidden" id="node-input-coolingOnType">
+    </div>
+    <div class="form-row specified-only" style="display: none;">
+        <label for="node-input-heatingOn" title="Temperature to turn heating on (number from num, msg, flow, or global)"><i class="fa fa-fire"></i> Heating On</label>
+        <input type="text" id="node-input-heatingOn" placeholder="66">
+        <input type="hidden" id="node-input-heatingOnType">
+    </div>
+
     <div class="form-row">
         <label for="node-input-swapTime" title="Minimum time before mode change (seconds, minimum 60, from num, msg, flow, or global)"><i class="fa fa-clock-o"></i> Swap Time</label>
         <input type="text" id="node-input-swapTime" class="node-input-typed" placeholder="300">
@@ -76,11 +86,8 @@
     </div>
     <div class="form-row">
         <label for="node-input-operationMode" title="Operation mode"><i class="fa fa-cogs"></i> Operation Mode</label>
-        <select id="node-input-operationMode">
-            <option value="auto">Auto</option>
-            <option value="heat">Heat</option>
-            <option value="cool">Cool</option>
-        </select>
+        <input type="text" id="node-input-operationMode" placeholder="auto">
+        <input type="hidden" id="node-input-operationModeType">
     </div>
 </script>
 
@@ -91,6 +98,7 @@
         defaults: {
             name: { value: "" },
             algorithm: { value: "single" },
+            algorithmType: { value: "dropdown" },
             setpoint: { value: "70" },
             setpointType: { value: "num" },
             deadband: { value: "2" },
@@ -98,6 +106,10 @@
             heatingSetpointType: { value: "num" },
             coolingSetpoint: { value: "74" },
             coolingSetpointType: { value: "num" },
+            coolingOn: { value: "74" },
+            coolingOnType: { value: "num" },
+            heatingOn: { value: "66" },
+            heatingOnType: { value: "num" },
             extent: { value: "1" },
             swapTime: { value: "300" },
             swapTimeType: { value: "num" },
@@ -106,7 +118,8 @@
             maxTempSetpoint: { value: "90" },
             maxTempSetpointType: { value: "num"},
             initWindow: { value: "10" },
-            operationMode: { value: "auto" }
+            operationMode: { value: "auto" },
+            operationModeType: { value: "dropdown" },
         },
         inputs: 1,
         outputs: 1,
@@ -122,9 +135,37 @@
             const $algorithm = $("#node-input-algorithm");
             const $singleFields = $(".single-only");
             const $splitFields = $(".split-only");
+            const $specifiedFields = $(".specified-only");
 
             try {
                 // Initialize typed inputs
+                
+                $("#node-input-operationMode").typedInput({
+                    default: "dropdown",
+                    types: [{
+                        value: "dropdown",
+                        options: [
+                            { value: "auto", label: "Auto"},
+                            { value: "heat", label: "Heat"},
+                            { value: "cool", label: "Cool"},
+                        ]
+                    }, "msg", "flow", "global"],
+                    typeField: "#node-input-operationModeType"
+                }).typedInput("type", node.operationModeType).typedInput("value", node.operationMode);
+                
+                $("#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-setpoint").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
@@ -143,6 +184,18 @@
                     typeField: "#node-input-coolingSetpointType"
                 }).typedInput("type", node.coolingSetpointType || "num").typedInput("value", node.coolingSetpoint);
 
+                $("#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-coolingOn").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-coolingOnType"
+                }).typedInput("type", node.coolingOnType || "num").typedInput("value", node.coolingOn);
+
                 $("#node-input-swapTime").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
@@ -178,9 +231,20 @@
                     if ($algorithm.val() === "single") {
                         $singleFields.show();
                         $splitFields.hide();
-                    } else {
+                        $specifiedFields.hide();
+                    } else if ($algorithm.val() === "split") {
                         $singleFields.hide();
                         $splitFields.show();
+                        $specifiedFields.hide();
+                    } else if ($algorithm.val() === "specified") {
+                        $singleFields.hide();
+                        $splitFields.hide();
+                        $specifiedFields.show();
+                    } else {
+                        $algorithm.val("single");
+                        $singleFields.show();
+                        $splitFields.hide();
+                        $specifiedFields.hide();
                     }
                 }
 
@@ -188,7 +252,7 @@
                 toggleFields();
                 
             } catch (err) {
-                console.error("Error in changeover-block oneditprepare:", err);
+                console.error("Error in oneditprepare:", err);
             }
         }
     });

package/nodes/changeover-block.js

@@ -10,10 +10,7 @@ module.exports = function(RED) {
         // Initialize runtime state
         node.runtime = {
             name: config.name,
-            algorithm: config.algorithm,
-            operationMode: config.operationMode,
             initWindow: parseFloat(config.initWindow),
-            currentMode: (config.operationMode === "cool" ? "cooling" : "heating"),
             lastTemperature: null,
             lastModeChange: 0
         };
@@ -27,7 +24,10 @@ module.exports = function(RED) {
             node.runtime.deadband = parseFloat(RED.util.evaluateNodeProperty( config.deadband, config.deadbandType, node ));
             node.runtime.extent = parseFloat(RED.util.evaluateNodeProperty( config.extent, config.extentType, node ));
             node.runtime.minTempSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.minTempSetpoint, config.minTempSetpointType, node ));
-            node.runtime.maxTempSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.maxTempSetpoint, config.maxTempSetpointType, node ));            
+            node.runtime.maxTempSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.maxTempSetpoint, config.maxTempSetpointType, node ));  
+            node.runtime.algorithm = RED.util.evaluateNodeProperty( config.algorithm, config.algorithmType, node );
+            node.runtime.operationMode = RED.util.evaluateNodeProperty( config.operationMode, config.operationModeType, node );
+            node.runtime.currentMode = node.runtime.operationMode === "cool" ? "cooling" : "heating";          
         } catch (err) {
             node.error(`Error evaluating properties: ${err.message}`);
             if (done) done();
@@ -74,7 +74,14 @@ module.exports = function(RED) {
                 }
                 if (utils.requiresEvaluation(config.maxTempSetpointType)) {
                     node.runtime.maxTempSetpoint = parseFloat(RED.util.evaluateNodeProperty( config.maxTempSetpoint, config.maxTempSetpointType, node, msg )); 
-                }             
+                }
+                if (utils.requiresEvaluation(config.algorithmType)) {
+                    node.runtime.algorithm = RED.util.evaluateNodeProperty( config.algorithm, config.algorithmType, node, msg );          
+                }    
+                if (utils.requiresEvaluation(config.operationModeType)) {
+                    node.runtime.operationMode = RED.util.evaluateNodeProperty( config.operationMode, config.operationModeType, node, msg );
+                    node.runtime.currentMode = node.runtime.operationMode === "cool" ? "cooling" : "heating";          
+                }
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();
@@ -277,9 +284,12 @@ module.exports = function(RED) {
                 if (node.runtime.algorithm === "single") {
                     heatingThreshold = node.runtime.setpoint - node.runtime.deadband / 2;
                     coolingThreshold = node.runtime.setpoint + node.runtime.deadband / 2;
-                } else {
+                } else if (node.runtime.algorithm === "split") {
                     heatingThreshold = node.runtime.heatingSetpoint - node.runtime.extent;
                     coolingThreshold = node.runtime.coolingSetpoint + node.runtime.extent;
+                } else if (node.runtime.algorithm === "specified") {
+                    heatingThreshold = node.runtime.heatingOn - node.runtime.extent;
+                    coolingThreshold = node.runtime.coolingOn + node.runtime.extent;
                 }
 
                 if (temp < heatingThreshold) {
@@ -311,9 +321,12 @@ module.exports = function(RED) {
                 if (node.runtime.algorithm === "single") {
                     heatingThreshold = node.runtime.setpoint - node.runtime.deadband / 2;
                     coolingThreshold = node.runtime.setpoint + node.runtime.deadband / 2;
-                } else {
+                } else if (node.runtime.algorithm === "split") {
                     heatingThreshold = node.runtime.heatingSetpoint - node.runtime.extent;
                     coolingThreshold = node.runtime.coolingSetpoint + node.runtime.extent;
+                } else if (node.runtime.algorithm === "specified") {
+                    heatingThreshold = node.runtime.heatingOn - node.runtime.extent;
+                    coolingThreshold = node.runtime.coolingOn + node.runtime.extent;
                 }
 
                 let desiredMode = node.runtime.currentMode;
@@ -352,9 +365,12 @@ module.exports = function(RED) {
             if (node.runtime.algorithm === "single") {
                 effectiveHeatingSetpoint = node.runtime.setpoint - node.runtime.deadband / 2;
                 effectiveCoolingSetpoint = node.runtime.setpoint + node.runtime.deadband / 2;
-            } else {
+            } else if (node.runtime.algorithm === "split") {
                 effectiveHeatingSetpoint = node.runtime.heatingSetpoint;
                 effectiveCoolingSetpoint = node.runtime.coolingSetpoint;
+            } else if (node.runtime.algorithm === "specified") {
+                effectiveHeatingSetpoint = node.runtime.heatingOn;
+                effectiveCoolingSetpoint = node.runtime.coolingOn;
             }
 
             return [

package/nodes/delay-block.html

@@ -70,7 +70,7 @@
                 }).typedInput("type", node.delayOffType || "num").typedInput("value", node.delayOff);
 
             } catch (err) {
-                console.error("Error in hysteresis-block oneditprepare:", err);
+                console.error("Error in oneditprepare:", err);
             }
         }
     });

package/nodes/frequency-block.html

@@ -39,9 +39,11 @@ Measures pulse frequency from boolean rising edges.
 
 ### Details
 Measures pulse frequency from rising edges in `msg.payload` (boolean, `true` for pulse), outputting a message with 
-`msg.payload = { ppm, pph, ppd }` (pulses per minute, hour, day) on the second and subsequent rising edges 
+`msg.payload = { ppm, pph, ppd, duty }` (pulses per minute, hour, day, duty/hr) on the second and subsequent rising edges 
 (first edge sets baseline). Resets state via `msg.context = "reset"` with `msg.payload = true`.
 
+Outputs a duty cycle in percentage of the last 60 minutes that the signal has been true.
+
 ### Status
 - Green (dot): Configuration
 - Blue (dot): Output, no alarm

package/nodes/frequency-block.js

@@ -11,7 +11,9 @@ module.exports = function(RED) {
             completeCycle: false,
             ppm: 0,
             pph: 0,
-            ppd: 0
+            ppd: 0,
+            pulseHistory: [], // Array to store {start: timestamp, duration: ms}
+            currentPulseStart: 0
         };
 
         node.status({ 
@@ -20,7 +22,37 @@ module.exports = function(RED) {
             text: "awaiting first pulse" 
         });
 
-        // FEATURE: I want a runtime percentage per hour duty cycle
+        function calculateDutyCycle(now, currentInputValue) {
+            const oneHourAgo = now - 3600000;
+            
+            // Clean up pulses older than 1 hour
+            node.runtime.pulseHistory = node.runtime.pulseHistory.filter(pulse => {
+                return (pulse.start + pulse.duration) > oneHourAgo;
+            });
+
+            let totalOnTime = 0;
+            
+            // Sum all pulse durations within the last hour
+            node.runtime.pulseHistory.forEach(pulse => {
+                const pulseEnd = pulse.start + pulse.duration;
+                const effectiveStart = Math.max(pulse.start, oneHourAgo);
+                const effectiveEnd = Math.min(pulseEnd, now);
+                if (effectiveEnd > effectiveStart) {
+                    totalOnTime += (effectiveEnd - effectiveStart);
+                }
+            });
+
+            // Add current ongoing pulse if active
+            if (currentInputValue && node.runtime.currentPulseStart > 0) {
+                const currentPulseTime = Math.max(node.runtime.currentPulseStart, oneHourAgo);
+                totalOnTime += (now - currentPulseTime);
+            }
+
+            return {
+                dutyCycle: (totalOnTime / 3600000) * 100,
+                onTime: totalOnTime
+            };
+        }
 
         node.on("input", function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
@@ -52,6 +84,8 @@ module.exports = function(RED) {
                         node.runtime.ppm = 0;
                         node.runtime.pph = 0;
                         node.runtime.ppd = 0;
+                        node.runtime.pulseHistory = [];
+                        node.runtime.currentPulseStart = 0;
                         node.status({ fill: "green", shape: "dot", text: "reset" });
                     }
                     if (done) done();
@@ -77,16 +111,39 @@ module.exports = function(RED) {
                 return;
             }
 
+            const now = Date.now();
+
+            // Track pulse edges for duty cycle
+            if (inputValue && !node.runtime.lastIn) {
+                // Rising edge - start new pulse
+                node.runtime.currentPulseStart = now;
+            } else if (!inputValue && node.runtime.lastIn) {
+                // Falling edge - record completed pulse
+                if (node.runtime.currentPulseStart > 0) {
+                    const duration = now - node.runtime.currentPulseStart;
+                    node.runtime.pulseHistory.push({
+                        start: node.runtime.currentPulseStart,
+                        duration: duration
+                    });
+                    node.runtime.currentPulseStart = 0;
+                }
+            }
+
+            // Calculate duty cycle for the rolling hour
+            const dutyData = calculateDutyCycle(now, inputValue);
+
             // Initialize output
             let output = {
                 ppm: node.runtime.ppm,
                 pph: node.runtime.pph,
-                ppd: node.runtime.ppd
+                ppd: node.runtime.ppd,
+                dutyCycle: dutyData.dutyCycle.toFixed(2),
+                onTime: dutyData.onTime
             };
 
             // Detect rising edge
-            if (inputValue && !node.runtime.lastIn) { // Rising edge: true and lastIn was false
-                let now = Date.now();
+            if (inputValue && !node.runtime.lastIn) { 
+                // Rising edge: true and lastIn was false
                 if (!node.runtime.completeCycle) {
                     node.runtime.completeCycle = true;
                 } else {
@@ -114,14 +171,14 @@ module.exports = function(RED) {
                 node.status({
                     fill: "blue",
                     shape: "dot",
-                    text: `input: ${inputValue}, ppm: ${output.ppm.toFixed(2)}, pph: ${output.pph.toFixed(2)}, ppd: ${output.ppd.toFixed(2)}`
+                    text: `input: ${inputValue}, ppm: ${output.ppm.toFixed(2)}, pph: ${output.pph.toFixed(2)}, ppd: ${output.ppd.toFixed(2)}, duty: ${output.dutyCycle}%`
                 });
                 send({ payload: output });
             } else {
                 node.status({
                     fill: "blue",
                     shape: "ring",
-                    text: `input: ${inputValue}, ppm: ${node.runtime.ppm.toFixed(2)}, pph: ${node.runtime.pph.toFixed(2)}, ppd: ${node.runtime.ppd.toFixed(2)}`
+                    text: `input: ${inputValue}, ppm: ${node.runtime.ppm.toFixed(2)}, pph: ${node.runtime.pph.toFixed(2)}, ppd: ${node.runtime.ppd.toFixed(2)}, duty: ${output.dutyCycle}%`
                 });
             }
 

package/nodes/global-getter.html

@@ -0,0 +1,96 @@
+<script type="text/html" data-template-name="global-getter">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-targetNode"><i class="fa fa-crosshairs"></i> Source</label>
+        <input type="text" id="node-input-targetNode" style="width:70%;">
+    </div>
+    <div class="form-tips">
+        Targeting by Node ID allows the source path to change without breaking this link.
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('global-getter', {
+        category: 'control',
+        color: '#301934',
+        defaults: {
+            name: { value: "" },
+            targetNode: { value: "", required: true } 
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-align-left",
+        label: function() {
+            if (this.targetNode) {
+                const target = RED.nodes.node(this.targetNode);
+                if (target) {
+                    // Display the path, removing the #store: prefix for readability in the label if present
+                    let lbl = target.path || target.name;
+                    if(lbl && lbl.includes(":")) {
+                        lbl = lbl.split(":").pop();
+                    }
+                    return "Get: " + lbl;
+                }
+            }
+            return this.name || "global get";
+        },
+        paletteLabel: "global get",
+        oneditprepare: function() {
+            const node = this;
+            
+            let candidateNodes = [];
+            RED.nodes.eachNode(function(n) {
+                if (n.type === 'global-setter') {
+                    let displayPath = n.path || "No Path";
+
+                    candidateNodes.push({
+                        value: n.id,
+                        label: displayPath + (n.name ? ` (${n.name})` : "")
+                    });
+                }
+            });
+
+            candidateNodes.sort((a, b) => a.label.localeCompare(b.label));
+
+            $("#node-input-targetNode").typedInput({
+                types: [{
+                    value: "target",
+                    options: candidateNodes
+                }]
+            });
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="global-getter">
+Manage a global variable in a repeatable way.
+
+### Inputs 
+
+### Outputs
+: payload (any) : The global variable value
+: topic (string) : The variable name/path used to store the value.
+: globalMetadata (object) : Metadata about the global variable (store, path).
+
+### Details
+Global variables are meant to be retrieved in other places, this necessarily means managing the same string in multiple places. 
+
+This node allows you to get a global variable while supporting rename and deletion.
+
+It links to a `global-setter` node by Node ID, so if that node's path is changed, this node will still work.
+
+### Status
+- Green (dot): Configuration update
+- Blue (dot): State changed
+- Blue (ring): State unchanged
+- Red (ring): Error
+- Yellow (ring): Warning
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)  
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/global-getter.js

@@ -0,0 +1,42 @@
+module.exports = function(RED) {
+    function GlobalGetterNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        node.targetNodeId = config.targetNode;
+
+        node.on('input', function(msg) {
+            const setterNode = RED.nodes.getNode(node.targetNodeId);
+
+            if (setterNode && setterNode.varName) {
+                const globalContext = node.context().global;
+                
+                // Retrieve the wrapper object
+                const storedObject = globalContext.get(setterNode.varName, setterNode.storeName);
+                
+                if (storedObject !== undefined) {
+                    // CHECK: Is this our wrapper format?
+                    if (storedObject && typeof storedObject === 'object' && storedObject.hasOwnProperty('value') && storedObject.hasOwnProperty('meta')) {
+                        // Yes: Unwrap it
+                        msg.payload = storedObject.value;
+                        msg.globalMetadata = storedObject.meta; // Expose the ID/Metadata here
+                    } else {
+                        // No: It's legacy/raw data, just pass it through
+                        msg.payload = storedObject;
+                    }
+                    
+                    msg.topic = setterNode.varName; 
+                    
+                    node.status({ fill: "blue", shape: "dot", text: `Get: ${msg.payload}` });
+                    node.send(msg);
+                } else {
+                    // Variable exists in config but not in memory yet
+                    // Optional: warn or just do nothing
+                }
+            } else {
+                node.warn("Source node not found or not configured.");
+                node.status({ fill: "red", shape: "ring", text: "Source node not found" });
+            }
+        });
+    }
+    RED.nodes.registerType("global-getter", GlobalGetterNode);
+}

package/nodes/global-setter.html

@@ -0,0 +1,72 @@
+<script type="text/html" data-template-name="global-setter">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-path"><i class="fa fa-sitemap"></i> Global Path</label>
+        <input type="text" id="node-input-path" placeholder="furnace/outputs/heat">
+    </div>
+    <div class="form-tips">
+        <b>Note:</b> Use the dropdown inside the Path input to select a specific Context Store (File, Memory, etc). 
+        When this node is redeployed or deleted, it will automatically remove (prune) the variable from that store.
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('global-setter', {
+        category: 'control',
+        color: '#301934',
+        defaults: {
+            name: { value: "" },
+            path: { value: "", required: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-align-right",
+        label: function() {
+            // Remove #store: prefix for cleaner label
+            let lbl = this.path;
+            if (lbl && lbl.startsWith("#") && lbl.includes(":")) {
+                lbl = lbl.split(":")[3];
+            }
+            return this.name || lbl || "global set";
+        },
+        paletteLabel: "global set",
+        oneditprepare: function() {
+            // RESTRICT TO GLOBAL ONLY
+            $("#node-input-path").typedInput({
+                types: ['global']
+            });
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="global-setter">
+Manage a global variable in a repeatable way.
+
+### Inputs 
+: payload (any) : Input payload is passed through unchanged.
+
+### Outputs
+: payload (any) : Original payload.
+
+### Details
+Global variables are meant to be retrieved in other places, this necessarily means managing the same string in multiple places. 
+
+This node allows you to set a global variable in one place, and retrieve it elsewhere using the `global-getter` node while supporting rename and deletion.
+
+When this node is deleted or the flow is redeployed, it will automatically remove (prune) the variable from the selected Context Store.
+
+### Status
+- Green (dot): Configuration update
+- Blue (dot): State changed
+- Blue (ring): State unchanged
+- Red (ring): Error
+- Yellow (ring): Warning
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)  
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/global-setter.js

@@ -0,0 +1,43 @@
+module.exports = function(RED) {
+    function GlobalSetterNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        const parsed = RED.util.parseContextStore(config.path);
+        
+        node.varName = parsed.key;
+        node.storeName = parsed.store;
+
+        node.on('input', function(msg) {
+            if (node.varName) {
+                const globalContext = node.context().global;
+                
+                // Create a clean wrapper object to store in global context
+                const storedObject = {
+                    value: msg.payload,
+                    meta: {
+                        sourceId: node.id,
+                        sourceName: node.name || config.path,
+                        topic: msg.topic,
+                        ts: Date.now()
+                    }
+                };
+                
+                globalContext.set(node.varName, storedObject, node.storeName);
+            }
+
+            node.status({ fill: "blue", shape: "dot", text: `Set: ${msg.payload}` });
+            node.send(msg);
+        });
+
+        // CLEANUP
+        node.on('close', function(removed, done) {
+            if (node.varName) {
+                const globalContext = node.context().global;
+                globalContext.set(node.varName, undefined, node.storeName); 
+            }
+            done();
+        });
+    }
+    RED.nodes.registerType("global-setter", GlobalSetterNode);
+}

package/nodes/hysteresis-block.js

@@ -84,7 +84,7 @@ module.exports = function(RED) {
 
             // Add validation to ensure numbers
             if (isNaN(upperTurnOn) || isNaN(upperTurnOff) || isNaN(lowerTurnOn) || isNaN(lowerTurnOff)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid boundary calculation" });
+                node.status({ fill: "red", shape: "ring", text: "invalid limits calculation" });
                 if (done) done();
                 return;
             }