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

package/nodes/hysteresis-block.js

@@ -7,15 +7,12 @@ module.exports = function(RED) {
         node.name = config.name;
         node.state = "within";
 
-        const typedProperties = ['upperLimit', 'lowerLimit', 'upperLimitThreshold', 'lowerLimitThreshold'];
-
         // Evaluate typed-input properties    
         try {      
-            const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, null, true);
-            node.upperLimit = parseFloat(evaluatedValues.upperLimit);
-            node.lowerLimit = parseFloat(evaluatedValues.lowerLimit);
-            node.upperLimitThreshold = parseFloat(evaluatedValues.upperLimitThreshold);
-            node.lowerLimitThreshold = parseFloat(evaluatedValues.lowerLimitThreshold);
+            node.upperLimit = parseFloat(RED.util.evaluateNodeProperty( config.upperLimit, config.upperLimitType, node ));
+            node.lowerLimit = parseFloat(RED.util.evaluateNodeProperty( config.lowerLimit, config.lowerLimitType, node ));
+            node.upperLimitThreshold = parseFloat(RED.util.evaluateNodeProperty( config.upperLimitThreshold, config.upperLimitThresholdType, node ));
+            node.lowerLimitThreshold = parseFloat(RED.util.evaluateNodeProperty( config.lowerLimitThreshold, config.lowerLimitThresholdType, node ));
         } catch (err) {
             node.error(`Error evaluating properties: ${err.message}`);
         }
