nodejs-poolcontroller 7.2.0 → 7.5.1

package/controller/nixie/chemistry/ChemController.ts

@@ -1,14 +1,16 @@
-import { InvalidEquipmentDataError, InvalidEquipmentIdError, InvalidOperationError } from '../../Errors';
-import { utils, Timestamp } from '../../Constants';
-import { logger } from '../../../logger/Logger';
-
-import { NixieEquipment, NixieChildEquipment, NixieEquipmentCollection, INixieControlPanel } from "../NixieEquipment";
-import { ChemController, Chemical, ChemicalPh, ChemicalORP, ChemicalPhProbe, ChemicalORPProbe, ChemicalTank, ChemicalPump, sys, ChemicalProbe, ChemControllerCollection, ChemFlowSensor } from "../../../controller/Equipment";
-import { ChemControllerState, ChemicalState, ChemicalORPState, ChemicalPhState, state, ChemicalProbeState, ChemicalProbePHState, ChemicalProbeORPState, ChemicalTankState, ChemicalPumpState, ChemicalDoseState } from "../../State";
-import { setTimeout, clearTimeout } from 'timers';
-import { webApp, InterfaceServerResponse } from "../../../web/Server";
+import { clearTimeout, setTimeout } from 'timers';
 import { conn } from '../../../controller/comms/Comms';
 import { Outbound, Protocol, Response } from '../../../controller/comms/messages/Messages';
+import { ChemController, ChemControllerCollection, ChemFlowSensor, Chemical, ChemicalChlor, ChemicalORP, ChemicalORPProbe, ChemicalPh, ChemicalPhProbe, ChemicalProbe, ChemicalPump, ChemicalTank, sys } from "../../../controller/Equipment";
+import { logger } from '../../../logger/Logger';
+import { InterfaceServerResponse, webApp } from "../../../web/Server";
+import { Timestamp, utils } from '../../Constants';
+import { EquipmentNotFoundError, EquipmentTimeoutError, InvalidEquipmentDataError, InvalidEquipmentIdError, InvalidOperationError } from '../../Errors';
+import { ChemControllerState, ChemicalChlorState, ChemicalDoseState, ChemicalORPState, ChemicalPhState, ChemicalProbeORPState, ChemicalProbePHState, ChemicalProbeState, ChemicalPumpState, ChemicalState, ChemicalTankState, ChlorinatorState, state } from "../../State";
+import { ncp } from '../Nixie';
+import { INixieControlPanel, NixieChildEquipment, NixieEquipment, NixieEquipmentCollection } from "../NixieEquipment";
+import { NixieChlorinator } from './Chlorinator';
+
 
 export class NixieChemControllerCollection extends NixieEquipmentCollection<NixieChemControllerBase> {
     public async manualDoseAsync(id: number, data: any) {
@@ -41,7 +43,7 @@ export class NixieChemControllerCollection extends NixieEquipmentCollection<Nixi
     }
 
     public async setControllerAsync(chem: ChemController, data: any) {
-        // By the time we get here we know that we are in control and this is a REMChem.
+        // By the time we get here we know that we are in control and this REM Chem or IntelliChem.
         try {
             let ncc: NixieChemControllerBase = this.find(elem => elem.id === chem.id) as NixieChemControllerBase;
             if (typeof ncc === 'undefined') {
@@ -49,12 +51,13 @@ export class NixieChemControllerCollection extends NixieEquipmentCollection<Nixi
                 ncc = NixieChemControllerBase.create(this.controlPanel, chem);
                 this.push(ncc);
                 let ctype = sys.board.valueMaps.chemControllerTypes.transform(chem.type);
-                logger.info(`A Chem controller was not found for id #${chem.id} starting ${ctype.desc}`);
+                logger.info(`Nixie Chem Controller was created at id #${chem.id} for type ${ctype.desc}`);
                 await ncc.setControllerAsync(data);
             }
             else {
                 await ncc.setControllerAsync(data);
             }
+            // Now go back through the array and undo anything that is in need of pruning.
         }
         catch (err) { logger.error(`setControllerAsync: ${err.message}`); return Promise.reject(err); }
     }
@@ -67,13 +70,20 @@ export class NixieChemControllerCollection extends NixieEquipmentCollection<Nixi
     }
     public async initAsync(controllers: ChemControllerCollection) {
         try {
-            this.length = 0;
             for (let i = 0; i < controllers.length; i++) {
                 let cc = controllers.getItemByIndex(i);
                 if (cc.master === 1) {
+                    let type = sys.board.valueMaps.chemControllerTypes.transform(cc.type);
                     logger.info(`Initializing chemController ${cc.name}`);
-                    let ncc = NixieChemControllerBase.create(this.controlPanel, cc);
-                    this.push(ncc);
+                    // First check to make sure it isnt already there.
+                    if (typeof this.find(elem => elem.id === cc.id) === 'undefined') {
+
+                        let ncc = NixieChemControllerBase.create(this.controlPanel, cc);
+                        this.push(ncc);
+                    }
+                    else {
+                        logger.info(`chemController ${cc.name} has already been initialized`);
+                    }
                 }
             }
         }
@@ -86,39 +96,56 @@ export class NixieChemControllerCollection extends NixieEquipmentCollection<Nixi
                     logger.info(`Closing chemController ${this[i].id}`);
                     await this[i].closeAsync();
                     this.splice(i, 1);
-                } catch (err) { logger.error(`Error stopping Nixie Chem Controller ${err}`); return Promise.reject(err);}
+                } catch (err) { logger.error(`Error stopping Nixie Chem Controller ${err}`); return Promise.reject(err); }
             }
 
         } catch (err) { } // Don't bail if we have an error
     }
