nodejs-poolcontroller 7.3.0 → 7.6.0

package/controller/nixie/chemistry/ChemController.ts

@@ -6,9 +6,10 @@ 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, ChemicalDoseState, ChemicalORPState, ChemicalPhState, ChemicalProbeORPState, ChemicalProbePHState, ChemicalProbeState, ChemicalPumpState, ChemicalState, ChemicalTankState, ChlorinatorState, state } from "../../State";
+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> {
@@ -50,7 +51,7 @@ 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 {
@@ -72,9 +73,11 @@ export class NixieChemControllerCollection extends NixieEquipmentCollection<Nixi
             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}`);
                     // 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);
                     }
@@ -98,6 +101,19 @@ export class NixieChemControllerCollection extends NixieEquipmentCollection<Nixi
 
         } catch (err) { } // Don't bail if we have an error
     }
+    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) { logger.error(`ncp.deleteChlorAsync: ${err.message}`); return Promise.reject(err); }
+    }
     // This is currently not used for anything.
     /*     public async searchIntelliChem(): Promise<number[]> {
             let arr = [];
@@ -145,12 +161,10 @@ export class NixieChemControllerBase extends NixieEquipment {
     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.
         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:
@@ -194,7 +208,7 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
             }
         }
         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 self.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 {
@@ -203,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;
@@ -543,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;
                 }
@@ -584,7 +599,6 @@ 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.processAlarms(schem);
@@ -596,15 +610,10 @@ export class NixieChemController extends NixieChemControllerBase {
             }
             this._ispolling = false;
         }
-        catch (err) { this._ispolling = false; logger.error(`Error polling Chem Controller - ${err}`); return Promise.reject(err); }
+        catch (err) { this._ispolling = false; logger.error(`Error polling Chem Controller - ${err}`); }
         finally {
             if (!this.closing && !this._ispolling)
-                this._pollTimer = setTimeout(async () => {
-                    try { await self.pollEquipmentAsync() } catch (err) {
-                        //return Promise.reject(err); 
-                        logger.error(err);
-                    }
-                }, this.pollingInterval || 10000);
+                this._pollTimer = setTimeout(() => { self.pollEquipmentAsync(); }, this.pollingInterval || 10000);
             logger.verbose(`End polling Chem Controller ${this.id}`);
         }
     }
@@ -963,10 +972,9 @@ class NixieChemical extends NixieChildEquipment {
             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){
-                    await this.chlor.stopDosing(schem, 'mixing');
+                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)} `);
+                        logger.debug(`Chem mixing ORP (chlorinator) paused waiting for chlor current output to be 0%.  Mix time remaining: ${utils.formatDuration(schem.mixTimeRemaining)} `);
                         return;
                     }
                 }
