nodejs-poolcontroller 7.7.0 → 8.0.1

package/controller/boards/SystemBoard.ts

@@ -1,5 +1,6 @@
 /*  nodejs-poolController.  An application to control pool equipment.
-Copyright (C) 2016, 2017, 2018, 2019, 2020.  Russell Goldin, tagyoureit.  russ.goldin@gmail.com
+Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022.  
+Russell Goldin, tagyoureit.  russ.goldin@gmail.com
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as
@@ -18,12 +19,13 @@ import * as extend from 'extend';
 import { logger } from '../../logger/Logger';
 import { Message, Outbound } from '../comms/messages/Messages';
 import { Timestamp, utils } from '../Constants';
-import { Body, ChemController, Chlorinator, Circuit, CircuitGroup, CircuitGroupCircuit, ConfigVersion, ControllerType, CustomName, CustomNameCollection, EggTimer, Equipment, Feature, Filter, General, Heater, ICircuit, ICircuitGroup, ICircuitGroupCircuit, LightGroup, LightGroupCircuit, Location, Options, Owner, PoolSystem, Pump, Schedule, sys, TempSensorCollection, Valve } from '../Equipment';
+import { Body, ChemController, ChemDoser, Chlorinator, Circuit, CircuitGroup, CircuitGroupCircuit, ConfigVersion, ControllerType, CustomName, CustomNameCollection, EggTimer, Equipment, Feature, Filter, General, Heater, ICircuit, ICircuitGroup, ICircuitGroupCircuit, LightGroup, LightGroupCircuit, Location, Options, Owner, PoolSystem, Pump, Schedule, sys, TempSensorCollection, Valve } from '../Equipment';
 import { EquipmentNotFoundError, InvalidEquipmentDataError, InvalidEquipmentIdError, BoardProcessError, InvalidOperationError } from '../Errors';
 import { ncp } from "../nixie/Nixie";
-import { BodyTempState, ChemControllerState, ChlorinatorState, CircuitGroupState, FilterState, ICircuitGroupState, ICircuitState, LightGroupState, ScheduleState, state, TemperatureState, ValveState, VirtualCircuitState } from '../State';
+import { BodyTempState, ChemControllerState, ChemDoserState, ChlorinatorState, CircuitGroupState, FilterState, ICircuitGroupState, ICircuitState, LightGroupState, ScheduleState, state, TemperatureState, ValveState, VirtualCircuitState } from '../State';
 import { RestoreResults } from '../../web/Server';
-import { group } from 'console';
+import { setTimeout } from 'timers/promises';
+import { setTimeout as setTimeoutSync } from 'timers';
 
 
 export class byteValueMap extends Map<number, any> {
@@ -265,7 +267,8 @@ export class byteValueMaps {
     [134, { name: 'heatEnable', desc: 'Heat Enable', assignableToPumpCircuit: false }],
     [135, { name: 'pumpSpeedUp', desc: 'Pump Speed +', assignableToPumpCircuit: false }],
     [136, { name: 'pumpSpeedDown', desc: 'Pump Speed -', assignableToPumpCircuit: false }],
-    [255, { name: 'notused', desc: 'NOT USED', assignableToPumpCircuit: true }]
+    [255, { name: 'notused', desc: 'NOT USED', assignableToPumpCircuit: true }],
+    [258, { name: 'anyHeater', desc: 'Any Heater' }],
   ]);
   public lightThemes: byteValueMap = new byteValueMap([
     [0, { name: 'off', desc: 'Off' }],
@@ -330,7 +333,16 @@ export class byteValueMaps {
         { isOn: true, timeout: 100 },
         { isOn: false, timeout: 100 }
       ]
-    }]
+      }],
+      [7, {
+          name: 'colorsync', desc: 'Sync', types: ['colorlogic'], command: 'colorSync', message: 'Synchronizing Lights', endingTheme: 'voodoolounge',
+          sequence: [
+              { isOn: true, timeout: 1000 },
+              { isOn: false, timeout: 12000 },
+              { isOn: true }
+          ]
+      }],
+      [100, { name: 'settheme', types: ['all'], desc: 'Set Theme', message: 'Sequencing Theme' }]
   ]);
   public lightGroupCommands = new byteValueMap([
     [1, { name: 'colorsync', desc: 'Sync', types: ['intellibrite'], command: 'colorSync', message:'Synchronizing' }],
@@ -364,7 +376,8 @@ export class byteValueMaps {
     [4, { name: 'lighttheme', desc: 'Sequencing Theme/Color Operation' }],
     [5, { name: 'colorhold', desc: 'Saving Current Color' }],
     [6, { name: 'colorrecall', desc: 'Recalling Saved Color' }],
-    [7, { name: 'lightthumper', desc: 'Setting Light Thumper' }]
+    [7, { name: 'lightthumper', desc: 'Setting Light Thumper' }],
+    [100, { name: 'settheme', desc: 'Setting Light Theme' }]
   ]);
   public lightColors: byteValueMap = new byteValueMap([
     [0, { name: 'white', desc: 'White' }],
@@ -458,13 +471,15 @@ export class byteValueMaps {
     [21, { name: 'solarpref', desc: 'Solar Preferred' }],
     [32, { name: 'nochange', desc: 'No Change' }]
   ]);
-  public heatStatus: byteValueMap = new byteValueMap([
-    [0, { name: 'off', desc: 'Off' }],
-    [1, { name: 'heater', desc: 'Heater' }],
-    [2, { name: 'solar', desc: 'Solar' }],
-    [3, { name: 'cooling', desc: 'Cooling' }],
-    [128, { name: 'cooldown', desc: 'Cooldown' }]
-  ]);
+    public heatStatus: byteValueMap = new byteValueMap([
+        [0, { name: 'off', desc: 'Off' }],
+        [1, { name: 'heater', desc: 'Heater' }],
+        [2, { name: 'solar', desc: 'Solar' }],
+        [3, { name: 'cooling', desc: 'Cooling' }],
+        [4, { name: 'hpheat', desc: 'Heatpump' }],
+        [5, { name: 'dual', desc: 'Dual' }],
+        [128, { name: 'cooldown', desc: 'Cooldown' }]
+    ]);
   public pumpStatus: byteValueMap = new byteValueMap([
     [0, { name: 'off', desc: 'Off' }], // When the pump is disconnected or has no power then we simply report off as the status.  This is not the recommended wiring
     // for a VS/VF pump as is should be powered at all times.  When it is, the status will always report a value > 0.
@@ -573,6 +588,10 @@ export class byteValueMaps {
     [2, { name: 'status', desc: 'Equipment Status' }],
     [82, { name: 'ivstatus', desc: 'IntelliValve Status' }]
   ]);
+    public chemDoserTypes: byteValueMap = new byteValueMap([
+        [0, { name: 'acid', desc: 'Acid' }],
+        [1, { name: 'chlor', desc: 'Chlorine' }]
+    ]);
   public chemControllerTypes: byteValueMap = new byteValueMap([
     [0, { name: 'none', desc: 'None', ph: { min: 6.8, max: 7.6 }, orp: { min: 400, max: 800 }, hasAddress: false }],
     [1, { name: 'unknown', desc: 'Unknown', ph: { min: 6.8, max: 7.6 }, hasAddress: false }],
@@ -587,7 +606,7 @@ export class byteValueMaps {
   public chemPumpTypes: byteValueMap = new byteValueMap([
     [0, { name: 'none', desc: 'No Pump', ratedFlow: false, tank: false, remAddress: false }],
     [1, { name: 'relay', desc: 'Relay Pump', ratedFlow: true, tank: true, remAddress: true }],
-    [2, { name: 'ezo-pmp', desc: 'Altas EZO-PMP', ratedFlow: false, tank: false, remAddress: true }]
+    [2, { name: 'ezo-pmp', desc: 'Altas EZO-PMP', ratedFlow: true, tank: true, remAddress: true }]
   ]);
   public chemPhProbeTypes: byteValueMap = new byteValueMap([
     [0, { name: 'none', desc: 'No Probe' }],
@@ -658,6 +677,43 @@ export class byteValueMaps {
     [1, { name: 'nocomms', desc: 'No Communication' }],
     [2, { name: 'config', desc: 'Invalid Configuration' }]
   ]);
+    public chemDoserStatus: byteValueMap = new byteValueMap([
+        [0, { name: 'ok', desc: 'Ok' }],
+        [1, { name: 'nocomms', desc: 'No Communication' }],
+        [2, { name: 'config', desc: 'Invalid Configuration' }]
+    ]);
+    public chemDoserHardwareFaults: byteValueMap = new byteValueMap([
+        [0, { name: 'ok', desc: 'Ok - No Faults' }],
+        [2, { name: 'pump', desc: 'Pump Fault' }],
+        [5, { name: 'chlormismatch', desc: 'Chlorinator body mismatch' }],
+        [6, { name: 'invalidbody', desc: 'Body capacity not valid' }],
+        [7, { name: 'flowsensor', desc: 'Flow Sensor Fault' }]
+    ]);
+    public chemDoserAlarms: byteValueMap = new byteValueMap([
+        [0, { name: 'ok', desc: 'Ok - No alarm' }],
+        [1, { name: 'noflow', desc: 'No Flow Detected' }],
+        [32, { name: 'tankempty', desc: 'Tank Empty' }],
+        [129, { name: 'tanklow', desc: 'Tank Low' }],
+        [131, { name: 'freezeprotect', desc: 'Freeze Protection Lockout' }]
+    ]);
+    public chemDoserWarnings: byteValueMap = new byteValueMap([
+        [0, { name: 'ok', desc: 'Ok - No Warning' }],
+        [8, { name: 'invalidsetup', desc: 'Invalid Setup' }],
+        [16, { name: 'chlorinatorComms', desc: 'Chlorinator Comms Error' }]
+    ]);
+    public chemDoserLimits: byteValueMap = new byteValueMap([
+        [0, { name: 'ok', desc: 'Ok - No limits reached' }],
+        [1, { name: 'lockout', desc: 'Lockout - Chemical will not dose' }],
+        [2, { name: 'dailylimit', desc: 'Daily Limit Reached' }],
+        [128, { name: 'commslost', desc: 'Communications with Chem Doser Lost' }]
+    ]);
+    public chemDoserDosingStatus: byteValueMap = new byteValueMap([
+        [0, { name: 'dosing', desc: 'Dosing' }],
+        [1, { name: 'mixing', desc: 'Mixing' }],
+        [2, { name: 'monitoring', desc: 'Monitoring' }]
+    ]);
+
+
   public chemControllerAlarms: byteValueMap = new byteValueMap([
     [0, { name: 'ok', desc: 'Ok - No alarm' }],
     [1, { name: 'noflow', desc: 'No Flow Detected' }],
@@ -681,7 +737,6 @@ export class byteValueMaps {
     [5, { name: 'chlormismatch', desc: 'Chlorinator body mismatch' }],
     [6, { name: 'invalidbody', desc: 'Body capacity not valid' }],
     [7, { name: 'flowsensor', desc: 'Flow Sensor Fault' }]
-
   ]);
   public chemControllerWarnings: byteValueMap = new byteValueMap([
     [0, { name: 'ok', desc: 'Ok - No Warning' }],
@@ -769,12 +824,12 @@ export class byteValueMaps {
   ]);
   public eqMessageSeverities: byteValueMap = new byteValueMap([
     [-1, { name: 'unspecified', desc: 'Unspecified' }],
-    [0, { name: 'info', desc: 'Information' }],
-    [1, { name: 'reminder', desc: 'Reminder' }],
-    [2, { name: 'alert', desc: 'Alert' }],
-    [3, { name: 'warning', desc: 'Warning' }],
-    [4, { name: 'error', desc: 'Error' }],
-    [5, { name: 'fatal', desc: 'Fatal' }]
+    [0, { name: 'info', desc: 'Information', icon: 'fas fa-circle-info' }],
+    [1, { name: 'reminder', desc: 'Reminder', icon: 'fas fa-bell' }],
+    [2, { name: 'alert', desc: 'Alert', icon: 'fas fa-circle-exclamation' }],
+    [3, { name: 'warning', desc: 'Warning', icon: 'fas fa-circle-exclamation' }],
+    [4, { name: 'error', desc: 'Error', icon: 'fas fa-triangle-exclamation' }],
+    [5, { name: 'fatal', desc: 'Fatal', icon: 'fas fa-skull-crossbones' }]
   ]);
   // need to validate these...
   public delay: byteValueMap = new byteValueMap([
@@ -826,20 +881,19 @@ export class SystemBoard {
   public async turnOffAllCircuits() {
     // turn off all circuits/features
     for (let i = 0; i < state.circuits.length; i++) {
-      let s = state.circuits.getItemByIndex(i);
-      await sys.board.circuits.setCircuitStateAsync(s.id, false);
+      let s = state.circuits.getItemByIndex(i)
+      s.isOn = s.manualPriorityActive = false;
     }
     for (let i = 0; i < state.features.length; i++) {
-      let s = state.features.getItemByIndex(i);
-      await sys.board.features.setFeatureStateAsync(s.id, false);
+      let s = state.features.getItemByIndex(i)
+      s.isOn = s.manualPriorityActive = false;
     }
     for (let i = 0; i < state.lightGroups.length; i++) {
-      let s = state.lightGroups.getItemByIndex(i);
-      await sys.board.circuits.setCircuitStateAsync(s.id, false);
+      let s = state.lightGroups.getItemByIndex(i)
+      s.isOn = s.manualPriorityActive = false;
     }
     for (let i = 0; i < state.temps.bodies.length; i++) {
-      let s = state.temps.bodies.getItemByIndex(i);
-      await sys.board.circuits.setCircuitStateAsync(s.id, false);
+      state.temps.bodies.getItemByIndex(i).isOn = false;  
     }
     // sys.board.virtualPumpControllers.setTargetSpeed();
     state.emitEquipmentChanges();
@@ -853,8 +907,8 @@ export class SystemBoard {
   public chlorinator: ChlorinatorCommands = new ChlorinatorCommands(this);
   public heaters: HeaterCommands = new HeaterCommands(this);
   public filters: FilterCommands = new FilterCommands(this);
-  public chemControllers: ChemControllerCommands = new ChemControllerCommands(this);
-
+    public chemControllers: ChemControllerCommands = new ChemControllerCommands(this);
+    public chemDosers: ChemDoserCommands = new ChemDoserCommands(this);
   public schedules: ScheduleCommands = new ScheduleCommands(this);
   public equipmentIds: EquipmentIds = new EquipmentIds();
   //public virtualChlorinatorController = new VirtualChlorinatorController(this);
@@ -879,14 +933,14 @@ export class SystemBoard {
     this._statusTimer = undefined;
     this._statusCheckRef = 0;
   }
-  public suspendStatus(bSuspend: boolean) {
-    // The way status suspension works is by using a reference value that is incremented and decremented
-    // the status check is only performed when the reference value is 0.  So suspending the status check 3 times and un-suspending
-    // it 2 times will still result in the status check being suspended.  This method also ensures the reference never falls below 0.
-    if (bSuspend) this._statusCheckRef++;
-    else this._statusCheckRef = Math.max(0, this._statusCheckRef - 1);
-    logger.verbose(`Suspending status check: ${bSuspend} -- ${this._statusCheckRef}`);
-  }
+    public suspendStatus(bSuspend: boolean) {
+        // The way status suspension works is by using a reference value that is incremented and decremented
+        // the status check is only performed when the reference value is 0.  So suspending the status check 3 times and un-suspending
+        // it 2 times will still result in the status check being suspended.  This method also ensures the reference never falls below 0.
+        if (bSuspend) this._statusCheckRef++;
+        else this._statusCheckRef = Math.max(0, this._statusCheckRef - 1);
+        if (this._statusCheckRef > 1) logger.verbose(`Suspending status check: ${bSuspend} -- ${this._statusCheckRef}`);
+    }
   /// This method processes the status message periodically.  The role of this method is to verify the circuit, valve, and heater
   /// relays.  This method does not control RS485 operations such as pumps and chlorinators.  These are done through the respective
   /// equipment polling functions.
@@ -907,20 +961,20 @@ export class SystemBoard {
     } catch (err) { state.status = 255; logger.error(`Error performing processStatusAsync ${err.message}`); }
     finally {
       this.suspendStatus(false);
-      if (this.statusInterval > 0) this._statusTimer = setTimeout(async () => await self.processStatusAsync(), this.statusInterval);
+      if (this.statusInterval > 0) this._statusTimer = setTimeoutSync(async () => await self.processStatusAsync(), this.statusInterval);
     }
   }
-  public async syncEquipmentItems() {
-    try {
-      await sys.board.circuits.syncCircuitRelayStates();
-      await sys.board.features.syncGroupStates();
-      await sys.board.circuits.syncVirtualCircuitStates();
-      await sys.board.valves.syncValveStates();
-      await sys.board.filters.syncFilterStates();
-      await sys.board.heaters.syncHeaterStates();
+    public async syncEquipmentItems() {
+        try {
+            await sys.board.circuits.syncCircuitRelayStates();
+            await sys.board.features.syncGroupStates();
+            await sys.board.circuits.syncVirtualCircuitStates();
+            await sys.board.valves.syncValveStates();
+            await sys.board.filters.syncFilterStates();
+            await sys.board.heaters.syncHeaterStates();
+        }
+        catch (err) { logger.error(`Error synchronizing equipment items: ${err.message}`); }
     }
-    catch (err) { logger.error(`Error synchronizing equipment items: ${err.message}`); }
-  }
   public async setControllerType(obj): Promise<Equipment> {
     try {
       if (obj.controllerType !== sys.controllerType)
@@ -998,347 +1052,413 @@ export class BoardCommands {
   constructor(parent: SystemBoard) { this.board = parent; }
 }
 export class SystemCommands extends BoardCommands {
-  public async restore(rest: { poolConfig: any, poolState: any }): Promise<RestoreResults> {
-    let res = new RestoreResults();
-    try {
-      let ctx = await sys.board.system.validateRestore(rest);
-      // Restore the general stuff.
-      if (ctx.general.update.length > 0) await sys.board.system.setGeneralAsync(ctx.general.update[0]);
-      for (let i = 0; i < ctx.customNames.update.length; i++) {
-        let cn = ctx.customNames.update[i];
+    public async restore(rest: { poolConfig: any, poolState: any }): Promise<RestoreResults> {
+        let res = new RestoreResults();
         try {
-          await sys.board.system.setCustomNameAsync(cn);
-          res.addModuleSuccess('customName', `Update: ${cn.id}-${cn.name}`);
-        } catch (err) { res.addModuleError('customName', `Update: ${cn.id}-${cn.name}: ${err.message}`); }
-      }
-      for (let i = 0; i < ctx.customNames.add.length; i++) {
-        let cn = ctx.customNames.add[i];
+            let ctx = await sys.board.system.validateRestore(rest);
+            // Restore the general stuff.
+            if (ctx.general.update.length > 0) await sys.board.system.setGeneralAsync(ctx.general.update[0]);
+            for (let i = 0; i < ctx.customNames.update.length; i++) {
+                let cn = ctx.customNames.update[i];
+                try {
+                    await sys.board.system.setCustomNameAsync(cn);
+                    res.addModuleSuccess('customName', `Update: ${cn.id}-${cn.name}`);
+                } catch (err) { res.addModuleError('customName', `Update: ${cn.id}-${cn.name}: ${err.message}`); }
+            }
+            for (let i = 0; i < ctx.customNames.add.length; i++) {
+                let cn = ctx.customNames.add[i];
+                try {
+                    await sys.board.system.setCustomNameAsync(cn);
+                    res.addModuleSuccess('customName', `Add: ${cn.id}-${cn.name}`);
+                } catch (err) { res.addModuleError('customName', `Add: ${cn.id}-${cn.name}: ${err.message}`); }
+            }
+            await sys.board.bodies.restore(rest, ctx, res);
+            await sys.board.filters.restore(rest, ctx, res);
+            await sys.board.circuits.restore(rest, ctx, res);
+            await sys.board.heaters.restore(rest, ctx, res);
+            await sys.board.features.restore(rest, ctx, res);
+            await sys.board.pumps.restore(rest, ctx, res);
+            await sys.board.valves.restore(rest, ctx, res);
+            await sys.board.chlorinator.restore(rest, ctx, res);
+            await sys.board.chemControllers.restore(rest, ctx, res);
+            await sys.board.schedules.restore(rest, ctx, res);
+            return res;
+            //await sys.board.covers.restore(rest, ctx);
+        } catch (err) { logger.error(`Error restoring njsPC server: ${err.message}`); res.addModuleError('system', err.message); return Promise.reject(err); }
+    }
+    public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<any> {
         try {
-          await sys.board.system.setCustomNameAsync(cn);
-          res.addModuleSuccess('customName', `Add: ${cn.id}-${cn.name}`);
-        } catch (err) { res.addModuleError('customName', `Add: ${cn.id}-${cn.name}: ${err.message}`); }
-      }
-      await sys.board.bodies.restore(rest, ctx, res);
-      await sys.board.filters.restore(rest, ctx, res);
-      await sys.board.circuits.restore(rest, ctx, res);
-      await sys.board.heaters.restore(rest, ctx, res);
-      await sys.board.features.restore(rest, ctx, res);
-      await sys.board.pumps.restore(rest, ctx, res);
-      await sys.board.valves.restore(rest, ctx, res);
-      await sys.board.chlorinator.restore(rest, ctx, res);
-      await sys.board.chemControllers.restore(rest, ctx, res);
-      await sys.board.schedules.restore(rest, ctx, res);
-      return res;
-      //await sys.board.covers.restore(rest, ctx);
-    } catch (err) { logger.error(`Error restoring njsPC server: ${err.message}`); res.addModuleError('system', err.message); return Promise.reject(err);}
-  }
-  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<any> {
-    try {
-      let ctx: any = { board: { errors: [], warnings: [] } };
+            let ctx: any = { board: { errors: [], warnings: [] } };
 
-      // Step 1 - Verify that the boards are the same.  For instance you do not want to restore an IntelliTouch to an IntelliCenter.
-      let cfg = rest.poolConfig;
-      if (sys.controllerType === cfg.controllerType) {
-        ctx.customNames = { errors: [], warnings: [], add: [], update: [], remove: [] };
-        let customNames = sys.customNames.get();
-        for (let i = 0; i < rest.poolConfig.customNames.length; i++) {
-          let cn = customNames.find(elem => elem.id === rest.poolConfig.customNames[i].id);
-          if (typeof cn === 'undefined') ctx.customNames.add.push(rest.poolConfig.customNames[i]);
-          else if (JSON.stringify(rest.poolConfig.customNames[i]) !== JSON.stringify(cn)) ctx.customNames.update.push(cn);
-        }
-        ctx.general = { errors: [], warnings: [], add: [], update: [], remove: [] };
-        if (JSON.stringify(sys.general.get()) !== JSON.stringify(cfg.pool)) ctx.general.update.push(cfg.pool);
-        ctx.bodies = await sys.board.bodies.validateRestore(rest);
-        ctx.pumps = await sys.board.pumps.validateRestore(rest);
-        await sys.board.circuits.validateRestore(rest, ctx);
-        ctx.features = await sys.board.features.validateRestore(rest);
-        ctx.chlorinators = await sys.board.chlorinator.validateRestore(rest);
-        ctx.heaters = await sys.board.heaters.validateRestore(rest);
-        ctx.valves = await sys.board.valves.validateRestore(rest);
+            // Step 1 - Verify that the boards are the same.  For instance you do not want to restore an IntelliTouch to an IntelliCenter.
+            let cfg = rest.poolConfig;
+            if (sys.controllerType === cfg.controllerType) {
+                ctx.customNames = { errors: [], warnings: [], add: [], update: [], remove: [] };
+                let customNames = sys.customNames.get();
+                for (let i = 0; i < rest.poolConfig.customNames.length; i++) {
+                    let cn = customNames.find(elem => elem.id === rest.poolConfig.customNames[i].id);
+                    if (typeof cn === 'undefined') ctx.customNames.add.push(rest.poolConfig.customNames[i]);
+                    else if (JSON.stringify(rest.poolConfig.customNames[i]) !== JSON.stringify(cn)) ctx.customNames.update.push(cn);
+                }
+                ctx.general = { errors: [], warnings: [], add: [], update: [], remove: [] };
+                if (JSON.stringify(sys.general.get()) !== JSON.stringify(cfg.pool)) ctx.general.update.push(cfg.pool);
+                ctx.bodies = await sys.board.bodies.validateRestore(rest);
+                ctx.pumps = await sys.board.pumps.validateRestore(rest);
+                await sys.board.circuits.validateRestore(rest, ctx);
+                ctx.features = await sys.board.features.validateRestore(rest);
+                ctx.chlorinators = await sys.board.chlorinator.validateRestore(rest);
+                ctx.heaters = await sys.board.heaters.validateRestore(rest);
+                ctx.valves = await sys.board.valves.validateRestore(rest);
 
-        //ctx.covers = await sys.board.covers.validateRestore(rest);
-        ctx.chemControllers = await sys.board.chemControllers.validateRestore(rest);
-        ctx.filters = await sys.board.filters.validateRestore(rest);
-        ctx.schedules = await sys.board.schedules.validateRestore(rest);
-      }
-      else ctx.board.errors.push(`Panel Types do not match cannot restore backup from ${sys.controllerType} to ${rest.poolConfig.controllerType}`);
+                //ctx.covers = await sys.board.covers.validateRestore(rest);
+                ctx.chemControllers = await sys.board.chemControllers.validateRestore(rest);
+                ctx.filters = await sys.board.filters.validateRestore(rest);
+                ctx.schedules = await sys.board.schedules.validateRestore(rest);
+            }
+            else ctx.board.errors.push(`Panel Types do not match cannot restore backup from ${sys.controllerType} to ${rest.poolConfig.controllerType}`);
 
-      return ctx;
+            return ctx;
 
-    } catch (err) { logger.error(`Error validating restore file: ${err.message}`); return Promise.reject(err); }
+        } catch (err) { logger.error(`Error validating restore file: ${err.message}`); return Promise.reject(err); }
 
-  }
-  public cancelDelay(): Promise<any> { state.delay = sys.board.valueMaps.delay.getValue('nodelay'); return Promise.resolve(state.data.delay); }
-  public setManualOperationPriority(id: number): Promise<any> { return Promise.resolve(); }
-  public setDateTimeAsync(obj: any): Promise<any> { return Promise.resolve(); }
-  public keepManualTime() {
-    try {
-      // every minute, updated the time from the system clock in server mode
-      // but only for Virtual.  Likely 'manual' on *Center means OCP time
-      if (sys.general.options.clockSource !== 'server') return;
-      state.time.setTimeFromSystemClock();
-      sys.board.system.setTZ();
-    } catch (err) { logger.error(`Error setting manual time: ${err.message}`); }
-  }
-  public setTZ() {
-    let tzOffsetObj = state.time.calcTZOffset();
-    if (sys.general.options.clockSource === 'server' || typeof sys.general.location.timeZone === 'undefined') {
-      let tzs = sys.board.valueMaps.timeZones.toArray();
-      sys.general.location.timeZone = tzs.find(tz => tz.utcOffset === tzOffsetObj.tzOffset).val;
-    }
-    if (sys.general.options.clockSource === 'server' || typeof sys.general.options.adjustDST === 'undefined') {
-      sys.general.options.adjustDST = tzOffsetObj.adjustDST;
-    }
-  }
-  public getDOW() { return this.board.valueMaps.scheduleDays.toArray(); }
-  public async setGeneralAsync(obj: any): Promise<General> {
-    if (typeof obj.alias === 'string') sys.general.alias = obj.alias;
-    if (typeof obj.options !== 'undefined') await sys.board.system.setOptionsAsync(obj.options);
-    if (typeof obj.location !== 'undefined') await sys.board.system.setLocationAsync(obj.location);
-    if (typeof obj.owner !== 'undefined') await sys.board.system.setOwnerAsync(obj.owner);
-    return sys.general;
-  }
-  public async setTempSensorsAsync(obj: any): Promise<TempSensorCollection> {
-    if (typeof obj.waterTempAdj1 != 'undefined' && obj.waterTempAdj1 !== sys.equipment.tempSensors.getCalibration('water1')) {
-      sys.equipment.tempSensors.setCalibration('water1', parseFloat(obj.waterTempAdj1));
-    }
-    if (typeof obj.waterTempAdj2 != 'undefined' && obj.waterTempAdj2 !== sys.equipment.tempSensors.getCalibration('water2')) {
-      sys.equipment.tempSensors.setCalibration('water2', parseFloat(obj.waterTempAdj2));
     }
-    if (typeof obj.waterTempAdj3 != 'undefined' && obj.waterTempAdj3 !== sys.equipment.tempSensors.getCalibration('water3')) {
-      sys.equipment.tempSensors.setCalibration('water3', parseFloat(obj.waterTempAdj3));
+    public cancelDelay(): Promise<any> { state.delay = sys.board.valueMaps.delay.getValue('nodelay'); return Promise.resolve(state.data.delay); }
+    public setManualOperationPriority(id: number): Promise<any> { return Promise.resolve(); }
+    public setDateTimeAsync(obj: any): Promise<any> { return Promise.resolve(); }
+    public keepManualTime() {
+        try {
+            // every minute, updated the time from the system clock in server mode
+            // but only for Virtual.  Likely 'manual' on *Center means OCP time
+            if (sys.general.options.clockSource !== 'server') return;
+            state.time.setTimeFromSystemClock();
+            sys.board.system.setTZ();
+        } catch (err) { logger.error(`Error setting manual time: ${err.message}`); }
     }
-    if (typeof obj.waterTempAdj4 != 'undefined' && obj.waterTempAdj4 !== sys.equipment.tempSensors.getCalibration('water4')) {
-      sys.equipment.tempSensors.setCalibration('water4', parseFloat(obj.waterTempAdj4));
+    public setTZ() {
+        let tzOffsetObj = state.time.calcTZOffset();
+        if (sys.general.options.clockSource === 'server' || typeof sys.general.location.timeZone === 'undefined') {
+            let tzs = sys.board.valueMaps.timeZones.toArray();
+            sys.general.location.timeZone = tzs.find(tz => tz.utcOffset === tzOffsetObj.tzOffset).val;
+        }
+        if (sys.general.options.clockSource === 'server' || typeof sys.general.options.adjustDST === 'undefined') {
+            sys.general.options.adjustDST = tzOffsetObj.adjustDST;
+        }
     }
-    if (typeof obj.solarTempAdj1 != 'undefined' && obj.solarTempAdj1 !== sys.equipment.tempSensors.getCalibration('solar1')) {
-      sys.equipment.tempSensors.setCalibration('solar1', parseFloat(obj.solarTempAdj1));
+    public getDOW() { return this.board.valueMaps.scheduleDays.toArray(); }
+    public async setGeneralAsync(obj: any): Promise<General> {
+        if (typeof obj.alias === 'string') sys.general.alias = obj.alias;
+        if (typeof obj.options !== 'undefined') await sys.board.system.setOptionsAsync(obj.options);
+        if (typeof obj.location !== 'undefined') await sys.board.system.setLocationAsync(obj.location);
+        if (typeof obj.owner !== 'undefined') await sys.board.system.setOwnerAsync(obj.owner);
+        return sys.general;
     }
-    if (typeof obj.solarTempAdj2 != 'undefined' && obj.solarTempAdj2 !== sys.equipment.tempSensors.getCalibration('solar2')) {
-      sys.equipment.tempSensors.setCalibration('solar2', parseFloat(obj.solarTempAdj2));
+    public async setTempSensorsAsync(obj: any): Promise<TempSensorCollection> {
+        if (typeof obj.waterTempAdj1 != 'undefined' && obj.waterTempAdj1 !== sys.equipment.tempSensors.getCalibration('water1')) {
+            sys.equipment.tempSensors.setCalibration('water1', parseFloat(obj.waterTempAdj1));
+        }
+        if (typeof obj.waterTempAdj2 != 'undefined' && obj.waterTempAdj2 !== sys.equipment.tempSensors.getCalibration('water2')) {
+            sys.equipment.tempSensors.setCalibration('water2', parseFloat(obj.waterTempAdj2));
+        }
+        if (typeof obj.waterTempAdj3 != 'undefined' && obj.waterTempAdj3 !== sys.equipment.tempSensors.getCalibration('water3')) {
+            sys.equipment.tempSensors.setCalibration('water3', parseFloat(obj.waterTempAdj3));
+        }
+        if (typeof obj.waterTempAdj4 != 'undefined' && obj.waterTempAdj4 !== sys.equipment.tempSensors.getCalibration('water4')) {
+            sys.equipment.tempSensors.setCalibration('water4', parseFloat(obj.waterTempAdj4));
+        }
+        if (typeof obj.solarTempAdj1 != 'undefined' && obj.solarTempAdj1 !== sys.equipment.tempSensors.getCalibration('solar1')) {
+            sys.equipment.tempSensors.setCalibration('solar1', parseFloat(obj.solarTempAdj1));
+        }
+        if (typeof obj.solarTempAdj2 != 'undefined' && obj.solarTempAdj2 !== sys.equipment.tempSensors.getCalibration('solar2')) {
+            sys.equipment.tempSensors.setCalibration('solar2', parseFloat(obj.solarTempAdj2));
+        }
+        if (typeof obj.solarTempAdj3 != 'undefined' && obj.solarTempAdj3 !== sys.equipment.tempSensors.getCalibration('solar3')) {
+            sys.equipment.tempSensors.setCalibration('solar3', parseFloat(obj.solarTempAdj3));
+        }
+        if (typeof obj.solarTempAdj4 != 'undefined' && obj.solarTempAdj4 !== sys.equipment.tempSensors.getCalibration('solar4')) {
+            sys.equipment.tempSensors.setCalibration('solar4', parseFloat(obj.solarTempAdj4));
+        }
+        if (typeof obj.airTempAdj != 'undefined' && obj.airTempAdj !== sys.equipment.tempSensors.getCalibration('air')) {
+            sys.equipment.tempSensors.setCalibration('air', parseFloat(obj.airTempAdj));
+        }
+        return sys.equipment.tempSensors;
     }
-    if (typeof obj.solarTempAdj3 != 'undefined' && obj.solarTempAdj3 !== sys.equipment.tempSensors.getCalibration('solar3')) {
-      sys.equipment.tempSensors.setCalibration('solar3', parseFloat(obj.solarTempAdj3));
+    public async setOptionsAsync(obj: any): Promise<Options> {
+        if (obj.clockSource === 'server') sys.board.system.setTZ();
+        sys.board.system.setTempSensorsAsync(obj);
+        sys.general.options.set(obj);
+        let bodyUnits = sys.general.options.units === 0 ? 1 : 2;
+        for (let i = 0; i < sys.bodies.length; i++) sys.bodies.getItemByIndex(i).capacityUnits = bodyUnits;
+        state.temps.units = sys.general.options.units === 0 ? 1 : 4;
+        return sys.general.options;
     }
-    if (typeof obj.solarTempAdj4 != 'undefined' && obj.solarTempAdj4 !== sys.equipment.tempSensors.getCalibration('solar4')) {
-      sys.equipment.tempSensors.setCalibration('solar4', parseFloat(obj.solarTempAdj4));
+    public async setLocationAsync(obj: any): Promise<Location> {
+        sys.general.location.set(obj);
+        return sys.general.location;
     }
-    if (typeof obj.airTempAdj != 'undefined' && obj.airTempAdj !== sys.equipment.tempSensors.getCalibration('air')) {
-      sys.equipment.tempSensors.setCalibration('air', parseFloat(obj.airTempAdj));
+    public async setOwnerAsync(obj: any): Promise<Owner> {
+        sys.general.owner.set(obj);
+        return sys.general.owner;
     }
-    return sys.equipment.tempSensors;
-  }
-  public async setOptionsAsync(obj: any): Promise<Options> {
-    if (obj.clockSource === 'server') sys.board.system.setTZ();
-    sys.board.system.setTempSensorsAsync(obj);
-    sys.general.options.set(obj);
-    let bodyUnits = sys.general.options.units === 0 ? 1 : 2;
-    for (let i = 0; i < sys.bodies.length; i++) sys.bodies.getItemByIndex(i).capacityUnits = bodyUnits;
-    state.temps.units = sys.general.options.units === 0 ? 1 : 4;
-    return sys.general.options;
-  }
-  public async setLocationAsync(obj: any): Promise<Location> {
-    sys.general.location.set(obj);
-    return sys.general.location;
-  }
-  public async setOwnerAsync(obj: any): Promise<Owner> {
-    sys.general.owner.set(obj);
-    return sys.general.owner;
-  }
-  public async setTempsAsync(obj: any): Promise<TemperatureState> {
-    return new Promise<TemperatureState>((resolve, reject) => {
-      for (let prop in obj) {
-        switch (prop) {
-          case 'air':
-          case 'airSensor':
-          case 'airSensor1':
-            {
-              let temp = obj[prop] !== null ? parseFloat(obj[prop]) : 0;
-              if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
-              state.temps.air = sys.equipment.tempSensors.getCalibration('air') + temp;
-            }
-            break;
-          case 'waterSensor1':
-            {
-              let temp = obj[prop] !== null ? parseFloat(obj[prop]) : 0;
-              if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
-              state.temps.waterSensor1 = sys.equipment.tempSensors.getCalibration('water1') + temp;
-              let body = state.temps.bodies.getItemById(1);
-              if (body.isOn) body.temp = state.temps.waterSensor1;
-              else if (sys.equipment.shared) {
-                body = state.temps.bodies.getItemById(2);
-                if (body.isOn) body.temp = state.temps.waterSensor1;
-              }
-            }
-            break;
-          case 'waterSensor2':
-            {
-              let temp = obj[prop] !== null ? parseFloat(obj[prop]) : 0;
-              if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
-              state.temps.waterSensor2 = sys.equipment.tempSensors.getCalibration('water2') + temp;
-              if (!state.equipment.shared) {
-                let body = state.temps.bodies.getItemById(2);
-                if (body.isOn) body.temp = state.temps.waterSensor2;
-              }
-            }
-            break;
-          case 'waterSensor3':
-            {
-              let temp = obj[prop] !== null ? parseFloat(obj[prop]) : 0;
-              if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
-              state.temps.waterSensor3 = sys.equipment.tempSensors.getCalibration('water3') + temp;
-              let body = state.temps.bodies.getItemById(3);
-              if (body.isOn) body.temp = state.temps.waterSensor3;
-            }
-            break;
-          case 'waterSensor4':
-            {
+    public async setTempsAsync(obj: any): Promise<TemperatureState> {
+        return new Promise<TemperatureState>((resolve, reject) => {
+            let units = sys.board.valueMaps.tempUnits.getName(state.temps.units) || 'F';
+            for (let prop in obj) {
+                switch (prop) {
+                    case 'air':
+                    case 'airSensor':
+                    case 'airSensor1':
+                        {
+                            let temp = 0;
+                            if (obj[prop] !== null) {
+                                if (typeof obj[prop].temperature !== 'undefined') {
+                                    temp = parseFloat(obj[prop].temperature);
+                                    if (typeof obj[prop].units === 'string') temp = utils.convert.temperature.convertUnits(temp, obj[prop].units || units, units);
+                                }
+                                else temp = parseFloat(obj[prop]);
+                            }
+                            if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
+                            state.temps.air = sys.equipment.tempSensors.getCalibration('air') + temp;
+                        }
+                        break;
+                    case 'waterSensor1':
+                        {
+                            let temp = 0;
+                            if (obj[prop] !== null) {
+                                if (typeof obj[prop].temperature !== 'undefined') {
+                                    temp = parseFloat(obj[prop].temperature);
+                                    if (typeof obj[prop].units === 'string') temp = utils.convert.temperature.convertUnits(temp, obj[prop].units || units, units);
+                                }
+                                else temp = parseFloat(obj[prop]);
+                            }
+                            if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
+                            state.temps.waterSensor1 = sys.equipment.tempSensors.getCalibration('water1') + temp;
+                            let body = state.temps.bodies.getItemById(1);
+                            if (body.isOn) body.temp = state.temps.waterSensor1;
+                            else if (!sys.equipment.dual) {
+                                body = state.temps.bodies.find(elem => elem.id === 2);
+                                if (typeof body !== 'undefined') {
+                                    body = state.temps.bodies.getItemById(2);
+                                    if (body.isOn) body.temp = state.temps.waterSensor1;
+                                }
+                            }
+                        }
+                        break;
+                    case 'waterSensor2':
+                        {
+                            let temp = 0;
+                            if (obj[prop] !== null) {
+                                if (typeof obj[prop].temperature !== 'undefined') {
+                                    temp = parseFloat(obj[prop].temperature);
+                                    if (typeof obj[prop].units === 'string') temp = utils.convert.temperature.convertUnits(temp, obj[prop].units || units, units);
+                                }
+                                else temp = parseFloat(obj[prop]);
+                            }
+                            if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
+                            state.temps.waterSensor2 = sys.equipment.tempSensors.getCalibration('water2') + temp;
+                            if (state.equipment.dual) {
+                                let body = state.temps.bodies.getItemById(2);
+                                if (body.isOn) body.temp = state.temps.waterSensor2;
+                            }
+                        }
+                        break;
+                    case 'waterSensor3':
+                        {
+                            let temp = 0;
+                            if (obj[prop] !== null) {
+                                if (typeof obj[prop].temperature !== 'undefined') {
+                                    temp = parseFloat(obj[prop].temperature);
+                                    if (typeof obj[prop].units === 'string') temp = utils.convert.temperature.convertUnits(temp, obj[prop].units || units, units);
+                                }
+                                else temp = parseFloat(obj[prop]);
+                            }
+                            if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
+                            state.temps.waterSensor3 = sys.equipment.tempSensors.getCalibration('water3') + temp;
+                            let body = state.temps.bodies.getItemById(3);
+                            if (body.isOn) body.temp = state.temps.waterSensor3;
+                        }
+                        break;
+                    case 'waterSensor4':
+                        {
+                            let temp = 0;
+                            if (obj[prop] !== null) {
+                                if (typeof obj[prop].temperature !== 'undefined') {
+                                    temp = parseFloat(obj[prop].temperature);
+                                    if (typeof obj[prop].units === 'string') temp = utils.convert.temperature.convertUnits(temp, obj[prop].units || units, units);
+                                }
+                                else temp = parseFloat(obj[prop]);
+                            }
+                            if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
+                            let body = state.temps.bodies.getItemById(4);
+                            if (body.isOn) body.temp = state.temps.waterSensor4;
+                        }
+                        break;
 
-              let temp = obj[prop] !== null ? parseFloat(obj[prop]) : 0;
-              if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
-              state.temps.waterSensor4 = sys.equipment.tempSensors.getCalibration('water4') + temp;
-              let body = state.temps.bodies.getItemById(4);
-              if (body.isOn) body.temp = state.temps.waterSensor4;
+                    case 'solarSensor1':
+                    case 'solar1':
+                    case 'solar':
+                        {
+                            let temp = 0;
+                            if (obj[prop] !== null) {
+                                if (typeof obj[prop].temperature !== 'undefined') {
+                                    temp = parseFloat(obj[prop].temperature);
+                                    if (typeof obj[prop].units === 'string') temp = utils.convert.temperature.convertUnits(temp, obj[prop].units || units, units);
+                                }
+                                else temp = parseFloat(obj[prop]);
+                            }
+                            if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
+                            state.temps.solar = sys.equipment.tempSensors.getCalibration('solar1') + temp;
+                        }
+                        break;
+                    case 'solar2':
+                    case 'solarSensor2':
+                        {
+                            let temp = 0;
+                            if (obj[prop] !== null) {
+                                if (typeof obj[prop].temperature !== 'undefined') {
+                                    temp = parseFloat(obj[prop].temperature);
+                                    if (typeof obj[prop].units === 'string') temp = utils.convert.temperature.convertUnits(temp, obj[prop].units || units, units);
+                                }
+                                else temp = parseFloat(obj[prop]);
+                            }
+                            if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
+                            state.temps.solarSensor2 = sys.equipment.tempSensors.getCalibration('solar2') + temp;
+                        }
+                        break;
+                    case 'solar3':
+                    case 'solarSensor3':
+                        {
+                            let temp = 0;
+                            if (obj[prop] !== null) {
+                                if (typeof obj[prop].temperature !== 'undefined') {
+                                    temp = parseFloat(obj[prop].temperature);
+                                    if (typeof obj[prop].units === 'string') temp = utils.convert.temperature.convertUnits(temp, obj[prop].units || units, units);
+                                }
+                                else temp = parseFloat(obj[prop]);
+                            }
+                            if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
+                            state.temps.solarSensor3 = sys.equipment.tempSensors.getCalibration('solar3') + temp;
+                        }
+                        break;
+                    case 'solar4':
+                    case 'solarSensor4':
+                        {
+                            let temp = 0;
+                            if (obj[prop] !== null) {
+                                if (typeof obj[prop].temperature !== 'undefined') {
+                                    temp = parseFloat(obj[prop].temperature);
+                                    if (typeof obj[prop].units === 'string') temp = utils.convert.temperature.convertUnits(temp, obj[prop].units || units, units);
+                                }
+                                else temp = parseFloat(obj[prop]);
+                            }
+                            if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
+                            state.temps.solarSensor4 = sys.equipment.tempSensors.getCalibration('solar4') + temp;
+                        }
+                        break;
+                }
             }
-            break;
+            sys.board.heaters.syncHeaterStates();
+            resolve(state.temps);
+        });
+    }
+    public getSensors() {
+        let sensors = [{ name: 'Air Sensor', temp: state.temps.air, tempAdj: sys.equipment.tempSensors.getCalibration('air'), binding: 'airTempAdj' }];
+        if (sys.equipment.shared) {
+            if (sys.equipment.maxBodies > 2)
+                sensors.push({ name: 'Water Sensor 1', temp: state.temps.waterSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('water1'), binding: 'waterTempAdj1' },
+                    { name: 'Water Sensor 2', temp: state.temps.waterSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('water2'), binding: 'waterTempAdj2' },
+                    { name: 'Water Sensor 3', temp: state.temps.waterSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('water3'), binding: 'waterTempAdj3' });
+            else
+                sensors.push({ name: 'Water Sensor', temp: state.temps.waterSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('water1'), binding: 'waterTempAdj1' });
+            if (sys.equipment.maxBodies > 3)
+                sensors.push({ name: 'Water Sensor 4', temp: state.temps.waterSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('water4'), binding: 'waterTempAdj4' });
 
-          case 'solarSensor1':
-          case 'solar1':
-          case 'solar':
-            {
-              let temp = obj[prop] !== null ? parseFloat(obj[prop]) : 0;
-              if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
-              state.temps.solar = sys.equipment.tempSensors.getCalibration('solar1') + temp;
+            if (sys.board.heaters.isSolarInstalled()) {
+                if (sys.equipment.maxBodies > 2) {
+                    sensors.push({ name: 'Solar Sensor 1', temp: state.temps.solar, tempAdj: sys.equipment.tempSensors.getCalibration('solar1'), binding: 'solarTempAdj1' },
+                        { name: 'Solar Sensor 2', temp: state.temps.solarSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('solar2'), binding: 'solarTempAdj2' });
+                }
+                else
+                    sensors.push({ name: 'Solar Sensor', temp: state.temps.solar, tempAdj: sys.equipment.tempSensors.getCalibration('solar1'), binding: 'solarTempAdj1' });
+                if (sys.equipment.maxBodies > 3)
+                    sensors.push({ name: 'Solar Sensor 4', temp: state.temps.solarSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('solar4'), binding: 'solarTempAdj4' });
             }
-            break;
-          case 'solar2':
-          case 'solarSensor2':
-            {
-              let temp = obj[prop] !== null ? parseFloat(obj[prop]) : 0;
-              if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
-              state.temps.solarSensor2 = sys.equipment.tempSensors.getCalibration('solar2') + temp;
+        }
+        else if (sys.equipment.dual) {
+            sensors.push({ name: 'Water Sensor 1', temp: state.temps.waterSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('water1'), binding: 'waterTempAdj1' },
+                { name: 'Water Sensor 2', temp: state.temps.waterSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('water2'), binding: 'waterTempAdj2' });
+            if (sys.equipment.maxBodies > 2)
+                sensors.push({ name: 'Water Sensor 3', temp: state.temps.waterSensor3, tempAdj: sys.equipment.tempSensors.getCalibration('water3'), binding: 'waterTempAdj3' });
+            if (sys.equipment.maxBodies > 3)
+                sensors.push({ name: 'Water Sensor 4', temp: state.temps.waterSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('water4'), binding: 'waterTempAdj4' });
+            if (sys.board.heaters.isSolarInstalled()) {
+                sensors.push({ name: 'Solar Sensor 1', temp: state.temps.solar, tempAdj: sys.equipment.tempSensors.getCalibration('solar1'), binding: 'solarTempAdj1' },
+                    { name: 'Solar Sensor 2', temp: state.temps.solarSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('solar2'), binding: 'solarTempAdj2' });
+                if (sys.equipment.maxBodies > 2)
+                    sensors.push({ name: 'Solar Sensor 3', temp: state.temps.solarSensor3, tempAdj: sys.equipment.tempSensors.getCalibration('solar3'), binding: 'solarTempAdj3' });
+                if (sys.equipment.maxBodies > 3)
+                    sensors.push({ name: 'Solar Sensor 4', temp: state.temps.solarSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('solar4'), binding: 'solarTempAdj4' });
             }
-            break;
-          case 'solar3':
-          case 'solarSensor3':
-            {
-              let temp = obj[prop] !== null ? parseFloat(obj[prop]) : 0;
-              if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
-              state.temps.solarSensor3 = sys.equipment.tempSensors.getCalibration('solar3') + temp;
+        }
+        else {
+            if (sys.equipment.maxBodies > 1) {
+                sensors.push({ name: 'Water Sensor 1', temp: state.temps.waterSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('water1'), binding: 'waterTempAdj1' },
+                    { name: 'Water Sensor 2', temp: state.temps.waterSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('water2'), binding: 'waterTempAdj2' });
+                if (sys.equipment.maxBodies > 2)
+                    sensors.push({ name: 'Water Sensor 3', temp: state.temps.waterSensor3, tempAdj: sys.equipment.tempSensors.getCalibration('water3'), binding: 'waterTempAdj3' });
+                if (sys.equipment.maxBodies > 3)
+                    sensors.push({ name: 'Water Sensor 4', temp: state.temps.waterSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('water4'), binding: 'waterTempAdj4' });
+
+                if (sys.board.heaters.isSolarInstalled()) {
+                    sensors.push({ name: 'Solar Sensor 1', temp: state.temps.solarSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('solar1'), binding: 'solarTempAdj1' },
+                        { name: 'Solar Sensor 2', temp: state.temps.solarSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('solar2'), binding: 'solarTempAdj2' });
+                    if (sys.equipment.maxBodies > 2)
+                        sensors.push({ name: 'Solar Sensor 3', temp: state.temps.solarSensor3, tempAdj: sys.equipment.tempSensors.getCalibration('solar3'), binding: 'solarTempAdj3' });
+                    if (sys.equipment.maxBodies > 3)
+                        sensors.push({ name: 'Water Sensor 4', temp: state.temps.solarSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('solar4'), binding: 'solarTempAdj4' });
+                }
             }
-            break;
-          case 'solar4':
-          case 'solarSensor4':
-            {
-              let temp = obj[prop] !== null ? parseFloat(obj[prop]) : 0;
-              if (isNaN(temp)) return reject(new InvalidEquipmentDataError(`Invalid value for ${prop} ${obj[prop]}`, `Temps:${prop}`, obj[prop]));
-              state.temps.solarSensor4 = sys.equipment.tempSensors.getCalibration('solar4') + temp;
+            else {
+                sensors.push({ name: 'Water Sensor', temp: state.temps.waterSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('water1'), binding: 'waterTempAdj1' });
+                if (sys.board.heaters.isSolarInstalled())
+                    sensors.push({ name: 'Solar Sensor', temp: state.temps.solar, tempAdj: sys.equipment.tempSensors.getCalibration('solar1'), binding: 'solarTempAdj1' });
             }
-            break;
         }
-      }
-      sys.board.heaters.syncHeaterStates();
-      resolve(state.temps);
-    });
-  }
-  public getSensors() {
-    let sensors = [{ name: 'Air Sensor', temp: state.temps.air, tempAdj: sys.equipment.tempSensors.getCalibration('air'), binding: 'airTempAdj' }];
-    if (sys.equipment.shared) {
-      if (sys.equipment.maxBodies > 2)
-        sensors.push({ name: 'Water Sensor 1', temp: state.temps.waterSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('water1'), binding: 'waterTempAdj1' },
-          { name: 'Water Sensor 2', temp: state.temps.waterSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('water2'), binding: 'waterTempAdj2' },
-          { name: 'Water Sensor 3', temp: state.temps.waterSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('water3'), binding: 'waterTempAdj3' });
-      else
-        sensors.push({ name: 'Water Sensor', temp: state.temps.waterSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('water1'), binding: 'waterTempAdj1' });
-      if (sys.equipment.maxBodies > 3)
-        sensors.push({ name: 'Water Sensor 4', temp: state.temps.waterSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('water4'), binding: 'waterTempAdj4' });
+        return sensors;
+    }
+    public async setCustomNamesAsync(names: any[]): Promise<CustomNameCollection> {
+        if (!Array.isArray(names)) return Promise.reject(new InvalidEquipmentDataError(`Data is not an array`, 'customNames', names))
+        let arr = [];
+        for (let i = 0; i < names.length; i++) { arr.push(sys.board.system.setCustomNameAsync(names[i])); }
+        return new Promise<CustomNameCollection>(async (resolve, reject) => {
+            try {
+                await Promise.all(arr).catch(err => reject(err));
+                // sys.board.system.syncCustomNamesValueMap(); Each custom name promise is already syncing the bytevalue array
 
-      if (sys.board.heaters.isSolarInstalled()) {
-        if (sys.equipment.maxBodies > 2) {
-          sensors.push({ name: 'Solar Sensor 1', temp: state.temps.solar, tempAdj: sys.equipment.tempSensors.getCalibration('solar1'), binding: 'solarTempAdj1' },
-            { name: 'Solar Sensor 2', temp: state.temps.solarSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('solar2'), binding: 'solarTempAdj2' });
-        }
-        else
-          sensors.push({ name: 'Solar Sensor', temp: state.temps.solar, tempAdj: sys.equipment.tempSensors.getCalibration('solar1'), binding: 'solarTempAdj1' });
-        if (sys.equipment.maxBodies > 3)
-          sensors.push({ name: 'Solar Sensor 4', temp: state.temps.solarSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('solar4'), binding: 'solarTempAdj4' });
-      }
+                resolve(sys.customNames);
+            }
+            catch (err) { reject(err); }
+        });
     }
-    else if (sys.equipment.dual) {
-      sensors.push({ name: 'Water Sensor 1', temp: state.temps.waterSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('water1'), binding: 'waterTempAdj1' },
-        { name: 'Water Sensor 2', temp: state.temps.waterSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('water2'), binding: 'waterTempAdj2' });
-      if (sys.equipment.maxBodies > 2)
-        sensors.push({ name: 'Water Sensor 3', temp: state.temps.waterSensor3, tempAdj: sys.equipment.tempSensors.getCalibration('water3'), binding: 'waterTempAdj3' });
-      if (sys.equipment.maxBodies > 3)
-        sensors.push({ name: 'Water Sensor 4', temp: state.temps.waterSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('water4'), binding: 'waterTempAdj4' });
-      if (sys.board.heaters.isSolarInstalled()) {
-        sensors.push({ name: 'Solar Sensor 1', temp: state.temps.solar, tempAdj: sys.equipment.tempSensors.getCalibration('solar1'), binding: 'solarTempAdj1' },
-          { name: 'Solar Sensor 2', temp: state.temps.solarSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('solar2'), binding: 'solarTempAdj2' });
-        if (sys.equipment.maxBodies > 2)
-          sensors.push({ name: 'Solar Sensor 3', temp: state.temps.solarSensor3, tempAdj: sys.equipment.tempSensors.getCalibration('solar3'), binding: 'solarTempAdj3' });
-        if (sys.equipment.maxBodies > 3)
-          sensors.push({ name: 'Solar Sensor 4', temp: state.temps.solarSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('solar4'), binding: 'solarTempAdj4' });
-      }
+    public async setCustomNameAsync(data: any, send: boolean = false): Promise<CustomName> {
+        return new Promise<CustomName>((resolve, reject) => {
+            let id = parseInt(data.id, 10);
+            if (isNaN(id)) return reject(new InvalidEquipmentIdError('Invalid Custom Name Id', data.id, 'customName'));
+            if (id > sys.equipment.maxCustomNames) return reject(new InvalidEquipmentIdError('Custom Name Id out of range', data.id, 'customName'));
+            let cname = sys.customNames.getItemById(id, true);
+            cname.name = data.name;
+            sys.board.system.syncCustomNamesValueMap();
+            return resolve(cname);
+        });
     }
-    else {
-      if (sys.equipment.maxBodies > 1) {
-        sensors.push({ name: 'Water Sensor 1', temp: state.temps.waterSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('water1'), binding: 'waterTempAdj1' },
-          { name: 'Water Sensor 2', temp: state.temps.waterSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('water2'), binding: 'waterTempAdj2' });
-        if (sys.equipment.maxBodies > 2)
-          sensors.push({ name: 'Water Sensor 3', temp: state.temps.waterSensor3, tempAdj: sys.equipment.tempSensors.getCalibration('water3'), binding: 'waterTempAdj3' });
-        if (sys.equipment.maxBodies > 3)
-          sensors.push({ name: 'Water Sensor 4', temp: state.temps.waterSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('water4'), binding: 'waterTempAdj4' });
-
-        if (sys.board.heaters.isSolarInstalled()) {
-          sensors.push({ name: 'Solar Sensor 1', temp: state.temps.solarSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('solar1'), binding: 'solarTempAdj1' },
-            { name: 'Solar Sensor 2', temp: state.temps.solarSensor2, tempAdj: sys.equipment.tempSensors.getCalibration('solar2'), binding: 'solarTempAdj2' });
-          if (sys.equipment.maxBodies > 2)
-            sensors.push({ name: 'Solar Sensor 3', temp: state.temps.solarSensor3, tempAdj: sys.equipment.tempSensors.getCalibration('solar3'), binding: 'solarTempAdj3' });
-          if (sys.equipment.maxBodies > 3)
-            sensors.push({ name: 'Water Sensor 4', temp: state.temps.solarSensor4, tempAdj: sys.equipment.tempSensors.getCalibration('solar4'), binding: 'solarTempAdj4' });
-        }
-      }
-      else {
-        sensors.push({ name: 'Water Sensor', temp: state.temps.waterSensor1, tempAdj: sys.equipment.tempSensors.getCalibration('water1'), binding: 'waterTempAdj1' });
-        if (sys.board.heaters.isSolarInstalled())
-          sensors.push({ name: 'Solar Sensor', temp: state.temps.solar, tempAdj: sys.equipment.tempSensors.getCalibration('solar1'), binding: 'solarTempAdj1' });
-      }
+    public syncCustomNamesValueMap() {
+        sys.customNames.sortById();
+        sys.board.valueMaps.customNames = new byteValueMap(
+            sys.customNames.get().map((el, idx) => {
+                return [idx + 200, { name: el.name, desc: el.name }];
+            })
+        );
     }
-    return sensors;
-  }
-  public async setCustomNamesAsync(names: any[]): Promise<CustomNameCollection> {
-    if (!Array.isArray(names)) return Promise.reject(new InvalidEquipmentDataError(`Data is not an array`, 'customNames', names))
-    let arr = [];
-    for (let i = 0; i < names.length; i++) { arr.push(sys.board.system.setCustomNameAsync(names[i])); }
-    return new Promise<CustomNameCollection>(async (resolve, reject) => {
-      try {
-        await Promise.all(arr).catch(err => reject(err));
-        // sys.board.system.syncCustomNamesValueMap(); Each custom name promise is already syncing the bytevalue array
-
-        resolve(sys.customNames);
-      }
-      catch (err) { reject(err); }
-    });
-  }
-  public async setCustomNameAsync(data: any): Promise<CustomName> {
-    return new Promise<CustomName>((resolve, reject) => {
-      let id = parseInt(data.id, 10);
-      if (isNaN(id)) return reject(new InvalidEquipmentIdError('Invalid Custom Name Id', data.id, 'customName'));
-      if (id > sys.equipment.maxCustomNames) return reject(new InvalidEquipmentIdError('Custom Name Id out of range', data.id, 'customName'));
-      let cname = sys.customNames.getItemById(id, true);
-      cname.name = data.name;
-      sys.board.system.syncCustomNamesValueMap();
-      return resolve(cname);
-    });
-  }
-  public syncCustomNamesValueMap() {
-    sys.customNames.sortById();
-    sys.board.valueMaps.customNames = new byteValueMap(
-      sys.customNames.get().map((el, idx) => {
-        return [idx + 200, { name: el.name, desc: el.name }];
-      })
-    );
-  }
+    public async setPanelModeAsync(data: any): Promise<any> { return { mode: state.mode }; }
 }
 export class BodyCommands extends BoardCommands {
   public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
@@ -1391,125 +1511,125 @@ export class BodyCommands extends BoardCommands {
   }
   public freezeProtectBodyOn: Date;
   public freezeProtectStart: Date;
-  public async syncFreezeProtection() {
-    try {
-      // Go through all the features and circuits to make sure we have the freeze protect set appropriately.  The freeze
-      // flag will have already been set whether this is a Nixie setup or there is an OCP involved.
+    public async syncFreezeProtection() {
+        try {
+            // Go through all the features and circuits to make sure we have the freeze protect set appropriately.  The freeze
+            // flag will have already been set whether this is a Nixie setup or there is an OCP involved.
 
-      // First turn on/off any features that are in our control that should be under our control.  If this is an OCP we
-      // do not create features beyond those controlled by the OCP so we don't need to check these in that condition.  That is
-      // why it first checks the controller type.
-      let freeze = utils.makeBool(state.freeze);
-      if (sys.controllerType === ControllerType.Nixie) {
-        // If we are a Nixie controller we need to evaluate the current freeze settings against the air temperature.
-        if (typeof state.temps.air !== 'undefined') {
-          // Start freeze protection when the temperature is <= the threshold but don't stop it until we are 2 degrees above the threshold.  This
-          // makes for a 3 degree offset.
-          if (state.temps.air <= sys.general.options.freezeThreshold) freeze = true;
-          else if (state.freeze && state.temps.air - 2 > sys.general.options.freezeThreshold) freeze = false;
-        }
-        else freeze = false;
+            // First turn on/off any features that are in our control that should be under our control.  If this is an OCP we
+            // do not create features beyond those controlled by the OCP so we don't need to check these in that condition.  That is
+            // why it first checks the controller type.
+            let freeze = utils.makeBool(state.freeze);
+            if (sys.controllerType === ControllerType.Nixie) {
+                // If we are a Nixie controller we need to evaluate the current freeze settings against the air temperature.
+                if (typeof state.temps.air !== 'undefined') {
+                    // Start freeze protection when the temperature is <= the threshold but don't stop it until we are 2 degrees above the threshold.  This
+                    // makes for a 3 degree offset.
+                    if (state.temps.air <= sys.general.options.freezeThreshold) freeze = true;
+                    else if (state.freeze && state.temps.air - 2 > sys.general.options.freezeThreshold) freeze = false;
+                }
+                else freeze = false;
 
-        // We need to know when we first turned the freeze protection on. This is because we will be rotating between pool and spa
-        // on shared body systems when both pool and spa have freeze protection checked.
-        if (state.freeze !== freeze) {
-          this.freezeProtectStart = freeze ? new Date() : undefined;
-          state.freeze = freeze;
-        }
-        for (let i = 0; i < sys.features.length; i++) {
-          let feature = sys.features.getItemByIndex(i);
-          let fstate = state.features.getItemById(feature.id, true);
-          if (!feature.freeze || !feature.isActive === true || feature.master !== 1) {
-            fstate.freezeProtect = false;
-            continue; // This is not affected by freeze conditions.
-          }
-          if (freeze && !fstate.isOn) {
-            // This feature should be on because we are freezing.
-            fstate.freezeProtect = true;
-            await sys.board.features.setFeatureStateAsync(feature.id, true);
-          }
-          else if (!freeze && fstate.freezeProtect) {
-            // This feature was turned on by freeze protection.  We need to turn it off because it has warmed up.
-            fstate.freezeProtect = false;
-            await sys.board.features.setFeatureStateAsync(feature.id, false);
-          }
-        }
-      }
-      let bodyRotationChecked = false;
-      for (let i = 0; i < sys.circuits.length; i++) {
-        let circ = sys.circuits.getItemByIndex(i);
-        let cstate = state.circuits.getItemById(circ.id);
-        if (!circ.freeze || !circ.isActive === true || circ.master !== 1) {
-          cstate.freezeProtect = false;
-          continue; // This is not affected by freeze conditions.
-        }
-        if (sys.equipment.shared && freeze && (circ.id === 1 || circ.id === 6)) {
-          // Exit out of here because we already checked the body rotation.  We only want to do this once since it can be expensive turning
-          // on a particular body.
-          if (bodyRotationChecked) continue;
-          // These are our body circuits so we need to check to see if they need to be rotated between pool and spa.
-          let pool = circ.id === 6 ? circ : sys.circuits.getItemById(6);
-          let spa = circ.id === 1 ? circ : sys.circuits.getItemById(1);
-          if (pool.freeze && spa.freeze) {
-            // We only need to rotate between pool and spa when they are both checked.
-            let pstate = circ.id === 6 ? cstate : state.circuits.getItemById(6);
-            let sstate = circ.id === 1 ? cstate : state.circuits.getItemById(1);
-            if (!pstate.isOn && !sstate.isOn) {
-              // Neither the pool or spa are on so we will turn on the pool first.
-              pstate.freezeProtect = true;
-              this.freezeProtectBodyOn = new Date();
-              await sys.board.circuits.setCircuitStateAsync(6, true);
+                // We need to know when we first turned the freeze protection on. This is because we will be rotating between pool and spa
+                // on shared body systems when both pool and spa have freeze protection checked.
+                if (state.freeze !== freeze) {
+                    this.freezeProtectStart = freeze ? new Date() : undefined;
+                    state.freeze = freeze;
+                }
+                for (let i = 0; i < sys.features.length; i++) {
+                    let feature = sys.features.getItemByIndex(i);
+                    let fstate = state.features.getItemById(feature.id, true);
+                    if (!feature.freeze || !feature.isActive === true || feature.master !== 1) {
+                        fstate.freezeProtect = false;
+                        continue; // This is not affected by freeze conditions.
+                    }
+                    if (freeze && !fstate.isOn) {
+                        // This feature should be on because we are freezing.
+                        fstate.freezeProtect = true;
+                        await sys.board.features.setFeatureStateAsync(feature.id, true);
+                    }
+                    else if (!freeze && fstate.freezeProtect) {
+                        // This feature was turned on by freeze protection.  We need to turn it off because it has warmed up.
+                        fstate.freezeProtect = false;
+                        await sys.board.features.setFeatureStateAsync(feature.id, false);
+                    }
+                }
             }
-            else {
-              // If neither of the bodies were turned on for freeze protection then we need to ignore this. 
-              if (!pstate.freezeProtect && !sstate.freezeProtect) {
-                this.freezeProtectBodyOn = undefined;
-                continue;
-              }
+            let bodyRotationChecked = false;
+            for (let i = 0; i < sys.circuits.length; i++) {
+                let circ = sys.circuits.getItemByIndex(i);
+                let cstate = state.circuits.getItemById(circ.id);
+                if (!circ.freeze || !circ.isActive === true || circ.master !== 1) {
+                    cstate.freezeProtect = false;
+                    continue; // This is not affected by freeze conditions.
+                }
+                if (sys.equipment.shared && freeze && (circ.id === 1 || circ.id === 6)) {
+                    // Exit out of here because we already checked the body rotation.  We only want to do this once since it can be expensive turning
+                    // on a particular body.
+                    if (bodyRotationChecked) continue;
+                    // These are our body circuits so we need to check to see if they need to be rotated between pool and spa.
+                    let pool = circ.id === 6 ? circ : sys.circuits.getItemById(6);
+                    let spa = circ.id === 1 ? circ : sys.circuits.getItemById(1);
+                    if (pool.freeze && spa.freeze) {
+                        // We only need to rotate between pool and spa when they are both checked.
+                        let pstate = circ.id === 6 ? cstate : state.circuits.getItemById(6);
+                        let sstate = circ.id === 1 ? cstate : state.circuits.getItemById(1);
+                        if (!pstate.isOn && !sstate.isOn) {
+                            // Neither the pool or spa are on so we will turn on the pool first.
+                            pstate.freezeProtect = true;
+                            this.freezeProtectBodyOn = new Date();
+                            await sys.board.circuits.setCircuitStateAsync(6, true);
+                        }
+                        else {
+                            // If neither of the bodies were turned on for freeze protection then we need to ignore this. 
+                            if (!pstate.freezeProtect && !sstate.freezeProtect) {
+                                this.freezeProtectBodyOn = undefined;
+                                continue;
+                            }
 
-              // One of the two bodies is on so we need to check for the rotation.  If it is time to rotate do the rotation.
-              if (typeof this.freezeProtectBodyOn === 'undefined') this.freezeProtectBodyOn = new Date();
-              let dt = new Date().getTime();
-              if (dt - 1000 * 60 * 15 > this.freezeProtectBodyOn.getTime()) {
-                logger.info(`Swapping bodies for freeze protection pool:${pstate.isOn} spa:${sstate.isOn} interval: ${utils.formatDuration(dt - this.freezeProtectBodyOn.getTime() / 1000)}`);
-                // 10 minutes has elapsed so we will be rotating to the other body.
-                if (pstate.isOn) {
-                  // The setCircuitState method will handle turning off the pool body.
-                  sstate.freezeProtect = true;
-                  pstate.freezeProtect = false;
-                  await sys.board.circuits.setCircuitStateAsync(1, true);
+                            // One of the two bodies is on so we need to check for the rotation.  If it is time to rotate do the rotation.
+                            if (typeof this.freezeProtectBodyOn === 'undefined') this.freezeProtectBodyOn = new Date();
+                            let dt = new Date().getTime();
+                            if (dt - 1000 * 60 * 15 > this.freezeProtectBodyOn.getTime()) {
+                                logger.info(`Swapping bodies for freeze protection pool:${pstate.isOn} spa:${sstate.isOn} interval: ${utils.formatDuration(dt - this.freezeProtectBodyOn.getTime() / 1000)}`);
+                                // 10 minutes has elapsed so we will be rotating to the other body.
+                                if (pstate.isOn) {
+                                    // The setCircuitState method will handle turning off the pool body.
+                                    sstate.freezeProtect = true;
+                                    pstate.freezeProtect = false;
+                                    await sys.board.circuits.setCircuitStateAsync(1, true);
+                                }
+                                else {
+                                    sstate.freezeProtect = false;
+                                    pstate.freezeProtect = true;
+                                    await sys.board.circuits.setCircuitStateAsync(6, true);
+                                }
+                                // Set a new date as this will be our rotation check now.
+                                this.freezeProtectBodyOn = new Date();
+                            }
+                        }
+                    }
+                    else {
+                        // Only this circuit is selected for freeze protection so we don't need any special treatment.
+                        cstate.freezeProtect = true;
+                        if (!cstate.isOn) await sys.board.circuits.setCircuitStateAsync(circ.id, true);
+                    }
+                    bodyRotationChecked = true;
                 }
-                else {
-                  sstate.freezeProtect = false;
-                  pstate.freezeProtect = true;
-                  await sys.board.circuits.setCircuitStateAsync(6, true);
+                else if (freeze && !cstate.isOn) {
+                    // This circuit should be on because we are freezing.
+                    cstate.freezeProtect = true;
+                    await sys.board.circuits.setCircuitStateAsync(circ.id, true);
+                }
+                else if (!freeze && cstate.freezeProtect) {
+                    // This feature was turned on by freeze protection.  We need to turn it off because it has warmed up.
+                    await sys.board.circuits.setCircuitStateAsync(circ.id, false);
+                    cstate.freezeProtect = false;
                 }
-                // Set a new date as this will be our rotation check now.
-                this.freezeProtectBodyOn = new Date();
-              }
             }
-          }
-          else {
-            // Only this circuit is selected for freeze protection so we don't need any special treatment.
-            cstate.freezeProtect = true;
-            if (!cstate.isOn) await sys.board.circuits.setCircuitStateAsync(circ.id, true);
-          }
-          bodyRotationChecked = true;
-        }
-        else if (freeze && !cstate.isOn) {
-          // This circuit should be on because we are freezing.
-          cstate.freezeProtect = true;
-          await sys.board.circuits.setCircuitStateAsync(circ.id, true);
         }
-        else if (!freeze && cstate.freezeProtect) {
-          // This feature was turned on by freeze protection.  We need to turn it off because it has warmed up.
-          await sys.board.circuits.setCircuitStateAsync(circ.id, false);
-          cstate.freezeProtect = false;
-        }
-      }
+        catch (err) { logger.error(`syncFreezeProtection: Error synchronizing freeze protection states: ${err.message}`); }
     }
-    catch (err) { logger.error(`syncFreezeProtection: Error synchronizing freeze protection states: ${err.message}`); }
-  }
 
   public async initFilters() {
     try {
@@ -1650,57 +1770,73 @@ export class BodyCommands extends BoardCommands {
     sys.board.heaters.syncHeaterStates();
     return Promise.resolve(bstate);
   }
-  public getHeatSources(bodyId: number) {
-    let heatSources = [];
-    let heatTypes = this.board.heaters.getInstalledHeaterTypes(bodyId);
-    heatSources.push(this.board.valueMaps.heatSources.transformByName('nochange'));
-    if (heatTypes.total > 0) heatSources.push(this.board.valueMaps.heatSources.transformByName('off'));
-    if (heatTypes.gas > 0) heatSources.push(this.board.valueMaps.heatSources.transformByName('heater'));
-    if (heatTypes.mastertemp > 0) heatSources.push(this.board.valueMaps.heatSources.transformByName('mastertemp'));
-    if (heatTypes.solar > 0) {
-      let hm = this.board.valueMaps.heatSources.transformByName('solar');
-      heatSources.push(hm);
-      if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('solarpref'));
-    }
-    if (heatTypes.heatpump > 0) {
-      let hm = this.board.valueMaps.heatSources.transformByName('heatpump');
-      heatSources.push(hm);
-      if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('heatpumppref'));
-    }
-    if (heatTypes.ultratemp > 0) {
-      let hm = this.board.valueMaps.heatSources.transformByName('ultratemp');
-      heatSources.push(hm);
-      if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('ultratemppref'));
+    public getHeatSources(bodyId: number) {
+        let heatSources = [];
+        let heatTypes = this.board.heaters.getInstalledHeaterTypes(bodyId);
+        heatSources.push(this.board.valueMaps.heatSources.transformByName('nochange'));
+        if (heatTypes.total > 0) heatSources.push(this.board.valueMaps.heatSources.transformByName('off'));
+        if (heatTypes.gas > 0) heatSources.push(this.board.valueMaps.heatSources.transformByName('heater'));
+        if (heatTypes.mastertemp > 0) heatSources.push(this.board.valueMaps.heatSources.transformByName('mastertemp'));
+        if (heatTypes.solar > 0) {
+            let hm = this.board.valueMaps.heatSources.transformByName('solar');
+            heatSources.push(hm);
+            if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('solarpref'));
+        }
+        if (heatTypes.heatpump > 0) {
+            let hm = this.board.valueMaps.heatSources.transformByName('heatpump');
+            heatSources.push(hm);
+            if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('heatpumppref'));
+        }
+        if (heatTypes.ultratemp > 0) {
+            let hm = this.board.valueMaps.heatSources.transformByName('ultratemp');
+            heatSources.push(hm);
+            if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('ultratemppref'));
+        }
+        if (heatTypes.hybrid > 0) {
+            heatSources.push(this.board.valueMaps.heatSources.transformByName('hybheat'));
+            heatSources.push(this.board.valueMaps.heatSources.transformByName('hybheatpump'));
+            heatSources.push(this.board.valueMaps.heatSources.transformByName('hybhybrid'));
+            heatSources.push(this.board.valueMaps.heatSources.transformByName('hybdual'));
+        }
+        return heatSources;
     }
-    return heatSources;
-  }
-  public getHeatModes(bodyId: number) {
-    let heatModes = [];
-    sys.board.heaters.updateHeaterServices();
+    public getHeatModes(bodyId: number) {
+        let heatModes = [];
+        sys.board.heaters.updateHeaterServices();
 
-    // RKS: 09-26-20 This will need to be overloaded in IntelliCenterBoard when the other heater types are identified. (e.g. ultratemp, hybrid, maxetherm, and mastertemp)
-    heatModes.push(this.board.valueMaps.heatModes.transformByName('off')); // In IC fw 1.047 off is no longer 0.
-    let heatTypes = this.board.heaters.getInstalledHeaterTypes(bodyId);
-    if (heatTypes.hybrid > 0) heatModes = this.board.valueMaps.heatModes.toArray();
-    if (heatTypes.gas > 0) heatModes.push(this.board.valueMaps.heatModes.transformByName('heater'));
-    if (heatTypes.mastertemp > 0) heatModes.push(this.board.valueMaps.heatModes.transformByName('mtheater'));
-    if (heatTypes.solar > 0) {
-      let hm = this.board.valueMaps.heatModes.transformByName('solar');
-      heatModes.push(hm);
-      if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('solarpref'));
-    }
-    if (heatTypes.heatpump > 0) {
-      let hm = this.board.valueMaps.heatModes.transformByName('heatpump');
-      heatModes.push(hm);
-      if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('heatpumppref'));
-    }
-    if (heatTypes.ultratemp > 0) {
-      let hm = this.board.valueMaps.heatModes.transformByName('ultratemp');
-      heatModes.push(hm);
-      if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('ultratemppref'));
+        // RKS: 09-26-20 This will need to be overloaded in IntelliCenterBoard when the other heater types are identified. (e.g. ultratemp, hybrid, maxetherm, and mastertemp)
+        heatModes.push(this.board.valueMaps.heatModes.transformByName('off')); // In IC fw 1.047 off is no longer 0.
+        let heatTypes = this.board.heaters.getInstalledHeaterTypes(bodyId);
+        if (heatTypes.hybrid > 0) {
+            // RKS: 08-24-22 Unfortunately we mistakenly thought that these needed to be matched to the other heater types.  The heat modes
+            // are unique for the hybrid heater.
+            heatModes.push(sys.board.valueMaps.heatModes.transformByName('hybheat'));
+            heatModes.push(sys.board.valueMaps.heatModes.transformByName('hybheatpump'));
+            heatModes.push(sys.board.valueMaps.heatModes.transformByName('hybhybrid'));
+            heatModes.push(sys.board.valueMaps.heatModes.transformByName('hybdual'));
+            //heatModes = this.board.valueMaps.heatModes.toArray();
+        }
+        if (heatTypes.gas > 0) {
+            heatModes.push(this.board.valueMaps.heatModes.transformByName('heater'));
+        }
+        if (heatTypes.mastertemp > 0) heatModes.push(this.board.valueMaps.heatModes.transformByName('mtheater'));
+        if (heatTypes.solar > 0) {
+            let hm = this.board.valueMaps.heatModes.transformByName('solar');
+            heatModes.push(hm);
+            if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('solarpref'));
+        }
+        if (heatTypes.heatpump > 0) {
+            let hm = this.board.valueMaps.heatModes.transformByName('heatpump');
+            heatModes.push(hm);
+            if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('heatpumppref'));
+        }
+        if (heatTypes.ultratemp > 0) {
+            let hm = this.board.valueMaps.heatModes.transformByName('ultratemp');
+            heatModes.push(hm);
+            if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('ultratemppref'));
+        }
+        return heatModes;
     }
-    return heatModes;
-  }
   public getPoolStates(): BodyTempState[] {
     let arrPools = [];
     for (let i = 0; i < state.temps.bodies.length; i++) {
@@ -1833,7 +1969,7 @@ export class PumpCommands extends BoardCommands {
       return this.board.valueMaps.pumpUnits.transform(val);
     }
   }
-  public async setPumpAsync(data: any): Promise<Pump> {
+  public async setPumpAsync(data: any, send: boolean = true): Promise<Pump> {
     try {
       let id = typeof data.id === 'undefined' ? -1 : parseInt(data.id, 10);
       if (id <= 0) id = sys.pumps.filter(elem => elem.master === 1).getMaxId(false, 49) + 1;
@@ -1877,42 +2013,6 @@ export class PumpCommands extends BoardCommands {
     let spump = state.pumps.getItemById(pump.id);
     spump.emitData('pumpExt', spump.getExtended());
   }
-
-  public setType(pump: Pump, pumpType: number) {
-    // if we are changing pump types, need to clear out circuits
-    // and props that aren't for this pump type
-    let _id = pump.id;
-    if (pump.type !== pumpType || pumpType === 0) {
-      let _p = pump.get(true);
-      // const _isVirtual = typeof _p.isVirtual !== 'undefined' ? _p.isVirtual : false;
-      sys.pumps.removeItemById(_id);
-      pump = sys.pumps.getItemById(_id, true);
-      /* if (_isVirtual) {
-        // pump.isActive = true;
-        // pump.isVirtual = true;
-        pump.master = 1;
-      } */
-      state.pumps.removeItemById(pump.id);
-      pump.type = pumpType;
-      let type = sys.board.valueMaps.pumpTypes.transform(pumpType);
-
-      if (type.name === 'vs' || type.name === 'vsf') {
-        pump.speedStepSize = 10;
-        pump.minSpeed = type.minSpeed;
-        pump.maxSpeed = type.maxSpeed;
-      }
-      if (type.name === 'vf' || type.name === 'vsf') {
-        pump.flowStepSize = 1;
-        pump.minFlow = type.minFlow;
-        pump.maxFlow = type.maxFlow;
-      }
-      let spump = state.pumps.getItemById(pump.id, true);
-      spump.type = pump.type;
-      spump.isActive = pump.isActive;
-      spump.status = 0;
-      spump.emitData('pumpExt', spump.getExtended());
-    }
-  }
   public availableCircuits() {
     let _availCircuits = [];
     for (let i = 0; i < sys.circuits.length; i++) {
@@ -2110,262 +2210,270 @@ export class CircuitCommands extends BoardCommands {
       }
     } catch (err) { logger.error(`syncCircuitRelayStates: Error synchronizing circuit relays ${err.message}`); }
   }
