nodejs-poolcontroller 7.2.0 → 7.5.1

package/controller/boards/NixieBoard.ts

@@ -50,7 +50,8 @@ export class NixieBoard extends SystemBoard {
             [10, { name: 'colorcascade', desc: 'ColorCascade', isLight: true }],
             [11, { name: 'mastercleaner2', desc: 'Master Cleaner 2' }],
             [12, { name: 'pool', desc: 'Pool', hasHeatSource: true }],
-            [13, { name: 'spa', desc: 'Spa', hasHeatSource: true }]
+            [13, { name: 'spa', desc: 'Spa', hasHeatSource: true }],
+            [14, { name: 'colorlogic', desc: 'ColorLogic', isLight:true }]
         ]);
         this.valueMaps.pumpTypes = new byteValueMap([
             [1, { name: 'ss', desc: 'Single Speed', maxCircuits: 0, hasAddress: false, hasBody: true, maxRelays: 1 }],
@@ -81,6 +82,20 @@ export class NixieBoard extends SystemBoard {
             [2, { name: 'off', desc: 'Off' }],
             [3, { name: 'ignore', desc: 'Ignore' }]
         ]);
+        this.valueMaps.chlorinatorModel = new byteValueMap([
+            [0, { name: 'unknown', desc: 'unknown', capacity: 0, chlorinePerDay: 0, chlorinePerSec: 0 }],
+            [1, { name: 'intellichlor--15', desc: 'IntelliChlor IC15', capacity: 15000, chlorinePerDay: 0.60, chlorinePerSec: 0.60 / 86400 }],
+            [2, { name: 'intellichlor--20', desc: 'IntelliChlor IC20', capacity: 20000, chlorinePerDay: 0.70, chlorinePerSec: 0.70 / 86400 }],
+            [3, { name: 'intellichlor--40', desc: 'IntelliChlor IC40', capacity: 40000, chlorinePerDay: 1.40, chlorinePerSec: 1.4 / 86400 }],
+            [4, { name: 'intellichlor--60', desc: 'IntelliChlor IC60', capacity: 60000, chlorinePerDay: 2, chlorinePerSec: 2 / 86400 }],
+            [5, { name: 'aquarite-t15', desc: 'AquaRite T15', capacity: 40000, chlorinePerDay: 1.47, chlorinePerSec: 1.47 / 86400 }],
+            [6, { name: 'aquarite-t9', desc: 'AquaRite T9', capacity: 30000, chlorinePerDay: 0.98, chlorinePerSec: 0.98 / 86400 }],
+            [7, { name: 'aquarite-t5', desc: 'AquaRite T5', capacity: 20000, chlorinePerDay: 0.735, chlorinePerSec: 0.735 / 86400 }],
+            [8, { name: 'aquarite-t3', desc: 'AquaRite T3', capacity: 15000, chlorinePerDay: 0.53, chlorinePerSec: 0.53 / 86400 }],
+            [9, { name: 'aquarite-925', desc: 'AquaRite 925', capacity: 25000, chlorinePerDay: 0.98, chlorinePerSec: 0.98 / 86400 }],
+            [10, { name: 'aquarite-940', desc: 'AquaRite 940', capacity: 40000, chlorinePerDay: 1.47, chlorinePerSec: 1.47 / 86400 }]
+        ]);
+
 
         // Keep this around for now so I can fart with the custom names array.
         //this.valueMaps.customNames = new byteValueMap(
@@ -126,7 +141,9 @@ export class NixieBoard extends SystemBoard {
             [1, { name: 'sunrise', desc: 'Sunrise' }],
             [2, { name: 'sunset', desc: 'Sunset' }]
         ]);
