@enyo-energy/sunspec-sdk 0.0.30 → 0.0.32

package/dist/sunspec-modbus-client.js

@@ -16,7 +16,7 @@
  * - pad: 0x8000 (always returns this value)
  * - string: all registers 0x0000 (NULL)
  */
-import { SunspecModelId, SunspecBatteryChargeState, SunspecStorageControlMode, SunspecChargeSource, SunspecStorageMode } from "./sunspec-interfaces.js";
+import { SunspecModelId, SunspecBatteryChargeState, SunspecStorageControlMode, SunspecChargeSource, SunspecStorageMode, SunspecBatteryType, SunspecBatteryBankState } from "./sunspec-interfaces.js";
 import { ConnectionRetryManager } from "./connection-retry-manager.js";
 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";
@@ -227,6 +227,22 @@ export class SunspecModbusClient {
         }
         // 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);
+                if (sunspecId.includes('SunS')) {
+                    console.log(`Detected 0-based addressing mode (base address: ${customBaseAddress})`);
+                    return {
+                        baseAddress: customBaseAddress,
+                        isZeroBased: true,
+                        nextAddress: customBaseAddress + 2
+                    };
+                }
+            }
+            catch (error) {
+                console.debug(`Could not read SunS at ${customBaseAddress}:`, error);
+            }
             // Try 1-based at custom address (customBaseAddress + 1)
             try {
                 const sunspecId = await this.modbusClient.readRegisterStringValue(customBaseAddress + 1, 2);
@@ -242,54 +258,41 @@ export class SunspecModbusClient {
             catch (error) {
                 console.debug(`Could not read SunS at ${customBaseAddress + 1}:`, error);
             }
-            // Try 0-based at custom address
+        }
+        else {
+            // Try 1-based addressing first (most common)
             try {
-                const sunspecId = await this.modbusClient.readRegisterStringValue(customBaseAddress, 2);
+                const sunspecId = await this.modbusClient.readRegisterStringValue(40001, 2);
                 if (sunspecId.includes('SunS')) {
-                    console.log(`Detected 0-based addressing mode (base address: ${customBaseAddress})`);
+                    console.log('Detected 1-based addressing mode (base address: 40001)');
                     return {
-                        baseAddress: customBaseAddress,
-                        isZeroBased: true,
-                        nextAddress: customBaseAddress + 2
+                        baseAddress: 40001,
+                        isZeroBased: false,
+                        nextAddress: 40003
                     };
                 }
             }
             catch (error) {
-                console.debug(`Could not read SunS at ${customBaseAddress}:`, error);
+                console.debug('Could not read SunS at 40001:', error);
             }
-        }
-        // Try 1-based addressing first (most common)
-        try {
-            const sunspecId = await this.modbusClient.readRegisterStringValue(40001, 2);
-            if (sunspecId.includes('SunS')) {
-                console.log('Detected 1-based addressing mode (base address: 40001)');
-                return {
-                    baseAddress: 40001,
-                    isZeroBased: false,
-                    nextAddress: 40003
-                };
+            // Try 0-based addressing
+            try {
+                const sunspecId = await this.modbusClient.readRegisterStringValue(40000, 2);
+                if (sunspecId.includes('SunS')) {
+                    console.log('Detected 0-based addressing mode (base address: 40000)');
+                    return {
+                        baseAddress: 40000,
+                        isZeroBased: true,
+                        nextAddress: 40002
+                    };
+                }
             }
-        }
-        catch (error) {
-            console.debug('Could not read SunS at 40001:', error);
-        }
-        // Try 0-based addressing
-        try {
-            const sunspecId = await this.modbusClient.readRegisterStringValue(40000, 2);
-            if (sunspecId.includes('SunS')) {
-                console.log('Detected 0-based addressing mode (base address: 40000)');
-                return {
-                    baseAddress: 40000,
-                    isZeroBased: true,
-                    nextAddress: 40002
-                };
+            catch (error) {
+                console.debug('Could not read SunS at 40000:', error);
             }
         }
-        catch (error) {
-            console.debug('Could not read SunS at 40000:', error);
-        }
         const addressesChecked = customBaseAddress !== undefined
-            ? `${customBaseAddress}, ${customBaseAddress + 1}, 40000, or 40001`
+            ? `${customBaseAddress}, ${customBaseAddress + 1}`
             : '40000 or 40001';
         throw new Error(`Device is not SunSpec compliant - "SunS" identifier not found at addresses ${addressesChecked}`);
     }
@@ -519,64 +522,44 @@ export class SunspecModbusClient {
             const voltageANRaw = await this.readRegisterValue(baseAddr + 10, 1, 'uint16');
             const voltageBNRaw = await this.readRegisterValue(baseAddr + 11, 1, 'uint16');
             const voltageCNRaw = await this.readRegisterValue(baseAddr + 12, 1, 'uint16');
+            // Read raw values for fields that need IIFEs removed
+            const acCurrentRaw = await this.readRegisterValue(baseAddr + 2, 1, 'uint16');
+            const acPowerRaw = await this.readRegisterValue(baseAddr + 14, 1, 'int16');
+            const dcCurrentRaw = await this.readRegisterValue(baseAddr + 27, 1, 'uint16');
+            const dcVoltageRaw = await this.readRegisterValue(baseAddr + 28, 1, 'uint16');
+            const dcPowerRaw = await this.readRegisterValue(baseAddr + 30, 1, 'int16');
             const data = {
                 blockNumber: 103,
                 blockAddress: model.address,
                 blockLength: model.length,
                 // AC Current values - Offsets 2-5
-                acCurrent: this.applyScaleFactor(await (async () => {
-                    const addr = baseAddr + 2;
-                    const raw = await this.readRegisterValue(addr, 1, 'uint16');
-                    console.log(`AC Current: address=${addr}, raw=0x${raw.toString(16).toUpperCase()} (${raw})`);
-                    return raw;
-                })(), scaleFactors.A_SF, 'uint16', 'AC Current'),
-                phaseACurrent: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 3, 1, 'uint16'), scaleFactors.A_SF, 'uint16', 'Phase A Current'),
-                phaseBCurrent: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 4, 1, 'uint16'), scaleFactors.A_SF, 'uint16', 'Phase B Current'),
-                phaseCCurrent: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 5, 1, 'uint16'), scaleFactors.A_SF, 'uint16', 'Phase C Current'),
+                acCurrent: this.applyScaleFactor(acCurrentRaw, scaleFactors.A_SF, 'uint16', 'AC Current', 2, 103),
+                phaseACurrent: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 3, 1, 'uint16'), scaleFactors.A_SF, 'uint16', 'Phase A Current', 3, 103),
+                phaseBCurrent: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 4, 1, 'uint16'), scaleFactors.A_SF, 'uint16', 'Phase B Current', 4, 103),
+                phaseCCurrent: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 5, 1, 'uint16'), scaleFactors.A_SF, 'uint16', 'Phase C Current', 5, 103),
                 // Voltage values - Offsets 7-12
-                voltageAB: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 7, 1, 'uint16'), scaleFactors.V_SF, 'uint16', 'Voltage AB'),
-                voltageBC: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 8, 1, 'uint16'), scaleFactors.V_SF, 'uint16', 'Voltage BC'),
-                voltageCA: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 9, 1, 'uint16'), scaleFactors.V_SF, 'uint16', 'Voltage CA'),
-                // Apply scale factor with unimplemented value checking
-                voltageAN: this.applyScaleFactor(voltageANRaw, scaleFactors.V_SF, 'uint16', 'Voltage AN'),
-                voltageBN: this.applyScaleFactor(voltageBNRaw, scaleFactors.V_SF, 'uint16', 'Voltage BN'),
-                voltageCN: this.applyScaleFactor(voltageCNRaw, scaleFactors.V_SF, 'uint16', 'Voltage CN'),
+                voltageAB: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 7, 1, 'uint16'), scaleFactors.V_SF, 'uint16', 'Voltage AB', 7, 103),
+                voltageBC: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 8, 1, 'uint16'), scaleFactors.V_SF, 'uint16', 'Voltage BC', 8, 103),
+                voltageCA: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 9, 1, 'uint16'), scaleFactors.V_SF, 'uint16', 'Voltage CA', 9, 103),
+                voltageAN: this.applyScaleFactor(voltageANRaw, scaleFactors.V_SF, 'uint16', 'Voltage AN', 10, 103),
+                voltageBN: this.applyScaleFactor(voltageBNRaw, scaleFactors.V_SF, 'uint16', 'Voltage BN', 11, 103),
+                voltageCN: this.applyScaleFactor(voltageCNRaw, scaleFactors.V_SF, 'uint16', 'Voltage CN', 12, 103),
                 // Power values - Offsets 14, 18, 20, 22
-                acPower: this.applyScaleFactor(await (async () => {
-                    const addr = baseAddr + 14;
-                    const raw = await this.readRegisterValue(addr, 1, 'int16');
-                    console.log(`AC Power (W): address=${addr}, raw=0x${raw.toString(16).toUpperCase()} (${raw}), SF=${scaleFactors.W_SF}`);
-                    return raw;
-                })(), scaleFactors.W_SF, 'int16', 'AC Power'),
-                apparentPower: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 18, 1, 'uint16'), scaleFactors.VA_SF, 'uint16', 'Apparent Power'),
-                reactivePower: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 20, 1, 'int16'), scaleFactors.VAr_SF, 'int16', 'Reactive Power'),
-                powerFactor: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 22, 1, 'int16'), scaleFactors.PF_SF, 'int16', 'Power Factor'),
+                acPower: this.applyScaleFactor(acPowerRaw, scaleFactors.W_SF, 'int16', 'AC Power', 14, 103),
+                apparentPower: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 18, 1, 'uint16'), scaleFactors.VA_SF, 'uint16', 'Apparent Power', 18, 103),
+                reactivePower: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 20, 1, 'int16'), scaleFactors.VAr_SF, 'int16', 'Reactive Power', 20, 103),
+                powerFactor: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 22, 1, 'int16'), scaleFactors.PF_SF, 'int16', 'Power Factor', 22, 103),
                 // Frequency - Offset 16
-                frequency: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 16, 1, 'uint16'), scaleFactors.Hz_SF, 'uint16', 'Frequency'),
+                frequency: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 16, 1, 'uint16'), scaleFactors.Hz_SF, 'uint16', 'Frequency', 16, 103),
                 // DC values - Offsets 27, 28, 30
