nodejs-poolcontroller 7.3.1 → 7.6.1

package/controller/comms/Comms.ts

@@ -43,9 +43,9 @@ export class Connection {
         if (conn.connTimer !== null) clearTimeout(conn.connTimer);
         if (!conn._cfg.mockPort && conn._cfg.inactivityRetry > 0 && !conn._closing) conn.connTimer = setTimeout(async () => {
             try {
-                await conn.openAsync()
+                await conn.openAsync();
             }
-            catch (err) {};
+            catch (err) { logger.error(`Error resetting RS485 port on inactivity: ${err.message}`); };
         }, conn._cfg.inactivityRetry * 1000);
     }
     public isRTS: boolean = true;
@@ -82,8 +82,132 @@ export class Connection {
             return this._cfg;
         } catch (err) { return Promise.reject(err); }
     }
+    // RKS: 12-18-21 This is a bullpen method to work through the inconsistencies in the socket implementation for node.  There
+    // are issues related to the event listeners and the construction of a socket.  We want an implementation that awaits until the socket
+    // is completely open before continuing.
+    // We also need to be able to destroy the port without it restarting on its own when tearing the port down or deliberately closing it.  This means
+    // that the listeners need to be removed before closing via method but re-open the port when the close is hit prematurely.
+    protected async openNetSerialPort(): Promise<boolean> {
+        try {
+            let opts: net.NetConnectOpts = {
+                host: this._cfg.netHost,
+                port: this._cfg.netPort
+            };
+            if (typeof this.connTimer !== 'undefined' && this.connTimer) clearTimeout(this.connTimer);
+            this.connTimer = null;
+            let ret = await new Promise<boolean>((resolve, _) => {
+                let nc = net.createConnection(opts, () => {
+                    nc.on('connect', () => { logger.info(`Net connect (socat) connected to: ${this._cfg.netHost}:${this._cfg.netPort}`); }); // Socket is opened but not yet ready.
+                    nc.on('ready', () => {
+                        this.isOpen = true;
+                        this.isRTS = true;
+                        logger.info(`Net connect (socat) ready and communicating: ${this._cfg.netHost}:${this._cfg.netPort}`);
+                        nc.on('data', (data) => {
+                            if (data.length > 0 && !this.isPaused) this.emitter.emit('packetread', data);
+                        });
+                        this._port = nc;
+                        // After the port is fully opened, set an inactivity timeout to restart it when it stops communicating.
+                        nc.setTimeout(Math.max(this._cfg.inactivityRetry, 10) * 1000, async () => {
+                            logger.warn(`Net connect (socat) connection idle: ${this._cfg.netHost}:${this._cfg.netPort} retrying connection.`);
+                            try {
+                                await conn.endAsync();
+                                await conn.openAsync();
+                            } catch (err) { logger.error(`Net connect (socat) error retrying connection ${err.message}`); }
+                        });
+                        resolve(true);
+                    });
+                    nc.on('close', (hadError: boolean) => {
+                        this.isOpen = false;
+                        if (typeof this._port !== 'undefined') {
+                            this._port.destroy();
+                            this._port.removeAllListeners();
+                        }
+                        this._port = undefined;
+                        this.buffer.clearOutbound();
+                        logger.info(`Net connect (socat) closed ${hadError === true ? 'due to error' : ''}: ${this._cfg.netHost}:${this._cfg.netPort}`);
+                        if (!this._closing) {
+                            // If we are closing manually this event should have been cleared already and should never be called.  If this is fired out
+                            // of sequence then we will check the closing flag to ensure we are not forcibly closing the socket.
+                            if (typeof this.connTimer !== 'undefined' && this.connTimer) {
+                                clearTimeout(this.connTimer);
+                                this.connTimer = null;
+                            }
+                            this.connTimer = setTimeout(async () => {
+                                try {
+                                    // We are already closed so give some inactivity retry and try again.
+                                    await conn.openAsync();
+                                } catch (err) { }
+                            }, this._cfg.inactivityRetry * 1000);
+                        }
+                    });
+                    nc.on('end', () => { // Happens when the other end of the socket closes.
+                        this.isOpen = false;
+                        logger.info(`Net connect (socat) end event was fired`);
+                    });
+                });
+                nc.once('error', (err) => {
+                    // if the promise has already been fulfilled, but the error happens later, we don't want to call the promise again.
+                    if (this._cfg.inactivityRetry > 0) {
+                        logger.error(`Net connect (socat) connection error: ${err}.  Retry in ${this._cfg.inactivityRetry} seconds`);
+                        this.connTimer = setTimeout(async () => {
+                            try {
+                                await conn.closeAsync();
+                                await conn.openAsync();
+                            } catch (err) { }
+                        }, this._cfg.inactivityRetry * 1000);
+                    }
+                    else logger.error(`Net connect (socat) connection error: ${err}.  Never retrying -- No retry time set`);
+                    resolve(false);
+                });
+            });
+            return ret;
+        } catch (err) { logger.error(`Error opening net serial port. ${this._cfg.netHost}:${this._cfg.netPort}`); }
+    }
+    protected async closeNetSerialPort(): Promise<boolean> {
+        try {
+            this._closing = true;
+            if (this.connTimer) clearTimeout(this.connTimer);
+            this.connTimer = null;
+            if (typeof this._port !== 'undefined' && this.isOpen) {
+                let success = await new Promise<boolean>((resolve, reject) => {
+                    if (this._cfg.netConnect) {
+                        this._port.removeAllListeners();
+                        this._port.once('error', (err) => {
+                            if (err) {
+                                logger.error(`Net connect (socat) error closing ${this._cfg.netHost}:${this._cfg.netPort}: ${err}`);
+                                resolve(false);
+                            }
+                            else {
+                                conn._port = undefined;
+                                this.isOpen = false;
+                                logger.info(`Successfully closed (socat) port ${this._cfg.netHost}:${this._cfg.netPort}`);
+                                resolve(true);
+                            }
+                        });
+                        this._port.once('close', (p) => {
+                            this.isOpen = false;
+                            this._port = undefined;
+                            logger.info(`Net connect (socat) successfully closed: ${this._cfg.netHost}:${this._cfg.netPort}`);
+                            resolve(true);
+                        });
+                        this._port.destroy();
+                    }
+                    else {
+                        resolve(true);
+                        conn._port = undefined;
+                    }
+                });
+                if (success) {
+                    if (typeof conn.buffer !== 'undefined') conn.buffer.close();
+                }
+                return success;
+            }
+            return true;
+        } catch (err) { logger.error(`Error closing comms connection: ${err.message}`); return Promise.resolve(false); }
+
+    }
     public async openAsync(): Promise<boolean> {
-        if (typeof (this.buffer) === 'undefined') {
+        if (typeof this.buffer === 'undefined') {
             this.buffer = new SendRecieveBuffer();
             this.emitter.on('packetread', (pkt) => { this.buffer.pushIn(pkt); });
             this.emitter.on('messagewrite', (msg) => { this.buffer.pushOut(msg); });
@@ -97,18 +221,38 @@ export class Connection {
             let nc: net.Socket = new net.Socket();
             nc.on('connect', () => { logger.info(`Net connect (socat) connected to: ${this._cfg.netHost}:${this._cfg.netPort}`); }); // Socket is opened but not yet ready.
             nc.on('ready', () => {
+                this.isOpen = true;
+                this.isRTS = true;
                 logger.info(`Net connect (socat) ready and communicating: ${this._cfg.netHost}:${this._cfg.netPort}`);
-                nc.on('data', (data) => { if (data.length > 0 && !this.isPaused) this.emitter.emit('packetread', data); });
+                nc.on('data', (data) => {
+                    //this.resetConnTimer();
+                    if (data.length > 0 && !this.isPaused) this.emitter.emit('packetread', data);
+                });
             });
             nc.on('close', (p) => {
                 this.isOpen = false;
                 if (typeof this._port !== 'undefined') this._port.destroy();
                 this._port = undefined;
+                this.buffer.clearOutbound();
+                if (!this._closing) {
+                    // If we are closing manually this event should have been cleared already and should never be called.  If this is fired out
+                    // of sequence then we will check the closing flag to ensure we are not forcibly closing the socket.
+                    if (typeof this.connTimer !== 'undefined' && this.connTimer) {
+                        clearTimeout(this.connTimer);
+                        this.connTimer = null;
+                    }
+                    this.connTimer = setTimeout(async () => {
+                        try {
+                            // We are already closed so give some inactivity retry and try again.
+                            await conn.openAsync();
+                        } catch (err) { }
+                    }, this._cfg.inactivityRetry * 1000);
+                }
                 logger.info(`Net connect (socat) closed ${p === true ? 'due to error' : ''}: ${this._cfg.netHost}:${this._cfg.netPort}`);
             });
             nc.on('end', () => { // Happens when the other end of the socket closes.
                 this.isOpen = false;
-                this.resetConnTimer();
+                //this.resetConnTimer();
                 logger.info(`Net connect (socat) end event was fired`);
             });
             //nc.on('drain', () => { logger.info(`The drain event was fired.`); });
@@ -116,15 +260,28 @@ export class Connection {
             // Occurs when there is no activity.  This should not reset the connection, the previous implementation did so and
             // left the connection in a weird state where the previous connection was processing events and the new connection was
             // doing so as well.  This isn't an error it is a warning as the RS485 bus will most likely be communicating at all times.
-            nc.on('timeout', () => { logger.warn(`Net connect (socat) Connection Idle: ${this._cfg.netHost}:${this._cfg.netPort}`); });
+            //nc.on('timeout', () => { logger.warn(`Net connect (socat) Connection Idle: ${this._cfg.netHost}:${this._cfg.netPort}`); });
+            nc.setTimeout(Math.max(this._cfg.inactivityRetry, 10) * 1000, async () => {
+                logger.warn(`Net connect (socat) connection idle: ${this._cfg.netHost}:${this._cfg.netPort} retrying connection.`);
+                try {
+                    await conn.endAsync();
+                    await conn.openAsync();
+                } catch (err) { logger.error(`Net connect (socat) error retrying connection ${err.message}`); }
+            });
+
             return await new Promise<boolean>((resolve, _) => {
                 // We only connect an error once as we will destroy this connection on error then recreate a new socket on failure.
                 nc.once('error', (err) => {
-                    logger.error(`Net connect (socat) Connection: ${err}. ${this._cfg.inactivityRetry > 0 ? `Retry in ${this._cfg.inactivityRetry} seconds` : `Never retrying; inactivityRetry set to ${this._cfg.inactivityRetry}`}`);
-                    this.resetConnTimer();
+                    //logger.error(`Net connect (socat) Connection: ${err}. ${this._cfg.inactivityRetry > 0 ? `Retry in ${this._cfg.inactivityRetry} seconds` : `Never retrying; inactivityRetry set to ${this._cfg.inactivityRetry}`}`);
+                    //this.resetConnTimer();
                     this.isOpen = false;
                     // if the promise has already been fulfilled, but the error happens later, we don't want to call the promise again.
                     if (typeof resolve !== 'undefined') { resolve(false); }
+                    if (this._cfg.inactivityRetry > 0) {
+                        logger.error(`Net connect (socat) connection error: ${err}.  Retry in ${this._cfg.inactivityRetry} seconds`);
+                        setTimeout(async () => { try { await conn.openAsync(); } catch (err) { } }, this._cfg.inactivityRetry * 1000);
+                    }
+                    else logger.error(`Net connect (socat) connection error: ${err}.  Never retrying -- No retry time set`);
                 });
                 nc.connect(conn._cfg.netPort, conn._cfg.netHost, () => {
                     if (typeof this._port !== 'undefined') logger.warn('Net connect (socat) recovered from lost connection.');
@@ -243,12 +400,67 @@ export class Connection {
                 if (success) {
                     if (typeof conn.buffer !== 'undefined') conn.buffer.close();
                 }
-               
                 return success;
             }
             return true;
         } catch (err) { logger.error(`Error closing comms connection: ${err.message}`); return Promise.resolve(false); }
     }
+    public async endAsync(): Promise<boolean> {
+        try {
+            this._closing = true;
+            if (this.connTimer) clearTimeout(this.connTimer);
+            if (typeof this._port !== 'undefined' && this.isOpen) {
+                let success = await new Promise<boolean>((resolve, reject) => {
+                    if (this._cfg.netConnect) {
+                        this._port.removeAllListeners();
+                        this._port.once('error', (err) => {
+                            if (err) {
+                                logger.error(`Error closing ${this._cfg.netHost}:${this._cfg.netPort}/${this._cfg.rs485Port}: ${err}`);
+                                resolve(false);
+                            }
+                            else {
+                                conn._port = undefined;
+                                this.isOpen = false;
+                                logger.info(`Successfully closed (socat) port ${this._cfg.netHost}:${this._cfg.netPort}/${this._cfg.rs485Port}`);
+                                resolve(true);
+                            }
+                        });
+                        this._port.once('close', (p) => {
+                            this.isOpen = false;
+                            this._port = undefined;
+                            logger.info(`Net connect (socat) successfully closed: ${this._cfg.netHost}:${this._cfg.netPort}`);
+                            resolve(true);
+                        });
+                        this._port.destroy();
+                    }
+                    else if (typeof conn._port.close === 'function') {
+                        conn._port.close((err) => {
+                            if (err) {
+                                logger.error(`Error closing ${this._cfg.rs485Port}: ${err}`);
+                                resolve(false);
+                            }
+                            else {
+                                conn._port = undefined;
+                                logger.info(`Successfully closed seral port ${this._cfg.rs485Port}`);
+                                resolve(true);
+                                this.isOpen = false;
+                            }
+                        });
+                    }
+                    else {
+                        resolve(true);
+                        conn._port = undefined;
+                    }
+                });
+                if (success) {
+                    if (typeof conn.buffer !== 'undefined') conn.buffer.close();
+                }
+                return success;
+            }
+            return true;
+        } catch (err) { logger.error(`Error closing comms connection: ${err.message}`); return Promise.resolve(false); }
+        finally { this._closing = false; }
+    }
     public drain(cb: Function) {
         if (typeof (conn._port.drain) === 'function')
             conn._port.drain(cb);
@@ -347,7 +559,7 @@ export class SendRecieveBuffer {
     public pushOut(msg) { conn.buffer._outBuffer.push(msg); setTimeout(() => { this.processPackets(); }, 0); }
     public clear() { conn.buffer._inBuffer.length = 0; conn.buffer._outBuffer.length = 0; }
     public close() { clearTimeout(conn.buffer.procTimer); conn.buffer.clear(); this._msg = undefined; }
-
+    public clearOutbound() { conn.buffer._outBuffer.length = 0; conn.buffer._waitingPacket = undefined; }
     /********************************************************************
      * RKS: 06-06-20
      * This used to process every 175ms.  While the processing was light

package/controller/comms/messages/Messages.ts

@@ -168,12 +168,13 @@ export class Inbound extends Message {
             return `{"id":${this.id},"valid":${this.isValid},"dir":"${this.direction}","proto":"${this.protocol}","for":${JSON.stringify(this.responseFor)},"pkt":[${JSON.stringify(this.padding)},${JSON.stringify(this.preamble)},${JSON.stringify(this.header)},${JSON.stringify(this.payload)},${JSON.stringify(this.term)}],"ts": "${Timestamp.toISOLocal(this.timestamp)}"}`;
         return `{"id":${this.id},"valid":${this.isValid},"dir":"${this.direction}","proto":"${this.protocol}","pkt":[${JSON.stringify(this.padding)},${JSON.stringify(this.preamble)},${JSON.stringify(this.header)},${JSON.stringify(this.payload)},${JSON.stringify(this.term)}],"ts": "${Timestamp.toISOLocal(this.timestamp)}"}`;
     }
-    private testChlorHeader(bytes: number[], ndx: number): boolean { 
+    private testChlorHeader(bytes: number[], ndx: number): boolean {
         // if packets have 16,2 (eg status=16,2,29) in them and they come as partial packets, they would have
         // prev been detected as chlor packets;
         // valid chlor packets should have 16,2,0 or 16,2,[80-96];
         // this should reduce the number of false chlor packets
-        return (ndx + 2 < bytes.length && bytes[ndx] === 16 && bytes[ndx + 1] === 2 && (bytes[ndx + 2] === 0 || (bytes[ndx + 2] >= 80 && bytes[ndx + 2] <= 96))); }
+        return (ndx + 2 < bytes.length && bytes[ndx] === 16 && bytes[ndx + 1] === 2 && (bytes[ndx + 2] === 0 || (bytes[ndx + 2] >= 80 && bytes[ndx + 2] <= 96)))
+    }
     private testBroadcastHeader(bytes: number[], ndx: number): boolean { return ndx < bytes.length - 3 && bytes[ndx] === 255 && bytes[ndx + 1] === 0 && bytes[ndx + 2] === 255 && bytes[ndx + 3] === 165; }
     private testUnidentifiedHeader(bytes: number[], ndx: number): boolean { return ndx < bytes.length - 3 && bytes[ndx] === 255 && bytes[ndx + 1] === 0 && bytes[ndx + 2] === 255 && bytes[ndx + 3] !== 165; }
     private testChlorTerm(bytes: number[], ndx: number): boolean { return ndx < bytes.length - 2 && bytes[ndx + 1] === 16 && bytes[ndx + 2] === 3; }
@@ -404,6 +405,7 @@ export class Inbound extends Message {
             case ControllerType.IntelliCenter:
                 switch (this.action) {
                     case 1: // ACK
+                        this.isProcessed = true;
                         break;
                     case 2:
                     case 204:
@@ -423,12 +425,14 @@ export class Inbound extends Message {
                         break;
                     case 222: // A panel is asking for action 30s
                     case 228: // A panel is asking for the current version
+                        this.isProcessed = true;
                         break;
                     default:
                         logger.info(`An unprocessed message was received ${this.toPacket()}`)
                         break;
 
                 }
+                if (!this.isProcessed) logger.info(`The message was not processed ${this.action} - ${this.toPacket()}`);
                 break;
             default:
                 switch (this.action) {
@@ -483,14 +487,12 @@ export class Inbound extends Message {
                         CircuitMessage.processTouch(this);
                         break;
                     case 40:
+                    case 168:
                         OptionsMessage.process(this);
                         break;
                     case 41:
                         CircuitGroupMessage.process(this);
                         break;
-                    case 168:
-                        if (sys.controllerType !== ControllerType.Unknown) HeaterMessage.process(this);
-                        break;
                     case 197:
                         EquipmentStateMessage.process(this);    // Date/Time request
                         break;
@@ -500,17 +502,19 @@ export class Inbound extends Message {
                     case 9:
                     case 16:
                     case 34:
-                    case 114:
                     case 137:
                     case 144:
                     case 162:
                         HeaterMessage.process(this);
                         break;
+                    case 114:
+                    case 115:
+                        HeaterStateMessage.process(this);
+                        break
                     case 147:
                         IntellichemMessage.process(this);
                         break;
                     default:
-                        // take these out...
                         if (this.action === 109 && this.payload[1] === 3) break;
                         if (this.source === 17 && this.payload[0] === 109) break;
                         logger.debug(`Packet not processed: ${this.toPacket()}`);
@@ -626,11 +630,11 @@ export class Outbound extends OutboundCommon {
         out.onComplete = obj.onComplete;
         out.onAbort = obj.onAbort;
         out.timeout = obj.timeout;
-        for (let i = 0; i < out.header.length; i++){
+        for (let i = 0; i < out.header.length; i++) {
             if (out.header[i] >= 0 && out.header[i] <= 255 && out.header[i] !== null && typeof out.header[i] !== 'undefined') continue;
             throw new OutboundMessageError(out, `Invalid header detected: ${out.toShortPacket()}`);
         }
-        for (let i = 0; i < out.payload.length; i++){
+        for (let i = 0; i < out.payload.length; i++) {
             if (out.payload[i] >= 0 && out.payload[i] <= 255 && out.payload[i] !== null && typeof out.payload[i] !== 'undefined') continue;
             throw new OutboundMessageError(out, `Invalid payload detected: ${out.toShortPacket()}`);
         }

package/controller/comms/messages/config/ChlorinatorMessage.ts

@@ -27,15 +27,19 @@ export class ChlorinatorMessage {
                 chlorId = 1;
                 for (let i = 0; i < 4 && i + 30 < msg.payload.length; i++) {
                     let isActive = msg.extractPayloadByte(i + 22) === 1;
+                    chlor = sys.chlorinators.getItemById(chlorId);
+                    if (chlor.master === 1) continue; // RSG: probably never need this.  See Touch chlor below.
                     if (isActive) {
-                        let chlor = sys.chlorinators.getItemById(chlorId, true);
+                        chlor = sys.chlorinators.getItemById(chlorId, true);
                         let schlor = state.chlorinators.getItemById(chlor.id, true);
                         chlor.isActive = schlor.isActive = true;
                         chlor.body = msg.extractPayloadByte(i + 2);
                         chlor.type = msg.extractPayloadByte(i + 6);
-                        if (!chlor.disabled) {
+                        if (!chlor.disabled && !chlor.isDosing) {
                             // RKS: We don't want to change the setpoints if our chem controller disabled
                             // the chlorinator.  These should be 0.
+                            if (msg.extractPayloadByte(i + 10) === 0 && chlor.poolSetpoint > 0) logger.info(`Changing pool setpoint to 0 ${msg.extractPayloadByte(i + 10)}`);
+
                             chlor.poolSetpoint = msg.extractPayloadByte(i + 10);
                             chlor.spaSetpoint = msg.extractPayloadByte(i + 14);
                         }
@@ -57,6 +61,7 @@ export class ChlorinatorMessage {
                     }
                     chlorId++;
                 }
+                msg.isProcessed = true;
                 break;
             default:
                 logger.debug(`Unprocessed Config Message ${msg.toPacket()}`)
@@ -65,6 +70,8 @@ export class ChlorinatorMessage {
     }
     public static processTouch(msg: Inbound) {
         // This is for the 25 message that is broadcast from the OCP.
+        let chlor = sys.chlorinators.getItemById(1);
+        if (chlor.master === 1) return;  // Some Aquarite chlors need more frequent control (via Nixie) but will be disabled via Touch.  https://github.com/tagyoureit/nodejs-poolController/issues/349
         let isActive = (msg.extractPayloadByte(0) & 0x01) === 1;
         if (isActive) {
             let chlor = sys.chlorinators.getItemById(1, true);
@@ -78,8 +85,9 @@ export class ChlorinatorMessage {
                 chlor.address = chlor.id + 79;
                 schlor.body = chlor.body = sys.equipment.maxBodies >= 1 || sys.equipment.shared === true ? 32 : 0;
             }
-            schlor.name = chlor.name = msg.extractPayloadString(6, 16);
-            if (typeof chlor.model === 'undefined') chlor.model  = schlor.name; 
+            if (typeof chlor.name === 'undefined') schlor.name = chlor.name = msg.extractPayloadString(6, 16);
+            if (typeof chlor.model === 'undefined') chlor.model  = sys.board.valueMaps.chlorinatorModel.getValue(schlor.name.toLowerCase()); 
+            if (typeof chlor.type === 'undefined') chlor.type = schlor.type = 0; 
             schlor.saltLevel = msg.extractPayloadByte(3) * 50 || schlor.saltLevel;
             schlor.status = msg.extractPayloadByte(4) & 0x007F; // Strip off the high bit.  The chlorinator does not actually report this.;
             // Pull the hours from the 25 message.
@@ -110,5 +118,6 @@ export class ChlorinatorMessage {
             sys.chlorinators.removeItemById(1);
             state.chlorinators.removeItemById(1);
         }
+        msg.isProcessed = true;
     }
 }

package/controller/comms/messages/config/CircuitGroupMessage.ts

@@ -80,6 +80,7 @@ export class CircuitGroupMessage {
                         group.circuits.removeItemByIndex(i);
                 }
             }
+            msg.isProcessed = true;
         }
         else if (msgId >= 16 && msgId <= 31) {
             groupId = msgId - 16 + sys.board.equipmentIds.circuitGroups.start;
@@ -90,6 +91,7 @@ export class CircuitGroupMessage {
                     group.name = msg.extractPayloadString(2, 16);
                     sgroup.name = group.name;
                 }
+                msg.isProcessed = true;
             }
         }
     }
@@ -143,6 +145,7 @@ export class CircuitGroupMessage {
             state.circuitGroups.removeItemById(groupId);
         }
         state.emitEquipmentChanges();
+        msg.isProcessed = true;
     }
     private static processGroupType(msg: Inbound) {
         var groupId = ((msg.extractPayloadByte(1) - 32) * 16) + sys.board.equipmentIds.circuitGroups.start;
@@ -188,6 +191,7 @@ export class CircuitGroupMessage {
             sgroup.type = group.type;
         }
         state.emitEquipmentChanges();
+        msg.isProcessed = true;
     }
     private static processColor(msg: Inbound) {
         var groupId = ((msg.extractPayloadByte(1) - 35)) + sys.board.equipmentIds.circuitGroups.start;
@@ -208,6 +212,7 @@ export class CircuitGroupMessage {
             }
 
         }
+        msg.isProcessed = true;
     }
     private static processEggTimer(msg: Inbound) {
         var groupId = ((msg.extractPayloadByte(1) - 34) * 16) + sys.board.equipmentIds.circuitGroups.start;
@@ -220,5 +225,6 @@ export class CircuitGroupMessage {
                 //  sgroup.eggTimer = group.eggTimer;
             }
         }
+        msg.isProcessed = true;
     }
 }

package/controller/comms/messages/config/CoverMessage.ts

@@ -32,6 +32,7 @@ export class CoverMessage {
               for (let i = 1; i < 10; i++) {
                   if (msg.extractPayloadByte(i + 18) !== 255) cover.circuits.push(msg.extractPayloadByte(i + 18));
               }
+              msg.isProcessed = true;
               break;
           default:
               logger.debug(`Unprocessed Config Message ${msg.toPacket()}`)

package/controller/comms/messages/config/CustomNameMessage.ts

@@ -1,31 +1,31 @@
-/*  nodejs-poolController.  An application to control pool equipment.
-Copyright (C) 2016, 2017, 2018, 2019, 2020.  Russell Goldin, tagyoureit.  russ.goldin@gmail.com
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU Affero General Public License as
-published by the Free Software Foundation, either version 3 of the
-License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Affero General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-import { Inbound } from "../Messages";
-import { sys } from "../../../Equipment";
-export class CustomNameMessage
-{
-    public static process ( msg: Inbound ): void
-    {
-        let customNameId = msg.extractPayloadByte( 0 );
-        let customName = sys.customNames.getItemById( customNameId, customNameId <= sys.equipment.maxCustomNames );
-        customName.name = msg.extractPayloadString( 1, 11 );
-        // customName.isActive = customNameId <= sys.equipment.maxCustomNames && !customName.name.includes('USERNAME-')
-        if (customNameId >= sys.equipment.maxCustomNames) sys.equipment.maxCustomNames = customNameId + 1;
-        sys.board.system.syncCustomNamesValueMap();
-        msg.isProcessed = true;
-    }
+/*  nodejs-poolController.  An application to control pool equipment.
+Copyright (C) 2016, 2017, 2018, 2019, 2020.  Russell Goldin, tagyoureit.  russ.goldin@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+import { Inbound } from "../Messages";
+import { sys } from "../../../Equipment";
+export class CustomNameMessage
+{
+    public static process ( msg: Inbound ): void
+    {
+        let customNameId = msg.extractPayloadByte( 0 );
+        let customName = sys.customNames.getItemById( customNameId, customNameId <= sys.equipment.maxCustomNames );
+        customName.name = msg.extractPayloadString( 1, 11 );
+        // customName.isActive = customNameId <= sys.equipment.maxCustomNames && !customName.name.includes('USERNAME-')
+        if (customNameId >= sys.equipment.maxCustomNames) sys.equipment.maxCustomNames = customNameId + 1;
+        sys.board.system.syncCustomNamesValueMap();
+        msg.isProcessed = true;
+    }
 }

package/controller/comms/messages/config/EquipmentMessage.ts

@@ -48,6 +48,7 @@ export class EquipmentMessage {
                         body.capacity = msg.extractPayloadByte(34) * 1000;
                         if (body.isActive && sys.equipment.maxBodies === 0) sys.bodies.removeItemById(1);
                         body.isActive = sys.equipment.maxBodies > 0;
+                        msg.isProcessed = true;
                         break;
                     case 1:
                         pnl = sys.equipment.expansions.getItemById(2);
@@ -66,6 +67,7 @@ export class EquipmentMessage {
                         }
                         pnl = sys.equipment.expansions.getItemById(3);
                         pnl.name = msg.extractPayloadString(18, 16);
+                        msg.isProcessed = true;
                         break;
                     case 2:
                         // The first name is the first body in this packet and the second is the third.  Go figure.
@@ -87,6 +89,7 @@ export class EquipmentMessage {
                             sys.bodies.removeItemById(bodyId);
                             state.temps.bodies.removeItemById(bodyId);
                         }
+                        msg.isProcessed = true;
                         break;
                     case 3:
                         // The first name is the second body and the 2nd is the 4th.  This packet also contains
@@ -136,6 +139,7 @@ export class EquipmentMessage {
                         state.equipment.maxValves = sys.equipment.maxValves;
                         state.equipment.maxSchedules = sys.equipment.maxSchedules;
                         state.equipment.maxPumps = sys.equipment.maxPumps;
+                        msg.isProcessed = true;
                         break;
                     default:
                         logger.debug(`Unprocessed Config Message ${msg.toPacket()}`)