-  public syncVirtualCircuitStates() {
-    try {
-      let arrCircuits = sys.board.valueMaps.virtualCircuits.toArray();
-      let poolStates = sys.board.bodies.getPoolStates();
-      let spaStates = sys.board.bodies.getSpaStates();
-      // The following should work for all board types if the virtualCiruit valuemaps use common names.  The circuit ids can be
-      // different as well as the descriptions but these should have common names since they are all derived from existing states.
+    public syncVirtualCircuitStates() {
+        try {
+            let arrCircuits = sys.board.valueMaps.virtualCircuits.toArray();
+            let poolStates = sys.board.bodies.getPoolStates();
+            let spaStates = sys.board.bodies.getSpaStates();
+            // The following should work for all board types if the virtualCiruit valuemaps use common names.  The circuit ids can be
+            // different as well as the descriptions but these should have common names since they are all derived from existing states.
 
-      // This also removes virtual circuits depending on whether heaters exsits on the bodies.  Not sure why we are doing this
-      // as the body data contains whether a body is heated or not.  Perhapse some attached interface is using
-      // the virtual circuit list as a means to determine whether solar is available.  That is totally flawed if that is the case.
-      for (let i = 0; i < arrCircuits.length; i++) {
-        let vc = arrCircuits[i];
-        let remove = false;
-        let bState = false;
-        let cstate: VirtualCircuitState = null;
-        switch (vc.name) {
-          case 'poolHeater':
-            // If any pool is heating up.
-            remove = true;
-            for (let j = 0; j < poolStates.length; j++) {
-              if (poolStates[j].heaterOptions.total > 0) remove = false;
-            }
-            if (!remove) {
-              // Determine whether the pool heater is on.
-              for (let j = 0; j < poolStates.length; j++) {
-                if (sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus) === 'heater') {
-                  // In this instance we may have a delay underway.
-                  let hstate = state.heaters.find(x => x.bodyId === 1 && x.startupDelay === true && x.type.name !== 'solar');
-                  bState = typeof hstate === 'undefined';
-                }
-              }
-            }
-            break;
-          case 'spaHeater':
-            remove = true;
-            for (let j = 0; j < spaStates.length; j++) {
-              if (spaStates[j].heaterOptions.total > 0) remove = false;
-            }
-            if (!remove) {
-              // Determine whether the spa heater is on.
-              for (let j = 0; j < spaStates.length; j++) {
-                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'heater') {
-                  // In this instance we may have a delay underway.
-                  let hstate = state.heaters.find(x => x.bodyId === 1 && x.startupDelay === true && x.type.name !== 'solar');
-                  bState = typeof hstate === 'undefined';
-                }
-              }
-              //for (let j = 0; j < spaStates.length; j++) {
-              //    if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'heater') bState = true;
-              //}
-            }
-            break;
-          case 'heater':
-            // If heater is on for any body
-            // RSG 5-3-22: Heater will now refer to any poolHeater or spaHeater but not solar or other types.  anyHeater now takes that role.
-            remove = true;
-            for (let j = 0; j < poolStates.length; j++) {
-              if (poolStates[j].heaterOptions.solar + poolStates[j].heaterOptions.heatpump > 0) remove = false;
-            }
-            if (remove) {
-              for (let j = 0; j < spaStates.length; j++) {
-                if (spaStates[j].heaterOptions.solar + spaStates[j].heaterOptions.heatpump > 0) remove = false;
-              }
-            }
-            if (!remove) {
-              for (let j = 0; j < poolStates.length && !bState; j++) {
-                if (sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus) === 'heater') bState = true;
-              }
-              for (let j = 0; j < spaStates.length && !bState; j++) {
-                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'heater') bState = true;
-              }
-            }
-            break;
-          case 'freeze':
-            // If freeze protection has been turned on.
-            bState = state.freeze;
-            break;
-          case 'poolSpa':
-            // If any pool or spa is on
-            for (let j = 0; j < poolStates.length && !bState; j++) {
-              if (poolStates[j].isOn) bState = true;
-            }
-            for (let j = 0; j < spaStates.length && !bState; j++) {
-              if (spaStates[j].isOn) bState = true;
-            }
-            break;
-          case 'solarHeat':
-          case 'solar':
-            // If solar is on for any body
-            remove = true;
-            for (let j = 0; j < poolStates.length; j++) {
-              if (poolStates[j].heaterOptions.solar + poolStates[j].heaterOptions.heatpump > 0) remove = false;
-            }
-            if (remove) {
-              for (let j = 0; j < spaStates.length; j++) {
-                if (spaStates[j].heaterOptions.solar + spaStates[j].heaterOptions.heatpump > 0) remove = false;
-              }
-            }
-            if (!remove) {
-              for (let j = 0; j < poolStates.length && !bState; j++) {
-                if (sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus) === 'solar') bState = true;
-              }
-              for (let j = 0; j < spaStates.length && !bState; j++) {
-                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') bState = true;
-              }
-            }
-            break;
-          case 'solar1':
-            remove = true;
-            for (let j = 0; j < poolStates.length; j++) {
-              if (poolStates[j].id === 1 && poolStates[j].heaterOptions.solar) {
-                remove = false;
-                vc.desc = `${poolStates[j].name} Solar`;
-                if (sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus) === 'solar') {
-                  // In this instance we may have a delay underway.
-                  let hstate = state.heaters.find(x => x.bodyId === 1 && x.startupDelay === true && x.type.name === 'solar');
-                  bState = typeof hstate === 'undefined';
-                }
-              }
-            }
-            for (let j = 0; j < spaStates.length; j++) {
-              if (spaStates[j].id === 1 && spaStates[j].heaterOptions.solar) {
-                remove = false;
-                vc.desc = `${spaStates[j].name} Solar`;
-                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
-                  // In this instance we may have a delay underway.
-                  let hstate = state.heaters.find(x => x.bodyId === 1 && x.startupDelay === true && x.type.name === 'solar');
-                  bState = typeof hstate === 'undefined';
-                }
-              }
-            }
+            // This also removes virtual circuits depending on whether heaters exsits on the bodies.  Not sure why we are doing this
+            // as the body data contains whether a body is heated or not.  Perhapse some attached interface is using
+            // the virtual circuit list as a means to determine whether solar is available.  That is totally flawed if that is the case.
+            for (let i = 0; i < arrCircuits.length; i++) {
+                let vc = arrCircuits[i];
+                let remove = false;
+                let bState = false;
+                let cstate: VirtualCircuitState = null;
+                switch (vc.name) {
+                    case 'poolHeater':
+                        // If any pool is heating up.
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            if (poolStates[j].heaterOptions.total > 0) remove = false;
+                        }
+                        if (!remove) {
+                            // Determine whether the pool heater is on.
+                            for (let j = 0; j < poolStates.length; j++) {
+                                let hstatus = sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus);
+                                if (hstatus !== 'off' && hstatus !== 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 1 && x.startupDelay === true && x.type.name !== 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
+                        break;
+                    case 'spaHeater':
+                        remove = true;
+                        for (let j = 0; j < spaStates.length; j++) {
+                            if (spaStates[j].heaterOptions.total > 0) remove = false;
+                        }
+                        if (!remove) {
+                            // Determine whether the spa heater is on.
+                            for (let j = 0; j < spaStates.length; j++) {
+                                let hstatus = sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus);
+                                if (hstatus !== 'off' && hstatus !== 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 2 && x.startupDelay === true && x.type.name !== 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                            //for (let j = 0; j < spaStates.length; j++) {
+                            //    if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'heater') bState = true;
+                            //}
+                        }
+                        break;
+                    case 'heater':
+                        // If heater is on for any body
+                        // RSG 5-3-22: Heater will now refer to any poolHeater or spaHeater but not solar or other types.  anyHeater now takes that role.
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            if (poolStates[j].heaterOptions.solar + poolStates[j].heaterOptions.heatpump > 0) remove = false;
+                        }
+                        if (remove) {
+                            for (let j = 0; j < spaStates.length; j++) {
+                                if (spaStates[j].heaterOptions.solar + spaStates[j].heaterOptions.heatpump > 0) remove = false;
+                            }
+                        }
+                        if (!remove) {
+                            for (let j = 0; j < poolStates.length && !bState; j++) {
+                                let hstatus = sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus);
+                                if (hstatus === 'heater' || hstatus === 'hpheat' || hstatus === 'mtheat' || hstatus === 'hybheat') bState = true;
+                            }
+                            for (let j = 0; j < spaStates.length && !bState; j++) {
+                                let hstatus = sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus);
+                                if (hstatus === 'heater' || hstatus === 'hpheat' || hstatus === 'mtheat' || hstatus === 'hybheat') bState = true;
+                            }
+                        }
+                        break;
+                    case 'freeze':
+                        // If freeze protection has been turned on.
+                        bState = state.freeze;
+                        break;
+                    case 'poolSpa':
+                        // If any pool or spa is on
+                        for (let j = 0; j < poolStates.length && !bState; j++) {
+                            if (poolStates[j].isOn) bState = true;
+                        }
+                        for (let j = 0; j < spaStates.length && !bState; j++) {
+                            if (spaStates[j].isOn) bState = true;
+                        }
+                        break;
+                    case 'solarHeat':
+                    case 'solar':
+                        // If solar is on for any body
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            // RKS: 05-30-22 - I have no idea why this would include the heatpump options
+                            //if (poolStates[j].heaterOptions.solar + poolStates[j].heaterOptions.heatpump > 0) remove = false;
+                            if (poolStates[j].heaterOptions.solar) remove = false;
+                        }
+                        if (remove) {
+                            for (let j = 0; j < spaStates.length; j++) {
+                                // RKS: 05-30-22 - I have no idea why this would include the heatpump options
+                                //if (spaStates[j].heaterOptions.solar + spaStates[j].heaterOptions.heatpump > 0) remove = false;
+                                if (spaStates[j].heaterOptions.solar) remove = false;
+                            }
+                        }
+                        if (!remove) {
+                            for (let j = 0; j < poolStates.length && !bState; j++) {
+                                if (sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus) === 'solar') bState = true;
+                            }
+                            for (let j = 0; j < spaStates.length && !bState; j++) {
+                                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') bState = true;
+                            }
+                        }
+                        break;
+                    case 'solar1':
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            if (poolStates[j].id === 1 && poolStates[j].heaterOptions.solar) {
+                                remove = false;
+                                vc.desc = `${poolStates[j].name} Solar`;
+                                if (sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus) === 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 1 && x.startupDelay === true && x.type.name === 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
+                        for (let j = 0; j < spaStates.length; j++) {
+                            if (spaStates[j].id === 1 && spaStates[j].heaterOptions.solar) {
+                                remove = false;
+                                vc.desc = `${spaStates[j].name} Solar`;
+                                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 1 && x.startupDelay === true && x.type.name === 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
 
-            break;
-          case 'solar2':
-            remove = true;
-            for (let j = 0; j < poolStates.length; j++) {
-              if (poolStates[j].id === 2 && poolStates[j].heaterOptions.solar) {
-                remove = false;
-                vc.desc = `${poolStates[j].name} Solar`;
-                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
-                  // In this instance we may have a delay underway.
-                  let hstate = state.heaters.find(x => x.bodyId === 2 && x.startupDelay === true && x.type.name === 'solar');
-                  bState = typeof hstate === 'undefined';
-                }
-              }
-            }
-            for (let j = 0; j < spaStates.length; j++) {
-              if (spaStates[j].id === 2 && spaStates[j].heaterOptions.solar) {
-                remove = false;
-                vc.desc = `${spaStates[j].name} Solar`;
-                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
-                  // In this instance we may have a delay underway.
-                  let hstate = state.heaters.find(x => x.bodyId === 2 && x.startupDelay === true && x.type.name === 'solar');
-                  bState = typeof hstate === 'undefined';
-                }
-              }
-            }
-            break;
-          case 'solar3':
-            remove = true;
-            for (let j = 0; j < poolStates.length; j++) {
-              if (poolStates[j].id === 3 && poolStates[j].heaterOptions.solar) {
-                remove = false;
-                vc.desc = `${poolStates[j].name} Solar`;
-                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
-                  // In this instance we may have a delay underway.
-                  let hstate = state.heaters.find(x => x.bodyId === 3 && x.startupDelay === true && x.type.name === 'solar');
-                  bState = typeof hstate === 'undefined';
-                }
-              }
-            }
-            for (let j = 0; j < spaStates.length; j++) {
-              if (spaStates[j].id === 3 && spaStates[j].heaterOptions.solar) {
-                remove = false;
-                vc.desc = `${spaStates[j].name} Solar`;
-                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
-                  // In this instance we may have a delay underway.
-                  let hstate = state.heaters.find(x => x.bodyId === 3 && x.startupDelay === true && x.type.name === 'solar');
-                  bState = typeof hstate === 'undefined';
-                }
-              }
-            }
+                        break;
+                    case 'solar2':
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            if (poolStates[j].id === 2 && poolStates[j].heaterOptions.solar) {
+                                remove = false;
+                                vc.desc = `${poolStates[j].name} Solar`;
+                                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 2 && x.startupDelay === true && x.type.name === 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
+                        for (let j = 0; j < spaStates.length; j++) {
+                            if (spaStates[j].id === 2 && spaStates[j].heaterOptions.solar) {
+                                remove = false;
+                                vc.desc = `${spaStates[j].name} Solar`;
+                                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 2 && x.startupDelay === true && x.type.name === 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
+                        break;
+                    case 'solar3':
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            if (poolStates[j].id === 3 && poolStates[j].heaterOptions.solar) {
+                                remove = false;
+                                vc.desc = `${poolStates[j].name} Solar`;
+                                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 3 && x.startupDelay === true && x.type.name === 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
+                        for (let j = 0; j < spaStates.length; j++) {
+                            if (spaStates[j].id === 3 && spaStates[j].heaterOptions.solar) {
+                                remove = false;
+                                vc.desc = `${spaStates[j].name} Solar`;
+                                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 3 && x.startupDelay === true && x.type.name === 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
 
-            break;
-          case 'solar4':
-            remove = true;
-            for (let j = 0; j < poolStates.length; j++) {
-              if (poolStates[j].id === 4 && poolStates[j].heaterOptions.solar) {
-                remove = false;
-                vc.desc = `${poolStates[j].name} Solar`;
-                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
-                  // In this instance we may have a delay underway.
-                  let hstate = state.heaters.find(x => x.bodyId === 4 && x.startupDelay === true && x.type.name === 'solar');
-                  bState = typeof hstate === 'undefined';
+                        break;
+                    case 'solar4':
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            if (poolStates[j].id === 4 && poolStates[j].heaterOptions.solar) {
+                                remove = false;
+                                vc.desc = `${poolStates[j].name} Solar`;
+                                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 4 && x.startupDelay === true && x.type.name === 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
+                        for (let j = 0; j < spaStates.length; j++) {
+                            if (spaStates[j].id === 4 && spaStates[j].heaterOptions.solar) {
+                                remove = false;
+                                vc.desc = `${spaStates[j].name} Solar`;
+                                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 4 && x.startupDelay === true && x.type.name === 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
+                        break;
+                    case 'anyHeater':
+                        // RSG 5-3-22 anyHeater now represents any solar, gas, etc heater.  This replaces 'heater' which now refers to only gas heaters.
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            if (poolStates[j].heaterOptions.total > 0) remove = false;
+                        }
+                        if (remove) {
+                            for (let j = 0; j < spaStates.length; j++) {
+                                if (spaStates[j].heaterOptions.total > 0) remove = false;
+                            }
+                        }
+                        if (!remove) {
+                            for (let j = 0; j < poolStates.length && !bState; j++) {
+                                let heat = sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus);
+                                if (heat !== 'off') bState = true;
+                            }
+                            for (let j = 0; j < spaStates.length && !bState; j++) {
+                                let heat = sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus);
+                                if (heat !== 'off') bState = true;
+                            }
+                        }
+                        break;
+                    default:
+                        remove = true;
+                        break;
                 }
-              }
-            }
-            for (let j = 0; j < spaStates.length; j++) {
-              if (spaStates[j].id === 4 && spaStates[j].heaterOptions.solar) {
-                remove = false;
-                vc.desc = `${spaStates[j].name} Solar`;
-                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
-                  // In this instance we may have a delay underway.
-                  let hstate = state.heaters.find(x => x.bodyId === 4 && x.startupDelay === true && x.type.name === 'solar');
-                  bState = typeof hstate === 'undefined';
+                if (remove) {
+                    if (state.virtualCircuits.exists(x => vc.val === x.id)) {
+                        cstate = state.virtualCircuits.getItemById(vc.val, true);
+                        cstate.isActive = false;
+                        cstate.emitEquipmentChange();
+                    }
+                    state.virtualCircuits.removeItemById(vc.val);
+                }
+                else {
+                    cstate = state.virtualCircuits.getItemById(vc.val, true);
+                    cstate.isActive = true;
+                    if (cstate !== null) {
+                        cstate.isOn = bState;
+                        cstate.type = vc.val;
+                        cstate.name = vc.desc;
+                    }
                 }
-              }
-            }
-            break;
-          case 'anyHeater':
-            // RSG 5-3-22 anyHeater now represents any solar, gas, etc heater.  This replaces 'heater' which now refers to only gas heaters.
-            remove = true;
-            for (let j = 0; j < poolStates.length; j++) {
-              if (poolStates[j].heaterOptions.total > 0) remove = false;
-            }
-            if (remove) {
-              for (let j = 0; j < spaStates.length; j++) {
-                if (spaStates[j].heaterOptions.total > 0) remove = false;
-              }
-            }
-            if (!remove) {
-              for (let j = 0; j < poolStates.length && !bState; j++) {
-                let heat = sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus);
-                if (heat !== 'off') bState = true;
-              }
-              for (let j = 0; j < spaStates.length && !bState; j++) {
-                let heat = sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus);
-                if (heat !== 'off') bState = true;
-              }
             }
-            break;
-          default:
-            remove = true;
-            break;
-        }
-        if (remove) {
-          if (state.virtualCircuits.exists(x => vc.val === x.id)) {
-            cstate = state.virtualCircuits.getItemById(vc.val, true);
-            cstate.isActive = false;
-            cstate.emitEquipmentChange();
-          }
-          state.virtualCircuits.removeItemById(vc.val);
-        }
-        else {
-          cstate = state.virtualCircuits.getItemById(vc.val, true);
-          cstate.isActive = true;
-          if (cstate !== null) {
-            cstate.isOn = bState;
-            cstate.type = vc.val;
-            cstate.name = vc.desc;
-          }
-        }
-      }
-    } catch (err) { logger.error(`Error syncronizing virtual circuits`); }
-  }
+        } catch (err) { logger.error(`Error synchronizing virtual circuits`); }
+    }
   public async setCircuitStateAsync(id: number, val: boolean, ignoreDelays?: boolean): Promise<ICircuitState> {
     sys.board.suspendStatus(true);
     try {
@@ -2443,60 +2551,50 @@ export class CircuitCommands extends BoardCommands {
         await sys.board.circuits.setCircuitStateAsync(arrCircs[i].id, false);
         //proms.push(ncp.circuits.sendOnOffSequenceAsync(arrCircs[i].id, cmd.sequence));
       }
-      await utils.sleep(10000);
+      await setTimeout(10000);
       for (let i = 0; i < arrCircs.length; i++) {
         await sys.board.circuits.setCircuitStateAsync(arrCircs[i].id, true);
         //proms.push(ncp.circuits.sendOnOffSequenceAsync(arrCircs[i].id, cmd.sequence));
       }
-
-      //if (proms.length > 0) {
-      //    //await Promise.all(proms);
-      //    // Let it simmer for 6 seconds then turn it off and back on.
-      //    proms.length = 0;
-      //    for (let i = 0; i < arrCircs.length; i++) {
-      //        proms.push(sys.board.circuits.setCircuitStateAsync(arrCircs[i].id, false));
-      //    }
-      //    await Promise.all(proms);
-      //    // Let it be off for 3 seconds then turn it back on.
-      //    await utils.sleep(10000);
-      //    proms.length = 0;
-      //    for (let i = 0; i < arrCircs.length; i++) {
-      //        proms.push(sys.board.circuits.setCircuitStateAsync(arrCircs[i].id, true));
-      //    }
-      //    await Promise.all(proms);
-      //}
       sgrp.action = 0;
       sgrp.emitEquipmentChange();
       return state.lightGroups.getItemById(id);
     }
     catch (err) { return Promise.reject(`Error runLightGroupCommandAsync ${err.message}`); }
   }