-                dcCurrent: this.applyScaleFactor(await (async () => {
-                    const addr = baseAddr + 27;
-                    const raw = await this.readRegisterValue(addr, 1, 'uint16');
-                    console.log(`DC Current: address=${addr}, raw=0x${raw.toString(16).toUpperCase()} (${raw})`);
-                    return raw;
-                })(), scaleFactors.DCA_SF, 'uint16', 'DC Current'),
-                dcVoltage: this.applyScaleFactor(await (async () => {
-                    const addr = baseAddr + 28;
-                    const raw = await this.readRegisterValue(addr, 1, 'uint16');
-                    console.log(`DC Voltage: address=${addr}, raw=0x${raw.toString(16).toUpperCase()} (${raw})`);
-                    return raw;
-                })(), scaleFactors.DCV_SF, 'uint16', 'DC Voltage'),
-                dcPower: this.applyScaleFactor(await (async () => {
-                    const addr = baseAddr + 30;
-                    const raw = await this.readRegisterValue(addr, 1, 'int16');
-                    console.log(`DC Power: address=${addr}, raw=0x${raw.toString(16).toUpperCase()} (${raw}), SF=${scaleFactors.DCW_SF}`);
-                    return raw;
-                })(), scaleFactors.DCW_SF, 'int16', 'DC Power'),
+                dcCurrent: this.applyScaleFactor(dcCurrentRaw, scaleFactors.DCA_SF, 'uint16', 'DC Current', 27, 103),
+                dcVoltage: this.applyScaleFactor(dcVoltageRaw, scaleFactors.DCV_SF, 'uint16', 'DC Voltage', 28, 103),
+                dcPower: this.applyScaleFactor(dcPowerRaw, scaleFactors.DCW_SF, 'int16', 'DC Power', 30, 103),
                 // Temperature values - Offsets 32, 34, 35, 36
-                cabinetTemperature: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 32, 1, 'int16'), scaleFactors.Tmp_SF, 'int16', 'Cabinet Temperature'),
-                heatSinkTemperature: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 34, 1, 'int16'), scaleFactors.Tmp_SF, 'int16', 'Heat Sink Temperature'),
-                transformerTemperature: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 35, 1, 'int16'), scaleFactors.Tmp_SF, 'int16', 'Transformer Temperature'),
-                otherTemperature: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 36, 1, 'int16'), scaleFactors.Tmp_SF, 'int16', 'Other Temperature'),
+                cabinetTemperature: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 32, 1, 'int16'), scaleFactors.Tmp_SF, 'int16', 'Cabinet Temperature', 32, 103),
+                heatSinkTemperature: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 34, 1, 'int16'), scaleFactors.Tmp_SF, 'int16', 'Heat Sink Temperature', 34, 103),
+                transformerTemperature: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 35, 1, 'int16'), scaleFactors.Tmp_SF, 'int16', 'Transformer Temperature', 35, 103),
+                otherTemperature: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 36, 1, 'int16'), scaleFactors.Tmp_SF, 'int16', 'Other Temperature', 36, 103),
                 // Status values - Offsets 38, 39
                 operatingState: await this.readRegisterValue(baseAddr + 38, 1, 'uint16'),
                 vendorState: await this.readRegisterValue(baseAddr + 39, 1, 'uint16'),
@@ -588,11 +571,20 @@ export class SunspecModbusClient {
                 vendorEvents3: await this.readRegisterValue(baseAddr + 48, 2, 'uint32'),
                 vendorEvents4: await this.readRegisterValue(baseAddr + 50, 2, 'uint32')
             };
+            // 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');
+            this.logRegisterRead(103, 42, 'Events2', data.events2, 'bitfield32');
+            this.logRegisterRead(103, 44, 'Vendor Events 1', data.vendorEvents1, 'bitfield32');
+            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 acEnergyAddr = baseAddr + 24;
-            const acEnergy = await this.readRegisterValue(acEnergyAddr, 2, 'uint32');
+            const acEnergy = await this.readRegisterValue(baseAddr + 24, 2, 'uint32');
+            this.logRegisterRead(103, 24, 'AC Energy', acEnergy, 'acc32');
             data.acEnergy = !this.isUnimplementedValue(acEnergy, 'acc32')
-                ? acEnergy * Math.pow(10, scaleFactors.WH_SF) // Regular number with scale factor
+                ? acEnergy * Math.pow(10, scaleFactors.WH_SF)
                 : undefined;
             return data;
         }
@@ -620,41 +612,32 @@ export class SunspecModbusClient {
                 DCV_SF: await this.readRegisterValue(baseAddr + 19, 1, 'int16'),
                 DCW_SF: await this.readRegisterValue(baseAddr + 21, 1, 'int16')
             };
-            console.log('Single-Phase Inverter Scale Factors:', JSON.stringify(scaleFactors, null, 2));
-            // Read raw values with logging
-            const acCurrentAddr = baseAddr + 2;
-            const acCurrentRaw = await this.readRegisterValue(acCurrentAddr, 1, 'uint16');
-            console.log(`AC Current: address=${acCurrentAddr}, raw=0x${acCurrentRaw.toString(16).toUpperCase()} (${acCurrentRaw})`);
-            const voltageAddr = baseAddr + 7;
-            const voltageRaw = await this.readRegisterValue(voltageAddr, 1, 'uint16');
-            console.log(`AC Voltage: address=${voltageAddr}, raw=0x${voltageRaw.toString(16).toUpperCase()} (${voltageRaw})`);
-            const acPowerAddr = baseAddr + 9;
-            const acPowerRaw = await this.readRegisterValue(acPowerAddr, 1, 'int16');
-            console.log(`AC Power: address=${acPowerAddr}, raw=0x${acPowerRaw.toString(16).toUpperCase()} (${acPowerRaw}), SF=${scaleFactors.W_SF}`);
-            const freqAddr = baseAddr + 11;
-            const freqRaw = await this.readRegisterValue(freqAddr, 1, 'uint16');
-            console.log(`Frequency: address=${freqAddr}, raw=0x${freqRaw.toString(16).toUpperCase()} (${freqRaw})`);
-            const dcCurrentAddr = baseAddr + 14;
-            const dcCurrentRaw = await this.readRegisterValue(dcCurrentAddr, 1, 'uint16');
-            console.log(`DC Current: address=${dcCurrentAddr}, raw=0x${dcCurrentRaw.toString(16).toUpperCase()} (${dcCurrentRaw})`);
-            const dcVoltageAddr = baseAddr + 15;
-            const dcVoltageRaw = await this.readRegisterValue(dcVoltageAddr, 1, 'uint16');
-            console.log(`DC Voltage: address=${dcVoltageAddr}, raw=0x${dcVoltageRaw.toString(16).toUpperCase()} (${dcVoltageRaw})`);
-            const dcPowerAddr = baseAddr + 20;
-            const dcPowerRaw = await this.readRegisterValue(dcPowerAddr, 1, 'int16');
-            console.log(`DC Power: address=${dcPowerAddr}, raw=0x${dcPowerRaw.toString(16).toUpperCase()} (${dcPowerRaw}), SF=${scaleFactors.DCW_SF}`);
-            const stateAddr = baseAddr + 24;
-            const stateRaw = await this.readRegisterValue(stateAddr, 1, 'uint16');
-            console.log(`Operating State: address=${stateAddr}, raw=0x${stateRaw.toString(16).toUpperCase()} (${stateRaw})`);
+            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, 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');
+            // Read raw values
+            const acCurrentRaw = await this.readRegisterValue(baseAddr + 2, 1, 'uint16');
+            const voltageRaw = await this.readRegisterValue(baseAddr + 7, 1, 'uint16');
+            const acPowerRaw = await this.readRegisterValue(baseAddr + 9, 1, 'int16');
+            const freqRaw = await this.readRegisterValue(baseAddr + 11, 1, 'uint16');
+            const dcCurrentRaw = await this.readRegisterValue(baseAddr + 14, 1, 'uint16');
+            const dcVoltageRaw = await this.readRegisterValue(baseAddr + 15, 1, 'uint16');
+            const dcPowerRaw = await this.readRegisterValue(baseAddr + 20, 1, 'int16');
+            const stateRaw = await this.readRegisterValue(baseAddr + 24, 1, 'uint16');
+            this.logRegisterRead(101, 24, 'Operating State', stateRaw, 'enum16');
             return {
                 blockNumber: 101,
-                voltageAN: this.applyScaleFactor(voltageRaw, scaleFactors.V_SF, 'uint16', 'Single Phase Voltage'),
-                acCurrent: this.applyScaleFactor(acCurrentRaw, scaleFactors.A_SF, 'uint16', 'Single Phase AC Current'),
-                acPower: this.applyScaleFactor(acPowerRaw, scaleFactors.W_SF, 'int16', 'Single Phase AC Power'),
-                frequency: this.applyScaleFactor(freqRaw, scaleFactors.Hz_SF, 'uint16', 'Single Phase Frequency'),
-                dcCurrent: this.applyScaleFactor(dcCurrentRaw, scaleFactors.DCA_SF, 'uint16', 'Single Phase DC Current'),
-                dcVoltage: this.applyScaleFactor(dcVoltageRaw, scaleFactors.DCV_SF, 'uint16', 'Single Phase DC Voltage'),
-                dcPower: this.applyScaleFactor(dcPowerRaw, scaleFactors.DCW_SF, 'int16', 'Single Phase DC Power'),
+                voltageAN: this.applyScaleFactor(voltageRaw, scaleFactors.V_SF, 'uint16', 'Voltage AN', 7, 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),
                 operatingState: stateRaw
             };
         }
@@ -681,24 +664,55 @@ export class SunspecModbusClient {
             DCW_SF: await this.readRegisterValue(baseAddr + 31, 1, 'int16'), // Offset 31
             Tmp_SF: await this.readRegisterValue(baseAddr + 36, 1, 'int16') // Offset 36
         };