+
         this.valueMaps.lightThemes = new byteValueMap([
+            // IntelliBrite Themes
             [0, { name: 'white', desc: 'White', type: 'intellibrite', sequence: 11 }],
             [1, { name: 'green', desc: 'Green', type: 'intellibrite', sequence: 9 }],
             [2, { name: 'blue', desc: 'Blue', type: 'intellibrite', sequence: 8 }],
@@ -139,6 +156,24 @@ export class NixieBoard extends SystemBoard {
             [9, { name: 'american', desc: 'American', type: 'intellibrite', sequence: 5 }],
             [10, { name: 'sunset', desc: 'Sunset', type: 'intellibrite', sequence: 6 }],
             [11, { name: 'royal', desc: 'Royal', type: 'intellibrite', sequence: 7 }],
+            // ColorLogic Themes
+            [20, { name: 'cloudwhite', desc: 'Cloud White', type: 'colorlogic', sequence: 7 }],
+            [21, { name: 'deepsea', desc: 'Deep Sea', type: 'colorlogic', sequence: 2 }],
+            [22, { name: 'royalblue', desc: 'Royal Blue', type: 'colorlogic', sequence: 3 }],
+            [23, { name: 'afternoonskies', desc: 'Afternoon Skies', type: 'colorlogic', sequence: 4 }],
+            [24, { name: 'aquagreen', desc: 'Aqua Green', type: 'colorlogic', sequence: 5 }],
+            [25, { name: 'emerald', desc: 'Emerald', type: 'colorlogic', sequence: 6 }],
+            [26, { name: 'warmred', desc: 'Warm Red', type: 'colorlogic', sequence: 8 }],
+            [27, { name: 'flamingo', desc: 'Flamingo', type: 'colorlogic', sequence: 9 }],
+            [28, { name: 'vividviolet', desc: 'Vivid Violet', type: 'colorlogic', sequence: 10 }],
+            [29, { name: 'sangria', desc: 'Sangria', type: 'colorlogic', sequence: 11 }],
+            [30, { name: 'twilight', desc: 'Twilight', type: 'colorlogic', sequence: 12 }],
+            [31, { name: 'tranquility', desc: 'Tranquility', type: 'colorlogic', sequence: 13 }],
+            [32, { name: 'gemstone', desc: 'Gemstone', type: 'colorlogic', sequence: 14 }],
+            [33, { name: 'usa', desc: 'USA', type: 'colorlogic', sequence: 15 }],
+            [34, { name: 'mardigras', desc: 'Mardi Gras', type: 'colorlogic', sequence: 16 }],
+            [35, { name: 'coolcabaret', desc: 'Cabaret', type: 'colorlogic', sequence: 17 }],
+
             [255, { name: 'none', desc: 'None' }]
         ]);
         this.valueMaps.lightColors = new byteValueMap([
@@ -185,6 +220,7 @@ export class NixieBoard extends SystemBoard {
     public async initNixieBoard() {
         try {
             this.killStatusCheck();
+            let self = this;
             sys.general.options.clockSource = 'server';
             state.status = sys.board.valueMaps.controllerStatus.transform(0, 0);
             // First lets clear out all the messages.
@@ -224,7 +260,8 @@ export class NixieBoard extends SystemBoard {
             sys.equipment.maxCustomNames = 0;
             state.equipment.model = type.desc;
             state.equipment.maxBodies = sys.equipment.maxBodies = type.bodies;
-            
+            let bodyUnits = sys.general.options.units === 0 ? 1 : 2;
+
             if (typeof state.temps.units === 'undefined' || state.temps.units < 0) state.temps.units = sys.general.options.units;
             if (type.bodies > 0) {
                 let pool = sys.bodies.getItemById(1, true);
@@ -236,6 +273,7 @@ export class NixieBoard extends SystemBoard {
                 pool.circuit = 6;
                 pool.isActive = true;
                 pool.master = 1;
+                pool.capacityUnits = bodyUnits;
                 sbody.name = pool.name;
                 sbody.setPoint = pool.setPoint;
                 sbody.circuit = pool.circuit;
@@ -271,6 +309,7 @@ export class NixieBoard extends SystemBoard {
                     sbody.setPoint = spa.setPoint;
                     sbody.circuit = spa.circuit;
                     sbody.type = spa.type;
+                    spa.capacityUnits = bodyUnits;
                     scirc = state.circuits.getItemById(1, true);
                     scirc.showInFeatures = circ.showInFeatures;
                     scirc.type = circ.type;
@@ -294,6 +333,7 @@ export class NixieBoard extends SystemBoard {
                 sys.circuits.removeItemById(6);
                 state.circuits.removeItemById(6);
             }
+            
             sys.equipment.setEquipmentIds();
             sys.board.bodies.initFilters();
             state.status = sys.board.valueMaps.controllerStatus.transform(2, 0);
@@ -308,6 +348,7 @@ export class NixieBoard extends SystemBoard {
             total += sys.valves.length;
             total += sys.schedules.length;
             this.initValves();
+            sys.board.heaters.initTempSensors();
             await this.verifySetup();
             await ncp.initAsync(sys);
             sys.board.heaters.updateHeaterServices();
@@ -315,7 +356,7 @@ export class NixieBoard extends SystemBoard {
             logger.info(`${sys.equipment.model} control board initialized`);
             state.status = sys.board.valueMaps.controllerStatus.transform(1, 100);
             // At this point we should have the start of a board so lets check to see if we are ready or if we are stuck initializing.
-            setTimeout(() => this.processStatusAsync(), 5000);
+            setTimeout(() => self.processStatusAsync(), 5000);
         } catch (err) { state.status = 255; logger.error(`Error Initializing Nixie Control Panel ${err.message}`); }
     }
     public initValves() {
@@ -476,15 +517,14 @@ export class NixieCircuitCommands extends CircuitCommands {
             else if (id === 1) state.temps.bodies.getItemById(2, true).isOn = val;
             // Let the main nixie controller set the circuit state and affect the relays if it needs to.
             await ncp.circuits.setCircuitStateAsync(circ, newState);
+            await sys.board.processStatusAsync();
             return state.circuits.getInterfaceById(circ.id);
         }
         catch (err) { return Promise.reject(`Nixie: Error setCircuitStateAsync ${err.message}`); }
         finally {
             state.emitEquipmentChanges();
-            // sys.board.virtualPumpControllers.start();
             ncp.pumps.syncPumpStates();
             sys.board.suspendStatus(false);
-            this.board.processStatusAsync();
         }
     }
     public toggleCircuitStateAsync(id: number): Promise<ICircuitState> {
@@ -493,6 +533,13 @@ export class NixieCircuitCommands extends CircuitCommands {
     }
     public async setLightThemeAsync(id: number, theme: number) {
         let cstate = state.circuits.getItemById(id);
+        let circ = sys.circuits.getItemById(id);
+        let thm = sys.board.valueMaps.lightThemes.findItem(theme);
+        if (typeof thm !== 'undefined' && typeof thm.sequence !== 'undefined' && circ.master === 1) {
+            logger.info(`Setting light theme for ${circ.name} to ${thm.name} [${thm.sequence}]`);
+            await sys.board.circuits.setCircuitStateAsync(id, true);
+            await ncp.circuits.sendOnOffSequenceAsync(id, thm.sequence);
+        }
         cstate.lightingTheme = theme;
         return Promise.resolve(cstate as ICircuitState);
     }
@@ -549,7 +596,15 @@ export class NixieCircuitCommands extends CircuitCommands {
         }
         return arrRefs;
     }
-    public getLightThemes(type?: number) { return sys.board.valueMaps.lightThemes.toArray(); }
+    public getLightThemes(type?: number) {
+        let tobj = (typeof type === 'undefined') ? sys.board.valueMaps.circuitFunctions.transformByName('intellibrite') : sys.board.valueMaps.circuitFunctions.transform(type);
+        let arrThemes = sys.board.valueMaps.lightThemes.toArray();
+        let arr = [];
+        for (let i = 0; i < arrThemes.length; i++) {
+            if (tobj.name === arrThemes[i].type) arr.push(arrThemes[i]);
+        }
+        return arr;
+    }
     public getCircuitFunctions() { return sys.board.valueMaps.circuitFunctions.toArray(); }
     public getCircuitNames() {
         return [...sys.board.valueMaps.circuitNames.toArray(), ...sys.board.valueMaps.customNames.toArray()];
@@ -564,8 +619,8 @@ export class NixieCircuitCommands extends CircuitCommands {
             if (isNaN(id) || !sys.board.equipmentIds.circuits.isInRange(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid circuit id: ${data.id}`, data.id, 'Circuit'));
             let circuit = sys.circuits.getItemById(id, true);
             let scircuit = state.circuits.getItemById(id, true);
-            circuit.isActive = true;
-            scircuit.isOn = false;
+            scircuit.isActive = circuit.isActive = true;
+            circuit.master = 1;
             if (data.name) circuit.name = scircuit.name = data.name;
             else if (!circuit.name && !data.name) circuit.name = scircuit.name = Circuit.getIdName(id);
             if (typeof data.type !== 'undefined' || typeof circuit.type === 'undefined') circuit.type = scircuit.type = parseInt(data.type, 10) || 0;
@@ -586,8 +641,14 @@ export class NixieCircuitCommands extends CircuitCommands {
         let group: CircuitGroup = null;
         let id = typeof obj.id !== 'undefined' ? parseInt(obj.id, 10) : -1;
         if (id <= 0) {
-            // We are adding a circuit group.
-            id = sys.circuitGroups.getNextEquipmentId(sys.board.equipmentIds.circuitGroups);
+            // We are adding a circuit group so we need to get the next equipment id.  For circuit groups and light groups, they share ids.
+            let range = sys.board.equipmentIds.circuitGroups;
+            for (let i = range.start; i <= range.end; i++) {
+                if (!sys.lightGroups.find(elem => elem.id === i) && !sys.circuitGroups.find(elem => elem.id === i)) {
+                    id = i;
+                    break;
+                }
+            }
         }
         if (typeof id === 'undefined') return Promise.reject(new InvalidEquipmentIdError(`Max circuit group id exceeded`, id, 'CircuitGroup'));
         if (isNaN(id) || !sys.board.equipmentIds.circuitGroups.isInRange(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid circuit group id: ${obj.id}`, obj.id, 'CircuitGroup'));
@@ -619,7 +680,7 @@ export class NixieCircuitCommands extends CircuitCommands {
                     //RKS: 09-26-20 There is no such thing as a lighting theme on a circuit group circuit.  That is what lighGroups are for.
                     //if (typeof cobj.lightingTheme !== 'undefined') c.lightingTheme = parseInt(cobj.lightingTheme, 10);
                 }
-                // group.circuits.length = obj.circuits.length;  // RSG - removed as this will delete circuits that were not changed
+                group.circuits.length = obj.circuits.length;  // RSG - removed as this will delete circuits that were not changed
             }
             resolve(group);
         });
@@ -629,14 +690,21 @@ export class NixieCircuitCommands extends CircuitCommands {
         let group: LightGroup = null;
         let id = typeof obj.id !== 'undefined' ? parseInt(obj.id, 10) : -1;
         if (id <= 0) {
-            // We are adding a circuit group.
-            id = sys.circuitGroups.getNextEquipmentId(sys.board.equipmentIds.circuitGroups);
+            // We are adding a circuit group so we need to get the next equipment id.  For circuit groups and light groups, they share ids.
+            let range = sys.board.equipmentIds.circuitGroups;
+            for (let i = range.start; i <= range.end; i++) {
+                if (!sys.lightGroups.find(elem => elem.id === i) && !sys.circuitGroups.find(elem => elem.id === i)) {
+                    id = i;
+                    break;
+                }
+            }
         }
         if (typeof id === 'undefined') return Promise.reject(new InvalidEquipmentIdError(`Max circuit light group id exceeded`, id, 'LightGroup'));
         if (isNaN(id) || !sys.board.equipmentIds.circuitGroups.isInRange(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid circuit group id: ${obj.id}`, obj.id, 'LightGroup'));
         group = sys.lightGroups.getItemById(id, true);
+        let sgroup = state.lightGroups.getItemById(id, true);
         return new Promise<LightGroup>((resolve, reject) => {
-            if (typeof obj.name !== 'undefined') group.name = obj.name;
+            if (typeof obj.name !== 'undefined') sgroup.name = group.name = obj.name;
             if (typeof obj.dontStop !== 'undefined' && utils.makeBool(obj.dontStop) === true) obj.eggTimer = 1440;
             if (typeof obj.eggTimer !== 'undefined') group.eggTimer = Math.min(Math.max(parseInt(obj.eggTimer, 10), 0), 1440);
             group.dontStop = group.eggTimer === 1440;
@@ -654,7 +722,11 @@ export class NixieCircuitCommands extends CircuitCommands {
                     if (typeof cobj.swimDelay !== 'undefined') c.swimDelay = parseInt(cobj.swimDelay, 10);
                     if (typeof cobj.position !== 'undefined') c.position = parseInt(cobj.position, 10);
                 }
+                // RKS: 09-25-21 - This has to be here.  Not sure the goal of not setting the entire circuit array when saving the group.
                 // group.circuits.length = obj.circuits.length; // RSG - removed as this will delete circuits that were not changed
+                group.circuits.length = obj.circuits.length;
+                sgroup.emitEquipmentChange();
+                
             }
             resolve(group);
         });
@@ -696,24 +768,30 @@ export class NixieCircuitCommands extends CircuitCommands {
             return Promise.reject(new InvalidEquipmentIdError('Group id has not been defined', id, 'LightGroup'));
     }
     public async deleteCircuitAsync(data: any): Promise<ICircuit> {
-        if (typeof data.id === 'undefined') return Promise.reject(new InvalidEquipmentIdError('You must provide an id to delete a circuit', data.id, 'Circuit'));
-        let circuit = sys.circuits.getInterfaceById(data.id);
+        let id = parseInt(data.id, 10);
+        if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid circuit id: ${data.id}`, data.id, 'Circuit'));
+        if (!sys.board.equipmentIds.circuits.isInRange(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid circuit id: ${data.id}`, data.id, 'Circuit'));
+        let circuit = sys.circuits.getInterfaceById(id);
+        let cstate = state.circuits.getInterfaceById(id);
         if (circuit instanceof Circuit) {
-            sys.circuits.removeItemById(data.id);
-            state.circuits.removeItemById(data.id);
+            sys.circuits.removeItemById(circuit.id);
+            state.circuits.removeItemById(circuit.id);
+            cstate.isActive = circuit.isActive = false;
         }
         if (circuit instanceof Feature) {
-            sys.features.removeItemById(data.id);
-            state.features.removeItemById(data.id);
+            sys.features.removeItemById(circuit.id);
+            state.features.removeItemById(circuit.id);
+            cstate.isActive = circuit.isActive = false;
         }
+        cstate.emitEquipmentChange();
         return new Promise<ICircuit>((resolve, reject) => { resolve(circuit); });
     }
     public deleteCircuit(data: any) {
         if (typeof data.id !== 'undefined') {
             let circuit = sys.circuits.getInterfaceById(data.id);
             if (circuit instanceof Circuit) {
-                sys.circuits.removeItemById(data.id);
-                state.circuits.removeItemById(data.id);
+                sys.circuits.removeItemById(circuit.id);
+                state.circuits.removeItemById(circuit.id);
                 return;
             }
             if (circuit instanceof Feature) {
@@ -800,13 +878,21 @@ export class NixieCircuitCommands extends CircuitCommands {
     }
     public async setCircuitGroupStateAsync(id: number, val: boolean): Promise<ICircuitGroupState> {
         let grp = sys.circuitGroups.getItemById(id, false, { isActive: false });
-        let gstate = (grp.dataName === 'circuitGroupConfig') ? state.circuitGroups.getItemById(grp.id, grp.isActive !== false) : state.lightGroups.getItemById(grp.id, grp.isActive !== false);
+        if (grp.dataName !== 'circuitGroupConfig') return await sys.board.circuits.setLightGroupStateAsync(id, val);
+        let gstate = state.circuitGroups.getItemById(grp.id, grp.isActive !== false);
         let circuits = grp.circuits.toArray();
+        sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(gstate.id), gstate, val);
         gstate.isOn = val;
         let arr = [];
         for (let i = 0; i < circuits.length; i++) {
             let circuit = circuits[i];
-            arr.push(sys.board.circuits.setCircuitStateAsync(circuit.circuit, val));
+            // The desiredState will be as follows.
+            // 1 = on, 2 = off, 3 = ignore.
+            let cval = true;
+            if (circuit.desiredState === 1) cval = val ? true : false;
+            else if (circuit.desiredState === 2) cval = val ? false : true;
+            else continue;
+            arr.push(sys.board.circuits.setCircuitStateAsync(circuit.circuit, cval));
         }
         return new Promise<ICircuitGroupState>(async (resolve, reject) => {
             await Promise.all(arr).catch((err) => { reject(err) });
@@ -814,16 +900,22 @@ export class NixieCircuitCommands extends CircuitCommands {
         });
     }
     public async setLightGroupStateAsync(id: number, val: boolean): Promise<ICircuitGroupState> {
-        return sys.board.circuits.setCircuitGroupStateAsync(id, val);
+        let grp = sys.circuitGroups.getItemById(id, false, { isActive: false });
+        if (grp.dataName === 'circuitGroupConfig') return await sys.board.circuits.setCircuitGroupStateAsync(id, val);
+        let gstate = state.lightGroups.getItemById(grp.id, grp.isActive !== false);
+        let circuits = grp.circuits.toArray();
+        sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(gstate.id), gstate, val);
+        gstate.isOn = val;
+        let arr = [];
+        for (let i = 0; i < circuits.length; i++) {
+            let circuit = circuits[i];
+            arr.push(sys.board.circuits.setCircuitStateAsync(circuit.circuit, val));
+        }
+        return new Promise<ICircuitGroupState>(async (resolve, reject) => {
+            await Promise.all(arr).catch((err) => { reject(err) });
+            resolve(gstate);
+        });
     }
-    /*     public sequenceIntelliBrite(operation: string) {
-            state.intellibrite.hasChanged = true;
-            let nop = sys.board.valueMaps.intellibriteActions.getValue(operation);
-            if (nop > 0) {
-                state.intellibrite.action = nop;
-                setTimeout(function() { state.intellibrite.action = 0; state.emitEquipmentChanges(); }, 20000); // It takes 20 seconds to sequence.
-            }
-        } */
 }
 export class NixieFeatureCommands extends FeatureCommands {
     public async setFeatureAsync(obj: any): Promise<Feature> {
@@ -864,6 +956,7 @@ export class NixieFeatureCommands extends FeatureCommands {
             feature.isActive = false;
             sfeature.isOn = false;
             sfeature.showInFeatures = false;
+            sfeature.isActive = false;
             sfeature.emitEquipmentChange();
             return new Promise<Feature>((resolve, reject) => { resolve(feature); });
         }
@@ -876,9 +969,9 @@ export class NixieFeatureCommands extends FeatureCommands {
             if (!sys.board.equipmentIds.features.isInRange(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid feature id: ${id}`, id, 'Feature'));
             let feature = sys.features.getItemById(id);
             let fstate = state.features.getItemById(feature.id, feature.isActive !== false);
+            sys.board.circuits.setEndTime(feature, fstate, val);
             fstate.isOn = val;
             sys.board.valves.syncValveStates();
-            // sys.board.virtualPumpControllers.start();
             ncp.pumps.syncPumpStates();
             state.emitEquipmentChanges();
             return fstate;
@@ -889,39 +982,48 @@ export class NixieFeatureCommands extends FeatureCommands {
         return this.setFeatureStateAsync(id, !(feat.isOn || false));
     }
     public syncGroupStates() {
+        // The way this should work is that when all of the states are met
+        // the group should be on.  Otherwise it should be off.  That means that if
+        // you turned on all the group circuits that should be on individually then
+        // the group should be on.
         for (let i = 0; i < sys.circuitGroups.length; i++) {
             let grp: CircuitGroup = sys.circuitGroups.getItemByIndex(i);
             let circuits = grp.circuits.toArray();
-            let bIsOn = false;
             if (grp.isActive) {
-                for (let j = 0; j < circuits.length; j++) {
-                    let circuit: CircuitGroupCircuit = grp.circuits.getItemById(j);
+                let bIsOn = true;
+                // Iterate the circuits and break out should we find a condition
+                // where the group should be off.
+                for (let j = 0; j < circuits.length && bIsOn === true; j++) {
+                    let circuit: CircuitGroupCircuit = grp.circuits.getItemByIndex(j);
                     let cstate = state.circuits.getInterfaceById(circuit.circuit);
-                    if (circuit.desiredState === 1 || circuit.desiredState === 0) {
-                        if (cstate.isOn === utils.makeBool(circuit.desiredState)) bIsOn = true;
+                    if (circuit.desiredState === 1) { // The circuit should be on.
+                        if (!utils.makeBool(cstate.isOn)) bIsOn = false;
+                    }
+                    else if (circuit.desiredState === 0) { // The circuit should be off.
+                        if (utils.makeBool(cstate.isOn)) bIsOn = false;
                     }
                 }
+                let sgrp = state.circuitGroups.getItemById(grp.id);
+                sgrp.isOn = bIsOn;
             }
-            let sgrp = state.circuitGroups.getItemById(grp.id);
-            sgrp.isOn = bIsOn && grp.isActive;
-
             sys.board.valves.syncValveStates();
         }
         // I am guessing that there will only be one here but iterate
         // just in case we expand.
         for (let i = 0; i < sys.lightGroups.length; i++) {
             let grp: LightGroup = sys.lightGroups.getItemByIndex(i);
-            let bIsOn = false;
+            let circuits = grp.circuits.toArray();
             if (grp.isActive) {
-                let circuits = grp.circuits.toArray();
-                for (let j = 0; j < circuits.length; j++) {
-                    let circuit = grp.circuits.getItemByIndex(j).circuit;
-                    let cstate = state.circuits.getInterfaceById(circuit);
-                    if (cstate.isOn) bIsOn = true;
+                let bIsOn = true;
+                for (let j = 0; j < circuits.length && bIsOn === true; j++) {
+                    let circuit: LightGroupCircuit = grp.circuits.getItemByIndex(j);
+                    let cstate = state.circuits.getInterfaceById(circuit.circuit);
+                    if (!utils.makeBool(cstate.isOn)) bIsOn = false;
                 }
+                let sgrp = state.lightGroups.getItemById(grp.id);
+                sgrp.isOn = bIsOn;
             }
-            let sgrp = state.lightGroups.getItemById(grp.id);
-            sgrp.isOn = bIsOn;
+            sys.board.valves.syncValveStates();
         }
         state.emitEquipmentChanges();
     }
@@ -946,7 +1048,7 @@ export class NixieValveCommands extends ValveCommands {
             valve.deviceBinding = typeof obj.deviceBinding !== 'undefined' ? obj.deviceBinding : valve.deviceBinding;
             valve.pinId = typeof obj.pinId !== 'undefined' ? obj.pinId : valve.pinId;
             await ncp.valves.setValveAsync(valve, obj);
-            sys.board.processStatusAsync();
+            await sys.board.syncEquipmentItems();
             return valve;
         } catch (err) { logger.error(`Nixie: Error setting valve definition. ${err.message}`); return Promise.reject(err); }
     }
@@ -982,7 +1084,7 @@ export class NixieHeaterCommands extends HeaterCommands {
             let heater: Heater;
             if (id <= 0) {
                 // We are adding a heater.  In this case all heaters are virtual.
-                let vheaters = sys.heaters.filter(h => h.isVirtual === true);
+                let vheaters = sys.heaters.filter(h => h.master === 1);
                 id = vheaters.length + 256;
             }
             heater = sys.heaters.getItemById(id, true);
@@ -993,7 +1095,7 @@ export class NixieHeaterCommands extends HeaterCommands {
                 }
             }
             let hstate = state.heaters.getItemById(id, true);
-            hstate.isVirtual = heater.isVirtual = true;
+            //hstate.isVirtual = heater.isVirtual = true;
             hstate.name = heater.name;
             hstate.type = heater.type;
             heater.master = 1;