@bldgblocks/node-red-contrib-control 0.1.28 → 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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bldgblocks/node-red-contrib-control",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "description": "Sedona-inspired control nodes for Node-RED",
   "keywords": [ "node-red", "sedona", "control", "hvac" ],
   "files": ["nodes/*.js", "nodes/*.html"],
@@ -31,6 +31,8 @@
         "edge-block": "nodes/edge-block.js",
         "enum-switch-block": "nodes/enum-switch-block.js",
         "frequency-block": "nodes/frequency-block.js",
+        "global-getter": "nodes/global-getter.js",
+        "global-setter": "nodes/global-setter.js",
         "hysteresis-block": "nodes/hysteresis-block.js",
         "interpolate-block": "nodes/interpolate-block.js",
         "latch-block": "nodes/latch-block.js",