nodejs-poolcontroller 7.5.1 → 7.6.0

package/Changelog

@@ -1,4 +1,18 @@
 # Changelog
+## 7.6
+1. MasterTemp RS485 support for Nixie and IntelliCenter
+2. Nixie Valve Rotation delay
+3. Nixie Heater Cooldown delay
+4. Nixie Cleaner Start delay
+5. Nixie Cleaner Shutdown on Solar
+6. Nixie Delay Cancel
+
+## 7.5.1
+1. Backup/restore fixes
+2. Egg timer expiration
+3. Bug Fixes
+4. dashPanel/messageManager Filter
+5. RS485 refactor
 
 ## 7.5
 1. Backup/restore

package/README.md

@@ -1,4 +1,4 @@
-# nodejs-poolController - Version 7.5
+# nodejs-poolController - Version 7.6
 
 ## What is nodejs-poolController
 

package/controller/Equipment.ts

@@ -724,6 +724,16 @@ export class Options extends EqItem {
         if (typeof this.data.clockMode === 'undefined') this.data.clockMode = 12;
         if (typeof this.data.adjustDST === 'undefined') this.data.adjustDST = true;
         if (typeof this.data.freezeThreshold === 'undefined') this.data.freezeThreshold = 35;
+        if (typeof this.data.pumpDelay === 'undefined') this.data.pumpDelay = false;
+        if (typeof this.data.valveDelayTime === 'undefined') this.data.valveDelayTime = 30;
+        // RKS: 12-04-21 If you are reading this in a few months delete the line below.
+        if (this.data.valveDelayTime > 1000) this.data.valveDelayTime = this.data.valveDelayTime / 1000;
+        if (typeof this.data.heaterStartDelay === 'undefined') this.data.heaterStartDelay = true;
+        if (typeof this.data.cleanerStartDelay === 'undefined') this.data.cleanerStartDelay = true;
+        if (typeof this.data.cleanerSolarDelay === 'undefined') this.data.cleanerSolarDelay = true;
+        if (typeof this.data.heaterStartDelayTime === 'undefined') this.data.heaterStartDelayTime = 10;
+        if (typeof this.data.cleanerStartDelayTime === 'undefined') this.data.cleanerStartDelayTime = 300; // 5min
+        if (typeof this.data.cleanerSolarDelayTime === 'undefined') this.data.cleanerSolarDelayTime = 300; // 5min
     }
     public get clockMode(): number | any { return this.data.clockMode; }
     public set clockMode(val: number | any) { this.setDataVal('clockMode', sys.board.valueMaps.clockModes.encode(val)); }
