nodejs-poolcontroller 7.6.0 → 7.6.1

package/controller/comms/Comms.ts

@@ -82,6 +82,130 @@ 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') {
             this.buffer = new SendRecieveBuffer();
@@ -110,6 +234,20 @@ export class Connection {
                 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.
@@ -262,7 +400,6 @@ export class Connection {
                 if (success) {
                     if (typeof conn.buffer !== 'undefined') conn.buffer.close();
                 }
-               
                 return success;
             }
             return true;

package/controller/comms/messages/Messages.ts

@@ -487,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;
@@ -632,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

@@ -38,7 +38,7 @@ export class ChlorinatorMessage {
                         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)}`);
+                            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);

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/ExternalMessage.ts

@@ -217,7 +217,7 @@ export class ExternalMessage {
                     if (group.isActive) {
                         for (let i = 0; i < 16; i++) {
                             let circuitId = msg.extractPayloadByte(i + 6);
-                            let circuit = group.circuits.getItemById(i + 1, circuitId !== 255);
+                            let circuit = group.circuits.getItemById(i + 1, circuitId < 255);
                             if (circuitId === 255) group.circuits.removeItemById(i + 1);
                             circuit.circuit = circuitId + 1;
 
@@ -429,13 +429,13 @@ export class ExternalMessage {
                         // [11] = No sequencing underway.
                         switch (byte) {
                             case 0: // Sync
-                                lg.action = 1;
+                                lg.action = sys.board.valueMaps.circuitActions.getValue('colorsync');
                                 break;
                             case 1: // Color swim
-                                lg.action = 3;
+                                lg.action = sys.board.valueMaps.circuitActions.getValue('colorswim');
                                 break;
                             case 2: // Color set
-                                lg.action = 2;
+                                lg.action = sys.board.valueMaps.circuitActions.getValue('colorset');
                                 break;
                             default:
                                 lg.action = 0;
@@ -500,11 +500,14 @@ export class ExternalMessage {
         let startTime = msg.extractPayloadInt(3);
         let endTime = msg.extractPayloadInt(5);
         let circuit = msg.extractPayloadByte(7) + 1;
-        let cfg = sys.schedules.getItemById(schedId, circuit !== 256 && startTime !== 0 && endTime !== 0);
-        cfg.isActive = (circuit !== 256 && startTime !== 0 && endTime !== 0);
+        let isActive = (msg.extractPayloadByte(8) & 128) === 128; // Inactive schedules do not have bit 8 set.
+        let cfg = sys.schedules.getItemById(schedId, isActive);
+        let s = state.schedules.getItemById(schedId, cfg.isActive);
+        //cfg.isActive = (circuit !== 256);
         cfg.startTime = startTime;
         cfg.endTime = endTime;
         cfg.circuit = circuit;
+        cfg.isActive = isActive;
         let byte = msg.extractPayloadByte(8);
         cfg.scheduleType = (byte & 1 & 0xFF) === 1 ? 0 : 128;
         if ((byte & 4 & 0xFF) === 4) cfg.startTimeType = 1;
@@ -525,7 +528,6 @@ export class ExternalMessage {
         cfg.heatSource = hs;
         cfg.heatSetpoint = msg.extractPayloadByte(14);
         cfg.coolSetpoint = msg.extractPayloadByte(15);
-        let s = state.schedules.getItemById(schedId, cfg.isActive);
         if (cfg.isActive) {
             let s = state.schedules.getItemById(schedId, cfg.isActive);
             s.isActive = cfg.isActive = true;

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

@@ -221,26 +221,6 @@ export class HeaterMessage {
                 sys.equipment.setEquipmentIds();
                 msg.isProcessed = true;
                 break;
-            case 168:
-                {
-                    // IntelliChem Installed
-                    if ((msg.extractPayloadByte(3) & 0x01) === 1) {
-                        // only support for 1 ic with EasyTouch
-                        let chem = sys.chemControllers.getItemByAddress(144, true);
-                        let schem = state.chemControllers.getItemById(chem.id, true);
-                        chem.ph.tank.capacity = chem.orp.tank.capacity = 6;
-                        chem.ph.tank.units = chem.orp.tank.units = '';
-
-                    }
-                    else {
-                        let chem = sys.chemControllers.getItemByAddress(144);
-                        state.chemControllers.removeItemById(chem.id);
-                        sys.chemControllers.removeItemById(chem.id);
-                    }
-                    // Spa Manual Heat on/off
-                    sys.general.options.manualHeat = msg.extractPayloadByte(4) === 1 ? true : false;
-                    msg.isProcessed = true;
-                }
         }
     }
     private static processCooldownDelay(msg: Inbound) {

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

@@ -139,6 +139,9 @@ export class OptionsMessage {
                 break;
             }
             case 40:
+            case 168:    
+            {
+
                 // [165,33,16,34,168,10],[0,0,0,254,0,0,0,0,0,0],[2,168 = manual heat mode off
                 // [165,33,16,34,168,10],[0,0,0,254,1,0,0,0,0,0],[2,169] = manual heat mode on
                 sys.general.options.manualHeat = msg.extractPayloadByte(4) === 1;
@@ -148,7 +151,7 @@ export class OptionsMessage {
                     let schem = state.chemControllers.getItemById(chem.id, true);
                     chem.ph.tank.capacity = chem.orp.tank.capacity = 6;
                     chem.ph.tank.units = chem.orp.tank.units = '';
-
+                    
                 }
                 else {
                     let chem = sys.chemControllers.getItemByAddress(144);
@@ -157,6 +160,27 @@ export class OptionsMessage {
                 }
                 msg.isProcessed = true;
                 break;
+            }
+            /* case 168:
+                {
+                    // IntelliChem Installed
+                    if ((msg.extractPayloadByte(3) & 0x01) === 1) {
+                        // only support for 1 ic with EasyTouch
+                        let chem = sys.chemControllers.getItemByAddress(144, true);
+                        let schem = state.chemControllers.getItemById(chem.id, true);
+                        chem.ph.tank.capacity = chem.orp.tank.capacity = 6;
+                        chem.ph.tank.units = chem.orp.tank.units = '';
+
+                    }
+                    else {
+                        let chem = sys.chemControllers.getItemByAddress(144);
+                        state.chemControllers.removeItemById(chem.id);
+                        sys.chemControllers.removeItemById(chem.id);
+                    }
+                    // Spa Manual Heat on/off
+                    sys.general.options.manualHeat = msg.extractPayloadByte(4) === 1 ? true : false;
+                    msg.isProcessed = true;
+                } */
         }
     }
 }