nodejs-poolcontroller 8.0.5 → 8.1.1

package/controller/nixie/chemistry/ChemController.ts

@@ -1,7 +1,7 @@
 import { clearTimeout, setTimeout } from 'timers';
 import { conn } from '../../../controller/comms/Comms';
 import { Outbound, Protocol, Response } from '../../../controller/comms/messages/Messages';
-import { IChemical, IChemController, Chlorinator, ChemController, ChemControllerCollection, ChemFlowSensor, Chemical, ChemicalChlor, ChemicalORP, ChemicalORPProbe, ChemicalPh, ChemicalPhProbe, ChemicalProbe, ChemicalPump, ChemicalTank, sys } from "../../../controller/Equipment";
+import { IChemical, IChemController, Chlorinator, ChemController, ChemControllerCollection, ChemFlowSensor, Chemical, ChemicalORP, ChemicalORPProbe, ChemicalPh, ChemicalPhProbe, ChemicalProbe, ChemicalPump, ChemicalTank, sys } from "../../../controller/Equipment";
 import { logger } from '../../../logger/Logger';
 import { InterfaceServerResponse, webApp } from "../../../web/Server";
 import { Timestamp, utils } from '../../Constants';
@@ -727,11 +727,16 @@ export class NixieChemController extends NixieChemControllerBase {
                     else schem.alarms.orp = 0;
                     let chlorErr = 0;
                     if (useChlorinator && schem.isBodyOn) {
-                        let chlors = sys.chlorinators.getByBody(schem.activeBodyId);
-                        let chlor = chlors.getItemByIndex(0);
-                        let schlor = state.chlorinators.getItemById(chlor.id);
-                        this.orp.chlor.chlorId = chlor.id;
-                        if (schlor.status & 0xF0) chlorErr = 16;
+                        const chlorCollection = sys.chlorinators.getByBody(schem.activeBodyId);
+                        if (chlorCollection.length > 0) {
+                            for (let chlor of chlorCollection.toArray()) {
+                                let schlor = state.chlorinators.getItemById(chlor.id);
+                                if (schlor.status & 0xF0) {
+                                    chlorErr = 16;
+                                    break;
+                                }
+                            }
+                        }
                     }
                     schem.warnings.chlorinatorCommError = chlorErr;
                     schem.warnings.pHLockout = useChlorinator === false && probeType !== 0 && pumpType !== 0 && schem.ph.level >= chem.orp.phLockout ? 1 : 0;
@@ -1067,7 +1072,7 @@ class NixieChemical extends NixieChildEquipment implements INixieChemical {
             schem.chlor.isDosing = schem.pump.isDosing = false;
             if (!this.chemical.flowOnlyMixing || (schem.chemController.isBodyOn && this.chemController.flowDetected && !schem.freezeProtect)) {
                 if (this.chemType === 'orp' && typeof this.chemController.orp.orp.useChlorinator !== 'undefined' && this.chemController.orp.orp.useChlorinator && this.chemController.orp.orp.chlorDosingMethod > 0) {
-                    if (state.chlorinators.getItemById(this.chemController.orp.chlor.chlorId).currentOutput !== 0) {
+                    if (state.chlorinators.getItemById(this.chlor.id).currentOutput !== 0) {
                         logger.debug(`Chem mixing ORP (chlorinator) paused waiting for chlor current output to be 0%.  Mix time remaining: ${utils.formatDuration(schem.mixTimeRemaining)} `);
                         return;
                     }
@@ -1422,24 +1427,25 @@ export class NixieChemPump extends NixieChildEquipment {
     }
 }
 export class NixieChemChlor extends NixieChildEquipment {
-    public chlor: ChemicalChlor;
-    public isOn: boolean;
-    public chlorId = 0;
+    public get chlor(): Chlorinator { return sys.chlorinators.getItemById((this.getParent() as NixieChemicalORP).orp.chlorId); }
+    public isOn: boolean; // can this just be chlor.isOn?
     public _lastOnStatus: number;
     protected _dosingTimer: NodeJS.Timeout;
     private _isStopping = false;
     public chlorInterval = 15;
-    constructor(chemical: NixieChemical, chlor: ChemicalChlor) { super(chemical); this.chlor = chlor; }
+    // constructor(chemical: NixieChemical, chlor: ChemicalChlor) { super(chemical); this.chlor = chlor; }
+    constructor(chemical: NixieChemical) { super(chemical); }
     public get chemical(): NixieChemical { return this.getParent() as NixieChemical; }
     public async setChlorAsync(schlor: ChemicalChlorState, data: any) {
         try {
             if (typeof data.chlorDosingMethod !== 'undefined' && data.chlorDosingMethod === 0) {
                 if (schlor.chemical.dosingStatus === 0) { await this.chemical.cancelDosing(schlor.chemController.orp, 'dosing method changed'); }
                 if (schlor.chemical.dosingStatus === 1) { await this.chemical.cancelMixing(schlor.chemController.orp); }
-                let chlor = sys.chlorinators.getItemById(this.chlorId);
+                let chlor = sys.chlorinators.getItemById((this.getParent() as NixieChemicalORP).orp.chlorId);
                 chlor.disabled = false;
                 chlor.isDosing = false;
             }
+            let c = sys.chlorinators.toArray
         } catch (err) { logger.error(`setChlorAsync: ${err.message}`); return Promise.reject(err); }
     }
     public async stopDosing(schem: IChemicalState, reason: string): Promise<void> {
@@ -1479,7 +1485,8 @@ export class NixieChemChlor extends NixieChildEquipment {
                 await this.chemical.cancelDosing(schem, 'undefined dose');
                 return;
             }
-            if (this.chlor.ratedLbs === 0) {
+            let chlor = sys.chlorinators.getItemById((this.getParent() as NixieChemicalORP).orp.chlorId);
+            if (chlor.ratedLbs === 0) {
                 // We aren't going to do anything.
                 logger.verbose(`Chem dose ignore chlor because it doesn't have a dosing rating.`);
             }
@@ -1488,7 +1495,7 @@ export class NixieChemChlor extends NixieChildEquipment {
                 let isBodyOn = schem.chemController.flowDetected;
                 await this.chemical.initDose(schem);
                 let chemController = schem.getParent()
-                let schlor = state.chlorinators.getItemById(this.chlorId);
+                let schlor = state.chlorinators.getItemById(chlor.id);
                 if (!isBodyOn) {
                     // Make sure the chlor is off.
                     logger.info(`Chem chlor flow not detected. Body is not running.`);
@@ -1501,7 +1508,7 @@ export class NixieChemChlor extends NixieChildEquipment {
                     if (chem.ph.dosePriority)
                         await this.chemical.cancelDosing(schem, 'ph dose priority');
                 }
-                else if (this.chlor.superChlor) {
+                else if (chlor.superChlor) {
                     // if superchlor is active, it may be to boost the ORP and we should respect that
                     await this.chemical.cancelDosing(schem, 'superchlor');
                 }
@@ -1518,7 +1525,7 @@ export class NixieChemChlor extends NixieChildEquipment {
                         else {
                             if (typeof dose._lastLatch !== 'undefined') {
                                 let time = new Date().getTime() - (dose._lastLatch || new Date().getTime());
-                                let vol = this.chlor.ratedLbs * time / 1000;
+                                let vol = chlor.ratedLbs * time / 1000;
                                 schem.appendDose(vol, time);
                             }
                             logger.info(`Chem Controller ${dose.chem} chlorinated ${Math.round(dose.volumeDosed * 1000000) / 1000000}lbs of ${Math.round(dose.volume * 1000000) / 1000000}lbs - ${utils.formatDuration(dose.timeRemaining)} remaining`);
@@ -1565,14 +1572,15 @@ export class NixieChemChlor extends NixieChildEquipment {
     public async turnOff(schem: IChemicalState): Promise<ChlorinatorState> {
         try {
             //logger.info(`Turning off the chlorinator`);
-            let chlor = sys.chlorinators.getItemById(this.chlorId);
+            let chemORP = this.getParent() as NixieChemicalORP;
+            let chlor = sys.chlorinators.getItemById(chemORP.orp.chlorId);
             let schlor = state.chlorinators.getItemById(chlor.id);
             if (schlor.currentOutput === 0 && schlor.targetOutput === 0 && !schlor.superChlor && chlor.disabled && !chlor.isDosing) {
                 this.isOn = schem.chlor.isDosing = false;
                 return schlor;
             }
             let cstate = await sys.board.chlorinator.setChlorAsync({
-                id: 1,
+                id: chlor.id,
                 disabled: true,
                 isDosing: false
             })
@@ -1583,14 +1591,15 @@ export class NixieChemChlor extends NixieChildEquipment {
     }
     public async turnOn(schem: ChemicalState, latchTimeout?: number): Promise<ChlorinatorState> {
         try {
-            let chlor = sys.chlorinators.getItemById(this.chlorId);
+            let chemORP = this.getParent() as NixieChemicalORP;
+            let chlor = sys.chlorinators.getItemById(chemORP.orp.chlorId);
             let schlor = state.chlorinators.getItemById(chlor.id);
             if (schlor.currentOutput === 100 && schlor.targetOutput === 100 && !schlor.superChlor && !chlor.disabled && chlor.isDosing) {
                 this.isOn = schem.chlor.isDosing = true;
                 return schlor;
             }
             let cstate = await sys.board.chlorinator.setChlorAsync({
-                id: 1,
+                id: chlor.id,
                 disabled: false,
                 isDosing: true
             })
@@ -1939,13 +1948,14 @@ export class NixieChemicalORP extends NixieChemical {
         this.chemType = 'orp';
         this.orp = chemical;
         this.probe = new NixieChemProbeORP(this, chemical.probe);
-        this.chlor = new NixieChemChlor(this, chemical.chlor);
+        // this.chlor = new NixieChemChlor(this, chemical.chlor);
+        this.chlor = new NixieChemChlor(this);
         let sorp = state.chemControllers.getItemById(controller.id).orp;
         if (!this.orp.enabled) {
             this.orp.doserType = 0;
             sorp.chemType = 'none';
         }
-        else if (sorp.useChlorinator) {
+        else if (this.orp.useChlorinator) {
             this.orp.doserType = 2;
             sorp.chemType = 'chlorine';
         }
@@ -1962,14 +1972,38 @@ export class NixieChemicalORP extends NixieChemical {
     public async setORPAsync(sorp: ChemicalORPState, data: any) {
         try {
             if (typeof data !== 'undefined') {
-                sorp.useChlorinator = this.orp.useChlorinator = typeof data.useChlorinator !== 'undefined' ? utils.makeBool(data.useChlorinator) : this.orp.useChlorinator;
+                this.orp.useChlorinator = typeof data.useChlorinator !== 'undefined' ? utils.makeBool(data.useChlorinator) : this.orp.useChlorinator;
+                if (this.orp.useChlorinator) {
+                    if (typeof data.chlorId === 'undefined') {
+                        return Promise.reject(new InvalidEquipmentDataError(`Chlorinator ID must be provided when useChlorinator is true`, 'chemController', data.chlorId));
+                    }
+                    let chlor = sys.chlorinators.getItemById(data.chlorId);
+                    if (typeof chlor === 'undefined') {
+                        return Promise.reject(new InvalidEquipmentDataError(`Chlorinator with ID ${data.chlorId} not found`, 'chemController', data.chlorId));
+                    }
+                    if (chlor.body !== this.chemController.chem.body && chlor.body !== 32) {
+                        return Promise.reject(new InvalidEquipmentDataError(`Chlorinator body does not match the chem controller body`, 'chemController', data.chlorId));
+                    }
+                    let assignedChemController = sys.chemControllers.get().find((cc: ChemController) => 
+                        {
+                            return cc.orp.chlorId === data.chlorId && cc.id !== this.chemController.id;
+                        });
+                    if (assignedChemController) {
+                        return Promise.reject(new InvalidEquipmentDataError(`Chlorinator is already assigned to another chem controller`, 'chemController', data.chlorId));
+                    }
+                    this.orp.chlorId = data.chlorId;
+                    if (typeof data.chlorDosingMethod !== 'undefined') { this.orp.chlorDosingMethod = data.chlorDosingMethod; }
+                } else {
+                    this.orp.chlorId = undefined;
+                    this.orp.chlorDosingMethod = undefined; 
+                }
                 sorp.enabled = this.orp.enabled = typeof data.enabled !== 'undefined' ? utils.makeBool(data.enabled) : this.orp.enabled;
                 sorp.level = typeof data.level !== 'undefined' && !isNaN(parseFloat(data.level)) ? parseFloat(data.level) : sorp.level;
                 this.orp.phLockout = typeof data.phLockout !== 'undefined' && !isNaN(parseFloat(data.phLockout)) ? parseFloat(data.phLockout) : this.orp.phLockout;
                 this.orp.flowReadingsOnly = typeof data.flowReadingsOnly !== 'undefined' ? utils.makeBool(data.flowReadingsOnly) : this.orp.flowReadingsOnly;
                 this.orp.disableOnFreeze = typeof data.disableOnFreeze !== 'undefined' ? utils.makeBool(data.disableOnFreeze) : this.orp.disableOnFreeze;
                 if (!this.orp.disableOnFreeze) sorp.freezeProtect = false;
-                if (typeof data.chlorDosingMethod !== 'undefined') { this.orp.chlorDosingMethod = data.chlorDosingMethod; }
+
                 await this.setDosing(this.orp, data);
                 await this.setMixing(this.orp, data);
                 await this.probe.setProbeORPAsync(sorp.probe, data.probe);
@@ -1980,7 +2014,7 @@ export class NixieChemicalORP extends NixieChemical {
                     this.orp.doserType = 0;
                     sorp.chemType = 'none';
                 }
-                else if (sorp.useChlorinator) {
+                else if (this.orp.useChlorinator) {
                     this.orp.doserType = 2;
                     sorp.chemType = 'chlorine';
                 }
@@ -2069,7 +2103,7 @@ export class NixieChemicalORP extends NixieChemical {
 
     public async cancelDosing(sorp: ChemicalORPState, reason: string): Promise<void> {
         try {
-            if (typeof sorp.useChlorinator !== 'undefined' && sorp.useChlorinator && this.chemController.orp.orp.chlorDosingMethod > 0) {
+            if (typeof this.orp.useChlorinator !== 'undefined' && this.orp.useChlorinator && this.chemController.orp.orp.chlorDosingMethod > 0) {
                 await this.chlor.stopDosing(sorp, reason);
                 // for chlor, we want 15 minute intervals
                 if (sorp.doseHistory.length) {
@@ -2104,7 +2138,7 @@ export class NixieChemicalORP extends NixieChemical {
                 if (typeof mixingTime !== 'undefined') {
                     // This is a manual mix so we need to make sure the pump is not dosing.
                     logger.info(`Clearing any possible ${schem.chemType} dosing or existing mix for mixingTime: ${mixingTime}`);
-                    if (schem.chemController.orp.useChlorinator) await this.chlor.stopDosing(schem, 'mix override');
+                    if (this.orp.useChlorinator) await this.chlor.stopDosing(schem, 'mix override');
                     else await this.pump.stopDosing(schem, 'mix override');
                     await this.stopMixing(schem);
                 }
@@ -2274,9 +2308,8 @@ export class NixieChemicalORP extends NixieChemical {
                                 return;
                             }
                         }
-
-
-                        let chlor = sys.chlorinators.getItemById(this.chlor.chlorId); // Still haven't seen any systems with 2+ chlors
+                        let chlor = this.chlor.chlor; // Still haven't seen any systems with 2+ chlors.  
+                        // 2024.12.25 RSG - Oh really?  See https://github.com/tagyoureit/nodejs-poolController/discussions/896
                         let schlor = state.chlorinators.getItemById(chlor.id);
                         // If someone or something is superchloring the pool, let it be
                         if (schlor.superChlor) return;
@@ -2429,7 +2462,7 @@ export class NixieChemicalORP extends NixieChemical {
         logger.info(`Removing chlor ${chlor.id} from Chem Controller ${this.getParent().id}`);
         let schem = state.chemControllers.getItemById(this.getParent().id);
         this.orp.useChlorinator = false;
-        schem.orp.useChlorinator = false;
+        // schem.orp.useChlorinator = false;
         if (schem.orp.dosingStatus === 0) { await this.cancelDosing(schem.orp, 'deleting chlorinator'); }
         if (schem.orp.dosingStatus === 1) { await this.cancelMixing(schem.orp); }
     }

package/controller/nixie/circuits/Circuit.ts

@@ -45,7 +45,7 @@ export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircui
         } catch (err) { return logger.error(`NCP: setServiceModeAsync: ${err.message}`); }
     }
     public async setLightThemeAsync(id: number, theme: any) {
-            let c: NixieCircuit = this.find(elem => elem.id === id) as NixieCircuit;
+        let c: NixieCircuit = this.find(elem => elem.id === id) as NixieCircuit;
         if (typeof c === 'undefined') return Promise.reject(new Error(`NCP: Circuit ${id} could not be found to set light theme ${theme.name}.`));
         await c.setLightThemeAsync(theme);
     } catch(err) { return logger.error(`NCP: sendOnOffSequence: ${err.message}`); }
@@ -75,10 +75,10 @@ export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircui
         catch (err) { logger.error(`setCircuitAsync: ${err.message}`); return Promise.reject(err); }
     }
     public async checkCircuitEggTimerExpirationAsync(cstate: ICircuitState) {
-     try {
-        let c: NixieCircuit = this.find(elem => elem.id === cstate.id) as NixieCircuit;
-        await c.checkCircuitEggTimerExpirationAsync(cstate);
-    } catch (err) { logger.error(`NCP: Error synching circuit states: ${err}`); }
+        try {
+            let c: NixieCircuit = this.find(elem => elem.id === cstate.id) as NixieCircuit;
+            await c.checkCircuitEggTimerExpirationAsync(cstate);
+        } catch (err) { logger.error(`NCP: Error synching circuit states: ${err}`); }
     }
     public async initAsync(circuits: CircuitCollection) {
         try {
@@ -159,21 +159,21 @@ export class NixieCircuit extends NixieEquipment {
     protected async setIntelliBriteThemeAsync(cstate: CircuitState, theme: any): Promise<InterfaceServerResponse> {
         let arr = [];
         let count = typeof theme !== 'undefined' && theme.sequence ? theme.sequence : 0;
-		
-		// Removing this. No need to turn the light off first.  We actually need it on to start the sequence for theme setting to work correctly when the light is starting from the off state.
-		// if (cstate.isOn) arr.push({ isOn: false, timeout: 1000 });
-		
-		// Start the sequence of off/on after the light is on.
+
+        // Removing this. No need to turn the light off first.  We actually need it on to start the sequence for theme setting to work correctly when the light is starting from the off state.
+        // if (cstate.isOn) arr.push({ isOn: false, timeout: 1000 });
+
+        // Start the sequence of off/on after the light is on.
         arr.push({ isOn: true, timeout: 100 });
         for (let i = 0; i < count; i++) {
-			arr.push({ isOn: false, timeout: 100 });
-			arr.push({ isOn: true, timeout: 100 });     
+            arr.push({ isOn: false, timeout: 100 });
+            arr.push({ isOn: true, timeout: 100 });
         }
-		// Ensure light stays on long enough for the theme to stick (required for light group theme setting to function correctly).
-		// 2s was too short.
-		arr.push({ isOn: true, timeout: 3000 });
-        
-		logger.debug(arr);
+        // Ensure light stays on long enough for the theme to stick (required for light group theme setting to function correctly).
+        // 2s was too short.
+        arr.push({ isOn: true, timeout: 3000 });
+
+        logger.debug(arr);
         let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, arr, 60000);
         // Even though we ended with on we need to make sure that the relay stays on now that we are done.
         if (!res.error) {
@@ -182,7 +182,7 @@ export class NixieCircuit extends NixieEquipment {
         }
         return res;
     }
-    protected async setWaterColorsThemeAsync(cstate: CircuitState, theme: any): Promise<InterfaceServerResponse> {
+    protected async setPoolToneThemeAsync(cstate: CircuitState, theme: any): Promise<InterfaceServerResponse> {
         let ptheme = sys.board.valueMaps.lightThemes.findItem(cstate.lightingTheme) || { val: 0, sequence: 0 };
         // First check to see if we are on.  If we are not then we need to emit our status as if we are initializing and busy.
         let arr = [];
@@ -196,7 +196,40 @@ export class NixieCircuit extends NixieEquipment {
         let count = theme.sequence - ptheme.sequence;
         if (count < 0) count = count + 16;
         for (let i = 0; i < count; i++) {
-            arr.push({ isOn: true, timeout: 200 }); 
+            arr.push({ isOn: true, timeout: 200 });
+            arr.push({ isOn: false, timeout: 200 });
+        }
+        console.log(arr);
+        if (arr.length === 0) return new InterfaceServerResponse(200, 'Success');
+        let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, arr, 60000);
+        // Even though we ended with on we need to make sure that the relay stays on now that we are done.
+        if (!res.error) {
+            cstate.lightingTheme = ptheme.val;
+            cstate.isOn = true; // At this point the relay will be off but we want the process
+            // to assume that the relay state is not actually changing.
+            this._sequencing = false;
+            await this.setCircuitStateAsync(cstate, true, false);
+        }
+        return res;
+    }
+    protected async setWaterColorsThemeAsync(cstate: CircuitState, theme: any): Promise<InterfaceServerResponse> {
+        // RSG 2024.12.24 - This logic was aligned with the Pool Tone themes.  I haven't checked if that 
+        // logic is correct, but made a copy and adjusted for the watercolors themes.
+        
+        let ptheme = sys.board.valueMaps.lightThemes.findItem(cstate.lightingTheme) || { val: 0, sequence: 0 };
+        // First check to see if we are on.  If we are not then we need to emit our status as if we are initializing and busy.
+        let arr = [];
+        if (ptheme.val === 0) {
+            // We don't know our previous theme so we are going to sync the lights to get a starting point.
+            arr.push({ isOn: true, timeout: 1000 }); // Turn on for 1 second
+            arr.push({ isOn: false, timeout: 5000 }); // Turn off for 5 seconds
+            arr.push({ isOn: true, timeout: 1000 });
+            ptheme = sys.board.valueMaps.lightThemes.findItem('alpinewhite');
+        }
+        let count = theme.sequence - ptheme.sequence;
+        if (count < 0) count = count + 14;
+        for (let i = 0; i < count; i++) {
+            arr.push({ isOn: true, timeout: 200 });
             arr.push({ isOn: false, timeout: 200 });
         }
         console.log(arr);
@@ -206,7 +239,7 @@ export class NixieCircuit extends NixieEquipment {
         if (!res.error) {
             cstate.lightingTheme = ptheme.val;
             cstate.isOn = true; // At this point the relay will be off but we want the process
-                                // to assume that the relay state is not actually changing.
+            // to assume that the relay state is not actually changing.
             this._sequencing = false;
             await this.setCircuitStateAsync(cstate, true, false);
         }
@@ -243,7 +276,7 @@ export class NixieCircuit extends NixieEquipment {
         if (!res.error) {
             cstate.lightingTheme = ptheme.val;
             cstate.isOn = true; // At this point the relay will be off but we want the process
-                                // to assume that the relay state is not actually changing.
+            // to assume that the relay state is not actually changing.
             this._sequencing = false;
             await this.setCircuitStateAsync(cstate, true, false);
         }
@@ -264,7 +297,6 @@ export class NixieCircuit extends NixieEquipment {
             switch (type.name) {
                 case 'colorcascade':
                 case 'globrite':
-                case 'pooltone':
                 case 'magicstream':
                 case 'intellibrite':
                     res = await this.setIntelliBriteThemeAsync(cstate, theme);
@@ -275,6 +307,9 @@ export class NixieCircuit extends NixieEquipment {
                 case 'watercolors':
                     res = await this.setWaterColorsThemeAsync(cstate, theme);
                     break;
+                case 'pooltone':
+                    res = await this.setPoolToneThemeAsync(cstate, theme);
+                    break;
             }
             cstate.action = 0;
             // Make sure clients know that we are done.
@@ -285,11 +320,11 @@ export class NixieCircuit extends NixieEquipment {
     }
     public async sendOnOffSequenceAsync(count: number | { isOn: boolean, timeout: number }[], timeout?: number): Promise<InterfaceServerResponse> {
         try {
-           
+
             this._sequencing = true;
             let arr = [];
             let cstate = state.circuits.getItemById(this.circuit.id);
-            
+
             if (typeof count === 'number') {
                 if (cstate.isOn) arr.push({ isOn: false, timeout: 1000 });
                 let t = typeof timeout === 'undefined' ? 100 : timeout;
@@ -339,21 +374,21 @@ export class NixieCircuit extends NixieEquipment {
                 // Check to see if we should be on by poking the schedules.
             }
             if (utils.isNullOrEmpty(this.circuit.connectionId) || utils.isNullOrEmpty(this.circuit.deviceBinding)) {
-                if (val && val !== cstate.isOn){
+                if (val && val !== cstate.isOn) {
                     sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(cstate.id), cstate, val);
                 }
-                else if (!val){
+                else if (!val) {
                     if (cstate.manualPriorityActive) delayMgr.cancelManualPriorityDelay(cstate.id);
                     cstate.manualPriorityActive = false; // if the delay was previously cancelled, still need to turn this off
-                } 
-                cstate.isOn = val; 
+                }
+                cstate.isOn = val;
                 return new InterfaceServerResponse(200, 'Success');
             }
             if (this._sequencing) return new InterfaceServerResponse(200, 'Success');
-            let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, { isOn: val, latch: val ? 10000 : undefined });
+        let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, { isOn: val, latch: val ? 10000 : undefined });
             if (res.status.code === 200) {
                 // Set this up so we can process our egg timer.
-                if (val && val !== cstate.isOn){
+                if (val && val !== cstate.isOn) {
                     sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(cstate.id), cstate, val);
                     switch (sys.board.valueMaps.circuitFunctions.getName(this.circuit.type)) {
                         case 'colorlogic':
@@ -385,7 +420,7 @@ export class NixieCircuit extends NixieEquipment {
                             break;
                     }
                 }
-                else if (!val){
+                else if (!val) {
                     delayMgr.cancelManualPriorityDelays();
                     cstate.manualPriorityActive = false; // if the delay was previously cancelled, still need to turn this off
                 }

package/logger/Logger.ts

@@ -270,6 +270,10 @@ class Logger {
         // start new replay directory
 
         if (!fs.existsSync(this.captureForReplayPath)) fs.mkdirSync(this.captureForReplayBaseDir, { recursive: true });
+        
+        // Create logs subdirectory for additional log files
+        let logsSubDir = path.join(this.captureForReplayBaseDir, 'logs');
+        if (!fs.existsSync(logsSubDir)) fs.mkdirSync(logsSubDir, { recursive: true });
         if (bResetLogs){
             if (fs.existsSync(path.join(process.cwd(), 'data/poolConfig.json'))) {
                 fs.copyFileSync(path.join(process.cwd(), 'data/poolConfig.json'), path.join(process.cwd(),'data/', `poolConfig-${this.getLogTimestamp()}.json`));
@@ -360,29 +364,68 @@ class Logger {
         logger._logger.add(this.transports.file);
         this.transports.console.level = 'silly';
     }
-    public async stopCaptureForReplayAsync():Promise<string> {
+    public async stopCaptureForReplayAsync(remLogs?: any[]):Promise<string> {
         return new Promise<string>(async (resolve, reject) => {
             try {
-                fs.copyFileSync(path.join(process.cwd(), "/config.json"), path.join(this.captureForReplayBaseDir, `config.json`));
-                fs.copyFileSync(path.join(process.cwd(), 'data/poolConfig.json'), path.join(this.captureForReplayBaseDir, 'poolConfig.json'));
-                fs.copyFileSync(path.join(process.cwd(), 'data/poolState.json'), path.join(this.captureForReplayBaseDir, 'poolState.json'));
-                fs.copyFileSync(logger.pktPath, path.join(this.captureForReplayBaseDir, `packetLog${this.getLogTimestamp()}`));
+                // Get REM server configurations from config
+                let configData = config.getSection();
+                let remServers = [];
+                if (configData.web && configData.web.interfaces) {
+                    for (let interfaceName in configData.web.interfaces) {
+                        let interfaceConfig = configData.web.interfaces[interfaceName];
+                        if (interfaceConfig.type === 'rem' && interfaceConfig.enabled) {
+                            remServers.push({
+                                name: interfaceConfig.name || interfaceName,
+                                uuid: interfaceConfig.uuid,
+                                host: interfaceConfig.options?.host || '',
+                                backup: true
+                            });
+                        }
+                    }
+                }
+
+                // Use the existing backup logic to create the base backup
+                let backupOptions = {
+                    njsPC: true,
+                    servers: remServers,
+                    name: `Packet Capture ${this.currentTimestamp}`,
+                    automatic: false
+                };
+                
+                let backupFile = await webApp.backupServer(backupOptions);
+                
+                // Add packet capture logs to the existing backup zip
+                let jszip = require("jszip");
+                let zip = await jszip.loadAsync(fs.readFileSync(backupFile.filePath));
+                
+                // Add packet capture logs to the njsPC/logs directory
+                zip.file(`njsPC/logs/${this.getPacketPath()}`, fs.readFileSync(logger.pktPath));
+                zip.file(`njsPC/logs/${this.getConsoleToFilePath()}`, fs.readFileSync(this.consoleToFilePath));
+                
+                // Add REM server logs if provided
+                if (remLogs && remLogs.length > 0) {
+                    logger.info(`Adding ${remLogs.length} REM logs to backup`);
+                    for (let remLog of remLogs) {
+                        // Create logs directory for the REM server using the hardcoded name
+                        let logPath = `Relay Equipment Manager/logs/${remLog.logFileName}`;
+                        logger.info(`Adding REM log to backup: ${logPath} (size: ${remLog.logData.length} characters)`);
+                        zip.file(logPath, remLog.logData);
+                    }
+                } else {
+                    logger.info(`No REM logs provided to add to backup`);
+                }
+                
+                // Generate the updated zip
+                await zip.generateAsync({type:'nodebuffer'}).then(content => {
+                    fs.writeFileSync(backupFile.filePath, content);
+                });
+                
+                // Restore original logging configuration
                 this.cfg = config.getSection('log');
                 logger._logger.remove(this.transports.file);
                 this.transports.console.level = this.cfg.app.level;
-                let jszip = require("jszip");
-                let zipPath = path.join(this.captureForReplayBaseDir,`${this.currentTimestamp}.zip`);
-                let zip = new jszip();
-                zip.file('config.json', fs.readFileSync(path.join(this.captureForReplayBaseDir, 'config.json')));
-                zip.file('poolConfig.json', fs.readFileSync(path.join(this.captureForReplayBaseDir, 'poolConfig.json')));
-                zip.file('poolState.json', fs.readFileSync(path.join(this.captureForReplayBaseDir, 'poolState.json')));
-                zip.file(this.getPacketPath(), fs.readFileSync(path.join(this.captureForReplayBaseDir, `packetLog${this.getLogTimestamp()}`)));
-                zip.file(this.getConsoleToFilePath(), fs.readFileSync(this.consoleToFilePath));
-                await zip.generateAsync({type:'nodebuffer'}).then(content=>
-                    {
-                        fs.writeFileSync(zipPath, content);
-                    });
-                resolve(zipPath);
+                
+                resolve(backupFile.filePath);
             }
             catch (err) {
                 reject(err.message);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nodejs-poolcontroller",
-    "version": "8.0.5",
+    "version": "8.1.1",
     "description": "nodejs-poolController",
     "main": "app.js",
     "author": {