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

package/nodes/saw-tooth-wave-block.js

@@ -1,32 +1,33 @@
 module.exports = function(RED) {
+    const utils = require("./utils")(RED);
+
     function SawToothWaveBlockNode(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) || 10) * (config.periodUnits === "minutes" ? 60000 : config.periodUnits === "seconds" ? 1000 : 1),
-            periodUnits: config.periodUnits || "seconds",
-            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) || 10) * (config.periodUnits === "minutes" ? 60000 : config.periodUnits === "seconds" ? 1000 : 1);
+        node.periodUnits = config.periodUnits || "seconds";
+        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 +35,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 +43,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,34 +100,26 @@ 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;
 
             // Sawtooth wave calculation
-            const amplitude = node.runtime.upperLimit - node.runtime.lowerLimit;
-            const value = node.runtime.lowerLimit + amplitude * node.runtime.phase;
+            const amplitude = node.upperLimit - node.lowerLimit;
+            const value = node.lowerLimit + amplitude * node.phase;
 
             // 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/scale-range-block.html

@@ -4,6 +4,10 @@
         <label for="node-input-name" title="Display name shown on the canvas"><i class="fa fa-tag"></i> Name</label>
         <input type="text" id="node-input-name" placeholder="Name">
     </div>
+    <div class="form-row">
+        <label for="node-input-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-inMin" title="Minimum input value (number)"><i class="fa fa-arrow-down"></i> Input Min</label>
         <input type="number" id="node-input-inMin" placeholder="0.0" step="any">
