nodejs-poolcontroller 8.0.1 → 8.0.4

package/controller/boards/IntelliCenterBoard.ts

@@ -26,6 +26,7 @@ import { state, ChlorinatorState, LightGroupState, VirtualCircuitState, ICircuit
 import { utils } from '../../controller/Constants';
 import { InvalidEquipmentIdError, InvalidEquipmentDataError, EquipmentNotFoundError, MessageError, InvalidOperationError } from '../Errors';
 import { ncp } from '../nixie/Nixie';
+import { Timestamp } from "../Constants"
 export class IntelliCenterBoard extends SystemBoard {
     public needsConfigChanges: boolean = false;
     constructor(system: PoolSystem) {
@@ -389,6 +390,10 @@ export class IntelliCenterBoard extends SystemBoard {
         for (let i = 0; i < sys.circuits.length; i++) {
             let c = sys.circuits.getItemByIndex(i);
             if (c.id <= 40) c.master = 0;
+            if (typeof sys.board.valueMaps.circuitFunctions.get(c.type).isLight) {
+                let s = state.circuits.getItemById(c.id);
+                if (s.action !== 0) s.action = 0;
+            }
         }
         for (let i = 0; i < sys.valves.length; i++) {
             let v = sys.valves.getItemByIndex(i);
@@ -2168,6 +2173,7 @@ class IntelliCenterCircuitCommands extends CircuitCommands {
             255, 255, 0, 0, 0, 0], // 30-35
             3);
 
+
         // Circuits are always contiguous so we don't have to worry about
         // them having a strange offset like features and groups. However, in
         // single body systems they start with 2.
@@ -2175,13 +2181,14 @@ class IntelliCenterCircuitCommands extends CircuitCommands {
             // We are using the index and setting the circuits based upon
             // the index.  This way it doesn't matter what the sort happens to
             // be and whether there are gaps in the ids or not.  The ordinal is the bit number.
-            let circuit = state.circuits.getItemByIndex(i);
-            let ordinal = circuit.id - 1;
+            let cstate = state.circuits.getItemByIndex(i);
+            let ordinal = cstate.id - 1;
+            if (ordinal >= 40) continue;
             let ndx = Math.floor(ordinal / 8);
             let byte = out.payload[ndx + 3];
             let bit = ordinal - (ndx * 8);
-            if (circuit.id === id) byte = isOn ? byte = byte | (1 << bit) : byte;
-            else if (circuit.isOn) byte = byte | (1 << bit);
+            if (cstate.id === id) byte = isOn ? byte = byte | (1 << bit) : byte;
+            else if (cstate.isOn) byte = byte | (1 << bit);
             out.payload[ndx + 3] = byte;
         }
         // Set the bits for the features.
@@ -2191,6 +2198,7 @@ class IntelliCenterCircuitCommands extends CircuitCommands {
             // be and whether there are gaps in the ids or not.  The ordinal is the bit number.
             let feature = state.features.getItemByIndex(i);
             let ordinal = feature.id - sys.board.equipmentIds.features.start;
+            if (ordinal >= 32) continue;
             let ndx = Math.floor(ordinal / 8);
             let byte = out.payload[ndx + 9];
             let bit = ordinal - (ndx * 8);
@@ -2202,6 +2210,7 @@ class IntelliCenterCircuitCommands extends CircuitCommands {
         for (let i = 0; i < state.data.circuitGroups.length; i++) {
             let group = state.circuitGroups.getItemByIndex(i);
             let ordinal = group.id - sys.board.equipmentIds.circuitGroups.start;
+            if (ordinal >= 16) continue;
             let ndx = Math.floor(ordinal / 8);
             let byte = out.payload[ndx + 13];
             let bit = ordinal - (ndx * 8);
@@ -2213,6 +2222,7 @@ class IntelliCenterCircuitCommands extends CircuitCommands {
         for (let i = 0; i < state.data.lightGroups.length; i++) {
             let group = state.lightGroups.getItemByIndex(i);
             let ordinal = group.id - sys.board.equipmentIds.circuitGroups.start;
+            if (ordinal >= 16) continue;
             let ndx = Math.floor(ordinal / 8);
             let byte = out.payload[ndx + 13];
             let bit = ordinal - (ndx * 8);
@@ -2248,6 +2258,7 @@ class IntelliCenterCircuitCommands extends CircuitCommands {
         for (let i = 0; i < state.data.schedules.length; i++) {
             let sched = state.schedules.getItemByIndex(i);
             let ordinal = sched.id - 1;
+            if (ordinal >= 100) continue;
             let ndx = Math.floor(ordinal / 8);
             let byte = out.payload[ndx + 15];
             let bit = ordinal - (ndx * 8);
@@ -2258,9 +2269,9 @@ class IntelliCenterCircuitCommands extends CircuitCommands {
                     let dow = dt.getDay();
                     // Convert the dow to the bit value.
                     let sd = sys.board.valueMaps.scheduleDays.toArray().find(elem => elem.dow === dow);
-                    let dayVal = sd.bitVal || sd.val;  // The bitval allows mask overrides.
+                    //let dayVal = sd.bitVal || sd.val;  // The bitval allows mask overrides.
                     let ts = dt.getHours() * 60 + dt.getMinutes();
-                    if ((sched.scheduleDays & dayVal) > 0 && ts >= sched.startTime && ts <= sched.endTime) byte = byte | (1 << bit);
+                    if ((sched.scheduleDays & sd.bitval) > 0 && ts >= sched.startTime && ts <= sched.endTime) byte = byte | (1 << bit);
                 }
             }
             else if (sched.isOn) byte = byte | (1 << bit);
@@ -2817,6 +2828,7 @@ class IntelliCenterBodyCommands extends BodyCommands {
         body2: { heatMode: number, heatSetpoint: number, coolSetpoint: number }
     };
     private async queueBodyHeatSettings(bodyId?: number, byte?: number, data?: any): Promise<Boolean> {
+        logger.debug(`queueBodyHeatSettings: ${JSON.stringify(this.bodyHeatSettings)}`);  // remove this line if #848 is fixed
         if (typeof this.bodyHeatSettings === 'undefined') {
             let body1 = sys.bodies.getItemById(1);
             let body2 = sys.bodies.getItemById(2);
@@ -2862,21 +2874,30 @@ class IntelliCenterBodyCommands extends BodyCommands {
                 retries: 2,
                 response: IntelliCenterBoard.getAckResponse(168)
             });
-            await out.sendAsync();
-            let body1 = sys.bodies.getItemById(1);
-            let sbody1 = state.temps.bodies.getItemById(1);
-            body1.heatMode = sbody1.heatMode = bhs.body1.heatMode;
-            body1.heatSetpoint = sbody1.heatSetpoint = bhs.body1.heatSetpoint;
-            body1.coolSetpoint = sbody1.coolSetpoint = bhs.body1.coolSetpoint;
-            if (sys.equipment.dual || sys.equipment.shared) {
-                let body2 = sys.bodies.getItemById(2);
-                let sbody2 = state.temps.bodies.getItemById(2);
-                body2.heatMode = sbody2.heatMode = bhs.body2.heatMode;
-                body2.heatSetpoint = sbody2.heatSetpoint = bhs.body2.heatSetpoint;
-                body2.coolSetpoint = sbody2.coolSetpoint = bhs.body2.coolSetpoint;
-            }
-            bhs.processing = false;
-            state.emitEquipmentChanges();
+            try {
+                await out.sendAsync();
+                let body1 = sys.bodies.getItemById(1);
+                let sbody1 = state.temps.bodies.getItemById(1);
+                body1.heatMode = sbody1.heatMode = bhs.body1.heatMode;
+                body1.heatSetpoint = sbody1.heatSetpoint = bhs.body1.heatSetpoint;
+                body1.coolSetpoint = sbody1.coolSetpoint = bhs.body1.coolSetpoint;
+                if (sys.equipment.dual || sys.equipment.shared) {
+                    let body2 = sys.bodies.getItemById(2);
+                    let sbody2 = state.temps.bodies.getItemById(2);
+                    body2.heatMode = sbody2.heatMode = bhs.body2.heatMode;
+                    body2.heatSetpoint = sbody2.heatSetpoint = bhs.body2.heatSetpoint;
+                    body2.coolSetpoint = sbody2.coolSetpoint = bhs.body2.coolSetpoint;
+                }
+                state.emitEquipmentChanges();
+            } catch (err) {
+                bhs.processing = false;
+                bhs.bytes = [];
+                throw (err);
+            }
+            finally {
+                bhs.processing = false;
+                bhs.bytes = [];
+            }
             return true;
         }
         else {
@@ -2885,7 +2906,10 @@ class IntelliCenterBodyCommands extends BodyCommands {
                 setTimeout(async () => {
                     try {
                         await this.queueBodyHeatSettings();
-                    } catch (err) { logger.error(`Error sending queued body setpoint message: ${err.message}`); }
+                    } catch (err) {
+                        logger.error(`Error sending queued body setpoint message: ${err.message}`);
+                        throw (err);
+                    }
                 }, 3000);
             }
             else bhs.processing = false;
@@ -3119,6 +3143,7 @@ class IntelliCenterBodyCommands extends BodyCommands {
     }
 }
 class IntelliCenterScheduleCommands extends ScheduleCommands {
+    _lastScheduleCheck: number = 0;
     public async setScheduleAsync(data: any): Promise<Schedule> {
         if (typeof data.id !== 'undefined') {
             let id = typeof data.id === 'undefined' ? -1 : parseInt(data.id, 10);
@@ -3141,6 +3166,8 @@ class IntelliCenterScheduleCommands extends ScheduleCommands {
             let endTime = typeof data.endTime !== 'undefined' ? data.endTime : sched.endTime;
             let schedDays = sys.board.schedules.transformDays(typeof data.scheduleDays !== 'undefined' ? data.scheduleDays : sched.scheduleDays);
             let display = typeof data.display !== 'undefined' ? data.display : sched.display || 0;
+            let endTimeOffset = typeof data.endTimeOffset !== 'undefined' ? data.endTimeOffset : sched.endTimeOffset;
+            let startTimeOffset = typeof data.startTimeOffset !== 'undefined' ? data.startTimeOffset : sched.startTimeOffset;
 
             // Ensure all the defaults.
             if (isNaN(startDate.getTime())) startDate = new Date();
@@ -3216,11 +3243,45 @@ class IntelliCenterScheduleCommands extends ScheduleCommands {
             ssched.isActive = sched.isActive = true;
             ssched.display = sched.display = display;
             ssched.emitEquipmentChange();
+            ssched.startTimeOffset = sched.startTimeOffset = startTimeOffset;
+            ssched.endTimeOffset = sched.endTimeOffset = endTimeOffset;
             return sched;
         }
         else
             return Promise.reject(new InvalidEquipmentIdError('No schedule information provided', undefined, 'Schedule'));
     }
+    public syncScheduleStates() {
+        // This is triggered from the 204 message in IntelliCenter.  We will
+        // be checking to ensure it does not load the server so we only do this every 10 seconds.
+        if (this._lastScheduleCheck > new Date().getTime() - 10000) return;
+        try {
+            // The call below also calculates the schedule window either the current or next.
+            ncp.schedules.triggerSchedules();  // At this point we are not adding Nixie schedules to IntelliCenter but this will trigger
+            // the proper time windows if they exist.
+            // Check each running circuit/feature to see when it will be going off.
+            let scheds = state.schedules.getActiveSchedules();
+            let circs: { state: ICircuitState, endTime: number }[] = [];
+            for (let i = 0; i < scheds.length; i++) {
+                let ssched = scheds[i];
+                if (!ssched.isOn || ssched.disabled || !ssched.isActive) continue;
+                let c = circs.find(x => x.state.id === ssched.circuit);
+                if (typeof c === 'undefined') {
+                    let cstate = state.circuits.getInterfaceById(ssched.circuit);
+                    c = { state: cstate, endTime: ssched.scheduleTime.endTime.getTime() };
+                    circs.push;
+                }
+                if (c.endTime < ssched.scheduleTime.endTime.getTime()) c.endTime = ssched.scheduleTime.endTime.getTime();
+            }
+            for (let i = 0; i < circs.length; i++) {
+                let c = circs[i];
+                if (c.state.endTime.getTime() !== c.endTime) {
+                    c.state.endTime = new Timestamp(new Date(c.endTime));
+                    c.state.emitEquipmentChange();
+                }
+            }
+            this._lastScheduleCheck = new Date().getTime();
+        } catch (err) { logger.error(`Error synchronizing schedule states`); }
+    }
     public async deleteScheduleAsync(data: any): Promise<Schedule> {
         if (typeof data.id !== 'undefined') {
             let id = typeof data.id === 'undefined' ? -1 : parseInt(data.id, 10);
@@ -3484,7 +3545,7 @@ class IntelliCenterHeaterCommands extends HeaterCommands {
             if (gasHeaterInstalled) sys.board.valueMaps.heatSources.merge([[2, { name: 'heater', desc: 'Heater' }]]);
             if (mastertempInstalled) sys.board.valueMaps.heatSources.merge([[11, { name: 'mtheater', desc: 'MasterTemp' }]]);
             if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatSources.merge([[3, { name: 'solar', desc: 'Solar Only', hasCoolSetpoint: htypes.hasCoolSetpoint }], [4, { name: 'solarpref', desc: 'Solar Preferred', hasCoolSetpoint: htypes.hasCoolSetpoint }]]);
-            else if (solarInstalled) sys.board.valueMaps.heatSources.merge([[3, { name: 'solar', desc: 'Solar', hasCoolsetpoint: htypes.hasCoolSetpoint }]]);
+            else if (solarInstalled) sys.board.valueMaps.heatSources.merge([[3, { name: 'solar', desc: 'Solar', hasCoolSetpoint: htypes.hasCoolSetpoint }]]);
             if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatSources.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Pref' }]]);
             else if (heatPumpInstalled) sys.board.valueMaps.heatSources.merge([[9, { name: 'heatpump', desc: 'Heat Pump' }]]);
             if (ultratempInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatSources.merge([[5, { name: 'ultratemp', desc: 'UltraTemp Only', hasCoolSetpoint: htypes.hasCoolSetpoint }], [6, { name: 'ultratemppref', desc: 'UltraTemp Pref', hasCoolSetpoint: htypes.hasCoolSetpoint }]]);

package/controller/boards/IntelliTouchBoard.ts

@@ -86,7 +86,7 @@ export class IntelliTouchBoard extends EasyTouchBoard {
 
         }
         if (typeof sys.valves.find((v) => v.id === 2) === 'undefined') {
-            let valve = sys.valves.getItemById(1, true);
+            let valve = sys.valves.getItemById(2, true);
             valve.isIntake = false;
             valve.isReturn = false;
             valve.type = 0;
@@ -360,9 +360,7 @@ class ITTouchConfigQueue extends TouchConfigQueue {
         this.queueItems(GetTouchConfigCategories.highSpeedCircuits, [0]);
         this.queueRange(GetTouchConfigCategories.pumpConfig, 1, sys.equipment.maxPumps);
         this.queueRange(GetTouchConfigCategories.circuitGroups, 0, sys.equipment.maxFeatures - 1);
-        // items not required by ScreenLogic
-        if (sys.chlorinators.getItemById(1).isActive)
-            this.queueItems(GetTouchConfigCategories.intellichlor, [0]);
+        this.queueItems(GetTouchConfigCategories.intellichlor, [0]);
         if (this.remainingItems > 0) {
             var self = this;
             setTimeout(() => { self.processNext(); }, 50);

package/controller/boards/NixieBoard.ts

@@ -18,7 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import * as extend from 'extend';
 import { ncp } from "../nixie/Nixie";
 import { NixieHeaterBase } from "../nixie/heaters/Heater";
-import { utils } from '../Constants';
+import { Timestamp, utils } from '../Constants';
 import {SystemBoard, byteValueMap, BodyCommands, FilterCommands, PumpCommands, SystemCommands, CircuitCommands, FeatureCommands, ValveCommands, HeaterCommands, ChlorinatorCommands, ChemControllerCommands, EquipmentIdRange} from './SystemBoard';
 import { logger } from '../../logger/Logger';
 import { state, CircuitState, ICircuitState, ICircuitGroupState, LightGroupState, ValveState, FilterState, BodyTempState, FeatureState } from '../State';
@@ -221,6 +221,21 @@ export class NixieBoard extends SystemBoard {
             [53, { name: 'greenblue', desc: 'Green-Blue', types: ['pooltone'], sequence: 14 }],
             [54, { name: 'redgreen', desc: 'Red-Green', types: ['pooltone'], sequence: 15 }],
             [55, { name: 'bluered', desc: 'Blue-red', types: ['pooltone'], sequence: 16 }],
+            // Jandy Pro Series WaterColors Themes
+            [56, { name: 'alpinewhite', desc: 'Alpine White', types: ['watercolors'], sequence: 1 }],
+            [57, { name: 'skyblue', desc: 'Sky Blue', types: ['watercolors'], sequence: 2 }],
+            [58, { name: 'cobaltblue', desc: 'Cobalt Blue', types: ['watercolors'], sequence: 3 }],
+            [59, { name: 'caribbeanblue', desc: 'Caribbean Blue', types: ['watercolors'], sequence: 4 }],
+            [60, { name: 'springgreen', desc: 'Spring Green', types: ['watercolors'], sequence: 5 }],
+            [61, { name: 'emeraldgreen', desc: 'Emerald Green', types: ['watercolors'], sequence: 6 }],
+            [62, { name: 'emeraldrose', desc: 'Emerald Rose', types: ['watercolors'], sequence: 7 }],
+            [63, { name: 'magenta', desc: 'Magenta', types: ['watercolors'], sequence: 8 }],
+            [64, { name: 'violet', desc: 'Violet', types: ['watercolors'], sequence: 9 }],
+            [65, { name: 'slowcolorsplash', desc: 'Slow Color Splash', types: ['watercolors'], sequence: 10 }],
+            [66, { name: 'fastcolorsplash', desc: 'Fast Color Splash', types: ['watercolors'], sequence: 11 }],
+            [67, { name: 'americathebeautiful', desc: 'America the Beautiful', types: ['watercolors'], sequence: 12 }],
+            [68, { name: 'fattuesday', desc: 'Fat Tuesday', types: ['watercolors'], sequence: 13 }],
+            [69, { name: 'discotech', desc: 'Disco Tech', types: ['watercolors'], sequence: 14 }],
             [255, { name: 'none', desc: 'None' }]
         ]);
         this.valueMaps.lightColors = new byteValueMap([
@@ -266,9 +281,35 @@ export class NixieBoard extends SystemBoard {
             [4, { name: 'spaCommand', desc: 'Spa Command', maxButtons: 10 }]
         ]);
     }
+    public async closeAsync() {
+        logger.info(`Closing Nixie Board`);
+        await ncp.closeAsync();
+    }
     public async checkConfiguration() {
         state.status = sys.board.valueMaps.controllerStatus.transform(0, 0);
         state.emitControllerChange();
+        // Set all the schedule data based upon the config.
+        for (let i = 0; i < sys.schedules.length; i++) {
+            let sched = sys.schedules.getItemByIndex(i);
+            let ssched = state.schedules.getItemById(sched.id, true);
+            ssched.circuit = sched.circuit;
+            ssched.scheduleDays = sched.scheduleDays;
+            ssched.scheduleType = sched.scheduleType;
+            ssched.changeHeatSetpoint = sched.changeHeatSetpoint;
+            ssched.heatSetpoint = sched.heatSetpoint;
+            ssched.coolSetpoint = sched.coolSetpoint;
+            ssched.heatSource = sched.heatSource;
+            ssched.startTime = sched.startTime;
+            ssched.endTime = sched.endTime;
+            ssched.startTimeType = sched.startTimeType;
+            ssched.endTimeType = sched.endTimeType;
+            ssched.startDate = sched.startDate;
+            ssched.isActive = sched.isActive = true;
+            sched.disabled = sched.disabled;
+            ssched.display = sched.display;
+
+        }
+
         state.status = sys.board.valueMaps.controllerStatus.transform(1, 100);
         state.emitControllerChange();
     }
@@ -390,7 +431,7 @@ export class NixieBoard extends SystemBoard {
                 sys.circuits.removeItemById(6);
                 state.circuits.removeItemById(6);
             }
-            
+
             sys.equipment.setEquipmentIds();
             sys.board.bodies.initFilters();
             state.status = sys.board.valueMaps.controllerStatus.transform(2, 0);
@@ -411,10 +452,11 @@ export class NixieBoard extends SystemBoard {
             sys.board.heaters.updateHeaterServices();
             state.cleanupState();
             logger.info(`${sys.equipment.model} control board initialized`);
-            state.status = sys.board.valueMaps.controllerStatus.transform(1, 100);
+            //state.status = sys.board.valueMaps.controllerStatus.transform(1, 100);
             state.mode = sys.board.valueMaps.panelModes.encode('auto');
             // At this point we should have the start of a board so lets check to see if we are ready or if we are stuck initializing.
             await setTimeout(5000);
+            state.status = sys.board.valueMaps.controllerStatus.transform(1, 100);
             await self.processStatusAsync();
         } catch (err) { state.status = 255; logger.error(`Error Initializing Nixie Control Panel ${err.message}`); }
     }
@@ -529,11 +571,11 @@ export class NixieSystemCommands extends SystemCommands {
         state.delay = sys.board.valueMaps.delay.getValue('nodelay');
         return Promise.resolve(state.data.delay);
     }
-    public setManualOperationPriority(id: number): Promise<any> { 
+    public setManualOperationPriority(id: number): Promise<any> {
         let cstate = state.circuits.getInterfaceById(id);
         delayMgr.setManualPriorityDelay(cstate);
-        return Promise.resolve(cstate); 
-     }
+        return Promise.resolve(cstate);
+    }
     public setDateTimeAsync(obj: any): Promise<any> { return Promise.resolve(); }
     public getDOW() { return this.board.valueMaps.scheduleDays.toArray(); }
     public async setGeneralAsync(obj: any): Promise<General> {
@@ -669,7 +711,6 @@ export class NixieCircuitCommands extends CircuitCommands {
                     break;
                 default:
                     await ncp.circuits.setCircuitStateAsync(circ, newState);
-                    await sys.board.processStatusAsync();
                     break;
             }
             // Let the main nixie controller set the circuit state and affect the relays if it needs to.
@@ -680,6 +721,7 @@ export class NixieCircuitCommands extends CircuitCommands {
             state.emitEquipmentChanges();
             ncp.pumps.syncPumpStates();
             sys.board.suspendStatus(false);
+            await sys.board.processStatusAsync();
         }
     }
     protected async setCleanerCircuitStateAsync(id: number, val: boolean, ignoreDelays?: boolean): Promise<ICircuitState> {
@@ -742,8 +784,9 @@ export class NixieCircuitCommands extends CircuitCommands {
                     }
                     if (sys.general.options.cleanerStartDelay && sys.general.options.cleanerStartDelayTime) {
                         let bcstate = state.circuits.getItemById(bstate.circuit);
+                        let stime = typeof bcstate.startTime === 'undefined' ? dtNow : (dtNow - bcstate.startTime.getTime());
                         // So we should be started.  Lets determine whethere there should be any delay.
-                        delayTime = Math.max(Math.round(((sys.general.options.cleanerStartDelayTime * 1000) - (dtNow - bcstate.startTime.getTime())) / 1000), delayTime);
+                        delayTime = Math.max(Math.round(((sys.general.options.cleanerStartDelayTime * 1000) - stime) / 1000), delayTime);
                         logger.info(`Cleaner delay time calculated to ${delayTime}`);
                     }
                 }
@@ -864,6 +907,7 @@ export class NixieCircuitCommands extends CircuitCommands {
                 // circuit is already under delay it should have been processed out earlier.
                 delayMgr.cancelPumpValveDelays();
                 delayMgr.cancelHeaterStartupDelays();
+                sys.board.heaters.clearPrevHeaterOffTemp();
                 if (cstate.startDelay) delayMgr.clearBodyStartupDelay(bstate);
                 await this.turnOffCleanerCircuits(bstate);
                 if (sys.equipment.shared && bstate.id === 2) await this.turnOffDrainCircuits(ignoreDelays);
@@ -967,7 +1011,7 @@ export class NixieCircuitCommands extends CircuitCommands {
             return cstate;
         } catch (err) { logger.error(`Nixie: Error setDrainCircuitStateAsync ${err.message}`); return Promise.reject(new BoardProcessError(`Nixie: Error setDrainCircuitStateAsync ${err.message}`, 'setDrainCircuitStateAsync')); }
     }
-    
+
     public toggleCircuitStateAsync(id: number): Promise<ICircuitState> {
         let circ = state.circuits.getInterfaceById(id);
         return this.setCircuitStateAsync(id, !(circ.isOn || false));
@@ -1112,7 +1156,7 @@ export class NixieCircuitCommands extends CircuitCommands {
             if (typeof obj.eggTimer !== 'undefined') group.eggTimer = Math.min(Math.max(parseInt(obj.eggTimer, 10), 0), 1440);
             if (typeof obj.showInFeatures !== 'undefined') sgroup.showInFeatures = group.showInFeatures = utils.makeBool(obj.showInFeatures);
             sgroup.type = group.type;
-            
+
             group.dontStop = group.eggTimer === 1440;
             group.isActive = sgroup.isActive = true;
 
@@ -1179,7 +1223,7 @@ export class NixieCircuitCommands extends CircuitCommands {
                 // group.circuits.length = obj.circuits.length; // RSG - removed as this will delete circuits that were not changed
                 group.circuits.length = obj.circuits.length;
                 sgroup.emitEquipmentChange();
-                
+
             }
             resolve(group);
         });
@@ -1266,7 +1310,7 @@ export class NixieCircuitCommands extends CircuitCommands {
         //grp.lightingTheme = sgrp.lightingTheme = theme;
         let thm = sys.board.valueMaps.lightThemes.transform(theme);
         sgrp.action = sys.board.valueMaps.circuitActions.getValue('lighttheme');
-       
+
         try {
             // Go through and set the theme for all lights in the group.
             for (let i = 0; i < grp.circuits.length; i++) {
@@ -1380,7 +1424,7 @@ export class NixieCircuitCommands extends CircuitCommands {
             else if (circuit.desiredState === 5){
                 // off/ignore
                 if (val) cval = false;
-                else continue; 
+                else continue;
             }
             await sys.board.circuits.setCircuitStateAsync(circuit.circuit, cval);
             //arr.push(sys.board.circuits.setCircuitStateAsync(circuit.circuit, cval));
@@ -1402,13 +1446,23 @@ export class NixieCircuitCommands extends CircuitCommands {
         let arr = [];
         for (let i = 0; i < circuits.length; i++) {
             let circuit = circuits[i];
-            arr.push(sys.board.circuits.setCircuitStateAsync(circuit.circuit, val));
+            // RSG 4/3/24 - This function was executing and returing the results to the array; not pushing the fn to the array.
+            //arr.push(sys.board.circuits.setCircuitStateAsync(circuit.circuit, val));
+            arr.push(async () => { await sys.board.circuits.setCircuitStateAsync(circuit.circuit, val) });
         }
+        // return new Promise<ICircuitGroupState>(async (resolve, reject) => {
+        //     await Promise.all(arr).catch((err) => { reject(err) });
+        //     resolve(gstate);
+        // });
         return new Promise<ICircuitGroupState>(async (resolve, reject) => {
-            await Promise.all(arr).catch((err) => { reject(err) });
-            resolve(gstate);
+            try {
+                Promise.all(arr.map(async func => await func()));
+                resolve(gstate);
+            } catch (err) {
+                reject(err);
+            };
         });
-    }
+     };
 }
 export class NixieFeatureCommands extends FeatureCommands {
     public async setFeatureAsync(obj: any): Promise<Feature> {
@@ -1484,7 +1538,7 @@ export class NixieFeatureCommands extends FeatureCommands {
             if (!val){
                 if (fstate.manualPriorityActive) delayMgr.cancelManualPriorityDelay(fstate.id);
                 fstate.manualPriorityActive = false; // if the delay was previously cancelled, still need to turn this off
-            } 
+            }
             state.emitEquipmentChanges();
             return fstate;
         } catch (err) { return Promise.reject(new Error(`Error setting feature state ${err.message}`)); }
@@ -1572,7 +1626,7 @@ export class NixieFeatureCommands extends FeatureCommands {
                     let circuit: CircuitGroupCircuit = grp.circuits.getItemByIndex(j);
                     let cstate = state.circuits.getInterfaceById(circuit.circuit);
                     // RSG: desiredState for Nixie is 1=on, 2=off, 3=ignore
-                    if (circuit.desiredState === 1 || circuit.desiredState === 4) { 
+                    if (circuit.desiredState === 1 || circuit.desiredState === 4) {
                         // The circuit should be on if the value is 1.
                         // If we are on 'ignore' we should still only treat the circuit as 
                         // desiredstate = 1.
@@ -1583,12 +1637,15 @@ export class NixieFeatureCommands extends FeatureCommands {
                     }
                 }
                 let sgrp = state.circuitGroups.getItemById(grp.id);
+                if (bIsOn && typeof sgrp.endTime === 'undefined') {
+                    sys.board.circuits.setEndTime(grp, sgrp, bIsOn, true);
+                }
                 sgrp.isOn = bIsOn;
-                if (sgrp.isOn && typeof sgrp.endTime === 'undefined') sys.board.circuits.setEndTime(grp, sgrp, sgrp.isOn, true);
+
                 if (!sgrp.isOn && sgrp.manualPriorityActive){
                     delayMgr.cancelManualPriorityDelays();
                     sgrp.manualPriorityActive = false; // if the delay was previously cancelled, still need to turn this off
-                } 
+                }
             }
             sys.board.valves.syncValveStates();
         }
@@ -1610,9 +1667,9 @@ export class NixieFeatureCommands extends FeatureCommands {
                 if (!sgrp.isOn && sgrp.manualPriorityActive){
                     delayMgr.cancelManualPriorityDelay(grp.id);
                     sgrp.manualPriorityActive = false; // if the delay was previously cancelled, still need to turn this off
-                } 
+                }
             }
-            
+
             sys.board.valves.syncValveStates();
         }
         state.emitEquipmentChanges();
@@ -1644,8 +1701,8 @@ export class NixiePumpCommands extends PumpCommands {
                             // to bodies.
                             console.log(`Body: ${pump.body} Pump: ${pump.name} Pool: ${circuitIds.includes(6)} `);
                             if ((pump.body === 255 && (circuitIds.includes(6) || circuitIds.includes(1))) ||
-                            (pump.body === 0 && circuitIds.includes(6)) ||
-                            (pump.body === 101 && circuitIds.includes(1))) {
+                                (pump.body === 0 && circuitIds.includes(6)) ||
+                                (pump.body === 101 && circuitIds.includes(1))) {
                                 delayMgr.setPumpValveDelay(pstate);
                             }
                             break;
@@ -1817,14 +1874,14 @@ export class NixieHeaterCommands extends HeaterCommands {
         if (gasHeaterInstalled) sys.board.valueMaps.heatSources.merge([[2, { name: 'heater', desc: 'Heater' }]]);
         if (mastertempInstalled) sys.board.valueMaps.heatSources.merge([[11, { name: 'mtheater', desc: 'MasterTemp' }]]);
         if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatSources.merge([[3, { name: 'solar', desc: 'Solar Only', hasCoolSetpoint: htypes.hasCoolSetpoint }], [4, { name: 'solarpref', desc: 'Solar Preferred', hasCoolSetpoint: htypes.hasCoolSetpoint }]]);
-        else if (solarInstalled) sys.board.valueMaps.heatSources.merge([[3, { name: 'solar', desc: 'Solar', hasCoolsetpoint: htypes.hasCoolSetpoint }]]);
+        else if (solarInstalled) sys.board.valueMaps.heatSources.merge([[3, { name: 'solar', desc: 'Solar', hasCoolSetpoint: htypes.hasCoolSetpoint }]]);
         if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatSources.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Pref' }]]);
         else if (heatPumpInstalled) sys.board.valueMaps.heatSources.merge([[9, { name: 'heatpump', desc: 'Heat Pump' }]]);
         if (ultratempInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatSources.merge([[5, { name: 'ultratemp', desc: 'UltraTemp Only', hasCoolSetpoint: htypes.hasCoolSetpoint }], [6, { name: 'ultratemppref', desc: 'UltraTemp Pref', hasCoolSetpoint: htypes.hasCoolSetpoint }]]);
         else if (ultratempInstalled) sys.board.valueMaps.heatSources.merge([[5, { name: 'ultratemp', desc: 'UltraTemp', hasCoolSetpoint: htypes.hasCoolSetpoint }]]);
         sys.board.valueMaps.heatSources.merge([[0, { name: 'nochange', desc: 'No Change' }]]);
 
-            
+
         if (gasHeaterInstalled) sys.board.valueMaps.heatModes.merge([[2, { name: 'heater', desc: 'Heater' }]]);
         if (mastertempInstalled) sys.board.valueMaps.heatModes.merge([[11, { name: 'mtheater', desc: 'MasterTemp' }]]);
         if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled || mastertempInstalled)) sys.board.valueMaps.heatModes.merge([[3, { name: 'solar', desc: 'Solar Only' }], [4, { name: 'solarpref', desc: 'Solar Preferred' }]]);

package/controller/boards/SunTouchBoard.ts

@@ -31,7 +31,7 @@ export class SunTouchBoard extends EasyTouchBoard {
     constructor(system: PoolSystem) {
         super(system); // graph chain to EasyTouchBoard constructor.
         this.valueMaps.expansionBoards = new byteValueMap([
-            [41, { name: 'shared', part: '520820', desc: 'Pool and Spa controller', bodies: 2, valves: 4, circuits: 5, single: false, shared: true, dual: false, features: 4, chlorinators: 1, chemControllers: 1 }],
+            [41, { name: 'stshared', part: '520820', desc: 'Pool and Spa controller', bodies: 2, valves: 4, circuits: 5, single: false, shared: true, dual: false, features: 4, chlorinators: 1, chemControllers: 1 }],
             [40, { name: 'stsingle', part: '520819', desc: 'Pool or Spa controller', bodies: 2, valves: 4, circuits: 5, single: true, shared: true, dual: false, features: 4, chlorinators: 1, chemControllers: 1 }]
         ]);
         this._statusInterval = -1;
@@ -222,8 +222,10 @@ class SunTouchConfigQueue extends TouchConfigQueue {
         // 196 - [0-2]
         // 198 - [0-2]
         // 199 - [0-2]
+        // 200 - Heat/Temperature Status
         // 201 - [0-2]
         // 202 - [0-2] - Custom Names
+        // 203 - Circuit Functions
         // 204 - [0-2]
         // 205 - [0-2]
         // 206 - [0-2]
@@ -238,13 +240,16 @@ class SunTouchConfigQueue extends TouchConfigQueue {
         // 218 - [0-2]
         // 219 - [0-2]
         // 220 - [0-2]
+        // 221 - Valve Assignments
         // 223 - [0-2]
         // 224 - [1-2]
-        // 226 - [0]
+        // 225 - Spa side remote
+        // 226 - [0] - Solar/HeatPump config
         // 228 - [0-2]
         // 229 - [0-2]
         // 230 - [0-2]
         // 231 - [0-2]
+        // 232 - Settings (Amazed that there is none of this)
         // 233 - [0-2]
         // 234 - [0-2]
         // 235 - [0-2]
@@ -264,6 +269,7 @@ class SunTouchConfigQueue extends TouchConfigQueue {
         // 249 - [0-2]
         // 250 - [0-2]
         // 251 - [0-2]
+        // 253 - Software Version
 
         this.queueItems(GetTouchConfigCategories.version); // 252
         this.queueItems(GetTouchConfigCategories.dateTime, [0]); //197