nodejs-poolcontroller 7.5.1 → 7.7.0

package/controller/nixie/chemistry/Chlorinator.ts

@@ -1,5 +1,5 @@
 import { InvalidEquipmentDataError, InvalidEquipmentIdError, InvalidOperationError } from '../../Errors';
-import { utils, Timestamp } from '../../Constants';
+import { utils, Timestamp, ControllerType } from '../../Constants';
 import { logger } from '../../../logger/Logger';
 
 import { NixieEquipment, NixieChildEquipment, NixieEquipmentCollection, INixieControlPanel } from "../NixieEquipment";
@@ -87,7 +87,11 @@ export class NixieChlorinator extends NixieEquipment {
     }
     public get id(): number { return typeof this.chlor !== 'undefined' ? this.chlor.id : -1; }
     public get suspendPolling(): boolean { return this._suspendPolling > 0; }
-    public set suspendPolling(val: boolean) { this._suspendPolling = Math.max(0, this._suspendPolling + (val ? 1 : -1));  }
+    public set suspendPolling(val: boolean) { this._suspendPolling = Math.max(0, this._suspendPolling + (val ? 1 : -1)); }
+    public get superChlorRemaining(): number {
+        if (typeof this.superChlorStart === 'undefined' || this.superChlorStart === 0 || !this.chlor.superChlor) return 0;
+        return Math.max(Math.floor(((this.chlor.superChlorHours * 3600 * 1000) - (new Date().getTime() - this.superChlorStart)) / 1000), 0);
+    }
     public async setChlorinatorAsync(data: any) {
         try {
             let chlor = this.chlor;
@@ -97,15 +101,20 @@ export class NixieChlorinator extends NixieEquipment {
             let poolSetpoint = typeof data.poolSetpoint !== 'undefined' ? parseInt(data.poolSetpoint, 10) : chlor.poolSetpoint;
             let spaSetpoint = typeof data.spaSetpoint !== 'undefined' ? parseInt(data.spaSetpoint, 10) : chlor.spaSetpoint;
             let body = sys.board.bodies.mapBodyAssociation(typeof data.body === 'undefined' ? chlor.body : data.body);
-            let superChlor = typeof data.superChlor !== 'undefined' ? utils.makeBool(data.superChlor) : chlor.superChlor;
+            let superChlor = typeof data.superChlor !== 'undefined' ? utils.makeBool(data.superChlor) : typeof data.superChlorinate !== 'undefined' ? utils.makeBool(data.superChlorinate) : chlor.superChlor;
             let chlorType = typeof data.type !== 'undefined' ? sys.board.valueMaps.chlorinatorType.encode(data.type) : chlor.type || 0;
             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 || 0;
-            if (typeof body === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Invalid body assignment`, 'chlorinator', data.body || chlor.body));
+            let model = typeof data.model !== 'undefined' ? sys.board.valueMaps.chlorinatorModel.encode(data.model) : chlor.model || 0;
+            let portId = typeof data.portId !== 'undefined' ? parseInt(data.portId, 10) : chlor.portId;
+            if (portId === 0 && sys.controllerType !== ControllerType.Nixie) return Promise.reject(new InvalidEquipmentDataError(`You may not install a chlorinator on an ${sys.controllerType} system that is assigned to the Primary Port that is under Nixe control`, 'Chlorinator', portId));
+            if (portId !== chlor.portId && sys.chlorinators.count(elem => elem.id !== this.chlor.id && elem.portId === portId && elem.master !== 2) > 0) return Promise.reject(new InvalidEquipmentDataError(`Another chlorinator is installed on port #${portId}.  Only one chlorinator can be installed per port.`, 'Chlorinator', portId));
+            if (isNaN(portId)) return Promise.reject(new InvalidEquipmentDataError(`Invalid port Id`, 'Chlorinator', data.portId));
+            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;
+            
             chlor.ignoreSaltReading = (typeof data.ignoreSaltReading !== 'undefined') ? utils.makeBool(data.ignoreSaltReading) : utils.makeBool(chlor.ignoreSaltReading);
             // Do a final validation pass so we dont send this off in a mess.
             let schlor = state.chlorinators.getItemById(chlor.id, true);
@@ -114,12 +123,17 @@ export class NixieChlorinator extends NixieEquipment {
             schlor.superChlor = chlor.superChlor = superChlor;
             schlor.superChlorHours = chlor.superChlorHours = superChlorHours;
             schlor.type = chlor.type = chlorType;
-            chlor.model = model;
+            schlor.model = chlor.model = model;
             schlor.body = chlor.body = body.val;
+            chlor.portId = portId;
             chlor.disabled = disabled;
             chlor.isDosing = isDosing;
             schlor.name = chlor.name = data.name || chlor.name || `Chlorinator ${chlor.id}`;
             schlor.isActive = chlor.isActive = true;
+            if (!chlor.superChlor) {
+                this.superChlorStart = 0;
+                this.superChlorinating = false;
+            }
         }
         catch (err) { logger.error(`setChlorinatorAsync: ${err.message}`); return Promise.reject(err); }
     }
@@ -148,9 +162,23 @@ export class NixieChlorinator extends NixieEquipment {
             this.pollEquipment();
         } catch (err) { logger.error(`Error initializing ${this.chlor.name} : ${err.message}`); }
     }
-    public isBodyOn() {
-        let isOn = sys.board.bodies.isBodyOn(this.chlor.body);
-        return isOn;
+    public isBodyOn() { return sys.board.bodies.isBodyOn(this.chlor.body); }
+    public setSuperChlor(cstate: ChlorinatorState) {
+        if (this.chlor.superChlor) {
+            if (!this.superChlorinating) {
+                // Deal with the start time.
+                let hours = this.chlor.superChlorHours * 3600;
+                let offset = cstate.superChlorRemaining > 0 ? Math.max((hours - (hours - cstate.superChlorRemaining)), 0) : 0;
+                this.superChlorStart = new Date().getTime() - offset;
+                this.superChlorinating = true;
+            }
+            cstate.superChlorRemaining = this.superChlorRemaining;
+        }
+        else {
+            this.superChlorStart = 0;
+            this.superChlorinating = false;
+            cstate.superChlorRemaining = 0;
+        }
     }
     public async pollEquipment() {
         let self = this;
@@ -190,34 +218,45 @@ export class NixieChlorinator extends NixieEquipment {
             // Disable the control panel by sending an action 0 the chlorinator should respond with an action 1.
             //[16, 2, 80, 0][0][98, 16, 3]
             let success = await new Promise<boolean>((resolve, reject) => {
-                let out = Outbound.create({
-                    protocol: Protocol.Chlorinator,
-                    dest: this.chlor.id,
-                    action: 0,
-                    payload: [0],
-                    retries: 3, // IntelliCenter tries 4 times to get a response.
-                    response: Response.create({ protocol: Protocol.Chlorinator, action: 1 }),
-                    onAbort: () => {},
-                    onComplete: (err) => {
-                        if (err) {
-                            // This flag is cleared in ChlorinatorStateMessage
-                            cstate.status = 128;
-                            resolve(false);
-                        }
-                        else {
-                            // If this is successful the action 1 message will have been
-                            // digested by ChlorinatorStateMessage and the lastComm will have been set clearing the
-                            // communication lost flag.
-                            resolve(true);
+                if (conn.isPortEnabled(this.chlor.portId || 0)) {
+                    let out = Outbound.create({
+                        portId: this.chlor.portId || 0,
+                        protocol: Protocol.Chlorinator,
+                        //dest: this.chlor.id,
+                        dest: 1,
+                        action: 0,
+                        payload: [0],
+                        retries: 3, // IntelliCenter tries 4 times to get a response.
+                        response: Response.create({ protocol: Protocol.Chlorinator, action: 1 }),
+                        onAbort: () => { this.chlor.superChlor = cstate.superChlor = false; this.setSuperChlor(cstate); },
+                        onComplete: (err) => {
+                            if (err) {
+                                // This flag is cleared in ChlorinatorStateMessage
+                                this.chlor.superChlor = cstate.superChlor = false;
+                                this.setSuperChlor(cstate);
+                                cstate.status = 128;
+                                resolve(false);
+                            }
+                            else {
+                                // If this is successful the action 1 message will have been
+                                // digested by ChlorinatorStateMessage and the lastComm will have been set clearing the
+                                // communication lost flag.
+                                resolve(true);
+                            }
+                            cstate.emitEquipmentChange();
                         }
-                    }
-                });
-                conn.queueSendMessage(out);
+                    });
+                    conn.queueSendMessage(out);
+                }
+                else {
+                    cstate.status = 0;
+                    resolve(true);
+                }
             });
             return success;
         } catch (err) { logger.error(`Communication error with Chlorinator ${this.chlor.name} : ${err.message}`); }
     }
-    public async setOutput() {
+    public async setOutput(): Promise<boolean> {
         try {
             // A couple of things need to be in place before setting the output.
             // 1. The chlorinator will have to have responded to the takeControl message.
@@ -226,57 +265,63 @@ export class NixieChlorinator extends NixieEquipment {
             // 3. If we are superchlorinating and the remaing superChlor time is > 0 then we need to keep it at 100%.
             // 4. If the chlorinator disabled flag is set then we need to make sure the setpoint is 0.
             let cstate = state.chlorinators.getItemById(this.chlor.id, true);
-            let body = state.temps.bodies.getBodyIsOn();
             let setpoint = 0;
-            if (typeof body !== 'undefined') {
-                setpoint = (body.id === 1) ? this.chlor.poolSetpoint : this.chlor.spaSetpoint;
-                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.
+            if (this.isBodyOn()) {
+                if (sys.equipment.shared) {
+                    let body = state.temps.bodies.getBodyIsOn();
+                    setpoint = (body.id === 1) ? this.chlor.poolSetpoint : this.chlor.spaSetpoint;
+                }
+                else setpoint = this.chlor.body === 0 ? this.chlor.poolSetpoint : this.chlor.spaSetpoint;
+                if (this.chlor.isDosing) setpoint = 100;
+            }
+            else {
+                this.chlor.superChlor = cstate.superChlor = false;
+                this.setSuperChlor(cstate);
             }
+            if (this.chlor.disabled === true) setpoint = 0; // Our target should be 0 because we have other things going on.  For instance,
             // RKS: Not sure if it needs to be smart enough to force an off message when the comms die.
             //if (cstate.status === 128) setpoint = 0; // If we haven't been able to get a response from the clorinator tell is to turn itself off.
             // Perhaps we will be luckier on the next poll cycle.
             // Tell the chlorinator that we are to use the current output.
             //[16, 2, 80, 17][0][115, 16, 3]
-            cstate.targetOutput = setpoint;
+            cstate.targetOutput = cstate.superChlor ? 100 : setpoint;
             let success = await new Promise<boolean>((resolve, reject) => {
-                let out = Outbound.create({
-                    protocol: Protocol.Chlorinator,
-                    dest: this.chlor.id,
-                    action: 17,
-                    payload: [setpoint],
-                    retries: 7, // IntelliCenter tries 8 times to make this happen.
-                    response: Response.create({ protocol: Protocol.Chlorinator, action: 18 }),
-                    onAbort: () => {},
-                    onComplete: (err) => {
-                        if (err) {
-                            cstate.currentOutput = 0;
-                            cstate.status = 128;
-                            resolve(false);
-                        }
-                        else {
-                            // The action:17 message originated from us so we will not see it in the
-                            // ChlorinatorStateMessage module.
-                            cstate.currentOutput = setpoint;
-                            if (!this.superChlorinating && cstate.superChlor) {
-                                cstate.superChlorRemaining = cstate.superChlorHours * 3600;
-                                this.superChlorStart = Math.floor(new Date().getTime() / 1000) * 1000;
+                if (conn.isPortEnabled(this.chlor.portId || 0)) {
+                    let out = Outbound.create({
+                        portId: this.chlor.portId || 0,
+                        protocol: Protocol.Chlorinator,
+                        //dest: this.chlor.id,
+                        dest: 1,
+                        action: 17,
+                        payload: [cstate.targetOutput],
+                        retries: 7, // IntelliCenter tries 8 times to make this happen.
+                        response: Response.create({ protocol: Protocol.Chlorinator, action: 18 }),
+                        onAbort: () => { },
+                        onComplete: (err) => {
+                            if (err) {
+                                cstate.currentOutput = 0;
+                                cstate.status = 128;
+                                resolve(false);
                             }
-                            else if (cstate.superChlor) {
-                                cstate.superChlorRemaining = cstate.superChlorHours * 3600 - ((Math.floor(new Date().getTime() / 1000) * 1000) - this.superChlorStart);
+                            else {
+                                cstate.currentOutput = cstate.targetOutput;
+                                this.setSuperChlor(cstate);
+                                resolve(true);
                             }
-                            else if (!cstate.superChlor)
-                                cstate.superChlorRemaining = 0;
-                            resolve(true);
                         }
-                    }
-                });
-                // #338
-                if (setpoint === 16) { out.appendPayloadByte(0); }
-                conn.queueSendMessage(out);
+                    });
+                    // #338
+                    if (setpoint === 16) { out.appendPayloadByte(0); }
+                    conn.queueSendMessage(out);
+                }
+                else {
+                    cstate.currentOutput = cstate.targetOutput;
+                    this.setSuperChlor(cstate);
+                    resolve(true);
+                }
             });
-
+            cstate.emitEquipmentChange();
+            return success;
         } catch (err) { logger.error(`Communication error with Chlorinator ${this.chlor.name} : ${err.message}`); return Promise.reject(err);}
 
     }
@@ -290,25 +335,29 @@ export class NixieChlorinator extends NixieEquipment {
                 // Ask the chlorinator for its model.
                 //[16, 2, 80, 20][0][118, 16, 3]
                 let success = await new Promise<boolean>((resolve, reject) => {
-                    let out = Outbound.create({
-                        protocol: Protocol.Chlorinator,
-                        dest: this.chlor.id,
-                        action: 20,
-                        payload: [0],
-                        retries: 3, // IntelliCenter tries 4 times to get a response.
-                        response: Response.create({ protocol: Protocol.Chlorinator, action: 3 }),
-                        onAbort: () => { },
-                        onComplete: (err) => {
-                            if (err) resolve(false);
-                            else resolve(true);
-                        }
-                    });
-                    conn.queueSendMessage(out);
+                    if (conn.isPortEnabled(this.chlor.portId || 0)) {
+                        let out = Outbound.create({
+                            portId: this.chlor.portId || 0,
+                            protocol: Protocol.Chlorinator,
+                            //dest: this.chlor.id,
+                            dest: 1,
+                            action: 20,
+                            payload: [0],
+                            retries: 3, // IntelliCenter tries 4 times to get a response.
+                            response: Response.create({ protocol: Protocol.Chlorinator, action: 3 }),
+                            onAbort: () => { },
+                            onComplete: (err) => {
+                                if (err) resolve(false);
+                                else resolve(true);
+                            }
+                        });
+                        conn.queueSendMessage(out);
+                    }
+                    else { resolve(true); }
                 });
+                return success;
             }
-            else return Promise.resolve(false);
+            else return false;
         } catch (err) { logger.error(`Communication error with Chlorinator ${this.chlor.name} : ${err.message}`); return Promise.reject(err);}
-
     }
-
 }

package/controller/nixie/circuits/Circuit.ts

@@ -8,6 +8,7 @@ import { CircuitState, state, ICircuitState, } from "../../State";
 import { setTimeout, clearTimeout } from 'timers';
 import { NixieControlPanel } from '../Nixie';
 import { webApp, InterfaceServerResponse } from "../../../web/Server";
+import { delayMgr } from '../../../controller/Lockouts';
 
 export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircuit> {
     public pollingInterval: number = 2000;
@@ -23,7 +24,7 @@ export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircui
             }
         } catch (err) { return Promise.reject(`Nixie Control Panel deleteCircuitAsync ${err.message}`); }
     }
-    public async sendOnOffSequenceAsync(id: number, count: number) {
+    public async sendOnOffSequenceAsync(id: number, count: number | { isOn: boolean, timeout: number }[]) {
         try {
             let c: NixieCircuit = this.find(elem => elem.id === id) as NixieCircuit;
             if (typeof c === 'undefined') return Promise.reject(new Error(`NCP: Circuit ${id} could not be found to send sequence ${count}.`));
@@ -60,7 +61,7 @@ export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircui
      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}`); }
+    } catch (err) { logger.error(`NCP: Error synching circuit states: ${err}`); }
     }
     public async initAsync(circuits: CircuitCollection) {
         try {
@@ -118,6 +119,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; }
@@ -127,17 +132,20 @@ export class NixieCircuit extends NixieEquipment {
         }
         catch (err) { logger.error(`Nixie setCircuitAsync: ${err.message}`); return Promise.reject(err); }
     }
-    public async sendOnOffSequenceAsync(count: number, timeout?:number): Promise<InterfaceServerResponse> {
+    public async sendOnOffSequenceAsync(count: number | { isOn: boolean, timeout: number }[], timeout?:number): Promise<InterfaceServerResponse> {
         try {
             this._sequencing = true;
             let arr = [];
-            let t = typeof timeout === 'undefined' ? 100 : timeout;
-            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: true, timeout: t });
-                if(i < count - 1) arr.push({ isOn: false, timeout: t });
+            if (typeof count === 'number') {
+                let t = typeof timeout === 'undefined' ? 100 : timeout;
+                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: true, timeout: t });
+                    if (i < count - 1) arr.push({ isOn: false, timeout: t });
+                }
             }
+            else arr = count;
             // The documentation for IntelliBrite is incorrect.  The sequence below will give us Party mode.
             // Party mode:2
             // Start: Off
@@ -157,7 +165,15 @@ export class NixieCircuit extends NixieEquipment {
         } 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}`);
@@ -169,18 +185,30 @@ 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;
+                if (val && val !== cstate.isOn){
+                    sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(cstate.id), cstate, val);
+                }
+                else if (!val){
+                    if (cstate.manualPriorityActive) delayMgr.cancelManualPriorityDelay(cstate.id);
+                    cstate.manualPriorityActive = false; // if the delay was previously cancelled, still need to turn this off
+                } 
+                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) {
-                sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(cstate.id), cstate, val);
-                cstate.isOn = 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;
+                if (val && val !== cstate.isOn){
+                    sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(cstate.id), cstate, val);
+                }
+                else if (!val){
+                    delayMgr.cancelManualPriorityDelays();
+                    cstate.manualPriorityActive = false; // if the delay was previously cancelled, still need to turn this off
+                } 
+                cstate.isOn = val;
             }
             return res;
         } catch (err) { logger.error(`Nixie: Error setting circuit state ${cstate.id}-${cstate.name} to ${val}`); }
@@ -190,9 +218,11 @@ export class NixieCircuit extends NixieEquipment {
         // (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();
+            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}`); }
     }
@@ -220,6 +250,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();
         }