@@ -1283,20 +1291,17 @@ export class NixieChemChlor extends NixieChildEquipment {
     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 !== 'undefined') {
-                    // this.chlor.enabled = typeof data.useChlorinator !== 'undefined' ? data.useChlorinator : this.chlor.enabled;
-                    // let's grab the chlor type from the one installed
-                    let chlor = sys.chlorinators.getItemById(1);
-                    let chlorModel = sys.board.valueMaps.chlorinatorModel.get(chlor.type);
-                    // this.chlor.type = typeof chlor.type !== 'undefined' ? chlor.type : this.chlor.type;
-                    // this.chlor.ratedLbs = typeof chlorModel.chlorModelinePerSec !== 'undefined' ? chlorModel.chlorinePerSec : this.chlor.ratedLbs;
-                    // this.chlor.connectionId = typeof data.connectionId !== 'undefined' ? data.connectionId : this.chlor.connectionId;
-                    // this.chlor.deviceBinding = typeof data.deviceBinding !== 'undefined' ? data.deviceBinding : this.chlor.deviceBinding;
-                }
-            } catch (err) { logger.error(`setChlorAsync: ${err.message}`); return Promise.reject(err); }
-        } */
+    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) {
@@ -1368,7 +1373,7 @@ export class NixieChemChlor extends NixieChildEquipment {
                     try {
                         await this.turnOn(schem);
                         if (schlor.currentOutput !== 100) {
-                            logger.error(`Chlor dose not added because current output is not 100%`);
+                            logger.warn(`Chlor dose not added because current output is not 100%`);
                         }
                         else {
                             if (typeof dose._lastLatch !== 'undefined') {
@@ -1419,18 +1424,15 @@ export class NixieChemChlor extends NixieChildEquipment {
     }
     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 && schlor.poolSetpoint === 0 && schlor.spaSetpoint === 0 && !chlor.isDosing) {
+            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,
-                poolSetpoint: 0,
-                spaSetpoint: 0,
-                superChlor: false,
-                superChlorHours: 0,
                 disabled: true,
                 isDosing: false
             })
@@ -1443,20 +1445,12 @@ export class NixieChemChlor extends NixieChildEquipment {
         try {
             let chlor = sys.chlorinators.getItemById(1);
             let schlor = state.chlorinators.getItemById(1);
-            let chem = schem.chemController;
-            let poolSetpoint: number = 0, spaSetpoint: number = 0;
-            if (chem.body === 0 || chem.body === 32) poolSetpoint = 100;
-            if (chem.body === 1 || chem.body === 32) spaSetpoint = 100;
-            if (schlor.currentOutput === 100 && schlor.targetOutput === 100 && !schlor.superChlor && !chlor.disabled && schlor.poolSetpoint === poolSetpoint && schlor.spaSetpoint === spaSetpoint && chlor.isDosing) {
+            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,
-                poolSetpoint,
-                spaSetpoint,
-                superChlor: false,
-                superChlorHours: 0,
                 disabled: false,
                 isDosing: true
             })
@@ -1512,7 +1506,7 @@ 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 || sorp.chlor.isDosing) await this.chemController.orp.cancelDosing(sorp, 'pH priority');
@@ -1756,24 +1750,13 @@ export class NixieChemicalORP extends NixieChemical {
                 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;
-                this.orp.chlorDosingMethod = typeof data.chlorDosingMethod !== 'undefined' ? data.chlorDosingMethod : this.orp.chlorDosingMethod;
-                // if dynamically calculating the chlor dose, set the chlor body assoc
-                // to the same as REM chem (dP will lock this out)
-                let schlor = state.chlorinators.getItemById(1);
-                /*                 if (this.orp.chlorDosingMethod > 0) {
-                                    let chlor = sys.chlorinators.getItemById(1);
-                                    chlor.body = this.chemController.chem.body;
-                                    schlor.lockSetpoints = true;
-                                }
-                                else {
-                                    schlor.lockSetpoints = false;
-                                } */
+                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);
+                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);
@@ -1812,7 +1795,7 @@ export class NixieChemicalORP extends NixieChemical {
             if (sorp.tank.level > 0) {
                 logger.verbose(`Chem orp dose activate pump ${this.pump.pump.ratedFlow}mL/min`);
                 await this.pump.dose(sorp);
-            } 
+            }
         }
         catch (err) { logger.error(`manualDoseAsync ORP: ${err.message}`); logger.error(err); return Promise.reject(err); }
     }