-        console.log('Inverter Scale Factors:', JSON.stringify(scaleFactors, null, 2));
+        this.logRegisterRead(103, 6, 'A_SF', scaleFactors.A_SF, 'int16');
+        this.logRegisterRead(103, 13, 'V_SF', scaleFactors.V_SF, 'int16');
+        this.logRegisterRead(103, 15, 'W_SF', scaleFactors.W_SF, 'int16');
+        this.logRegisterRead(103, 17, 'Hz_SF', scaleFactors.Hz_SF, 'int16');
+        this.logRegisterRead(103, 19, 'VA_SF', scaleFactors.VA_SF, 'int16');
+        this.logRegisterRead(103, 21, 'VAr_SF', scaleFactors.VAr_SF, 'int16');
+        this.logRegisterRead(103, 23, 'PF_SF', scaleFactors.PF_SF, 'int16');
+        this.logRegisterRead(103, 26, 'WH_SF', scaleFactors.WH_SF, 'int16');
+        this.logRegisterRead(103, 28, 'DCA_SF', scaleFactors.DCA_SF, 'int16');
+        this.logRegisterRead(103, 29, 'DCV_SF', scaleFactors.DCV_SF, 'int16');
+        this.logRegisterRead(103, 31, 'DCW_SF', scaleFactors.DCW_SF, 'int16');
+        this.logRegisterRead(103, 36, 'Tmp_SF', scaleFactors.Tmp_SF, 'int16');
         return scaleFactors;
     }
     /**
      * Apply scale factor to a value
      * Returns undefined if the value is unimplemented or scale factor is out of range
      */