@@ -33,6 +37,7 @@
         color: "#301934",
         defaults: {
             name: { value: "" },
+            inputProperty: { value: "payload" },
             inMin: { value: 0.0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
             inMax: { value: 100.0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
             outMin: { value: 0.0, required: true, validate: function(v) { return !isNaN(parseFloat(v)) && isFinite(parseFloat(v)); } },
@@ -53,16 +58,18 @@
 
 <!-- Help Section -->
 <script type="text/markdown" data-help-name="scale-range-block">
-Scales a numeric input from one range to another and passes the original message.
+Scales numeric input from one range to another.
 
 ### Inputs
+: input-property (number) : Numeric value to scale, read from the configured Input Property.
 : context (string) : Configures settings (`"inMin"`, `"inMax"`, `"outMin"`, `"outMax"`, `"clamp"`). Unmatched values trigger error.
-: payload (number | boolean) : Number for input or range configuration, boolean for clamp.
 
 ### Outputs
 : payload (number) : Scaled output value.
 
 ### Properties
+: name (string) : Display name in editor.
+: inputProperty (string) : Message property to read input from (default: `payload`). Supports nested properties (e.g., `data.value`).
 : inMin (number) : Minimum input value.
 : inMax (number) : Maximum input value (> inMin).
 : outMin (number) : Minimum output value.
@@ -70,12 +77,11 @@ Scales a numeric input from one range to another and passes the original message
 : clamp (boolean) : Clamp output to output range.
 
 ### Details
-Scales `msg.payload` (number) from an input range (`inMin` to `inMax`) to an output range (`outMin` to `outMax`) using linear interpolation, with optional 
-clamping to `[outMin, outMax]` if `clamp` is `true`.
+Scales numeric input (read from the configured **Input Property**, default: `msg.payload`) from an input range (`inMin` to `inMax`) to an output range (`outMin` to `outMax`) using linear interpolation, with optional clamping to `[outMin, outMax]` if `clamp` is enabled.
 
-Outputs the input message with `msg.payload` set to the scaled value, preserving other properties. 
+Formula: `outValue = outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin)`
 
-Outputs on valid input or configuration change (recalculates with last input).
+Output is always written to `msg.payload`.
 
 ### Status
 - Green (dot): Configuration update

package/nodes/scale-range-block.js

@@ -1,25 +1,26 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
     function ScaleRangeBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name || "",
-            inMin: parseFloat(config.inMin),
-            inMax: parseFloat(config.inMax),
-            outMin: parseFloat(config.outMin),
-            outMax: parseFloat(config.outMax),
-            clamp: config.clamp,
-            lastInput: parseFloat(config.inMin)
-        };
+        // Initialize state
+        node.name = config.name || "";
+        node.inputProperty = config.inputProperty || "payload";
+        node.inMin = parseFloat(config.inMin);
+        node.inMax = parseFloat(config.inMax);
+        node.outMin = parseFloat(config.outMin);
+        node.outMax = parseFloat(config.outMax);
+        node.clamp = config.clamp;
+        node.lastInput = parseFloat(config.inMin);
 
         // Validate initial config
-        if (isNaN(node.runtime.inMin) || isNaN(node.runtime.inMax) || !isFinite(node.runtime.inMin) || !isFinite(node.runtime.inMax) || node.runtime.inMin >= node.runtime.inMax) {
-            node.runtime.inMin = 0.0;
-            node.runtime.inMax = 100.0;
-            node.runtime.lastInput = 0.0;
-            node.status({ fill: "red", shape: "ring", text: "invalid input range" });
+        if (isNaN(node.inMin) || isNaN(node.inMax) || !isFinite(node.inMin) || !isFinite(node.inMax) || node.inMin >= node.inMax) {
+            node.inMin = 0.0;
+            node.inMax = 100.0;
+            node.lastInput = 0.0;
+            utils.setStatusError(node, "invalid input range");
         }
 
         node.on("input", function(msg, send, done) {
@@ -27,7 +28,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;
             }
@@ -35,7 +36,7 @@ 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;
                 }
@@ -48,74 +49,80 @@ module.exports = function(RED) {
                     case "outMax":
                         const 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;
                         }
-                        node.runtime[msg.context] = value;
-                        if (node.runtime.inMax <= node.runtime.inMin) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid input range" });
+                        node[msg.context] = value;
+                        if (node.inMax <= node.inMin) {
+                            utils.setStatusError(node, "invalid input range");
                             if (done) done();
                             return;
                         }
-                        if (node.runtime.outMax <= node.runtime.outMin) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid output range" });
+                        if (node.outMax <= node.outMin) {
+                            utils.setStatusError(node, "invalid output range");
                             if (done) done();
                             return;
                         }
-                        node.status({ fill: "green", shape: "dot", text: `${msg.context}: ${value.toFixed(2)}` });
+                        utils.setStatusOK(node, `${msg.context}: ${value.toFixed(2)}`);
                         shouldOutput = true;
                         break;
                     case "clamp":
                         if (typeof msg.payload !== "boolean") {
-                            node.status({ fill: "red", shape: "ring", text: "invalid clamp" });
+                            utils.setStatusError(node, "invalid clamp");
                             if (done) done();
                             return;
                         }
-                        node.runtime.clamp = msg.payload;
-                        node.status({ fill: "green", shape: "dot", text: `clamp: ${node.runtime.clamp}` });
+                        node.clamp = msg.payload;
+                        utils.setStatusOK(node, `clamp: ${node.clamp}`);
                         shouldOutput = true;
                         break;
                     default:
-                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        utils.setStatusWarn(node, "unknown context");
                         if (done) done("Unknown context");
                         return;
                 }
 
                 // Recalculate with last input after config update
                 if (shouldOutput) {
-                    const out = calculate(node.runtime.lastInput, node.runtime.inMin, node.runtime.inMax, node.runtime.outMin, node.runtime.outMax, node.runtime.clamp);
+                    const out = calculate(node.lastInput, node.inMin, node.inMax, node.outMin, node.outMax, node.clamp);
                     msg.payload = out;
-                    node.status({ fill: "blue", shape: "dot", text: `in: ${node.runtime.lastInput.toFixed(2)}, out: ${out.toFixed(2)}` });
+                    utils.setStatusOK(node, `in: ${node.lastInput.toFixed(2)}, out: ${out.toFixed(2)}`);
                     send(msg);
                 }
                 if (done) done();
                 return;
             }
 
-            // Validate input
-            if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing input" });
+            // Get input from configured property
+            let input;
+            try {
+                input = RED.util.getMessageProperty(msg, node.inputProperty);
+            } catch (err) {
+                input = undefined;
+            }
+            if (input === undefined) {
+                utils.setStatusError(node, "missing or invalid input property");
                 if (done) done();
                 return;
             }
-            const inputValue = parseFloat(msg.payload);
+            const inputValue = parseFloat(input);
             if (isNaN(inputValue) || !isFinite(inputValue)) {
-                node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                utils.setStatusError(node, "invalid input");
                 if (done) done();
                 return;
             }
-            if (node.runtime.inMax <= node.runtime.inMin) {
-                node.status({ fill: "red", shape: "ring", text: "inMinx must be < inMax" });
+            if (node.inMax <= node.inMin) {
+                utils.setStatusError(node, "inMinx must be < inMax");
                 if (done) done();
                 return;
             }
 
             // Scale input
-            node.runtime.lastInput = inputValue;
-            const out = calculate(inputValue, node.runtime.inMin, node.runtime.inMax, node.runtime.outMin, node.runtime.outMax, node.runtime.clamp);
+            node.lastInput = inputValue;
+            const out = calculate(inputValue, node.inMin, node.inMax, node.outMin, node.outMax, node.clamp);
             msg.payload = out;
-            node.status({ fill: "blue", shape: "dot", text: `in: ${inputValue.toFixed(2)}, out: ${out.toFixed(2)}` });
+            utils.setStatusOK(node, `in: ${inputValue.toFixed(2)}, out: ${out.toFixed(2)}`);
             send(msg);
 
             if (done) done();

package/nodes/sine-wave-block.js

@@ -1,32 +1,32 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
     function SineWaveBlockNode(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,62 +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;
                 }
@@ -107,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;
 
             // Sine wave calculation
-            const sineValue = Math.sin(2 * Math.PI * node.runtime.phase);
-            const amplitude = (node.runtime.upperLimit - node.runtime.lowerLimit) / 2;
-            const value = node.runtime.lowerLimit + amplitude * (sineValue + 1);
+            const sineValue = Math.sin(2 * Math.PI * node.phase);
+            const amplitude = (node.upperLimit - node.lowerLimit) / 2;
+            const value = node.lowerLimit + amplitude * (sineValue + 1);
 
             // 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();