nodejs-poolcontroller 8.4.0 → 8.4.1

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

@@ -23,6 +23,20 @@ export class VersionMessage {
     // Debounce config refresh requests to avoid duplicate requests from overlapping triggers
     private static lastConfigRefreshTime: number = 0;
     private static readonly CONFIG_REFRESH_DEBOUNCE_MS = 2000;  // 2 seconds
+    private static pendingConfigRefreshTimer?: NodeJS.Timeout;
+    private static pendingConfigRefreshSource?: string;
+    private static scheduleConfigRefresh(delayMs: number, source: string, reason: string): void {
+        this.pendingConfigRefreshSource = source;
+        if (!this.pendingConfigRefreshTimer) {
+            this.pendingConfigRefreshTimer = setTimeout(() => {
+                this.pendingConfigRefreshTimer = undefined;
+                const src = this.pendingConfigRefreshSource ? `${this.pendingConfigRefreshSource} (trailing)` : 'Trailing';
+                this.pendingConfigRefreshSource = undefined;
+                this.triggerConfigRefresh(src);
+            }, delayMs);
+        }
+        logger.silly(`v3.004+ ${source}: Deferring config refresh (${reason}, retry in ${delayMs}ms)`);
+    }
 
     /**
      * Shared method to trigger a config refresh with debouncing.
@@ -30,21 +44,43 @@ export class VersionMessage {
      */
     private static triggerConfigRefresh(source: string): void {
         const now = Date.now();
-        if (now - this.lastConfigRefreshTime < this.CONFIG_REFRESH_DEBOUNCE_MS) {
-            logger.silly(`v3.004+ ${source}: Skipping config refresh (debounced, last was ${now - this.lastConfigRefreshTime}ms ago)`);
+        const elapsed = now - this.lastConfigRefreshTime;
+        if (elapsed < this.CONFIG_REFRESH_DEBOUNCE_MS) {
+            // Throttle-with-trailing: don't lose rapid toggle updates; schedule one refresh at end of window.
+            const remainingMs = Math.max(0, this.CONFIG_REFRESH_DEBOUNCE_MS - elapsed);
+            this.scheduleConfigRefresh(remainingMs, source, `debounced (last send ${elapsed}ms ago)`);
             return;
         }
-        this.lastConfigRefreshTime = now;
-
         (sys.board as any).needsConfigChanges = true;
         // Invalidate cached options version so queueChanges() will request category 0.
         // OCP doesn't increment options version when heat mode/setpoints change,
         // so we force a refresh by clearing our cached version.
         sys.configVersion.options = 0;
+        // v3.004+: OCP does NOT reliably increment systemState when features toggle (esp. rapid OFF/ON sequences).
+        // Force a systemState refresh so queueChanges() will request category 15 (systemState), option [0] => Action 222 [15,0].
+        sys.configVersion.systemState = 0;
+        // v3.004+: OCP does NOT increment pumps version when pump config changes via WCP (Action 168 type 4).
+        // Force a pumps refresh so queueChanges() will request category 4 (pumps).
+        sys.configVersion.pumps = 0;
+        // v3.x: personal-information updates (Action 168 type 12) are not always reflected by
+        // version deltas in the field; force a general refresh so category 12 is re-polled.
+        sys.configVersion.general = 0;
+
+        // If a config queue run is already active, coalesce this refresh and retry after a short delay.
+        // This avoids extra 228/164 churn in the middle of an in-flight loading pass.
+        if (typeof (sys.board as any).isConfigQueueProcessing === 'function' &&
+            (sys.board as any).isConfigQueueProcessing()) {
+            this.scheduleConfigRefresh(this.CONFIG_REFRESH_DEBOUNCE_MS, source, 'config queue already processing');
+            return;
+        }
+
+        this.lastConfigRefreshTime = now;
         logger.silly(`v3.004+ ${source}: Sending Action 228`);
         Outbound.create({
             dest: 16, action: 228, payload: [0], retries: 2,
-            response: Response.create({ action: 164 })
+            scope: 'v3RefreshTrigger',
+            // v3.004+: require 164 addressed to us (not to Wireless).
+            response: Response.create({ dest: Message.pluginAddress, action: 164 })
         }).sendAsync();
     }
 
@@ -62,21 +98,34 @@ export class VersionMessage {
     }
 
     /**
-     * v3.004+ ACK Trigger: When OCP ACKs a Wireless device's Action 168,
-     * trigger a config refresh. OCP doesn't send Action 228 after Wireless changes,
-     * so we must detect the ACK and request config ourselves.
-     * See AGENTS.md for protocol details.
+     * v3.004+ ACK Trigger (single entrypoint):
+     * When OCP ACKs a Wireless/other device's Action 168 or 184, trigger a debounced config refresh.
+     *
+     * Intended call-site: `Messages.ts` should gate on ACK payload[0] (168/184) and then call this method once.
      */
-    public static processAction168Ack(msg: Inbound): void {
-        // Only for v3.004+ when OCP (src=16) ACKs a non-njsPC device's 168
-        if (sys.equipment.isIntellicenterV3 &&
-            msg.source === 16 &&                          // From OCP
-            msg.dest !== Message.pluginAddress &&         // Not to us
-            msg.dest !== 16 &&                            // Not to OCP itself
-            msg.payload.length > 0 &&
-            msg.payload[0] === 168) {                     // ACKing Action 168
-            this.triggerConfigRefresh(`ACK Trigger (device ${msg.dest})`);
+    public static processActionAck(msg: Inbound): void {
+        // Gate: only v3.004+
+        if (!sys.equipment.isIntellicenterV3) {
+            msg.isProcessed = true;
+            return;
+        }
+        // Gate: only when ACK originates from OCP (src=16) to some other device (not us, not OCP).
+        if (msg.source !== 16 || msg.dest === Message.pluginAddress || msg.dest === 16) {
+            msg.isProcessed = true;
+            return;
+        }
+        // Gate: only ACKing Action 168 or 184 (caller should gate, but keep defensive checks here too).
+        const ackedAction = msg.payload.length > 0 ? msg.payload[0] : undefined;
+        if (ackedAction !== 168 && ackedAction !== 184) {
+            msg.isProcessed = true;
+            return;
         }
+
+        const label =
+            ackedAction === 168
+                ? `ACK(168) Trigger (device ${msg.dest})`
+                : `ACK(184) Trigger (device ${msg.dest})`;
+        this.triggerConfigRefresh(label);
         msg.isProcessed = true;
     }
 

package/controller/nixie/chemistry/ChemController.ts

@@ -1,4 +1,4 @@
-import { clearTimeout, setTimeout } from 'timers';
+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, ChemicalORP, ChemicalORPProbe, ChemicalPh, ChemicalPhProbe, ChemicalProbe, ChemicalPump, ChemicalTank, sys } from "../../../controller/Equipment";
@@ -234,14 +234,15 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
 
             let schem = state.chemControllers.getItemById(this.chem.id, !this.closing);
             schem.calculateSaturationIndex();
-            // If the body isn't on then we won't communicate with the chem controller.  There is no need
-            // since most of the time these are attached to the filter relay.
-            if (this.isBodyOn() && !this.closing) {
+            // By default IntelliChem tracks body relay state. When standalone is enabled,
+            // allow polling even if the body circuit is currently off.
+            let canCommunicate = this.isBodyOn() || this.chem.intellichemStandalone;
+            if (canCommunicate && !this.closing) {
                 if (!this.configSent) await this.sendConfig(schem);
                 if (!this.closing) await this.requestStatus(schem);
             }
         }
-        catch (err) { logger.error(`Error polling IntelliChem Controller - ${err}`); return Promise.reject(err); }
+        catch (err) { logger.error(`Error polling IntelliChem Controller - ${err}`); }
         finally { this.suspendPolling = false; if (!this.closing) this._pollTimer = setTimeout(() => { self.pollEquipmentAsync(); }, this.pollingInterval || 10000); }
     }
     public async setServiceModeAsync() {}
@@ -257,6 +258,7 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
             let cyanuricAcid = typeof data.cyanuricAcid !== 'undefined' ? parseInt(data.cyanuricAcid, 10) : chem.cyanuricAcid;
             let alkalinity = typeof data.alkalinity !== 'undefined' ? parseInt(data.alkalinity, 10) : chem.alkalinity;
             let borates = typeof data.borates !== 'undefined' ? parseInt(data.borates, 10) : chem.borates || 0;
+            let intellichemStandalone = typeof data.intellichemStandalone !== 'undefined' ? utils.makeBool(data.intellichemStandalone) : chem.intellichemStandalone;
             let body = sys.board.bodies.mapBodyAssociation(typeof data.body === 'undefined' ? chem.body : data.body);
             if (typeof body === 'undefined') return Promise.reject(new InvalidEquipmentDataError(`Invalid body assignment`, 'chemController', data.body || chem.body));
             // Do a final validation pass so we dont send this off in a mess.
@@ -309,6 +311,7 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
             chem.borates = borates;
             chem.body = schem.body = body;
             chem.type = schem.type = type.val;
+            chem.intellichemStandalone = intellichemStandalone;
 
             let acidTankLevel = typeof data.ph !== 'undefined' && typeof data.ph.tank !== 'undefined' && typeof data.ph.tank.level !== 'undefined' ? parseInt(data.ph.tank.level, 10) : schem.ph.tank.level;
             let orpTankLevel = typeof data.orp !== 'undefined' && typeof data.orp.tank !== 'undefined' && typeof data.orp.tank.level !== 'undefined' ? parseInt(data.orp.tank.level, 10) : schem.orp.tank.level;
@@ -320,6 +323,7 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
             chem.alkalinity = alkalinity;
             chem.borates = borates;
             chem.body = schem.body = body;
+            chem.intellichemStandalone = intellichemStandalone;
             schem.isActive = chem.isActive = true;
             chem.lsiRange.enabled = lsiRange.enabled;
             chem.lsiRange.low = lsiRange.low;
@@ -348,35 +352,39 @@ export class NixieIntelliChemController extends NixieChemControllerBase {
     }
     public async sendConfig(schem: ChemControllerState): Promise<boolean> {
         try {
-                this.configSent = false;
-                let out = Outbound.create({
-                    protocol: Protocol.IntelliChem,
-                    source: 16,
-                    dest: this.chem.address,
-                    action: 146,
-                    payload: [],
-                    retries: 3, // We are going to try 4 times.
-                    response: Response.create({ protocol: Protocol.IntelliChem, action: 1 }),
-                    onAbort: () => { }
-                });
-                out.insertPayloadBytes(0, 0, 21);
-                out.setPayloadByte(0, Math.floor((this.chem.ph.setpoint * 100) / 256) || 0);
-                out.setPayloadByte(1, Math.round((this.chem.ph.setpoint * 100) % 256) || 0);
-                out.setPayloadByte(2, Math.floor(this.chem.orp.setpoint / 256) || 0);
-                out.setPayloadByte(3, Math.round(this.chem.orp.setpoint % 256) || 0);
-                out.setPayloadByte(4, schem.ph.enabled ? schem.ph.tank.level + 1 : 0);
-                out.setPayloadByte(5, schem.orp.enabled ? schem.orp.tank.level + 1 : 0);
-                out.setPayloadByte(6, Math.floor(this.chem.calciumHardness / 256) || 0);
-                out.setPayloadByte(7, Math.round(this.chem.calciumHardness % 256) || 0);
-                out.setPayloadByte(9, this.chem.cyanuricAcid);
-                out.setPayloadByte(10, Math.floor(this.chem.alkalinity / 256) || 0);
-                out.setPayloadByte(12, Math.round(this.chem.alkalinity % 256) || 0);
-                logger.verbose(`Nixie: ${this.chem.name} sending IntelliChem settings action 146`);
-                out.sendAsync();
-                this.configSent = true;
-                return true;
+            this.configSent = false;
+            let out = Outbound.create({
+                protocol: Protocol.IntelliChem,
+                source: 16,
+                dest: this.chem.address,
+                action: 146,
+                payload: [],
+                retries: 3, // We are going to try 4 times.
+                response: Response.create({ protocol: Protocol.IntelliChem, action: 1 }),
+                onAbort: () => { }
+            });
+            out.insertPayloadBytes(0, 0, 21);
+            out.setPayloadByte(0, Math.floor((this.chem.ph.setpoint * 100) / 256) || 0);
+            out.setPayloadByte(1, Math.round((this.chem.ph.setpoint * 100) % 256) || 0);
+            out.setPayloadByte(2, Math.floor(this.chem.orp.setpoint / 256) || 0);
+            out.setPayloadByte(3, Math.round(this.chem.orp.setpoint % 256) || 0);
+            out.setPayloadByte(4, schem.ph.enabled ? schem.ph.tank.level + 1 : 0);
+            out.setPayloadByte(5, schem.orp.enabled ? schem.orp.tank.level + 1 : 0);
+            out.setPayloadByte(6, Math.floor(this.chem.calciumHardness / 256) || 0);
+            out.setPayloadByte(7, Math.round(this.chem.calciumHardness % 256) || 0);
+            out.setPayloadByte(9, this.chem.cyanuricAcid);
+            out.setPayloadByte(10, Math.floor(this.chem.alkalinity / 256) || 0);
+            out.setPayloadByte(12, Math.round(this.chem.alkalinity % 256) || 0);
+            logger.verbose(`Nixie: ${this.chem.name} sending IntelliChem settings action 146`);
+            await out.sendAsync();
+            this.configSent = true;
+            return true;
+        }
+        catch (err) {
+            this.configSent = false;
+            logger.error(`Error updating IntelliChem: ${err.message}`);
+            return false;
         }
-        catch (err) { logger.error(`Error updating IntelliChem: ${err.message}`); }
     }
     public async requestStatus(schem: ChemControllerState): Promise<boolean> {
         try {
@@ -1413,6 +1421,7 @@ export class NixieChemPump extends NixieChildEquipment {
             // about an EZO pump all the values are maintained anyway through the state settings.
             let res = await NixieEquipment.putDeviceService(this.pump.connectionId, `/state/device/${this.pump.deviceBinding}`, { state: false });
             this.isOn = schem.pump.isDosing = false;
+            await this.syncBoundCircuitStatesAsync(false);
             return res;
         }
         catch (err) { logger.error(`chemController.pump.turnOff: ${err.message}`); return Promise.reject(err); }
@@ -1421,10 +1430,33 @@ export class NixieChemPump extends NixieChildEquipment {
         try {
             let res = await NixieEquipment.putDeviceService(this.pump.connectionId, `/state/device/${this.pump.deviceBinding}`, typeof latchTimeout !== 'undefined' ? { isOn: true, latch: latchTimeout } : { isOn: true });
             this.isOn = schem.pump.isDosing = true;
+            await this.syncBoundCircuitStatesAsync(true);
             return res;
         }
         catch (err) { logger.error(`chemController.pump.turnOn: ${err.message}`); return Promise.reject(err); }
     }
+    private async syncBoundCircuitStatesAsync(isOn: boolean): Promise<void> {
+        if (utils.isNullOrEmpty(this.pump.connectionId) || utils.isNullOrEmpty(this.pump.deviceBinding)) return;
+        try {
+            let hasChanged = false;
+            for (let i = 0; i < sys.circuits.length; i++) {
+                let circuit = sys.circuits.getItemByIndex(i);
+                if (!circuit.isActive) continue;
+                if (circuit.connectionId !== this.pump.connectionId || circuit.deviceBinding !== this.pump.deviceBinding) continue;
+                let cstate = state.circuits.find(elem => elem.id === circuit.id);
+                if (typeof cstate === 'undefined' || cstate.isOn === isOn) continue;
+                sys.board.circuits.setEndTime(circuit, cstate, isOn);
+                cstate.isOn = isOn;
+                hasChanged = true;
+            }
+            if (hasChanged) {
+                sys.board.valves.syncValveStates();
+                ncp.pumps.syncPumpStates();
+                state.emitEquipmentChanges();
+            }
+        }
+        catch (err) { logger.warn(`chemController.pump.syncBoundCircuitStatesAsync: ${err.message}`); }
+    }
 }
 export class NixieChemChlor extends NixieChildEquipment {
     public get chlor(): Chlorinator { return sys.chlorinators.getItemById((this.getParent() as NixieChemicalORP).orp.chlorId); }

package/controller/nixie/heaters/Heater.ts

@@ -28,7 +28,16 @@ export class NixieHeaterCollection extends NixieEquipmentCollection<NixieHeaterB
         try {
             let h: NixieHeaterBase = this.find(elem => elem.id === hstate.id) as NixieHeaterBase;
             if (typeof h === 'undefined') {
-                return Promise.reject(new Error(`NCP: Heater ${hstate.id}-${hstate.name} could not be found to set the state to ${val}.`));
+                // Auto-initialize if heater exists in config with master=1 but hasn't been
+                // added to NCP yet (e.g. syncHeaterStates runs before ncp.initAsync completes).
+                let heater = sys.heaters.getItemById(hstate.id);
+                if (typeof heater !== 'undefined' && heater.master === 1 && heater.isActive !== false) {
+                    logger.info(`NCP: Auto-initializing heater ${hstate.id}-${heater.name}`);
+                    h = await this.initHeaterAsync(heater);
+                }
+                if (typeof h === 'undefined') {
+                    return Promise.reject(new Error(`NCP: Heater ${hstate.id}-${hstate.name} could not be found to set the state to ${val}.`));
+                }
             }
             await h.setHeaterStateAsync(hstate, val, isCooling);
         }

package/controller/nixie/pumps/Pump.ts

@@ -1,4 +1,4 @@
-import { EquipmentNotFoundError, InvalidEquipmentDataError, InvalidEquipmentIdError, ParameterOutOfRangeError } from '../../Errors';
+import { EquipmentNotFoundError, InvalidEquipmentDataError, InvalidEquipmentIdError, ParameterOutOfRangeError } from '../../Errors';
 import { utils, Timestamp } from '../../Constants';
 import { logger } from '../../../logger/Logger';
 
@@ -11,6 +11,7 @@ import { webApp, InterfaceServerResponse } from "../../../web/Server";
 import { Outbound, Protocol, Response } from '../../comms/messages/Messages';
 import { conn } from '../../comms/Comms';
 import { setTimeout } from 'timers/promises';
+import { NeptuneModbusStateMessage } from '../../comms/messages/status/NeptuneModbusStateMessage';
 
 export class NixiePumpCollection extends NixieEquipmentCollection<NixiePump> {
     public async deletePumpAsync(id: number) {
@@ -139,6 +140,8 @@ export class NixiePumpCollection extends NixieEquipmentCollection<NixiePump> {
                 return new NixiePumpHWRLY(this.controlPanel, pump);
             case 'regalmodbus':
                 return new NixiePumpRegalModbus(this.controlPanel, pump);
+            case 'neptunemodbus':
+                return new NixiePumpNeptuneModbus(this.controlPanel, pump);
             default:
                 throw new EquipmentNotFoundError(`NCP: Cannot create pump ${pump.name}.`, type);
         }
@@ -238,6 +241,7 @@ export class NixiePump extends NixieEquipment {
                         case 'vssvrs':
                         case 'vs':
                         case 'regalmodbus':
+                        case 'neptunemodbus':
                             c.units = sys.board.valueMaps.pumpUnits.getValue('rpm');
                             break;
                         case 'ss':
@@ -285,7 +289,9 @@ export class NixiePump extends NixieEquipment {
             // for the 112 address prevented that previously, but now is just a final fail safe.
             if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
             this._pollTimer = null;
-            if (this.suspendPolling || this.closing || this.pump.address > 112) {
+            const pumpTypeName = sys.board.valueMaps.pumpTypes.getName(this.pump.type);
+            const supportsHighAddress = pumpTypeName === 'regalmodbus' || pumpTypeName === 'neptunemodbus';
+            if (this.suspendPolling || this.closing || (!supportsHighAddress && this.pump.address > 112)) {
                 if (this.suspendPolling) logger.info(`Pump ${this.id} Polling Suspended`);
                 if (this.closing) logger.info(`Pump ${this.id} is closing`);
                 return;
@@ -1191,4 +1197,141 @@ export class NixiePumpRegalModbus extends NixiePump {
         catch (err) { logger.error(`Nixie Pump closeAsync: ${err.message}`); return Promise.reject(err); }
         finally { this.suspendPolling = false; }
     }
+}
+
+export class NixiePumpNeptuneModbus extends NixiePump {
+    private static readonly REG_MOTOR_ON_OFF = 0;    // 40001 address offset
+    private static readonly REG_MANUAL_SPEED = 1;    // 40002 address offset
+
+    constructor(ncp: INixieControlPanel, pump: Pump) {
+        super(ncp, pump);
+    }
+
+    public setTargetSpeed(pumpState: PumpState) {
+        let newSpeed = 0;
+        if (!pumpState.pumpOnDelay) {
+            const circuitConfigs = this.pump.circuits.get();
+            for (let i = 0; i < circuitConfigs.length; i++) {
+                const circuitConfig = circuitConfigs[i];
+                const circ = state.circuits.getInterfaceById(circuitConfig.circuit);
+                if (circ.isOn) newSpeed = Math.max(newSpeed, circuitConfig.speed);
+            }
+        }
+        if (isNaN(newSpeed)) newSpeed = 0;
+        this._targetSpeed = newSpeed;
+        if (this._targetSpeed !== 0) Math.min(Math.max(this.pump.minSpeed, this._targetSpeed), this.pump.maxSpeed);
+        if (this._targetSpeed !== newSpeed) logger.info(`NCP: Setting Pump ${this.pump.name} to ${newSpeed} RPM.`);
+    }
+
+    public async setServiceModeAsync() {
+        this._targetSpeed = 0;
+        await this.setDriveStateAsync(false);
+    }
+
+    public async setPumpStateAsync(pstate: PumpState) {
+        this.suspendPolling = true;
+        try {
+            const pt = sys.board.valueMaps.pumpTypes.get(this.pump.type);
+            if (state.mode === 0) {
+                if (!this.closing && this._targetSpeed >= pt.minSpeed && this._targetSpeed <= pt.maxSpeed) {
+                    await this.setPumpRPMAsync();
+                }
+                if (!this.closing) await this.setDriveStateAsync();
+                if (!this.closing) await setTimeout(500);
+                if (!this.closing) await this.requestPumpStatusAsync();
+            }
+            return new InterfaceServerResponse(200, 'Success');
+        }
+        catch (err) {
+            logger.error(`Error running pump sequence for ${this.pump.name}: ${err.message}`);
+            return Promise.reject(err);
+        }
+        finally { this.suspendPolling = false; }
+    };
+
+    private toWord(value: number): [number, number] {
+        return [(value >> 8) & 0xFF, value & 0xFF];
+    }
+
+    private async writeSingleRegisterAsync(registerAddr: number, value: number, retries: number = 1) {
+        if (!conn.isPortEnabled(this.pump.portId || 0)) return;
+        const [regHi, regLo] = this.toWord(registerAddr);
+        const [valHi, valLo] = this.toWord(value & 0xFFFF);
+        const out = Outbound.create({
+            portId: this.pump.portId || 0,
+            protocol: Protocol.NeptuneModbus,
+            dest: this.pump.address,
+            action: 0x06,
+            payload: [regHi, regLo, valHi, valLo],
+            retries,
+            response: true,
+        });
+        try {
+            await out.sendAsync();
+        }
+        catch (err) {
+            logger.error(`Error writing Neptune register ${registerAddr} for ${this.pump.name}: ${err.message}`);
+        }
+    }
+
+    private async readInputRegistersAsync(startAddr: number, quantity: number, retries: number = 2) {
+        if (!conn.isPortEnabled(this.pump.portId || 0)) return;
+        const [startHi, startLo] = this.toWord(startAddr);
+        const [qtyHi, qtyLo] = this.toWord(quantity);
+        const out = Outbound.create({
+            portId: this.pump.portId || 0,
+            protocol: Protocol.NeptuneModbus,
+            dest: this.pump.address,
+            action: 0x04,
+            payload: [startHi, startLo, qtyHi, qtyLo],
+            retries,
+            response: true,
+        });
+        NeptuneModbusStateMessage.enqueueReadRequest(this.pump.address, startAddr, quantity);
+        try {
+            await out.sendAsync();
+        }
+        catch (err) {
+            NeptuneModbusStateMessage.clearReadRequests(this.pump.address);
+            logger.error(`Error reading Neptune registers ${startAddr}-${startAddr + quantity - 1} for ${this.pump.name}: ${err.message}`);
+        }
+    }
+
+    protected async setDriveStateAsync(isRunning: boolean = true) {
+        const shouldRun = isRunning && this._targetSpeed > 0;
+        logger.debug(`NixiePumpNeptuneModbus: setDriveStateAsync ${this.pump.name} ${shouldRun ? 'RUN' : 'STOP'}`);
+        await this.writeSingleRegisterAsync(NixiePumpNeptuneModbus.REG_MOTOR_ON_OFF, shouldRun ? 1 : 0);
+    }
+
+    protected async requestPumpStatusAsync() {
+        // Block 30001-30007 (speed/power/fault summary).
+        await this.readInputRegistersAsync(0, 7);
+        // Block 30031-30033 (interface fault state/code).
+        await this.readInputRegistersAsync(30, 3);
+        // Block 30114-30128 (stopped state, line volts, temps, target speed, etc.).
+        await this.readInputRegistersAsync(113, 15);
+    }
+
+    protected async setPumpRPMAsync() {
+        logger.debug(`NixiePumpNeptuneModbus: setPumpRPMAsync ${this.pump.name} ${this._targetSpeed}`);
+        await this.writeSingleRegisterAsync(NixiePumpNeptuneModbus.REG_MANUAL_SPEED, Math.round(this._targetSpeed));
+    }
+
+    public async closeAsync() {
+        try {
+            this.suspendPolling = true;
+            logger.info(`Nixie Pump closing ${this.pump.name}.`)
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            this.closing = true;
+            const pumpState = state.pumps.getItemById(this.pump.id);
+            this._targetSpeed = 0;
+            await this.setDriveStateAsync(false);
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            pumpState.emitEquipmentChange();
+        }
+        catch (err) { logger.error(`Nixie Pump closeAsync: ${err.message}`); return Promise.reject(err); }
+        finally { this.suspendPolling = false; }
+    }
 }

package/docker-compose.yml

@@ -1,5 +1,6 @@
 services:
   njspc:
+    # Local dev compose: build from current workspace instead of pulling remote image.
     build:
       context: .
       dockerfile: Dockerfile