-    applyScaleFactor(value, scaleFactor, dataType = 'uint16', fieldName) {
+    applyScaleFactor(value, scaleFactor, dataType = 'uint16', fieldName, offset, modelId) {
         // Check for unimplemented values
         if (this.isUnimplementedValue(value, dataType)) {
             return undefined;
         }
         const scaledValue = value * Math.pow(10, scaleFactor);
-        // Log the raw and scaled values in decimal format
-        const fieldPrefix = fieldName ? `${fieldName}: ` : '';
-        console.log(`Scale Factor Applied - ${fieldPrefix}raw=${value} (decimal), SF=${scaleFactor}, scaled=${scaledValue}`);
+        // Log the raw and scaled values
+        if (offset !== undefined && modelId !== undefined && fieldName) {
+            const hex = value >= 0 ? value.toString(16).toUpperCase() : (value >>> 0).toString(16).toUpperCase();
+            console.log(`[Model ${modelId}] offset ${offset}: ${fieldName} raw=${value} (0x${hex}), SF=${scaleFactor}, scaled=${scaledValue}`);
+        }
+        else {
+            const fieldPrefix = fieldName ? `${fieldName}: ` : '';
+            console.log(`Scale Factor Applied - ${fieldPrefix}raw=${value} (decimal), SF=${scaleFactor}, scaled=${scaledValue}`);
+        }
         return scaledValue;
     }
+    logRegisterRead(modelId, offset, fieldName, rawValue, dataType) {
+        const typeInfo = dataType ? ` (${dataType})` : '';
+        if (rawValue === undefined) {
+            console.log(`[Model ${modelId}] offset ${offset}: ${fieldName} = -${typeInfo}`);
+            return;
+        }
+        if (typeof rawValue === 'number') {
+            const hex = rawValue >= 0 ? rawValue.toString(16).toUpperCase() : (rawValue >>> 0).toString(16).toUpperCase();
+            console.log(`[Model ${modelId}] offset ${offset}: ${fieldName} = ${rawValue} (0x${hex})${typeInfo}`);
+        }
+        else {
+            console.log(`[Model ${modelId}] offset ${offset}: ${fieldName} = "${rawValue}"${typeInfo}`);
+        }
+    }
     /**
      * Read MPPT Scale Factors for a specific module
      * Returns the scale factors for DC Current, DC Voltage, DC Power, and DC Energy
@@ -732,10 +746,10 @@ export class SunspecModbusClient {
                 DCW_SF, // Power Scale Factor
                 DCWH_SF, // Energy Scale Factor
             };
-            console.log(`  DCA_SF (Current): ${DCA_SF} at register ${moduleAddr + 2}`);
-            console.log(`  DCV_SF (Voltage): ${DCV_SF} at register ${moduleAddr + 3}`);
-            console.log(`  DCW_SF (Power): ${DCW_SF} at register ${moduleAddr + 4}`);
-            console.log(`  DCWH_SF (Energy): ${DCWH_SF} at register ${moduleAddr + 5}`);
+            this.logRegisterRead(160, 2, 'DCA_SF', DCA_SF, 'int16');
+            this.logRegisterRead(160, 3, 'DCV_SF', DCV_SF, 'int16');
+            this.logRegisterRead(160, 4, 'DCW_SF', DCW_SF, 'int16');
+            this.logRegisterRead(160, 5, 'DCWH_SF', DCWH_SF, 'int16');
             return scaleFactors;
         }
         catch (error) {
@@ -765,7 +779,6 @@ export class SunspecModbusClient {
                 console.error(`Failed to read scale factors for MPPT module ${moduleId}`);
                 return null;
             }
-            console.log(`MPPT Module ${moduleId} Scale Factors:`, JSON.stringify(scaleFactors, null, 2));
             const id = await this.readRegisterValue(moduleAddr, 1, 'uint16');
             const idString = await this.readRegisterValue(moduleAddr + 1, 8, 'string');
             const dcCurrentRaw = await this.readRegisterValue(moduleAddr + 9, 1, 'uint16');
@@ -774,6 +787,8 @@ export class SunspecModbusClient {
             const dcEnergyRaw = await this.readRegisterValue(moduleAddr + 12, 2, 'uint32');
             const temperatureRaw = await this.readRegisterValue(moduleAddr + 16, 1, 'int16');
             const dcst = await this.readRegisterValue(moduleAddr + 17, 1, 'uint16');
+            this.logRegisterRead(160, 0, `MPPT ${moduleId} ID`, id, 'uint16');
+            this.logRegisterRead(160, 1, `MPPT ${moduleId} String ID`, idString, 'string');
             // Map the DC module state to human-readable name
             // Check if this module is actually implemented/connected
             // If all key values are unimplemented, this module doesn't exist
@@ -787,24 +802,28 @@ export class SunspecModbusClient {
             // Note: There appears to be a temperature scale factor in the original model,
             // but it's not in the current register map. We'll apply a default scale factor.
             const temperatureScaleFactor = -1; // Common default for temperature readings
+            this.logRegisterRead(160, 12, `MPPT ${moduleId} DC Energy`, dcEnergyRaw, 'acc32');
+            const timestampRaw = await this.readRegisterValue(moduleAddr + 14, 2, 'uint32');
+            this.logRegisterRead(160, 14, `MPPT ${moduleId} Timestamp`, timestampRaw, 'uint32');
+            this.logRegisterRead(160, 17, `MPPT ${moduleId} Operating State`, dcst, 'enum16');
             const data = {
                 blockNumber: 160,
                 blockAddress: model.address,
                 blockLength: model.length,
                 id: id,
                 stringId: idString,
-                dcCurrent: this.applyScaleFactor(dcCurrentRaw, scaleFactors.DCA_SF, 'uint16', `MPPT ${moduleId} DC Current`),
+                dcCurrent: this.applyScaleFactor(dcCurrentRaw, scaleFactors.DCA_SF, 'uint16', `MPPT ${moduleId} DC Current`, 9, 160),
                 dcCurrentSF: scaleFactors.DCA_SF,
-                dcVoltage: this.applyScaleFactor(dcVoltageRaw, scaleFactors.DCV_SF, 'uint16', `MPPT ${moduleId} DC Voltage`),
+                dcVoltage: this.applyScaleFactor(dcVoltageRaw, scaleFactors.DCV_SF, 'uint16', `MPPT ${moduleId} DC Voltage`, 10, 160),
                 dcVoltageSF: scaleFactors.DCV_SF,
-                dcPower: this.applyScaleFactor(dcPowerRaw, scaleFactors.DCW_SF, 'uint16', `MPPT ${moduleId} DC Power`),
+                dcPower: this.applyScaleFactor(dcPowerRaw, scaleFactors.DCW_SF, 'uint16', `MPPT ${moduleId} DC Power`, 11, 160),
                 dcPowerSF: scaleFactors.DCW_SF,
                 dcEnergy: !this.isUnimplementedValue(dcEnergyRaw, 'acc32')
-                    ? dcEnergyRaw * Math.pow(10, scaleFactors.DCWH_SF) // Regular number with scale factor
+                    ? dcEnergyRaw * Math.pow(10, scaleFactors.DCWH_SF)
                     : undefined,
                 dcEnergySF: scaleFactors.DCWH_SF,
-                timestamp: await this.readRegisterValue(moduleAddr + 14, 2, 'uint32'),
-                temperature: this.applyScaleFactor(temperatureRaw, temperatureScaleFactor, 'int16', `MPPT ${moduleId} Temperature`),
+                timestamp: timestampRaw,
+                temperature: this.applyScaleFactor(temperatureRaw, temperatureScaleFactor, 'int16', `MPPT ${moduleId} Temperature`, 16, 160),
                 temperatureSF: temperatureScaleFactor,
                 operatingState: dcst,
             };
@@ -897,6 +916,238 @@ export class SunspecModbusClient {
                 return `UNKNOWN(${state})`;
         }
     }
+    /**
+     * Map battery type to human-readable name (Model 802)
+     */
+    mapBatteryType(typ) {
+        switch (typ) {
+            case SunspecBatteryType.NOT_APPLICABLE_UNKNOWN:
+                return "NOT_APPLICABLE_UNKNOWN";
+            case SunspecBatteryType.LEAD_ACID:
+                return "LEAD_ACID";
+            case SunspecBatteryType.NICKEL_METAL_HYDRIDE:
+                return "NICKEL_METAL_HYDRIDE";
+            case SunspecBatteryType.NICKEL_CADMIUM:
+                return "NICKEL_CADMIUM";
+            case SunspecBatteryType.LITHIUM_ION:
+                return "LITHIUM_ION";
+            case SunspecBatteryType.CARBON_ZINC:
+                return "CARBON_ZINC";
+            case SunspecBatteryType.ZINC_CHLORIDE:
+                return "ZINC_CHLORIDE";
+            case SunspecBatteryType.ALKALINE:
+                return "ALKALINE";
+            case SunspecBatteryType.RECHARGEABLE_ALKALINE:
+                return "RECHARGEABLE_ALKALINE";
+            case SunspecBatteryType.SODIUM_SULFUR:
+                return "SODIUM_SULFUR";
+            case SunspecBatteryType.FLOW:
+                return "FLOW";
+            case SunspecBatteryType.SUPER_CAPACITOR:
+                return "SUPER_CAPACITOR";
+            case SunspecBatteryType.OTHER:
+                return "OTHER";
+            default:
+                if (this.isUnimplementedValue(typ, 'enum16')) {
+                    return "NOT_IMPLEMENTED";
+                }
+                return `UNKNOWN(${typ})`;
+        }
+    }
+    /**
+     * Map battery bank state to human-readable name (Model 802)
+     */
+    mapBatteryBankState(state) {
+        switch (state) {
+            case SunspecBatteryBankState.DISCONNECTED:
+                return "DISCONNECTED";
+            case SunspecBatteryBankState.INITIALIZING:
+                return "INITIALIZING";
+            case SunspecBatteryBankState.CONNECTED:
+                return "CONNECTED";
+            case SunspecBatteryBankState.STANDBY:
+                return "STANDBY";
+            case SunspecBatteryBankState.SOC_PROTECTION:
+                return "SOC_PROTECTION";
+            case SunspecBatteryBankState.SUSPENDING:
+                return "SUSPENDING";
+            case SunspecBatteryBankState.FAULT:
+                return "FAULT";
+            default:
+                if (this.isUnimplementedValue(state, 'enum16')) {
+                    return "NOT_IMPLEMENTED";
+                }
+                return `UNKNOWN(${state})`;
+        }
+    }
+    /**
+     * Read Model 802 scale factors (offsets 52-63)
+     */
+    async readBatteryBaseScaleFactors(baseAddr) {
+        const scaleFactors = {
+            AHRtg_SF: await this.readRegisterValue(baseAddr + 52, 1, 'int16'),
+            WHRtg_SF: await this.readRegisterValue(baseAddr + 53, 1, 'int16'),
+            WChaDisChaMax_SF: await this.readRegisterValue(baseAddr + 54, 1, 'int16'),
+            DisChaRte_SF: await this.readRegisterValue(baseAddr + 55, 1, 'int16'),
+            SoC_SF: await this.readRegisterValue(baseAddr + 56, 1, 'int16'),
+            DoD_SF: await this.readRegisterValue(baseAddr + 57, 1, 'int16'),
+            SoH_SF: await this.readRegisterValue(baseAddr + 58, 1, 'int16'),
+            V_SF: await this.readRegisterValue(baseAddr + 59, 1, 'int16'),
+            CellV_SF: await this.readRegisterValue(baseAddr + 60, 1, 'int16'),
+            A_SF: await this.readRegisterValue(baseAddr + 61, 1, 'int16'),
+            AMax_SF: await this.readRegisterValue(baseAddr + 62, 1, 'int16'),
+            W_SF: await this.readRegisterValue(baseAddr + 63, 1, 'int16'),
+        };
+        this.logRegisterRead(802, 52, 'AHRtg_SF', scaleFactors.AHRtg_SF, 'int16');
+        this.logRegisterRead(802, 53, 'WHRtg_SF', scaleFactors.WHRtg_SF, 'int16');
+        this.logRegisterRead(802, 54, 'WChaDisChaMax_SF', scaleFactors.WChaDisChaMax_SF, 'int16');
+        this.logRegisterRead(802, 55, 'DisChaRte_SF', scaleFactors.DisChaRte_SF, 'int16');
+        this.logRegisterRead(802, 56, 'SoC_SF', scaleFactors.SoC_SF, 'int16');
+        this.logRegisterRead(802, 57, 'DoD_SF', scaleFactors.DoD_SF, 'int16');
+        this.logRegisterRead(802, 58, 'SoH_SF', scaleFactors.SoH_SF, 'int16');
+        this.logRegisterRead(802, 59, 'V_SF', scaleFactors.V_SF, 'int16');
+        this.logRegisterRead(802, 60, 'CellV_SF', scaleFactors.CellV_SF, 'int16');
+        this.logRegisterRead(802, 61, 'A_SF', scaleFactors.A_SF, 'int16');
+        this.logRegisterRead(802, 62, 'AMax_SF', scaleFactors.AMax_SF, 'int16');
+        this.logRegisterRead(802, 63, 'W_SF', scaleFactors.W_SF, 'int16');
+        return scaleFactors;
+    }
+    /**
+     * Read battery base data from Model 802 (Battery Base)
+     */
+    async readBatteryBaseData() {
+        const model = this.findModel(SunspecModelId.BatteryBase);
+        if (!model) {
+            console.log('Battery Base model 802 not found');
+            return null;
+        }
+        const baseAddr = model.address;
+        console.log(`Reading Battery Base Data from Model 802 at base address: ${baseAddr}`);
+        try {
+            // Read scale factors first (offsets 52-63)
+            const sf = await this.readBatteryBaseScaleFactors(baseAddr);
+            // Read raw values
+            const ahRtgRaw = await this.readRegisterValue(baseAddr + 2, 1, 'uint16');
+            const whRtgRaw = await this.readRegisterValue(baseAddr + 3, 1, 'uint16');
+            const wChaRteMaxRaw = await this.readRegisterValue(baseAddr + 4, 1, 'uint16');
+            const wDisChaRteMaxRaw = await this.readRegisterValue(baseAddr + 5, 1, 'uint16');
+            const disChaRteRaw = await this.readRegisterValue(baseAddr + 6, 1, 'uint16');
+            const soCMaxRaw = await this.readRegisterValue(baseAddr + 7, 1, 'uint16');
+            const soCMinRaw = await this.readRegisterValue(baseAddr + 8, 1, 'uint16');
+            const soCRsvMaxRaw = await this.readRegisterValue(baseAddr + 9, 1, 'uint16');
+            const soCRsvMinRaw = await this.readRegisterValue(baseAddr + 10, 1, 'uint16');
+            const soCRaw = await this.readRegisterValue(baseAddr + 11, 1, 'uint16');
+            const doDRaw = await this.readRegisterValue(baseAddr + 12, 1, 'uint16');
+            const soHRaw = await this.readRegisterValue(baseAddr + 13, 1, 'uint16');
+            const nCycRaw = await this.readRegisterValue(baseAddr + 14, 2, 'uint32');
+            const chaStRaw = await this.readRegisterValue(baseAddr + 16, 1, 'uint16');
+            const locRemCtlRaw = await this.readRegisterValue(baseAddr + 17, 1, 'uint16');
+            const typRaw = await this.readRegisterValue(baseAddr + 21, 1, 'uint16');
+            const stateRaw = await this.readRegisterValue(baseAddr + 22, 1, 'uint16');
+            const evt1Raw = await this.readRegisterValue(baseAddr + 26, 2, 'uint32');
+            const evt2Raw = await this.readRegisterValue(baseAddr + 28, 2, 'uint32');
+            const evtVnd1Raw = await this.readRegisterValue(baseAddr + 30, 2, 'uint32');
+            const evtVnd2Raw = await this.readRegisterValue(baseAddr + 32, 2, 'uint32');
+            const vRaw = await this.readRegisterValue(baseAddr + 34, 1, 'uint16');
+            const vMaxRaw = await this.readRegisterValue(baseAddr + 35, 1, 'uint16');
+            const vMinRaw = await this.readRegisterValue(baseAddr + 36, 1, 'uint16');
+            const cellVMaxRaw = await this.readRegisterValue(baseAddr + 37, 1, 'uint16');
+            const cellVMaxStrRaw = await this.readRegisterValue(baseAddr + 38, 1, 'uint16');
+            const cellVMaxModRaw = await this.readRegisterValue(baseAddr + 39, 1, 'uint16');
+            const cellVMinRaw = await this.readRegisterValue(baseAddr + 40, 1, 'uint16');
+            const cellVMinStrRaw = await this.readRegisterValue(baseAddr + 41, 1, 'uint16');
+            const cellVMinModRaw = await this.readRegisterValue(baseAddr + 42, 1, 'uint16');
+            const cellVAvgRaw = await this.readRegisterValue(baseAddr + 43, 1, 'uint16');
+            const aRaw = await this.readRegisterValue(baseAddr + 44, 1, 'int16');
+            const aChaMaxRaw = await this.readRegisterValue(baseAddr + 45, 1, 'uint16');
+            const aDisChaMaxRaw = await this.readRegisterValue(baseAddr + 46, 1, 'uint16');
+            const wRaw = await this.readRegisterValue(baseAddr + 47, 1, 'int16');
+            const reqInvStateRaw = await this.readRegisterValue(baseAddr + 48, 1, 'uint16');
+            const reqWRaw = await this.readRegisterValue(baseAddr + 49, 1, 'int16');
+            const setOpRaw = await this.readRegisterValue(baseAddr + 50, 1, 'uint16');
+            const setInvStateRaw = await this.readRegisterValue(baseAddr + 51, 1, 'uint16');
+            // Map enum fields
+            const chaStName = this.mapBatteryChargeState(chaStRaw);
+            const typName = this.mapBatteryType(typRaw);
+            const stateName = this.mapBatteryBankState(stateRaw);
+            // Log non-scaled fields
+            this.logRegisterRead(802, 14, 'nCyc', nCycRaw, 'uint32');
+            this.logRegisterRead(802, 16, 'chaSt', chaStRaw, 'enum16');
+            this.logRegisterRead(802, 17, 'locRemCtl', locRemCtlRaw, 'enum16');
+            this.logRegisterRead(802, 21, 'typ', typRaw, 'enum16');
+            this.logRegisterRead(802, 22, 'state', stateRaw, 'enum16');
+            this.logRegisterRead(802, 26, 'evt1', evt1Raw, 'bitfield32');
+            this.logRegisterRead(802, 28, 'evt2', evt2Raw, 'bitfield32');
+            this.logRegisterRead(802, 30, 'evtVnd1', evtVnd1Raw, 'bitfield32');
+            this.logRegisterRead(802, 32, 'evtVnd2', evtVnd2Raw, 'bitfield32');
+            this.logRegisterRead(802, 38, 'cellVMaxStr', cellVMaxStrRaw, 'uint16');
+            this.logRegisterRead(802, 39, 'cellVMaxMod', cellVMaxModRaw, 'uint16');
+            this.logRegisterRead(802, 41, 'cellVMinStr', cellVMinStrRaw, 'uint16');
+            this.logRegisterRead(802, 42, 'cellVMinMod', cellVMinModRaw, 'uint16');
+            this.logRegisterRead(802, 48, 'reqInvState', reqInvStateRaw, 'enum16');
+            this.logRegisterRead(802, 50, 'setOp', setOpRaw, 'enum16');
+            this.logRegisterRead(802, 51, 'setInvState', setInvStateRaw, 'enum16');
+            const data = {
+                blockNumber: 802,
+                blockAddress: model.address,
+                blockLength: model.length,
+                // Nameplate
+                ahRtg: this.applyScaleFactor(ahRtgRaw, sf.AHRtg_SF, 'uint16', 'AH Rating', 2, 802),
+                whRtg: this.applyScaleFactor(whRtgRaw, sf.WHRtg_SF, 'uint16', 'WH Rating', 3, 802),
+                wChaRteMax: this.applyScaleFactor(wChaRteMaxRaw, sf.WChaDisChaMax_SF, 'uint16', 'Max Charge Rate', 4, 802),
+                wDisChaRteMax: this.applyScaleFactor(wDisChaRteMaxRaw, sf.WChaDisChaMax_SF, 'uint16', 'Max Discharge Rate', 5, 802),
+                // SoC/Health
+                disChaRte: this.applyScaleFactor(disChaRteRaw, sf.DisChaRte_SF, 'uint16', 'Self Discharge Rate', 6, 802),
+                soCMax: this.applyScaleFactor(soCMaxRaw, sf.SoC_SF, 'uint16', 'SoC Max', 7, 802),
+                soCMin: this.applyScaleFactor(soCMinRaw, sf.SoC_SF, 'uint16', 'SoC Min', 8, 802),
+                soCRsvMax: this.applyScaleFactor(soCRsvMaxRaw, sf.SoC_SF, 'uint16', 'SoC Reserve Max', 9, 802),
+                soCRsvMin: this.applyScaleFactor(soCRsvMinRaw, sf.SoC_SF, 'uint16', 'SoC Reserve Min', 10, 802),
+                soC: this.applyScaleFactor(soCRaw, sf.SoC_SF, 'uint16', 'State of Charge', 11, 802),
+                doD: this.applyScaleFactor(doDRaw, sf.DoD_SF, 'uint16', 'Depth of Discharge', 12, 802),
+                soH: this.applyScaleFactor(soHRaw, sf.SoH_SF, 'uint16', 'State of Health', 13, 802),
+                // Status
+                nCyc: !this.isUnimplementedValue(nCycRaw, 'uint32') ? nCycRaw : undefined,
+                chaSt: !this.isUnimplementedValue(chaStRaw, 'enum16') ? chaStRaw : undefined,
+                chaStName,
+                locRemCtl: !this.isUnimplementedValue(locRemCtlRaw, 'enum16') ? locRemCtlRaw : undefined,
+                typ: !this.isUnimplementedValue(typRaw, 'enum16') ? typRaw : undefined,
+                typName,
+                state: !this.isUnimplementedValue(stateRaw, 'enum16') ? stateRaw : undefined,
+                stateName,
+                // Events
+                evt1: !this.isUnimplementedValue(evt1Raw, 'bitfield32') ? evt1Raw : undefined,
+                evt2: !this.isUnimplementedValue(evt2Raw, 'bitfield32') ? evt2Raw : undefined,
+                evtVnd1: !this.isUnimplementedValue(evtVnd1Raw, 'bitfield32') ? evtVnd1Raw : undefined,
+                evtVnd2: !this.isUnimplementedValue(evtVnd2Raw, 'bitfield32') ? evtVnd2Raw : undefined,
+                // Voltage
+                v: this.applyScaleFactor(vRaw, sf.V_SF, 'uint16', 'Battery Voltage', 34, 802),
+                vMax: this.applyScaleFactor(vMaxRaw, sf.V_SF, 'uint16', 'Max Battery Voltage', 35, 802),
+                vMin: this.applyScaleFactor(vMinRaw, sf.V_SF, 'uint16', 'Min Battery Voltage', 36, 802),
+                cellVMax: this.applyScaleFactor(cellVMaxRaw, sf.CellV_SF, 'uint16', 'Max Cell Voltage', 37, 802),
+                cellVMaxStr: !this.isUnimplementedValue(cellVMaxStrRaw, 'uint16') ? cellVMaxStrRaw : undefined,
+                cellVMaxMod: !this.isUnimplementedValue(cellVMaxModRaw, 'uint16') ? cellVMaxModRaw : undefined,
+                cellVMin: this.applyScaleFactor(cellVMinRaw, sf.CellV_SF, 'uint16', 'Min Cell Voltage', 40, 802),
+                cellVMinStr: !this.isUnimplementedValue(cellVMinStrRaw, 'uint16') ? cellVMinStrRaw : undefined,
+                cellVMinMod: !this.isUnimplementedValue(cellVMinModRaw, 'uint16') ? cellVMinModRaw : undefined,
+                cellVAvg: this.applyScaleFactor(cellVAvgRaw, sf.CellV_SF, 'uint16', 'Avg Cell Voltage', 43, 802),
+                // Current
+                a: this.applyScaleFactor(aRaw, sf.A_SF, 'int16', 'Battery Current', 44, 802),
+                aChaMax: this.applyScaleFactor(aChaMaxRaw, sf.AMax_SF, 'uint16', 'Max Charge Current', 45, 802),
+                aDisChaMax: this.applyScaleFactor(aDisChaMaxRaw, sf.AMax_SF, 'uint16', 'Max Discharge Current', 46, 802),
+                // Power
+                w: this.applyScaleFactor(wRaw, sf.W_SF, 'int16', 'Battery Power', 47, 802),
+                reqInvState: !this.isUnimplementedValue(reqInvStateRaw, 'enum16') ? reqInvStateRaw : undefined,
+                reqW: this.applyScaleFactor(reqWRaw, sf.W_SF, 'int16', 'Requested Power', 49, 802),
+                setOp: !this.isUnimplementedValue(setOpRaw, 'enum16') ? setOpRaw : undefined,
+                setInvState: !this.isUnimplementedValue(setInvStateRaw, 'enum16') ? setInvStateRaw : undefined,
+            };
+            return data;
+        }
+        catch (error) {
+            console.error(`Error reading battery base data: ${error}`);
+            return null;
+        }
+    }
     /**
      * Read battery data from Model 124 (Basic Storage Controls)
      */
@@ -931,7 +1182,14 @@ export class SunspecModbusClient {
                     InBatV_SF: await this.readRegisterValue(baseAddr + 24, 1, 'int16'),
                     InOutWRte_SF: await this.readRegisterValue(baseAddr + 25, 1, 'int16')
                 };
-                console.log('Battery Scale Factors:', JSON.stringify(scaleFactors, null, 2));
+                this.logRegisterRead(124, 18, 'WChaMax_SF', scaleFactors.WChaMax_SF, 'int16');
+                this.logRegisterRead(124, 19, 'WChaDisChaGra_SF', scaleFactors.WChaDisChaGra_SF, 'int16');
+                this.logRegisterRead(124, 20, 'VAChaMax_SF', scaleFactors.VAChaMax_SF, 'int16');
+                this.logRegisterRead(124, 21, 'MinRsvPct_SF', scaleFactors.MinRsvPct_SF, 'int16');
+                this.logRegisterRead(124, 22, 'ChaState_SF', scaleFactors.ChaState_SF, 'int16');
+                this.logRegisterRead(124, 23, 'StorAval_SF', scaleFactors.StorAval_SF, 'int16');
+                this.logRegisterRead(124, 24, 'InBatV_SF', scaleFactors.InBatV_SF, 'int16');
+                this.logRegisterRead(124, 25, 'InOutWRte_SF', scaleFactors.InOutWRte_SF, 'int16');
                 // Read raw values
                 const wChaMaxRaw = await this.readRegisterValue(baseAddr + 2, 1, 'uint16');
                 const wChaGraRaw = await this.readRegisterValue(baseAddr + 3, 1, 'uint16');
@@ -949,43 +1207,42 @@ export class SunspecModbusClient {
                 const inOutWRteRvrtTmsRaw = await this.readRegisterValue(baseAddr + 15, 1, 'uint16');
                 const inOutWRteRmpTmsRaw = await this.readRegisterValue(baseAddr + 16, 1, 'uint16');
                 const chaGriSetRaw = await this.readRegisterValue(baseAddr + 17, 1, 'uint16');
-                // Map charge state to human-readable name
+                // Map charge state and log non-scaled fields
                 const chaStName = this.mapBatteryChargeState(chaStRaw);
-                console.log(`Battery Charge State: ${chaStRaw} (${chaStName})`);
-                // Log storage control mode
-                if (!this.isUnimplementedValue(storCtlModRaw, 'bitfield16')) {
-                    const chargeEnabled = (storCtlModRaw & SunspecStorageControlMode.CHARGE) !== 0;
-                    const dischargeEnabled = (storCtlModRaw & SunspecStorageControlMode.DISCHARGE) !== 0;
-                    console.log(`Storage Control Mode: 0x${storCtlModRaw.toString(16)} (Charge: ${chargeEnabled}, Discharge: ${dischargeEnabled})`);
-                }
+                this.logRegisterRead(124, 5, 'storCtlMod', storCtlModRaw, 'bitfield16');
+                this.logRegisterRead(124, 11, 'chaSt', chaStRaw, 'enum16');
+                this.logRegisterRead(124, 14, 'inOutWRteWinTms', inOutWRteWinTmsRaw, 'uint16');
+                this.logRegisterRead(124, 15, 'inOutWRteRvrtTms', inOutWRteRvrtTmsRaw, 'uint16');
+                this.logRegisterRead(124, 16, 'inOutWRteRmpTms', inOutWRteRmpTmsRaw, 'uint16');
+                this.logRegisterRead(124, 17, 'chaGriSet', chaGriSetRaw, 'enum16');
                 // Calculate actual values with scale factors
                 const data = {
                     blockNumber: 124,
                     blockAddress: model.address,
                     blockLength: model.length,
                     // Control settings
-                    wChaMax: this.applyScaleFactor(wChaMaxRaw, scaleFactors.WChaMax_SF, 'uint16', 'Max Charge Power'),
+                    wChaMax: this.applyScaleFactor(wChaMaxRaw, scaleFactors.WChaMax_SF, 'uint16', 'Max Charge Power', 2, 124),
                     wChaMaxSF: scaleFactors.WChaMax_SF,
-                    wChaGra: this.applyScaleFactor(wChaGraRaw, scaleFactors.WChaDisChaGra_SF, 'uint16', 'Charge Rate Gradient'),
-                    wDisChaGra: this.applyScaleFactor(wDisChaGraRaw, scaleFactors.WChaDisChaGra_SF, 'uint16', 'Discharge Rate Gradient'),
+                    wChaGra: this.applyScaleFactor(wChaGraRaw, scaleFactors.WChaDisChaGra_SF, 'uint16', 'Charge Rate Gradient', 3, 124),
+                    wDisChaGra: this.applyScaleFactor(wDisChaGraRaw, scaleFactors.WChaDisChaGra_SF, 'uint16', 'Discharge Rate Gradient', 4, 124),
                     wChaDisChaGraSF: scaleFactors.WChaDisChaGra_SF,
                     storCtlMod: !this.isUnimplementedValue(storCtlModRaw, 'bitfield16') ? storCtlModRaw : undefined,
-                    vaChaMax: this.applyScaleFactor(vaChaMaxRaw, scaleFactors.VAChaMax_SF, 'uint16', 'Max Charging VA'),
+                    vaChaMax: this.applyScaleFactor(vaChaMaxRaw, scaleFactors.VAChaMax_SF, 'uint16', 'Max Charging VA', 6, 124),
                     vaChaMaxSF: scaleFactors.VAChaMax_SF,
-                    minRsvPct: this.applyScaleFactor(minRsvPctRaw, scaleFactors.MinRsvPct_SF, 'uint16', 'Min Reserve Percent'),
+                    minRsvPct: this.applyScaleFactor(minRsvPctRaw, scaleFactors.MinRsvPct_SF, 'uint16', 'Min Reserve Percent', 7, 124),
                     minRsvPctSF: scaleFactors.MinRsvPct_SF,
                     // Status values
-                    chaState: this.applyScaleFactor(chaStateRaw, scaleFactors.ChaState_SF, 'uint16', 'State of Charge'),
+                    chaState: this.applyScaleFactor(chaStateRaw, scaleFactors.ChaState_SF, 'uint16', 'State of Charge', 8, 124),
                     chaStateSF: scaleFactors.ChaState_SF,
-                    storAval: this.applyScaleFactor(storAvalRaw, scaleFactors.StorAval_SF, 'uint16', 'Available Storage'),
+                    storAval: this.applyScaleFactor(storAvalRaw, scaleFactors.StorAval_SF, 'uint16', 'Available Storage', 9, 124),
                     storAvalSF: scaleFactors.StorAval_SF,
-                    inBatV: this.applyScaleFactor(inBatVRaw, scaleFactors.InBatV_SF, 'uint16', 'Battery Voltage'),
+                    inBatV: this.applyScaleFactor(inBatVRaw, scaleFactors.InBatV_SF, 'uint16', 'Battery Voltage', 10, 124),
                     inBatVSF: scaleFactors.InBatV_SF,
                     chaSt: !this.isUnimplementedValue(chaStRaw, 'enum16') ? chaStRaw : undefined,
                     chaStName: chaStName,
                     // Rate control
-                    outWRte: this.applyScaleFactor(outWRteRaw, scaleFactors.InOutWRte_SF, 'int16', 'Discharge Rate'),
-                    inWRte: this.applyScaleFactor(inWRteRaw, scaleFactors.InOutWRte_SF, 'int16', 'Charge Rate'),
+                    outWRte: this.applyScaleFactor(outWRteRaw, scaleFactors.InOutWRte_SF, 'int16', 'Discharge Rate', 12, 124),
+                    inWRte: this.applyScaleFactor(inWRteRaw, scaleFactors.InOutWRte_SF, 'int16', 'Charge Rate', 13, 124),
                     inOutWRteSF: scaleFactors.InOutWRte_SF,
                     // Timing parameters
                     inOutWRteWinTms: !this.isUnimplementedValue(inOutWRteWinTmsRaw, 'uint16') ? inOutWRteWinTmsRaw : undefined,
@@ -1010,8 +1267,43 @@ export class SunspecModbusClient {
                 }
                 return data;
             }
+            else if (model.id === 802) {
+                // Model 802: Battery Base
+                console.log('Using Model 802 (Battery Base)');
+                const baseData = await this.readBatteryBaseData();
+                if (!baseData) {
+                    return null;
+                }
+                // Derive charge/discharge power from w field
+                let chargePower;
+                let dischargePower;
+                if (baseData.w !== undefined) {
+                    if (baseData.w >= 0) {
+                        chargePower = baseData.w;
+                        dischargePower = 0;
+                    }
+                    else {
+                        chargePower = 0;
+                        dischargePower = Math.abs(baseData.w);
+                    }
+                }
+                return {
+                    blockNumber: 802,
+                    blockAddress: model.address,
+                    blockLength: model.length,
+                    soc: baseData.soC,
+                    soh: baseData.soH,
+                    voltage: baseData.v,
+                    current: baseData.a,
+                    chaSt: baseData.chaSt,
+                    chaStName: baseData.chaStName,
+                    status: baseData.state,
+                    chargePower,
+                    dischargePower,
+                };
+            }
             else {
-                // Handle other battery models (802, 803) if needed
+                // Handle other battery models (803) if needed
                 console.log(`Battery Model ${model.id} reading not yet implemented`);
                 return {
                     blockNumber: model.id,
@@ -1142,6 +1434,9 @@ export class SunspecModbusClient {
                 MinRsvPct_SF: await this.readRegisterValue(baseAddr + 21, 1, 'int16'),
                 InOutWRte_SF: await this.readRegisterValue(baseAddr + 25, 1, 'int16')
             };
+            this.logRegisterRead(124, 18, 'WChaMax_SF', scaleFactors.WChaMax_SF, 'int16');
+            this.logRegisterRead(124, 21, 'MinRsvPct_SF', scaleFactors.MinRsvPct_SF, 'int16');
+            this.logRegisterRead(124, 25, 'InOutWRte_SF', scaleFactors.InOutWRte_SF, 'int16');
             // Read raw values
             const wChaMaxRaw = await this.readRegisterValue(baseAddr + 2, 1, 'uint16');
             const storCtlModRaw = await this.readRegisterValue(baseAddr + 5, 1, 'uint16');
@@ -1149,14 +1444,16 @@ export class SunspecModbusClient {
             const outWRteRaw = await this.readRegisterValue(baseAddr + 12, 1, 'int16');
             const inWRteRaw = await this.readRegisterValue(baseAddr + 13, 1, 'int16');
             const chaGriSetRaw = await this.readRegisterValue(baseAddr + 17, 1, 'uint16');
+            this.logRegisterRead(124, 5, 'storCtlMod', storCtlModRaw, 'bitfield16');
+            this.logRegisterRead(124, 17, 'chaGriSet', chaGriSetRaw, 'enum16');
             // Apply scale factors and return control settings
             return {
                 storCtlMod: !this.isUnimplementedValue(storCtlModRaw, 'bitfield16') ? storCtlModRaw : undefined,
                 chaGriSet: !this.isUnimplementedValue(chaGriSetRaw, 'enum16') ? chaGriSetRaw : undefined,
-                wChaMax: this.applyScaleFactor(wChaMaxRaw, scaleFactors.WChaMax_SF, 'uint16'),
-                inWRte: this.applyScaleFactor(inWRteRaw, scaleFactors.InOutWRte_SF, 'int16'),
-                outWRte: this.applyScaleFactor(outWRteRaw, scaleFactors.InOutWRte_SF, 'int16'),
-                minRsvPct: this.applyScaleFactor(minRsvPctRaw, scaleFactors.MinRsvPct_SF, 'uint16')
+                wChaMax: this.applyScaleFactor(wChaMaxRaw, scaleFactors.WChaMax_SF, 'uint16', 'Max Charge Power', 2, 124),
+                inWRte: this.applyScaleFactor(inWRteRaw, scaleFactors.InOutWRte_SF, 'int16', 'Charge Rate', 13, 124),
+                outWRte: this.applyScaleFactor(outWRteRaw, scaleFactors.InOutWRte_SF, 'int16', 'Discharge Rate', 12, 124),
+                minRsvPct: this.applyScaleFactor(minRsvPctRaw, scaleFactors.MinRsvPct_SF, 'uint16', 'Min Reserve Percent', 7, 124)
             };
         }
         catch (error) {
@@ -1227,25 +1524,21 @@ export class SunspecModbusClient {
             const powerSF = await this.readRegisterValue(baseAddr + powerSFOffset, 1, 'int16');
             const freqSF = await this.readRegisterValue(baseAddr + freqSFOffset, 1, 'int16');
             const energySF = await this.readRegisterValue(baseAddr + energySFOffset, 1, 'int16');
-            console.log(`Meter Scale Factors: Power_SF=${powerSF}, Freq_SF=${freqSF}, Energy_SF=${energySF}`);
+            this.logRegisterRead(model.id, powerSFOffset, 'W_SF', powerSF, 'int16');
+            this.logRegisterRead(model.id, freqSFOffset, 'Hz_SF', freqSF, 'int16');
+            this.logRegisterRead(model.id, energySFOffset, 'TotWh_SF', energySF, 'int16');
             // Read raw values
-            const powerAddr = baseAddr + powerOffset;
-            const powerRaw = await this.readRegisterValue(powerAddr, 1, 'int16');
-            console.log(`Meter Total Power: address=${powerAddr}, raw=0x${powerRaw.toString(16).toUpperCase()} (${powerRaw}), SF=${powerSF}`);
-            const freqAddr = baseAddr + freqOffset;
-            const freqRaw = await this.readRegisterValue(freqAddr, 1, 'uint16');
-            console.log(`Meter Frequency: address=${freqAddr}, raw=0x${freqRaw.toString(16).toUpperCase()} (${freqRaw}), SF=${freqSF}`);
-            const exportAddr = baseAddr + exportOffset;
-            const exportRaw = await this.readRegisterValue(exportAddr, 2, 'uint32');
-            console.log(`Meter Export Energy: address=${exportAddr}, raw=0x${exportRaw.toString(16).toUpperCase()} (${exportRaw}), SF=${energySF}`);
-            const importAddr = baseAddr + importOffset;
-            const importRaw = await this.readRegisterValue(importAddr, 2, 'uint32');
-            console.log(`Meter Import Energy: address=${importAddr}, raw=0x${importRaw.toString(16).toUpperCase()} (${importRaw}), SF=${energySF}`);
+            const powerRaw = await this.readRegisterValue(baseAddr + powerOffset, 1, 'int16');
+            const freqRaw = await this.readRegisterValue(baseAddr + freqOffset, 1, 'uint16');
+            const exportRaw = await this.readRegisterValue(baseAddr + exportOffset, 2, 'uint32');
+            const importRaw = await this.readRegisterValue(baseAddr + importOffset, 2, 'uint32');
+            this.logRegisterRead(model.id, exportOffset, 'TotWhExp', exportRaw, 'acc32');
+            this.logRegisterRead(model.id, importOffset, 'TotWhImp', importRaw, 'acc32');
             // Calculate final values with scale factors
-            const totalPower = this.applyScaleFactor(powerRaw, powerSF, 'int16', 'Meter Total Power');
-            const frequency = this.applyScaleFactor(freqRaw, freqSF, 'uint16', 'Meter Frequency');
-            const exportedEnergy = this.applyScaleFactor(exportRaw, energySF, "acc32");
-            const importedEnergy = this.applyScaleFactor(importRaw, energySF, "acc32");
+            const totalPower = this.applyScaleFactor(powerRaw, powerSF, 'int16', 'Total Power', powerOffset, model.id);
+            const frequency = this.applyScaleFactor(freqRaw, freqSF, 'uint16', 'Frequency', freqOffset, model.id);
+            const exportedEnergy = this.applyScaleFactor(exportRaw, energySF, "acc32", 'Exported Energy', exportOffset, model.id);
+            const importedEnergy = this.applyScaleFactor(importRaw, energySF, "acc32", 'Imported Energy', importOffset, model.id);
             return {
                 blockNumber: model.id,
                 totalPower,
@@ -1279,30 +1572,26 @@ export class SunspecModbusClient {
             const versionAddr = baseAddr + 40; // Offset 40-47 (8 registers) from data start
             const serialAddr = baseAddr + 48; // Offset 48-63 (16 registers) from data start
             const deviceAddrAddr = baseAddr + 64; // Offset 64 from data start
-            console.log(`Reading manufacturer from address ${manufacturerAddr} (16 registers)`);
             const manufacturer = await this.readRegisterValue(manufacturerAddr, 16, 'string');
-            console.log(`Manufacturer raw value: "${manufacturer}"`);
-            console.log(`Reading model from address ${modelAddr} (16 registers)`);
+            this.logRegisterRead(1, 0, 'Manufacturer', manufacturer, 'string');
             const modelName = await this.readRegisterValue(modelAddr, 16, 'string');
-            console.log(`Model raw value: "${modelName}"`);
-            console.log(`Reading options from address ${optionsAddr} (8 registers)`);
+            this.logRegisterRead(1, 16, 'Model', modelName, 'string');
             const options = await this.readRegisterValue(optionsAddr, 8, 'string');
-            console.log(`Reading version from address ${versionAddr} (8 registers)`);
+            this.logRegisterRead(1, 32, 'Options', options, 'string');
             const version = await this.readRegisterValue(versionAddr, 8, 'string');
-            console.log(`Reading serial from address ${serialAddr} (16 registers)`);
+            this.logRegisterRead(1, 40, 'Version', version, 'string');
             const serialNumber = await this.readRegisterValue(serialAddr, 16, 'string');
-            console.log(`Reading device address from address ${deviceAddrAddr}`);
+            this.logRegisterRead(1, 48, 'Serial Number', serialNumber, 'string');
             const deviceAddress = await this.readRegisterValue(deviceAddrAddr, 1, 'uint16');
-            const result = {
-                manufacturer: manufacturer,
+            this.logRegisterRead(1, 64, 'Device Address', deviceAddress, 'uint16');
+            return {
+                manufacturer,
                 model: modelName,
-                options: options,
-                version: version,
-                serialNumber: serialNumber,
-                deviceAddress: deviceAddress
+                options,
+                version,
+                serialNumber,
+                deviceAddress
             };
-            console.log('Common Block Data:', JSON.stringify(result, null, 2));
-            return result;
         }
         catch (error) {
             console.error(`Error reading common block: ${error}`);
@@ -1358,47 +1647,64 @@ export class SunspecModbusClient {
                 MaxRmpRte_SF: await this.readRegisterValue(baseAddr + 30, 1, 'int16'),
                 ECPNomHz_SF: await this.readRegisterValue(baseAddr + 31, 1, 'int16')
             };
+            this.logRegisterRead(121, 22, 'WMax_SF', scaleFactors.WMax_SF, 'int16');
+            this.logRegisterRead(121, 23, 'VRef_SF', scaleFactors.VRef_SF, 'int16');
+            this.logRegisterRead(121, 24, 'VRefOfs_SF', scaleFactors.VRefOfs_SF, 'int16');
+            this.logRegisterRead(121, 25, 'VMinMax_SF', scaleFactors.VMinMax_SF, 'int16');
+            this.logRegisterRead(121, 26, 'VAMax_SF', scaleFactors.VAMax_SF, 'int16');
+            this.logRegisterRead(121, 27, 'VArMax_SF', scaleFactors.VArMax_SF, 'int16');
+            this.logRegisterRead(121, 28, 'WGra_SF', scaleFactors.WGra_SF, 'int16');
+            this.logRegisterRead(121, 29, 'PFMin_SF', scaleFactors.PFMin_SF, 'int16');
+            this.logRegisterRead(121, 30, 'MaxRmpRte_SF', scaleFactors.MaxRmpRte_SF, 'int16');
+            this.logRegisterRead(121, 31, 'ECPNomHz_SF', scaleFactors.ECPNomHz_SF, 'int16');
+            // Read non-scaled fields first for logging
+            const vArActRaw = await this.readRegisterValue(baseAddr + 17, 1, 'uint16');
+            const clcTotVARaw = await this.readRegisterValue(baseAddr + 18, 1, 'uint16');
+            const connPhRaw = await this.readRegisterValue(baseAddr + 21, 1, 'uint16');
+            this.logRegisterRead(121, 17, 'VArAct', vArActRaw, 'enum16');
+            this.logRegisterRead(121, 18, 'ClcTotVA', clcTotVARaw, 'enum16');
+            this.logRegisterRead(121, 21, 'ConnPh', connPhRaw, 'enum16');
             return {
                 blockNumber: 121,
                 blockAddress: model.address,
                 blockLength: model.length,
                 // Power settings - Offset 2
-                WMax: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 2, 1, 'uint16'), scaleFactors.WMax_SF, 'uint16', 'Max Power'),
+                WMax: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 2, 1, 'uint16'), scaleFactors.WMax_SF, 'uint16', 'Max Power', 2, 121),
                 WMax_SF: scaleFactors.WMax_SF,
                 // Voltage settings - Offsets 3-6
-                VRef: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 3, 1, 'uint16'), scaleFactors.VRef_SF, 'uint16', 'Voltage Reference'),
+                VRef: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 3, 1, 'uint16'), scaleFactors.VRef_SF, 'uint16', 'Voltage Reference', 3, 121),
                 VRef_SF: scaleFactors.VRef_SF,
-                VRefOfs: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 4, 1, 'int16'), scaleFactors.VRefOfs_SF, 'int16', 'Voltage Reference Offset'),
+                VRefOfs: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 4, 1, 'int16'), scaleFactors.VRefOfs_SF, 'int16', 'Voltage Reference Offset', 4, 121),
                 VRefOfs_SF: scaleFactors.VRefOfs_SF,
