nodejs-poolcontroller 8.0.1 → 8.0.2

package/controller/nixie/schedules/Schedule.ts

@@ -4,11 +4,12 @@ import { logger } from '../../../logger/Logger';
 
 import { NixieEquipment, NixieChildEquipment, NixieEquipmentCollection, INixieControlPanel } from "../NixieEquipment";
 import { CircuitGroup, CircuitGroupCircuit, ICircuitGroup, ICircuitGroupCircuit, LightGroup, LightGroupCircuit, Schedule, ScheduleCollection, sys } from "../../../controller/Equipment";
-import { CircuitGroupState, ICircuitGroupState, ScheduleState, state, } from "../../State";
+import { ICircuitState, CircuitGroupState, ICircuitGroupState, ScheduleState, ScheduleTime, state, } from "../../State";
 import { setTimeout, clearTimeout } from 'timers';
 import { NixieControlPanel } from '../Nixie';
 import { webApp, InterfaceServerResponse } from "../../../web/Server";
 import { delayMgr } from '../../../controller/Lockouts';
+import { time } from 'console';
 
 
 export class NixieScheduleCollection extends NixieEquipmentCollection<NixieSchedule> {
@@ -23,9 +24,8 @@ export class NixieScheduleCollection extends NixieEquipmentCollection<NixieSched
                 await c.setScheduleAsync(data);
                 logger.info(`A Schedule was not found for id #${schedule.id} creating Schedule`);
             }
-            else {
+            else 
                 await c.setScheduleAsync(data);
-            }
         }
         catch (err) { logger.error(`setScheduleAsync: ${err.message}`); return Promise.reject(err); }
     }
