nodejs-poolcontroller 7.4.0 → 7.5.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;
@@ -83,7 +83,7 @@ export class Connection {
         } catch (err) { return Promise.reject(err); }
     }
     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 +97,24 @@ 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();
                 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 +122,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.');
@@ -249,6 +268,62 @@ export class Connection {
             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 +422,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) {
@@ -500,17 +504,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()}`);

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) 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/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()}`)

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

@@ -17,7 +17,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import { Inbound } from "../Messages";
 import { sys, Body, ICircuitGroup, LightGroup, CircuitGroup } from "../../../Equipment";
 import { state, ICircuitGroupState, LightGroupState } from "../../../State";
-import { utils } from "../../../Constants";
+import { Timestamp, utils } from "../../../Constants";
 import { logger } from "../../../../logger/Logger";
 export class ExternalMessage {
     public static processIntelliCenter(msg: Inbound): void {
@@ -83,7 +83,8 @@ export class ExternalMessage {
         if (isActive) {
             let chem = sys.chemControllers.getItemById(id, true);
             let schem = state.chemControllers.getItemById(id, true);
-            chem.isVirtual = false;
+            // chem.isVirtual = false;
+            chem.master = 0;
             chem.ph.tank.capacity = chem.orp.tank.capacity = 6;
             chem.ph.tank.units = chem.orp.tank.units = '';
             schem.type = chem.type = 2;
@@ -106,7 +107,8 @@ export class ExternalMessage {
         let valve = sys.valves.getItemById(msg.extractPayloadByte(2) + 1);
         valve.circuit = msg.extractPayloadByte(3) + 1;
         valve.name = msg.extractPayloadString(4, 16);
-        valve.isVirtual = false;
+        valve.master = 0;
+        // valve.isVirtual = false;
         msg.isProcessed = true;
     }
     public static processPool(msg: Inbound) {
@@ -272,31 +274,30 @@ export class ExternalMessage {
     private static processHeater(msg: Inbound) {
         // So a user is changing the heater info.  Lets
         // hijack it and get it ourselves.
-        let heater = sys.heaters.getItemById(msg.extractPayloadByte(2) + 1);
-        heater.type = msg.extractPayloadByte(3);
-        heater.body = msg.extractPayloadByte(4);
-        heater.cooldownDelay = msg.extractPayloadByte(5);
-        heater.startTempDelta = msg.extractPayloadByte(6);
-        heater.stopTempDelta = msg.extractPayloadByte(7);
-        heater.coolingEnabled = msg.extractPayloadByte(8) > 0;
-        heater.differentialTemp = msg.extractPayloadByte(9);
-        heater.address = msg.extractPayloadByte(10);
-        heater.name = msg.extractPayloadString(11, 16);
-        heater.efficiencyMode = msg.extractPayloadByte(27);
-        heater.maxBoostTemp = msg.extractPayloadByte(28);
-        heater.economyTime = msg.extractPayloadByte(29);
-        if (heater.type === 0) {
-            sys.heaters.removeItemById(heater.id);
-            state.heaters.removeItemById(heater.id);
+        let isActive = msg.extractPayloadByte(3) !== 0;
+        let heaterId = msg.extractPayloadByte(2) + 1;
+        if (isActive) {
+            let heater = sys.heaters.getItemById(heaterId, true);
+            let hstate = state.heaters.getItemById(heater.id, true);
+
+            hstate.type = heater.type = msg.extractPayloadByte(3);
+            heater.body = msg.extractPayloadByte(4);
+            heater.cooldownDelay = msg.extractPayloadByte(5);
+            heater.startTempDelta = msg.extractPayloadByte(6);
+            heater.stopTempDelta = msg.extractPayloadByte(7);
+            heater.coolingEnabled = msg.extractPayloadByte(8) > 0;
+            heater.differentialTemp = msg.extractPayloadByte(9);
+            heater.address = msg.extractPayloadByte(10);
+            hstate.name = heater.name = msg.extractPayloadString(11, 16);
+            heater.efficiencyMode = msg.extractPayloadByte(27);
+            heater.maxBoostTemp = msg.extractPayloadByte(28);
+            heater.economyTime = msg.extractPayloadByte(29);
+            heater.master = 0;
         }
         else {
-            let hstate = state.heaters.getItemById(heater.id, true);
-            hstate.name = heater.name;
-            //heater.isVirtual = hstate.isVirtual = false;
-            hstate.name = heater.name;
-            hstate.type = heater.type;
+            sys.heaters.removeItemById(heaterId);
+            state.heaters.removeItemById(heaterId);
         }
-
         sys.board.heaters.updateHeaterServices();
         // Check anyway to make sure we got it all.
         //setTimeout(() => sys.checkConfiguration(), 500);
@@ -738,6 +739,8 @@ export class ExternalMessage {
                 sys.general.options.clockMode = (msg.extractPayloadByte(14) & 0x0001) == 1 ? 24 : 12;
                 msg.isProcessed = true;
                 break;
+            case 12: // This is byte 15 but we don't know what it is.  Numbers witnessed include 51, 52, 89, 235.
+                break;
             case 14: // Clock source
                 if ((msg.extractPayloadByte(17) & 0x0040) === 1)
                     sys.general.options.clockSource = 'internet';
@@ -745,6 +748,8 @@ export class ExternalMessage {
                     sys.general.options.clockSource = 'manual';
                 msg.isProcessed = true;
                 break;
+            case 15: // This is byte 18 but we don't know what it is.  Numbers witnessed include 1, 2, 3, 5, 100.
+                break;
             case 18: // Body 1 Heat Setpoint
                 body = sys.bodies.getItemById(1, false);
                 body.heatSetpoint = msg.extractPayloadByte(21);
@@ -817,6 +822,19 @@ export class ExternalMessage {
                 sys.general.options.manualHeat = msg.extractPayloadByte(40) !== 0;
                 msg.isProcessed = true;
                 break;
+            case 64: // Vacation mode
+                let yy = msg.extractPayloadByte(5) + 2000;
+                let mm = msg.extractPayloadByte(6);
+                let dd = msg.extractPayloadByte(7);
+                sys.general.options.vacation.startDate = new Date(yy, mm - 1, dd);
+                yy = msg.extractPayloadByte(8) + 2000;
+                mm = msg.extractPayloadByte(9);
+                dd = msg.extractPayloadByte(10);
+                sys.general.options.vacation.endDate = new Date(yy, mm - 1, dd);
+                sys.general.options.vacation.enabled = msg.extractPayloadByte(3) > 0;
+                sys.general.options.vacation.useTimeframe = msg.extractPayloadByte(4) > 0;
+                msg.isProcessed = true;
+                break;
         }
     }
     public static processTouchChlorinator(msg: Inbound) {

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

@@ -58,6 +58,7 @@ export class FeatureMessage {
                 FeatureMessage.processFeatureNames(msg);
                 break;
             case 22: // Not sure what this is.
+                msg.isProcessed = true;
                 break;
             default:
                 logger.debug(`Unprocessed Config Message ${msg.toPacket()}`)
@@ -70,6 +71,7 @@ export class FeatureMessage {
             var feature: Feature = sys.features.getItemById(featureId, false);
             feature.dontStop = msg.extractPayloadByte(i + 1) == 1;
         }
+        msg.isProcessed = true;
     }
     private static processFeatureType(msg: Inbound) {
         for (let i = 1; i < msg.payload.length - 1 && i <= sys.equipment.maxFeatures; i++) {
@@ -88,6 +90,7 @@ export class FeatureMessage {
                 state.features.removeItemById(featureId);
             }
         }
+        msg.isProcessed = true;
     }
     private static processFreezeProtect(msg: Inbound) {
         for (let i = 1; i < msg.payload.length - 1 && i <= sys.equipment.maxFeatures; i++) {
@@ -95,6 +98,7 @@ export class FeatureMessage {
             var feature: Feature = sys.features.getItemById(featureId);
             feature.freeze = msg.extractPayloadByte(i + 1) > 0;
         }
+        msg.isProcessed = true;
     }
     private static processFeatureNames(msg: Inbound) {
         var featureId = ((msg.extractPayloadByte(1) - 6) * 2) + sys.board.equipmentIds.features.start;
@@ -109,6 +113,7 @@ export class FeatureMessage {
             if (feature.isActive) state.features.getItemById(feature.id).name = feature.name;
         }
         state.emitEquipmentChanges();
+        msg.isProcessed = true;
     }
     private static processEggTimerHours(msg: Inbound) {
         for (let i = 1; i < msg.payload.length - 1 && i <= sys.equipment.maxFeatures; i++) {
@@ -116,6 +121,7 @@ export class FeatureMessage {
             let feature: Feature = sys.features.getItemById(featureId);
             feature.eggTimer = (msg.extractPayloadByte(i + 1) * 60) + ((feature.eggTimer || 0) % 60);
         }
+        msg.isProcessed = true;
     }
     private static processEggTimerMinutes(msg: Inbound) {
         for (let i = 1; i < msg.payload.length - 1 && i <= sys.equipment.maxFeatures; i++) {
@@ -123,6 +129,7 @@ export class FeatureMessage {
             var feature: Feature = sys.features.getItemById(featureId);
             feature.eggTimer = (Math.floor(feature.eggTimer / 60) * 60) + msg.extractPayloadByte(i + 1);
         }
+        msg.isProcessed = true;
     }
     private static processShowInFeatures(msg: Inbound) {
         for (let i = 1; i < msg.payload.length - 1 && i <= sys.equipment.maxFeatures; i++) {
@@ -132,6 +139,6 @@ export class FeatureMessage {
             if (feature.isActive) state.features.getItemById(featureId, feature.isActive).showInFeatures = feature.showInFeatures;
         }
         state.emitEquipmentChanges();
+        msg.isProcessed = true;
     }
-
 }

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

@@ -24,31 +24,39 @@ export class GeneralMessage {
                 sys.general.alias = msg.extractPayloadString(2, 16);
                 sys.general.owner.name = msg.extractPayloadString(18, 16);
                 sys.general.location.zip = msg.extractPayloadString(34, 6);
+                msg.isProcessed = true;
                 break;
             case 1:
                 sys.general.owner.phone = msg.extractPayloadString(2, 20);
                 sys.general.owner.phone2 = msg.extractPayloadString(21, 15);
                 sys.general.location.latitude = ((msg.extractPayloadByte(35) * 256) + msg.extractPayloadByte(34)) / 100;
+                msg.isProcessed = true;
                 break;
             case 2:
                 sys.general.location.address = msg.extractPayloadString(2, 32);
                 sys.general.location.longitude = -(((msg.extractPayloadByte(35) * 256) + msg.extractPayloadByte(34)) / 100);
+                msg.isProcessed = true;
                 break;
             case 3:
                 sys.general.owner.email = msg.extractPayloadString(2, 32);
                 sys.general.location.timeZone = msg.extractPayloadByte(34);
+                msg.isProcessed = true;
                 break;
             case 4:
                 sys.general.owner.email2 = msg.extractPayloadString(2, 32);
+                msg.isProcessed = true;
                 break;
             case 5:
                 sys.general.location.country = msg.extractPayloadString(2, 32);
+                msg.isProcessed = true;
                 break;
             case 6:
                 sys.general.location.city = msg.extractPayloadString(2, 32);
+                msg.isProcessed = true;
                 break;
             case 7:
                 sys.general.location.state = msg.extractPayloadString(2, 32);
+                msg.isProcessed = true;
                 break;
             default:
                 logger.debug(`Unprocessed Config Message ${msg.toPacket()}`)