-                VMax: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 5, 1, 'uint16'), scaleFactors.VMinMax_SF, 'uint16', 'Max Voltage'),
-                VMin: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 6, 1, 'uint16'), scaleFactors.VMinMax_SF, 'uint16', 'Min Voltage'),
+                VMax: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 5, 1, 'uint16'), scaleFactors.VMinMax_SF, 'uint16', 'Max Voltage', 5, 121),
+                VMin: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 6, 1, 'uint16'), scaleFactors.VMinMax_SF, 'uint16', 'Min Voltage', 6, 121),
                 VMinMax_SF: scaleFactors.VMinMax_SF,
                 // Apparent power settings - Offset 7
-                VAMax: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 7, 1, 'uint16'), scaleFactors.VAMax_SF, 'uint16', 'Max Apparent Power'),
+                VAMax: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 7, 1, 'uint16'), scaleFactors.VAMax_SF, 'uint16', 'Max Apparent Power', 7, 121),
                 VAMax_SF: scaleFactors.VAMax_SF,
                 // Reactive power settings - Offsets 8-11
-                VArMaxQ1: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 8, 1, 'int16'), scaleFactors.VArMax_SF, 'int16', 'Max Reactive Power Q1'),
-                VArMaxQ2: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 9, 1, 'int16'), scaleFactors.VArMax_SF, 'int16', 'Max Reactive Power Q2'),
-                VArMaxQ3: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 10, 1, 'int16'), scaleFactors.VArMax_SF, 'int16', 'Max Reactive Power Q3'),
-                VArMaxQ4: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 11, 1, 'int16'), scaleFactors.VArMax_SF, 'int16', 'Max Reactive Power Q4'),
+                VArMaxQ1: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 8, 1, 'int16'), scaleFactors.VArMax_SF, 'int16', 'Max Reactive Power Q1', 8, 121),
+                VArMaxQ2: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 9, 1, 'int16'), scaleFactors.VArMax_SF, 'int16', 'Max Reactive Power Q2', 9, 121),
+                VArMaxQ3: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 10, 1, 'int16'), scaleFactors.VArMax_SF, 'int16', 'Max Reactive Power Q3', 10, 121),
+                VArMaxQ4: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 11, 1, 'int16'), scaleFactors.VArMax_SF, 'int16', 'Max Reactive Power Q4', 11, 121),
                 VArMax_SF: scaleFactors.VArMax_SF,
                 // Ramp rate settings - Offset 12
