nodejs-poolcontroller 7.4.0 → 7.5.1

package/controller/comms/messages/status/IntelliChemStateMessage.ts

@@ -23,15 +23,25 @@ import { Timestamp, utils } from "../../../Constants"
 export class IntelliChemStateMessage {
     public static process(msg: Inbound) {
         if (sys.controllerType === ControllerType.Unknown) return;
-        if (msg.source < 144 || msg.source > 158) return;
+        let address = (msg.dest >= 144 && msg.dest <= 158) ? msg.dest : msg.source;
+        if (address < 144 || address > 158) return;
+        let controller = sys.chemControllers.getItemByAddress(address);
+        if (!controller.isActive) {
+            msg.isProcessed = true;
+            return;
+        }
         switch (msg.action) {
-
             // ---------- IntelliChem Control panel is spitting out its status ----------- //
             case 18: // IntelliChem is sending us it's status.
                 IntelliChemStateMessage.processState(msg);
                 break;
             case 210: // OCP is asking IntelliChem controller for it's current status info.
                 // [165,0,144,16,210,1],[210],[2,234]
+                let schem = state.chemControllers.getItemById(controller.id);
+                if (schem.lastComm + (30 * 1000) < new Date().getTime()) {
+                    // We have not talked to the chem controller in 30 seconds so we have lost communication.
+                    schem.status = schem.alarms.comms = 1;
+                }
                 msg.isProcessed = true;
                 break;
             // ---------- End IntelliChem set get ----------- //
@@ -43,7 +53,7 @@ export class IntelliChemStateMessage {
 
             /* RKS: This is processed in the IntellichemMessage.processTouch() and is the results of asking for the IntelliChem configuration.
             case 147: // OCP is broadcasting it's known ic values...  Need to change our settings if virtual.
-                // 147 is a proto:broadcast message; 
+                // 147 is a proto:broadcast message;
                 // it has exactly the same format as 18 but there is payload[0] which is inserted at the beginning.  Likely the chem controller id.
                 if (msg.dest < 144 || msg.dest > 158) return;
                 IntelliChemStateMessage.processControllerChange(msg);
@@ -57,14 +67,11 @@ export class IntelliChemStateMessage {
                 msg.isProcessed = true;
                 break;
             case 146: // OCP is telling IntelliChem that it needs to change its settings to...
-                let address = msg.dest;
-                // The address is king here.  The id is not.
-                let controller = sys.chemControllers.getItemByAddress(address, true);
-                let scontroller = state.chemControllers.getItemById(controller.id, true);
-                if (scontroller.lastComm + (30 * 1000) < new Date().getTime()) {
-                    // We have not talked to the chem controller in 30 seconds so we have lost communication.
-                    scontroller.status = scontroller.alarms.comms = 1;                   
-                }
+                //let scontroller = state.chemControllers.getItemById(controller.id, true);
+                //if (scontroller.lastComm + (30 * 1000) < new Date().getTime()) {
+                //    // We have not talked to the chem controller in 30 seconds so we have lost communication.
+                //    scontroller.status = scontroller.alarms.comms = 1;
+                //}
                 controller.ph.tank.capacity = controller.orp.tank.capacity = 6;
                 controller.ph.tank.units = controller.orp.tank.units = '';
                 msg.isProcessed = true;
@@ -89,8 +96,8 @@ export class IntelliChemStateMessage {
         //      6-7 : ORP Setpoint : byte(6) x 256 + byte(7)
         //      8 : Unknown = 0
         //      9 : Unknown = 0
-        //      10 : Unknown = 0
-        //      11-12 : pH Dose time seconds. The number of seconds since the dose started. byte(11) x 256 + byte(12)
+        //      10-11 : pH Dose time seconds. The number of seconds since the dose started. byte(10) x 256 + byte(11)
+        //      12: Unknown
         //      13 : Unknown
         //      14-15 : ORP Dose time seconds.  The number of seconds since the dose started. byte(14) x 256 + byte(15)
         //      16-17 : pH Dose volume (unknown units) - These appear to be mL.
@@ -122,10 +129,13 @@ export class IntelliChemStateMessage {
         schem.type = chem.type = sys.board.valueMaps.chemControllerTypes.getValue('intellichem');
         chem.name = chem.name || `IntelliChem ${chem.address - 143}`; // default to true id if no name is set
         schem.lastComm = new Date().getTime();
-        schem.status = schem.alarms.comms = 0; 
+        schem.status = schem.alarms.comms = 0;
         chem.ph.tank.capacity = chem.orp.tank.capacity = 6;
         chem.ph.tank.units = chem.orp.tank.units = '';
-        
+        chem.ph.tank.alarmEmptyEnabled = false;
+        chem.ph.tank.alarmEmptyLevel = 1;
+        chem.orp.tank.alarmEmptyEnabled = false;
+        chem.orp.tank.alarmEmptyLevel = 1;
         schem.address = chem.address;
         schem.ph.level = schem.ph.probe.level = msg.extractPayloadIntBE(0) / 100;
         schem.orp.level = schem.orp.probe.level = msg.extractPayloadIntBE(2);
@@ -133,11 +143,11 @@ export class IntelliChemStateMessage {
         chem.orp.setpoint = msg.extractPayloadIntBE(6);
         // Missing information on the related bytes.
         // Bytes 8-14 (Probably Total Dissolved Solids in here if no IntelliChlor)
-        let phPrev = { status: schem.orp.dosingStatus, time: schem.ph.timeDosed || 0, vol: schem.ph.volumeDosed };
+        let phPrev = { status: schem.ph.dosingStatus, time: schem.ph.timeDosed || 0, vol: schem.ph.volumeDosed };
         let orpPrev = { status: schem.orp.dosingStatus, time: schem.orp.timeDosed || 0, vol: schem.orp.volumeDosed };
         // IntelliChem never tells us what the dose time or volume is so we will let that dog lie.
-        //      11-12 : pH Dose time
-        schem.ph.timeDosed = (msg.extractPayloadByte(11) * 256) + msg.extractPayloadByte(12);
+        //      10-11 : pH Dose time
+        schem.ph.timeDosed = (msg.extractPayloadByte(10) * 256) + msg.extractPayloadByte(11);
         //      14-15 : ORP Dose time seconds.  The number of seconds since the dose started.
         schem.orp.timeDosed = (msg.extractPayloadByte(14) * 256) + msg.extractPayloadByte(15);
         //      16-17 : pH Dose volume (unknown units) = 35
@@ -157,7 +167,7 @@ export class IntelliChemStateMessage {
         chem.cyanuricAcid = msg.extractPayloadByte(26);
         //      27-28 : Alkalinity
         chem.alkalinity = (msg.extractPayloadByte(27) * 256) + msg.extractPayloadByte(28);
-        //      29 : Salt level = 20 
+        //      29 : Salt level = 20
         if (sys.chlorinators.length > 0) {
             let chlor = state.chlorinators.find(elem => elem.id === 1);
             schem.orp.probe.saltLevel = (typeof chlor !== 'undefined') ? chlor.saltLevel : msg.extractPayloadByte(29) * 50;
@@ -169,6 +179,7 @@ export class IntelliChemStateMessage {
         //      32 : Alarms = 8 = (no alarm)
         const alarms = schem.alarms;
         alarms.flow = msg.extractPayloadByte(32) & 0x01;
+        if (alarms.flow === 0) schem.flowDetected = true;
         alarms.pH = msg.extractPayloadByte(32) & 0x06;
         alarms.orp = msg.extractPayloadByte(32) & 0x18;
         alarms.pHTank = msg.extractPayloadByte(32) & 0x20;
@@ -187,11 +198,11 @@ export class IntelliChemStateMessage {
         schem.ph.dosingStatus = (msg.extractPayloadByte(34) & 0x30) >> 4; // mask 00xx0000 and shift bit 5 & 6
         schem.orp.dosingStatus = (msg.extractPayloadByte(34) & 0xC0) >> 6; // mask xx000000 and shift bit 7 & 8
         //      35 : Delays = 0
-        schem.status = msg.extractPayloadByte(35) & 0x80 >> 7; // to be verified as comms lost
+        schem.status = (msg.extractPayloadByte(35) & 0x80) >> 7; // to be verified as comms lost
         schem.ph.manualDosing = (msg.extractPayloadByte(35) & 0x08) === 1 ? true : false;
         chem.orp.useChlorinator = (msg.extractPayloadByte(35) & 0x10) === 1 ? true : false;
         chem.HMIAdvancedDisplay = (msg.extractPayloadByte(35) & 0x20) === 1 ? true : false;
-        chem.ph.phSupply = (msg.extractPayloadByte(35) & 0x40) === 1 ? true : false; // acid pH dosing = 1; base pH dosing = 0;
+        chem.ph.phSupply = (msg.extractPayloadByte(35) & 0x40) === 1 ? 'acid' : 'base'; // acid pH dosing = 1; base pH dosing = 0;
         //      36-37 : Firmware = 80,1 = 1.080
         chem.firmware = `${msg.extractPayloadByte(37)}.${msg.extractPayloadByte(36).toString().padStart(3, '0')}`
         //      38 : Water Chemistry Warning
@@ -230,12 +241,12 @@ export class IntelliChemStateMessage {
             if (typeof schem.ph.currentDose !== 'undefined') {
                 // We just ended a dose so write it out to the chem logs.
                 schem.ph.endDose(Timestamp.now.addSeconds(-(schem.ph.doseTime - phPrev.time)).toDate(), 'completed',
-                    schem.ph.volumeDosed - phPrev.vol, (schem.ph.doseTime - phPrev.time) * 1000);
+                    schem.ph.volumeDosed - phPrev.vol, (schem.ph.timeDosed - phPrev.time) * 1000);
             }
         }
         else if (schem.ph.dosingStatus === 0) {
             // We are still dosing so add the time and volume to the dose.
-            schem.ph.appendDose(schem.ph.doseVolume - phPrev.vol, (schem.ph.doseTime - phPrev.time) * 1000);
+            schem.ph.appendDose(schem.ph.doseVolume - phPrev.vol, (schem.ph.timeDosed - phPrev.time) * 1000);
         }
         else {
             console.log(`DOSING STATUS === ${schem.ph.dosingStatus}`);
@@ -246,19 +257,19 @@ export class IntelliChemStateMessage {
         if (schem.orp.dosingStatus === 0 && orpPrev.status !== 0) {
             if (schem.orp.dosingStatus === 0) {
                 // We are starting a dose so we need to set the current dose.
-                schem.orp.startDose(Timestamp.now.addSeconds(-schem.orp.doseTime).toDate(), schem.orp.manualDosing ? 'manual' : 'auto', 0, schem.orp.volumeDosed, schem.orp.timeDosed * 1000);
+                schem.orp.startDose(Timestamp.now.addSeconds(-schem.orp.doseTime).toDate(), schem.orp.manualDosing ? 'manual' : 'auto', 0, schem.orp.volumeDosed, 0, schem.orp.timeDosed * 1000);
             }
         }
         else if (schem.orp.dosingStatus !== 0 && orpPrev.status === 0) {
             if (typeof schem.orp.currentDose !== 'undefined') {
                 // We just ended a dose so write it out to the chem logs.
                 schem.orp.endDose(Timestamp.now.addSeconds(-(schem.orp.doseTime - orpPrev.time)).toDate(), 'completed',
-                    schem.orp.volumeDosed - orpPrev.vol, schem.orp.doseTime - orpPrev.time);
+                    schem.orp.volumeDosed - orpPrev.vol, (schem.orp.timeDosed - orpPrev.time) * 1000);
             }
         }
         else if (schem.orp.dosingStatus === 0) {
             // We are still dosing so add the time and volume to the dose.
-            schem.orp.appendDose(schem.orp.doseTime - orpPrev.time, schem.orp.doseVolume - orpPrev.vol);
+            schem.orp.appendDose(schem.orp.doseVolume - orpPrev.vol, (schem.orp.timeDosed - orpPrev.time) * 1000);
         }
         else {
             // Make sure we don't have a current dose going.

package/controller/nixie/Nixie.ts

@@ -136,23 +136,25 @@ export class NixieControlPanel implements INixieControlPanel {
         try {
             let srv = [];
             let servers = webApp.findServersByType('rem');
-            for (let i = 0; i < servers.length; i++) {
-                let server = servers[i];
-                // Sometimes I hate type safety.
-                let devices = typeof server['getDevices'] === 'function' ? await server['getDevices']() : [];
-                let int = config.getInterfaceByUuid(servers[i].uuid);
-                srv.push({
-                    uuid: servers[i].uuid,
-                    name: servers[i].name,
-                    type: servers[i].type,
-                    isRunning: servers[i].isRunning,
-                    isConnected: servers[i].isConnected,
-                    devices: devices,
-                    remoteConnectionId: servers[i].remoteConnectionId,
-                    interface: int
-                });
+            if (typeof servers !== 'undefined') {
+                for (let i = 0; i < servers.length; i++) {
+                    let server = servers[i];
+                    // Sometimes I hate type safety.
+                    let devices = typeof server['getDevices'] === 'function' ? await server['getDevices']() : [];
+                    let int = config.getInterfaceByUuid(servers[i].uuid);
+                    srv.push({
+                        uuid: servers[i].uuid,
+                        name: servers[i].name,
+                        type: servers[i].type,
+                        isRunning: servers[i].isRunning,
+                        isConnected: servers[i].isConnected,
+                        devices: devices,
+                        remoteConnectionId: servers[i].remoteConnectionId,
+                        interface: int
+                    });
+                }
+                await ncp.chemControllers.syncRemoteREMFeeds(srv);
             }
-            await ncp.chemControllers.syncRemoteREMFeeds(srv);
             return srv;
         } catch (err) { logger.error(err); }
     }

package/controller/nixie/chemistry/ChemController.ts

@@ -9,6 +9,7 @@ import { EquipmentNotFoundError, EquipmentTimeoutError, InvalidEquipmentDataErro
 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:
@@ -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}`);
         }
     }
@@ -964,9 +973,8 @@ class NixieChemical extends NixieChildEquipment {
             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 (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;
                     }
                 }
@@ -1365,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') {
@@ -1416,9 +1424,10 @@ 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;
             }
@@ -1436,11 +1445,7 @@ 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;
             }
@@ -1802,13 +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 (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);
+                    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.
@@ -2030,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 {
@@ -2064,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) {
@@ -2137,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); }
@@ -2190,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;
@@ -2216,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,
@@ -2224,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); }
     }
@@ -2307,11 +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); // don't muck up chem controller if we can't set the feeds.
-    }
     }
     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;
@@ -308,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 syncing circuit states: ${err}`); }
+    }
     public async initAsync(circuits: CircuitCollection) {
         try {
             for (let i = 0; i < circuits.length; i++) {
@@ -179,6 +185,17 @@ export class NixieCircuit extends NixieEquipment {
             return res;
         } catch (err) { logger.error(`Nixie: Error setting circuit state ${cstate.id}-${cstate.name} to ${val}`); }
     }
+    public async checkCircuitEggTimerExpirationAsync(cstate: ICircuitState) {
+        // if circuit end time is past current time, either the schedule is finished
+        // (this should already be turned off) or the egg timer has expired
+        try {
+            if (!cstate.isActive || !cstate.isOn) return;
+            if (cstate.endTime.toDate() < new Timestamp().toDate()) {
+                await sys.board.circuits.setCircuitStateAsync(cstate.id, false);
+                cstate.emitEquipmentChange();
+            }
+        } catch (err) { logger.error(`Error syncing circuit: ${err}`); }
+    }
     private async checkHardwareStatusAsync(connectionId: string, deviceBinding: string) {
         try {
             let dev = await NixieEquipment.getDeviceService(connectionId, `/status/device/${deviceBinding}`);