@@ -1824,12 +1807,17 @@ export class NixieChemicalORP extends NixieChemical {
                 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
-                    let lastDoseTime = sorp.doseHistory[0].timeDosed;
-                    let mixTime = Math.min(Math.max(this.chlor.chlorInterval * 60 - lastDoseTime, 0), this.chlor.chlorInterval * 60);
-                    if (sorp.dosingStatus === 0) await this.mixChemicals(sorp, mixTime);
+                    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
+                else{
                     if (sorp.dosingStatus === 0) await this.mixChemicals(sorp);
+                }
+                return;
             }
             else {
                 // Just stop the pump for now but we will do some logging later.
@@ -1871,6 +1859,7 @@ export class NixieChemicalORP extends NixieChemical {
                                 // 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
@@ -1899,14 +1888,15 @@ export class NixieChemicalORP extends NixieChemical {
     }
     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)){   
+            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');
@@ -1991,7 +1981,7 @@ export class NixieChemicalORP extends NixieChemical {
                             return;
                         }
                         // Old fashion method; let the setpoints on chlor be the master
-                        if (chem.orp.chlorDosingMethod === 0) return;
+                        // 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
@@ -2049,7 +2039,6 @@ export class NixieChemicalORP extends NixieChemical {
                             percentOfTime = 1;
                         }
                         else if (sorp.demand < -20) {
-                            logger.info(`Chlor % of time should be 0%`)
                             await this.cancelDosing(sorp, 'demand < -20');
                         }
                         else {
@@ -2083,16 +2072,16 @@ export class NixieChemicalORP extends NixieChemical {
                         // 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;
-                        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)}.`)
-
+                        
                         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);
+                        // await this.mixChemicals(sorp, this.chlor.chlorInterval * 60);
 
                     }
                     else if (this.orp.setpoint > sorp.level) {
@@ -2156,6 +2145,14 @@ export class NixieChemicalORP extends NixieChemical {
         }
         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 {
     constructor(parent: NixieChemical) { super(parent); }
@@ -2209,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;
@@ -2235,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,
@@ -2243,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); }
     }
@@ -2326,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

package/controller/nixie/chemistry/Chlorinator.ts

@@ -9,6 +9,7 @@ import { setTimeout, clearTimeout } from 'timers';
 import { webApp, InterfaceServerResponse } from "../../../web/Server";
 import { Outbound, Protocol, Response } from '../../comms/messages/Messages';
 import { conn } from '../../comms/Comms';
+import { ncp } from '../Nixie';
 
 export class NixieChlorinatorCollection extends NixieEquipmentCollection<NixieChlorinator> {
     public async deleteChlorinatorAsync(id: number) {
@@ -18,6 +19,7 @@ export class NixieChlorinatorCollection extends NixieEquipmentCollection<NixieCh
             for (let i = this.length - 1; i >= 0; i--) {
                 let c = this[i];
                 if (c.id === id) {
+                    await ncp.chemControllers.deleteChlorAsync(c as NixieChlorinator);
                     await c.closeAsync();
                     this.splice(i, 1);
                 }
@@ -75,7 +77,6 @@ export class NixieChlorinator extends NixieEquipment {
     private _pollTimer: NodeJS.Timeout = null;
     private superChlorinating: boolean = false;
     private superChlorStart: number = 0;
-    private chlorinating: boolean = false;
     public chlor: Chlorinator;
     public bodyOnTime: number;
     protected _suspendPolling: number = 0;
@@ -101,7 +102,7 @@ export class NixieChlorinator extends NixieEquipment {
             let superChlorHours = typeof data.superChlorHours !== 'undefined' ? parseInt(data.superChlorHours, 10) : chlor.superChlorHours;
             let disabled = typeof data.disabled !== 'undefined' ? utils.makeBool(data.disabled) : chlor.disabled;
             let isDosing = typeof data.isDosing !== 'undefined' ? utils.makeBool(data.isDosing) : chlor.isDosing;
-            let model = typeof data.model !== 'undefined' ? data.model : chlor.model;
+            let model = typeof data.model !== 'undefined' ? data.model : chlor.model || 0;
             if (typeof body === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Invalid body assignment`, 'chlorinator', data.body || chlor.body));
             if (isNaN(poolSetpoint)) poolSetpoint = 0;
             if (isNaN(spaSetpoint)) spaSetpoint = 0;
