@bldgblocks/node-red-contrib-control 0.1.4

package/nodes/changeover-block.html

@@ -0,0 +1,234 @@
+<script type="text/html" data-template-name="changeover-block">
+    <div class="form-row">
+        <label for="node-input-name" title="Display name shown on the canvas"><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-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>
+    </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>
+        <input type="text" id="node-input-setpoint" class="node-input-typed" placeholder="70">
+        <input type="hidden" id="node-input-setpointType">
+    </div>
+    <div class="form-row single-only">
+        <label for="node-input-deadband" title="Temperature range for no action (positive number)"><i class="fa fa-arrows-v"></i> Deadband</label>
+        <input type="text" id="node-input-deadband" placeholder="2">
+    </div>
+    <div class="form-row split-only" style="display: none;">
+        <label for="node-input-heatingSetpoint" title="Heating setpoint for split algorithm (number from num, msg, flow, or global)"><i class="fa fa-thermometer-empty"></i> Heating Setpoint</label>
+        <input type="text" id="node-input-heatingSetpoint" class="node-input-typed" placeholder="68">
+        <input type="hidden" id="node-input-heatingSetpointType">
+    </div>
+    <div class="form-row split-only" style="display: none;">
+        <label for="node-input-coolingSetpoint" title="Cooling setpoint for split algorithm (number from num, msg, flow, or global)"><i class="fa fa-thermometer-full"></i> Cooling Setpoint</label>
+        <input type="text" id="node-input-coolingSetpoint" class="node-input-typed" placeholder="74">
+        <input type="hidden" id="node-input-coolingSetpointType">
+    </div>
+    <div class="form-row split-only" style="display: none;">
+        <div id="split-setpoint-warning" style="color: red; display: none; margin-top: 5px;">
+            Cooling setpoint must be greater than heating setpoint
+        </div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-extent" title="Extra buffer mode switching thresholds (non-negative number)"><i class="fa fa-tachometer"></i> Extent</label>
+        <input type="text" id="node-input-extent" placeholder="1">
+    </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">
+        <input type="hidden" id="node-input-swapTimeType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-minTempSetpoint" title="Minimum allowable setpoint"><i class="fa fa-thermometer-empty"></i> Min Setpoint</label>
+        <input type="text" id="node-input-minTempSetpoint" placeholder="55">
+        <input type="hidden" id="node-input-minTempSetpointType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-maxTempSetpoint" title="Maximum allowable setpoint"><i class="fa fa-thermometer-full"></i> Max Setpoint</label>
+        <input type="text" id="node-input-maxTempSetpoint" placeholder="90">
+        <input type="hidden" id="node-input-maxTempSetpointType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-initWindow" title="Initialization window to collect inputs before mode selection (seconds, non-negative number)"><i class="fa fa-hourglass-start"></i> Init Window</label>
+        <input type="text" id="node-input-initWindow" placeholder="10">
+    </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>
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("changeover-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            algorithm: { value: "single" },
+            setpoint: { value: "70" },
+            setpointType: { value: "num" },
+            deadband: { value: "2" },
+            heatingSetpoint: { value: "68" },
+            heatingSetpointType: { value: "num" },
+            coolingSetpoint: { value: "74" },
+            coolingSetpointType: { value: "num" },
+            extent: { value: "1" },
+            swapTime: { value: "300" },
+            swapTimeType: { value: "num" },
+            minTempSetpoint: { value: "55" },
+            minTempSetpointType: { value: "num"},
+            maxTempSetpoint: { value: "90" },
+            maxTempSetpointType: { value: "num"},
+            initWindow: { value: "10" },
+            operationMode: { value: "auto" }
+        },
+        inputs: 1,
+        outputs: 2,
+        inputLabels: ["temperature"],
+        outputLabels: ["isHeating", "status"],
+        icon: "font-awesome/fa-retweet",
+        paletteLabel: "changeover",
+        label: function() {
+            return this.name || "changeover";
+        },
+        oneditprepare: function() {
+            const node = this;
+            const $algorithm = $("#node-input-algorithm");
+            const $singleFields = $(".single-only");
+            const $splitFields = $(".split-only");
+
+            try {
+                // Initialize typed inputs
+                $("#node-input-setpoint").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-setpointType"
+                }).typedInput("type", node.setpointType || "num").typedInput("value", node.setpoint);
+
+                $("#node-input-heatingSetpoint").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-heatingSetpointType"
+                }).typedInput("type", node.heatingSetpointType || "num").typedInput("value", node.heatingSetpoint);
+
+                $("#node-input-coolingSetpoint").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-coolingSetpointType"
+                }).typedInput("type", node.coolingSetpointType || "num").typedInput("value", node.coolingSetpoint);
+
+                $("#node-input-swapTime").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-swapTimeType"
+                }).typedInput("type", node.swapTimeType || "num").typedInput("value", node.swapTime);
+
+                $("#node-input-minTempSetpoint").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-minTempSetpointType"
+                }).typedInput("type", node.minTempSetpointType || "num").typedInput("value", node.minTempSetpoint);
+
+                $("#node-input-maxTempSetpoint").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-maxTempSetpointType"
+                }).typedInput("type", node.maxTempSetpointType || "num").typedInput("value", node.maxTempSetpoint);
+
+                // Toggle fields based on algorithm
+                function toggleFields() {
+                    if ($algorithm.val() === "single") {
+                        $singleFields.show();
+                        $splitFields.hide();
+                        $("#split-setpoint-warning").hide();
+                    } else {
+                        $singleFields.hide();
+                        $splitFields.show();
+                    }
+                }
+
+                $algorithm.on("change", toggleFields);
+                toggleFields();
+
+                // Validate non-typed inputs
+                $("#node-input-deadband").on("input", function() {
+                    const val = parseFloat($(this).val());
+                    $(this).toggleClass("input-error", isNaN(val) || val <= 0);
+                });
+
+                $("#node-input-extent").on("input", function() {
+                    const val = parseFloat($(this).val());
+                    $(this).toggleClass("input-error", isNaN(val) || val < 0);
+                });
+
+                $("#node-input-initWindow").on("input", function() {
+                    const val = parseFloat($(this).val());
+                    $(this).toggleClass("input-error", isNaN(val) || val < 0);
+                });
+                
+            } catch (err) {
+                console.error("Error in changeover-block oneditprepare:", err);
+            }
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="changeover-block">
+Manages HVAC mode switching between heating and cooling based on temperature inputs and setpoint configurations.
+
+### Inputs
+: context (string) : Configuration commands - (`"operationMode"`, `"algorithm"`, `"setpoint"`, `"deadband"`, `"heatingSetpoint"`, `"coolingSetpoint"`, `"extent"`, `"swapTime"`, `"minTempSetpoint"`, `"maxTempSetpoint"`, `"initWindow"`). Unknown values trigger a warning.
+: payload (number | string) : Temperature for mode evaluation; configuration value with `msg.context`.
+
+### Outputs
+: isHeating (boolean) : `true` for heating, `false` for cooling, with `msg.context = "isHeating"`.
+: status (object) : `{ mode, isHeating, heatingSetpoint, coolingSetpoint, temperature }`.
+
+### Algorithms
+The node supports two algorithms for determining HVAC mode
+
+- **Single Setpoint**
+  - Uses a single `setpoint`, `deadband`, and `extent`.
+  - **Heating** is triggered if the input temperature is below `setpoint - deadband/2 - extent`.
+  - **Cooling** is triggered if the temperature exceeds `setpoint + deadband/2 + extent`.
+  - Example With `setpoint=70`, `deadband=2`, `extent=1`, heating starts below `70 - 2/2 - 1 = 68`, and cooling starts above `70 + 2/2 + 1 = 72`.
+  - The `extent` widens thresholds to prevent nuisance mode changes due to overshoot.
+
+- **Split Setpoint**
+  - Uses separate `heatingSetpoint`, `coolingSetpoint`, and `extent`.
+  - **Heating** is triggered if the temperature is below `heatingSetpoint - extent`.
+  - **Cooling** is triggered if the temperature exceeds `coolingSetpoint + extent`.
+  - Example With `heatingSetpoint=68`, `coolingSetpoint=74`, `extent=1`, heating starts below `68 - 1 = 67`, and cooling starts above `74 + 1 = 75`.
+  - Ensures `coolingSetpoint >= heatingSetpoint` to avoid overlap.
+
+### Details
+Controls HVAC mode (heating or cooling) based on `msg.payload` temperature compared to setpoints. 
+Utilizes a delay on startup for sensor normalization and caches the last temperature to make an immediate decision after the `initWindow` period.
+
+- In **auto** mode, the node switches modes based on the algorithm thresholds, requiring the condition to persist for `swapTime` seconds (minimum 60s). A countdown is shown (e.g., `pending cooling in 120s`).
+- In **heat** or **cool** mode, the node locks to heating or cooling, respectively, ignoring temperature inputs.
+- The `extent` widens switching thresholds to prevent unnecessary mode changes while allowing sharing of `deadband` with global variables and other nodes.
+- Configuration options can be set via the editor or `msg.context`
+- Effective setpoints (`effectiveHeatingThreshold`, `effectiveCoolingThreshold`) are always displayed in "Effective Setpoints" for both new and active nodes, 
+showing the calculated mode-switching thresholds.
+
+### 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/changeover-block.js

