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

package/nodes/rate-of-change-block.js

@@ -0,0 +1,233 @@
+module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
+    function RateOfChangeNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Initialize runtime state
+        node.runtime = {
+            maxSamples: parseInt(config.sampleSize),
+            samples: [], // Array of {timestamp: Date, value: number}
+            units: config.units || "minutes", // minutes, seconds, hours
+            lastRate: null
+        };
+
+        // Evaluate typed-input properties    
+        try {     
+            node.runtime.minValid = parseFloat(RED.util.evaluateNodeProperty( config.minValid, config.minValidType, node ));
+            node.runtime.maxValid = parseFloat(RED.util.evaluateNodeProperty( config.maxValid, config.maxValidType, node ));
+        } catch (err) {
+            node.error(`Error evaluating properties: ${err.message}`);
+        }
+
+        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" });
+                if (done) done();
+                return;
+            }    
+
+            // Update typed-input properties if needed
+            try {                    
+                if (utils.requiresEvaluation(config.minValidType)) {
+                    node.runtime.minValid = parseFloat(RED.util.evaluateNodeProperty( config.minValid, config.minValidType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.maxValidType)) {
+                    node.runtime.maxValid = parseFloat(RED.util.evaluateNodeProperty( config.maxValid, config.maxValidType, node, msg ));
+                }
+            } catch (err) {
+                node.error(`Error evaluating properties: ${err.message}`);
+                if (done) done();
+                return;
+            }
+
+            // Acceptable fallbacks
+            if (isNaN(node.runtime.maxSamples) || node.runtime.maxSamples < 2) {
+                node.runtime.maxSamples = 10;
+                node.status({ fill: "red", shape: "ring", text: "invalid sample size, using 10" });
+            }
+
+            // 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 (done) done();
+                return;
+            }
+
+            // Handle configuration messages
+            if (msg.hasOwnProperty("context")) {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: "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" });
+                            if (done) done();
+                            return;
+                        }
+                        if (msg.payload === true) {
+                            node.runtime.samples = [];
+                            node.runtime.lastRate = null;
+                            node.status({ fill: "green", shape: "dot", text: "state reset" });
+                        }
+                        break;
+                        
+                    case "sampleSize":
+                        let newMaxSamples = parseInt(msg.payload);
+                        if (isNaN(newMaxSamples) || newMaxSamples < 2) {
+                            node.status({ fill: "red", shape: "ring", text: "sample size must be at least 2" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.maxSamples = newMaxSamples;
+                        // Trim samples if new window is smaller
+                        if (node.runtime.samples.length > newMaxSamples) {
+                            node.runtime.samples = node.runtime.samples.slice(-newMaxSamples);
+                        }
+                        node.status({ fill: "green", shape: "dot", text: `samples: ${newMaxSamples}` });
+                        break;
+                        
+                    case "units":
+                        const validUnits = ["seconds", "minutes", "hours"];
+                        if (typeof msg.payload === "string" && validUnits.includes(msg.payload.toLowerCase())) {
+                            node.runtime.units = msg.payload.toLowerCase();
+                            node.status({ fill: "green", shape: "dot", text: `units: ${msg.payload}` });
+                        } else {
+                            node.status({ fill: "red", shape: "ring", text: "invalid units" });
+                        }
+                        break;
+                        
+                    default:
+                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        break;
+                }                
+                if (done) done();
+                return;
+            }
+
+            // Check for missing payload
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            // Process input
+            const inputValue = parseFloat(msg.payload);
+            const timestamp = msg.timestamp ? new Date(msg.timestamp) : new Date();
+            
+            if (isNaN(inputValue) || inputValue < node.runtime.minValid || inputValue > node.runtime.maxValid) {
+                node.status({ fill: "yellow", shape: "ring", text: "out of range" });
+                if (done) done();
+                return;
+            }
+
+            // Add new sample
+            node.runtime.samples.push({ timestamp: timestamp, value: inputValue });
+            
+            // Maintain sample window
+            if (node.runtime.samples.length > node.runtime.maxSamples + 1) {
+                node.runtime.samples = node.runtime.samples.slice(-node.runtime.maxSamples);
+            } else if (node.runtime.samples.length > node.runtime.maxSamples) {
+                node.runtime.samples.shift();
+            }
+
+            // Calculate rate of change (temperature per time unit)
+            let rate = null;
+            if (node.runtime.samples.length >= node.runtime.maxSamples) { // Need at least 3 points for good regression
+                const n = node.runtime.samples.length;
+                let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
+                
+                // Convert timestamps to relative time in the selected units
+                const baseTime = node.runtime.samples[0].timestamp;
+                let timeScale; // Conversion factor from ms to selected units
+                
+                switch (node.runtime.units) {
+                    case "seconds":
+                        timeScale = 1000; // ms to seconds
+                        break;
+                    case "minutes":
+                        timeScale = 1000 * 60; // ms to minutes
+                        break;
+                    case "hours":
+                        timeScale = 1000 * 60 * 60; // ms to hours
+                        break;
+                    default:
+                        timeScale = 1000 * 60; // default to minutes
+                }
+                
+                // Calculate regression sums
+                node.runtime.samples.forEach((sample, i) => {
+                    const x = (sample.timestamp - baseTime) / timeScale; // time in selected units
+                    const y = sample.value;
+                    
+                    sumX += x;
+                    sumY += y;
+                    sumXY += x * y;
+                    sumXX += x * x;
+                });
+                
+                // Calculate slope (rate of change) using linear regression formula
+                const denominator = n * sumXX - sumX * sumX;
+                
+                // Avoid division by zero - use original endpoint method if regression fails
+                if (Math.abs(denominator) > 1e-10) { // Small tolerance for floating point
+                    rate = (n * sumXY - sumX * sumY) / denominator;
+                } else {
+                    // Fallback to original endpoint method if regression is unstable
+                    const firstSample = node.runtime.samples[0];
+                    const lastSample = node.runtime.samples[node.runtime.samples.length - 1];
+                    const timeDiff = (lastSample.timestamp - firstSample.timestamp) / timeScale;
+                    rate = timeDiff > 0 ? (lastSample.value - firstSample.value) / timeDiff : 0;
+                }
+            }
+
+            const isUnchanged = rate === node.runtime.lastRate;
+
+            // Send new message
+            const unitsDisplay = {
+                seconds: "/sec",
+                minutes: "/min",
+                hours: "/hr"
+            };
+
+            node.status({ 
+                fill: "blue", 
+                shape: isUnchanged ? "ring" : "dot", 
+                text: `rate: ${rate !== null ? rate.toFixed(2) : "not ready"} ${unitsDisplay[node.runtime.units] || "/min"}`
+            });
+            
+            node.runtime.lastRate = rate;
+            
+            // Enhanced output with metadata
+            const outputMsg = {
+                payload: rate,
+                samples: node.runtime.samples.length,
+                units: `${unitsDisplay[node.runtime.units] || "/min"}`,
+                currentValue: inputValue,
+                timeSpan: node.runtime.samples.length >= 2 ? 
+                    (node.runtime.samples[node.runtime.samples.length - 1].timestamp - node.runtime.samples[0].timestamp) / 1000 : 0
+            };
+            
+            if (node.runtime.samples.length >= node.runtime.maxSamples) {
+                send(outputMsg);
+            }
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("rate-of-change-block", RateOfChangeNode);
+};

