nodejs-poolcontroller 8.0.1 → 8.0.4

package/controller/nixie/chemistry/ChemController.ts

@@ -1,7 +1,7 @@
 import { clearTimeout, setTimeout } from 'timers';
 import { conn } from '../../../controller/comms/Comms';
 import { Outbound, Protocol, Response } from '../../../controller/comms/messages/Messages';
-import { IChemical, IChemController, ChemController, ChemControllerCollection, ChemFlowSensor, Chemical, ChemicalChlor, ChemicalORP, ChemicalORPProbe, ChemicalPh, ChemicalPhProbe, ChemicalProbe, ChemicalPump, ChemicalTank, sys } from "../../../controller/Equipment";
+import { IChemical, IChemController, Chlorinator, 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';
@@ -21,6 +21,8 @@ export interface INixieChemical extends NixieEquipment {
     chemController: INixieChemController;
     chemical: IChemical;
 }
+
+//#region 
 export class NixieChemControllerCollection extends NixieEquipmentCollection<NixieChemControllerBase> {
     public async manualDoseAsync(id: number, data: any) {
         try {
@@ -208,6 +210,7 @@ export class NixieChemControllerBase extends NixieEquipment implements INixieChe
         else if (!isOn) this.bodyOnTime = undefined;
         return isOn;
     }
+    public get activeBodyId(): number { return sys.board.bodies.getActiveBody(this.chem.body); }
     public async setControllerAsync(data: any) { } // This is meant to be abstract override this value
     public processAlarms(schem: any) { }
 
@@ -692,6 +695,7 @@ export class NixieChemController extends NixieChemControllerBase {
                 // to indicate this to the user.
                 schem.alarms.flow = schem.isBodyOn && !schem.flowDetected ? 1 : 0;
             }
+            schem.activeBodyId = this.activeBodyId;
             schem.ph.dailyVolumeDosed = schem.ph.calcDoseHistory();
             schem.orp.dailyVolumeDosed = schem.orp.calcDoseHistory();
             let chem = this.chem;
@@ -699,7 +703,6 @@ export class NixieChemController extends NixieChemControllerBase {
             schem.ph.enabled = this.chem.ph.enabled;
             let probeType = chem.orp.probe.type;
             if (this.chem.orp.enabled) {
-
                 let useChlorinator = chem.orp.useChlorinator;
                 let pumpType = chem.orp.pump.type;
                 let currLevelPercent = schem.orp.tank.level / schem.orp.tank.capacity * 100;
@@ -710,7 +713,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 && !this.chem.orp.useChlorinator) {
+                if (this.chem.orp.dosingMethod !== 0 && this.chem.orp.maxDailyVolume <= schem.orp.dailyVolumeDosed && !this.chem.orp.useChlorinator) {
                     schem.warnings.orpDailyLimitReached = 4;
                     schem.orp.dailyLimitReached = true;
                 }
@@ -722,7 +725,15 @@ export class NixieChemController extends NixieChemControllerBase {
                     if (probeType !== 0 && chem.orp.tolerance.enabled)
                         schem.alarms.orp = schem.orp.level < chem.orp.tolerance.low ? 16 : schem.orp.level > chem.orp.tolerance.high ? 8 : 0;
                     else schem.alarms.orp = 0;
-                    schem.warnings.chlorinatorCommError = useChlorinator && schem.isBodyOn && state.chlorinators.getItemById(1).status & 0xF0 ? 16 : 0;
+                    let chlorErr = 0;
+                    if (useChlorinator && schem.isBodyOn) {
+                        let chlors = sys.chlorinators.getByBody(schem.activeBodyId);
+                        let chlor = chlors.getItemByIndex(0);
+                        let schlor = state.chlorinators.getItemById(chlor.id);
+                        this.orp.chlor.chlorId = chlor.id;
+                        if (schlor.status & 0xF0) chlorErr = 16;
+                    }
+                    schem.warnings.chlorinatorCommError = chlorErr;
                     schem.warnings.pHLockout = useChlorinator === false && probeType !== 0 && pumpType !== 0 && schem.ph.level >= chem.orp.phLockout ? 1 : 0;
                 }
                 else {
@@ -756,7 +767,7 @@ export class NixieChemController extends NixieChemControllerBase {
                 schem.warnings.pHDailyLimitReached = 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.ph.pump.type > 0 ? (this.chem.ph.pump.ratedFlow / 60) * 3 : 0;
-                if (this.chem.ph.maxDailyVolume <= schem.ph.dailyVolumeDosed + padj) {
+                if (this.chem.ph.dosingMethod !== 0 && this.chem.ph.maxDailyVolume <= schem.ph.dailyVolumeDosed + padj) {
                     schem.warnings.pHDailyLimitReached = 2;
                     schem.ph.dailyLimitReached = true;
                 }
@@ -773,7 +784,6 @@ export class NixieChemController extends NixieChemControllerBase {
                 else schem.alarms.pH = 0;
                 schem.ph.freezeProtect = (state.freeze && chem.ph.disableOnFreeze && schem.isBodyOn);
             }
-
             else {
                 schem.alarms.pHTank = 0;
                 schem.warnings.pHDailyLimitReached = 0;
@@ -1057,7 +1067,7 @@ class NixieChemical extends NixieChildEquipment implements INixieChemical {
             schem.chlor.isDosing = schem.pump.isDosing = false;
             if (!this.chemical.flowOnlyMixing || (schem.chemController.isBodyOn && this.chemController.flowDetected && !schem.freezeProtect)) {
                 if (this.chemType === 'orp' && typeof this.chemController.orp.orp.useChlorinator !== 'undefined' && this.chemController.orp.orp.useChlorinator && this.chemController.orp.orp.chlorDosingMethod > 0) {
-                    if (state.chlorinators.getItemById(1).currentOutput !== 0) {
+                    if (state.chlorinators.getItemById(this.chemController.orp.chlor.chlorId).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;
                     }
@@ -1130,10 +1140,10 @@ export class NixieChemTank extends NixieChildEquipment {
         try {
             if (typeof data !== 'undefined') {
                 stank.level = typeof data.level !== 'undefined' ? parseFloat(data.level) : stank.level;
-                stank.capacity = this.tank.capacity = typeof data.capacity !== 'undefined' ? parseFloat(data.capacity) : stank.capacity;
+                stank.capacity = this.tank.capacity = typeof data.capacity !== 'undefined' ? parseFloat(data.capacity) : this.tank.capacity;
                 stank.units = this.tank.units = typeof data.units !== 'undefined' ? sys.board.valueMaps.volumeUnits.encode(data.units) : this.tank.units;
-                stank.alarmEmptyEnabled = this.tank.alarmEmptyEnabled = typeof data.alarmEmptyEnabled !== 'undefined' ? data.alarmEmptyEnabled : stank.alarmEmptyEnabled;
-                stank.alarmEmptyLevel = this.tank.alarmEmptyLevel = typeof data.alarmEmptyLevel !== 'undefined' ? data.alarmEmptyLevel : stank.alarmEmptyLevel;
+                stank.alarmEmptyEnabled = this.tank.alarmEmptyEnabled = typeof data.alarmEmptyEnabled !== 'undefined' ? data.alarmEmptyEnabled : this.tank.alarmEmptyEnabled;
+                stank.alarmEmptyLevel = this.tank.alarmEmptyLevel = typeof data.alarmEmptyLevel !== 'undefined' ? data.alarmEmptyLevel : this.tank.alarmEmptyLevel;
             }
         }
         catch (err) { logger.error(`setTankAsync: ${err.message}`); return Promise.reject(err); }
@@ -1370,8 +1380,7 @@ export class NixieChemPump extends NixieChildEquipment {
                         await self.dose(schem);
                     }
                     catch (err) {
-                        logger.error(`self.dose error in finally:`);
-                        logger.error(err);
+                        logger.error(`self.dose error in finally: ${err.message}`);
                         //return Promise.reject(err); // this isn't a promise we should be returning
                     }
                 }, 1000);
@@ -1383,8 +1392,7 @@ export class NixieChemPump extends NixieChildEquipment {
                         await this.chemical.cancelDosing(schem, 'completed');
                     }
                     catch (err) {
-                        logger.error(`this.chemical.cancelDosing error in finally:`);
-                        logger.error(err);
+                        logger.error(`this.chemical.cancelDosing error in finally: ${err.message}`);
                     }
                     schem.pump.isDosing = this.isOn = false;
                     schem.manualDosing = false;
@@ -1416,6 +1424,7 @@ export class NixieChemPump extends NixieChildEquipment {
 export class NixieChemChlor extends NixieChildEquipment {
     public chlor: ChemicalChlor;
     public isOn: boolean;
+    public chlorId = 0;
     public _lastOnStatus: number;
     protected _dosingTimer: NodeJS.Timeout;
     private _isStopping = false;
@@ -1427,7 +1436,7 @@ export class NixieChemChlor extends NixieChildEquipment {
             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);
+                let chlor = sys.chlorinators.getItemById(this.chlorId);
                 chlor.disabled = false;
                 chlor.isDosing = false;
             }
@@ -1479,7 +1488,7 @@ export class NixieChemChlor extends NixieChildEquipment {
                 let isBodyOn = schem.chemController.flowDetected;
                 await this.chemical.initDose(schem);
                 let chemController = schem.getParent()
-                let schlor = state.chlorinators.getItemById(1);
+                let schlor = state.chlorinators.getItemById(this.chlorId);
                 if (!isBodyOn) {
                     // Make sure the chlor is off.
                     logger.info(`Chem chlor flow not detected. Body is not running.`);
@@ -1538,7 +1547,7 @@ export class NixieChemChlor extends NixieChildEquipment {
                 this._dosingTimer = setTimeout(async () => {
                     try { await self.dose(schem); }
                     catch (err) {
-                        logger.error(err);
+                        logger.error(`Chem dosing error: ${err.message}`);
                         // return Promise.reject(err); // should not be returning a promise in a finally 
                     }
                 }, 1000);
@@ -1556,8 +1565,8 @@ export class NixieChemChlor extends NixieChildEquipment {
     public async turnOff(schem: IChemicalState): Promise<ChlorinatorState> {
         try {
             //logger.info(`Turning off the chlorinator`);
-            let chlor = sys.chlorinators.getItemById(1);
-            let schlor = state.chlorinators.getItemById(1);
+            let chlor = sys.chlorinators.getItemById(this.chlorId);
+            let schlor = state.chlorinators.getItemById(chlor.id);
             if (schlor.currentOutput === 0 && schlor.targetOutput === 0 && !schlor.superChlor && chlor.disabled && !chlor.isDosing) {
                 this.isOn = schem.chlor.isDosing = false;
                 return schlor;
@@ -1574,8 +1583,8 @@ export class NixieChemChlor extends NixieChildEquipment {
     }
     public async turnOn(schem: ChemicalState, latchTimeout?: number): Promise<ChlorinatorState> {
         try {
-            let chlor = sys.chlorinators.getItemById(1);
-            let schlor = state.chlorinators.getItemById(1);
+            let chlor = sys.chlorinators.getItemById(this.chlorId);
+            let schlor = state.chlorinators.getItemById(chlor.id);
             if (schlor.currentOutput === 100 && schlor.targetOutput === 100 && !schlor.superChlor && !chlor.disabled && chlor.isDosing) {
                 this.isOn = schem.chlor.isDosing = true;
                 return schlor;
@@ -1818,7 +1827,7 @@ export class NixieChemicalPh extends NixieChemical {
                 }
             }
         }
-        catch (err) { logger.error(err); return Promise.reject(err); }
+        catch (err) { logger.error(`Error checking for dosing: ${err.message}`); return Promise.reject(err); }
         finally {
             logger.debug(`End check ${sph.chemType} dosing status = ${sys.board.valueMaps.chemControllerDosingStatus.getName(sph.dosingStatus)}`);
         }
@@ -1870,7 +1879,7 @@ export class NixieChemicalPh extends NixieChemical {
             logger.verbose(`Chem acid manual calibration dose activate pump`);
             await this.pump.dose(sph);
         }
-        catch (err) { logger.error(`calibrateDoseAsync: ${err.message}`); logger.error(err); return Promise.reject(err); }
+        catch (err) { logger.error(`calibrateDoseAsync: ${err.message}`); return Promise.reject(err); }
     }
     public async manualDoseVolumeAsync(sph: ChemicalPhState, volume: number) {
         try {
@@ -1903,7 +1912,7 @@ export class NixieChemicalPh extends NixieChemical {
                 await this.pump.dose(sph);
             }
         }
-        catch (err) { logger.error(`manualDoseVolumeAsync: ${err.message}`); logger.error(err); return Promise.reject(err); }
+        catch (err) { logger.error(`manualDoseVolumeAsync: ${err.message}`); return Promise.reject(err); }
     }
     public async initDose(sph: ChemicalPhState) {
         try {
@@ -2024,7 +2033,7 @@ export class NixieChemicalORP extends NixieChemical {
                 await this.pump.dose(sorp);
             }
         }
-        catch (err) { logger.error(`manualDoseVolumeAsync ORP: ${err.message}`); logger.error(err); return Promise.reject(err); }
+        catch (err) { logger.error(`manualDoseVolumeAsync ORP: ${err.message}`); return Promise.reject(err); }
     }
     public async calibrateDoseAsync(sorp: ChemicalORPState, time: number) {
         try {
@@ -2055,7 +2064,7 @@ export class NixieChemicalORP extends NixieChemical {
             logger.verbose(`Chem acid manual dose activate pump ${this.pump.pump.ratedFlow}mL/min`);
             await this.pump.dose(sorp);
         }
-        catch (err) { logger.error(`calibrateDoseAsync: ${err.message}`); logger.error(err); return Promise.reject(err); }
+        catch (err) { logger.error(`calibrateDoseAsync: ${err.message}`); return Promise.reject(err); }
     }
 
     public async cancelDosing(sorp: ChemicalORPState, reason: string): Promise<void> {
@@ -2267,8 +2276,8 @@ export class NixieChemicalORP extends NixieChemical {
                         }
 
 
-                        let chlor = sys.chlorinators.getItemById(1); // Still haven't seen any systems with 2+ chlors
-                        let schlor = state.chlorinators.getItemById(1);
+                        let chlor = sys.chlorinators.getItemById(this.chlor.chlorId); // Still haven't seen any systems with 2+ chlors
+                        let schlor = state.chlorinators.getItemById(chlor.id);
                         // 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

package/controller/nixie/circuits/Circuit.ts

@@ -140,6 +140,9 @@ export class NixieCircuit extends NixieEquipment {
         let cstate = state.circuits.getItemById(circuit.id);
         cstate.startDelay = false;
         cstate.stopDelay = false;
+        cstate.name = circuit.name;
+        cstate.type = circuit.type;
+        cstate.showInFeatures = circuit.showInFeatures;
     }
     public async setServiceModeAsync() {
         let cstate = state.circuits.getItemById(this.circuit.id);
@@ -155,20 +158,55 @@ export class NixieCircuit extends NixieEquipment {
     }
     protected async setIntelliBriteThemeAsync(cstate: CircuitState, theme: any): Promise<InterfaceServerResponse> {
         let arr = [];
-        if (cstate.isOn) arr.push({ isOn: false, timeout: 1000 });
         let count = typeof theme !== 'undefined' && theme.sequence ? theme.sequence : 0;
-        if (cstate.isOn) arr.push({ isOn: false, timeout: 1000 });
+		
+		// Removing this. No need to turn the light off first.  We actually need it on to start the sequence for theme setting to work correctly when the light is starting from the off state.
+		// if (cstate.isOn) arr.push({ isOn: false, timeout: 1000 });
+		
+		// Start the sequence of off/on after the light is on.
+        arr.push({ isOn: true, timeout: 100 });
         for (let i = 0; i < count; i++) {
-            if (i < count - 1) {
-                arr.push({ isOn: true, timeout: 100 });
-                arr.push({ isOn: false, timeout: 100 });
-            }
-            else arr.push({ isOn: true, timeout: 1000 });
+			arr.push({ isOn: false, timeout: 100 });
+			arr.push({ isOn: true, timeout: 100 });     
+        }
+		// Ensure light stays on long enough for the theme to stick (required for light group theme setting to function correctly).
+		// 2s was too short.
+		arr.push({ isOn: true, timeout: 3000 });
+        
+		logger.debug(arr);
+        let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, arr, 60000);
+        // Even though we ended with on we need to make sure that the relay stays on now that we are done.
+        if (!res.error) {
+            this._sequencing = false;
+            await this.setCircuitStateAsync(cstate, true, false);
+        }
+        return res;
+    }
+    protected async setWaterColorsThemeAsync(cstate: CircuitState, theme: any): Promise<InterfaceServerResponse> {
+        let ptheme = sys.board.valueMaps.lightThemes.findItem(cstate.lightingTheme) || { val: 0, sequence: 0 };
+        // First check to see if we are on.  If we are not then we need to emit our status as if we are initializing and busy.
+        let arr = [];
+        if (ptheme.val === 0) {
+            // We don't know our previous theme so we are going to sync the lights to get a starting point.
+            arr.push({ isOn: true, timeout: 1000 }); // Turn on for 1 second
+            arr.push({ isOn: false, timeout: 5000 }); // Turn off for 5 seconds
+            arr.push({ isOn: true, timeout: 1000 });
+            ptheme = sys.board.valueMaps.lightThemes.findItem('eveningsea');
+        }
+        let count = theme.sequence - ptheme.sequence;
+        if (count < 0) count = count + 16;
+        for (let i = 0; i < count; i++) {
+            arr.push({ isOn: true, timeout: 200 }); 
+            arr.push({ isOn: false, timeout: 200 });
         }
         console.log(arr);
+        if (arr.length === 0) return new InterfaceServerResponse(200, 'Success');
         let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, arr, 60000);
         // Even though we ended with on we need to make sure that the relay stays on now that we are done.
         if (!res.error) {
+            cstate.lightingTheme = ptheme.val;
+            cstate.isOn = true; // At this point the relay will be off but we want the process
+                                // to assume that the relay state is not actually changing.
             this._sequencing = false;
             await this.setCircuitStateAsync(cstate, true, false);
         }
@@ -234,6 +272,9 @@ export class NixieCircuit extends NixieEquipment {
                 case 'colorlogic':
                     res = await this.setColorLogicThemeAsync(cstate, theme);
                     break;
+                case 'watercolors':
+                    res = await this.setWaterColorsThemeAsync(cstate, theme);
+                    break;
             }
             cstate.action = 0;
             // Make sure clients know that we are done.

package/controller/nixie/heaters/Heater.ts

@@ -287,11 +287,15 @@ export class NixieSolarHeater extends NixieHeaterBase {
             if (typeof this._lastState === 'undefined' || target || this._lastState !== target) {
                 if (utils.isNullOrEmpty(this.heater.connectionId) || utils.isNullOrEmpty(this.heater.deviceBinding)) {
                     this._lastState = hstate.isOn = target;
+                    hstate.isCooling = target && isCooling;
                 }
                 else {
                     let res = await NixieEquipment.putDeviceService(this.heater.connectionId, `/state/device/${this.heater.deviceBinding}`,
                         { isOn: target, latch: target ? 10000 : undefined });
-                    if (res.status.code === 200) this._lastState = hstate.isOn = target;
+                    if (res.status.code === 200) {
+                        this._lastState = hstate.isOn = target;
+                        hstate.isCooling = target && isCooling;
+                    }
                     else logger.error(`Nixie Error setting heater state: ${res.status.code} -${res.status.message} ${res.error.message}`);
                 }
                 if (target) {
@@ -578,6 +582,7 @@ export class NixieMastertemp extends NixieGasHeater {
         // Set the polling interval to 3 seconds.
         this.pollEquipmentAsync();
         this.pollingInterval = 3000;
+
     }
     /*     public getCooldownTime(): number {
             // Delays are always in terms of seconds so convert the minute to seconds.
@@ -589,12 +594,26 @@ export class NixieMastertemp extends NixieGasHeater {
     public async setHeaterStateAsync(hstate: HeaterState, isOn: boolean) {
         try {
             // Initialize the desired state.
+            this.isOn = isOn;
             this.isCooling = false;
-            // Here we go we need to set the firemans switch state.
-            if (hstate.isOn !== isOn) {
-                logger.info(`Nixie: Set Heater ${hstate.id}-${hstate.name} to ${isOn}`);
+            let target = hstate.startupDelay === false && isOn;
+            if (target && typeof hstate.endTime !== 'undefined') {
+                // Calculate a short cycle time so that the gas heater does not cycle
+                // too often.  For gas heaters this is 60 seconds.  This gives enough time
+                // for the heater control circuit to make a full cycle.
+                if (new Date().getTime() - hstate.endTime.getTime() < this.heater.minCycleTime * 60000) {
+                    logger.verbose(`${hstate.name} short cycle detected deferring turn on state`);
+                    target = false;
+                }
+            }
+            // Here we go we need to set the state.
+            if (hstate.isOn !== target) {
+                logger.info(`Nixie: Set Mastertemp ${hstate.id}-${hstate.name} to ${isOn}`);
+            }
+            if (typeof this._lastState === 'undefined' || target || this._lastState !== target) {
+                this._lastState = hstate.isOn = target;
+                if (target) this.lastHeatCycle = new Date();
             }
-            if (isOn && !hstate.startupDelay) this.lastHeatCycle = new Date();
             hstate.isOn = isOn;
         } catch (err) { return logger.error(`Nixie Error setting heater state ${hstate.id}-${hstate.name}: ${err.message}`); }
     }