@enyo-energy/sunspec-sdk 0.0.51 → 0.0.54

package/dist/sunspec-modbus-client.js

@@ -20,21 +20,75 @@ import { SunspecModelId, SunspecBatteryChargeState, SunspecStorageControlMode, S
 import { EnergyAppModbusConnectionHealth } from "@enyo-energy/energy-app-sdk/dist/implementations/modbus/EnergyAppModbusConnectionHealth.js";
 import { EnergyAppModbusFaultTolerantReader } from "@enyo-energy/energy-app-sdk/dist/implementations/modbus/EnergyAppModbusFaultTolerantReader.js";
 import { EnergyAppModbusDataTypeConverter } from "@enyo-energy/energy-app-sdk/dist/implementations/modbus/EnergyAppModbusDataTypeConverter.js";
+/**
+ * Module-level registry: one SunspecModbusClient per network device (host:port).
+ * Refcounted so the underlying connection only tears down when the last consumer releases.
+ */
+const CLIENT_REGISTRY = new Map();
+const registryKey = (host, port) => `${host}:${port}`;
+/**
+ * Get (or create) the singleton SunspecModbusClient for this network device.
+ * Increments the refcount; pair with `releaseSunspecClient` on teardown.
+ */
+export function getOrCreateSunspecClient(energyApp, host, port = 502) {
+    const key = registryKey(host, port);
+    let entry = CLIENT_REGISTRY.get(key);
+    if (!entry) {
+        entry = { client: new SunspecModbusClient(energyApp), refcount: 0 };
+        CLIENT_REGISTRY.set(key, entry);
+    }
+    entry.refcount++;
+    return entry.client;
+}
+/**
+ * Release a refcount on the network-device client. When the last consumer releases,
+ * the client is fully disconnected (all units closed) and removed from the registry.
+ *
+ * Releasing more times than acquired is a programming error and is logged; the count
+ * is clamped at zero so repeat releases are no-ops.
+ */
+export async function releaseSunspecClient(host, port = 502) {
+    const key = registryKey(host, port);
+    const entry = CLIENT_REGISTRY.get(key);
+    if (!entry)
+        return;
+    if (entry.refcount <= 0) {
+        console.warn(`releaseSunspecClient(${host}:${port}): refcount already 0 — extra release ignored`);
+        return;
+    }
+    entry.refcount--;
+    if (entry.refcount === 0) {
+        // Disconnect first, THEN remove from registry, so a concurrent getOrCreate
+        // doesn't bind a fresh client to the same host:port while sockets are still
+        // closing on the old one.
+        try {
+            await entry.client.disconnect();
+        }
+        finally {
+            // Guard against the very-unlikely case where someone re-acquired during await.
+            if (CLIENT_REGISTRY.get(key) === entry && entry.refcount === 0) {
+                CLIENT_REGISTRY.delete(key);
+            }
+        }
+    }
+}
 export class SunspecModbusClient {
     energyApp;
-    modbusClient = null;
-    discoveredModels = new Map();
-    connected = false;
+    // Per-unit Modbus instance/reader/discovered-models maps. One client = one network device,
+    // many unit IDs share that client (each unit ID is one EnergyAppModbusInstance underneath).
+    modbusInstances = new Map();
+    faultTolerantReaders = new Map();
+    discoveredModelsByUnit = new Map();
     connectionHealth;
-    faultTolerantReader = null;
     modbusDataTypeConverter;
     connectionParams = null;
+    // Per-unit known parameters so reconnect() can replay every unit ID we've seen.
+    knownUnits = new Set();
     autoReconnectEnabled = true;
     openCount = 0;
     closeCount = 0;
-    currentlyOpen = 0;
-    // Serializes connection-state transitions so concurrent callers cannot open a second
-    // TCP socket while the first is still alive (some Modbus devices allow only one client).
+    // Serializes connection-state transitions so concurrent callers cannot open duplicate
+    // sockets for the same unit ID while one is still alive.
     operationChain = Promise.resolve();
     constructor(energyApp) {
         this.energyApp = energyApp;
@@ -42,7 +96,10 @@ export class SunspecModbusClient {
         this.modbusDataTypeConverter = new EnergyAppModbusDataTypeConverter();
     }
     /**
-     * Connect to Modbus device
+     * Connect to a Modbus device unit. Multiple unit IDs on the same network device share this
+     * client; calling connect() with different unit IDs adds each as a separately-managed unit.
+     * The first call locks in the host/port for this client; later calls for a different host
+     * are rejected.
      * @param host Primary host (hostname) to connect to
      * @param port Modbus port (default 502)
      * @param unitId Modbus unit ID (default 1)
@@ -50,45 +107,64 @@ export class SunspecModbusClient {
      */
     async connect(host, port = 502, unitId = 1, secondaryHost) {
         return this.withConnectionLock(async () => {
-            const sameParams = this.connected
-                && this.connectionParams !== null
-                && this.connectionParams.primaryHost === host
-                && this.connectionParams.port === port
-                && this.connectionParams.unitId === unitId;
-            if (sameParams) {
-                console.debug(`connect(): already connected to ${host}:${port} unit ${unitId}, skipping`);
-                return;
+            if (this.connectionParams) {
+                if (this.connectionParams.primaryHost !== host || this.connectionParams.port !== port) {
+                    throw new Error(`SunspecModbusClient is bound to ${this.connectionParams.primaryHost}:${this.connectionParams.port}; ` +
+                        `cannot reuse it for ${host}:${port}. Use getOrCreateSunspecClient() per (host, port).`);
+                }
+                if (secondaryHost && !this.connectionParams.secondaryHost) {
+                    this.connectionParams.secondaryHost = secondaryHost;
+                }
             }
-            if (this.connected || this.modbusClient) {
-                await this._closeSocket();
+            else {
+                this.connectionParams = { primaryHost: host, secondaryHost, port };
             }
-            this.connectionParams = { primaryHost: host, secondaryHost, port, unitId };
-            await this._openSocket(host, port, unitId);
-            console.log(`Connected to Sunspec device at ${host}:${port} unit ${unitId} (opens=${this.openCount}, closes=${this.closeCount}, current=${this.currentlyOpen})`);
+            this.knownUnits.add(unitId);
+            if (this.modbusInstances.has(unitId)) {
+                console.debug(`connect(): unit ${unitId} on ${host}:${port} already open, skipping`);
+                return;
+            }
+            await this._openUnit(host, port, unitId);
+            console.log(`Connected to Sunspec device at ${host}:${port} unit ${unitId} (opens=${this.openCount}, closes=${this.closeCount}, openUnits=${this.modbusInstances.size})`);
         });
     }
     /**
-     * Disconnect from Modbus device.
+     * Disconnect from all units of this network device.
      *
-     * Note: connection parameters are preserved so reconnect() can be called afterwards.
-     * They will be overwritten by the next connect() call anyway.
+     * Note: connection parameters and the set of known units are preserved so reconnect() can
+     * be called afterwards. They will be overwritten by the next connect() call anyway.
      */
     async disconnect() {
         return this.withConnectionLock(async () => {
-            if (!this.modbusClient && !this.connected) {
+            if (this.modbusInstances.size === 0) {
                 return;
             }
             const host = this.connectionParams?.primaryHost ?? 'unknown';
             const port = this.connectionParams?.port ?? 0;
-            const unitId = this.connectionParams?.unitId ?? 0;
-            await this._closeSocket();
-            console.log(`Disconnected from Sunspec device at ${host}:${port} unit ${unitId} (opens=${this.openCount}, closes=${this.closeCount}, current=${this.currentlyOpen})`);
+            const units = [...this.modbusInstances.keys()];
+            for (const unitId of units) {
+                await this._closeUnit(unitId);
+            }
+            console.log(`Disconnected from Sunspec device at ${host}:${port} units [${units.join(',')}] (opens=${this.openCount}, closes=${this.closeCount})`);
+        });
+    }
+    /**
+     * Disconnect a single unit on this network device. Other units on the same device stay open.
+     */
+    async disconnectUnit(unitId) {
+        return this.withConnectionLock(async () => {
+            if (!this.modbusInstances.has(unitId))
+                return;
+            const host = this.connectionParams?.primaryHost ?? 'unknown';
+            const port = this.connectionParams?.port ?? 0;
+            await this._closeUnit(unitId);
+            console.log(`Disconnected unit ${unitId} from Sunspec device at ${host}:${port} (opens=${this.openCount}, closes=${this.closeCount})`);
         });
     }
     /**
-     * Reconnect using stored connection parameters
-     * First tries primaryHost (hostname), then falls back to secondaryHost (ipAddress) if available
-     * Returns true if reconnection was successful, false otherwise
+     * Reconnect every previously-known unit on this network device using stored connection
+     * parameters. First tries primaryHost (hostname), then falls back to secondaryHost
+     * (ipAddress) if available. Returns true only if every known unit reconnected successfully.
      */
     async reconnect() {
         return this.withConnectionLock(async () => {
@@ -96,18 +172,23 @@ export class SunspecModbusClient {
                 console.error('Cannot reconnect: no connection parameters stored. Call connect() first.');
                 return false;
             }
-            const { primaryHost, secondaryHost, port, unitId } = this.connectionParams;
-            console.log(`Attempting to reconnect to primary host ${primaryHost}:${port} unit ${unitId}...`);
-            const primarySuccess = await this.attemptConnection(primaryHost, port, unitId);
+            if (this.knownUnits.size === 0) {
+                console.error('Cannot reconnect: no known unit IDs. Call connect(unitId) at least once first.');
+                return false;
+            }
+            const { primaryHost, secondaryHost, port } = this.connectionParams;
+            const units = [...this.knownUnits];
+            console.log(`Attempting to reconnect to primary host ${primaryHost}:${port} units [${units.join(',')}]...`);
+            const primarySuccess = await this.attemptConnection(primaryHost, port, units);
             if (primarySuccess) {
-                console.log(`Successfully reconnected to primary host ${primaryHost}:${port} unit ${unitId}`);
+                console.log(`Successfully reconnected to primary host ${primaryHost}:${port} units [${units.join(',')}]`);
                 return true;
             }
             if (secondaryHost && secondaryHost !== primaryHost) {
-                console.log(`Primary host failed, attempting secondary host ${secondaryHost}:${port} unit ${unitId}...`);
-                const secondarySuccess = await this.attemptConnection(secondaryHost, port, unitId);
+                console.log(`Primary host failed, attempting secondary host ${secondaryHost}:${port} units [${units.join(',')}]...`);
+                const secondarySuccess = await this.attemptConnection(secondaryHost, port, units);
                 if (secondarySuccess) {
-                    console.log(`Successfully reconnected to secondary host ${secondaryHost}:${port} unit ${unitId}`);
+                    console.log(`Successfully reconnected to secondary host ${secondaryHost}:${port} units [${units.join(',')}]`);
                     return true;
                 }
             }
@@ -116,16 +197,53 @@ export class SunspecModbusClient {
         });
     }
     /**
-     * Attempt to establish a connection to a specific host. Caller must hold the connection lock.
-     * Returns true if successful, false otherwise.
+     * Reconnect a single previously-known unit on this network device. Other units on the
+     * same client stay open. Useful when one device's polling loop detects a dropped
+     * connection and only needs to recover its own unit, not thrash siblings.
+     *
+     * Returns true if the unit reconnected successfully (on primary or secondary host).
+     */
+    async reconnectUnit(unitId) {
+        return this.withConnectionLock(async () => {
+            if (!this.connectionParams) {
+                console.error(`Cannot reconnectUnit(${unitId}): no connection parameters stored. Call connect() first.`);
+                return false;
+            }
+            const { primaryHost, secondaryHost, port } = this.connectionParams;
+            console.log(`Attempting to reconnect unit ${unitId} on primary host ${primaryHost}:${port}...`);
+            const primarySuccess = await this.attemptConnection(primaryHost, port, [unitId]);
+            if (primarySuccess) {
+                console.log(`Successfully reconnected unit ${unitId} on primary host ${primaryHost}:${port}`);
+                return true;
+            }
+            if (secondaryHost && secondaryHost !== primaryHost) {
+                console.log(`Primary host failed for unit ${unitId}, attempting secondary host ${secondaryHost}:${port}...`);
+                const secondarySuccess = await this.attemptConnection(secondaryHost, port, [unitId]);
+                if (secondarySuccess) {
+                    console.log(`Successfully reconnected unit ${unitId} on secondary host ${secondaryHost}:${port}`);
+                    return true;
+                }
+            }
+            console.error(`Reconnection failed for unit ${unitId} on all available hosts`);
+            return false;
+        });
+    }
+    /**
+     * Attempt to (re)open every requested unit on a specific host. Caller must hold the
+     * connection lock. Closes any pre-existing per-unit instances first. Returns true only
+     * if every unit succeeded.
      */
-    async attemptConnection(host, port, unitId) {
-        if (this.connected || this.modbusClient) {
-            await this._closeSocket();
+    async attemptConnection(host, port, units) {
+        for (const unitId of units) {
+            if (this.modbusInstances.has(unitId)) {
+                await this._closeUnit(unitId);
+            }
         }
         try {
-            await this._openSocket(host, port, unitId);
-            console.log(`Connection attempt to ${host}:${port} unit ${unitId} succeeded (opens=${this.openCount}, closes=${this.closeCount}, current=${this.currentlyOpen})`);
+            for (const unitId of units) {
+                await this._openUnit(host, port, unitId);
+            }
+            console.log(`Connection attempt to ${host}:${port} units [${units.join(',')}] succeeded (opens=${this.openCount}, closes=${this.closeCount}, openUnits=${this.modbusInstances.size})`);
             return true;
         }
         catch (error) {
@@ -134,11 +252,11 @@ export class SunspecModbusClient {
         }
     }
     /**
-     * Open a new Modbus socket and wire up the fault-tolerant reader. On any failure, the
-     * just-opened socket (if any) is closed so we never leak. Caller must hold the connection
-     * lock and ensure no prior socket is open (use _closeSocket first).
+     * Open a new Modbus instance for one unit ID and wire up its fault-tolerant reader.
+     * On any failure, the just-opened instance (if any) is closed so we never leak. Caller must
+     * hold the connection lock and ensure the unit is not already open.
      */
-    async _openSocket(host, port, unitId) {
+    async _openUnit(host, port, unitId) {
         let candidate = null;
         try {
             candidate = await this.energyApp.useModbus().connect({
@@ -150,9 +268,9 @@ export class SunspecModbusClient {
             if (!candidate) {
                 throw new Error(`useModbus().connect returned null for ${host}:${port} unit ${unitId}`);
             }
-            this.faultTolerantReader = new EnergyAppModbusFaultTolerantReader(candidate, this.connectionHealth);
-            this.modbusClient = candidate;
-            this.connected = true;
+            const reader = new EnergyAppModbusFaultTolerantReader(candidate, this.connectionHealth);
+            this.modbusInstances.set(unitId, candidate);
+            this.faultTolerantReaders.set(unitId, reader);
             this.connectionHealth.recordSuccess();
             this.recordOpen();
         }
@@ -163,31 +281,28 @@ export class SunspecModbusClient {
                 }
                 catch { /* ignore */ }
             }
-            this.modbusClient = null;
-            this.faultTolerantReader = null;
-            this.connected = false;
+            this.modbusInstances.delete(unitId);
+            this.faultTolerantReaders.delete(unitId);
             throw err;
         }
     }
     /**
-     * Close the current Modbus socket if any. Idempotent. Caller must hold the connection lock.
+     * Close the Modbus instance for a single unit. Idempotent. Caller must hold the
+     * connection lock.
      */
-    async _closeSocket() {
-        if (!this.modbusClient && !this.connected)
-            return;
-        const client = this.modbusClient;
-        const wasConnected = this.connected;
-        this.modbusClient = null;
-        this.faultTolerantReader = null;
-        this.connected = false;
-        this.discoveredModels.clear();
-        if (client) {
+    async _closeUnit(unitId) {
+        const instance = this.modbusInstances.get(unitId);
+        const wasOpen = instance !== undefined;
+        this.modbusInstances.delete(unitId);
+        this.faultTolerantReaders.delete(unitId);
+        this.discoveredModelsByUnit.delete(unitId);
+        if (instance) {
             try {
-                await client.disconnect();
+                await instance.disconnect();
             }
             catch { /* ignore */ }
         }
-        if (wasConnected)
+        if (wasOpen)
             this.recordClose();
     }
     /**
@@ -201,27 +316,55 @@ export class SunspecModbusClient {
     }
     recordOpen() {
         this.openCount++;
-        this.currentlyOpen++;
-        if (this.currentlyOpen > 1) {
-            console.error(`SunspecModbusClient: currentlyOpen=${this.currentlyOpen} after open ` +
-                `(opens=${this.openCount}, closes=${this.closeCount}). ` +
+        const expected = this.modbusInstances.size;
+        const delta = this.openCount - this.closeCount;
+        if (delta > expected) {
+            console.error(`SunspecModbusClient: open/close imbalance — ` +
+                `opens=${this.openCount}, closes=${this.closeCount}, instances=${expected}. ` +
                 `This indicates a code path bypassing the connection lock — please investigate.`);
         }
     }
     recordClose() {
         this.closeCount++;
-        if (this.currentlyOpen > 0) {
-            this.currentlyOpen--;
-        }
-        else {
-            console.warn(`SunspecModbusClient: closeCount incremented while currentlyOpen was 0 — possible double-close`);
+        if (this.closeCount > this.openCount) {
+            console.warn(`SunspecModbusClient: closeCount=${this.closeCount} exceeded openCount=${this.openCount} — possible double-close`);
         }
     }
     /**
-     * Get cumulative open/close counts for this client. Useful for spotting connection leaks.
+     * Get cumulative open/close counts for this client (across all unit IDs). Useful for
+     * spotting connection leaks.
      */
     getConnectionStats() {
-        return { opens: this.openCount, closes: this.closeCount, currentlyOpen: this.currentlyOpen };
+        return { opens: this.openCount, closes: this.closeCount, openUnits: this.modbusInstances.size };
+    }
+    /**
+     * Get the EnergyAppModbusInstance for a unit, throwing if it isn't open.
+     */
+    getInstance(unitId) {
+        const inst = this.modbusInstances.get(unitId);
+        if (!inst)
+            throw new Error(`Modbus instance for unit ${unitId} not initialized — call connect(host, port, ${unitId}) first`);
+        return inst;
+    }
+    /**
+     * Get the fault-tolerant reader for a unit, throwing if it isn't open.
+     */
+    getReader(unitId) {
+        const reader = this.faultTolerantReaders.get(unitId);
+        if (!reader)
+            throw new Error(`Fault-tolerant reader for unit ${unitId} not initialized — call connect(host, port, ${unitId}) first`);
+        return reader;
+    }
+    /**
+     * Get (or create) the discovered-models map for a unit.
+     */
+    getModelsMap(unitId) {
+        let m = this.discoveredModelsByUnit.get(unitId);
+        if (!m) {
+            m = new Map();
+            this.discoveredModelsByUnit.set(unitId, m);
+        }
+        return m;
     }
     /**
      * Enable or disable automatic reconnection
@@ -239,16 +382,14 @@ export class SunspecModbusClient {
     /**
      * Detect the base address and addressing mode (0-based or 1-based) for SunSpec
      */
-    async detectSunspecBaseAddress(customBaseAddress) {
-        if (!this.modbusClient) {
-            throw new Error('Modbus client not initialized');
-        }
+    async detectSunspecBaseAddress(unitId, customBaseAddress) {
+        const instance = this.getInstance(unitId);
         // If custom base address provided, try it first (1-based, then 0-based variant)
         if (customBaseAddress !== undefined) {
             console.log(`Detect models for custom base address '${customBaseAddress}' ...`);
             // Try 0-based at custom address
             try {
-                const sunspecId = await this.modbusClient.readRegisterStringValue(customBaseAddress, 2);
+                const sunspecId = await instance.readRegisterStringValue(customBaseAddress, 2);
                 if (sunspecId.includes('SunS')) {
                     console.log(`Detected 0-based addressing mode (base address: ${customBaseAddress})`);
                     return {
@@ -263,7 +404,7 @@ export class SunspecModbusClient {
             }
             // Try 1-based at custom address (customBaseAddress + 1)
             try {
-                const sunspecId = await this.modbusClient.readRegisterStringValue(customBaseAddress + 1, 2);
+                const sunspecId = await instance.readRegisterStringValue(customBaseAddress + 1, 2);
                 if (sunspecId.includes('SunS')) {
                     console.log(`Detected 1-based addressing mode (base address: ${customBaseAddress + 1})`);
                     return {
@@ -280,7 +421,7 @@ export class SunspecModbusClient {
         else {
             // Try 1-based addressing first (most common)
             try {
-                const sunspecId = await this.modbusClient.readRegisterStringValue(40001, 2);
+                const sunspecId = await instance.readRegisterStringValue(40001, 2);
                 if (sunspecId.includes('SunS')) {
                     console.log('Detected 1-based addressing mode (base address: 40001)');
                     return {
@@ -295,7 +436,7 @@ export class SunspecModbusClient {
             }
             // Try 0-based addressing
             try {
-                const sunspecId = await this.modbusClient.readRegisterStringValue(40000, 2);
+                const sunspecId = await instance.readRegisterStringValue(40000, 2);
                 if (sunspecId.includes('SunS')) {
                     console.log('Detected 0-based addressing mode (base address: 40000)');
                     return {
@@ -315,27 +456,22 @@ export class SunspecModbusClient {
         throw new Error(`Device is not SunSpec compliant - "SunS" identifier not found at addresses ${addressesChecked}`);
     }
     /**
-     * Discover all available Sunspec models
+     * Discover all available Sunspec models for a unit
      * Automatically detects base address (40000 or 40001) and scans from there
      */
-    async discoverModels(customBaseAddress) {
-        if (!this.connected) {
-            throw new Error('Not connected to Modbus device');
-        }
-        this.discoveredModels.clear();
+    async discoverModels(unitId, customBaseAddress) {
+        const instance = this.getInstance(unitId);
+        const models = this.getModelsMap(unitId);
+        models.clear();
         const maxAddress = 50000; // Safety limit
         let currentAddress = 0;
-        console.log('Starting Sunspec model discovery...');
+        console.log(`Starting Sunspec model discovery for unit ${unitId}...`);
         try {
             // Detect the base address and addressing mode
-            const addressInfo = await this.detectSunspecBaseAddress(customBaseAddress);
+            const addressInfo = await this.detectSunspecBaseAddress(unitId, customBaseAddress);
             currentAddress = addressInfo.nextAddress;
             while (currentAddress < maxAddress) {
-                // Read model ID and length
-                if (!this.modbusClient) {
-                    throw new Error('Modbus client not initialized');
-                }
-                const buffer = await this.modbusClient.readHoldingRegisters(currentAddress, 2);
+                const buffer = await instance.readHoldingRegisters(currentAddress, 2);
                 const modelData = [buffer.readUInt16BE(0), buffer.readUInt16BE(2)];
                 if (!modelData || modelData.length < 2) {
                     console.log(`No data at address ${currentAddress}, ending discovery`);
@@ -354,23 +490,23 @@ export class SunspecModbusClient {
                     address: currentAddress,
                     length: modelLength
                 };
-                this.discoveredModels.set(modelId, model);
-                console.log(`Discovered Model ${modelId} at address ${currentAddress} with length ${modelLength}`);
+                models.set(modelId, model);
+                console.log(`Discovered Model ${modelId} at address ${currentAddress} with length ${modelLength} (unit ${unitId})`);
                 // Jump to next model: current address + 2 (header) + model length
                 currentAddress = currentAddress + 2 + modelLength;
             }
         }
         catch (error) {
-            console.error(`Error during model discovery at address ${currentAddress}: ${error}`);
+            console.error(`Error during model discovery at address ${currentAddress} (unit ${unitId}): ${error}`);
         }
-        console.log(`Discovery complete. Found ${this.discoveredModels.size} models`);
-        return this.discoveredModels;
+        console.log(`Discovery complete for unit ${unitId}. Found ${models.size} models: [${[...models.keys()].sort((a, b) => a - b).join(', ')}]`);
+        return models;
     }
     /**
-     * Find a specific model by ID
+     * Find a specific model by ID for a given unit
      */
-    findModel(modelId) {
-        return this.discoveredModels.get(modelId);
+    findModel(unitId, modelId) {
+        return this.discoveredModelsByUnit.get(unitId)?.get(modelId);
     }
     /**
      * Check if a value is "unimplemented" according to Sunspec specification
@@ -446,17 +582,15 @@ export class SunspecModbusClient {
      * Read an entire model's register block in a single Modbus call.
      * Returns a Buffer containing all registers for the model.
      */
-    async readModelBlock(model) {
-        if (!this.faultTolerantReader) {
-            throw new Error('Fault-tolerant reader not initialized');
-        }
+    async readModelBlock(unitId, model) {
+        const reader = this.getReader(unitId);
         // Read model.length + 2 registers: the 2-register header (ID + length) plus all data registers.
         // This way buffer offsets match the convention used throughout: offset 0 = model ID,
         // offset 1 = model length, offset 2 = first data register, etc.
         const totalRegisters = model.length + 2;
-        const result = await this.faultTolerantReader.readHoldingRegisters(model.address, totalRegisters);
+        const result = await reader.readHoldingRegisters(model.address, totalRegisters);
         if (!result.success || !result.value) {
-            throw new Error(`Failed to read model block ${model.id} at address ${model.address}: ${result.error?.message || 'Unknown error'}`);
+            throw new Error(`Failed to read model block ${model.id} at address ${model.address} (unit ${unitId}): ${result.error?.message || 'Unknown error'}`);
         }
         this.connectionHealth.recordSuccess();
         return result.value;
@@ -481,12 +615,10 @@ export class SunspecModbusClient {
     /**
      * Helper to read register value(s) using the fault-tolerant reader with data type conversion
      */
-    async readRegisterValue(address, quantity = 1, dataType) {
-        if (!this.faultTolerantReader) {
-            throw new Error('Fault-tolerant reader not initialized');
-        }
+    async readRegisterValue(unitId, address, quantity = 1, dataType) {
+        const reader = this.getReader(unitId);
         try {
-            const result = await this.faultTolerantReader.readHoldingRegisters(address, quantity);
+            const result = await reader.readHoldingRegisters(address, quantity);
             // Check if the read was successful
             if (!result.success || !result.value) {
                 throw new Error(`Failed to read register at address ${address}: ${result.error?.message || 'Unknown error'}`);
@@ -507,10 +639,8 @@ export class SunspecModbusClient {
     /**
      * Helper to write register value(s)
      */
-    async writeRegisterValue(address, value, dataType = 'uint16') {
-        if (!this.modbusClient) {
-            throw new Error('Modbus client not initialized');
-        }
+    async writeRegisterValue(unitId, address, value, dataType = 'uint16') {
+        const instance = this.getInstance(unitId);
         try {
             // Convert value to array of register values
             let registerValues;
@@ -539,9 +669,9 @@ export class SunspecModbusClient {
                 }
             }
             // Write to holding registers
-            await this.modbusClient.writeMultipleRegisters(address, registerValues);
+            await instance.writeMultipleRegisters(address, registerValues);
             this.connectionHealth.recordSuccess();
-            console.log(`Successfully wrote value ${value} to register ${address}`);
+            console.log(`Successfully wrote value ${value} to register ${address} (unit ${unitId})`);
             return true;
         }
         catch (error) {
@@ -551,28 +681,36 @@ export class SunspecModbusClient {
         }
     }
     /**
-     * Read inverter data from Model 101 (Single Phase) / Model 103 (Three Phase)
+     * Read inverter data. Detects which SunSpec inverter model the device exposes —
+     * int+SF (101/103) or float (111/112/113) — by checking the discovered model directory,
+     * and dispatches to the appropriate decoder.
      */
-    async readInverterData() {
-        const model = this.findModel(SunspecModelId.Inverter3Phase);
-        if (!model) {
-            console.debug('Inverter model 103 not found, trying single phase model 101');
-            const singlePhaseModel = this.findModel(SunspecModelId.InverterSinglePhase);
-            if (!singlePhaseModel) {
-                console.error('No inverter model found');
-                return null;
+    async readInverterData(unitId) {
+        const tryOrder = [
+            { id: 103, reader: m => this.readThreePhaseInverterData_IntSF(unitId, m) },
+            { id: 113, reader: m => this.readFloatInverterData(unitId, m, 113) },
+            { id: 112, reader: m => this.readFloatInverterData(unitId, m, 112) },
+            { id: 101, reader: m => this.readSinglePhaseInverterData(unitId, m) },
+            { id: 111, reader: m => this.readFloatInverterData(unitId, m, 111) },
+        ];
+        for (const { id, reader } of tryOrder) {
+            const model = this.findModel(unitId, id);
+            if (model) {
+                console.debug(`Using inverter Model ${id} at address ${model.address} (length ${model.length}) on unit ${unitId}`);
+                return reader(model);
             }
-            console.warn('IMPORTANT: Working with single-phase inverter, but 3-phase is expected!');
-            return this.readSinglePhaseInverterData(singlePhaseModel);
         }
-        console.debug(`Found 3-phase inverter model 103 at address ${model.address} with length ${model.length}`);
+        console.debug(`No inverter model (101/103/111/112/113) on unit ${unitId}`);
+        return null;
+    }
+    /**
+     * Read three-phase inverter data from Model 103 (int + scale factor encoding).
+     */
+    async readThreePhaseInverterData_IntSF(unitId, model) {
         try {
-            // Read entire model block in a single Modbus call
-            console.debug(`Reading Inverter Data from Model ${model.id} at base address: ${model.address}`);
-            const buffer = await this.readModelBlock(model);
-            // Extract all scale factors from buffer
+            console.debug(`Reading Inverter Data from Model 103 at base address: ${model.address} (unit ${unitId})`);
+            const buffer = await this.readModelBlock(unitId, model);
             const scaleFactors = this.extractInverterScaleFactors(buffer);
-            // Extract raw values from buffer
             const acCurrentRaw = this.extractValue(buffer, 2, 'uint16');
             const voltageANRaw = this.extractValue(buffer, 10, 'uint16');
             const voltageBNRaw = this.extractValue(buffer, 11, 'uint16');
@@ -624,7 +762,6 @@ export class SunspecModbusClient {
                 vendorEvents3: this.extractValue(buffer, 48, 'uint32', 2),
                 vendorEvents4: this.extractValue(buffer, 50, 'uint32', 2)
             };
-            // Log non-scaled fields
             this.logRegisterRead(103, 38, 'Operating State', data.operatingState, 'enum16');
             this.logRegisterRead(103, 39, 'Vendor State', data.vendorState, 'uint16');
             this.logRegisterRead(103, 40, 'Events', data.events, 'bitfield32');
@@ -633,7 +770,6 @@ export class SunspecModbusClient {
             this.logRegisterRead(103, 46, 'Vendor Events 2', data.vendorEvents2, 'bitfield32');
             this.logRegisterRead(103, 48, 'Vendor Events 3', data.vendorEvents3, 'bitfield32');
             this.logRegisterRead(103, 50, 'Vendor Events 4', data.vendorEvents4, 'bitfield32');
-            // Read AC Energy (32-bit accumulator) - Offset 24-25
             const acEnergy = this.extractValue(buffer, 24, 'uint32', 2);
             this.logRegisterRead(103, 24, 'AC Energy', acEnergy, 'acc32');
             data.acEnergy = !this.isUnimplementedValue(acEnergy, 'acc32')
@@ -650,49 +786,49 @@ export class SunspecModbusClient {
     /**
      * Read single phase inverter data (Model 101)
      */
-    async readSinglePhaseInverterData(model) {
+    async readSinglePhaseInverterData(unitId, model) {
         try {
-            console.debug(`Reading Single-Phase Inverter Data from Model 101 at base address: ${model.address}`);
+            console.debug(`Reading Single-Phase Inverter Data from Model 101 at base address: ${model.address} (unit ${unitId})`);
             // Read entire model block in a single Modbus call
-            const buffer = await this.readModelBlock(model);
-            // Extract scale factors from buffer
+            const buffer = await this.readModelBlock(unitId, model);
+            // Extract scale factors from buffer (offsets aligned with Model 103 reader, which works on real
+            // hardware; differs from the published SunSpec Model 101 spec for DC fields).
             const scaleFactors = {
                 A_SF: this.extractValue(buffer, 6, 'int16'),
                 V_SF: this.extractValue(buffer, 13, 'int16'),
-                W_SF: this.extractValue(buffer, 10, 'int16'),
-                Hz_SF: this.extractValue(buffer, 12, 'int16'),
+                W_SF: this.extractValue(buffer, 15, 'int16'),
+                Hz_SF: this.extractValue(buffer, 17, 'int16'),
                 WH_SF: this.extractValue(buffer, 26, 'int16'),
-                DCA_SF: this.extractValue(buffer, 18, 'int16'),
-                DCV_SF: this.extractValue(buffer, 19, 'int16'),
-                DCW_SF: this.extractValue(buffer, 21, 'int16')
+                DCA_SF: this.extractValue(buffer, 28, 'int16'),
+                DCV_SF: this.extractValue(buffer, 29, 'int16'),
+                DCW_SF: this.extractValue(buffer, 31, 'int16')
             };
             this.logRegisterRead(101, 6, 'A_SF', scaleFactors.A_SF, 'int16');
             this.logRegisterRead(101, 13, 'V_SF', scaleFactors.V_SF, 'int16');
-            this.logRegisterRead(101, 10, 'W_SF', scaleFactors.W_SF, 'int16');
-            this.logRegisterRead(101, 12, 'Hz_SF', scaleFactors.Hz_SF, 'int16');
+            this.logRegisterRead(101, 15, 'W_SF', scaleFactors.W_SF, 'int16');
+            this.logRegisterRead(101, 17, 'Hz_SF', scaleFactors.Hz_SF, 'int16');
             this.logRegisterRead(101, 26, 'WH_SF', scaleFactors.WH_SF, 'int16');
-            this.logRegisterRead(101, 18, 'DCA_SF', scaleFactors.DCA_SF, 'int16');
-            this.logRegisterRead(101, 19, 'DCV_SF', scaleFactors.DCV_SF, 'int16');
-            this.logRegisterRead(101, 21, 'DCW_SF', scaleFactors.DCW_SF, 'int16');
-            // Extract raw values from buffer
+            this.logRegisterRead(101, 28, 'DCA_SF', scaleFactors.DCA_SF, 'int16');
+            this.logRegisterRead(101, 29, 'DCV_SF', scaleFactors.DCV_SF, 'int16');
+            this.logRegisterRead(101, 31, 'DCW_SF', scaleFactors.DCW_SF, 'int16');
             const acCurrentRaw = this.extractValue(buffer, 2, 'uint16');
-            const voltageRaw = this.extractValue(buffer, 7, 'uint16');
-            const acPowerRaw = this.extractValue(buffer, 9, 'int16');
-            const freqRaw = this.extractValue(buffer, 11, 'uint16');
-            const dcCurrentRaw = this.extractValue(buffer, 14, 'uint16');
-            const dcVoltageRaw = this.extractValue(buffer, 15, 'uint16');
-            const dcPowerRaw = this.extractValue(buffer, 20, 'int16');
-            const stateRaw = this.extractValue(buffer, 24, 'uint16');
-            this.logRegisterRead(101, 24, 'Operating State', stateRaw, 'enum16');
+            const voltageRaw = this.extractValue(buffer, 10, 'uint16');
+            const acPowerRaw = this.extractValue(buffer, 14, 'int16');
+            const freqRaw = this.extractValue(buffer, 16, 'uint16');
+            const dcCurrentRaw = this.extractValue(buffer, 27, 'uint16');
+            const dcVoltageRaw = this.extractValue(buffer, 28, 'uint16');
+            const dcPowerRaw = this.extractValue(buffer, 30, 'int16');
+            const stateRaw = this.extractValue(buffer, 38, 'uint16');
+            this.logRegisterRead(101, 38, 'Operating State', stateRaw, 'enum16');
             const data = {
                 blockNumber: 101,
-                voltageAN: this.applyScaleFactor(voltageRaw, scaleFactors.V_SF, 'uint16', 'Voltage AN', 7, 101),
+                voltageAN: this.applyScaleFactor(voltageRaw, scaleFactors.V_SF, 'uint16', 'Voltage AN', 10, 101),
                 acCurrent: this.applyScaleFactor(acCurrentRaw, scaleFactors.A_SF, 'uint16', 'AC Current', 2, 101),
-                acPower: this.applyScaleFactor(acPowerRaw, scaleFactors.W_SF, 'int16', 'AC Power', 9, 101),
-                frequency: this.applyScaleFactor(freqRaw, scaleFactors.Hz_SF, 'uint16', 'Frequency', 11, 101),
-                dcCurrent: this.applyScaleFactor(dcCurrentRaw, scaleFactors.DCA_SF, 'uint16', 'DC Current', 14, 101),
-                dcVoltage: this.applyScaleFactor(dcVoltageRaw, scaleFactors.DCV_SF, 'uint16', 'DC Voltage', 15, 101),
-                dcPower: this.applyScaleFactor(dcPowerRaw, scaleFactors.DCW_SF, 'int16', 'DC Power', 20, 101),
+                acPower: this.applyScaleFactor(acPowerRaw, scaleFactors.W_SF, 'int16', 'AC Power', 14, 101),
+                frequency: this.applyScaleFactor(freqRaw, scaleFactors.Hz_SF, 'uint16', 'Frequency', 16, 101),
+                dcCurrent: this.applyScaleFactor(dcCurrentRaw, scaleFactors.DCA_SF, 'uint16', 'DC Current', 27, 101),
+                dcVoltage: this.applyScaleFactor(dcVoltageRaw, scaleFactors.DCV_SF, 'uint16', 'DC Voltage', 28, 101),
+                dcPower: this.applyScaleFactor(dcPowerRaw, scaleFactors.DCW_SF, 'int16', 'DC Power', 30, 101),
                 operatingState: stateRaw
             };
             // Read AC Energy (32-bit accumulator) - Offset 24-25
@@ -709,6 +845,70 @@ export class SunspecModbusClient {
             return null;
         }
     }
+    /**
+     * Read inverter data from a float-variant model: 111 (single-phase), 112 (split-phase), or 113 (three-phase).
+     *
+     * All three models share the same SunSpec register layout — measurement fields are 32-bit IEEE 754 floats
+     * (no scale factors), status registers stay enum16, event registers stay bitfield32. Phase scope differs
+     * by model: 111 populates phase A only; 112 phases A+B; 113 all three. Unpopulated phase fields read NaN
+     * and are returned as undefined.
+     */
+    async readFloatInverterData(unitId, model, blockNumber) {
+        try {
+            console.debug(`Reading Float Inverter Data from Model ${blockNumber} at base address: ${model.address} (unit ${unitId})`);
+            const buffer = await this.readModelBlock(unitId, model);
+            const data = {
+                blockNumber,
+                blockAddress: model.address,
+                blockLength: model.length,
+                acCurrent: this.extractFloat32OrUndefined(buffer, 2, blockNumber, 'AC Current'),
+                phaseACurrent: this.extractFloat32OrUndefined(buffer, 4, blockNumber, 'Phase A Current'),
+                phaseBCurrent: this.extractFloat32OrUndefined(buffer, 6, blockNumber, 'Phase B Current'),
+                phaseCCurrent: this.extractFloat32OrUndefined(buffer, 8, blockNumber, 'Phase C Current'),
+                voltageAB: this.extractFloat32OrUndefined(buffer, 10, blockNumber, 'Voltage AB'),
+                voltageBC: this.extractFloat32OrUndefined(buffer, 12, blockNumber, 'Voltage BC'),
+                voltageCA: this.extractFloat32OrUndefined(buffer, 14, blockNumber, 'Voltage CA'),
+                voltageAN: this.extractFloat32OrUndefined(buffer, 16, blockNumber, 'Voltage AN'),
+                voltageBN: this.extractFloat32OrUndefined(buffer, 18, blockNumber, 'Voltage BN'),
+                voltageCN: this.extractFloat32OrUndefined(buffer, 20, blockNumber, 'Voltage CN'),
+                acPower: this.extractFloat32OrUndefined(buffer, 22, blockNumber, 'AC Power'),
+                frequency: this.extractFloat32OrUndefined(buffer, 24, blockNumber, 'Frequency'),
+                apparentPower: this.extractFloat32OrUndefined(buffer, 26, blockNumber, 'Apparent Power'),
+                reactivePower: this.extractFloat32OrUndefined(buffer, 28, blockNumber, 'Reactive Power'),
+                powerFactor: this.extractFloat32OrUndefined(buffer, 30, blockNumber, 'Power Factor'),
+                acEnergy: this.extractFloat32OrUndefined(buffer, 32, blockNumber, 'AC Energy'),
+                dcCurrent: this.extractFloat32OrUndefined(buffer, 34, blockNumber, 'DC Current'),
+                dcVoltage: this.extractFloat32OrUndefined(buffer, 36, blockNumber, 'DC Voltage'),
+                dcPower: this.extractFloat32OrUndefined(buffer, 38, blockNumber, 'DC Power'),
+                cabinetTemperature: this.extractFloat32OrUndefined(buffer, 40, blockNumber, 'Cabinet Temperature'),
+                heatSinkTemperature: this.extractFloat32OrUndefined(buffer, 42, blockNumber, 'Heat Sink Temperature'),
+                transformerTemperature: this.extractFloat32OrUndefined(buffer, 44, blockNumber, 'Transformer Temperature'),
+                otherTemperature: this.extractFloat32OrUndefined(buffer, 46, blockNumber, 'Other Temperature'),
+                operatingState: this.extractValue(buffer, 48, 'uint16'),
+                vendorState: this.extractValue(buffer, 49, 'uint16'),
+                events: this.extractValue(buffer, 50, 'uint32', 2),
+                events2: this.extractValue(buffer, 52, 'uint32', 2),
+                vendorEvents1: this.extractValue(buffer, 54, 'uint32', 2),
+                vendorEvents2: this.extractValue(buffer, 56, 'uint32', 2),
+                vendorEvents3: this.extractValue(buffer, 58, 'uint32', 2),
+                vendorEvents4: this.extractValue(buffer, 60, 'uint32', 2),
+            };
+            this.logRegisterRead(blockNumber, 48, 'Operating State', data.operatingState, 'enum16');
+            this.logRegisterRead(blockNumber, 49, 'Vendor State', data.vendorState, 'enum16');
+            this.logRegisterRead(blockNumber, 50, 'Events', data.events, 'bitfield32');
+            this.logRegisterRead(blockNumber, 52, 'Events2', data.events2, 'bitfield32');
+            this.logRegisterRead(blockNumber, 54, 'Vendor Events 1', data.vendorEvents1, 'bitfield32');
+            this.logRegisterRead(blockNumber, 56, 'Vendor Events 2', data.vendorEvents2, 'bitfield32');
+            this.logRegisterRead(blockNumber, 58, 'Vendor Events 3', data.vendorEvents3, 'bitfield32');
+            this.logRegisterRead(blockNumber, 60, 'Vendor Events 4', data.vendorEvents4, 'bitfield32');
+            console.debug(`[Model ${blockNumber}] Float Inverter Data:`, data);
+            return data;
+        }
+        catch (error) {
+            console.error(`Error reading float inverter data (Model ${blockNumber}): ${error}`);
+            return null;
+        }
+    }
     /**
      * Extract inverter scale factors from a pre-read model buffer
      */
@@ -776,6 +976,16 @@ export class SunspecModbusClient {
             console.debug(`[Model ${modelId}] offset ${offset}: ${fieldName} = "${rawValue}"${typeInfo}`);
         }
     }
+    /**
+     * Read a float32 (IEEE 754, big-endian, 2 registers) from a model buffer.
+     * SunSpec uses NaN as the "unimplemented" sentinel for floats; returns undefined in that case.
+     */
+    extractFloat32OrUndefined(buffer, offset, modelId, fieldName) {
+        const value = this.extractValue(buffer, offset, 'float32', 2);
+        const display = Number.isNaN(value) ? 'NaN' : value;
+        console.debug(`[Model ${modelId}] offset ${offset}: ${fieldName} = ${display} (float32)`);
+        return Number.isNaN(value) ? undefined : value;
+    }
     /**
      * Read scale factors from Model 160 (MPPT)
      *
@@ -803,18 +1013,18 @@ export class SunspecModbusClient {
         this.logRegisterRead(160, 5, 'DCWH_SF', scaleFactors.DCWH_SF, 'int16');
         return scaleFactors;
     }
-    async readMPPTScaleFactors() {
-        const model = this.findModel(SunspecModelId.MPPT);
+    async readMPPTScaleFactors(unitId) {
+        const model = this.findModel(unitId, SunspecModelId.MPPT);
         if (!model) {
-            console.debug('MPPT model 160 not found');
+            console.debug(`MPPT model 160 not found on unit ${unitId}`);
             return null;
         }
         try {
-            const buffer = await this.readModelBlock(model);
+            const buffer = await this.readModelBlock(unitId, model);
             return this.extractMPPTScaleFactors(buffer);
         }
         catch (error) {
-            console.error(`Error reading MPPT scale factors: ${error}`);
+            console.error(`Error reading MPPT scale factors (unit ${unitId}): ${error}`);
             return null;
         }
     }
@@ -875,36 +1085,36 @@ export class SunspecModbusClient {
     /**
      * Read MPPT data from Model 160
      */
-    async readMPPTData(moduleId = 1) {
-        const model = this.findModel(SunspecModelId.MPPT);
+    async readMPPTData(unitId, moduleId = 1) {
+        const model = this.findModel(unitId, SunspecModelId.MPPT);
         if (!model) {
-            console.debug('MPPT model 160 not found');
+            console.debug(`MPPT model 160 not found on unit ${unitId}`);
             return null;
         }
         try {
             // Read entire model block in a single Modbus call
-            const buffer = await this.readModelBlock(model);
+            const buffer = await this.readModelBlock(unitId, model);
             const scaleFactors = this.extractMPPTScaleFactors(buffer);
             return this.extractMPPTModuleData(buffer, model, moduleId, scaleFactors);
         }
         catch (error) {
-            console.error(`Error reading MPPT data for module ${moduleId}: ${error}`);
+            console.error(`Error reading MPPT data for module ${moduleId} (unit ${unitId}): ${error}`);
             return null;
         }
     }
     /**
      * Read all MPPT strings from Model 160 (Multiple MPPT)
      */
-    async readAllMPPTData() {
+    async readAllMPPTData(unitId) {
         const mpptData = [];
-        const model = this.findModel(SunspecModelId.MPPT);
+        const model = this.findModel(unitId, SunspecModelId.MPPT);
         if (!model) {
-            console.debug('MPPT model 160 not found');
+            console.debug(`MPPT model 160 not found on unit ${unitId}`);
             return [];
         }
         try {
             // Read entire model block in a single Modbus call
-            const buffer = await this.readModelBlock(model);
+            const buffer = await this.readModelBlock(unitId, model);
             const scaleFactors = this.extractMPPTScaleFactors(buffer);
             // Read the module count from register 8
             let moduleCount = 4; // Default fallback value
@@ -1065,16 +1275,16 @@ export class SunspecModbusClient {
     /**
      * Read battery base data from Model 802 (Battery Base)
      */
-    async readBatteryBaseData() {
-        const model = this.findModel(SunspecModelId.BatteryBase);
+    async readBatteryBaseData(unitId) {
+        const model = this.findModel(unitId, SunspecModelId.BatteryBase);
         if (!model) {
-            console.debug('Battery Base model 802 not found');
+            console.debug(`Battery Base model 802 not found on unit ${unitId}`);
             return null;
         }
-        console.debug(`Reading Battery Base Data from Model 802 at base address: ${model.address}`);
+        console.debug(`Reading Battery Base Data from Model 802 at base address: ${model.address} (unit ${unitId})`);
         try {
             // Read entire model block in a single Modbus call
-            const buffer = await this.readModelBlock(model);
+            const buffer = await this.readModelBlock(unitId, model);
             // Extract scale factors from buffer (offsets 52-63)
             const sf = this.extractBatteryBaseScaleFactors(buffer);
             // Extract raw values from buffer
@@ -1203,27 +1413,27 @@ export class SunspecModbusClient {
     /**
      * Read battery data from Model 124 (Basic Storage) with fallback to Model 802 / Model 803
      */
-    async readBatteryData() {
+    async readBatteryData(unitId) {
         // Try Model 124 first (Basic Storage Controls)
-        let model = this.findModel(SunspecModelId.Battery);
+        let model = this.findModel(unitId, SunspecModelId.Battery);
         // Fall back to other battery models if needed
         if (!model) {
-            model = this.findModel(SunspecModelId.BatteryBase);
+            model = this.findModel(unitId, SunspecModelId.BatteryBase);
         }
         if (!model) {
-            model = this.findModel(SunspecModelId.BatteryControl);
+            model = this.findModel(unitId, SunspecModelId.BatteryControl);
         }
         if (!model) {
-            console.debug('No battery model found');
+            console.debug(`No battery model found on unit ${unitId}`);
             return null;
         }
-        console.debug(`Reading Battery Data from Model ${model.id} at base address: ${model.address}`);
+        console.debug(`Reading Battery Data from Model ${model.id} at base address: ${model.address} (unit ${unitId})`);
         try {
             if (model.id === 124) {
                 // Model 124: Basic Storage Controls
                 console.debug('Using Model 124 (Basic Storage Controls)');
                 // Read entire model block in a single Modbus call
-                const buffer = await this.readModelBlock(model);
+                const buffer = await this.readModelBlock(unitId, model);
                 // Extract scale factors from buffer (offsets 18-25)
                 const scaleFactors = {
                     WChaMax_SF: this.extractValue(buffer, 18, 'int16'),
@@ -1324,7 +1534,7 @@ export class SunspecModbusClient {
             else if (model.id === 802) {
                 // Model 802: Battery Base
                 console.debug('Using Model 802 (Battery Base)');
-                const baseData = await this.readBatteryBaseData();
+                const baseData = await this.readBatteryBaseData(unitId);
                 if (!baseData) {
                     return null;
                 }
@@ -1376,55 +1586,55 @@ export class SunspecModbusClient {
     /**
      * Write battery control settings to Model 124
      */
-    async writeBatteryControls(controls) {
-        const model = this.findModel(SunspecModelId.Battery);
+    async writeBatteryControls(unitId, controls) {
+        const model = this.findModel(unitId, SunspecModelId.Battery);
         if (!model) {
-            console.error('Battery model 124 not found');
+            console.error(`Battery model 124 not found on unit ${unitId}`);
             return false;
         }
         const baseAddr = model.address;
-        console.log(`Writing Battery Controls to Model 124 at base address: ${baseAddr}`);
+        console.log(`Writing Battery Controls to Model 124 at base address: ${baseAddr} (unit ${unitId})`);
         try {
             // Write storage control mode (Register 5)
             if (controls.storCtlMod !== undefined) {
-                await this.writeRegisterValue(baseAddr + 5, controls.storCtlMod, 'uint16');
+                await this.writeRegisterValue(unitId, baseAddr + 5, controls.storCtlMod, 'uint16');
                 console.log(`Set storage control mode to 0x${controls.storCtlMod.toString(16)}`);
             }
             // Write charge source setting (Register 17)
             if (controls.chaGriSet !== undefined) {
-                await this.writeRegisterValue(baseAddr + 17, controls.chaGriSet, 'uint16');
+                await this.writeRegisterValue(unitId, baseAddr + 17, controls.chaGriSet, 'uint16');
                 console.log(`Set charge source to ${controls.chaGriSet === SunspecChargeSource.GRID ? 'GRID' : 'PV'}`);
             }
             // Write maximum charge power (Register 2) - needs scale factor
             if (controls.wChaMax !== undefined) {
                 const scaleFactorAddr = baseAddr + 18;
-                const scaleFactor = await this.readRegisterValue(scaleFactorAddr, 1, 'int16');
+                const scaleFactor = await this.readRegisterValue(unitId, scaleFactorAddr, 1, 'int16');
                 const scaledValue = Math.round(controls.wChaMax / Math.pow(10, scaleFactor));
-                await this.writeRegisterValue(baseAddr + 2, scaledValue, 'uint16');
+                await this.writeRegisterValue(unitId, baseAddr + 2, scaledValue, 'uint16');
                 console.log(`Set max charge power to ${controls.wChaMax}W (scaled: ${scaledValue})`);
             }
             // Write charge rate (Register 13) - needs scale factor
             if (controls.inWRte !== undefined) {
                 const scaleFactorAddr = baseAddr + 25;
-                const scaleFactor = await this.readRegisterValue(scaleFactorAddr, 1, 'int16');
+                const scaleFactor = await this.readRegisterValue(unitId, scaleFactorAddr, 1, 'int16');
                 const scaledValue = Math.round(controls.inWRte / Math.pow(10, scaleFactor));
-                await this.writeRegisterValue(baseAddr + 13, scaledValue, 'int16');
+                await this.writeRegisterValue(unitId, baseAddr + 13, scaledValue, 'int16');
                 console.log(`Set charge rate to ${controls.inWRte}% (scaled: ${scaledValue})`);
             }
             // Write discharge rate (Register 12) - needs scale factor
             if (controls.outWRte !== undefined) {
                 const scaleFactorAddr = baseAddr + 25;
-                const scaleFactor = await this.readRegisterValue(scaleFactorAddr, 1, 'int16');
+                const scaleFactor = await this.readRegisterValue(unitId, scaleFactorAddr, 1, 'int16');
                 const scaledValue = Math.round(controls.outWRte / Math.pow(10, scaleFactor));
-                await this.writeRegisterValue(baseAddr + 12, scaledValue, 'int16');
+                await this.writeRegisterValue(unitId, baseAddr + 12, scaledValue, 'int16');
                 console.log(`Set discharge rate to ${controls.outWRte}% (scaled: ${scaledValue})`);
             }
             // Write minimum reserve percentage (Register 7) - needs scale factor
             if (controls.minRsvPct !== undefined) {
                 const scaleFactorAddr = baseAddr + 21;
-                const scaleFactor = await this.readRegisterValue(scaleFactorAddr, 1, 'int16');
+                const scaleFactor = await this.readRegisterValue(unitId, scaleFactorAddr, 1, 'int16');
                 const scaledValue = Math.round(controls.minRsvPct / Math.pow(10, scaleFactor));
-                await this.writeRegisterValue(baseAddr + 7, scaledValue, 'uint16');
+                await this.writeRegisterValue(unitId, baseAddr + 7, scaledValue, 'uint16');
                 console.log(`Set minimum reserve to ${controls.minRsvPct}% (scaled: ${scaledValue})`);
             }
             console.log('Battery controls written successfully');
@@ -1438,7 +1648,7 @@ export class SunspecModbusClient {
     /**
      * Set battery storage mode (simplified interface)
      */
-    async setStorageMode(mode) {
+    async setStorageMode(unitId, mode) {
         let storCtlMod;
         switch (mode) {
             case SunspecStorageMode.CHARGE:
@@ -1462,29 +1672,29 @@ export class SunspecModbusClient {
                 return false;
         }
         console.log(`Setting storage mode to ${mode} (control bits: 0x${storCtlMod.toString(16)})`);
-        return this.writeBatteryControls({ storCtlMod });
+        return this.writeBatteryControls(unitId, { storCtlMod });
     }
     /**
      * Enable or disable grid charging
      */
-    async enableGridCharging(enable) {
+    async enableGridCharging(unitId, enable) {
         const chaGriSet = enable ? SunspecChargeSource.GRID : SunspecChargeSource.PV;
-        console.log(`${enable ? 'Enabling' : 'Disabling'} grid charging`);
-        return this.writeBatteryControls({ chaGriSet });
+        console.log(`${enable ? 'Enabling' : 'Disabling'} grid charging on unit ${unitId}`);
+        return this.writeBatteryControls(unitId, { chaGriSet });
     }
     /**
      * Read battery control settings from Model 124 (Basic Storage Controls)
      */
-    async readBatteryControls() {
-        const model = this.findModel(SunspecModelId.Battery);
+    async readBatteryControls(unitId) {
+        const model = this.findModel(unitId, SunspecModelId.Battery);
         if (!model) {
-            console.log('Battery model 124 not found');
+            console.log(`Battery model 124 not found on unit ${unitId}`);
             return null;
         }
-        console.log(`Reading Battery Controls from Model 124 at base address: ${model.address}`);
+        console.log(`Reading Battery Controls from Model 124 at base address: ${model.address} (unit ${unitId})`);
         try {
             // Read entire model block in a single Modbus call
-            const buffer = await this.readModelBlock(model);
+            const buffer = await this.readModelBlock(unitId, model);
             // Extract scale factors from buffer
             const scaleFactors = {
                 WChaMax_SF: this.extractValue(buffer, 18, 'int16'),
@@ -1523,19 +1733,19 @@ export class SunspecModbusClient {
     /**
      * Read meter data from Model 201 (Single Phase) / Model 203 (Three Phase) / Model 204 (Split Phase)
      */
-    async readMeterData() {
-        let model = this.findModel(SunspecModelId.Meter3Phase);
+    async readMeterData(unitId) {
+        let model = this.findModel(unitId, SunspecModelId.Meter3Phase);
         if (!model) {
-            model = this.findModel(SunspecModelId.MeterWye);
+            model = this.findModel(unitId, SunspecModelId.MeterWye);
         }
         if (!model) {
-            model = this.findModel(SunspecModelId.MeterSinglePhase);
+            model = this.findModel(unitId, SunspecModelId.MeterSinglePhase);
         }
         if (!model) {
-            console.debug('No meter model found');
+            console.debug(`No meter model found on unit ${unitId}`);
             return null;
         }
-        console.debug(`Reading Meter Data from Model ${model.id} at base address: ${model.address}`);
+        console.debug(`Reading Meter Data from Model ${model.id} at base address: ${model.address} (unit ${unitId})`);
         try {
             // Different meter models have different register offsets
             console.debug(`Meter is Model ${model.id}`);
@@ -1579,7 +1789,7 @@ export class SunspecModbusClient {
                     energySFOffset = 54; // TotWh_SF - Total Energy scale factor
             }
             // Read entire model block in a single Modbus call
-            const buffer = await this.readModelBlock(model);
+            const buffer = await this.readModelBlock(unitId, model);
             // Extract scale factors from buffer
             const powerSF = this.extractValue(buffer, powerSFOffset, 'int16');
             const freqSF = this.extractValue(buffer, freqSFOffset, 'int16');
@@ -1617,16 +1827,16 @@ export class SunspecModbusClient {
     /**
      * Read common block data (Model 1)
      */
-    async readCommonBlock() {
-        const model = this.findModel(SunspecModelId.Common);
+    async readCommonBlock(unitId) {
+        const model = this.findModel(unitId, SunspecModelId.Common);
         if (!model) {
-            console.error('Common block model not found');
+            console.error(`Common block model not found on unit ${unitId}`);
             return null;
         }
-        console.log(`Reading Common Block - Model address: ${model.address}`);
+        console.log(`Reading Common Block - Model address: ${model.address} (unit ${unitId})`);
         try {
             // Read entire model block in a single Modbus call
-            const buffer = await this.readModelBlock(model);
+            const buffer = await this.readModelBlock(unitId, model);
             // Common block offsets are relative to the model start (after ID and Length header,
             // but readModelBlock reads from model.address which includes the data area).
             // The offsets below are relative to the data start within the model block.
@@ -1663,24 +1873,24 @@ export class SunspecModbusClient {
     /**
      * Get serial number from device
      */
-    async getSerialNumber() {
-        const commonData = await this.readCommonBlock();
+    async getSerialNumber(unitId) {
+        const commonData = await this.readCommonBlock(unitId);
         return commonData?.serialNumber;
     }
     /**
-     * Check if connected
+     * Check if a specific unit is connected on this network device
      */
-    isConnected() {
-        return this.connected;
+    isConnected(unitId) {
+        return this.modbusInstances.has(unitId);
     }
     /**
-     * Check if connection is healthy
+     * Check if a specific unit's connection is healthy
      */
-    isHealthy() {
-        return this.connected && this.connectionHealth.isHealthy();
+    isHealthy(unitId) {
+        return this.modbusInstances.has(unitId) && this.connectionHealth.isHealthy();
     }
     /**
-     * Get connection health details
+     * Get connection health details (shared across all units on this network device)
      */
     getConnectionHealth() {
         return this.connectionHealth;
@@ -1688,15 +1898,15 @@ export class SunspecModbusClient {
     /**
      * Read inverter settings from Model 121 (Inverter Settings)
      */
-    async readInverterSettings() {
-        const model = this.findModel(SunspecModelId.Settings);
+    async readInverterSettings(unitId) {
+        const model = this.findModel(unitId, SunspecModelId.Settings);
         if (!model) {
-            console.debug('Settings model 121 not found');
+            console.debug(`Settings model 121 not found on unit ${unitId}`);
             return null;
         }
         try {
             // Read entire model block in a single Modbus call
-            const buffer = await this.readModelBlock(model);
+            const buffer = await this.readModelBlock(unitId, model);
             // Extract scale factors from buffer (offsets 22-31)
             const scaleFactors = {
                 WMax_SF: this.extractValue(buffer, 22, 'int16'),
@@ -1780,15 +1990,15 @@ export class SunspecModbusClient {
     /**
      * Read inverter controls from Model 123 (Immediate Inverter Controls)
      */
-    async readInverterControls() {
-        const model = this.findModel(SunspecModelId.Controls);
+    async readInverterControls(unitId) {
+        const model = this.findModel(unitId, SunspecModelId.Controls);
         if (!model) {
-            console.log('Controls model 123 not found');
+            console.log(`Controls model 123 not found on unit ${unitId}`);
             return null;
         }
         try {
             // Read entire model block in a single Modbus call
-            const buffer = await this.readModelBlock(model);
+            const buffer = await this.readModelBlock(unitId, model);
             // Extract scale factors from buffer (offsets 21-23)
             const scaleFactors = {
                 WMaxLimPct_SF: this.extractValue(buffer, 21, 'int16'),
@@ -1875,27 +2085,28 @@ export class SunspecModbusClient {
     /**
      * Write Block 121 - Inverter Basic Settings
      */
-    async writeInverterSettings(settings) {
-        const model = this.findModel(SunspecModelId.Settings);
+    async writeInverterSettings(unitId, settings) {
+        const model = this.findModel(unitId, SunspecModelId.Settings);
         if (!model) {
-            console.error('Settings model 121 not found');
+            console.error(`Settings model 121 not found on unit ${unitId}`);
             return false;
         }
         const baseAddr = model.address;
         try {
+            const instance = this.getInstance(unitId);
             // For each setting, write the value if provided
             // Note: This is a simplified implementation. In production, you'd batch writes
-            if (settings.WMax !== undefined && this.modbusClient) {
+            if (settings.WMax !== undefined) {
                 // Need to read scale factor first if not provided
-                const sfBuffer = await this.modbusClient.readHoldingRegisters(baseAddr + 22, 1);
+                const sfBuffer = await instance.readHoldingRegisters(baseAddr + 22, 1);
                 const scaleFactor = sfBuffer.readInt16BE(0);
                 const scaledValue = Math.round(settings.WMax / Math.pow(10, scaleFactor));
                 // Writing registers needs to be implemented in EnergyAppModbusInstance
                 // For now, log the write operation
                 console.log(`Would write value ${scaledValue} to register ${baseAddr}`);
             }
-            if (settings.VRef !== undefined && this.modbusClient) {
-                const sfBuffer = await this.modbusClient.readHoldingRegisters(baseAddr + 23, 1);
+            if (settings.VRef !== undefined) {
+                const sfBuffer = await instance.readHoldingRegisters(baseAddr + 23, 1);
                 const scaleFactor = sfBuffer.readInt16BE(0);
                 const scaledValue = Math.round(settings.VRef / Math.pow(10, scaleFactor));
                 console.log(`Would write value ${scaledValue} to register ${baseAddr + 1}`);
@@ -1912,41 +2123,41 @@ export class SunspecModbusClient {
     /**
      * Write inverter controls to Model 123 (Immediate Inverter Controls)
      */
-    async writeInverterControls(controls) {
-        const model = this.findModel(SunspecModelId.Controls);
+    async writeInverterControls(unitId, controls) {
+        const model = this.findModel(unitId, SunspecModelId.Controls);
         if (!model) {
-            console.error('Controls model 123 not found');
+            console.error(`Controls model 123 not found on unit ${unitId}`);
             return false;
         }
         const baseAddr = model.address;
         try {
             // Connection control (Register 2)
             if (controls.Conn !== undefined) {
-                await this.writeRegisterValue(baseAddr + 2, controls.Conn, 'uint16');
+                await this.writeRegisterValue(unitId, baseAddr + 2, controls.Conn, 'uint16');
                 console.log(`Set connection control to ${controls.Conn}`);
             }
             // Power limit control (Register 3) - needs scale factor
             if (controls.WMaxLimPct !== undefined) {
-                const scaleFactor = await this.readRegisterValue(baseAddr + 21, 1, 'int16');
+                const scaleFactor = await this.readRegisterValue(unitId, baseAddr + 21, 1, 'int16');
                 const scaledValue = Math.round(controls.WMaxLimPct / Math.pow(10, scaleFactor));
-                await this.writeRegisterValue(baseAddr + 3, scaledValue, 'uint16');
+                await this.writeRegisterValue(unitId, baseAddr + 3, scaledValue, 'uint16');
                 console.log(`Set power limit to ${controls.WMaxLimPct}% (scaled: ${scaledValue})`);
             }
             // Throttle enable/disable (Register 7)
             if (controls.WMaxLim_Ena !== undefined) {
-                await this.writeRegisterValue(baseAddr + 7, controls.WMaxLim_Ena, 'uint16');
+                await this.writeRegisterValue(unitId, baseAddr + 7, controls.WMaxLim_Ena, 'uint16');
                 console.log(`Set throttle enable to ${controls.WMaxLim_Ena}`);
             }
             // Power factor control (Register 8) - needs scale factor
             if (controls.OutPFSet !== undefined) {
-                const scaleFactor = await this.readRegisterValue(baseAddr + 22, 1, 'int16');
+                const scaleFactor = await this.readRegisterValue(unitId, baseAddr + 22, 1, 'int16');
                 const scaledValue = Math.round(controls.OutPFSet / Math.pow(10, scaleFactor));
-                await this.writeRegisterValue(baseAddr + 8, scaledValue, 'int16');
+                await this.writeRegisterValue(unitId, baseAddr + 8, scaledValue, 'int16');
                 console.log(`Set power factor to ${controls.OutPFSet} (scaled: ${scaledValue})`);
             }
             // Power factor enable/disable (Register 12)
             if (controls.OutPFSet_Ena !== undefined) {
-                await this.writeRegisterValue(baseAddr + 12, controls.OutPFSet_Ena, 'uint16');
+                await this.writeRegisterValue(unitId, baseAddr + 12, controls.OutPFSet_Ena, 'uint16');
                 console.log(`Set PF enable to ${controls.OutPFSet_Ena}`);
             }
             console.log('Inverter controls written successfully');
@@ -1967,21 +2178,21 @@ export class SunspecModbusClient {
      * @param limitW - Power limit in Watts, or null to remove the limit
      * @returns true if successful, false otherwise
      */
-    async setFeedInLimit(limitW) {
+    async setFeedInLimit(unitId, limitW) {
         if (limitW === null) {
             // Remove limit: disable WMaxLim_Ena
-            console.log('Removing feed-in limit (disabling WMaxLim_Ena)');
-            return this.writeInverterControls({ WMaxLim_Ena: SunspecEnableControl.DISABLED });
+            console.log(`Removing feed-in limit (disabling WMaxLim_Ena) on unit ${unitId}`);
+            return this.writeInverterControls(unitId, { WMaxLim_Ena: SunspecEnableControl.DISABLED });
         }
         // Read WMax from Model 121 to compute percentage
-        const settings = await this.readInverterSettings();
+        const settings = await this.readInverterSettings(unitId);
         if (!settings || !settings.WMax) {
-            console.error('Cannot set feed-in limit: unable to read WMax from Model 121');
+            console.error(`Cannot set feed-in limit on unit ${unitId}: unable to read WMax from Model 121`);
             return false;
         }
         const pct = (limitW / settings.WMax) * 100;
-        console.log(`Setting feed-in limit to ${limitW}W (${pct.toFixed(2)}% of WMax ${settings.WMax}W)`);
-        return this.writeInverterControls({
+        console.log(`Setting feed-in limit to ${limitW}W (${pct.toFixed(2)}% of WMax ${settings.WMax}W) on unit ${unitId}`);
+        return this.writeInverterControls(unitId, {
             WMaxLimPct: pct,
             WMaxLim_Ena: SunspecEnableControl.ENABLED
         });