package/nodes/string-builder-block.html

@@ -0,0 +1,112 @@
+<!-- UI Template Section: Defines the edit dialog -->
+<script type="text/html" data-template-name="string-builder-block">
+    <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-in1"><i class="fa fa-bars"></i> in1</label>
+        <input type="text" id="node-input-in1" placeholder="">
+        <input type="hidden" id="node-input-in1Type">
+    </div>
+    <div class="form-row">
+        <label for="node-input-in2"><i class="fa fa-bars"></i> in2</label>
+        <input type="text" id="node-input-in2" placeholder="">
+        <input type="hidden" id="node-input-in2Type">
+    </div>
+    <div class="form-row">
+        <label for="node-input-in3"><i class="fa fa-bars"></i> in3</label>
+        <input type="text" id="node-input-in3" placeholder="">
+        <input type="hidden" id="node-input-in3Type">
+    </div>
+    <div class="form-row">
+        <label for="node-input-in4"><i class="fa fa-bars"></i> in4</label>
+        <input type="text" id="node-input-in4" placeholder="">
+        <input type="hidden" id="node-input-in4Type">
+    </div>
+</script>
+
+
+<!-- JavaScript Section: Registers the node and handles editor logic -->
+<script type="text/javascript">
+    RED.nodes.registerType("string-builder-block", {
+    category: "control",
+    color: "#301934",
+    defaults: {
+        name: { value: "" },
+        in1: { value: "", required: false },
+        in1Type: { value: "str" },
+        in2: { value: "", required: false },
+        in2Type: { value: "str" },
+        in3: { value: "", required: false },
+        in3Type: { value: "str" },
+        in4: { value: "", required: false },
+        in4Type: { value: "str" },
+    },
+    inputs: 1,
+    outputs: 1,
+    inputLabels: ["input"],
+    outputLabels: ["output"],
+    icon: "font-awesome/fa-bars",
+    paletteLabel: "string builder",
+    label: function() {
+        return this.name || "string builder";
+    },
+    oneditprepare: function() {
+        const node = this;
+
+        try {
+            // Initialize typed inputs
+            $("#node-input-in1").typedInput({
+                default: "str",
+                types: ["str", "msg", "flow", "global"],
+                typeField: "#node-input-in1Type"
+            }).typedInput("type", node.in1Type || "str").typedInput("value", node.in1);
+
+            $("#node-input-in2").typedInput({
+                default: "str",
+                types: ["str", "msg", "flow", "global"],
+                typeField: "#node-input-in2Type"
+            }).typedInput("type", node.in2Type || "str").typedInput("value", node.in2);
+
+            $("#node-input-in3").typedInput({
+                default: "str",
+                types: ["str", "msg", "flow", "global"],
+                typeField: "#node-input-in3Type"
+            }).typedInput("type", node.in3Type || "str").typedInput("value", node.in3);
+
+            $("#node-input-in4").typedInput({
+                default: "str",
+                types: ["str", "msg", "flow", "global"],
+                typeField: "#node-input-in4Type"
+            }).typedInput("type", node.in4Type || "str").typedInput("value", node.in4);
+
+        } catch (err) {
+            console.error("Error in oneditprepare:", err);
+        }
+    }
+});
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="string-builder-block">
+Concatenates multiple string inputs into a single output string on any input.
+
+### Inputs
+: payload (number) : Input value to evaluate
+: context (string) : Configure `inX` string inputs via context variables
+
+### Outputs
+: output (string) : Each string input concatenated in order
+
+### 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/string-builder-block.js

