nodejs-poolcontroller 8.3.0 → 8.4.1

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

@@ -1,37 +1,37 @@
-/*  nodejs-poolController.  An application to control pool equipment.
-Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022.  
-Russell Goldin, tagyoureit.  russ.goldin@gmail.com
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU Affero General Public License as
-published by the Free Software Foundation, either version 3 of the
-License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Affero General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-import { Inbound } from "../Messages";
-import { state } from "../../../State";
-import { sys, ControllerType } from "../../../Equipment";
-import { logger } from "../../../../logger/Logger";
-
-export class IntelliValveStateMessage {
-    public static process(msg: Inbound) {
-        if (sys.controllerType === ControllerType.Unknown) return;
-        // We only want to process the messages that are coming from IntelliValve.
-        if (msg.source !== 12) return;
-        switch (msg.action) {
-            case 82: // This is hail from the valve that says it is not bound yet.
-                break;
-            default:
-                logger.info(`IntelliValve sent an unknown action ${msg.action}`);
-                break;
-        }
-        state.emitEquipmentChanges();
-    }
+/*  nodejs-poolController.  An application to control pool equipment.
+Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022.  
+Russell Goldin, tagyoureit.  russ.goldin@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+import { Inbound } from "../Messages";
+import { state } from "../../../State";
+import { sys, ControllerType } from "../../../Equipment";
+import { logger } from "../../../../logger/Logger";
+
+export class IntelliValveStateMessage {
+    public static process(msg: Inbound) {
+        if (sys.controllerType === ControllerType.Unknown) return;
+        // We only want to process the messages that are coming from IntelliValve.
+        if (msg.source !== 12) return;
+        switch (msg.action) {
+            case 82: // This is hail from the valve that says it is not bound yet.
+                break;
+            default:
+                logger.info(`IntelliValve sent an unknown action ${msg.action}`);
+                break;
+        }
+        state.emitEquipmentChanges();
+    }
 }

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

@@ -0,0 +1,217 @@
+/*  nodejs-poolController.  An application to control pool equipment.
+Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022.
+Russell Goldin, tagyoureit.  russ.goldin@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+import { Inbound } from "../Messages";
+import { state, PumpState } from "../../../State";
+import { sys, Pump } from "../../../Equipment";
+import { logger } from "../../../../logger/Logger";
+
+type PendingRead = {
+    startAddr: number;
+    quantity: number;
+    requestedAt: number;
+};
+
+export class NeptuneModbusStateMessage {
+    private static pendingReads: Map<number, PendingRead[]> = new Map();
+
+    public static enqueueReadRequest(address: number, startAddr: number, quantity: number) {
+        const queue = this.pendingReads.get(address) || [];
+        queue.push({ startAddr, quantity, requestedAt: Date.now() });
+        this.pendingReads.set(address, queue);
+    }
+
+    public static clearReadRequests(address: number) {
+        this.pendingReads.delete(address);
+    }
+
+    private static dequeueReadRequest(address: number): PendingRead {
+        const queue = this.pendingReads.get(address);
+        if (!queue || queue.length === 0) return undefined;
+        const request = queue.shift();
+        if (queue.length === 0) this.pendingReads.delete(address);
+        else this.pendingReads.set(address, queue);
+        return request;
+    }
+
+    private static getNeptunePumpByAddress(address: number): Pump {
+        for (let i = 0; i < sys.pumps.length; i++) {
+            const pump = sys.pumps.getItemByIndex(i);
+            const typeName = sys.board.valueMaps.pumpTypes.getName(pump.type);
+            if (typeName === 'neptunemodbus' && pump.address === address) return pump;
+        }
+        return undefined;
+    }
+
+    private static toSigned16(value: number): number {
+        return value > 0x7FFF ? value - 0x10000 : value;
+    }
+
+    private static decodeModbusException(code: number): string {
+        const modbusExceptions = {
+            0x01: 'Illegal function',
+            0x02: 'Illegal data address',
+            0x03: 'Illegal data value',
+            0x04: 'Server device failure',
+            0x05: 'Acknowledge',
+            0x06: 'Server device busy',
+            0x08: 'Memory parity error',
+            0x0A: 'Gateway path unavailable',
+            0x0B: 'Gateway target failed to respond',
+        };
+        return modbusExceptions[code] || `Unknown Modbus exception ${code}`;
+    }
+
+    private static processReadInput(msg: Inbound, address: number, pumpState: PumpState) {
+        const request = this.dequeueReadRequest(address);
+        const byteCount = msg.extractPayloadByte(0, 0);
+        if (byteCount <= 0 || (byteCount % 2) !== 0) {
+            logger.debug(`NeptuneModbusStateMessage.processReadInput invalid byte count ${byteCount} (Address: ${address})`);
+            return;
+        }
+        if (msg.payload.length < byteCount + 1) {
+            logger.debug(`NeptuneModbusStateMessage.processReadInput short payload (Address: ${address})`);
+            return;
+        }
+
+        let motorFaultCode = 0;
+        let interfaceFaultCode = 0;
+        let stoppedState: number = undefined;
+
+        for (let i = 0; i < byteCount; i += 2) {
+            const value = (msg.payload[i + 1] << 8) | msg.payload[i + 2];
+            const offset = i / 2;
+            const registerAddr = request ? request.startAddr + offset : -1;
+            switch (registerAddr) {
+                case 0: // 30001 Current Speed
+                    pumpState.rpm = value;
+                    break;
+                case 3: // 30004 Motor Power
+                    pumpState.watts = value;
+                    break;
+                case 5: // 30006 Motor Fault Status
+                    logger.debug(`Neptune motor fault status ${value} (Address: ${address})`);
+                    break;
+                case 6: // 30007 Motor Fault Code
+                    motorFaultCode = value;
+                    break;
+                case 30: // 30031 Interface Fault State
+                    logger.debug(`Neptune interface fault state ${value} (Address: ${address})`);
+                    break;
+                case 31: // 30032 Interface Fault Code
+                    interfaceFaultCode = value;
+                    break;
+                case 113: // 30114 Stopped State bit image
+                    stoppedState = value;
+                    break;
+                case 119: // 30120 Target shaft speed (signed)
+                    pumpState.targetSpeed = Math.abs(this.toSigned16(value));
+                    break;
+                default:
+                    // Keep MVP mapping focused on existing pump state fields.
+                    break;
+            }
+        }
+
+        const hasFault = motorFaultCode > 0 || interfaceFaultCode > 0;
+        if (hasFault) {
+            logger.warn(`Neptune fault detected (Address: ${address}) motorFault=${motorFaultCode} interfaceFault=${interfaceFaultCode}`);
+            pumpState.status = 16;
+            pumpState.driveState = 4;
+            pumpState.command = 4;
+            return;
+        }
+
+        if (typeof stoppedState !== 'undefined') {
+            const isStopped = (stoppedState & 0x01) === 1;
+            pumpState.driveState = isStopped ? 0 : 2;
+            pumpState.command = isStopped ? 4 : 10;
+            pumpState.status = isStopped ? 0 : 1;
+        }
+        else if (pumpState.rpm > 0) {
+            pumpState.driveState = 2;
+            pumpState.command = 10;
+            pumpState.status = 1;
+        }
+        else {
+            pumpState.driveState = 0;
+            pumpState.command = 4;
+            pumpState.status = 0;
+        }
+    }
+
+    private static processWriteSingle(msg: Inbound, address: number, pumpState: PumpState) {
+        if (msg.payload.length < 4) return;
+        const registerAddr = (msg.payload[0] << 8) | msg.payload[1];
+        const registerValue = (msg.payload[2] << 8) | msg.payload[3];
+        switch (registerAddr) {
+            case 0: // 40001 Motor On/Off
+                if (registerValue === 0) {
+                    pumpState.driveState = 0;
+                    pumpState.command = 4;
+                    pumpState.status = 0;
+                }
+                else if (registerValue === 1) {
+                    pumpState.driveState = 2;
+                    pumpState.command = 10;
+                    pumpState.status = 1;
+                }
+                break;
+            case 1: // 40002 Manual speed RPM
+                pumpState.rpm = registerValue;
+                break;
+            default:
+                logger.debug(`Neptune write ack for unhandled register ${registerAddr}=${registerValue} (Address: ${address})`);
+                break;
+        }
+    }
+
+    public static process(msg: Inbound) {
+        const address = msg.dest;
+        const functionCode = msg.action;
+        const pumpCfg = this.getNeptunePumpByAddress(address);
+        if (typeof pumpCfg === 'undefined') {
+            logger.debug(`NeptuneModbusStateMessage.process ignored unconfigured address ${address}`);
+            return;
+        }
+        const pumpState = state.pumps.getItemById(pumpCfg.id, pumpCfg.isActive === true);
+
+        if ((functionCode & 0x80) === 0x80) {
+            const exceptionCode = msg.extractPayloadByte(0, 0);
+            logger.warn(`Neptune Modbus exception response fn=0x${functionCode.toString(16)} code=${exceptionCode} (${this.decodeModbusException(exceptionCode)}) address=${address}`);
+            pumpState.status = 16;
+            state.emitEquipmentChanges();
+            return;
+        }
+
+        switch (functionCode) {
+            case 0x04: // Read input registers
+                this.processReadInput(msg, address, pumpState);
+                break;
+            case 0x06: // Write single register
+                this.processWriteSingle(msg, address, pumpState);
+                break;
+            case 0x10: // Write multiple registers
+                logger.debug(`Neptune write-multiple response (Address: ${address})`);
+                break;
+            default:
+                logger.debug(`NeptuneModbusStateMessage.process unhandled function 0x${functionCode.toString(16)} (Address: ${address})`);
+                break;
+        }
+        state.emitEquipmentChanges();
+    }
+}