nodejs-poolcontroller 8.0.1 → 8.0.2

package/controller/boards/EasyTouchBoard.ts

@@ -21,7 +21,7 @@ import * as extend from 'extend';
 import { logger } from '../../logger/Logger';
 import { conn } from '../comms/Comms';
 import { Message, Outbound, Protocol, Response } from '../comms/messages/Messages';
-import { Timestamp, utils } from '../Constants';
+import { ControllerType, Timestamp, utils } from '../Constants';
 import { Body, ChemController, ConfigVersion, CustomName, EggTimer, Feature, Heater, ICircuit, LightGroup, LightGroupCircuit, Options, PoolSystem, Pump, Schedule, sys, Valve } from '../Equipment';
 import { InvalidEquipmentDataError, InvalidEquipmentIdError, InvalidOperationError } from '../Errors';
 import { ncp } from "../nixie/Nixie";
@@ -174,7 +174,7 @@ export class EasyTouchBoard extends SystemBoard {
         this.valueMaps.pumpTypes = new byteValueMap([
             [1, { name: 'vf', desc: 'Intelliflo VF', maxPrimingTime: 6, 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 }],
+            [65, { name: 'ds', desc: 'Two-Speed', maxCircuits: 4, hasAddress: false, hasBody: true }],
             [128, { name: 'vs', desc: 'Intelliflo VS', maxPrimingTime: 10, 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 }],
             [257, { name: 'ss', desc: 'Single Speed', maxCircuits: 0, hasAddress: false, hasBody: true, equipmentMaster: 1, maxRelays: 1, relays: [{ id: 1, name: 'Pump On/Off' }] }],
@@ -348,6 +348,49 @@ export class EasyTouchBoard extends SystemBoard {
             [131, { name: 'ET4P', part: 'ET-4P', desc: 'EasyTouch 4P', circuits: 4, single: true, shared: false }]
         ]);
     }
+    public initValves(eq) {
+        if (typeof sys.valves.find((v) => v.id === 1) === 'undefined') {
+            let valve = sys.valves.getItemById(1, true);
+            valve.isIntake = false;
+            valve.isReturn = false;
+            valve.type = 0;
+            valve.master = 0;
+            valve.isActive = true;
+            valve.name = 'Valve A';
+            logger.info(`Initializing EasyTouch Valve A`);
+
+        }
+        if (typeof sys.valves.find((v) => v.id === 2) === 'undefined') {
+            let valve = sys.valves.getItemById(2, true);
+            valve.isIntake = false;
+            valve.isReturn = false;
+            valve.type = 0;
+            valve.master = 0;
+            valve.isActive = true;
+            valve.name = 'Valve B';
+            logger.info(`Initializing EasyTouch Valve B`);
+        }
+        if (eq.intakeReturnValves) {
+            logger.info(`Initializing EasyTouch Intake/Return Valves`);
+            let valve = sys.valves.getItemById(3, true);
+            valve.isIntake = true;
+            valve.isReturn = false;
+            valve.circuit = 6;
+            valve.type = 0;
+            valve.master = 0;
+            valve.isActive = true;
+            valve.name = 'Intake';
+
+            valve = sys.valves.getItemById(4, true);
+            valve.isIntake = false;
+            valve.isReturn = true;
+            valve.circuit = 6;
+            valve.type = 0;
+            valve.master = 0;
+            valve.isActive = true;
+            valve.name = 'Return';
+        }
+    }
     public initHeaterDefaults() {
         sys.board.heaters.updateHeaterServices();
         // RKS: 03-03-22 This is not correct.  As it turns out there is a case where the only heater installed is not
@@ -428,7 +471,7 @@ export class EasyTouchBoard extends SystemBoard {
         eq.maxChlorinators = md.chlorinators = 1;
         eq.maxChemControllers = md.chemControllers = 1;
         eq.maxCustomNames = 10;
-        eq.intakeReturnValves = md.intakeReturnValves = typeof mt.intakeReturnValves !== 'undefined' ? mt.intakeReturnValves : false;
+        eq.intakeReturnValves = md.intakeReturnValves = typeof mt.intakeReturnValves !== 'undefined' ? mt.intakeReturnValves : mt.shared;
         // Calculate out the invalid ids.
         sys.board.equipmentIds.invalidIds.set([]);
         if (!eq.shared) sys.board.equipmentIds.invalidIds.merge([1]);
@@ -438,6 +481,7 @@ export class EasyTouchBoard extends SystemBoard {
         state.equipment.controllerType = 'easytouch';
         this.initBodyDefaults();
         this.initHeaterDefaults();
+        this.initValves(eq);
         sys.board.bodies.initFilters();
         sys.equipment.shared ? sys.board.equipmentIds.circuits.start = 1 : sys.board.equipmentIds.circuits.start = 2;
         (async () => {
@@ -677,7 +721,8 @@ export class TouchScheduleCommands extends ScheduleCommands {
             let schedDays = sys.board.schedules.transformDays(typeof data.scheduleDays !== 'undefined' ? data.scheduleDays : sched.scheduleDays || 255); // default to all days
             let changeHeatSetpoint = typeof (data.changeHeatSetpoint !== 'undefined') ? utils.makeBool(data.changeHeatSetpoint) : sched.changeHeatSetpoint;
             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();
             if (typeof startTime === 'undefined') startTime = 480; // 8am
@@ -722,10 +767,10 @@ export class TouchScheduleCommands extends ScheduleCommands {
             if (state.heliotrope.isCalculated) {
                 const sunrise = state.heliotrope.sunrise.getHours() * 60 + state.heliotrope.sunrise.getMinutes();
                 const sunset = state.heliotrope.sunset.getHours() * 60 + state.heliotrope.sunset.getMinutes();
-                if (startTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunrise')) startTime = sunrise;
-                else if (startTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunset')) startTime = sunset;
-                if (endTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunrise')) endTime = sunrise;
-                else if (endTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunset')) endTime = sunset;
+                if (startTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunrise')) startTime = (sunrise + startTimeOffset);
+                else if (startTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunset')) startTime = (sunset + startTimeOffset);
+                if (endTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunrise')) endTime = (sunrise + endTimeOffset);
+                else if (endTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunset')) endTime = (sunset + endTimeOffset);
             }
 
 
@@ -769,6 +814,8 @@ export class TouchScheduleCommands extends ScheduleCommands {
             sched.endTimeType = ssched.endTimeType = endTimeType;
             sched.isActive = ssched.isActive = true;
             ssched.display = sched.display = display;
+            sched.startTimeOffset = ssched.startTimeOffset = startTimeOffset;
+            sched.endTimeOffset = ssched.endTimeOffset = endTimeOffset;
             ssched.emitEquipmentChange();
             // For good measure russ is sending out a config request for
             // the schedule in question.  If there was a failure on the
@@ -925,19 +972,19 @@ export class TouchScheduleCommands extends ScheduleCommands {
             let sUpdated = false;
             let sched = sys.schedules.getItemByIndex(i);
             if (sched.startTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunrise') && sched.startTime !== sunrise) {
-                sched.startTime = sunrise;
+                sched.startTime = sunrise + (sched.startTimeOffset || 0);
                 anyUpdated = sUpdated = true;
             }
             else if (sched.startTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunset') && sched.startTime !== sunset) {
-                sched.startTime = sunset;
+                sched.startTime = sunset + (sched.startTimeOffset || 0);
                 anyUpdated = sUpdated = true;
             }
             if (sched.endTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunrise') && sched.endTime !== sunrise) {
-                sched.endTime = sunrise;
+                sched.endTime = sunrise + (sched.endTimeOffset || 0);
                 anyUpdated = sUpdated = true;
             }
             else if (sched.endTimeType === sys.board.valueMaps.scheduleTimeTypes.getValue('sunset') && sched.endTime !== sunset) {
-                sched.endTime = sunset;
+                sched.endTime = sunset + (sched.endTimeOffset || 0);
                 anyUpdated = sUpdated = true;
             }
             if (sUpdated) {
@@ -1919,14 +1966,18 @@ class TouchChlorinatorCommands extends ChlorinatorCommands {
                 if (typeof superChlorinate === 'undefined') superChlorinate = utils.makeBool(chlor.superChlor);
             }
             if (typeof obj.disabled !== 'undefined') chlor.disabled = utils.makeBool(obj.disabled);
+            if (typeof obj.body !== 'undefined') chlor.body = parseInt(obj.body, 10);
             if (typeof chlor.body === 'undefined') chlor.body = parseInt(obj.body, 10) || 32;
             // Verify the data.
-            let body = sys.board.bodies.mapBodyAssociation(chlor.body).val;
-            if (typeof body === 'undefined') {
+            let bdy = sys.board.bodies.mapBodyAssociation(chlor.body || 0);
+            let body;
+            if (typeof bdy === 'undefined') {
                 if (sys.equipment.shared) body = 32;
                 else if (!sys.equipment.dual) body = 0;
                 else return Promise.reject(new InvalidEquipmentDataError(`Chlorinator body association is not valid: ${body}`, 'chlorinator', body));
             }
+            else
+                body = bdy.val;
             if (poolSetpoint > 100 || poolSetpoint < 0) return Promise.reject(new InvalidEquipmentDataError(`Chlorinator poolSetpoint is out of range: ${chlor.poolSetpoint}`, 'chlorinator', chlor.poolSetpoint));
             if (spaSetpoint > 100 || spaSetpoint < 0) return Promise.reject(new InvalidEquipmentDataError(`Chlorinator spaSetpoint is out of range: ${chlor.poolSetpoint}`, 'chlorinator', chlor.spaSetpoint));
             if (typeof obj.ignoreSaltReading !== 'undefined') chlor.ignoreSaltReading = utils.makeBool(obj.ignoreSaltReading);
@@ -1988,7 +2039,7 @@ class TouchChlorinatorCommands extends ChlorinatorCommands {
             let id = parseInt(obj.id, 10);
             if (isNaN(id)) return Promise.reject(new InvalidEquipmentDataError(`Chlorinator id is not valid: ${obj.id}`, 'chlorinator', obj.id));
             let chlor = sys.chlorinators.getItemById(id);
-            if (chlor.master === 1) return await super.deleteChlorAsync(obj);
+            if (chlor.master >= 1) return await super.deleteChlorAsync(obj);
             if (sl.enabled) {
                 await sl.chlor.setChlorEnabledAsync(false);
             }
@@ -2026,11 +2077,25 @@ class TouchPumpCommands extends PumpCommands {
     //}
     // RKS: 05-20-22 This was moved out of systemBoard it does not belong there and probably should not 
     // be called in any current form since it was not being called as part of a message result.
-    private setType(pump: Pump, pumpType: number) {
+    private async setType(pump: Pump, pumpType: number) {
         // if we are changing pump types, need to clear out circuits
         // and props that aren't for this pump type
         let _id = pump.id;
         if (pump.type !== pumpType || pumpType === 0) {
+            if (pump.type === 65) { // This used to be a two-speed pump.  We need to remove the high speed circuits.
+                let outc = Outbound.create({
+                    action: 158,
+                    retries: 2,
+                    response: Response.create({ action: 1, payload: [158] })
+                });
+                outc.appendPayloadBytes(0, 16);
+                if (sys.controllerType !== ControllerType.IntelliTouch) {
+                    outc.setPayloadByte(4, 1);
+                    outc.setPayloadByte(5, 72);
+                    outc.setPayloadByte(13, 2);
+                }
+                await outc.sendAsync();
+            }
             let _p = pump.get(true);
             sys.pumps.removeItemById(_id);
             pump = sys.pumps.getItemById(_id, true);
@@ -2054,7 +2119,6 @@ class TouchPumpCommands extends PumpCommands {
             spump.emitData('pumpExt', spump.getExtended());
         }
     }
-
     public async setPumpAsync(data: any, send: boolean = true): Promise<Pump> {
         // Rules regarding Pumps in *Touch
         // In *Touch there are basically three classifications of pumps. These include those under control of RS485, Dual Speed, and Single Speed.
@@ -2083,28 +2147,26 @@ class TouchPumpCommands extends PumpCommands {
                 if (type.equipmentMaster > 0 || data.master > 0) return await super.setPumpAsync(data);
                 data.master = 0;
                 if (typeof data.type === 'undefined' || isNaN(ntype) || typeof type.name === 'undefined') return Promise.reject(new InvalidEquipmentDataError('You must supply a pump type when creating a new pump', 'Pump', data));
+                // Do not rely on the address for the id.  This will not work overall since more than
+                // one pump type that exists in the ET and IT realm.
+                id = sys.pumps.getNextEquipmentId(new EquipmentIdRange(1, 255));
                 if (type.name === 'ds') {
-                    id = 9;
                     if (sys.pumps.find(elem => elem.type === ntype)) return Promise.reject(new InvalidEquipmentDataError(`You may add only one ${type.desc} pump`, 'Pump', data));
                 }
                 else if (type.name === 'ss') {
-                    id = 10;
                     if (sys.pumps.find(elem => elem.type === ntype)) return Promise.reject(new InvalidEquipmentDataError(`You may add only one ${type.desc} pump`, 'Pump', data));
                 }
-                else if (type.name === 'none') return Promise.reject(new InvalidEquipmentDataError('You must supply a valid id when removing a pump.', 'Pump', data));
+                else if (type.name === 'none') // This is a mis-guided relic.  None should simply not exist.
+                    return Promise.reject(new InvalidEquipmentDataError('You must supply a valid type when adding a pump.', 'Pump', data));
                 else {
-                    // Under most circumstances the id will = the address minus 95.
                     if (typeof data.address !== 'undefined') {
                         data.address = parseInt(data.address, 10);
                         if (isNaN(data.address)) return Promise.reject(new InvalidEquipmentDataError(`You must supply a valid pump address to add a ${type.desc} pump.`, 'Pump', data));
-                        id = data.address - 95;
                         // Make sure it doesn't already exist.
                         if (sys.pumps.find(elem => elem.address === data.address)) return Promise.reject(new InvalidEquipmentDataError(`A pump already exists at address ${data.address - 95}`, 'Pump', data));
                     }
                     else {
                         if (typeof id === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`You may not add another ${type.desc} pump.  Max number of pumps exceeded.`, 'Pump', data));
-                        id = sys.pumps.getNextEquipmentId(sys.board.equipmentIds.pumps);
-                        data.address = id + 95;
                     }
                 }
                 isAdd = true;
@@ -2112,24 +2174,42 @@ class TouchPumpCommands extends PumpCommands {
             }
             else {
                 pump = sys.pumps.getItemById(id, false);
-                if (data.master > 0 || pump.master > 0) return await super.setPumpAsync(data);
                 data.master = 0;
                 ntype = typeof data.type === 'undefined' ? pump.type : parseInt(data.type, 10);
                 if (isNaN(ntype)) return Promise.reject(new InvalidEquipmentDataError(`Pump type ${data.type} is not valid`, 'Pump', data));
                 type = sys.board.valueMaps.pumpTypes.transform(ntype);
+                data.master = type.name in ['ss', 'hwvs', 'hwrly', 'sf'] ? 1 : 0;
+                if (data.master > 0 || pump.master > 0) return await super.setPumpAsync(data);
+
                 // changing type?  clear out all props and add as new
                 if (ntype !== pump.type) {
                     isAdd = true;
-                    this.setType(pump, ntype);
+                    await this.setType(pump, ntype);
                     pump = sys.pumps.getItemById(id, false); // refetch pump with new value
                 }
             }
             // Validate all the ids since in *Touch the address is determined from the id.
+            // RKS: 05-07-23 - The pump address is no longer determined by the id.  This was such a twisted effort to try to match these to the id.
+            // while the order of the pump coming out of the config messages determine the address the id is not relevant since *Touch panels should simply
+            // search for the address using byte index + 96.  All of this was becoming too much.
             if (!isAdd) isAdd = sys.pumps.find(elem => elem.id === id) === undefined;
+            if (type.name === 'ss') {
+                data.master = 1; // All single speed pumps are Nixie controlled.
+                return await super.setPumpAsync(data);
+            }
+
+            if (isAdd) {
+                // The ids for dual speed and single speed pumps have been mixed up in the past.  Originally, the code relied on ss id === 10 and ds === 9.  However, when the screenLogic
+                // code was added these got switched and essentially invalidated all ds and ss pumps.  The way this works now is that the single ds pump for ET and IT will be determined by
+                // type and the id will not matter.
+                data.master = 0;
+                if (type.name === 'ds' && typeof sys.pumps.find(x => x.type === 65) !== 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Only one Two-speed pump may be added`, 'Pump', data));
+                else if (sys.pumps.count(x => x.type in [1, 64, 128, 169]) >= sys.equipment.maxPumps) return Promise.reject(new InvalidEquipmentDataError(`The maximum number of variable pumps have been exceeded for this panel. ${type.desc}`, 'Pump', data));
+            }
             // Now lets validate the ids related to the type.
-            if (id === 9 && type.name !== 'ds') return Promise.reject(new InvalidEquipmentDataError(`The id for a ${type.desc} pump must be 9`, 'Pump', data));
-            else if (id === 10 && type.name !== 'ss') return Promise.reject(new InvalidEquipmentDataError(`The id for a ${type.desc} pump must be 10`, 'Pump', data));
-            else if (id > sys.equipment.maxPumps) return Promise.reject(new InvalidEquipmentDataError(`The id for a ${type.desc} must be less than ${sys.equipment.maxPumps}`, 'Pump', data));
+            //if (id === 10 && type.name !== 'ds') return Promise.reject(new InvalidEquipmentDataError(`The id for a Two-speed pump must be 9`, 'Pump', data));
+            //else if (id === 9 && type.name !== 'ss') return Promise.reject(new InvalidEquipmentDataError(`The id for a Single-Speed pump must be 10`, 'Pump', data));
+            //else if (id > sys.equipment.maxPumps) return Promise.reject(new InvalidEquipmentDataError(`The id for a ${type.desc} must be less than ${sys.equipment.maxPumps}`, 'Pump', data));
 
             // Need to do a check here if we are clearing out the circuits; id data.circuits === []
             // extend will keep the original array
@@ -2180,34 +2260,60 @@ class TouchPumpCommands extends PumpCommands {
             // We will not be sending message for ss type pumps.
             if (type.name === 'ss') {
                 // The OCP doesn't deal with single speed pumps.  Simply add it to the config.
-                data.circuits = [];
-                pump.set(pump);
+                pump.circuits.clear();
                 let spump = state.pumps.getItemById(id, true);
                 for (let prop in spump) {
                     if (typeof data[prop] !== 'undefined') spump[prop] = data[prop];
                 }
-                data.model = typeof data.model === 'undefined' ? sys.board.valueMaps.pumpSSModels.encode(data.model) : pump.model || 0;
+                spump.type = pump.type = type.val;
+                pump.model = typeof data.model === 'undefined' ? sys.board.valueMaps.pumpSSModels.encode(data.model) : pump.model || 0;
                 spump.emitEquipmentChange();
-                return Promise.resolve(pump);
+
+                return pump;
             }
             else if (type.name === 'ds') {
                 // We are going to set all the high speed circuits.
                 // RSG: TODO I don't know what the message is to set the high speed circuits.  The following should
                 // be moved into the onComplete for the outbound message to set high speed circuits.
-                data.model = typeof data.model === 'undefined' ? sys.board.valueMaps.pumpDSModels.encode(data.model) : pump.model || 0;
-                for (let prop in pump) {
-                    if (typeof data[prop] !== 'undefined') pump[prop] = data[prop];
+                // RKS: 05-06-23 - Send the message for high speed circuits.
+                let outc = Outbound.create({
+                    action: 158,
+                    retries: 2,
+                    response: Response.create({ action: 1, payload: [158] })
+                });
+                outc.appendPayloadBytes(0, 16);
+                if (sys.controllerType !== ControllerType.IntelliTouch) {
+                    outc.setPayloadByte(4, 1);
+                    outc.setPayloadByte(5, 72);
+                    outc.setPayloadByte(13, 2);
                 }
-                let spump = state.pumps.getItemById(id, true);
-                for (let prop in spump) {
-                    if (typeof data[prop] !== 'undefined') spump[prop] = data[prop];
+                let maxCircuits = typeof data.circuits !== 'undefined' ? Math.min(data.circuits.length, sys.controllerType === ControllerType.IntelliTouch ? 8 : 4) : 0;
+                for (let i = 0; i < maxCircuits; i++) {
+                    outc.setPayloadByte(i, data.circuits[i].circuit, 0);
                 }
-                spump.emitEquipmentChange();
-                return Promise.resolve(pump);
+                // So lets send the message for setting the high speed circuits.
+                if (await outc.sendAsync()) {
+                    let spump = state.pumps.getItemById(id, true);
+                    pump.model = typeof data.model === 'undefined' ? sys.board.valueMaps.pumpDSModels.encode(data.model) : pump.model || 0;
+                    let circs = [];
+                    // Lets do this to rearrange cases where 0s are sent.
+                    for (let i = 0; i < maxCircuits; i++) {
+                        if (data.circuits[i].circuit > 0) {
+                            circs.push(data.circuits[i].circuit);
+                        }
+                    }
+                    pump.circuits.clear();
+                    for (let i = 0; i < circs.length; i++) {
+                        pump.circuits.getItemById(i + 1, true, { id: i + 1, circuit: circs[i] });
+                    }
+                    spump.emitEquipmentChange();
+                }
+                return pump;
             }
             else {
                 let arrCircuits = [];
-                data.address = id + 95;
+                // Look to see if there is another pump at the same address.
+                if (typeof sys.pumps.find(x => x.id !== id && x.address === data.address) !== 'undefined') return Promise.reject(new InvalidEquipmentDataError(`A pump already exists at address ${data.address - 95}`, 'Pump', data));
                 if (isVersion1) {
                     if (data.address !== 96) return Promise.reject(new InvalidEquipmentDataError(`EasyTouch Version 1 controllers only support VS pumps at the first address`, 'Pump', data));
                     if (type.name !== 'vs') return Promise.reject(new InvalidEquipmentDataError(`EasyTouch Version 1 controllers only support VS pump types. ${type.desc} pumps are not supported`, 'Pump', data));
@@ -2250,7 +2356,7 @@ class TouchPumpCommands extends PumpCommands {
                     data.circuits = arrCircuits;
 
                     if (send) {
-                        return new Promise<Pump>(async (resolve, reject) => {
+                        return await new Promise<Pump>(async (resolve, reject) => {
                             outc.onComplete = (err, msg) => {
                                 if (err) reject(err);
                                 else {
@@ -2268,10 +2374,12 @@ class TouchPumpCommands extends PumpCommands {
                                         retries: 2,
                                         response: true
                                     });
-                                    conn.queueSendMessage(pumpConfigRequest);
+                                    (async () => { pumpConfigRequest.sendAsync(); })();
+                                    //conn.queueSendMessage(pumpConfigRequest);
                                 }
                             };
                             await outc.sendAsync();
+                            return pump;
                         });
                     }
                 }
@@ -2428,32 +2536,26 @@ class TouchPumpCommands extends PumpCommands {
                         return Promise.resolve(pump);
                     }
                     else if (send) {
-                        return new Promise<Pump>(async (resolve, reject) => {
-                            outc.onComplete = (err, msg) => {
-                                if (err) reject(err);
-                                else {
-                                    pump = sys.pumps.getItemById(id, true);
-                                    // RKS: 05-20-22 Boooh to this if the payload does not include its
-                                    // circuits we have just destroyed the pump definition.  So I added code to
-                                    // make sure that the data is complete.
-                                    pump.set(data); // Sets all the data back to the pump.
-                                    let spump = state.pumps.getItemById(id, true);
-                                    spump.isActive = pump.isActive = true;
-                                    spump.name = pump.name;
-                                    spump.type = pump.type;
-                                    spump.emitEquipmentChange();
-                                    resolve(pump);
-                                    const pumpConfigRequest = Outbound.create({
-                                        action: 216,
-                                        payload: [pump.id],
-                                        retries: 2,
-                                        response: true
-                                    });
-                                    conn.queueSendMessage(pumpConfigRequest);
-                                }
-                            };
-                            await outc.sendAsync();
-                        });
+                        if (await outc.sendAsync()) {
+                            pump = sys.pumps.getItemById(id, true);
+                            // RKS: 05-20-22 Boooh to this if the payload does not include its
+                            // circuits we have just destroyed the pump definition.  So I added code to
+                            // make sure that the data is complete.
+                            pump.set(data); // Sets all the data back to the pump.
+                            let spump = state.pumps.getItemById(id, true);
+                            spump.isActive = pump.isActive = true;
+                            spump.name = pump.name;
+                            spump.type = pump.type;
+                            spump.emitEquipmentChange();
+                            const pumpConfigRequest = Outbound.create({
+                                action: 216,
+                                payload: [pump.id],
+                                retries: 2,
+                                response: true
+                            });
+                            await pumpConfigRequest.sendAsync();
+                            return pump;
+                        }
                     }
                 }
             }
@@ -2548,30 +2650,50 @@ class TouchPumpCommands extends PumpCommands {
         if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`deletePumpAsync: Pump ${id} is not valid.`, 0, `pump`));
         let pump = sys.pumps.getItemById(id, false);
         if (pump.master === 1) return super.deletePumpAsync(data);
-        const outc = Outbound.create({
-            action: 155,
-            payload: [id, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-            retries: 2,
-            response: true
-        });
-        return new Promise<Pump>(async (resolve, reject) => {
-            outc.onComplete = (err, msg) => {
-                if (err) reject(err);
-                else {
-                    sys.pumps.removeItemById(id);
-                    state.pumps.removeItemById(id);
-                    resolve(sys.pumps.getItemById(id, false));
-                    const pumpConfigRequest = Outbound.create({
-                        action: 216,
-                        payload: [id],
-                        retries: 2,
-                        response: true
-                    });
-                    conn.queueSendMessage(pumpConfigRequest);
-                }
-            };
+        else if (pump.type === 65) { // Dual speed pump.
+            let outc = Outbound.create({
+                action: 158,
+                retries: 2,
+                response: Response.create({ action: 1, payload: [158] })
+            });
+            outc.appendPayloadBytes(0, 16);
+            if (sys.controllerType !== ControllerType.IntelliTouch) {
+                outc.setPayloadByte(4, 1);
+                outc.setPayloadByte(5, 72);
+                outc.setPayloadByte(13, 2);
+            }
             await outc.sendAsync();
-        });
+            pump.isActive = false;
+            sys.pumps.removeItemById(id);
+            state.pumps.removeItemById(id);
+            return pump;
+        }
+        else {
+            const outc = Outbound.create({
+                action: 155,
+                payload: [id, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                retries: 2,
+                response: true
+            });
+            return new Promise<Pump>(async (resolve, reject) => {
+                outc.onComplete = (err, msg) => {
+                    if (err) reject(err);
+                    else {
+                        sys.pumps.removeItemById(id);
+                        state.pumps.removeItemById(id);
+                        resolve(sys.pumps.getItemById(id, false));
+                        const pumpConfigRequest = Outbound.create({
+                            action: 216,
+                            payload: [id],
+                            retries: 2,
+                            response: true
+                        });
+                        (async () => { await pumpConfigRequest.sendAsync(); });
+                    }
+                };
+                await outc.sendAsync();
+            });
+        }
     }
 }
 class TouchHeaterCommands extends HeaterCommands {
@@ -2807,15 +2929,15 @@ class TouchHeaterCommands extends HeaterCommands {
             // 2 = Gas Heater
             // 3 = Hybrid
             // 16 = Dual 
-            sys.board.valueMaps.heatModes.set(1, { name: 'heatpump', desc: 'Heat Pump' });
-            sys.board.valueMaps.heatModes.set(2, { name: 'heater', desc: 'Gas Heat' });
-            sys.board.valueMaps.heatModes.set(3, { name: 'heatpumppref', desc: 'Hybrid' });
-            sys.board.valueMaps.heatModes.set(16, { name: 'dual', desc: 'Dual Heat' });
+            sys.board.valueMaps.heatModes.set(1, { name: 'hybheatpump', desc: 'Heat Pump' });
+            sys.board.valueMaps.heatModes.set(2, { name: 'hybheat', desc: 'Gas Heat' });
+            sys.board.valueMaps.heatModes.set(3, { name: 'hybhybrid', desc: 'Hybrid' });
+            sys.board.valueMaps.heatModes.set(16, { name: 'hybdual', desc: 'Dual Heat' });
 
-            sys.board.valueMaps.heatSources.set(2, { name: 'heater', desc: 'Gas Heat' });
-            sys.board.valueMaps.heatSources.set(5, { name: 'heatpumppref', desc: 'Hybrid' });
-            sys.board.valueMaps.heatSources.set(20, { name: 'dual', desc: 'Dual Heat' });
-            sys.board.valueMaps.heatSources.set(21, { name: 'heatpump', desc: 'Heat Pump' });
+            sys.board.valueMaps.heatSources.set(2, { name: 'hybheat', desc: 'Gas Heat' });
+            sys.board.valueMaps.heatSources.set(5, { name: 'hybhybrid', desc: 'Hybrid' });
+            sys.board.valueMaps.heatSources.set(20, { name: 'hybdual', desc: 'Dual Heat' });
+            sys.board.valueMaps.heatSources.set(21, { name: 'hybheatpump', desc: 'Heat Pump' });
         }
         else {
             if (gasHeaterInstalled) {
@@ -2863,6 +2985,8 @@ class TouchHeaterCommands extends HeaterCommands {
             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.data.heatMode = sys.board.valueMaps.heatModes.transform(btemp.heatMode);
+            btemp.data.heatStatus = sys.board.valueMaps.heatStatus.transform(btemp.heatStatus);
             btemp.heaterOptions = opts;
         }
         this.setActiveTempSensors();