@@ -0,0 +1,392 @@
+module.exports = function(RED) {
+    function ChangeoverBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name,
+            algorithm: config.algorithm,
+            deadband: parseFloat(config.deadband),
+            extent: parseFloat(config.extent),
+            minTempSetpoint: parseFloat(config.minTempSetpoint),
+            maxTempSetpoint: parseFloat(config.maxTempSetpoint),
+            operationMode: config.operationMode,
+            initWindow: parseFloat(config.initWindow),
+            currentMode: (config.operationMode === "cool" ? "cooling" : "heating"),
+            lastTemperature: null,
+            lastModeChange: 0
+        };
+
+        // Initialize state
+        let initComplete = false;
+        let conditionStartTime = null;
+        let pendingMode = null;
+        const initStartTime = Date.now() / 1000;
+
+        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;
+            }
+
+            // Resolve typed inputs
+            let minTemp = node.runtime.minTempSetpoint;
+            let maxTemp = node.runtime.maxTempSetpoint;
+
+            if (node.runtime.algorithm === "single") {
+                node.runtime.setpoint = RED.util.evaluateNodeProperty(
+                    config.setpoint, config.setpointType, node, msg
+                );
+                node.runtime.setpoint = parseFloat(node.runtime.setpoint);
+            } else {
+                node.runtime.heatingSetpoint = RED.util.evaluateNodeProperty(
+                    config.heatingSetpoint, config.heatingSetpointType, node, msg
+                );
+                node.runtime.heatingSetpoint = parseFloat(node.runtime.heatingSetpoint);
+
+                node.runtime.coolingSetpoint = RED.util.evaluateNodeProperty(
+                    config.coolingSetpoint, config.coolingSetpointType, node, msg
+                );
+                node.runtime.coolingSetpoint = parseFloat(node.runtime.coolingSetpoint);
+
+                // Validate
+                if (node.runtime.coolingSetpoint < node.runtime.heatingSetpoint) {
+                    node.runtime.coolingSetpoint = node.runtime.heatingSetpoint + 4;
+                    node.status({ fill: "red", shape: "ring", text: "invalid setpoints, using fallback" });
+                }
+            }
+            
+            node.runtime.swapTime = RED.util.evaluateNodeProperty(
+                config.swapTime, config.swapTimeType, node, msg
+            );
+            node.runtime.swapTime = parseFloat(node.runtime.swapTime);
+
+            if (node.runtime.swapTime < 60) {
+                node.runtime.swapTime = 60;
+                node.status({ fill: "red", shape: "ring", text: "swapTime below 60s, using 60" });
+            }
+
+            if (msg.hasOwnProperty("context")) {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+                    if (done) done();
+                    return;
+                }
+
+                const value = parseFloat(msg.payload);
+                switch (msg.context) {
+                    case "operationMode":
+                        if (!["auto", "heat", "cool"].includes(msg.payload)) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid operationMode" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.operationMode = msg.payload;
+                        node.status({ fill: "green", shape: "dot", text: `in: operationMode=${msg.payload}, out: ${node.runtime.currentMode}` });
+                        break;
+                    case "algorithm":
+                        if (!["single", "split"].includes(msg.payload)) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid algorithm" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.algorithm = msg.payload;
+                        node.status({ fill: "green", shape: "dot", text: `in: algorithm=${msg.payload}, out: ${node.runtime.currentMode}` });
+                        break;
+                    case "setpoint":
+                        if (node.runtime.algorithm !== "single") {
+                            node.status({ fill: "red", shape: "ring", text: "setpoint not used in split algorithm" });
+                            if (done) done();
+                            return;
+                        }
+                        if (isNaN(value) || value < minTemp || value > maxTemp) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid setpoint" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.setpoint = value.toString();
+                        node.runtime.setpointType = "num";
+                        node.status({ fill: "green", shape: "dot", text: `in: setpoint=${value.toFixed(1)}, out: ${node.runtime.currentMode}` });
+                        break;
+                    case "deadband":
+                        if (node.runtime.algorithm !== "single") {
+                            node.status({ fill: "red", shape: "ring", text: "deadband not used in split algorithm" });
+                            if (done) done();
+                            return;
+                        }
+                        if (isNaN(value) || value <= 0) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid deadband" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.deadband = value;
+                        node.status({ fill: "green", shape: "dot", text: `in: deadband=${value.toFixed(1)}, out: ${node.runtime.currentMode}` });
+                        break;
+                    case "heatingSetpoint":
+                        if (node.runtime.algorithm !== "split") {
+                            node.status({ fill: "red", shape: "ring", text: "heatingSetpoint not used in single algorithm" });
+                            if (done) done();
+                            return;
+                        }
+                        if (isNaN(value) || value < minTemp || value > maxTemp || value > node.runtime.coolingSetpoint) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid heatingSetpoint" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.heatingSetpoint = value.toString();
+                        node.runtime.heatingSetpointType = "num";
+                        node.status({ fill: "green", shape: "dot", text: `in: heatingSetpoint=${value.toFixed(1)}, out: ${node.runtime.currentMode}` });
+                        break;
+                    case "coolingSetpoint":
+                        if (node.runtime.algorithm !== "split") {
+                            node.status({ fill: "red", shape: "ring", text: "coolingSetpoint not used in single algorithm" });
+                            if (done) done();
+                            return;
+                        }
+                        if (isNaN(value) || value < minTemp || value > maxTemp || value < node.runtime.heatingSetpoint) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid coolingSetpoint" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.coolingSetpoint = value.toString();
+                        node.runtime.coolingSetpointType = "num";
+                        node.status({ fill: "green", shape: "dot", text: `in: coolingSetpoint=${value.toFixed(1)}, out: ${node.runtime.currentMode}` });
+                        break;
+                    case "extent":
+                        if (isNaN(value) || value < 0) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid extent" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.extent = value;
+                        node.status({ fill: "green", shape: "dot", text: `in: extent=${value.toFixed(1)}, out: ${node.runtime.currentMode}` });
+                        break;
+                    case "swapTime":
+                        if (isNaN(value) || value < 60) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid swapTime, minimum 60s" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.swapTime = value.toString();
+                        node.runtime.swapTimeType = "num";
+                        node.status({ fill: "green", shape: "dot", text: `in: swapTime=${value.toFixed(0)}, out: ${node.runtime.currentMode}` });
+                        break;
+                    case "minTempSetpoint":
+                        if (isNaN(value) || value >= node.runtime.maxTempSetpoint ||
+                            (node.runtime.algorithm === "single" && value > node.runtime.setpoint) ||
+                            (node.runtime.algorithm === "split" && (value > node.runtime.heatingSetpoint || value > node.runtime.coolingSetpoint))) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid minTempSetpoint" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.minTempSetpoint = value;
+                        node.status({ fill: "green", shape: "dot", text: `in: minTempSetpoint=${value.toFixed(1)}, out: ${node.runtime.currentMode}` });
+                        break;
+                    case "maxTempSetpoint":
+                        if (isNaN(value) || value <= node.runtime.minTempSetpoint ||
+                            (node.runtime.algorithm === "single" && value < node.runtime.setpoint) ||
+                            (node.runtime.algorithm === "split" && (value < node.runtime.heatingSetpoint || value < node.runtime.coolingSetpoint))) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid maxTempSetpoint" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.maxTempSetpoint = value;
+                        node.status({ fill: "green", shape: "dot", text: `in: maxTempSetpoint=${value.toFixed(1)}, out: ${node.runtime.currentMode}` });
+                        break;
+                    case "initWindow":
+                        if (isNaN(value) || value < 0) {
+                            node.status({ fill: "red", shape: "ring", text: "invalid initWindow" });
+                            if (done) done();
+                            return;
+                        }
+                        node.runtime.initWindow = value;
+                        node.status({ fill: "green", shape: "dot", text: `in: initWindow=${value.toFixed(0)}, out: ${node.runtime.currentMode}` });
+                        break;
+                    default:
+                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        if (done) done();
+                        return;
+                }
+                conditionStartTime = null;
+                pendingMode = null;
+
+                send(evaluateState() || buildOutputs());
+                if (done) done();
+                return;
+            }
+
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing temperature" });
+                if (done) done();
+                return;
+            }
+
+            let input = parseFloat(msg.payload);
+            if (isNaN(input)) {
+                node.status({ fill: "red", shape: "ring", text: "invalid temperature" });
+                if (done) done();
+                return;
+            }
+            
+            if (node.runtime.lastTemperature !== input) {
+                node.runtime.lastTemperature = input;
+            }
+
+            const now = Date.now() / 1000;
+            if (!initComplete && now - initStartTime >= node.runtime.initWindow) {
+                initComplete = true;
+                evaluateInitialMode();
+            }
+
+            if (!initComplete) {
+                updateStatus();
+                if (done) done();
+                return;
+            }
+
+
+
+            send(evaluateState() || buildOutputs());
+            updateStatus();
+            if (done) done();
+        });
+
+        function evaluateInitialMode() {
+            if (node.runtime.lastTemperature === null) return;
+            const temp = node.runtime.lastTemperature;
+            let newMode = node.runtime.currentMode;
+
+            if (node.runtime.operationMode === "heat") {
+                newMode = "heating";
+            } else if (node.runtime.operationMode === "cool") {
+                newMode = "cooling";
+            } else {
+                let heatingThreshold, coolingThreshold;
+                if (node.runtime.algorithm === "single") {
+                    heatingThreshold = node.runtime.setpoint - node.runtime.deadband / 2 - node.runtime.extent;
+                    coolingThreshold = node.runtime.setpoint + node.runtime.deadband / 2 + node.runtime.extent;
+                } else {
+                    heatingThreshold = node.runtime.heatingSetpoint - node.runtime.extent;
+                    coolingThreshold = node.runtime.coolingSetpoint + node.runtime.extent;
+                }
+
+                if (temp < heatingThreshold) {
+                    newMode = "heating";
+                } else if (temp > coolingThreshold) {
+                    newMode = "cooling";
+                }
+            }
+
+            node.runtime.currentMode = newMode;
+            node.runtime.lastModeChange = Date.now() / 1000;
+        }
+
+        function evaluateState() {
+            const now = Date.now() / 1000;
+            if (!initComplete) return null;
+
+            let newMode = node.runtime.currentMode;
+            if (node.runtime.operationMode === "heat") {
+                newMode = "heating";
+                conditionStartTime = null;
+                pendingMode = null;
+            } else if (node.runtime.operationMode === "cool") {
+                newMode = "cooling";
+                conditionStartTime = null;
+                pendingMode = null;
+            } else if (node.runtime.lastTemperature !== null) {
+                let heatingThreshold, coolingThreshold;
+                if (node.runtime.algorithm === "single") {
+                    heatingThreshold = node.runtime.setpoint - node.runtime.deadband / 2 - node.runtime.extent;
+                    coolingThreshold = node.runtime.setpoint + node.runtime.deadband / 2 + node.runtime.extent;
+                } else {
+                    heatingThreshold = node.runtime.heatingSetpoint - node.runtime.extent;
+                    coolingThreshold = node.runtime.coolingSetpoint + node.runtime.extent;
+                }
+
+                let desiredMode = node.runtime.currentMode;
+                if (node.runtime.lastTemperature < heatingThreshold) {
+                    desiredMode = "heating";
+                } else if (node.runtime.lastTemperature > coolingThreshold) {
+                    desiredMode = "cooling";
+                }
+
+                if (desiredMode !== node.runtime.currentMode) {
+                    if (pendingMode !== desiredMode) {
+                        conditionStartTime = now;
+                        pendingMode = desiredMode;
+                    } else if (conditionStartTime && now - conditionStartTime >= node.runtime.swapTime) {
+                        newMode = desiredMode;
+                        conditionStartTime = null;
+                        pendingMode = null;
+                    }
+                } else {
+                    conditionStartTime = null;
+                    pendingMode = null;
+                }
+            }
+
+            if (newMode !== node.runtime.currentMode) {
+                node.runtime.currentMode = newMode;
+                node.runtime.lastModeChange = now;
+            }
+
+            return null;
+        }
+
+        function buildOutputs() {
+            const isHeating = node.runtime.currentMode === "heating";
+            let heatingSetpoint, coolingSetpoint;
+            if (node.runtime.algorithm === "single") {
+                heatingSetpoint = node.runtime.setpoint - node.runtime.deadband / 2;
+                coolingSetpoint = node.runtime.setpoint + node.runtime.deadband / 2;
+            } else {
+                heatingSetpoint = node.runtime.heatingSetpoint;
+                coolingSetpoint = node.runtime.coolingSetpoint;
+            }
+
+            return [
+                { payload: isHeating, context: "isHeating" },
+                {
+                    payload: {
+                        mode: node.runtime.currentMode,
+                        isHeating,
+                        heatingSetpoint,
+                        coolingSetpoint,
+                        temperature: node.runtime.lastTemperature
+                    }
+                }
+            ];
+        }
+
+        function updateStatus() {
+            const now = Date.now() / 1000;
+            const inInitWindow = !initComplete && now - initStartTime < node.runtime.initWindow;
+
+            if (inInitWindow) {
+                node.status({ fill: "yellow", shape: "ring", text: `initializing, out: ${node.runtime.currentMode}` });
+            } else {
+                let statusText = `in: temp=${node.runtime.lastTemperature !== null ? node.runtime.lastTemperature.toFixed(1) : "unknown"}, out: ${node.runtime.currentMode}`;
+                if (pendingMode && conditionStartTime) {
+                    const remaining = Math.max(0, node.runtime.swapTime - (now - conditionStartTime));
+                    statusText += `, pending: ${pendingMode} in ${remaining.toFixed(0)}s`;
+                }
+                node.status({
+                    fill: "blue",
+                    shape: now - node.runtime.lastModeChange < 1 ? "dot" : "ring",
+                    text: statusText
+                });
+            }
+        }
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("changeover-block", ChangeoverBlockNode);
+};