nodejs-poolcontroller 8.1.2 → 8.3.0

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/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/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) {

package/controller/comms/messages/Messages.ts

@@ -42,6 +42,7 @@ import { IntellichemMessage } from "./config/IntellichemMessage";
 import { TouchScheduleCommands } from "controller/boards/EasyTouchBoard";
 import { IntelliValveStateMessage } from "./status/IntelliValveStateMessage";
 import { IntelliChemStateMessage } from "./status/IntelliChemStateMessage";
+import { RegalModbusStateMessage } from "./status/RegalModbusStateMessage";
 import { OutboundMessageError } from "../../Errors";
 import { conn } from "../Comms"
 import extend = require("extend");
@@ -61,7 +62,8 @@ export enum Protocol {
     Heater = 'heater',
     AquaLink = 'aqualink',
     Hayward = 'hayward',
-    Unidentified = 'unidentified'
+    Unidentified = 'unidentified',
+    RegalModbus = 'regalmodbus'
 }
 export class Message {
     constructor() { }
@@ -105,6 +107,9 @@ export class Message {
                 //0x10, 0x02, 0x00, 0x0C, 0x00, 0x00, 0x2D, 0x02, 0x36, 0x00, 0x83, 0x10, 0x03 -- Response from pump
                 return this.header.length > 4 ? this.header[2] : -1;
             }
+            else if (this.protocol === Protocol.RegalModbus) {
+                return this.header.length > 0 ? this.header[0] : -1;
+            }
             else return this.header.length > 2 ? this.header[2] : -1;
         }
         else return -1;
@@ -128,6 +133,10 @@ export class Message {
             //0x10, 0x02, 0x0C, 0x01, 0x02, 0x2D, 0x00, 0x4E, 0x10, 0x03 -- Command to AUX2 Pump
             return this.header.length > 4 ? this.header[4] : -1;
         }
+        else if (this.protocol === Protocol.RegalModbus) {
+            // No source address in RegalModbus.
+            return -1;
+        }
         if (this.header.length > 3) return this.header[3];
         else return -1;
     }
@@ -141,10 +150,57 @@ export class Message {
             //0x10, 0x02, 0x0C, 0x01, 0x02, 0x2D, 0x00, 0x4E, 0x10, 0x03 -- Command to AUX2 Pump
             return this.header.length > 3 ? this.header[3] || this.header[2] : -1;
         }
+        else if (this.protocol === Protocol.RegalModbus) {
+            return this.header.length > 1 ? this.header[1]: -1;
+        }
+        else if (this.header.length > 4) return this.header[4];
+        else return -1;
         if (this.header.length > 4) return this.header[4];
         else return -1;
     }
