nodejs-poolcontroller 8.3.0 → 8.4.1

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

@@ -1,42 +1,153 @@
-/*  nodejs-poolController.  An application to control pool equipment.
-Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022.  
-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, ConfigVersion } from "../../../Equipment";
-export class VersionMessage {
-    public static process(msg: Inbound): void {
-        var ver: ConfigVersion = new ConfigVersion({});
-        ver.options = msg.extractPayloadInt(6);
-        ver.circuits = msg.extractPayloadInt(8);
-        ver.features = msg.extractPayloadInt(10);
-        ver.schedules = msg.extractPayloadInt(12);
-        ver.pumps = msg.extractPayloadInt(14);
-        ver.remotes = msg.extractPayloadInt(16);
-        ver.circuitGroups = msg.extractPayloadInt(18);
-        ver.chlorinators = msg.extractPayloadInt(20);
-        ver.intellichem = msg.extractPayloadInt(22);
-        ver.valves = msg.extractPayloadInt(24);
-        ver.heaters = msg.extractPayloadInt(26);
-        ver.security = msg.extractPayloadInt(28);
-        ver.general = msg.extractPayloadInt(30);
-        ver.equipment = msg.extractPayloadInt(32);
-        ver.covers = msg.extractPayloadInt(34);
-        ver.systemState = msg.extractPayloadInt(36);
-        sys.processVersionChanges(ver);
-        msg.isProcessed = true;
-    }
+/*  nodejs-poolController.  An application to control pool equipment.
+Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022.  
+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, Message, Outbound, Response } from "../Messages";
+import { sys, ConfigVersion } from "../../../Equipment";
+import { logger } from "../../../../logger/Logger";
+
+export class VersionMessage {
+    // Debounce config refresh requests to avoid duplicate requests from overlapping triggers
+    private static lastConfigRefreshTime: number = 0;
+    private static readonly CONFIG_REFRESH_DEBOUNCE_MS = 2000;  // 2 seconds
+    private static pendingConfigRefreshTimer?: NodeJS.Timeout;
+    private static pendingConfigRefreshSource?: string;
+    private static scheduleConfigRefresh(delayMs: number, source: string, reason: string): void {
+        this.pendingConfigRefreshSource = source;
+        if (!this.pendingConfigRefreshTimer) {
+            this.pendingConfigRefreshTimer = setTimeout(() => {
+                this.pendingConfigRefreshTimer = undefined;
+                const src = this.pendingConfigRefreshSource ? `${this.pendingConfigRefreshSource} (trailing)` : 'Trailing';
+                this.pendingConfigRefreshSource = undefined;
+                this.triggerConfigRefresh(src);
+            }, delayMs);
+        }
+        logger.silly(`v3.004+ ${source}: Deferring config refresh (${reason}, retry in ${delayMs}ms)`);
+    }
+
+    /**
+     * Shared method to trigger a config refresh with debouncing.
+     * Prevents duplicate requests when multiple triggers fire in quick succession.
+     */
+    private static triggerConfigRefresh(source: string): void {
+        const now = Date.now();
+        const elapsed = now - this.lastConfigRefreshTime;
+        if (elapsed < this.CONFIG_REFRESH_DEBOUNCE_MS) {
+            // Throttle-with-trailing: don't lose rapid toggle updates; schedule one refresh at end of window.
+            const remainingMs = Math.max(0, this.CONFIG_REFRESH_DEBOUNCE_MS - elapsed);
+            this.scheduleConfigRefresh(remainingMs, source, `debounced (last send ${elapsed}ms ago)`);
+            return;
+        }
+        (sys.board as any).needsConfigChanges = true;
+        // Invalidate cached options version so queueChanges() will request category 0.
+        // OCP doesn't increment options version when heat mode/setpoints change,
+        // so we force a refresh by clearing our cached version.
+        sys.configVersion.options = 0;
+        // v3.004+: OCP does NOT reliably increment systemState when features toggle (esp. rapid OFF/ON sequences).
+        // Force a systemState refresh so queueChanges() will request category 15 (systemState), option [0] => Action 222 [15,0].
+        sys.configVersion.systemState = 0;
+        // v3.004+: OCP does NOT increment pumps version when pump config changes via WCP (Action 168 type 4).
+        // Force a pumps refresh so queueChanges() will request category 4 (pumps).
+        sys.configVersion.pumps = 0;
+        // v3.x: personal-information updates (Action 168 type 12) are not always reflected by
+        // version deltas in the field; force a general refresh so category 12 is re-polled.
+        sys.configVersion.general = 0;
+
+        // If a config queue run is already active, coalesce this refresh and retry after a short delay.
+        // This avoids extra 228/164 churn in the middle of an in-flight loading pass.
+        if (typeof (sys.board as any).isConfigQueueProcessing === 'function' &&
+            (sys.board as any).isConfigQueueProcessing()) {
+            this.scheduleConfigRefresh(this.CONFIG_REFRESH_DEBOUNCE_MS, source, 'config queue already processing');
+            return;
+        }
+
+        this.lastConfigRefreshTime = now;
+        logger.silly(`v3.004+ ${source}: Sending Action 228`);
+        Outbound.create({
+            dest: 16, action: 228, payload: [0], retries: 2,
+            scope: 'v3RefreshTrigger',
+            // v3.004+: require 164 addressed to us (not to Wireless).
+            response: Response.create({ dest: Message.pluginAddress, action: 164 })
+        }).sendAsync();
+    }
+
+    /**
+     * v3.004+ Piggyback: When another device sends Action 228 to OCP,
+     * send our own to catch config changes. See .plan/202-intellicenter-bodies-temps.md
+     */
+    public static processVersionRequest(msg: Inbound): void {
+        if (sys.equipment.isIntellicenterV3 &&
+            msg.source !== Message.pluginAddress &&  // Not from us
+            msg.dest === 16) {                        // Directed to OCP
+            this.triggerConfigRefresh('Piggyback');
+        }
+        msg.isProcessed = true;
+    }
+
+    /**
+     * v3.004+ ACK Trigger (single entrypoint):
+     * When OCP ACKs a Wireless/other device's Action 168 or 184, trigger a debounced config refresh.
+     *
+     * Intended call-site: `Messages.ts` should gate on ACK payload[0] (168/184) and then call this method once.
+     */
+    public static processActionAck(msg: Inbound): void {
+        // Gate: only v3.004+
+        if (!sys.equipment.isIntellicenterV3) {
+            msg.isProcessed = true;
+            return;
+        }
+        // Gate: only when ACK originates from OCP (src=16) to some other device (not us, not OCP).
+        if (msg.source !== 16 || msg.dest === Message.pluginAddress || msg.dest === 16) {
+            msg.isProcessed = true;
+            return;
+        }
+        // Gate: only ACKing Action 168 or 184 (caller should gate, but keep defensive checks here too).
+        const ackedAction = msg.payload.length > 0 ? msg.payload[0] : undefined;
+        if (ackedAction !== 168 && ackedAction !== 184) {
+            msg.isProcessed = true;
+            return;
+        }
+
+        const label =
+            ackedAction === 168
+                ? `ACK(168) Trigger (device ${msg.dest})`
+                : `ACK(184) Trigger (device ${msg.dest})`;
+        this.triggerConfigRefresh(label);
+        msg.isProcessed = true;
+    }
+
+    public static process(msg: Inbound): void {
+        var ver: ConfigVersion = new ConfigVersion({});
+        ver.options = msg.extractPayloadInt(6);
+        ver.circuits = msg.extractPayloadInt(8);
+        ver.features = msg.extractPayloadInt(10);
+        ver.schedules = msg.extractPayloadInt(12);
+        ver.pumps = msg.extractPayloadInt(14);
+        ver.remotes = msg.extractPayloadInt(16);
+        ver.circuitGroups = msg.extractPayloadInt(18);
+        ver.chlorinators = msg.extractPayloadInt(20);
+        ver.intellichem = msg.extractPayloadInt(22);
+        ver.valves = msg.extractPayloadInt(24);
+        ver.heaters = msg.extractPayloadInt(26);
+        ver.security = msg.extractPayloadInt(28);
+        ver.general = msg.extractPayloadInt(30);
+        ver.equipment = msg.extractPayloadInt(32);
+        ver.covers = msg.extractPayloadInt(34);
+        ver.systemState = msg.extractPayloadInt(36);
+        sys.processVersionChanges(ver);
+        msg.isProcessed = true;
+    }
 }