-                WGra: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 12, 1, 'uint16'), scaleFactors.WGra_SF, 'uint16', 'Power Ramp Rate'),
+                WGra: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 12, 1, 'uint16'), scaleFactors.WGra_SF, 'uint16', 'Power Ramp Rate', 12, 121),
                 WGra_SF: scaleFactors.WGra_SF,
                 // Power factor settings - Offsets 13-16
-                PFMinQ1: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 13, 1, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q1'),
-                PFMinQ2: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 14, 1, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q2'),
-                PFMinQ3: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 15, 1, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q3'),
-                PFMinQ4: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 16, 1, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q4'),
+                PFMinQ1: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 13, 1, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q1', 13, 121),
+                PFMinQ2: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 14, 1, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q2', 14, 121),
+                PFMinQ3: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 15, 1, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q3', 15, 121),
+                PFMinQ4: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 16, 1, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q4', 16, 121),
                 PFMin_SF: scaleFactors.PFMin_SF,
                 // Other settings - Offsets 17-21
-                VArAct: await this.readRegisterValue(baseAddr + 17, 1, 'uint16'),
-                ClcTotVA: await this.readRegisterValue(baseAddr + 18, 1, 'uint16'),
-                MaxRmpRte: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 19, 1, 'uint16'), scaleFactors.MaxRmpRte_SF, 'uint16', 'Max Ramp Rate'),
+                VArAct: vArActRaw,
+                ClcTotVA: clcTotVARaw,
+                MaxRmpRte: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 19, 1, 'uint16'), scaleFactors.MaxRmpRte_SF, 'uint16', 'Max Ramp Rate', 19, 121),
                 MaxRmpRte_SF: scaleFactors.MaxRmpRte_SF,
