@bldgblocks/node-red-contrib-control 0.1.20 → 0.1.22

package/nodes/average-block.js

@@ -1,4 +1,6 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function AverageBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
@@ -10,34 +12,15 @@ module.exports = function(RED) {
             lastAvg: null
         };
 
-        // Evaluate all properties
-        try {
-            node.runtime.minValid = RED.util.evaluateNodeProperty(
-                config.minValid, config.minValidType, node
-            );
+        const typedProperties = ['minValid', 'maxValid'];
 
-            node.runtime.maxValid = RED.util.evaluateNodeProperty(
-                config.maxValid, config.maxValidType, node
-            );
-            
-            // Validate values
-            if (isNaN(node.runtime.maxValid) || isNaN(node.runtime.minValid) || node.runtime.maxValid <= node.runtime.minValid ) {
-                node.status({ fill: "red", shape: "ring", text: `invalid evaluated values ${node.runtime.minValid}, ${node.runtime.maxValid}` });
-                if (done) done();
-                return;
-            }
-        } catch(err) {
-            node.status({ fill: "red", shape: "ring", text: "error evaluating properties" });
-            if (done) done(err);
-            return;
-        }
-
-        // Validate initial config
-        if (isNaN(node.runtime.maxValues) || node.runtime.maxValues < 1) {
-            node.runtime.maxValues = 10;
-            node.status({ fill: "red", shape: "ring", text: "invalid window size, using 10" });
-        } else {
-            node.status({ shape: "dot", text: `name: ${config.name}, window: ${config.sampleSize}` });
+        // Evaluate typed-input properties    
+        try {     
+            const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, null, true);
+            node.runtime.minValid = parseFloat(evaluatedValues.minValid);
+            node.runtime.maxValid = parseFloat(evaluatedValues.maxValid);
+        } catch (err) {
+            node.error(`Error evaluating properties: ${err.message}`);
         }
 
         node.on("input", function(msg, send, done) {
@@ -48,6 +31,30 @@ module.exports = function(RED) {
                 node.status({ fill: "red", shape: "ring", text: "invalid message" });
                 if (done) done();
                 return;
+            }    
+
+            // Update typed-input properties if needed
+            try {                    
+                const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, msg);
+                node.runtime.minValid = parseFloat(evaluatedValues.minValid);
+                node.runtime.maxValid = parseFloat(evaluatedValues.maxValid);
+            } catch (err) {
+                node.error(`Error evaluating properties: ${err.message}`);
+                if (done) done();
+                return;
+            }
+
+            // Acceptable fallbacks
+            if (isNaN(node.runtime.maxValues) || node.runtime.maxValues < 1) {
+                node.runtime.maxValues = 10;
+                node.status({ fill: "red", shape: "ring", text: "invalid window size, using 10" });
+            }
+
+            // Validate values
+            if (isNaN(node.runtime.maxValid) || isNaN(node.runtime.minValid) || node.runtime.maxValid <= node.runtime.minValid ) {
+                node.status({ fill: "red", shape: "ring", text: `invalid evaluated values ${node.runtime.minValid}, ${node.runtime.maxValid}` });
+                if (done) done();
+                return;
             }
 
             // Handle configuration messages

package/nodes/changeover-block.html

@@ -18,6 +18,12 @@
     <div class="form-row single-only">
         <label for="node-input-deadband" title="Temperature range for no action (positive number)"><i class="fa fa-arrows-v"></i> Deadband</label>
         <input type="text" id="node-input-deadband" placeholder="2">
+        <input type="hidden" id="node-input-deadbandType">
+    </div>
+    <div class="form-row split-only" style="display: none;">
+        <div id="deadband-warning" style="color: red; display: none; margin-top: 5px;">
+            Invalid
+        </div>
     </div>
     <div class="form-row split-only" style="display: none;">
         <label for="node-input-heatingSetpoint" title="Heating setpoint for split algorithm (number from num, msg, flow, or global)"><i class="fa fa-thermometer-empty"></i> Heating Setpoint</label>
@@ -34,9 +40,15 @@
             Cooling setpoint must be greater than heating setpoint
         </div>
     </div>
-    <div class="form-row">
+    <div class="form-row split-only">
         <label for="node-input-extent" title="Extra buffer mode switching thresholds (non-negative number)"><i class="fa fa-tachometer"></i> Extent</label>
         <input type="text" id="node-input-extent" placeholder="1">
+        <input type="hidden" id="node-input-extentType">
+    </div>
+    <div class="form-row split-only" style="display: none;">
+        <div id="extent-warning" style="color: red; display: none; margin-top: 5px;">
+            Invalid
+        </div>
     </div>
     <div class="form-row">
         <label for="node-input-swapTime" title="Minimum time before mode change (seconds, minimum 60, from num, msg, flow, or global)"><i class="fa fa-clock-o"></i> Swap Time</label>
@@ -57,6 +69,11 @@
         <label for="node-input-initWindow" title="Initialization window to collect inputs before mode selection (seconds, non-negative number)"><i class="fa fa-hourglass-start"></i> Init Window</label>
         <input type="text" id="node-input-initWindow" placeholder="10">
     </div>
+    <div class="form-row split-only" style="display: none;">
+        <div id="initWindow-warning" style="color: red; display: none; margin-top: 5px;">
+            Invalid
+        </div>
+    </div>
     <div class="form-row">
         <label for="node-input-operationMode" title="Operation mode"><i class="fa fa-cogs"></i> Operation Mode</label>
         <select id="node-input-operationMode">
@@ -92,7 +109,7 @@
             operationMode: { value: "auto" }
         },
         inputs: 1,