package/controller/nixie/Nixie.ts

@@ -1,174 +1,174 @@
-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 { NixieChemDoserCollection } from "./chemistry/ChemDoser";
-
-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.
-    chemDosers: NixieChemDoserCollection = new NixieChemDoserCollection(this);
-    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 setServiceModeAsync() {
-        await this.circuits.setServiceModeAsync();
-        await this.heaters.setServiceModeAsync();
-        await this.chlorinators.setServiceModeAsync();
-        await this.chemControllers.setServiceModeAsync();
-        await this.chemDosers.setServiceModeAsync();
-        await this.pumps.setServiceModeAsync();
-    }
-    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.chemDosers.initAsync(equipment.chemDosers);
-            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(`Error reading log file ${logFile}: ${err.message}`); }
-    }
-    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(`Error logging to ${logFile}: ${err.message}`); }
-    }
-    public async closeAsync() {
-        // Close all the associated equipment.
-        await this.chemDosers.closeAsync();
-        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(`Error gettting REM Servers: ${err.message}`); }
-    }
-}
-
+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 { NixieChemDoserCollection } from "./chemistry/ChemDoser";
+
+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.
+    chemDosers: NixieChemDoserCollection = new NixieChemDoserCollection(this);
+    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 setServiceModeAsync() {
+        await this.circuits.setServiceModeAsync();
+        await this.heaters.setServiceModeAsync();
+        await this.chlorinators.setServiceModeAsync();
+        await this.chemControllers.setServiceModeAsync();
+        await this.chemDosers.setServiceModeAsync();
+        await this.pumps.setServiceModeAsync();
+    }
+    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.chemDosers.initAsync(equipment.chemDosers);
+            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(`Error reading log file ${logFile}: ${err.message}`); }
+    }
+    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(`Error logging to ${logFile}: ${err.message}`); }
+    }
+    public async closeAsync() {
+        // Close all the associated equipment.
+        await this.chemDosers.closeAsync();
+        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(`Error gettting REM Servers: ${err.message}`); }
+    }
+}
+
 export let ncp = new NixieControlPanel();