nodejs-poolcontroller 7.5.1 → 7.6.0

package/controller/comms/messages/config/ExternalMessage.ts

@@ -773,7 +773,7 @@ export class ExternalMessage {
                 break;
             case 21: // Body 2 Cool Setpoint
                 body = sys.bodies.getItemById(2, false);
-                body.setPoint = msg.extractPayloadByte(24);
+                body.coolSetpoint = msg.extractPayloadByte(24);
                 state.temps.bodies.getItemById(2).coolSetpoint = body.coolSetpoint;
                 state.emitEquipmentChanges();
                 msg.isProcessed = true;

package/controller/comms/messages/config/ValveMessage.ts

@@ -174,7 +174,7 @@ export class ValveMessage {
         // for i10d.
         let ndx: number = 2;
         let id = 1;
-        for (let i = 0; i < sys.equipment.maxValves - 1; i++) {
+        for (let i = 0; i < sys.equipment.maxValves; i++) {
             if (id === 3 && !sys.equipment.shared) {
                 // The intake/return valves are skipped for non-shared systems.
                 sys.valves.removeItemById(3);

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

@@ -22,15 +22,20 @@ export class HeaterStateMessage {
     public static process(msg: Inbound) {
         if (msg.protocol === Protocol.Heater) {
             switch (msg.action) {
-                case 114: // This is a message from a master controlling the heater
+                case 112: // This is a message from a master controlling MasterTemp
+                case 114: // This is a message from a master controlling UltraTemp
+                    msg.isProcessed = true;
+                    break;
+                case 116:
+                    HeaterStateMessage.processMasterTempStatus(msg);
                     break;
                 case 115:
-                    HeaterStateMessage.processHeaterStatus(msg);
+                    HeaterStateMessage.processUltraTempStatus(msg);
                     break;
             }
         }
     }
-    public static processHeaterStatus(msg: Inbound) {
+    public static processUltraTempStatus(msg: Inbound) {
         // RKS: 07-03-21 - We only know byte 2 at this point for Ultratemp for the 115 message we are processing here.  The 
         // byte  description
         // ------------------------------------------------
@@ -60,4 +65,23 @@ export class HeaterStateMessage {
         state.equipment.messages.removeItemByCode(`heater:${heater.id}:comms`);
         msg.isProcessed = true;
     }
+    public static processMasterTempStatus(msg: Inbound) {
+        //[255, 0, 255][165, 0, 16, 112, 116, 23][67, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 10, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0][2, 66]
+        // Byte 1 is the indicator to which setpoint it is heating to.
+        // Byte 8 increments over time when the heater is on.
+        // Byte 13 looks like the mode the heater is in for instance it is in cooldown mode.
+        //  0 = Normal
+        //  2 = ??????
+        //  6 = Cooldown
+        // Byte 14 looks like the cooldown delay in minutes.
+        let heater: Heater = sys.heaters.getItemByAddress(msg.source);
+        let sheater = state.heaters.getItemById(heater.id);
+        let byte = msg.extractPayloadByte(1);
+        sheater.isOn = byte >= 1;
+        sheater.isCooling = false;
+        sheater.commStatus = 0;
+        state.equipment.messages.removeItemByCode(`heater:${heater.id}:comms`);
+        msg.isProcessed = true;
+    }
+
 }

package/controller/nixie/bodies/Body.ts

@@ -64,6 +64,9 @@ export class NixieBody extends NixieEquipment {
         super(ncp);
         this.body = body;
         this.pollEquipmentAsync();
+        let bs = state.temps.bodies.getItemById(body.id);
+        bs.heaterCooldownDelay = false;
+        bs.heatStatus = 0;
     }
     public get id(): number { return typeof this.body !== 'undefined' ? this.body.id : -1; }
     public async setBodyAsync(data: any) {

package/controller/nixie/circuits/Circuit.ts

@@ -60,7 +60,7 @@ export class NixieCircuitCollection extends NixieEquipmentCollection<NixieCircui
      try {
         let c: NixieCircuit = this.find(elem => elem.id === cstate.id) as NixieCircuit;
         await c.checkCircuitEggTimerExpirationAsync(cstate);
-    } catch (err) { logger.error(`NCP: Error syncing circuit states: ${err}`); }
+    } catch (err) { logger.error(`NCP: Error synching circuit states: ${err}`); }
     }
     public async initAsync(circuits: CircuitCollection) {
         try {
@@ -118,6 +118,10 @@ export class NixieCircuit extends NixieEquipment {
     constructor(ncp: INixieControlPanel, circuit: Circuit) {
         super(ncp);
         this.circuit = circuit;
+        // Clear out the delays.
+        let cstate = state.circuits.getItemById(circuit.id);
+        cstate.startDelay = false;
+        cstate.stopDelay = false;
     }
     public get id(): number { return typeof this.circuit !== 'undefined' ? this.circuit.id : -1; }
     public get eggTimerOff(): Timestamp { return typeof this.timeOn !== 'undefined' && !this.circuit.dontStop ? this.timeOn.clone().addMinutes(this.circuit.eggTimer) : undefined; }
@@ -157,7 +161,15 @@ export class NixieCircuit extends NixieEquipment {
         } catch (err) { logger.error(`Nixie: Error sending circuit sequence ${this.id}: ${count}`); }
         finally { this._sequencing = false; }
     }
-    public async setCircuitStateAsync(cstate: ICircuitState, val: boolean, scheduled: boolean = false) : Promise<InterfaceServerResponse> {
+    public async setThemeAsync(cstate: ICircuitState, theme: number): Promise<InterfaceServerResponse> {
+        try {
+            
+
+
+            return new InterfaceServerResponse(200, 'Sucess');
+        } catch (err) { logger.error(`Nixie: Error setting light theme ${cstate.id}-${cstate.name} to ${theme}`); }
+    }
+    public async setCircuitStateAsync(cstate: ICircuitState, val: boolean, scheduled: boolean = false): Promise<InterfaceServerResponse> {
         try {
             if (val !== cstate.isOn) {
                 logger.info(`NCP: Setting Circuit ${cstate.name} to ${val}`);
@@ -177,10 +189,10 @@ export class NixieCircuit extends NixieEquipment {
             let res = await NixieEquipment.putDeviceService(this.circuit.connectionId, `/state/device/${this.circuit.deviceBinding}`, { isOn: val, latch: val ? 10000 : undefined });
             if (res.status.code === 200) {
                 sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(cstate.id), cstate, val);
-                cstate.isOn = val;
                 // Set this up so we can process our egg timer.
-                if (!cstate.isOn && val) { this.timeOn = new Timestamp(); }
-                else if (!val) this.timeOn = undefined;
+                //if (!cstate.isOn && val) { cstate.startTime = this.timeOn = new Timestamp(); }
+                //else if (!val) cstate.startTime = this.timeOn = undefined;
+                cstate.isOn = val;
             }
             return res;
         } catch (err) { logger.error(`Nixie: Error setting circuit state ${cstate.id}-${cstate.name} to ${val}`); }
@@ -190,9 +202,11 @@ export class NixieCircuit extends NixieEquipment {
         // (this should already be turned off) or the egg timer has expired
         try {
             if (!cstate.isActive || !cstate.isOn) return;
-            if (cstate.endTime.toDate() < new Timestamp().toDate()) {
-                await sys.board.circuits.setCircuitStateAsync(cstate.id, false);
-                cstate.emitEquipmentChange();
+            if (typeof cstate.endTime !== 'undefined') {
+                if (cstate.endTime.toDate() < new Timestamp().toDate()) {
+                    await sys.board.circuits.setCircuitStateAsync(cstate.id, false);
+                    cstate.emitEquipmentChange();
+                }
             }
         } catch (err) { logger.error(`Error syncing circuit: ${err}`); }
     }
@@ -220,6 +234,8 @@ export class NixieCircuit extends NixieEquipment {
     public async closeAsync() {
         try {
             let cstate = state.circuits.getItemById(this.circuit.id);
+            cstate.stopDelay = false;
+            cstate.startDelay = false;
             await this.setCircuitStateAsync(cstate, false);
             cstate.emitEquipmentChange();
         }

package/controller/nixie/heaters/Heater.ts

@@ -4,12 +4,13 @@ import { logger } from '../../../logger/Logger';
 
 import { NixieEquipment, NixieChildEquipment, NixieEquipmentCollection, INixieControlPanel } from "../NixieEquipment";
 import { Heater, HeaterCollection, sys } from "../../../controller/Equipment";
-import { HeaterState, state, } from "../../State";
+import { BodyTempState, HeaterState, state, } from "../../State";
 import { setTimeout, clearTimeout } from 'timers';
 import { NixieControlPanel } from '../Nixie';
 import { webApp, InterfaceServerResponse } from "../../../web/Server";
 import { conn } from '../../../controller/comms/Comms';
 import { Outbound, Protocol, Response } from '../../../controller/comms/messages/Messages';
+import { delayMgr } from '../../Lockouts';
 
 export class NixieHeaterCollection extends NixieEquipmentCollection<NixieHeaterBase> {
     public async deleteHeaterAsync(id: number) {
@@ -96,6 +97,8 @@ export class NixieHeaterBase extends NixieEquipment {
     protected bodyOnTime: number;
     protected isOn: boolean = false;
     protected isCooling: boolean = false;
+    protected lastHeatCycle: Date;
+    protected lastCoolCycle: Date;
     constructor(ncp: INixieControlPanel, heater: Heater) {
         super(ncp);
         this.heater = heater;
@@ -103,6 +106,7 @@ export class NixieHeaterBase extends NixieEquipment {
     public get suspendPolling(): boolean { return this._suspendPolling > 0; }
     public set suspendPolling(val: boolean) { this._suspendPolling = Math.max(0, this._suspendPolling + (val ? 1 : -1)); }
     public get id(): number { return typeof this.heater !== 'undefined' ? this.heater.id : -1; }
+    public getCooldownTime() { return 0; }
     public static create(ncp: INixieControlPanel, heater: Heater): NixieHeaterBase {
         let type = sys.board.valueMaps.heaterTypes.transform(heater.type);
         switch (type.name) {
@@ -144,34 +148,50 @@ export class NixieHeaterBase extends NixieEquipment {
 }
 export class NixieGasHeater extends NixieHeaterBase {
     public pollingInterval: number = 10000;
-    declare heater: Heater;
+    //declare heater: Heater;
     constructor(ncp: INixieControlPanel, heater: Heater) {
         super(ncp, heater);
         this.heater = heater;
         this.pollEquipmentAsync();
     }
     public get id(): number { return typeof this.heater !== 'undefined' ? this.heater.id : -1; }
+    public getCooldownTime(): number {
+        // Delays are always in terms of seconds so convert the minute to seconds.
+        if (this.heater.cooldownDelay === 0 || typeof this.lastHeatCycle === 'undefined') return 0;
+        let now = new Date().getTime();
+        let cooldown = this.isOn ? this.heater.cooldownDelay * 60000 : Math.round( ((this.lastHeatCycle.getDate() + this.heater.cooldownDelay * 60000) - now) / 1000);
+        return Math.min(Math.max(0, cooldown), this.heater.cooldownDelay * 60);
+    }
     public async setHeaterStateAsync(hstate: HeaterState, isOn: boolean) {
         try {
             // Initialize the desired state.
             this.isOn = isOn;
             this.isCooling = false;
+            let target = hstate.startupDelay === false && isOn;
+            if (target && typeof hstate.endTime !== 'undefined') {
+                // Calculate a short cycle time so that the solar heater does not cycle
+                // too often.  For gas heaters this is 60 seconds.  This gives enough time
+                // for the heater control circuit to make a full cycle.
+                if (new Date().getTime() - hstate.endTime.getTime() < 60000) {
+                    logger.verbose(`${hstate.name} short cycle detected deferring turn on state`);
+                    target = false;
+                }
+            }
             // Here we go we need to set the firemans switch state.
-            if (hstate.isOn !== isOn) {
+            if (hstate.isOn !== target) {
                 logger.info(`Nixie: Set Heater ${hstate.id}-${hstate.name} to ${isOn}`);
             }
-            if (utils.isNullOrEmpty(this.heater.connectionId) || utils.isNullOrEmpty(this.heater.deviceBinding)) {
-                hstate.isOn = isOn;
-                return;
-            }
-            if (typeof this._lastState === 'undefined' || isOn || this._lastState !== isOn) {
-                let res = await NixieEquipment.putDeviceService(this.heater.connectionId, `/state/device/${this.heater.deviceBinding}`, { isOn: isOn, latch: isOn ? 10000 : undefined });
-                if (res.status.code === 200) this._lastState = hstate.isOn = isOn;
-                else logger.error(`Nixie Error setting heater state: ${res.status.code} -${res.status.message} ${res.error.message}`);
-            }
-            else {
-                hstate.isOn = isOn;
-                return;
+            if (typeof this._lastState === 'undefined' || target || this._lastState !== target) {
+                if (utils.isNullOrEmpty(this.heater.connectionId) || utils.isNullOrEmpty(this.heater.deviceBinding)) {
+                    this._lastState = hstate.isOn = target;
+                }
+                else {
+                    let res = await NixieEquipment.putDeviceService(this.heater.connectionId, `/state/device/${this.heater.deviceBinding}`,
+                        { isOn: target, latch: target ? 10000 : undefined });
+                    if (res.status.code === 200) this._lastState = hstate.isOn = target;
+                    else logger.error(`Nixie Error setting heater state: ${res.status.code} -${res.status.message} ${res.error.message}`);
+                }
+                if (target) this.lastHeatCycle = new Date();
             }
         } catch (err) { return logger.error(`Nixie Error setting heater state ${hstate.id}-${hstate.name}: ${err.message}`); }
     }
@@ -228,25 +248,59 @@ export class NixieSolarHeater extends NixieHeaterBase {
     public get id(): number { return typeof this.heater !== 'undefined' ? this.heater.id : -1; }
     public async setHeaterStateAsync(hstate: HeaterState, isOn: boolean, isCooling: boolean) {
         try {
+            let origState = hstate.isOn;
             // Initialize the desired state.
             this.isOn = isOn;
             this.isCooling = isCooling;
-            // Here we go we need to set the firemans switch state.
-            if (hstate.isOn !== isOn) {
-                logger.info(`Nixie: Set Heater ${hstate.id}-${hstate.name} to ${isOn}`);
+            let target = hstate.startupDelay === false && isOn;
+            if (target && typeof hstate.endTime !== 'undefined') {
+                // Calculate a short cycle time so that the solar heater does not cycle
+                // too often.  For solar heaters this is 60 seconds.  This gives enough time
+                // for the valve to rotate and start heating.  If the solar and water sensors are
+                // not having issues this should be plenty of time.
+                if (new Date().getTime() - hstate.endTime.getTime() < 60000) {
+                    logger.verbose(`${hstate.name} short cycle detected deferring turn on state`);
+                    target = false;
+                }
             }
-            if (utils.isNullOrEmpty(this.heater.connectionId) || utils.isNullOrEmpty(this.heater.deviceBinding)) {
-                hstate.isOn = isOn;
-                return;
+
+            // Here we go we need to set the valve status that is attached to solar.
+            if (hstate.isOn !== target) {
+                logger.info(`Nixie: Set Heater ${hstate.id}-${hstate.name} to ${isOn}`);
             }
-            if (typeof this._lastState === 'undefined' || isOn || this._lastState !== isOn) {
-                let res = await NixieEquipment.putDeviceService(this.heater.connectionId, `/state/device/${this.heater.deviceBinding}`, { isOn: isOn, latch: isOn ? 10000 : undefined });
-                if (res.status.code === 200) this._lastState = hstate.isOn = isOn;
-                else logger.error(`Nixie Error setting heater state: ${res.status.code} -${res.status.message} ${res.error.message}`);
+            if (typeof this._lastState === 'undefined' || target || this._lastState !== target) {
+                if (utils.isNullOrEmpty(this.heater.connectionId) || utils.isNullOrEmpty(this.heater.deviceBinding)) {
+                    this._lastState = hstate.isOn = target;
+                }
+                else {
+                    let res = await NixieEquipment.putDeviceService(this.heater.connectionId, `/state/device/${this.heater.deviceBinding}`,
+                        { isOn: target, latch: target ? 10000 : undefined });
+                    if (res.status.code === 200) this._lastState = hstate.isOn = target;
+                    else logger.error(`Nixie Error setting heater state: ${res.status.code} -${res.status.message} ${res.error.message}`);
+                }
+                if (target) {
+                    if (isCooling) this.lastCoolCycle = new Date();
+                    else if (isOn) this.lastHeatCycle = new Date();
+                }
             }
-            else {
-                hstate.isOn = isOn;
-                return;
+            // In this instance we need to see if there are cleaner circuits that we need to turn off
+            // then delay for the current body because the solar just came on.
+            if (hstate.isOn && sys.general.options.cleanerSolarDelay && !origState) {
+                let arrTypes = sys.board.valueMaps.circuitFunctions.toArray().filter(x => { return x.name.indexOf('cleaner') !== -1 && x.body === hstate.bodyId });
+                let cleaners = sys.circuits.filter(x => { return arrTypes.findIndex(t => { return t.val === x.type }) !== -1 });
+                // Turn off all the cleaner circuits and set an on delay if they are on.
+                for (let i = 0; i < cleaners.length; i++) {
+                    let cleaner = cleaners.getItemByIndex(i);
+                    if (cleaner.isActive) {
+                        let cstate = state.circuits.getItemById(cleaner.id);
+                        if (cstate.isOn && sys.general.options.cleanerSolarDelayTime > 0) {
+                            // Turn off the circuit then set a delay.
+                            logger.info(`Setting cleaner solar delay for ${cleaner.name} to ${sys.general.options.cleanerSolarDelayTime}`);
+                            await sys.board.circuits.setCircuitStateAsync(cstate.id, false);
+                            delayMgr.setCleanerStartDelay(cstate, hstate.bodyId, sys.general.options.cleanerSolarDelayTime);
+                        }
+                    }
+                }
             }
         } catch (err) { return logger.error(`Nixie Error setting heater state ${hstate.id}-${hstate.name}: ${err.message}`); }
     }
@@ -304,6 +358,11 @@ export class NixieHeatpump extends NixieHeaterBase {
             this.suspendPolling = true;
             this.isOn = isOn;
             this.isCooling = isCooling;
+            if (!hstate.startupDelay) {
+                if (isOn && !isCooling) this.lastHeatCycle = new Date();
+                else if (isCooling) this.lastCoolCycle = new Date();
+            }
+            // When this is implemented lets not forget to deal with the startup delay.  See UltraTemp for implementation.
         } catch (err) { return logger.error(`Nixie Error setting heater state ${hstate.id}-${hstate.name}: ${err.message}`); }
         finally { this.suspendPolling = false; }
     }
@@ -420,7 +479,16 @@ export class NixieUltratemp extends NixieHeatpump {
                 });
                 out.appendPayloadBytes(0, 10);
                 out.setPayloadByte(0, 144);
-                out.setPayloadByte(1, this.isOn ? (this.isCooling ? 2 : 1) : 0, 0);
+                // If we are in startup delay simply tell the heater that it is off.
+                if (sheater.startupDelay)
+                    out.setPayloadByte(1, 0, 0);
+                else {
+                    if (this.isOn) {
+                        if (!this.isCooling) this.lastHeatCycle = new Date();
+                        else this.lastCoolCycle = new Date();
+                    }
+                    out.setPayloadByte(1, this.isOn ? (this.isCooling ? 2 : 1) : 0, 0);
+                }
                 conn.queueSendMessage(out);
             });
             return success;
@@ -433,9 +501,101 @@ export class NixieUltratemp extends NixieHeatpump {
             if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
             this._pollTimer = null;
             logger.info(`Closing Heater ${this.heater.name}`);
-
         }
         catch (err) { logger.error(`Ultratemp closeAsync: ${err.message}`); return Promise.reject(err); }
     }
 }
-export class NixieMastertemp extends NixieGasHeater {}
+export class NixieMastertemp extends NixieGasHeater {
+    constructor(ncp: INixieControlPanel, heater: Heater) {
+        super(ncp, heater);
+        // Set the polling interval to 3 seconds.
+        this.pollEquipmentAsync();
+        this.pollingInterval = 3000;
+    }
+    public getCooldownTime(): number {
+        // Delays are always in terms of seconds so convert the minute to seconds.
+        if (this.heater.cooldownDelay === 0 || typeof this.lastHeatCycle === 'undefined') return 0;
+        let now = new Date().getTime();
+        let cooldown = this.isOn ? this.heater.cooldownDelay * 60000 : Math.round(((this.lastHeatCycle.getDate() + this.heater.cooldownDelay * 60000) - now) / 1000);
+        return Math.min(Math.max(0, cooldown), this.heater.cooldownDelay * 60);
+    }
+    public async setHeaterStateAsync(hstate: HeaterState, isOn: boolean) {
+        try {
+            // Initialize the desired state.
+            this.isOn = isOn;
+            this.isCooling = false;
+            // Here we go we need to set the firemans switch state.
+            if (hstate.isOn !== isOn) {
+                logger.info(`Nixie: Set Heater ${hstate.id}-${hstate.name} to ${isOn}`);
+            }
+            if (isOn && !hstate.startupDelay) this.lastHeatCycle = new Date();
+            hstate.isOn = isOn;
+        } catch (err) { return logger.error(`Nixie Error setting heater state ${hstate.id}-${hstate.name}: ${err.message}`); }
+    }
+    public async pollEquipmentAsync() {
+        let self = this;
+        try {
+            this.suspendPolling = true;
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            if (this._suspendPolling > 1) return;
+            let sheater = state.heaters.getItemById(this.heater.id, !this.closing);
+            if (!this.closing) await this.setStatus(sheater);
+        }
+        catch (err) { logger.error(`Error polling MasterTemp heater - ${err}`); }
+        finally {
+            this.suspendPolling = false; if (!this.closing) this._pollTimer = setTimeout(async () => {
+                try { await self.pollEquipmentAsync() } catch (err) { }
+            }, this.pollingInterval || 3000);
+        }
+    }
+    public async setStatus(sheater: HeaterState): Promise<boolean> {
+        try {
+            let success = await new Promise<boolean>((resolve, reject) => {
+                let out = Outbound.create({
+                    protocol: Protocol.Heater,
+                    source: 16,
+                    dest: this.heater.address,
+                    action: 112,
+                    payload: [],
+                    retries: 3, // We are going to try 4 times.
+                    response: Response.create({ protocol: Protocol.Heater, action: 116 }),
+                    onAbort: () => { },
+                    onComplete: (err) => {
+                        if (err) {
+                            // If the MasterTemp is not responding we need to store that off but at this point we know none of the codes.  If a 115 does
+                            // come across this will be cleared by the processing of that message.
+                            sheater.commStatus = sys.board.valueMaps.equipmentCommStatus.getValue('commerr');
+                            state.equipment.messages.setMessageByCode(`heater:${sheater.id}:comms`, 'error', `Communication error with ${sheater.name}`);
+                            resolve(false);
+                        }
+                        else { resolve(true); }
+                    }
+                });
+                out.appendPayloadBytes(0, 11);
+                // If we have a startup delay we need to simply send 0 to the heater to make sure that it is off.
+                if (sheater.startupDelay)
+                    out.setPayloadByte(0, 0);
+                else {
+                    // The cooldown delay is a bit hard to figure out here since I think the heater does it on its own.
+                    out.setPayloadByte(0, sheater.bodyId <= 2 ? sheater.bodyId : 0);
+                }
+                out.setPayloadByte(1, sys.bodies.getItemById(1).heatSetpoint || 0);
+                out.setPayloadByte(2, sys.bodies.getItemById(2).heatSetpoint || 0);
+                conn.queueSendMessage(out);
+            });
+            return success;
+        } catch (err) { logger.error(`Communication error with MasterTemp : ${err.message}`); }
+    }
+    public async closeAsync() {
+        try {
+            this.suspendPolling = true;
+            this.closing = true;
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            logger.info(`Closing Heater ${this.heater.name}`);
+
+        }
+        catch (err) { logger.error(`MasterTemp closeAsync: ${err.message}`); return Promise.reject(err); }
+    }
+}