-    public get datalen(): number { return this.protocol === Protocol.Chlorinator || this.protocol === Protocol.AquaLink || this.protocol === Protocol.Hayward ? this.payload.length : this.header.length > 5 ? this.header[5] : -1; }
+    public get datalen(): number {
+        if (
+            this.protocol === Protocol.Chlorinator ||
+            this.protocol === Protocol.AquaLink ||
+            this.protocol === Protocol.Hayward
+        ) {
+            return this.payload.length;
+        }
+        else if (this.protocol === Protocol.RegalModbus) {
+            let action = this.action;
+            let ack = this.header[2];
+            switch (action) {
+                case 0x41: // Go
+                case 0x42: // Stop
+                    return 0;
+                case 0x43: // Status
+                    switch (ack) {
+                        case 0x10:
+                            return 1;
+                        case 0x20:
+                            return 0
+                    }
+                case 0x44:  // Set demand
+                    return 3;
+                case 0x45: // Read sensor
+                    switch (ack) {
+                        case 0x10:
+                            return 4;
+                        case 0x20:
+                            return 2;
+                    }
+                case 0x46:  // Read identification
+                    console.log("RegalModbus: Read identification not implemented yet.");
+                    break;
+                case 0x64:  // Configuration read/write
+                    console.log("RegalModbus: Configuration read/write not implemented yet.");
+                    break;
+                case 0x65:  // Store configuration
+                    return 0;
+            }
+        }
+        return this.header.length > 5 ? this.header[5] : -1;
+    }
     public get chkHi(): number { return this.protocol === Protocol.Chlorinator || this.protocol === Protocol.AquaLink ? 0 : this.term.length > 0 ? this.term[0] : -1; }
     public get chkLo(): number { return this.protocol === Protocol.Chlorinator || this.protocol === Protocol.AquaLink ? this.term[0] : this.term[1]; }
     public get checksum(): number {
@@ -249,8 +305,19 @@ export class Inbound extends Message {
     public rewinds: number = 0;
     // Private methods
     private isValidChecksum(): boolean {
-        if (this.protocol === Protocol.Chlorinator || this.protocol === Protocol.AquaLink) return this.checksum % 256 === this.chkLo;
-        return (this.chkHi * 256) + this.chkLo === this.checksum;
+        switch (this.protocol) {
+            case Protocol.Chlorinator:
+            case Protocol.AquaLink:
+                return this.checksum % 256 === this.chkLo;
+            case Protocol.RegalModbus: {
+                const data = this.header.concat(this.payload);
+                const crcComputed = computeCRC16(data);
+                const crcReceived = (this.chkLo << 8) | this.chkHi;
+                return crcComputed === crcReceived;
+            }
+            default:
+                return (this.chkHi * 256) + this.chkLo === this.checksum;
+        }
     }
     public toLog() {
         if (this.responseFor.length > 0)
@@ -284,6 +351,26 @@ export class Inbound extends Message {
         }
         return false;
     }
+    private testRegalModbusHeader(bytes: number[], ndx: number): boolean {
+        // RegalModbus protocol: header, function, ack, payload, crcLo, crcHi
+        if (bytes.length > ndx + 3 && sys.controllerType === 'nixie') {
+            // address must be in the range 0x15 to 0xF7
+            // function code must be in the range 0x00 to 0x7F
+            // ack must be in 0x10, 0x20, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x09, 0x0A
+            let addr = bytes[ndx];
+            let func = bytes[ndx + 1];
+            let ack = bytes[ndx + 2];
+            let acceptableAcks = [0x10, 0x20, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x09, 0x0A];
+
+            // logger.debug('Testing RegalModbus header', bytes, addr, func, ack, acceptableAcks.includes(ack));
+            // logger.debug(`Current bytes: ${JSON.stringify(bytes)}`);
+
+            if (addr >= 0x15 && addr <= 0xF7 && func >= 0x00 && func <= 0x7F && acceptableAcks.includes(ack)) {
+                return true;
+            }
+        }
+        return false;
+    }
     private testAquaLinkHeader(bytes: number[], ndx: number): boolean {
         if (bytes.length > ndx + 4 && sys.controllerType === 'aqualink') {
             if (bytes[ndx] === 16 && bytes[ndx + 1] === 2) {
@@ -412,6 +499,11 @@ export class Inbound extends Message {
                     this.protocol = Protocol.Hayward;
                     break;
                 }
+                if (this.testRegalModbusHeader(bytes, ndx)) {
+                    this.protocol = Protocol.RegalModbus;
+                    logger.debug(`RegalModbus header detected. ${JSON.stringify(bytes)}`);
+                    break;
+                }
                 this.padding.push(bytes[ndx++]);
             }
         }
@@ -496,6 +588,17 @@ export class Inbound extends Message {
                     return ndxHeader;
                 }
                 break;
+            case Protocol.RegalModbus:
+                ndx = this.pushBytes(this.header, bytes, ndx, 3);
+                if (this.header.length < 3) {
+                    // We actually don't have a complete header yet so just return.
+                    // we will pick it up next go around.
+                    logger.debug(`We have an incoming RegalModbus message but the serial port hasn't given a complete header. [${this.padding}][${this.preamble}][${this.header}]`);
+                    this.preamble = [];
+                    this.header = [];
+                    return ndxHeader;
+                }
+                break;
             default:
                 // We didn't get a message signature. don't do anything with it.
                 ndx = ndxStart;
@@ -567,6 +670,17 @@ export class Inbound extends Message {
                     }
                 }
                 break;
+            case Protocol.RegalModbus:
+                // RegalModbus protocol: header, function, ack, payload, crcLo, crcHi
+                while (ndx + 3 <= bytes.length) {
+                    this.payload.push(bytes[ndx++]);
+                    if (this.payload.length > 11) {
+                        this.isValid = false; // We have a runaway packet.  Some collision occurred so lets preserve future packets.
+                        logger.debug(`RegalModbus message marked as invalid due to payload more than 11 bytes`);
+                        break;
+                    }
+                }
+                break;
 
         }
         return ndx;
@@ -580,6 +694,7 @@ export class Inbound extends Message {
             case Protocol.IntelliValve:
             case Protocol.IntelliChem:
             case Protocol.Heater:
+            case Protocol.RegalModbus:
             case Protocol.Unidentified:
                 // If we don't have enough bytes to make the terminator then continue on and
                 // hope we get them on the next go around.
@@ -810,6 +925,9 @@ export class Inbound extends Message {
             case Protocol.Hayward:
                 PumpStateMessage.processHayward(this);
                 break;
+            case Protocol.RegalModbus:
+                RegalModbusStateMessage.process(this);
+                break;
             default:
                 logger.debug(`Unprocessed Message ${this.toPacket()}`)
                 break;
@@ -822,6 +940,7 @@ class OutboundCommon extends Message {
     public set dest(val: number) {
         if (this.protocol === Protocol.Chlorinator) this.header[2] = val;
         else if (this.protocol === Protocol.Hayward) this.header[4] = val;
+        else if (this.protocol === Protocol.RegalModbus) this.header[0] = val;
         else this.header[2] = val;
     }
     public get dest() { return super.dest; }
@@ -832,6 +951,8 @@ class OutboundCommon extends Message {
             case Protocol.Hayward:
                 this.header[3] = val;
                 break;
+            case Protocol.RegalModbus:
+                break;
             default:
                 this.header[3] = val;
                 break;
@@ -848,13 +969,20 @@ class OutboundCommon extends Message {
             case Protocol.Hayward:
                 this.header[2] = val;
                 break;
+            case Protocol.RegalModbus:
+                this.header[1] = val;
+                break;
             default:
                 this.header[4] = val;
                 break;
         }
     }
     public get action() { return super.action; }
-    public set datalen(val: number) { if (this.protocol !== Protocol.Chlorinator && this.protocol !== Protocol.Hayward) this.header[5] = val; }
+    public set datalen(val: number) { 
+        if (this.protocol !== Protocol.Chlorinator && this.protocol !== Protocol.Hayward && this.protocol !== Protocol.RegalModbus) {
+            this.header[5] = val; 
+        }
+    }
     public get datalen() { return super.datalen; }
     public set chkHi(val: number) { if (this.protocol !== Protocol.Chlorinator) this.term[0] = val; }
     public get chkHi() { return super.chkHi; }
@@ -879,6 +1007,16 @@ class OutboundCommon extends Message {
             case Protocol.Chlorinator:
                 this.term[0] = sum % 256;
                 break;
+            case Protocol.RegalModbus:
+                // Calculate checksum using the CRC16 algorithm and set chkHi and chkLo.
+                // This.payload is expected to be an array of numbers (byte values 0–255)
+                // combine header and payload for CRC calculation
+                let data: number[] = this.header.concat(this.payload);
+                const crc: number = computeCRC16(data);
+                // Extract the high and low bytes from the 16-bit CRC:
+                this.chkLo = (crc >> 8) & 0xFF;
+                this.chkHi = crc & 0xFF;
+                break;
         }
     }
 }
@@ -911,6 +1049,9 @@ export class Outbound extends OutboundCommon {
             this.header.push.apply(this.header, [16, 2, 0, 0, 0]);
             this.term.push.apply(this.term, [0, 0, 16, 3]);
         }
+        else if (proto === Protocol.RegalModbus) {
+            this.header.push.apply(this.header, [this.dest, this.action, 0x20]);
+        }
         this.scope = scope;
         this.source = source;
         this.dest = dest;
@@ -1184,6 +1325,12 @@ export class Response extends OutboundCommon {
                     return false;
             }
         }
+        else if (msgIn.protocol === Protocol.RegalModbus) {
+            // RegalModbus is a little different.  The action is the function code and the payload is the data.
+            // We are looking for a match on the action an ack of 0x10.
+            if (msgIn.action === msgOut.action && msgIn.header[2] === 0x10) return true;
+            return false;
+        }
         else if (msgIn.protocol === Protocol.Chlorinator) {
             switch (msgIn.action) {
                 case 1:
@@ -1240,4 +1387,20 @@ export class Response extends OutboundCommon {
             return true;
         }
     }
-}
+}
+
+/**
+ * Computes the CRC16 checksum over an array of bytes using the RegalModbus algorithm.
+ * @param data - The array of byte values (numbers between 0 and 255).
+ * @returns The computed 16-bit checksum.
+ */
+export function computeCRC16(data: number[]): number {
+    let crc = 0xFFFF;
+    for (const byte of data) {
+        crc ^= byte;
+        for (let j = 0; j < 8; j++) {
+            crc = (crc & 0x0001) ? (crc >> 1) ^ 0xA001 : crc >> 1;
+        }
+    }
+    return crc;
+}