-  public async runLightCommandAsync(obj: any): Promise<ICircuitState> {
-    // Do all our validation.
-    try {
-      let id = parseInt(obj.id, 10);
-      let cmd = typeof obj.command !== 'undefined' ? sys.board.valueMaps.lightCommands.findItem(obj.command) : { val: 0, name: 'undefined' };
-      if (cmd.val === 0) return Promise.reject(new InvalidOperationError(`Light command ${cmd.name} does not exist`, 'runLightCommandAsync'));
-      if (isNaN(id)) return Promise.reject(new InvalidOperationError(`Light ${id} does not exist`, 'runLightCommandAsync'));
-      let circ = sys.circuits.getItemById(id);
-      if (!circ.isActive) return Promise.reject(new InvalidOperationError(`Light circuit #${id} is not active`, 'runLightCommandAsync'));
-      let type = sys.board.valueMaps.circuitFunctions.transform(circ.type);
-      if (!type.isLight) return Promise.reject(new InvalidOperationError(`Circuit #${id} is not a light`, 'runLightCommandAsync'));
-      let nop = sys.board.valueMaps.circuitActions.getValue(cmd.name);
-      let slight = state.circuits.getItemById(circ.id);
-      slight.action = nop;
-      console.log(nop);
-      slight.emitEquipmentChange();
-      await ncp.circuits.sendOnOffSequenceAsync(circ.id, cmd.sequence);
-      await utils.sleep(7000);
-      await sys.board.circuits.setCircuitStateAsync(circ.id, false);
-      await sys.board.circuits.setCircuitStateAsync(circ.id, true);
-      slight.action = 0;
-      slight.emitEquipmentChange();
-      return slight;
+    public async runLightCommandAsync(obj: any): Promise<ICircuitState> {
+        // Do all our validation.
+        try {
+            let id = parseInt(obj.id, 10);
+            let cmd = typeof obj.command !== 'undefined' ? sys.board.valueMaps.lightCommands.findItem(obj.command) : { val: 0, name: 'undefined' };
+            if (cmd.val === 0) return Promise.reject(new InvalidOperationError(`Light command ${cmd.name} does not exist`, 'runLightCommandAsync'));
+            if (isNaN(id)) return Promise.reject(new InvalidOperationError(`Light ${id} does not exist`, 'runLightCommandAsync'));
+            let circ = sys.circuits.getItemById(id);
+            if (!circ.isActive) return Promise.reject(new InvalidOperationError(`Light circuit #${id} is not active`, 'runLightCommandAsync'));
+            let type = sys.board.valueMaps.circuitFunctions.transform(circ.type);
+            if (!type.isLight) return Promise.reject(new InvalidOperationError(`Circuit #${id} is not a light`, 'runLightCommandAsync'));
+            let nop = sys.board.valueMaps.circuitActions.getValue(cmd.name);
+            let slight = state.circuits.getItemById(circ.id);
+            slight.action = nop;
+            console.log(nop);
+            slight.emitEquipmentChange();
+            await ncp.circuits.sendOnOffSequenceAsync(circ.id, cmd.sequence);
+            if (cmd.sequence.length > 0) {
+                await sys.board.circuits.setCircuitStateAsync(circ.id, cmd.sequence[cmd.sequence.length - 1].isOn);
+            }
+            if (typeof cmd.endingTheme !== 'undefined') {
+                let thm = sys.board.valueMaps.lightThemes.findItem(cmd.endingTheme);
+                if (typeof thm !== 'undefined') slight.lightingTheme = circ.lightingTheme = thm.val;
+            }
+            //await setTimeout(7000);
+            //await sys.board.circuits.setCircuitStateAsync(circ.id, false);
+            //await sys.board.circuits.setCircuitStateAsync(circ.id, true);
+            slight.action = 0;
+            slight.emitEquipmentChange();
+            return slight;
+        }
+        catch (err) { return Promise.reject(`Error runLightCommandAsync ${err.message}`); }
     }
-    catch (err) { return Promise.reject(`Error runLightCommandAsync ${err.message}`); }
-  }
   public async setLightThemeAsync(id: number, theme: number): Promise<ICircuitState> {
     let cstate = state.circuits.getItemById(id);
     let circ = sys.circuits.getItemById(id);
@@ -2507,7 +2605,7 @@ export class CircuitCommands extends BoardCommands {
     try {
       if (typeof thm !== 'undefined' && typeof thm.sequence !== 'undefined' && circ.master === 1) {
         await sys.board.circuits.setCircuitStateAsync(id, true);
-        await ncp.circuits.sendOnOffSequenceAsync(id, thm.sequence);
+        await ncp.circuits.setLightThemeAsync(id, thm);
       }
       cstate.lightingTheme = theme;
       return cstate;
@@ -2595,63 +2693,64 @@ export class CircuitCommands extends BoardCommands {
   }
   public getLightThemes(type?: number) { return sys.board.valueMaps.lightThemes.toArray(); }
   public getCircuitFunctions() {
-    let cf = sys.board.valueMaps.circuitFunctions.toArray();
-    if (!sys.equipment.shared) cf = cf.filter(x => { return x.name !== 'spillway' && x.name !== 'spadrain' });
-    return cf;
-  }
-  public getCircuitNames() { return [...sys.board.valueMaps.circuitNames.toArray(), ...sys.board.valueMaps.customNames.toArray()]; }
-  public async setCircuitAsync(data: any): Promise<ICircuit> {
-    try {
-      let id = parseInt(data.id, 10);
-      if (id <= 0 || typeof data.id === 'undefined') {
-        // We are adding a new circuit.  If we are operating as a nixie controller then we need to start this
-        // circuit outside the range of circuits that can be defined on the panel.  For any of the non-OCP controllers
-        // these are added within the range of the circuits starting with 1.  For all others these are added with an id > 255.
-        switch (state.equipment.controllerType) {
-          case 'intellicenter':
-          case 'intellitouch':
-          case 'easytouch':
-            id = sys.circuits.getNextEquipmentId(new EquipmentIdRange(255, 300));
-            break;
-          default:
-            id = sys.circuits.getNextEquipmentId(sys.board.equipmentIds.circuits, [1, 6]);
-            break;
-        }
-      }
-      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(`Circuit id is out of range: ${id}`, data.id, 'Circuit'));;
-      if (typeof data.id !== 'undefined') {
-        let circuit = sys.circuits.getItemById(id, true);
-        let scircuit = state.circuits.getItemById(id, true);
-        scircuit.isActive = circuit.isActive = true;
-        circuit.master = 1;
-        scircuit.isOn = false;
-        if (data.name) circuit.name = scircuit.name = data.name;
-        else if (!circuit.name && !data.name) circuit.name = scircuit.name = `circuit${data.id}`;
-        if (typeof data.type !== 'undefined' || typeof circuit.type === 'undefined') {
-          circuit.type = scircuit.type = parseInt(data.type, 10) || 0;
-        }
-        if (id === 6) circuit.type = sys.board.valueMaps.circuitFunctions.getValue('pool');
-        if (id === 1 && sys.equipment.shared) circuit.type = sys.board.valueMaps.circuitFunctions.getValue('spa');
-        if (typeof data.freeze !== 'undefined' || typeof circuit.freeze === 'undefined') circuit.freeze = utils.makeBool(data.freeze) || false;
-        if (typeof data.showInFeatures !== 'undefined' || typeof data.showInFeatures === 'undefined') circuit.showInFeatures = scircuit.showInFeatures = utils.makeBool(data.showInFeatures) || true;
-        if (typeof data.dontStop !== 'undefined' && utils.makeBool(data.dontStop) === true) data.eggTimer = 1440;
-        if (typeof data.eggTimer !== 'undefined' || typeof circuit.eggTimer === 'undefined') circuit.eggTimer = parseInt(data.eggTimer, 10) || 0;
-        if (typeof data.connectionId !== 'undefined') circuit.connectionId = data.connectionId;
-        if (typeof data.deviceBinding !== 'undefined') circuit.deviceBinding = data.deviceBinding;
-        if (typeof data.showInFeatures !== 'undefined') scircuit.showInFeatures = circuit.showInFeatures = utils.makeBool(data.showInFeatures);
-        circuit.dontStop = circuit.eggTimer === 1440;
+    let cf = sys.board.valueMaps.circuitFunctions.toArray();
+    if (!sys.equipment.shared) cf = cf.filter(x => { return x.name !== 'spillway' && x.name !== 'spadrain' });
+    return cf;
+  }
+  public getCircuitNames() { return [...sys.board.valueMaps.circuitNames.toArray(), ...sys.board.valueMaps.customNames.toArray()]; }
+    public async setCircuitAsync(data: any, send: boolean = true): Promise<ICircuit> {
+        try {
+            let id = parseInt(data.id, 10);
+            if (id <= 0 || typeof data.id === 'undefined') {
+                // We are adding a new circuit.  If we are operating as a nixie controller then we need to start this
+                // circuit outside the range of circuits that can be defined on the panel.  For any of the non-OCP controllers
+                // these are added within the range of the circuits starting with 1.  For all others these are added with an id > 255.
+                switch (state.equipment.controllerType) {
+                    case 'intellicenter':
+                    case 'intellitouch':
+                    case 'easytouch':
+                    case 'suntouch':
+                        id = sys.circuits.getNextEquipmentId(new EquipmentIdRange(255, 300));
+                        break;
+                    default:
+                        id = sys.circuits.getNextEquipmentId(sys.board.equipmentIds.circuits, [1, 6]);
+                        break;
+                }
+            }
+            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(`Circuit id is out of range: ${id}`, data.id, 'Circuit'));;
+            if (typeof data.id !== 'undefined') {
+                let circuit = sys.circuits.getItemById(id, true);
+                let scircuit = state.circuits.getItemById(id, true);
+                scircuit.isActive = circuit.isActive = true;
+                circuit.master = 1;
+                scircuit.isOn = false;
+                if (data.name) circuit.name = scircuit.name = data.name;
+                else if (!circuit.name && !data.name) circuit.name = scircuit.name = `circuit${data.id}`;
+                if (typeof data.type !== 'undefined' || typeof circuit.type === 'undefined') {
+                    circuit.type = scircuit.type = parseInt(data.type, 10) || 0;
+                }
+                if (id === 6) circuit.type = sys.board.valueMaps.circuitFunctions.getValue('pool');
+                if (id === 1 && sys.equipment.shared) circuit.type = sys.board.valueMaps.circuitFunctions.getValue('spa');
+                if (typeof data.freeze !== 'undefined' || typeof circuit.freeze === 'undefined') circuit.freeze = utils.makeBool(data.freeze) || false;
+                if (typeof data.showInFeatures !== 'undefined' || typeof data.showInFeatures === 'undefined') circuit.showInFeatures = scircuit.showInFeatures = utils.makeBool(data.showInFeatures);
+                if (typeof data.dontStop !== 'undefined' && utils.makeBool(data.dontStop) === true) data.eggTimer = 1440;
+                if (typeof data.eggTimer !== 'undefined' || typeof circuit.eggTimer === 'undefined') circuit.eggTimer = parseInt(data.eggTimer, 10) || 0;
+                if (typeof data.connectionId !== 'undefined') circuit.connectionId = data.connectionId;
+                if (typeof data.deviceBinding !== 'undefined') circuit.deviceBinding = data.deviceBinding;
+                if (typeof data.showInFeatures !== 'undefined') scircuit.showInFeatures = circuit.showInFeatures = utils.makeBool(data.showInFeatures);
+                circuit.dontStop = circuit.eggTimer === 1440;
 
-        sys.emitEquipmentChange();
-        state.emitEquipmentChanges();
-        if (circuit.master === 1) await ncp.circuits.setCircuitAsync(circuit, data);
-        return Promise.resolve(circuit);
-      }
-      else
-        return Promise.reject(new Error('Circuit id has not been defined'));
+                sys.emitEquipmentChange();
+                state.emitEquipmentChanges();
+                if (circuit.master === 1) await ncp.circuits.setCircuitAsync(circuit, data);
+                return Promise.resolve(circuit);
+            }
+            else
+                return Promise.reject(new Error('Circuit id has not been defined'));
+        }
+        catch (err) { logger.error(`setCircuitAsync error with ${data}. ${err}`); return Promise.reject(err); }
     }
-    catch (err) { logger.error(`setCircuitAsync error with ${data}. ${err}`); return Promise.reject(err); }
-  }
   public async setCircuitGroupAsync(obj: any): Promise<CircuitGroup> {
     let group: CircuitGroup = null;
     let sgroup: CircuitGroupState = null;
@@ -2714,7 +2813,7 @@ export class CircuitCommands extends BoardCommands {
     });
 
   }
-  public async setLightGroupAsync(obj: any): Promise<LightGroup> {
+  public async setLightGroupAsync(obj: any, send: boolean = true): Promise<LightGroup> {
     let group: LightGroup = null;
     let id = typeof obj.id !== 'undefined' ? parseInt(obj.id, 10) : -1;
     if (id <= 0) {
@@ -2885,7 +2984,7 @@ export class CircuitCommands extends BoardCommands {
       if (nop > 0) {
         sgroup.action = nop;
         sgroup.emitEquipmentChange();
-        await utils.sleep(10000);
+        await setTimeout(10000);
         sgroup.action = 0;
         state.emitAllEquipmentChanges();
       }
@@ -3112,32 +3211,33 @@ export class FeatureCommands extends BoardCommands {
     } catch (err) { logger.error(`Error validating features for restore: ${err.message}`); }
   }
 
-  public async setFeatureAsync(obj: any): Promise<Feature> {
-    let id = parseInt(obj.id, 10);
-    if (id <= 0 || isNaN(id)) {
-      id = sys.features.getNextEquipmentId(sys.board.equipmentIds.features);
-    }
-    if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid feature id: ${obj.id}`, obj.id, 'Feature'));
-    if (!sys.board.equipmentIds.features.isInRange(id)) return Promise.reject(new InvalidEquipmentIdError(`Feature id out of range: ${id}: ${sys.board.equipmentIds.features.start} to ${sys.board.equipmentIds.features.end}`, obj.id, 'Feature'));
-    let feature = sys.features.getItemById(id, true);
-    let sfeature = state.features.getItemById(id, true);
-    feature.isActive = true;
-    sfeature.isOn = false;
-    if (obj.nameId) {
-      feature.nameId = sfeature.nameId = obj.nameId;
-      feature.name = sfeature.name = sys.board.valueMaps.circuitNames.get(obj.nameId);
+    public async setFeatureAsync(obj: any): Promise<Feature> {
+        let id = parseInt(obj.id, 10);
+        if (id <= 0 || isNaN(id)) {
+            id = sys.features.getNextEquipmentId(sys.board.equipmentIds.features);
+        }
+        if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid feature id: ${obj.id}`, obj.id, 'Feature'));
+        if (!sys.board.equipmentIds.features.isInRange(id)) return Promise.reject(new InvalidEquipmentIdError(`Feature id out of range: ${id}: ${sys.board.equipmentIds.features.start} to ${sys.board.equipmentIds.features.end}`, obj.id, 'Feature'));
+        let feature = sys.features.getItemById(id, true);
+        let sfeature = state.features.getItemById(id, true);
+        feature.isActive = true;
+        sfeature.isOn = false;
+        if (obj.nameId) {
+            feature.nameId = sfeature.nameId = obj.nameId;
+            feature.name = sfeature.name = sys.board.valueMaps.circuitNames.get(obj.nameId);
+        }
+        else if (obj.name) feature.name = sfeature.name = obj.name;
+        else if (!feature.name && !obj.name) feature.name = sfeature.name = `feature${obj.id}`;
+        if (typeof obj.type !== 'undefined') feature.type = sfeature.type = parseInt(obj.type, 10);
+        else if (!feature.type && typeof obj.type !== 'undefined') feature.type = sfeature.type = 0;
+        if (typeof obj.freeze !== 'undefined') feature.freeze = utils.makeBool(obj.freeze);
+        if (typeof obj.showInFeatures !== 'undefined') feature.showInFeatures = sfeature.showInFeatures = utils.makeBool(obj.showInFeatures);
+        sfeature.showInFeatures = feature.showInFeatures;
+        if (typeof obj.dontStop !== 'undefined' && utils.makeBool(obj.dontStop) === true) obj.eggTimer = 1440;
+        if (typeof obj.eggTimer !== 'undefined') feature.eggTimer = parseInt(obj.eggTimer, 10);
+        feature.dontStop = feature.eggTimer === 1440;
+        return new Promise<Feature>((resolve, reject) => { resolve(feature); });
     }
-    else if (obj.name) feature.name = sfeature.name = obj.name;
-    else if (!feature.name && !obj.name) feature.name = sfeature.name = `feature${obj.id}`;
-    if (typeof obj.type !== 'undefined') feature.type = sfeature.type = parseInt(obj.type, 10);
-    else if (!feature.type && typeof obj.type !== 'undefined') feature.type = sfeature.type = 0;
-    if (typeof obj.freeze !== 'undefined') feature.freeze = utils.makeBool(obj.freeze);
-    if (typeof obj.showInFeatures !== 'undefined') feature.showInFeatures = sfeature.showInFeatures = utils.makeBool(obj.showInFeatures);
-    if (typeof obj.dontStop !== 'undefined' && utils.makeBool(obj.dontStop) === true) obj.eggTimer = 1440;
-    if (typeof obj.eggTimer !== 'undefined') feature.eggTimer = parseInt(obj.eggTimer, 10);
-    feature.dontStop = feature.eggTimer === 1440;
-    return new Promise<Feature>((resolve, reject) => { resolve(feature); });
-  }
   public async deleteFeatureAsync(obj: any): Promise<Feature> {
     let id = parseInt(obj.id, 10);
     if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid feature id: ${obj.id}`, obj.id, 'Feature'));
@@ -3278,7 +3378,7 @@ export class ChlorinatorCommands extends BoardCommands {
     } catch (err) { logger.error(`Error validating chlorinators for restore: ${err.message}`); }
   }
 
-  public async setChlorAsync(obj: any): Promise<ChlorinatorState> {
+  public async setChlorAsync(obj: any, send: boolean = true): Promise<ChlorinatorState> {
     try {
       let id = parseInt(obj.id, 10);
       let chlor: Chlorinator;
@@ -3338,6 +3438,7 @@ export class ChlorinatorCommands extends BoardCommands {
         schlor.model = chlor.model = typeof obj.model !== 'undefined' ? sys.board.valueMaps.chlorinatorModel.encode(obj.model) : chlor.model;
         chlor.type = schlor.type = typeof obj.type !== 'undefined' ? sys.board.valueMaps.chlorinatorType.encode(obj.type) : chlor.type || 0;
         chlor.body = schlor.body = body.val;
+        chlor.address = typeof obj.address !== 'undefined' ? parseInt(obj.address,10) : 80;
         schlor.poolSetpoint = chlor.poolSetpoint = poolSetpoint;
         schlor.spaSetpoint = chlor.spaSetpoint = spaSetpoint;
         chlor.ignoreSaltReading = typeof obj.ignoreSaltReading !== 'undefined' ? utils.makeBool(obj.ignoreSaltReading) : utils.makeBool(chlor.ignoreSaltReading);
@@ -3506,16 +3607,16 @@ export class ScheduleCommands extends BoardCommands {
         // if scheduleDays includes today
         if (days.includes(state.time.toDate().getDay())) {
           if (sched.changeHeatSetpoint && (sched.heatSource as any).val !== sys.board.valueMaps.heatSources.getValue('off') && sched.heatSetpoint > 0 && sched.heatSetpoint !== tbody.setPoint) {
-            setTimeout(() => sys.board.bodies.setHeatSetpointAsync(cbody, sched.heatSetpoint), 100);
+            setTimeoutSync(() => sys.board.bodies.setHeatSetpointAsync(cbody, sched.heatSetpoint), 100);
           }
           if ((sched.heatSource as any).val !== sys.board.valueMaps.heatSources.getValue('nochange') && sched.heatSource !== tbody.heatMode) {
-            setTimeout(() => sys.board.bodies.setHeatModeAsync(cbody, sys.board.valueMaps.heatModes.getValue((sched.heatSource as any).name)), 100);
+            setTimeoutSync(() => sys.board.bodies.setHeatModeAsync(cbody, sys.board.valueMaps.heatModes.getValue((sched.heatSource as any).name)), 100);
           }
         }
       }
     };
   }
-  public async setScheduleAsync(data: any): Promise<Schedule> {
+  public async setScheduleAsync(data: any, send: boolean = true): Promise<Schedule> {
     let id = typeof data.id === 'undefined' ? -1 : parseInt(data.id, 10);
     if (id <= 0) id = sys.schedules.getNextEquipmentId(new EquipmentIdRange(1, sys.equipment.maxSchedules));
     if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid schedule id: ${data.id}`, data.id, 'Schedule'));