@@ -740,10 +750,25 @@ export class Options extends EqItem {
     public set manualHeat(val: boolean) { this.setDataVal('manualHeat', val); }
     public get pumpDelay(): boolean { return this.data.pumpDelay; }
     public set pumpDelay(val: boolean) { this.setDataVal('pumpDelay', val); }
+    public get valveDelayTime(): number { return this.data.valveDelayTime; }
+    public set valveDelayTime(val: number) { this.setDataVal('valveDelayTime', val); }
     public get cooldownDelay(): boolean { return this.data.cooldownDelay; }
     public set cooldownDelay(val: boolean) { this.setDataVal('cooldownDelay', val); }
     public get freezeThreshold(): number { return this.data.freezeThreshold; }
     public set freezeThreshold(val: number) { this.setDataVal('freezeThreshold', val); }
+    public get heaterStartDelay(): boolean { return this.data.heaterStartDelay; }
+    public set heaterStartDelay(val: boolean) { this.setDataVal('heaterStartDelay', val); }
+    public get heaterStartDelayTime(): number { return this.data.heaterStartDelayTime; }
+    public set heaterStartDelayTime(val: number) { this.setDataVal('heaterStartDelayTime', val); }
+
+    public get cleanerStartDelay(): boolean { return this.data.cleanerStartDelay; }
+    public set cleanerStartDelay(val: boolean) { this.setDataVal('cleanerStartDelay', val); }
+    public get cleanerStartDelayTime(): number { return this.data.cleanerStartDelayTime; }
+    public set cleanerStartDelayTime(val: number) { this.setDataVal('cleanerStartDelayTime', val); }
+    public get cleanerSolarDelay(): boolean { return this.data.cleanerSolarDelay; }
+    public set cleanerSolarDelay(val: boolean) { this.setDataVal('cleanerSolarDelay', val); }
+    public get cleanerSolarDelayTime(): number { return this.data.cleanerSolarDelayTime; }
+    public set cleanerSolarDelayTime(val: number) { this.setDataVal('cleanerSolarDelayTime', val); }
 
     //public get airTempAdj(): number { return typeof this.data.airTempAdj === 'undefined' ? 0 : this.data.airTempAdj; }
     //public set airTempAdj(val: number) { this.setDataVal('airTempAdj', val); }
@@ -1129,6 +1154,9 @@ export class EggTimer extends EqItem {
 }
 export class CircuitCollection extends EqItemCollection<Circuit> {
     constructor(data: any, name?: string) { super(data, name || "circuits"); }
+    public filter(f: (value: Circuit, index?: any, array?: any[]) => boolean): CircuitCollection {
+        return new CircuitCollection({ circuits: this.data.filter(f) });
+    }
     public createItem(data: any): Circuit { return new Circuit(data); }
     public add(obj: any): Circuit {
         this.data.push(obj);
@@ -1185,7 +1213,22 @@ export class Circuit extends EqItem implements ICircuit {
     public get deviceBinding(): string { return this.data.deviceBinding; }
     public set deviceBinding(val: string) { this.setDataVal('deviceBinding', val); }
     public get hasHeatSource() { return typeof sys.board.valueMaps.circuitFunctions.get(this.type || 0).hasHeatSource !== 'undefined' ? sys.board.valueMaps.circuitFunctions.get(this.type || 0).hasHeatSource : false };
-    public getLightThemes() { return sys.board.circuits.getLightThemes(this.type); }
+    public getLightThemes() {
+        // Lets do this universally driven by the metadata.
+        let cf = sys.board.valueMaps.circuitFunctions.transform(this.type);
+        if (cf.isLight && typeof cf.theme !== 'undefined') {
+            let arrThemes = sys.board.valueMaps.lightThemes.toArray();
+            let themes = [];
+            for (let i = 0; i < arrThemes.length; i++) {
+                let thm = arrThemes[i];
+                if (typeof thm.types !== 'undefined' && thm.types.length > 0 && thm.types.includes(cf.theme)) themes.push(thm);
+            }
+            return themes;
+        }
+        else return [];
+
+        //return sys.board.circuits.getLightThemes(this.type);
+    }
     public static getIdName(id: number) {
         // todo: adjust for intellitouch
         let defName = "Aux" + (id + 1).toString();
@@ -1197,6 +1240,9 @@ export class Circuit extends EqItem implements ICircuit {
 }
 export class FeatureCollection extends EqItemCollection<Feature> {
     constructor(data: any, name?: string) { super(data, name || "features"); }
+    public filter(f: (value: Circuit, index?: any, array?: any[]) => boolean): FeatureCollection {
+        return new FeatureCollection({ features: this.data.filter(f) });
+    }
     public createItem(data: any): Feature { return new Feature(data); }
 }
 export class Feature extends EqItem implements ICircuit {
@@ -1206,6 +1252,7 @@ export class Feature extends EqItem implements ICircuit {
         if (typeof this.data.isActive === 'undefined') this.data.isActive = true;
         if (typeof this.data.eggTimer === 'undefined') this.data.eggTimer = 720;
         if (typeof this.data.showInFeatures === 'undefined') this.data.showInFeatures = true;
+        if (typeof this.data.master === 'undefined') this.data.master = sys.board.equipmentMaster; 
     }
     public dataName = 'featureConfig';
     public get id(): number { return this.data.id; }
@@ -1454,6 +1501,22 @@ export class Chlorinator extends EqItem {
 export class ValveCollection extends EqItemCollection<Valve> {
     constructor(data: any, name?: string) { super(data, name || "valves"); }
     public createItem(data: any): Valve { return new Valve(data); }
+    public getIntake(): Valve[] {
+        let valves = this.data.filter(x => x.isIntake === true);
+        let ret = [];
+        for (let i = 0; i < valves.length; i++) {
+            ret.push(this.getItemById(valves[i].id));
+        }
+        return ret;
+    }
+    public getReturn(): Valve[] {
+        let valves = this.data.filter(x => x.isReturn === true);
+        let ret = [];
+        for (let i = 0; i < valves.length; i++) {
+            ret.push(this.getItemById(valves[i].id));
+        }
+        return ret;
+    }
 }
 export class Valve extends EqItem {
     public dataName = 'valveConfig';
@@ -1492,6 +1555,22 @@ export class HeaterCollection extends EqItemCollection<Heater> {
         if (typeof add !== 'undefined' && add) return this.add(data || { id: this.data.length + 1, address: address });
         return this.createItem(data || { id: this.data.length + 1, address: address });
     }
+    public filter(f: (value: Heater, index?: any, array?: any[]) => boolean): HeaterCollection {
+        return new HeaterCollection({ heaters: this.data.filter(f) });
+    }
+
+    public getSolarHeaters(bodyId?: number): EqItemCollection<Heater> {
+        let htype = sys.board.valueMaps.heaterTypes.getValue('solar');
+        return new HeaterCollection(this.data.filter(x => {
+            if (x.type === htype) {
+                if (typeof bodyId !== 'undefined') {
+                    if (!x.isActive) return false;
+                    return (bodyId === x.body || (sys.equipment.shared && x.body === 32)) ? true : false;
+                }
+            }
+            return false;
+        }));
+    }
 }
 export class Heater extends EqItem {
     public dataName = 'heaterConfig';
@@ -1664,7 +1743,33 @@ export class LightGroup extends EqItem implements ICircuitGroup, ICircuit {
     public get lightingTheme(): number | any { return this.data.lightingTheme; }
     public set lightingTheme(val: number | any) { this.setDataVal('lightingTheme', sys.board.valueMaps.lightThemes.encode(val)); }
     public get circuits(): LightGroupCircuitCollection { return new LightGroupCircuitCollection(this.data, "circuits"); }
-    public getLightThemes() { return sys.board.valueMaps.lightThemes.toArray(); }
+    public getLightThemes() {
+        // Go through the circuits and gather the themes.
+        // This method first looks at the circuits to determine their type (function)
+        // then it filters the list by the types associated with the circuits.  It does this because
+        // there can be combined ColorLogic and IntelliBrite lights.  The themes array has
+        // the circuit function.
+        let arrThemes = [];
+        for (let i = 0; i < this.circuits.length; i++) {
+            let circ = this.circuits.getItemByIndex(i);
+            let c = sys.circuits.getInterfaceById(circ.circuit);
+            let cf = sys.board.valueMaps.circuitFunctions.transform(c.type);
+            if (cf.isLight && typeof cf.theme !== 'undefined') {
+                if (!arrThemes.includes(cf.theme)) arrThemes.push(cf.theme);
+            }
+        }
+        // Alright now we need to get a listing of the themes.
+        let t = sys.board.valueMaps.lightThemes.toArray();
+        let ret = [];
+        for (let i = 0; i < t.length; i++) {
+            let thm = t[i];
+            if (typeof thm.types !== 'undefined' && thm.types.length > 0) {
+                // Look in the themes array of the theme.
+                if (arrThemes.some(x => thm.types.includes(x))) ret.push(thm);
+            }
+        }
+        return ret;
+    }
     public getExtended() {
         let group = this.get(true);
         group.type = sys.board.valueMaps.circuitGroupTypes.transform(group.type);

package/controller/Errors.ts

@@ -144,6 +144,16 @@ export class ParameterOutOfRangeError extends InvalidOperationError {
     public value;
     public parameter: string;
 }
+export class BoardProcessError extends ApiError {
+    constructor(message: string, process?: string) {
+        super(message, 300, 400);
+        this.name = 'ProcessingError';
+        this.process = process;
+    }
+    public process: string;
+    
+}
+
 export class MessageError extends ApiError {
     constructor(msg: Message, message: string, code?: number, httpCode?: number) {
         super(message, code, httpCode);

package/controller/Lockouts.ts

@@ -0,0 +1,423 @@
+/*  nodejs-poolController.  An application to control pool equipment.
+Copyright (C) 2016, 2017, 2018, 2019, 2020.  Russell Goldin, tagyoureit.  russ.goldin@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+import { PumpState, HeaterState, BodyTempState, ICircuitState, state } from "./State";
+import { Equipment, sys } from "./Equipment";
+import { utils } from "./Constants";
+import { logger } from "../logger/Logger";
+import { webApp } from "../web/Server";
+// LOCKOUT PRIMER
+// Lockouts are either time based (Delays) or based upon the current state configuration for
+// the system.  So in some cases circuits can only be engaged in pool mode or in spa mode.  In
+// others a period of time must occur before a particular action can continue.  Delays can typically
+// be cancelled manually while lockouts can only be cancelled when the condition required for the lockout
+// is changed.
+
+// DELAYS:
+// Pump Off During Valve Rotation (30 sec):  This turns any pump associated with the body being turned on to
+// so that is is off.  This gives the valves time to rotate so that cold water from the pool does not cycle into
+// the spa and hot water from the spa does not escape into the pool.  This has nothing to do with
+// water hammer or anything else.
+//
+// Heater Cooldown Delay (based on max heater time):  When the system is heating and an event is occurring
+// that will cause the heater to be turned off, the current mode will be retained until the delay is either
+// cancelled or expired.  
+//    Delay Conditions:
+//    1. Being in either pool or spa mode and simply turning off that mode where the heater will be turned off.
+//    2. Switching between pool and spa when the target mode does not use the identified heater.
+//    Exceptions:
+//    1. The last call for heat was earlier than the current time minus the cooldown delay defined for the heater.
+//    2. The heater mode is in a cooling mode.
+//
+// Heater Startup: When a body is first turned on the heater will not be engaged for 10 seconds after any pump delay
+// or the time that the body is engaged.
+//
+// Cleaner Circuit Start Delay: Delays turning on any circuit with a cleaner function until the delay expires.  This is
+// so booster pumps can be assured of sufficient forward pressure prior to turning on.  These pumps often require sufficient
+// pressure before engaging and will cavitate if they do not have it.  The Pentair default is 5min.
+//
+// Cleaner Circuit Solar Delay: This only exists with Pentair panels.  This shuts off any circuit 
+// designated as a pool cleaner circuit if it is on and delays turning it on for 5min after the solar starts.  The assumption
+// here is that pressure reduction that can occur when the solar kicks on can cavitate the pump.
+//
+// LOCKOUTS (Proposed):
+// Spillway Lockout: This locks out any circuit or feature that is marked with a Spillway circuit function (type) whenever
+// whenever the pool circuit is not engaged.  This should mark the spillway circuit as a delayStart then release it when the
+// pool body starts.
+interface ILockout {
+    type: string
+}
+export class EquipmentLockout implements ILockout {
+    public id = utils.uuid();
+    public create() { }
+    public startTime: Date;
+    public type: string = 'lockout';
+    public message: string = '';
+}
+export class EquipmentDelay implements ILockout {
+    public constructor() { this.id = delayMgr.getNextId(); }
+    public id;
+    public type: string = 'delay';
+    public endTime: Date;
+    public canCancel: boolean = true;
+    public cancelDelay() { };
+    public reset() { };
+    public clearDelay() { };
+    public message;
+    protected _delayTimer: NodeJS.Timeout;
+    public serialize(): any {
+        return {
+            id: this.id,
+            type: this.type,
+            canCancel: this.canCancel,
+            message: this.message
+        };
+    }
+}
+export class PumpValveDelay extends EquipmentDelay {
+    public constructor(ps: PumpState, delay?: number) {
+        super();
+        this.type = 'pumpValveDelay';
+        this.message = `${ps.name} will start after valve Delay`;
+        this.pumpState = ps;
+        this.pumpState.pumpOnDelay = true;
+        this._delayTimer = setTimeout(() => {
+            logger.info(`Valve delay expired for ${this.pumpState.name}`);
+            this.pumpState.pumpOnDelay = false;
+            delayMgr.deleteDelay(this.id);
+        }, delay * 1000 || sys.general.options.valveDelayTime * 1000);
+        logger.info(`Valve delay started for ${this.pumpState.name} - ${delay || sys.general.options.valveDelayTime}sec`);
+    }
+    public pumpState: PumpState;
+    public cancelDelay() {
+        this.pumpState.pumpOnDelay = false;
+        if (typeof this._delayTimer !== 'undefined') clearTimeout(this._delayTimer);
+        logger.info(`Valve delay cancelled for ${this.pumpState.name}`);
+        this._delayTimer = undefined;
+        delayMgr.deleteDelay(this.id);
+    }
+    public clearDelay() {
+        if (typeof this._delayTimer !== 'undefined') clearTimeout(this._delayTimer);
+        logger.info(`Valve delay cleared for ${this.pumpState.name}`);
+        this._delayTimer = undefined;
+        delayMgr.deleteDelay(this.id);
+    }
+}
+export class HeaterStartupDelay extends EquipmentDelay {
+    public constructor(hs: HeaterState, delay?: number) {
+        super();
+        this.type = 'heaterStartupDelay';
+        this.message = `${hs.name} will start after delay`;
+        this.heaterState = hs;
+        this.heaterState.startupDelay = true;
+        this._delayTimer = setTimeout(() => {
+            logger.info(`Heater Startup delay expired for ${this.heaterState.name}`);
+            this.heaterState.startupDelay = false;
+            delayMgr.deleteDelay(this.id);
+        }, delay * 1000 || sys.general.options.valveDelayTime * 1000);
+        logger.info(`Heater delay started for ${this.heaterState.name} - ${delay || sys.general.options.heaterStartDelayTime}sec`);
+    }
+    public heaterState: HeaterState;
+    public cancelDelay() {
+        this.heaterState.startupDelay = false;
+        if (typeof this._delayTimer !== 'undefined') clearTimeout(this._delayTimer);
+        logger.info(`Heater Startup delay cancelled for ${this.heaterState.name}`);
+        this._delayTimer = undefined;
+        delayMgr.deleteDelay(this.id);
+    }
+}
+export class HeaterCooldownDelay extends EquipmentDelay {
+    public constructor(bsoff: BodyTempState, bson?: BodyTempState, delay?: number) {
+        super();
+        this.type = 'heaterCooldownDelay';
+        this.message = `${bsoff.name} Heater Cooldown in progress`;
+        this.bodyStateOff = bsoff;
+        this.bodyStateOff.heaterCooldownDelay = true;
+        this.bodyStateOff.heatStatus = sys.board.valueMaps.heatStatus.getValue('cooldown');
+        let cstateOff = state.circuits.getItemById(bsoff.circuit);
+        this.bodyStateOn = bson;
+        this.bodyStateOff.stopDelay = cstateOff.stopDelay = true;
+        let cstateOn = (typeof bson !== 'undefined') ? state.circuits.getItemById(bson.circuit) : undefined;
+        if (typeof cstateOn !== 'undefined') {
+            this.bodyStateOn.startDelay = cstateOn.startDelay = true;
+        }
+        logger.verbose(`Heater Cooldown Delay started for ${this.bodyStateOff.name} - ${delay/1000}sec`);
+        this._delayTimer = setTimeout(() => {
+            logger.verbose(`Heater Cooldown delay expired for ${this.bodyStateOff.name}`);
+            this.bodyStateOff.stopDelay = state.circuits.getItemById(this.bodyStateOff.circuit).stopDelay = false;
+            // Now that the startup delay expired cancel the delay and shut off the circuit.
+            (async () => {
+                try {
+                    await sys.board.circuits.setCircuitStateAsync(cstateOff.id, false, true);
+                    if (typeof this.bodyStateOn !== 'undefined') {
+                        this.bodyStateOn.startDelay = state.circuits.getItemById(this.bodyStateOn.circuit).startDelay = false;
+                        await sys.board.circuits.setCircuitStateAsync(this.bodyStateOn.circuit, true);
+                    }
+                } catch (err) { logger.error(`Error executing Cooldown Delay completion: ${err}`); }
+            })();
+            this.bodyStateOff.heaterCooldownDelay = false;
+            this.bodyStateOff.heatStatus = sys.board.valueMaps.heatStatus.getValue('off');
+            delayMgr.deleteDelay(this.id);
+        }, delay);
+        state.emitEquipmentChanges();
+    }
+    public bodyStateOff: BodyTempState;
+    public bodyStateOn: BodyTempState;
+    public setBodyStateOn(bson?: BodyTempState) {
+        if (typeof this.bodyStateOn !== 'undefined' && (typeof bson === 'undefined' || this.bodyStateOn.id !== bson.id))
+            this.bodyStateOn.startDelay = state.circuits.getItemById(this.bodyStateOn.circuit).startDelay = false;
+        if (typeof bson !== 'undefined') {
+            if (typeof this.bodyStateOn === 'undefined' || this.bodyStateOn.id !== bson.id) {
+                bson.startDelay = state.circuits.getItemById(bson.circuit).startDelay = true;
+                logger.info(`${bson.name} will Start After Cooldown Delay`);
+                this.bodyStateOn = bson;
+            }
+        }
+        else this.bodyStateOn = undefined;
+    }
+    public cancelDelay() {
+        let cstateOff = state.circuits.getItemById(this.bodyStateOff.circuit);
+        cstateOff.stopDelay = false;
+        (async () => {
+            await sys.board.circuits.setCircuitStateAsync(cstateOff.id, false);
+            if (typeof this.bodyStateOn !== 'undefined') {
+                this.bodyStateOn.startDelay = state.circuits.getItemById(this.bodyStateOn.circuit).startDelay = false;
+                await sys.board.circuits.setCircuitStateAsync(this.bodyStateOn.circuit, true);
+            }
+        })();
+        this.bodyStateOff.stopDelay = this.bodyStateOff.heaterCooldownDelay = false;
+        this.bodyStateOff.heatStatus = sys.board.valueMaps.heatStatus.getValue('off');
+        if (typeof this._delayTimer !== 'undefined') clearTimeout(this._delayTimer);
+        logger.info(`Heater Cooldown delay cancelled for ${this.bodyStateOff.name}`);
+        this._delayTimer = undefined;
+        delayMgr.deleteDelay(this.id);
+        state.emitEquipmentChanges();
+    }
+
+}
+interface ICleanerDelay {
+    cleanerState: ICircuitState,
+    bodyId: number
+}
+export class CleanerStartDelay extends EquipmentDelay implements ICleanerDelay {
+    constructor(cs: ICircuitState, bodyId: number, delay?: number) {
+        super();
+        this.type = 'cleanerStartDelay';
+        this.message = `${cs.name} will start after delay`;
+        this.bodyId = bodyId;
+        this.cleanerState = cs;
+        cs.startDelay = true;
+        this._delayTimer = setTimeout(() => {
+            logger.info(`Cleaner delay expired for ${this.cleanerState.name}`);
+            this.cleanerState.startDelay = false;
+            (async () => {
+                try {
+                    await sys.board.circuits.setCircuitStateAsync(this.cleanerState.id, true, true);
+                    this.cleanerState.startDelay = false;
+                } catch (err) { logger.error(`Error executing Cleaner Start Delay completion: ${err}`); }
+            })();
+            delayMgr.deleteDelay(this.id);
+        }, delay * 1000 || sys.general.options.cleanerStartDelayTime * 1000);
+        logger.info(`Cleaner delay started for ${this.cleanerState.name} - ${delay || sys.general.options.cleanerStartDelayTime}sec`);
+    }
+    public cleanerState: ICircuitState;
+    public bodyId: number;
+    public cancelDelay() {
+        this.cleanerState.startDelay = false;
+        if (typeof this._delayTimer !== 'undefined') clearTimeout(this._delayTimer);
+        logger.info(`Cleaner Start delay cancelled for ${this.cleanerState.name}`);
+        this._delayTimer = undefined;
+        this.cleanerState.startDelay = false;
+        (async () => {
+            try {
+                await sys.board.circuits.setCircuitStateAsync(this.cleanerState.id, true, true);
+            } catch (err) { logger.error(`Error executing Cleaner Start Delay completion: ${err}`); }
+        })();
+        delayMgr.deleteDelay(this.id);
+    }
+    public clearDelay() {
+        this.cleanerState.startDelay = false;
+        if (typeof this._delayTimer !== 'undefined') clearTimeout(this._delayTimer);
+        logger.info(`Cleaner Start delay cleared for ${this.cleanerState.name}`);
+        this._delayTimer = undefined;
+        this.cleanerState.startDelay = false;
+        delayMgr.deleteDelay(this.id);
+    }
+
+    public reset(delay?: number) {
+        if (typeof this._delayTimer !== 'undefined') clearTimeout(this._delayTimer);
+        this.cleanerState.startDelay = true;
+        logger.info(`Cleaner Start delay reset for ${this.cleanerState.name}`);
+        this._delayTimer = setTimeout(() => {
+            logger.info(`Cleaner delay expired for ${this.cleanerState.name}`);
+            this.cleanerState.startDelay = false;
+            (async () => {
+                try {
+                    await sys.board.circuits.setCircuitStateAsync(this.cleanerState.id, true);
+                    this.cleanerState.startDelay = false;
+                } catch (err) { logger.error(`Error executing Cleaner Start Delay completion: ${err}`); }
+            })();
+            delayMgr.deleteDelay(this.id);
+        }, delay * 1000 || sys.general.options.cleanerStartDelayTime * 1000);
+    }
+}
+export class DelayManager extends Array<EquipmentDelay> {
+    protected _id = 1;
+    private _emitTimer: NodeJS.Timeout;
+    public setDirty() {
+        if (typeof this._emitTimer) clearTimeout(this._emitTimer);
+        this._emitTimer = setTimeout(() => this.emitDelayState(), 1000);
+    }
+    public getNextId() { return this._id++; }
+    public cancelDelay(id: number) {
+        let del = this.find(x => x.id === id);
+        if (typeof del !== 'undefined') del.cancelDelay();
+    }
+    public setPumpValveDelay(ps: PumpState, delay?: number) {
+        let cds = this.filter(x => x.type === 'pumpValveDelay');
+        for (let i = 0; i < cds.length; i++) {
+            let delay = cds[i] as PumpValveDelay;
+            if (delay.pumpState.id === ps.id) delay.clearDelay();
+        }
+        this.push(new PumpValveDelay(ps, delay)); this.setDirty();
+    }
+    public cancelPumpValveDelays() { this.cancelDelaysByType('pumpValveDelay'); this.setDirty(); }
+    public setHeaterStartupDelay(hs: HeaterState, delay?: number) {
+        let cds = this.filter(x => x.type === 'heaterStartupDelay');
+        for (let i = 0; i < cds.length; i++) {
+            let delay = cds[i] as HeaterStartupDelay;
+            if (delay.heaterState.id === hs.id) delay.cancelDelay();
+        }
+        this.push(new HeaterStartupDelay(hs, delay)); this.setDirty();
+    }
+    public cancelHeaterStartupDelays() {
+        this.cancelDelaysByType('heaterStartupDelay');
+    }
+    public setHeaterCooldownDelay(bsOff: BodyTempState, bsOn?: BodyTempState, delay?: number) {
+        logger.info(`Setting Heater Cooldown Delay for ${bsOff.name}`);
+        let cds = this.filter(x => x.type === 'heaterCooldownDelay');
+        for (let i = 0; i < cds.length; i++) {
+            let delay = cds[i] as HeaterCooldownDelay;
+            if (delay.bodyStateOff.id === bsOff.id) {
+                if(typeof bsOn !== 'undefined') logger.info(`Found Cooldown Delay adding on circuit ${bsOn.name}`);
+                delay.setBodyStateOn(bsOn);
+                this.setDirty();
+                return;
+            }
+        }
+        this.push(new HeaterCooldownDelay(bsOff, bsOn, delay));
+        this.setDirty();
+    }
+    public clearBodyStartupDelay(bs: BodyTempState) {
+        logger.info(`Clearing startup delays for ${bs.name}`);
+        // We are doing this non type safety thing below so that
+        // we can only emit when the body is cleared.
+        let cds = this.filter(x => {
+            return x.type === 'heaterCooldownDelay' &&
+                typeof x['bodyStateOn'] !== 'undefined' &&
+                x['bodyStateOn'].id === bs.id;
+        });
+        for (let i = 0; i < cds.length; i++) {
+            let delay = cds[i] as HeaterCooldownDelay;
+            logger.info(`Clearing ${bs.name} from Cooldown Delay`);
+            delay.setBodyStateOn();
+        }
+        if (cds.length) this.setDirty();
+    }
+    public cancelHeaterCooldownDelays() { this.cancelDelaysByType('heaterCooldownDelay'); }
+    public setCleanerStartDelay(cs: ICircuitState, bodyId: number, delay?: number) {
+        let cds = this.filter(x => x.type === ('cleanerStartDelay' || 'cleanerSolarDelay'));
+        let startDelay: CleanerStartDelay;
+        for (let i = 0; i < cds.length; i++) {
+            let delay = cds[i] as unknown as ICleanerDelay;
+            if (delay.cleanerState.id === cs.id) {
+                if (delay.bodyId !== bodyId || cds[i].type !== 'cleanerStartDelay') cds[i].cancelDelay();
+                else if (typeof startDelay !== 'undefined') {
+                    startDelay.cancelDelay();
+                    startDelay = cds[i] as CleanerStartDelay;
+                }
+                else startDelay = cds[i] as CleanerStartDelay;
+            }
+        }
+        if (typeof startDelay !== 'undefined') {
+            startDelay.reset(delay);
+            this.setDirty();
+        }
+        else {
+            this.push(new CleanerStartDelay(cs, bodyId, delay));
+            this.setDirty();
+        }
+    }
+    public cancelCleanerStartDelays(bodyId?: number) {
+        if (typeof bodyId === 'undefined') this.cancelDelaysByType('cleanerStartDelay');
+        else {
+            let delays = this.filter(x => x.type === 'cleanerStartDelay' && x['bodyId'] === bodyId);
+            for (let i = 0; i < delays.length; i++) {
+                delays[i].cancelDelay();
+            }
+            if (delays.length > 0) this.setDirty();
+        }
+    }
+    public clearCleanerStartDelays(bodyId?: number) {
+        if (typeof bodyId === 'undefined') this.clearDelaysByType('cleanerStartDelay');
+        else {
+            let delays = this.filter(x => x.type === 'cleanerStartDelay' && x['bodyId'] === bodyId);
+            for (let i = 0; i < delays.length; i++) {
+                delays[i].clearDelay();
+            }
+            if (delays.length > 0) this.setDirty();
+        }
+    }
+    public deleteDelay(id: number) {
+        for (let i = this.length - 1; i >= 0; i--) {
+            if (this[i].id === id) {
+                this.splice(i, 1);
+                this.setDirty();
+            }
+        }
+    }
+    public setSolarStartupDelay
+    protected cancelDelaysByType(type: string) {
+        let delays = this.filter(x => x.type === type);
+        for (let i = 0; i < delays.length; i++) {
+            delays[i].cancelDelay();
+        }
+    }
+    protected clearDelaysByType(type: string) {
+        let delays = this.filter(x => x.type === type);
+        for (let i = 0; i < delays.length; i++) {
+            delays[i].clearDelay();
+        }
+        if (delays.length > 0) this.setDirty();
+    }
+    public serialize() {
+        try {
+            let delays = [];
+            for (let i = 0; i < this.length; i++) {
+                delays.push(this[i].serialize());
+            }
+            return delays;
+        } catch (err) { logger.error(`Error serializing delays: ${err.message}`); }
+    }
+    public emitDelayState() {
+        try {
+            // We have to use a custom serializer because the properties of
+            // our delays will create a circular reference due to the timers and state references.
+            webApp.emitToClients('delays', this.serialize());
+        } catch (err) { logger.error(`Error emitting delay states ${err.message}`); }
+    }
+}
+export let delayMgr = new DelayManager();