-                ECPNomHz: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 20, 1, 'uint16'), scaleFactors.ECPNomHz_SF, 'uint16', 'Nominal Frequency'),
+                ECPNomHz: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 20, 1, 'uint16'), scaleFactors.ECPNomHz_SF, 'uint16', 'Nominal Frequency', 20, 121),
                 ECPNomHz_SF: scaleFactors.ECPNomHz_SF,
-                ConnPh: await this.readRegisterValue(baseAddr + 21, 1, 'uint16')
+                ConnPh: connPhRaw
             };
         }
         catch (error) {
@@ -1423,38 +1729,74 @@ export class SunspecModbusClient {
                 OutPFSet_SF: await this.readRegisterValue(baseAddr + 22, 1, 'int16'),
                 VArPct_SF: await this.readRegisterValue(baseAddr + 23, 1, 'int16')
             };
+            this.logRegisterRead(123, 21, 'WMaxLimPct_SF', scaleFactors.WMaxLimPct_SF, 'int16');
+            this.logRegisterRead(123, 22, 'OutPFSet_SF', scaleFactors.OutPFSet_SF, 'int16');
+            this.logRegisterRead(123, 23, 'VArPct_SF', scaleFactors.VArPct_SF, 'int16');
+            // Read non-scaled fields
+            const connWinTmsRaw = await this.readRegisterValue(baseAddr, 1, 'uint16');
+            const connRvrtTmsRaw = await this.readRegisterValue(baseAddr + 1, 1, 'uint16');
+            const connRaw = await this.readRegisterValue(baseAddr + 2, 1, 'uint16');
+            const wMaxLimPctWinTmsRaw = await this.readRegisterValue(baseAddr + 4, 1, 'uint16');
+            const wMaxLimPctRvrtTmsRaw = await this.readRegisterValue(baseAddr + 5, 1, 'uint16');
+            const wMaxLimPctRmpTmsRaw = await this.readRegisterValue(baseAddr + 6, 1, 'uint16');
+            const wMaxLimEnaRaw = await this.readRegisterValue(baseAddr + 7, 1, 'uint16');
+            const outPFSetWinTmsRaw = await this.readRegisterValue(baseAddr + 9, 1, 'uint16');
+            const outPFSetRvrtTmsRaw = await this.readRegisterValue(baseAddr + 10, 1, 'uint16');
+            const outPFSetRmpTmsRaw = await this.readRegisterValue(baseAddr + 11, 1, 'uint16');
+            const outPFSetEnaRaw = await this.readRegisterValue(baseAddr + 12, 1, 'uint16');
+            const vArPctWinTmsRaw = await this.readRegisterValue(baseAddr + 16, 1, 'uint16');
+            const vArPctRvrtTmsRaw = await this.readRegisterValue(baseAddr + 17, 1, 'uint16');
+            const vArPctRmpTmsRaw = await this.readRegisterValue(baseAddr + 18, 1, 'uint16');
+            const vArPctModRaw = await this.readRegisterValue(baseAddr + 19, 1, 'uint16');
+            const vArPctEnaRaw = await this.readRegisterValue(baseAddr + 20, 1, 'uint16');
+            this.logRegisterRead(123, 0, 'Conn_WinTms', connWinTmsRaw, 'uint16');
+            this.logRegisterRead(123, 1, 'Conn_RvrtTms', connRvrtTmsRaw, 'uint16');
+            this.logRegisterRead(123, 2, 'Conn', connRaw, 'enum16');
+            this.logRegisterRead(123, 4, 'WMaxLimPct_WinTms', wMaxLimPctWinTmsRaw, 'uint16');
+            this.logRegisterRead(123, 5, 'WMaxLimPct_RvrtTms', wMaxLimPctRvrtTmsRaw, 'uint16');
+            this.logRegisterRead(123, 6, 'WMaxLimPct_RmpTms', wMaxLimPctRmpTmsRaw, 'uint16');
+            this.logRegisterRead(123, 7, 'WMaxLim_Ena', wMaxLimEnaRaw, 'enum16');
+            this.logRegisterRead(123, 9, 'OutPFSet_WinTms', outPFSetWinTmsRaw, 'uint16');
+            this.logRegisterRead(123, 10, 'OutPFSet_RvrtTms', outPFSetRvrtTmsRaw, 'uint16');
+            this.logRegisterRead(123, 11, 'OutPFSet_RmpTms', outPFSetRmpTmsRaw, 'uint16');
+            this.logRegisterRead(123, 12, 'OutPFSet_Ena', outPFSetEnaRaw, 'enum16');
+            this.logRegisterRead(123, 16, 'VArPct_WinTms', vArPctWinTmsRaw, 'uint16');
+            this.logRegisterRead(123, 17, 'VArPct_RvrtTms', vArPctRvrtTmsRaw, 'uint16');
+            this.logRegisterRead(123, 18, 'VArPct_RmpTms', vArPctRmpTmsRaw, 'uint16');
+            this.logRegisterRead(123, 19, 'VArPct_Mod', vArPctModRaw, 'enum16');
+            this.logRegisterRead(123, 20, 'VArPct_Ena', vArPctEnaRaw, 'enum16');
             const controls = {
                 blockNumber: 123,
                 blockAddress: model.address,
                 blockLength: model.length,
                 // Connection control - Offsets 0-2
-                Conn_WinTms: await this.readRegisterValue(baseAddr, 1, 'uint16'),
-                Conn_RvrtTms: await this.readRegisterValue(baseAddr + 1, 1, 'uint16'),
-                Conn: await this.readRegisterValue(baseAddr + 2, 1, 'uint16'),
+                Conn_WinTms: connWinTmsRaw,
+                Conn_RvrtTms: connRvrtTmsRaw,
+                Conn: connRaw,
                 // Power limit control - Offsets 3-7
-                WMaxLimPct: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 3, 1, 'uint16'), scaleFactors.WMaxLimPct_SF, 'uint16', 'Power Limit Percentage'),
+                WMaxLimPct: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 3, 1, 'uint16'), scaleFactors.WMaxLimPct_SF, 'uint16', 'Power Limit Percentage', 3, 123),
                 WMaxLimPct_SF: scaleFactors.WMaxLimPct_SF,
