nodejs-poolcontroller 8.0.0 → 8.0.2

package/controller/Constants.ts

@@ -18,10 +18,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import { EventEmitter } from 'events';
 import { logger } from "../logger/Logger";
 import * as util from 'util';
-export class Heliotrope {
-    constructor() {
-        this.isCalculated = false;
-        this._zenith = 90 + 50 / 60;
+class HeliotropeContext {
+    constructor(longitude: number, latitude: number, zenith: number) {
+        this._zenith = typeof zenith !== 'undefined' ? zenith : 90 + 50 / 60;
+        this._longitude = longitude;
+        this._latitude = latitude;
     }
     private dMath = {
         sin: function (deg) { return Math.sin(deg * (Math.PI / 180)); },
@@ -31,42 +32,14 @@ export class Heliotrope {
         acos: function (x) { return (180 / Math.PI) * Math.acos(x); },
         atan: function (x) { return (180 / Math.PI) * Math.atan(x); }
     }
-    public isCalculated: boolean = false;
-    public isValid: boolean = false;
-    public get date() { return this.dt; }
-    public set date(dt: Date) {
-        if (typeof this.dt === 'undefined' ||
-            this.dt.getFullYear() !== dt.getFullYear() ||
-            this.dt.getMonth() !== dt.getMonth() ||
-            this.dt.getDate() !== dt.getDate()) {
-            this.isCalculated = false;
-            // Always store a copy since we don't want to create instances where the change doesn't get reflected.  This
-            // also could hold onto references that we don't want held for garbage cleanup.
-            this.dt = typeof dt !== 'undefined' && typeof dt.getMonth === 'function' ? new Date(dt.getFullYear(), dt.getMonth(), dt.getDate(),
-                dt.getHours(), dt.getMinutes(), dt.getSeconds(), dt.getMilliseconds()) : undefined;
-        }
-    }
-    public get longitude() { return this._longitude; }
-    public set longitude(lon: number) {
-        if (this._longitude !== lon) this.isCalculated = false;
-        this._longitude = lon;
-    }
-    public get latitude() { return this._latitude; }
-    public set latitude(lat: number) {
-        if (this._latitude !== lat) this.isCalculated = false;
-        this._latitude = lat;
-    }
-    public get zenith() { return this._zenith; }
-    public set zenith(zen: number) {
-        if (this._zenith !== zen) this.isCalculated = false;
-        this._zenith = zen;
-    }
     private dt: Date;
     private _longitude: number;
     private _latitude: number;
     private _zenith: number;
-    private _dtSunrise: Date;
-    private _dtSunset: Date;
+    public get longitude() { return this._longitude; }
+    public get latitude() { return this._latitude; }
+    public get zenith() { return this._zenith; }
+    public get isValid(): boolean { return typeof this._longitude === 'number' && typeof this._latitude === 'number'; }
     private get longitudeHours(): number { return this.longitude / 15.0; }
     private get doy(): number { return Math.ceil((this.dt.getTime() - new Date(this.dt.getFullYear(), 0, 1).getTime()) / 8.64e7); }
     private get sunriseApproxTime(): number { return this.doy + ((6.0 - this.longitudeHours) / 24.0); }
@@ -125,57 +98,175 @@ export class Heliotrope {
         dtLocal.setFullYear(this.dt.getFullYear(), this.dt.getMonth(), this.dt.getDate());
         return dtLocal;
     }
-    public get isNight(): boolean {
-        let times = this.calculatedTimes;
+    public calculate(dt: Date): { dt: Date, sunrise: Date, sunset: Date } {
+        let times = { dt: this.dt = dt, sunrise: undefined, sunset: undefined };
         if (this.isValid) {
-            let time = new Date().getTime();
-            if (time >= times.sunset.getTime() && time < times.sunrise.getTime()) return true;
-        }
-        return false;
-    }
-    public calculate() {
-        if (typeof this.dt !== 'undefined'
-            && typeof this._latitude !== 'undefined'
-            && typeof this._longitude !== 'undefined'
-            && typeof this._zenith !== 'undefined') {
             let sunriseLocal = this.sunriseLocalTime;
             let sunsetLocal = this.sunsetLocalTime;
             if (typeof sunriseLocal !== 'undefined') {
                 sunriseLocal = (sunriseLocal - this.longitudeHours);
                 while (sunriseLocal >= 24) sunriseLocal -= 24;
                 while (sunriseLocal < 0) sunriseLocal += 24;
-                this._dtSunrise = this.toLocalTime(sunriseLocal);
+                times.sunrise = this.toLocalTime(sunriseLocal);
             }
-            else this._dtSunrise = undefined;
+            else times.sunrise = undefined;
             if (typeof sunsetLocal !== 'undefined') {
                 sunsetLocal = (sunsetLocal - this.longitudeHours);
                 while (sunsetLocal >= 24) sunsetLocal -= 24;
                 while (sunsetLocal < 0) sunsetLocal += 24;
-                this._dtSunset = this.toLocalTime(sunsetLocal);
+                times.sunset = this.toLocalTime(sunsetLocal);
             }
-            else this._dtSunset = undefined;
-            logger.verbose(`sunriseLocal:${sunriseLocal} sunsetLocal:${sunsetLocal} Calculating Heliotrope Valid`);
-            this.isValid = typeof this._dtSunrise !== 'undefined' && typeof this._dtSunset !== 'undefined';
-            this.isCalculated = true;
+            else times.sunset = undefined;
         }
-        else {
-            logger.warn(`dt:${this.dt} lat:${this._latitude} lon:${this._longitude} Not enough information to calculate Heliotrope.  See https://github.com/tagyoureit/nodejs-poolController/issues/245`);
-            this.isValid = false;
-            this._dtSunset = undefined;
-            this._dtSunrise = undefined;
+        return times;
+    }
+
+}
+export class Heliotrope {
+    constructor() {
+        this.isCalculated = false;
+        this._zenith = 90 + 50 / 60;
+    }
+    public isCalculated: boolean = false;
+    public get isValid(): boolean { return typeof this.dt !== 'undefined' && typeof this.dt.getMonth === 'function' && typeof this._longitude === 'number' && typeof this._latitude === 'number'; }
+    public get date() { return this.dt; }
+    public set date(dt: Date) {
+        if (typeof this.dt === 'undefined' ||
+            this.dt.getFullYear() !== dt.getFullYear() ||
+            this.dt.getMonth() !== dt.getMonth() ||
+            this.dt.getDate() !== dt.getDate()) {
             this.isCalculated = false;
+            // Always store a copy since we don't want to create instances where the change doesn't get reflected.  This
+            // also could hold onto references that we don't want held for garbage cleanup.
+            this.dt = typeof dt !== 'undefined' && typeof dt.getMonth === 'function' ? new Date(dt.getFullYear(), dt.getMonth(), dt.getDate(),
+                dt.getHours(), dt.getMinutes(), dt.getSeconds(), dt.getMilliseconds()) : undefined;
         }
-
+    }
+    public get longitude() { return this._longitude; }
+    public set longitude(lon: number) {
+        if (this._longitude !== lon) {
+            this.isCalculated = false;
+        }
+        this._longitude = lon;
+    }
+    public get latitude() { return this._latitude; }
+    public set latitude(lat: number) {
+        if (this._latitude !== lat) {
+            this.isCalculated = false;
+        }
+        this._latitude = lat;
+    }
+    public get zenith() { return this._zenith; }
+    public set zenith(zen: number) {
+        if (this._zenith !== zen) this.isCalculated = false;
+        this._zenith = zen;
+    }
+    private dt: Date;
+    private _longitude: number;
+    private _latitude: number;
+    private _zenith: number;
+    private _dtSunrise: Date;
+    private _dtSunset: Date;
+    private _dtNextSunrise: Date;
+    private _dtNextSunset: Date;
+    private _dtPrevSunrise: Date;
+    private _dtPrevSunset: Date;
+    public get isNight(): boolean {
+        let times = this.calculatedTimes;
+        if (this.isValid) {
+            let time = new Date().getTime();
+            if (time >= times.sunset.getTime()) // We are after sunset.
+                return time < times.nextSunrise.getTime(); // It is night so long as we are less than the next sunrise.  
+                                                           // Normally this would be updated on 1 min after midnight so it should never be true.
+            else
+                return time < times.sunrise.getTime();     // If the Heliotrope is updated then we need to declare pre-sunrise to be night.
+                                                           // This is the normal condition where it would be night since at 1 min after midnight the sunrise/sunset
+                                                           // will get updated.  So it will be before sunrise that it will still be night.
+        }
+        return false;
+    }
+    public calculate(dt: Date): { isValid: boolean, dt: Date, sunrise: Date, sunset: Date, nextSunrise: Date, nextSunset: Date, prevSunrise: Date, prevSunset: Date } {
+        let ctx = new HeliotropeContext(this.longitude, this.latitude, this.zenith);
+        let ret = { isValid: ctx.isValid, dt: dt, sunrise: undefined, sunset: undefined, nextSunrise: undefined, nextSunset: undefined, prevSunrise: undefined, prevSunset: undefined };
+        if (ctx.isValid) {
+            let tToday = ctx.calculate(dt);
+            let tTom = ctx.calculate(new Date(dt.getTime() + 86400000));
+            let tYesterday = ctx.calculate(new Date(dt.getTime() - 86400000));
+            ret.sunrise = tToday.sunrise;
+            ret.sunset = tToday.sunset;
+            ret.nextSunrise = tTom.sunrise;
+            ret.nextSunset = tTom.sunset;
+            ret.prevSunrise = tYesterday.sunrise;
+            ret.prevSunset = tYesterday.sunset;
+        }
+        return ret;
+    }
+    private calcInternal() {
+        if (this.isValid) {
+            let times = this.calculate(this.dt);
+            this._dtSunrise = times.sunrise;
+            this._dtSunset = times.sunset;
+            this._dtNextSunrise = times.nextSunrise;
+            this._dtNextSunset = times.nextSunset;
+            this._dtPrevSunrise = times.prevSunrise;
+            this._dtPrevSunset = times.prevSunset;
+            this.isCalculated = true;
+            logger.verbose(`Calculated Heliotrope: sunrise:${Timestamp.toISOLocal(this._dtSunrise)} sunset:${Timestamp.toISOLocal(this._dtSunset)}`);
+        }
+        else 
+            logger.warn(`dt:${this.dt} lat:${this._latitude} lon:${this._longitude} Not enough information to calculate Heliotrope.  See https://github.com/tagyoureit/nodejs-poolController/issues/245`);
     }
     public get sunrise(): Date {
-        if (!this.isCalculated) this.calculate();
+        if (!this.isCalculated) this.calcInternal();
         return this._dtSunrise;
     }
     public get sunset(): Date {
-        if (!this.isCalculated) this.calculate();
+        if (!this.isCalculated) this.calcInternal();
         return this._dtSunset;
     }
-    public get calculatedTimes(): any { return { sunrise: this.sunrise, sunset: this.sunset, isValid: this.isValid }; }
+    public get nextSunrise(): Date {
+        if (!this.isCalculated) this.calcInternal();
+        return this._dtNextSunrise;
+    }
+    public get nextSunset(): Date {
+        if (!this.isCalculated) this.calcInternal();
+        return this._dtNextSunset;
+    }
+    public get prevSunrise(): Date {
+        if (!this.isCalculated) this.calcInternal();
+        return this._dtPrevSunrise;
+    }
+    public get prevSunset(): Date {
+        if (!this.isCalculated) this.calcInternal();
+        return this._dtPrevSunset;
+    }
+    public get calculatedTimes(): { sunrise?: Date, sunset?: Date, nextSunrise?: Date, nextSunset?: Date, prevSunrise?: Date, prevSunset: Date, isValid: boolean } { return { sunrise: this.sunrise, sunset: this.sunset, nextSunrise: this.nextSunrise, nextSunset: this.nextSunset, prevSunrise: this.prevSunrise, prevSunset: this.prevSunset, isValid: this.isValid }; }
+    public calcAdjustedTimes(dt: Date, hours = 0, min = 0): { sunrise?: Date, sunset?: Date, nextSunrise?: Date, nextSunset?: Date, prevSunrise?: Date, prevSunset: Date, isValid: boolean } {
+        if (this.dt.getFullYear() === dt.getFullYear() && this.dt.getMonth() === dt.getMonth() && this.dt.getDate() === dt.getDate()) return this.getAdjustedTimes(hours, min);
+        let ms = (hours * 3600000) + (min * 60000);
+        let times = this.calculate(dt);
+        return {
+            sunrise: new Date(times.sunrise.getTime() + ms),
+            sunset: new Date(times.sunset.getTime() + ms),
+            nextSunrise: new Date(times.nextSunrise.getTime() + ms),
+            nextSunset: new Date(times.nextSunset.getTime() + ms),
+            prevSunrise: new Date(times.prevSunrise.getTime() + ms),
+            prevSunset: new Date(times.prevSunset.getTime() + ms),
+            isValid: this.isValid
+        } 
+    }
+    public getAdjustedTimes(hours = 0, min = 0): { sunrise?: Date, sunset?: Date, nextSunrise?: Date, nextSunset?: Date, prevSunrise?: Date, prevSunset: Date, isValid: boolean } {
+        let ms = (hours * 3600000) + (min * 60000);
+        return {
+            sunrise: new Date(this.sunrise.getTime() + ms),
+            sunset: new Date(this.sunset.getTime() + ms),
+            nextSunrise: new Date(this.nextSunrise.getTime() + ms),
+            nextSunset: new Date(this.nextSunset.getTime() + ms),
+            prevSunrise: new Date(this.prevSunrise.getTime() + ms),
+            prevSunset: new Date(this.prevSunset.getTime() + ms),
+            isValid: this.isValid
+        } 
+    }
 }
 export class Timestamp {
     private static dateTextISO = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*))(?:Z|(\+|-)([\d|:]*))?$/;
@@ -185,11 +276,15 @@ export class Timestamp {
     constructor(dt?: Date | string) {
         if (typeof dt === 'string') this._dt = new Date(dt);
         else this._dt = dt || new Date();
+        if (!this.isValid) this._dt = new Date();
         this.emitter = new EventEmitter();
     }
     private _isUpdating: boolean = false;
     public static get now(): Timestamp { return new Timestamp(); }
-    public toDate() { return this._dt; }
+    public toDate(): Date { return this._dt; }
+    public get isValid() {
+        return this._dt instanceof Date && !isNaN(this._dt.getTime());
+    }
     public set isUpdating(val: boolean) { this._isUpdating = val; }
     public get isUpdating(): boolean { return this._isUpdating; }
     public get hours(): number { return this._dt.getHours(); }
@@ -221,7 +316,8 @@ export class Timestamp {
     public set fullYear(val: number) { this._dt.setFullYear(val); }
     public get year(): number { return this._dt.getFullYear(); }
     public set year(val: number) {
-        let y = val < 100 ? (Math.floor(this._dt.getFullYear() / 100) * 100) + val : val;
+        let dt = new Date();
+        let y = val < 100 ? (Math.floor(dt.getFullYear() / 100) * 100) + val : val;
         if (y !== this.year) {
             this._dt.setFullYear(y);
             this.emitter.emit('change');
@@ -244,7 +340,8 @@ export class Timestamp {
     public getDay(): number { return this._dt.getDay(); }
     public getTime() { return this._dt.getTime(); }
     public format(): string { return Timestamp.toISOLocal(this._dt); }
-    public static toISOLocal(dt): string {
+    public static toISOLocal(dt: Date): string {
+        if (typeof dt === 'undefined' || typeof dt.getTime !== 'function' || isNaN(dt.getTime())) return '';
         let tzo = dt.getTimezoneOffset();
         var pad = function (n) {
             var t = Math.floor(Math.abs(n));

package/controller/Equipment.ts

@@ -75,10 +75,11 @@ interface IPoolSystem {
 export class PoolSystem implements IPoolSystem {
     public _hasChanged: boolean = false;
     public isReady: boolean = false;
+    private _startOCPTimer: NodeJS.Timeout;
     constructor() {
         this.cfgPath = path.posix.join(process.cwd(), '/data/poolConfig.json');
     }
-    public getAvailableControllerTypes(include:string[] = ['easytouch', 'intellitouch', 'intellicenter', 'nixie']) {
+    public getAvailableControllerTypes(include:string[] = ['easytouch', 'intellitouch', 'intellicenter', 'suntouch', 'nixie']) {
         let arr = [];
         if (include.indexOf('easytouch')>=0) arr.push({
             type: 'easytouch', name: 'EasyTouch',
@@ -124,7 +125,14 @@ export class PoolSystem implements IPoolSystem {
                 { val: 7, name: 'i10D', part: '523029Z', desc: 'IntelliCenter i10D', bodies: 2, valves: 2, circuits: 11, shared: false, dual: true, chlorinators: 2, chemControllers: 2 },
             ]
         });
-        if (include.indexOf('nixie')>=0) arr.push({
+        if (include.indexOf('suntouch') >= 0) arr.push({
+            type: 'suntouch', name: 'SunTouch',
+            models: [
+                { val: 41, name: 'stshared', part: '520820', desc: 'Pool and Spa controller', bodies: 2, valves: 4, circuits: 5, single: false, shared: true, dual: false, features: 4, chlorinators: 1, chemControllers: 1 },
+                { val: 40, name: 'stsingle', part: '520819', desc: 'Pool or Spa controller', bodies: 2, valves: 4, circuits: 5, single: true, shared: true, dual: false, features: 4, chlorinators: 1, chemControllers: 1 }
+            ]
+        })
+        if (include.indexOf('nixie') >= 0) arr.push({
             type: 'nixie', name: 'Nixie', canChange: true,
             models: [
                 { val: 0, name: 'nxp', part: 'NXP', desc: 'Nixie Single Body', bodies: 1, shared: false, dual: false },
@@ -143,7 +151,9 @@ export class PoolSystem implements IPoolSystem {
         if (this.controllerType === 'unknown' || typeof this.controllerType === 'undefined') {
             // Delay for 7.5 seconds to give any OCPs a chance to start emitting messages.
             logger.info(`Listening for any installed OCPs`);
-            setTimeout(() => { self.initNixieController(); }, 7500);
+            if (this._startOCPTimer) clearTimeout(this._startOCPTimer);
+            this._startOCPTimer = null;
+            this._startOCPTimer = setTimeout(() => { self.initNixieController(); }, 7500);
         }
         else
             this.initNixieController();
@@ -217,15 +227,40 @@ export class PoolSystem implements IPoolSystem {
     }
 
     public resetSystem() {
-        conn.pauseAll();
-        this.resetData();
-        state.resetData();
-        this.data.controllerType === 'unknown';
-        state.equipment.controllerType = ControllerType.Unknown;
-        this.controllerType = ControllerType.Unknown;
-        state.status = 0;
-        this.board = BoardFactory.fromControllerType(ControllerType.Unknown, this);
-        setTimeout(function () { state.status = 0; conn.resumeAll(); }, 0);
+        logger.info(`Resetting System to initial defaults`);
+        (async () => {
+            await this.board.closeAsync();
+            logger.info(`Closed ${this.controllerType} board`);
+            this.controllerType = ControllerType.Unknown;
+        })();
+
+        /*
+        let self = this;
+        if (this.controllerType === ControllerType.Nixie) {
+            (async () => {
+                await this.board.closeAsync();
+                this.board = BoardFactory.fromControllerType(ControllerType.Nixie, this);
+                let board = sys.board as NixieBoard;
+                await board.initNixieBoard();
+            })();
+            state.status = 0;
+
+            logger.info(`Listening for any installed OCPs`);
+            setTimeout(() => { self.initNixieController(); }, 7500);
+
+        }
+        else {
+            conn.pauseAll();
+            this.resetData();
+            state.resetData();
+            this.data.controllerType === 'unknown';
+            state.equipment.controllerType = ControllerType.Unknown;
+            this.controllerType = ControllerType.Unknown;
+            state.status = 0;
+            this.board = BoardFactory.fromControllerType(ControllerType.Unknown, this);
+            setTimeout(function () { state.status = 0; conn.resumeAll(); }, 0);
+        }
+        */
     }
     public get anslq25ControllerType(): ControllerType { return this.data.anslq25.controllerType as ControllerType; }
     public set anslq25ControllerType(val: ControllerType) {
@@ -250,11 +285,17 @@ export class PoolSystem implements IPoolSystem {
             // Only go in here if there is a change to the controller type.
             this.resetData(); // Clear the configuration data.
             state.resetData(); // Clear the state data.
+            state.status = 0; // We are performing a re-initialize.
             this.data.controllerType = val;
             EquipmentStateMessage.initDefaults();
+           
             // We are actually changing the config so lets clear out all the data.
             this.board = BoardFactory.fromControllerType(val, this);
-            if (this.data.controllerType === ControllerType.Unknown) setTimeout(() => { self.initNixieController(); }, 7500);
+            if (this.data.controllerType === ControllerType.Unknown) {
+                if (this._startOCPTimer) clearTimeout(this._startOCPTimer);
+                this._startOCPTimer = null;
+                this._startOCPTimer = setTimeout(() => { self.initNixieController(); }, 7500);
+            }
         }
     }
     public resetData() {
@@ -1144,6 +1185,8 @@ export class Schedule extends EqItem {
         if (typeof this.data.startTimeType === 'undefined') this.data.startTimeType = 0;
         if (typeof this.data.endTimeType === 'undefined') this.data.endTimeType = 0;
         if (typeof this.data.display === 'undefined') this.data.display = 0;
+        if (typeof this.data.startTimeOffset === 'undefined') this.data.startTimeOffset = 0;
+        if (typeof this.data.endTimeOffset === 'undefined') this.data.endTimeOffset = 0;
     }
 
     // todo: investigate schedules having startDate and _startDate
@@ -1155,6 +1198,11 @@ export class Schedule extends EqItem {
     public set startTime(val: number) { this.setDataVal('startTime', val); }
     public get endTime(): number { return this.data.endTime; }
     public set endTime(val: number) { this.setDataVal('endTime', val); }
+    public get startTimeOffset(): number { return this.data.startTimeOffset || 0; }
+    public set startTimeOffset(val: number) { this.setDataVal('startTimeOffset', val); }
+    public get endTimeOffset(): number { return this.data.endTimeOffset || 0; }
+    public set endTimeOffset(val: number) { this.setDataVal('endTimeOffset', val); }
+
     public get scheduleDays(): number { return this.data.scheduleDays; }
     public set scheduleDays(val: number) { this.setDataVal('scheduleDays', val); }
     public get circuit(): number { return this.data.circuit; }
@@ -1177,7 +1225,10 @@ export class Schedule extends EqItem {
     public set startDay(val: number) { if (typeof this._startDate === 'undefined') this._startDate = new Date(); this._startDate.setDate(val); this._saveStartDate(); }
     public get startYear(): number { if (typeof this._startDate === 'undefined') this._startDate = new Date(); return this._startDate.getFullYear(); }
     public set startYear(val: number) { if (typeof this._startDate === 'undefined') this._startDate = new Date(); this._startDate.setFullYear(val < 100 ? val + 2000 : val); this._saveStartDate(); }
-    public get startDate(): Date { return typeof this._startDate === 'undefined' ? this._startDate = new Date() : this._startDate; }
+    public get startDate(): Date {
+        this._startDate = typeof this._startDate === 'undefined' ? new Date(this.data.startDate) : this._startDate;
+        return typeof this._startDate === 'undefined' || isNaN(this._startDate.getTime()) ? new Date() : this._startDate;
+    }
     public set startDate(val: Date) { this._startDate = val; }
     public get scheduleType(): number | any { return this.data.scheduleType; }
     public set scheduleType(val: number | any) { this.setDataVal('scheduleType', sys.board.valueMaps.scheduleTypes.encode(val)); }
@@ -1390,14 +1441,22 @@ export class PumpCollection extends EqItemCollection<Pump> {
     constructor(data: any, name?: string) { super(data, name || "pumps"); }
     public createItem(data: any): Pump { return new Pump(data); }
     public getDualSpeed(add?: boolean): Pump {
-        return this.getItemById(10, add, { id: 10, type: 65, name: 'Two Speed' });
+        let ds = sys.board.valueMaps.pumpTypes.getValue('ds');
+        let pump = this.find(x => x.type === ds);
+        return typeof pump !== 'undefined' ? pump : this.getItemById(10, add, { id: 10, type: ds, name: 'Two Speed', master: 0 });
     }
-    public getPumpByAddress(address: number, add?: boolean, data?: any) {
+    public removePumpByAddress(address: number) {
         let pmp = this.find(elem => elem.address === address);
-        if (typeof pmp !== 'undefined') return this.createItem(pmp);
+        if (typeof pmp !== 'undefined') return this.removeItemById(pmp.id);
+        return pmp;
+    }
+    public getPumpByAddress(address: number, add?: boolean, data?: any) : Pump {
+        let pmp = this.find(elem => elem.address === address);
+        if (typeof pmp !== 'undefined') return pmp;
         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 });
+        return this.createItem(data || { id: this.getNextEquipmentId(), address: address });
     }
+    public getNextEquipmentId(range?: EquipmentIdRange, exclude?: number[]): number { return super.getNextEquipmentId(typeof range === 'undefined' ? sys.board.equipmentIds.pumps : range, exclude); }
 }
 export class Pump extends EqItem {
     public dataName = 'pumpConfig';
@@ -2439,6 +2498,7 @@ export class ChemicalPh extends Chemical {
     public getExtended() {
         let chem = super.getExtended();
         chem.probe = this.probe.getExtended();
+        chem.tank = this.tank.getExtended();
         chem.phSupply = sys.board.valueMaps.phSupplyTypes.transform(this.phSupply);
         chem.doserType = sys.board.valueMaps.phDoserTypes.transform(this.doserType);
         return chem;
@@ -2469,6 +2529,7 @@ export class ChemicalORP extends Chemical {
     public getExtended() {
         let chem = super.getExtended();
         chem.probe = this.probe.getExtended();
+        chem.tank = this.tank.getExtended();
         chem.doserType = sys.board.valueMaps.orpDoserTypes.transform(this.doserType);
         return chem;
     }

package/controller/Lockouts.ts

@@ -135,6 +135,21 @@ export class ManualPriorityDelay extends EquipmentDelay {
         logger.info(`Manual Operation Priority cancelled for ${this.circuitState.name}`);
         this._delayTimer = undefined;
         this.circuitState.manualPriorityActive = false;
+        // Rip through all the schedules and clear the manual priority.
+        let sscheds = state.schedules.getActiveSchedules();
+        let circIds = [];
+        for (let i = 0; i < sscheds.length; i++) {
+            let ssched = sscheds[i];
+            ssched.manualPriorityActive = false;
+            if (!circIds.includes(ssched.circuit)) circIds.push(ssched.circuit);
+        }
+        for (let i = 0; i < circIds.length; i++) {
+            let circ = sys.circuits.getInterfaceById(circIds[i]);
+            if (!circ.isActive) continue;
+            let cstate = state.circuits.getInterfaceById(circ.id);
+            sys.board.circuits.setEndTime(circ, cstate, cstate.isOn, true);
+        }
+
         delayMgr.deleteDelay(this.id);
     }
     public clearDelay() {