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

package/nodes/string-builder-block.js

@@ -16,7 +16,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;
             }
@@ -27,7 +27,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;
                 }
@@ -82,7 +82,7 @@ module.exports = function(RED) {
             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;
                 }
@@ -94,12 +94,12 @@ module.exports = function(RED) {
                         if (config[`in${index}Type`] === "str") {
                             node[`in${index}`] = msg.payload;
                         } else {
-                            node.status({ fill: "red", shape: "ring", text: `Field type is ${config[`in${index}Type`]}` });
+                            utils.setStatusError(node, `Field type is ${config[`in${index}Type`]}`);
                             if (done) done();
                             return;
                         }
                     } else {
-                        node.status({ fill: "red", shape: "ring", text: `invalid input index ${index || "NaN"}` });
+                        utils.setStatusError(node, `invalid input index ${index || "NaN"}`);
                         if (done) done();
                         return;
                     }
@@ -107,7 +107,7 @@ module.exports = function(RED) {
             }
 
             const output = { payload: `${node.in1}${node.in2}${node.in3}${node.in4}` };
-            node.status({ fill: "blue", shape: "dot", text: `${ output.payload }` });
+            utils.setStatusOK(node, `${ output.payload }`);
             send(output);
 
             if (done) done();

package/nodes/subtract-block.js

@@ -1,28 +1,25 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
+
     function SubtractBlockNode(config) {
         RED.nodes.createNode(this, config);
         
         const node = this;
         
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            slots: parseInt(config.slots),
-            inputs: Array(parseInt(config.slots)).fill(0),
-            lastResult: null
-        };
+        // Initialize state
+        node.name = config.name;
+        node.slots = parseInt(config.slots);
+        node.inputs = Array(parseInt(config.slots)).fill(0);
+        node.lastResult = null;
 
         // Validate initial config
