@bldgblocks/node-red-contrib-control 0.1.34 → 0.1.36

package/nodes/triangle-wave-block.js

@@ -1,32 +1,32 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
     function TriangleWaveBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name || "",
-            lowerLimit: parseFloat(config.lowerLimit),
-            upperLimit: parseFloat(config.upperLimit),
-            period: (parseFloat(config.period)) * (config.periodUnits === "minutes" ? 60000 : config.periodUnits === "seconds" ? 1000 : 1),
-            periodUnits: config.periodUnits,
-            lastExecution: Date.now(),
-            phase: 0
-        };
+        // Initialize state
+        node.name = config.name || "";
+        node.lowerLimit = parseFloat(config.lowerLimit);
+        node.upperLimit = parseFloat(config.upperLimit);
+        node.period = (parseFloat(config.period)) * (config.periodUnits === "minutes" ? 60000 : config.periodUnits === "seconds" ? 1000 : 1);
+        node.periodUnits = config.periodUnits;
+        node.lastExecution = Date.now();
+        node.phase = 0;
 
         // Validate initial config
-        if (isNaN(node.runtime.lowerLimit) || isNaN(node.runtime.upperLimit) || !isFinite(node.runtime.lowerLimit) || !isFinite(node.runtime.upperLimit)) {
-            node.runtime.lowerLimit = 0;
-            node.runtime.upperLimit = 100;
-            node.status({ fill: "red", shape: "ring", text: "invalid limits" });
-        } else if (node.runtime.lowerLimit > node.runtime.upperLimit) {
-            node.runtime.upperLimit = node.runtime.lowerLimit;
-            node.status({ fill: "red", shape: "ring", text: "invalid limits" });
+        if (isNaN(node.lowerLimit) || isNaN(node.upperLimit) || !isFinite(node.lowerLimit) || !isFinite(node.upperLimit)) {
+            node.lowerLimit = 0;
+            node.upperLimit = 100;
+            utils.setStatusError(node, "invalid limits");
+        } else if (node.lowerLimit > node.upperLimit) {
+            node.upperLimit = node.lowerLimit;
+            utils.setStatusError(node, "invalid limits");
         }
-        if (isNaN(node.runtime.period) || node.runtime.period <= 0 || !isFinite(node.runtime.period)) {
-            node.runtime.period = 10000;
-            node.runtime.periodUnits = "milliseconds";
-            node.status({ fill: "red", shape: "ring", text: "invalid period" });
+        if (isNaN(node.period) || node.period <= 0 || !isFinite(node.period)) {
+            node.period = 10000;
+            node.periodUnits = "milliseconds";
+            utils.setStatusError(node, "invalid period");
         }
 
         node.on("input", function(msg, send, done) {
@@ -34,7 +34,7 @@ module.exports = function(RED) {
 
             // Guard against invalid message
             if (!msg) {
-                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }
@@ -42,74 +42,54 @@ module.exports = function(RED) {
             // Handle context updates
             if (msg.hasOwnProperty("context")) {
                 if (!msg.hasOwnProperty("payload")) {
-                    node.status({ fill: "red", shape: "ring", text: `missing payload for ${msg.context}` });
+                    utils.setStatusError(node, `missing payload for ${msg.context}`);
                     if (done) done();
                     return;
                 }
                 if (typeof msg.context !== "string") {
-                    node.status({ fill: "red", shape: "ring", text: "invalid context" });
+                    utils.setStatusError(node, "invalid context");
                     if (done) done();
                     return;
                 }
                 let value = parseFloat(msg.payload);
                 if (isNaN(value) || !isFinite(value)) {
-                    node.status({ fill: "red", shape: "ring", text: `invalid ${msg.context}` });
+                    utils.setStatusError(node, `invalid ${msg.context}`);
                     if (done) done();
                     return;
                 }
                 switch (msg.context) {
                     case "lowerLimit":
-                        node.runtime.lowerLimit = value;
-                        if (node.runtime.lowerLimit > node.runtime.upperLimit) {
-                            node.runtime.upperLimit = node.runtime.lowerLimit;
-                            node.status({
-                                fill: "green",
-                                shape: "dot",
-                                text: `lower: ${node.runtime.lowerLimit.toFixed(2)}, upper adjusted to ${node.runtime.upperLimit.toFixed(2)}`
-                            });
+                        node.lowerLimit = value;
+                        if (node.lowerLimit > node.upperLimit) {
+                            node.upperLimit = node.lowerLimit;
+                            utils.setStatusOK(node, `lower: ${node.lowerLimit.toFixed(2)}, upper adjusted to ${node.upperLimit.toFixed(2)}`);
                         } else {
-                            node.status({
-                                fill: "green",
-                                shape: "dot",
-                                text: `lower: ${node.runtime.lowerLimit.toFixed(2)}`
-                            });
+                            utils.setStatusOK(node, `lower: ${node.lowerLimit.toFixed(2)}`);
                         }
                         break;
                     case "upperLimit":
-                        node.runtime.upperLimit = value;
-                        if (node.runtime.upperLimit < node.runtime.lowerLimit) {
-                            node.runtime.lowerLimit = node.runtime.upperLimit;
-                            node.status({
-                                fill: "green",
-                                shape: "dot",
-                                text: `upper: ${node.runtime.upperLimit.toFixed(2)}, lower adjusted to ${node.runtime.lowerLimit.toFixed(2)}`
-                            });
+                        node.upperLimit = value;
+                        if (node.upperLimit < node.lowerLimit) {
+                            node.lowerLimit = node.upperLimit;
+                            utils.setStatusOK(node, `upper: ${node.upperLimit.toFixed(2)}, lower adjusted to ${node.lowerLimit.toFixed(2)}`);
                         } else {
-                            node.status({
-                                fill: "green",
-                                shape: "dot",
-                                text: `upper: ${node.runtime.upperLimit.toFixed(2)}`
-                            });
+                            utils.setStatusOK(node, `upper: ${node.upperLimit.toFixed(2)}`);
                         }
                         break;
                     case "period":
                         const multiplier = msg.units === "minutes" ? 60000 : msg.units === "seconds" ? 1000 : 1;
                         value *= multiplier;
                         if (value <= 0) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid period" });
+                            utils.setStatusError(node, "invalid period");
                             if (done) done();
                             return;
                         }
-                        node.runtime.period = value;
-                        node.runtime.periodUnits = msg.units || "milliseconds";
-                        node.status({
-                            fill: "green",
-                            shape: "dot",
-                            text: `period: ${node.runtime.period.toFixed(2)} ms`
-                        });
+                        node.period = value;
+                        node.periodUnits = msg.units || "milliseconds";
+                        utils.setStatusOK(node, `period: ${node.period.toFixed(2)} ms`);
                         break;
                     default:
-                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        utils.setStatusWarn(node, "unknown context");
                         if (done) done("Unknown context");
                         return;
                 }
@@ -119,27 +99,27 @@ module.exports = function(RED) {
 
             // Calculate time difference
             const now = Date.now();
-            const deltaTime = (now - node.runtime.lastExecution) / 1000; // Seconds
-            node.runtime.lastExecution = now;
+            const deltaTime = (now - node.lastExecution) / 1000; // Seconds
+            node.lastExecution = now;
 
             // Return lowerLimit if period is invalid
-            if (node.runtime.period <= 0) {
-                node.status({ fill: "blue", shape: "dot", text: `out: ${node.runtime.lowerLimit.toFixed(2)}, phase: ${node.runtime.phase.toFixed(2)}` });
-                send({ payload: node.runtime.lowerLimit });
+            if (node.period <= 0) {
+                utils.setStatusOK(node, `out: ${node.lowerLimit.toFixed(2)}, phase: ${node.phase.toFixed(2)}`);
+                send({ payload: node.lowerLimit });
                 if (done) done();
                 return;
             }
 
             // Update phase
-            node.runtime.phase = (node.runtime.phase + deltaTime / (node.runtime.period / 1000)) % 1;
+            node.phase = (node.phase + deltaTime / (node.period / 1000)) % 1;
 
             // Triangle wave calculation
-            const triangleValue = node.runtime.phase < 0.5 ? 2 * node.runtime.phase : 2 * (1 - node.runtime.phase);
-            const amplitude = (node.runtime.upperLimit - node.runtime.lowerLimit) / 2;
-            const value = node.runtime.lowerLimit + amplitude * triangleValue;
+            const triangleValue = node.phase < 0.5 ? 2 * node.phase : 2 * (1 - node.phase);
+            const amplitude = (node.upperLimit - node.lowerLimit) / 2;
+            const value = node.lowerLimit + amplitude * triangleValue;
 
             // Output new message
-            node.status({ fill: "blue", shape: "dot", text: `out: ${value.toFixed(2)}, phase: ${node.runtime.phase.toFixed(2)}` });
+            utils.setStatusOK(node, `out: ${value.toFixed(2)}, phase: ${node.phase.toFixed(2)}`);
             send({ payload: value });
 
             if (done) done();

package/nodes/tstat-block.js

@@ -33,7 +33,7 @@ module.exports = function(RED) {
             send = send || function() { node.send.apply(node, arguments); };
 
             if (!msg) {
-                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }
@@ -44,7 +44,7 @@ module.exports = function(RED) {
                 // Check busy lock
                 if (node.isBusy) {
                     // Update status to let user know they are pushing too fast
-                    node.status({ fill: "yellow", shape: "ring", text: "busy - dropped msg" });
+                    utils.setStatusBusy(node, "busy - dropped msg");
                     if (done) done(); 
                     return;
                 }
@@ -166,7 +166,7 @@ module.exports = function(RED) {
             // Handle configuration messages
             if (msg.hasOwnProperty("context")) {
                 if (!msg.hasOwnProperty("payload")) {
-                    node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                    utils.setStatusError(node, "missing payload");
                     if (done) done();
                     return;
                 }
@@ -175,103 +175,101 @@ module.exports = function(RED) {
                     case "algorithm":
                         if (["single", "split", "specified"].includes(msg.payload)) {
                             node.algorithm = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `algorithm: ${msg.payload}` });
+                            utils.setStatusOK(node, `algorithm: ${msg.payload}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid algorithm" });
+                            utils.setStatusError(node, "invalid algorithm");
                         }
                         break;
                     case "setpoint":
                         if (typeof msg.payload === 'number') {
                             node.setpoint = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `setpoint: ${msg.payload.toFixed(2)}` });
+                            utils.setStatusOK(node, `setpoint: ${msg.payload.toFixed(2)}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid setpoint" });
+                            utils.setStatusError(node, "invalid setpoint");
                         }
                         break;
                     case "heatingSetpoint":
                         if (typeof msg.payload === 'number') {
                             node.heatingSetpoint = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `heatingSetpoint: ${msg.payload.toFixed(2)}`
-                            });
+                            utils.setStatusOK(node, `heatingSetpoint: ${msg.payload.toFixed(2)}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid heatingSetpoint" });
+                            utils.setStatusError(node, "invalid heatingSetpoint");
                         }
                         break;
                     case "coolingSetpoint":
                         if (typeof msg.payload === 'number') {
                             node.coolingSetpoint = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `coolingSetpoint: ${msg.payload.toFixed(2)}` });
+                            utils.setStatusOK(node, `coolingSetpoint: ${msg.payload.toFixed(2)}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid coolingSetpoint" });
+                            utils.setStatusError(node, "invalid coolingSetpoint");
                         }
                         break;
                     case "coolingOn":
                         if (typeof msg.payload === 'number') {
                             node.coolingOn = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `coolingOn: ${msg.payload.toFixed(2)}` });
+                            utils.setStatusOK(node, `coolingOn: ${msg.payload.toFixed(2)}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid coolingOn" });
+                            utils.setStatusError(node, "invalid coolingOn");
                         }
                         break;
                     case "coolingOff":
                         if (typeof msg.payload === 'number') {
                             node.coolingOff = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `coolingOff: ${msg.payload.toFixed(2)}`
-                            });
+                            utils.setStatusOK(node, `coolingOff: ${msg.payload.toFixed(2)}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid coolingOff" });
+                            utils.setStatusError(node, "invalid coolingOff");
                         }
                         break;
                     case "heatingOff":
                         if (typeof msg.payload === 'number') {
                             node.heatingOff = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `heatingOff: ${msg.payload.toFixed(2)}` });
+                            utils.setStatusOK(node, `heatingOff: ${msg.payload.toFixed(2)}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid heatingOff" });
+                            utils.setStatusError(node, "invalid heatingOff");
                         }
                         break;
                     case "heatingOn":
                         if (typeof msg.payload === 'number') {
                             node.heatingOn = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `heatingOn: ${msg.payload.toFixed(2)}` });
+                            utils.setStatusOK(node, `heatingOn: ${msg.payload.toFixed(2)}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid heatingOn" });
+                            utils.setStatusError(node, "invalid heatingOn");
                         }
                         break;
                     case "diff":
                         if (typeof msg.payload === 'number' && msg.payload >= 0.01) {
                             node.diff = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `diff: ${msg.payload.toFixed(2)}` });
+                            utils.setStatusOK(node, `diff: ${msg.payload.toFixed(2)}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid diff" });
+                            utils.setStatusError(node, "invalid diff");
                         }
                         break;
                     case "anticipator":
                         if (typeof msg.payload === 'number' && msg.payload >= -2) {
                             node.anticipator = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `anticipator: ${msg.payload.toFixed(2)}` });
+                            utils.setStatusOK(node, `anticipator: ${msg.payload.toFixed(2)}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid anticipator" });
+                            utils.setStatusError(node, "invalid anticipator");
                         }
                         break;
                     case "ignoreAnticipatorCycles":
                         if (typeof msg.payload === 'number' && msg.payload >= 0) {
                             node.ignoreAnticipatorCycles = Math.floor(msg.payload);
-                            node.status({ fill: "green", shape: "dot", text: `ignoreAnticipatorCycles: ${Math.floor(msg.payload)}` });
+                            utils.setStatusOK(node, `ignoreAnticipatorCycles: ${Math.floor(msg.payload)}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid ignoreAnticipatorCycles" });
+                            utils.setStatusError(node, "invalid ignoreAnticipatorCycles");
                         }
                         break;
                     case "isHeating":
                         if (typeof msg.payload === "boolean") {
                             node.isHeating = msg.payload;
-                            node.status({ fill: "green", shape: "dot", text: `isHeating: ${msg.payload}` });
+                            utils.setStatusOK(node, `isHeating: ${msg.payload}`);
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: "invalid isHeating" });
+                            utils.setStatusError(node, "invalid isHeating");
                         }
                         break;
                     default:
-                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        utils.setStatusWarn(node, "unknown context");
                         break;
                 }
                 if (done) done();
@@ -279,21 +277,21 @@ module.exports = function(RED) {
             }
 
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
                 if (done) done();
                 return;
             }
 
             const input = parseFloat(msg.payload);
             if (isNaN(input)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+                utils.setStatusError(node, "invalid payload");
                 if (done) done();
                 return;
             }
 
             const isHeating = msg.hasOwnProperty("isHeating") && typeof msg.isHeating === "boolean" ? msg.isHeating : node.isHeating;
             if (msg.hasOwnProperty("isHeating") && typeof msg.isHeating !== "boolean") {
-                node.status({ fill: "red", shape: "ring", text: "invalid isHeating (must be boolean)" });
+                utils.setStatusError(node, "invalid isHeating (must be boolean)");
                 if (done) done();
                 return;
             }
@@ -330,7 +328,7 @@ module.exports = function(RED) {
             // The Tstat node does not control heating/cooling mode, only operates heating or cooling according to the mode set and respective setpoints.
             if (node.algorithm === "single") {
                 // Note:
-                // Make sure your mode selection is handled upstream and does not osciallate modes.
+                // Make sure your mode selection is handled upstream and does not oscillate modes.
                 // This was changed to allow for broader anticipator authority, or even negative (overshoot) so duty cycle can be better managed.
                 // So the same setpoint can be used year round and maintain tight control. 
                 // Alternatively, you would need a larger diff value to prevent oscillation.
@@ -458,17 +456,9 @@ module.exports = function(RED) {
             send(outputs);
 
             if (above === lastAbove && below === lastBelow) {
-                node.status({
-                    fill: "blue",
-                    shape: "ring",
-                    text: `in: ${input.toFixed(2)}, out: ${node.isHeating ? "heating" : "cooling"}, above: ${above}, below: ${below}`
-                });
+                utils.setStatusUnchanged(node, `in: ${input.toFixed(2)}, out: ${node.isHeating ? "heating" : "cooling"}, above: ${above}, below: ${below}`);
             } else {
-                node.status({
-                    fill: "blue",
-                    shape: "dot",
-                    text: `in: ${input.toFixed(2)}, out: ${node.isHeating ? "heating" : "cooling"}, above: ${above}, below: ${below}`
-                });
+                utils.setStatusChanged(node, `in: ${input.toFixed(2)}, out: ${node.isHeating ? "heating" : "cooling"}, above: ${above}, below: ${below}`);
             }
 
             if (done) done();

package/nodes/units-block.html

@@ -4,10 +4,82 @@
         <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">
+    <div class="form-row">        
+        <label for="node-input-inputProperty" title="Message property to read input from"><i class="fa fa-folder-open"></i> Input Property</label>
+        <input type="text" id="node-input-inputProperty" placeholder="payload">
+    </div>
+    <div class="form-row">        
         <label for="node-input-unit" title="Unit to append to msg.units"><i class="fa fa-tag"></i> Unit</label>
-        <input type="text" id="node-input-unit">
-        <input type="hidden" id="node-input-unitType">
+        <select id="node-input-unit">
+            <option value="">Text (none)</option>
+            <optgroup label="Temperature">
+                <option value="°C">°C (Celsius)</option>
+                <option value="°F">°F (Fahrenheit)</option>
+                <option value="K">K (Kelvin)</option>
+                <option value="°R">°R (Rankine)</option>
+            </optgroup>
+            <optgroup label="Humidity">
+                <option value="%RH">%RH (Relative Humidity)</option>
+                <option value="%">% (Percent)</option>
+            </optgroup>
+            <optgroup label="Pressure">
+                <option value="Pa">Pa (Pascal)</option>
+                <option value="kPa">kPa (Kilopascal)</option>
+                <option value="bar">bar</option>
+                <option value="mbar">mbar (Millibar)</option>
+                <option value="psi">psi</option>
+                <option value="inHg">inHg (Inches of Mercury)</option>
+                <option value="atm">atm (Atmosphere)</option>
+                <option value="inH₂O">inH₂O (Inches of Water)</option>
+                <option value="mmH₂O">mmH₂O (Millimeters of Water)</option>
+            </optgroup>
+            <optgroup label="Flow Rate">
+                <option value="CFM">CFM (Cubic Feet per Minute)</option>
+                <option value="m³/h">m³/h (Cubic Meters per Hour)</option>
+                <option value="L/s">L/s (Liters per Second)</option>
+            </optgroup>
+            <optgroup label="Electrical">
+                <option value="V">V (Volt)</option>
+                <option value="mV">mV (Millivolt)</option>
+                <option value="A">A (Ampere)</option>
+                <option value="mA">mA (Milliampere)</option>
+                <option value="W">W (Watt)</option>
+                <option value="kW">kW (Kilowatt)</option>
+                <option value="hp">hp (Horsepower)</option>
+                <option value="Ω">Ω (Ohm)</option>
+            </optgroup>
+            <optgroup label="Distance">
+                <option value="m">m (Meter)</option>
+                <option value="cm">cm (Centimeter)</option>
+                <option value="mm">mm (Millimeter)</option>
+                <option value="km">km (Kilometer)</option>
+                <option value="ft">ft (Foot)</option>
+                <option value="in">in (Inch)</option>
+            </optgroup>
+            <optgroup label="Mass">
+                <option value="kg">kg (Kilogram)</option>
+                <option value="g">g (Gram)</option>
+                <option value="lb">lb (Pound)</option>
+            </optgroup>
+            <optgroup label="Time">
+                <option value="s">s (Second)</option>
+                <option value="min">min (Minute)</option>
+                <option value="h">h (Hour)</option>
+            </optgroup>
+            <optgroup label="Volume">
+                <option value="L">L (Liter)</option>
+                <option value="mL">mL (Milliliter)</option>
+                <option value="gal">gal (Gallon)</option>
+            </optgroup>
+            <optgroup label="Light">
+                <option value="lx">lx (Lux)</option>
+                <option value="cd">cd (Candela)</option>
+            </optgroup>
+            <optgroup label="Other">
+                <option value="B">B (Bel)</option>
+                <option value="T">T (Tesla)</option>
+            </optgroup>
+        </select>
     </div>
 </script>
 
@@ -18,8 +90,8 @@
         color: "#301934",
         defaults: {
             name: { value: "" },
-            unit: { value: "°F" },
-            unitType: { value: "str" }
+            inputProperty: { value: "payload" },
+            unit: { value: "°F" }
         },
         inputs: 1,
         outputs: 1,
@@ -30,62 +102,6 @@
         label: function() {
             return this.name || `units ${this.unit}`;
         },
-        oneditprepare: function() {
-            $("#node-input-unit").typedInput({
-                default: "str",
-                types: [{
-                    value: "str",
-                    options: [
-                        { value: "", label: "Text (none)" },
-                        { value: "°C", label: "°C (Celsius)" },
-                        { value: "°F", label: "°F (Fahrenheit)" },
-                        { value: "K", label: "K (Kelvin)" },
-                        { value: "°R", label: "°R (Rankine)" },
-                        { value: "%RH", label: "%RH (Relative Humidity)" },
-                        { value: "%", label: "% (Percent)" },
-                        { value: "Pa", label: "Pa (Pascal)" },
-                        { value: "kPa", label: "kPa (Kilopascal)" },
-                        { value: "bar", label: "bar" },
-                        { value: "mbar", label: "mbar (Millibar)" },
-                        { value: "psi", label: "psi" },
-                        { value: "inHg", label: "inHg (Inches of Mercury)" },
-                        { value: "atm", label: "atm (Atmosphere)" },
-                        { value: "inH₂O", label: "inH₂O (Inches of Water)" },
-                        { value: "mmH₂O", label: "mmH₂O (Millimeters of Water)" },
-                        { value: "CFM", label: "CFM (Cubic Feet per Minute)" },
-                        { value: "m³/h", label: "m³/h (Cubic Meters per Hour)" },
-                        { value: "L/s", label: "L/s (Liters per Second)" },
-                        { value: "V", label: "V (Volt)" },
-                        { value: "mV", label: "mV (Millivolt)" },
-                        { value: "A", label: "A (Ampere)" },
-                        { value: "mA", label: "mA (Milliampere)" },
-                        { value: "W", label: "W (Watt)" },
-                        { value: "kW", label: "kW (Kilowatt)" },
-                        { value: "hp", label: "hp (Horsepower)" },
-                        { value: "Ω", label: "Ω (Ohm)" },
-                        { value: "m", label: "m (Meter)" },
-                        { value: "cm", label: "cm (Centimeter)" },
-                        { value: "mm", label: "mm (Millimeter)" },
-                        { value: "km", label: "km (Kilometer)" },
-                        { value: "ft", label: "ft (Foot)" },
-                        { value: "in", label: "in (Inch)" },
-                        { value: "kg", label: "kg (Kilogram)" },
-                        { value: "g", label: "g (Gram)" },
-                        { value: "lb", label: "lb (Pound)" },
-                        { value: "s", label: "s (Second)" },
-                        { value: "min", label: "min (Minute)" },
-                        { value: "h", label: "h (Hour)" },
-                        { value: "L", label: "L (Liter)" },
-                        { value: "mL", label: "mL (Milliliter)" },
-                        { value: "gal", label: "gal (Gallon)" },
-                        { value: "lx", label: "lx (Lux)" },
-                        { value: "cd", label: "cd (Candela)" },
-                        { value: "B", label: "B (Bel)" },
-                        { value: "T", label: "T (Tesla)" }
-                    ]
-                }], typeField: "#node-input-unitType"
-            }).typedInput("type", node.unitType).typedInput("value", node.unit);
-        }
     });
 </script>
 
@@ -94,17 +110,22 @@
 Appends a selected unit to `msg.units` of every input message.
 
 ### Inputs
-: context (string) : Configures unit (`"unit"`) if provided. Ignored otherwise.  
-: payload (any) : Input payload to pass through unchanged.
+: input-property (any) : Input value to read from the configured Input Property.  
+: context (string) : Configures unit (`"unit"`) if provided. Ignored otherwise.
 
 ### Outputs
-: payload (any) : Original payload.  
-: units (string) : Selected unit (e.g., °F, %RH, inH₂O).  
+: payload (any) : Original payload from configured Input Property.  
+: units (string) : Selected unit (e.g., °F, %RH, inH₂O).
+
+### Properties
+: name (string) : Display name in editor.
+: inputProperty (string) : Message property to read from (default: `payload`). Supports nested properties (e.g., `data.value`).
+: unit (string) : Unit label to append to `msg.units`.
 
 ### Details
-Appends `msg.units` with the configured unit to every input message.  
-Unit can be set via editor or dynamically with `msg.context = "unit"` and a valid unit in `msg.payload`.  
-Supports units like °C, °F, %RH, inH₂O, CFM for HVAC and control systems.  
+Appends `msg.units` with the configured unit to every input message. The input value is read from the configured **Input Property** (default: `msg.payload`).
+Unit can be set via editor or dynamically with `msg.context = "unit"` and a valid unit in `msg.payload`.
+Supports units like °C, °F, %RH, inH₂O, CFM for HVAC and control systems.
 Processes every input message, preserving all original properties, just adding `msg.units`.
 
 ### Status
@@ -115,6 +136,6 @@ Processes every input message, preserving all original properties, just adding `
 - Yellow (ring): Warning
 
 ### References
-- [Node-RED Documentation](https://nodered.org/docs/)  
+- [Node-RED Documentation](https://nodered.org/docs/)
 - [GitHub Repository](https://github.com/BldgBlocks/node-red-contrib-buildingblocks-control.git)
 </script>