@@ -31,11 +28,18 @@ module.exports = function(RED) {
             
             // Update typed-input properties if needed
             try {           
-                const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, msg);
-                node.upperLimit = parseFloat(evaluatedValues.upperLimit);
-                node.lowerLimit = parseFloat(evaluatedValues.lowerLimit);
-                node.upperLimitThreshold = parseFloat(evaluatedValues.upperLimitThreshold);
-                node.lowerLimitThreshold = parseFloat(evaluatedValues.lowerLimitThreshold);
+                if (utils.requiresEvaluation(config.upperLimitType)) {
+                    node.upperLimit = parseFloat(RED.util.evaluateNodeProperty( config.upperLimit, config.upperLimitType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.lowerLimitType)) {
+                    node.lowerLimit = parseFloat(RED.util.evaluateNodeProperty( config.lowerLimit, config.lowerLimitType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.upperLimitThresholdType)) {
+                    node.upperLimitThreshold = parseFloat(RED.util.evaluateNodeProperty( config.upperLimitThreshold, config.upperLimitThresholdType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.lowerLimitThresholdType)) {
+                    node.lowerLimitThreshold = parseFloat(RED.util.evaluateNodeProperty( config.lowerLimitThreshold, config.lowerLimitThresholdType, node, msg ));
+                }
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();
@@ -80,7 +84,7 @@ module.exports = function(RED) {
 
             // Add validation to ensure numbers
             if (isNaN(upperTurnOn) || isNaN(upperTurnOff) || isNaN(lowerTurnOn) || isNaN(lowerTurnOff)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid boundary calculation" });
+                node.status({ fill: "red", shape: "ring", text: "invalid limits calculation" });
                 if (done) done();
                 return;
             }

package/nodes/latch-block.html

@@ -0,0 +1,55 @@
+<!-- UI Template Section -->
+<script type="text/html" data-template-name="latch-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 -->
+<script type="text/javascript">
+    RED.nodes.registerType("latch-block", {
+        category: "control",
+        color: "#301934",
+        defaults: {
+            name: { value: "" },
+            state: { value: false }
+        },
+        inputs: 1,
+        outputs: 1,
+        inputLabels: ["input"],
+        outputLabels: ["output"],
+        icon: "font-awesome/fa-toggle-on",
+        paletteLabel: "latch",
+        label: function() {
+            return this.name || "latch";
+        }
+    });
+</script>
+
+<!-- Help Section -->
+<script type="text/markdown" data-help-name="latch-block">
+Latch output based on control messages.
+
+### Inputs
+: context (string) : Configuration commands (`set`, `reset`).
+: payload (boolean) : `true` to set latch, `false` to reset latch when paired with appropriate `context`.
+
+### Outputs
+: output (msg) : `msg.payload` `true` or `false` based on latch state.
+
+### Details
+Set or reset the latch state based on input messages. `msg.context` = `"set"` with `msg.payload` = `true` 
+sets the latch `true`, while `msg.context` = `"reset"` with `msg.payload` = `true` resets it to `false`.
+
+### 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/latch-block.js

@@ -0,0 +1,77 @@
+module.exports = function(RED) {
+    function LatchBlockNode(config) {
+        RED.nodes.createNode(this, config);
+
+        const node = this;
+
+        // Initialize state from config
+        node.state = config.state;
+
+        // Set initial status
+        node.status({
+            fill: "green",
+            shape: "dot",
+            text: `state: ${node.state}`
+        });
+
+        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;
+            }
+
+            // Validate context
+            if (!msg.hasOwnProperty("context") || typeof msg.context !== "string") {
+                node.status({ fill: "red", shape: "ring", text: "missing or invalid context" });
+                if (done) done();
+                return;
+            }
+
+            // Handle context commands
+            switch (msg.context) {
+                case "set":
+                    if (node.state) {
+                        node.status({ fill: "blue", shape: "ring", text: `state: ${node.state}` });
+                    } else {
+                        if (msg.payload) {
+                            node.state = true;
+                            node.status({ fill: "blue", shape: "dot", text: `state: ${node.state}` });
+                        } else {
+                            node.status({ fill: "blue", shape: "ring", text: `state: ${node.state}` });
+                        }
+                    }
+                    // Output latch value regardless
+                    send({ payload: node.state });
+                    break;
+                case "reset":
+                    if (node.state === false) {
+                        node.status({ fill: "blue", shape: "ring", text: `state: ${node.state}` });
+                    } else {
+                        if (msg.payload) {
+                            node.state = false;
+                            node.status({ fill: "blue", shape: "dot", text: `state: ${node.state}` });
+                        } else {
+                            node.status({ fill: "blue", shape: "ring", text: `state: ${node.state}` });
+                        }
+                    }
+                    send({ payload: node.state });
+                    break;
+                default:
+                    node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                    if (done) done("Unknown context");
+                    return;
+            }
+            if (done) done();
+        });
+
+        node.on("close", function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("latch-block", LatchBlockNode);
+};

package/nodes/max-block.js

@@ -12,8 +12,7 @@ module.exports = function(RED) {
 
         // Evaluate typed-inputs
         try {
-            node.runtime.max = RED.util.evaluateNodeProperty( config.max, config.maxType, node );
-            node.runtime.max = parseFloat(node.runtime.max);
+            node.runtime.max = parseFloat( RED.util.evaluateNodeProperty( config.max, config.maxType, node ));
         } catch(err) {
             node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });
         }
@@ -34,8 +33,7 @@ module.exports = function(RED) {
             // Evaluate typed-inputs if needed
             try {
                 if (utils.requiresEvaluation(config.maxType)) {
-                    node.runtime.max = RED.util.evaluateNodeProperty( config.max, config.maxType, node, msg );
-                    node.runtime.max = parseFloat(node.runtime.max);
+                    node.runtime.max = parseFloat( RED.util.evaluateNodeProperty( config.max, config.maxType, node, msg ));
                 }
             } catch(err) {
                 node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });

package/nodes/memory-block.js

@@ -13,15 +13,13 @@ module.exports = function(RED) {
         node.runtime = {
             name: config.name,
             writePeriod: config.writePeriod,
-            writePeriodType: config.writePeriodType,
             transferProperty: config.transferProperty,
             writeOnUpdate: config.writeOnUpdate === true,
             storedMsg: null
         };
 
         // Resolve typed inputs
-        node.runtime.writePeriod = RED.util.evaluateNodeProperty( config.writePeriod, config.writePeriodType, node );
-        node.runtime.writePeriod = parseFloat(node.runtime.writePeriod);
+        node.runtime.writePeriod = parseFloat(RED.util.evaluateNodeProperty( config.writePeriod, config.writePeriodType, node ));
 
         // File path for persistent storage
         const filePath = path.join(RED.settings.userDir, `memory-${node.id}.json`);
@@ -88,9 +86,8 @@ module.exports = function(RED) {
             }
 
             // Evaluate typed-inputs if needed
-            if (utils.requiresEvaluation(node.runtime.writePeriodType)) {
-                node.runtime.writePeriod = RED.util.evaluateNodeProperty( config.writePeriod, config.writePeriodType, node, msg );
-                node.runtime.writePeriod = parseFloat(node.runtime.writePeriod);
+            if (utils.requiresEvaluation(config.writePeriodType)) {
+                node.runtime.writePeriod = parseFloat(RED.util.evaluateNodeProperty( config.writePeriod, config.writePeriodType, node, msg ));
             }
 
             // Initialize output array: [Output 1, Output 2]

package/nodes/min-block.js

@@ -12,8 +12,7 @@ module.exports = function(RED) {
 
         // Evaluate typed-inputs
         try {
-            node.runtime.min = RED.util.evaluateNodeProperty( config.min, config.minType, node );
-            node.runtime.min = parseFloat(node.runtime.min);
+            node.runtime.min = parseFloat(RED.util.evaluateNodeProperty( config.min, config.minType, node ));
         } catch(err) {
             node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });
         }
@@ -34,8 +33,7 @@ module.exports = function(RED) {
             // Evaluate typed-inputs if needed
             try {
                 if (utils.requiresEvaluation(config.minType)) {
-                    node.runtime.min = RED.util.evaluateNodeProperty( config.min, config.minType, node, msg );
-                    node.runtime.min = parseFloat(node.runtime.min);
+                    node.runtime.min = parseFloat(RED.util.evaluateNodeProperty( config.min, config.minType, node, msg ));
                 }
             } catch(err) {
                 node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });

package/nodes/minmax-block.js

@@ -9,14 +9,11 @@ module.exports = function(RED) {
         node.runtime = {
             name: config.name,
         };       
-        
-        const typedProperties = ['min', 'max'];
 
         // Evaluate typed-input properties    
         try {      
-            const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, null, true);
-            node.runtime.min = parseFloat(evaluatedValues.min);
-            node.runtime.max = parseFloat(evaluatedValues.max);
+            node.runtime.min = parseFloat(RED.util.evaluateNodeProperty( config.min, config.minType, node ));
+            node.runtime.max = parseFloat(RED.util.evaluateNodeProperty( config.max, config.maxType, node ));
         } catch (err) {
             node.error(`Error evaluating properties: ${err.message}`);
         }
@@ -35,10 +32,13 @@ module.exports = function(RED) {
             }
 
             // Update typed-input properties if needed
-            try {    
-                const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, msg);
-                node.runtime.min = parseFloat(evaluatedValues.min);
-                node.runtime.max = parseFloat(evaluatedValues.max);
+            try {
+                if (utils.requiresEvaluation(config.minType)) {
+                    node.runtime.min = parseFloat(RED.util.evaluateNodeProperty( config.min, config.minType, node, msg ));
+                }
+                if (utils.requiresEvaluation(config.maxType)) {
+                    node.runtime.max = parseFloat(RED.util.evaluateNodeProperty( config.max, config.maxType, node, msg ));
+                }
             } catch (err) {
                 node.error(`Error evaluating properties: ${err.message}`);
                 if (done) done();

package/nodes/on-change-block.html

@@ -64,7 +64,6 @@ differs from the last output value. When `period > 0`, outputs the first message
 Supports complex payloads (objects, arrays) via deep comparison. 
 Configuration
 - `msg.context = "period"` Sets period (ms), no output.
-- `msg.context = "status"` Outputs `{ period, periodType }`.
 
 ### Status
 - Green (dot): Configuration update

package/nodes/on-change-block.js

@@ -14,8 +14,7 @@ module.exports = function(RED) {
 
         // Evaluate typed-input properties
         try {
-            node.runtime.period = RED.util.evaluateNodeProperty( config.period, config.periodType, node );
-            node.runtime.period = parseFloat(node.runtime.period);
+            node.runtime.period = parseFloat(RED.util.evaluateNodeProperty( config.period, config.periodType, node ));
         } catch (err) {
             node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });
         }
@@ -33,8 +32,7 @@ module.exports = function(RED) {
             // Evaluate typed-input properties if needed
             try {
                 if (utils.requiresEvaluation(node.runtime.periodType)) {
-                    node.runtime.period = RED.util.evaluateNodeProperty( node.runtime.period, node.runtime.periodType, node, msg );
-                    node.runtime.period = parseFloat(node.runtime.period);
+                    node.runtime.period = parseFloat(RED.util.evaluateNodeProperty( config.period, config.periodType, node, msg ));
                 }
             } catch (err) {
                 node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });
@@ -72,16 +70,6 @@ module.exports = function(RED) {
                     if (done) done();
                     return;
                 }
-                if (msg.context === "status") {
-                    send({
-                        payload: {
-                            period: node.runtime.period,
-                            periodType: node.runtime.periodType
-                        }
-                    });
-                    if (done) done();
-                    return;
-                }
                 // Ignore unknown context
             }
 
@@ -117,7 +105,7 @@ module.exports = function(RED) {
                 node.status({
                     fill: "blue",
                     shape: "ring",
-                    text: `filtered: ${JSON.stringify(currentValue).slice(0, 20)}`
+                    text: `filtered: ${JSON.stringify(currentValue).slice(0, 20)} |`
                 });
                 if (done) done();
                 return;
@@ -141,7 +129,7 @@ module.exports = function(RED) {
                     node.status({
                         fill: "blue",
                         shape: "ring",
-                        text: `Filter period expired`
+                        text: `filtered: ${JSON.stringify(currentValue).slice(0, 20)}` // remove ' |' to indicate end of filter period
                     });
                 }, node.runtime.period);
             }

package/nodes/pid-block.html

@@ -6,23 +6,28 @@
     </div>
     <div class="form-row">
         <label for="node-input-kp" title="Proportional gain (number)"><i class="fa fa-sliders"></i> Kp</label>
-        <input type="number" id="node-input-kp" placeholder="0" step="any">
+        <input type="text" id="node-input-kp" placeholder="0" step="any">
+        <input type="hidden" id="node-input-kpType">
     </div>
     <div class="form-row">
         <label for="node-input-ki" title="Integral gain (number)"><i class="fa fa-sliders"></i> Ki</label>
-        <input type="number" id="node-input-ki" placeholder="0" step="any">
+        <input type="text" id="node-input-ki" placeholder="0" step="any">
+        <input type="hidden" id="node-input-kiType">
     </div>
     <div class="form-row">
         <label for="node-input-kd" title="Derivative gain (number)"><i class="fa fa-sliders"></i> Kd</label>
-        <input type="number" id="node-input-kd" placeholder="0" step="any">
+        <input type="text" id="node-input-kd" placeholder="0" step="any">
+        <input type="hidden" id="node-input-kdType">
     </div>
     <div class="form-row">
         <label for="node-input-setpoint" title="Target setpoint (number)"><i class="fa fa-crosshairs"></i> Setpoint</label>
-        <input type="number" id="node-input-setpoint" placeholder="0" step="any">
+        <input type="text" id="node-input-setpoint" placeholder="0" step="any">
+        <input type="hidden" id="node-input-setpointType">
     </div>
     <div class="form-row">
         <label for="node-input-deadband" title="Deadband range around setpoint (non-negative number)"><i class="fa fa-arrows-h"></i> Deadband</label>
-        <input type="number" id="node-input-deadband" placeholder="0" step="any" min="0">
+        <input type="text" id="node-input-deadband" placeholder="0" step="any" min="0">
+        <input type="hidden" id="node-input-deadbandType">
     </div>
     <div class="form-row">
         <label for="node-input-dbBehavior" title="Deadband behavior: ReturnToZero or HoldLastResult"><i class="fa fa-cog"></i> Deadband Behavior</label>
@@ -33,15 +38,18 @@
     </div>
     <div class="form-row">
         <label for="node-input-outMin" title="Minimum output limit (number, less than outMax, leave empty for no limit)"><i class="fa fa-arrow-down"></i> Out Min</label>
-        <input type="number" id="node-input-outMin" placeholder="No min" step="any">
+        <input type="text" id="node-input-outMin" placeholder="No min" step="any">
+        <input type="hidden" id="node-input-outMinType">
     </div>
     <div class="form-row">
         <label for="node-input-outMax" title="Maximum output limit (number, greater than outMin, leave empty for no limit)"><i class="fa fa-arrow-up"></i> Out Max</label>
-        <input type="number" id="node-input-outMax" placeholder="No max" step="any">
+        <input type="text" id="node-input-outMax" placeholder="No max" step="any">
+        <input type="hidden" id="node-input-outMaxType">
     </div>
     <div class="form-row">
         <label for="node-input-maxChange" title="Maximum output change per cycle (non-negative number)"><i class="fa fa-exchange"></i> Max Change</label>
-        <input type="number" id="node-input-maxChange" placeholder="0" step="any" min="0">
+        <input type="text" id="node-input-maxChange" placeholder="0" step="any" min="0">
+        <input type="hidden" id="node-input-maxChangeType">
     </div>
     <div class="form-row">
         <label for="node-input-directAction" title="Direct (true) or reverse (false) action"><i class="fa fa-exchange"></i> Direct Action</label>
@@ -49,11 +57,8 @@
     </div>
     <div class="form-row">
         <label for="node-input-run" title="Enable (true) or disable (false) PID calculation"><i class="fa fa-play"></i> Run</label>
-        <input type="checkbox" id="node-input-run" style="width: auto; vertical-align: middle;" checked>
-    </div>
-    <div class="form-row">
-        <label><i class="fa fa-info-circle"></i> Changed Runtime Values</label>
-        <pre id="node-runtime-changes" style="color: #555; white-space: pre-wrap;">Changed Values: None</pre>
+        <input type="text" id="node-input-run" style="width: auto; vertical-align: middle;" checked>
+        <input type="hidden" id="node-input-runType">
     </div>
 </script>
 
@@ -64,17 +69,26 @@
         color: "#301934",
         defaults: {
             name: { value: "" },
-            kp: { value: 0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
-            ki: { value: 0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
-            kd: { value: 0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
-            setpoint: { value: 0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
-            deadband: { value: 0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) >= 0 && isFinite(parseFloat(v)); } },
+            kp: { value: 0, required: true },
+            kpType: { value: "num" },
+            ki: { value: 0, required: true },
+            kiType: { value: "num" },
+            kd: { value: 0, required: true },
+            kdType: { value: "num" },
+            setpoint: { value: 0, required: true },
+            setpointType: { value: "num" },
+            deadband: { value: 0, required: true },
+            deadbandType: { value: "num" },
             dbBehavior: { value: "ReturnToZero" },
-            outMin: { value: null, validate: function(v) { return v === "" || (!isNaN(parseFloat(v)) && isFinite(parseFloat(v))); } },
-            outMax: { value: null, validate: function(v) { return v === "" || (!isNaN(parseFloat(v)) && isFinite(parseFloat(v))); } },
-            maxChange: { value: 0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && parseFloat(v) >= 0 && isFinite(parseFloat(v)); } },
+            outMin: { value: null },
+            outMinType: { value: "num" },
+            outMax: { value: null },
+            outMaxType: { value: "num" },
+            maxChange: { value: 0, required: true },
+            maxChangeType: { value: "num" },
             directAction: { value: false },
-            run: { value: true }
+            run: { value: true },
+            runType: { value: "bool" }
         },
         inputs: 1,
         outputs: 1,
@@ -87,59 +101,67 @@
         },
         oneditprepare: function() {
             const node = this;
-            $("#node-input-name").val(node.name || "");
-            $("#node-input-kp").val(node.kp || 0);
-            $("#node-input-ki").val(node.ki || 0);
-            $("#node-input-kd").val(node.kd || 0);
-            $("#node-input-setpoint").val(node.setpoint || 0);
-            $("#node-input-deadband").val(node.deadband || 0);
-            $("#node-input-dbBehavior").val(node.dbBehavior || "ReturnToZero");
-            $("#node-input-outMin").val(node.outMin == null ? "" : node.outMin);
-            $("#node-input-outMax").val(node.outMax == null ? "" : node.outMax);
-            $("#node-input-maxChange").val(node.maxChange || 0);
-            $("#node-input-directAction").prop("checked", !!node.directAction);
-            $("#node-input-run").prop("checked", node.run !== false);
-
-            $.getJSON(`/pid-block-runtime/${this.id}?t=${Date.now()}`, function(data) {
-                const changes = [];
-                if (data.name) changes.push(`name: ${data.name}`);
-                if (data.kp !== parseFloat(node.kp || 0)) changes.push(`kp: ${data.kp.toFixed(2)}`);
-                if (data.ki !== parseFloat(node.ki || 0)) changes.push(`ki: ${data.ki.toFixed(2)}`);
-                if (data.kd !== parseFloat(node.kd || 0)) changes.push(`kd: ${data.kd.toFixed(2)}`);
-                if (data.setpoint !== parseFloat(node.setpoint || 0)) changes.push(`setpoint: ${data.setpoint.toFixed(2)}`);
-                if (data.deadband !== parseFloat(node.deadband || 0)) changes.push(`deadband: ${data.deadband.toFixed(2)}`);
-                if (data.dbBehavior !== (node.dbBehavior || "ReturnToZero")) changes.push(`dbBehavior: ${data.dbBehavior}`);
-                if (data.outMin != null && data.outMin !== parseFloat(node.outMin || null)) changes.push(`outMin: ${data.outMin.toFixed(2)}`);
-                if (data.outMax != null && data.outMax !== parseFloat(node.outMax || null)) changes.push(`outMax: ${data.outMax.toFixed(2)}`);
-                if (data.maxChange !== parseFloat(node.maxChange || 0)) changes.push(`maxChange: ${data.maxChange.toFixed(2)}`);
-                if (data.directAction !== !!node.directAction) changes.push(`directAction: ${data.directAction}`);
-                if (data.run !== (node.run !== false)) changes.push(`run: ${data.run}`);
-                $("#node-runtime-changes").text(changes.length > 0 ? `Changed Values:\n${changes.join("\n")}` : "Changed Values: None");
-            }).fail(function() {
-                $("#node-runtime-changes").text("Changed Values: Unknown");
-            });
-        },
-        oneditsave: function() {
-            // Standard config properties are automatically saved by Node-RED
-        },
-        oneditvalidate: function() {
-            const kp = parseFloat($("#node-input-kp").val());
-            const ki = parseFloat($("#node-input-ki").val());
-            const kd = parseFloat($("#node-input-kd").val());
-            const setpoint = parseFloat($("#node-input-setpoint").val());
-            const deadband = parseFloat($("#node-input-deadband").val());
-            const outMin = $("#node-input-outMin").val() === "" ? null : parseFloat($("#node-input-outMin").val());
-            const outMax = $("#node-input-outMax").val() === "" ? null : parseFloat($("#node-input-outMax").val());
-            const maxChange = parseFloat($("#node-input-maxChange").val());
-            return !isNaN(kp) && isFinite(kp) &&
-                   !isNaN(ki) && isFinite(ki) &&
-                   !isNaN(kd) && isFinite(kd) &&
-                   !isNaN(setpoint) && isFinite(setpoint) &&
-                   !isNaN(deadband) && isFinite(deadband) && deadband >= 0 &&
-                   (outMin === null || (!isNaN(outMin) && isFinite(outMin))) &&
-                   (outMax === null || (!isNaN(outMax) && isFinite(outMax))) &&
-                   (outMin === null || outMax === null || outMax > outMin) &&
-                   !isNaN(maxChange) && isFinite(maxChange) && maxChange >= 0;
+
+            try {
+                // Initialize typed inputs
+                $("#node-input-kp").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-kpType"
+                }).typedInput("type", node.kpType || "num").typedInput("value", node.kp);
+
+                $("#node-input-ki").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-kiType"
+                }).typedInput("type", node.kiType || "num").typedInput("value", node.ki);
+
+                $("#node-input-kd").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-kdType"
+                }).typedInput("type", node.kdType || "num").typedInput("value", node.kd);
+
+                $("#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-deadband").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-deadbandType"
+                }).typedInput("type", node.deadbandType || "num").typedInput("value", node.deadband);
+
+                $("#node-input-outMin").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-outMinType"
+                }).typedInput("type", node.outMinType || "num").typedInput("value", node.outMin);
+
+                $("#node-input-outMax").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-outMaxType"
+                }).typedInput("type", node.outMaxType || "num").typedInput("value", node.outMax);
+
+                $("#node-input-maxChange").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-maxChangeType"
+                }).typedInput("type", node.maxChangeType || "num").typedInput("value", node.maxChange);
+
+                $("#node-input-run").typedInput({
+                    default: "bool",
+                    types: ["bool", "msg", "flow", "global"],
+                    typeField: "#node-input-runType"
+                }).typedInput("type", node.runType || "bool").typedInput("value", node.run);
+
+            } catch (err) {
+                console.error("Error in oneditprepare:", err);
+            }
+
         }
     });
 </script>
@@ -193,11 +215,11 @@ Ziegler-Nichols tuning sets `kp = 0.6*Ku`, `ki = 2*kp/Tu`, `kd = kp*Tu/8` after
 - Invalid config at startup: Red status (`invalid config` or specific), resets to defaults.
 
 ### Status
-- Green (dot): Configuration, reset, or tuning (e.g., `setpoint: 50.00`, `reset`, `tune: completed, Kp=1.20, Ki=0.40, Kd=0.90`).
-- Blue (dot): Output change (e.g., `in: 25.00, out: 50.00, setpoint: 50.00`).
-- Blue (ring): Output unchanged (e.g., `in: 25.00, out: 50.00, setpoint: 50.00`).
-- Red (ring): Errors (e.g., `invalid input`, `invalid setpoint`).
-- Yellow (ring): Unknown context (e.g., `unknown context`).
+- Green (dot): Configuration, reset, or tuning
+- Blue (dot): Output change
+- Blue (ring): Output unchanged
+- Red (ring): Errors
+- Yellow (ring): Unknown context
 
 ### References
 - [Node-RED Documentation](https://nodered.org/docs/)