nodejs-poolcontroller 7.7.0 → 8.0.1

package/controller/nixie/chemistry/Chlorinator.ts

@@ -4,12 +4,13 @@ import { logger } from '../../../logger/Logger';
 
 import { NixieEquipment, NixieChildEquipment, NixieEquipmentCollection, INixieControlPanel } from "../NixieEquipment";
 import { Chlorinator, sys, ChlorinatorCollection } from "../../../controller/Equipment";
-import { ChlorinatorState, state,  } from "../../State";
-import { setTimeout, clearTimeout } from 'timers';
+import { ChlorinatorState, state, } from "../../State";
+import { setTimeout as setTimeoutSync, 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';
+import { setTimeout } from 'timers/promises';
 
 export class NixieChlorinatorCollection extends NixieEquipmentCollection<NixieChlorinator> {
     public async deleteChlorinatorAsync(id: number) {
@@ -45,6 +46,14 @@ export class NixieChlorinatorCollection extends NixieEquipmentCollection<NixieCh
         }
         catch (err) { logger.error(`setChlorinatorAsync: ${err.message}`); return Promise.reject(err); }
     }
+    public async setServiceModeAsync() {
+        try {
+            for (let i = this.length - 1; i >= 0; i--) {
+                let c = this[i] as NixieChlorinator;
+                await c.setServiceModeAsync();
+            }
+        } catch (err) { logger.error(`Nixie Chlorinator Error setServiceModeAsync: ${err.message}`) }
+    }
     public async initAsync(chlorinators: ChlorinatorCollection) {
         try {
             for (let i = 0; i < chlorinators.length; i++) {
@@ -92,6 +101,13 @@ export class NixieChlorinator extends NixieEquipment {
         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 setServiceModeAsync() {
+        let cstate = state.chlorinators.getItemById(this.chlor.id);
+        cstate.targetOutput = 0;
+        cstate.superChlor = this.chlor.superChlor = false;
+        await this.setSuperChlor(cstate);
+        await this.sendOutputMessageAsync(cstate);
+    }
     public async setChlorinatorAsync(data: any) {
         try {
             let chlor = this.chlor;
@@ -107,14 +123,18 @@ export class NixieChlorinator extends NixieEquipment {
             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' ? sys.board.valueMaps.chlorinatorModel.encode(data.model) : chlor.model || 0;
+            let saltTarget = typeof data.saltTarget === 'number' ? parseInt(data.saltTarget, 10) : chlor.saltTarget;
+            let address = typeof data.address !== 'undefined' ? parseInt(data.address, 10) : chlor.address || 80;
             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 (chlor.portId !== 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);
@@ -126,14 +146,18 @@ export class NixieChlorinator extends NixieEquipment {
             schlor.model = chlor.model = model;
             schlor.body = chlor.body = body.val;
             chlor.portId = portId;
+            chlor.address = address;
             chlor.disabled = disabled;
+            chlor.saltTarget = saltTarget;
             chlor.isDosing = isDosing;
             schlor.name = chlor.name = data.name || chlor.name || `Chlorinator ${chlor.id}`;
             schlor.isActive = chlor.isActive = true;
+            chlor.hasChanged = true;
             if (!chlor.superChlor) {
                 this.superChlorStart = 0;
                 this.superChlorinating = false;
             }
+            this.pollEquipmentAsync();
         }
         catch (err) { logger.error(`setChlorinatorAsync: ${err.message}`); return Promise.reject(err); }
     }
@@ -159,7 +183,8 @@ export class NixieChlorinator extends NixieEquipment {
             this.closing = false;
             this._suspendPolling = 0;
             // During startup it won't be uncommon for the comms to be out.  This will be because the body will be off so don't stress it so much.
-            this.pollEquipment();
+            logger.debug(`Begin sending chlorinator messages ${this.chlor.name}`);
+            this.pollEquipmentAsync();
         } catch (err) { logger.error(`Error initializing ${this.chlor.name} : ${err.message}`); }
     }
     public isBodyOn() { return sys.board.bodies.isBodyOn(this.chlor.body); }
@@ -180,7 +205,7 @@ export class NixieChlorinator extends NixieEquipment {
             cstate.superChlorRemaining = 0;
         }
     }
-    public async pollEquipment() {
+    public async pollEquipmentAsync() {
         let self = this;
         try {
             if (this._pollTimer) {
@@ -188,14 +213,15 @@ export class NixieChlorinator extends NixieEquipment {
                 this._pollTimer = undefined;
             }
             if (!this.suspendPolling) {
-                logger.debug(`Begin sending chlorinator messages ${this.chlor.name}`);
                 try {
                     this.suspendPolling = true;
-                    if (!this.closing) await this.takeControl();
-                    if (!this.closing) await utils.sleep(300);
-                    if (!this.closing) await this.setOutput();
-                    if (!this.closing) await utils.sleep(300);
-                    if (!this.closing) await this.getModel();
+                    if (state.mode === 0) {
+                        if (!this.closing) await this.takeControlAsync();
+                        if (!this.closing) await setTimeout(300);
+                        if (!this.closing) await this.setOutputAsync();
+                        if (!this.closing) await setTimeout(300);
+                        if (!this.closing) await this.getModelAsync();
+                    }
                 } catch (err) {
                     // We only display an error here if the body is on.  The chlorinator should be powered down when it is not.
                     if (this.isBodyOn()) logger.error(`Chlorinator ${this.chlor.name} comms failure: ${err.message}`);
@@ -206,57 +232,46 @@ 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(() => {self.pollEquipment();}, this.pollingInterval); }
+        finally { if (!this.closing) this._pollTimer = setTimeoutSync(() => { self.pollEquipmentAsync(); }, this.pollingInterval); }
     }
-    public async takeControl(): Promise<boolean> {
-        try {
-            let cstate = state.chlorinators.getItemById(this.chlor.id, true);
-            // The sequence is as follows.
-            // 0 = Disabled control panel by taking control of it.
-            // 17 = Set the current setpoint
-            // 20 = Request the status
-            // 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) => {
-                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);
-                }
-                else {
-                    cstate.status = 0;
-                    resolve(true);
-                }
+    public async takeControlAsync(): Promise<void> {
+        //try {
+        let cstate = state.chlorinators.getItemById(this.chlor.id, true);
+        // The sequence is as follows.
+        // 0 = Disabled control panel by taking control of it.
+        // 17 = Set the current setpoint
+        // 20 = Request the status
+        // 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) => {
+        if (conn.isPortEnabled(this.chlor.portId || 0)) {
+            let out = Outbound.create({
+                portId: this.chlor.portId || 0,
+                protocol: Protocol.Chlorinator,
+                dest: this.chlor.address || 80,
+                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); },
             });
-            return success;
-        } catch (err) { logger.error(`Communication error with Chlorinator ${this.chlor.name} : ${err.message}`); }
+            try {
+                // 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.
+                await out.sendAsync();
+                cstate.emitEquipmentChange();
+            }
+            catch (err) {
+                logger.error(`Communication error with Chlorinator ${this.chlor.name} : ${err.message}`);
+                // This flag is cleared in ChlorinatorStateMessage
+                this.chlor.superChlor = cstate.superChlor = false;
+                this.setSuperChlor(cstate);
+                cstate.status = 128;
+            }
+        }
     }
-    public async setOutput(): Promise<boolean> {
+    public async setOutputAsync(): Promise<void> {
         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.
@@ -285,79 +300,68 @@ export class NixieChlorinator extends NixieEquipment {
             // Tell the chlorinator that we are to use the current output.
             //[16, 2, 80, 17][0][115, 16, 3]
             cstate.targetOutput = cstate.superChlor ? 100 : setpoint;
-            let success = await new Promise<boolean>((resolve, reject) => {
-                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 {
-                                cstate.currentOutput = cstate.targetOutput;
-                                this.setSuperChlor(cstate);
-                                resolve(true);
-                            }
-                        }
-                    });
-                    // #338
-                    if (setpoint === 16) { out.appendPayloadByte(0); }
-                    conn.queueSendMessage(out);
-                }
-                else {
-                    cstate.currentOutput = cstate.targetOutput;
-                    this.setSuperChlor(cstate);
-                    resolve(true);
-                }
-            });
+            await this.sendOutputMessageAsync(cstate);
             cstate.emitEquipmentChange();
-            return success;
-        } catch (err) { logger.error(`Communication error with Chlorinator ${this.chlor.name} : ${err.message}`); return Promise.reject(err);}
+        } catch (err) { logger.error(`Communication error with Chlorinator ${this.chlor.name} : ${err.message}`); return Promise.reject(err); }
 
     }
-    public async getModel() {
-        try {
-            // We only need to ask for this if we can communicate with the chlorinator.  IntelliCenter
-            // asks for this anyway but it really is gratuitous.  If the setOutput and takeControl fail
-            // then this will too.
-            let cstate = state.chlorinators.getItemById(this.chlor.id, true);
-            if (cstate.status !== 128) {
-                // Ask the chlorinator for its model.
-                //[16, 2, 80, 20][0][118, 16, 3]
-                let success = await new Promise<boolean>((resolve, reject) => {
-                    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); }
+    public async sendOutputMessageAsync(cstate: ChlorinatorState): Promise<void> {
+        if (conn.isPortEnabled(this.chlor.portId || 0)) {
+            let out = Outbound.create({
+                portId: this.chlor.portId || 0,
+                protocol: Protocol.Chlorinator,
+                dest: this.chlor.address || 80,
+                action: 17,
+                payload: [cstate.targetOutput],
+                retries: 3, // IntelliCenter tries 8 times to make this happen.
+                response: Response.create({ protocol: Protocol.Chlorinator, action: 18 }),
+                onAbort: () => { }
+            });
+            // #338
+            if (cstate.targetOutput === 16) { out.appendPayloadByte(0); }
+            try {
+                await out.sendAsync();
+                cstate.currentOutput = cstate.targetOutput;
+                this.setSuperChlor(cstate);
+            }
+            catch (err) {
+                cstate.currentOutput = 0;
+                cstate.status = 128;
+            }
+        }
+        else {
+            cstate.currentOutput = cstate.targetOutput;
+            this.setSuperChlor(cstate);
+        }
+
+    }
+    public async getModelAsync() {
+        // We only need to ask for this if we can communicate with the chlorinator.  IntelliCenter
+        // asks for this anyway but it really is gratuitous.  If the setOutput and takeControl fail
+        // then this will too.
+        // RSG - Only need to ask if the model or name isn't defined.  Added checks below.
+        let cstate = state.chlorinators.getItemById(this.chlor.id, true);
+        if (cstate.status !== 128 && (typeof cstate.model === 'undefined' || cstate.model === 0 || typeof cstate.name === 'undefined' || cstate.name === '')) {
+            // Ask the chlorinator for its model.
+            //[16, 2, 80, 20][0][118, 16, 3]
+            if (conn.isPortEnabled(this.chlor.portId || 0)) {
+                let out = Outbound.create({
+                    portId: this.chlor.portId || 0,
+                    protocol: Protocol.Chlorinator,
+                    dest: this.chlor.address || 80,
+                    action: 20,
+                    payload: [0],
+                    retries: 3, // IntelliCenter tries 4 times to get a response.
+                    response: Response.create({ protocol: Protocol.Chlorinator, action: 3 }),
+                    onAbort: () => { }
                 });
-                return success;
+                try {
+                    await out.sendAsync();
+                }
+                catch (err) {
+                    logger.error(`Communication error with Chlorinator ${this.chlor.name} : ${err.message}`);
+                }
             }
-            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

@@ -9,6 +9,7 @@ import { setTimeout, clearTimeout } from 'timers';
 import { NixieControlPanel } from '../Nixie';
 import { webApp, InterfaceServerResponse } from "../../../web/Server";
 import { delayMgr } from '../../../controller/Lockouts';
+import { time } from 'console';
 
 export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircuit> {
     public pollingInterval: number = 2000;
@@ -32,6 +33,22 @@ export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircui
 
         } catch (err) { return logger.error(`NCP: sendOnOffSequence: ${err.message}`); }
     }
+    public async setServiceModeAsync() {
+        try {
+            for (let i = this.length - 1; i >= 0; i--) {
+                try {
+                    let c = this[i] as NixieCircuit;
+                    await c.setServiceModeAsync();
+                } catch (err) { logger.error(`Error stopping Nixie Circuit ${err}`); }
+            }
+
+        } catch (err) { return logger.error(`NCP: setServiceModeAsync: ${err.message}`); }
+    }
+    public async setLightThemeAsync(id: number, theme: any) {
+            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 set light theme ${theme.name}.`));
+        await c.setLightThemeAsync(theme);
+    } catch(err) { return logger.error(`NCP: sendOnOffSequence: ${err.message}`); }
     public async setCircuitStateAsync(cstate: ICircuitState, val: boolean) {
         try {
             let c: NixieCircuit = this.find(elem => elem.id === cstate.id) as NixieCircuit;
@@ -86,7 +103,6 @@ export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircui
                     this.splice(i, 1);
                 } catch (err) { logger.error(`Error stopping Nixie Circuit ${err}`); }
             }
-
         } catch (err) { } // Don't bail if we have an errror.
     }
 
@@ -116,6 +132,7 @@ export class NixieCircuit extends NixieEquipment {
     private _sequencing = false;
     private scheduled = false;
     private timeOn: Timestamp;
+    private timeOff: Timestamp;
     constructor(ncp: INixieControlPanel, circuit: Circuit) {
         super(ncp);
         this.circuit = circuit;
@@ -124,6 +141,10 @@ export class NixieCircuit extends NixieEquipment {
         cstate.startDelay = false;
         cstate.stopDelay = false;
     }
+    public async setServiceModeAsync() {
+        let cstate = state.circuits.getItemById(this.circuit.id);
+        await this.setCircuitStateAsync(cstate, false, 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; }
     public async setCircuitAsync(data: any) {
@@ -132,49 +153,141 @@ export class NixieCircuit extends NixieEquipment {
         }
         catch (err) { logger.error(`Nixie setCircuitAsync: ${err.message}`); return Promise.reject(err); }
     }
-    public async sendOnOffSequenceAsync(count: number | { isOn: boolean, timeout: number }[], timeout?:number): Promise<InterfaceServerResponse> {
+    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 });
+        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 });
+        }
+        console.log(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 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.
+        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: 12000 }); // Turn off for 12 seconds
+            arr.push({ isOn: true, timeout: 1000 });
+            ptheme = sys.board.valueMaps.lightThemes.findItem('voodoolounge');
+        }
+        else if (!cstate.isOn) {
+            if (typeof this.timeOff === 'undefined' || new Date().getTime() - this.timeOff.getTime() > 15000) {
+                // We have been off for more than 15 seconds so we need to turn it on then wait for 17 seconds while the safety light processes.
+                arr.push({ isOn: true, timeout: 17000 }); // Crazy pants
+            }
+            else arr.push({ isOn: true, timeout: 1000 }); // Start with on
+        }
+        let count = theme.sequence - ptheme.sequence;
+        if (count < 0) count = count + 17;
+        for (let i = 0; i < count; i++) {
+            arr.push({ isOn: true, timeout: 200 }); // Use 200ms since @Crewski verified 200ms is reliable
+            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;
+    }
+    // This method only dispatches to the proper light setting algorithm.  Previously we assumed that simply switching on/off sequences the proper
+    // number of times was all there was but the nutcases who make these things must torture small animals.
+    public async setLightThemeAsync(theme: any) {
         try {
             this._sequencing = true;
+            let res = new InterfaceServerResponse(200, 'Success');
             let arr = [];
+            let cstate = state.circuits.getItemById(this.circuit.id);
+            let type = sys.board.valueMaps.circuitFunctions.transform(this.circuit.type);
+            // Now set the command state so that users do not get all button mashy.
+            cstate.action = sys.board.valueMaps.circuitActions.getValue('settheme');
+            cstate.emitEquipmentChange();
+            switch (type.name) {
+                case 'colorcascade':
+                case 'globrite':
+                case 'pooltone':
+                case 'magicstream':
+                case 'intellibrite':
+                    res = await this.setIntelliBriteThemeAsync(cstate, theme);
+                    break;
+                case 'colorlogic':
+                    res = await this.setColorLogicThemeAsync(cstate, theme);
+                    break;
+            }
+            cstate.action = 0;
+            // Make sure clients know that we are done.
+            cstate.emitEquipmentChange();
+            return res;
+        } catch (err) { logger.error(`Nixie: Error setting lighting theme ${this.id} - ${theme.desc}: ${err.message}`); }
+        finally { this._sequencing = false; }
+    }
+    public async sendOnOffSequenceAsync(count: number | { isOn: boolean, timeout: number }[], timeout?: number): Promise<InterfaceServerResponse> {
+        try {
+           
+            this._sequencing = true;
+            let arr = [];
+            let cstate = state.circuits.getItemById(this.circuit.id);
+            
             if (typeof count === 'number') {
+                if (cstate.isOn) arr.push({ isOn: false, timeout: 1000 });
                 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.
+                //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 (i < count - 1) {
+                        arr.push({ isOn: true, timeout: t });
+                        arr.push({ isOn: false, timeout: t });
+                    }
+                    else arr.push({ isOn: true, timeout: 1000 });
                 }
+                console.log(arr);
             }
             else arr = count;
-            // The documentation for IntelliBrite is incorrect.  The sequence below will give us Party mode.
-            // Party mode:2
-            // Start: Off
-            // On
-            // Off
-            // On
-            // According to the docs this is the sequence they lay out.
-            // Party mode:2
-            // Start: On
-            // Off
-            // On
-            // Off
-            // On
-
             let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, arr, 60000);
+            // 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;
         } catch (err) { logger.error(`Nixie: Error sending circuit sequence ${this.id}: ${count}`); }
         finally { this._sequencing = false; }
     }
-    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 {
+            // Lets do some special processing here for service mode
+            if (state.mode !== 0 && val) {
+                // Always set the state to off if we are in service mode for bodies.  Other circuits
+                // may actually be turned on but only if they are not one of the body circuits.
+                switch (sys.board.valueMaps.circuitFunctions.getName(this.circuit.type)) {
+                    case 'pool':
+                    case 'spa':
+                    case 'chemrelay':
+                        val = false;
+                        break;
+                }
+            }
             if (val !== cstate.isOn) {
                 logger.info(`NCP: Setting Circuit ${cstate.name} to ${val}`);
                 if (cstate.isOn && val) {
@@ -199,15 +312,43 @@ export class NixieCircuit extends NixieEquipment {
             let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, { isOn: val, latch: val ? 10000 : undefined });
             if (res.status.code === 200) {
                 // Set this up so we can process our egg timer.
-                //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);
+                    switch (sys.board.valueMaps.circuitFunctions.getName(this.circuit.type)) {
+                        case 'colorlogic':
+                            if (!this._sequencing) {
+                                // We need a little bit of special time for ColorLogic circuits.  
+                                let timeDiff = typeof this.timeOff === 'undefined' ? 30000 : new Date().getTime() - this.timeOff.getTime();
+                                //logger.info(`Resetting ColorLogic themes ${cstate.isOn}:${val} ${cstate.lightingTheme}... ${timeDiff}`);
+                                if (timeDiff > 15000) {
+                                    // There is this wacko thing that the lights will come on white for 15 seconds
+                                    // so we need to make sure they don't try to advance the theme setting during this period.  We will simply set this to a holding pattern for
+                                    // that timeframe.
+                                    cstate.action = sys.board.valueMaps.circuitActions.getValue('settheme');
+                                    let theme = cstate.lightingTheme;
+                                    cstate.lightingTheme = sys.board.valueMaps.lightThemes.getValue('cloudwhite');
+                                    cstate.startDelay = true;
+                                    setTimeout(() => { cstate.startDelay = false; cstate.action = 0; cstate.lightingTheme = theme; cstate.emitEquipmentChange(); }, 17000);
+                                }
+                                else if (timeDiff <= 10000) {
+                                    // If the user turns the light back on within 10 seconds.  Surprise!  You are forced into the next theme.
+                                    let thm = sys.board.valueMaps.lightThemes.get(cstate.lightingTheme);
+                                    let themes = this.circuit.getLightThemes();
+                                    cstate.lightingTheme = thm.sequence === 17 ? themes.find(elem => elem.sequence === 1).val : themes.find(elem => elem.sequence === thm.sequence + 1).val;
+                                }
+                                else if (timeDiff <= 15000) {
+                                    // If the user turns the light back on before 15 seconds expire then we are going to do voodoo.  Switch the theme to voodoolounge.
+                                    cstate.lightingTheme = sys.board.valueMaps.lightThemes.getValue('voodoolounge');
+                                }
+                            }
+                            break;
+                    }
                 }
                 else if (!val){
                     delayMgr.cancelManualPriorityDelays();
                     cstate.manualPriorityActive = false; // if the delay was previously cancelled, still need to turn this off
-                } 
+                }
+                if (!val && cstate.isOn) this.timeOff = new Timestamp();
                 cstate.isOn = val;
             }
             return res;