@@ -0,0 +1,89 @@
+module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
+    function StringBuilderBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        node.name = config.name;
+
+        // Evaluate typed-input properties    
+        try {      
+            node.in1 = RED.util.evaluateNodeProperty( config.in1, config.in1Type, node );
+            node.in2 = RED.util.evaluateNodeProperty( config.in2, config.in2Type, node );
+            node.in3 = RED.util.evaluateNodeProperty( config.in3, config.in3Type, node );
+            node.in4 = RED.util.evaluateNodeProperty( config.in4, config.in4Type, node );
+        } catch (err) {
+            node.error(`Error evaluating properties: ${err.message}`);
+        }
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+            
+            // Update typed-input properties if needed
+            try {           
+                if (utils.requiresEvaluation(config.in1Type)) {
+                    node.in1 = RED.util.evaluateNodeProperty( config.in1, config.in1Type, node, msg );
+                }
+                if (utils.requiresEvaluation(config.in2Type)) {
+                    node.in2 = RED.util.evaluateNodeProperty( config.in2, config.in2Type, node, msg );
+                }
+                if (utils.requiresEvaluation(config.in3Type)) {
+                    node.in3 = RED.util.evaluateNodeProperty( config.in3, config.in3Type, node, msg );
+                }
+                if (utils.requiresEvaluation(config.in4Type)) {
+                    node.in4 = RED.util.evaluateNodeProperty( config.in4, config.in4Type, node, msg );
+                }
+            } catch (err) {
+                node.error(`Error evaluating properties: ${err.message}`);
+                if (done) done();
+                return;
+            }
+
+            // Check required properties
+            if (msg.hasOwnProperty("context")) {
+
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: "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 <= 4) {
+                        if (config[`in${index}Type`] === "str") {
+                            node[`in${index}`] = msg.payload;
+                        } else {
+                            node.status({ fill: "red", shape: "ring", text: `Field type is ${config[`in${index}Type`]}` });
+                            if (done) done();
+                            return;
+                        }
+                    } else {
+                        node.status({ fill: "red", shape: "ring", text: `invalid input index ${index || "NaN"}` });
+                        if (done) done();
+                        return;
+                    }
+                }                
+            }
+
+            const output = { payload: `${node.in1}${node.in2}${node.in3}${node.in4}` };
+            node.status({ fill: "blue", shape: "dot", text: `${ output.payload }` });
+            send(output);
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("string-builder-block", StringBuilderBlockNode);
+};