-        outputs: 2,
+        outputs: 1,
         inputLabels: ["temperature"],
         outputLabels: ["isHeating", "status"],
         icon: "font-awesome/fa-retweet",
@@ -132,6 +149,18 @@
                     typeField: "#node-input-swapTimeType"
                 }).typedInput("type", node.swapTimeType || "num").typedInput("value", node.swapTime);
 
+                $("#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-extent").typedInput({
+                    default: "num",
+                    types: ["num", "msg", "flow", "global"],
+                    typeField: "#node-input-extentType"
+                }).typedInput("type", node.extentType || "num").typedInput("value", node.extent);
+
                 $("#node-input-minTempSetpoint").typedInput({
                     default: "num",
                     types: ["num", "msg", "flow", "global"],
@@ -149,7 +178,6 @@
                     if ($algorithm.val() === "single") {
                         $singleFields.show();
                         $splitFields.hide();
-                        $("#split-setpoint-warning").hide();
                     } else {
                         $singleFields.hide();
                         $splitFields.show();
@@ -158,22 +186,6 @@
 
                 $algorithm.on("change", toggleFields);
                 toggleFields();
-
-                // Validate non-typed inputs
-                $("#node-input-deadband").on("input", function() {
-                    const val = parseFloat($(this).val());
-                    $(this).toggleClass("input-error", isNaN(val) || val <= 0);
-                });
-
-                $("#node-input-extent").on("input", function() {
-                    const val = parseFloat($(this).val());
-                    $(this).toggleClass("input-error", isNaN(val) || val < 0);
-                });
-
-                $("#node-input-initWindow").on("input", function() {
-                    const val = parseFloat($(this).val());
-                    $(this).toggleClass("input-error", isNaN(val) || val < 0);
-                });
                 
             } catch (err) {
                 console.error("Error in changeover-block oneditprepare:", err);
@@ -200,7 +212,7 @@ The node supports two algorithms for determining HVAC mode
   - Uses a single `setpoint`, `deadband`, and `extent`.
   - **Heating** is triggered if the input temperature is below `setpoint - deadband/2 - extent`.
   - **Cooling** is triggered if the temperature exceeds `setpoint + deadband/2 + extent`.
-  - Example With `setpoint=70`, `deadband=2`, `extent=1`, heating starts below `70 - 2/2 - 1 = 68`, and cooling starts above `70 + 2/2 + 1 = 72`.
+  - Example With `setpoint=70`, `deadband=2``, heating starts below `70 - 2/2 = 68`, and cooling starts above `70 + 2/2 = 72`.
   - The `extent` widens thresholds to prevent nuisance mode changes due to overshoot.
 
 - **Split Setpoint**

package/nodes/changeover-block.js

@@ -1,4 +1,6 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function ChangeoverBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
@@ -7,10 +9,6 @@ module.exports = function(RED) {
         node.runtime = {
             name: config.name,
             algorithm: config.algorithm,
-            deadband: parseFloat(config.deadband),
-            extent: parseFloat(config.extent),
-            minTempSetpoint: parseFloat(config.minTempSetpoint),
-            maxTempSetpoint: parseFloat(config.maxTempSetpoint),
             operationMode: config.operationMode,
             initWindow: parseFloat(config.initWindow),
             currentMode: (config.operationMode === "cool" ? "cooling" : "heating"),
@@ -18,37 +16,25 @@ module.exports = function(RED) {
             lastModeChange: 0
         };
 
-        // Resolve typed inputs
-        let minTemp = node.runtime.minTempSetpoint;
-        let maxTemp = node.runtime.maxTempSetpoint;
-
-        if (node.runtime.algorithm === "single") {
-            node.runtime.setpoint = RED.util.evaluateNodeProperty(
-                config.setpoint, config.setpointType, node
-            );
-            node.runtime.setpoint = parseFloat(node.runtime.setpoint);
-        } else {
-            node.runtime.heatingSetpoint = RED.util.evaluateNodeProperty(
-                config.heatingSetpoint, config.heatingSetpointType, node
-            );
-            node.runtime.heatingSetpoint = parseFloat(node.runtime.heatingSetpoint);
-
-            node.runtime.coolingSetpoint = RED.util.evaluateNodeProperty(
-                config.coolingSetpoint, config.coolingSetpointType, node
-            );
-            node.runtime.coolingSetpoint = parseFloat(node.runtime.coolingSetpoint);
-
-            // Validate
-            if (node.runtime.coolingSetpoint < node.runtime.heatingSetpoint) {
-                node.runtime.coolingSetpoint = node.runtime.heatingSetpoint + 4;
-                node.status({ fill: "red", shape: "ring", text: "invalid setpoints, using fallback" });
-            }
+        const typedProperties = ['setpoint', 'heatingSetpoint', 'coolingSetpoint', 'swapTime', 'deadband', 
+            'extent', 'minTempSetpoint', 'maxTempSetpoint'];
+
+        // Evaluate typed-input properties    
+        try {            
+            const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, null, true);
+            node.runtime.setpoint = parseFloat(evaluatedValues.setpoint);
+            node.runtime.heatingSetpoint = parseFloat(evaluatedValues.heatingSetpoint);
+            node.runtime.coolingSetpoint = parseFloat(evaluatedValues.coolingSetpoint);
+            node.runtime.swapTime = parseFloat(evaluatedValues.swapTime);
+            node.runtime.deadband = parseFloat(evaluatedValues.deadband);
+            node.runtime.extent = parseFloat(evaluatedValues.extent);
+            node.runtime.minTempSetpoint = parseFloat(evaluatedValues.minTempSetpoint);
+            node.runtime.maxTempSetpoint = parseFloat(evaluatedValues.maxTempSetpoint);
+        } catch (err) {
+            node.error(`Error evaluating properties: ${err.message}`);
+            if (done) done();
+            return;
         }
-        
-        node.runtime.swapTime = RED.util.evaluateNodeProperty(
-            config.swapTime, config.swapTimeType, node
-        );
-        node.runtime.swapTime = parseFloat(node.runtime.swapTime);
 
         // Initialize state
         let initComplete = false;
@@ -63,9 +49,34 @@ module.exports = function(RED) {
                 node.status({ fill: "red", shape: "ring", text: "invalid message" });
                 if (done) done();
                 return;
+            }     
+
+            // Update typed-input properties if needed
+            try {    
+                const evaluatedValues = utils.evaluateProperties(node, config, typedProperties, msg);
+                node.runtime.setpoint = parseFloat(evaluatedValues.setpoint);
+                node.runtime.heatingSetpoint = parseFloat(evaluatedValues.heatingSetpoint);
+                node.runtime.coolingSetpoint = parseFloat(evaluatedValues.coolingSetpoint);
+                node.runtime.swapTime = parseFloat(evaluatedValues.swapTime);
+                node.runtime.deadband = parseFloat(evaluatedValues.deadband);
+                node.runtime.extent = parseFloat(evaluatedValues.extent);
+                node.runtime.minTempSetpoint = parseFloat(evaluatedValues.minTempSetpoint);
+                node.runtime.maxTempSetpoint = parseFloat(evaluatedValues.maxTempSetpoint);                
+            } catch (err) {
+                node.error(`Error evaluating properties: ${err.message}`);
+                if (done) done();
+                return;
             }
-            
+
             // Validate
+            if (node.runtime.coolingSetpoint < node.runtime.heatingSetpoint 
+                || node.runtime.maxTempSetpoint < node.runtime.minTempSetpoint 
+                || node.runtime.deadband <= 0 || node.runtime.extent < 0) {
+                node.status({ fill: "red", shape: "ring", text: "error validating properties, check setpoints" });
+                if (done) done(err);
+                return;
+            }
+            
             if (node.runtime.swapTime < 60) {
                 node.runtime.swapTime = 60;
                 node.status({ fill: "red", shape: "ring", text: "swapTime below 60s, using 60" });
@@ -104,12 +115,7 @@ module.exports = function(RED) {
                         node.status({ fill: "green", shape: "dot", text: `in: algorithm=${msg.payload}, out: ${node.runtime.currentMode}` });
                         break;
                     case "setpoint":
-                        if (node.runtime.algorithm !== "single") {
-                            node.status({ fill: "red", shape: "ring", text: "setpoint not used in split algorithm" });
-                            if (done) done();
-                            return;
-                        }
-                        if (isNaN(value) || value < minTemp || value > maxTemp) {
+                        if (isNaN(value) || value < node.runtime.minTempSetpoint || value > node.runtime.maxTempSetpoint) {
                             node.status({ fill: "red", shape: "ring", text: "invalid setpoint" });
                             if (done) done();
                             return;
@@ -119,11 +125,6 @@ module.exports = function(RED) {
                         node.status({ fill: "green", shape: "dot", text: `in: setpoint=${value.toFixed(1)}, out: ${node.runtime.currentMode}` });
                         break;
                     case "deadband":
-                        if (node.runtime.algorithm !== "single") {
-                            node.status({ fill: "red", shape: "ring", text: "deadband not used in split algorithm" });
-                            if (done) done();
-                            return;
-                        }
                         if (isNaN(value) || value <= 0) {
                             node.status({ fill: "red", shape: "ring", text: "invalid deadband" });
                             if (done) done();
@@ -133,12 +134,7 @@ module.exports = function(RED) {
                         node.status({ fill: "green", shape: "dot", text: `in: deadband=${value.toFixed(1)}, out: ${node.runtime.currentMode}` });
                         break;
                     case "heatingSetpoint":
-                        if (node.runtime.algorithm !== "split") {
-                            node.status({ fill: "red", shape: "ring", text: "heatingSetpoint not used in single algorithm" });
-                            if (done) done();
-                            return;
-                        }
-                        if (isNaN(value) || value < minTemp || value > maxTemp || value > node.runtime.coolingSetpoint) {
+                        if (isNaN(value) || value < node.runtime.minTempSetpoint || value > node.runtime.maxTempSetpoint || value > node.runtime.coolingSetpoint) {
                             node.status({ fill: "red", shape: "ring", text: "invalid heatingSetpoint" });
                             if (done) done();
                             return;
@@ -148,12 +144,7 @@ module.exports = function(RED) {
                         node.status({ fill: "green", shape: "dot", text: `in: heatingSetpoint=${value.toFixed(1)}, out: ${node.runtime.currentMode}` });
                         break;
                     case "coolingSetpoint":
-                        if (node.runtime.algorithm !== "split") {
-                            node.status({ fill: "red", shape: "ring", text: "coolingSetpoint not used in single algorithm" });
-                            if (done) done();
-                            return;
-                        }
-                        if (isNaN(value) || value < minTemp || value > maxTemp || value < node.runtime.heatingSetpoint) {
+                        if (isNaN(value) || value < node.runtime.minTempSetpoint || value > node.runtime.maxTempSetpoint || value < node.runtime.heatingSetpoint) {
                             node.status({ fill: "red", shape: "ring", text: "invalid coolingSetpoint" });
                             if (done) done();
                             return;
@@ -226,14 +217,14 @@ module.exports = function(RED) {
             }
 
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing temperature" });
+                node.status({ fill: "red", shape: "ring", text: "missing temperature payload property" });
                 if (done) done();
                 return;
             }
 
             let input = parseFloat(msg.payload);
             if (isNaN(input)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid temperature" });
+                node.status({ fill: "red", shape: "ring", text: "invalid temperature payload" });
                 if (done) done();
                 return;
             }
@@ -254,8 +245,6 @@ module.exports = function(RED) {
                 return;
             }
 
-
-
             send(evaluateState() || buildOutputs());
             updateStatus();
             if (done) done();
@@ -273,8 +262,8 @@ module.exports = function(RED) {
             } else {
                 let heatingThreshold, coolingThreshold;
                 if (node.runtime.algorithm === "single") {
-                    heatingThreshold = node.runtime.setpoint - node.runtime.deadband / 2 - node.runtime.extent;
-                    coolingThreshold = node.runtime.setpoint + node.runtime.deadband / 2 + node.runtime.extent;
+                    heatingThreshold = node.runtime.setpoint - node.runtime.deadband / 2;
+                    coolingThreshold = node.runtime.setpoint + node.runtime.deadband / 2;
                 } else {
                     heatingThreshold = node.runtime.heatingSetpoint - node.runtime.extent;
                     coolingThreshold = node.runtime.coolingSetpoint + node.runtime.extent;
@@ -307,8 +296,8 @@ module.exports = function(RED) {
             } else if (node.runtime.lastTemperature !== null) {
                 let heatingThreshold, coolingThreshold;
                 if (node.runtime.algorithm === "single") {
-                    heatingThreshold = node.runtime.setpoint - node.runtime.deadband / 2 - node.runtime.extent;
-                    coolingThreshold = node.runtime.setpoint + node.runtime.deadband / 2 + node.runtime.extent;
+                    heatingThreshold = node.runtime.setpoint - node.runtime.deadband / 2;
+                    coolingThreshold = node.runtime.setpoint + node.runtime.deadband / 2;
                 } else {
                     heatingThreshold = node.runtime.heatingSetpoint - node.runtime.extent;
                     coolingThreshold = node.runtime.coolingSetpoint + node.runtime.extent;
@@ -346,26 +335,27 @@ module.exports = function(RED) {
 
         function buildOutputs() {
             const isHeating = node.runtime.currentMode === "heating";
-            let heatingSetpoint, coolingSetpoint;
+            let effectiveHeatingSetpoint, effectiveCoolingSetpoint;
             if (node.runtime.algorithm === "single") {
-                heatingSetpoint = node.runtime.setpoint - node.runtime.deadband / 2;
-                coolingSetpoint = node.runtime.setpoint + node.runtime.deadband / 2;
+                effectiveHeatingSetpoint = node.runtime.setpoint - node.runtime.deadband / 2;
+                effectiveCoolingSetpoint = node.runtime.setpoint + node.runtime.deadband / 2;
             } else {
-                heatingSetpoint = node.runtime.heatingSetpoint;
-                coolingSetpoint = node.runtime.coolingSetpoint;
+                effectiveHeatingSetpoint = node.runtime.heatingSetpoint;
+                effectiveCoolingSetpoint = node.runtime.coolingSetpoint;
             }
 
             return [
-                { payload: isHeating, context: "isHeating" },
-                {
-                    payload: {
+                { 
+                    payload: isHeating,
+                    context: "isHeating", 
+                    status: {
                         mode: node.runtime.currentMode,
                         isHeating,
-                        heatingSetpoint,
-                        coolingSetpoint,
+                        heatingSetpoint: effectiveHeatingSetpoint,
+                        coolingSetpoint: effectiveCoolingSetpoint,
                         temperature: node.runtime.lastTemperature
                     }
-                }
+                },
             ];
         }
 

package/nodes/convert-block.js

@@ -1,45 +1,45 @@
-const validConversions = [
-    "F to C", 
-    "C to F", 
-    "K to C",
-    "C to K", 
-    "K to F",
-    "F to K",
-    "R to F",
-    "F to R",
-    "decimal to %", 
-    "% to decimal", 
-    "Pa to inH₂O", 
-    "inH₂O to Pa", 
-    "Pa to inHg", 
-    "inHg to Pa", 
-    "Pa to bar", 
-    "bar to Pa", 
-    "Pa to psi", 
-    "psi to Pa",
-    "m to ft",
-    "ft to m",
-    "m to in",
-    "in to m",
-    "mm to in",
-    "in to mm",
-    "kg to lb",
-    "lb to kg",
-    "L to gal",
-    "gal to L",
-    "kW to hp",
-    "hp to kW",
-    "rad to deg",
-    "deg to rad",
-    "s to min",
-    "min to s"
-];
-
 module.exports = function(RED) {
     function ConvertBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
+        const validConversions = [
+            "F to C", 
+            "C to F", 
+            "K to C",
+            "C to K", 
+            "K to F",
+            "F to K",
+            "R to F",
+            "F to R",
+            "decimal to %", 
+            "% to decimal", 
+            "Pa to inH₂O", 
+            "inH₂O to Pa", 
+            "Pa to inHg", 
+            "inHg to Pa", 
+            "Pa to bar", 
+            "bar to Pa", 
+            "Pa to psi", 
+            "psi to Pa",
+            "m to ft",
+            "ft to m",
+            "m to in",
+            "in to m",
+            "mm to in",
+            "in to mm",
+            "kg to lb",
+            "lb to kg",
+            "L to gal",
+            "gal to L",
+            "kW to hp",
+            "hp to kW",
+            "rad to deg",
+            "deg to rad",
+            "s to min",
+            "min to s"
+        ];
+
         // Initialize runtime state
         node.runtime = {
             conversion: validConversions.includes(config.conversion) ? config.conversion : "C to F"
@@ -87,7 +87,7 @@ module.exports = function(RED) {
 
             const inputValue = parseFloat(msg.payload);
             if (isNaN(inputValue) || !isFinite(inputValue)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid payload" });
+                node.status({ fill: "red", shape: "ring", text: `Invalid payload` });
                 if (done) done();
                 return;
             }
@@ -96,62 +96,62 @@ module.exports = function(RED) {
             let output, inUnit, outUnit;
             switch (node.runtime.conversion) {
                 case "F to C":
-                    output = (msg.payload - 32) * 5 / 9;
+                    output = (inputValue - 32) * 5 / 9;
                     inUnit = "°F";
                     outUnit = "°C";
                     break;
                 case "C to F":
-                    output = (msg.payload * 9 / 5) + 32;
+                    output = (inputValue * 9 / 5) + 32;
                     inUnit = "°C";
                     outUnit = "°F";
                     break;
                 case "decimal to %":
-                    output = msg.payload * 100;
+                    output = inputValue * 100;
                     inUnit = "";
                     outUnit = "%";
                     break;
                 case "% to decimal":
-                    output = msg.payload / 100;
+                    output = inputValue / 100;
                     inUnit = "%";
                     outUnit = "";
                     break;
                 case "Pa to inH₂O":
-                    output = msg.payload * 0.00401463;
+                    output = inputValue * 0.00401463;
                     inUnit = "Pa";
                     outUnit = "inH₂O";
                     break;
                 case "inH₂O to Pa":
-                    output = msg.payload / 0.00401463;
+                    output = inputValue / 0.00401463;
                     inUnit = "inH₂O";
                     outUnit = "Pa";
                     break;
                 case "Pa to inHg":
-                    output = msg.payload * 0.0002953;
+                    output = inputValue * 0.0002953;
                     inUnit = "Pa";
                     outUnit = "inHg";
                     break;
                 case "inHg to Pa":
-                    output = msg.payload / 0.0002953;
+                    output = inputValue / 0.0002953;
                     inUnit = "inHg";
                     outUnit = "Pa";
                     break;
                 case "Pa to bar":
-                    output = msg.payload * 0.00001;
+                    output = inputValue * 0.00001;
                     inUnit = "Pa";
                     outUnit = "bar";
                     break;
                 case "bar to Pa":
-                    output = msg.payload / 0.00001;
+                    output = inputValue / 0.00001;
                     inUnit = "bar";
                     outUnit = "Pa";
                     break;
                 case "Pa to psi":
-                    output = msg.payload * 0.000145038;
+                    output = inputValue * 0.000145038;
                     inUnit = "Pa";
                     outUnit = "psi";
                     break;
                 case "psi to Pa":
-                    output = msg.payload / 0.000145038;
+                    output = inputValue / 0.000145038;
                     inUnit = "psi";
                     outUnit = "Pa";
                     break;