@@ -3626,7 +3727,7 @@ export class ScheduleCommands extends BoardCommands {
       }
     } catch (err) { logger.error(`Error synchronizing schedule states`); }
   }
-  public async setEggTimerAsync(data?: any): Promise<EggTimer> { return Promise.resolve(sys.eggTimers.getItemByIndex(1)); }
+  public async setEggTimerAsync(data?: any, send: boolean = true): Promise<EggTimer> { return Promise.resolve(sys.eggTimers.getItemByIndex(1)); }
   public async deleteEggTimerAsync(data?: any): Promise<EggTimer> { return Promise.resolve(sys.eggTimers.getItemByIndex(1)); }
   public includesCircuit(sched: Schedule, circuit: number) {
     let bIncludes = false;
@@ -3682,7 +3783,7 @@ export class ScheduleCommands extends BoardCommands {
     if (state.circuitGroups.getInterfaceById(circuit).manualPriorityActive) return true;
     if (grp && grp.isActive) cgc = grp.circuits.toArray();
     for (let i = 0; i < cgc.length; i++) {
-      let c = state.circuits.getInterfaceById(cgc[i].id);
+      let c = state.circuits.getInterfaceById(cgc[i].circuit);
       if (c.manualPriorityActive) return true;
     }
     return false;
@@ -3702,7 +3803,7 @@ export class ScheduleCommands extends BoardCommands {
 
     if (schedule.isActive === false) return false;
     if (schedule.disabled) return false;
-    if (!sys.general.options.manualPriority) return false;
+    //if (!sys.general.options.manualPriority) return false; //if we override a circuit to be mOP, this will not be true
 
     let currGrp: ICircuitGroup;
     let currSchedGrpCircs = [];
@@ -3743,7 +3844,7 @@ export class ScheduleCommands extends BoardCommands {
               let cgc = grp.circuits.getItemByIndex(j);
               let scgc = state.circuits.getInterfaceById(cgc.circuit);
               // if the circuit id's match and mOP is active, we delay
-              if (scgc.id === schedule.circuit && scgc.manualPriorityActive) return true;
+              if (scgc.id === schedule.circuit && manualPriorityByProxy) return true;
               // check all the other cgc against this cgc
               // note: circuit/light groups cannot be part of a group themselves
               for (let k = 0; k < currSchedGrpCircs.length; k++) {
@@ -3788,569 +3889,607 @@ export class ScheduleCommands extends BoardCommands {
     // if we make it this far, nothing is impacting us
     return false;
   }
+  public async updateSunriseSunsetAsync():Promise<boolean> {return Promise.resolve(false);};
 }
 export class HeaterCommands extends BoardCommands {
-  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
-    try {
-      // First delete the heaters that should be removed.
-      for (let i = 0; i < ctx.heaters.remove.length; i++) {
-        let h = ctx.heaters.remove[i];
-        try {
-          await sys.board.heaters.deleteHeaterAsync(h);
-          res.addModuleSuccess('heater', `Remove: ${h.id}-${h.name}`);
-        } catch (err) { res.addModuleError('heater', `Remove: ${h.id}-${h.name}: ${err.message}`); }
-      }
-      for (let i = 0; i < ctx.heaters.update.length; i++) {
-        let h = ctx.heaters.update[i];
-        try {
-          await sys.board.heaters.setHeaterAsync(h);
-          res.addModuleSuccess('heater', `Update: ${h.id}-${h.name}`);
-        } catch (err) { res.addModuleError('heater', `Update: ${h.id}-${h.name}: ${err.message}`); }
-      }
-      for (let i = 0; i < ctx.heaters.add.length; i++) {
-        let h = ctx.heaters.add[i];
+    public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
         try {
-          // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
-          // it won't error out.
-          sys.heaters.getItemById(h.id, true);
-          await sys.board.heaters.setHeaterAsync(h);
-          res.addModuleSuccess('heater', `Add: ${h.id}-${h.name}`);
-        } catch (err) { res.addModuleError('heater', `Add: ${h.id}-${h.name}: ${err.message}`); }
-      }
-      return true;
-    } catch (err) { logger.error(`Error restoring heaters: ${err.message}`); res.addModuleError('system', `Error restoring heaters: ${err.message}`); return false; }
-  }
-  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
-    try {
-      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
-      // Look at heaters.
-      let cfg = rest.poolConfig;
-      for (let i = 0; i < cfg.heaters.length; i++) {
-        let r = cfg.heaters[i];
-        let c = sys.heaters.find(elem => r.id === elem.id);
-        if (typeof c === 'undefined') ctx.add.push(r);
-        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
-      }
-      for (let i = 0; i < sys.heaters.length; i++) {
-        let c = sys.heaters.getItemByIndex(i);
-        let r = cfg.heaters.find(elem => elem.id == c.id);
-        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
-      }
-      return ctx;
-    } catch (err) { logger.error(`Error validating heaters for restore: ${err.message}`); }
-  }
-  public getHeatersByCircuitId(circuitId: number): Heater[] {
-    let heaters: Heater[] = [];
-    let bodyId = circuitId === 6 ? 1 : circuitId === 1 ? 2 : 0;
-    if (bodyId > 0) {
-      for (let i = 0; i < sys.heaters.length; i++) {
-        let heater = sys.heaters.getItemByIndex(i);
-        if (!heater.isActive) continue;
-        if (bodyId === heater.body || sys.equipment.shared && heater.body === 32) heaters.push(heater);
-      }
+            // First delete the heaters that should be removed.
+            for (let i = 0; i < ctx.heaters.remove.length; i++) {
+                let h = ctx.heaters.remove[i];
+                try {
+                    await sys.board.heaters.deleteHeaterAsync(h);
+                    res.addModuleSuccess('heater', `Remove: ${h.id}-${h.name}`);
+                } catch (err) { res.addModuleError('heater', `Remove: ${h.id}-${h.name}: ${err.message}`); }
+            }
+            for (let i = 0; i < ctx.heaters.update.length; i++) {
+                let h = ctx.heaters.update[i];
+                try {
+                    await sys.board.heaters.setHeaterAsync(h);
+                    res.addModuleSuccess('heater', `Update: ${h.id}-${h.name}`);
+                } catch (err) { res.addModuleError('heater', `Update: ${h.id}-${h.name}: ${err.message}`); }
+            }
+            for (let i = 0; i < ctx.heaters.add.length; i++) {
+                let h = ctx.heaters.add[i];
+                try {
+                    // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+                    // it won't error out.
+                    sys.heaters.getItemById(h.id, true);
+                    await sys.board.heaters.setHeaterAsync(h);
+                    res.addModuleSuccess('heater', `Add: ${h.id}-${h.name}`);
+                } catch (err) { res.addModuleError('heater', `Add: ${h.id}-${h.name}: ${err.message}`); }
+            }
+            return true;
+        } catch (err) { logger.error(`Error restoring heaters: ${err.message}`); res.addModuleError('system', `Error restoring heaters: ${err.message}`); return false; }
     }
-    return heaters;
-  }
-  public getInstalledHeaterTypes(body?: number): any {
-    let heaters = sys.heaters.get();
-    let types = sys.board.valueMaps.heaterTypes.toArray();
-    let inst = { total: 0 };
-    for (let i = 0; i < types.length; i++) if (types[i].name !== 'none') inst[types[i].name] = 0;
-    for (let i = 0; i < heaters.length; i++) {
-      let heater = heaters[i];
-      if (typeof body !== 'undefined' && heater.body !== 'undefined') {
-        if ((heater.body !== 32 && body !== heater.body + 1) || (heater.body === 32 && body > 2)) continue;
-      }
-      let type = types.find(elem => elem.val === heater.type);
-      if (typeof type !== 'undefined') {
-        if (inst[type.name] === 'undefined') inst[type.name] = 0;
-        inst[type.name] = inst[type.name] + 1;
-        if (heater.coolingEnabled === true && type.hasCoolSetpoint === true) inst['hasCoolSetpoint'] = true;
-        inst.total++;
-      }
+    public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
+        try {
+            let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+            // Look at heaters.
+            let cfg = rest.poolConfig;
+            for (let i = 0; i < cfg.heaters.length; i++) {
+                let r = cfg.heaters[i];
+                let c = sys.heaters.find(elem => r.id === elem.id);
+                if (typeof c === 'undefined') ctx.add.push(r);
+                else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+            }
+            for (let i = 0; i < sys.heaters.length; i++) {
+                let c = sys.heaters.getItemByIndex(i);
+                let r = cfg.heaters.find(elem => elem.id == c.id);
+                if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+            }
+            return ctx;
+        } catch (err) { logger.error(`Error validating heaters for restore: ${err.message}`); }
     }
-    return inst;
-  }
-  public isSolarInstalled(body?: number): boolean {
-    let heaters = sys.heaters.get();
-    let types = sys.board.valueMaps.heaterTypes.toArray();
-    for (let i = 0; i < heaters.length; i++) {
-      let heater = heaters[i];
-      if (typeof body !== 'undefined' && body !== heater.body) continue;
-      let type = types.find(elem => elem.val === heater.type);
-      if (typeof type !== 'undefined') {
-        switch (type.name) {
-          case 'solar':
-            return true;
+    public getHeatersByCircuitId(circuitId: number): Heater[] {
+        let heaters: Heater[] = [];
+        let bodyId = circuitId === 6 ? 1 : circuitId === 1 ? 2 : 0;
+        if (bodyId > 0) {
+            for (let i = 0; i < sys.heaters.length; i++) {
+                let heater = sys.heaters.getItemByIndex(i);
+                if (!heater.isActive) continue;
+                if (bodyId === heater.body || sys.equipment.shared && heater.body === 32) heaters.push(heater);
+            }
         }
-      }
+        return heaters;
     }
-  }
-  public isHeatPumpInstalled(body?: number): boolean {
-    let heaters = sys.heaters.get();
-    let types = sys.board.valueMaps.heaterTypes.toArray();
-    for (let i = 0; i < heaters.length; i++) {
-      let heater = heaters[i];
-      if (typeof body !== 'undefined' && body !== heater.body) continue;
-      let type = types.find(elem => elem.val === heater.type);
-      if (typeof type !== 'undefined') {
-        switch (type.name) {
-          case 'heatpump':
-            return true;
+    public getInstalledHeaterTypes(body?: number): any {
+        let heaters = sys.heaters.get();
+        let types = sys.board.valueMaps.heaterTypes.toArray();
+        let inst = { total: 0 };
+        for (let i = 0; i < types.length; i++) if (types[i].name !== 'none') inst[types[i].name] = 0;
+        for (let i = 0; i < heaters.length; i++) {
+            let heater = heaters[i];
+            if (typeof body !== 'undefined' && heater.body !== 'undefined') {
+                if ((heater.body !== 32 && body !== heater.body + 1) || (heater.body === 32 && body > 2)) continue;
+            }
+            let type = types.find(elem => elem.val === heater.type);
+            if (typeof type !== 'undefined') {
+                if (inst[type.name] === 'undefined') inst[type.name] = 0;
+                inst[type.name] = inst[type.name] + 1;
+                if (heater.coolingEnabled === true && type.hasCoolSetpoint === true) inst['hasCoolSetpoint'] = true;
+                inst.total++;
+            }
         }
-      }
-    }
-  }
-  public setHeater(heater: Heater, obj?: any) {
-    if (typeof obj !== undefined) {
-      for (var s in obj)
-        heater[s] = obj[s];
+        return inst;
     }
-  }
-  public async setHeaterAsync(obj: any): Promise<Heater> {
-    try {
-      let id = typeof obj.id === 'undefined' ? -1 : parseInt(obj.id, 10);
-      if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError('Heater Id is not valid.', obj.id, 'Heater'));
-      else if (id < 256 && id > 0) return Promise.reject(new InvalidEquipmentIdError('Virtual Heaters controlled by njspc must have an Id > 256.', obj.id, 'Heater'));
-      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.master === 1);
-        id = vheaters.length + 256;
-      }
-      heater = sys.heaters.getItemById(id, true);
-      if (typeof obj !== undefined) {
-        for (var s in obj) {
-          if (s === 'id') continue;
-          heater[s] = obj[s];
+    public isSolarInstalled(body?: number): boolean {
+        let heaters = sys.heaters.get();
+        let types = sys.board.valueMaps.heaterTypes.toArray();
+        for (let i = 0; i < heaters.length; i++) {
+            let heater = heaters[i];
+            if (typeof body !== 'undefined' && body !== heater.body) continue;
+            let type = types.find(elem => elem.val === heater.type);
+            if (typeof type !== 'undefined') {
+                switch (type.name) {
+                    case 'solar':
+                        return true;
+                }
+            }
         }
-      }
-      let hstate = state.heaters.getItemById(id, true);
-      //hstate.isVirtual = heater.isVirtual = true;
-      hstate.name = heater.name;
-      hstate.type = heater.type;
-      heater.master = 1;
-      if (heater.master === 1) await ncp.heaters.setHeaterAsync(heater, obj);
-      await sys.board.heaters.updateHeaterServices();
-      await sys.board.heaters.syncHeaterStates();
-      return heater;
-    } catch (err) { return Promise.reject(new Error(`Error setting heater configuration: ${err}`)); }
-  }
-  public async deleteHeaterAsync(obj: any): Promise<Heater> {
-    try {
-      let id = parseInt(obj.id, 10);
-      if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError('Cannot delete.  Heater Id is not valid.', obj.id, 'Heater'));
-      let heater = sys.heaters.getItemById(id);
-      heater.isActive = false;
-      if (heater.master === 1) await ncp.heaters.deleteHeaterAsync(heater.id);
-      sys.heaters.removeItemById(id);
-      state.heaters.removeItemById(id);
-      sys.board.heaters.updateHeaterServices();
-      sys.board.heaters.syncHeaterStates();
-      return heater;
-    } catch (err) { return Promise.reject(`Error deleting heater: ${err.message}`) }
-  }
-  public updateHeaterServices() {
-    let htypes = sys.board.heaters.getInstalledHeaterTypes();
-    let solarInstalled = htypes.solar > 0;
-    let heatPumpInstalled = htypes.heatpump > 0;
-    let gasHeaterInstalled = htypes.gas > 0;
-
-    if (sys.heaters.length > 0) sys.board.valueMaps.heatSources = new byteValueMap([[0, { name: 'off', desc: 'Off' }]]);
-    if (gasHeaterInstalled) sys.board.valueMaps.heatSources.set(3, { name: 'heater', desc: 'Heater' });
-    if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatSources.merge([[5, { name: 'solar', desc: 'Solar Only' }], [21, { name: 'solarpref', desc: 'Solar Preferred' }]]);
-    else if (solarInstalled) sys.board.valueMaps.heatSources.set(5, { name: 'solar', desc: 'Solar' });
-    if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatSources.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Preferred' }]]);
-    else if (heatPumpInstalled) sys.board.valueMaps.heatSources.set(9, { name: 'heatpump', desc: 'Heat Pump' });
-    sys.board.valueMaps.heatSources.set(32, { name: 'nochange', desc: 'No Change' });
-
-    sys.board.valueMaps.heatModes = new byteValueMap([[0, { name: 'off', desc: 'Off' }]]);
-    if (gasHeaterInstalled) sys.board.valueMaps.heatModes.set(3, { name: 'heater', desc: 'Heater' });
-    if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatModes.merge([[5, { name: 'solar', desc: 'Solar Only' }], [21, { name: 'solarpref', desc: 'Solar Preferred' }]]);
-    else if (solarInstalled) sys.board.valueMaps.heatModes.set(5, { name: 'solar', desc: 'Solar' });
-    if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatModes.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Preferred' }]]);
-    else if (heatPumpInstalled) sys.board.valueMaps.heatModes.set(9, { name: 'heatpump', desc: 'Heat Pump' });
-    // Now set the body data.
-    for (let i = 0; i < sys.bodies.length; i++) {
-      let body = sys.bodies.getItemByIndex(i);
-      let btemp = state.temps.bodies.getItemById(body.id, body.isActive !== false);
-      let opts = sys.board.heaters.getInstalledHeaterTypes(body.id);
-      btemp.heaterOptions = opts;
-    }
-    this.setActiveTempSensors();
-  }
-  public initTempSensors() {
-    // Add in the potential sensors and delete the ones that shouldn't exist.
-    let maxPairs = sys.equipment.maxBodies + (sys.equipment.shared ? -1 : 0);
-    sys.equipment.tempSensors.getItemById('air', true, { id: 'air', isActive: true, calibration: 0 }).name = 'Air';
-    sys.equipment.tempSensors.getItemById('water1', true, { id: 'water1', isActive: true, calibration: 0 }).name = maxPairs == 1 ? 'Water' : 'Body 1';
-    sys.equipment.tempSensors.getItemById('solar1', true, { id: 'solar1', isActive: false, calibration: 0 }).name = maxPairs == 1 ? 'Solar' : 'Solar 1';
-    if (maxPairs > 1) {
-      sys.equipment.tempSensors.getItemById('water2', true, { id: 'water2', isActive: false, calibration: 0 }).name = 'Body 2';
-      sys.equipment.tempSensors.getItemById('solar2', true, { id: 'solar2', isActive: false, calibration: 0 }).name = 'Solar 2';
     }
-    else {
-      sys.equipment.tempSensors.removeItemById('water2');
-      sys.equipment.tempSensors.removeItemById('solar2');
-    }
-    if (maxPairs > 2) {
-      sys.equipment.tempSensors.getItemById('water3', true, { id: 'water3', isActive: false, calibration: 0 }).name = 'Body 3';
-      sys.equipment.tempSensors.getItemById('solar3', true, { id: 'solar3', isActive: false, calibration: 0 }).name = 'Solar 3';
+    public isHeatPumpInstalled(body?: number): boolean {
+        let heaters = sys.heaters.get();
+        let types = sys.board.valueMaps.heaterTypes.toArray();
+        for (let i = 0; i < heaters.length; i++) {
+            let heater = heaters[i];
+            if (typeof body !== 'undefined' && body !== heater.body) continue;
+            let type = types.find(elem => elem.val === heater.type);
+            if (typeof type !== 'undefined') {
+                switch (type.name) {
+                    case 'heatpump':
+                        return true;
+                }
+            }
+        }
     }
-    else {
-      sys.equipment.tempSensors.removeItemById('water3');
-      sys.equipment.tempSensors.removeItemById('solar3');
+    public setHeater(heater: Heater, obj?: any) {
+        if (typeof obj !== undefined) {
+            for (var s in obj)
+                heater[s] = obj[s];
+        }
     }
-    if (maxPairs > 3) {
-      sys.equipment.tempSensors.getItemById('water4', true, { id: 'water4', isActive: false, calibration: 0 }).name = 'Body 4';
-      sys.equipment.tempSensors.getItemById('solar4', true, { id: 'solar4', isActive: false, calibration: 0 }).name = 'Solar 4';
+    public async setHeaterAsync(obj: any, send: boolean = true): Promise<Heater> {
+        try {
+            let id = typeof obj.id === 'undefined' ? -1 : parseInt(obj.id, 10);
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError('Heater Id is not valid.', obj.id, 'Heater'));
+            else if (id < 256 && id > 0) return Promise.reject(new InvalidEquipmentIdError('Virtual Heaters controlled by njspc must have an Id > 256.', obj.id, 'Heater'));
+            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.master === 1);
+                id = vheaters.length + 256;
+            }
+            heater = sys.heaters.getItemById(id, true);
+            if (typeof obj !== undefined) {
+                for (var s in obj) {
+                    if (s === 'id') continue;
+                    heater[s] = obj[s];
+                }
+            }
+            let hstate = state.heaters.getItemById(id, true);
+            //hstate.isVirtual = heater.isVirtual = true;
+            hstate.name = heater.name;
+            hstate.type = heater.type;
+            heater.master = 1;
+            if (heater.master === 1) await ncp.heaters.setHeaterAsync(heater, obj);
+            await sys.board.heaters.updateHeaterServices();
+            await sys.board.heaters.syncHeaterStates();
+            return heater;
+        } catch (err) { return Promise.reject(new Error(`Error setting heater configuration: ${err}`)); }
     }
-    else {
-      sys.equipment.tempSensors.removeItemById('water4');
-      sys.equipment.tempSensors.removeItemById('solar4');
+    public async deleteHeaterAsync(obj: any): Promise<Heater> {
+        try {
+            let id = parseInt(obj.id, 10);
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError('Cannot delete.  Heater Id is not valid.', obj.id, 'Heater'));
+            let heater = sys.heaters.getItemById(id);
+            heater.isActive = false;
+            if (heater.master === 1) await ncp.heaters.deleteHeaterAsync(heater.id);
+            sys.heaters.removeItemById(id);
+            state.heaters.removeItemById(id);
+            sys.board.heaters.updateHeaterServices();
+            sys.board.heaters.syncHeaterStates();
+            return heater;
+        } catch (err) { return Promise.reject(`Error deleting heater: ${err.message}`) }
     }
+    public updateHeaterServices() {
+        let htypes = sys.board.heaters.getInstalledHeaterTypes();
+        let solarInstalled = htypes.solar > 0;
+        let heatPumpInstalled = htypes.heatpump > 0;
+        let gasHeaterInstalled = htypes.gas > 0;
 
-  }
-  // Sets the active temp sensors based upon the installed equipment.  At this point all
-  // detectable temp sensors should exist.
-  public setActiveTempSensors() {
-    let htypes;
-    // We are iterating backwards through the sensors array on purpose.  We do this just in case we need
-    // to remove a sensor during the iteration.  This way the index values will not be impacted and we can
-    // safely remove from the array we are iterating.
-    for (let i = sys.equipment.tempSensors.length - 1; i >= 0; i--) {
-      let sensor = sys.equipment.tempSensors.getItemByIndex(i);
-      // The names are normalized in this array.
-      switch (sensor.id) {
-        case 'air':
-          sensor.isActive = true;
-          break;
-        case 'water1':
-          sensor.isActive = sys.equipment.maxBodies > 0;
-          break;
-        case 'water2':
-          sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 2 : sys.equipment.maxBodies > 1;
-          break;
-        case 'water3':
-          sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 3 : sys.equipment.maxBodies > 2;
-          break;
-        case 'water4':
-          // It's a little weird but technically you should be able to install 3 expansions and a i10D personality
-          // board.  If this situation ever comes up we will see if it works. Whether it reports is another story
-          // since the 2 message is short a byte for this.
-          sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 4 : sys.equipment.maxBodies > 3;
-          break;
-        // Solar sensors are funny ducks. This is because they are for both heatpumps and solar and the equipment
-        // can be installed on specific bodies.  This will be true for heaters installed in expansion panels for *Touch, dual body systems,
-        // and any IntelliCenter with more than one body.  At some point simply implementing the multi-body functions for touch will make
-        // this all work. This will only be with i10D or expansion panels.
-        case 'solar1':
-          // The first solar sensor is a funny duck in that it should be active for shared systems
-          // if either body has an active solar heater or heatpump.
-          htypes = sys.board.heaters.getInstalledHeaterTypes(1);
-          if ('solar' in htypes || 'heatpump' in htypes) sensor.isActive = true;
-          else if (sys.equipment.shared) {
-            htypes = sys.board.heaters.getInstalledHeaterTypes(2);
-            sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
-          }
-          else sensor.isActive = false;
-          break;
-        case 'solar2':
-          if (sys.equipment.maxBodies > 1 + (sys.equipment.shared ? 1 : 0)) {
-            htypes = sys.board.heaters.getInstalledHeaterTypes(2 + (sys.equipment.shared ? 1 : 0));
-            sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
-          }
-          else sensor.isActive = false;
-          break;
-        case 'solar3':
-          if (sys.equipment.maxBodies > 2 + (sys.equipment.shared ? 1 : 0)) {
-            htypes = sys.board.heaters.getInstalledHeaterTypes(3 + (sys.equipment.shared ? 1 : 0));
-            sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
-          }
-          else sensor.isActive = false;
-          break;
-        case 'solar4':
-          if (sys.equipment.maxBodies > 3 + (sys.equipment.shared ? 1 : 0)) {
-            htypes = sys.board.heaters.getInstalledHeaterTypes(4 + (sys.equipment.shared ? 1 : 0));
-            sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
-          }
-          else sensor.isActive = false;
-          break;
-        default:
-          if (typeof sensor.id === 'undefined') sys.equipment.tempSensors.removeItemByIndex(i);
-          break;
-      }
+        if (sys.heaters.length > 0) sys.board.valueMaps.heatSources = new byteValueMap([[0, { name: 'off', desc: 'Off' }]]);
+        if (gasHeaterInstalled) sys.board.valueMaps.heatSources.set(3, { name: 'heater', desc: 'Heater' });
+        if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatSources.merge([[5, { name: 'solar', desc: 'Solar Only' }], [21, { name: 'solarpref', desc: 'Solar Preferred' }]]);
+        else if (solarInstalled) sys.board.valueMaps.heatSources.set(5, { name: 'solar', desc: 'Solar' });
+        if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatSources.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Preferred' }]]);
+        else if (heatPumpInstalled) sys.board.valueMaps.heatSources.set(9, { name: 'heatpump', desc: 'Heat Pump' });
+        sys.board.valueMaps.heatSources.set(32, { name: 'nochange', desc: 'No Change' });
+
+        sys.board.valueMaps.heatModes = new byteValueMap([[0, { name: 'off', desc: 'Off' }]]);
+        if (gasHeaterInstalled) sys.board.valueMaps.heatModes.set(3, { name: 'heater', desc: 'Heater' });
+        if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatModes.merge([[5, { name: 'solar', desc: 'Solar Only' }], [21, { name: 'solarpref', desc: 'Solar Preferred' }]]);
+        else if (solarInstalled) sys.board.valueMaps.heatModes.set(5, { name: 'solar', desc: 'Solar' });
+        if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatModes.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Preferred' }]]);
+        else if (heatPumpInstalled) sys.board.valueMaps.heatModes.set(9, { name: 'heatpump', desc: 'Heat Pump' });
+        // Now set the body data.
+        for (let i = 0; i < sys.bodies.length; i++) {
+            let body = sys.bodies.getItemByIndex(i);
+            let btemp = state.temps.bodies.getItemById(body.id, body.isActive !== false);
+            let opts = sys.board.heaters.getInstalledHeaterTypes(body.id);
+            btemp.heaterOptions = opts;
+        }
+        this.setActiveTempSensors();
     }
-  }
-  // This updates the heater states based upon the installed heaters.  This is true for heaters that are tied to the OCP
-  // and those that are not.
-  public syncHeaterStates() {
-    try {
-      // Go through the installed heaters and bodies to determine whether they should be on.  If there is a
-      // heater that is not controlled by the OCP then we need to determine whether it should be on.
-      let heaters = sys.heaters.toArray();
-      let bodies = state.temps.bodies.toArray();
-      let hon = [];
-      for (let i = 0; i < bodies.length; i++) {
-        let body: BodyTempState = bodies[i];
-        let cfgBody: Body = sys.bodies.getItemById(body.id);
-        let isHeating = false;
-        let isCooling = false;
-        let hstatus = sys.board.valueMaps.heatStatus.getName(body.heatStatus);
-        let mode = sys.board.valueMaps.heatModes.getName(body.heatMode);
-        if (body.isOn) {
-          if (typeof body.temp === 'undefined' && heaters.length > 0) logger.warn(`The body temperature for ${body.name} cannot be determined. Heater status for this body cannot be calculated.`);
-          // Now get all the heaters associated with the body in an array.
-          let bodyHeaters: Heater[] = [];
-          for (let j = 0; j < heaters.length; j++) {
-            let heater: Heater = heaters[j];
-            if (heater.isActive === false) continue;
-            if (heater.body === body.id) bodyHeaters.push(heater);
-            else {
-              let b = sys.board.valueMaps.bodies.transform(heater.body);
-              switch (b.name) {
-                case 'body1':
-                case 'pool':
-                  if (body.id === 1) bodyHeaters.push(heater);
-                  break;
-                case 'body2':
-                case 'spa':
-                  if (body.id === 2) bodyHeaters.push(heater);
-                  break;
-                case 'poolspa':
-                  if (body.id === 1 || body.id === 2) bodyHeaters.push(heater);
-                  break;
-                case 'body3':
-                  if (body.id === 3) bodyHeaters.push(heater);
-                  break;
-                case 'body4':
-                  if (body.id === 4) bodyHeaters.push(heater);
-                  break;
-              }
-            }
-          }
-          // Alright we have all the body heaters so sort them in a way that will make our heater preferences work.  Solar, heatpumps, and ultratemp should be in the list first
-          // so that if we have a heater preference set up then we do not have to evaluate the other heater.
-          let heaterTypes = sys.board.valueMaps.heaterTypes;
-          bodyHeaters.sort((a, b) => {
-            if (heaterTypes.transform(a.type).hasPreference) return -1;
-            else if (heaterTypes.transform(b.type).hasPreference) return 1;
-            return 0;
-          });
+    public initTempSensors() {
+        // Add in the potential sensors and delete the ones that shouldn't exist.
+        let maxPairs = sys.equipment.maxBodies + (sys.equipment.shared ? -1 : 0);
+        sys.equipment.tempSensors.getItemById('air', true, { id: 'air', isActive: true, calibration: 0 }).name = 'Air';
+        sys.equipment.tempSensors.getItemById('water1', true, { id: 'water1', isActive: true, calibration: 0 }).name = maxPairs == 1 ? 'Water' : 'Body 1';
+        sys.equipment.tempSensors.getItemById('solar1', true, { id: 'solar1', isActive: false, calibration: 0 }).name = maxPairs == 1 ? 'Solar' : 'Solar 1';
+        if (maxPairs > 1) {
+            sys.equipment.tempSensors.getItemById('water2', true, { id: 'water2', isActive: false, calibration: 0 }).name = 'Body 2';
+            sys.equipment.tempSensors.getItemById('solar2', true, { id: 'solar2', isActive: false, calibration: 0 }).name = 'Solar 2';
+        }
+        else {
+            sys.equipment.tempSensors.removeItemById('water2');
+            sys.equipment.tempSensors.removeItemById('solar2');
+        }
+        if (maxPairs > 2) {
+            sys.equipment.tempSensors.getItemById('water3', true, { id: 'water3', isActive: false, calibration: 0 }).name = 'Body 3';
+            sys.equipment.tempSensors.getItemById('solar3', true, { id: 'solar3', isActive: false, calibration: 0 }).name = 'Solar 3';
+        }
+        else {
+            sys.equipment.tempSensors.removeItemById('water3');
+            sys.equipment.tempSensors.removeItemById('solar3');
+        }
+        if (maxPairs > 3) {
+            sys.equipment.tempSensors.getItemById('water4', true, { id: 'water4', isActive: false, calibration: 0 }).name = 'Body 4';
+            sys.equipment.tempSensors.getItemById('solar4', true, { id: 'solar4', isActive: false, calibration: 0 }).name = 'Solar 4';
+        }
+        else {
+            sys.equipment.tempSensors.removeItemById('water4');
+            sys.equipment.tempSensors.removeItemById('solar4');
+        }
 
-          // Alright so now we should have a sorted array that has preference type heaters first.
-          for (let j = 0; j < bodyHeaters.length; j++) {
-            let heater: Heater = bodyHeaters[j];
-            let isOn = false;
-            let htype = sys.board.valueMaps.heaterTypes.transform(heater.type);
-            let hstate = state.heaters.getItemById(heater.id, true);
-            if (heater.master === 1) {
-              if (hstatus !== 'cooldown') {
-                // We need to do our own calculation as to whether it is on.  This is for Nixie heaters.
-                switch (htype.name) {
-                  case 'solar':
-                    if (mode === 'solar' || mode === 'solarpref') {
-                      // Measure up against start and stop temp deltas for effective solar heating.
-                      if (body.temp < cfgBody.heatSetpoint &&
-                        state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('solar');
-                        isHeating = true;
-                      }
-                      else if (heater.coolingEnabled && body.temp > cfgBody.coolSetpoint && state.heliotrope.isNight &&
-                        state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('cooling');
-                        isHeating = true;
-                        isCooling = true;
-                      }
+    }
+    // Sets the active temp sensors based upon the installed equipment.  At this point all
+    // detectable temp sensors should exist.
+    public setActiveTempSensors() {
+        let htypes;
+        // We are iterating backwards through the sensors array on purpose.  We do this just in case we need
+        // to remove a sensor during the iteration.  This way the index values will not be impacted and we can
+        // safely remove from the array we are iterating.
+        for (let i = sys.equipment.tempSensors.length - 1; i >= 0; i--) {
+            let sensor = sys.equipment.tempSensors.getItemByIndex(i);
+            // The names are normalized in this array.
+            switch (sensor.id) {
+                case 'air':
+                    sensor.isActive = true;
+                    break;
+                case 'water1':
+                    sensor.isActive = sys.equipment.maxBodies > 0;
+                    break;
+                case 'water2':
+                    sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 2 : sys.equipment.maxBodies > 1;
+                    break;
+                case 'water3':
+                    sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 3 : sys.equipment.maxBodies > 2;
+                    break;
+                case 'water4':
+                    // It's a little weird but technically you should be able to install 3 expansions and a i10D personality
+                    // board.  If this situation ever comes up we will see if it works. Whether it reports is another story
+                    // since the 2 message is short a byte for this.
+                    sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 4 : sys.equipment.maxBodies > 3;
+                    break;
+                // Solar sensors are funny ducks. This is because they are for both heatpumps and solar and the equipment
+                // can be installed on specific bodies.  This will be true for heaters installed in expansion panels for *Touch, dual body systems,
+                // and any IntelliCenter with more than one body.  At some point simply implementing the multi-body functions for touch will make
+                // this all work. This will only be with i10D or expansion panels.
+                case 'solar1':
+                    // The first solar sensor is a funny duck in that it should be active for shared systems
+                    // if either body has an active solar heater or heatpump.
+                    htypes = sys.board.heaters.getInstalledHeaterTypes(1);
+                    if ('solar' in htypes || 'heatpump' in htypes) sensor.isActive = true;
+                    else if (sys.equipment.shared) {
+                        htypes = sys.board.heaters.getInstalledHeaterTypes(2);
+                        sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
                     }
+                    else sensor.isActive = false;
                     break;
-                  case 'ultratemp':
-                    // There is a temperature differential setting on UltraTemp.  This is how
-                    // much the water temperature needs to drop below the set temperature, for the heater
-                    // to start up again.  For instance, if the set temperature and the water temperature is 82 and then the
-                    // heater will shut off and not turn on again until the water temperature = setpoint - differentialTemperature.
-                    // This is the default operation on IntelliCenter and it appears to simply not start on the setpoint.  We can do better
-                    // than this by heating 1 degree past the setpoint then applying this rule for 30 minutes.  This allows for a more
-                    // responsive heater.
-                    // 
-                    // For Ultratemp we need to determine whether the differential temp
-                    // is within range.  The other thing that needs to be calculated here is
-                    // whether Ultratemp can effeciently heat the pool.
-                    if (mode === 'ultratemp' || mode === 'ultratemppref') {
-                      if (hstate.isOn) {
-                        // For the preference mode we will try to reach the setpoint for a period of time then
-                        // switch over to the gas heater.  Our algorithm for this is to check the rate of
-                        // change when the heater first kicks on.  If we go for longer than an hour and still
-                        // haven't reached the setpoint then we will switch to gas.
-                        if (mode === 'ultratemppref' &&
-                          typeof hstate.startTime !== 'undefined' &&
-                          hstate.startTime.getTime() < new Date().getTime() - (60 * 60 * 1000))
-                          break;
-                        // If the heater is already on we will heat to 1 degree past the setpoint.
-                        if (body.temp - 1 < cfgBody.heatSetpoint) {
-                          isOn = true;
-                          body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpheat');
-                          isHeating = true;
-                          isCooling = false;
-                        }
-                        else if (body.temp + 1 > cfgBody.coolSetpoint && heater.coolingEnabled) {
-                          isOn = true;
-                          body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpcool');
-                          isHeating = false;
-                          isCooling = true;
-                        }
-                      }
-                      else {
-                        let delayStart = typeof hstate.endTime !== 'undefined' ? (hstate.endTime.getTime() + (30 * 60 * 1000)) > new Date().getTime() : false;
-                        // The heater is not currently on lets turn it on if we pass all the criteria.
-                        if ((body.temp < cfgBody.heatSetpoint && !delayStart)
-                          || body.temp + heater.differentialTemp < cfgBody.heatSetpoint) {
-                          isOn = true;
-                          body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpheat');
-                          isHeating = true;
-                          isCooling = false;
-                        }
-                        else if (body.temp > cfgBody.coolSetpoint && heater.coolingEnabled) {
-                          if (!delayStart || body.temp - heater.differentialTemp > cfgBody.coolSetpoint) {
-                            isOn = true;
-                            body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpcool');
-                            isHeating = false;
-                            isCooling = true;
-                          }
-                        }
-                      }
+                case 'solar2':
+                    if (sys.equipment.maxBodies > 1 + (sys.equipment.shared ? 1 : 0)) {
+                        htypes = sys.board.heaters.getInstalledHeaterTypes(2 + (sys.equipment.shared ? 1 : 0));
+                        sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
                     }
+                    else sensor.isActive = false;
                     break;
-                  case 'mastertemp':
-                    // If we make it here, the other heater is not heating the body.
-                    if (mode === 'mtheater' || mode === 'heatpumppref' || mode === 'ultratemppref' || mode === 'solarpref') {
-                      if (body.temp < cfgBody.setPoint) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('mtheat');
-                        isHeating = true;
-                      }
+                case 'solar3':
+                    if (sys.equipment.maxBodies > 2 + (sys.equipment.shared ? 1 : 0)) {
+                        htypes = sys.board.heaters.getInstalledHeaterTypes(3 + (sys.equipment.shared ? 1 : 0));
+                        sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
                     }
+                    else sensor.isActive = false;
                     break;
-                  case 'maxetherm':
-                  case 'gas':
-                    // If we make it here, the other heater is not heating the body.
-                    if (mode === 'heater' || mode === 'solarpref' || mode === 'heatpumppref' || mode === 'ultratemppref') {
-                      // Heat past the setpoint for the heater but only if the heater is currently on.
-                      if ((body.temp - (hstate.isOn ? heater.stopTempDelta : 0)) < cfgBody.setPoint) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
-                        isHeating = true;
-                      }
+                case 'solar4':
+                    if (sys.equipment.maxBodies > 3 + (sys.equipment.shared ? 1 : 0)) {
+                        htypes = sys.board.heaters.getInstalledHeaterTypes(4 + (sys.equipment.shared ? 1 : 0));
+                        sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
                     }
+                    else sensor.isActive = false;
                     break;
-                  case 'heatpump':
-                    if (mode === 'heatpump' || mode === 'heatpumppref') {
-                      if (hstate.isOn) {
-                        // If the heater is already on we will heat to 1 degree past the setpoint.
-                        if (body.temp - 1 < cfgBody.heatSetpoint) {
-                          isOn = true;
-                          body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpheat');
-                          isHeating = true;
-                          isCooling = false;
+                default:
+                    if (typeof sensor.id === 'undefined') sys.equipment.tempSensors.removeItemByIndex(i);
+                    break;
+            }
+        }
+    }
+    // This updates the heater states based upon the installed heaters.  This is true for heaters that are tied to the OCP
+    // and those that are not.
+    public syncHeaterStates() {
+        try {
+            
+            // Go through the installed heaters and bodies to determine whether they should be on.  If there is a
+            // heater that is not controlled by the OCP then we need to determine whether it should be on.
+            let heaters = sys.heaters.toArray();
+            let bodies = state.temps.bodies.toArray();
+            let hon = [];
+            for (let i = 0; i < bodies.length; i++) {
+                let body: BodyTempState = bodies[i];
+                let cfgBody: Body = sys.bodies.getItemById(body.id);
+                let isHeating = false;
+                let isCooling = false;
+                let hstatus = sys.board.valueMaps.heatStatus.getName(body.heatStatus);
+                let mode = sys.board.valueMaps.heatModes.getName(body.heatMode);
+                if (body.isOn) {
+                    if (typeof body.temp === 'undefined' && heaters.length > 0) logger.warn(`The body temperature for ${body.name} cannot be determined. Heater status for this body cannot be calculated.`);
+                    // Now get all the heaters associated with the body in an array.
+                    let bodyHeaters: Heater[] = [];
+                    for (let j = 0; j < heaters.length; j++) {
+                        let heater: Heater = heaters[j];
+                        if (heater.isActive === false) continue;
+                        if (heater.body === body.id) bodyHeaters.push(heater);
+                        else {
+                            let b = sys.board.valueMaps.bodies.transform(heater.body);
+                            switch (b.name) {
+                                case 'body1':
+                                case 'pool':
+                                    if (body.id === 1) bodyHeaters.push(heater);
+                                    break;
+                                case 'body2':
+                                case 'spa':
+                                    if (body.id === 2) bodyHeaters.push(heater);
+                                    break;
+                                case 'poolspa':
+                                    if (body.id === 1 || body.id === 2) bodyHeaters.push(heater);
+                                    break;
+                                case 'body3':
+                                    if (body.id === 3) bodyHeaters.push(heater);
+                                    break;
+                                case 'body4':
+                                    if (body.id === 4) bodyHeaters.push(heater);
+                                    break;
+                            }
+                        }
+                    }
+                    // Alright we have all the body heaters so sort them in a way that will make our heater preferences work.  Solar, heatpumps, and ultratemp should be in the list first
+                    // so that if we have a heater preference set up then we do not have to evaluate the other heater.
+                    let heaterTypes = sys.board.valueMaps.heaterTypes;
+                    bodyHeaters.sort((a, b) => {
+                        if (heaterTypes.transform(a.type).hasPreference) return -1;
+                        else if (heaterTypes.transform(b.type).hasPreference) return 1;
+                        return 0;
+                    });
+
+                    // Alright so now we should have a sorted array that has preference type heaters first.
+                    for (let j = 0; j < bodyHeaters.length; j++) {
+                        let heater: Heater = bodyHeaters[j];
+                        let isOn = false;
+                        let htype = sys.board.valueMaps.heaterTypes.transform(heater.type);
+                        let hstate = state.heaters.getItemById(heater.id, true);
+                        if (heater.master === 1) {
+                            if (hstatus !== 'cooldown') {
+                                // We need to do our own calculation as to whether it is on.  This is for Nixie heaters.
+                                switch (htype.name) {
+                                    case 'solar':
+                                        if (mode === 'solar' || mode === 'solarpref') {
+                                            // Measure up against start and stop temp deltas for effective solar heating.
+                                            if (body.temp < cfgBody.heatSetpoint &&
+                                                state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('solar');
+                                                isHeating = true;
+                                            }
+                                            else if (heater.coolingEnabled && body.temp > cfgBody.coolSetpoint && state.heliotrope.isNight &&
+                                                state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('cooling');
+                                                isHeating = true;
+                                                isCooling = true;
+                                            }
+                                        }
+                                        break;
+                                    case 'ultratemp':
+                                        // There is a temperature differential setting on UltraTemp.  This is how
+                                        // much the water temperature needs to drop below the set temperature, for the heater
+                                        // to start up again.  For instance, if the set temperature and the water temperature is 82 and then the
+                                        // heater will shut off and not turn on again until the water temperature = setpoint - differentialTemperature.
+                                        // This is the default operation on IntelliCenter and it appears to simply not start on the setpoint.  We can do better
+                                        // than this by heating 1 degree past the setpoint then applying this rule for 30 minutes.  This allows for a more
+                                        // responsive heater.
+                                        // 
+                                        // For Ultratemp we need to determine whether the differential temp
+                                        // is within range.  The other thing that needs to be calculated here is
+                                        // whether Ultratemp can effeciently heat the pool.
+                                        if (mode === 'ultratemp' || mode === 'ultratemppref') {
+                                            if (hstate.isOn) {
+                                                // For the preference mode we will try to reach the setpoint for a period of time then
+                                                // switch over to the gas heater.  Our algorithm for this is to check the rate of
+                                                // change when the heater first kicks on.  If we go for longer than an hour and still
+                                                // haven't reached the setpoint then we will switch to gas.
+                                                if (mode === 'ultratemppref' &&
+                                                    typeof hstate.startTime !== 'undefined' &&
+                                                    hstate.startTime.getTime() < new Date().getTime() - (60 * 60 * 1000))
+                                                    break;
+                                                // If the heater is already on we will heat to 1 degree past the setpoint.
+                                                if (body.temp - 1 < cfgBody.heatSetpoint) {
+                                                    isOn = true;
+                                                    body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpheat');
+                                                    isHeating = true;
+                                                    isCooling = false;
+                                                }
+                                                else if (body.temp + 1 > cfgBody.coolSetpoint && heater.coolingEnabled) {
+                                                    isOn = true;
+                                                    body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpcool');
+                                                    isHeating = false;
+                                                    isCooling = true;
+                                                }
+                                            }
+                                            else {
+                                                let delayStart = typeof hstate.endTime !== 'undefined' ? (hstate.endTime.getTime() + (30 * 60 * 1000)) > new Date().getTime() : false;
+                                                // The heater is not currently on lets turn it on if we pass all the criteria.
+                                                if ((body.temp < cfgBody.heatSetpoint && !delayStart)
+                                                    || body.temp + heater.differentialTemp < cfgBody.heatSetpoint) {
+                                                    isOn = true;
+                                                    body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpheat');
+                                                    isHeating = true;
+                                                    isCooling = false;
+                                                }
+                                                else if (body.temp > cfgBody.coolSetpoint && heater.coolingEnabled) {
+                                                    if (!delayStart || body.temp - heater.differentialTemp > cfgBody.coolSetpoint) {
+                                                        isOn = true;
+                                                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpcool');
+                                                        isHeating = false;
+                                                        isCooling = true;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        break;
+                                    case 'hybrid':
+                                        if (mode !== 'off') {
+                                            //console.log(`Mode: ${mode} Setpoint: ${cfgBody.setPoint}`);
+                                            isHeating = isOn = true;
+                                            isCooling = false;
+                                            if (hstate.isOn) {
+                                                // If the heater is already on we will heat to 1 degree past the setpoint.
+                                                if (body.temp - 1 < cfgBody.heatSetpoint) {
+                                                    isOn = true;
+                                                    // Heat Status will be set by the returns from the heater.
+                                                    //body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
+                                                    isHeating = true;
+                                                    isCooling = false;
+                                                }
+                                            }
+                                            else {
+                                                let delayStart = typeof hstate.endTime !== 'undefined' ? (hstate.endTime.getTime() + (30 * 60 * 1000)) > new Date().getTime() : false;
+                                                // The heater is not currently on lets turn it on if we pass all the criteria.
+                                                if ((body.temp < cfgBody.heatSetpoint && !delayStart)
+                                                    || body.temp + heater.differentialTemp < cfgBody.heatSetpoint) {
+                                                    isOn = true;
+                                                    // Heat Status will be set by the returns from the heater.
+                                                    //body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
+                                                    isHeating = true;
+                                                    isCooling = false;
+                                                }
+                                            }
+                                        }
+                                        break;
+
+                                    case 'mastertemp':
+                                        // If we make it here, the other heater is not heating the body.
+                                        if (mode === 'mtheater' || mode === 'heatpumppref' || mode === 'ultratemppref' || mode === 'solarpref') {
+                                            if (body.temp < cfgBody.setPoint) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('mtheat');
+                                                isHeating = true;
+                                            }
+                                        }
+                                        break;
+                                    case 'maxetherm':
+                                    case 'gas':
+                                        // If we make it here, the other heater is not heating the body.
+                                        if (mode === 'heater' || mode === 'solarpref' || mode === 'heatpumppref' || mode === 'ultratemppref') {
+                                            // Heat past the setpoint for the heater but only if the heater is currently on.
+                                            if ((body.temp - (hstate.isOn ? heater.stopTempDelta : 0)) < cfgBody.setPoint) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
+                                                isHeating = true;
+                                            }
+                                        }
+                                        break;
+                                    case 'heatpump':
+                                        if (mode === 'heatpump' || mode === 'heatpumppref') {
+                                            // Heat past the setpoint for the heater but only if the heater is currently on.
+                                            if ((body.temp - (hstate.isOn ? heater.stopTempDelta : 0)) < cfgBody.setPoint) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpheat');
+                                                isHeating = true;
+                                            }
+                                            //if (hstate.isOn) {
+                                            //    // If the heater is already on we will heat to 1 degree past the setpoint.
+                                            //    if (body.temp - 1 < cfgBody.heatSetpoint) {
+                                            //        isOn = true;
+                                            //        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpheat');
+                                            //        isHeating = true;
+                                            //        isCooling = false;
+                                            //    }
+                                            //}
+                                            //else {
+                                            //    // The heater is not currently on lets turn it on if we pass all the criteria.
+                                            //    if ((body.temp < cfgBody.heatSetpoint && hstate.endTime.getTime() < new Date().getTime() + (30 * 60 * 1000))
+                                            //        || body.temp + heater.differentialTemp < cfgBody.heatSetpoint) {
+                                            //        isOn = true;
+                                            //        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpcool');
+                                            //        isHeating = true;
+                                            //        isCooling = false;
+                                            //    }
+                                            //}
+                                        }
+                                        break;
+                                    default:
+                                        isOn = utils.makeBool(hstate.isOn);
+                                        break;
+                                }
+                                logger.debug(`Heater Type: ${htype.name} Mode:${mode} Temp: ${body.temp} Setpoint: ${cfgBody.setPoint} Status: ${body.heatStatus}`);
+                            }
+                        }
+                        else {
+                            let mode = sys.board.valueMaps.heatModes.getName(body.heatMode);
+                            switch (htype.name) {
+                                case 'mastertemp':
+                                    if (hstatus === 'mtheat') isHeating = isOn = true;
+                                    break;
+                                case 'maxetherm':
+                                case 'gas':
+                                    if (hstatus === 'heater') isHeating = isOn = true;
+                                    break;
+                                case 'hybrid':
+                                    if (hstatus === 'mtheat' || hstatus === 'heater' || hstatus === 'dual' || hstatus === 'hybheat') isHeating = isOn = true;
+                                    break;
+                                case 'ultratemp':
+                                case 'heatpump':
+                                    if (mode === 'ultratemp' || mode === 'ultratemppref' || mode === 'heatpump' || mode === 'heatpumppref') {
+                                        if (hstatus === 'heater') isHeating = isOn = true;
+                                        else if (hstatus === 'cooling') isCooling = isOn = true;
+                                    }
+                                    break;
+                                case 'solar':
+                                    if (mode === 'solar' || mode === 'solarpref') {
+                                        if (hstatus === 'solar') isHeating = isOn = true;
+                                        else if (hstatus === 'cooling') isCooling = isOn = true;
+                                    }
+                                    break;
+                            }
                         }
-                      }
-                      else {
-                        // The heater is not currently on lets turn it on if we pass all the criteria.
-                        if ((body.temp < cfgBody.heatSetpoint && hstate.endTime.getTime() < new Date().getTime() + (30 * 60 * 1000))
-                          || body.temp + heater.differentialTemp < cfgBody.heatSetpoint) {
-                          isOn = true;
-                          body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpcool');
-                          isHeating = true;
-                          isCooling = false;
+                        if (isOn === true && typeof hon.find(elem => elem === heater.id) === 'undefined') {
+                            hon.push(heater.id);
+                            if (heater.master === 1 && isOn) (async () => {
+                                try {
+                                    hstate.bodyId = body.id;
+                                    if (sys.board.valueMaps.heatStatus.getName(body.heatStatus) === 'cooldown')
+                                        await ncp.heaters.setHeaterStateAsync(hstate, false, false);
+                                    else if (isOn) {
+                                        hstate.bodyId = body.id;
+                                        await ncp.heaters.setHeaterStateAsync(hstate, isOn, isCooling);
+                                    }
+                                    else if (hstate.isOn !== isOn || hstate.isCooling !== isCooling) {
+                                        await ncp.heaters.setHeaterStateAsync(hstate, isOn, isCooling);
+                                    }
+                                } catch (err) { logger.error(`Error setting heater state ${hstate.name}: ${err.message}`); }
+                            })();
+                            else {
+                                hstate.isOn = isOn;
+                                hstate.bodyId = body.id;
+                            }
                         }
-                      }
+                        // If there is a heater on for the body we need break out of the loop.  This will make sure for instance a gas heater
+                        // isn't started when one of the more economical methods are.
+                        if (isOn === true) break;
                     }
-                    break;
-                  default:
-                    isOn = utils.makeBool(hstate.isOn);
-                    break;
                 }
-                logger.debug(`Heater Type: ${htype.name} Mode:${mode} Temp: ${body.temp} Setpoint: ${cfgBody.setPoint} Status: ${body.heatStatus}`);
-              }
-            }
-            else {
-              let mode = sys.board.valueMaps.heatModes.getName(body.heatMode);
-              switch (htype.name) {
-                case 'mastertemp':
-                  if (hstatus === 'mtheat') isHeating = isOn = true;
-                  break;
-                case 'maxetherm':
-                case 'gas':
-                  if (hstatus === 'heater') isHeating = isOn = true;
-                  break;
-                case 'hybrid':
-                  if (hstatus === 'mtheat' || hstatus === 'heater' || hstatus === 'dual') isHeating = isOn = true;
-                  break;
-                case 'ultratemp':
-                case 'heatpump':
-                  if (mode === 'ultratemp' || mode === 'ultratemppref' || mode === 'heatpump' || mode === 'heatpumppref') {
-                    if (hstatus === 'heater') isHeating = isOn = true;
-                    else if (hstatus === 'cooling') isCooling = isOn = true;
-                  }
-                  break;
-                case 'solar':
-                  if (mode === 'solar' || mode === 'solarpref') {
-                    if (hstatus === 'solar') isHeating = isOn = true;
-                    else if (hstatus === 'cooling') isCooling = isOn = true;
-                  }
-                  break;
-              }
+                if (sys.controllerType === ControllerType.Nixie && !isHeating && !isCooling && hstatus !== 'cooldown') body.heatStatus = sys.board.valueMaps.heatStatus.getValue('off');
+                //else if (sys.controllerType === ControllerType.Nixie) body.heatStatus = 0;
             }
-            if (isOn === true && typeof hon.find(elem => elem === heater.id) === 'undefined') {
-              hon.push(heater.id);
-              if (heater.master === 1 && isOn) (async () => {
-                try {
-                  hstate.bodyId = body.id;
-                  if (sys.board.valueMaps.heatStatus.getName(body.heatStatus) === 'cooldown')
-                    await ncp.heaters.setHeaterStateAsync(hstate, false, false);
-                  else if (isOn) {
-                    hstate.bodyId = body.id;
-                    await ncp.heaters.setHeaterStateAsync(hstate, isOn, isCooling);
-                  }
-                  else if (hstate.isOn !== isOn || hstate.isCooling !== isCooling) {
-                    await ncp.heaters.setHeaterStateAsync(hstate, isOn, isCooling);
-                  }
-                } catch (err) { logger.error(err.message); }
-              })();
-              else {
-                hstate.isOn = isOn;
-                hstate.bodyId = body.id;
-              }
+            // Turn off any heaters that should be off.  The code above only turns heaters on.
+            for (let i = 0; i < heaters.length; i++) {
+                let heater: Heater = heaters[i];
+                if (typeof hon.find(elem => elem === heater.id) === 'undefined') {
+                    let hstate = state.heaters.getItemById(heater.id, true);
+                    if (heater.master === 1) (async () => {
+                        try {
+                            await ncp.heaters.setHeaterStateAsync(hstate, false, false);
+                            hstate.bodyId = 0;
+                        } catch (err) { logger.error(`Error turning off heater ${heater.name}: ${err.message}`); }
+                    })();
+                    else {
+                        hstate.isOn = false;
+                        hstate.bodyId = 0;
+                    }
+                }
             }
-            // If there is a heater on for the body we need break out of the loop.  This will make sure for instance a gas heater
-            // isn't started when one of the more economical methods are.
-            if (isOn === true) break;
-          }
-        }
-        if (sys.controllerType === ControllerType.Nixie && !isHeating && !isCooling && hstatus !== 'cooldown') body.heatStatus = sys.board.valueMaps.heatStatus.getValue('off');
-        //else if (sys.controllerType === ControllerType.Nixie) body.heatStatus = 0;
-      }
-      // Turn off any heaters that should be off.  The code above only turns heaters on.
-      for (let i = 0; i < heaters.length; i++) {
-        let heater: Heater = heaters[i];
-        if (typeof hon.find(elem => elem === heater.id) === 'undefined') {
-          let hstate = state.heaters.getItemById(heater.id, true);
-          if (heater.master === 1) (async () => {
-            try {
-              await ncp.heaters.setHeaterStateAsync(hstate, false, false);
-              hstate.bodyId = 0;
-            } catch (err) { logger.error(err.message); }
-          })();
-          else {
-            hstate.isOn = false;
-            hstate.bodyId = 0;
-          }
-        }
-      }
-    } catch (err) { logger.error(`Error synchronizing heater states: ${err.message}`); }
-  }
+        } catch (err) { logger.error(`Error synchronizing heater states: ${err.message}`); }
+    }
 }
 export class ValveCommands extends BoardCommands {
   public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
@@ -4409,7 +4548,7 @@ export class ValveCommands extends BoardCommands {
     else
       vstate.isDiverted = isDiverted;
   }
-  public async setValveAsync(obj: any): Promise<Valve> {
+  public async setValveAsync(obj: any, send: boolean = true): Promise<Valve> {
     try {
       let id = typeof obj.id !== 'undefined' ? parseInt(obj.id, 10) : -1;
       obj.master = 1;
@@ -4533,60 +4672,224 @@ export class ValveCommands extends BoardCommands {
     return arrIds;
   }
 }
-export class ChemControllerCommands extends BoardCommands {
-  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
-    try {
-      // First delete the chemControllers that should be removed.
-      for (let i = 0; i < ctx.chemControllers.remove.length; i++) {
-        let c = ctx.chemControllers.remove[i];
+export class ChemDoserCommands extends BoardCommands {
+    public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
         try {
-          await sys.board.chemControllers.deleteChemControllerAsync(c);
-          res.addModuleSuccess('chemController', `Remove: ${c.id}-${c.name}`);
-        } catch (err) { res.addModuleError('chemController', `Remove: ${c.id}-${c.name}: ${err.message}`); }
-      }
-      for (let i = 0; i < ctx.chemControllers.update.length; i++) {
-        let c = ctx.chemControllers.update[i];
+            // First delete the chemDosers that should be removed.
+            for (let i = 0; i < ctx.chemDosers.remove.length; i++) {
+                let c = ctx.chemDosers.remove[i];
+                try {
+                    await sys.board.chemDosers.deleteChemDoserAsync(c);
+                    res.addModuleSuccess('chemDoser', `Remove: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('chemDoser', `Remove: ${c.id}-${c.name}: ${err.message}`); }
+            }
+            for (let i = 0; i < ctx.chemDosers.update.length; i++) {
+                let c = ctx.chemDosers.update[i];
+                try {
+                    await sys.board.chemDosers.setChemDoserAsync(c);
+                    res.addModuleSuccess('chemDoser', `Update: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('chemDoser', `Update: ${c.id}-${c.name}: ${err.message}`); }
+            }
+            for (let i = 0; i < ctx.chemDosers.add.length; i++) {
+                let c = ctx.chemDosers.add[i];
+                try {
+                    // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+                    // it won't error out.
+                    let chem = sys.chemDosers.getItemById(c.id, true);
+                    await sys.board.chemDosers.setChemDoserAsync(c);
+                    res.addModuleSuccess('chemDoser', `Add: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('chemDoser', `Add: ${c.id}-${c.name}: ${err.message}`); }
+            }
+            return true;
+        } catch (err) { logger.error(`Error restoring chemDosers: ${err.message}`); res.addModuleError('system', `Error restoring chemDosers: ${err.message}`); return false; }
+    }
+    public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
         try {
-          await sys.board.chemControllers.setChemControllerAsync(c);
-          res.addModuleSuccess('chemController', `Update: ${c.id}-${c.name}`);
-        } catch (err) { res.addModuleError('chemController', `Update: ${c.id}-${c.name}: ${err.message}`); }
-      }
-      for (let i = 0; i < ctx.chemControllers.add.length; i++) {
-        let c = ctx.chemControllers.add[i];
+            let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+            // Look at chemDosers.
+            let cfg = rest.poolConfig;
+            for (let i = 0; i < cfg.chemDosers.length; i++) {
+                let r = cfg.chemDosers[i];
+                let c = sys.chemDosers.find(elem => r.id === elem.id);
+                if (typeof c === 'undefined') ctx.add.push(r);
+                else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+            }
+            for (let i = 0; i < sys.chemDosers.length; i++) {
+                let c = sys.chemDosers.getItemByIndex(i);
+                let r = cfg.chemDosers.find(elem => elem.id == c.id);
+                if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+            }
+            return ctx;
+        } catch (err) { logger.error(`Error validating chemDosers for restore: ${err.message}`); }
+    }
+
+    public async deleteChemDoserAsync(data: any): Promise<ChemDoser> {
         try {
-          // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
-          // it won't error out.
-          let chem = sys.chemControllers.getItemById(c.id, true);
-          // RSG 11.24.21.  setChemControllerAsync will only set the type/address if it thinks it's new.   
-          // For a restore, if we set the type/address here it will pass the validation steps.
-          chem.type = c.type;
-          // chem.address = c.address;
-          await sys.board.chemControllers.setChemControllerAsync(c);
-          res.addModuleSuccess('chemController', `Add: ${c.id}-${c.name}`);
-        } catch (err) { res.addModuleError('chemController', `Add: ${c.id}-${c.name}: ${err.message}`); }
-      }
-      return true;
-    } catch (err) { logger.error(`Error restoring chemControllers: ${err.message}`); res.addModuleError('system', `Error restoring chemControllers: ${err.message}`); return false; }
-  }
-  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
-    try {
-      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
-      // Look at chemControllers.
-      let cfg = rest.poolConfig;
-      for (let i = 0; i < cfg.chemControllers.length; i++) {
-        let r = cfg.chemControllers[i];
-        let c = sys.chemControllers.find(elem => r.id === elem.id);
-        if (typeof c === 'undefined') ctx.add.push(r);
-        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
-      }
-      for (let i = 0; i < sys.chemControllers.length; i++) {
-        let c = sys.chemControllers.getItemByIndex(i);
-        let r = cfg.chemControllers.find(elem => elem.id == c.id);
-        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
-      }
-      return ctx;
-    } catch (err) { logger.error(`Error validating chemControllers for restore: ${err.message}`); }
-  }
+            let id = typeof data.id !== 'undefined' ? parseInt(data.id, 10) : -1;
+            if (typeof id === 'undefined' || isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid Chem Controller Id`, id, 'chemDoser'));
+            let chem = sys.chemDosers.getItemById(id);
+            let schem = state.chemDosers.getItemById(id);
+            schem.isActive = chem.isActive = false;
+            await ncp.chemDosers.removeById(id);
+            sys.chemDosers.removeItemById(id);
+            state.chemDosers.removeItemById(id);
+            sys.emitEquipmentChange();
+            return Promise.resolve(chem);
+        } catch (err) { logger.error(`Error deleting chem controller ${err.message}`); }
+    }
+    public async manualDoseAsync(data: any): Promise<ChemDoserState> {
+        try {
+            let id = typeof data.id !== 'undefined' ? parseInt(data.id) : undefined;
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentDataError(`Cannot begin dosing: Invalid chem doser id was provided ${data.id}`, 'chemDoser', data.id));
+            let chem = sys.chemDosers.find(elem => elem.id === id);
+            if (typeof chem === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Cannot begin dosing: Chem doser was not found ${data.id}`, 'chemDoser', data.id));
+            // Let's check the type.  AFAIK you cannot manual dose an IntelliChem.
+            // We are down to the nitty gritty.  Let REM Chem do its thing.
+            await ncp.chemDosers.manualDoseAsync(chem.id, data);
+            return Promise.resolve(state.chemDosers.getItemById(id));
+        } catch (err) { return Promise.reject(err); }
+    }
+    public async calibrateDoseAsync(data: any): Promise<ChemDoserState> {
+        try {
+            let id = typeof data.id !== 'undefined' ? parseInt(data.id) : undefined;
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentDataError(`Cannot begin calibration: Invalid chem doser id was provided ${data.id}`, 'chemDoser', data.id));
+            let chem = sys.chemDosers.find(elem => elem.id === id);
+            if (typeof chem === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Cannot begin calibration: Chem doser was not found ${data.id}`, 'chemDoser', data.id));
+            // We are down to the nitty gritty.  Let REM Chem do its thing.
+            await ncp.chemDosers.calibrateDoseAsync(chem.id, data);
+            return Promise.resolve(state.chemDosers.getItemById(id));
+        } catch (err) { return Promise.reject(err); }
+    }
+
+    public async cancelDosingAsync(data: any): Promise<ChemDoserState> {
+        try {
+            let id = typeof data.id !== 'undefined' ? parseInt(data.id) : undefined;
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentDataError(`Cannot cancel dosing: Invalid chem doser id was provided ${data.id}`, 'chemDoser', data.id));
+            let chem = sys.chemDosers.find(elem => elem.id === id);
+            if (typeof chem === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Cannot cancel dosing: Chem doser was not found ${data.id}`, 'chemDoser', data.id));
+            // We are down to the nitty gritty.  Let REM Chem do its thing.
+            await ncp.chemDosers.cancelDoseAsync(chem.id, data);
+            return Promise.resolve(state.chemDosers.getItemById(id));
+        } catch (err) { return Promise.reject(err); }
+    }
+    public async manualMixAsync(data: any): Promise<ChemDoserState> {
+        try {
+            let id = typeof data.id !== 'undefined' ? parseInt(data.id) : undefined;
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentDataError(`Cannot begin mixing: Invalid chem doser id was provided ${data.id}`, 'chemDoser', data.id));
+            let chem = sys.chemDosers.find(elem => elem.id === id);
+            if (typeof chem === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Cannot begin mixing: Chem doser was not found ${data.id}`, 'chemDoser', data.id));
+            // We are down to the nitty gritty.  Let REM Chem do its thing.
+            await ncp.chemDosers.manualMixAsync(chem.id, data);
+            return Promise.resolve(state.chemDosers.getItemById(id));
+        } catch (err) { return Promise.reject(err); }
+    }
+    public async cancelMixingAsync(data: any): Promise<ChemDoserState> {
+        try {
+            let id = typeof data.id !== 'undefined' ? parseInt(data.id) : undefined;
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentDataError(`Cannot cancel mixing: Invalid chem doser id was provided ${data.id}`, 'chemDoser', data.id));
+            let chem = sys.chemDosers.find(elem => elem.id === id);
+            if (typeof chem === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Cannot cancel mixing: Chem doser was not found ${data.id}`, 'chemDoser', data.id));
+            // We are down to the nitty gritty.  Let REM Chem do its thing.
+            await ncp.chemDosers.cancelMixingAsync(chem.id, data);
+            return Promise.resolve(state.chemDosers.getItemById(id));
+        } catch (err) { return Promise.reject(err); }
+    }
+    public findChemDoser(data: any) {
+        let id = parseInt(data.id, 10);
+        if (!isNaN(id)) return sys.chemDosers.find(x => x.id === id);
+    }
+    public async setChemDoserAsync(data: any): Promise<ChemDoser> {
+        // The following are the rules related to when an OCP is present.
+        // ==============================================================
+        // 1. IntelliChem cannot be controlled/polled via Nixie, since there is no enable/disable from the OCP at this point we don't know who is in control of polling.
+        // 2. With *Touch Commands will be sent directly to the IntelliChem controller in the hopes that the OCP will pick it up. Turns out this is not correct.  The TouchBoard now has the proper interface.
+        // 3. njspc will communicate to the OCP for IntelliChem control via the configuration interface.
+
+        // The following are the rules related to when no OCP is present.
+        // =============================================================
+        // 1. All chemDosers will be controlled via Nixie (IntelliChem, REM Chem).
+        try {
+            let chem = sys.board.chemDosers.findChemDoser(data);
+            let isAdd = typeof chem === 'undefined';
+            if (isAdd && sys.equipment.maxChemDosers <= sys.chemDosers.length) return Promise.reject(new InvalidEquipmentDataError(`The maximum number of chem controllers have been added to your controller`, 'chemDoser', sys.equipment.maxChemDosers));
+            if (isAdd) {
+                // At this point we are going to add the chem controller no matter what.
+                data.id = sys.chemDosers.getNextEquipmentId(new EquipmentIdRange(1, 10));
+                chem = sys.chemDosers.getItemById(data.id, true);
+            }
+            chem.isActive = true;
+            // So here is the thing.  If you have an OCP then the IntelliChem must be controlled by that.
+            // the messages on the bus will talk back to the OCP so if you do not do this mayhem will ensue.
+            await ncp.chemDosers.setDoserAsync(chem, data);
+            return Promise.resolve(chem);
+        }
+        catch (err) { return Promise.reject(err); }
+    }
+    public async setChemDoserStateAsync(data: any): Promise<ChemDoserState> {
+        let chem = sys.board.chemDosers.findChemDoser(data);
+        if (typeof chem === 'undefined') return Promise.reject(new InvalidEquipmentIdError(`A valid chem doser could not be found for id:${data.id}`, data.id, 'chemDoser'));
+        data.id = chem.id;
+        logger.info(`Setting ${chem.name} data ${chem.master}`);
+        if (chem.master === 1) await ncp.chemDosers.setDoserAsync(chem, data);
+        else await sys.board.chemDosers.setChemDoserAsync(data);
+        let schem = state.chemDosers.getItemById(chem.id, true);
+        return Promise.resolve(schem);
+    }
+}
+export class ChemControllerCommands extends BoardCommands {
+    public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+        try {
+            // First delete the chemControllers that should be removed.
+            for (let i = 0; i < ctx.chemControllers.remove.length; i++) {
+                let c = ctx.chemControllers.remove[i];
+                try {
+                    await sys.board.chemControllers.deleteChemControllerAsync(c);
+                    res.addModuleSuccess('chemController', `Remove: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('chemController', `Remove: ${c.id}-${c.name}: ${err.message}`); }
+            }
+            for (let i = 0; i < ctx.chemControllers.update.length; i++) {
+                let c = ctx.chemControllers.update[i];
+                try {
+                    await sys.board.chemControllers.setChemControllerAsync(c);
+                    res.addModuleSuccess('chemController', `Update: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('chemController', `Update: ${c.id}-${c.name}: ${err.message}`); }
+            }
+            for (let i = 0; i < ctx.chemControllers.add.length; i++) {
+                let c = ctx.chemControllers.add[i];
+                try {
+                    // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+                    // it won't error out.
+                    let chem = sys.chemControllers.getItemById(c.id, true);
+                    // RSG 11.24.21.  setChemControllerAsync will only set the type/address if it thinks it's new.   
+                    // For a restore, if we set the type/address here it will pass the validation steps.
+                    chem.type = c.type;
+                    // chem.address = c.address;
+                    await sys.board.chemControllers.setChemControllerAsync(c);
+                    res.addModuleSuccess('chemController', `Add: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('chemController', `Add: ${c.id}-${c.name}: ${err.message}`); }
+            }
+            return true;
+        } catch (err) { logger.error(`Error restoring chemControllers: ${err.message}`); res.addModuleError('system', `Error restoring chemControllers: ${err.message}`); return false; }
+    }
+    public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
+        try {
+            let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+            // Look at chemControllers.
+            let cfg = rest.poolConfig;
+            for (let i = 0; i < cfg.chemControllers.length; i++) {
+                let r = cfg.chemControllers[i];
+                let c = sys.chemControllers.find(elem => r.id === elem.id);
+                if (typeof c === 'undefined') ctx.add.push(r);
+                else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+            }
+            for (let i = 0; i < sys.chemControllers.length; i++) {
+                let c = sys.chemControllers.getItemByIndex(i);
+                let r = cfg.chemControllers.find(elem => elem.id == c.id);
+                if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+            }
+            return ctx;
+        } catch (err) { logger.error(`Error validating chemControllers for restore: ${err.message}`); }
+    }
 
   public async deleteChemControllerAsync(data: any): Promise<ChemController> {
     try {
@@ -4602,20 +4905,35 @@ export class ChemControllerCommands extends BoardCommands {
       return Promise.resolve(chem);
     } catch (err) { logger.error(`Error deleting chem controller ${err.message}`); }
   }
-  public async manualDoseAsync(data: any): Promise<ChemControllerState> {
-    try {
-      let id = typeof data.id !== 'undefined' ? parseInt(data.id) : undefined;
-      if (isNaN(id)) return Promise.reject(new InvalidEquipmentDataError(`Cannot begin dosing: Invalid chem controller id was provided ${data.id}`, 'chemController', data.id));
-      let chem = sys.chemControllers.find(elem => elem.id === id);
-      if (typeof chem === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Cannot begin dosing: Chem controller was not found ${data.id}`, 'chemController', data.id));
-      // Let's check the type.  AFAIK you cannot manual dose an IntelliChem.
-      let type = sys.board.valueMaps.chemControllerTypes.transform(chem.type);
-      if (type.name !== 'rem') return Promise.reject(new InvalidEquipmentDataError(`You can only perform manual dosing on REM Chem controllers. Cannot manually dose ${type.desc}`, 'chemController', data.id));
-      // We are down to the nitty gritty.  Let REM Chem do its thing.
-      await ncp.chemControllers.manualDoseAsync(chem.id, data);
-      return Promise.resolve(state.chemControllers.getItemById(id));
-    } catch (err) { return Promise.reject(err); }
-  }
+    public async manualDoseAsync(data: any): Promise<ChemControllerState> {
+        try {
+            let id = typeof data.id !== 'undefined' ? parseInt(data.id) : undefined;
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentDataError(`Cannot begin dosing: Invalid chem controller id was provided ${data.id}`, 'chemController', data.id));
+            let chem = sys.chemControllers.find(elem => elem.id === id);
+            if (typeof chem === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Cannot begin dosing: Chem controller was not found ${data.id}`, 'chemController', data.id));
+            // Let's check the type.  AFAIK you cannot manual dose an IntelliChem.
+            let type = sys.board.valueMaps.chemControllerTypes.transform(chem.type);
+            if (type.name !== 'rem') return Promise.reject(new InvalidEquipmentDataError(`You can only perform manual dosing on REM Chem controllers. Cannot manually dose ${type.desc}`, 'chemController', data.id));
+            // We are down to the nitty gritty.  Let REM Chem do its thing.
+            await ncp.chemControllers.manualDoseAsync(chem.id, data);
+            return Promise.resolve(state.chemControllers.getItemById(id));
+        } catch (err) { return Promise.reject(err); }
+    }
+    public async calibrateDoseAsync(data: any): Promise<ChemControllerState> {
+        try {
+            let id = typeof data.id !== 'undefined' ? parseInt(data.id) : undefined;
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentDataError(`Cannot begin calibration: Invalid chem controller id was provided ${data.id}`, 'chemController', data.id));
+            let chem = sys.chemControllers.find(elem => elem.id === id);
+            if (typeof chem === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Cannot begin calibration: Chem controller was not found ${data.id}`, 'chemController', data.id));
+            // Let's check the type.  AFAIK you cannot manual dose an IntelliChem.
+            let type = sys.board.valueMaps.chemControllerTypes.transform(chem.type);
+            if (type.name !== 'rem') return Promise.reject(new InvalidEquipmentDataError(`You can only perform calibration dosing on REM Chem controllers. Cannot calibrate ${type.desc}`, 'chemController', data.id));
+            // We are down to the nitty gritty.  Let REM Chem do its thing.
+            await ncp.chemControllers.calibrateDoseAsync(chem.id, data);
+            return Promise.resolve(state.chemControllers.getItemById(id));
+        } catch (err) { return Promise.reject(err); }
+    }
+
   public async cancelDosingAsync(data: any): Promise<ChemControllerState> {
     try {
       let id = typeof data.id !== 'undefined' ? parseInt(data.id) : undefined;
@@ -4672,7 +4990,7 @@ export class ChemControllerCommands extends BoardCommands {
     if (!isNaN(id)) return sys.chemControllers.find(x => x.id === id);
     else if (!isNaN(address)) return sys.chemControllers.find(x => x.address === address);
   }
-  public async setChemControllerAsync(data: any): Promise<ChemController> {
+  public async setChemControllerAsync(data: any, send: boolean = true): Promise<ChemController> {
     // The following are the rules related to when an OCP is present.
     // ==============================================================
     // 1. IntelliChem cannot be controlled/polled via Nixie, since there is no enable/disable from the OCP at this point we don't know who is in control of polling.
@@ -4683,8 +5001,9 @@ export class ChemControllerCommands extends BoardCommands {
     // =============================================================
     // 1. All chemControllers will be controlled via Nixie (IntelliChem, REM Chem).
     try {
+      // let c1 = sys.chemControllers.getItemById(1);
       let chem = sys.board.chemControllers.findChemController(data);
-      let isAdd = typeof chem === 'undefined';
+      let isAdd = typeof chem === 'undefined' || typeof chem.isActive === 'undefined';
       let type = sys.board.valueMaps.chemControllerTypes.encode(isAdd ? data.type : chem.type);
       if (typeof type === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`The chem controller type could not be determined ${data.type || type}`, 'chemController', type));
       if (isAdd && sys.equipment.maxChemControllers <= sys.chemControllers.length) return Promise.reject(new InvalidEquipmentDataError(`The maximum number of chem controllers have been added to your controller`, 'chemController', sys.equipment.maxChemControllers));