nodejs-poolcontroller 7.6.1 → 7.7.0

package/controller/comms/messages/status/IntelliValveStateMessage.ts

@@ -1,36 +1,36 @@
-/*  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 { state } from "../../../State";
-import { sys, ControllerType } from "../../../Equipment";
-import { logger } from "../../../../logger/Logger";
-
-export class IntelliValveStateMessage {
-    public static process(msg: Inbound) {
-        if (sys.controllerType === ControllerType.Unknown) return;
-        // We only want to process the messages that are coming from IntelliValve.
-        if (msg.source !== 12) return;
-        switch (msg.action) {
-            case 82: // This is hail from the valve that says it is not bound yet.
-                break;
-            default:
-                logger.info(`IntelliValve sent an unknown action ${msg.action}`);
-                break;
-        }
-        state.emitEquipmentChanges();
-    }
+/*  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 { state } from "../../../State";
+import { sys, ControllerType } from "../../../Equipment";
+import { logger } from "../../../../logger/Logger";
+
+export class IntelliValveStateMessage {
+    public static process(msg: Inbound) {
+        if (sys.controllerType === ControllerType.Unknown) return;
+        // We only want to process the messages that are coming from IntelliValve.
+        if (msg.source !== 12) return;
+        switch (msg.action) {
+            case 82: // This is hail from the valve that says it is not bound yet.
+                break;
+            default:
+                logger.info(`IntelliValve sent an unknown action ${msg.action}`);
+                break;
+        }
+        state.emitEquipmentChanges();
+    }
 }

package/controller/comms/messages/status/PumpStateMessage.ts

@@ -55,7 +55,29 @@ export class PumpStateMessage {
         state.emitEquipmentChanges();
         // if (msg.action !== 7) this.processDirectPumpMessages(msg);
     }
-
+    public static processHayward(msg: Inbound) {
+        switch (msg.action) {
+            case 12:
+                PumpStateMessage.processHaywardStar(msg);
+                break;
+        }
+    }
+    public static processHaywardStar(msg: Inbound) {
+        //             src   act   dest             
+        //[0x10, 0x02, 0x00, 0x0C, 0x00][0x00, 0x62, 0x17, 0x81][0x01, 0x18, 0x10, 0x03]
+        //[0x10, 0x02, 0x00, 0x0C, 0x00][0x00, 0x2D, 0x02, 0x36][0x00, 0x83, 0x10, 0x03] -- Response from pump
+        let ptype = sys.board.valueMaps.pumpTypes.transformByName('hwvs');
+        let pump = sys.pumps.find(elem => elem.address === msg.source + 96 && elem.type === 6);
+        if (typeof pump !== 'undefined') {
+            let pstate = state.pumps.getItemById(pump.id, true);
+            // 3450 * .5
+            pstate.rpm = Math.round(ptype.maxSpeed * (msg.extractPayloadByte(1) / 100));
+            // This is really goofy as the watts are actually the hex string from the two bytes.
+            pstate.watts = parseInt(msg.extractPayloadByte(2).toString(16) + msg.extractPayloadByte(3).toString(16), 10);
+            pstate.isActive = true;
+            state.emitEquipmentChanges();
+        }
+    }
     public static processDirectPumpMessages(msg: Inbound) {
 
         if (msg.payload.length === 2)

package/controller/nixie/Nixie.ts

@@ -1,163 +1,163 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import * as os from 'os';
-import { webApp } from "../../web/Server";
-import { logger } from "../../logger/Logger";
-import { INixieControlPanel } from "./NixieEquipment";
-import { NixieChemControllerCollection } from "./chemistry/ChemController";
-
-import { sys, PoolSystem } from "../../controller/Equipment";
-import { NixieCircuitCollection } from './circuits/Circuit';
-import { NixieBodyCollection } from './bodies/Body';
-import { NixieValveCollection } from './valves/Valve';
-import { NixieHeaterCollection } from './heaters/Heater';
-import { config } from '../../config/Config';
-import { NixieFilterCollection } from './bodies/Filter';
-import { NixieChlorinatorCollection } from './chemistry/Chlorinator';
-import { NixiePump, NixiePumpCollection } from './pumps/Pump';
-import { NixieScheduleCollection } from './schedules/Schedule';
-
-/************************************************************************
- * Nixie:  Nixie is a control panel that controls devices as a master. It
- * can extend an existing *Touch or Center control panel.  Or it can run
- * standalone as a master controller.  The NixieControlPanel will always
- * be instantiated to control equipment when that equipment is not
- * supported or controlled by a traditional OCP.  However, if a traditional
- * OCP exists, it will be subordinate to that OCP in regard to controlling
- * pool bodies.
- * 
- * Equipment: Equipment identified as ncp (Nixie Control Panel) will be
- * managed by the Nixie controller.  It works hand-in-glove with the REM
- * (Relay Equipment Manager) to provide low level hardware support.
- * 
- * RS485: RS485 occurs directly within nixie through the standard RS485
- * bus identified for njspc and does not route through REM.  This is an
- * important distinction to provide robust hardware level communication.
- * Items Controlled on this channel include: Pumps, Chlorinators, and
- * IntelliChem controllers.  When and if IntelliValve functions become
- * available these too will be performed through the njspc RS485 bus.
- * 
- * Configuration and State Management:
- * Nixie uses the underlying njspc configuration structures.  The intent
- * is not to replace these rather the intention is to extend them with
- * low level control.  For this reason, only when a Nixie is the only
- * master controller on the pool do commands get routed through NixieBoard.
- * this mode is identified at startup. When a particular piece of equipment 
- * is identified to be controlled by Nixie as a master then the command 
- * will eventually be marshalled to the NixieControlPanel.  Any connected
- * OCP will get first crack at it.
- * 
- * LifeCycle: The Nixie controller does not persist data outside of
- * the PoolConfig.json and PoolState.json files.  It is initialized
- * at startup and torn down when the application is stopped. 
- * */
-export class NixieControlPanel implements INixieControlPanel {
-    // Only equipment controlled by Nixie is represented on the controller.  If interaction with
-    // other equipment is required this should be sent back through the original controller.
-    // Command sequence is <OCP>Board -> SystemBoard -> NixieController whenever the master is not identified as Nixie.
-    chemControllers: NixieChemControllerCollection = new NixieChemControllerCollection(this);
-    chlorinators: NixieChlorinatorCollection = new NixieChlorinatorCollection(this);
-    circuits: NixieCircuitCollection = new NixieCircuitCollection(this);
-    bodies: NixieBodyCollection = new NixieBodyCollection(this);
-    filters: NixieFilterCollection = new NixieFilterCollection(this);
-    valves: NixieValveCollection = new NixieValveCollection(this);
-    heaters: NixieHeaterCollection = new NixieHeaterCollection(this);
-    pumps: NixiePumpCollection = new NixiePumpCollection(this);
-    schedules: NixieScheduleCollection = new NixieScheduleCollection(this);
-
-    public async initAsync(equipment: PoolSystem) {
-        try {
-
-            // We need to tell Nixie what her place is.  If there is an existing OCP she needs to be a partner.  However, if
-            // she is the only master then she needs to step up and take command.  The way we will signify this is
-            // by using settings in config.json.
-            // The controller types define the number of bodies and whether they are shared.
-            logger.info(`Initializing Nixie Controller`);
-            await this.bodies.initAsync(equipment.bodies);
-            await this.filters.initAsync(equipment.filters);
-            await this.circuits.initAsync(equipment.circuits);
-            await this.valves.initAsync(equipment.valves);
-            await this.heaters.initAsync(equipment.heaters);
-            await this.chlorinators.initAsync(equipment.chlorinators);
-            await this.chemControllers.initAsync(equipment.chemControllers);
-            await this.pumps.initAsync(equipment.pumps);
-            await this.schedules.initAsync(equipment.schedules);
-            logger.info(`Nixie Controller Initialized`)
-        }
-        catch (err) { return Promise.reject(err); }
-    }
-    public async readLogFile(logFile: string): Promise<string[]> {
-        try {
-            let logPath = path.join(process.cwd(), '/logs');
-            if (!fs.existsSync(logPath)) fs.mkdirSync(logPath);
-            logPath += (`/${logFile}`);
-            let lines = [];
-            if (fs.existsSync(logPath)) {
-                let buff = fs.readFileSync(logPath);
-                lines = buff.toString().split('\n');
-            }
-            return lines;
-        } catch (err) { logger.error(err); }
-    }
-    public async logData(logFile: string, data: any) {
-        try {
-            let logPath = path.join(process.cwd(), '/logs');
-            if (!fs.existsSync(logPath)) fs.mkdirSync(logPath);
-            logPath += (`/${logFile}`);
-            let lines = [];
-            if (fs.existsSync(logPath)) {
-                let buff = fs.readFileSync(logPath);
-                lines = buff.toString().split('\n');
-            }
-            if (typeof data === 'object')
-                lines.unshift(JSON.stringify(data));
-            else
-                lines.unshift(data.toString());
-            fs.writeFileSync(logPath, lines.join('\n'));
-        } catch (err) { logger.error(err); }
-    }
-    public async closeAsync() {
-        // Close all the associated equipment.
-        await this.pumps.closeAsync();
-        await this.chemControllers.closeAsync();
-        await this.chlorinators.closeAsync();
-        await this.heaters.closeAsync();
-        await this.circuits.closeAsync();
-        await this.filters.closeAsync();
-        await this.bodies.closeAsync();
-        await this.valves.closeAsync();
-    }
-    /*
-     * This method is used to obtain a list of existing REM servers for configuration.  This returns all servers and 
-     * their potential devices and is not designed to be used at run-time or to detect failure.
-     *  
-     */
-    public async getREMServers() {
-        try {
-            let srv = [];
-            let servers = webApp.findServersByType('rem');
-            if (typeof servers !== 'undefined') {
-                for (let i = 0; i < servers.length; i++) {
-                    let server = servers[i];
-                    // Sometimes I hate type safety.
-                    let devices = typeof server['getDevices'] === 'function' ? await server['getDevices']() : [];
-                    let int = config.getInterfaceByUuid(servers[i].uuid);
-                    srv.push({
-                        uuid: servers[i].uuid,
-                        name: servers[i].name,
-                        type: servers[i].type,
-                        isRunning: servers[i].isRunning,
-                        isConnected: servers[i].isConnected,
-                        devices: devices,
-                        remoteConnectionId: servers[i].remoteConnectionId,
-                        interface: int
-                    });
-                }
-                await ncp.chemControllers.syncRemoteREMFeeds(srv);
-            }
-            return srv;
-        } catch (err) { logger.error(err); }
-    }
-}
-
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import { webApp } from "../../web/Server";
+import { logger } from "../../logger/Logger";
+import { INixieControlPanel } from "./NixieEquipment";
+import { NixieChemControllerCollection } from "./chemistry/ChemController";
+
+import { sys, PoolSystem } from "../../controller/Equipment";
+import { NixieCircuitCollection } from './circuits/Circuit';
+import { NixieBodyCollection } from './bodies/Body';
+import { NixieValveCollection } from './valves/Valve';
+import { NixieHeaterCollection } from './heaters/Heater';
+import { config } from '../../config/Config';
+import { NixieFilterCollection } from './bodies/Filter';
+import { NixieChlorinatorCollection } from './chemistry/Chlorinator';
+import { NixiePump, NixiePumpCollection } from './pumps/Pump';
+import { NixieScheduleCollection } from './schedules/Schedule';
+
+/************************************************************************
+ * Nixie:  Nixie is a control panel that controls devices as a master. It
+ * can extend an existing *Touch or Center control panel.  Or it can run
+ * standalone as a master controller.  The NixieControlPanel will always
+ * be instantiated to control equipment when that equipment is not
+ * supported or controlled by a traditional OCP.  However, if a traditional
+ * OCP exists, it will be subordinate to that OCP in regard to controlling
+ * pool bodies.
+ * 
+ * Equipment: Equipment identified as ncp (Nixie Control Panel) will be
+ * managed by the Nixie controller.  It works hand-in-glove with the REM
+ * (Relay Equipment Manager) to provide low level hardware support.
+ * 
+ * RS485: RS485 occurs directly within nixie through the standard RS485
+ * bus identified for njspc and does not route through REM.  This is an
+ * important distinction to provide robust hardware level communication.
+ * Items Controlled on this channel include: Pumps, Chlorinators, and
+ * IntelliChem controllers.  When and if IntelliValve functions become
+ * available these too will be performed through the njspc RS485 bus.
+ * 
+ * Configuration and State Management:
+ * Nixie uses the underlying njspc configuration structures.  The intent
+ * is not to replace these rather the intention is to extend them with
+ * low level control.  For this reason, only when a Nixie is the only
+ * master controller on the pool do commands get routed through NixieBoard.
+ * this mode is identified at startup. When a particular piece of equipment 
+ * is identified to be controlled by Nixie as a master then the command 
+ * will eventually be marshalled to the NixieControlPanel.  Any connected
+ * OCP will get first crack at it.
+ * 
+ * LifeCycle: The Nixie controller does not persist data outside of
+ * the PoolConfig.json and PoolState.json files.  It is initialized
+ * at startup and torn down when the application is stopped. 
+ * */
+export class NixieControlPanel implements INixieControlPanel {
+    // Only equipment controlled by Nixie is represented on the controller.  If interaction with
+    // other equipment is required this should be sent back through the original controller.
+    // Command sequence is <OCP>Board -> SystemBoard -> NixieController whenever the master is not identified as Nixie.
+    chemControllers: NixieChemControllerCollection = new NixieChemControllerCollection(this);
+    chlorinators: NixieChlorinatorCollection = new NixieChlorinatorCollection(this);
+    circuits: NixieCircuitCollection = new NixieCircuitCollection(this);
+    bodies: NixieBodyCollection = new NixieBodyCollection(this);
+    filters: NixieFilterCollection = new NixieFilterCollection(this);
+    valves: NixieValveCollection = new NixieValveCollection(this);
+    heaters: NixieHeaterCollection = new NixieHeaterCollection(this);
+    pumps: NixiePumpCollection = new NixiePumpCollection(this);
+    schedules: NixieScheduleCollection = new NixieScheduleCollection(this);
+
+    public async initAsync(equipment: PoolSystem) {
+        try {
+
+            // We need to tell Nixie what her place is.  If there is an existing OCP she needs to be a partner.  However, if
+            // she is the only master then she needs to step up and take command.  The way we will signify this is
+            // by using settings in config.json.
+            // The controller types define the number of bodies and whether they are shared.
+            logger.info(`Initializing Nixie Controller`);
+            await this.bodies.initAsync(equipment.bodies);
+            await this.filters.initAsync(equipment.filters);
+            await this.circuits.initAsync(equipment.circuits);
+            await this.valves.initAsync(equipment.valves);
+            await this.heaters.initAsync(equipment.heaters);
+            await this.chlorinators.initAsync(equipment.chlorinators);
+            await this.chemControllers.initAsync(equipment.chemControllers);
+            await this.pumps.initAsync(equipment.pumps);
+            await this.schedules.initAsync(equipment.schedules);
+            logger.info(`Nixie Controller Initialized`)
+        }
+        catch (err) { return Promise.reject(err); }
+    }
+    public async readLogFile(logFile: string): Promise<string[]> {
+        try {
+            let logPath = path.join(process.cwd(), '/logs');
+            if (!fs.existsSync(logPath)) fs.mkdirSync(logPath);
+            logPath += (`/${logFile}`);
+            let lines = [];
+            if (fs.existsSync(logPath)) {
+                let buff = fs.readFileSync(logPath);
+                lines = buff.toString().split('\n');
+            }
+            return lines;
+        } catch (err) { logger.error(err); }
+    }
+    public async logData(logFile: string, data: any) {
+        try {
+            let logPath = path.join(process.cwd(), '/logs');
+            if (!fs.existsSync(logPath)) fs.mkdirSync(logPath);
+            logPath += (`/${logFile}`);
+            let lines = [];
+            if (fs.existsSync(logPath)) {
+                let buff = fs.readFileSync(logPath);
+                lines = buff.toString().split('\n');
+            }
+            if (typeof data === 'object')
+                lines.unshift(JSON.stringify(data));
+            else
+                lines.unshift(data.toString());
+            fs.writeFileSync(logPath, lines.join('\n'));
+        } catch (err) { logger.error(err); }
+    }
+    public async closeAsync() {
+        // Close all the associated equipment.
+        await this.chemControllers.closeAsync();
+        await this.chlorinators.closeAsync();
+        await this.heaters.closeAsync();
+        await this.circuits.closeAsync();
+        await this.pumps.closeAsync();
+        await this.filters.closeAsync();
+        await this.bodies.closeAsync();
+        await this.valves.closeAsync();
+    }
+    /*
+     * This method is used to obtain a list of existing REM servers for configuration.  This returns all servers and 
+     * their potential devices and is not designed to be used at run-time or to detect failure.
+     *  
+     */
+    public async getREMServers() {
+        try {
+            let srv = [];
+            let servers = webApp.findServersByType('rem');
+            if (typeof servers !== 'undefined') {
+                for (let i = 0; i < servers.length; i++) {
+                    let server = servers[i];
+                    // Sometimes I hate type safety.
+                    let devices = typeof server['getDevices'] === 'function' ? await server['getDevices']() : [];
+                    let int = config.getInterfaceByUuid(servers[i].uuid);
+                    srv.push({
+                        uuid: servers[i].uuid,
+                        name: servers[i].name,
+                        type: servers[i].type,
+                        isRunning: servers[i].isRunning,
+                        isConnected: servers[i].isConnected,
+                        devices: devices,
+                        remoteConnectionId: servers[i].remoteConnectionId,
+                        interface: int
+                    });
+                }
+                await ncp.chemControllers.syncRemoteREMFeeds(srv);
+            }
+            return srv;
+        } catch (err) { logger.error(err); }
+    }
+}
+
 export let ncp = new NixieControlPanel();