package/nodes/tstat-block.html

@@ -5,15 +5,12 @@
     </div>
     <div class="form-row">
         <label for="node-input-algorithm" title="Algorithm: single setpoint with diff, split setpoints, or specified setpoints"><i class="fa fa-cog"></i> Algorithm</label>
-        <select id="node-input-algorithm">
-            <option value="single">Single Setpoint</option>
-            <option value="split">Split Setpoint</option>
-            <option value="specified">Specified Setpoint</option>
-        </select>
+        <input type="text" id="node-input-algorithm" placeholder="single">
+        <input type="hidden" id="node-input-algorithmType">
     </div>
     <div class="form-row single-setpoint">
         <label for="node-input-setpoint" title="Target temperature setpoint (number from num, msg, flow, or global)"><i class="fa fa-crosshairs"></i> Setpoint</label>
-        <input type="text" id="node-input-setpoint" laceholder="70">
+        <input type="text" id="node-input-setpoint" placeholder="70">
         <input type="hidden" id="node-input-setpointType">
     </div>
     <div class="form-row split-setpoint" style="display: none;">
@@ -63,7 +60,8 @@
     </div>
     <div class="form-row">
         <label for="node-input-isHeating" title="Heating mode (true) or cooling mode (false)"><i class="fa fa-fire"></i> Heating Mode</label>
-        <input type="checkbox" id="node-input-isHeating" style="width: auto; vertical-align: middle;">
+        <input type="text" id="node-input-isHeating" style="width: auto; vertical-align: middle;">
+        <input type="hidden" id="node-input-isHeatingType">
     </div>
 </script>
 
@@ -74,6 +72,7 @@
         defaults: {
             name: { value: "" },
             algorithm: { value: "single" },
+            algorithmType: { value: "dropdown" },
             setpoint: { value: "70" },
             setpointType: { value: "num" },
             heatingSetpoint: { value: "68" },
@@ -94,7 +93,8 @@
             anticipatorType: { value: "num" },
             ignoreAnticipatorCycles: { value: "1" },
             ignoreAnticipatorCyclesType: { value: "num" },
-            isHeating: { value: false }
+            isHeating: { value: false },
+            isHeatingType: { value: "bool" }
         },
         inputs: 1,
         outputs: 3,
@@ -112,41 +112,85 @@
                 const $singleFields = $(".single-setpoint");
                 const $splitFields = $(".split-setpoint");
                 const $specifiedFields = $(".specified-setpoint");
+                
+                $("#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-name").val(node.name || "");
-                $("#node-input-algorithm").val(node.algorithm || "single");
-                $("#node-input-isHeating").prop("checked", node.isHeating === true);
+                $("#node-input-setpoint").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-setpointType"
+                }).typedInput("type", node.setpointType || "num").typedInput("value", node.setpoint);
 