@@ -113,9 +114,8 @@ export class NixieChlorinator extends NixieEquipment {
             schlor.superChlor = chlor.superChlor = superChlor;
             schlor.superChlorHours = chlor.superChlorHours = superChlorHours;
             schlor.type = chlor.type = chlorType;
-            chlor.body = body;
             chlor.model = model;
-            schlor.body = chlor.body;
+            schlor.body = chlor.body = body.val;
             chlor.disabled = disabled;
             chlor.isDosing = isDosing;
             schlor.name = chlor.name = data.name || chlor.name || `Chlorinator ${chlor.id}`;
@@ -178,7 +178,7 @@ export class NixieChlorinator extends NixieEquipment {
             // Comms failure will be handeled by the message processor.
             logger.error(`Chlorinator ${this.chlor.name} comms failure: ${err.message}`);
         }
-        finally { if(!this.closing) this._pollTimer = setTimeout(async () => { await self.pollEquipment(); }, this.pollingInterval); }
+        finally { if(!this.closing) this._pollTimer = setTimeout(() => {self.pollEquipment();}, this.pollingInterval); }
     }
     public async takeControl(): Promise<boolean> {
         try {
@@ -230,7 +230,7 @@ export class NixieChlorinator extends NixieEquipment {
             let setpoint = 0;
             if (typeof body !== 'undefined') {
                 setpoint = (body.id === 1) ? this.chlor.poolSetpoint : this.chlor.spaSetpoint;
-                if (this.chlor.superChlor === true) setpoint = 100;
+                if (this.chlor.superChlor === true || this.chlor.isDosing) setpoint = 100;
                 if (this.chlor.disabled === true) setpoint = 0; // Our target should be 0 because we have other things going on.  For instance,
                 // we may be dosing acid which will cause the disabled flag to be true.
             }
@@ -251,7 +251,6 @@ export class NixieChlorinator extends NixieEquipment {
                     onAbort: () => {},
                     onComplete: (err) => {
                         if (err) {
-                            this.chlorinating = false;
                             cstate.currentOutput = 0;
                             cstate.status = 128;
                             resolve(false);
@@ -260,7 +259,6 @@ export class NixieChlorinator extends NixieEquipment {
                             // The action:17 message originated from us so we will not see it in the
                             // ChlorinatorStateMessage module.
                             cstate.currentOutput = setpoint;
-                            this.chlorinating = true;
                             if (!this.superChlorinating && cstate.superChlor) {
                                 cstate.superChlorRemaining = cstate.superChlorHours * 3600;
                                 this.superChlorStart = Math.floor(new Date().getTime() / 1000) * 1000;
@@ -274,6 +272,8 @@ export class NixieChlorinator extends NixieEquipment {
                         }
                     }
                 });
+                // #338
+                if (setpoint === 16) { out.appendPayloadByte(0); }
                 conn.queueSendMessage(out);
             });
 
@@ -306,6 +306,7 @@ export class NixieChlorinator extends NixieEquipment {
                     conn.queueSendMessage(out);
                 });
             }
+            else return Promise.resolve(false);
         } catch (err) { logger.error(`Communication error with Chlorinator ${this.chlor.name} : ${err.message}`); return Promise.reject(err);}
 
     }

package/controller/nixie/circuits/Circuit.ts

@@ -56,6 +56,12 @@ export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircui
         }
         catch (err) { logger.error(`setCircuitAsync: ${err.message}`); return Promise.reject(err); }
     }
