nodejs-poolcontroller 7.3.0 → 7.6.0

package/controller/boards/SystemBoard.ts

@@ -19,9 +19,11 @@ 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 { EquipmentNotFoundError, InvalidEquipmentDataError, InvalidEquipmentIdError, BoardProcessError } 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';
+
 
 export class byteValueMap extends Map<number, any> {
   public transform(byte: number, ext?: number) { return extend(true, { val: byte || 0 }, this.get(byte) || this.get(0)); }
@@ -115,362 +117,404 @@ export class EquipmentIds {
   public invalidIds: InvalidEquipmentIdArray = new InvalidEquipmentIdArray([]);
 }
 export class byteValueMaps {
-  constructor() {
-    this.pumpStatus.transform = function (byte) {
-      // if (byte === 0) return this.get(0);
-      if (byte === 0) return extend(true, {}, this.get(0), { val: byte });
-      for (let b = 16; b > 0; b--) {
-        let bit = (1 << (b - 1));
-        if ((byte & bit) > 0) {
-          let v = this.get(b);
-          if (typeof v !== 'undefined') {
-            return extend(true, {}, v, { val: byte });
-          }
-        }
-      }
-      return { val: byte, name: 'error' + byte, desc: 'Unspecified Error ' + byte };
-    };
-    this.chlorinatorStatus.transform = function (byte) {
-      if (byte === 128) return { val: 128, name: 'commlost', desc: 'Communication Lost' };
-      else if (byte === 0) return { val: 0, name: 'ok', desc: 'Ok' };
-      for (let b = 8; b > 0; b--) {
-        let bit = (1 << (b - 1));
-        if ((byte & bit) > 0) {
-          let v = this.get(b);
-          if (typeof v !== "undefined") {
-            return extend(true, {}, v, { val: byte & 0x00FF });
-          }
-        }
-      }
-      return { val: byte, name: 'unknown' + byte, desc: 'Unknown status ' + byte };
-    };
-    this.scheduleTypes.transform = function (byte) {
-      return (byte & 128) > 0 ? extend(true, { val: 128 }, this.get(128)) : extend(true, { val: 0 }, this.get(0));
-    };
-    this.scheduleDays.transform = function (byte) {
-      let days = [];
-      let b = byte & 0x007F;
-      for (let bit = 7; bit >= 0; bit--) {
-        if ((byte & (1 << (bit - 1))) > 0) days.push(extend(true, {}, this.get(bit)));
-      }
-      return { val: b, days: days };
-    };
-    this.scheduleDays.toArray = function () {
-      let arrKeys = Array.from(this.keys());
-      let arr = [];
-      for (let i = 0; i < arrKeys.length; i++) arr.push(extend(true, { val: arrKeys[i] }, this.get(arrKeys[i])));
-      return arr;
-    };
-    this.virtualCircuits.transform = function (byte) {
-      return extend(true, {}, { val: byte, name: 'Unknown ' + byte }, this.get(byte), { val: byte });
-    };
-    this.tempUnits.transform = function (byte) { return extend(true, {}, { val: byte & 0x04 }, this.get(byte & 0x04)); };
-    this.panelModes.transform = function (byte) { return extend(true, { val: byte & 0x83 }, this.get(byte & 0x83)); };
-    this.controllerStatus.transform = function (byte: number, percent?: number) {
-      let v = extend(true, {}, this.get(byte) || this.get(0));
-      if (typeof percent !== 'undefined') v.percent = percent;
-      return v;
-    };
-    this.lightThemes.transform = function (byte) { return typeof byte === 'undefined' ? this.get(255) : extend(true, { val: byte }, this.get(byte) || this.get(255)); };
-    this.timeZones.findItem = function (val: string | number | { val: any, name: string }) {
-      if (typeof val === null || typeof val === 'undefined') return;
-      else if (typeof val === 'number') {
-        if (val <= 12) {  // We are looking for timezones based upon the utcOffset.
-          let arr = this.toArray();
-          let tz = arr.find(elem => elem.utcOffset === val);
-          return typeof tz !== 'undefined' ? this.transform(tz.val) : undefined;
-        }
-        return this.transform(val);
-      }
-      else if (typeof val === 'string') {
-        let v = parseInt(val, 10);
-        if (!isNaN(v)) {
-          if (v <= 12) {
-            let arr = this.toArray();
-            let tz = arr.find(elem => elem.utcOffset === val);
-            return typeof tz !== 'undefined' ? this.transform(tz.val) : undefined;
-          }
-          return this.transform(v);
-        }
-        else {
-          let arr = this.toArray();
-          let tz = arr.find(elem => elem.abbrev === val || elem.name === val);
-          return typeof tz !== 'undefined' ? this.transform(tz.val) : undefined;
+    constructor() {
+        this.pumpStatus.transform = function (byte) {
+            // if (byte === 0) return this.get(0);
+            if (byte === 0) return extend(true, {}, this.get(0), { val: byte });
+            for (let b = 16; b > 0; b--) {
+                let bit = (1 << (b - 1));
+                if ((byte & bit) > 0) {
+                    let v = this.get(b);
+                    if (typeof v !== 'undefined') {
+                        return extend(true, {}, v, { val: byte });
+                    }
+                }
+            }
+            return { val: byte, name: 'error' + byte, desc: 'Unspecified Error ' + byte };
+        };
+        this.chlorinatorStatus.transform = function (byte) {
+            if (byte === 128) return { val: 128, name: 'commlost', desc: 'Communication Lost' };
+            else if (byte === 0) return { val: 0, name: 'ok', desc: 'Ok' };
+            for (let b = 8; b > 0; b--) {
+                let bit = (1 << (b - 1));
+                if ((byte & bit) > 0) {
+                    let v = this.get(b);
+                    if (typeof v !== "undefined") {
+                        return extend(true, {}, v, { val: byte & 0x00FF });
+                    }
+                }
+            }
+            return { val: byte, name: 'unknown' + byte, desc: 'Unknown status ' + byte };
+        };
+        this.scheduleTypes.transform = function (byte) {
+            return (byte & 128) > 0 ? extend(true, { val: 128 }, this.get(128)) : extend(true, { val: 0 }, this.get(0));
+        };
+        this.scheduleDays.transform = function (byte) {
+            let days = [];
+            let b = byte & 0x007F;
+            for (let bit = 7; bit >= 0; bit--) {
+                if ((byte & (1 << (bit - 1))) > 0) days.push(extend(true, {}, this.get(bit)));
+            }
+            return { val: b, days: days };
+        };
+        this.scheduleDays.toArray = function () {
+            let arrKeys = Array.from(this.keys());
+            let arr = [];
+            for (let i = 0; i < arrKeys.length; i++) arr.push(extend(true, { val: arrKeys[i] }, this.get(arrKeys[i])));
+            return arr;
+        };
+        this.virtualCircuits.transform = function (byte) {
+            return extend(true, {}, { val: byte, name: 'Unknown ' + byte }, this.get(byte), { val: byte });
+        };
+        this.tempUnits.transform = function (byte) { return extend(true, {}, { val: byte & 0x04 }, this.get(byte & 0x04)); };
+        this.panelModes.transform = function (byte) { return extend(true, { val: byte & 0x83 }, this.get(byte & 0x83)); };
+        this.controllerStatus.transform = function (byte: number, percent?: number) {
+            let v = extend(true, {}, this.get(byte) || this.get(0));
+            if (typeof percent !== 'undefined') v.percent = percent;
+            return v;
+        };
+        this.lightThemes.transform = function (byte) { return typeof byte === 'undefined' ? this.get(255) : extend(true, { val: byte }, this.get(byte) || this.get(255)); };
+        this.timeZones.findItem = function (val: string | number | { val: any, name: string }) {
+            if (typeof val === null || typeof val === 'undefined') return;
+            else if (typeof val === 'number') {
+                if (val <= 12) {  // We are looking for timezones based upon the utcOffset.
+                    let arr = this.toArray();
+                    let tz = arr.find(elem => elem.utcOffset === val);
+                    return typeof tz !== 'undefined' ? this.transform(tz.val) : undefined;
+                }
+                return this.transform(val);
+            }
+            else if (typeof val === 'string') {
+                let v = parseInt(val, 10);
+                if (!isNaN(v)) {
+                    if (v <= 12) {
+                        let arr = this.toArray();
+                        let tz = arr.find(elem => elem.utcOffset === val);
+                        return typeof tz !== 'undefined' ? this.transform(tz.val) : undefined;
+                    }
+                    return this.transform(v);
+                }
+                else {
+                    let arr = this.toArray();
+                    let tz = arr.find(elem => elem.abbrev === val || elem.name === val);
+                    return typeof tz !== 'undefined' ? this.transform(tz.val) : undefined;
+                }
+            }
+            else if (typeof val === 'object') {
+                if (typeof val.val !== 'undefined') return this.transform(parseInt(val.val, 10));
+                else if (typeof val.name !== 'undefined') return this.transformByName(val.name);
+            }
         }
-      }
-      else if (typeof val === 'object') {
-        if (typeof val.val !== 'undefined') return this.transform(parseInt(val.val, 10));
-        else if (typeof val.name !== 'undefined') return this.transformByName(val.name);
-      }
     }
-  }
-  public expansionBoards: byteValueMap = new byteValueMap();
-  // 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' }]
-  ]);
-  public equipmentCommStatus: byteValueMap = new byteValueMap([
-    [0, { val: 0, name: 'ready', desc: 'Ready' }],
-    [1, { val: 1, name: 'commerr', desc: 'Communication Error' }]
-  ]);
-  public panelModes: byteValueMap = new byteValueMap([
-    [0, { val: 0, name: 'auto', desc: 'Auto' }],
-    [1, { val: 1, name: 'service', desc: 'Service' }],
-    [8, { val: 8, name: 'freeze', desc: 'Freeze' }],
-    [128, { val: 128, name: 'timeout', desc: 'Timeout' }],
-    [129, { val: 129, name: 'service-timeout', desc: 'Service/Timeout' }],
-    [255, { name: 'error', desc: 'System Error' }]
-  ]);
-  public controllerStatus: byteValueMap = new byteValueMap([
-    [0, { val: 0, name: 'initializing', desc: 'Initializing', percent: 0 }],
-    [1, { val: 1, name: 'ready', desc: 'Ready', percent: 100 }],
-    [2, { val: 2, name: 'loading', desc: 'Loading', percent: 0 }],
-    [3, { val: 255, name: 'Error', desc: 'Error', percent: 0 }]
-  ]);
+    public expansionBoards: byteValueMap = new byteValueMap();
+    // 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' }]
+    ]);
+    public equipmentCommStatus: byteValueMap = new byteValueMap([
+        [0, { val: 0, name: 'ready', desc: 'Ready' }],
+        [1, { val: 1, name: 'commerr', desc: 'Communication Error' }]
+    ]);
+    public panelModes: byteValueMap = new byteValueMap([
+        [0, { val: 0, name: 'auto', desc: 'Auto' }],
+        // [1, { val: 1, name: 'service', desc: 'Service' }],
+        // [8, { val: 8, name: 'freeze', desc: 'Freeze' }],
+        // [128, { val: 128, name: 'timeout', desc: 'Timeout' }],
+        // [129, { val: 129, name: 'service-timeout', desc: 'Service/Timeout' }],
+        [255, { name: 'error', desc: 'System Error' }]
+    ]);
+    public controllerStatus: byteValueMap = new byteValueMap([
+        [0, { val: 0, name: 'initializing', desc: 'Initializing', percent: 0 }],
+        [1, { val: 1, name: 'ready', desc: 'Ready', percent: 100 }],
+        [2, { val: 2, name: 'loading', desc: 'Loading', percent: 0 }],
+        [3, { val: 255, name: 'Error', desc: 'Error', percent: 0 }]
+    ]);
 
-  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' }],
-    [7, { name: 'light', desc: 'Light', isLight: true }],
-    [9, { name: 'samlight', desc: 'SAM Light', isLight: true }],
-    [10, { name: 'sallight', desc: 'SAL Light', isLight: true }],
-    [11, { name: 'photongen', desc: 'Photon Gen', isLight: true }],
-    [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 }],
-    [19, { name: 'notused', desc: 'Not Used' }]
-  ]);
+    public circuitFunctions: byteValueMap = new byteValueMap([
+        [0, { name: 'generic', desc: 'Generic' }],
+        [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 }],
+        [11, { name: 'photongen', desc: 'Photon Gen', isLight: true }],
+        [12, { name: 'colorwheel', desc: 'Color Wheel', isLight: true }],
+        [13, { name: 'valve', desc: 'Valve' }],
+        [14, { name: 'spillway', desc: 'Spillway' }],
+        [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, themes: 'intellibrite' }],
+        [17, { name: 'magicstream', desc: 'Magicstream', isLight: true, themes: 'magicstream' }],
+        [19, { name: 'notused', desc: 'Not Used' }],
+        [65, { name: 'lotemp', desc: 'Lo-Temp' }],
+        [66, { name: 'hightemp', desc: 'Hi-Temp' }]
+    ]);
 