-                WMaxLimPct_WinTms: await this.readRegisterValue(baseAddr + 4, 1, 'uint16'),
-                WMaxLimPct_RvrtTms: await this.readRegisterValue(baseAddr + 5, 1, 'uint16'),
-                WMaxLimPct_RmpTms: await this.readRegisterValue(baseAddr + 6, 1, 'uint16'),
-                WMaxLim_Ena: await this.readRegisterValue(baseAddr + 7, 1, 'uint16'),
+                WMaxLimPct_WinTms: wMaxLimPctWinTmsRaw,
+                WMaxLimPct_RvrtTms: wMaxLimPctRvrtTmsRaw,
+                WMaxLimPct_RmpTms: wMaxLimPctRmpTmsRaw,
+                WMaxLim_Ena: wMaxLimEnaRaw,
                 // Power factor control - Offsets 8-12
-                OutPFSet: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 8, 1, 'int16'), scaleFactors.OutPFSet_SF, 'int16', 'Output Power Factor Set'),
+                OutPFSet: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 8, 1, 'int16'), scaleFactors.OutPFSet_SF, 'int16', 'Output Power Factor Set', 8, 123),
                 OutPFSet_SF: scaleFactors.OutPFSet_SF,
-                OutPFSet_WinTms: await this.readRegisterValue(baseAddr + 9, 1, 'uint16'),
-                OutPFSet_RvrtTms: await this.readRegisterValue(baseAddr + 10, 1, 'uint16'),
-                OutPFSet_RmpTms: await this.readRegisterValue(baseAddr + 11, 1, 'uint16'),
-                OutPFSet_Ena: await this.readRegisterValue(baseAddr + 12, 1, 'uint16'),
+                OutPFSet_WinTms: outPFSetWinTmsRaw,
+                OutPFSet_RvrtTms: outPFSetRvrtTmsRaw,
+                OutPFSet_RmpTms: outPFSetRmpTmsRaw,
+                OutPFSet_Ena: outPFSetEnaRaw,
                 // Reactive power control - Offsets 13-20
-                VArWMaxPct: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 13, 1, 'int16'), scaleFactors.VArPct_SF, 'int16', 'Reactive Power at Max Power %'),
-                VArMaxPct: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 14, 1, 'int16'), scaleFactors.VArPct_SF, 'int16', 'Max Reactive Power %'),
-                VArAvalPct: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 15, 1, 'int16'), scaleFactors.VArPct_SF, 'int16', 'Available Reactive Power %'),
+                VArWMaxPct: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 13, 1, 'int16'), scaleFactors.VArPct_SF, 'int16', 'Reactive Power at Max Power %', 13, 123),
+                VArMaxPct: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 14, 1, 'int16'), scaleFactors.VArPct_SF, 'int16', 'Max Reactive Power %', 14, 123),
+                VArAvalPct: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 15, 1, 'int16'), scaleFactors.VArPct_SF, 'int16', 'Available Reactive Power %', 15, 123),
                 VArPct_SF: scaleFactors.VArPct_SF,
-                VArPct_WinTms: await this.readRegisterValue(baseAddr + 16, 1, 'uint16'),
-                VArPct_RvrtTms: await this.readRegisterValue(baseAddr + 17, 1, 'uint16'),
-                VArPct_RmpTms: await this.readRegisterValue(baseAddr + 18, 1, 'uint16'),
-                VArPct_Mod: await this.readRegisterValue(baseAddr + 19, 1, 'uint16'),
-                VArPct_Ena: await this.readRegisterValue(baseAddr + 20, 1, 'uint16')
+                VArPct_WinTms: vArPctWinTmsRaw,
+                VArPct_RvrtTms: vArPctRvrtTmsRaw,
+                VArPct_RmpTms: vArPctRmpTmsRaw,
+                VArPct_Mod: vArPctModRaw,
+                VArPct_Ena: vArPctEnaRaw
             };
             return controls;
         }