nodejs-poolcontroller 7.5.1 → 7.7.0

package/controller/boards/SystemBoard.ts

@@ -18,11 +18,12 @@ 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, LightGroup, LightGroupCircuit, Location, Options, Owner, PoolSystem, Pump, Schedule, sys, TempSensorCollection, Valve } from '../Equipment';
-import { EquipmentNotFoundError, InvalidEquipmentDataError, InvalidEquipmentIdError } from '../Errors';
+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 { 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 { RestoreResults } from '../../web/Server';
+import { group } from 'console';
 
 
 export class byteValueMap extends Map<number, any> {
@@ -210,7 +211,8 @@ export class byteValueMaps {
   // Identifies which controller manages the underlying equipment.
   public equipmentMaster: byteValueMap = new byteValueMap([
     [0, { val: 0, name: 'ocp', desc: 'Outdoor Control Panel' }],
-    [1, { val: 1, name: 'ncp', desc: 'Nixie Control Panel' }]
+    [1, { val: 1, name: 'ncp', desc: 'Nixie Control Panel' }],
+    [2, { val: 2, name: 'ext', desc: 'External Control Panel' }]
   ]);
   public equipmentCommStatus: byteValueMap = new byteValueMap([
     [0, { val: 0, name: 'ready', desc: 'Ready' }],
@@ -233,9 +235,9 @@ export class byteValueMaps {
 
   public circuitFunctions: byteValueMap = new byteValueMap([
     [0, { name: 'generic', desc: 'Generic' }],
-    [1, { name: 'spa', desc: 'Spa', hasHeatSource: true }],
-    [2, { name: 'pool', desc: 'Pool', hasHeatSource: true }],
-    [5, { name: 'mastercleaner', desc: 'Master Cleaner' }],
+    [1, { name: 'spa', desc: 'Spa', hasHeatSource: true, body: 2 }],
+    [2, { name: 'pool', desc: 'Pool', hasHeatSource: true, body: 1 }],
+    [5, { name: 'mastercleaner', desc: 'Master Cleaner', body: 1 }],
     [7, { name: 'light', desc: 'Light', isLight: true }],
     [9, { name: 'samlight', desc: 'SAM Light', isLight: true }],
     [10, { name: 'sallight', desc: 'SAL Light', isLight: true }],
@@ -243,9 +245,9 @@ export class byteValueMaps {
     [12, { name: 'colorwheel', desc: 'Color Wheel', isLight: true }],
     [13, { name: 'valve', desc: 'Valve' }],
     [14, { name: 'spillway', desc: 'Spillway' }],
-    [15, { name: 'floorcleaner', desc: 'Floor Cleaner' }],
-    [16, { name: 'intellibrite', desc: 'Intellibrite', isLight: true }],
-    [17, { name: 'magicstream', desc: 'Magicstream', isLight: true }],
+    [15, { name: 'floorcleaner', desc: 'Floor Cleaner', body: 1 }],  // This circuit function does not seem to exist in IntelliTouch.
+    [16, { name: 'intellibrite', desc: 'Intellibrite', isLight: true, theme: 'intellibrite' }],
+    [17, { name: 'magicstream', desc: 'Magicstream', isLight: true, theme: 'magicstream' }],
     [19, { name: 'notused', desc: 'Not Used' }],
     [65, { name: 'lotemp', desc: 'Lo-Temp' }],
     [66, { name: 'hightemp', desc: 'Hi-Temp' }]
@@ -266,51 +268,104 @@ export class byteValueMaps {
     [255, { name: 'notused', desc: 'NOT USED', assignableToPumpCircuit: true }]
   ]);
   public lightThemes: byteValueMap = new byteValueMap([
-    [0, { name: 'off', desc: 'Off', type: 'intellibrite' }],
-    [1, { name: 'on', desc: 'On', type: 'intellibrite' }],
-    [128, { name: 'colorsync', desc: 'Color Sync', type: 'intellibrite' }],
-    [144, { name: 'colorswim', desc: 'Color Swim', type: 'intellibrite' }],
-    [160, { name: 'colorset', desc: 'Color Set', type: 'intellibrite' }],
-    [177, { name: 'party', desc: 'Party', type: 'intellibrite', sequence: 2 }],
-    [178, { name: 'romance', desc: 'Romance', type: 'intellibrite', sequence: 3 }],
-    [179, { name: 'caribbean', desc: 'Caribbean', type: 'intellibrite', sequence: 4 }],
-    [180, { name: 'american', desc: 'American', type: 'intellibrite', sequence: 5 }],
-    [181, { name: 'sunset', desc: 'Sunset', type: 'intellibrite', sequence: 6 }],
-    [182, { name: 'royal', desc: 'Royal', type: 'intellibrite', sequence: 7 }],
-    [190, { name: 'save', desc: 'Save', type: 'intellibrite', sequence: 13 }],
-    [191, { name: 'recall', desc: 'Recall', type: 'intellibrite', sequence: 14 }],
-    [193, { name: 'blue', desc: 'Blue', type: 'intellibrite', sequence: 8 }],
-    [194, { name: 'green', desc: 'Green', type: 'intellibrite', sequence: 9 }],
-    [195, { name: 'red', desc: 'Red', type: 'intellibrite', sequence: 10 }],
-    [196, { name: 'white', desc: 'White', type: 'intellibrite', sequence: 11 }],
-    [197, { name: 'magenta', desc: 'Magenta', type: 'intellibrite', sequence: 12 }],
-    [208, { name: 'thumper', desc: 'Thumper', type: 'magicstream' }],
-    [209, { name: 'hold', desc: 'Hold', type: 'magicstream' }],
-    [210, { name: 'reset', desc: 'Reset', type: 'magicstream' }],
-    [211, { name: 'mode', desc: 'Mode', type: 'magicstream' }],
+    [0, { name: 'off', desc: 'Off' }],
+    [1, { name: 'on', desc: 'On' }],
+    [128, { name: 'colorsync', desc: 'Color Sync' }],
+    [144, { name: 'colorswim', desc: 'Color Swim' }],
+    [160, { name: 'colorset', desc: 'Color Set' }],
+    [177, { name: 'party', desc: 'Party', types: ['intellibrite'], sequence: 2 }],
+    [178, { name: 'romance', desc: 'Romance', types: ['intellibrite'], sequence: 3 }],
+    [179, { name: 'caribbean', desc: 'Caribbean', types: ['intellibrite'], sequence: 4 }],
+    [180, { name: 'american', desc: 'American', types: ['intellibrite'], sequence: 5 }],
+    [181, { name: 'sunset', desc: 'Sunset', types: ['intellibrite'], sequence: 6 }],
+    [182, { name: 'royal', desc: 'Royal', types: ['intellibrite'], sequence: 7 }],
+    [190, { name: 'save', desc: 'Save', types: ['intellibrite'], sequence: 13 }],
+    [191, { name: 'recall', desc: 'Recall', types: ['intellibrite'], sequence: 14 }],
+    [193, { name: 'blue', desc: 'Blue', types: ['intellibrite'], sequence: 8 }],
+    [194, { name: 'green', desc: 'Green', types: ['intellibrite'], sequence: 9 }],
+    [195, { name: 'red', desc: 'Red', types: ['intellibrite'], sequence: 10 }],
+    [196, { name: 'white', desc: 'White', types: ['intellibrite'], sequence: 11 }],
+    [197, { name: 'magenta', desc: 'Magenta', types: ['intellibrite'], sequence: 12 }],
+    [208, { name: 'thumper', desc: 'Thumper', types: ['magicstream'] }],
+    [209, { name: 'hold', desc: 'Hold', types: ['magicstream'] }],
+    [210, { name: 'reset', desc: 'Reset', types: ['magicstream'] }],
+    [211, { name: 'mode', desc: 'Mode', types: ['magicstream'] }],
     [254, { name: 'unknown', desc: 'unknown' }],
     [255, { name: 'none', desc: 'None' }]
   ]);
   public colorLogicThemes = new byteValueMap([
-    [0, { name: 'cloudwhite', desc: 'Cloud White', type: 'colorlogic', sequence: 7 }],
-    [1, { name: 'deepsea', desc: 'Deep Sea', type: 'colorlogic', sequence: 2 }],
-    [2, { name: 'royalblue', desc: 'Royal Blue', type: 'colorlogic', sequence: 3 }],
-    [3, { name: 'afernoonskies', desc: 'Afternoon Skies', type: 'colorlogic', sequence: 4 }],
-    [4, { name: 'aquagreen', desc: 'Aqua Green', type: 'colorlogic', sequence: 5 }],
-    [5, { name: 'emerald', desc: 'Emerald', type: 'colorlogic', sequence: 6 }],
-    [6, { name: 'warmred', desc: 'Warm Red', type: 'colorlogic', sequence: 8 }],
-    [7, { name: 'flamingo', desc: 'Flamingo', type: 'colorlogic', sequence: 9 }],
-    [8, { name: 'vividviolet', desc: 'Vivid Violet', type: 'colorlogic', sequence: 10 }],
-    [9, { name: 'sangria', desc: 'Sangria', type: 'colorlogic', sequence: 11 }],
-    [10, { name: 'twilight', desc: 'Twilight', type: 'colorlogic', sequence: 12 }],
-    [11, { name: 'tranquility', desc: 'Tranquility', type: 'colorlogic', sequence: 13 }],
-    [12, { name: 'gemstone', desc: 'Gemstone', type: 'colorlogic', sequence: 14 }],
-    [13, { name: 'usa', desc: 'USA', type: 'colorlogic', sequence: 15 }],
-    [14, { name: 'mardigras', desc: 'Mardi Gras', type: 'colorlogic', sequence: 16 }],
-    [15, { name: 'cabaret', desc: 'Cabaret', type: 'colorlogic', sequence: 17 }],
+    [0, { name: 'cloudwhite', desc: 'Cloud White', types: ['colorlogic'], sequence: 7 }],
+    [1, { name: 'deepsea', desc: 'Deep Sea', types: ['colorlogic'], sequence: 2 }],
+    [2, { name: 'royalblue', desc: 'Royal Blue', types: ['colorlogic'], sequence: 3 }],
+    [3, { name: 'afernoonskies', desc: 'Afternoon Skies', types: ['colorlogic'], sequence: 4 }],
+    [4, { name: 'aquagreen', desc: 'Aqua Green', types: ['colorlogic'], sequence: 5 }],
+    [5, { name: 'emerald', desc: 'Emerald', types: ['colorlogic'], sequence: 6 }],
+    [6, { name: 'warmred', desc: 'Warm Red', types: ['colorlogic'], sequence: 8 }],
+    [7, { name: 'flamingo', desc: 'Flamingo', types: ['colorlogic'], sequence: 9 }],
+    [8, { name: 'vividviolet', desc: 'Vivid Violet', types: ['colorlogic'], sequence: 10 }],
+    [9, { name: 'sangria', desc: 'Sangria', types: ['colorlogic'], sequence: 11 }],
+    [10, { name: 'twilight', desc: 'Twilight', types: ['colorlogic'], sequence: 12 }],
+    [11, { name: 'tranquility', desc: 'Tranquility', types: ['colorlogic'], sequence: 13 }],
+    [12, { name: 'gemstone', desc: 'Gemstone', types: ['colorlogic'], sequence: 14 }],
+    [13, { name: 'usa', desc: 'USA', types: ['colorlogic'], sequence: 15 }],
+    [14, { name: 'mardigras', desc: 'Mardi Gras', types: ['colorlogic'], sequence: 16 }],
+    [15, { name: 'cabaret', desc: 'Cabaret', types: ['colorlogic'], sequence: 17 }],
     [255, { name: 'none', desc: 'None' }]
   ]);
-
+  public lightCommands = new byteValueMap([
+    [4, { name: 'colorhold', desc: 'Hold', types: ['intellibrite', 'magicstream'], command: 'colorHold', sequence: 13 }],
+    [5, { name: 'colorrecall', desc: 'Recall', types: ['intellibrite', 'magicstream'], command: 'colorRecall', sequence: 14 }],
+    [6, {
+      name: 'lightthumper', desc: 'Thumper', types: ['magicstream'], command: 'lightThumper', message: 'Toggling Thumper',
+      sequence: [ // Cycle party mode 3 times.
+        { isOn: false, timeout: 100 },
+        { isOn: true, timeout: 100 },
+        { isOn: false, timeout: 100 },
+        { isOn: true, timeout: 5000 },
+        { isOn: false, timeout: 100 },
+        { isOn: true, timeout: 100 },
+        { isOn: false, timeout: 100 },
+        { isOn: true, timeout: 5000 },
+        { isOn: false, timeout: 100 },
+        { isOn: true, timeout: 100 },
+        { isOn: false, timeout: 100 }
+      ]
+    }]
+  ]);
+  public lightGroupCommands = new byteValueMap([
+    [1, { name: 'colorsync', desc: 'Sync', types: ['intellibrite'], command: 'colorSync', message:'Synchronizing' }],
+    [2, { name: 'colorset', desc: 'Set', types: ['intellibrite'], command: 'colorSet', message: 'Sequencing Set Operation' }],
+    [3, { name: 'colorswim', desc: 'Swim', types: ['intellibrite'], command: 'colorSwim', message:'Sequencing Swim Operation' }],
+    [4, { name: 'colorhold', desc: 'Hold', types: ['intellibrite', 'magicstream'], command: 'colorHold', message: 'Saving Current Colors', sequence: 13 }],
+    [5, { name: 'colorrecall', desc: 'Recall', types: ['intellibrite', 'magicstream'], command: 'colorRecall', message: 'Recalling Saved Colors', sequence: 14 }],
+    [6, {
+      name: 'lightthumper', desc: 'Thumper', types: ['magicstream'], command: 'lightThumper', message: 'Toggling Thumper',
+      sequence: [ // Cycle party mode 3 times.
+        { isOn: false, timeout: 100 },
+        { isOn: true, timeout: 100 },
+        { isOn: false, timeout: 100 },
+        { isOn: true, timeout: 5000 },
+        { isOn: false, timeout: 100 },
+        { isOn: true, timeout: 100 },
+        { isOn: false, timeout: 100 },
+        { isOn: true, timeout: 5000 },
+        { isOn: false, timeout: 100 },
+        { isOn: true, timeout: 100 },
+        { isOn: false, timeout: 100 },
+        { isOn: true, timeout: 1000 },
+      ]
+    }]
+  ]);
+  public circuitActions: byteValueMap = new byteValueMap([
+    [0, { name: 'ready', desc: 'Ready' }],
+    [1, { name: 'colorsync', desc: 'Synchronizing' }],
+    [2, { name: 'colorset', desc: 'Sequencing Set Operation' }],
+    [3, { name: 'colorswim', desc: 'Sequencing Swim Operation' }],
+    [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' }]
+  ]);
   public lightColors: byteValueMap = new byteValueMap([
     [0, { name: 'white', desc: 'White' }],
     [2, { name: 'lightgreen', desc: 'Light Green' }],
@@ -338,7 +393,6 @@ export class byteValueMaps {
     [1, { name: 'active', desc: 'When Active' }],
     [2, { name: 'never', desc: 'Never' }]
   ]);
-
   public pumpTypes: byteValueMap = new byteValueMap([
     [1, { name: 'vf', desc: 'Intelliflo VF', minFlow: 15, maxFlow: 130, flowStepSize: 1, maxCircuits: 8, hasAddress: true }],
     [64, { name: 'vsf', desc: 'Intelliflo VSF', minSpeed: 450, maxSpeed: 3450, speedStepSize: 10, minFlow: 15, maxFlow: 130, flowStepSize: 1, maxCircuits: 8, hasAddress: true }],
@@ -384,12 +438,12 @@ export class byteValueMaps {
   ]);
   public heaterTypes: byteValueMap = new byteValueMap([
     [1, { name: 'gas', desc: 'Gas Heater', hasAddress: false }],
-    [2, { name: 'solar', desc: 'Solar Heater', hasAddress: false, hasCoolSetpoint: true }],
-    [3, { name: 'heatpump', desc: 'Heat Pump', hasAddress: true }],
-    [4, { name: 'ultratemp', desc: 'UltraTemp', hasAddress: true, hasCoolSetpoint: true }],
+    [2, { name: 'solar', desc: 'Solar Heater', hasAddress: false, hasCoolSetpoint: true, hasPreference: true }],
+    [3, { name: 'heatpump', desc: 'Heat Pump', hasAddress: true, hasPreference: true }],
+    [4, { name: 'ultratemp', desc: 'UltraTemp', hasAddress: true, hasCoolSetpoint: true, hasPreference: true }],
     [5, { name: 'hybrid', desc: 'Hybrid', hasAddress: true }],
-    [6, { name: 'maxetherm', desc: 'Max-E-Therm', hasAddress: true }],
-    [7, { name: 'mastertemp', desc: 'MasterTemp', hasAddress: true }]
+    [6, { name: 'mastertemp', desc: 'MasterTemp', hasAddress: true }],
+    [7, { name: 'maxetherm', desc: 'Max-E-Therm', hasAddress: true }],
   ]);
   public heatModes: byteValueMap = new byteValueMap([
     [0, { name: 'off', desc: 'Off' }],
@@ -408,7 +462,8 @@ export class byteValueMaps {
     [0, { name: 'off', desc: 'Off' }],
     [1, { name: 'heater', desc: 'Heater' }],
     [2, { name: 'solar', desc: 'Solar' }],
-    [3, { name: 'cooling', desc: 'Cooling' }]
+    [3, { name: 'cooling', desc: 'Cooling' }],
+    [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
@@ -507,13 +562,12 @@ export class byteValueMaps {
     [0, { name: 'standard', desc: 'Standard' }],
     [1, { name: 'intellivalve', desc: 'IntelliValve' }]
   ]);
-  public intellibriteActions: byteValueMap = new byteValueMap([
-    [0, { name: 'ready', desc: 'Ready' }],
-    [1, { name: 'sync', desc: 'Synchronizing' }],
-    [2, { name: 'set', desc: 'Sequencing Set Operation' }],
-    [3, { name: 'swim', desc: 'Sequencing Swim Operation' }],
-    [4, { name: 'color', desc: 'Sequencing Theme/Color Operation' }],
-    [5, { name: 'other', desc: 'Sequencing Save/Recall Operation' }]
+  public valveModes: byteValueMap = new byteValueMap([
+    [0, { name: 'off', desc: 'Off' }],
+    [1, { name: 'pool', desc: 'Pool' }],
+    [2, { name: 'spa', dest: 'Spa' }],
+    [3, { name: 'spillway', desc: 'Spillway' }],
+    [4, { name: 'spadrain', desc: 'Spa Drain' }]
   ]);
   public msgBroadcastActions: byteValueMap = new byteValueMap([
     [2, { name: 'status', desc: 'Equipment Status' }],
@@ -564,6 +618,18 @@ export class byteValueMaps {
     [0, { name: 'base', desc: 'Base pH+' }],
     [1, { name: 'acid', desc: 'Acid pH-' }]
   ]);
+  public phDoserTypes: byteValueMap = new byteValueMap([
+    [0, { name: 'none', desc: 'No Doser Attached' }],
+    [1, { name: 'extrelay', desc: 'External Relay' }],
+    [2, { name: 'co2', desc: 'CO2 Tank' }],
+    [3, { name: 'intrelay', desc: 'Internal Relay'}]
+  ]);
+  public orpDoserTypes: byteValueMap = new byteValueMap([
+    [0, { name: 'none', desc: 'No Doser Attached' }],
+    [1, { name: 'extrelay', desc: 'External Relay' }],
+    [2, { name: 'chlorinator', desc: 'Chlorinator'}],
+    [3, { name: 'intrelay', desc: 'Internal Relay'}]
+  ])
   public volumeUnits: byteValueMap = new byteValueMap([
     [0, { name: '', desc: 'No Units' }],
     [1, { name: 'gal', desc: 'Gallons' }],
@@ -603,7 +669,8 @@ export class byteValueMaps {
     [64, { name: 'orptankempty', desc: 'orp Tank Empty' }],
     [128, { name: 'probefault', desc: 'Probe Fault' }],
     [129, { name: 'phtanklow', desc: 'pH Tank Low' }],
-    [130, { name: 'orptanklow', desc: 'orp Tank Low' }]
+    [130, { name: 'orptanklow', desc: 'orp Tank Low' }],
+    [131, { name: 'freezeprotect', desc: 'Freeze Protection Lockout'}]
   ]);
   public chemControllerHardwareFaults: byteValueMap = new byteValueMap([
     [0, { name: 'ok', desc: 'Ok - No Faults' }],
@@ -614,6 +681,7 @@ 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' }],
@@ -749,7 +817,7 @@ export class SystemBoard {
     // turn off chlor
     console.log(`Stopping sys`);
     //sys.board.virtualChlorinatorController.stop();
-    if (sys.controllerType === ControllerType.Virtual) this.turnOffAllCircuits();
+    if (sys.controllerType === ControllerType.Nixie) this.turnOffAllCircuits();
     // sys.board.virtualChemControllers.stop();
     this.killStatusCheck();
     await ncp.closeAsync();
@@ -758,16 +826,20 @@ export class SystemBoard {
   public async turnOffAllCircuits() {
     // turn off all circuits/features
     for (let i = 0; i < state.circuits.length; i++) {
-      state.circuits.getItemByIndex(i).isOn = false;
+      let s = state.circuits.getItemByIndex(i);
+      await sys.board.circuits.setCircuitStateAsync(s.id, false);
     }
     for (let i = 0; i < state.features.length; i++) {
-      state.features.getItemByIndex(i).isOn = false;
+      let s = state.features.getItemByIndex(i);
+      await sys.board.features.setFeatureStateAsync(s.id, false);
     }
     for (let i = 0; i < state.lightGroups.length; i++) {
-      state.lightGroups.getItemByIndex(i).isOn = false;
+      let s = state.lightGroups.getItemByIndex(i);
+      await sys.board.circuits.setCircuitStateAsync(s.id, false);
     }
     for (let i = 0; i < state.temps.bodies.length; i++) {
-      state.temps.bodies.getItemByIndex(i).isOn = false;
+      let s = state.temps.bodies.getItemByIndex(i);
+      await sys.board.circuits.setCircuitStateAsync(s.id, false);
     }
     // sys.board.virtualPumpControllers.setTargetSpeed();
     state.emitEquipmentChanges();
@@ -989,14 +1061,15 @@ export class SystemCommands extends BoardCommands {
         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 bakup from ${sys.controllerType} to ${rest.poolConfig.controllerType}`);
+      else ctx.board.errors.push(`Panel Types do not match cannot restore backup from ${sys.controllerType} to ${rest.poolConfig.controllerType}`);
 
       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 {
@@ -1019,12 +1092,11 @@ export class SystemCommands extends BoardCommands {
   }
   public getDOW() { return this.board.valueMaps.scheduleDays.toArray(); }
   public async setGeneralAsync(obj: any): Promise<General> {
-    let general = sys.general.get();
     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 new Promise<General>(function (resolve, reject) { resolve(sys.general); });
+    return sys.general;
   }
   public async setTempSensorsAsync(obj: any): Promise<TempSensorCollection> {
     if (typeof obj.waterTempAdj1 != 'undefined' && obj.waterTempAdj1 !== sys.equipment.tempSensors.getCalibration('water1')) {
@@ -1054,7 +1126,7 @@ export class SystemCommands extends BoardCommands {
     if (typeof obj.airTempAdj != 'undefined' && obj.airTempAdj !== sys.equipment.tempSensors.getCalibration('air')) {
       sys.equipment.tempSensors.setCalibration('air', parseFloat(obj.airTempAdj));
     }
-    return new Promise<TempSensorCollection>((resolve, reject) => { resolve(sys.equipment.tempSensors); });
+    return sys.equipment.tempSensors;
   }
   public async setOptionsAsync(obj: any): Promise<Options> {
     if (obj.clockSource === 'server') sys.board.system.setTZ();
@@ -1063,15 +1135,15 @@ export class SystemCommands extends BoardCommands {
     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 new Promise<Options>(function (resolve, reject) { resolve(sys.general.options); });
+    return sys.general.options;
   }
   public async setLocationAsync(obj: any): Promise<Location> {
     sys.general.location.set(obj);
-    return new Promise<Location>(function (resolve, reject) { resolve(sys.general.location); });
+    return sys.general.location;
   }
   public async setOwnerAsync(obj: any): Promise<Owner> {
     sys.general.owner.set(obj);
-    return new Promise<Owner>(function (resolve, reject) { resolve(sys.general.owner); });
+    return sys.general.owner;
   }
   public async setTempsAsync(obj: any): Promise<TemperatureState> {
     return new Promise<TemperatureState>((resolve, reject) => {
@@ -1330,7 +1402,12 @@ export class BodyCommands extends BoardCommands {
       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') freeze = state.temps.air <= sys.general.options.freezeThreshold;
+        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
@@ -1422,7 +1499,7 @@ export class BodyCommands extends BoardCommands {
         else if (freeze && !cstate.isOn) {
           // This circuit should be on because we are freezing.
           cstate.freezeProtect = true;
-          await sys.board.features.setFeatureStateAsync(circ.id, 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.
@@ -1431,7 +1508,7 @@ export class BodyCommands extends BoardCommands {
         }
       }
     }
-    catch (err) { logger.error(`syncFreezeProtection: Error synchronizing freeze protection states`); }
+    catch (err) { logger.error(`syncFreezeProtection: Error synchronizing freeze protection states: ${err.message}`); }
   }
 
   public async initFilters() {
@@ -1477,7 +1554,10 @@ export class BodyCommands extends BoardCommands {
       let id = parseInt(obj.id, 10); 1
       if (isNaN(id)) reject(new InvalidEquipmentIdError('Body Id has not been defined', obj.id, 'Body'));
       let body = sys.bodies.getItemById(id, false);
+      let sbody = state.temps.bodies.getItemById(id, false);
       body.set(obj);
+      sbody.name = body.name;
+      sbody.showInDashboard = body.showInDashboard;
       resolve(body);
     });
   }
@@ -1570,54 +1650,57 @@ 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'));
-        }
-        return heatSources;
+  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'));
     }
-    public getHeatModes(bodyId: number) {
-        let heatModes = [];
-        // 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.gas > 0) heatModes.push(this.board.valueMaps.heatModes.transformByName('heater'));
-        if (heatTypes.mastertemp > 0) heatModes.push(this.board.valueMaps.heatModes.transformByName('mastertemp'));
-        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;
+    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'));
+    }
+    return heatSources;
+  }
+  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'));
     }
+    return heatModes;
+  }
   public getPoolStates(): BodyTempState[] {
     let arrPools = [];
     for (let i = 0; i < state.temps.bodies.length; i++) {
@@ -1676,8 +1759,9 @@ export class BodyCommands extends BoardCommands {
       case 'body4':
         return state.temps.bodies.getItemById(4).isOn;
       case 'poolspa':
-        if (sys.equipment.shared && sys.equipment.maxBodies >= 2)
-          return state.temps.bodies.getItemById(1).isOn || state.temps.bodies.getItemById(2).isOn;
+        if (sys.equipment.shared && sys.equipment.maxBodies >= 2) {
+          return state.temps.bodies.getItemById(1).isOn === true || state.temps.bodies.getItemById(2).isOn === true;
+        }
         else
           return state.temps.bodies.getItemById(1).isOn;
     }
@@ -1857,6 +1941,7 @@ export class PumpCommands extends BoardCommands {
     _availCircuits.push({ type: 'none', id: 255, name: 'Remove' });
     return _availCircuits;
   }
+  public setPumpValveDelays(circuitIds: number[], delay?: number) {}
 }
 export class CircuitCommands extends BoardCommands {
   public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
@@ -1918,7 +2003,7 @@ export class CircuitCommands extends BoardCommands {
           res.addModuleSuccess('circuitGroup', `Update: ${c.id}-${c.name}`);
         } catch (err) { res.addModuleError('circuitGroup', `Update: ${c.id}-${c.name}: ${err.message}`); }
       }
-      for (let i = 0; i < ctx.lightGroups.add.length; i++) {
+      for (let i = 0; i < ctx.lightGroups.update.length; i++) {
         let c = ctx.lightGroups.update[i];
         try {
           await sys.board.circuits.setLightGroupAsync(c);
@@ -1982,14 +2067,14 @@ export class CircuitCommands extends BoardCommands {
       for (let i = 0; i < sys.circuits.length; i++) {
         let c = sys.circuits.getItemByIndex(i);
         let cstate = state.circuits.getItemByIndex(i);
-        if (!cstate.isActive || !cstate.isOn) continue;
+        if (!cstate.isActive || !cstate.isOn || typeof cstate.endTime === 'undefined') continue;
         if (c.master === 1) {
           await ncp.circuits.checkCircuitEggTimerExpirationAsync(cstate);
         }
       }
       for (let i = 0; i < sys.features.length; i++) {
         let fstate = state.features.getItemByIndex(i);
-        if (!fstate.isActive || !fstate.isOn) continue;
+        if (!fstate.isActive || !fstate.isOn || typeof fstate.endTime === 'undefined') continue;
         if (fstate.endTime.toDate() < new Timestamp().toDate()) {
           await sys.board.circuits.setCircuitStateAsync(fstate.id, false);
           fstate.emitEquipmentChange();
@@ -1997,7 +2082,7 @@ export class CircuitCommands extends BoardCommands {
       }
       for (let i = 0; i < sys.circuitGroups.length; i++) {
         let cgstate = state.circuitGroups.getItemByIndex(i);
-        if (!cgstate.isActive || !cgstate.isOn) continue;
+        if (!cgstate.isActive || !cgstate.isOn || typeof cgstate.endTime === 'undefined') continue;
         if (cgstate.endTime.toDate() < new Timestamp().toDate()) {
           await sys.board.circuits.setCircuitGroupStateAsync(cgstate.id, false);
           cgstate.emitEquipmentChange();
@@ -2005,7 +2090,7 @@ export class CircuitCommands extends BoardCommands {
       }
       for (let i = 0; i < sys.lightGroups.length; i++) {
         let lgstate = state.lightGroups.getItemByIndex(i);
-        if (!lgstate.isActive || !lgstate.isOn) continue;
+        if (!lgstate.isActive || !lgstate.isOn || typeof lgstate.endTime === 'undefined') continue;
         if (lgstate.endTime.toDate() < new Timestamp().toDate()) {
           await sys.board.circuits.setLightGroupStateAsync(lgstate.id, false);
           lgstate.emitEquipmentChange();
@@ -2050,8 +2135,13 @@ export class CircuitCommands extends BoardCommands {
             }
             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') bState = true;
+              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':
@@ -2062,6 +2152,34 @@ export class CircuitCommands extends BoardCommands {
             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;
               }
             }
@@ -2100,7 +2218,110 @@ export class CircuitCommands extends BoardCommands {
               }
             }
             break;
-          case 'heater':
+          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 '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;
@@ -2125,10 +2346,17 @@ export class CircuitCommands extends BoardCommands {
             remove = true;
             break;
         }
-        if (remove)
+        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;
@@ -2138,7 +2366,7 @@ export class CircuitCommands extends BoardCommands {
       }
     } catch (err) { logger.error(`Error syncronizing virtual circuits`); }
   }
-  public async setCircuitStateAsync(id: number, val: boolean): Promise<ICircuitState> {
+  public async setCircuitStateAsync(id: number, val: boolean, ignoreDelays?: boolean): Promise<ICircuitState> {
     sys.board.suspendStatus(true);
     try {
       // We need to do some routing here as it is now critical that circuits, groups, and features
@@ -2185,17 +2413,133 @@ export class CircuitCommands extends BoardCommands {
     let circ = state.circuits.getInterfaceById(id);
     return await this.setCircuitStateAsync(id, !(circ.isOn || false));
   }
-  public async setLightThemeAsync(id: number, theme: number) {
+  public async runLightGroupCommandAsync(obj: any): Promise<ICircuitState> {
+    // Do all our validation.
+    try {
+      let id = parseInt(obj.id, 10);
+      let cmd = typeof obj.command !== 'undefined' ? sys.board.valueMaps.lightGroupCommands.findItem(obj.command) : { val: 0, name: 'undefined' };
+      if (cmd.val === 0) return Promise.reject(new InvalidOperationError(`Light group command ${cmd.name} does not exist`, 'runLightGroupCommandAsync'));
+      if (isNaN(id)) return Promise.reject(new InvalidOperationError(`Light group ${id} does not exist`, 'runLightGroupCommandAsync'));
+      let grp = sys.lightGroups.getItemById(id);
+      let nop = sys.board.valueMaps.circuitActions.getValue(cmd.name);
+      let sgrp = state.lightGroups.getItemById(grp.id);
+      sgrp.action = nop;
+      sgrp.emitEquipmentChange();
+      // So here we are now we can run the command against all lights in the group that match the command so get a list of the lights.
+      let arrCircs = [];
+      for (let i = 0; i < grp.circuits.length; i++) {
+        let circ = sys.circuits.getItemById(grp.circuits.getItemByIndex(i).circuit);
+        let type = sys.board.valueMaps.circuitFunctions.transform(circ.type);
+        if (type.isLight && cmd.types.includes(type.theme)) arrCircs.push(circ);
+      }
+      // So now we should hav a complete list of the lights that are part of the command list so start them off on their sequence.  We want all the lights
+      // to be doing their thing at the same time so in the lieu of threads we will ceate a promise all.
+      let proms = [];
+      for (let i = 0; i < arrCircs.length; i++) {
+        await ncp.circuits.sendOnOffSequenceAsync(arrCircs[i].id, cmd.sequence);
+        //proms.push(ncp.circuits.sendOnOffSequenceAsync(arrCircs[i].id, cmd.sequence));
+      }
+      for (let i = 0; i < arrCircs.length; i++) {
+        await sys.board.circuits.setCircuitStateAsync(arrCircs[i].id, false);
+        //proms.push(ncp.circuits.sendOnOffSequenceAsync(arrCircs[i].id, cmd.sequence));
+      }
+      await utils.sleep(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;
+    }
+    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);
     let thm = sys.board.valueMaps.lightThemes.findItem(theme);
-    if (typeof thm !== 'undefined' && typeof thm.sequence !== 'undefined' && circ.master === 1) {
+    let nop = sys.board.valueMaps.circuitActions.getValue('lighttheme');
+    cstate.action = nop;
+    cstate.emitEquipmentChange();
+    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);
+      }
+      cstate.lightingTheme = theme;
+      return cstate;
+    } catch (err) { return Promise.reject(new InvalidOperationError(err.message, 'setLightThemeAsync')); }
+    finally { cstate.action = 0; cstate.emitEquipmentChange(); }
+  }
+  public async setColorHoldAsync(id: number): Promise<ICircuitState> {
+    try {
+      let circ = sys.circuits.getItemById(id);
+      if (!circ.isActive) return Promise.reject(new InvalidEquipmentIdError(`Invalid circuit id ${id}`, id, 'circuit'));
+      let cstate = state.circuits.getItemById(circ.id);
+      let cmd = sys.board.valueMaps.lightCommands.findItem('colorhold');
+      await sys.board.circuits.setCircuitStateAsync(id, true);
+      if (circ.master === 1) await ncp.circuits.sendOnOffSequenceAsync(id, cmd.sequence);
+      return cstate;
+    }
+    catch (err) { return Promise.reject(`Nixie: Error setColorHoldAsync ${err.message}`); }
+  }
+  public async setColorRecallAsync(id: number): Promise<ICircuitState> {
+    try {
+      let circ = sys.circuits.getItemById(id);
+      if (!circ.isActive) return Promise.reject(new InvalidEquipmentIdError(`Invalid circuit id ${id}`, id, 'circuit'));
+      let cstate = state.circuits.getItemById(circ.id);
+      let cmd = sys.board.valueMaps.lightCommands.findItem('colorrecall');
       await sys.board.circuits.setCircuitStateAsync(id, true);
-      await ncp.circuits.sendOnOffSequenceAsync(id, thm.sequence);
+      if (circ.master === 1) await ncp.circuits.sendOnOffSequenceAsync(id, cmd.sequence);
+      return cstate;
     }
-    cstate.lightingTheme = theme;
-    return Promise.resolve(cstate as ICircuitState);
+    catch (err) { return Promise.reject(`Nixie: Error setColorHoldAsync ${err.message}`); }
   }
+  public async setLightThumperAsync(id: number): Promise<ICircuitState> { return state.circuits.getItemById(id); }
+
   public setDimmerLevelAsync(id: number, level: number): Promise<ICircuitState> {
     let circ = state.circuits.getItemById(id);
     circ.level = level;
@@ -2250,7 +2594,11 @@ export class CircuitCommands extends BoardCommands {
     return arrRefs;
   }
   public getLightThemes(type?: number) { return sys.board.valueMaps.lightThemes.toArray(); }
-  public getCircuitFunctions() { return sys.board.valueMaps.circuitFunctions.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 {
@@ -2529,20 +2877,20 @@ export class CircuitCommands extends BoardCommands {
     }
     catch (err) { return Promise.reject(err); }
   }
-  public sequenceLightGroupAsync(id: number, operation: string): Promise<LightGroupState> {
+  public async sequenceLightGroupAsync(id: number, operation: string): Promise<LightGroupState> {
     let sgroup = state.lightGroups.getItemById(id);
-    let nop = sys.board.valueMaps.intellibriteActions.getValue(operation);
-    if (nop > 0) {
-      sgroup.action = nop;
-      sgroup.hasChanged = true; // Say we are dirty but we really are pure as the driven snow.
-      state.emitEquipmentChanges();
-      setTimeout(function () {
+    // This is the default action which really does nothing.
+    try {
+      let nop = sys.board.valueMaps.circuitActions.getValue(operation);
+      if (nop > 0) {
+        sgroup.action = nop;
+        sgroup.emitEquipmentChange();
+        await utils.sleep(10000);
         sgroup.action = 0;
-        sgroup.hasChanged = true; // Say we are dirty but we really are pure as the driven snow.
-        state.emitEquipmentChanges();
-      }, 20000); // It takes 20 seconds to sequence.
-    }
-    return Promise.resolve(sgroup);
+        state.emitAllEquipmentChanges();
+      }
+      return sgroup;
+    } catch (err) { return Promise.reject(new InvalidOperationError(`Error sequencing light group ${err.message}`, 'sequenceLightGroupAsync')); }
   }
   public async setCircuitGroupStateAsync(id: number, val: boolean): Promise<ICircuitGroupState> {
     let grp = sys.circuitGroups.getItemById(id, false, { isActive: false });
@@ -2567,7 +2915,7 @@ export class CircuitCommands extends BoardCommands {
   public async setLightGroupStateAsync(id: number, val: boolean): Promise<ICircuitGroupState> {
     return sys.board.circuits.setCircuitGroupStateAsync(id, val);
   }
-  public setEndTime(thing: ICircuit, thingState: ICircuitState, isOn: boolean, bForce: boolean= false) {
+  public setEndTime(thing: ICircuit, thingState: ICircuitState, isOn: boolean, bForce: boolean = false) {
     /*
     this is a generic fn for circuits, features, circuitGroups, lightGroups
     to set the end time based on the egg timer.
@@ -2601,25 +2949,29 @@ export class CircuitCommands extends BoardCommands {
           eggTimerEndTime = state.time.clone().addHours(0, thing.eggTimer);
         }
         // egg timers don't come into play if a schedule will control the circuit
-        for (let i = 0; i < sys.schedules.length; i++) {
-          let sched = sys.schedules.getItemByIndex(i);
-          let ssched = state.schedules.getItemById(sched.id);
-          if (sched.isActive && sys.board.schedules.includesCircuit(sched, thing.id)) {
-            let nearestStartTime = sys.board.schedules.getNearestStartTime(sched);
-            let nearestEndTime = sys.board.schedules.getNearestEndTime(sched);
-            // if the schedule doesn't have an end date (eg no days)...
-            if (nearestEndTime.getTime() === 0) continue;
-            if (ssched.isOn) {
-              if (typeof endTime === 'undefined' || nearestEndTime.getTime() < endTime.getTime()) {
-                endTime = nearestEndTime.clone();
-                eggTimerEndTime = undefined;
+        // schedules don't come into play if the circuit is in manualPriority
+        if (!thingState.manualPriorityActive) {
+
+          for (let i = 0; i < sys.schedules.length; i++) {
+            let sched = sys.schedules.getItemByIndex(i);
+            let ssched = state.schedules.getItemById(sched.id);
+            if (sched.isActive && sys.board.schedules.includesCircuit(sched, thing.id)) {
+              let nearestStartTime = sys.board.schedules.getNearestStartTime(sched);
+              let nearestEndTime = sys.board.schedules.getNearestEndTime(sched);
+              // if the schedule doesn't have an end date (eg no days)...
+              if (nearestEndTime.getTime() === 0) continue;
+              if (ssched.isOn) {
+                if (typeof endTime === 'undefined' || nearestEndTime.getTime() < endTime.getTime()) {
+                  endTime = nearestEndTime.clone();
+                  eggTimerEndTime = undefined;
+                }
               }
-            }
-            else {
-              if (typeof eggTimerEndTime !== 'undefined' && eggTimerEndTime.getTime() < nearestStartTime.getTime()) {
-                if (typeof endTime === 'undefined' || eggTimerEndTime.getTime() < endTime.getTime()) endTime = eggTimerEndTime.clone();
+              else {
+                if (typeof eggTimerEndTime !== 'undefined' && eggTimerEndTime.getTime() < nearestStartTime.getTime()) {
+                  if (typeof endTime === 'undefined' || eggTimerEndTime.getTime() < endTime.getTime()) endTime = eggTimerEndTime.clone();
+                }
+                else if (typeof endTime === 'undefined' || nearestEndTime.getTime() < endTime.getTime()) endTime = nearestEndTime.clone();
               }
-              else if (typeof endTime === 'undefined' || nearestEndTime.getTime() < endTime.getTime()) endTime = nearestEndTime.clone();
             }
           }
         }
@@ -2631,8 +2983,85 @@ export class CircuitCommands extends BoardCommands {
       logger.error(`Error setting end time for ${thing.id}: ${err}`)
     }
   }
+  public async turnOffDrainCircuits(ignoreDelays: boolean) {
+    try {
+      {
+        let drt = sys.board.valueMaps.circuitFunctions.getValue('spadrain');
+        let drains = sys.circuits.filter(x => { return x.type === drt });
+        for (let i = 0; i < drains.length; i++) {
+          let drain = drains.getItemByIndex(i);
+          let sdrain = state.circuits.getItemById(drain.id);
+          if (sdrain.isOn) await sys.board.circuits.setCircuitStateAsync(drain.id, false, ignoreDelays);
+          sdrain.startDelay = false;
+          sdrain.stopDelay = false;
+        }
+      }
+      {
+        let drt = sys.board.valueMaps.featureFunctions.getValue('spadrain');
+        let drains = sys.features.filter(x => { return x.type === drt });
+        for (let i = 0; i < drains.length; i++) {
+          let drain = drains.getItemByIndex(i);
+          let sdrain = state.features.getItemById(drain.id);
+          if (sdrain.isOn) await sys.board.features.setFeatureStateAsync(drain.id, false, ignoreDelays);
+        }
+      }
+
+    } catch (err) { return Promise.reject(new BoardProcessError(`turnOffDrainCircuits: ${err.message}`)); }
+  }
+  public async turnOffCleanerCircuits(bstate: BodyTempState, ignoreDelays?: boolean) {
+    try {
+      // First we have to get all the cleaner circuits that are associated with the
+      // body.  To do this we get the circuit functions for all cleaner types associated with the body.
+      //
+      // Cleaner ciruits can always be turned off.  However, they cannot always be turned on.
+      let arrTypes = sys.board.valueMaps.circuitFunctions.toArray().filter(x => { return x.name.indexOf('cleaner') !== -1 && x.body === bstate.id; });
+      let cleaners = sys.circuits.filter(x => { return arrTypes.findIndex(t => { return t.val === x.type }) !== -1 });
+      // So now we should have all the cleaner circuits so lets make sure they are off.
+      for (let i = 0; i < cleaners.length; i++) {
+        let cleaner = cleaners.getItemByIndex(i);
+        if (cleaner.isActive) {
+          let cstate = state.circuits.getItemById(cleaner.id, true);
+          if (cstate.isOn || cstate.startDelay) await sys.board.circuits.setCircuitStateAsync(cleaner.id, false, ignoreDelays);
+        }
+      }
+    } catch (err) { return Promise.reject(new BoardProcessError(`turnOffCleanerCircuits: ${err.message}`)); }
+  }
+  public async turnOffSpillwayCircuits(ignoreDelays?: boolean) {
+    try {
+      {
+        let arrTypes = sys.board.valueMaps.circuitFunctions.toArray().filter(x => { return x.name.indexOf('spillway') !== -1 });
+        let spillways = sys.circuits.filter(x => { return arrTypes.findIndex(t => { return t.val === x.type }) !== -1 });
+        // So now we should have all the cleaner circuits so lets make sure they are off.
+        for (let i = 0; i < spillways.length; i++) {
+          let spillway = spillways.getItemByIndex(i);
+          if (spillway.isActive) {
+            let cstate = state.circuits.getItemById(spillway.id, true);
+            if (cstate.isOn || cstate.startDelay) await sys.board.circuits.setCircuitStateAsync(spillway.id, false, ignoreDelays);
+          }
+        }
+      }
+      {
+        let arrTypes = sys.board.valueMaps.featureFunctions.toArray().filter(x => { return x.name.indexOf('spillway') !== -1 });
+        let spillways = sys.features.filter(x => { return arrTypes.findIndex(t => { return t.val === x.type }) !== -1 });
+        // So now we should have all the cleaner features so lets make sure they are off.
+        for (let i = 0; i < spillways.length; i++) {
+          let spillway = spillways.getItemByIndex(i);
+          if (spillway.isActive) {
+            let cstate = state.features.getItemById(spillway.id, true);
+            if (cstate.isOn) await sys.board.features.setFeatureStateAsync(spillway.id, false, ignoreDelays);
+          }
+        }
+      }
+    } catch (err) { return Promise.reject(new BoardProcessError(`turnOffSpillwayCircuits: ${err.message}`)); }
+  }
 }
 export class FeatureCommands extends BoardCommands {
+  public getFeatureFunctions() {
+    let cf = sys.board.valueMaps.featureFunctions.toArray();
+    if (!sys.equipment.shared) cf = cf.filter(x => { return x.name !== 'spillway' && x.name !== 'spadrain' });
+    return cf;
+  }
+
   public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
     try {
       // First delete the features that should be removed.
@@ -2727,7 +3156,7 @@ export class FeatureCommands extends BoardCommands {
     else
       Promise.reject(new InvalidEquipmentIdError('Feature id has not been defined', undefined, 'Feature'));
   }
-  public async setFeatureStateAsync(id: number, val: boolean): Promise<ICircuitState> {
+  public async setFeatureStateAsync(id: number, val: boolean, ignoreDelays?: boolean): Promise<ICircuitState> {
     try {
       if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid feature id: ${id}`, id, 'Feature'));
       if (!sys.board.equipmentIds.features.isInRange(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid feature id: ${id}`, id, 'Feature'));
@@ -2852,12 +3281,77 @@ export class ChlorinatorCommands extends BoardCommands {
   public async setChlorAsync(obj: any): Promise<ChlorinatorState> {
     try {
       let id = parseInt(obj.id, 10);
-      if (isNaN(id) || id <= 0) id = 1;
-      let cchlor = sys.chlorinators.getItemById(id, true);
-      await ncp.chlorinators.setChlorinatorAsync(cchlor, obj);
-      let schlor = state.chlorinators.getItemById(cchlor.id, true);
+      let chlor: Chlorinator;
+      let master = parseInt(obj.master, 10);
+      let portId = typeof obj.portId !== 'undefined' ? parseInt(obj.portId, 10) : 0;
+      if (isNaN(master)) master = 1; // NCP to control.
+      if (isNaN(id) || id <= 0) {
+        let body = sys.board.bodies.mapBodyAssociation(typeof obj.body !== 'undefined' ? parseInt(obj.body, 10) : 0);
+        if (typeof body === 'undefined') {
+          if (sys.equipment.shared) body = 32;
+          else if (!sys.equipment.dual) body = 1;
+          else return Promise.reject(new InvalidEquipmentDataError(`Chlorinator body association is not valid: ${body}`, 'chlorinator', body));
+        }
+        let poolSetpoint = typeof obj.poolSetpoint !== 'undefined' ? parseInt(obj.poolSetpoint, 10) : 50;
+        let spaSetpoint = typeof obj.spaSetpoint !== 'undefined' ? parseInt(obj.spaSetpoint, 10) : 10;
+        if (isNaN(poolSetpoint) || poolSetpoint > 100 || poolSetpoint < 0) return Promise.reject(new InvalidEquipmentDataError(`Chlorinator poolSetpoint is out of range: ${chlor.poolSetpoint}`, 'chlorinator', poolSetpoint));
+        if (isNaN(spaSetpoint) || spaSetpoint > 100 || spaSetpoint < 0) return Promise.reject(new InvalidEquipmentDataError(`Chlorinator spaSetpoint is out of range: ${chlor.poolSetpoint}`, 'chlorinator', spaSetpoint));
+        if (master === 2) {
+          // We can add as many external chlorinators as we want.
+          id = sys.chlorinators.count(elem => elem.master === 2) + 50;
+          chlor = sys.chlorinators.getItemById(id, true, { id: id, master: parseInt(obj.master, 10) });
+        }
+        else {
+          if (portId === 0 && sys.controllerType !== ControllerType.Nixie) return Promise.reject(new InvalidEquipmentDataError(`You may not install a chlorinator on an ${sys.controllerType} system that is assigned to the Primary Port`, 'Chlorinator', portId));
+          if (sys.chlorinators.count(elem => elem.portId === portId && elem.master !== 2) > 0) return Promise.reject(new InvalidEquipmentDataError(`There is already a chlorinator using port #${portId}.  Only one chlorinator may be installed per port.`, 'Chlorinator', portId));
+          // We are adding so we need to see if there is another chlorinator that is not external.
+          if (sys.chlorinators.count(elem => elem.master !== 2) > sys.equipment.maxChlorinators) return Promise.reject(new InvalidEquipmentDataError(`The max number of chlorinators has been exceeded you may only add ${sys.equipment.maxChlorinators}`, 'Chlorinator', sys.equipment.maxChlorinators));
+          id = sys.chlorinators.getMaxId(false, 0) + 1;
+          chlor = sys.chlorinators.getItemById(id, true, { id: id, master: 1 });
+        }
+      }
+      else chlor = sys.chlorinators.getItemById(id, false);
+
+      if (chlor.master === 1)
+        await ncp.chlorinators.setChlorinatorAsync(chlor, obj);
+      else {
+        let body = sys.board.bodies.mapBodyAssociation(typeof obj.body !== 'undefined' ? parseInt(obj.body, 10) : chlor.body);
+        if (typeof body === 'undefined') {
+          if (sys.equipment.shared) body = 32;
+          else if (!sys.equipment.dual) body = 1;
+          else return Promise.reject(new InvalidEquipmentDataError(`Chlorinator body association is not valid: ${body}`, 'chlorinator', body));
+        }
+        let poolSetpoint = typeof obj.poolSetpoint !== 'undefined' ? parseInt(obj.poolSetpoint, 10) : isNaN(chlor.poolSetpoint) ? 50 : chlor.poolSetpoint;
+        let spaSetpoint = typeof obj.spaSetpoint !== 'undefined' ? parseInt(obj.spaSetpoint, 10) : isNaN(chlor.spaSetpoint) ? 10 : chlor.spaSetpoint;
+        if (poolSetpoint > 100 || poolSetpoint < 0) return Promise.reject(new InvalidEquipmentDataError(`Chlorinator poolSetpoint is out of range: ${chlor.poolSetpoint}`, 'chlorinator', chlor.poolSetpoint));
+        if (spaSetpoint > 100 || spaSetpoint < 0) return Promise.reject(new InvalidEquipmentDataError(`Chlorinator spaSetpoint is out of range: ${chlor.poolSetpoint}`, 'chlorinator', chlor.spaSetpoint));
+
+        chlor = sys.chlorinators.getItemById(id, true);
+        let schlor = state.chlorinators.getItemById(chlor.id, true);
+        chlor.name = schlor.name = obj.name || chlor.name || 'Chlorinator --' + id;
+        chlor.superChlorHours = schlor.superChlorHours = typeof obj.superChlorHours !== 'undefined' ? parseInt(obj.superChlorHours, 10) : isNaN(chlor.superChlorHours) ? 8 : chlor.superChlorHours;
+        chlor.superChlor = schlor.superChlor = typeof obj.superChlorinate !== 'undefined' ? utils.makeBool(obj.superChlorinate) : chlor.superChlor;
+        chlor.superChlor = schlor.superChlor = typeof obj.superChlor !== 'undefined' ? utils.makeBool(obj.superChlor) : chlor.superChlor;
+
+        chlor.isDosing = typeof obj.isDosing !== 'undefined' ? utils.makeBool(obj.isDosing) : chlor.isDosing || false;
+        chlor.disabled = typeof obj.disabled !== 'undefined' ? utils.makeBool(obj.disabled) : chlor.disabled || false;
+        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;
+        schlor.poolSetpoint = chlor.poolSetpoint = poolSetpoint;
+        schlor.spaSetpoint = chlor.spaSetpoint = spaSetpoint;
+        chlor.ignoreSaltReading = typeof obj.ignoreSaltReading !== 'undefined' ? utils.makeBool(obj.ignoreSaltReading) : utils.makeBool(chlor.ignoreSaltReading);
+        schlor.isActive = chlor.isActive = typeof obj.isActive !== 'undefined' ? utils.makeBool(obj.isActive) : typeof chlor.isActive !== 'undefined' ? utils.makeBool(chlor.isActive) : true;
+        chlor.master = 2;
+        schlor.currentOutput = typeof obj.currentOutput !== 'undefined' ? parseInt(obj.currentOutput, 10) : schlor.currentOutput;
+        schlor.lastComm = typeof obj.lastComm !== 'undefined' ? obj.lastComm : schlor.lastComm || Date.now();
+        schlor.status = typeof obj.status !== 'undefined' ? sys.board.valueMaps.chlorinatorStatus.encode(obj.status) : sys.board.valueMaps.chlorinatorStatus.encode(schlor.status || 0);
+        if (typeof obj.superChlorRemaining !== 'undefined') schlor.superChlorRemaining = parseInt(obj.superChlorRemaining, 10);
+        schlor.targetOutput = typeof obj.targetOutput !== 'undefined' ? parseInt(obj.targetOutput, 10) : schlor.targetOutput;
+        schlor.saltLevel = typeof obj.saltLevel !== 'undefined' ? parseInt(obj.saltLevel, 10) : schlor.saltLevel;
+      }
       state.emitEquipmentChanges();
-      return Promise.resolve(schlor);
+      return Promise.resolve(state.chlorinators.getItemById(id));
     }
     catch (err) {
       logger.error(`Error setting chlorinator: ${err}`)
@@ -3043,6 +3537,7 @@ export class ScheduleCommands extends BoardCommands {
     let schedDays = sys.board.schedules.transformDays(typeof data.scheduleDays !== 'undefined' ? data.scheduleDays : sched.scheduleDays);
     let changeHeatSetpoint = typeof (data.changeHeatSetpoint !== 'undefined') ? data.changeHeatSetpoint : false;
     let display = typeof data.display !== 'undefined' ? data.display : sched.display || 0;
+    let disabled = typeof data.disabled !== 'undefined' ? utils.makeBool(data.disabled) : sched.disabled;
 
     // Ensure all the defaults.
     if (isNaN(startDate.getTime())) startDate = new Date();
@@ -3079,12 +3574,16 @@ export class ScheduleCommands extends BoardCommands {
     sched.startYear = startDate.getFullYear();
     sched.startMonth = startDate.getMonth() + 1;
     sched.startDay = startDate.getDate();
-    sched.isActive = sched.startTime !== 0;
-
+    ssched.isActive = sched.isActive = true;
+    ssched.disabled = sched.disabled = disabled;
     ssched.display = sched.display = display;
     if (typeof sched.startDate === 'undefined')
       sched.master = 1;
     await ncp.schedules.setScheduleAsync(sched, data);
+    // update end time in case sched is changed while circuit is on
+    let cstate = state.circuits.getInterfaceById(sched.circuit);
+    sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(sched.circuit), cstate, cstate.isOn, true);
+    cstate.emitEquipmentChange();
     ssched.emitEquipmentChange();
     return sched;
   }
@@ -3113,7 +3612,8 @@ export class ScheduleCommands extends BoardCommands {
         let schedIsOn: boolean;
         let ssched = state.schedules.getItemByIndex(i);
         let scirc = state.circuits.getInterfaceById(ssched.circuit);
-        if (scirc.isOn &&
+        let mOP = sys.board.schedules.manualPriorityActive(ssched);  //sys.board.schedules.manualPriorityActiveByProxy(scirc.id);
+        if (scirc.isOn && !mOP &&
           (ssched.scheduleDays & dayVal) > 0 &&
           ts >= ssched.startTime && ts <= ssched.endTime) schedIsOn = true
         else schedIsOn = false;
@@ -3173,484 +3673,684 @@ export class ScheduleCommands extends BoardCommands {
     }
     return nearestStartTime;
   }
-}
-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];
-                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, 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 manualPriorityForThisCircuit(circuit: number): boolean {
+    // This fn will test if this circuit/light group has any circuit group circuits that have manual priority active
+    let grp: ICircuitGroup;
+    let cgc: ICircuitGroupCircuit[] = [];
+    if (sys.board.equipmentIds.circuitGroups.isInRange(circuit) || sys.board.equipmentIds.features.isInRange(circuit))
+      grp = sys.circuitGroups.getInterfaceById(circuit);
+    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);
+      if (c.manualPriorityActive) return true;
     }
+    return false;
+  }
+  public manualPriorityActive(schedule: ScheduleState): boolean {
+    // This method will look at all other schedules.  If any of them have been resumed, 
+    // and manualPriority (global setting) is on, and this schedule would otherwise impact
+    // that circuit, then we declared this schedule as being delayed due to manual override
+    // priority (mOP).
+    // We only need to check this if shouldBeOn = true; if that's false, exit.
+    // Rules:
+    // 1. If the circuit id for this schedule is in manual priority, then true
+    // 2. If the other schedule will turn on a body in a shared body, and it will affect
+    //    this circuit id, return true
+    // 3. If this is a circuit/light group schedule, check to see if any member circuit/lights have mOP active
+    // 4. If this is a circuit/light/feature, is there another group that has this same id with mOP active
 
-    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++;
-            }
-        }
-        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;
+    if (schedule.isActive === false) return false;
+    if (schedule.disabled) return false;
+    if (!sys.general.options.manualPriority) return false;
+
+    let currGrp: ICircuitGroup;
+    let currSchedGrpCircs = [];
+    if (sys.board.equipmentIds.circuitGroups.isInRange(schedule.circuit) || sys.board.equipmentIds.features.isInRange(schedule.circuit))
+    currGrp = sys.circuitGroups.getInterfaceById(schedule.circuit);
+    if (currGrp && currGrp.isActive) currSchedGrpCircs = currGrp.circuits.toArray();
+    let circuitGrps: ICircuitGroup[] = sys.circuitGroups.toArray();
+    let lightGrps: ICircuitGroup[] = sys.lightGroups.toArray();
+    let currManualPriorityByProxy = sys.board.schedules.manualPriorityForThisCircuit(schedule.circuit);
+    // check this circuit
+    if (state.circuits.getInterfaceById(schedule.circuit).manualPriorityActive) return true;
+    // check this group, if present
+    if (currManualPriorityByProxy) return true;
+
+    let schedules: ScheduleState[] = state.schedules.get(true);
+    for (let i = 0; i < schedules.length; i++) {
+      let sched = schedules[i];
+      // if the id of another circuit is the same as this, we should delay
+      let schedCState = state.circuits.getInterfaceById(sched.circuit);
+      if (schedule.circuit === schedCState.id && schedCState.manualPriorityActive) return true;
+      // if OCP includes a shared body, and this schedule affects the shared body, 
+      // and this body is still on, we should delay
+      if (sys.equipment.shared && schedCState.dataName === 'circuit') {
+        let otherBody = sys.bodies.find(elem => elem.circuit === sched.circuit);
+        // let otherBodyIsOn = state.circuits.getInterfaceById(sched.circuit).isOn;
+        let thisBody = sys.bodies.find(elem => elem.circuit === schedule.circuit);
+        if (typeof otherBody !== 'undefined' && typeof thisBody !== 'undefined' && schedCState.manualPriorityActive) return true;
+      }
+      // if other circuit/schedule groups have this circ id, and it's mOP, return true
+      if (schedCState.dataName === 'circuitGroup') {
+        for (let i = 0; i < circuitGrps.length; i++) {
+          let grp: ICircuitGroup = circuitGrps[i];
+          let sgrp: ICircuitGroupState = state.circuitGroups.getInterfaceById(grp.id);
+          let circuits = grp.circuits.toArray();
+          if (grp.isActive) {
+            let manualPriorityByProxy = sys.board.schedules.manualPriorityForThisCircuit(grp.id);
+            for (let j = 0; j < circuits.length; j++) {
+              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;
+              // 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++) {
+                let currCircGrpCirc = state.circuits.getInterfaceById(currSchedGrpCircs[k].circuit);
+                // if either circuit in either group has mOP then delay
+                if (currManualPriorityByProxy || manualPriorityByProxy) {
+                  if (currCircGrpCirc.id === schedCState.id) return true;
+                  if (currCircGrpCirc.id === scgc.id) return true;
                 }
+              }
             }
+          }
         }
-    }
-    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;
+      }
+      if (schedCState.dataName === 'lightGroup') {
+        for (let i = 0; i < lightGrps.length; i++) {
+          let grp: ICircuitGroup = lightGrps[i];
+          let sgrp: ICircuitGroupState = state.circuitGroups.getInterfaceById(grp.id);
+          let circuits = grp.circuits.toArray();
+          if (grp.isActive) {
+            let manualPriorityByProxy = sys.board.schedules.manualPriorityForThisCircuit(grp.id);
+            for (let j = 0; j < circuits.length; j++) {
+              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;
+              // 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++) {
+                let currCircGrpCirc = state.circuits.getInterfaceById(currSchedGrpCircs[k].circuit);
+                // if either circuit in either group has mOP then delay
+                if (currManualPriorityByProxy || manualPriorityByProxy) {
+                  if (currCircGrpCirc.id === schedCState.id) return true;
+                  if (currCircGrpCirc.id === scgc.id) return true;
                 }
+              }
             }
+          }
         }
+      }
     }
-    public setHeater(heater: Heater, obj?: any) {
-        if (typeof obj !== undefined) {
-            for (var s in obj)
-                heater[s] = obj[s];
-        }
-    }
-    public async setHeaterAsync(obj: any): Promise<Heater> {
+    // if we make it this far, nothing is impacting us
+    return 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 {
-            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}`)); }
-    }
-    public async deleteHeaterAsync(obj: any): Promise<Heater> {
+          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 {
-            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}`) }
+          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; }
+  }
+  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);
+      }
     }
-    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();
+    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 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');
+    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;
         }
-        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 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('water4');
-            sys.equipment.tempSensors.removeItemById('solar4');
+      }
+    }
+  }
+  public setHeater(heater: Heater, obj?: any) {
+    if (typeof obj !== undefined) {
+      for (var s in obj)
+        heater[s] = obj[s];
+    }
+  }
+  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];
         }
+      }
+      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;
     }
-    // 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);
+    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';
+    }
+    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');
+    }
+
+  }
+  // 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;
+      }
+    }
+  }
+  // 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;
+                      }
                     }
