nodejs-poolcontroller 7.2.0 → 7.5.1

package/controller/nixie/chemistry/Chlorinator.ts

@@ -9,6 +9,7 @@ import { setTimeout, clearTimeout } from 'timers';
 import { webApp, InterfaceServerResponse } from "../../../web/Server";
 import { Outbound, Protocol, Response } from '../../comms/messages/Messages';
 import { conn } from '../../comms/Comms';
+import { ncp } from '../Nixie';
 
 export class NixieChlorinatorCollection extends NixieEquipmentCollection<NixieChlorinator> {
     public async deleteChlorinatorAsync(id: number) {
@@ -18,6 +19,7 @@ export class NixieChlorinatorCollection extends NixieEquipmentCollection<NixieCh
             for (let i = this.length - 1; i >= 0; i--) {
                 let c = this[i];
                 if (c.id === id) {
+                    await ncp.chemControllers.deleteChlorAsync(c as NixieChlorinator);
                     await c.closeAsync();
                     this.splice(i, 1);
                 }
@@ -45,14 +47,15 @@ export class NixieChlorinatorCollection extends NixieEquipmentCollection<NixieCh
     }
     public async initAsync(chlorinators: ChlorinatorCollection) {
         try {
-            this.length = 0;
             for (let i = 0; i < chlorinators.length; i++) {
                 let cc = chlorinators.getItemByIndex(i);
                 if (cc.master === 1) {
-                    logger.info(`Initializing Nixie chlorinator ${cc.name}`);
-                    let ncc = new NixieChlorinator(this.controlPanel, cc);
-                    this.push(ncc);
-                    await ncc.initAsync();
+                    if (typeof this.find(elem => elem.id === cc.id) === 'undefined') {
+                        logger.info(`Initializing Nixie chlorinator ${cc.name}`);
+                        let ncc = new NixieChlorinator(this.controlPanel, cc);
+                        this.push(ncc);
+                        await ncc.initAsync();
+                    }
                 }
             }
         }
@@ -74,7 +77,6 @@ export class NixieChlorinator extends NixieEquipment {
     private _pollTimer: NodeJS.Timeout = null;
     private superChlorinating: boolean = false;
     private superChlorStart: number = 0;
-    private chlorinating: boolean = false;
     public chlor: Chlorinator;
     public bodyOnTime: number;
     protected _suspendPolling: number = 0;
@@ -96,12 +98,14 @@ export class NixieChlorinator extends NixieEquipment {
             let spaSetpoint = typeof data.spaSetpoint !== 'undefined' ? parseInt(data.spaSetpoint, 10) : chlor.spaSetpoint;
             let body = sys.board.bodies.mapBodyAssociation(typeof data.body === 'undefined' ? chlor.body : data.body);
             let superChlor = typeof data.superChlor !== 'undefined' ? utils.makeBool(data.superChlor) : chlor.superChlor;
-            let chlorType = typeof data.type !== 'undefined' ? sys.board.valueMaps.chlorinatorType.encode(data.type) : chlor.type;
+            let chlorType = typeof data.type !== 'undefined' ? sys.board.valueMaps.chlorinatorType.encode(data.type) : chlor.type || 0;
             let superChlorHours = typeof data.superChlorHours !== 'undefined' ? parseInt(data.superChlorHours, 10) : chlor.superChlorHours;
+            let disabled = typeof data.disabled !== 'undefined' ? utils.makeBool(data.disabled) : chlor.disabled;
+            let isDosing = typeof data.isDosing !== 'undefined' ? utils.makeBool(data.isDosing) : chlor.isDosing;
+            let model = typeof data.model !== 'undefined' ? data.model : chlor.model || 0;
             if (typeof body === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Invalid body assignment`, 'chlorinator', data.body || chlor.body));
             if (isNaN(poolSetpoint)) poolSetpoint = 0;
             if (isNaN(spaSetpoint)) spaSetpoint = 0;
-            if (isNaN(chlorType)) chlorType = sys.board.valueMaps.chlorinatorType.getValue('intellichlor');
             chlor.ignoreSaltReading = (typeof data.ignoreSaltReading !== 'undefined') ? utils.makeBool(data.ignoreSaltReading) : utils.makeBool(chlor.ignoreSaltReading);
             // Do a final validation pass so we dont send this off in a mess.
             let schlor = state.chlorinators.getItemById(chlor.id, true);
@@ -110,8 +114,10 @@ export class NixieChlorinator extends NixieEquipment {
             schlor.superChlor = chlor.superChlor = superChlor;
             schlor.superChlorHours = chlor.superChlorHours = superChlorHours;
             schlor.type = chlor.type = chlorType;
-            chlor.body = body;
-            schlor.body = chlor.body;
+            chlor.model = model;
+            schlor.body = chlor.body = body.val;
+            chlor.disabled = disabled;
+            chlor.isDosing = isDosing;
             schlor.name = chlor.name = data.name || chlor.name || `Chlorinator ${chlor.id}`;
             schlor.isActive = chlor.isActive = true;
         }
@@ -147,6 +153,7 @@ export class NixieChlorinator extends NixieEquipment {
         return isOn;
     }
     public async pollEquipment() {
+        let self = this;
         try {
             if (this._pollTimer) {
                 clearTimeout(this._pollTimer);
@@ -171,7 +178,7 @@ export class NixieChlorinator extends NixieEquipment {
             // Comms failure will be handeled by the message processor.
             logger.error(`Chlorinator ${this.chlor.name} comms failure: ${err.message}`);
         }
-        finally { if(!this.closing) this._pollTimer = setTimeout(async () => { await this.pollEquipment(); }, this.pollingInterval); }
+        finally { if(!this.closing) this._pollTimer = setTimeout(() => {self.pollEquipment();}, this.pollingInterval); }
     }
     public async takeControl(): Promise<boolean> {
         try {
@@ -223,7 +230,7 @@ export class NixieChlorinator extends NixieEquipment {
             let setpoint = 0;
             if (typeof body !== 'undefined') {
                 setpoint = (body.id === 1) ? this.chlor.poolSetpoint : this.chlor.spaSetpoint;
-                if (this.chlor.superChlor === true) setpoint = 100;
+                if (this.chlor.superChlor === true || this.chlor.isDosing) setpoint = 100;
                 if (this.chlor.disabled === true) setpoint = 0; // Our target should be 0 because we have other things going on.  For instance,
                 // we may be dosing acid which will cause the disabled flag to be true.
             }
@@ -244,7 +251,6 @@ export class NixieChlorinator extends NixieEquipment {
                     onAbort: () => {},
                     onComplete: (err) => {
                         if (err) {
-                            this.chlorinating = false;
                             cstate.currentOutput = 0;
                             cstate.status = 128;
                             resolve(false);
@@ -253,7 +259,6 @@ export class NixieChlorinator extends NixieEquipment {
                             // The action:17 message originated from us so we will not see it in the
                             // ChlorinatorStateMessage module.
                             cstate.currentOutput = setpoint;
-                            this.chlorinating = true;
                             if (!this.superChlorinating && cstate.superChlor) {
                                 cstate.superChlorRemaining = cstate.superChlorHours * 3600;
                                 this.superChlorStart = Math.floor(new Date().getTime() / 1000) * 1000;
@@ -267,6 +272,8 @@ export class NixieChlorinator extends NixieEquipment {
                         }
                     }
                 });
+                // #338
+                if (setpoint === 16) { out.appendPayloadByte(0); }
                 conn.queueSendMessage(out);
             });
 
@@ -299,6 +306,7 @@ export class NixieChlorinator extends NixieEquipment {
                     conn.queueSendMessage(out);
                 });
             }
+            else return Promise.resolve(false);
         } catch (err) { logger.error(`Communication error with Chlorinator ${this.chlor.name} : ${err.message}`); return Promise.reject(err);}
 
     }

package/controller/nixie/circuits/Circuit.ts

@@ -56,15 +56,22 @@ export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircui
         }
         catch (err) { logger.error(`setCircuitAsync: ${err.message}`); return Promise.reject(err); }
     }
+    public async checkCircuitEggTimerExpirationAsync(cstate: ICircuitState) {
+     try {
+        let c: NixieCircuit = this.find(elem => elem.id === cstate.id) as NixieCircuit;
+        await c.checkCircuitEggTimerExpirationAsync(cstate);
+    } catch (err) { logger.error(`NCP: Error syncing circuit states: ${err}`); }
+    }
     public async initAsync(circuits: CircuitCollection) {
         try {
-            this.length = 0;
             for (let i = 0; i < circuits.length; i++) {
                 let circuit = circuits.getItemByIndex(i);
                 if (circuit.master === 1) {
-                    logger.info(`Initializing Nixie circuit ${circuit.name}`);
-                    let ncircuit = new NixieCircuit(this.controlPanel, circuit);
-                    this.push(ncircuit);
+                    if (typeof this.find(elem => elem.id === circuit.id) === 'undefined') {
+                        logger.info(`Initializing Nixie circuit ${circuit.name}`);
+                        let ncircuit = new NixieCircuit(this.controlPanel, circuit);
+                        this.push(ncircuit);
+                    }
                 }
             }
         }
@@ -93,13 +100,14 @@ export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircui
         } catch (err) { logger.error(`initCircuitAsync: ${err.message}`); return Promise.reject(err); }
     }
     public async pollCircuitsAsync() {
+        let self = this;
         try {
             if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
             this._pollTimer = null;
             let success = false;
 
         } catch (err) { logger.error(`Error polling circuits: ${err.message}`); return Promise.reject(err); }
-        finally { this._pollTimer = setTimeout(async () => await this.pollCircuitsAsync(), this.pollingInterval || 10000); }
+        finally { this._pollTimer = setTimeout(async () => await self.pollCircuitsAsync(), this.pollingInterval || 10000); }
     }
 }
 export class NixieCircuit extends NixieEquipment {
@@ -124,12 +132,26 @@ export class NixieCircuit extends NixieEquipment {
             this._sequencing = true;
             let arr = [];
             let t = typeof timeout === 'undefined' ? 100 : timeout;
-            arr.push({ isOn: true, timeout: t }); // This may not be needed but we always need to start from on.
+            arr.push({ isOn: false, timeout: t }); // This may not be needed but we always need to start from off.
             //[{ isOn: true, timeout: 1000 }, { isOn: false, timeout: 1000 }]
             for (let i = 0; i < count; i++) {
-                arr.push({ isOn: false, timeout: t });
                 arr.push({ isOn: true, timeout: t });
+                if(i < count - 1) arr.push({ isOn: false, timeout: t });
             }
+            // The documentation for IntelliBrite is incorrect.  The sequence below will give us Party mode.
+            // Party mode:2
+            // Start: Off
+            // On
+            // Off
+            // On
+            // According to the docs this is the sequence they lay out.
+            // Party mode:2
+            // Start: On
+            // Off
+            // On
+            // Off
+            // On
+
             let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, arr, 60000);
             return res;
         } catch (err) { logger.error(`Nixie: Error sending circuit sequence ${this.id}: ${count}`); }
@@ -147,12 +169,14 @@ export class NixieCircuit extends NixieEquipment {
                 // Check to see if we should be on by poking the schedules.
             }
             if (utils.isNullOrEmpty(this.circuit.connectionId) || utils.isNullOrEmpty(this.circuit.deviceBinding)) {
+                sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(cstate.id), cstate, val);
                 cstate.isOn = val;
                 return new InterfaceServerResponse(200, 'Success');
             }
             if (this._sequencing) return new InterfaceServerResponse(200, 'Success');
             let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, { isOn: val, latch: val ? 10000 : undefined });
             if (res.status.code === 200) {
+                sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(cstate.id), cstate, val);
                 cstate.isOn = val;
                 // Set this up so we can process our egg timer.
                 if (!cstate.isOn && val) { this.timeOn = new Timestamp(); }
@@ -161,6 +185,17 @@ export class NixieCircuit extends NixieEquipment {
             return res;
         } catch (err) { logger.error(`Nixie: Error setting circuit state ${cstate.id}-${cstate.name} to ${val}`); }
     }
+    public async checkCircuitEggTimerExpirationAsync(cstate: ICircuitState) {
+        // if circuit end time is past current time, either the schedule is finished
+        // (this should already be turned off) or the egg timer has expired
+        try {
+            if (!cstate.isActive || !cstate.isOn) return;
+            if (cstate.endTime.toDate() < new Timestamp().toDate()) {
+                await sys.board.circuits.setCircuitStateAsync(cstate.id, false);
+                cstate.emitEquipmentChange();
+            }
+        } catch (err) { logger.error(`Error syncing circuit: ${err}`); }
+    }
     private async checkHardwareStatusAsync(connectionId: string, deviceBinding: string) {
         try {
             let dev = await NixieEquipment.getDeviceService(connectionId, `/status/device/${deviceBinding}`);

package/controller/nixie/heaters/Heater.ts

@@ -1,4 +1,4 @@
-import { EquipmentNotFoundError, InvalidEquipmentDataError, InvalidEquipmentIdError, ParameterOutOfRangeError } from '../../Errors';
+import { EquipmentNotFoundError, InvalidEquipmentDataError, InvalidEquipmentIdError, InvalidOperationError, ParameterOutOfRangeError } from '../../Errors';
 import { utils, Timestamp } from '../../Constants';
 import { logger } from '../../../logger/Logger';
 
@@ -8,8 +8,10 @@ import { HeaterState, state, } from "../../State";
 import { setTimeout, clearTimeout } from 'timers';
 import { NixieControlPanel } from '../Nixie';
 import { webApp, InterfaceServerResponse } from "../../../web/Server";
+import { conn } from '../../../controller/comms/Comms';
+import { Outbound, Protocol, Response } from '../../../controller/comms/messages/Messages';
 
-export class NixieHeaterCollection extends NixieEquipmentCollection<NixieHeater> {
+export class NixieHeaterCollection extends NixieEquipmentCollection<NixieHeaterBase> {
     public async deleteHeaterAsync(id: number) {
         try {
             for (let i = this.length - 1; i >= 0; i--) {
@@ -21,24 +23,23 @@ export class NixieHeaterCollection extends NixieEquipmentCollection<NixieHeater>
             }
         } catch (err) { return Promise.reject(`Nixie Control Panel deleteHeaterAsync ${err.message}`); }
     }
-
-    public async setHeaterStateAsync(hstate: HeaterState, val: boolean) {
+    public async setHeaterStateAsync(hstate: HeaterState, val: boolean, isCooling: boolean) {
         try {
-            let h: NixieHeater = this.find(elem => elem.id === hstate.id) as NixieHeater;
+            let h: NixieHeaterBase = this.find(elem => elem.id === hstate.id) as NixieHeaterBase;
             if (typeof h === 'undefined') {
                 return Promise.reject(new Error(`NCP: Heater ${hstate.id}-${hstate.name} could not be found to set the state to ${val}.`));
             }
-            await h.setHeaterStateAsync(hstate, val);
+            await h.setHeaterStateAsync(hstate, val, isCooling);
         }
         catch (err) { return logger.error(`NCP: setHeaterStateAsync ${hstate.id}-${hstate.name}: ${err.message}`); }
     }
     public async setHeaterAsync(heater: Heater, data: any) {
         // By the time we get here we know that we are in control and this is a Nixie heater.
         try {
-            let h: NixieHeater = this.find(elem => elem.id === heater.id) as NixieHeater;
+            let h: NixieHeaterBase = this.find(elem => elem.id === heater.id) as NixieHeaterBase;
             if (typeof h === 'undefined') {
                 heater.master = 1;
-                h = new NixieHeater(this.controlPanel, heater);
+                h = NixieHeaterBase.create(this.controlPanel, heater);
                 this.push(h);
                 await h.setHeaterAsync(data);
                 logger.info(`A Heater was not found for id #${heater.id} creating Heater`);
@@ -51,13 +52,14 @@ export class NixieHeaterCollection extends NixieEquipmentCollection<NixieHeater>
     }
     public async initAsync(heaters: HeaterCollection) {
         try {
-            this.length = 0;
             for (let i = 0; i < heaters.length; i++) {
                 let heater = heaters.getItemByIndex(i);
                 if (heater.master === 1) {
-                    logger.info(`Initializing Heater ${heater.name}`);
-                    let nHeater = new NixieHeater(this.controlPanel, heater);
-                    this.push(nHeater);
+                    if (typeof this.find(elem => elem.id === heater.id) === 'undefined') {
+                        logger.info(`Initializing Heater ${heater.name}`);
+                        let nHeater = NixieHeaterBase.create(this.controlPanel, heater);
+                        this.push(nHeater);
+                    }
                 }
             }
         }
@@ -73,66 +75,190 @@ export class NixieHeaterCollection extends NixieEquipmentCollection<NixieHeater>
             }
         } catch (err) { } // Don't bail if we have an errror.
     }
-    public async initHeaterAsync(heater: Heater): Promise<NixieHeater> {
+    public async initHeaterAsync(heater: Heater): Promise<NixieHeaterBase> {
         try {
-            let c: NixieHeater = this.find(elem => elem.id === heater.id) as NixieHeater;
+            let c: NixieHeaterBase = this.find(elem => elem.id === heater.id) as NixieHeaterBase;
             if (typeof c === 'undefined') {
-                c = new NixieHeater(this.controlPanel, heater);
+                c = NixieHeaterBase.create(this.controlPanel, heater);
                 this.push(c);
             }
             return c;
         } catch (err) { logger.error(`initHeaterAsync: ${err.message}`); return Promise.reject(err); }
     }
-
 }
-export class NixieHeater extends NixieEquipment {
+export class NixieHeaterBase extends NixieEquipment {
+    protected _suspendPolling: number = 0;
     public pollingInterval: number = 10000;
-    private _pollTimer: NodeJS.Timeout = null;
-    private _lastState;
     public heater: Heater;
+    protected _pollTimer: NodeJS.Timeout = null;
+    protected _lastState;
+    protected closing = false;
+    protected bodyOnTime: number;
+    protected isOn: boolean = false;
+    protected isCooling: boolean = false;
     constructor(ncp: INixieControlPanel, heater: Heater) {
         super(ncp);
         this.heater = heater;
+    }
+    public get suspendPolling(): boolean { return this._suspendPolling > 0; }
+    public set suspendPolling(val: boolean) { this._suspendPolling = Math.max(0, this._suspendPolling + (val ? 1 : -1)); }
+    public get id(): number { return typeof this.heater !== 'undefined' ? this.heater.id : -1; }
+    public static create(ncp: INixieControlPanel, heater: Heater): NixieHeaterBase {
+        let type = sys.board.valueMaps.heaterTypes.transform(heater.type);
+        switch (type.name) {
+            case 'heatpump':
+                return new NixieHeatpump(ncp, heater);
+            case 'ultratemp':
+                return new NixieUltratemp(ncp, heater);
+            case 'gas':
+                return new NixieGasHeater(ncp, heater);
+            case 'mastertemp':
+                return new NixieMastertemp(ncp, heater);
+            case 'solar':
+                return new NixieSolarHeater(ncp, heater);
+            default:
+                return new NixieHeaterBase(ncp, heater);
+        }
+    }
+    public isBodyOn() {
+        let isOn = sys.board.bodies.isBodyOn(this.heater.body);
+        if (isOn && typeof this.bodyOnTime === 'undefined') {
+            this.bodyOnTime = new Date().getTime();
+        }
+        else if (!isOn) this.bodyOnTime = undefined;
+        return isOn;
+    }
+    public async setHeaterStateAsync(hstate: HeaterState, isOn: boolean, isCooling: boolean) {
+        try {
+            return Promise.reject(new InvalidOperationError(`You cannot change the state on this type of heater ${hstate.name}`, 'setHeaterStateAsync'));
+        } catch (err) { return logger.error(`Nixie Error setting heater state ${hstate.id}-${hstate.name}: ${err.message}`); }
+    }
+    public async setHeaterAsync(data: any) {
+        try {
+            let heater = this.heater;
+           
+        }
+        catch (err) { logger.error(`Nixie setHeaterAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public async closeAsync() {}
+}
+export class NixieGasHeater extends NixieHeaterBase {
+    public pollingInterval: number = 10000;
+    declare heater: Heater;
+    constructor(ncp: INixieControlPanel, heater: Heater) {
+        super(ncp, heater);
+        this.heater = heater;
         this.pollEquipmentAsync();
     }
     public get id(): number { return typeof this.heater !== 'undefined' ? this.heater.id : -1; }
     public async setHeaterStateAsync(hstate: HeaterState, isOn: boolean) {
         try {
-            // Here we go we need to set the valve state.
+            // Initialize the desired state.
+            this.isOn = isOn;
+            this.isCooling = false;
+            // Here we go we need to set the firemans switch state.
             if (hstate.isOn !== isOn) {
                 logger.info(`Nixie: Set Heater ${hstate.id}-${hstate.name} to ${isOn}`);
             }
             if (utils.isNullOrEmpty(this.heater.connectionId) || utils.isNullOrEmpty(this.heater.deviceBinding)) {
                 hstate.isOn = isOn;
-                return new InterfaceServerResponse(200, 'Success');
+                return;
             }
             if (typeof this._lastState === 'undefined' || isOn || this._lastState !== isOn) {
                 let res = await NixieEquipment.putDeviceService(this.heater.connectionId, `/state/device/${this.heater.deviceBinding}`, { isOn: isOn, latch: isOn ? 10000 : undefined });
                 if (res.status.code === 200) this._lastState = hstate.isOn = isOn;
-                return res;
+                else logger.error(`Nixie Error setting heater state: ${res.status.code} -${res.status.message} ${res.error.message}`);
             }
             else {
                 hstate.isOn = isOn;
-                return new InterfaceServerResponse(200, 'Success');
+                return;
             }
-
-
         } catch (err) { return logger.error(`Nixie Error setting heater state ${hstate.id}-${hstate.name}: ${err.message}`); }
     }
-    public async setHeaterAsync(data: any) {
+    public async pollEquipmentAsync() {
+        let self = this;
         try {
-            let heater = this.heater;
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            let success = false;
         }
-        catch (err) { logger.error(`Nixie setHeaterAsync: ${err.message}`); return Promise.reject(err); }
+        catch (err) { logger.error(`Nixie Error polling Heater - ${err}`); }
+        finally { this._pollTimer = setTimeout(async () => await self.pollEquipmentAsync(), this.pollingInterval || 10000); }
+    }
+    private async checkHardwareStatusAsync(connectionId: string, deviceBinding: string) {
+        try {
+            let dev = await NixieEquipment.getDeviceService(connectionId, `/status/device/${deviceBinding}`);
+            return dev;
+        } catch (err) { logger.error(`Nixie Heater Error checkHardwareStatusAsync: ${err.message}`); return { hasFault: true } }
+    }
+    public async validateSetupAsync(heater: Heater, hstate: HeaterState) {
+        try {
+            if (typeof heater.connectionId !== 'undefined' && heater.connectionId !== ''
+                && typeof heater.deviceBinding !== 'undefined' && heater.deviceBinding !== '') {
+                try {
+                    let stat = await this.checkHardwareStatusAsync(heater.connectionId, heater.deviceBinding);
+                    // If we have a status check the return.
+                    hstate.commStatus = stat.hasFault ? 1 : 0;
+                } catch (err) { hstate.commStatus = 1; }
+            }
+            else
+                hstate.commStatus = 0;
+        } catch (err) { logger.error(`Nixie Error checking heater Hardware ${this.heater.name}: ${err.message}`); hstate.commStatus = 1; return Promise.reject(err); }
+    }
+    public async closeAsync() {
+        try {
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            let hstate = state.heaters.getItemById(this.heater.id);
+            await this.setHeaterStateAsync(hstate, false);
+            hstate.emitEquipmentChange();
+        }
+        catch (err) { logger.error(`Nixie Heater closeAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public logData(filename: string, data: any) { this.controlPanel.logData(filename, data); }
+}
+export class NixieSolarHeater extends NixieHeaterBase {
+    public pollingInterval: number = 10000;
+    declare heater: Heater;
+    constructor(ncp: INixieControlPanel, heater: Heater) {
+        super(ncp, heater);
+        this.heater = heater;
+        this.pollEquipmentAsync();
+    }
+    public get id(): number { return typeof this.heater !== 'undefined' ? this.heater.id : -1; }
+    public async setHeaterStateAsync(hstate: HeaterState, isOn: boolean, isCooling: boolean) {
+        try {
+            // Initialize the desired state.
+            this.isOn = isOn;
+            this.isCooling = isCooling;
+            // Here we go we need to set the firemans switch state.
+            if (hstate.isOn !== isOn) {
+                logger.info(`Nixie: Set Heater ${hstate.id}-${hstate.name} to ${isOn}`);
+            }
+            if (utils.isNullOrEmpty(this.heater.connectionId) || utils.isNullOrEmpty(this.heater.deviceBinding)) {
+                hstate.isOn = isOn;
+                return;
+            }
+            if (typeof this._lastState === 'undefined' || isOn || this._lastState !== isOn) {
+                let res = await NixieEquipment.putDeviceService(this.heater.connectionId, `/state/device/${this.heater.deviceBinding}`, { isOn: isOn, latch: isOn ? 10000 : undefined });
+                if (res.status.code === 200) this._lastState = hstate.isOn = isOn;
+                else logger.error(`Nixie Error setting heater state: ${res.status.code} -${res.status.message} ${res.error.message}`);
+            }
+            else {
+                hstate.isOn = isOn;
+                return;
+            }
+        } catch (err) { return logger.error(`Nixie Error setting heater state ${hstate.id}-${hstate.name}: ${err.message}`); }
     }
     public async pollEquipmentAsync() {
+        let self = this;
         try {
             if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
             this._pollTimer = null;
             let success = false;
         }
         catch (err) { logger.error(`Nixie Error polling Heater - ${err}`); }
-        finally { this._pollTimer = setTimeout(async () => await this.pollEquipmentAsync(), this.pollingInterval || 10000); }
+        finally { this._pollTimer = setTimeout(async () => await self.pollEquipmentAsync(), this.pollingInterval || 10000); }
     }
     private async checkHardwareStatusAsync(connectionId: string, deviceBinding: string) {
         try {
@@ -159,10 +285,157 @@ export class NixieHeater extends NixieEquipment {
             if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
             this._pollTimer = null;
             let hstate = state.heaters.getItemById(this.heater.id);
-            await this.setHeaterStateAsync(hstate, false);
+            await this.setHeaterStateAsync(hstate, false, false);
             hstate.emitEquipmentChange();
         }
         catch (err) { logger.error(`Nixie Heater closeAsync: ${err.message}`); return Promise.reject(err); }
     }
     public logData(filename: string, data: any) { this.controlPanel.logData(filename, data); }
 }
+export class NixieHeatpump extends NixieHeaterBase {
+    public configSent: boolean = false;
+    constructor(ncp: INixieControlPanel, heater: Heater) {
+        super(ncp, heater);
+        // Set the polling interval to 3 seconds.
+        this.pollEquipmentAsync();
+    }
+    public async setHeaterStateAsync(hstate: HeaterState, isOn: boolean, isCooling: boolean) {
+        try {
+            this.suspendPolling = true;
+            this.isOn = isOn;
+            this.isCooling = isCooling;
+        } catch (err) { return logger.error(`Nixie Error setting heater state ${hstate.id}-${hstate.name}: ${err.message}`); }
+        finally { this.suspendPolling = false; }
+    }
+    public async pollEquipmentAsync() {
+        let self = this;
+        try {
+            this.suspendPolling = true;
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            if (this._suspendPolling > 1) return;
+            let sheater = state.heaters.getItemById(this.heater.id, !this.closing);
+            // If the body isn't on then we won't communicate with the chem controller.  There is no need
+            // since most of the time these are attached to the filter relay.
+            if (this.isBodyOn() && !this.closing) {
+                await this.sendState(sheater);
+                //if (!this.closing) await this.requestStatus(sheater);
+            }
+        }
+        catch (err) { logger.error(`Error polling Heat Pump - ${err}`); }
+        finally {
+            this.suspendPolling = false; if (!this.closing) this._pollTimer = setTimeout(async () => {
+                try { await self.pollEquipmentAsync() } catch (err) { }
+            }, this.pollingInterval || 10000);
+        }
+    }
+    public async sendState(sheater: HeaterState): Promise<boolean> {
+        try {
+            sheater.type = 2;
+            let success = await new Promise<boolean>((resolve, reject) => {
+                let out = Outbound.create({
+                    protocol: Protocol.Heater,
+                    source: 16,
+                    dest: this.heater.address,
+                    action: 210,
+                    payload: [210],
+                    retries: 3, // We are going to try 4 times.
+                    response: Response.create({ protocol: Protocol.IntelliChem, action: 18 }),
+                    onAbort: () => { },
+                    onComplete: (err) => {
+                        if (err) {
+                            // If the IntelliChem is not responding we need to store that off.  If an 18 does
+                            // come across this will be cleared by the processing of that message.
+                            resolve(false);
+                        }
+                        else { resolve(true); }
+                    }
+                });
+                conn.queueSendMessage(out);
+            });
+            return success;
+        } catch (err) { logger.error(`Communication error with Ultratemp : ${err.message}`); }
+    }
+    public async closeAsync() {
+        try {
+            this.suspendPolling = true;
+            this.closing = true;
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            logger.info(`Closing Heater ${this.heater.name}`);
+
+        }
+        catch (err) { logger.error(`Ultratemp closeAsync: ${err.message}`); return Promise.reject(err); }
+    }
+}
+export class NixieUltratemp extends NixieHeatpump {
+    constructor(ncp: INixieControlPanel, heater: Heater) {
+        super(ncp, heater);
+        // Set the polling interval to 3 seconds.
+        this.pollEquipmentAsync();
+    }
+    public async pollEquipmentAsync() {
+        let self = this;
+        try {
+            this.suspendPolling = true;
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            if (this._suspendPolling > 1) return;
+            let sheater = state.heaters.getItemById(this.heater.id, !this.closing);
+            // If the body isn't on then we won't communicate with the chem controller.  There is no need
+            // since most of the time these are attached to the filter relay.
+            if (!this.closing) {
+                await this.setStatus(sheater);
+            }
+        }
+        catch (err) { logger.error(`Error polling UltraTemp heater - ${err}`); }
+        finally {
+            this.suspendPolling = false; if (!this.closing) this._pollTimer = setTimeout(async () => {
+                try { await self.pollEquipmentAsync() } catch (err) {}
+            }, this.pollingInterval || 10000);
+        }
+    }
+    public async setStatus(sheater: HeaterState): Promise<boolean> {
+        try {
+            let success = await new Promise<boolean>((resolve, reject) => {
+                let out = Outbound.create({
+                    protocol: Protocol.Heater,
+                    source: 16,
+                    dest: this.heater.address,
+                    action: 114,
+                    payload: [],
+                    retries: 3, // We are going to try 4 times.
+                    response: Response.create({ protocol: Protocol.Heater, action: 115 }),
+                    onAbort: () => { },
+                    onComplete: (err) => {
+                        if (err) {
+                            // If the Ultratemp is not responding we need to store that off but at this point we know none of the codes.  If a 115 does
+                            // come across this will be cleared by the processing of that message.
+                            sheater.commStatus = sys.board.valueMaps.equipmentCommStatus.getValue('commerr');
+                            state.equipment.messages.setMessageByCode(`heater:${sheater.id}:comms`, 'error', `Communication error with ${sheater.name}`);
+                            resolve(false);
+                        }
+                        else { resolve(true); }
+                    }
+                });
+                out.appendPayloadBytes(0, 10);
+                out.setPayloadByte(0, 144);
+                out.setPayloadByte(1, this.isOn ? (this.isCooling ? 2 : 1) : 0, 0);
+                conn.queueSendMessage(out);
+            });
+            return success;
+        } catch (err) { logger.error(`Communication error with Ultratemp : ${err.message}`); }
+    }
+    public async closeAsync() {
+        try {
+            this.suspendPolling = true;
+            this.closing = true;
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            logger.info(`Closing Heater ${this.heater.name}`);
+
+        }
+        catch (err) { logger.error(`Ultratemp closeAsync: ${err.message}`); return Promise.reject(err); }
+    }
+}
+export class NixieMastertemp extends NixieGasHeater {}