@@ -46,24 +46,168 @@ export class NixieScheduleCollection extends NixieEquipmentCollection<NixieSched
     }
     public async triggerSchedules() {
         try {
-            let ctx = new NixieScheduleContext();
-            for (let i = 0; i < this.length; i++) {
-                (this[i] as NixieSchedule).triggerScheduleAsync(ctx);
-            }
-            // Set the heat modes for the bodies.
-            for (let i = 0; i < ctx.heatModes.length; i++) {
-                let mode = ctx.heatModes[i];
-                let body = sys.bodies.getItemById(mode.id);
-                await sys.board.bodies.setHeatModeAsync(sys.bodies.getItemById(mode.id), mode.heatMode);
-                if (typeof mode.heatSetpoint !== 'undefined') await sys.board.bodies.setHeatSetpointAsync(body, mode.heatSetpoint);
-                if (typeof mode.coolSetpoint !== 'undefined') await sys.board.bodies.setCoolSetpointAsync(body, mode.coolSetpoint);
+            // This is a listing of all the active schedules that are either currently on or should be on.
+            let sscheds: ScheduleState[] = state.schedules.getActiveSchedules();
+            // Go through all the schedules and hash them by circuit id.
+            let circuits: { circuitId: number, cstate: ICircuitState, hasNixie: boolean, sscheds: ScheduleState[] }[] = []
+            for (let i = 0; i < sscheds.length; i++) {
+                // We only care about schedules that are currently running or should be running.
+                if (!sscheds[i].isOn && !sscheds[i].scheduleTime.shouldBeOn) continue;
+                let circ = circuits.find(elem => elem.circuitId === sscheds[i].circuit);
+                let sched = sys.schedules.getItemById(sscheds[i].id)
+                if (typeof circ === 'undefined') circuits.push({
+                    circuitId: sscheds[i].circuit,
+                    cstate: state.circuits.getInterfaceById(sscheds[i].circuit), hasNixie: sched.master !== 0, sscheds: [sscheds[i]]
+                });
+                else {
+                    if (sched.master !== 0) circ.hasNixie = true;
+                    circ.sscheds.push(sscheds[i]);
+                }
             }
-            // Alright now that we are done with that we need to set all the circuit states that need changing.
-            for (let i = 0; i < ctx.circuits.length; i++) {
-                let circuit = ctx.circuits[i];
-                await sys.board.circuits.setCircuitStateAsync(circuit.id, circuit.isOn);
+            // Sort this so that body circuits are evaluated first.  This is required when there are schedules for things like cleaner
+            // or delay circuits.  If we do not do this then a schedule that requires the pool to be on for instance will never
+            // get triggered.
+            circuits.sort((x, y) => y.circuitId === 6 || y.circuitId === 1 ? 1 : y.circuitId - x.circuitId);
+
+
+            /*
+            RSG 5-8-22
+            Manual OP needs to play a role here.From the IC manual: 
+            # Manual OP General
+
+            From the manual: 
+            Manual OP Priority: ON: This feature allows for a circuit to be manually switched OFF and switched ON within a scheduled program, 
+            the circuit will continue to run for a maximum of 12 hours or whatever that circuit Egg Timer is set to, after which the scheduled 
+            program will resume. This feature will turn off any scheduled program to allow manual pump override.The Default setting is OFF.
+
+            ## When on
+            1.  If a schedule should be on and the user turns the schedule off then the schedule expires until such time as the time off has 
+            expired.When that occurs the schedule should be reset to run at the designated time.If the user resets the schedule by turning the 
+            circuit back on again ~~then the schedule will resume and turn off at the specified time~~then the schedule will be ignored and 
+            the circuit will run until the egg timer expires or the circuit / feature is manually turned off.This setting WILL affect 
+            other schedules that may impact this circuit.
+
+            ## When off
+            1. "Normal" = If a schedule should be on and the user turns the schedule off then the schedule expires until such time as the time 
+            off has expired.When that occurs the schedule should be reset to run at the designated time.If the user resets the schedule by 
+            turning the circuit back on again then the schedule will resume and turn off at the specified time.
+            */
+
+            let mOP = sys.general.options.manualPriority;
+
+            // Now lets evaluate the schedules by virtue of their state related to the circuits.
+            for (let i = 0; i < circuits.length; i++) {
+                let c = circuits[i];
+                if (!c.hasNixie) continue; // If this has nothing to do with Nixie move on.
+                let shouldBeOn = typeof c.sscheds.find(elem => elem.scheduleTime.shouldBeOn === true) !== 'undefined';
+                // 1. If the feature is currently running and the schedule is not on then it will set the priority for the circuit to [scheduled].
+                // 2. If the feature is currently running but there are overlapping schedules then this will catch any schedules that need to be turned off.
+                if (c.cstate.isOn && shouldBeOn) {
+                    c.cstate.priority = shouldBeOn ? 'scheduled' : 'manual';
+                    for (let j = 0; j < c.sscheds.length; j++) {
+                        let ssched = c.sscheds[j];
+                        ssched.triggered = ssched.scheduleTime.shouldBeOn;
+                        if (mOP && ssched.manualPriorityActive) {
+                            ssched.isOn = false;
+                            // Not sure what setting a delay for this does but ok.
+                            if (!c.cstate.manualPriorityActive) delayMgr.setManualPriorityDelay(c.cstate);
+                        }
+                        else ssched.isOn = ssched.scheduleTime.shouldBeOn && !ssched.manualPriorityActive;
+                    }
+                }
+                // 3. If the schedule should be on and it isn't and the schedule has not been triggered then we need to 
+                // turn the schedule and circuit on.
+                else if (!c.cstate.isOn && shouldBeOn) {
+                    // The circuit is not on but it should be. Check to ensure all schedules have been triggered.
+                    let untriggered = false;
+                    // If this schedule has been triggered then mOP comes into play if manualPriority has been set in the config.
+                    for (let j = 0; j < c.sscheds.length; j++) {
+                        let ssched = c.sscheds[j];
+                        // If this schedule is turned back on then the egg timer will come into play.  This is all that is required
+                        // for the mOP function.  The setEndDate for the circuit makes the determination as to when off will occur.
+                        if (mOP && ssched.scheduleTime.shouldBeOn && ssched.triggered) {
+                            ssched.manualPriorityActive = true;
+                        }
+                        // The reason we check to see if anything has not been triggered is so we do not have to perform the circuit changes
+                        // if the schedule has already been triggered.
+                        else if (!ssched.triggered) untriggered = true;
+                    }
+                    let heatSource = { heatMode: 'nochange', heatSetpoint: undefined, coolSetpoint: undefined };
+                    // Check to see if any of the schedules have not been triggered.  If they haven't then trigger them and turn the circuit on.
+                    if (untriggered) {
+                        // Get the heat modes and temps for all the schedules that have not been triggered.
+                        let body = sys.bodies.find(elem => elem.circuit === c.circuitId);
+                        if (typeof body !== 'undefined') {
+                            // If this is a body circuit then we need to set the heat mode and the temperature but only do this once. If
+                            // the user changes it later then that is on them.
+                            for (let j = 0; j < c.sscheds.length; j++) {
+                                if (sscheds[j].triggered) continue;
+                                let ssched = sscheds[j];
+                                let hs = sys.board.valueMaps.heatSources.transform(c.sscheds[i].heatSource);
+                                switch (hs.name) {
+                                    case 'nochange':
+                                    case 'dontchange':
+                                        break;
+                                    case 'off':
+                                        // If the heatsource setting is off only change it if it is currently don't change.
+                                        if (heatSource.heatMode === 'nochange') heatSource.heatMode = hs.name;
+                                        break;
+                                    default:
+                                        switch (heatSource.heatMode) {
+                                            case 'off':
+                                            case 'nochange':
+                                            case 'dontchange':
+                                                heatSource.heatMode = hs.name;
+                                                heatSource.heatSetpoint = ssched.heatSetpoint;
+                                                heatSource.coolSetpoint = hs.hasCoolSetpoint ? ssched.coolSetpoint : undefined;
+                                                break;
+                                        }
+                                        break;
+                                }
+                                // Ok if we need to change the setpoint or the heatmode then lets do it.
+                                if (heatSource.heatMode !== 'nochange') {
+                                    await sys.board.bodies.setHeatModeAsync(body, sys.board.valueMaps.heatSources.getValue(heatSource.heatMode));
+                                    if (typeof heatSource.heatSetpoint !== 'undefined') await sys.board.bodies.setHeatSetpointAsync(body, heatSource.heatSetpoint);
+                                    if (typeof heatSource.coolSetpoint !== 'undefined') await sys.board.bodies.setCoolSetpointAsync(body, heatSource.coolSetpoint);
+                                }
+                            }
+                        }
+                        // By now we have everything we need to turn on the circuit.
+                        for (let j = 0; j < c.sscheds.length; j++) {
+                            let ssched = c.sscheds[j];
+                            if (!ssched.triggered && ssched.scheduleTime.shouldBeOn) {
+                                if (!c.cstate.isOn) {
+                                    await sys.board.circuits.setCircuitStateAsync(c.circuitId, true);
+                                }
+                                let ssched = c.sscheds[j];
+                                c.cstate.priority = 'scheduled';
+                                ssched.triggered = ssched.isOn = ssched.scheduleTime.shouldBeOn;
+                                ssched.manualPriorityActive = false;
+                            }
+                        }
+                    }
+                }
+                else if (c.cstate.isOn && !shouldBeOn) {
+                    // Time to turn off the schedule.
+                    for (let j = 0; j < c.sscheds.length; j++) {
+                        let ssched = c.sscheds[j];
+                        // Only turn off the schedule if it is not actively mOP.
+                        if (c.cstate.isOn && !ssched.manualPriorityActive) await sys.board.circuits.setCircuitStateAsync(c.circuitId, false);
+                        c.cstate.priority = 'manual';
+                        // The schedule has expired we need to clear all the info for it.
+                        ssched.manualPriorityActive = ssched.triggered = ssched.isOn = c.sscheds[j].scheduleTime.shouldBeOn;
+                    }
+                }
+                else if (!c.cstate.isOn && !shouldBeOn) {
+                    // Everything is off so lets clear it all.
+                    for (let j = 0; j < c.sscheds.length; j++) {
+                        let ssched = c.sscheds[j];
+                        ssched.isOn = ssched.manualPriorityActive = ssched.triggered = false;
+                    }
+                }
+                state.emitEquipmentChanges();
             }
-        } catch (err) { logger.error(`Error triggering schedules: ${err}`); }
+        } catch (err) { logger.error(`Error triggering nixie schedules: ${err.message}`); }
     }
 }
 export class NixieSchedule extends NixieEquipment {
@@ -77,29 +221,44 @@ export class NixieSchedule extends NixieEquipment {
         super(ncp);
         this.schedule = schedule;
         this.pollEquipmentAsync();
+        let ssched = state.schedules.getItemById(schedule.id, true);
+        ssched.circuit = schedule.circuit;
+        ssched.scheduleDays = schedule.scheduleDays;
+        ssched.scheduleType = schedule.scheduleType;
+        ssched.changeHeatSetpoint = schedule.changeHeatSetpoint;
+        ssched.heatSetpoint = schedule.heatSetpoint;
+        ssched.coolSetpoint = schedule.coolSetpoint;
+        ssched.heatSource = schedule.heatSource;
+        ssched.startTime = schedule.startTime;
+        ssched.endTime = schedule.endTime;
+        ssched.startTimeType = schedule.startTimeType;
+        ssched.endTimeType = schedule.endTimeType;
+        ssched.startDate = schedule.startDate;
     }
     public get id(): number { return typeof this.schedule !== 'undefined' ? this.schedule.id : -1; }
     public async setScheduleAsync(data: any) {
         try {
             let schedule = this.schedule;
+            let sschedule = state.schedules.getItemById(schedule.id);
+            sschedule.scheduleTime.calculated = false;
         }
         catch (err) { logger.error(`Nixie setScheduleAsync: ${err.message}`); return Promise.reject(err); }
     }
-    public async pollEquipmentAsync() {
-        let self = this;
-        try {
-            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
-            this._pollTimer = null;
-            let success = false;
-        }
-        catch (err) { logger.error(`Nixie Error polling Schedule - ${err}`); }
-        finally { this._pollTimer = setTimeout(async () => await self.pollEquipmentAsync(), this.pollingInterval || 10000); }
-    }
+    public async pollEquipmentAsync() {}
     public async validateSetupAsync(Schedule: Schedule, temp: ScheduleState) {
         try {
             // The validation will be different if the Schedule is on or not.  So lets get that information.
         } catch (err) { logger.error(`Nixie Error checking Schedule Hardware ${this.schedule.id}: ${err.message}`); return Promise.reject(err); }
     }
+    public async closeAsync() {
+        try {
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+        }
+        catch (err) { logger.error(`Nixie Schedule closeAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public logData(filename: string, data: any) { this.controlPanel.logData(filename, data); }
+    /*
     public async triggerScheduleAsync(ctx: NixieScheduleContext) {
         try {
             if (this.schedule.isActive === false) return;
@@ -109,22 +268,20 @@ export class NixieSchedule extends NixieEquipment {
             // Schedules can be overridden so it is important that when the 
             // state is changed for the schedule if it is currently active that
             // Nixie does not override the state of the scheduled circuit or feature.
-            /*
-            RSG 5-8-22
-            Manual OP needs to play a role here.  From the IC manual: 
-            # Manual OP General
+            //RSG 5-8-22
+            //Manual OP needs to play a role here.  From the IC manual: 
+            //# Manual OP General
 
-            From the manual: 
-            Manual OP Priority: ON: This feature allows for a circuit to be manually switched OFF and switched ON within a scheduled program, the circuit will continue to run for a maximum of 12 hours or whatever that circuit Egg Timer is set to, after which the scheduled program will resume. This feature will turn off any scheduled program to allow manual pump override. The Default setting is OFF.
+            //From the manual: 
+            //Manual OP Priority: ON: This feature allows for a circuit to be manually switched OFF and switched ON within a scheduled program, the circuit will continue to run for a maximum of 12 hours or whatever that circuit Egg Timer is set to, after which the scheduled program will resume. This feature will turn off any scheduled program to allow manual pump override. The Default setting is OFF.
 
-            ## When on
-            1.  If a schedule should be on and the user turns the schedule off then the schedule expires until such time as the time off has expired.  When that occurs the schedule should be reset to run at the designated time.  If the user resets the schedule by turning the circuit back on again ~~then the schedule will resume and turn off at the specified time~~ then the schedule will be ignored and the circuit will run until the egg timer expires or the circuit/feature is manually turned off.  This setting WILL affect other schedules that may impact this circuit.
+            //## When on
+            //1.  If a schedule should be on and the user turns the schedule off then the schedule expires until such time as the time off has expired.  When that occurs the schedule should be reset to run at the designated time.  If the user resets the schedule by turning the circuit back on again ~~then the schedule will resume and turn off at the specified time~~ then the schedule will be ignored and the circuit will run until the egg timer expires or the circuit/feature is manually turned off.  This setting WILL affect other schedules that may impact this circuit.
 
-            ## When off
-            1. "Normal" = If a schedule should be on and the user turns the schedule off then the schedule expires until such time as the time off has expired.  When that occurs the schedule should be reset to run at the designated time.  If the user resets the schedule by turning the circuit back on again then the schedule will resume and turn off at the specified time.
+            //## When off
+            //1. "Normal" = If a schedule should be on and the user turns the schedule off then the schedule expires until such time as the time off has expired.  When that occurs the schedule should be reset to run at the designated time.  If the user resets the schedule by turning the circuit back on again then the schedule will resume and turn off at the specified time.
 
-            Interestingly, there also seems to be a schedule level setting for this.  We will ignore that for now as the logic could get much more complicated.
-            */
+            //Interestingly, there also seems to be a schedule level setting for this.  We will ignore that for now as the logic could get much more complicated.
             // 1. If the feature happens to be running and the schedule is not yet turned on then
             // it should not override what the user says.
             // 2. If a schedule is running and the state of the circuit changes to off then the new state should suspend the schedule
@@ -154,8 +311,7 @@ export class NixieSchedule extends NixieEquipment {
                 ssched.isOn = false;
                 return;
             }
-            let shouldBeOn = this.shouldBeOn(); // This should also set the validity for the schedule if there are errors.
-            
+            let shouldBeOn = ssched.shouldBeOn(); // This should also set the validity for the schedule if there are errors.
             let manualPriorityActive: boolean = shouldBeOn ? sys.board.schedules.manualPriorityActive(ssched) : false;
             //console.log(`Processing schedule ${this.schedule.id} - ${circuit.name} : ShouldBeOn: ${shouldBeOn} ManualPriorityActive: ${manualPriorityActive} Running: ${this.running} Suspended: ${this.suspended} Resumed: ${this.resumed}`);
 
@@ -199,6 +355,11 @@ export class NixieSchedule extends NixieEquipment {
                 this.running = true;
             }
             else if (shouldBeOn && this.running) {
+                // Check to see if circuit is on, if not turn it on.
+                // RKS: 07-09-23 - This was in PR#819 buut this needs further review since the circuit states are not to be set here. This would
+                // trash delays and manualPriority.
+                // if(!cstate.isOn) ctx.setCircuit(circuit.id, true);
+
                 // With mOP, we need to see if the schedule will come back into play and also set the circut
                 if (this.suspended && cstate.isOn) {
                     if (sys.general.options.manualPriority) {
@@ -208,13 +369,13 @@ export class NixieSchedule extends NixieEquipment {
                     this.resumed = true;
                 }
                 this.suspended = !cstate.isOn;
-                if (manualPriorityActive){
+                if (manualPriorityActive) {
                     ssched.isOn = false;
                     ssched.manualPriorityActive = true;
                 }
                 else {
                     ssched.isOn = cstate.isOn;
-                    ssched.manualPriorityActive = false;  
+                    ssched.manualPriorityActive = false;
                 }
             }
             // Our schedule has expired it is time to turn it off, but only if !manualPriorityActive.
@@ -235,86 +396,6 @@ export class NixieSchedule extends NixieEquipment {
             }
             ssched.emitEquipmentChange();
         } catch (err) { logger.error(`Error processing schedule: ${err.message}`); }
-
     }
-    protected calcTime(dt: Timestamp, type: number, offset: number): Timestamp {
-        let tt = sys.board.valueMaps.scheduleTimeTypes.transform(type);
-        switch (tt.name) {
-            case 'sunrise':
-                return new Timestamp(state.heliotrope.sunrise);
-            case 'sunset':
-                return new Timestamp(state.heliotrope.sunset);
-            default:
-                return dt.startOfDay().addMinutes(offset);
-        }
-    }
-    protected shouldBeOn(): boolean {
-        if (this.schedule.isActive === false) return false;
-        if (this.schedule.disabled) return false;
-        // Be careful with toDate since this returns a mutable date object from the state timestamp.  startOfDay makes it immutable.
-        let sod = state.time.startOfDay()
-        let dow = sod.toDate().getDay();
-        let type = sys.board.valueMaps.scheduleTypes.transform(this.schedule.scheduleType);
-        if (type.name === 'runonce') {
-            // If we are not matching up with the day then we shouldn't be running.
-            if (sod.fullYear !== this.schedule.startYear || sod.month + 1 !== this.schedule.startMonth || sod.date !== this.schedule.startDay) return false;
-        }
-        else {
-            // Convert the dow to the bit value.
-            let sd = sys.board.valueMaps.scheduleDays.toArray().find(elem => elem.dow === dow);
-            let dayVal = sd.bitVal || sd.val;  // The bitval allows mask overrides.
-            // First check to see if today is one of our days.
-            if ((this.schedule.scheduleDays & dayVal) === 0) return false;
-        }
-        // Next normalize our start and end times.  Fortunately, the start and end times are normalized here so that
-        // [0, {name: 'manual', desc: 'Manual }]
-        // [1, { name: 'sunrise', desc: 'Sunrise' }],
-        // [2, { name: 'sunset', desc: 'Sunset' }]
-        let tmStart = this.calcTime(sod, this.schedule.startTimeType, this.schedule.startTime).getTime();
-        let tmEnd = this.calcTime(sod, this.schedule.endTimeType, this.schedule.endTime).getTime();
-
-        if (isNaN(tmStart)) return false;
-        if (isNaN(tmEnd)) return false;
-        // If we are past our window we should be off.
-        let tm = state.time.getTime();
-        if (tm >= tmEnd) return false;
-        if (tm <= tmStart) return false;
-
-        // Let's now check to see 
-
-        // If we make it here we should be on.
-        return true;
-    }
-    
-
-    public async closeAsync() {
-        try {
-            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
-            this._pollTimer = null;
-        }
-        catch (err) { logger.error(`Nixie Schedule closeAsync: ${err.message}`); return Promise.reject(err); }
-    }
-    public logData(filename: string, data: any) { this.controlPanel.logData(filename, data); }
+    */
 }
-class NixieScheduleContext {
-    constructor() {
-
-    }
-    public circuits: { id: number, isOn: boolean }[] = [];
-    public heatModes: { id: number, heatMode: number, heatSetpoint?: number, coolSetpoint?: number }[] = [];
-    public setCircuit(id: number, isOn: boolean) {
-        let c = this.circuits.find(elem => elem.id === id);
-        if (typeof c === 'undefined') this.circuits.push({ id: id, isOn: isOn });
-        else c.isOn = isOn;
-    }
-    public setHeatMode(id: number, heatMode: string, heatSetpoint?: number, coolSetpoint?: number) {
-        let mode = sys.board.valueMaps.heatModes.transformByName(heatMode);
-        let hm = this.heatModes.find(elem => elem.id == id);
-        if (typeof hm === 'undefined') this.heatModes.push({ id: id, heatMode: mode.val, heatSetpoint: heatSetpoint, coolSetpoint: coolSetpoint });
-        else {
-            hm.heatMode = mode.val;
-            if (typeof heatSetpoint !== 'undefined') hm.heatSetpoint = heatSetpoint;
-            if (typeof coolSetpoint !== 'undefined') hm.coolSetpoint = coolSetpoint;
-        }
-    }
-}

package/defaultConfig.json

@@ -164,7 +164,7 @@
           "username": "",
           "password": "",
           "selfSignedCertificate": false,
-          "rootTopic": "@bind=(state.equipment.model).replace(' ','-').replace('/','').toLowerCase();",
+          "rootTopic": "@bind=(state.equipment.model).replace(/ /g,'-').replace('/','').toLowerCase();",
           "retain": true,
           "qos": 0,
           "changesOnly": true
@@ -204,7 +204,7 @@
           "port": 1883,
           "username": "",
           "password": "",
-          "rootTopic": "@bind=(state.equipment.model).replace(' ','-').replace('/','').toLowerCase();Alt",
+          "rootTopic": "@bind=(state.equipment.model).replace(/ /,'-').replace('/','').toLowerCase();Alt",
           "retain": true,
           "qos": 0,
           "changesOnly": true
@@ -230,7 +230,7 @@
         "vars": {
           "_note": "hassTopic is the topic that HASS reads for configuration and should not be changed.  mqttTopic should match the topic in the MQTT binding (do not use MQTTAlt for HASS).",
           "hassTopic": "homeassistant",
-          "mqttTopic": "@bind=(state.equipment.model).replace(' ','-').replace('/','').toLowerCase();"
+          "mqttTopic": "@bind=(state.equipment.model).replace(/ /g,'-').replace('/','').toLowerCase();"
         }
       },
       "rem": {

package/logger/DataLogger.ts

@@ -35,7 +35,7 @@ export class DataLogger {
                 } catch (err) { logger.error(`Skipping invalid dose history entry: ${err.message}`); }
             }
             return arr;
-        } catch (err) { logger.error(err); }
+        } catch (err) { logger.error(`Skipping dose history ${err.message}`); }
     }
     // This method uses a callback to end the file read from the end of the file.  If the callback returns false then the iteration through the
     // file will end and the log entries will be returned.  If the callback returns true then the entry will be added to the
@@ -103,11 +103,11 @@ export class DataLogger {
                     }
                     catch (err) { return Promise.reject(err); }
                     finally { if (typeof file !== 'undefined') await new Promise<boolean>((resolve, reject) => fs.close(file, (err) => { if (err) reject(err); else resolve(true); })); }
-                } catch (err) { logger.error(err); }
+                } catch (err) { logger.error(`readFromEndAsync: ${err.message}`); }
             }
             return arr;
         }
-        catch (err) { logger.error(err); }
+        catch (err) { logger.error(`readFromEndAsync: ${logFile} ${err.message}`); }
 
     }
     // This method uses a callback to end the file read from the end of the file.  If the callback returns false then the iteration through the
@@ -235,11 +235,11 @@ export class DataLogger {
                     }
                     catch (err) { return Promise.reject(err); }
                     finally { if (typeof file !== 'undefined') await new Promise<boolean>((resolve, reject) => fs.close(file, (err) => { if (err) reject(err); else resolve(true); })); }
-                } catch (err) { logger.error(err); }
+                } catch (err) { logger.error(`readFromStart: ${err.message}`); }
             }
             return arr;
         }
-        catch (err) { logger.error(err); }
+        catch (err) { logger.error(`readFromStart ${logFile}: ${err.message}`); }
 
     }
 
@@ -316,7 +316,7 @@ export class DataLogger {
             else
                 lines.unshift(data.toString());
             fs.writeFileSync(logPath, lines.join('\n'));
-        } catch (err) { logger.error(err); }
+        } catch (err) { logger.error(`writeStart ${logFile}: ${err.message}`); }
     }
     public static writeEnd(logFile: string, entry: DataLoggerEntry) {
         try {
@@ -384,7 +384,7 @@ export class DataLogger {
                 finally { if (typeof file !== 'undefined') await new Promise<boolean>((resolve, reject) => fs.close(file, (err) => { if (err) reject(err); else resolve(true); })); }
             }
             return lines;
-        } catch (err) { logger.error(err); }
+        } catch (err) { logger.error(`readEnd ${logFile}: ${err.message}`); }
     }
     private static makeLogFilePath(logFile: string) { return `${DataLogger.ensureLogPath()}/${logFile}`; }
     private static ensureLogPath(): string {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nodejs-poolcontroller",
-    "version": "8.0.1",
+    "version": "8.0.2",
     "description": "nodejs-poolController",
     "main": "app.js",
     "author": {
@@ -33,7 +33,7 @@
         "multicast-dns": "^7.2.4",
         "node-screenlogic": "^2.0.0",
         "node-ssdp": "^4.0.1",
-        "serialport": "^10.4.0",
+        "serialport": "^11.0.0",
         "socket.io": "^4.5.0",
         "socket.io-client": "^4.5.0",
         "source-map-support": "^0.5.21",

package/sendSocket.js

@@ -0,0 +1,32 @@
+// Import Socket.IO client
+const io = require('socket.io-client');
+
+// Connect to the server
+const socket = io('http://localhost:4200');
+
+// Event handler for successful connection
+socket.on('connect', () => {
+    console.log('Connected to server.');
+
+    // Emit data to the server
+    socket.emit('message', 'Hello, server!');
+    socket.emit('echo', `testing 123`);
+    socket.on('echo', (string)=>{
+      console.log(string);
+    })
+    //const hexData = "02 10 01 01 14 00 03 10 02 10 01 01 14 00 03 10 02 10 01 01 14 00 03 10 02 10 02 01 80 20 00 00 00 00 00 00 b5 00 03 10 02 10 03 01 20 20 6f 50 6c 6f 54 20 6d 65 20 70 37 20 5f 34 20 46 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 07 00 10 d6 10 03 01 02 00 01 10 14 10 03 01 02 00 01 10 14 10 03 01 02 00 01 10 14";
+    const hexData = "10 02 01 80 20 00 00 00 00 00 00 b5 00 03 10 02 10 03";
+    const formattedHexData = hexData.split(' ').map(hex => parseInt(hex, 16));
+    //socket.emit('rawbytes', Buffer.from([1, 2, 3]));
+    socket.emit('rawbytes', formattedHexData);
+});
+
+// Event handler for receiving data from the server
+socket.on('message', (data) => {
+    console.log('Received from server:', data);
+});
+
+// Event handler for disconnection
+socket.on('disconnect', () => {
+    console.log('Disconnected from server.');
+});

package/web/Server.ts

@@ -681,6 +681,10 @@ export class HttpServer extends ProtoServer {
                 logger.error(`Error replaying packet: ${err.message}`);
             }
         });
+        sock.on('rawbytes', (data:any)=>{
+            let port = conn.findPortById(0);
+            port.pushIn(Buffer.from(data));
+        })
         sock.on('sendLogMessages', function (sendMessages: boolean) {
             console.log(`sendLogMessages set to ${sendMessages}`);
             if (!sendMessages) sock.leave('msgLogger');
@@ -1636,7 +1640,7 @@ export class REMInterfaceServer extends ProtoServer {
             }
             return (response.status.code === 200) ? JSON.parse(response.data) : [];
         }
-        catch (err) { logger.error(err); }
+        catch (err) { logger.error(`getDevices: ${err.message}`); }
     }
 }
 export class BackupFile {
@@ -1719,16 +1723,18 @@ export class RestoreFile {
                 this.njsPC.poolConfig = await this.extractFile(zip, 'njsPC/data/poolConfig.json');
                 this.njsPC.poolState = await this.extractFile(zip, 'njsPC/data/poolState.json');
             }
-            for (let i = 0; i < this.options.servers.length; i++) {
-                // Extract each server from the file.
-                let srv = this.options.servers[i];
-                if (srv.backup && srv.success) {
-                    this.servers.push({
-                        name: srv.name,
-                        uuid: srv.uuid,
-                        serverConfig: await this.extractFile(zip, `${srv.name}/serverConfig.json`),
-                        controllerConfig: await this.extractFile(zip, `${srv.name}/data/controllerConfig.json`)
-                    });
+            if (typeof this.options.servers !== 'undefined') {
+                for (let i = 0; i < this.options.servers.length; i++) {
+                    // Extract each server from the file.
+                    let srv = this.options.servers[i];
+                    if (srv.backup && srv.success) {
+                        this.servers.push({
+                            name: srv.name,
+                            uuid: srv.uuid,
+                            serverConfig: await this.extractFile(zip, `${srv.name}/serverConfig.json`),
+                            controllerConfig: await this.extractFile(zip, `${srv.name}/data/controllerConfig.json`)
+                        });
+                    }
                 }
             }
         } catch(err) { this.errors.push(err); logger.error(`Error extracting restore options from ${file}: ${err.message}`); }

package/web/bindings/homeassistant.json

@@ -34,7 +34,7 @@
         }
       ],
       "rootTopic-DIRECTIONS": "rootTopic in config.json is ingored. Instead set the two topic variables in the vars section",
-      "_rootTopic": "@bind=(state.equipment.model).replace(' ','-').replace(' / ','').toLowerCase();",
+      "_rootTopic": "@bind=(state.equipment.model).replace(/ /g,'-').replace(' / ','').toLowerCase();",
       "clientId": "@bind=`hass_njsPC_${webApp.mac().replace(/:/g, '_'}-${webApp.httpPort()}`;"
     }
   },
@@ -434,4 +434,4 @@
       ]
     }
   ]
-}
+}