nodejs-poolcontroller 8.1.1 → 8.3.0

package/config/VersionCheck.ts

@@ -28,10 +28,24 @@ class VersionCheck {
     private gitApiHost: string;
     private gitLatestReleaseJSONPath: string;
     private redirects: number;
+    private gitAvailable: boolean;
+    private warnedBranch: boolean = false;
+    private warnedCommit: boolean = false;
     constructor() {
         this.userAgent = 'tagyoureit-nodejs-poolController-app';
         this.gitApiHost = 'api.github.com';
         this.gitLatestReleaseJSONPath = '/repos/tagyoureit/nodejs-poolController/releases/latest';
+        this.gitAvailable = this.detectGit();
+        // NOTE:
+        //  * SOURCE_BRANCH / SOURCE_COMMIT env vars (if present) override git commands. These are expected in container builds where .git may be absent.
+        //  * If git is not available (no binary or not a repo) we suppress repeated warnings after the first occurrence.
+        //  * Version comparison is rate-limited via nextCheckTime (every 2 days) to avoid Github API throttling.
+    }
+    private detectGit(): boolean {
+        try {
+            execSync('git --version', { stdio: 'ignore' });
+            return true;
+        } catch { return false; }
     }
 
     public checkGitRemote() {
@@ -40,43 +54,46 @@ class VersionCheck {
         if (typeof state.appVersion.nextCheckTime === 'undefined' || new Date() > new Date(state.appVersion.nextCheckTime)) setTimeout(() => { this.checkAll(); }, 100);
     }
     public checkGitLocal() {
-        let env = process.env;
-        // check local git version
+        const env = process.env;
+        // Branch
         try {
             let out: string;
-            if (typeof env.SOURCE_BRANCH !== 'undefined') 
-            {
-                out = env.SOURCE_BRANCH // check for docker variable
-            }
-            else {
-                let res = execSync('git rev-parse --abbrev-ref HEAD', { stdio: 'pipe' });
+            if (typeof env.SOURCE_BRANCH !== 'undefined') {
+                out = env.SOURCE_BRANCH;
+            } else if (this.gitAvailable) {
+                const res = execSync('git rev-parse --abbrev-ref HEAD', { stdio: 'pipe' });
                 out = res.toString().trim();
+            } else {
+                out = '--';
             }
-            logger.info(`The current git branch output is ${out}`);
+            if (out !== '--') logger.info(`The current git branch output is ${out}`);
             switch (out) {
-            case 'fatal':
-            case 'command':
-                state.appVersion.gitLocalBranch = '--';
-                break;
-            default:
-                state.appVersion.gitLocalBranch = out;
-        }
-        }
-        catch (err) {
+                case 'fatal':
+                case 'command':
+                    state.appVersion.gitLocalBranch = '--';
+                    break;
+                default:
+                    state.appVersion.gitLocalBranch = out;
+            }
+        } catch (err) {
             state.appVersion.gitLocalBranch = '--';
-            logger.warn(`Unable to retrieve local git branch.  ${err}`);
+            if (!this.warnedBranch) {
+                logger.warn(`Unable to retrieve local git branch (git missing or not a repo). Further branch warnings suppressed.`);
+                this.warnedBranch = true;
+            }
         }
+        // Commit
         try {
             let out: string;
-            if (typeof env.SOURCE_COMMIT !== 'undefined') 
-            {
-                out = env.SOURCE_COMMIT; // check for docker variable
-            }
-            else {
-                let res = execSync('git rev-parse HEAD', { stdio: 'pipe' });
+            if (typeof env.SOURCE_COMMIT !== 'undefined') {
+                out = env.SOURCE_COMMIT;
+            } else if (this.gitAvailable) {
+                const res = execSync('git rev-parse HEAD', { stdio: 'pipe' });
                 out = res.toString().trim();
+            } else {
+                out = '--';
             }
-            logger.info(`The current git commit output is ${out}`);
+            if (out !== '--') logger.info(`The current git commit output is ${out}`);
             switch (out) {
                 case 'fatal':
                 case 'command':
@@ -85,10 +102,12 @@ class VersionCheck {
                 default:
                     state.appVersion.gitLocalCommit = out;
             }
-        }
-        catch (err) { 
+        } catch (err) {
             state.appVersion.gitLocalCommit = '--';
-            logger.warn(`Unable to retrieve local git commit.  ${err}`); 
+            if (!this.warnedCommit) {
+                logger.warn(`Unable to retrieve local git commit (git missing or not a repo). Further commit warnings suppressed.`);
+                this.warnedCommit = true;
+            }
         }
     }
     private checkAll() {
@@ -126,15 +145,24 @@ class VersionCheck {
         return new Promise<string>((resolve, reject) => {
             try {
                 let req = https.request(url, options, async res => {
-                    if (res.statusCode > 300 && res.statusCode < 400 && res.headers.location) await this.getLatestRelease(res.headers.location);
+                    if (res.statusCode > 300 && res.statusCode < 400 && res.headers.location) {
+                        try {
+                            const redirected = await this.getLatestRelease(res.headers.location);
+                            return resolve(redirected);
+                        } catch (e) { return reject(e); }
+                    }
                     let data = '';
                     res.on('data', d => { data += d; });
                     res.on('end', () => {
-                        let jdata = JSON.parse(data);
-                        if (typeof jdata.tag_name !== 'undefined')
-                            resolve(jdata.tag_name.replace('v', ''));
-                        else
-                            reject(`No data returned.`)
+                        try {
+                            let jdata = JSON.parse(data);
+                            if (typeof jdata.tag_name !== 'undefined')
+                                resolve(jdata.tag_name.replace('v', ''));
+                            else
+                                reject(`No data returned.`)
+                        } catch(parseErr: any){
+                            reject(`Error parsing Github response: ${ parseErr.message }`);
+                        }
                     })
                 })
                     .end();

package/controller/Equipment.ts

@@ -1478,7 +1478,7 @@ export class Pump extends EqItem {
     public set id(val: number) { this.setDataVal('id', val); }
     public get portId(): number { return this.data.portId; }
     public set portId(val: number) { this.setDataVal('portId', val); }
-    public get address(): number { return this.data.address || this.data.id + 95; }
+    public get address(): number { return this.data.address; }
     public set address(val: number) { this.setDataVal('address', val); }
     public get name(): string { return this.data.name; }
     public set name(val: string) { this.setDataVal('name', val); }

package/controller/State.ts

@@ -393,8 +393,18 @@ export class State implements IState {
             self.data.time = self._dt.format();
             self.hasChanged = true;
             self.heliotrope.date = self._dt.toDate();
-            self.heliotrope.longitude = sys.general.location.longitude;
-            self.heliotrope.latitude = sys.general.location.latitude;
+            // Provide safe access & environment fallback for coordinates
+            const loc = sys?.general?.location || {} as any;
+            let lon = loc.longitude;
+            let lat = loc.latitude;
+            if (typeof lon !== 'number' || typeof lat !== 'number') {
+                const envLat = process.env.POOL_LATITUDE ? parseFloat(process.env.POOL_LATITUDE) : undefined;
+                const envLon = process.env.POOL_LONGITUDE ? parseFloat(process.env.POOL_LONGITUDE) : undefined;
+                if (typeof lon !== 'number' && typeof envLon === 'number' && !isNaN(envLon)) lon = envLon;
+                if (typeof lat !== 'number' && typeof envLat === 'number' && !isNaN(envLat)) lat = envLat;
+            }
+            self.heliotrope.longitude = lon;
+            self.heliotrope.latitude = lat;
             let times = self.heliotrope.calculatedTimes;
             self.data.sunrise = times.isValid ? Timestamp.toISOLocal(times.sunrise) : '';
             self.data.sunset = times.isValid ? Timestamp.toISOLocal(times.sunset) : '';
@@ -947,7 +957,7 @@ export class PumpState extends EqState {
     }
     public get id(): number { return this.data.id; }
     public set id(val: number) { this.data.id = val; }
-    public get address(): number { return this.data.address || this.data.id + 95; }
+    public get address(): number { return this.data.address; }
     public set address(val: number) { this.setDataVal('address', val); }
     public get name(): string { return this.data.name; }
     public set name(val: string) { this.setDataVal('name', val); }
@@ -1042,6 +1052,7 @@ export class PumpState extends EqState {
                 case 'hwvs':
                 case 'vssvrs':
                 case 'vs':
+                case 'regalmodbus':
                     c.units = sys.board.valueMaps.pumpUnits.transformByName('rpm');
                     break;
                 case 'ss':

package/controller/boards/EasyTouchBoard.ts

@@ -3030,8 +3030,8 @@ class TouchChemControllerCommands extends ChemControllerCommands {
             if (isNaN(alkalinity)) return Promise.reject(new InvalidEquipmentDataError(`Invalid alkalinity`, 'chemController', alkalinity));
             if (isNaN(borates)) return Promise.reject(new InvalidEquipmentDataError(`Invalid borates`, 'chemController', borates));
             let schem = state.chemControllers.getItemById(chem.id, true);
-            let pHSetpoint = typeof data.ph !== 'undefined' && typeof data.ph.setpoint !== 'undefined' ? parseFloat(data.ph.setpoint) : chem.ph.setpoint;
-            let orpSetpoint = typeof data.orp !== 'undefined' && typeof data.orp.setpoint !== 'undefined' ? parseInt(data.orp.setpoint, 10) : chem.orp.setpoint;
+            let pHSetpoint = (typeof data.ph !== 'undefined' && typeof data.ph.setpoint !== 'undefined') ? parseFloat(data.ph.setpoint) : chem.ph.setpoint;
+            let orpSetpoint = (typeof data.orp !== 'undefined' && typeof data.orp.setpoint !== 'undefined') ? parseInt(data.orp.setpoint, 10) : chem.orp.setpoint;
             let lsiRange = typeof data.lsiRange !== 'undefined' ? data.lsiRange : chem.lsiRange || {};
             if (typeof data.lsiRange !== 'undefined') {
                 if (typeof data.lsiRange.enabled !== 'undefined') lsiRange.enabled = utils.makeBool(data.lsiRange.enabled);
@@ -3040,31 +3040,31 @@ class TouchChemControllerCommands extends ChemControllerCommands {
             }
             if (isNaN(pHSetpoint) || pHSetpoint > type.ph.max || pHSetpoint < type.ph.min) return Promise.reject(new InvalidEquipmentDataError(`Invalid pH setpoint`, 'ph.setpoint', pHSetpoint));
             if (isNaN(orpSetpoint) || orpSetpoint > type.orp.max || orpSetpoint < type.orp.min) return Promise.reject(new InvalidEquipmentDataError(`Invalid orp setpoint`, 'orp.setpoint', orpSetpoint));
-            let phTolerance = typeof data.ph.tolerance !== 'undefined' ? data.ph.tolerance : chem.ph.tolerance;
-            let orpTolerance = typeof data.orp.tolerance !== 'undefined' ? data.orp.tolerance : chem.orp.tolerance;
-            if (typeof data.ph.tolerance !== 'undefined') {
+            let phTolerance = (typeof data.ph !== 'undefined' && typeof data.ph.tolerance !== 'undefined') ? data.ph.tolerance : chem.ph.tolerance;
+            let orpTolerance = (typeof data.orp !== 'undefined' && typeof data.orp.tolerance !== 'undefined') ? data.orp.tolerance : chem.orp.tolerance;
+            if (typeof data.ph !== 'undefined' && typeof data.ph.tolerance !== 'undefined') {
                 if (typeof data.ph.tolerance.enabled !== 'undefined') phTolerance.enabled = utils.makeBool(data.ph.tolerance.enabled);
                 if (typeof data.ph.tolerance.low !== 'undefined') phTolerance.low = parseFloat(data.ph.tolerance.low);
                 if (typeof data.ph.tolerance.high !== 'undefined') phTolerance.high = parseFloat(data.ph.tolerance.high);
                 if (isNaN(phTolerance.low)) phTolerance.low = type.ph.min;
                 if (isNaN(phTolerance.high)) phTolerance.high = type.ph.max;
             }
-            if (typeof data.orp.tolerance !== 'undefined') {
+            if (typeof data.orp !== 'undefined' && typeof data.orp.tolerance !== 'undefined') {
                 if (typeof data.orp.tolerance.enabled !== 'undefined') orpTolerance.enabled = utils.makeBool(data.orp.tolerance.enabled);
                 if (typeof data.orp.tolerance.low !== 'undefined') orpTolerance.low = parseFloat(data.orp.tolerance.low);
                 if (typeof data.orp.tolerance.high !== 'undefined') orpTolerance.high = parseFloat(data.orp.tolerance.high);
                 if (isNaN(orpTolerance.low)) orpTolerance.low = type.orp.min;
                 if (isNaN(orpTolerance.high)) orpTolerance.high = type.orp.max;
             }
-            let phEnabled = typeof data.ph.enabled !== 'undefined' ? utils.makeBool(data.ph.enabled) : chem.ph.enabled;
-            let orpEnabled = typeof data.orp.enabled !== 'undefined' ? utils.makeBool(data.orp.enabled) : chem.orp.enabled;
+            let phEnabled = (typeof data.ph !== 'undefined' && typeof data.ph.enabled !== 'undefined') ? utils.makeBool(data.ph.enabled) : chem.ph.enabled;
+            let orpEnabled = (typeof data.orp !== 'undefined' && typeof data.orp.enabled !== 'undefined') ? utils.makeBool(data.orp.enabled) : chem.orp.enabled;
             let siCalcType = typeof data.siCalcType !== 'undefined' ? sys.board.valueMaps.siCalcTypes.encode(data.siCalcType, 0) : chem.siCalcType;
 
             let saltLevel = (state.chlorinators.length > 0) ? state.chlorinators.getItemById(1).saltLevel || 1000 : 1000
             chem.ph.tank.capacity = 6;
             chem.orp.tank.capacity = 6;
-            let acidTankLevel = typeof data.ph !== 'undefined' && typeof data.ph.tank !== 'undefined' && typeof data.ph.tank.level !== 'undefined' ? parseInt(data.ph.tank.level, 10) : schem.ph.tank.level;
-            let orpTankLevel = typeof data.orp !== 'undefined' && typeof data.orp.tank !== 'undefined' && typeof data.orp.tank.level !== 'undefined' ? parseInt(data.orp.tank.level, 10) : schem.orp.tank.level;
+            let acidTankLevel = (typeof data.ph !== 'undefined' && typeof data.ph.tank !== 'undefined' && typeof data.ph.tank.level !== 'undefined') ? parseInt(data.ph.tank.level, 10) : schem.ph.tank.level;
+            let orpTankLevel = (typeof data.orp !== 'undefined' && typeof data.orp.tank !== 'undefined' && typeof data.orp.tank.level !== 'undefined') ? parseInt(data.orp.tank.level, 10) : schem.orp.tank.level;
             // OCP needs to set the IntelliChem as active so it knows that it exists
             if (sl.enabled && send) {
                 if (!schem.isActive) {

package/controller/boards/IntelliCenterBoard.ts

@@ -2825,7 +2825,8 @@ class IntelliCenterBodyCommands extends BodyCommands {
         processing: boolean,
         bytes: number[],
         body1: { heatMode: number, heatSetpoint: number, coolSetpoint: number },
-        body2: { heatMode: number, heatSetpoint: number, coolSetpoint: number }
+        body2: { heatMode: number, heatSetpoint: number, coolSetpoint: number },
+        _processingStartTime?: 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
@@ -2837,9 +2838,18 @@ class IntelliCenterBodyCommands extends BodyCommands {
                 bytes: [],
                 body1: { heatMode: body1.heatMode || 1, heatSetpoint: body1.heatSetpoint || 78, coolSetpoint: body1.coolSetpoint || 100 },
                 body2: { heatMode: body2.heatMode || 1, heatSetpoint: body2.heatSetpoint || 78, coolSetpoint: body2.coolSetpoint || 100 }
-            }
+            };
         }
         let bhs = this.bodyHeatSettings;
+        
+        // Reset processing state if it's been stuck for too long (more than 10 seconds)
+        if (bhs.processing && bhs._processingStartTime && (Date.now() - bhs._processingStartTime > 10000)) {
+            logger.warn(`Resetting stuck bodyHeatSettings processing state after timeout`);
+            bhs.processing = false;
+            bhs.bytes = [];
+            delete bhs._processingStartTime;
+        }
+        
         if (typeof data !== 'undefined' && typeof bodyId !== 'undefined' && bodyId > 0) {
             let body = bodyId === 2 ? bhs.body2 : bhs.body1;
             if (!bhs.bytes.includes(byte) && byte) bhs.bytes.push(byte);
@@ -2849,6 +2859,7 @@ class IntelliCenterBodyCommands extends BodyCommands {
         }
         if (!bhs.processing && bhs.bytes.length > 0) {
             bhs.processing = true;
+            bhs._processingStartTime = Date.now();
             let byte2 = bhs.bytes.shift();
             let fnToByte = function (num) { return num < 0 ? Math.abs(num) | 0x80 : Math.abs(num) || 0; };
             let payload = [0, 0, byte2, 1,
@@ -2890,13 +2901,16 @@ class IntelliCenterBodyCommands extends BodyCommands {
                 }
                 state.emitEquipmentChanges();
             } catch (err) {
+                logger.error(`Error in queueBodyHeatSettings: ${err.message}`);
                 bhs.processing = false;
                 bhs.bytes = [];
+                delete bhs._processingStartTime;
                 throw (err);
             }
             finally {
                 bhs.processing = false;
                 bhs.bytes = [];
+                delete bhs._processingStartTime;
             }
             return true;
         }
@@ -2912,7 +2926,10 @@ class IntelliCenterBodyCommands extends BodyCommands {
                     }
                 }, 3000);
             }
-            else bhs.processing = false;
+            else {
+                bhs.processing = false;
+                delete bhs._processingStartTime;
+            }
             return true;
         }
     }

package/controller/boards/NixieBoard.ts

@@ -29,6 +29,12 @@ import { webApp } from "../../web/Server";
 import { setTimeout } from 'timers/promises';
 import { setTimeout as setTimeoutSync } from 'timers';
 
+const addrsPentairPump = Object.freeze([96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111]);
+const addrsRegalModbusPump = Object.freeze(
+    Array.from({ length: ((0xF7 - 0x15) / 2) + 1 }, (_, i) => 0x15 + i * 2)  // Odd numbers fro 0x15 through 0xF7
+  );
+
+
 export class NixieBoard extends SystemBoard {
     constructor (system: PoolSystem){
         super(system);
@@ -76,14 +82,15 @@ export class NixieBoard extends SystemBoard {
             [17, { name: 'watercolors', desc: 'WaterColors', isLight: true, theme: 'watercolors' }],
         ]);
         this.valueMaps.pumpTypes = new byteValueMap([
-            [1, { name: 'ss', desc: 'Single Speed', maxCircuits: 8, hasAddress: false, hasBody: false, maxRelays: 1, relays: [{ id: 1, name: 'Pump On/Off' }]}],
-            [2, { name: 'ds', desc: 'Two Speed', maxCircuits: 8, hasAddress: false, hasBody: false, maxRelays: 2, relays: [{ id: 1, name: 'Low Speed' }, { id: 2, name: 'High Speed' }]}],
-            [3, { name: 'vs', desc: 'Intelliflo VS', maxPrimingTime: 6, minSpeed: 450, maxSpeed: 3450, maxCircuits: 8, hasAddress: true }],
-            [4, { name: 'vsf', desc: 'Intelliflo VSF', minSpeed: 450, maxSpeed: 3450, minFlow: 15, maxFlow: 130, maxCircuits: 8, hasAddress: true }],
-            [5, { name: 'vf', desc: 'Intelliflo VF', minFlow: 15, maxFlow: 130, maxCircuits: 8, hasAddress: true }],
-            [6, { name: 'hwvs', desc: 'Hayward Eco/TriStar VS', minSpeed: 450, maxSpeed: 3450, maxCircuits: 8, hasAddress: true }],
-            [7, { name: 'hwrly', desc: 'Hayward Relay VS', hasAddress: false, maxCircuits: 8, maxRelays: 4, maxSpeeds: 8, relays: [{ id: 1, name: 'Step #1' }, { id: 2, name: 'Step #2'}, { id: 3, name: 'Step #3' }, { id: 4, name: 'Pump On' }] }],
-            [100, { name: 'sf', desc: 'SuperFlo VS', hasAddress: false, maxCircuits: 8, maxRelays: 4, equipmentMaster: 1, maxSpeeds: 4, relays: [{ id: 1, name: 'Program #1' }, { id: 2, name: 'Program #2' }, { id: 3, name: 'Program #3' }, { id: 4, name: 'Program #4' }]}]
+            [1, { name: 'ss', desc: 'Single Speed', maxCircuits: 8, hasAddress: false, hasBody: false, maxRelays: 1, relays: [{ id: 1, name: 'Pump On/Off' }], addresses: []}],
+            [2, { name: 'ds', desc: 'Two Speed', maxCircuits: 8, hasAddress: false, hasBody: false, maxRelays: 2, relays: [{ id: 1, name: 'Low Speed' }, { id: 2, name: 'High Speed' }], addresses: []}],
+            [3, { name: 'vs', desc: 'Intelliflo VS', maxPrimingTime: 6, minSpeed: 450, maxSpeed: 3450, maxCircuits: 8, hasAddress: true, addresses: addrsPentairPump }],
+            [4, { name: 'vsf', desc: 'Intelliflo VSF', minSpeed: 450, maxSpeed: 3450, minFlow: 15, maxFlow: 130, maxCircuits: 8, hasAddress: true, addresses: addrsPentairPump }],
+            [5, { name: 'vf', desc: 'Intelliflo VF', minFlow: 15, maxFlow: 130, maxCircuits: 8, hasAddress: true, addresses: addrsPentairPump }],
+            [6, { name: 'hwvs', desc: 'Hayward Eco/TriStar VS', minSpeed: 450, maxSpeed: 3450, maxCircuits: 8, hasAddress: true, addresses: addrsPentairPump }],
+            [7, { name: 'hwrly', desc: 'Hayward Relay VS', hasAddress: false, maxCircuits: 8, maxRelays: 4, maxSpeeds: 8, relays: [{ id: 1, name: 'Step #1' }, { id: 2, name: 'Step #2'}, { id: 3, name: 'Step #3' }, { id: 4, name: 'Pump On' }], addresses: [] }],
+            [100, { name: 'sf', desc: 'SuperFlo VS', hasAddress: false, maxCircuits: 8, maxRelays: 4, equipmentMaster: 1, maxSpeeds: 4, relays: [{ id: 1, name: 'Program #1' }, { id: 2, name: 'Program #2' }, { id: 3, name: 'Program #3' }, { id: 4, name: 'Program #4' }], addresses: [] }],
+            [200, { name: 'regalmodbus', desc: 'Regal Modbus', minSpeed: 450, maxSpeed: 3450, maxCircuits: 8, hasAddress: true, addresses: addrsRegalModbusPump}],
         ]);
         // RSG - same as systemBoard definition; can delete.
         this.valueMaps.heatModes = new byteValueMap([
@@ -101,12 +108,20 @@ export class NixieBoard extends SystemBoard {
             [6, { name: 'sat', desc: 'Saturday', dow: 6, bitval: 32 }],
             [7, { name: 'sun', desc: 'Sunday', dow: 0, bitval: 64 }]
         ]);
+        /**
+         * groupCircuitStates value map:
+         * 1: 'on'         - Circuit should be ON when group is ON, OFF when group is OFF.
+         * 2: 'off'        - Circuit should be OFF when group is ON, ON when group is OFF.
+         * 3: 'ignore'     - Circuit is ignored by group state changes.
+         * 4: 'on+ignore'  - Circuit should be ON when group is ON, ignored when group is OFF.
+         * 5: 'off+ignore' - Circuit should be OFF when group is ON, ignored when group is OFF.
+         */
         this.valueMaps.groupCircuitStates = new byteValueMap([
-            [1, { name: 'on', desc: 'On/Off' }],
-            [2, { name: 'off', desc: 'Off/On' }],
-            [3, { name: 'ignore', desc: 'Ignore' }],
-            [4, { name: 'on+ignore', desc: 'On/Ignore' }],
-            [5, { name: 'off+ignore', desc: 'Off/Ignore' }]
+            [1, { name: 'on', desc: 'On/Off' }],         // 1: ON when group ON, OFF when group OFF
+            [2, { name: 'off', desc: 'Off/On' }],        // 2: OFF when group ON, ON when group OFF
+            [3, { name: 'ignore', desc: 'Ignore' }],     // 3: Ignored by group state
+            [4, { name: 'on+ignore', desc: 'On/Ignore' }],   // 4: ON when group ON, ignored when group OFF
+            [5, { name: 'off+ignore', desc: 'Off/Ignore' }]  // 5: OFF when group ON, ignored when group OFF
         ]);
         this.valueMaps.chlorinatorModel = new byteValueMap([
             [0, { name: 'unknown', desc: 'unknown', capacity: 0, chlorinePerDay: 0, chlorinePerSec: 0 }],
@@ -1231,7 +1246,7 @@ export class NixieCircuitCommands extends CircuitCommands {
     }
     public async deleteCircuitGroupAsync(obj: any): Promise<CircuitGroup> {
         let id = parseInt(obj.id, 10);
-        if (isNaN(id)) return Promise.reject(new EquipmentNotFoundError(`Invalid group id: ${obj.id}`, 'CircuitGroup'));
+        if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid group id: ${obj.id}`, obj.id, 'CircuitGroup'));
         if (!sys.board.equipmentIds.circuitGroups.isInRange(id)) return;
         if (typeof obj.id !== 'undefined') {
             let group = sys.circuitGroups.getItemById(id, false);
@@ -1249,7 +1264,7 @@ export class NixieCircuitCommands extends CircuitCommands {
     }
     public async deleteLightGroupAsync(obj: any): Promise<LightGroup> {
         let id = parseInt(obj.id, 10);
-        if (isNaN(id)) return Promise.reject(new EquipmentNotFoundError(`Invalid group id: ${obj.id}`, 'LightGroup'));
+        if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid group id: ${obj.id}`, obj.id, 'LightGroup'));
         if (!sys.board.equipmentIds.circuitGroups.isInRange(id)) return;
         if (typeof obj.id !== 'undefined') {
             let group = sys.lightGroups.getItemById(id, false);
@@ -1762,7 +1777,7 @@ export class NixieValveCommands extends ValveCommands {
             state.valves.removeItemById(id);
             ncp.valves.removeById(id);
             return valve;
-        } catch (err) { logger.error(`Nixie: Error removing valve from system ${obj.id}: ${err.message}`); return Promise.reject(new Error(`Nixie: Error removing valve from system ${ obj.id }: ${ err.message }`)); }
+        } catch (err) { return Promise.reject(new BoardProcessError(err.message, 'deleteValveAsync')); }
     }
     public async setValveStateAsync(valve: Valve, vstate: ValveState, isDiverted: boolean) {
         try {

package/controller/boards/SunTouchBoard.ts

@@ -31,6 +31,8 @@ export class SunTouchBoard extends EasyTouchBoard {
     constructor(system: PoolSystem) {
         super(system); // graph chain to EasyTouchBoard constructor.
         this.valueMaps.expansionBoards = new byteValueMap([
+            // 33 added per #1108; 
+            [33, { 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 }],
             [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 }]
         ]);

package/controller/boards/SystemBoard.ts

@@ -582,7 +582,7 @@ export class byteValueMaps {
     public valveModes: byteValueMap = new byteValueMap([
         [0, { name: 'off', desc: 'Off' }],
         [1, { name: 'pool', desc: 'Pool' }],
-        [2, { name: 'spa', dest: 'Spa' }],
+        [2, { name: 'spa', desc: 'Spa' }],
         [3, { name: 'spillway', desc: 'Spillway' }],
         [4, { name: 'spadrain', desc: 'Spa Drain' }]
     ]);

package/controller/comms/Comms.ts

@@ -139,7 +139,7 @@ export class Connection {
                 else {
                     if (!await existing.closeAsync()) {
                         existing.closing = false;  // if closing fails, reset flag so user can try again
-                        return Promise.reject(new InvalidOperationError(`Unable to close the current RS485 port`, 'setPortAsync'));
+                        return Promise.reject(new InvalidOperationError(`Unable to close the current RS485 port (Try to save the port again as it usually works the second time).`, 'setPortAsync'));
                     }
                 }
             config.setSection(section, pdata);
@@ -526,6 +526,8 @@ export class RS485Port {
     private procTimer: NodeJS.Timeout;
     public writeTimer: NodeJS.Timeout
     private _processing: boolean = false;
+    private _lastTx: number = 0;
+    private _lastRx: number = 0;
     private _inBytes: number[] = [];
     private _inBuffer: number[] = [];
     private _outBuffer: Outbound[] = [];
@@ -897,7 +899,9 @@ export class RS485Port {
     }
     // make public for now; should enable writing directly to mock port at Conn level...
     public pushIn(pkt: Buffer) {
-        this._inBuffer.push.apply(this._inBuffer, pkt.toJSON().data); if (sys.isReady) setImmediate(() => { this.processPackets(); });
+        this._inBuffer.push.apply(this._inBuffer, pkt.toJSON().data);
+        this._lastRx = Date.now();
+        if (sys.isReady) setImmediate(() => { this.processPackets(); });
     }
     private pushOut(msg) {
         this._outBuffer.push(msg); setImmediate(() => { this.processPackets(); });
@@ -988,9 +992,11 @@ export class RS485Port {
         // but this condition would be eval'd before the callback of port.write was calls and the outbound packet
         // would be sitting idle for eternity. 
         if (this._outBuffer.length > 0 || typeof this._waitingPacket !== 'undefined' || this._waitingPacket || typeof msg !== 'undefined') {
-            // Come back later as we still have items to send.
+            // Configurable inter-frame delay (default 30ms) overrides fixed 100ms.
+            const dCfg = (config.getSection('controller').txDelays || {});
+            const interFrame = Math.max(0, Number(dCfg.interFrameDelayMs || 30));
             let self = this;
-            this.procTimer = setTimeout(() => self.processPackets(), 100);
+            this.procTimer = setTimeout(() => self.processPackets(), interFrame);
         }
     }
     private writeMessage(msg: Outbound) {
@@ -1022,10 +1028,44 @@ export class RS485Port {
                     this.isRTS = true;
                     return;
                 }
-                this.counter.bytesSent += bytes.length;
-                msg.timestamp = new Date();
-                logger.packet(msg);
-                this.write(msg, (err) => {
+                const dCfg = (config.getSection('controller').txDelays || {});
+                const idleBeforeTx = Math.max(0, Number(dCfg.idleBeforeTxMs || 0));
+                const interByte = Math.max(0, Number(dCfg.interByteDelayMs || 0));
+                const now = Date.now();
+                const idleElapsed = now - Math.max(this._lastTx, this._lastRx);
+                const doWrite = () => {
+                    this.counter.bytesSent += bytes.length;
+                    msg.timestamp = new Date();
+                    logger.packet(msg);
+                    if (interByte > 0 && bytes.length > 1 && this._port && (this._port instanceof SerialPort || this._port instanceof SerialPortMock)) {
+                        // Manual inter-byte pacing
+                        let idx = 0;
+                        const writeNext = () => {
+                            if (idx >= bytes.length) {
+                                this._lastTx = Date.now();
+                                completeWrite(undefined);
+                                return;
+                            }
+                            const b = Buffer.from([bytes[idx++]]);
+                            (this._port as any).write(b, (err) => {
+                                if (err) {
+                                    this._lastTx = Date.now();
+                                    completeWrite(err);
+                                    return;
+                                }
+                                if (interByte > 0) setTimeout(writeNext, interByte);
+                                else setImmediate(writeNext);
+                            });
+                        };
+                        writeNext();
+                    } else {
+                        this.write(msg, (err) => {
+                            this._lastTx = Date.now();
+                            completeWrite(err);
+                        });
+                    }
+                };
+                const completeWrite = (err?: Error) => {
                     clearTimeout(this.writeTimer);
                     this.writeTimer = null;
                     msg.tries++;
@@ -1042,7 +1082,6 @@ export class RS485Port {
                             self._waitingPacket = null;
                             self.counter.sndAborted++;
                         }
-                        return;
                     }
                     else {
                         logger.verbose(`Wrote packet [Port ${this.portId} id: ${msg.id}] [${bytes}].Retries remaining: ${msg.remainingTries} `);
@@ -1053,15 +1092,17 @@ export class RS485Port {
                             self._waitingPacket = null;
                             self.counter.sndSuccess++;
                             if (typeof msg.onComplete === 'function') msg.onComplete(err, undefined);
-
-                        }
-                        else if (msg.remainingTries >= 0) {
-                            self._waitingPacket = msg;
                         }
+                        else if (msg.remainingTries >= 0) self._waitingPacket = msg;
                     }
                     self.counter.updatefailureRate();
                     self.emitPortStats();
-                });
+                };
+                // Honor idle-before-TX if not enough bus quiet time has elapsed
+                if (idleBeforeTx > 0 && idleElapsed < idleBeforeTx) {
+                    const wait = idleBeforeTx - idleElapsed;
+                    setTimeout(doWrite, wait);
+                } else doWrite();
             }
         }
         catch (err) {