nodejs-poolcontroller 8.0.1 → 8.0.2

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);
@@ -174,6 +177,36 @@ export class NixieCircuit extends NixieEquipment {
         }
         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);
+        }
+        return res;
+    }
     protected async setColorLogicThemeAsync(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.
@@ -234,6 +267,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}`); }
     }