package/controller/nixie/NixieEquipment.ts

@@ -1,104 +1,104 @@
-import { webApp, REMInterfaceServer, InterfaceServerResponse } from "../../web/Server";
-import { logger } from "../../logger/Logger";
-import e = require("express");
-export interface INixieControlPanel {
-    getREMServers();
-    logData(file: string, data: any);
-    readLogFile(file: string);
-}
-export class NixieEquipment {
-    protected _pmap = new WeakSet();
-    //private _dataKey = { id: 'parent' };
-    constructor(ncp: INixieControlPanel) { this._pmap['ncp'] = ncp; }
-    public get controlPanel(): INixieControlPanel { return this._pmap['ncp']; }
-    public get id(): number { return -1; }
-    public static get isConnected(): boolean {
-        let servers = webApp.findServersByType("rem");
-        for (let i = 0; i < servers.length; i++) {
-            if (!servers[0].isConnected) return false;
-        }
-        return true;
-    }
-    public static async putDeviceService(uuid: string, url: string, data?: any, timeout: number = 3600): Promise<InterfaceServerResponse> {
-        try {
-            let result: InterfaceServerResponse;
-            let server = webApp.findServerByGuid(uuid);
-            if (typeof server === 'undefined')
-                return InterfaceServerResponse.createError(new Error(`Error sending device command: Server [${uuid}] not found.`));
-            if (!server.isConnected) {
-                logger.warn(`Cannot send PUT ${url} to ${server.name} server is not connected.`);
-                return InterfaceServerResponse.createError(new Error(`Error sending device command: [${server.name}] not connected.`));
-            }
-            if (server.type === 'rem') {
-                let rem = server as REMInterfaceServer;
-                result = await rem.putApiService(url, data, timeout);
-                // If the result code is > 200 we have an issue.
-                //if (result.status.code > 200 || result.status.code === -1)
-                //    return Promise.reject(new Error(`putDeviceService: ${result.error.message}`));
-            }
-            return result;
-        }
-        catch (err) { return Promise.reject(err); }
-    }
-    public static async getDeviceService(uuid: string, url: string, data?: any, timeout:number = 3600): Promise<any> {
-        try {
-            let result: InterfaceServerResponse;
-            let server = webApp.findServerByGuid(uuid);
-            if (typeof server === 'undefined') return Promise.reject(new Error(`Error sending device command: Server [${uuid}] not found.`));
-            if (!server.isConnected) return Promise.reject(new Error(`Error sending device command: [${server.name}] not connected.`));
-            if (server.type === 'rem') {
-                let rem = server as REMInterfaceServer;
-                //console.log(`CALLING GET FROM GETDEVSER`);
-                
-                result = await rem.getApiService(url, data, timeout);
-                //console.log(`RETURNING GET FROM GETDEVSER`);
-                // If the result code is > 200 we have an issue.
-                if (result.status.code > 200) return Promise.reject(new Error(`putDeviceService: ${result.error.message}`));
-            }
-            return result;
-        }
-        catch (err) { return Promise.reject(err); }
-    }
-    public async closeAsync() {
-        try {
-        }
-        catch (err) { logger.error(err); }
-    }
-}
-export class NixieChildEquipment extends NixieEquipment {
-    constructor(parent: NixieEquipment) {
-        super(parent.controlPanel);
-        this._pmap['parent'] = parent;
-    }
-    public getParent(): NixieEquipment { return this._pmap['parent']; }
-}
-export class NixieEquipmentCollection<T> extends Array<NixieEquipment> {
-    private _pmap = new WeakSet();
-    public get controlPanel(): INixieControlPanel { return this._pmap['ncp']; }
-    constructor(ncp: INixieControlPanel) {
-        super();
-        this._pmap['ncp'] = ncp;
-    }
-    public async removeById(id: number) {
-        try {
-            let ndx = this.findIndex(elem => elem.id === id);
-            if (ndx >= 0) {
-                let eq = this[ndx];
-                await eq.closeAsync();
-                this.splice(ndx, 1);
-            }
-            else
-                logger.warn(`A Nixie equipment item was not found with id ${id}. Equipment not removed.`);
-        }
-        catch (err) { return Promise.reject(err); }
-    }
-}
-//export class NixieRelay extends NixieEquipment {
-
-//}
-//export class NixieCircuit extends NixieRelay {
-
-//}
-//export class NixieValve extends NixieRelay {
-
+import { webApp, REMInterfaceServer, InterfaceServerResponse } from "../../web/Server";
+import { logger } from "../../logger/Logger";
+import e = require("express");
+export interface INixieControlPanel {
+    getREMServers();
+    logData(file: string, data: any);
+    readLogFile(file: string);
+}
+export class NixieEquipment {
+    protected _pmap = new WeakSet();
+    //private _dataKey = { id: 'parent' };
+    constructor(ncp: INixieControlPanel) { this._pmap['ncp'] = ncp; }
+    public get controlPanel(): INixieControlPanel { return this._pmap['ncp']; }
+    public get id(): number { return -1; }
+    public static get isConnected(): boolean {
+        let servers = webApp.findServersByType("rem");
+        for (let i = 0; i < servers.length; i++) {
+            if (!servers[0].isConnected) return false;
+        }
+        return true;
+    }
+    public static async putDeviceService(uuid: string, url: string, data?: any, timeout: number = 3600): Promise<InterfaceServerResponse> {
+        try {
+            let result: InterfaceServerResponse;
+            let server = webApp.findServerByGuid(uuid);
+            if (typeof server === 'undefined')
+                return InterfaceServerResponse.createError(new Error(`Error sending device command: Server [${uuid}] not found.`));
+            if (!server.isConnected) {
+                logger.warn(`Cannot send PUT ${url} to ${server.name} server is not connected.`);
+                return InterfaceServerResponse.createError(new Error(`Error sending device command: [${server.name}] not connected.`));
+            }
+            if (server.type === 'rem') {
+                let rem = server as REMInterfaceServer;
+                result = await rem.putApiService(url, data, timeout);
+                // If the result code is > 200 we have an issue.
+                //if (result.status.code > 200 || result.status.code === -1)
+                //    return Promise.reject(new Error(`putDeviceService: ${result.error.message}`));
+            }
+            return result;
+        }
+        catch (err) { return Promise.reject(err); }
+    }
+    public static async getDeviceService(uuid: string, url: string, data?: any, timeout:number = 3600): Promise<any> {
+        try {
+            let result: InterfaceServerResponse;
+            let server = webApp.findServerByGuid(uuid);
+            if (typeof server === 'undefined') return Promise.reject(new Error(`Error sending device command: Server [${uuid}] not found.`));
+            if (!server.isConnected) return Promise.reject(new Error(`Error sending device command: [${server.name}] not connected.`));
+            if (server.type === 'rem') {
+                let rem = server as REMInterfaceServer;
+                //console.log(`CALLING GET FROM GETDEVSER`);
+                
+                result = await rem.getApiService(url, data, timeout);
+                //console.log(`RETURNING GET FROM GETDEVSER`);
+                // If the result code is > 200 we have an issue.
+                if (result.status.code > 200) return Promise.reject(new Error(`putDeviceService: ${result.error.message}`));
+            }
+            return result;
+        }
+        catch (err) { return Promise.reject(err); }
+    }
+    public async closeAsync() {
+        try {
+        }
+        catch (err) { logger.error(err); }
+    }
+}
+export class NixieChildEquipment extends NixieEquipment {
+    constructor(parent: NixieEquipment) {
+        super(parent.controlPanel);
+        this._pmap['parent'] = parent;
+    }
+    public getParent(): NixieEquipment { return this._pmap['parent']; }
+}
+export class NixieEquipmentCollection<T> extends Array<NixieEquipment> {
+    private _pmap = new WeakSet();
+    public get controlPanel(): INixieControlPanel { return this._pmap['ncp']; }
+    constructor(ncp: INixieControlPanel) {
+        super();
+        this._pmap['ncp'] = ncp;
+    }
+    public async removeById(id: number) {
+        try {
+            let ndx = this.findIndex(elem => elem.id === id);
+            if (ndx >= 0) {
+                let eq = this[ndx];
+                await eq.closeAsync();
+                this.splice(ndx, 1);
+            }
+            else
+                logger.warn(`A Nixie equipment item was not found with id ${id}. Equipment not removed.`);
+        }
+        catch (err) { return Promise.reject(err); }
+    }
+}
+//export class NixieRelay extends NixieEquipment {
+
+//}
+//export class NixieCircuit extends NixieRelay {
+
+//}
+//export class NixieValve extends NixieRelay {
+
 //}