-  // Feature functions are used as the available options to define a circuit.
-  public featureFunctions: byteValueMap = new byteValueMap([[0, { name: 'generic', desc: 'Generic' }], [1, { name: 'spillway', desc: 'Spillway' }]]);
-  public virtualCircuits: byteValueMap = new byteValueMap([
-    [128, { name: 'solar', desc: 'Solar', assignableToPumpCircuit: true }],
-    [129, { name: 'heater', desc: 'Either Heater', assignableToPumpCircuit: true }],
-    [130, { name: 'poolHeater', desc: 'Pool Heater', assignableToPumpCircuit: true }],
-    [131, { name: 'spaHeater', desc: 'Spa Heater', assignableToPumpCircuit: true }],
-    [132, { name: 'freeze', desc: 'Freeze', assignableToPumpCircuit: true }],
-    [133, { name: 'heatBoost', desc: 'Heat Boost', assignableToPumpCircuit: false }],
-    [134, { name: 'heatEnable', desc: 'Heat Enable', assignableToPumpCircuit: false }],
-    [135, { name: 'pumpSpeedUp', desc: 'Pump Speed +', assignableToPumpCircuit: false }],
-    [136, { name: 'pumpSpeedDown', desc: 'Pump Speed -', assignableToPumpCircuit: false }],
-    [255, { name: 'notused', desc: 'NOT USED', assignableToPumpCircuit: true }]
-  ]);
-  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' }],
-    [254, { name: 'unknown', desc: 'unknown' }],
-    [255, { name: 'none', desc: 'None' }]
-  ]);
-  public lightColors: byteValueMap = new byteValueMap([
-    [0, { name: 'white', desc: 'White' }],
-    [2, { name: 'lightgreen', desc: 'Light Green' }],
-    [4, { name: 'green', desc: 'Green' }],
-    [6, { name: 'cyan', desc: 'Cyan' }],
-    [8, { name: 'blue', desc: 'Blue' }],
-    [10, { name: 'lavender', desc: 'Lavender' }],
-    [12, { name: 'magenta', desc: 'Magenta' }],
-    [14, { name: 'lightmagenta', desc: 'Light Magenta' }]
-  ]);
-  public scheduleDays: byteValueMap = new byteValueMap([
-    [1, { name: 'sat', desc: 'Saturday', dow: 6 }],
-    [2, { name: 'fri', desc: 'Friday', dow: 5 }],
-    [3, { name: 'thu', desc: 'Thursday', dow: 4 }],
-    [4, { name: 'wed', desc: 'Wednesday', dow: 3 }],
-    [5, { name: 'tue', desc: 'Tuesday', dow: 2 }],
-    [6, { name: 'mon', desc: 'Monday', dow: 1 }],
-    [7, { name: 'sun', desc: 'Sunday', dow: 0 }]
-  ]);
-  public scheduleTimeTypes: byteValueMap = new byteValueMap([
-    [0, { name: 'manual', desc: 'Manual' }]
-  ]);
-  public scheduleDisplayTypes: byteValueMap = new byteValueMap([
-    [0, { name: 'always', desc: 'Always' }],
-    [1, { name: 'active', desc: 'When Active' }],
-    [2, { name: 'never', desc: 'Never' }]
-  ]);
+    // Feature functions are used as the available options to define a circuit.
+    public featureFunctions: byteValueMap = new byteValueMap([[0, { name: 'generic', desc: 'Generic' }], [1, { name: 'spillway', desc: 'Spillway' }]]);
+    public virtualCircuits: byteValueMap = new byteValueMap([
+        [128, { name: 'solar', desc: 'Solar', assignableToPumpCircuit: true }],
+        [129, { name: 'heater', desc: 'Either Heater', assignableToPumpCircuit: true }],
+        [130, { name: 'poolHeater', desc: 'Pool Heater', assignableToPumpCircuit: true }],
+        [131, { name: 'spaHeater', desc: 'Spa Heater', assignableToPumpCircuit: true }],
+        [132, { name: 'freeze', desc: 'Freeze', assignableToPumpCircuit: true }],
+        [133, { name: 'heatBoost', desc: 'Heat Boost', assignableToPumpCircuit: false }],
+        [134, { name: 'heatEnable', desc: 'Heat Enable', assignableToPumpCircuit: false }],
+        [135, { name: 'pumpSpeedUp', desc: 'Pump Speed +', assignableToPumpCircuit: false }],
+        [136, { name: 'pumpSpeedDown', desc: 'Pump Speed -', assignableToPumpCircuit: false }],
+        [255, { name: 'notused', desc: 'NOT USED', assignableToPumpCircuit: true }]
+    ]);
+    public lightThemes: byteValueMap = new byteValueMap([
+        [0, { name: 'off', desc: 'Off', types: ['intellibrite'] }],
+        [1, { name: 'on', desc: 'On', types: ['intellibrite'] }],
+        [128, { name: 'colorsync', desc: 'Color Sync', types: ['intellibrite'] }],
+        [144, { name: 'colorswim', desc: 'Color Swim', types: ['intellibrite'] }],
+        [160, { name: 'colorset', desc: 'Color Set', types: ['intellibrite'] }],
+        [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', 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 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 }],
-    [65, { name: 'ds', desc: 'Two-Speed', maxCircuits: 40, hasAddress: false, hasBody: true }],
-    [128, { name: 'vs', desc: 'Intelliflo VS', maxPrimingTime: 6, minSpeed: 450, maxSpeed: 3450, speedStepSize: 10, maxCircuits: 8, hasAddress: true }],
-    [169, { name: 'vssvrs', desc: 'IntelliFlo VS+SVRS', maxPrimingTime: 6, minSpeed: 450, maxSpeed: 3450, speedStepSize: 10, maxCircuits: 8, hasAddress: true }]
-  ]);
-  public pumpSSModels: byteValueMap = new byteValueMap([
-    [0, { name: 'unspecified', desc: 'Unspecified', amps: 0, pf: 0, volts: 0, watts: 0 }],
-    [1, { name: 'wf1hpE', desc: '1hp WhisperFlo E+', amps: 7.4, pf: .9, volts: 230, watts: 1532 }],
-    [2, { name: 'wf1hpMax', desc: '1hp WhisperFlo Max', amps: 9, pf: .87, volts: 230, watts: 1600 }],
-    [3, { name: 'generic15hp', desc: '1.5hp Pump', amps: 9.3, pf: .9, volts: 230, watts: 1925 }],
-    [4, { name: 'generic2hp', desc: '2hp Pump', amps: 12, pf: .9, volts: 230, watts: 2484 }],
-    [5, { name: 'generic25hp', desc: '2.5hp Pump', amps: 12.5, pf: .9, volts: 230, watts: 2587 }],
-    [6, { name: 'generic3hp', desc: '3hp Pump', amps: 13.5, pf: .9, volts: 230, watts: 2794 }]
-  ]);
-  public pumpDSModels: byteValueMap = new byteValueMap([
-    [0, { name: 'unspecified', desc: 'Unspecified', loAmps: 0, hiAmps: 0, pf: 0, volts: 0, loWatts: 0, hiWatts: 0 }],
-    [1, { name: 'generic1hp', desc: '1hp Pump', loAmps: 2.4, hiAmps: 6.5, pf: .9, volts: 230, loWatts: 497, hiWatts: 1345 }],
-    [2, { name: 'generic15hp', desc: '1.5hp Pump', loAmps: 2.7, hiAmps: 9.3, pf: .9, volts: 230, loWatts: 558, hiWatts: 1925 }],
-    [3, { name: 'generic2hp', desc: '2hp Pump', loAmps: 2.9, hiAmps: 12, pf: .9, volts: 230, loWatts: 600, hiWatts: 2484 }],
-    [4, { name: 'generic25hp', desc: '2.5hp Pump', loAmps: 3.1, hiAmps: 12.5, pf: .9, volts: 230, loWatts: 642, hiWatts: 2587 }],
-    [5, { name: 'generic3hp', desc: '3hp Pump', loAmps: 3.3, hiAmps: 13.5, pf: .9, volts: 230, loWatts: 683, hiWatts: 2794 }]
-  ]);
-  public pumpVSModels: byteValueMap = new byteValueMap([
-    [0, { name: 'intelliflovs', desc: 'IntelliFlo VS' }]
-  ]);
-  public pumpVFModels: byteValueMap = new byteValueMap([
-    [0, { name: 'intelliflovf', desc: 'IntelliFlo VF' }]
-  ]);
-  public pumpVSFModels: byteValueMap = new byteValueMap([
-    [0, { name: 'intelliflovsf', desc: 'IntelliFlo VSF' }]
-  ]);
-  public pumpVSSVRSModels: byteValueMap = new byteValueMap([
-    [0, { name: 'intelliflovssvrs', desc: 'IntelliFlo VS+SVRS' }]
-  ]);
-  // These are used for single-speed pump definitions.  Essentially the way this works is that when
-  // the body circuit is running the single speed pump is on.
-  public pumpBodies: byteValueMap = new byteValueMap([
-    [0, { name: 'pool', desc: 'Pool' }],
-    [101, { name: 'spa', desc: 'Spa' }],
-    [255, { name: 'poolspa', desc: 'Pool/Spa' }]
-  ]);
-  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 }],
-    [5, { name: 'hybrid', desc: 'Hybrid', hasAddress: true }],
-    [6, { name: 'maxetherm', desc: 'Max-E-Therm', hasAddress: true }],
-    [7, { name: 'mastertemp', desc: 'MasterTemp', hasAddress: true }]
-  ]);
-  public heatModes: byteValueMap = new byteValueMap([
-    [0, { name: 'off', desc: 'Off' }],
-    [3, { name: 'heater', desc: 'Heater' }],
-    [5, { name: 'solar', desc: 'Solar Only' }],
-    [12, { name: 'solarpref', desc: 'Solar Preferred' }]
-  ]);
-  public heatSources: byteValueMap = new byteValueMap([
-    [0, { name: 'off', desc: 'No Heater' }],
-    [3, { name: 'heater', desc: 'Heater' }],
-    [5, { name: 'solar', desc: 'Solar Only' }],
-    [21, { name: 'solarpref', desc: 'Solar Preferred' }],
-    [32, { name: 'nochange', desc: 'No Change' }]
-  ]);
-  public heatStatus: byteValueMap = new byteValueMap([
-    [0, { name: 'off', desc: 'Off' }],
-    [1, { name: 'heater', desc: 'Heater' }],
-    [2, { name: 'solar', desc: 'Solar' }],
-    [3, { name: 'cooling', desc: 'Cooling' }]
-  ]);
-  public pumpStatus: byteValueMap = new byteValueMap([
-    [0, { name: 'off', desc: 'Off' }], // When the pump is disconnected or has no power then we simply report off as the status.  This is not the recommended wiring
-    // for a VS/VF pump as is should be powered at all times.  When it is, the status will always report a value > 0.
-    [1, { name: 'ok', desc: 'Ok' }], // Status is always reported when the pump is not wired to a relay regardless of whether it is on or not
-    // as is should be if this is a VS / VF pump.  However if it is wired to a relay most often filter, the pump will report status
-    // 0 if it is not running.  Essentially this is no error but it is not a status either.
-    [2, { name: 'filter', desc: 'Filter warning' }],
-    [3, { name: 'overcurrent', desc: 'Overcurrent condition' }],
-    [4, { name: 'priming', desc: 'Priming' }],
-    [5, { name: 'blocked', desc: 'System blocked' }],
-    [6, { name: 'general', desc: 'General alarm' }],
-    [7, { name: 'overtemp', desc: 'Overtemp condition' }],
-    [8, { name: 'power', dec: 'Power outage' }],
-    [9, { name: 'overcurrent2', desc: 'Overcurrent condition 2' }],
-    [10, { name: 'overvoltage', desc: 'Overvoltage condition' }],
-    [11, { name: 'error11', desc: 'Unspecified Error 11' }],
-    [12, { name: 'error12', desc: 'Unspecified Error 12' }],
-    [13, { name: 'error13', desc: 'Unspecified Error 13' }],
-    [14, { name: 'error14', desc: 'Unspecified Error 14' }],
-    [15, { name: 'error15', desc: 'Unspecified Error 15' }],
-    [16, { name: 'commfailure', desc: 'Communication failure' }]
-  ]);
-  public pumpUnits: byteValueMap = new byteValueMap([
-    [0, { name: 'rpm', desc: 'RPM' }],
-    [1, { name: 'gpm', desc: 'GPM' }]
-  ]);
-  public bodyTypes: byteValueMap = new byteValueMap([
-    [0, { name: 'pool', desc: 'Pool' }],
-    [1, { name: 'spa', desc: 'Spa' }]
-  ]);
-  public bodies: byteValueMap = new byteValueMap([
-    [0, { name: 'pool', desc: 'Pool' }],
-    [1, { name: 'spa', desc: 'Spa' }],
-    [2, { name: 'body3', desc: 'Body 3' }],
-    [3, { name: 'body4', desc: 'Body 4' }],
-    [32, { name: 'poolspa', desc: 'Pool/Spa' }]
-  ]);
-  public chlorinatorStatus: byteValueMap = new byteValueMap([
-    [0, { name: 'ok', desc: 'Ok' }],
-    [1, { name: 'lowflow', desc: 'Low Flow' }],
-    [2, { name: 'lowsalt', desc: 'Low Salt' }],
-    [3, { name: 'verylowsalt', desc: 'Very Low Salt' }],
-    [4, { name: 'highcurrent', desc: 'High Current' }],
-    [5, { name: 'clean', desc: 'Clean Cell' }],
-    [6, { name: 'lowvoltage', desc: 'Low Voltage' }],
-    [7, { name: 'lowtemp', desc: 'Water Temp Low' }],
-    [8, { name: 'commlost', desc: 'Communication Lost' }]
-  ]);
-  public chlorinatorType: byteValueMap = new byteValueMap([
-    [0, { name: 'pentair', desc: 'Pentair' }],
-    [1, { name: 'unknown', desc: 'unknown' }],
-    [2, { name: 'aquarite', desc: 'Aquarite' }],
-    [3, { name: 'unknown', desc: 'unknown' }]
-  ]);
-  public chlorinatorModel: byteValueMap = new byteValueMap([
-    [0, { name: 'unknown', desc: 'unknown', capacity: 0, chlorinePerDay: 0, chlorinePerSec: 0 }],
-    [1, { name: 'intellichlor--15', desc: 'IC15', capacity: 15000, chlorinePerDay: 0.60, chlorinePerSec: 0.60/86400 }],
-    [2, { name: 'intellichlor--20', desc: 'IC20', capacity: 20000, chlorinePerDay: 0.70, chlorinePerSec: 0.70/86400 }],
-    [3, { name: 'intellichlor--40', desc: 'IC40', capacity: 40000, chlorinePerDay: 1.40, chlorinePerSec: 1.4/86400 }],
-    [4, { name: 'intellichlor--60', desc: 'IC60', capacity: 60000, chlorinePerDay: 2, chlorinePerSec: 2/86400 }], 
-  ])
-  public customNames: byteValueMap = new byteValueMap();
-  public circuitNames: byteValueMap = new byteValueMap();
-  public scheduleTypes: byteValueMap = new byteValueMap([
-    [0, { name: 'runonce', desc: 'Run Once', startDate: true, startTime: true, endTime: true, days: false, heatSource: true, heatSetpoint: true }],
-    [128, { name: 'repeat', desc: 'Repeats', startDate: false, startTime: true, endTime: true, days: 'multi', heatSource: true, heatSetpoint: true }]
-  ]);
-  public circuitGroupTypes: byteValueMap = new byteValueMap([
-    [0, { name: 'none', desc: 'Unspecified' }],
-    [1, { name: 'light', desc: 'Light' }],
-    [2, { name: 'circuit', desc: 'Circuit' }],
-    [3, { name: 'intellibrite', desc: 'IntelliBrite' }]
-  ]);
-  public groupCircuitStates: byteValueMap = new byteValueMap([
-    [0, { name: 'off', desc: 'Off' }],
-    [1, { name: 'on', desc: 'On' }]
-  ]);
-  public tempUnits: byteValueMap = new byteValueMap([
-    [0, { name: 'F', desc: 'Fahrenheit' }],
-    [4, { name: 'C', desc: 'Celsius' }]
-  ]);
-  public valveTypes: byteValueMap = new byteValueMap([
-    [0, { name: 'standard', desc: 'Standard' }],
-    [1, { name: 'intellivalve', desc: 'IntelliValve' }]
-  ]);
+    public lightColors: byteValueMap = new byteValueMap([
+        [0, { name: 'white', desc: 'White' }],
+        [2, { name: 'lightgreen', desc: 'Light Green' }],
+        [4, { name: 'green', desc: 'Green' }],
+        [6, { name: 'cyan', desc: 'Cyan' }],
+        [8, { name: 'blue', desc: 'Blue' }],
+        [10, { name: 'lavender', desc: 'Lavender' }],
+        [12, { name: 'magenta', desc: 'Magenta' }],
+        [14, { name: 'lightmagenta', desc: 'Light Magenta' }]
+    ]);
+    public scheduleDays: byteValueMap = new byteValueMap([
+        [1, { name: 'sat', desc: 'Saturday', dow: 6 }],
+        [2, { name: 'fri', desc: 'Friday', dow: 5 }],
+        [3, { name: 'thu', desc: 'Thursday', dow: 4 }],
+        [4, { name: 'wed', desc: 'Wednesday', dow: 3 }],
+        [5, { name: 'tue', desc: 'Tuesday', dow: 2 }],
+        [6, { name: 'mon', desc: 'Monday', dow: 1 }],
+        [7, { name: 'sun', desc: 'Sunday', dow: 0 }]
+    ]);
+    public scheduleTimeTypes: byteValueMap = new byteValueMap([
+        [0, { name: 'manual', desc: 'Manual' }]
+    ]);
+    public scheduleDisplayTypes: byteValueMap = new byteValueMap([
+        [0, { name: 'always', desc: 'Always' }],
+        [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 }],
+        [65, { name: 'ds', desc: 'Two-Speed', maxCircuits: 40, hasAddress: false, hasBody: true }],
+        [128, { name: 'vs', desc: 'Intelliflo VS', maxPrimingTime: 6, minSpeed: 450, maxSpeed: 3450, speedStepSize: 10, maxCircuits: 8, hasAddress: true }],
+        [169, { name: 'vssvrs', desc: 'IntelliFlo VS+SVRS', maxPrimingTime: 6, minSpeed: 450, maxSpeed: 3450, speedStepSize: 10, maxCircuits: 8, hasAddress: true }]
+    ]);
+    public pumpSSModels: byteValueMap = new byteValueMap([
+        [0, { name: 'unspecified', desc: 'Unspecified', amps: 0, pf: 0, volts: 0, watts: 0 }],
+        [1, { name: 'wf1hpE', desc: '1hp WhisperFlo E+', amps: 7.4, pf: .9, volts: 230, watts: 1532 }],
+        [2, { name: 'wf1hpMax', desc: '1hp WhisperFlo Max', amps: 9, pf: .87, volts: 230, watts: 1600 }],
+        [3, { name: 'generic15hp', desc: '1.5hp Pump', amps: 9.3, pf: .9, volts: 230, watts: 1925 }],
+        [4, { name: 'generic2hp', desc: '2hp Pump', amps: 12, pf: .9, volts: 230, watts: 2484 }],
+        [5, { name: 'generic25hp', desc: '2.5hp Pump', amps: 12.5, pf: .9, volts: 230, watts: 2587 }],
+        [6, { name: 'generic3hp', desc: '3hp Pump', amps: 13.5, pf: .9, volts: 230, watts: 2794 }]
+    ]);
+    public pumpDSModels: byteValueMap = new byteValueMap([
+        [0, { name: 'unspecified', desc: 'Unspecified', loAmps: 0, hiAmps: 0, pf: 0, volts: 0, loWatts: 0, hiWatts: 0 }],
+        [1, { name: 'generic1hp', desc: '1hp Pump', loAmps: 2.4, hiAmps: 6.5, pf: .9, volts: 230, loWatts: 497, hiWatts: 1345 }],
+        [2, { name: 'generic15hp', desc: '1.5hp Pump', loAmps: 2.7, hiAmps: 9.3, pf: .9, volts: 230, loWatts: 558, hiWatts: 1925 }],
+        [3, { name: 'generic2hp', desc: '2hp Pump', loAmps: 2.9, hiAmps: 12, pf: .9, volts: 230, loWatts: 600, hiWatts: 2484 }],
+        [4, { name: 'generic25hp', desc: '2.5hp Pump', loAmps: 3.1, hiAmps: 12.5, pf: .9, volts: 230, loWatts: 642, hiWatts: 2587 }],
+        [5, { name: 'generic3hp', desc: '3hp Pump', loAmps: 3.3, hiAmps: 13.5, pf: .9, volts: 230, loWatts: 683, hiWatts: 2794 }]
+    ]);
+    public pumpVSModels: byteValueMap = new byteValueMap([
+        [0, { name: 'intelliflovs', desc: 'IntelliFlo VS' }]
+    ]);
+    public pumpVFModels: byteValueMap = new byteValueMap([
+        [0, { name: 'intelliflovf', desc: 'IntelliFlo VF' }]
+    ]);
+    public pumpVSFModels: byteValueMap = new byteValueMap([
+        [0, { name: 'intelliflovsf', desc: 'IntelliFlo VSF' }]
+    ]);
+    public pumpVSSVRSModels: byteValueMap = new byteValueMap([
+        [0, { name: 'intelliflovssvrs', desc: 'IntelliFlo VS+SVRS' }]
+    ]);
+    // These are used for single-speed pump definitions.  Essentially the way this works is that when
+    // the body circuit is running the single speed pump is on.
+    public pumpBodies: byteValueMap = new byteValueMap([
+        [0, { name: 'pool', desc: 'Pool' }],
+        [101, { name: 'spa', desc: 'Spa' }],
+        [255, { name: 'poolspa', desc: 'Pool/Spa' }]
+    ]);
+    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 }],
+        [5, { name: 'hybrid', desc: 'Hybrid', 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' }],
+        [3, { name: 'heater', desc: 'Heater' }],
+        [5, { name: 'solar', desc: 'Solar Only' }],
+        [12, { name: 'solarpref', desc: 'Solar Preferred' }]
+    ]);
+    public heatSources: byteValueMap = new byteValueMap([
+        [0, { name: 'off', desc: 'No Heater' }],
+        [3, { name: 'heater', desc: 'Heater' }],
+        [5, { name: 'solar', desc: 'Solar Only' }],
+        [21, { name: 'solarpref', desc: 'Solar Preferred' }],
+        [32, { name: 'nochange', desc: 'No Change' }]
+    ]);
+    public heatStatus: byteValueMap = new byteValueMap([
+        [0, { name: 'off', desc: 'Off' }],
+        [1, { name: 'heater', desc: 'Heater' }],
+        [2, { name: 'solar', desc: 'Solar' }],
+        [3, { name: 'cooling', desc: 'Cooling' }],
+        [128, { name: 'cooldown', desc: 'Cooldown' }]
+    ]);
+    public pumpStatus: byteValueMap = new byteValueMap([
+        [0, { name: 'off', desc: 'Off' }], // When the pump is disconnected or has no power then we simply report off as the status.  This is not the recommended wiring
+        // for a VS/VF pump as is should be powered at all times.  When it is, the status will always report a value > 0.
+        [1, { name: 'ok', desc: 'Ok' }], // Status is always reported when the pump is not wired to a relay regardless of whether it is on or not
+        // as is should be if this is a VS / VF pump.  However if it is wired to a relay most often filter, the pump will report status
+        // 0 if it is not running.  Essentially this is no error but it is not a status either.
+        [2, { name: 'filter', desc: 'Filter warning' }],
+        [3, { name: 'overcurrent', desc: 'Overcurrent condition' }],
+        [4, { name: 'priming', desc: 'Priming' }],
+        [5, { name: 'blocked', desc: 'System blocked' }],
+        [6, { name: 'general', desc: 'General alarm' }],
+        [7, { name: 'overtemp', desc: 'Overtemp condition' }],
+        [8, { name: 'power', dec: 'Power outage' }],
+        [9, { name: 'overcurrent2', desc: 'Overcurrent condition 2' }],
+        [10, { name: 'overvoltage', desc: 'Overvoltage condition' }],
+        [11, { name: 'error11', desc: 'Unspecified Error 11' }],
+        [12, { name: 'error12', desc: 'Unspecified Error 12' }],
+        [13, { name: 'error13', desc: 'Unspecified Error 13' }],
+        [14, { name: 'error14', desc: 'Unspecified Error 14' }],
+        [15, { name: 'error15', desc: 'Unspecified Error 15' }],
+        [16, { name: 'commfailure', desc: 'Communication failure' }]
+    ]);
+    public pumpUnits: byteValueMap = new byteValueMap([
+        [0, { name: 'rpm', desc: 'RPM' }],
+        [1, { name: 'gpm', desc: 'GPM' }]
+    ]);
+    public bodyTypes: byteValueMap = new byteValueMap([
+        [0, { name: 'pool', desc: 'Pool' }],
+        [1, { name: 'spa', desc: 'Spa' }],
+        [2, { name: 'spa', desc: 'Spa' }],
+        [3, { name: 'spa', desc: 'Spa' }]
+    ]);
+    public bodies: byteValueMap = new byteValueMap([
+        [0, { name: 'pool', desc: 'Pool' }],
+        [1, { name: 'spa', desc: 'Spa' }],
+        [2, { name: 'body3', desc: 'Body 3' }],
+        [3, { name: 'body4', desc: 'Body 4' }],
+        [32, { name: 'poolspa', desc: 'Pool/Spa' }]
+    ]);
+    public chlorinatorStatus: byteValueMap = new byteValueMap([
+        [0, { name: 'ok', desc: 'Ok' }],
+        [1, { name: 'lowflow', desc: 'Low Flow' }],
+        [2, { name: 'lowsalt', desc: 'Low Salt' }],
+        [3, { name: 'verylowsalt', desc: 'Very Low Salt' }],
+        [4, { name: 'highcurrent', desc: 'High Current' }],
+        [5, { name: 'clean', desc: 'Clean Cell' }],
+        [6, { name: 'lowvoltage', desc: 'Low Voltage' }],
+        [7, { name: 'lowtemp', desc: 'Water Temp Low' }],
+        [8, { name: 'commlost', desc: 'Communication Lost' }]
+    ]);
+    public chlorinatorType: byteValueMap = new byteValueMap([
+        [0, { name: 'pentair', desc: 'Pentair' }],
+        [1, { name: 'unknown', desc: 'unknown' }],
+        [2, { name: 'aquarite', desc: 'Aquarite' }],
+        [3, { name: 'unknown', desc: 'unknown' }]
+    ]);
+    public chlorinatorModel: byteValueMap = new byteValueMap([
+        [0, { name: 'unknown', desc: 'unknown', capacity: 0, chlorinePerDay: 0, chlorinePerSec: 0 }],
+        [1, { name: 'intellichlor--15', desc: 'IntelliChlor IC15', capacity: 15000, chlorinePerDay: 0.60, chlorinePerSec: 0.60 / 86400 }],
+        [2, { name: 'intellichlor--20', desc: 'IntelliChlor IC20', capacity: 20000, chlorinePerDay: 0.70, chlorinePerSec: 0.70 / 86400 }],
+        [3, { name: 'intellichlor--40', desc: 'IntelliChlor IC40', capacity: 40000, chlorinePerDay: 1.40, chlorinePerSec: 1.4 / 86400 }],
+        [4, { name: 'intellichlor--60', desc: 'IntelliChlor IC60', capacity: 60000, chlorinePerDay: 2, chlorinePerSec: 2 / 86400 }],
+        [5, { name: 'aquarite-t15', desc: 'AquaRite T15', capacity: 40000, chlorinePerDay: 1.47, chlorinePerSec: 1.47 / 86400 }],
+        [6, { name: 'aquarite-t9', desc: 'AquaRite T9', capacity: 30000, chlorinePerDay: 0.98, chlorinePerSec: 0.98 / 86400 }],
+        [7, { name: 'aquarite-t5', desc: 'AquaRite T5', capacity: 20000, chlorinePerDay: 0.735, chlorinePerSec: 0.735 / 86400 }],
+        [8, { name: 'aquarite-t3', desc: 'AquaRite T3', capacity: 15000, chlorinePerDay: 0.53, chlorinePerSec: 0.53 / 86400 }],
+        [9, { name: 'aquarite-925', desc: 'AquaRite 925', capacity: 25000, chlorinePerDay: 0.98, chlorinePerSec: 0.98 / 86400 }],
+        [10, { name: 'aquarite-940', desc: 'AquaRite 940', capacity: 40000, chlorinePerDay: 1.47, chlorinePerSec: 1.47 / 86400 }]
+    ])
+    public customNames: byteValueMap = new byteValueMap();
+    public circuitNames: byteValueMap = new byteValueMap();
+    public scheduleTypes: byteValueMap = new byteValueMap([
+        [0, { name: 'runonce', desc: 'Run Once', startDate: true, startTime: true, endTime: true, days: false, heatSource: true, heatSetpoint: true }],
+        [128, { name: 'repeat', desc: 'Repeats', startDate: false, startTime: true, endTime: true, days: 'multi', heatSource: true, heatSetpoint: true }]
+    ]);
+    public circuitGroupTypes: byteValueMap = new byteValueMap([
+        [0, { name: 'none', desc: 'Unspecified' }],
+        [1, { name: 'light', desc: 'Light' }],
+        [2, { name: 'circuit', desc: 'Circuit' }],
+        [3, { name: 'intellibrite', desc: 'IntelliBrite' }]
+    ]);
+    public groupCircuitStates: byteValueMap = new byteValueMap([
+        [0, { name: 'off', desc: 'Off' }],
+        [1, { name: 'on', desc: 'On' }]
+    ]);
+    public systemUnits: byteValueMap = new byteValueMap([
+        [0, { name: 'english', desc: 'English' }],
+        [4, { name: 'metric', desc: 'Metric' }]
+    ]);
+    public tempUnits: byteValueMap = new byteValueMap([
+        [0, { name: 'F', desc: 'Fahrenheit' }],
+        [4, { name: 'C', desc: 'Celsius' }]
+    ]);
+    public valveTypes: byteValueMap = new byteValueMap([
+        [0, { name: 'standard', desc: 'Standard' }],
+        [1, { name: 'intellivalve', desc: 'IntelliValve' }]
+    ]);
+    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 intellibriteActions: byteValueMap = new byteValueMap([
     [0, { name: 'ready', desc: 'Ready' }],
     [1, { name: 'sync', desc: 'Synchronizing' }],
@@ -487,7 +531,7 @@ export class byteValueMaps {
     [0, { name: 'none', desc: 'None', ph: { min: 6.8, max: 7.6 }, orp: { min: 400, max: 800 }, hasAddress: false }],
     [1, { name: 'unknown', desc: 'Unknown', ph: { min: 6.8, max: 7.6 }, hasAddress: false }],
     [2, { name: 'intellichem', desc: 'IntelliChem', ph: { min: 7.2, max: 7.6 }, orp: { min: 400, max: 800 }, hasAddress: true }],
-    [3, { name: 'homegrown', desc: 'Homegrown', ph: { min: 6.8, max: 7.6 }, hasAddress: false }],
+    // [3, { name: 'homegrown', desc: 'Homegrown', ph: { min: 6.8, max: 7.6 }, hasAddress: false }],
     [4, { name: 'rem', desc: 'REM Chem', ph: { min: 6.8, max: 8.0 }, hasAddress: false }]
   ]);
   public siCalcTypes: byteValueMap = new byteValueMap([
@@ -538,6 +582,14 @@ export class byteValueMaps {
     [6, { name: 'qt', desc: 'Quarts' }],
     [7, { name: 'pt', desc: 'Pints' }]
   ]);
+  public pressureUnits: byteValueMap = new byteValueMap([
+    [0, { name: 'psi', desc: 'Pounds per Sqare Inch' }],
+    [1, { name: 'Pa', desc: 'Pascal' }],
+    [2, { name: 'kPa', desc: 'Kilo-pascals' }],
+    [3, { name: 'atm', desc: 'Atmospheres' }],
+    [4, { name: 'bar', desc: 'Barometric' }]
+  ]);
+
   public areaUnits: byteValueMap = new byteValueMap([
     [0, { name: '', desc: 'No Units' }],
     [1, { name: 'sqft', desc: 'Square Feet' }],
@@ -774,29 +826,37 @@ export class SystemBoard {
   /// This method processes the status message periodically.  The role of this method is to verify the circuit, valve, and heater
   /// relays.  This method does not control RS485 operations such as pumps and chlorinators.  These are done through the respective
   /// equipment polling functions.
-    public async processStatusAsync() {
-        let self = this;
-        try {
-            if (this._statusCheckRef > 0) return;
-            this.suspendStatus(true);
-            if (typeof this._statusTimer !== 'undefined' && this._statusTimer) clearTimeout(this._statusTimer);
-            // Go through all the assigned equipment and verify the current state.
-            sys.board.system.keepManualTime();
-            await sys.board.circuits.syncCircuitRelayStates();
-            await sys.board.features.syncGroupStates();
-            await sys.board.circuits.syncVirtualCircuitStates();
-            await sys.board.valves.syncValveStates();
-            await sys.board.filters.syncFilterStates();
-            await sys.board.heaters.syncHeaterStates();
-            await sys.board.schedules.syncScheduleStates();
-            state.emitControllerChange();
-            state.emitEquipmentChanges();
-        } catch (err) { state.status = 255; logger.error(`Error performing processStatusAsync ${err.message}`); }
-        finally {
-            this.suspendStatus(false);
-            if (this.statusInterval > 0) this._statusTimer = setTimeout(() => self.processStatusAsync(), this.statusInterval);
-        }
+  public async processStatusAsync() {
+    let self = this;
+    try {
+      if (this._statusCheckRef > 0) return;
+      this.suspendStatus(true);
+      if (typeof this._statusTimer !== 'undefined' && this._statusTimer) clearTimeout(this._statusTimer);
+      // Go through all the assigned equipment and verify the current state.
+      sys.board.system.keepManualTime();
+      await sys.board.bodies.syncFreezeProtection();
+      await sys.board.syncEquipmentItems();
+      await sys.board.schedules.syncScheduleStates();
+      await sys.board.circuits.checkEggTimerExpirationAsync();
+      state.emitControllerChange();
+      state.emitEquipmentChanges();
+    } catch (err) { state.status = 255; logger.error(`Error performing processStatusAsync ${err.message}`); }
+    finally {
+      this.suspendStatus(false);
+      if (this.statusInterval > 0) this._statusTimer = setTimeout(async () => await self.processStatusAsync(), this.statusInterval);
+    }
+  }
+  public async syncEquipmentItems() {
+    try {
+      await sys.board.circuits.syncCircuitRelayStates();
+      await sys.board.features.syncGroupStates();
+      await sys.board.circuits.syncVirtualCircuitStates();
+      await sys.board.valves.syncValveStates();
+      await sys.board.filters.syncFilterStates();
+      await sys.board.heaters.syncHeaterStates();
     }
+    catch (err) { logger.error(`Error synchronizing equipment items: ${err.message}`); }
+  }
   public async setControllerType(obj): Promise<Equipment> {
     try {
       if (obj.controllerType !== sys.controllerType)
@@ -874,6 +934,76 @@ export class BoardCommands {
   constructor(parent: SystemBoard) { this.board = parent; }
 }
 export class SystemCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }): Promise<RestoreResults> {
+    let res = new RestoreResults();
+    try {
+      let ctx = await sys.board.system.validateRestore(rest);
+      // Restore the general stuff.
+      if (ctx.general.update.length > 0) await sys.board.system.setGeneralAsync(ctx.general.update[0]);
+      for (let i = 0; i < ctx.customNames.update.length; i++) {
+        let cn = ctx.customNames.update[i];
+        try {
+          await sys.board.system.setCustomNameAsync(cn);
+          res.addModuleSuccess('customName', `Update: ${cn.id}-${cn.name}`);
+        } catch (err) { res.addModuleError('customName', `Update: ${cn.id}-${cn.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.customNames.add.length; i++) {
+        let cn = ctx.customNames.add[i];
+        try {
+          await sys.board.system.setCustomNameAsync(cn);
+          res.addModuleSuccess('customName', `Add: ${cn.id}-${cn.name}`);
+        } catch (err) { res.addModuleError('customName', `Add: ${cn.id}-${cn.name}: ${err.message}`); }
+      }
+      await sys.board.bodies.restore(rest, ctx, res);
+      await sys.board.filters.restore(rest, ctx, res);
+      await sys.board.circuits.restore(rest, ctx, res);
+      await sys.board.heaters.restore(rest, ctx, res);
+      await sys.board.features.restore(rest, ctx, res);
+      await sys.board.pumps.restore(rest, ctx, res);
+      await sys.board.valves.restore(rest, ctx, res);
+      await sys.board.chlorinator.restore(rest, ctx, res);
+      await sys.board.chemControllers.restore(rest, ctx, res);
+      await sys.board.schedules.restore(rest, ctx, res);
+      return res;
+      //await sys.board.covers.restore(rest, ctx);
+    } catch (err) { logger.error(`Error restoring njsPC server: ${err.message}`); res.addModuleError('system', err.message); return Promise.reject(err);}
+  }
+  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<any> {
+    try {
+      let ctx: any = { board: { errors: [], warnings: [] } };
+
+      // Step 1 - Verify that the boards are the same.  For instance you do not want to restore an IntelliTouch to an IntelliCenter.
+      let cfg = rest.poolConfig;
+      if (sys.controllerType === cfg.controllerType) {
+        ctx.customNames = { errors: [], warnings: [], add: [], update: [], remove: [] };
+        let customNames = sys.customNames.get();
+        for (let i = 0; i < rest.poolConfig.customNames.length; i++) {
+          let cn = customNames.find(elem => elem.id === rest.poolConfig.customNames[i].id);
+          if (typeof cn === 'undefined') ctx.customNames.add.push(rest.poolConfig.customNames[i]);
+          else if (JSON.stringify(rest.poolConfig.customNames[i]) !== JSON.stringify(cn)) ctx.customNames.update.push(cn);
+        }
+        ctx.general = { errors: [], warnings: [], add: [], update: [], remove: [] };
+        if (JSON.stringify(sys.general.get()) !== JSON.stringify(cfg.pool)) ctx.general.update.push(cfg.pool);
+        ctx.bodies = await sys.board.bodies.validateRestore(rest);
+        ctx.pumps = await sys.board.pumps.validateRestore(rest);
+        await sys.board.circuits.validateRestore(rest, ctx);
+        ctx.features = await sys.board.features.validateRestore(rest);
+        ctx.chlorinators = await sys.board.chlorinator.validateRestore(rest);
+        ctx.heaters = await sys.board.heaters.validateRestore(rest);
+        ctx.valves = await sys.board.valves.validateRestore(rest);
+
+        //ctx.covers = await sys.board.covers.validateRestore(rest);
+        ctx.chemControllers = await sys.board.chemControllers.validateRestore(rest);
+        ctx.filters = await sys.board.filters.validateRestore(rest);
+        ctx.schedules = await sys.board.schedules.validateRestore(rest);
+      }
+      else ctx.board.errors.push(`Panel Types do not match cannot restore bakup from ${sys.controllerType} to ${rest.poolConfig.controllerType}`);
+
+      return ctx;
+
+    } 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 setDateTimeAsync(obj: any): Promise<any> { return Promise.resolve(); }
   public keepManualTime() {
@@ -938,6 +1068,9 @@ export class SystemCommands extends BoardCommands {
     if (obj.clockSource === 'server') sys.board.system.setTZ();
     sys.board.system.setTempSensorsAsync(obj);
     sys.general.options.set(obj);
+    let bodyUnits = sys.general.options.units === 0 ? 1 : 2;
+    for (let i = 0; i < sys.bodies.length; i++) sys.bodies.getItemByIndex(i).capacityUnits = bodyUnits;
+    state.temps.units = sys.general.options.units === 0 ? 1 : 4;
     return new Promise<Options>(function (resolve, reject) { resolve(sys.general.options); });
   }
   public async setLocationAsync(obj: any): Promise<Location> {
@@ -968,7 +1101,10 @@ export class SystemCommands extends BoardCommands {
               state.temps.waterSensor1 = sys.equipment.tempSensors.getCalibration('water1') + temp;
               let body = state.temps.bodies.getItemById(1);
               if (body.isOn) body.temp = state.temps.waterSensor1;
-
+              else if (sys.equipment.shared) {
+                body = state.temps.bodies.getItemById(2);
+                if (body.isOn) body.temp = state.temps.waterSensor1;
+              }
             }
             break;
           case 'waterSensor2':
@@ -1141,17 +1277,182 @@ export class SystemCommands extends BoardCommands {
   }
 }
 export class BodyCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the bodies that should be removed.
+      for (let i = 0; i < ctx.bodies.remove.length; i++) {
+        let body = ctx.bodies.remove[i];
+        try {
+          sys.bodies.removeItemById(body.id);
+          state.temps.bodies.removeItemById(body.id);
+          res.addModuleSuccess('body', `Remove: ${body.id}-${body.name}`);
+        } catch (err) { res.addModuleError('body', `Remove: ${body.id}-${body.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.bodies.update.length; i++) {
+        let body = ctx.bodies.update[i];
+        try {
+          await sys.board.bodies.setBodyAsync(body);
+          res.addModuleSuccess('body', `Update: ${body.id}-${body.name}`);
+        } catch (err) { res.addModuleError('body', `Update: ${body.id}-${body.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.bodies.add.length; i++) {
+        let body = ctx.bodies.add[i];
+        try {
+          // pull a little trick to first add the data then perform the update.
+          sys.bodies.getItemById(body.id, true);
+          await sys.board.bodies.setBodyAsync(body);
+        } catch (err) { res.addModuleError('body', `Add: ${body.id}-${body.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring bodies: ${err.message}`); res.addModuleError('system', `Error restoring bodies: ${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 bodies.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.bodies.length; i++) {
+        let r = cfg.bodies[i];
+        let c = sys.bodies.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.bodies.length; i++) {
+        let c = sys.bodies.getItemByIndex(i);
+        let r = cfg.bodies.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating bodies for restore: ${err.message}`); }
+  }
+  public freezeProtectBodyOn: Date;
+  public freezeProtectStart: Date;
+    public async syncFreezeProtection() {
+        try {
+            // Go through all the features and circuits to make sure we have the freeze protect set appropriately.  The freeze
+            // flag will have already been set whether this is a Nixie setup or there is an OCP involved.
+
+            // First turn on/off any features that are in our control that should be under our control.  If this is an OCP we
+            // do not create features beyond those controlled by the OCP so we don't need to check these in that condition.  That is
+            // why it first checks the controller type.
+            let freeze = utils.makeBool(state.freeze);
+            if (sys.controllerType === ControllerType.Nixie) {
+                // If we are a Nixie controller we need to evaluate the current freeze settings against the air temperature.
+                if (typeof state.temps.air !== 'undefined') freeze = state.temps.air <= sys.general.options.freezeThreshold;
+                else freeze = false;
+
+                // We need to know when we first turned the freeze protection on. This is because we will be rotating between pool and spa
+                // on shared body systems when both pool and spa have freeze protection checked.
+                if (state.freeze !== freeze) {
+                    this.freezeProtectStart = freeze ? new Date() : undefined;
+                    state.freeze = freeze;
+                }
+                for (let i = 0; i < sys.features.length; i++) {
+                    let feature = sys.features.getItemByIndex(i);
+                    let fstate = state.features.getItemById(feature.id, true);
+                    if (!feature.freeze || !feature.isActive === true || feature.master !== 1) {
+                        fstate.freezeProtect = false;
+                        continue; // This is not affected by freeze conditions.
+                    }
+                    if (freeze && !fstate.isOn) {
+                        // This feature should be on because we are freezing.
+                        fstate.freezeProtect = true;
+                        await sys.board.features.setFeatureStateAsync(feature.id, true);
+                    }
+                    else if (!freeze && fstate.freezeProtect) {
+                        // This feature was turned on by freeze protection.  We need to turn it off because it has warmed up.
+                        fstate.freezeProtect = false;
+                        await sys.board.features.setFeatureStateAsync(feature.id, false);
+                    }
+                }
+            }
+            let bodyRotationChecked = false;
+            for (let i = 0; i < sys.circuits.length; i++) {
+                let circ = sys.circuits.getItemByIndex(i);
+                let cstate = state.circuits.getItemById(circ.id);
+                if (!circ.freeze || !circ.isActive === true || circ.master !== 1) {
+                    cstate.freezeProtect = false;
+                    continue; // This is not affected by freeze conditions.
+                }
+                if (sys.equipment.shared && freeze && (circ.id === 1 || circ.id === 6)) {
+                    // Exit out of here because we already checked the body rotation.  We only want to do this once since it can be expensive turning
+                    // on a particular body.
+                    if (bodyRotationChecked) continue;
+                    // These are our body circuits so we need to check to see if they need to be rotated between pool and spa.
+                    let pool = circ.id === 6 ? circ : sys.circuits.getItemById(6);
+                    let spa = circ.id === 1 ? circ : sys.circuits.getItemById(1);
+                    if (pool.freeze && spa.freeze) {
+                        // We only need to rotate between pool and spa when they are both checked.
+                        let pstate = circ.id === 6 ? cstate : state.circuits.getItemById(6);
+                        let sstate = circ.id === 1 ? cstate : state.circuits.getItemById(1);
+                        if (!pstate.isOn && !sstate.isOn) {
+                            // Neither the pool or spa are on so we will turn on the pool first.
+                            pstate.freezeProtect = true;
+                            this.freezeProtectBodyOn = new Date();
+                            await sys.board.circuits.setCircuitStateAsync(6, true);
+                        }
+                        else {
+                            // If neither of the bodies were turned on for freeze protection then we need to ignore this. 
+                            if (!pstate.freezeProtect && !sstate.freezeProtect) {
+                                this.freezeProtectBodyOn = undefined;
+                                continue;
+                            }
+
+                            // One of the two bodies is on so we need to check for the rotation.  If it is time to rotate do the rotation.
+                            if (typeof this.freezeProtectBodyOn === 'undefined') this.freezeProtectBodyOn = new Date();
+                            let dt = new Date().getTime();
+                            if (dt - 1000 * 60 * 15 > this.freezeProtectBodyOn.getTime()) {
+                                logger.info(`Swapping bodies for freeze protection pool:${pstate.isOn} spa:${sstate.isOn} interval: ${utils.formatDuration(dt - this.freezeProtectBodyOn.getTime() / 1000)}`);
+                                // 10 minutes has elapsed so we will be rotating to the other body.
+                                if (pstate.isOn) {
+                                    // The setCircuitState method will handle turning off the pool body.
+                                    sstate.freezeProtect = true;
+                                    pstate.freezeProtect = false;
+                                    await sys.board.circuits.setCircuitStateAsync(1, true);
+                                }
+                                else {
+                                    sstate.freezeProtect = false;
+                                    pstate.freezeProtect = true;
+                                    await sys.board.circuits.setCircuitStateAsync(6, true);
+                                }
+                                // Set a new date as this will be our rotation check now.
+                                this.freezeProtectBodyOn = new Date();
+                            }
+                        }
+                    }
+                    else {
+                        // Only this circuit is selected for freeze protection so we don't need any special treatment.
+                        cstate.freezeProtect = true;
+                        if (!cstate.isOn) await sys.board.circuits.setCircuitStateAsync(circ.id, true);
+                    }
+                    bodyRotationChecked = true;
+                }
+                else if (freeze && !cstate.isOn) {
+                    // This circuit should be on because we are freezing.
+                    cstate.freezeProtect = true;
+                    await sys.board.circuits.setCircuitStateAsync(circ.id, true);
+                }
+                else if (!freeze && cstate.freezeProtect) {
+                    // This feature was turned on by freeze protection.  We need to turn it off because it has warmed up.
+                    await sys.board.circuits.setCircuitStateAsync(circ.id, false);
+                    cstate.freezeProtect = false;
+                }
+            }
+        }
+        catch (err) { logger.error(`syncFreezeProtection: Error synchronizing freeze protection states: ${err.message}`); }
+    }
+
   public async initFilters() {
     try {
       let filter: Filter;
       let sFilter: FilterState;
       if (sys.equipment.maxBodies > 0) {
         filter = sys.filters.getItemById(1, true, { filterType: 3, name: sys.equipment.shared ? 'Filter' : 'Filter 1' });
-        sFilter = state.filters.getItemById(1, true, { name: filter.name });
+        sFilter = state.filters.getItemById(1, true, { id: 1, name: filter.name });
         filter.isActive = true;
         filter.master = sys.board.equipmentMaster;
         filter.body = sys.equipment.shared ? sys.board.valueMaps.bodies.transformByName('poolspa') : 0;
-        sFilter = state.filters.getItemById(1, true);
+        //sFilter = state.filters.getItemById(1, true);
         sFilter.body = filter.body;
         sFilter.filterType = filter.filterType;
         sFilter.name = filter.name;
@@ -1277,53 +1578,54 @@ 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.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 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.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 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 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('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++) {
@@ -1343,54 +1645,105 @@ export class BodyCommands extends BoardCommands {
     }
     return arrSpas;
   }
-  public getBodyState(bodyCode: number): BodyTempState {
-    let assoc = sys.board.valueMaps.bodies.transform(bodyCode);
-    switch (assoc.name) {
-      case 'body1':
-      case 'pool':
-        return state.temps.bodies.getItemById(1);
-      case 'body2':
-      case 'spa':
-        return state.temps.bodies.getItemById(2);
-      case 'body3':
-        return state.temps.bodies.getItemById(3);
-      case 'body4':
-        return state.temps.bodies.getItemById(4);
-      case 'poolspa':
-        if (sys.equipment.shared && sys.equipment.maxBodies >= 2) {
-          let body = state.temps.bodies.getItemById(1);
-          if (body.isOn) return body;
-          body = state.temps.bodies.getItemById(2);
-          if (body.isOn) return body;
-          return state.temps.bodies.getItemById(1);
+    public getBodyState(bodyCode: number): BodyTempState {
+        let assoc = sys.board.valueMaps.bodies.transform(bodyCode);
+        switch (assoc.name) {
+            case 'body1':
+            case 'pool':
+                return state.temps.bodies.getItemById(1);
+            case 'body2':
+            case 'spa':
+                return state.temps.bodies.getItemById(2);
+            case 'body3':
+                return state.temps.bodies.getItemById(3);
+            case 'body4':
+                return state.temps.bodies.getItemById(4);
+            case 'poolspa':
+                if (sys.equipment.shared && sys.equipment.maxBodies >= 2) {
+                    let body = state.temps.bodies.getItemById(1);
+                    if (body.isOn) return body;
+                    body = state.temps.bodies.getItemById(2);
+                    if (body.isOn) return body;
+                    return state.temps.bodies.getItemById(1);
+                }
+                else
+                    return state.temps.bodies.getItemById(1);
         }
-        else
-          return state.temps.bodies.getItemById(1);
-    }
-  }
-  public isBodyOn(bodyCode: number): boolean {
-    let assoc = sys.board.valueMaps.bodies.transform(bodyCode);
-    switch (assoc.name) {
-      case 'body1':
-      case 'pool':
-        return state.temps.bodies.getItemById(1).isOn;
-      case 'body2':
-      case 'spa':
-        return state.temps.bodies.getItemById(2).isOn;
-      case 'body3':
-        return state.temps.bodies.getItemById(3).isOn;
-      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;
-        else
-          return state.temps.bodies.getItemById(1).isOn;
     }
-    return false;
-  }
+    public isBodyOn(bodyCode: number): boolean {
+        let assoc = sys.board.valueMaps.bodies.transform(bodyCode);
+        switch (assoc.name) {
+            case 'body1':
+            case 'pool':
+                return state.temps.bodies.getItemById(1).isOn;
+            case 'body2':
+            case 'spa':
+                return state.temps.bodies.getItemById(2).isOn;
+            case 'body3':
+                return state.temps.bodies.getItemById(3).isOn;
+            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 === true || state.temps.bodies.getItemById(2).isOn === true;
+                }
+                else
+                    return state.temps.bodies.getItemById(1).isOn;
+        }
+        return false;
+    }
 }
 export class PumpCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the pumps that should be removed.
+      for (let i = 0; i < ctx.pumps.remove.length; i++) {
+        let p = ctx.pumps.remove[i];
+        try {
+          await sys.board.pumps.deletePumpAsync(p);
+          res.addModuleSuccess('pump', `Remove: ${p.id}-${p.name}`);
+        } catch (err) { res.addModuleError('pump', `Remove: ${p.id}-${p.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.pumps.update.length; i++) {
+        let p = ctx.pumps.update[i];
+        try {
+          await sys.board.pumps.setPumpAsync(p);
+          res.addModuleSuccess('pump', `Update: ${p.id}-${p.name}`);
+        } catch (err) { res.addModuleError('pump', `Update: ${p.id}-${p.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.pumps.add.length; i++) {
+        let p = ctx.pumps.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.pumps.getItemById(p, true);
+          await sys.board.pumps.setPumpAsync(p);
+          res.addModuleSuccess('pump', `Add: ${p.id}-${p.name}`);
+        } catch (err) { res.addModuleError('pump', `Add: ${p.id}-${p.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring pumps: ${err.message}`); res.addModuleError('system', `Error restoring pumps: ${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 pumps.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.pumps.length; i++) {
+        let r = cfg.pumps[i];
+        let c = sys.pumps.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.pumps.length; i++) {
+        let c = sys.pumps.getItemByIndex(i);
+        let r = cfg.pumps.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating pumps for restore: ${err.message}`); }
+  }
+
   public getPumpTypes() { return this.board.valueMaps.pumpTypes.toArray(); }
   public getCircuitUnits(pump?: Pump) {
     if (typeof pump === 'undefined')
@@ -1455,14 +1808,15 @@ export class PumpCommands extends BoardCommands {
     // and props that aren't for this pump type
     let _id = pump.id;
     if (pump.type !== pumpType || pumpType === 0) {
-      const _isVirtual = sys.pumps.getItemById(_id).isVirtual;
+      let _p = pump.get(true);
+      // const _isVirtual = typeof _p.isVirtual !== 'undefined' ? _p.isVirtual : false;
       sys.pumps.removeItemById(_id);
-      let pump = sys.pumps.getItemById(_id, true);
-      if (_isVirtual) {
+      pump = sys.pumps.getItemById(_id, true);
+      /* if (_isVirtual) {
         // pump.isActive = true;
         // pump.isVirtual = true;
         pump.master = 1;
-      }
+      } */
       state.pumps.removeItemById(pump.id);
       pump.type = pumpType;
       let type = sys.board.valueMaps.pumpTypes.transform(pumpType);
@@ -1512,179 +1866,452 @@ 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 syncCircuitRelayStates() {
-    try {
-      for (let i = 0; i < sys.circuits.length; i++) {
-        // Run through all the valves to see whether they should be triggered or not.
-        let circ = sys.circuits.getItemByIndex(i);
-        if (circ.master === 1 && circ.isActive) {
-          let cstate = state.circuits.getItemById(circ.id);
-          if (cstate.isOn) await ncp.circuits.setCircuitStateAsync(cstate, cstate.isOn);
-        }
-      }
-    } catch (err) { logger.error(`syncCircuitRelayStates: Error synchronizing circuit relays ${err.message}`); }
-  }
-
-  public syncVirtualCircuitStates() {
-    try {
-      let arrCircuits = sys.board.valueMaps.virtualCircuits.toArray();
-      let poolStates = sys.board.bodies.getPoolStates();
-      let spaStates = sys.board.bodies.getSpaStates();
-      // The following should work for all board types if the virtualCiruit valuemaps use common names.  The circuit ids can be
-      // different as well as the descriptions but these should have common names since they are all derived from existing states.
-
-      // This also removes virtual circuits depending on whether heaters exsits on the bodies.  Not sure why we are doing this
-      // as the body data contains whether a body is heated or not.  Perhapse some attached interface is using
-      // the virtual circuit list as a means to determine whether solar is available.  That is totally flawed if that is the case.
-      for (let i = 0; i < arrCircuits.length; i++) {
-        let vc = arrCircuits[i];
-        let remove = false;
-        let bState = false;
-        let cstate: VirtualCircuitState = null;
-        switch (vc.name) {
-          case 'poolHeater':
-            // If any pool is heating up.
-            remove = true;
-            for (let j = 0; j < poolStates.length; j++) {
-              if (poolStates[j].heaterOptions.total > 0) remove = false;
+    public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+        try {
+            // First delete the circuit/lightGroups that should be removed.
+            for (let i = 0; i < ctx.circuitGroups.remove.length; i++) {
+                let c = ctx.circuitGroups.remove[i];
+                try {
+                    await sys.board.circuits.deleteCircuitGroupAsync(c);
+                    res.addModuleSuccess('circuitGroup', `Remove: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('circuitGroup', `Remove: ${c.id}-${c.name}: ${err.message}`); }
             }
-            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 i = 0; i < ctx.lightGroups.remove.length; i++) {
+                let c = ctx.lightGroups.remove[i];
+                try {
+                    await sys.board.circuits.deleteLightGroupAsync(c);
+                    res.addModuleSuccess('lightGroup', `Remove: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('lightGroup', `Remove: ${c.id}-${c.name}: ${err.message}`); }
             }
-            break;
-          case 'spaHeater':
-            remove = true;
-            for (let j = 0; j < spaStates.length; j++) {
-              if (spaStates[j].heaterOptions.total > 0) remove = false;
+            for (let i = 0; i < ctx.circuits.remove.length; i++) {
+                let c = ctx.circuits.remove[i];
+                try {
+                    await sys.board.circuits.deleteCircuitAsync(c);
+                    res.addModuleSuccess('circuit', `Remove: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('circuit', `Remove: ${c.id}-${c.name}: ${err.message}`); }
             }
-            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') bState = true;
-              }
+            for (let i = 0; i < ctx.circuits.add.length; i++) {
+                let c = ctx.circuits.add[i];
+                try {
+                    await sys.board.circuits.setCircuitAsync(c);
+                    res.addModuleSuccess('circuit', `Add: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('circuit', `Add: ${c.id}-${c.name}: ${err.message}`); }
             }
-            break;
-          case 'freeze':
-            // If freeze protection has been turned on.
-            bState = state.freeze;
-            break;
-          case 'poolSpa':
-            // If any pool or spa is on
-            for (let j = 0; j < poolStates.length && !bState; j++) {
-              if (poolStates[j].isOn) bState = true;
+            for (let i = 0; i < ctx.circuitGroups.add.length; i++) {
+                let c = ctx.circuitGroups.add[i];
+                try {
+                    await sys.board.circuits.setCircuitGroupAsync(c);
+                    res.addModuleSuccess('circuitGroup', `Add: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('circuitGroup', `Add: ${c.id}-${c.name}: ${err.message}`); }
             }
-            for (let j = 0; j < spaStates.length && !bState; j++) {
-              if (spaStates[j].isOn) bState = true;
+            for (let i = 0; i < ctx.lightGroups.add.length; i++) {
+                let c = ctx.lightGroups.add[i];
+                try {
+                    await sys.board.circuits.setLightGroupAsync(c);
+                    res.addModuleSuccess('lightGroup', `Add: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('lightGroup', `Add: ${c.id}-${c.name}: ${err.message}`); }
             }
-            break;
-          case 'solarHeat':
-          case 'solar':
-            // If solar is on for any body
-            remove = true;
-            for (let j = 0; j < poolStates.length; j++) {
-              if (poolStates[j].heaterOptions.solar + poolStates[j].heaterOptions.heatpump > 0) remove = false;
+            for (let i = 0; i < ctx.circuits.update.length; i++) {
+                let c = ctx.circuits.update[i];
+                try {
+                    await sys.board.circuits.setCircuitAsync(c);
+                    res.addModuleSuccess('circuit', `Update: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('circuit', `Update: ${c.id}-${c.name}: ${err.message}`); }
             }
-            if (remove) {
-              for (let j = 0; j < spaStates.length; j++) {
-                if (spaStates[j].heaterOptions.solar + spaStates[j].heaterOptions.heatpump > 0) remove = false;
-              }
+            for (let i = 0; i < ctx.circuitGroups.update.length; i++) {
+                let c = ctx.circuitGroups.update[i];
+                try {
+                    await sys.board.circuits.setCircuitGroupAsync(c);
+                    res.addModuleSuccess('circuitGroup', `Update: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('circuitGroup', `Update: ${c.id}-${c.name}: ${err.message}`); }
             }
-            if (!remove) {
-              for (let j = 0; j < poolStates.length && !bState; j++) {
-                if (sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus) === 'solar') bState = true;
-              }
-              for (let j = 0; j < spaStates.length && !bState; j++) {
-                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') bState = true;
-              }
+            for (let i = 0; i < ctx.lightGroups.update.length; i++) {
+                let c = ctx.lightGroups.update[i];
+                try {
+                    await sys.board.circuits.setLightGroupAsync(c);
+                    res.addModuleSuccess('lightGroup', `Update: ${c.id}-${c.name}`);
+                } catch (err) { res.addModuleError('lightGroup', `Update: ${c.id}-${c.name}: ${err.message}`); }
             }
-            break;
-          case 'heater':
-            remove = true;
-            for (let j = 0; j < poolStates.length; j++) {
-              if (poolStates[j].heaterOptions.total > 0) remove = false;
+            return true;
+        } catch (err) { logger.error(`Error restoring circuits: ${err.message}`); res.addModuleError('system', `Error restoring circuits/features: ${err.message}`); return false; }
+    }
+  public async validateRestore(rest: { poolConfig: any, poolState: any }, ctxRoot): Promise<boolean> {
+    try {
+      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      // Look at circuits.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.circuits.length; i++) {
+        let r = cfg.circuits[i];
+        let c = sys.circuits.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.circuits.length; i++) {
+        let c = sys.circuits.getItemByIndex(i);
+        let r = cfg.circuits.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      ctxRoot.circuits = ctx;
+      ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      for (let i = 0; i < cfg.circuitGroups.length; i++) {
+        let r = cfg.circuitGroups[i];
+        let c = sys.circuitGroups.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.circuitGroups.length; i++) {
+        let c = sys.circuitGroups.getItemByIndex(i);
+        let r = cfg.circuitGroups.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      ctxRoot.circuitGroups = ctx;
+      ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      for (let i = 0; i < cfg.lightGroups.length; i++) {
+        let r = cfg.lightGroups[i];
+        let c = sys.lightGroups.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.lightGroups.length; i++) {
+        let c = sys.lightGroups.getItemByIndex(i);
+        let r = cfg.lightGroups.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      ctxRoot.lightGroups = ctx;
+      return true;
+    } catch (err) { logger.error(`Error validating circuits for restore: ${err.message}`); }
+  }
+    public async checkEggTimerExpirationAsync() {
+        // turn off any circuits that have reached their egg timer;
+        // Nixie circuits we have 100% control over; 
+        // but features/cg/lg may override OCP control
+        try {
+            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 || typeof cstate.endTime === 'undefined') continue;
+                if (c.master === 1) {
+                    await ncp.circuits.checkCircuitEggTimerExpirationAsync(cstate);
+                }
             }
-            if (remove) {
-              for (let j = 0; j < spaStates.length; j++) {
-                if (spaStates[j].heaterOptions.total > 0) remove = false;
-              }
+            for (let i = 0; i < sys.features.length; i++) {
+                let fstate = state.features.getItemByIndex(i);
+                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();
+                }
             }
-            if (!remove) {
-              for (let j = 0; j < poolStates.length && !bState; j++) {
-                let heat = sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus);
-                if (heat !== 'off') bState = true;
-              }
-              for (let j = 0; j < spaStates.length && !bState; j++) {
-                let heat = sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus);
-                if (heat !== 'off') bState = true;
-              }
+            for (let i = 0; i < sys.circuitGroups.length; i++) {
+                let cgstate = state.circuitGroups.getItemByIndex(i);
+                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();
+                }
             }
-            break;
-          default:
-            remove = true;
-            break;
-        }
-        if (remove)
-          state.virtualCircuits.removeItemById(vc.val);
-        else {
-          cstate = state.virtualCircuits.getItemById(vc.val, true);
-          if (cstate !== null) {
-            cstate.isOn = bState;
-            cstate.type = vc.val;
-            cstate.name = vc.desc;
-          }
-        }
-      }
-    } catch (err) { logger.error(`Error syncronizing virtual circuits`); }
-  }
-  public async setCircuitStateAsync(id: number, val: boolean): Promise<ICircuitState> {
-    sys.board.suspendStatus(true);
+            for (let i = 0; i < sys.lightGroups.length; i++) {
+                let lgstate = state.lightGroups.getItemByIndex(i);
+                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();
+                }
+            }
+        } catch (err) { logger.error(`checkEggTimerExpiration: Error synchronizing circuit relays ${err.message}`); }
+    }
+  public async syncCircuitRelayStates() {
     try {
-      // We need to do some routing here as it is now critical that circuits, groups, and features
-      // have their own processing.  The virtual controller used to only deal with one circuit.
-      if (sys.board.equipmentIds.circuitGroups.isInRange(id))
-        return await sys.board.circuits.setCircuitGroupStateAsync(id, val);
-      else if (sys.board.equipmentIds.features.isInRange(id))
-        return await sys.board.features.setFeatureStateAsync(id, val);
-      let circuit: ICircuit = sys.circuits.getInterfaceById(id, false, { isActive: false });
-      if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Circuit or Feature id ${id} not valid`, id, 'Circuit'));
-      let circ = state.circuits.getInterfaceById(id, circuit.isActive !== false);
-      let newState = utils.makeBool(val);
-      // First, if we are turning the circuit on, lets determine whether the circuit is a pool or spa circuit and if this is a shared system then we need
-      // to turn off the other body first.
-      //[12, { name: 'pool', desc: 'Pool', hasHeatSource: true }],
-      //[13, { name: 'spa', desc: 'Spa', hasHeatSource: true }]
-      let func = sys.board.valueMaps.circuitFunctions.get(circuit.type);
-      if (newState && (func.name === 'pool' || func.name === 'spa') && sys.equipment.shared === true) {
-        console.log(`Turning off shared body circuit`);
-        // If we are shared we need to turn off the other circuit.
-        let offType = func.name === 'pool' ? sys.board.valueMaps.circuitFunctions.getValue('spa') : sys.board.valueMaps.circuitFunctions.getValue('pool');
-        let off = sys.circuits.get().filter(elem => elem.type === offType);
-        // Turn the circuits off that are part of the shared system.  We are going back to the board
-        // just in case we got here for a circuit that isn't on the current defined panel.
-        for (let i = 0; i < off.length; i++) {
-          let coff = off[i];
-          await sys.board.circuits.setCircuitStateAsync(coff.id, false);
+      for (let i = 0; i < sys.circuits.length; i++) {
+        // Run through all the controlled circuits to see whether they should be triggered or not.
+        let circ = sys.circuits.getItemByIndex(i);
+        if (circ.master === 1 && circ.isActive) {
+          let cstate = state.circuits.getItemById(circ.id);
+          if (cstate.isOn) await ncp.circuits.setCircuitStateAsync(cstate, cstate.isOn);
         }
       }
-      if (id === 6) state.temps.bodies.getItemById(1, true).isOn = val;
-      else if (id === 1) state.temps.bodies.getItemById(2, true).isOn = val;
-      // Let the main nixie controller set the circuit state and affect the relays if it needs to.
-      await ncp.circuits.setCircuitStateAsync(circ, newState);
-      return state.circuits.getInterfaceById(circ.id);
+    } catch (err) { logger.error(`syncCircuitRelayStates: Error synchronizing circuit relays ${err.message}`); }
+  }
+    public syncVirtualCircuitStates() {
+        try {
+            let arrCircuits = sys.board.valueMaps.virtualCircuits.toArray();
+            let poolStates = sys.board.bodies.getPoolStates();
+            let spaStates = sys.board.bodies.getSpaStates();
+            // The following should work for all board types if the virtualCiruit valuemaps use common names.  The circuit ids can be
+            // different as well as the descriptions but these should have common names since they are all derived from existing states.
+
+            // This also removes virtual circuits depending on whether heaters exsits on the bodies.  Not sure why we are doing this
+            // as the body data contains whether a body is heated or not.  Perhapse some attached interface is using
+            // the virtual circuit list as a means to determine whether solar is available.  That is totally flawed if that is the case.
+            for (let i = 0; i < arrCircuits.length; i++) {
+                let vc = arrCircuits[i];
+                let remove = false;
+                let bState = false;
+                let cstate: VirtualCircuitState = null;
+                switch (vc.name) {
+                    case 'poolHeater':
+                        // If any pool is heating up.
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            if (poolStates[j].heaterOptions.total > 0) remove = false;
+                        }
+                        if (!remove) {
+                            // Determine whether the pool heater is on.
+                            for (let j = 0; j < poolStates.length; j++) {
+                                if (sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus) === 'heater') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 1 && x.startupDelay === true && x.type.name !== 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
+                        break;
+                    case 'spaHeater':
+                        remove = true;
+                        for (let j = 0; j < spaStates.length; j++) {
+                            if (spaStates[j].heaterOptions.total > 0) remove = false;
+                        }
+                        if (!remove) {
+                            // Determine whether the spa heater is on.
+                            for (let j = 0; j < spaStates.length; j++) {
+                                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'heater') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 1 && x.startupDelay === true && x.type.name !== 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                            //for (let j = 0; j < spaStates.length; j++) {
+                            //    if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'heater') bState = true;
+                            //}
+                        }
+                        break;
+                    case 'freeze':
+                        // If freeze protection has been turned on.
+                        bState = state.freeze;
+                        break;
+                    case 'poolSpa':
+                        // If any pool or spa is on
+                        for (let j = 0; j < poolStates.length && !bState; j++) {
+                            if (poolStates[j].isOn) bState = true;
+                        }
+                        for (let j = 0; j < spaStates.length && !bState; j++) {
+                            if (spaStates[j].isOn) bState = true;
+                        }
+                        break;
+                    case 'solarHeat':
+                    case 'solar':
+                        // If solar is on for any body
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            if (poolStates[j].heaterOptions.solar + poolStates[j].heaterOptions.heatpump > 0) remove = false;
+                        }
+                        if (remove) {
+                            for (let j = 0; j < spaStates.length; j++) {
+                                if (spaStates[j].heaterOptions.solar + spaStates[j].heaterOptions.heatpump > 0) remove = false;
+                            }
+                        }
+                        if (!remove) {
+                            for (let j = 0; j < poolStates.length && !bState; j++) {
+                                if (sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus) === 'solar') bState = true;
+                            }
+                            for (let j = 0; j < spaStates.length && !bState; j++) {
+                                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') bState = true;
+                            }
+                        }
+                        break;
+                    case 'solar1':
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            if (poolStates[j].id === 1 && poolStates[j].heaterOptions.solar) {
+                                remove = false;
+                                vc.desc = `${poolStates[j].name} Solar`;
+                                if (sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus) === 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 1 && x.startupDelay === true && x.type.name === 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
+                        for (let j = 0; j < spaStates.length; j++) {
+                            if (spaStates[j].id === 1 && spaStates[j].heaterOptions.solar) {
+                                remove = false;
+                                vc.desc = `${spaStates[j].name} Solar`;
+                                if (sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus) === 'solar') {
+                                    // In this instance we may have a delay underway.
+                                    let hstate = state.heaters.find(x => x.bodyId === 1 && x.startupDelay === true && x.type.name === 'solar');
+                                    bState = typeof hstate === 'undefined';
+                                }
+                            }
+                        }
+
+                        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 'heater':
+                        remove = true;
+                        for (let j = 0; j < poolStates.length; j++) {
+                            if (poolStates[j].heaterOptions.total > 0) remove = false;
+                        }
+                        if (remove) {
+                            for (let j = 0; j < spaStates.length; j++) {
+                                if (spaStates[j].heaterOptions.total > 0) remove = false;
+                            }
+                        }
+                        if (!remove) {
+                            for (let j = 0; j < poolStates.length && !bState; j++) {
+                                let heat = sys.board.valueMaps.heatStatus.getName(poolStates[j].heatStatus);
+                                if (heat !== 'off') bState = true;
+                            }
+                            for (let j = 0; j < spaStates.length && !bState; j++) {
+                                let heat = sys.board.valueMaps.heatStatus.getName(spaStates[j].heatStatus);
+                                if (heat !== 'off') bState = true;
+                            }
+                        }
+                        break;
+                    default:
+                        remove = true;
+                        break;
+                }
+                if (remove) {
+                    if (state.virtualCircuits.exists(x => vc.val === x.id)) {
+                        cstate = state.virtualCircuits.getItemById(vc.val, true);
+                        cstate.isActive = false;
+                        cstate.emitEquipmentChange();
+                    }
+                    state.virtualCircuits.removeItemById(vc.val);
+                }
+                else {
+                    cstate = state.virtualCircuits.getItemById(vc.val, true);
+                    cstate.isActive = true;
+                    if (cstate !== null) {
+                        cstate.isOn = bState;
+                        cstate.type = vc.val;
+                        cstate.name = vc.desc;
+                    }
+                }
+            }
+        } catch (err) { logger.error(`Error syncronizing virtual circuits`); }
     }
-    catch (err) { return Promise.reject(`Nixie: Error setCircuitStateAsync ${err.message}`); }
-    finally {
-      // sys.board.virtualPumpControllers.start();
-      ncp.pumps.syncPumpStates();
-      sys.board.suspendStatus(false);
-      this.board.processStatusAsync();
-      state.emitEquipmentChanges();
+    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
+            // have their own processing.  The virtual controller used to only deal with one circuit.
+            if (sys.board.equipmentIds.circuitGroups.isInRange(id))
+                return await sys.board.circuits.setCircuitGroupStateAsync(id, val);
+            else if (sys.board.equipmentIds.features.isInRange(id))
+                return await sys.board.features.setFeatureStateAsync(id, val);
+            let circuit: ICircuit = sys.circuits.getInterfaceById(id, false, { isActive: false });
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Circuit or Feature id ${id} not valid`, id, 'Circuit'));
+            let circ = state.circuits.getInterfaceById(id, circuit.isActive !== false);
+            let newState = utils.makeBool(val);
+            // First, if we are turning the circuit on, lets determine whether the circuit is a pool or spa circuit and if this is a shared system then we need
+            // to turn off the other body first.
+            //[12, { name: 'pool', desc: 'Pool', hasHeatSource: true }],
+            //[13, { name: 'spa', desc: 'Spa', hasHeatSource: true }]
+            let func = sys.board.valueMaps.circuitFunctions.get(circuit.type);
+            if (newState && (func.name === 'pool' || func.name === 'spa') && sys.equipment.shared === true) {
+                // If we are shared we need to turn off the other circuit.
+                let offType = func.name === 'pool' ? sys.board.valueMaps.circuitFunctions.getValue('spa') : sys.board.valueMaps.circuitFunctions.getValue('pool');
+                let off = sys.circuits.get().filter(elem => elem.type === offType);
+                // Turn the circuits off that are part of the shared system.  We are going back to the board
+                // just in case we got here for a circuit that isn't on the current defined panel.
+                for (let i = 0; i < off.length; i++) {
+                    let coff = off[i];
+                    await sys.board.circuits.setCircuitStateAsync(coff.id, false);
+                }
+            }
+            if (id === 6) state.temps.bodies.getItemById(1, true).isOn = val;
+            else if (id === 1) state.temps.bodies.getItemById(2, true).isOn = val;
+            // Let the main nixie controller set the circuit state and affect the relays if it needs to.
+            await ncp.circuits.setCircuitStateAsync(circ, newState);
+            await sys.board.syncEquipmentItems();
+            return state.circuits.getInterfaceById(circ.id);
+        }
+        catch (err) { return Promise.reject(`Nixie: Error setCircuitStateAsync ${err.message}`); }
+        finally {
+            ncp.pumps.syncPumpStates();
+            sys.board.suspendStatus(false);
+            state.emitEquipmentChanges();
+        }
     }
-  }
   public async toggleCircuitStateAsync(id: number): Promise<ICircuitState> {
     let circ = state.circuits.getInterfaceById(id);
     return await this.setCircuitStateAsync(id, !(circ.isOn || false));
@@ -1754,7 +2381,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 {
@@ -1779,7 +2410,7 @@ export class CircuitCommands extends BoardCommands {
       if (typeof data.id !== 'undefined') {
         let circuit = sys.circuits.getItemById(id, true);
         let scircuit = state.circuits.getItemById(id, true);
-        circuit.isActive = true;
+        scircuit.isActive = circuit.isActive = true;
         circuit.master = 1;
         scircuit.isOn = false;
         if (data.name) circuit.name = scircuit.name = data.name;
@@ -1797,6 +2428,7 @@ export class CircuitCommands extends BoardCommands {
         if (typeof data.deviceBinding !== 'undefined') circuit.deviceBinding = data.deviceBinding;
         if (typeof data.showInFeatures !== 'undefined') scircuit.showInFeatures = circuit.showInFeatures = utils.makeBool(data.showInFeatures);
         circuit.dontStop = circuit.eggTimer === 1440;
+
         sys.emitEquipmentChange();
         state.emitEquipmentChanges();
         if (circuit.master === 1) await ncp.circuits.setCircuitAsync(circuit, data);
@@ -1879,8 +2511,9 @@ export class CircuitCommands extends BoardCommands {
     if (typeof id === 'undefined') return Promise.reject(new InvalidEquipmentIdError(`Max circuit light group id exceeded`, id, 'LightGroup'));
     if (isNaN(id) || !sys.board.equipmentIds.circuitGroups.isInRange(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid circuit group id: ${obj.id}`, obj.id, 'LightGroup'));
     group = sys.lightGroups.getItemById(id, true);
+    let sgroup = state.lightGroups.getItemById(id, true);
     return new Promise<LightGroup>((resolve, reject) => {
-      if (typeof obj.name !== 'undefined') group.name = obj.name;
+      if (typeof obj.name !== 'undefined') sgroup.name = group.name = obj.name;
       if (typeof obj.dontStop !== 'undefined' && utils.makeBool(obj.dontStop) === true) obj.eggTimer = 1440;
       if (typeof obj.eggTimer !== 'undefined') group.eggTimer = Math.min(Math.max(parseInt(obj.eggTimer, 10), 0), 1440);
       group.dontStop = group.eggTimer === 1440;
@@ -1987,7 +2620,9 @@ export class CircuitCommands extends BoardCommands {
         await sys.board.circuits.setCircuitStateAsync(c.circuit, false);
       else if (!cstate.isOn && sys.board.valueMaps.lightThemes.getName(theme) !== 'off') await sys.board.circuits.setCircuitStateAsync(c.circuit, true);
     }
-    sgrp.isOn = sys.board.valueMaps.lightThemes.getName(theme) === 'off' ? false : true;
+    let isOn = sys.board.valueMaps.lightThemes.getName(theme) === 'off' ? false : true;
+    sys.board.circuits.setEndTime(grp, sgrp, isOn);
+    sgrp.isOn = isOn;
     // If we truly want to support themes in lightGroups we probably need to program
     // the specific on/off toggles to enable that.  For now this will go through the motions but it's just a pretender.
     switch (theme) {
@@ -2131,8 +2766,135 @@ export class CircuitCommands extends BoardCommands {
       logger.error(`Error setting end time for ${thing.id}: ${err}`)
     }
   }
-}
-export class FeatureCommands extends BoardCommands {
+    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.
+      for (let i = 0; i < ctx.features.remove.length; i++) {
+        let f = ctx.features.remove[i];
+        try {
+          await sys.board.features.deleteFeatureAsync(f);
+          res.addModuleSuccess('feature', `Remove: ${f.id}-${f.name}`);
+        } catch (err) { res.addModuleError('feature', `Remove: ${f.id}-${f.name}: ${err.message}`) }
+      }
+      for (let i = 0; i < ctx.features.update.length; i++) {
+        let f = ctx.features.update[i];
+        try {
+          await sys.board.features.setFeatureAsync(f);
+          res.addModuleSuccess('feature', `Update: ${f.id}-${f.name}`);
+        } catch (err) { res.addModuleError('feature', `Update: ${f.id}-${f.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.features.add.length; i++) {
+        // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+        // it won't error out.
+        let f = ctx.features.add[i];
+        try {
+          sys.features.getItemById(f, true);
+          await sys.board.features.setFeatureAsync(f);
+          res.addModuleSuccess('feature', `Add: ${f.id}-${f.name}`);
+        } catch (err) { res.addModuleError('feature', `Add: ${f.id}-${f.name}: ${err.message}`) }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring features: ${err.message}`); res.addModuleError('system', `Error restoring features: ${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 features.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.features.length; i++) {
+        let r = cfg.features[i];
+        let c = sys.features.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.features.length; i++) {
+        let c = sys.features.getItemByIndex(i);
+        let r = cfg.features.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating features for restore: ${err.message}`); }
+  }
+
   public async setFeatureAsync(obj: any): Promise<Feature> {
     let id = parseInt(obj.id, 10);
     if (id <= 0 || isNaN(id)) {
@@ -2177,7 +2939,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'));
@@ -2186,7 +2948,6 @@ export class FeatureCommands extends BoardCommands {
       sys.board.circuits.setEndTime(feature, fstate, val);
       fstate.isOn = val;
       sys.board.valves.syncValveStates();
-      // sys.board.virtualPumpControllers.start();
       ncp.pumps.syncPumpStates();
       state.emitEquipmentChanges();
       return fstate;
@@ -2249,6 +3010,57 @@ export class FeatureCommands extends BoardCommands {
   }
 }
 export class ChlorinatorCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the chlorinators that should be removed.
+      for (let i = 0; i < ctx.chlorinators.remove.length; i++) {
+        let c = ctx.chlorinators.remove[i];
+        try {
+          await sys.board.chlorinator.deleteChlorAsync(c);
+          res.addModuleSuccess('chlorinator', `Remove: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chlorinator', `Remove: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.chlorinators.update.length; i++) {
+        let c = ctx.chlorinators.update[i];
+        try {
+          await sys.board.chlorinator.setChlorAsync(c);
+          res.addModuleSuccess('chlorinator', `Update: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chlorinator', `Update: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.chlorinators.add.length; i++) {
+        let c = ctx.chlorinators.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.chlorinators.getItemById(c.id, true);
+          await sys.board.chlorinator.setChlorAsync(c);
+          res.addModuleSuccess('chlorinator', `Add: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chlorinator', `Add: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring chlorinators: ${err.message}`); res.addModuleError('system', `Error restoring chlorinators: ${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 chlorinators.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.chlorinators.length; i++) {
+        let r = cfg.chlorinators[i];
+        let c = sys.chlorinators.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.chlorinators.length; i++) {
+        let c = sys.chlorinators.getItemByIndex(i);
+        let r = cfg.chlorinators.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating chlorinators for restore: ${err.message}`); }
+  }
+
   public async setChlorAsync(obj: any): Promise<ChlorinatorState> {
     try {
       let id = parseInt(obj.id, 10);
@@ -2267,7 +3079,7 @@ export class ChlorinatorCommands extends BoardCommands {
   public async deleteChlorAsync(obj: any): Promise<ChlorinatorState> {
     try {
       let id = parseInt(obj.id, 10);
-      if (isNaN(id)) obj.id = 1;
+      if (isNaN(id)) return Promise.reject(new InvalidEquipmentDataError(`Chlorinator id is not valid: ${obj.id}`, 'chlorinator', obj.id));
       let chlor = state.chlorinators.getItemById(id);
       chlor.isActive = false;
       await ncp.chlorinators.deleteChlorinatorAsync(id);
@@ -2291,6 +3103,56 @@ export class ChlorinatorCommands extends BoardCommands {
   }
 }
 export class ScheduleCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the schedules that should be removed.
+      for (let i = 0; i < ctx.schedules.remove.length; i++) {
+        let s = ctx.schedules.remove[i];
+        try {
+          await sys.board.schedules.deleteScheduleAsync(ctx.schedules.remove[i]);
+          res.addModuleSuccess('schedule', `Remove: ${s.id}-${s.circuitId}`);
+        } catch (err) { res.addModuleError('schedule', `Remove: ${s.id}-${s.circuitId} ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.schedules.update.length; i++) {
+        let s = ctx.schedules.update[i];
+        try {
+          await sys.board.schedules.setScheduleAsync(s);
+          res.addModuleSuccess('schedule', `Update: ${s.id}-${s.circuitId}`);
+        } catch (err) { res.addModuleError('schedule', `Update: ${s.id}-${s.circuitId} ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.schedules.add.length; i++) {
+        let s = ctx.schedules.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.schedules.getItemById(s.id, true);
+          await sys.board.schedules.setScheduleAsync(s);
+          res.addModuleSuccess('schedule', `Add: ${s.id}-${s.circuitId}`);
+        } catch (err) { res.addModuleError('schedule', `Add: ${s.id}-${s.circuitId} ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring schedules: ${err.message}`); res.addModuleError('system', `Error restoring schedules: ${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 schedules.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.schedules.length; i++) {
+        let r = cfg.schedules[i];
+        let c = sys.schedules.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.schedules.length; i++) {
+        let c = sys.schedules.getItemByIndex(i);
+        let r = cfg.schedules.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating schedules for restore: ${err.message}`); }
+  }
+
   public transformDays(val: any): number {
     if (typeof val === 'number') return val;
     let edays = sys.board.valueMaps.scheduleDays.toArray();
@@ -2411,6 +3273,9 @@ export class ScheduleCommands extends BoardCommands {
       return Promise.reject(new InvalidEquipmentDataError(`Invalid circuit reference: ${circuit}`, 'Schedule', circuit));
     if (schedType === 128 && schedDays === 0) return Promise.reject(new InvalidEquipmentDataError(`Invalid schedule days: ${schedDays}. You must supply days that the schedule is to run.`, 'Schedule', schedDays));
 
+    // If we made it to here we are valid and the schedula and it state should exist.
+    sched = sys.schedules.getItemById(id, true);
+    ssched = state.schedules.getItemById(id, true);
     sched.circuit = ssched.circuit = circuit;
     sched.scheduleDays = ssched.scheduleDays = schedDays;
     sched.scheduleType = ssched.scheduleType = schedType;
@@ -2426,6 +3291,7 @@ export class ScheduleCommands extends BoardCommands {
     sched.startYear = startDate.getFullYear();
     sched.startMonth = startDate.getMonth() + 1;
     sched.startDay = startDate.getDate();
+    sched.isActive = sched.startTime !== 0;
 
     ssched.display = sched.display = display;
     if (typeof sched.startDate === 'undefined')
@@ -2521,399 +3387,564 @@ export class ScheduleCommands extends BoardCommands {
   }
 }
 export class HeaterCommands extends BoardCommands {
-  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':
+    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.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);
+            }
         }
-      }
+        return heaters;
     }
-  }
-  public isHeatPumpInstalled(body?: number): boolean {
-    let heaters = sys.heaters.get();
-    let types = sys.board.valueMaps.heaterTypes.toArray();
-    for (let i = 0; i < heaters.length; i++) {
-      let heater = heaters[i];
-      if (typeof body !== 'undefined' && body !== heater.body) continue;
-      let type = types.find(elem => elem.val === heater.type);
-      if (typeof type !== 'undefined') {
-        switch (type.name) {
-          case 'heatpump':
-            return true;
+    public getInstalledHeaterTypes(body?: number): any {
+        let heaters = sys.heaters.get();
+        let types = sys.board.valueMaps.heaterTypes.toArray();
+        let inst = { total: 0 };
+        for (let i = 0; i < types.length; i++) if (types[i].name !== 'none') inst[types[i].name] = 0;
+        for (let i = 0; i < heaters.length; i++) {
+            let heater = heaters[i];
+            if (typeof body !== 'undefined' && heater.body !== 'undefined') {
+                if ((heater.body !== 32 && body !== heater.body + 1) || (heater.body === 32 && body > 2)) continue;
+            }
+            let type = types.find(elem => elem.val === heater.type);
+            if (typeof type !== 'undefined') {
+                if (inst[type.name] === 'undefined') inst[type.name] = 0;
+                inst[type.name] = inst[type.name] + 1;
+                if (heater.coolingEnabled === true && type.hasCoolSetpoint === true) inst['hasCoolSetpoint'] = true;
+                inst.total++;
+            }
         }
-      }
+        return inst;
     }
-  }
-  public setHeater(heater: Heater, obj?: any) {
-    if (typeof obj !== undefined) {
-      for (var s in obj)
-        heater[s] = obj[s];
+    public isSolarInstalled(body?: number): boolean {
+        let heaters = sys.heaters.get();
+        let types = sys.board.valueMaps.heaterTypes.toArray();
+        for (let i = 0; i < heaters.length; i++) {
+            let heater = heaters[i];
+            if (typeof body !== 'undefined' && body !== heater.body) continue;
+            let type = types.find(elem => elem.val === heater.type);
+            if (typeof type !== 'undefined') {
+                switch (type.name) {
+                    case 'solar':
+                        return true;
+                }
+            }
+        }
     }
-  }
-  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.isVirtual === true);
-        id = vheaters.length + 256;
-      }
-      heater = sys.heaters.getItemById(id, true);
-      if (typeof obj !== undefined) {
-        for (var s in obj) {
-          if (s === 'id') continue;
-          heater[s] = obj[s];
+    public 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;
+                }
+            }
         }
-      }
-      let hstate = state.heaters.getItemById(id, true);
-      //hstate.isVirtual = heater.isVirtual = true;
-      hstate.name = heater.name;
-      hstate.type = heater.type;
-      heater.master = 1;
-      if (heater.master === 1) await ncp.heaters.setHeaterAsync(heater, obj);
-      await sys.board.heaters.updateHeaterServices();
-      await sys.board.heaters.syncHeaterStates();
-      return heater;
-    } catch (err) { return Promise.reject(new Error(`Error setting heater configuration: ${err}`)); }
-  }
-  public async deleteHeaterAsync(obj: any): Promise<Heater> {
-    try {
-      let id = parseInt(obj.id, 10);
-      if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError('Cannot delete.  Heater Id is not valid.', obj.id, 'Heater'));
-      let heater = sys.heaters.getItemById(id);
-      heater.isActive = false;
-      if (heater.master === 1) await ncp.heaters.deleteHeaterAsync(heater.id);
-      sys.heaters.removeItemById(id);
-      state.heaters.removeItemById(id);
-      sys.board.heaters.updateHeaterServices();
-      sys.board.heaters.syncHeaterStates();
-      return heater;
-    } catch (err) { return Promise.reject(`Error deleting heater: ${err.message}`) }
-  }
-  public updateHeaterServices() {
-    let htypes = sys.board.heaters.getInstalledHeaterTypes();
-    let solarInstalled = htypes.solar > 0;
-    let heatPumpInstalled = htypes.heatpump > 0;
-    let gasHeaterInstalled = htypes.gas > 0;
-
-    if (sys.heaters.length > 0) sys.board.valueMaps.heatSources = new byteValueMap([[0, { name: 'off', desc: 'Off' }]]);
-    if (gasHeaterInstalled) sys.board.valueMaps.heatSources.set(3, { name: 'heater', desc: 'Heater' });
-    if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatSources.merge([[5, { name: 'solar', desc: 'Solar Only' }], [21, { name: 'solarpref', desc: 'Solar Preferred' }]]);
-    else if (solarInstalled) sys.board.valueMaps.heatSources.set(5, { name: 'solar', desc: 'Solar' });
-    if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatSources.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Preferred' }]]);
-    else if (heatPumpInstalled) sys.board.valueMaps.heatSources.set(9, { name: 'heatpump', desc: 'Heat Pump' });
-    sys.board.valueMaps.heatSources.set(32, { name: 'nochange', desc: 'No Change' });
-
-    sys.board.valueMaps.heatModes = new byteValueMap([[0, { name: 'off', desc: 'Off' }]]);
-    if (gasHeaterInstalled) sys.board.valueMaps.heatModes.set(3, { name: 'heater', desc: 'Heater' });
-    if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatModes.merge([[5, { name: 'solar', desc: 'Solar Only' }], [21, { name: 'solarpref', desc: 'Solar Preferred' }]]);
-    else if (solarInstalled) sys.board.valueMaps.heatModes.set(5, { name: 'solar', desc: 'Solar' });
-    if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatModes.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Preferred' }]]);
-    else if (heatPumpInstalled) sys.board.valueMaps.heatModes.set(9, { name: 'heatpump', desc: 'Heat Pump' });
-    // Now set the body data.
-    for (let i = 0; i < sys.bodies.length; i++) {
-      let body = sys.bodies.getItemByIndex(i);
-      let btemp = state.temps.bodies.getItemById(body.id, body.isActive !== false);
-      let opts = sys.board.heaters.getInstalledHeaterTypes(body.id);
-      btemp.heaterOptions = opts;
-    }
-    this.setActiveTempSensors();
-  }
-  public initTempSensors() {
-    // Add in the potential sensors and delete the ones that shouldn't exist.
-    let maxPairs = sys.equipment.maxBodies + (sys.equipment.shared ? -1 : 0);
-    sys.equipment.tempSensors.getItemById('air', true, { id: 'air', isActive: true, calibration: 0 }).name = 'Air';
-    sys.equipment.tempSensors.getItemById('water1', true, { id: 'water1', isActive: true, calibration: 0 }).name = maxPairs == 1 ? 'Water' : 'Body 1';
-    sys.equipment.tempSensors.getItemById('solar1', true, { id: 'solar1', isActive: false, calibration: 0 }).name = maxPairs == 1 ? 'Solar' : 'Solar 1';
-    if (maxPairs > 1) {
-      sys.equipment.tempSensors.getItemById('water2', true, { id: 'water2', isActive: false, calibration: 0 }).name = 'Body 2';
-      sys.equipment.tempSensors.getItemById('solar2', true, { id: 'solar2', isActive: false, calibration: 0 }).name = 'Solar 2';
     }
-    else {
-      sys.equipment.tempSensors.removeItemById('water2');
-      sys.equipment.tempSensors.removeItemById('solar2');
+    public setHeater(heater: Heater, obj?: any) {
+        if (typeof obj !== undefined) {
+            for (var s in obj)
+                heater[s] = obj[s];
+        }
     }
-    if (maxPairs > 2) {
-      sys.equipment.tempSensors.getItemById('water3', true, { id: 'water3', isActive: false, calibration: 0 }).name = 'Body 3';
-      sys.equipment.tempSensors.getItemById('solar3', true, { id: 'solar3', isActive: false, calibration: 0 }).name = 'Solar 3';
+    public 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}`)); }
     }
-    else {
-      sys.equipment.tempSensors.removeItemById('water3');
-      sys.equipment.tempSensors.removeItemById('solar3');
+    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}`) }
     }
-    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 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();
     }
-    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;
-      }
+    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');
+        }
+
     }
-  }
-  // 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;
-            }
-            // 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.isVirtual === true || 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;
-                      }
-                      //else if (heater.coolingEnabled && state.time.isNight)
-                    }
+    // 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 '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;
-                      }
+                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 'gas':
-                    if (mode === 'heater') {
-                      if (body.temp < cfgBody.setPoint) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
-                        isHeating = true;
-                      }
+                case 'solar2':
+                    if (sys.equipment.maxBodies > 1 + (sys.equipment.shared ? 1 : 0)) {
+                        htypes = sys.board.heaters.getInstalledHeaterTypes(2 + (sys.equipment.shared ? 1 : 0));
+                        sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
                     }
-                    else 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;
-                      }
+                    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 '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;
-                      }
+                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:
-                    isOn = utils.makeBool(hstate.isOn);
+                default:
+                    if (typeof sensor.id === 'undefined') sys.equipment.tempSensors.removeItemByIndex(i);
                     break;
-                }
-                logger.debug(`Heater Type: ${htype.name} Mode:${mode} Temp: ${body.temp} Setpoint: ${cfgBody.setPoint} Status: ${body.heatStatus}`);
-              }
-              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;
-              }
             }
-          }
         }
-        // When the controller is a virtual one we need to control the heat status ourselves.
-        if (!isHeating && (sys.controllerType === ControllerType.Virtual || 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);
-            } catch (err) { logger.error(err.message); }
-          })();
-          else hstate.isOn = false;
-        }
-      }
-    } catch (err) { logger.error(`Error synchronizing heater states`); }
-  }
+    }
+    // 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.`);
+                    for (let j = 0; j < heaters.length; j++) {
+                        let heater: Heater = heaters[j];
+                        if (heater.isActive === false) continue;
+                        let isOn = 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;
+                        }
+                        // 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 hstate = state.heaters.getItemById(heater.id, true);
+                            if (heater.master === 1) {
+                                if (hstatus !== 'cooldown') {
+                                    // We need to do our own calculation as to whether it is on.  This is for Nixie heaters.
+                                    switch (htype.name) {
+                                        case 'solar':
+                                            if (mode === 'solar' || mode === 'solarpref') {
+                                                // Measure up against start and stop temp deltas for effective solar heating.
+                                                if (body.temp < cfgBody.heatSetpoint &&
+                                                    state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
+                                                    isOn = true;
+                                                    body.heatStatus = sys.board.valueMaps.heatStatus.getValue('solar');
+                                                    isHeating = true;
+                                                }
+                                                else if (heater.coolingEnabled && body.temp > cfgBody.coolSetpoint && state.heliotrope.isNight &&
+                                                    state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
+                                                    isOn = true;
+                                                    body.heatStatus = sys.board.valueMaps.heatStatus.getValue('cooling');
+                                                    isHeating = true;
+                                                    isCooling = true;
+                                                }
+                                            }
+                                            break;
+                                        case 'ultratemp':
+                                            // 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.heatStatus.getValue('mtheat');
+                                                    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 (hstatus === 'mtheat') isHeating = isOn = true;
+                                        break;
+                                    case 'maxetherm':
+                                    case 'gas':
+                                        if (hstatus === 'heater') isHeating = isOn = true;
+                                        break;
+                                    case 'hybrid':
+                                    case 'ultratemp':
+                                    case 'heatpump':
+                                        if (mode === 'ultratemp' || mode === 'ultratemppref' || mode === 'heatpump' || mode === 'heatpumppref') {
+                                            if (hstatus === 'heater') isHeating = isOn = true;
+                                            else if (hstatus === 'cooling') isCooling = isOn = true;
+                                        }
+                                        break;
+                                    case 'solar':
+                                        if (mode === 'solar' || mode === 'solarpref') {
+                                            if (hstatus === 'solar') isHeating = isOn = true;
+                                            else if (hstatus === 'cooling') isCooling = isOn = true;
+                                        }
+                                        break;
+                                }
+                            }
+                            if (isOn === true && typeof hon.find(elem => elem === heater.id) === 'undefined') {
+                                hon.push(heater.id);
+                                if (heater.master === 1 && isOn) (async () => {
+                                    try {
+                                        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 (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> {
+    try {
+      // First delete the valves that should be removed.
+      for (let i = 0; i < ctx.valves.remove.length; i++) {
+        let v = ctx.valves.remove[i];
+        try {
+          await sys.board.valves.deleteValveAsync(v);
+          res.addModuleSuccess('valve', `Remove: ${v.id}-${v.name}`);
+        } catch (err) { res.addModuleError('valve', `Remove: ${v.id}-${v.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.valves.update.length; i++) {
+        let v = ctx.valves.update[i];
+        try {
+          await sys.board.valves.setValveAsync(v);
+          res.addModuleSuccess('valve', `Update: ${v.id}-${v.name}`);
+        } catch (err) { res.addModuleError('valve', `Update: ${v.id}-${v.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.valves.add.length; i++) {
+        let v = ctx.valves.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.valves.getItemById(ctx.valves.add[i].id, true);
+          await sys.board.valves.setValveAsync(v);
+          res.addModuleSuccess('valve', `Add: ${v.id}-${v.name}`);
+        } catch (err) { res.addModuleError('valve', `Add: ${v.id}-${v.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring valves: ${err.message}`); res.addModuleError('system', `Error restoring valves: ${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 valves.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.valves.length; i++) {
+        let r = cfg.valves[i];
+        let c = sys.valves.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.valves.length; i++) {
+        let c = sys.valves.getItemByIndex(i);
+        let r = cfg.valves.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating valves for restore: ${err.message}`); }
+  }
+
   public async setValveStateAsync(valve: Valve, vstate: ValveState, isDiverted: boolean) {
     if (valve.master === 1) await ncp.valves.setValveStateAsync(vstate, isDiverted);
     else
@@ -2958,39 +3989,146 @@ export class ValveCommands extends BoardCommands {
     } catch (err) { return Promise.reject(new Error(`Error deleting valve: ${err.message}`)); }
     // The following code will make sure we do not encroach on any valves defined by the OCP.
   }
-  public async syncValveStates() {
-    try {
-      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);
-        if (valve.isActive) {
-          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.
-            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);
+    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);
+                if (valve.isActive) {
+                    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) {
+                            // 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) {
+                            // 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);
+                            isDiverted = utils.makeBool(circ.isOn);
+                        }
+                    }
+                    else
+                        isDiverted = false;
+                    vstate.type = valve.type;
+                    vstate.name = valve.name;
+                    await sys.board.valves.setValveStateAsync(valve, vstate, isDiverted);
+                }
             }
-            else {
-              let circ = state.circuits.getInterfaceById(valve.circuit);
-              isDiverted = utils.makeBool(circ.isOn);
+        } 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);
+                }
             }
-          }
-          else
-            isDiverted = false;
-          vstate.type = valve.type;
-          vstate.name = valve.name;
-          await sys.board.valves.setValveStateAsync(valve, vstate, isDiverted);
         }
-      }
-    } catch (err) { logger.error(`syncValveStates: Error synchronizing valves ${err.message}`); }
-  }
+        {
+            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> {
+    try {
+      // First delete the chemControllers that should be removed.
+      for (let i = 0; i < ctx.chemControllers.remove.length; i++) {
+        let c = ctx.chemControllers.remove[i];
+        try {
+          await sys.board.chemControllers.deleteChemControllerAsync(c);
+          res.addModuleSuccess('chemController', `Remove: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chemController', `Remove: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.chemControllers.update.length; i++) {
+        let c = ctx.chemControllers.update[i];
+        try {
+          await sys.board.chemControllers.setChemControllerAsync(c);
+          res.addModuleSuccess('chemController', `Update: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chemController', `Update: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.chemControllers.add.length; i++) {
+        let c = ctx.chemControllers.add[i];
+        try {
+          // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+          // it won't error out.
+          let chem = sys.chemControllers.getItemById(c.id, true);
+          // RSG 11.24.21.  setChemControllerAsync will only set the type/address if it thinks it's new.   
+          // For a restore, if we set the type/address here it will pass the validation steps.
+          chem.type = c.type;
+          // chem.address = c.address;
+          await sys.board.chemControllers.setChemControllerAsync(c);
+          res.addModuleSuccess('chemController', `Add: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chemController', `Add: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring chemControllers: ${err.message}`); res.addModuleError('system', `Error restoring chemControllers: ${err.message}`); return false; }
+  }
+  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
+    try {
+      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      // Look at chemControllers.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.chemControllers.length; i++) {
+        let r = cfg.chemControllers[i];
+        let c = sys.chemControllers.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.chemControllers.length; i++) {
+        let c = sys.chemControllers.getItemByIndex(i);
+        let r = cfg.chemControllers.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating chemControllers for restore: ${err.message}`); }
+  }
+
   public async deleteChemControllerAsync(data: any): Promise<ChemController> {
     try {
       let id = typeof data.id !== 'undefined' ? parseInt(data.id, 10) : -1;
@@ -3075,47 +4213,47 @@ export class ChemControllerCommands extends BoardCommands {
     if (!isNaN(id)) return sys.chemControllers.find(x => x.id === id);
     else if (!isNaN(address)) return sys.chemControllers.find(x => x.address === address);
   }
-  public async setChemControllerAsync(data: any): Promise<ChemController> {
-    // The following are the rules related to when an OCP is present.
-    // ==============================================================
-    // 1. IntelliChem cannot be controlled/polled via Nixie, since there is no enable/disable from the OCP at this point we don't know who is in control of polling.
-    // 2. With *Touch Commands will be sent directly to the IntelliChem controller in the hopes that the OCP will pick it up. Turns out this is not correct.  The TouchBoard now has the proper interface.
-    // 3. njspc will communicate to the OCP for IntelliChem control via the configuration interface.
+    public async setChemControllerAsync(data: any): Promise<ChemController> {
+        // The following are the rules related to when an OCP is present.
+        // ==============================================================
+        // 1. IntelliChem cannot be controlled/polled via Nixie, since there is no enable/disable from the OCP at this point we don't know who is in control of polling.
+        // 2. With *Touch Commands will be sent directly to the IntelliChem controller in the hopes that the OCP will pick it up. Turns out this is not correct.  The TouchBoard now has the proper interface.
+        // 3. njspc will communicate to the OCP for IntelliChem control via the configuration interface.
 
-    // The following are the rules related to when no OCP is present.
-    // =============================================================
-    // 1. All chemControllers will be controlled via Nixie (IntelliChem, REM Chem).
-    try {
-      let chem = sys.board.chemControllers.findChemController(data);
-      let isAdd = typeof chem === 'undefined';
-      let type = sys.board.valueMaps.chemControllerTypes.encode(isAdd ? data.type : chem.type);
-      if (typeof type === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`The chem controller type could not be determined ${data.type || type}`, 'chemController', type));
-      if (isAdd && sys.equipment.maxChemControllers <= sys.chemControllers.length) return Promise.reject(new InvalidEquipmentDataError(`The maximum number of chem controllers have been added to your controller`, 'chemController', sys.equipment.maxChemControllers));
-      let address = parseInt(data.address, 10);
-      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 (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) {
-        // At this point we are going to add the chem controller no matter what.
-        data.id = sys.chemControllers.getNextControllerId(type);
-        chem = sys.chemControllers.getItemById(data.id, true);
-        chem.type = type;
-        if (t.hasAddress) chem.address = address;
-      }
-      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);
-      else
-        await ncp.chemControllers.setControllerAsync(chem, data);
-      return Promise.resolve(chem);
+        // The following are the rules related to when no OCP is present.
+        // =============================================================
+        // 1. All chemControllers will be controlled via Nixie (IntelliChem, REM Chem).
+        try {
+            let chem = sys.board.chemControllers.findChemController(data);
+            let isAdd = typeof chem === 'undefined';
+            let type = sys.board.valueMaps.chemControllerTypes.encode(isAdd ? data.type : chem.type);
+            if (typeof type === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`The chem controller type could not be determined ${data.type || type}`, 'chemController', type));
+            if (isAdd && sys.equipment.maxChemControllers <= sys.chemControllers.length) return Promise.reject(new InvalidEquipmentDataError(`The maximum number of chem controllers have been added to your controller`, 'chemController', sys.equipment.maxChemControllers));
+            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(`${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) {
+                // At this point we are going to add the chem controller no matter what.
+                data.id = sys.chemControllers.getNextControllerId(type);
+                chem = sys.chemControllers.getItemById(data.id, true);
+                chem.type = type;
+                if (t.hasAddress) chem.address = address;
+            }
+            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);
+            else
+                await ncp.chemControllers.setControllerAsync(chem, data);
+            return Promise.resolve(chem);
+        }
+        catch (err) { return Promise.reject(err); }
     }
-    catch (err) { return Promise.reject(err); }
-  }
   public async setChemControllerStateAsync(data: any): Promise<ChemControllerState> {
     // For the most part all of the settable settings for IntelliChem are config settings.  REM is a bit of a different story so that
     // should map to the ncp
@@ -3129,21 +4267,147 @@ export class ChemControllerCommands extends BoardCommands {
   }
 }
 export class FilterCommands extends BoardCommands {
-  public async syncFilterStates() {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the filters that should be removed.
+      for (let i = 0; i < ctx.filters.remove.length; i++) {
+        let filter = ctx.filters.remove[i];
+        try {
+          sys.filters.removeItemById(filter.id);
+          state.filters.removeItemById(filter.id);
+          res.addModuleSuccess('filter', `Remove: ${filter.id}-${filter.name}`);
+        } catch (err) { res.addModuleError('filter', `Remove: ${filter.id}-${filter.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.filters.update.length; i++) {
+        let filter = ctx.filters.update[i];
+        try {
+          await sys.board.filters.setFilterAsync(filter);
+          res.addModuleSuccess('filter', `Update: ${filter.id}-${filter.name}`);
+        } catch (err) { res.addModuleError('filter', `Update: ${filter.id}-${filter.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.filters.add.length; i++) {
+        let filter = ctx.filters.add[i];
+        try {
+          // pull a little trick to first add the data then perform the update.
+          sys.filters.getItemById(filter.id, true);
+          await sys.board.filters.setFilterAsync(filter);
+          res.addModuleSuccess('filter', `Add: ${filter.id}-${filter.name}`);
+        } catch (err) { res.addModuleError('filter', `Add: ${filter.id}-${filter.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring filters: ${err.message}`); res.addModuleError('system', `Error restoring filters: ${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 filters.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.filters.length; i++) {
+        let r = cfg.filters[i];
+        let c = sys.filters.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.filters.length; i++) {
-        // Run through all the valves to see whether they should be triggered or not.
-        let filter = sys.filters.getItemByIndex(i);
-        if (filter.isActive) {
-          let fstate = state.filters.getItemById(filter.id, true);
-          // Check to see if the associated body is on.
-          await sys.board.filters.setFilterStateAsync(filter, fstate, sys.board.bodies.isBodyOn(filter.body));
+        let c = sys.filters.getItemByIndex(i);
+        let r = cfg.filters.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating filters for restore: ${err.message}`); }
+  }
+
+    public async syncFilterStates() {
+        try {
+            for (let i = 0; i < sys.filters.length; i++) {
+                // Run through all the valves to see whether they should be triggered or not.
+                let filter = sys.filters.getItemByIndex(i);
+                if (filter.isActive && !isNaN(filter.id)) {
+                    let fstate = state.filters.getItemById(filter.id, true);
+                    // Check to see if the associated body is on.
+                    await sys.board.filters.setFilterStateAsync(filter, fstate, sys.board.bodies.isBodyOn(filter.body));
+                }
+            }
+        } catch (err) { logger.error(`syncFilterStates: Error synchronizing filters ${err.message}`); }
+    }
+  public async setFilterPressure(id: number, pressure: number, units?: string) {
+    try {
+      let filter = sys.filters.find(elem => elem.id === id);
+      if (typeof filter === 'undefined' || isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`setFilterPressure: Invalid equipmentId ${id}`, id, 'Filter'));
+      if (isNaN(pressure)) return Promise.reject(new InvalidEquipmentDataError(`setFilterPressure: Invalid filter pressure ${pressure} for ${filter.name}`, 'Filter', pressure));
+      let sfilter = state.filters.getItemById(filter.id, true);
+      // Convert the pressure to the units that we have set on the filter for the pressure units.
+      let pu = sys.board.valueMaps.pressureUnits.transform(filter.pressureUnits || 0);
+      if (typeof units === 'undefined' || units === '') units = pu.name;
+      sfilter.pressureUnits = filter.pressureUnits;
+      sfilter.pressure = Math.round(pressure * 1000) / 1000; // Round this to 3 decimal places just in case we are getting stupid scales.
+      // Check to see if our circuit is the only thing on.  If it is then we will be setting our current clean pressure to the incoming pressure and calculating a percentage.
+      // Rules for the circuit.
+      // 1. The assigned circuit must be on.
+      // 2. There must not be a current freeze condition
+      // 3. No heaters can be on.
+      // 4. The assigned circuit must be on exclusively but we will be ignoring any of the light circuit types for the exclusivity.
+      let cstate = state.circuits.getInterfaceById(filter.pressureCircuitId);
+      if (cstate.isOn && state.freeze !== true) {
+        // Ok so our circuit is on.  We need to check to see if any other circuits are on.  This includes heaters.  The reason for this is that even with
+        // a gas heater there may be a heater bypass that will screw up our numbers.  Certainly reflow on a solar heater will skew the numbers.
+        let hon = state.temps.bodies.toArray().find(elem => elem.isOn && (elem.heatStatus || 0) !== 0);
+        if (typeof hon === 'undefined') {
+          // Put together the circuit types that could be lights.  We don't want these.
+          let ctypes = [];
+          let funcs = sys.board.valueMaps.circuitFunctions.toArray();
+          for (let i = 0; i < funcs.length; i++) {
+            let f = funcs[i];
+            if (f.isLight) ctypes.push(f.val);
+          }
+          let con = state.circuits.find(elem => elem.isOn === true && elem.id !== filter.pressureCircuitId && elem.id !== 1 && elem.id !== 6 && !ctypes.includes(elem.type));
+          if (typeof con === 'undefined') {
+            // This check is the one that will be the most problematic.  For this reason we are only going to check features that are not generic.  If they are spillway
+            // it definitely has to be off.
+            let feats = state.features.toArray();
+            let fon = false;
+            for (let i = 0; i < feats.length && fon === false; i++) {
+              let f = feats[i];
+              if (!f.isOn) continue;
+              if (f.id === filter.pressureCircuitId) continue;
+              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')
+                fon = true;
+              else {
+                // Finally if the feature happens to be used on a pump then we don't want it either.
+                let pumps = sys.pumps.get();
+                for (let j = 0; j < pumps.length; j++) {
+                  let pmp = pumps[j];
+                  if (typeof pmp.circuits !== 'undefined') {
+                    if (typeof pmp.circuits.find(elem => elem.circuit === f.id) !== 'undefined') {
+                      fon = true;
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+            if (!fon) {
+              // Finally we have a value we can believe in.
+              sfilter.refPressure = pressure;
+            }
+          }
+          else {
+            logger.verbose(`Circuit ${con.id}-${con.name} is currently on filter pressure for cleaning ignored.`);
+          }
+        }
+        else {
+          logger.verbose(`Heater for body ${hon.name} is currently on ${hon.heatStatus} filter pressure for cleaning skipped.`);
         }
       }
-    } catch (err) { logger.error(`syncFilterStates: Error synchronizing filters ${err.message}`); }
+      sfilter.emitEquipmentChange();
+    }
+    catch (err) { logger.error(`setFilterPressure: Error setting filter #${id} pressure to ${pressure}${units || ''}`); }
   }
   public async setFilterStateAsync(filter: Filter, fstate: FilterState, isOn: boolean) { fstate.isOn = isOn; }
-  public setFilter(data: any): any {
+  public async setFilterAsync(data: any): Promise<Filter> {
     let id = typeof data.id === 'undefined' ? -1 : parseInt(data.id, 10);
     if (id <= 0) id = sys.filters.length + 1; // set max filters?
     if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid filter id: ${data.id}`, data.id, 'Filter'));
@@ -3152,50 +4416,48 @@ export class FilterCommands extends BoardCommands {
     let filterType = typeof data.filterType !== 'undefined' ? parseInt(data.filterType, 10) : filter.filterType;
     if (typeof filterType === 'undefined') filterType = sys.board.valueMaps.filterTypes.getValue('unknown');
 
-    if (typeof data.isActive !== 'undefined') {
-      if (utils.makeBool(data.isActive) === false) {
-        sys.filters.removeItemById(id);
-        state.filters.removeItemById(id);
-        return;
-      }
-    }
+    // The only way to delete a filter is to call deleteFilterAsync.
+    //if (typeof data.isActive !== 'undefined') {
+    //    if (utils.makeBool(data.isActive) === false) {
+    //        sys.filters.removeItemById(id);
+    //        state.filters.removeItemById(id);
+    //        return;
+    //    }
+    //}
 
     let body = typeof data.body !== 'undefined' ? data.body : filter.body;
     let name = typeof data.name !== 'undefined' ? data.name : filter.name;
-
-    let psi = typeof data.psi !== 'undefined' ? parseFloat(data.psi) : sfilter.psi;
-    let lastCleanDate = typeof data.lastCleanDate !== 'undefined' ? data.lastCleanDate : sfilter.lastCleanDate;
-    let filterPsi = typeof data.filterPsi !== 'undefined' ? parseInt(data.filterPsi, 10) : sfilter.filterPsi;
-    let needsCleaning = typeof data.needsCleaning !== 'undefined' ? data.needsCleaning : sfilter.needsCleaning;
-
-    // Ensure all the defaults.
-    if (isNaN(psi)) psi = 0;
     if (typeof body === 'undefined') body = 32;
-
     // At this point we should have all the data.  Validate it.
     if (!sys.board.valueMaps.filterTypes.valExists(filterType)) return Promise.reject(new InvalidEquipmentDataError(`Invalid filter type; ${filterType}`, 'Filter', filterType));
 
+    filter.pressureUnits = typeof data.pressureUnits !== 'undefined' ? data.pressureUnits || 0 : filter.pressureUnits || 0;
+    filter.pressureCircuitId = parseInt(data.pressureCircuitId || filter.pressureCircuitId || 6, 10);
+    filter.cleanPressure = parseFloat(data.cleanPressure || filter.cleanPressure || 0);
+    filter.dirtyPressure = parseFloat(data.dirtyPressure || filter.dirtyPressure || 0);
+
     filter.filterType = sfilter.filterType = filterType;
     filter.body = sfilter.body = body;
-    filter.filterType = sfilter.filterType = filterType;
     filter.name = sfilter.name = name;
     filter.capacity = typeof data.capacity === 'number' ? data.capacity : filter.capacity;
     filter.capacityUnits = typeof data.capacityUnits !== 'undefined' ? data.capacityUnits : filter.capacity;
-    sfilter.psi = psi;
-    sfilter.filterPsi = filterPsi;
-    filter.needsCleaning = sfilter.needsCleaning = needsCleaning;
-    filter.lastCleanDate = sfilter.lastCleanDate = lastCleanDate;
     filter.connectionId = typeof data.connectionId !== 'undefined' ? data.connectionId : filter.connectionId;
     filter.deviceBinding = typeof data.deviceBinding !== 'undefined' ? data.deviceBinding : filter.deviceBinding;
+    sfilter.pressureUnits = filter.pressureUnits;
+    sfilter.calcCleanPercentage();
     sfilter.emitEquipmentChange();
     return filter; // Always return the config when we are dealing with the config not state.
   }
-
-  public deleteFilter(data: any): any {
-    let id = typeof data.id === 'undefined' ? -1 : parseInt(data.id, 10);
-    if (isNaN(id)) return;
-    sys.filters.removeItemById(id);
-    state.filters.removeItemById(id);
-    return state.filters.getItemById(id);
+  public async deleteFilterAsync(data: any): Promise<Filter> {
+    try {
+      let id = typeof data.id === 'undefined' ? -1 : parseInt(data.id, 10);
+      let filter = sys.filters.getItemById(id);
+      let sfilter = state.filters.getItemById(filter.id);
+      filter.isActive = false;
+      sys.filters.removeItemById(id);
+      state.filters.removeItemById(id);
+      sfilter.emitEquipmentChange();
+      return filter;
+    } catch (err) { logger.error(`deleteFilterAsync: Error deleting filter ${err.message}`); }
   }
-}
+}