@bldgblocks/node-red-contrib-control 0.1.4

package/nodes/frequency-block.html

@@ -0,0 +1,55 @@
+<!-- UI Template Section: Defines the edit dialog -->
+<script type="text/html" data-template-name="frequency-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>
+</script>
+
+<!-- JavaScript Section: Registers the node and handles editor logic -->
+<script type="text/javascript">
+    RED.nodes.registerType("frequency-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["stats"],
+        icon: "font-awesome/fa-tachometer",
+        paletteLabel: "frequency",
+        label: function() {
+            return this.name || "frequency";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="frequency-block">
+Measures pulse frequency from boolean rising edges.
+
+### Inputs
+: context (string) : Resets state (`"reset"`). Unmatched values trigger error.
+: payload (boolean) : Input boolean to detect rising edges (`true` for pulse).
+
+### Outputs
+: payload (object) : Pulse rates `{ ppm, pph, ppd }` (pulses per minute, hour, day).
+
+### 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 
+(first edge sets baseline). Resets state via `msg.context = "reset"` with `msg.payload = true`.
+
+### Status
+- Green (dot): Configuration
+- Blue (dot): Output, no alarm
+- Red (dot): Output with alarm
+- Red (ring): Errors
+- Yellow (ring): Unknown context
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/frequency-block.js

@@ -0,0 +1,140 @@
+module.exports = function(RED) {
+    function FrequencyBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name || "",
+            lastIn: false,
+            lastEdge: 0,
+            completeCycle: false,
+            ppm: 0,
+            pph: 0,
+            ppd: 0
+        };
+
+        node.status({ 
+            fill: "green", 
+            shape: "dot", 
+            text: "awaiting first pulse" 
+        });
+
+        // FEATURE: I want a runtime percentage per hour duty cycle
+
+        node.on("input", function(msg, send, done) {
+            send = send || function() { node.send.apply(node, arguments); };
+
+            // Guard against invalid message
+            if (!msg) {
+                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                if (done) done();
+                return;
+            }
+
+            // Handle context updates
+            if (msg.hasOwnProperty("context")) {
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: "missing payload for reset" });
+                    if (done) done();
+                    return;
+                }
+                if (msg.context === "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.lastIn = false;
+                        node.runtime.lastEdge = 0;
+                        node.runtime.completeCycle = false;
+                        node.runtime.ppm = 0;
+                        node.runtime.pph = 0;
+                        node.runtime.ppd = 0;
+                        node.status({ fill: "green", shape: "dot", text: "reset" });
+                    }
+                    if (done) done();
+                    return;
+                } else {
+                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    if (done) done("Unknown context");
+                    return;
+                }
+            }
+
+            // Validate input payload
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+
+            const inputValue = msg.payload;
+            if (typeof inputValue !== "boolean") {
+                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+                if (done) done();
+                return;
+            }
+
+            // Initialize output
+            let output = {
+                ppm: node.runtime.ppm,
+                pph: node.runtime.pph,
+                ppd: node.runtime.ppd
+            };
+
+            // Detect rising edge
+            if (inputValue && !node.runtime.lastIn) { // Rising edge: true and lastIn was false
+                let now = Date.now();
+                if (!node.runtime.completeCycle) {
+                    node.runtime.completeCycle = true;
+                } else {
+                    // Compute period in minutes
+                    let periodMs = now - node.runtime.lastEdge;
+                    let periodMin = periodMs / 60000;
+                    if (periodMin > 0.001) {
+                        // Minimum 0.6ms period (1000 pulses/sec)
+                        output.ppm = 1 / periodMin; // Pulses per minute
+                        output.pph = output.ppm * 60; // Pulses per hour
+                        output.ppd = output.ppm * 1440; // Pulses per day
+                    } else {
+                        // Handle ultra-high frequency
+                        output.ppm = 1000;
+                        output.pph = 60000;
+                        output.ppd = 1440000;
+                    }
+                    node.runtime.ppm = output.ppm;
+                    node.runtime.pph = output.pph;
+                    node.runtime.ppd = output.ppd;
+                }
+                node.runtime.lastEdge = now;
+                node.runtime.completeCycle = true;
+
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: `ppm: ${output.ppm.toFixed(2)}, pph: ${output.pph.toFixed(2)}, ppd: ${output.ppd.toFixed(2)}`
+                });
+                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)}`
+                });
+            }
+
+            // Update lastIn
+            node.runtime.lastIn = inputValue;
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("frequency-block", FrequencyBlockNode);
+};

package/nodes/hysteresis-block.html

@@ -0,0 +1,131 @@
+<!-- UI Template Section: Defines the edit dialog -->
+<script type="text/html" data-template-name="hysteresis-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-upperLimit"><i class="fa fa-arrow-up"></i> Upper Limit (turn on)</label>
+        <input type="text" id="node-input-upperLimit" placeholder="50">
+        <input type="hidden" id="node-input-upperLimitType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-upperLimitThreshold"><i class="fa fa-arrows-h"></i> Upper Differential (turn off)</label>
+        <input type="text" id="node-input-upperLimitThreshold" placeholder="2">
+        <input type="hidden" id="node-input-upperLimitThresholdType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-lowerLimit"><i class="fa fa-arrow-down"></i> Lower Limit (turn on)</label>
+        <input type="text" id="node-input-lowerLimit" placeholder="30">
+        <input type="hidden" id="node-input-lowerLimitType">
+    </div>
+    <div class="form-row">
+        <label for="node-input-lowerLimitThreshold"><i class="fa fa-arrows-h"></i> Lower Differential (turn off)</label>
+        <input type="text" id="node-input-lowerLimitThreshold" placeholder="2">
+        <input type="hidden" id="node-input-lowerLimitThresholdType">
+    </div>
+</script>
+
+
+<!-- JavaScript Section: Registers the node and handles editor logic -->
+<script type="text/javascript">
+    RED.nodes.registerType("hysteresis-block", {
+    category: "control",
+    color: "#301934",
+    defaults: {
+        name: { value: "" },
+        upperLimit: { value: 50, required: true },
+        upperLimitType: { value: "num" },
+        lowerLimit: { value: 30, required: true },
+        lowerLimitType: { value: "num" },
+        upperLimitThreshold: { value: 2, required: true },
+        upperLimitThresholdType: { value: "num" },
+        lowerLimitThreshold: { value: 2, required: true },
+        lowerLimitThresholdType: { value: "num" }
+    },
+    inputs: 1,
+    outputs: 3,
+    inputLabels: ["input"],
+    outputLabels: ["above", "within", "below"],
+    icon: "font-awesome/fa-toggle-on",
+    paletteLabel: "hysteresis",
+    label: function() {
+        return this.name || "hysteresis";
+    },
+    oneditprepare: function() {
+        const node = this;
+
+        try {
+            // Initialize typed inputs
+            $("#node-input-upperLimit").typedInput({
+                default: "num",
+                types: ["num", "msg", "flow", "global"],
+                typeField: "#node-input-upperLimitType"
+            }).typedInput("type", node.upperLimitType || "num").typedInput("value", node.upperLimit);
+
+            $("#node-input-lowerLimit").typedInput({
+                default: "num",
+                types: ["num", "msg", "flow", "global"],
+                typeField: "#node-input-lowerLimitType"
+            }).typedInput("type", node.lowerLimitType || "num").typedInput("value", node.lowerLimit);
+
+            $("#node-input-upperLimitThreshold").typedInput({
+                default: "num",
+                types: ["num", "msg", "flow", "global"],
+                typeField: "#node-input-upperLimitThresholdType"
+            }).typedInput("type", node.upperLimitThresholdType || "num").typedInput("value", node.upperLimitThreshold);
+
+            $("#node-input-lowerLimitThreshold").typedInput({
+                default: "num",
+                types: ["num", "msg", "flow", "global"],
+                typeField: "#node-input-lowerLimitThresholdType"
+            }).typedInput("type", node.lowerLimitThresholdType || "num").typedInput("value", node.lowerLimitThreshold);
+
+        } catch (err) {
+            console.error("Error in hysteresis-block oneditprepare:", err);
+        }
+    }
+});
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="hysteresis-block">
+Hysteresis controller with separate turn-on limits and turn-off differentials.
+
+### Inputs
+: payload (number) : Input value to evaluate
+: context (string) : Configure `upperLimit`, `lowerLimit`, `upperLimitThreshold`, `lowerLimitThreshold`
+
+### Outputs
+: above (boolean) : Input > upperLimit
+: within (boolean) : lowerLimit ≤ input ≤ upperLimit  
+: below (boolean) : Input < lowerLimit
+
+### Properties
+: upperLimit (number) : Turn on "above" state when input exceeds this value
+: upperLimitThreshold (number) : Turn off "above" state when input drops below (upperLimit - this value)
+: lowerLimit (number) : Turn on "below" state when input drops below this value  
+: lowerLimitThreshold (number) : Turn off "below" state when input rises above (lowerLimit + this value)
+
+### Hysteresis Behavior
+- **Above**: Turns on at upperLimit, turns off at (upperLimit - upperLimitThreshold)
+- **Below**: Turns on at lowerLimit, turns off at (lowerLimit + lowerLimitThreshold)  
+- **Within**: State between turn-off points
+
+### Example: Temperature Control
+- upperLimit: 75°F (turn on cooling)
+- upperLimitThreshold: 2°F (turn off cooling at 73°F)  
+- lowerLimit: 65°F (turn on heating)
+- lowerLimitThreshold: 2°F (turn off heating at 67°F)
+
+### 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/hysteresis-block.js

@@ -0,0 +1,142 @@
+module.exports = function(RED) {
+    function HysteresisBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        node.name = config.name;
+        node.state = "within";
+
+        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;
+            }
+
+            // Evaluate typed-inputs
+            try {
+                node.upperLimit = RED.util.evaluateNodeProperty(
+                    config.upperLimit, config.upperLimitType, node, msg
+                );
+                node.lowerLimit = RED.util.evaluateNodeProperty(
+                    config.lowerLimit, config.lowerLimitType, node, msg
+                );
+                node.upperLimitThreshold = RED.util.evaluateNodeProperty(
+                    config.upperLimitThreshold, config.upperLimitThresholdType, node, msg
+                );
+                node.lowerLimitThreshold = RED.util.evaluateNodeProperty(
+                    config.lowerLimitThreshold, config.lowerLimitThresholdType, node, msg
+                );
+                
+                // Validate values
+                if (isNaN(node.upperLimit) || isNaN(node.lowerLimit) || 
+                    isNaN(node.upperLimitThreshold) || isNaN(node.lowerLimitThreshold) ||
+                    node.upperLimit <= node.lowerLimit ||
+                    node.upperLimitThreshold < 0 || node.lowerLimitThreshold < 0) {
+                    node.status({ fill: "red", shape: "ring", text: "invalid evaluated values" });
+                    if (done) done();
+                    return;
+                }
+            } catch(err) {
+                node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });
+                if (done) done(err);
+                return;
+            }
+
+            if (msg.hasOwnProperty("context")) {
+                if (msg.context === "upperLimitThreshold") {
+                    const value = parseFloat(msg.payload);
+                    if (!isNaN(value) && value >= 0) {
+                        node.upperLimitThreshold = value;
+                        node.status({ fill: "green", shape: "dot", text: `upperLimitThreshold: ${value}` });
+                    }
+                } else if (msg.context === "lowerLimitThreshold") {
+                    const value = parseFloat(msg.payload);
+                    if (!isNaN(value) && value >= 0) {
+                        node.lowerLimitThreshold = value;
+                        node.status({ fill: "green", shape: "dot", text: `lowerLimitThreshold: ${value}` });
+                    }
+                }
+                if (done) done();
+                return;
+            }
+
+            if (!msg.hasOwnProperty("payload")) {
+                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                if (done) done();
+                return;
+            }
+            const inputValue = parseFloat(msg.payload);
+            if (isNaN(inputValue)) {
+                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+                if (done) done();
+                return;
+            }
+
+            // Calculate all boundary points - ensure numeric values
+            const upperTurnOn = node.upperLimit;
+            const upperTurnOff = node.upperLimit - node.upperLimitThreshold;
+            const lowerTurnOn = node.lowerLimit;
+            const lowerTurnOff = node.lowerLimit + node.lowerLimitThreshold;
+
+            // Add validation to ensure numbers
+            if (isNaN(upperTurnOn) || isNaN(upperTurnOff) || isNaN(lowerTurnOn) || isNaN(lowerTurnOff)) {
+                node.status({ fill: "red", shape: "ring", text: "invalid boundary calculation" });
+                if (done) done();
+                return;
+            }
+            // Apply comprehensive hysteresis logic
+            let newState = node.state;
+
+            switch (node.state) {
+                case "above":
+                    if (inputValue <= upperTurnOff) {
+                        newState = "within";
+                        if (inputValue <= lowerTurnOn) {
+                            newState = "below"; 
+                        }
+                    }
+                    break;
+                case "below":
+                    if (inputValue >= lowerTurnOff) {
+                        newState = "within";
+                        if (inputValue >= upperTurnOn) {
+                            newState = "above";
+                        }
+                    }
+                    break;
+                case "within":
+                    if (inputValue >= upperTurnOn) {
+                        newState = "above";
+                    } else if (inputValue <= lowerTurnOn) {
+                        newState = "below";
+                    }
+                    break;
+                }
+
+            const output = [
+                { payload: newState === "above" },
+                { payload: newState === "within" },
+                { payload: newState === "below" }
+            ];
+
+            node.status({
+                fill: "blue",
+                shape: "dot",
+                text: `in: ${inputValue.toFixed(2)}, state: ${newState}`
+            });
+
+            node.state = newState;
+            send(output);
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("hysteresis-block", HysteresisBlockNode);
+};

package/nodes/interpolate-block.html

@@ -0,0 +1,74 @@
+<script type="text/html" data-template-name="interpolate-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-points" title="Default points table for interpolation (array of {x, y} objects, ≥2 points)"><i class="fa fa-table"></i> Points</label>
+        <textarea id="node-input-points" placeholder='[{"x": 0, "y": 0}, {"x": 100, "y": 100}]' style="height: 100px;"></textarea>
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType("interpolate-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            points: {
+                value: JSON.stringify([{ x: 0, y: 0 }, { x: 100, y: 100 }], null, 2),
+                required: true,
+                validate: function(v) {
+                    try {
+                        const points = JSON.parse(v);
+                        return Array.isArray(points) && points.length >= 2 &&
+                               points.every(p => typeof p.x === "number" && !isNaN(p.x) &&
+                                                 typeof p.y === "number" && !isNaN(p.y));
+                    } catch (e) {
+                        return false;
+                    }
+                }
+            }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-line-chart",
+        paletteLabel: "interpolate",
+        label: function() {
+            return this.name ? `${this.name} (${this.points ? JSON.parse(this.points).length : 2})` : `interpolate (${this.points ? JSON.parse(this.points).length : 2})`;
+        }
+    });
+</script>
+
+<script type="text/markdown" data-help-name="interpolate-block">
+Linearly interpolates a numeric input using a configurable points table.
+
+### Inputs
+: context (string) : Configures points table (`"points"`).
+: payload (number | array) : Number for interpolation, or array of `{x, y}` objects for points configuration.
+
+### Outputs
+: payload (number) : Interpolated output value.
+
+### Details
+Interpolates a numeric `msg.payload` using a table of `{x, y}` points. 
+
+Points are set via editor or `msg.context = "points"` with an array of ≥2 `{x, y}` objects (x and y as numbers). 
+
+Outputs only when the interpolated value changes. 
+
+Input must be within the x-range of points; out-of-range inputs are rejected. 
+
+### Status
+- Green (dot): Configuration
+- Blue (dot): Output, no alarm
+- Red (dot): Output with alarm
+- Red (ring): Errors
+- Yellow (ring): Unknown context
+
+### References
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
+</script>

package/nodes/interpolate-block.js

@@ -0,0 +1,141 @@
+module.exports = function(RED) {
+    function InterpolateBlockNode(config) {
+        RED.nodes.createNode(this, config);
+        
+        const node = this;
+        
+        // Initialize runtime state
+        node.runtime = {
+            name: config.name || "interpolate",
+            points: null,
+            lastOutput: null
+        };
+
+        // Initialize points
+        try {
+            node.runtime.points = config.points ? JSON.parse(config.points) : [{ x: 0, y: 0 }, { x: 100, y: 100 }];
+            if (!Array.isArray(node.runtime.points) || node.runtime.points.length < 2 ||
+                !node.runtime.points.every(p => typeof p.x === "number" && !isNaN(p.x) &&
+                                                typeof p.y === "number" && !isNaN(p.y))) {
+                node.runtime.points = [{ x: 0, y: 0 }, { x: 100, y: 100 }];
+                node.status({ fill: "red", shape: "ring", text: "invalid points, using default" });
+            } else {
+                node.status({
+                    fill: "green",
+                    shape: "dot",
+                    text: `name: ${node.runtime.name}, points: ${node.runtime.points.length}`
+                });
+            }
+        } catch (e) {
+            node.runtime.points = [{ x: 0, y: 0 }, { x: 100, y: 100 }];
+            node.status({ fill: "red", shape: "ring", text: "invalid points, using default" });
+        }
+
+        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;
+            }
+
+            // Handle configuration messages
+            if (msg.context) {
+                if (typeof msg.context !== "string" || !msg.context.trim()) {
+                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    if (done) done();
+                    return;
+                }
+                if (!msg.hasOwnProperty("payload")) {
+                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    if (done) done();
+                    return;
+                }
+                if (msg.context === "points") {
+                    try {
+                        const newPoints = Array.isArray(msg.payload) ? msg.payload : JSON.parse(msg.payload);
+                        if (Array.isArray(newPoints) && newPoints.length >= 2 &&
+                            newPoints.every(p => typeof p.x === "number" && !isNaN(p.x) &&
+                                                typeof p.y === "number" && !isNaN(p.y))) {
+                            node.runtime.points = newPoints;
+                            node.status({
+                                fill: "green",
+                                shape: "dot",
+                                text: `points: ${newPoints.length}`
+                            });
+                        } else {
+                            node.status({ fill: "red", shape: "ring", text: "invalid points" });
+                        }
+                    } catch (e) {
+                        node.status({ fill: "red", shape: "ring", text: "invalid points" });
+                    }
+                    if (done) done();
+                    return;
+                } else {
+                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    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);
+            if (isNaN(inputValue)) {
+                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                if (done) done();
+                return;
+            }
+
+            // Linear interpolation
+            let outputValue = NaN;
+            const isPositiveSlope = node.runtime.points.length >= 2 && node.runtime.points[1].x > node.runtime.points[0].x;
+
+            for (let i = 0; i < node.runtime.points.length - 1; i++) {
+                let x1 = node.runtime.points[i].x, y1 = node.runtime.points[i].y;
+                let x2 = node.runtime.points[i + 1].x, y2 = node.runtime.points[i + 1].y;
+                if (isPositiveSlope ? (inputValue >= x1 && inputValue <= x2) : (inputValue <= x1 && inputValue >= x2)) {
+                    let m = (y2 - y1) / (x2 - x1);
+                    let b = y1 - (m * x1);
+                    outputValue = (m * inputValue) + b;
+                    break;
+                }
+            }
+
+            if (isNaN(outputValue)) {
+                node.status({ fill: "red", shape: "ring", text: "input out of range" });
+                if (done) done();
+                return;
+            }
+
+            // Check if output value has changed
+            const isUnchanged = outputValue === node.runtime.lastOutput;
+            node.status({
+                fill: "blue",
+                shape: isUnchanged ? "ring" : "dot",
+                text: `in: ${inputValue.toFixed(2)}, out: ${outputValue.toFixed(2)}`
+            });
+
+            if (!isUnchanged) {
+                node.runtime.lastOutput = outputValue;
+                send({ payload: outputValue });
+            }
+
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("interpolate-block", InterpolateBlockNode);
+};