-    // This is currently not used for anything.
-    public async searchIntelliChem(): Promise<number[]> {
-        let arr = [];
-        try {
-            for (let addr = 144; addr <= 152; addr++) {
-                let success = await new Promise<boolean>((resolve, reject) => {
-                    let out = Outbound.create({
-                        protocol: Protocol.IntelliChem,
-                        dest: addr,
-                        action: 210,
-                        payload: [210],
-                        retries: 1, // We are going to try 2 times.
-                        response: Response.create({ protocol: Protocol.IntelliChem, action: 18 }),
-                        onAbort: () => { },
-                        onComplete: (err) => {
-                            if (err) resolve(false);
-                            else resolve(true); 
-                        }
-                    });
-                    conn.queueSendMessage(out);
-                });
-                if (success) arr.push(addr)
+    public async deleteChlorAsync(chlor: NixieChlorinator) {
+        // if we delete the chlor, make sure it is removed from all REM Chem Controllers
+        try {
+            for (let i = this.length - 1; i >= 0; i--) {
+                try {
+                    let ncc = this[i] as NixieChemControllerBase;;
+                    ncc.orp.deleteChlorAsync(chlor);
+                } catch (err) { logger.error(`Error deleting chlor from Nixie Chem Controller ${err}`); return Promise.reject(err); }
             }
-        } catch (err) { return arr; }
+
+        }
+        catch (err) { logger.error(`ncp.deleteChlorAsync: ${err.message}`); return Promise.reject(err); }
     }
+    // This is currently not used for anything.
+    /*     public async searchIntelliChem(): Promise<number[]> {
+            let arr = [];
+            try {
+                for (let addr = 144; addr <= 152; addr++) {
+                    let success = await new Promise<void>((resolve, reject) => {
+                        let out = Outbound.create({
+                            protocol: Protocol.IntelliChem,
+                            dest: addr,
+                            action: 210,
+                            payload: [210],
+                            retries: 1, // We are going to try 2 times.
+                            response: Response.create({ protocol: Protocol.IntelliChem, action: 18 }),
+                            onAbort: () => { },
+                            onComplete: (err) => {
+                                if (err) resolve(false);
+                                else resolve(true);
+                            }
+                        });
+                        conn.queueSendMessage(out);
+                    });
+                    if (success) arr.push(addr)
+                }
+            } catch (err) { return arr; }
+        } */
 }
 export class NixieChemControllerBase extends NixieEquipment {
     public pollingInterval: number = 10000;
+    protected _suspendPolling: number = 0;
+    public get suspendPolling(): boolean { return this._suspendPolling > 0; }
+    public set suspendPolling(val: boolean) { this._suspendPolling = Math.max(0, this._suspendPolling + (val ? 1 : -1)); }
+    public _ispolling = false;
     protected _pollTimer: NodeJS.Timeout = null;
     protected closing = false;
     public orp: NixieChemicalORP;
@@ -132,14 +159,12 @@ export class NixieChemControllerBase extends NixieEquipment {
         this.chem = chem;
     }
     public chem: ChemController;
-    public syncRemoteREMFeeds(servers) {}
-    public static create(ncp: INixieControlPanel, chem: ChemController): NixieChemControllerBase  {
-        // RKS: 06-25-21 - Keeping the homegrown around for now but I don't really know why we care.
+    public syncRemoteREMFeeds(servers) { }
+    public static create(ncp: INixieControlPanel, chem: ChemController): NixieChemControllerBase {
         let type = sys.board.valueMaps.chemControllerTypes.transform(chem.type);
         switch (type.name) {
             case 'intellichem':
                 return new NixieIntelliChemController(ncp, chem);
-            case 'homegrown':
             case 'rem':
                 return new NixieChemController(ncp, chem);
             default:
@@ -155,12 +180,9 @@ export class NixieChemControllerBase extends NixieEquipment {
         else if (!isOn) this.bodyOnTime = undefined;
         return isOn;
     }
-    public async setControllerAsync(data: any) {} // This is meant to be abstract override this value
+    public async setControllerAsync(data: any) { } // This is meant to be abstract override this value
 }
 export class NixieIntelliChemController extends NixieChemControllerBase {
-    protected _suspendPolling: number = 0;
-    public get suspendPolling(): boolean { return this._suspendPolling > 0; }
-    public set suspendPolling(val: boolean) { this._suspendPolling = Math.max(0, this._suspendPolling + (val ? 1 : -1)); }
     public configSent: boolean = false;
     constructor(ncp: INixieControlPanel, chem: ChemController) {
         super(ncp, chem);
@@ -169,6 +191,7 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
         this.pollEquipmentAsync();
     }
     public async pollEquipmentAsync() {
+        let self = this;
         try {
             this.suspendPolling = true;
             if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
@@ -181,11 +204,11 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
             // since most of the time these are attached to the filter relay.
             if (this.isBodyOn() && !this.closing) {
                 if (!this.configSent) await this.sendConfig(schem);
-                if(!this.closing) await this.requestStatus(schem);
+                if (!this.closing) await this.requestStatus(schem);
             }
         }
         catch (err) { logger.error(`Error polling IntelliChem Controller - ${err}`); return Promise.reject(err); }
-        finally { this.suspendPolling = false; if (!this.closing) this._pollTimer = setTimeout(async () => { try { await this.pollEquipmentAsync() } catch (err) { return Promise.reject(err); } }, this.pollingInterval || 10000); }
+        finally { this.suspendPolling = false; if (!this.closing) this._pollTimer = setTimeout(() => { self.pollEquipmentAsync(); }, this.pollingInterval || 10000); }
     }
     public async setControllerAsync(data: any) {
         try {
@@ -194,7 +217,7 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
             let address = typeof data.address !== 'undefined' ? parseInt(data.address) : chem.address;
             let name = typeof data.name !== 'undefined' ? data.name : chem.name || `IntelliChem - ${address - 143}`;
             let type = sys.board.valueMaps.chemControllerTypes.transformByName('intellichem');
-            // So now we are down to the nitty gritty setting the data for the REM or Homegrown Chem controller.
+            // So now we are down to the nitty gritty setting the data for the REM Chem controller.
             let calciumHardness = typeof data.calciumHardness !== 'undefined' ? parseInt(data.calciumHardness, 10) : chem.calciumHardness;
             let cyanuricAcid = typeof data.cyanuricAcid !== 'undefined' ? parseInt(data.cyanuricAcid, 10) : chem.cyanuricAcid;
             let alkalinity = typeof data.alkalinity !== 'undefined' ? parseInt(data.alkalinity, 10) : chem.alkalinity;
@@ -247,7 +270,7 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
             chem.borates = borates;
             chem.body = schem.body = body;
             chem.type = schem.type = type.val;
-           
+
             let acidTankLevel = typeof data.ph !== 'undefined' && typeof data.ph.tank !== 'undefined' && typeof data.ph.tank.level !== 'undefined' ? parseInt(data.ph.tank.level, 10) : schem.ph.tank.level;
             let orpTankLevel = typeof data.orp !== 'undefined' && typeof data.orp.tank !== 'undefined' && typeof data.orp.tank.level !== 'undefined' ? parseInt(data.orp.tank.level, 10) : schem.orp.tank.level;
             // Copy the data back to the chem object.
@@ -270,7 +293,7 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
             chem.orp.tolerance.high = orpTolerance.high;
             chem.ph.setpoint = pHSetpoint;
             chem.orp.setpoint = orpSetpoint;
-            chem.siCalcType = siCalcType;
+            schem.siCalcType = chem.siCalcType = siCalcType;
             chem.address = schem.address = address;
             chem.name = schem.name = name;
             chem.flowSensor.enabled = false;
@@ -357,10 +380,10 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
             if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
             this._pollTimer = null;
             let schem = state.chemControllers.getItemById(this.chem.id);
-            if(typeof this.ph !== 'undefined') await this.ph.closeAsync();
+            if (typeof this.ph !== 'undefined') await this.ph.closeAsync();
             if (typeof this.orp !== 'undefined') await this.orp.closeAsync();
             logger.info(`Closing Chem Controller ${this.chem.name}`);
-            
+
         }
         catch (err) { logger.error(`ChemController closeAsync: ${err.message}`); return Promise.reject(err); }
     }
@@ -382,6 +405,7 @@ export class NixieChemController extends NixieChemControllerBase {
             // not been set and we have a state obect defined.
             let cstate = state.chemControllers.find(x => x.id === chem.id);
             if (cstate && typeof cstate !== 'undefined') {
+                console.log(`Converting to v2.x data structure`);
                 if (cstate.ph.dosingStatus === 1) cstate.ph.dosingStatus = 2;
                 else if (cstate.ph.dosingStatus === 2) cstate.ph.dosingStatus = 1;
                 if (cstate.orp.dosingStatus === 1) cstate.orp.dosingStatus = 2;
@@ -391,6 +415,7 @@ export class NixieChemController extends NixieChemControllerBase {
     }
     public async manualDoseAsync(data: any) {
         try {
+            this.suspendPolling = true;
             // Check to see that we are a rem chem.
             let vol = parseInt(data.volume, 10);
             if (isNaN(vol)) return Promise.reject(new InvalidEquipmentDataError(`Volume was not supplied for the manual chem dose`, 'chemController', data.volume));
@@ -406,9 +431,11 @@ export class NixieChemController extends NixieChemControllerBase {
             else if (chemType === 'orp') await this.orp.manualDoseAsync(schem, vol);
         }
         catch (err) { logger.error(`manualDoseAsync: ${err.message}`); return Promise.reject(err); }
+        finally { this.suspendPolling = false; }
     }
     public async manualMixAsync(data: any) {
         try {
+            this.suspendPolling = true;
             // Check to see that we are a rem chem.
             let time = 0;
             if (typeof data.hours !== 'undefined') time += parseInt(data.hours, 10) * 3600;
@@ -427,9 +454,11 @@ export class NixieChemController extends NixieChemControllerBase {
             else if (chemType === 'orp') await this.orp.mixChemicals(schem, time);
         }
         catch (err) { logger.error(`manualMixAsync: ${err.message}`); return Promise.reject(err); }
+        finally { this.suspendPolling = false; }
     }
     public async cancelDosingAsync(data: any) {
         try {
+            this.suspendPolling = true;
             // Determine which chemical we are cancelling.  This will be ph or orp.
             let chemType = typeof data.chemType === 'string' ? data.chemType.toLowerCase() : '';
             if (typeof this[chemType] === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`A valid Chem type was not supplied for the manual chem dose ${data.chemType}`, 'chemController', data.chemType));
@@ -442,25 +471,24 @@ export class NixieChemController extends NixieChemControllerBase {
             else if (chemType === 'orp') await this.orp.cancelDosing(schem, 'cancelled');
         }
         catch (err) { logger.error(`cancelDosingAsync: ${err.message}`); return Promise.reject(err); }
+        finally { this.suspendPolling = false; }
     }
     public async cancelMixingAsync(data: any) {
         try {
+            this.suspendPolling = true;
             // Determine which chemical we are cancelling.  This will be ph or orp.
             let chemType = typeof data.chemType === 'string' ? data.chemType.toLowerCase() : '';
-            if (typeof this[chemType] === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`A valid Chem type was not supplied for mix chemical ${data.chemType}`, 'chemController', data.chemType));
-            let chem = this.chem[chemType];
-            if (typeof chem === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Could not cancel ${data.chemType} mix config not found.`, 'chemController', data.chemType));
-            let schem = state.chemControllers.getItemById(this.chem.id, true)[chemType];
-            if (typeof schem === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Could not cancel ${data.chemType} mix state not found.`, 'chemController', data.chemType));
-            // Now we can tell the chemical to dose.
-            if (chemType === 'ph') await this.ph.cancelMixing(schem);
-            else if (chemType === 'orp') await this.orp.cancelMixing(schem);
-            schem.dosingStatus = sys.board.valueMaps.chemControllerDosingStatus.getValue('monitoring');
+            let schem = state.chemControllers.getItemById(this.chem.id);
+            if (chemType === 'ph') await this.ph.cancelMixing(schem.ph);
+            else if (chemType === 'orp') await this.orp.cancelMixing(schem.orp);
+            else return Promise.reject(new InvalidEquipmentDataError(`A valid Chem type was not supplied for chemical ${data.chemType}`, 'chemController', data.chemType));
         }
-        catch (err) { logger.error(`cancelDosingAsync: ${err.message}`); return Promise.reject(err); }
+        catch (err) { logger.error(`cancelMixingAsync: ${err.message}`); return Promise.reject(err); }
+        finally { this.suspendPolling = false; }
     }
     public async setControllerAsync(data: any) {
         try {
+            this.suspendPolling = true;
             let chem = this.chem;
             // So now we are down to the nitty gritty setting the data for the REM or Homegrown Chem controller.
             let calciumHardness = typeof data.calciumHardness !== 'undefined' ? parseInt(data.calciumHardness, 10) : chem.calciumHardness;
@@ -488,7 +516,7 @@ export class NixieChemController extends NixieChemControllerBase {
                 if (typeof data.lsiRange.low === 'number') chem.lsiRange.low = data.lsiRange.low;
                 if (typeof data.lsiRange.high === 'number') chem.lsiRange.high = data.lsiRange.high;
             }
-            if (typeof data.siCalcType !== 'undefined') chem.siCalcType = data.siCalcType;
+            if (typeof data.siCalcType !== 'undefined') schem.siCalcType = chem.siCalcType = data.siCalcType;
             await this.flowSensor.setSensorAsync(data.flowSensor);
             // Alright we are down to the equipment items all validation should have been completed by now.
             // ORP Settings
@@ -498,9 +526,11 @@ export class NixieChemController extends NixieChemControllerBase {
             await this.processAlarms(schem);
         }
         catch (err) { logger.error(`setControllerAsync: ${err.message}`); return Promise.reject(err); }
+        finally { this.suspendPolling = false; }
     }
     public async checkFlowAsync(schem: ChemControllerState): Promise<boolean> {
         try {
+            this.suspendPolling = true;
             schem.isBodyOn = this.isBodyOn();
             // rsg - we were not returning the flow sensor state when the body was off.  
             // first, this would not allow us to retrieve a pressure of 0 to update flowSensor.state
@@ -510,6 +540,7 @@ export class NixieChemController extends NixieChemControllerBase {
                 schem.alarms.flowSensorFault = 0;
             }
             else {
+                logger.verbose(`Begin getting flow sensor state`);
                 let ret = await this.flowSensor.getState();
                 schem.flowSensor.state = ret.obj.state;
                 // Call out to REM to see if we have flow.
@@ -526,6 +557,7 @@ export class NixieChemController extends NixieChemControllerBase {
                     else if (typeof ret.obj.state === 'boolean') v = ret.obj.state;
                     else if (typeof ret.obj.state === 'number') v = utils.makeBool(ret.obj.state);
                     else if (typeof ret.obj.state.val === 'number') v = utils.makeBool(ret.obj.state.val);
+                    else if (typeof ret.obj.state.value === 'number') v = utils.makeBool(ret.obj.state.value);
                     else v = false;
                     this.flowDetected = schem.flowDetected = v;
                 }
@@ -541,15 +573,22 @@ export class NixieChemController extends NixieChemControllerBase {
             }
             if (!schem.flowDetected) this.bodyOnTime = undefined;
             else if (typeof this.bodyOnTime === 'undefined') this.bodyOnTime = new Date().getTime();
+            logger.verbose(`End getting flow sensor state`);
             return schem.flowDetected;
         }
-        catch (err) { logger.error(`checkFlowAsync: ${err.message}`); schem.alarms.flowSensorFault = 7; this.flowDetected = schem.flowDetected = false; return Promise.reject(err);}
+        catch (err) { logger.error(`checkFlowAsync: ${err.message}`); schem.alarms.flowSensorFault = 7; this.flowDetected = schem.flowDetected = false; return Promise.reject(err); }
+        finally { this.suspendPolling = false; }
     }
     public async pollEquipmentAsync() {
+        let self = this;
         try {
+            logger.verbose(`Begin polling Chem Controller ${this.id}`);
+            if (this._suspendPolling > 0) logger.warn(`Suspend polling for ${this.chem.name} -> ${this._suspendPolling}`);
+            if (this.suspendPolling) return;
+            if (this._ispolling) return;
+            this._ispolling = true;
             if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
             this._pollTimer = null;
-            let success = false;
             let schem = state.chemControllers.getItemById(this.chem.id, !this.closing);
             // We need to check on the equipment to make sure it is solid.
             if (sys.board.valueMaps.chemControllerTypes.getName(this.chem.type) === 'rem') {
@@ -560,10 +599,8 @@ export class NixieChemController extends NixieChemControllerBase {
                     await this.checkFlowAsync(schem);
                     await this.validateSetupAsync(this.chem, schem);
                     if (this.chem.ph.enabled) await this.ph.probe.setTempCompensationAsync(schem.ph.probe);
-                    // We are not processing Homegrown at this point.
                     // Check each piece of equipment to make sure it is doing its thing.
                     schem.calculateSaturationIndex();
-                    //this.calculateSaturationIndex();
                     this.processAlarms(schem);
                     if (this.chem.ph.enabled) await this.ph.checkDosing(this.chem, schem.ph);
                     if (this.chem.orp.enabled) await this.orp.checkDosing(this.chem, schem.orp);
@@ -571,9 +608,14 @@ export class NixieChemController extends NixieChemControllerBase {
                 else
                     logger.warn('REM Server not Connected');
             }
+            this._ispolling = false;
+        }
+        catch (err) { this._ispolling = false; logger.error(`Error polling Chem Controller - ${err}`); }
+        finally {
+            if (!this.closing && !this._ispolling)
+                this._pollTimer = setTimeout(() => { self.pollEquipmentAsync(); }, this.pollingInterval || 10000);
+            logger.verbose(`End polling Chem Controller ${this.id}`);
         }
-        catch (err) { logger.error(`Error polling Chem Controller - ${err}`); return Promise.reject(err);}
-        finally { if(!this.closing) this._pollTimer = setTimeout(async () => {try {await this.pollEquipmentAsync()} catch (err){return Promise.reject(err);}}, this.pollingInterval || 10000); }
     }
     public processAlarms(schem: ChemControllerState) {
         try {
@@ -588,7 +630,7 @@ export class NixieChemController extends NixieChemControllerBase {
                 }
                 else {
                     // both flow and pressure sensors (type 2 & 4)
-                    if (schem.isBodyOn && schem.flowSensor.state === 0 || !schem.isBodyOn && schem.flowSensor.state > 0) {
+                    if (schem.isBodyOn && !schem.flowDetected || !schem.isBodyOn && schem.flowDetected) {
                         schem.alarms.flow = 1;
                     }
                     else schem.alarms.flow = 0;
@@ -612,7 +654,7 @@ export class NixieChemController extends NixieChemControllerBase {
                 else schem.alarms.orpTank = 0;
                 // Alright we need to determine whether we need to adjust the volume any so that we get at least 3 seconds out of the pump.
                 let padj = this.chem.orp.pump.type > 0 && !this.chem.orp.useChlorinator ? (this.chem.orp.pump.ratedFlow / 60) * 3 : 0;
-                if (this.chem.orp.maxDailyVolume <= schem.orp.dailyVolumeDosed) {
+                if (this.chem.orp.maxDailyVolume <= schem.orp.dailyVolumeDosed && !this.chem.orp.useChlorinator) {
                     schem.warnings.orpDailyLimitReached = 4;
                     schem.orp.dailyLimitReached = true;
                 }
@@ -671,6 +713,7 @@ export class NixieChemController extends NixieChemControllerBase {
             if (chem.lsiRange.enabled) {
                 schem.warnings.waterChemistry = schem.saturationIndex < chem.lsiRange.low ? 1 : schem.saturationIndex > chem.lsiRange.high ? 2 : 0;
             }
+            else schem.warnings.waterChemistry = 0;
         } catch (err) { logger.error(`Error processing chem controller ${this.chem.name} alarms: ${err.message}`); }
     }
     private async checkHardwareStatusAsync(connectionId: string, deviceBinding: string) {
@@ -682,6 +725,7 @@ export class NixieChemController extends NixieChemControllerBase {
     public async validateSetupAsync(chem: ChemController, schem: ChemControllerState) {
         try {
             // The validation will be different if the body is on or not.  So lets get that information.
+            logger.verbose(`Begin validating ${chem.id} - ${chem.name} setup`);
             if (chem.orp.enabled) {
                 if (chem.orp.probe.type !== 0) {
                     let type = sys.board.valueMaps.chemORPProbeTypes.transform(chem.orp.probe.type);
@@ -741,8 +785,11 @@ export class NixieChemController extends NixieChemControllerBase {
                 if (chem.body === 2) totalGallons += sys.bodies.getItemById(3).capacity;
                 if (chem.body === 3) totalGallons += sys.bodies.getItemById(4).capacity;
                 schem.alarms.bodyFault = (isNaN(totalGallons) || totalGallons === 0) ? 6 : 0;
+                if (schem.alarms.bodyFault !== 0) logger.warn(`Chem controller body calculation invalid ${totalGallons} -> ${chem.body}`);
             }
             schem.alarms.comms = 0;
+            logger.verbose(`End validating ${chem.id} - ${chem.name} setup`);
+
         } catch (err) { logger.error(`Error checking Chem Controller Hardware ${this.chem.name}: ${err.message}`); schem.alarms.comms = 2; return Promise.reject(err); }
     }
     public async closeAsync() {
@@ -768,44 +815,40 @@ export class NixieChemController extends NixieChemControllerBase {
 class NixieChemical extends NixieChildEquipment {
     public chemical: Chemical;
     public pump: NixieChemPump;
+    public chlor: NixieChemChlor;
     public tank: NixieChemTank;
     public _lastOnStatus: number;
+    protected _stoppingMix = false;
+    protected _suspendPolling: number = 0;
+    public get suspendPolling(): boolean { return this._suspendPolling > 0; }
+    public set suspendPolling(val: boolean) { this._suspendPolling = Math.max(0, this._suspendPolling + (val ? 1 : -1)); }
+    protected _processingMix = false;
     //public currentDose: ChemicalDoseState;
     public chemType: string;
-    public currentMix: NixieChemMix;
+    public _currentMix: NixieChemMix;
     //public doseHistory: NixieChemDoseLog[] = [];
     protected _mixTimer: NodeJS.Timeout;
     //public get logFilename() { return `chemDosage_unknown.log`; }
     public get chemController(): NixieChemController { return this.getParent() as NixieChemController; }
+    public get currentMix(): NixieChemMix { return this._currentMix; }
+    public set currentMix(val: NixieChemMix) {
+        if (typeof val === 'undefined' && typeof this._currentMix !== 'undefined') logger.debug(`${this.chemical.chemType} mix set to undefined`);
+        else logger.debug(`Set new current mix ${this.chemical.chemType}`)
+        this._currentMix = val;
+    }
     constructor(controller: NixieChemController, chemical: Chemical) {
         super(controller);
         chemical.master = 1;
         this.chemical = chemical;
         this.pump = new NixieChemPump(this, chemical.pump);
         this.tank = new NixieChemTank(this, chemical.tank);
-        // RKS: We no longer need this as the chemicalState functions will take care of it all.
-        //// Load up the dose history so we can do our 24 hour thingy.
-        //(async () => {
-        //    let lines = await this.chemController.controlPanel.readLogFile(this.logFilename);
-        //    let dt = new Date().getTime() - 86400000;
-        //    let total = 0;
-        //    for (let i = 0; i < lines.length; i++) {
-        //        try {
-        //            let log = NixieChemDoseLog.fromLog(lines[i]);
-        //            if (log.end.getTime() > dt) {
-        //                this.doseHistory.push(log);
-        //            }
-        //            else break;  // The file should be ordered where the latest dose is at the top.
-        //        } catch (err) { logger.error(`read chemController Dose History: ${err.message}`); }
-        //    }
-        //})();
-    }
-    public async cancelMixing(schem: ChemicalState) {
+        logger.info(`Nixie Chemical ${chemical.chemType} object created`);
+    }
+    public async cancelMixing(schem: ChemicalState): Promise<void> {
         try {
-            // Just stop the pump for now but we will do some logging later.
+            logger.verbose(`Cancelling ${this.chemType} Mix`);
             await this.stopMixing(schem);
-            schem.mixTimeRemaining = 0;
-        } catch (err) { logger.error(`cancelMixing pH: ${err.message}`); return Promise.reject(err); }
+        } catch (err) { logger.error(`cancelMixing ${this.chemType}: ${err.message}`); return Promise.reject(err); }
     }
     protected async setHardware(chemical: Chemical, data: any) {
         try {
@@ -813,7 +856,7 @@ class NixieChemical extends NixieChildEquipment {
         }
         catch (err) { return Promise.reject(err); }
     }
-    protected async setDosing(chemical: Chemical, data: any) {
+    protected async setDosing(chemical: Chemical, data: any): Promise<void> {
         try {
             if (typeof data !== 'undefined') {
                 chemical.enabled = typeof data.enabled !== 'undefined' ? utils.makeBool(data.enabled) : chemical.enabled;
@@ -830,8 +873,9 @@ class NixieChemical extends NixieChildEquipment {
             }
         } catch (err) { logger.error(`setDosing: ${err.message}`); return Promise.reject(err); }
     }
-    protected async setMixing(chemical: Chemical, data: any) {
+    protected async setMixing(chemical: Chemical, data: any): Promise<void> {
         try {
+            this.suspendPolling = true;
             if (typeof data !== 'undefined') {
                 if (typeof data.mixingTimeHours !== 'undefined' || typeof data.mixingTimeMinutes !== 'undefined') {
                     data.mixingTime = (typeof data.mixingTimeHours !== 'undefined' ? parseInt(data.mixingTimeHours, 10) * 3600 : 0) +
@@ -842,103 +886,154 @@ class NixieChemical extends NixieChildEquipment {
                 chemical.flowOnlyMixing = typeof data.flowOnlyMixing !== 'undefined' ? utils.makeBool(data.flowOnlyMixing) : chemical.flowOnlyMixing;
             }
         } catch (err) { logger.error(`setMixing: ${err.message}`); return Promise.reject(err); }
+        finally { this.suspendPolling = false; }
     }
-    protected async stopMixing(schem: ChemicalState) {
+    protected async stopMixing(schem: ChemicalState): Promise<void> {
         try {
-            let chem = this.chemController.chem;
-            schem.pump.isDosing = false;
-            if (typeof this._mixTimer !== 'undefined') {
-                clearTimeout(this._mixTimer);
-                this._mixTimer = undefined;
+            this._stoppingMix = true;
+            this.suspendPolling = true;
+            if (typeof this.currentMix !== 'undefined') logger.debug(`Stopping ${schem.chemType} mix and clearing the current mix object.`);
+            if (typeof this.chemController.orp.orp.useChlorinator !== 'undefined' && this.chemController.orp.orp.useChlorinator && this.chemController.orp.orp.dosingMethod > 0)
+                schem.chlor.isDosing = false;
+            else
+                schem.pump.isDosing = false;
+
+            if (typeof this.currentMix !== 'undefined' || typeof this._mixTimer !== 'undefined' || this._mixTimer) {
+                if (this._mixTimer || typeof this._mixTimer !== 'undefined') {
+                    clearInterval(this._mixTimer);
+                    this._mixTimer = undefined;
+                    logger.verbose(`Cleared ${schem.chemType} mix timer`);
+                }
+                else
+                    logger.warn(`${schem.chemType} did not have a mix timer set when cancelling.`);
+
+                if (typeof this.currentMix !== 'undefined') {
+                    this.currentMix = undefined;
+                    logger.verbose(`Cleared ${schem.chemType} mix object`);
+                }
+                else
+                    logger.warn(`${schem.chemType} did not have a currentMix object set when cancelling.`);
+                schem.dosingStatus = sys.board.valueMaps.chemControllerDosingStatus.getValue('monitoring');
+                schem.mixTimeRemaining = 0;
+                schem.manualMixing = false;
             }
-            schem.mixTimeRemaining = 0;
-            this.currentMix = undefined;
-        } catch (err) { logger.error(`Error stopping chemical mix`); return Promise.reject(err);}
+        } catch (err) { logger.error(`Error stopping chemical mix`); return Promise.reject(err); }
+        finally { this._stoppingMix = false; this.suspendPolling = false; }
     }
-    public async mixChemicals(schem: ChemicalState, mixingTime?: number) {
+    protected async initMixChemicals(schem: ChemicalState, mixingTime?: number): Promise<void> {
         try {
-            let chem = this.chemController.chem;
-            let flowDetected = this.chemController.flowDetected;
-            if (typeof this._mixTimer !== 'undefined') {
-                clearTimeout(this._mixTimer);
-                this._mixTimer = undefined;
-            }
-            let dt = new Date().getTime();
-            if (typeof mixingTime !== 'undefined') {
-                // This is a manual mix so we need to make sure the pump is not dosing.
-                await this.pump.stopDosing(schem, 'completed');
-                await this.stopMixing(schem);
-            }
-            schem.pump.isDosing = false;
+            if (this._stoppingMix) return;
             if (typeof this.currentMix === 'undefined') {
+                if (typeof mixingTime !== 'undefined') {
+                    // This is a manual mix so we need to make sure the pump is not dosing.
+                    logger.info(`Clearing any possible ${schem.chemType} dosing or existing mix for mixingTime: ${mixingTime}`);
+                    await this.pump.stopDosing(schem, 'mix override');
+                    await this.stopMixing(schem);
+                }
                 this.currentMix = new NixieChemMix();
                 if (typeof mixingTime !== 'undefined' && !isNaN(mixingTime)) {
                     this.currentMix.set({ time: mixingTime, timeMixed: 0, isManual: true });
+                    schem.manualMixing = true;
                 }
                 else if (schem.mixTimeRemaining > 0) {
-                    this.currentMix.set({ time: this.chemical.mixingTime, timeMixed: Math.max(0, this.chemical.mixingTime - schem.mixTimeRemaining) });
+                    if (schem.manualMixing) {
+                        this.currentMix.set({ time: schem.mixTimeRemaining, timeMixed: 0, isManual: true });
+                    }
+                    else
+
+                        this.currentMix.set({ time: this.chemical.mixingTime, timeMixed: Math.max(0, this.chemical.mixingTime - schem.mixTimeRemaining) });
                 }
+
                 else
                     this.currentMix.set({ time: this.chemical.mixingTime, timeMixed: 0 });
                 logger.info(`Chem Controller begin mixing ${schem.chemType} for ${utils.formatDuration(this.currentMix.timeRemaining)} of ${utils.formatDuration(this.currentMix.time)}`)
-                schem.dosingStatus = sys.board.valueMaps.chemControllerDosingStatus.getValue('mixing');
-                this.currentMix.lastChecked = dt;
+                schem.mixTimeRemaining = this.currentMix.timeRemaining;
+            }
+            if (typeof this._mixTimer === 'undefined' || !this._mixTimer) {
+                let self = this;
+                this._mixTimer = setInterval(async () => { await self.mixChemicals(schem); }, 1000);
+                logger.verbose(`Set ${schem.chemType} mix timer`);
+            }
+        } catch (err) { logger.error(`Error initializing ${schem.chemType} mix: ${err.message}`); }
+    }
+    public async mixChemicals(schem: ChemicalState, mixingTime?: number): Promise<void> {
+        try {
+            if (this._stoppingMix) {
+                logger.verbose(`${schem.chemType} is currently stopping mixChemicals ignored.`)
+                return;
+            }
+            if (this._processingMix) {
+                logger.verbose(`${schem.chemType} is already processing mixChemicals ignored.`);
+                return;
             }
-            // rsg - added isBodyOn check because flowDetected will be true if the spa is on but nixie is set to pool only
-            if ((schem.chemController.isBodyOn && flowDetected) || !this.chemical.flowOnlyMixing) {
+            this._processingMix = true;
+            let dt = new Date().getTime();
+            await this.initMixChemicals(schem, mixingTime);
+            if (this._stoppingMix) return;
+            schem.chlor.isDosing = schem.pump.isDosing = false;
+            if (!this.chemical.flowOnlyMixing || (schem.chemController.isBodyOn && this.chemController.flowDetected)) {
+                if (this.chemType === 'orp' && typeof this.chemController.orp.orp.useChlorinator !== 'undefined' && this.chemController.orp.orp.useChlorinator && this.chemController.orp.orp.dosingMethod > 0) {
+                    if (state.chlorinators.getItemById(1).currentOutput !== 0) {
+                        logger.debug(`Chem mixing ORP (chlorinator) paused waiting for chlor current output to be 0%.  Mix time remaining: ${utils.formatDuration(schem.mixTimeRemaining)} `);
+                        return;
+                    }
+                }
                 this.currentMix.timeMixed += Math.round((dt - this.currentMix.lastChecked) / 1000);
                 // Reflect any changes to the configuration.
-                if (!this.currentMix.isManual) this.currentMix.time = this.chemical.mixingTime;
-                schem.mixTimeRemaining = this.currentMix.timeRemaining;
+                if (!this.currentMix.isManual) { this.currentMix.time = this.chemical.mixingTime; }
+                schem.mixTimeRemaining = Math.round(this.currentMix.timeRemaining);
                 logger.verbose(`Chem mixing ${schem.chemType} remaining: ${utils.formatDuration(schem.mixTimeRemaining)}`);
             }
-            else {
-                logger.verbose(`Chem mixing paused because body is not on.`);
-            }
+            else
+                logger.verbose(`Chem ${schem.chemType} mixing paused because body is not on.`);
             this.currentMix.lastChecked = dt;
-            if (schem.mixTimeRemaining === 0) {
-                logger.info(`Chem Controller ${schem.chemType} mixing Complete after ${utils.formatDuration(this.currentMix.timeMixed)}`)
-                schem.dosingStatus = sys.board.valueMaps.chemControllerDosingStatus.getValue('monitoring');
-                this.currentMix = undefined;
+            if (schem.mixTimeRemaining <= 0) {
+                logger.info(`Chem Controller ${schem.chemType} mixing Complete after ${utils.formatDuration(this.currentMix.timeMixed)}`);
+                await this.stopMixing(schem);
             }
-            else { schem.dosingStatus = sys.board.valueMaps.chemControllerDosingStatus.getValue('mixing'); }
-            //state.emitEquipmentChanges();
-            schem.chemController.emitEquipmentChange();
-        } catch (err) { logger.error(`Error mixing chemicals.`) }
-        finally { if (schem.mixTimeRemaining > 0) this._mixTimer = setTimeout(() => { this.mixChemicals(schem); }, 1000); }
+            else {
+                schem.dosingStatus = sys.board.valueMaps.chemControllerDosingStatus.getValue('mixing');
+            }
+        } catch (err) { logger.error(`Error mixing chemicals: ${err.message}`); }
+        finally {
+            this._processingMix = false;
+            setImmediate(() => {
+                schem.chemController.emitEquipmentChange();
+            });
+        }
     }
     public async initDose(schem: ChemicalState) { }
     public async closeAsync() {
         try {
-            if (typeof this._mixTimer !== 'undefined') clearTimeout(this._mixTimer);
+            // We are only killing the mix timer here so when njsPC is restarted it picks up where
+            // it left off with mixing.
+            if (typeof this._mixTimer !== 'undefined') clearInterval(this._mixTimer);
             this._mixTimer = undefined;
             await super.closeAsync();
         }
-        catch (err) { logger.error(`chemController closeAsync ${err.message}`); return Promise.reject(err);}
+        catch (err) { logger.error(`chemController closeAsync ${err.message}`); return Promise.reject(err); }
     }
-    public async cancelDosing(schem: ChemicalState, reason: string) {
+    public async cancelDosing(schem: ChemicalState, reason: string): Promise<void> {
         try {
-            // Just stop the pump for now but we will do some logging later.
-            await this.pump.stopDosing(schem, reason);
-            if (schem.dosingStatus === 0)
-                await this.mixChemicals(schem);
+            if (typeof this.chemController.orp.orp.useChlorinator !== 'undefined' && this.chemController.orp.orp.useChlorinator && this.chemController.orp.orp.dosingMethod > 0) {
+                if (!this.chlor.chlor.superChlor) await this.chlor.stopDosing(schem, reason);
+                // for chlor, we want 15 minute intervals
+                if (schem.doseHistory.length) {
+                    // if last dose was within 15 minutes, set mix time to 15 mins-lastdose
+                    // if no dose in last 15, then we should be monitoring
+                    let lastDoseTime = schem.doseHistory[0].timeDosed;
+                    let mixTime = Math.min(Math.max(this.chlor.chlorInterval * 60 - lastDoseTime, 0), this.chlor.chlorInterval * 60);
+                    if (schem.dosingStatus === 0) await this.mixChemicals(schem, mixTime);
+                }
+                else
+                    if (schem.dosingStatus === 0) await this.mixChemicals(schem);
+            }
+            else {
+                // Just stop the pump for now but we will do some logging later.
+                if (schem.dosingStatus === 0) await this.mixChemicals(schem);
+            }
         } catch (err) { logger.error(`cancelDosing: ${err.message}`); return Promise.reject(err); }
     }
-    //public calcTotalDosed(hours: number, trim: boolean = false): number {
-    //    let total = 0;
-    //    let dt = new Date().getTime() - (hours * 3600000);
-    //    for (let i = this.doseHistory.length - 1; i >= 0; i--) {
-    //        let log = this.doseHistory[i];
-    //        if (log.end.getTime() > dt) total += log.volumeDosed;
-    //        else if (trim) {
-    //            this.doseHistory.splice(i, 1);
-    //        }
-    //    }
-    //    if (typeof this.currentDose !== 'undefined' && this.currentDose.volumeRemaining > 0 && this.currentDose.timeRemaining > 0) {
-    //        total += this.currentDose.volumeDosed;
-    //    }
-    //    return Math.round(total);
-    //}
 }
 export class NixieChemTank extends NixieChildEquipment {
     public tank: ChemicalTank;
@@ -982,7 +1077,7 @@ export class NixieChemPump extends NixieChildEquipment {
     private _isStopping = false;
     constructor(chemical: NixieChemical, pump: ChemicalPump) { super(chemical); this.pump = pump; }
     public get chemical(): NixieChemical { return this.getParent() as NixieChemical; }
-    public async setPumpAsync(spump: ChemicalPumpState, data: any) {
+    public async setPumpAsync(spump: ChemicalPumpState, data: any): Promise<void> {
         try {
             if (typeof data !== 'undefined') {
                 this.pump.enabled = typeof data.enabled !== 'undefined' ? data.enabled : this.pump.enabled;
@@ -994,8 +1089,9 @@ export class NixieChemPump extends NixieChildEquipment {
         } catch (err) { logger.error(`setPumpAsync: ${err.message}`); return Promise.reject(err); }
 
     }
-    public async stopDosing(schem: ChemicalState, reason: string) {
+    public async stopDosing(schem: ChemicalState, reason: string): Promise<void> {
         try {
+            logger.debug(`Stopping ${schem.chemType} pump: ${reason}`);
             if (this._dosingTimer) {
                 clearTimeout(this._dosingTimer);
                 this._dosingTimer = undefined;
@@ -1006,20 +1102,20 @@ export class NixieChemPump extends NixieChildEquipment {
             }
             this._isStopping = true;
             let dose = schem.currentDose;
-            //let dose = this.chemical.currentDose;
             if (this.pump.type !== 0) await this.turnOff(schem);
             if (typeof dose !== 'undefined') {
-                //dose.log(this.chemical);
-                schem.endDose();
+                schem.endDose(new Date(), reason);
                 schem.manualDosing = false;
                 schem.dosingTimeRemaining = 0;
                 schem.dosingVolumeRemaining = 0;
                 schem.volumeDosed = 0;
+                schem.timeDosed = 0;
             }
         } catch (err) { logger.error(`Error stopping ${schem.chemType} dosing: ${err.message}`); return Promise.reject(err); }
         finally { this._isStopping = false; }
     }
-    public async dose(schem: ChemicalState) {
+    public async dose(schem: ChemicalState): Promise<void> {
+        let self = this;
         let dose: ChemicalDoseState = schem.currentDose;
         try {
             if (this._dosingTimer) {
@@ -1128,10 +1224,11 @@ export class NixieChemPump extends NixieChildEquipment {
                     await this.chemical.cancelDosing(schem, 'empty tank');
             }
             //dosage.schem.dosingStatus = status;
+            return;
         } catch (err) {
             // If we have an error then we want to clear the latch time.  Theoretically we could add 3 seconds of latch time but who knows when the failure
             // actually occurred.
-            if(typeof dose !== 'undefined') dose._lastLatch = undefined;
+            if (typeof dose !== 'undefined') dose._lastLatch = undefined;
             logger.error(`chemController.pump dose: ${err.message}`);
             return Promise.reject(err);
         }
@@ -1140,14 +1237,24 @@ export class NixieChemPump extends NixieChildEquipment {
             // Add a check to tell the chem when we are done.
             if (schem.dosingStatus === 0) {
                 this._dosingTimer = setTimeout(async () => {
-                    try { await this.dose(schem); }
-                    catch (err) { logger.error(err); return Promise.reject(err);}
+                    try { await self.dose(schem); }
+                    catch (err) {
+                        logger.error(`self.dose error in finally:`);
+                        logger.error(err);
+                        //return Promise.reject(err); // this isn't a promise we should be returning
+                    }
                 }, 1000);
             }
             else {
                 // Tell whichever chemical we are dealing with to begin mixing.
                 if (typeof dose !== 'undefined') {
-                    await this.chemical.cancelDosing(schem, 'completed');
+                    try {
+                        await this.chemical.cancelDosing(schem, 'completed');
+                    }
+                    catch (err) {
+                        logger.error(`this.chemical.cancelDosing error in finally:`);
+                        logger.error(err);
+                    }
                     schem.pump.isDosing = this.isOn = false;
                     schem.manualDosing = false;
                 }
@@ -1169,12 +1276,190 @@ export class NixieChemPump extends NixieChildEquipment {
     public async turnOn(schem: ChemicalState, latchTimeout?: number): Promise<InterfaceServerResponse> {
         try {
             let res = await NixieEquipment.putDeviceService(this.pump.connectionId, `/state/device/${this.pump.deviceBinding}`, typeof latchTimeout !== 'undefined' ? { isOn: true, latch: latchTimeout } : { isOn: true });
-            this.isOn = schem.pump.isDosing = false;
+            this.isOn = schem.pump.isDosing = true;
             return res;
         }
         catch (err) { logger.error(`chemController.pump.turnOn: ${err.message}`); return Promise.reject(err); }
     }
 }
+export class NixieChemChlor extends NixieChildEquipment {
+    public chlor: ChemicalChlor;
+    public isOn: boolean;
+    public _lastOnStatus: number;
+    protected _dosingTimer: NodeJS.Timeout;
+    private _isStopping = false;
+    public chlorInterval = 15;
+    constructor(chemical: NixieChemical, chlor: ChemicalChlor) { super(chemical); this.chlor = chlor; }
+    public get chemical(): NixieChemical { return this.getParent() as NixieChemical; }
+    public async setChlorAsync(schlor: ChemicalChlorState, data: any) {
+        try {
+            if (typeof data.chlorDosingMethod !== 'undefined' && data.chlorDosingMethod === 0) {
+                if (schlor.chemical.dosingStatus === 0) { await this.chemical.cancelDosing(schlor.chemController.orp, 'dosing method changed'); }
+                if (schlor.chemical.dosingStatus === 1) { await this.chemical.cancelMixing(schlor.chemController.orp); }
+                let chlor = sys.chlorinators.getItemById(1);
+                chlor.disabled = false;
+                chlor.isDosing = false;
+            }
+        } catch (err) { logger.error(`setChlorAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public async stopDosing(schem: ChemicalState, reason: string): Promise<void> {
+        try {
+            if (this._dosingTimer) {
+                clearTimeout(this._dosingTimer);
+                this._dosingTimer = undefined;
+            }
+            if (this._isStopping) {
+                logger.warn('Trying to stop dosing chlor but it has not yet responded.');
+                return Promise.reject(new EquipmentTimeoutError(`Already trying to stop chlor dosing.`, `chlorStopDosingInProgress`));
+                // return false;  // We have to semaphore here just in case the chlor is not stopping as we would like.
+            }
+            logger.debug(`Stopping chlorinating: ${reason}`);
+            this._isStopping = true;
+            let dose = schem.currentDose;
+            await this.turnOff(schem);
+            if (typeof dose !== 'undefined') {
+                schem.endDose();
+                schem.manualDosing = false;
+                schem.dosingTimeRemaining = 0;
+                schem.dosingVolumeRemaining = 0;
+                schem.volumeDosed = 0;
+            }
+        } catch (err) { logger.error(`Error stopping ${schem.chemType} dosing: ${err.message}`); return Promise.reject(err); }
+        finally { this._isStopping = false; }
+    }
+    public async dose(schem: ChemicalState): Promise<void> {
+        let self = this;
+        let dose: ChemicalDoseState = schem.currentDose;
+        try {
+            if (this._dosingTimer) {
+                clearTimeout(this._dosingTimer);
+                this._dosingTimer = undefined;
+            }
+            if (typeof dose === 'undefined') {
+                await this.chemical.cancelDosing(schem, 'undefined dose');
+                return;
+            }
+            if (this.chlor.ratedLbs === 0) {
+                // We aren't going to do anything.
+                logger.verbose(`Chem dose ignore chlor because it doesn't have a dosing rating.`);
+            }
+            else {
+                await this.chemical.chemController.processAlarms(schem.chemController);
+                let isBodyOn = schem.chemController.flowDetected;
+                await this.chemical.initDose(schem);
+                let chemController = schem.getParent()
+                let schlor = state.chlorinators.getItemById(1);
+                if (!isBodyOn) {
+                    // Make sure the chlor is off.
+                    logger.info(`Chem chlor flow not detected. Body is not running.`);
+                    await this.chemical.cancelDosing(schem, 'no flow');
+                }
+
+                else if (chemController.ph.enabled && chemController.ph.pump.isDosing && chemController.ph.dosePriority) {
+                    // If ph has dose priority and is dosing, we shouldn't be continuing here
+                    let chem = sys.chemControllers.getItemById(chemController.id, false);
+                    if (chem.ph.dosePriority)
+                        await this.chemical.cancelDosing(schem, 'ph dose priority');
+                }
+                else if (this.chlor.superChlor) {
+                    // if superchlor is active, it may be to boost the ORP and we should respect that
+                    await this.chemical.cancelDosing(schem, 'superchlor');
+                }
+                else if (dose.timeRemaining <= 0 || dose.volumeRemaining <= 0) {
+                    logger.info(`Dose completed ${dose.volumeDosed}lbs ${dose.timeRemaining} ${dose.volumeRemaining}`);
+                    await this.chemical.cancelDosing(schem, 'completed');
+                }
+                else if (dose.timeRemaining > 0 && dose.volumeRemaining > 0) { // We are actually dosing here
+                    try {
+                        await this.turnOn(schem);
+                        if (schlor.currentOutput !== 100) {
+                            logger.warn(`Chlor dose not added because current output is not 100%`);
+                        }
+                        else {
+                            if (typeof dose._lastLatch !== 'undefined') {
+                                let time = new Date().getTime() - (dose._lastLatch || new Date().getTime());
+                                let vol = this.chlor.ratedLbs * time / 1000;
+                                schem.appendDose(vol, time);
+                            }
+                            logger.info(`Chem Controller ${dose.chem} chlorinated ${Math.round(dose.volumeDosed * 1000000) / 1000000}lbs of ${Math.round(dose.volume * 1000000) / 1000000}lbs - ${utils.formatDuration(dose.timeRemaining)} remaining`);
+                            dose._lastLatch = new Date().getTime();
+                        }
+                    }
+                    catch (err) {
+                        logger.error(`Error starting chlorination: ${err}.`)
+                    }
+                    // if we don't reach the chlorinator, we still want to be in dosing status
+                    schem.dosingStatus = 0;
+                }
+                else {
+                    await this.chemical.cancelDosing(schem, 'unknown cancel');
+                }
+                return;
+            }
+        } catch (err) {
+            logger.error(`chemController.chlor dose: ${err.message}`);
+            return Promise.reject(err);
+        }
+        finally {
+            schem.chemController.emitEquipmentChange();
+            // Add a check to tell the chem when we are done.
+            if (schem.dosingStatus === 0) {
+                this._dosingTimer = setTimeout(async () => {
+                    try { await self.dose(schem); }
+                    catch (err) {
+                        logger.error(err);
+                        // return Promise.reject(err); // should not be returning a promise in a finally 
+                    }
+                }, 1000);
+            }
+            else {
+                // Tell whichever chemical we are dealing with to begin mixing.
+                if (typeof dose !== 'undefined') {
+                    await this.chemical.cancelDosing(schem, 'completed');
+                    schem.chlor.isDosing = this.isOn = false;
+                    // schem.manualDosing = false;
+                }
+            }
+        }
+    }
+    public async turnOff(schem: ChemicalState): Promise<ChlorinatorState> {
+        try {
+            logger.info(`Turning off the chlorinator`);
+            let chlor = sys.chlorinators.getItemById(1);
+            let schlor = state.chlorinators.getItemById(1);
+            if (schlor.currentOutput === 0 && schlor.targetOutput === 0 && !schlor.superChlor && chlor.disabled && !chlor.isDosing) {
+                this.isOn = schem.chlor.isDosing = false;
+                return schlor;
+            }
+            let cstate = await sys.board.chlorinator.setChlorAsync({
+                id: 1,
+                disabled: true,
+                isDosing: false
+            })
+            this.isOn = schem.chlor.isDosing = false;
+            return cstate;
+        }
+        catch (err) { logger.error(`chemController.chlor.turnOff: ${err.message}`); return Promise.reject(err); }
+    }
+    public async turnOn(schem: ChemicalState, latchTimeout?: number): Promise<ChlorinatorState> {
+        try {
+            let chlor = sys.chlorinators.getItemById(1);
+            let schlor = state.chlorinators.getItemById(1);
+            if (schlor.currentOutput === 100 && schlor.targetOutput === 100 && !schlor.superChlor && !chlor.disabled && chlor.isDosing) {
+                this.isOn = schem.chlor.isDosing = true;
+                return schlor;
+            }
+            let cstate = await sys.board.chlorinator.setChlorAsync({
+                id: 1,
+                disabled: false,
+                isDosing: true
+            })
+            this.isOn = schem.chlor.isDosing = true;
+            return cstate;
+        }
+        catch (err) { logger.error(`chemController.chlor.turnOn: ${err.message}`); return Promise.reject(err); }
+    }
+}
 export class NixieChemicalPh extends NixieChemical {
     public get ph(): ChemicalPh { return this.chemical as ChemicalPh; }
     public probe: NixieChemProbePh;
@@ -1221,10 +1506,10 @@ export class NixieChemicalPh extends NixieChemical {
                             let sorp = sph.chemController.orp;
                             for (let i = 0; i < chlors.length; i++) {
                                 let chlor = chlors.getItemByIndex(i);
-                                if (!chlor.disabled) await sys.board.chlorinator.setChlorAsync({ id: chlor.id, disabled: true });
+                                if (!chlor.disabled) await sys.board.chlorinator.setChlorAsync({ id: chlor.id, disabled: true, isDosing: false });
                             }
                             // If we are currently dosing ORP then we need to stop that because pH is currently dosing.
-                            if (sorp.pump.isDosing) await this.chemController.orp.cancelDosing(sorp, 'pH priority');
+                            if (sorp.pump.isDosing || sorp.chlor.isDosing) await this.chemController.orp.cancelDosing(sorp, 'pH priority');
                         }
                         this.ph.dosePriority = b;
                     }
@@ -1234,45 +1519,12 @@ export class NixieChemicalPh extends NixieChemical {
         }
         catch (err) { logger.error(`chemController setPhAysnc.: ${err.message}`); return Promise.reject(err); }
     }
-    //public calcDemand(sph: ChemicalPhState): number {
-    //    let chem = this.chemController.chem;
-    //    // Calculate how many mL are required to raise to our pH level.
-    //    // 1. Get the total gallons of water that the chem controller is in
-    //    // control of.
-    //    let totalGallons = 0;
-
-    //    if (chem.body === 0 || chem.body === 32 || sys.equipment.shared) totalGallons += sys.bodies.getItemById(1).capacity;
-    //    if (chem.body === 1 || chem.body === 32 || sys.equipment.shared) totalGallons += sys.bodies.getItemById(2).capacity;
-    //    if (chem.body === 2) totalGallons += sys.bodies.getItemById(3).capacity;
-    //    if (chem.body === 3) totalGallons += sys.bodies.getItemById(4).capacity;
-    //    logger.verbose(`Chem begin calculating demand: ${sph.level} setpoint: ${this.ph.setpoint} body: ${totalGallons}`);
-    //    let chg = this.ph.setpoint - sph.level;
-    //    let delta = chg * totalGallons;
-    //    let temp = (sph.level + this.ph.setpoint) / 2;
-    //    let adj = (192.1626 + -60.1221 * temp + 6.0752 * temp * temp + -0.1943 * temp * temp * temp) * (chem.alkalinity + 13.91) / 114.6;
-    //    let extra = (-5.476259 + 2.414292 * temp + -0.355882 * temp * temp + 0.01755 * temp * temp * temp) * (chem.borates || 0);
-    //    extra *= delta;
-    //    delta *= adj;
-    //    let dose = 0;
-    //    if (this.ph.phSupply === 0) {  // We are dispensing base so we need to calculate the demand here.
-    //        if (chg > 0) {
-
-    //        }
-    //    }
-    //    else {
-    //        if (chg < 0) {
-    //            let at = sys.board.valueMaps.acidTypes.transform(this.ph.acidType);
-    //            dose = Math.round(utils.convert.volume.convertUnits((delta / -240.15 * at.dosingFactor) + (extra / -240.15 * at.dosingFactor), 'oz', 'mL'));
-    //        }
-    //    }
-    //    sph.demand = dose;
-    //    return dose;
-    //}
     public async checkDosing(chem: ChemController, sph: ChemicalPhState) {
         try {
             let status = sys.board.valueMaps.chemControllerDosingStatus.getName(sph.dosingStatus);
+            logger.debug(`Begin check ${sph.chemType} dosing status = ${status}`);
             let demand = sph.calcDemand(chem);
-            //let demand = this.calcDemand(sph);
+            sph.demand = Math.max(demand, 0);
             if (sph.suspendDosing) {
                 // Kill off the dosing and make sure the pump isn't running.  Let's force the issue here.
                 await this.cancelDosing(sph, 'suspended');
@@ -1283,17 +1535,37 @@ export class NixieChemicalPh extends NixieChemical {
                 // let the system clean these up.
                 if (typeof sph.currentDose !== 'undefined') logger.error('Somehow we made it to monitoring and still have a current dose');
                 sph.currentDose = undefined;
-                this.currentMix = undefined;
                 sph.manualDosing = false;
-                sph.mixTimeRemaining = 0;
                 sph.dosingVolumeRemaining = 0;
                 sph.dosingTimeRemaining = 0;
-                await this.stopMixing(sph);
-                await this.cancelDosing(sph, 'completed');
+                if (typeof this.currentMix !== 'undefined') {
+                    if (ncp.chemControllers.length > 1) {
+                        let arrIds = [];
+                        for (let i = 0; i < ncp.chemControllers.length; i++) {
+                            arrIds.push(ncp[i].id);
+                        }
+                        logger.info(`More than one NixieChemController object was found ${JSON.stringify(arrIds)}`);
+                    }
+                    logger.debug(`We are now monitoring and have a mixing object`);
+                    await this.stopMixing(sph);
+                }
+                await this.cancelDosing(sph, 'monitoring');
             }
             if (status === 'mixing') {
-                await this.cancelDosing(sph, 'completed');
-                await this.mixChemicals(sph);
+                await this.cancelDosing(sph, 'mixing');
+                if (typeof this.currentMix === 'undefined') {
+                    // First lets check to see how many chem controllers we have.
+                    // RKS: Keep this case around in case there is another Moby Dick and Nixie has an orphan out there.
+                    //if (ncp.chemControllers.length > 1) {
+                    //    let arrIds = [];
+                    //    for (let i = 0; i < ncp.chemControllers.length; i++) {
+                    //        arrIds.push(ncp[i].id);
+                    //    }
+                    //    logger.info(`More than one NixieChemController object was found ${JSON.stringify(arrIds)}`);
+                    //}
+                    logger.info(`Current ${sph.chemType} mix object not defined initializing mix`);
+                    await this.mixChemicals(sph);
+                }
             }
             else if (sph.manualDosing) {
                 // We are manually dosing.  We are not going to dynamically change the dose.
@@ -1302,7 +1574,6 @@ export class NixieChemicalPh extends NixieChemical {
                     // Unfortunately we will lose the original start date but who cares as the volumes should remain the same.
                     let volume = sph.volumeDosed + sph.dosingVolumeRemaining;
                     let time = sph.timeDosed + sph.dosingTimeRemaining;
-                    sph.demand = sph.calcDemand(this.chemController.chem);
                     sph.startDose(new Timestamp().addSeconds(-sph.doseTime).toDate(), 'manual', volume, sph.dosingVolumeRemaining, time * 1000, sph.doseTime * 1000);
                 }
                 if (sph.tank.level > 0) {
@@ -1360,7 +1631,6 @@ export class NixieChemicalPh extends NixieChemical {
                             break;
                     }
                     logger.verbose(`Chem acid dosing maximums applied ${dose}mL for ${utils.formatDuration(time)}`);
-                    sph.demand = demand;
                     if (typeof sph.currentDose === 'undefined' && sph.tank.level > 0) {
                         // We will include this with the dose demand because our limits may reduce it.
                         //dosage.demand = demand;
@@ -1386,10 +1656,12 @@ export class NixieChemicalPh extends NixieChemical {
                         await this.cancelDosing(sph, 'empty tank');
                     }
                 }
-                return true;
             }
         }
-        catch (err) { logger.error(err); return Promise.reject(err);}
+        catch (err) { logger.error(err); return Promise.reject(err); }
+        finally {
+            logger.debug(`End check ${sph.chemType} dosing status = ${sys.board.valueMaps.chemControllerDosingStatus.getName(sph.dosingStatus)}`);
+        }
     }
     public async cancelDosing(sph: ChemicalPhState, reason: string) {
         try {
@@ -1406,11 +1678,12 @@ export class NixieChemicalPh extends NixieChemical {
                     }
                 }
             }
-            if(typeof sph.currentDose !== 'undefined') sph.endDose(new Date(), 'cancelled');
+            if (typeof sph.currentDose !== 'undefined') sph.endDose(new Date(), 'cancelled');
         } catch (err) { logger.error(`cancelDosing pH: ${err.message}`); return Promise.reject(err); }
     }
     public async manualDoseAsync(sph: ChemicalPhState, volume: number) {
         try {
+            logger.debug(`Starting manual ${sph.chemType} dose of ${volume}mL`);
             let status = sys.board.valueMaps.chemControllerDosingStatus.getName(sph.dosingStatus);
             if (status === 'monitoring') {
                 // Alright our mixing and dosing have either been cancelled or we fininsed a mixing cycle.  Either way
@@ -1439,7 +1712,7 @@ export class NixieChemicalPh extends NixieChemical {
                 await this.pump.dose(sph);
             }
         }
-        catch (err) { logger.error(`manualDoseAsync: ${err.message}`); logger.error(err); return Promise.reject(err);}
+        catch (err) { logger.error(`manualDoseAsync: ${err.message}`); logger.error(err); return Promise.reject(err); }
     }
     public async initDose(sph: ChemicalPhState) {
         try {
@@ -1466,21 +1739,24 @@ export class NixieChemicalORP extends NixieChemical {
         this.chemType = 'orp';
         this.orp = chemical;
         this.probe = new NixieChemProbeORP(this, chemical.probe);
+        this.chlor = new NixieChemChlor(this, chemical.chlor);
     }
     public get logFilename() { return `chemDosage_orp.log`; }
     public async setORPAsync(sorp: ChemicalORPState, data: any) {
         try {
             if (typeof data !== 'undefined') {
-                this.orp.useChlorinator = typeof data.useChlorinator !== 'undefined' ? utils.makeBool(data.useChlorinator) : this.orp.useChlorinator;
+                sorp.useChlorinator = this.orp.useChlorinator = typeof data.useChlorinator !== 'undefined' ? utils.makeBool(data.useChlorinator) : this.orp.useChlorinator;
                 sorp.enabled = this.orp.enabled = typeof data.enabled !== 'undefined' ? utils.makeBool(data.enabled) : this.orp.enabled;
                 sorp.level = typeof data.level !== 'undefined' && !isNaN(parseFloat(data.level)) ? parseFloat(data.level) : sorp.level;
                 this.orp.phLockout = typeof data.phLockout !== 'undefined' && !isNaN(parseFloat(data.phLockout)) ? parseFloat(data.phLockout) : this.orp.phLockout;
                 this.orp.flowReadingsOnly = typeof data.flowReadingsOnly !== 'undefined' ? utils.makeBool(data.flowReadingsOnly) : this.orp.flowReadingsOnly;
+                if (typeof data.chlorDosingMethod !== 'undefined') { this.orp.chlorDosingMethod = data.chlorDosingMethod; }
                 await this.setDosing(this.orp, data);
                 await this.setMixing(this.orp, data);
                 await this.probe.setProbeORPAsync(sorp.probe, data.probe);
                 await this.tank.setTankAsync(sorp.tank, data.tank);
                 await this.pump.setPumpAsync(sorp.pump, data.pump);
+                await this.chlor.setChlorAsync(sorp.chlor, data);
                 this.orp.setpoint = sorp.setpoint = typeof data.setpoint !== 'undefined' ? parseInt(data.setpoint, 10) : this.orp.setpoint;
                 if (typeof data.tolerance !== 'undefined') {
                     if (typeof data.tolerance.enabled !== 'undefined') this.orp.tolerance.enabled = utils.makeBool(data.tolerance.enabled);
@@ -1521,21 +1797,106 @@ export class NixieChemicalORP extends NixieChemical {
                 await this.pump.dose(sorp);
             }
         }
-        catch (err) { logger.error(`manualDoseAsync ORP: ${err.message}`); logger.error(err); return Promise.reject(err);}
+        catch (err) { logger.error(`manualDoseAsync ORP: ${err.message}`); logger.error(err); return Promise.reject(err); }
     }
-    public async cancelDosing(sorp: ChemicalORPState, reason: string) {
+    public async cancelDosing(sorp: ChemicalORPState, reason: string): Promise<void> {
         try {
-            // Just stop the pump for now but we will do some logging later.
-            await this.pump.stopDosing(sorp, reason);
+            if (typeof sorp.useChlorinator !== 'undefined' && sorp.useChlorinator && this.chemController.orp.orp.dosingMethod > 0) {
+                await this.chlor.stopDosing(sorp, reason);
+                // for chlor, we want 15 minute intervals
+                if (sorp.doseHistory.length) {
+                    // if last dose was within 15 minutes, set mix time to 15 mins-lastdose
+                    // if no dose in last 15, then we should be monitoring
+                    if (new Date().getTime() - sorp.doseHistory[0].end.getTime() <  this.chlor.chlorInterval * 60 * 1000){
+                        let lastDoseTime = sorp.doseHistory[0].timeDosed;
+                        let mixTime = Math.min(Math.max(this.chlor.chlorInterval * 60 - lastDoseTime, 0), this.chlor.chlorInterval * 60);
+                        // if (mixTime === 0) return; // due to delays with setting chlor, let the checkDosing pick up the cycle again with the chlor already on.
+                        if (sorp.dosingStatus === 0) await this.mixChemicals(sorp, mixTime);
+                    }
+                }
+                else{
+                    if (sorp.dosingStatus === 0) await this.mixChemicals(sorp);
+                }
+                return;
+            }
+            else {
+                // Just stop the pump for now but we will do some logging later.
+                await this.pump.stopDosing(sorp, reason);
+            }
             if (sorp.dosingStatus === 0) {
                 await this.mixChemicals(sorp);
                 sorp.endDose(new Date(), 'cancelled');
             }
         } catch (err) { logger.error(`cancelDosing ORP: ${err.message}`); return Promise.reject(err); }
     }
-    public async checkDosing(chem: ChemController, sorp: ChemicalORPState) {
+    protected async initMixChemicals(schem: ChemicalState, mixingTime?: number): Promise<void> {
+        try {
+            if (this._stoppingMix) return;
+            if (typeof this.currentMix === 'undefined' || (typeof this.currentMix !== 'undefined' && isNaN(this.currentMix.timeMixed))) {
+                if (typeof mixingTime !== 'undefined') {
+                    // This is a manual mix so we need to make sure the pump is not dosing.
+                    logger.info(`Clearing any possible ${schem.chemType} dosing or existing mix for mixingTime: ${mixingTime}`);
+                    if (schem.chemController.orp.useChlorinator) await this.chlor.stopDosing(schem, 'mix override');
+                    else await this.pump.stopDosing(schem, 'mix override');
+                    await this.stopMixing(schem);
+                }
+                this.currentMix = new NixieChemMix();
+                if (typeof mixingTime !== 'undefined' && !isNaN(mixingTime)) {
+                    this.currentMix.set({ time: Math.round(mixingTime), timeMixed: 0, isManual: true });
+                    schem.manualMixing = true;
+                }
+                else if (schem.mixTimeRemaining > 0) {
+                    if (schem.manualMixing) {
+                        this.currentMix.set({ time: schem.mixTimeRemaining, timeMixed: 0, isManual: true });
+                    }
+                    else
+                        if (typeof this.chemController.orp.orp.useChlorinator !== 'undefined' && this.chemController.orp.orp.useChlorinator && this.chemController.orp.orp.dosingMethod > 0) {
+                            // if last dose was within 15 minutes, set mix time to 15 mins-(now-lastdose)
+                            // if no dose in last 15, then we should be monitoring
+                            await this.chlor.stopDosing(schem, 'mix override'); // ensure chlor has stopped
+                            if (schem.doseHistory.length) {
+                                // if last dose was within 15 minutes, set mix time to 15 mins-lastdose
+                                // if no dose in last 15, then we should be monitoring
+                                let lastDoseTime = schem.doseHistory[0].timeDosed;
+                                let mixTime = Math.min(Math.max(this.chlor.chlorInterval * 60 - lastDoseTime, 0), this.chlor.chlorInterval * 60);
+                                // if (mixTime === 0) return; // due to delays in the setting the chlor, if we had a full dose last time let the chlor continue
+                                this.currentMix.set({ time: this.chlor.chlorInterval, timeMixed: Math.max(0, mixTime - schem.mixTimeRemaining) });
+                            }
+                            else
+                                // if no dose history, mix for 0s
+                                // this.currentMix.set({ time: this.chemical.mixingTime, timeMixed: Math.max(0, (this.chlor.chlorInterval * 60) - schem.mixTimeRemaining) });
+                                this.currentMix.set({ time: 0, timeMixed: 0 });
+                        }
+                        else {
+                            this.currentMix.set({ time: this.chemical.mixingTime, timeMixed: Math.max(0, this.chemical.mixingTime - schem.mixTimeRemaining) });
+                        }
+                }
+                else
+                    if (typeof this.chemController.orp.orp.useChlorinator !== 'undefined' && this.chemController.orp.orp.useChlorinator && this.chemController.orp.orp.dosingMethod > 0)
+                        this.currentMix.set({ time: this.chlor.chlorInterval * 60, timeMixed: 0 });
+                    else
+                        this.currentMix.set({ time: this.chemical.mixingTime, timeMixed: 0 });
+                logger.info(`Chem Controller begin mixing ${schem.chemType} for ${utils.formatDuration(this.currentMix.timeRemaining)} of ${utils.formatDuration(this.currentMix.time)}`)
+                schem.mixTimeRemaining = this.currentMix.timeRemaining;
+            }
+            if (typeof this._mixTimer === 'undefined' || !this._mixTimer) {
+                let self = this;
+                this._mixTimer = setInterval(async () => { await self.mixChemicals(schem); }, 1000);
+                logger.verbose(`Set ${schem.chemType} mix timer`);
+            }
+        } catch (err) { logger.error(`Error initializing ${schem.chemType} mix: ${err.message}`); }
+    }
+    public async checkDosing(chem: ChemController, sorp: ChemicalORPState): Promise<void> {
         try {
             let status = sys.board.valueMaps.chemControllerDosingStatus.getName(sorp.dosingStatus);
+            if (!chem.orp.flowReadingsOnly || (chem.orp.flowReadingsOnly && sorp.chemController.flowDetected)) {
+                // demand in raw mV
+                sorp.demand = this.orp.setpoint - sorp.level;
+                // log the demand.  We'll store the last 100 data points.  
+                // With 1s intervals, this will only be 1m 40s.  Likely should consider more... and def time to move this to an external file.
+                sorp.appendDemand(new Date().valueOf(), sorp.demand);
+            }
+            if (chem.orp.useChlorinator && chem.orp.chlorDosingMethod === 0) return; // if chlor is managing itself, don't even cancel/stop as it will set the flags on the chlor
             if (sorp.suspendDosing) {
                 // Kill off the dosing and make sure the pump isn't running.  Let's force the issue here.
                 await this.cancelDosing(sorp, 'suspended');
@@ -1550,10 +1911,10 @@ export class NixieChemicalORP extends NixieChemical {
                 sorp.dosingVolumeRemaining = 0;
                 sorp.dosingTimeRemaining = 0;
                 await this.stopMixing(sorp);
-                await this.cancelDosing(sorp, 'unknown cancel');
+                await this.cancelDosing(sorp, 'monitoring');
             }
             if (status === 'mixing') {
-                await this.cancelDosing(sorp, 'completed');
+                await this.cancelDosing(sorp, 'mixing');
                 await this.mixChemicals(sorp);
             }
             else if (sorp.manualDosing) {
@@ -1573,74 +1934,224 @@ export class NixieChemicalORP extends NixieChemical {
                 }
                 else await this.cancelDosing(sorp, 'empty tank');
             }
-            else if (sorp.dailyLimitReached) {
+            else if (sorp.dailyLimitReached && !chem.orp.useChlorinator) {
                 await this.cancelDosing(sorp, 'daily limit');
             }
-            else if (status === 'monitoring' || status === 'dosing' && !this.orp.useChlorinator) {
-                let dose = 0;
-                if (this.orp.setpoint > sorp.level && !sorp.lockout) {
-                    // Calculate how many mL are required to raise to our ORP level.
+            // if the ph pump is dosing and dosePriority is enabled, do not dose
+            else if (sorp.chemController.ph.pump.isDosing && chem.ph.dosePriority) {
+                await this.cancelDosing(sorp, 'ph pump dosing + dose priority');
+                return;
+            }
+            else if (status === 'monitoring' || status === 'dosing') {
+                // let _doseCalculatedSec = 0;
+                if (!sorp.lockout) {
+
                     // 1. Get the total gallons of water that the chem controller is in control of.
                     let totalGallons = 0;
-                    if (chem.body === 0 || chem.body === 32) totalGallons += sys.bodies.getItemById(1).capacity;
-                    if (chem.body === 1 || chem.body === 32) totalGallons += sys.bodies.getItemById(2).capacity;
+                    let body1 = sys.bodies.getItemById(1);
+                    let body2 = sys.bodies.getItemById(2);
+                    if (chem.body === 0 || chem.body === 32) totalGallons += body1.capacity;
+                    if (chem.body === 1 || chem.body === 32) totalGallons += body2.capacity;
                     if (chem.body === 2) totalGallons += sys.bodies.getItemById(3).capacity;
                     if (chem.body === 3) totalGallons += sys.bodies.getItemById(4).capacity;
-                    let pump = this.pump.pump;
-                    let demand = dose = Math.round(utils.convert.volume.convertUnits(0, 'oz', 'mL'));
-                    let time = typeof pump.ratedFlow === 'undefined' || pump.ratedFlow <= 0 ? 0 : Math.round(dose / (pump.ratedFlow / 60));
-                    let meth = sys.board.valueMaps.chemDosingMethods.getName(this.orp.dosingMethod);
-                    // Now that we know our chlorine demand we need to adjust this dose based upon the limits provided in the setup.
-                    switch (meth) {
-                        case 'time':
-                            time = this.orp.maxDosingTime;
-                            dose = typeof pump.ratedFlow === 'undefined' ? 0 : Math.round(time * (this.pump.pump.ratedFlow / 60));
-                            break;
-                        case 'volume':
-                            dose = this.orp.maxDosingVolume;
-                            time = time = typeof pump.ratedFlow === 'undefined' || pump.ratedFlow <= 0 ? 0 : Math.round(dose / (pump.ratedFlow / 60));
-                            break;
-                        case 'volumeTime':
-                        default:
-                            // This is maybe a bit dumb as the volume and time should equal out for the rated flow.  In other words
-                            // you will never get to the volume limit if the rated flow can't keep up to the time.
-                            if (dose > this.orp.maxDosingVolume) {
-                                dose = this.orp.maxDosingVolume;
-                                time = time = typeof pump.ratedFlow === 'undefined' || pump.ratedFlow <= 0 ? 0 : Math.round(dose / (pump.ratedFlow / 60));
+
+                    if (chem.orp.useChlorinator) {
+                        /*
+            Alright, here's the current thinking.
+            1. If the orp setpoint is > 50mV below the current orp, the chlor will
+            be run at 100%.
+            2. At the other end, if the demand is  < -20mV above the setpoint, chlor
+            will be run at 0%.
+            3. This assumes a sliding scale where we will have an equilibrium point when
+            setpoint = current orp and hopefully this will be somewhere near (50-20 / 100) = ~30% of time the chlor is on
+             
+            Thoughts from @rstrouste
+            Volume -- Check
+            Delivery Rate -- IC40, IC60, IC20 and IC30 all have different production rates in pounds/day.  The pounds are Sodium Hypochlorite which translates into Hypochlorous acid (HOCl) + Hypochlorite (OCI-).  The former is stronger and the amount of this that is produced is based upon, temperature, pH, and CYA with pH within range being irrelevant (hence the reason for pH lockout).
+             
+             
+            Additional future factors to consider-
+            * If temp is below 65(?), the chlor won't be producing any chlorine.  Throw a warning/error?
+            * If salt level is too low/high it will cause issues.  Warning/error?
+            * Adjust chlor output if it is under/oversized for the total gallons
+            */
+                        // if we are still mixing, return
+                        if (typeof sorp.mixTimeRemaining !== 'undefined' && sorp.mixTimeRemaining > 0) {
+                            await this.cancelDosing(sorp, 'still mixing');
+                            return;
+                        }
+                        // Old fashion method; let the setpoints on chlor be the master
+                        // if (chem.orp.chlorDosingMethod === 0) return;
+                        // if there is a current pending dose, finish it out
+                        if (typeof sorp.currentDose === 'undefined') {
+                            if (sorp.dosingStatus === 0) { // 0 is dosing
+                                // We need to finish off a dose that was interrupted by regular programming.  This occurs
+                                // when for instance njspc is interrupted and restarted in the middle of a dose. If we were
+                                // mixing before we will never get here.
+                                if (typeof sorp.currentDose === 'undefined')
+                                    sorp.startDose(new Timestamp().addSeconds(-sorp.doseTime).toDate(), 'auto', sorp.doseVolume + sorp.dosingVolumeRemaining, sorp.doseVolume, (sorp.doseTime + sorp.dosingTimeRemaining) * 1000, sorp.doseTime * 1000);
+                                await this.chlor.dose(sorp);
+                                return;
                             }
-                            if (time > this.orp.maxDosingTime) {
-                                time = this.orp.maxDosingTime;
-                                dose = typeof pump.ratedFlow === 'undefined' ? 0 : Math.round(time * (this.pump.pump.ratedFlow / 60));
+                        }
+
+
+                        let chlor = sys.chlorinators.getItemById(1); // Still haven't seen any systems with 2+ chlors
+                        let schlor = state.chlorinators.getItemById(1);
+                        // If someone or something is superchloring the pool, let it be
+                        if (schlor.superChlor) return;
+                        // Let's have some fun trying to figure out a dynamic approach to chlor management
+                        let body = sys.board.bodies.getBodyState(this.chemController.chem.body);
+                        let adj = 1;
+                        if (typeof body !== 'undefined' && totalGallons > 0 && sys.bodies.length > 1) {
+                            // Intellichem scales down dosing based on the spa being on
+                            // vs the pool.  May be interesting to experiment with.
+                            let type = sys.board.valueMaps.bodyTypes.getName(body.type);
+                            switch (type) {
+                                case "pool":
+                                case "pool/spa":
+                                    // normal dosing
+                                    break;
+                                default:
+                                    // case "spa":
+                                    // adjust dosing down to the amount of the smaller body
+                                    adj -= Math.abs((body1.capacity - body2.capacity) / Math.max(body1.capacity, body2.capacity));
+                                    break;
                             }
-                            break;
-                    }
-                    logger.info(`Chem orp dose calculated ${dose}mL for ${utils.formatDuration(time)} Tank Level: ${sorp.tank.level} using ${meth}`);
+                        }
+                        let model = sys.board.valueMaps.chlorinatorModel.findItem(chlor.model);
+                        if (typeof model === 'undefined' || model === 0) return Promise.reject(new EquipmentNotFoundError(`Please specify a chlorinator model to allow Nixie to calculate chlorine demand`, `chlorinator`));
+                        // if we want to adjust for over/under sized chlorinator we can do so here
+                        // if (typeof model !== 'undefined' && model.capacity > 0) {
+                        //     adj *= totalGallons / model.capacity;
+                        // }
 
-                    sorp.demand = sorp.calcDemand(chem);
-                    if (typeof sorp.currentDose === 'undefined') {
-                        // We will include this with the dose demand because our limits may reduce it.
-                        //dosage.demand = demand;
-                        if (sorp.dosingStatus === 0) { // 0 is dosing.
-                            // We need to finish off a dose that was interrupted by regular programming.  This occurs
-                            // when for instance njspc is interrupted and restarted in the middle of a dose. If we were
-                            // mixing before we will never get here.
-                            if (typeof sorp.currentDose === 'undefined')
-                                sorp.startDose(new Timestamp().addSeconds(-sorp.doseTime).toDate(), 'auto', sorp.doseVolume + sorp.dosingVolumeRemaining, sorp.doseVolume, (sorp.doseTime + sorp.dosingTimeRemaining) * 1000, sorp.doseTime * 1000);
+                        // unlike ph/orp tank dosing, we are using 15 min intervals so if there is an existing dose then continue
+                        if (typeof sorp.currentDose !== 'undefined' && sorp.currentDose.volumeRemaining > 0) {
+                            await this.chlor.dose(sorp);
+                            return;
+                        }
+
+                        // We could store these data points in a separate file like the dosing logs.
+                        let percentOfTime = 0;
+                        if (sorp.demand > 50) {
+                            logger.info(`Chlor demand  ${sorp.demand} > 50;  % of time set to 100%.`);
+                            percentOfTime = 1;
+                        }
+                        else if (sorp.demand < -20) {
+                            await this.cancelDosing(sorp, 'demand < -20');
+                        }
+                        else {
+                            // y=mx+b; m = 100/70; b = 100-(50*100/70) = 28.57
+                            // let's start with a straight line
+                            let b = 100 - (50 * 100 / 70);
+                            percentOfTime = ((100 / 70) * sorp.demand * adj + b) / 100;
+                            logger.info(`Chlor trend line is ${sorp.demandHistory.slope}.`);
+                            if (sorp.demandHistory.slope > 5 && sorp.demand < 0) {
+                                // need less chlorine, but we're getting there too fast
+                                // slope is high; turn down dose
+                                percentOfTime *= .5;
+                            }
+                            else if (sorp.demandHistory.slope < 5 && sorp.demand > 0) {
+                                // need more chlorine, but we aren't getting there fast enough
+                                // slope is too low, turn up dose
+                                percentOfTime *= 1.1;
+                            }
+                            else if (sorp.demandHistory.slope > 0 && sorp.demand > 0) {
+                                // chlorine is increasing, but we need less of it
+                                percentOfTime *= .5;
+                            }
+                            else if (sorp.demandHistory.slope < 0 && sorp.demand > 0) {
+                                // chlorine is decreasing, but we need more
+                                percentOfTime *= 1.1;
+                            }
+                            percentOfTime = Math.min(1, Math.max(0, percentOfTime));
+                            logger.info(`Chlor dosing % of time is ${Math.round(percentOfTime * 10000) / 100}%`)
                         }
-                        else
+
+                        // convert the % of time back to an amount of chlorine over 15 minutes; 
+                        let time = this.chlor.chlorInterval * 60 * percentOfTime;
+                        let dose = model.chlorinePerSec * time;
+                        
+                        if (dose > 0) {
+                            logger.info(`Chem chlor calculated dosing at ${Math.round(percentOfTime * 10000) / 100}% and will dose ${Math.round(dose * 1000000) / 1000000}Lbs of chlorine over the next ${utils.formatDuration(time)}.`)
                             sorp.startDose(new Date(), 'auto', dose, 0, time, 0);
+                            await this.chlor.dose(sorp);
+                            return;
+                        }
+
+                        // if none of the other conditions are true, mix
+                        // await this.mixChemicals(sorp, this.chlor.chlorInterval * 60);
+
                     }
-                    // Now let's determine what we need to do with our pump to satisfy our acid demand.
-                    if (sorp.tank.level > 0) {
-                        await this.pump.dose(sorp);
+                    else if (this.orp.setpoint > sorp.level) {
+                        let pump = this.pump.pump;
+                        // Calculate how many mL are required to raise to our ORP level.
+                        let demand = Math.round(utils.convert.volume.convertUnits(0, 'oz', 'mL'));
+                        let time = typeof pump.ratedFlow === 'undefined' || pump.ratedFlow <= 0 ? 0 : Math.round(demand / (pump.ratedFlow / 60));
+                        let meth = sys.board.valueMaps.chemDosingMethods.getName(this.orp.dosingMethod);
+                        // Now that we know our chlorine demand we need to adjust this dose based upon the limits provided in the setup.
+                        switch (meth) {
+                            case 'time':
+                                time = this.orp.maxDosingTime;
+                                demand = typeof pump.ratedFlow === 'undefined' ? 0 : Math.round(time * (this.pump.pump.ratedFlow / 60));
+                                break;
+                            case 'volume':
+                                demand = this.orp.maxDosingVolume;
+                                time = typeof pump.ratedFlow === 'undefined' || pump.ratedFlow <= 0 ? 0 : Math.round(demand / (pump.ratedFlow / 60));
+                                break;
+                            case 'volumeTime':
+                            default:
+                                // This is maybe a bit dumb as the volume and time should equal out for the rated flow.  In other words
+                                // you will never get to the volume limit if the rated flow can't keep up to the time.
+                                if (demand > this.orp.maxDosingVolume) {
+                                    demand = this.orp.maxDosingVolume;
+                                    time = typeof pump.ratedFlow === 'undefined' || pump.ratedFlow <= 0 ? 0 : Math.round(demand / (pump.ratedFlow / 60));
+                                }
+                                if (time > this.orp.maxDosingTime) {
+                                    time = this.orp.maxDosingTime;
+                                    demand = typeof pump.ratedFlow === 'undefined' ? 0 : Math.round(time * (this.pump.pump.ratedFlow / 60));
+                                }
+                                break;
+                        }
+                        logger.info(`Chem orp dose calculated ${demand}mL for ${utils.formatDuration(time)} Tank Level: ${sorp.tank.level} using ${meth}`);
+
+                        sorp.demand = sorp.calcDemand(chem);
+                        if (sorp.demand > 0) logger.info(`Chem orp dose calculated ${demand}mL for ${utils.formatDuration(time)} Tank Level: ${sorp.tank.level} using ${meth}`);
+
+                        if (typeof sorp.currentDose === 'undefined') {
+                            // We will include this with the dose demand because our limits may reduce it.
+                            //dosage.demand = demand;
+                            if (sorp.dosingStatus === 0) { // 0 is dosing.
+                                // We need to finish off a dose that was interrupted by regular programming.  This occurs
+                                // when for instance njspc is interrupted and restarted in the middle of a dose. If we were
+                                // mixing before we will never get here.
+                                if (typeof sorp.currentDose === 'undefined')
+                                    sorp.startDose(new Timestamp().addSeconds(-sorp.doseTime).toDate(), 'auto', sorp.doseVolume + sorp.dosingVolumeRemaining, sorp.doseVolume, (sorp.doseTime + sorp.dosingTimeRemaining) * 1000, sorp.doseTime * 1000);
+                            }
+                            else
+                                sorp.startDose(new Date(), 'auto', demand, 0, time, 0);
+                        }
+                        // Now let's determine what we need to do with our pump to satisfy our acid demand.
+                        if (sorp.tank.level > 0) {
+                            await this.pump.dose(sorp);
+                        }
+                        else await this.cancelDosing(sorp, 'empty tank');
                     }
-                    else await this.cancelDosing(sorp, 'empty tank');
                 }
                 else
                     await this.cancelDosing(sorp, 'unknown cancel');
             }
         }
-        catch (err) { logger.error(`checkDosing ORP: ${err.message}`); return Promise.reject(err);}
+        catch (err) { logger.error(`checkDosing ORP: ${err.message}`); return Promise.reject(err); }
+    }
+    public async deleteChlorAsync(chlor: NixieChlorinator) {
+        logger.info(`Removing chlor ${chlor.id} from Chem Controller ${this.getParent().id}`);
+        let schem = state.chemControllers.getItemById(this.getParent().id);
+        this.orp.useChlorinator = false;
+        schem.orp.useChlorinator = false;
+        if (schem.orp.dosingStatus === 0) { await this.cancelDosing(schem.orp, 'deleting chlorinator'); }
+        if (schem.orp.dosingStatus === 1) { await this.cancelMixing(schem.orp); }
     }
 }
 class NixieChemProbe extends NixieChildEquipment {
@@ -1695,7 +2206,7 @@ export class NixieChemProbePh extends NixieChemProbe {
                     // Set the current body so that it references the temperature of the current running body.
                     let body = sys.board.bodies.getBodyState(this.chemical.chemController.chem.body);
                     if (typeof body !== 'undefined' && body.isOn) {
-                        let units = sys.board.valueMaps.tempUnits.transform(sys.general.options.units);
+                        let units = sys.board.valueMaps.tempUnits.transform(state.temps.units);
                         let obj = {};
                         obj[`temp${units.name.toUpperCase()}`] = body.temp;
                         sprobe.tempUnits = units.val;
@@ -1721,7 +2232,7 @@ export class NixieChemProbePh extends NixieChemProbe {
                 deviceBinding: this.probe.deviceBinding,
                 eventName: "chemController",
                 property: "pHLevel",
-                sendValue: 'pH',
+                sendValue: 'all',
                 isActive: data.remFeedEnabled,
                 sampling: 1,
                 changesOnly: false,
@@ -1729,7 +2240,7 @@ export class NixieChemProbePh extends NixieChemProbe {
             }
             let res = await NixieChemController.putDeviceService(this.probe.connectionId, '/config/feed', d);
             if (res.status.code === 200) { this.probe.remFeedEnabled = data.remFeedEnabled; }
-            else { logger.warn(`setRemoteREMFeed: Cannot set remote feed. Message:${JSON.stringify(res.status)} for feed: ${JSON.stringify(d)}.`); return Promise.reject(`Cannot set REM feed for pH probe: ${JSON.stringify(res)}.`); }
+            else { logger.warn(`setRemoteREMFeed: Cannot set remote feed. Message:${JSON.stringify(res.status)} for feed: ${JSON.stringify(d)}.`); }
         }
         catch (err) { logger.error(`setRemoteREMFeed: ${err.message}`); return Promise.reject(err); }
     }
@@ -1812,9 +2323,15 @@ export class NixieChemProbeORP extends NixieChemProbe {
             }
             let res = await NixieChemController.putDeviceService(this.probe.connectionId, '/config/feed', d);
             if (res.status.code === 200) { this.probe.remFeedEnabled = data.remFeedEnabled; }
-            else { logger.warn(`setRemoteREMFeed: Cannot set remote feed. Message:${JSON.stringify(res.status)} for feed: ${JSON.stringify(d)}.`); return Promise.reject(new InvalidOperationError(`Nixie could not set remote REM feed for the ORP probe.`, this.probe.dataName)); }
+            else {
+                logger.warn(`setRemoteREMFeed: Cannot set remote feed. Message:${JSON.stringify(res.status)} for feed: ${JSON.stringify(d)}.`);
+                // return Promise.reject(new InvalidOperationError(`Nixie could not set remote REM feed for the ORP probe.`, this.probe.dataName));
+            }
+        }
+        catch (err) {
+            logger.error(`setRemoteREMFeed: ${err.message}`);
+            //return Promise.reject(err); // don't muck up chem controller if we can't set the feeds.
         }
-        catch (err) { logger.error(`setRemoteREMFeed: ${err.message}`); return Promise.reject(err); }
     }
     public syncRemoteREMFeeds(chem: ChemController, servers) {
         // match any feeds and store the id/statusf