nodejs-poolcontroller 7.2.0 → 7.5.1

package/controller/comms/Comms.ts

@@ -22,13 +22,16 @@ import { logger } from '../../logger/Logger';
 import * as net from 'net';
 import { setTimeout, setInterval } from 'timers';
 import { Message, Outbound, Inbound, Response } from './messages/Messages';
-import { MessageError, OutboundMessageError } from '../Errors';
+import { InvalidOperationError, MessageError, OutboundMessageError } from '../Errors';
+import { utils } from "../Constants";
+import { webApp } from "../../web/Server";
 const extend = require("extend");
 export class Connection {
     constructor() {
         this.emitter = new EventEmitter();
     }
     public isOpen: boolean = false;
+    private _closing: boolean = false;
     private _cfg: any;
     private _port: any;
     public mockPort: boolean = false;
@@ -38,19 +41,49 @@ export class Connection {
     protected resetConnTimer(...args) {
         //console.log(`resetting connection timer`);
         if (conn.connTimer !== null) clearTimeout(conn.connTimer);
-        if (!conn._cfg.mockPort && conn._cfg.inactivityRetry > 0) conn.connTimer = setTimeout(async () => {
+        if (!conn._cfg.mockPort && conn._cfg.inactivityRetry > 0 && !conn._closing) conn.connTimer = setTimeout(async () => {
             try {
-                await conn.openAsync()
+                await conn.openAsync();
             }
-            catch (err) {};
-        }
-            , conn._cfg.inactivityRetry * 1000);
+            catch (err) { logger.error(`Error resetting RS485 port on inactivity: ${err.message}`); };
+        }, conn._cfg.inactivityRetry * 1000);
     }
     public isRTS: boolean = true;
     public emitter: EventEmitter;
     public get enabled(): boolean { return typeof this._cfg !== 'undefined' && this._cfg.enabled; }
+    public async setPortAsync(data: any) : Promise<any> {
+        try {
+            // Lets set the config data.
+            let pdata = config.getSection('controller.comms', {});
+            pdata.enabled = typeof data.enabled !== 'undefined' ? utils.makeBool(data.enabled) : utils.makeBool(pdata.enabled);
+            pdata.netConnect = typeof data.netConnect !== 'undefined' ? utils.makeBool(data.netConnect) : utils.makeBool(pdata.netConnect);
+            pdata.rs485Port = typeof data.rs485Port !== 'undefined' ? data.rs485Port : pdata.rs485Port;
+            pdata.inactivityRetry = typeof data.inactivityRetry === 'number' ? data.inactivityRetry : pdata.inactivityRetry;
+            if (pdata.netConnect) {
+                pdata.netHost = typeof data.netHost !== 'undefined' ? data.netHost : pdata.netHost;
+                pdata.netPort = typeof data.netPort === 'number' ? data.netPort : pdata.netPort;
+            }
+            if (!await this.closeAsync()) {
+                return Promise.reject(new InvalidOperationError(`Unable to close the current RS485 port`, 'setPortAsync'));
+            }
+            config.setSection('controller.comms', pdata);
+            this._cfg = config.getSection('controller.comms', {
+                rs485Port: "/dev/ttyUSB0",
+                portSettings: { baudRate: 9600, dataBits: 8, parity: 'none', stopBits: 1, flowControl: false, autoOpen: false, lock: false },
+                mockPort: false,
+                netConnect: false,
+                netHost: "raspberrypi",
+                netPort: 9801,
+                inactivityRetry: 10
+            });
+            if (!await this.openAsync()) {
+                return Promise.reject(new InvalidOperationError(`Unable to open RS485 port ${pdata.rs485Port}`, 'setPortAsync'));
+            }
+            return this._cfg;
+        } 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); });
@@ -64,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.`); });
@@ -83,18 +122,32 @@ 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}`); });
-            return new Promise<boolean>((resolve, _) => {
+            //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.');
+                    logger.info(`Net connect (socat) Connection connected`);
                     this._port = nc;
                     this.isOpen = true;
                     resolve(true);
@@ -159,19 +212,117 @@ export class Connection {
             });
         }
     }