-                    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);
+                  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;
+                          }
+                        }
+                      }
                     }
-                    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);
+                  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;
+                      }
                     }
-                    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);
+                  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;
+                      }
                     }
-                    else sensor.isActive = false;
-                    break;
-                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;
-                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.`);
-                    for (let j = 0; j < heaters.length; j++) {
-                        let heater: Heater = heaters[j];
-                        if (heater.isActive === false) continue;
-                        let isOn = false;
-                        let isCooling = false;
-                        let sensorTemp = state.temps.waterSensor1;
-                        if (body.id === 4) sensorTemp = state.temps.waterSensor4;
-                        if (body.id === 3) sensorTemp = state.temps.waterSensor3;
-                        if (body.id === 2 && !sys.equipment.shared) sensorTemp = state.temps.waterSensor2;
-
-                        // Determine whether the heater can be used on this body.
-                        let isAssociated = false;
-                        let b = sys.board.valueMaps.bodies.transform(heater.body);
-                        switch (b.name) {
-                            case 'body1':
-                            case 'pool':
-                                if (body.id === 1) isAssociated = true;
-                                break;
-                            case 'body2':
-                            case 'spa':
-                                if (body.id === 2) isAssociated = true;
-                                break;
-                            case 'poolspa':
-                                if (body.id === 1 || body.id === 2) isAssociated = true;
-                                break;
-                            case 'body3':
-                                if (body.id === 3) isAssociated = true;
-                                break;
-                            case 'body4':
-                                if (body.id === 4) isAssociated = true;
-                                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;
                         }
-                        // logger.silly(`Heater ${heater.name} is ${isAssociated === true ? '' : 'not '}associated with ${body.name}`);
-                        if (isAssociated) {
-                            let htype = sys.board.valueMaps.heaterTypes.transform(heater.type);
-                            let status = sys.board.valueMaps.heatStatus.transform(body.heatStatus);
-                            let hstate = state.heaters.getItemById(heater.id, true);
-                            if (heater.master === 1) {
-                                // We need to do our own calculation as to whether it is on.  This is for Nixie heaters.
-                                let mode = sys.board.valueMaps.heatModes.getName(body.heatMode);
-                                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':
-                                        // We need to determine whether we are going to use the air temp or the solar temp
-                                        // for the sensor.
-                                        let deltaTemp = Math.max(state.temps.air, state.temps.solar || 0);
-                                        if (mode === 'ultratemp' || mode === 'ultratemppref') {
-                                            if (body.temp < cfgBody.heatSetpoint &&
-                                                deltaTemp > body.temp + heater.differentialTemp || 0) {
-                                                isOn = true;
-                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpheat');
-                                                isHeating = true;
-                                                isCooling = false;
-                                            }
-                                            else if (body.temp > cfgBody.coolSetpoint && heater.coolingEnabled) {
-                                                isOn = true;
-                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpcool');
-                                                isHeating = true;
-                                                isCooling = true;
-                                            }
-                                        }
-                                        break;
-                                    case 'mastertemp':
-                                        if (mode === 'mtheater') {
-                                            if (body.temp < cfgBody.setPoint) {
-                                                isOn = true;
-                                                body.heatStatus = sys.board.valueMaps.heaterTypes.getValue('mtheater');
-                                                isHeating = true;
-                                            }
-                                        }
-                                        break;
-                                    case 'maxetherm':
-                                    case 'gas':
-                                        if (mode === 'heater') {
-                                            if (body.temp < cfgBody.setPoint) {
-                                                isOn = true;
-                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
-                                                isHeating = true;
-                                            }
-                                        }
-                                        else if (mode === 'solarpref' || mode === 'heatpumppref') {
-                                            // If solar should be running gas heater should be off.
-                                            if (body.temp < cfgBody.setPoint &&
-                                                state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) isOn = false;
-                                            else if (body.temp < cfgBody.setPoint) {
-                                                isOn = true;
-                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
-                                                isHeating = true;
-                                            }
-                                        }
-                                        break;
-                                    case 'heatpump':
-                                        if (mode === 'heatpump' || mode === 'heatpumppref') {
-                                            if (body.temp < cfgBody.setPoint &&
-                                                state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
-                                                isOn = true;
-                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
-                                                isHeating = true;
-                                            }
-                                        }
-                                        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 (status === 'mtheater') isHeating = isOn = true;
-                                        break;
-                                    case 'maxetherm':
-                                    case 'gas':
-                                        if (status === 'heater') isHeating = isOn = true;
-                                        break;
-                                    case 'hybrid':
-                                    case 'ultratemp':
-                                    case 'heatpump':
-                                        if (mode === 'ultratemp' || mode === 'ultratemppref' || mode === 'heatpump' || mode === 'heatpumppref') {
-                                            if (status === 'heater') isHeating = isOn = true;
-                                            else if (status === 'cooling') isCooling = isOn = true;
-                                        }
-                                        break;
-                                    case 'solar':
-                                        if (mode === 'solar' || mode === 'solarpref') {
-                                            if (status === 'solar') isHeating = isOn = true;
-                                            else if (status === 'cooling') isCooling = isOn = true;
-                                        }
-                                        break;
-                                }
-                            }
-                            if (isOn === true && typeof hon.find(elem => elem === heater.id) === 'undefined') {
-                                hon.push(heater.id);
-                                if (heater.master === 1 && isOn) (async () => {
-                                    try {
-                                        await ncp.heaters.setHeaterStateAsync(hstate, isOn, isCooling);
-                                    } catch (err) { logger.error(err.message); }
-                                })();
-                                else hstate.isOn = isOn;
-                            }
+                      }
+                      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;
                 }
-                // When the controller is a virtual one we need to control the heat status ourselves.
-                if (!isHeating && (sys.controllerType === ControllerType.Nixie)) body.heatStatus = 0;
+                logger.debug(`Heater Type: ${htype.name} Mode:${mode} Temp: ${body.temp} Setpoint: ${cfgBody.setPoint} Status: ${body.heatStatus}`);
+              }
             }
-            // 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);
-                        } catch (err) { logger.error(err.message); }
-                    })();
-                    else hstate.isOn = false;
-                }
+            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;
+              }
             }
-        } catch (err) { logger.error(`Error synchronizing heater states`); }
-    }
+            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;
+              }
+            }
+            // 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}`); }
+  }
 }
 export class ValveCommands extends BoardCommands {
   public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
@@ -3750,6 +4450,22 @@ export class ValveCommands extends BoardCommands {
   }
   public async syncValveStates() {
     try {
+      // Check to see if there is a drain circuit or feature on.  If it is on then the intake will be diverted no mater what.
+      let drain = sys.equipment.shared ? typeof state.circuits.get().find(elem => typeof elem.type !== 'undefined' && elem.type.name === 'spadrain' && elem.isOn === true) !== 'undefined' ||
+        typeof state.features.get().find(elem => typeof elem.type !== 'undefined' && elem.type.name === 'spadrain' && elem.isOn === true) !== 'undefined' : false;
+      // Check to see if there is a spillway circuit or feature on.  If it is on then the return will be diverted no mater what.
+      let spillway = sys.equipment.shared ? typeof state.circuits.get().find(elem => typeof elem.type !== 'undefined' && elem.type.name === 'spillway' && elem.isOn === true) !== 'undefined' ||
+        typeof state.features.get().find(elem => typeof elem.type !== 'undefined' && elem.type.name === 'spillway' && elem.isOn === true) !== 'undefined' : false;
+      let spa = sys.equipment.shared ? state.circuits.getItemById(1).isOn : false;
+      let pool = sys.equipment.shared ? state.circuits.getItemById(6).isOn : false;
+      // Set the valve mode.
+      if (!sys.equipment.shared) state.valveMode = sys.board.valueMaps.valveModes.getValue('off');
+      else if (drain) state.valveMode = sys.board.valueMaps.valveModes.getValue('spadrain');
+      else if (spillway) state.valveMode = sys.board.valueMaps.valveModes.getValue('spillway');
+      else if (spa) state.valveMode = sys.board.valueMaps.valveModes.getValue('spa');
+      else if (pool) state.valveMode = sys.board.valueMaps.valveModes.getValue('pool');
+      else state.valveMode = sys.board.valueMaps.valveModes.getValue('off');
+
       for (let i = 0; i < sys.valves.length; i++) {
         // Run through all the valves to see whether they should be triggered or not.
         let valve = sys.valves.getItemByIndex(i);
@@ -3757,13 +4473,21 @@ export class ValveCommands extends BoardCommands {
           let vstate = state.valves.getItemById(valve.id, true);
           let isDiverted = vstate.isDiverted;
           if (typeof valve.circuit !== 'undefined' && valve.circuit > 0) {
-            if (sys.equipment.shared && valve.isIntake === true)
-              isDiverted = utils.makeBool(state.circuits.getItemById(1).isOn); // If the spa is on then the intake is diverted.
+            if (sys.equipment.shared && valve.isIntake === true) {
+              // Valve Diverted Positions
+              // Spa: Y
+              // Drain: Y
+              // Spillway: N
+              // Pool: N
+              isDiverted = utils.makeBool(spa || drain); // If the spa is on then the intake is diverted.
+            }
             else if (sys.equipment.shared && valve.isReturn === true) {
-              // Check to see if there is a spillway circuit or feature on.  If it is on then the return will be diverted no mater what.
-              let spillway = typeof state.circuits.get().find(elem => typeof elem.type !== 'undefined' && elem.type.name === 'spillway' && elem.isOn === true) !== 'undefined' ||
-                typeof state.features.get().find(elem => typeof elem.type !== 'undefined' && elem.type.name === 'spillway' && elem.isOn === true) !== 'undefined';
-              isDiverted = utils.makeBool(spillway || state.circuits.getItemById(1).isOn);
+              // Valve Diverted Positions
+              // Spa: Y
+              // Drain: N
+              // Spillway: Y
+              // Pool: N
+              isDiverted = utils.makeBool((spa || spillway) && !drain);
             }
             else {
               let circ = state.circuits.getInterfaceById(valve.circuit);
@@ -3779,6 +4503,35 @@ export class ValveCommands extends BoardCommands {
       }
     } catch (err) { logger.error(`syncValveStates: Error synchronizing valves ${err.message}`); }
   }
+  public getBodyValveCircuitIds(isOn?: boolean): number[] {
+    let arrIds: number[] = [];
+    if (sys.equipment.shared !== true) return arrIds;
+
+    {
+      let dtype = sys.board.valueMaps.circuitFunctions.getValue('spadrain');
+      let stype = sys.board.valueMaps.circuitFunctions.getValue('spillway');
+      let ptype = sys.board.valueMaps.circuitFunctions.getValue('pool');
+      let sptype = sys.board.valueMaps.circuitFunctions.getValue('spa');
+      for (let i = 0; i < state.circuits.length; i++) {
+        let cstate = state.circuits.getItemByIndex(i);
+        if (typeof isOn === 'undefined' || cstate.isOn === isOn) {
+          if (cstate.id === 1 || cstate.id === 6) arrIds.push(cstate.id);
+          if (cstate.type === dtype || cstate.type === stype || cstate.type === ptype || cstate.type === sptype) arrIds.push(cstate.id);
+        }
+      }
+    }
+    {
+      let dtype = sys.board.valueMaps.featureFunctions.getValue('spadrain');
+      let stype = sys.board.valueMaps.featureFunctions.getValue('spillway');
+      for (let i = 0; i < state.features.length; i++) {
+        let fstate = state.features.getItemByIndex(i);
+        if (typeof isOn === 'undefined' || fstate.isOn === isOn) {
+          if (fstate.type === dtype || fstate.type === stype) arrIds.push(fstate.id);
+        }
+      }
+    }
+    return arrIds;
+  }
 }
 export class ChemControllerCommands extends BoardCommands {
   public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
@@ -3910,7 +4663,7 @@ export class ChemControllerCommands extends BoardCommands {
   protected async setIntelliChemAsync(data: any): Promise<ChemController> {
     try {
       let chem = sys.chemControllers.getItemById(data.id);
-      return await ncp.chemControllers.setControllerAsync(chem, data);
+      return chem.master === 1 ? await ncp.chemControllers.setControllerAsync(chem, data) : chem;
     } catch (err) { return Promise.reject(err); }
   }
   public findChemController(data: any) {
@@ -3935,11 +4688,11 @@ export class ChemControllerCommands extends BoardCommands {
       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));
-      let address = parseInt(data.address, 10);
+      let address = typeof data.address !== 'undefined' ? parseInt(data.address, 10) : isAdd ? undefined : chem.address;
       let t = sys.board.valueMaps.chemControllerTypes.transform(type);
       if (t.hasAddress) {
         // First lets make sure the user supplied an address.
-        if (isNaN(address)) return Promise.reject(new InvalidEquipmentDataError(`${type.desc} chem controllers require a valid address`, 'chemController', data.address));
+        if (isNaN(address)) return Promise.reject(new InvalidEquipmentDataError(`${t.desc} chem controllers require a valid address`, 'chemController', data.address));
         if (typeof sys.chemControllers.find(x => x.address === address && x.id !== (isAdd ? -1 : chem.id)) !== 'undefined') return Promise.reject(new InvalidEquipmentDataError(`${type.desc} chem controller addresses must be unique`, 'chemController', data.address));
       }
       if (isAdd) {
@@ -3952,8 +4705,10 @@ export class ChemControllerCommands extends BoardCommands {
       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.
-      if (type.name === 'intellichem')
-        await this.setIntelliChemAsync(data);
+      if (t.name === 'intellichem') {
+        logger.info(`${chem.name} - ${chem.id} routing IntelliChem to OCP`);
+        await sys.board.chemControllers.setIntelliChemAsync(data);
+      }
       else
         await ncp.chemControllers.setControllerAsync(chem, data);
       return Promise.resolve(chem);
@@ -3966,7 +4721,8 @@ export class ChemControllerCommands extends BoardCommands {
     let chem = sys.board.chemControllers.findChemController(data);
     if (typeof chem === 'undefined') return Promise.reject(new InvalidEquipmentIdError(`A valid chem controller could not be found for id:${data.id} or address ${data.address}`, data.id || data.address, 'chemController'));
     data.id = chem.id;
-    if (chem.master !== 0) await ncp.chemControllers.setControllerAsync(chem, data);
+    logger.info(`Setting ${chem.name} data ${chem.master}`);
+    if (chem.master === 1) await ncp.chemControllers.setControllerAsync(chem, data);
     else await sys.board.chemControllers.setChemControllerAsync(data);
     let schem = state.chemControllers.getItemById(chem.id, true);
     return Promise.resolve(schem);
@@ -4079,7 +4835,7 @@ export class FilterCommands extends BoardCommands {
               if (f.type !== 0) fon = true;
               // Check to see if this feature is used on a valve.  This will make it
               // not include this pressure either.  We do not care whether the valve is diverted or not.
-              if (typeof sys.valves.find(elem => elem.circuitId === f.id) !== 'undefined')
+              if (typeof sys.valves.find(elem => elem.circuit === f.id) !== 'undefined')
                 fon = true;
               else {
                 // Finally if the feature happens to be used on a pump then we don't want it either.