+    public async checkCircuitEggTimerExpirationAsync(cstate: ICircuitState) {
+     try {
+        let c: NixieCircuit = this.find(elem => elem.id === cstate.id) as NixieCircuit;
+        await c.checkCircuitEggTimerExpirationAsync(cstate);
+    } catch (err) { logger.error(`NCP: Error synching circuit states: ${err}`); }
+    }
     public async initAsync(circuits: CircuitCollection) {
         try {
             for (let i = 0; i < circuits.length; i++) {
@@ -112,6 +118,10 @@ export class NixieCircuit extends NixieEquipment {
     constructor(ncp: INixieControlPanel, circuit: Circuit) {
         super(ncp);
         this.circuit = circuit;
+        // Clear out the delays.
+        let cstate = state.circuits.getItemById(circuit.id);
+        cstate.startDelay = false;
+        cstate.stopDelay = false;
     }
     public get id(): number { return typeof this.circuit !== 'undefined' ? this.circuit.id : -1; }
     public get eggTimerOff(): Timestamp { return typeof this.timeOn !== 'undefined' && !this.circuit.dontStop ? this.timeOn.clone().addMinutes(this.circuit.eggTimer) : undefined; }
@@ -126,18 +136,40 @@ export class NixieCircuit extends NixieEquipment {
             this._sequencing = true;
             let arr = [];
             let t = typeof timeout === 'undefined' ? 100 : timeout;
-            arr.push({ isOn: true, timeout: t }); // This may not be needed but we always need to start from on.
+            arr.push({ isOn: false, timeout: t }); // This may not be needed but we always need to start from off.
             //[{ isOn: true, timeout: 1000 }, { isOn: false, timeout: 1000 }]
             for (let i = 0; i < count; i++) {
-                arr.push({ isOn: false, timeout: t });
                 arr.push({ isOn: true, timeout: t });
+                if(i < count - 1) arr.push({ isOn: false, timeout: t });
             }
+            // The documentation for IntelliBrite is incorrect.  The sequence below will give us Party mode.
+            // Party mode:2
+            // Start: Off
+            // On
+            // Off
+            // On
+            // According to the docs this is the sequence they lay out.
+            // Party mode:2
+            // Start: On
+            // Off
+            // On
+            // Off
+            // On
+
             let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, arr, 60000);
             return res;
         } catch (err) { logger.error(`Nixie: Error sending circuit sequence ${this.id}: ${count}`); }
         finally { this._sequencing = false; }
     }
-    public async setCircuitStateAsync(cstate: ICircuitState, val: boolean, scheduled: boolean = false) : Promise<InterfaceServerResponse> {
+    public async setThemeAsync(cstate: ICircuitState, theme: number): Promise<InterfaceServerResponse> {
+        try {
+            
+
+
+            return new InterfaceServerResponse(200, 'Sucess');
+        } catch (err) { logger.error(`Nixie: Error setting light theme ${cstate.id}-${cstate.name} to ${theme}`); }
+    }
+    public async setCircuitStateAsync(cstate: ICircuitState, val: boolean, scheduled: boolean = false): Promise<InterfaceServerResponse> {
         try {
             if (val !== cstate.isOn) {
                 logger.info(`NCP: Setting Circuit ${cstate.name} to ${val}`);
@@ -149,20 +181,35 @@ export class NixieCircuit extends NixieEquipment {
                 // Check to see if we should be on by poking the schedules.
             }
             if (utils.isNullOrEmpty(this.circuit.connectionId) || utils.isNullOrEmpty(this.circuit.deviceBinding)) {
+                sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(cstate.id), cstate, val);
                 cstate.isOn = val;
                 return new InterfaceServerResponse(200, 'Success');
             }
             if (this._sequencing) return new InterfaceServerResponse(200, 'Success');
             let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, { isOn: val, latch: val ? 10000 : undefined });
             if (res.status.code === 200) {
-                cstate.isOn = val;
+                sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(cstate.id), cstate, val);
                 // Set this up so we can process our egg timer.
-                if (!cstate.isOn && val) { this.timeOn = new Timestamp(); }
-                else if (!val) this.timeOn = undefined;
+                //if (!cstate.isOn && val) { cstate.startTime = this.timeOn = new Timestamp(); }
+                //else if (!val) cstate.startTime = this.timeOn = undefined;
+                cstate.isOn = val;
             }
             return res;
         } catch (err) { logger.error(`Nixie: Error setting circuit state ${cstate.id}-${cstate.name} to ${val}`); }
     }
+    public async checkCircuitEggTimerExpirationAsync(cstate: ICircuitState) {
+        // if circuit end time is past current time, either the schedule is finished
+        // (this should already be turned off) or the egg timer has expired
+        try {
+            if (!cstate.isActive || !cstate.isOn) return;
+            if (typeof cstate.endTime !== 'undefined') {
+                if (cstate.endTime.toDate() < new Timestamp().toDate()) {
+                    await sys.board.circuits.setCircuitStateAsync(cstate.id, false);
+                    cstate.emitEquipmentChange();
+                }
+            }
+        } catch (err) { logger.error(`Error syncing circuit: ${err}`); }
+    }
     private async checkHardwareStatusAsync(connectionId: string, deviceBinding: string) {
         try {
             let dev = await NixieEquipment.getDeviceService(connectionId, `/status/device/${deviceBinding}`);
@@ -187,6 +234,8 @@ export class NixieCircuit extends NixieEquipment {
     public async closeAsync() {
         try {
             let cstate = state.circuits.getItemById(this.circuit.id);
+            cstate.stopDelay = false;
+            cstate.startDelay = false;
             await this.setCircuitStateAsync(cstate, false);
             cstate.emitEquipmentChange();
         }