-    public closeAsync() {
+    public async closeAsync(): Promise<boolean> {
         try {
-            if (conn.connTimer) clearTimeout(conn.connTimer);
-            if (typeof (conn._port) !== 'undefined' && conn._cfg.netConnect) {
-                if (typeof (conn._port.destroy) !== 'function')
-                    conn._port.close(function (err) {
-                        if (err) logger.error('Error closing %s:%s', conn._cfg.netHost, conn._cfg.netPort);
-                    });
-                else
-                    conn._port.destroy();
+            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;
             }
-            if (typeof conn.buffer !== 'undefined') conn.buffer.close();
-        } catch (err) { logger.error(`Error closing comms connection: ${err.message}`); }
+            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')
@@ -265,12 +416,13 @@ export class SendRecieveBuffer {
     private _waitingPacket: Outbound;
     private _msg: Inbound;
     public pushIn(pkt) {
-        conn.buffer._inBuffer.push.apply(conn.buffer._inBuffer, pkt.toJSON().data); setTimeout(() => { this.processPackets(); }, 0);
+        let self = this;
+        conn.buffer._inBuffer.push.apply(conn.buffer._inBuffer, pkt.toJSON().data); setTimeout(() => { self.processPackets(); }, 0);
     }
     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
@@ -303,6 +455,7 @@ export class SendRecieveBuffer {
             let dt = new Date();
             if (conn.buffer._waitingPacket.timestamp.getTime() + timeout < dt.getTime()) {
                 logger.silly(`Retrying outbound message after ${(dt.getTime() - conn.buffer._waitingPacket.timestamp.getTime()) / 1000} secs with ${conn.buffer._waitingPacket.remainingTries} attempt(s) left. - ${conn.buffer._waitingPacket.toShortPacket()} `);
+                conn.buffer.counter.sndRetries++;
                 conn.buffer.writeMessage(conn.buffer._waitingPacket);
             }
             return true;
@@ -339,7 +492,8 @@ export class SendRecieveBuffer {
         // would be sitting idle for eternity. 
         if (conn.buffer._outBuffer.length > 0 || typeof conn.buffer._waitingPacket !== 'undefined' || conn.buffer._waitingPacket || typeof msg !== 'undefined') {
             // Come back later as we still have items to send.
-            conn.buffer.procTimer = setTimeout(() => this.processPackets(), 100);
+            let self = this;
+            conn.buffer.procTimer = setTimeout(() => self.processPackets(), 100);
         }
     }
     /*
@@ -375,6 +529,7 @@ export class SendRecieveBuffer {
                         setTimeout(msg.response.callback, 100, msg);
                     }
                 }
+                conn.buffer.counter.sndAborted++;
                 conn.isRTS = true;
                 return;
             }
@@ -396,21 +551,26 @@ export class SendRecieveBuffer {
                         let error = new OutboundMessageError(msg, `Message aborted after ${msg.tries} attempt(s): ${err} `);
                         if (typeof msg.onComplete === 'function') msg.onComplete(error, undefined);
                         conn.buffer._waitingPacket = null;
+                        conn.buffer.counter.sndAborted++;
                     }
                 }
                 else {
                     logger.verbose(`Wrote packet[${bytes}].Retries remaining: ${msg.remainingTries} `);
                     // We have all the success we are going to get so if the call succeeded then
                     // don't set the waiting packet when we aren't actually waiting for a response.
+                    conn.buffer.counter.sndSuccess++;
                     if (!msg.requiresResponse) {
                         // As far as we know the message made it to OCP.
                         conn.buffer._waitingPacket = null;
                         if (typeof msg.onComplete === 'function') msg.onComplete(err, undefined);
+
                     }
                     else if (msg.remainingTries >= 0) {
                         conn.buffer._waitingPacket = msg;
                     }
                 }
+                conn.buffer.counter.updatefailureRate();
+                webApp.emitToChannel('rs485PortStats', 'rs485Stats', conn.buffer.counter);
             });
         }
     }
@@ -439,7 +599,9 @@ export class SendRecieveBuffer {
             let out = conn.buffer._outBuffer[i--];
             if (typeof out === 'undefined') continue;
             let resp = out.response;
-            if (out.requiresResponse) {
+            // RG - added check for msgOut because the *Touch chlor packet 153 adds an status packet 217
+            // but if it is the only packet on the queue the outbound will have been cleared out already.
+            if (out.requiresResponse && msgOut !== null) {
                 if (resp instanceof Response && resp.isResponse(msgIn, out) && (typeof out.scope === 'undefined' || out.scope === msgOut.scope)) {
                     resp.message = msgIn;
                     if (typeof (resp.callback) === 'function' && resp.callback) callback = resp.callback;
@@ -456,20 +618,21 @@ export class SendRecieveBuffer {
     private processCompletedMessage(msg: Inbound, ndx): number {
         msg.timestamp = new Date();
         msg.id = Message.nextMessageId;
-        conn.buffer.counter.collisions += msg.collisions;
+        conn.buffer.counter.recCollisions += msg.collisions;
+        logger.packet(msg);
+        webApp.emitToChannel('rs485PortStats', 'rs485Stats', conn.buffer.counter);
         if (msg.isValid) {
-            conn.buffer.counter.success++;
+            conn.buffer.counter.recSuccess++;
             conn.buffer.counter.updatefailureRate();
             msg.process();
             conn.buffer.clearResponses(msg);
         }
         else {
-            conn.buffer.counter.failed++;
+            conn.buffer.counter.recFailed++;
             conn.buffer.counter.updatefailureRate();
-            console.log('RS485 Stats:' + JSON.stringify(conn.buffer.counter));
+            console.log('RS485 Stats:' + conn.buffer.counter.toLog());
             ndx = this.rewindFailedMessage(msg, ndx);
         }
-        logger.packet(msg);
         return ndx;
     }
     private rewindFailedMessage(msg: Inbound, ndx: number): number {
@@ -513,20 +676,34 @@ export class SendRecieveBuffer {
 export class Counter {
     constructor() {
         this.bytesReceived = 0;
-        this.success = 0;
-        this.failed = 0;
+        this.recSuccess = 0;
+        this.recFailed = 0;
+        this.recCollisions = 0;
         this.bytesSent = 0;
-        this.collisions = 0;
-        this.failureRate = '0.00%';
+        this.sndAborted = 0;
+        this.sndRetries = 0;
+        this.sndSuccess = 0;
+        this.recFailureRate = 0;
+        this.sndFailureRate = 0;
     }
     public bytesReceived: number;
-    public success: number;
-    public failed: number;
     public bytesSent: number;
-    public collisions: number;
-    public failureRate: string;
+    public recSuccess: number;
+    public recFailed: number;
+    public recCollisions: number;
+    public recFailureRate: number;
+    public sndSuccess: number;
+    public sndAborted: number;
+    public sndRetries: number;
+    public sndFailureRate: number;
     public updatefailureRate(): void {
-        conn.buffer.counter.failureRate = `${(conn.buffer.counter.failed / (conn.buffer.counter.failed + conn.buffer.counter.success) * 100).toFixed(2)}% `;
+        conn.buffer.counter.recFailureRate = (this.recFailed + this.recSuccess) !== 0 ? (this.recFailed / (this.recFailed + this.recSuccess) * 100) : 0;
+        conn.buffer.counter.sndFailureRate = (this.sndAborted + this.sndSuccess) !== 0 ? (this.sndAborted / (this.sndAborted + this.sndSuccess) * 100) : 0;
+        //conn.buffer.counter.recFailureRate = `${(conn.buffer.counter.recFailed / (conn.buffer.counter.recFailed + conn.buffer.counter.recSuccess) * 100).toFixed(2)}% `;
+        //conn.buffer.counter.sndFailureRate = `${(conn.buffer.counter.sndAborted / (conn.buffer.counter.sndAborted + conn.buffer.counter.sndSuccess) * 100).toFixed(2)}% `;
+    }
+    public toLog(): string {
+        return `{ "bytesReceived": ${this.bytesReceived} "success": ${this.recSuccess}, "failed": ${this.recFailed}, "bytesSent": ${this.bytesSent}, "collisions": ${this.recCollisions}, "failureRate": ${this.recFailureRate.toFixed(2)}% }`;
     }
 }
 export var conn: Connection = new Connection();

package/controller/comms/messages/Messages.ts

@@ -168,7 +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 { return (ndx + 1 < bytes.length && bytes[ndx] === 16 && bytes[ndx + 1] === 2); }
+    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)))
+    }
     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; }
@@ -399,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:
@@ -418,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) {
@@ -495,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()}`);
@@ -568,6 +579,7 @@ class OutboundCommon extends Message {
             case Protocol.IntelliValve:
             case Protocol.Unidentified:
             case Protocol.IntelliChem:
+            case Protocol.Heater:
                 this.chkHi = Math.floor(sum / 256);
                 this.chkLo = (sum - (super.chkHi * 256));
                 break;
@@ -597,7 +609,7 @@ export class Outbound extends OutboundCommon {
             this.header.push.apply(this.header, [165, Message.headerSubByte, 15, Message.pluginAddress, 0, 0]);
             this.term.push.apply(this.term, [0, 0]);
         }
-        else if (proto === Protocol.Pump || proto === Protocol.IntelliValve || proto === Protocol.IntelliChem) {
+        else if (proto === Protocol.Pump || proto === Protocol.IntelliValve || proto === Protocol.IntelliChem || proto === Protocol.Heater) {
             this.preamble.push.apply(this.preamble, [255, 0, 255]);
             this.header.push.apply(this.header, [165, 0, 15, Message.pluginAddress, 0, 0]);
             this.term.push.apply(this.term, [0, 0]);

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,7 +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.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.
@@ -109,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/CircuitMessage.ts

@@ -250,7 +250,7 @@ export class CircuitMessage {
             circuit.freeze = (functionId & 64) === 64;
             circuit.showInFeatures = typeof circuit.showInFeatures === 'undefined' ? true : circuit.showInFeatures;
             circuit.isActive = _isActive;
-            if (typeof circuit.eggTimer === 'undefined') circuit.eggTimer = 720;
+            if (typeof circuit.eggTimer === 'undefined' || circuit.eggTimer === 0) circuit.eggTimer = 720;
             if (typeof circuit.dontStop === 'undefined') circuit.dontStop = circuit.eggTimer === 1620;
             if ([9, 10, 16, 17].includes(circuit.type)) {
                 const lg = sys.lightGroups.getItemById(sys.board.equipmentIds.circuitGroups.start, 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()}`)