-        if (isNaN(node.runtime.slots) || node.runtime.slots < 1) {
-            node.runtime.slots = 2;
-            node.runtime.inputs = Array(2).fill(0);
-            node.status({ fill: "red", shape: "ring", text: "invalid slots, using 2" });
+        if (isNaN(node.slots) || node.slots < 1) {
+            node.slots = 2;
+            node.inputs = Array(2).fill(0);
+            utils.setStatusError(node, "invalid slots, using 2");
         } else {
-            node.status({
-                fill: "green",
-                shape: "dot",
-                text: `name: ${node.runtime.name}, slots: ${node.runtime.slots}`
-            });
+            utils.setStatusOK(node, `name: ${node.name}, slots: ${node.slots}`);
         }
 
         node.on("input", function(msg, send, done) {
@@ -30,65 +27,72 @@ module.exports = function(RED) {
 
             // Guard against invalid msg
             if (!msg) {
-                node.status({ fill: "red", shape: "ring", text: "invalid message" });
+                utils.setStatusError(node, "invalid message");
                 if (done) done();
                 return;
             }
 
             // Check for missing context or payload
             if (!msg.hasOwnProperty("context")) {
-                node.status({ fill: "red", shape: "ring", text: "missing context" });
+                utils.setStatusError(node, "missing context");
                 if (done) done();
                 return;
             }
 
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing payload" });
+                utils.setStatusError(node, "missing payload");
                 if (done) done();
                 return;
             }
 
             // Handle configuration messages
             if (msg.context === "reset") {
-                if (typeof msg.payload !== "boolean") {
-                    node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                const boolVal = utils.validateBoolean(msg.payload);
+                if (!boolVal.valid) {
+                    utils.setStatusError(node, boolVal.error);
                     if (done) done();
                     return;
                 }
-                if (msg.payload === true) {
-                    node.runtime.inputs = Array(node.runtime.slots).fill(0);
-                    node.runtime.lastResult = null;
-                    node.status({ fill: "green", shape: "dot", text: "state reset" });
+                if (boolVal.value === true) {
+                    node.inputs = Array(node.slots).fill(0);
+                    node.lastResult = null;
+                    utils.setStatusOK(node, "state reset");
                     if (done) done();
                     return;
                 }
             } else if (msg.context.startsWith("in")) {
-                let slotIndex = parseInt(msg.context.slice(2)) - 1;
-                if (isNaN(slotIndex) || slotIndex < 0 || slotIndex >= node.runtime.slots) {
-                    node.status({ fill: "red", shape: "ring", text: `invalid input slot ${msg.context}` });
+                const slotVal = utils.validateSlotIndex(msg.context, node.slots);
+                if (!slotVal.valid) {
+                    utils.setStatusError(node, slotVal.error);
                     if (done) done();
                     return;
                 }
+                const slotIndex = slotVal.index - 1;
                 let newValue = parseFloat(msg.payload);
                 if (isNaN(newValue)) {
-                    node.status({ fill: "red", shape: "ring", text: "invalid input" });
+                    utils.setStatusError(node, "invalid input");
                     if (done) done();
                     return;
                 }
-                node.runtime.inputs[slotIndex] = newValue;
+                node.inputs[slotIndex] = newValue;
                 
                 // Calculate subtraction
-                const result = node.runtime.inputs.reduce((acc, val, idx) => idx === 0 ? val : acc - val, 0);
-                const isUnchanged = result === node.runtime.lastResult;
-                node.status({ fill: "blue", shape: isUnchanged ? "ring" : "dot", text: `${msg.context}: ${newValue.toFixed(2)}, diff: ${result.toFixed(2)}` });
+                const result = node.inputs.reduce((acc, val, idx) => idx === 0 ? val : acc - val, 0);
+                const isUnchanged = result === node.lastResult;
+                const statusText = `${msg.context}: ${newValue.toFixed(2)}, diff: ${result.toFixed(2)}`;
+                if (isUnchanged) {
+                    utils.setStatusUnchanged(node, statusText);
+                } else {
+                    utils.setStatusChanged(node, statusText);
+                }
 
-                node.runtime.lastResult = result;
+                node.lastResult = result;
                 send({ payload: result });
 
                 if (done) done();
                 return;
             } else {
-                node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                utils.setStatusWarn(node, "unknown context");
                 if (done) done();
                 return;
             }

package/nodes/thermistor-block.js

@@ -1,51 +1,51 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
     function ThermistorBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
         const context = this.context();
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            R_fixed: parseFloat(config.R_fixed),
-            Vsupply: parseFloat(config.Vsupply),
-            Vref: parseFloat(config.Vref),
-            ADC_max: parseFloat(config.ADC_max),
-            lastVoltage: context.get("lastVoltage"),
-            lastResistance: context.get("lastResistance")
-        };
+        // Initialize state
+        node.name = config.name;
+        node.R_fixed = parseFloat(config.R_fixed);
+        node.Vsupply = parseFloat(config.Vsupply);
+        node.Vref = parseFloat(config.Vref);
+        node.ADC_max = parseFloat(config.ADC_max);
+        node.lastVoltage = context.get("lastVoltage");
+        node.lastResistance = context.get("lastResistance");
 
         // Validate configuration
-        if (isNaN(node.runtime.R_fixed) || node.runtime.R_fixed <= 0) {
-            node.status({ fill: "red", shape: "ring", text: "invalid r_fixed" });
-            node.warn(`Invalid configuration: r_fixed=${node.runtime.R_fixed}`);
+        if (isNaN(node.R_fixed) || node.R_fixed <= 0) {
+            utils.setStatusError(node, "invalid r_fixed");
+            node.warn(`Invalid configuration: r_fixed=${node.R_fixed}`);
             return;
         }
-        if (isNaN(node.runtime.Vsupply) || node.runtime.Vsupply <= 0) {
-            node.status({ fill: "red", shape: "ring", text: "invalid vsupply" });
-            node.warn(`Invalid configuration: vsupply=${node.runtime.Vsupply}`);
+        if (isNaN(node.Vsupply) || node.Vsupply <= 0) {
+            utils.setStatusError(node, "invalid vsupply");
+            node.warn(`Invalid configuration: vsupply=${node.Vsupply}`);
             return;
         }
-        if (isNaN(node.runtime.Vref) || node.runtime.Vref <= 0) {
-            node.status({ fill: "red", shape: "ring", text: "invalid vref" });
-            node.warn(`Invalid configuration: vref=${node.runtime.Vref}`);
+        if (isNaN(node.Vref) || node.Vref <= 0) {
+            utils.setStatusError(node, "invalid vref");
+            node.warn(`Invalid configuration: vref=${node.Vref}`);
             return;
         }
-        if (isNaN(node.runtime.ADC_max) || node.runtime.ADC_max <= 0) {
-            node.status({ fill: "red", shape: "ring", text: "invalid adc_max" });
-            node.warn(`Invalid configuration: adc_max=${node.runtime.ADC_max}`);
+        if (isNaN(node.ADC_max) || node.ADC_max <= 0) {
+            utils.setStatusError(node, "invalid adc_max");
+            node.warn(`Invalid configuration: adc_max=${node.ADC_max}`);
             return;
         }
 
         // Set initial status
-        node.status({ fill: "green", shape: "dot", text: `r_fixed: ${node.runtime.R_fixed}, vsupply: ${node.runtime.Vsupply}` });
+        utils.setStatusOK(node, `r_fixed: ${node.R_fixed}, vsupply: ${node.Vsupply}`);
 
         node.on("input", function(msg, send, done) {
             send = send || function() { node.send.apply(node, arguments); };
 
             // Validate input
             if (!msg || typeof msg !== "object") {
-                node.status({ fill: "red", shape: "ring", text: "missing message" });
+                utils.setStatusError(node, "missing message");
                 node.warn(`Missing message`);
                 if (done) done();
                 return;
@@ -54,7 +54,7 @@ module.exports = function(RED) {
             let inputArray;
             if (Buffer.isBuffer(msg.payload)) {
                 if (msg.payload.length !== 2) {
-                    node.status({ fill: "red", shape: "ring", text: "invalid input: expected 2-byte buffer" });
+                    utils.setStatusError(node, "invalid input: expected 2-byte buffer");
                     node.warn(`Invalid input: expected 2-byte buffer, got ${JSON.stringify(msg.payload)}`);
                     if (done) done();
                     return;
@@ -63,7 +63,7 @@ module.exports = function(RED) {
             } else if (typeof msg.payload === "object" && msg.payload.type === "Buffer" && Array.isArray(msg.payload.data) && msg.payload.data.length === 2) {
                 inputArray = msg.payload.data;
                 if (typeof inputArray[0] !== "number" || typeof inputArray[1] !== "number") {
-                    node.status({ fill: "red", shape: "ring", text: "invalid input: expected numeric [highByte, lowByte]" });
+                    utils.setStatusError(node, "invalid input: expected numeric [highByte, lowByte]");
                     node.warn(`Invalid input: expected numeric [highByte, lowByte], got ${JSON.stringify(msg.payload)}`);
                     if (done) done();
                     return;
@@ -71,7 +71,7 @@ module.exports = function(RED) {
             } else if (Array.isArray(msg.payload) && msg.payload.length === 2 && typeof msg.payload[0] === "number" && typeof msg.payload[1] === "number") {
                 inputArray = msg.payload;
             } else {
-                node.status({ fill: "red", shape: "ring", text: "invalid input: expected [highByte, lowByte] or 2-byte buffer" });
+                utils.setStatusError(node, "invalid input: expected [highByte, lowByte] or 2-byte buffer");
                 node.warn(`Invalid input: expected [highByte, lowByte] or 2-byte buffer, got ${JSON.stringify(msg.payload)}`);
                 if (done) done();
                 return;
@@ -80,43 +80,43 @@ module.exports = function(RED) {
             try {
                 // Calculate raw 16-bit value
                 const raw = (inputArray[0] << 8) | inputArray[1];
-                if (raw < 0 || raw > node.runtime.ADC_max) {
-                    node.status({ fill: "red", shape: "ring", text: "raw value out of range" });
-                    node.warn(`Raw value ${raw} out of range [0, ${node.runtime.ADC_max}]`);
+                if (raw < 0 || raw > node.ADC_max) {
+                    utils.setStatusError(node, "raw value out of range");
+                    node.warn(`Raw value ${raw} out of range [0, ${node.ADC_max}]`);
                     if (done) done();
                     return;
                 }
 
                 // Calculate voltage
-                const voltage = (raw * node.runtime.Vref) / node.runtime.ADC_max;
-                if (voltage >= node.runtime.Vsupply || voltage <= 0) {
-                    node.status({ fill: "red", shape: "ring", text: "voltage out of range" });
-                    node.warn(`Voltage ${voltage} out of range (0, ${node.runtime.Vsupply})`);
+                const voltage = (raw * node.Vref) / node.ADC_max;
+                if (voltage >= node.Vsupply || voltage <= 0) {
+                    utils.setStatusError(node, "voltage out of range");
+                    node.warn(`Voltage ${voltage} out of range (0, ${node.Vsupply})`);
                     if (done) done();
                     return;
                 }
 
                 // Calculate thermistor resistance
-                const R_thermistor = node.runtime.R_fixed * (voltage / (node.runtime.Vsupply - voltage));
+                const R_thermistor = node.R_fixed * (voltage / (node.Vsupply - voltage));
                 if (isNaN(R_thermistor) || R_thermistor < 0) {
-                    node.status({ fill: "red", shape: "ring", text: "invalid resistance" });
+                    utils.setStatusError(node, "invalid resistance");
                     node.warn(`Invalid resistance ${R_thermistor}`);
                     if (done) done();
                     return;
                 }
 
                 // Check if outputs have changed
-                const isUnchanged = voltage === node.runtime.lastVoltage && R_thermistor === node.runtime.lastResistance;
-                node.status({
-                    fill: "blue",
-                    shape: isUnchanged ? "ring" : "dot",
-                    text: `in: ${raw}, out: ${voltage.toFixed(2)}, ${R_thermistor.toFixed(2)}`
-                });
+                const isUnchanged = voltage === node.lastVoltage && R_thermistor === node.lastResistance;
+                if (isUnchanged) {
+                    utils.setStatusUnchanged(node, `in: ${raw}, out: ${voltage.toFixed(2)}, ${R_thermistor.toFixed(2)}`);
+                } else {
+                    utils.setStatusChanged(node, `in: ${raw}, out: ${voltage.toFixed(2)}, ${R_thermistor.toFixed(2)}`);
+                }
 
                 if (!isUnchanged) {
                     // Update context and runtime
-                    node.runtime.lastVoltage = voltage;
-                    node.runtime.lastResistance = R_thermistor;
+                    node.lastVoltage = voltage;
+                    node.lastResistance = R_thermistor;
                     context.set("lastVoltage", voltage);
                     context.set("lastResistance", R_thermistor);
 
@@ -128,7 +128,7 @@ module.exports = function(RED) {
                 }
 
             } catch (error) {
-                node.status({ fill: "red", shape: "ring", text: "calculation error" });
+                utils.setStatusError(node, "calculation error");
                 node.warn(`Calculation error: ${error.message}`);
                 if (done) done(error);
                 return;

package/nodes/tick-tock-block.js

@@ -1,19 +1,19 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
     function TickTockBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            period: parseFloat(config.period),
-            state: true
-        };
+        // Initialize state
+        node.name = config.name;
+        node.period = parseFloat(config.period);
+        node.state = true;
 
         // Validate initial config
-        if (isNaN(node.runtime.period) || node.runtime.period <= 0 || !isFinite(node.runtime.period)) {
-            node.runtime.period = 10;
-            node.status({ fill: "red", shape: "ring", text: "invalid period" });
+        if (isNaN(node.period) || node.period <= 0 || !isFinite(node.period)) {
+            node.period = 10;
+            utils.setStatusError(node, "invalid period");
         }
 
         let intervalId = null;
@@ -23,7 +23,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;
             }
@@ -31,12 +31,12 @@ 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;
                 }
@@ -44,50 +44,50 @@ module.exports = function(RED) {
                     case "period":
                         const value = parseFloat(msg.payload);
                         if (isNaN(value) || value <= 0 || !isFinite(value)) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid period" });
+                            utils.setStatusError(node, "invalid period");
                             if (done) done();
                             return;
                         }
-                        node.runtime.period = value;
-                        node.status({ fill: "green", shape: "dot", text: `period: ${node.runtime.period.toFixed(2)}` });
+                        node.period = value;
+                        utils.setStatusOK(node, `period: ${node.period.toFixed(2)}`);
                         if (intervalId) {
                             clearInterval(intervalId);
-                            node.runtime.state = true;
-                            const halfPeriodMs = (node.runtime.period * 1000) / 2;
-                            send({ payload: node.runtime.state });
-                            node.status({ fill: "blue", shape: "dot", text: `out: ${node.runtime.state}` });
+                            node.state = true;
+                            const halfPeriodMs = (node.period * 1000) / 2;
+                            send({ payload: node.state });
+                            utils.setStatusChanged(node, `out: ${node.state}`);
                             intervalId = setInterval(() => {
-                                node.runtime.state = !node.runtime.state;
-                                send({ payload: node.runtime.state });
-                                node.status({ fill: "blue", shape: "dot", text: `out: ${node.runtime.state}` });
+                                node.state = !node.state;
+                                send({ payload: node.state });
+                                utils.setStatusChanged(node, `out: ${node.state}`);
                             }, halfPeriodMs);
                         }
                         break;
                     case "command":
                         if (typeof msg.payload !== "string" || !["start", "stop"].includes(msg.payload)) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid command" });
+                            utils.setStatusError(node, "invalid command");
                             if (done) done();
                             return;
                         }
                         if (msg.payload === "start" && !intervalId) {
-                            node.runtime.state = true;
-                            const halfPeriodMs = (node.runtime.period * 1000) / 2;
-                            send({ payload: node.runtime.state });
-                            node.status({ fill: "blue", shape: "dot", text: `out: ${node.runtime.state}` });
+                            node.state = true;
+                            const halfPeriodMs = (node.period * 1000) / 2;
+                            send({ payload: node.state });
+                            utils.setStatusChanged(node, `out: ${node.state}`);
                             intervalId = setInterval(() => {
-                                node.runtime.state = !node.runtime.state;
-                                send({ payload: node.runtime.state });
-                                node.status({ fill: "blue", shape: "dot", text: `out: ${node.runtime.state}` });
+                                node.state = !node.state;
+                                send({ payload: node.state });
+                                utils.setStatusChanged(node, `out: ${node.state}`);
                             }, halfPeriodMs);
-                            node.status({ fill: "green", shape: "dot", text: `started, period: ${node.runtime.period.toFixed(2)}` });
+                            utils.setStatusOK(node, `started, period: ${node.period.toFixed(2)}`);
                         } else if (msg.payload === "stop" && intervalId) {
                             clearInterval(intervalId);
                             intervalId = null;
-                            node.status({ fill: "yellow", shape: "dot", text: "stopped" });
+                            utils.setStatusWarn(node, "stopped");
                         }
                         break;
                     default:
-                        node.status({ fill: "yellow", shape: "ring", text: "unknown context" });
+                        utils.setStatusWarn(node, "unknown context");
                         if (done) done("Unknown context");
                         return;
                 }

package/nodes/time-sequence-block.js

@@ -1,19 +1,19 @@
 module.exports = function(RED) {
+    const utils = require('./utils')(RED);
     function TimeSequenceBlockNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
 
         // Initialize runtime state
-        node.runtime = {
-            name: config.name,
-            delay: parseFloat(config.delay),
-            stage: 0
-        };
+        // Initialize state
+        node.name = config.name;
+        node.delay = parseFloat(config.delay);
+        node.stage = 0;
 
         // Validate initial config
-        if (isNaN(node.runtime.delay) || node.runtime.delay < 0 || !isFinite(node.runtime.delay)) {
-            node.runtime.delay = 5000;
-            node.status({ fill: "red", shape: "ring", text: "invalid delay" });
+        if (isNaN(node.delay) || node.delay < 0 || !isFinite(node.delay)) {
+            node.delay = 5000;
+            utils.setStatusError(node, "invalid delay");
         }
 
         let timer = null;
@@ -23,7 +23,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;
             }
@@ -31,39 +31,35 @@ module.exports = function(RED) {
             // Handle context updates
             if (msg.hasOwnProperty("context")) {
                 if (typeof msg.context !== "string") {
-                    node.status({ fill: "red", shape: "ring", text: "invalid context" });
+                    utils.setStatusError(node, "invalid context");
                     if (done) done();
                     return;
                 }
                 switch (msg.context) {
                     case "delay":
                         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;
                         }
                         const delayValue = parseFloat(msg.payload);
                         if (isNaN(delayValue) || delayValue < 0 || !isFinite(delayValue)) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid delay" });
+                            utils.setStatusError(node, "invalid delay");
                             if (done) done();
                             return;
                         }
-                        node.runtime.delay = delayValue;
-                        node.status({
-                            fill: "green",
-                            shape: "dot",
-                            text: `delay: ${node.runtime.delay.toFixed(2)} ms`
-                        });
+                        node.delay = delayValue;
+                        utils.setStatusOK(node, `delay: ${node.delay.toFixed(2)} ms`);
                         if (done) done();
                         return;
                     case "reset":
                         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.payload !== "boolean" || !msg.payload) {
-                            node.status({ fill: "red", shape: "ring", text: "invalid reset" });
+                            utils.setStatusError(node, "invalid reset");
                             if (done) done();
                             return;
                         }
@@ -71,13 +67,9 @@ module.exports = function(RED) {
                             clearTimeout(timer);
                             timer = null;
                         }
-                        node.runtime.stage = 0;
+                        node.stage = 0;
                         const resetMsg = { payload: false };
-                        node.status({
-                            fill: "green",
-                            shape: "dot",
-                            text: "state reset"
-                        });
+                        utils.setStatusOK(node, "state reset");
                         send([resetMsg, resetMsg, resetMsg, resetMsg]);
                         if (done) done();
                         return;
@@ -88,41 +80,37 @@ module.exports = function(RED) {
 
             // Validate input
             if (!msg.hasOwnProperty("payload")) {
-                node.status({ fill: "red", shape: "ring", text: "missing input" });
+                utils.setStatusError(node, "missing input");
                 if (done) done();
                 return;
             }
 
             // Process input
-            if (node.runtime.stage !== 0) {
-                node.status({ fill: "yellow", shape: "ring", text: "sequence already running" });
+            if (node.stage !== 0) {
+                utils.setStatusWarn(node, "sequence already running");
                 if (done) done();
                 return;
             }
 
             // Start new sequence
-            node.runtime.stage = 1;
+            node.stage = 1;
             const cloneMsg = RED.util.cloneMessage(msg);
 
             // Output sequence
             const sendNextOutput = () => {
-                if (node.runtime.stage === 0) return;
+                if (node.stage === 0) return;
                 const stageLabels = ["stage 1", "stage 2", "stage 3", "stage 4"];
                 const outputs = [null, null, null, null];
-                cloneMsg.stage = node.runtime.stage;
-                outputs[node.runtime.stage - 1] = cloneMsg;
-                node.status({
-                    fill: "blue",
-                    shape: "dot",
-                    text: `stage: ${stageLabels[node.runtime.stage - 1]}, in: ${JSON.stringify(cloneMsg.payload).slice(0, 20)}`
-                });
+                cloneMsg.stage = node.stage;
+                outputs[node.stage - 1] = cloneMsg;
+                utils.setStatusOK(node, `stage: ${stageLabels[node.stage - 1]}, in: ${JSON.stringify(cloneMsg.payload).slice(0, 20)}`);
                 send(outputs);
 
-                node.runtime.stage++;
-                if (node.runtime.stage <= 4) {
-                    timer = setTimeout(sendNextOutput, node.runtime.delay);
+                node.stage++;
+                if (node.stage <= 4) {
+                    timer = setTimeout(sendNextOutput, node.delay);
                 } else {
-                    node.runtime.stage = 0;
+                    node.stage = 0;
                     timer = null;
                 }
             };