nodejs-poolcontroller 7.5.1 → 7.7.0

package/controller/nixie/schedules/Schedule.ts

@@ -3,11 +3,13 @@ import { utils, Timestamp } from '../../Constants';
 import { logger } from '../../../logger/Logger';
 
 import { NixieEquipment, NixieChildEquipment, NixieEquipmentCollection, INixieControlPanel } from "../NixieEquipment";
-import { Schedule, ScheduleCollection, sys } from "../../../controller/Equipment";
-import { ScheduleState, state, } from "../../State";
+import { CircuitGroup, CircuitGroupCircuit, ICircuitGroup, ICircuitGroupCircuit, LightGroup, LightGroupCircuit, Schedule, ScheduleCollection, sys } from "../../../controller/Equipment";
+import { CircuitGroupState, ICircuitGroupState, ScheduleState, state, } from "../../State";
 import { setTimeout, clearTimeout } from 'timers';
 import { NixieControlPanel } from '../Nixie';
 import { webApp, InterfaceServerResponse } from "../../../web/Server";
+import { delayMgr } from '../../../controller/Lockouts';
+
 
 export class NixieScheduleCollection extends NixieEquipmentCollection<NixieSchedule> {
     public async setScheduleAsync(schedule: Schedule, data: any) {
@@ -69,6 +71,7 @@ export class NixieSchedule extends NixieEquipment {
     private _pollTimer: NodeJS.Timeout = null;
     public schedule: Schedule;
     private suspended: boolean = false;
+    private resumed: boolean = false;
     private running: boolean = false;
     constructor(ncp: INixieControlPanel, schedule: Schedule) {
         super(ncp);
@@ -106,74 +109,122 @@ export class NixieSchedule extends NixieEquipment {
             // Schedules can be overridden so it is important that when the 
             // state is changed for the schedule if it is currently active that
             // Nixie does not override the state of the scheduled circuit or feature.
+            /*
+            RSG 5-8-22
+            Manual OP needs to play a role here.  From the IC manual: 
+            # Manual OP General
+
+            From the manual: 
+            Manual OP Priority: ON: This feature allows for a circuit to be manually switched OFF and switched ON within a scheduled program, the circuit will continue to run for a maximum of 12 hours or whatever that circuit Egg Timer is set to, after which the scheduled program will resume. This feature will turn off any scheduled program to allow manual pump override. The Default setting is OFF.
+
+            ## When on
+            1.  If a schedule should be on and the user turns the schedule off then the schedule expires until such time as the time off has expired.  When that occurs the schedule should be reset to run at the designated time.  If the user resets the schedule by turning the circuit back on again ~~then the schedule will resume and turn off at the specified time~~ then the schedule will be ignored and the circuit will run until the egg timer expires or the circuit/feature is manually turned off.  This setting WILL affect other schedules that may impact this circuit.
+
+            ## When off
+            1. "Normal" = If a schedule should be on and the user turns the schedule off then the schedule expires until such time as the time off has expired.  When that occurs the schedule should be reset to run at the designated time.  If the user resets the schedule by turning the circuit back on again then the schedule will resume and turn off at the specified time.
+
+            Interestingly, there also seems to be a schedule level setting for this.  We will ignore that for now as the logic could get much more complicated.
+            */
             // 1. If the feature happens to be running and the schedule is not yet turned on then
             // it should not override what the user says.
             // 2. If a schedule is running and the state of the circuit changes to off then the new state should suspend the schedule
-            // until which time the feature is turned back on again.  Then the off time will come into play.
+            // until which time the feature is turned back on again.  
+            // Manual OP Off: Then the off time will come into play.
+            // Manual OP On: The egg timer will take precedence.  No other schedules will turn off this feature
             // 3. Egg timers will be managed by the individual circuit.  If this is being turned on via the schedule then
             // the egg timer is not in effect.
             // 4. If there are overlapping schedules, then the off date is determined by
             // the maximum off date.
             // 5. If a schedule should be on and the user turns the schedule off then the schedule expires until such time
             // as the time off has expired.  When that occurs the schedule should be reset to run at the designated time.  If the
-            // user resets the schedule by turning the circuit back on again then the schedule will resume and turn off at the specified
-            // time.
+            // user resets the schedule by turning the circuit back on again then the schedule will...
+            // Manual OP Off: ..resume and turn off at the specified time.
+            // Manual OP On: ...continue to run until the egg timer time is reached or the circuit is manually turned off.
             // 6. Heat setpoints should only be changed when the schedule is first turning on the scheduled circuit.
+            // 7. If schedule is disabled, skip it
+            // 8. Manual OP On: If another schedule has been resumed and this schedule would affect that feature, do not start this schedule.
+
+            // Definitions:
+            // this.resumed = Flag to show if this schedule has been suspended and resumed.
+            // this.manualPriorityActive = Flag to show if this schedule has been suspended and resumed, and Manual Priority (global is active)
+            // this.delayed = Flag to show if this schedule is running, but another schedule is mOP and overriding this one.
             let cstate = state.circuits.getInterfaceById(this.schedule.circuit, false);
             let circuit = sys.circuits.getInterfaceById(this.schedule.circuit, false, { isActive: false });
             if (circuit.isActive === false) {
                 ssched.isOn = false;
                 return;
             }
-            let shouldBeOn = this.shouldBeOn(ssched); // This should also set the validity for the schedule if there are errors.
-            //console.log(`Processing schedule ${this.schedule.id} - ${circuit.name} : ShouldBeOn: ${shouldBeOn} Suspended: ${this.suspended} Running: ${this.running}`);
+            let shouldBeOn = this.shouldBeOn(); // This should also set the validity for the schedule if there are errors.
+            
+            let manualPriorityActive: boolean = shouldBeOn ? sys.board.schedules.manualPriorityActive(ssched) : false;
+            console.log(`Processing schedule ${this.schedule.id} - ${circuit.name} : ShouldBeOn: ${shouldBeOn} ManualPriorityActive: ${manualPriorityActive} Running: ${this.running} Suspended: ${this.suspended} Resumed: ${this.resumed}`);
+
+
             // COND 1: The schedule should be on and the schedule is not yet on.
-            if (shouldBeOn && !this.running && !this.suspended) {
+            if (shouldBeOn && !this.running && !this.suspended || manualPriorityActive) {
                 // If the circuit is on then we need to clear the suspended flag and set the running flag.
                 if (cstate.isOn) {
                     // If the suspended flag was previously on then we need to clear it
                     // because the user turned it back on.
                     this.suspended = false;
                 }
-                ctx.setCircuit(circuit.id, true);
-                // Alright we are turning on the circuit.  If these are body circuits then we need to determine
-                // whether we will be setting the setpoints/heatmode on the body.
-                let body = sys.bodies.find(elem => elem.circuit === circuit.id);
-                if (typeof body !== 'undefined') {
-                    let heatSource = sys.board.valueMaps.heatSources.transform(this.schedule.heatSource);
-                    if (heatSource.name !== 'nochange') {
-                        switch (heatSource.name) {
-                            case 'nochange':
-                            case 'dontchange':
-                                break;
-                            case 'off':
-                                ctx.setHeatMode(body.id, 'off');
-                                break;
-                            default:
-                                ctx.setHeatMode(body.id, heatSource.name, this.schedule.heatSetpoint, heatSource.hasCoolSetpoint ? this.schedule.coolSetpoint : undefined);
-                                break;
+                if (manualPriorityActive) {
+                    ssched.manualPriorityActive = true;
+                    ssched.isOn = false;
+                }
+                else {
+                    ctx.setCircuit(circuit.id, true);
+                    // Alright we are turning on the circuit.  If these are body circuits then we need to determine
+                    // whether we will be setting the setpoints/heatmode on the body.
+                    let body = sys.bodies.find(elem => elem.circuit === circuit.id);
+                    if (typeof body !== 'undefined') {
+                        let heatSource = sys.board.valueMaps.heatSources.transform(this.schedule.heatSource);
+                        if (heatSource.name !== 'nochange') {
+                            switch (heatSource.name) {
+                                case 'nochange':
+                                case 'dontchange':
+                                    break;
+                                case 'off':
+                                    ctx.setHeatMode(body.id, 'off');
+                                    break;
+                                default:
+                                    ctx.setHeatMode(body.id, heatSource.name, this.schedule.heatSetpoint, heatSource.hasCoolSetpoint ? this.schedule.coolSetpoint : undefined);
+                                    break;
+                            }
                         }
                     }
+                    ssched.manualPriorityActive = false;
+                    ssched.isOn = true;
                 }
-                ssched.isOn = true;
                 this.running = true;
             }
             else if (shouldBeOn && this.running) {
-                // We do nothing here.
+                // With mOP, we need to see if the schedule will come back into play and also set the circut
+                if (this.suspended && cstate.isOn) {
+                    if (sys.general.options.manualPriority) {
+                        delayMgr.setManualPriorityDelay(cstate);
+                        ssched.manualPriorityActive = true;
+                    }
+                    this.resumed = true;
+                }
                 this.suspended = !cstate.isOn;
+                ssched.isOn = cstate.isOn && !manualPriorityActive;
+                if (this.suspended && !cstate.isOn) ssched.manualPriorityActive = false;
             }
-            // Our schedule has expired it is time to turn it off.
+            // Our schedule has expired it is time to turn it off, but only if !manualPriorityActive.
             else if (!shouldBeOn) {
                 // Turn this sucker off.  But wait if there is an overlapping schedule then we should
                 // not turn it off. We will need some logic to deal with this.
-                if (this.running) ctx.setCircuit(circuit.id, false);
+                if (this.running && !cstate.manualPriorityActive) ctx.setCircuit(circuit.id, false);
                 ssched.isOn = false;
                 this.running = false;
                 this.suspended = false;
+                this.resumed = false;
+                ssched.manualPriorityActive = false;
             }
             if (!shouldBeOn && ssched.isOn === true) {
                 // Turn off the circuit.
-                ctx.setCircuit(circuit.id, false);
+                if (!manualPriorityActive) ctx.setCircuit(circuit.id, false);
                 ssched.isOn = false;
             }
             ssched.emitEquipmentChange();
@@ -191,8 +242,9 @@ export class NixieSchedule extends NixieEquipment {
                 return dt.startOfDay().addMinutes(offset);
         }
     }
-    protected shouldBeOn(sstate: ScheduleState): boolean {
+    protected shouldBeOn(): boolean {
         if (this.schedule.isActive === false) return false;
+        if (this.schedule.disabled) return false;
         // Be careful with toDate since this returns a mutable date object from the state timestamp.  startOfDay makes it immutable.
         let sod = state.time.startOfDay()
         let dow = sod.toDate().getDay();
@@ -212,19 +264,23 @@ export class NixieSchedule extends NixieEquipment {
         // [0, {name: 'manual', desc: 'Manual }]
         // [1, { name: 'sunrise', desc: 'Sunrise' }],
         // [2, { name: 'sunset', desc: 'Sunset' }]
-        let tmStart = this.calcTime(sod, this.schedule.startTime, this.schedule.startTime).getTime();
+        let tmStart = this.calcTime(sod, this.schedule.startTimeType, this.schedule.startTime).getTime();
         let tmEnd = this.calcTime(sod, this.schedule.endTimeType, this.schedule.endTime).getTime();
-       
+
         if (isNaN(tmStart)) return false;
         if (isNaN(tmEnd)) return false;
         // If we are past our window we should be off.
         let tm = state.time.getTime();
         if (tm >= tmEnd) return false;
         if (tm <= tmStart) return false;
-        
+
+        // Let's now check to see 
+
         // If we make it here we should be on.
         return true;
     }
+    
+
     public async closeAsync() {
         try {
             if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
@@ -234,7 +290,7 @@ export class NixieSchedule extends NixieEquipment {
     }
     public logData(filename: string, data: any) { this.controlPanel.logData(filename, data); }
 }
-class   NixieScheduleContext {
+class NixieScheduleContext {
     constructor() {
 
     }

package/controller/nixie/valves/Valve.ts

@@ -102,7 +102,7 @@ export class NixieValve extends NixieEquipment {
         try {
             // Here we go we need to set the valve state.
             if (vstate.isDiverted !== isDiverted) {
-                logger.info(`Nixie: Set valve ${vstate.id}-${vstate.name} to ${isDiverted}`);
+                logger.verbose(`Nixie: Set valve ${vstate.id}-${vstate.name} to ${isDiverted}`);
             }
             if (utils.isNullOrEmpty(this.valve.connectionId) || utils.isNullOrEmpty(this.valve.deviceBinding)) {
                 vstate.isDiverted = isDiverted;

package/defaultConfig.json

@@ -1,6 +1,7 @@
 {
   "controller": {
     "comms": {
+      "portId": 0,
       "enabled": true,
       "rs485Port": "/dev/ttyUSB0",
       "mockPort": false,
@@ -159,6 +160,25 @@
           "changesOnly": true
         }
       },
+      "aqualinkD": {
+        "name": "AquaLinkD",
+        "type": "mqtt",
+        "enabled": false,
+        "fileName": "aqualinkD.json",
+        "globals": {},
+        "options": {
+          "protocol": "mqtt://",
+          "host": "192.168.0.1",
+          "port": 1883,
+          "username": "",
+          "password": "",
+          "rootTopic": "aqualinkd",
+          "retain": true,
+          "qos": 0,
+          "changesOnly": true
+        }
+
+      },
       "mqttAlt": {
         "name": "MQTTAlt",
         "type": "mqtt",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nodejs-poolcontroller",
-    "version": "7.5.1",
+    "version": "7.7.0",
     "description": "nodejs-poolController",
     "main": "app.js",
     "author": {
@@ -19,38 +19,38 @@
         "watch": "tsc -w"
     },
     "dependencies": {
-        "@influxdata/influxdb-client": "^1.17.0",
+        "@influxdata/influxdb-client": "^1.25.0",
         "eslint-config-promise": "^2.0.2",
-        "express": "^4.17.1",
+        "express": "^4.18.1",
         "extend": "^3.0.2",
-        "jszip": "^3.7.1",
-        "mqtt": "^4.2.8",
-        "multer": "^1.4.3",
-        "multicast-dns": "^7.2.3",
+        "jszip": "^3.9.1",
+        "mqtt": "^4.3.7",
+        "multer": "^1.4.4",
+        "multicast-dns": "^7.2.4",
         "node-ssdp": "^4.0.1",
-        "serialport": "^9.2.1",
-        "socket.io": "^4.2.0",
-        "socket.io-client": "^4.2.0",
-        "source-map-support": "^0.5.13",
-        "winston": "^3.3.3"
+        "serialport": "^9.2.8",
+        "socket.io": "^4.5.0",
+        "socket.io-client": "^4.5.0",
+        "source-map-support": "^0.5.21",
+        "winston": "^3.7.2"
     },
     "devDependencies": {
         "@types/express": "^4.17.13",
         "@types/extend": "^3.0.1",
         "@types/multer": "^1.4.7",
-        "@types/node": "^12.20.23",
-        "@typescript-eslint/eslint-plugin": "^4.30.0",
-        "@typescript-eslint/parser": "^4.30.0",
-        "eslint": "^7.32.0",
+        "@types/node": "^12.20.52",
+        "@typescript-eslint/eslint-plugin": "^5.23.0",
+        "@typescript-eslint/parser": "^5.23.0",
+        "eslint": "^8.15.0",
         "eslint-config-defaults": "^9.0.0",
         "eslint-config-standard": "^16.0.3",
-        "eslint-plugin-import": "^2.24.2",
+        "eslint-plugin-import": "^2.26.0",
         "eslint-plugin-node": "^11.1.0",
-        "eslint-plugin-promise": "^5.1.0",
+        "eslint-plugin-promise": "^6.0.0",
         "eslint-plugin-standard": "^5.0.0",
-        "grunt": "^1.4.1",
+        "grunt": "^1.5.3",
         "grunt-banner": "^0.6.0",
-        "ts-node": "^10.2.1",
-        "typescript": "^4.4.2"
+        "ts-node": "^10.7.0",
+        "typescript": "^4.6.4"
     }
 }

package/web/Server.ts

@@ -54,6 +54,7 @@ export class WebServer {
     private _servers: ProtoServer[] = [];
     private family = 'IPv4';
     private _autoBackupTimer: NodeJS.Timeout;
+    private _httpPort: number;
     constructor() { }
     public async init() {
         try {
@@ -68,12 +69,15 @@ export class WebServer {
                 switch (s) {
                     case 'http':
                         srv = new HttpServer(s, s);
+                        if (c.enabled !== false) this._httpPort = c.port;
                         break;
                     case 'http2':
                         srv = new Http2Server(s, s);
+                        if (c.enabled !== false) this._httpPort = c.port;
                         break;
                     case 'https':
                         srv = new HttpsServer(s, s);
+                        if (c.enabled !== false) this._httpPort = c.port;
                         break;
                     case 'mdns':
                         srv = new MdnsServer(s, s);
@@ -173,12 +177,9 @@ export class WebServer {
             }
         }
     }
-    public ip() {
-        return typeof this.getInterface() === 'undefined' ? '0.0.0.0' : this.getInterface().address;
-    }
-    public mac() {
-        return typeof this.getInterface() === 'undefined' ? '00:00:00:00' : this.getInterface().mac;
-    }
+    public ip() { return typeof this.getInterface() === 'undefined' ? '0.0.0.0' : this.getInterface().address; }
+    public mac() { return typeof this.getInterface() === 'undefined' ? '00:00:00:00' : this.getInterface().mac; }
+    public httpPort(): number { return this._httpPort }
     public findServer(name: string): ProtoServer { return this._servers.find(elem => elem.name === name); }
     public findServersByType(type: string) { return this._servers.filter(elem => elem.type === type); }
     public findServerByGuid(uuid: string) { return this._servers.find(elem => elem.uuid === uuid); }
@@ -563,7 +564,7 @@ export class HttpServer extends ProtoServer {
     public app: express.Application;
     public server: http.Server;
     public sockServer: SocketIoServer<ClientToServerEvents, ServerToClientEvents>;
-    private _sockets: RemoteSocket<ServerToClientEvents>[] = [];
+    private _sockets: RemoteSocket<ServerToClientEvents, any>[] = [];
     public emitToClients(evt: string, ...data: any) {
         if (this.isRunning) {
             this.sockServer.emit(evt, ...data);
@@ -618,42 +619,6 @@ export class HttpServer extends ProtoServer {
             self._sockets = await self.sockServer.fetchSockets();
         });
         sock.on('echo', (msg) => { sock.emit('echo', msg); });
-/*         sock.on('receivePacketRaw', function (incomingPacket: any[]) {
-            //var str = 'Add packet(s) to incoming buffer: ';
-            logger.silly('User request (replay.html) to RECEIVE packet: %s', JSON.stringify(incomingPacket));
-            for (var i = 0; i < incomingPacket.length; i++) {
-                conn.buffer.pushIn(Buffer.from(incomingPacket[i]));
-                // str += JSON.stringify(incomingPacket[i]) + ' ';
-            }
-            //logger.info(str);
-        });
-        sock.on('replayPackets', function (inboundPkts: number[][]) {
-            // used for replay
-            logger.debug(`Received replayPackets: ${inboundPkts}`);
-            inboundPkts.forEach(inbound => {
-                conn.buffer.pushIn(Buffer.from([].concat.apply([], inbound)));
-                // conn.queueInboundMessage([].concat.apply([], inbound));
-            });
-        });
-        sock.on('sendPackets', function (bytesToProcessArr: number[][]) {
-            // takes an input of bytes (src/dest/action/payload) and sends
-            if (!bytesToProcessArr.length) return;
-            logger.silly('User request (replay.html) to SEND packet: %s', JSON.stringify(bytesToProcessArr));
-
-            do {
-                let bytesToProcess: number[] = bytesToProcessArr.shift();
-
-                // todo: logic for chlor packets
-                let out = Outbound.create({
-                    source: bytesToProcess.shift(),
-                    dest: bytesToProcess.shift(),
-                    action: bytesToProcess.shift(),
-                    payload: bytesToProcess.splice(1, bytesToProcess[0])
-                });
-                conn.queueSendMessage(out);
-            } while (bytesToProcessArr.length > 0);
-
-        }); */
         sock.on('sendOutboundMessage', (mdata) => {
             let msg: Outbound = Outbound.create({});
             Object.assign(msg, mdata);
@@ -733,7 +698,7 @@ export class HttpServer extends ProtoServer {
                     res.header('Access-Control-Allow-Methods', 'OPTIONS, GET, POST, PUT, DELETE');
                     if ('OPTIONS' === req.method) { res.sendStatus(200); }
                     else {
-                        if (req.url !== '/device') {
+                        if (req.url !== '/upnp.xml') {
                             logger.info(`[${new Date().toLocaleTimeString()}] ${req.ip} ${req.method} ${req.url} ${typeof req.body === 'undefined' ? '' : JSON.stringify(req.body)}`);
                             logger.logAPI(`{"dir":"in","proto":"api","requestor":"${req.ip}","method":"${req.method}","path":"${req.url}",${typeof req.body === 'undefined' ? '' : `"body":${JSON.stringify(req.body)},`}"ts":"${Timestamp.toISOLocal(new Date())}"}${os.EOL}`);
                         }
@@ -824,7 +789,7 @@ export class HttpsServer extends HttpServer {
                 res.header('Access-Control-Allow-Methods', 'OPTIONS, GET, POST, PUT, DELETE');
                 if ('OPTIONS' === req.method) { res.sendStatus(200); }
                 else {
-                    if (req.url !== '/device') {
+                    if (req.url !== '/upnp.xml') {
                         logger.info(`[${new Date().toLocaleString()}] ${req.ip} ${req.method} ${req.url} ${typeof req.body === 'undefined' ? '' : JSON.stringify(req.body)}`);
                         logger.logAPI(`{"dir":"in","proto":"api","requestor":"${req.ip}","method":"${req.method}","path":"${req.url}",${typeof req.body === 'undefined' ? '' : `"body":${JSON.stringify(req.body)},`}"ts":"${Timestamp.toISOLocal(new Date())}"}${os.EOL}`);
                     }
@@ -874,6 +839,84 @@ export class HttpsServer extends HttpServer {
     }
 }
 export class SsdpServer extends ProtoServer {
+    // Simple service discovery protocol
+    public server: any; //node-ssdp;
+    public deviceUUID: string;
+    public upnpPath: string;
+    public modelName: string;
+    public modelNumber: string;
+    public serialNumber: string;
+    public deviceType = 'urn:schemas-tagyoureit-org:device:PoolController:1';
+    public async init(cfg) {
+        this.uuid = cfg.uuid;
+        if (cfg.enabled) {
+            let self = this;
+            logger.info('Starting up SSDP server');
+            let ver = JSON.parse(fs.readFileSync(path.posix.join(process.cwd(), '/package.json'), 'utf8')).version || '0.0.0';
+            this.deviceUUID = 'uuid:806f52f4-1f35-4e33-9299-' + webApp.mac().replace(/:/g, '');
+            this.serialNumber = webApp.mac();
+            this.modelName = `njsPC v${ver}`;
+            this.modelNumber = `njsPC${ver.replace(/\./g, '-')}`;
+            // todo: should probably check if http/https is enabled at this point
+            let port = config.getSection('web').servers.http.port || 7777;
+            this.upnpPath = 'http://' + webApp.ip() + ':' + port + '/upnp.xml';
+            let SSDP = ssdp.Server;
+            this.server = new SSDP({
+                //customLogger: (...args) => console.log.apply(null, args),
+                logLevel: 'INFO',
+                udn: this.deviceUUID,
+                location: this.upnpPath,
+                sourcePort: 1900
+            });
+            this.server.addUSN('upnp:rootdevice'); // This line will make the server show up in windows.
+            this.server.addUSN(this.deviceType);
+            // start the server
+            this.server.start()
+                .then(function () {
+                    logger.silly('SSDP/UPnP Server started.');
+                    self.isRunning = true;
+                });
+
+            this.server.on('error', function (e) {
+                logger.error('error from SSDP:', e);
+            });
+        }
+    }
+    public deviceXML(): string {
+        let XML = `<?xml version="1.0"?>
+        <root xmlns="urn:schemas-upnp-org:device-1-0">
+            <specVersion>
+                <major>1</major>
+                <minor>0</minor>
+            </specVersion>
+            <device>
+                <deviceType>${this.deviceType}</deviceType>
+                <friendlyName>NodeJS Pool Controller</friendlyName> 
+                <manufacturer>tagyoureit</manufacturer>
+                <manufacturerURL>https://github.com/tagyoureit/nodejs-poolController</manufacturerURL>
+                <presentationURL>http://${webApp.ip()}:${webApp.httpPort()}/state/all</presentationURL>
+                <modelName>${this.modelName}</modelName>
+                <modelNumber>${this.modelNumber}</modelNumber>
+                <modelDescription>An application to control pool equipment.</modelDescription>
+                <serialNumber>${this.serialNumber}</serialNumber>
+                <UDN>${this.deviceUUID}::${this.deviceType}</UDN>
+                <serviceList></serviceList>
+                <deviceList></deviceList>
+            </device>
+        </root>`;
+        return XML;
+    }
+    public async stopAsync() {
+        try {
+            if (typeof this.server !== 'undefined') {
+                this.server.stop();
+                logger.info(`Stopped SSDP server: ${this.name}`);
+            }
+        } catch (err) { logger.error(`Error stopping SSDP server ${err.message}`); }
+    }
+}
+/* RKS DEPRECATED: 05-07-22 - This did not follow the upnp rules so it was not detecting properly.  The entire class above emits the proper xml layout.
+export class SsdpServer1 extends ProtoServer {
     // Simple service discovery protocol
     public server: any; //node-ssdp;
     public async init(cfg) {
@@ -939,6 +982,10 @@ export class SsdpServer extends ProtoServer {
         } catch (err) { logger.error(`Error stopping SSDP server ${err.message}`); }
     }
 }
+*/
+
+
+
 export class MdnsServer extends ProtoServer {
     // Multi-cast DNS server
     public server;
@@ -1102,7 +1149,6 @@ export class HttpInterfaceServer extends ProtoServer {
         catch (err) { }
     }
 }
-
 export class InfluxInterfaceServer extends ProtoServer {
     public bindingsPath: string;
     public bindings: InfluxInterfaceBindings;
@@ -1163,7 +1209,6 @@ export class InfluxInterfaceServer extends ProtoServer {
         }
     }
 }
-
 export class MqttInterfaceServer extends ProtoServer {
     public bindingsPath: string;
     public bindings: HttpInterfaceBindings;
@@ -1344,7 +1389,7 @@ export class REMInterfaceServer extends ProtoServer {
     public sockClient;
     protected agent: http.Agent = new http.Agent({ keepAlive: true });
     public get isConnected() { return this.sockClient !== 'undefined' && this.sockClient.connected; };
-    private _sockets: RemoteSocket<ServerToClientEvents>[] = [];
+    private _sockets: RemoteSocket<ServerToClientEvents, any>[] = [];
     private async sendClientRequest(method: string, url: string, data?: any, timeout: number = 10000): Promise<InterfaceServerResponse> {
         try {
 
@@ -1450,7 +1495,7 @@ export class REMInterfaceServer extends ProtoServer {
     }
     private isJSONString(s: string): boolean {
         if (typeof s !== 'string') return false;
-        if (typeof s.startsWith('{') || typeof s.startsWith('[')) return true;
+        if (s.startsWith('{') || s.startsWith('[')) return true;
         return false;
     }
     public async getApiService(url: string, data?: any, timeout: number = 3600): Promise<InterfaceServerResponse> {