-                const typedInputs = [
-                    { id: "node-input-setpoint", typeId: "node-input-setpointType", defaultValue: "70", defaultType: "num" },
-                    { id: "node-input-heatingSetpoint", typeId: "node-input-heatingSetpointType", defaultValue: "68", defaultType: "num" },
-                    { id: "node-input-coolingSetpoint", typeId: "node-input-coolingSetpointType", defaultValue: "74", defaultType: "num" },
-                    { id: "node-input-coolingOn", typeId: "node-input-coolingOnType", defaultValue: "74", defaultType: "num" },
-                    { id: "node-input-coolingOff", typeId: "node-input-coolingOffType", defaultValue: "72", defaultType: "num" },
-                    { id: "node-input-heatingOff", typeId: "node-input-heatingOffType", defaultValue: "68", defaultType: "num" },
-                    { id: "node-input-heatingOn", typeId: "node-input-heatingOnType", defaultValue: "66", defaultType: "num" },
-                    { id: "node-input-diff", typeId: "node-input-diffType", defaultValue: "2", defaultType: "num" },
-                    { id: "node-input-anticipator", typeId: "node-input-anticipatorType", defaultValue: "0.5", defaultType: "num" },
-                    { id: "node-input-ignoreAnticipatorCycles", typeId: "node-input-ignoreAnticipatorCyclesType", defaultValue: "1", defaultType: "num" }
-                ];
+                $("#node-input-heatingSetpoint").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-heatingSetpointType"
+                }).typedInput("type", node.heatingSetpointType || "num").typedInput("value", node.heatingSetpoint);
 
-                typedInputs.forEach(input => {
-                    try {
-                        const fieldName = input.id.replace("node-input-", "");
-                        const storedValue = node[fieldName] !== undefined ? node[fieldName] : input.defaultValue;
-                        const storedType = node[`${fieldName}Type`] || input.defaultType;
+                $("#node-input-coolingSetpoint").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-coolingSetpointType"
+                }).typedInput("type", node.coolingSetpointType || "num").typedInput("value", node.coolingSetpoint);
 
-                        $(`#${input.id}`).typedInput({
-                            default: input.defaultType,
-                            types: ["num", "msg", "flow", "global"],
-                            typeField: `#${input.typeId}`
-                        }).typedInput("type", storedType)
-                        .typedInput("value", storedValue);
-                    } catch (err) {
-                        console.error(`Error initializing typedInput for ${input.id}:`, err);
-                    }
-                });
+                $("#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-coolingOff").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-coolingOffType"
+                }).typedInput("type", node.coolingOffType || "num").typedInput("value", node.coolingOff);
+
+                $("#node-input-heatingOff").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-heatingOffType"
+                }).typedInput("type", node.heatingOffType || "num").typedInput("value", node.heatingOff);
 
+                $("#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-diff").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-diffType"
+                }).typedInput("type", node.diffType || "num").typedInput("value", node.diff);
+                
+                $("#node-input-anticipator").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-anticipatorType"
+                }).typedInput("type", node.anticipatorType || "num").typedInput("value", node.anticipator);
+
+                $("#node-input-ignoreAnticipatorCycles").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-ignoreAnticipatorCyclesType"
+                }).typedInput("type", node.ignoreAnticipatorCyclesType || "num").typedInput("value", node.ignoreAnticipatorCycles);
+
+                $("#node-input-isHeating").typedInput({
+                    default: "bool",
+                    types: ["bool", "msg", "flow", "global"],
+                    typeField: "#node-input-isHeatingType"
+                }).typedInput("type", node.isHeatingType || "bool").typedInput("value", node.isHeating);
 
                 function toggleFields() {
                     const algorithm = $algorithm.val();
@@ -201,7 +245,7 @@ All output messages include a `msg.status` object containing runtime information
   - `effectiveAnticipator`: Current anticipator value after mode change adjustments
 
 ### Status Monitoring
-Instead of a dedicated status output, all outputs include comprehensive status information
+All outputs include comprehensive status information in `msg.status`. Example:
 ```json
 {
   "status": {
@@ -218,6 +262,8 @@ Instead of a dedicated status output, all outputs include comprehensive status i
     "effectiveAnticipator": 0.5
   }
 }
+```
+
 ### Algorithms
 - **Single Setpoint**:
   - Uses `setpoint`, `diff`, and `anticipator`.