npm - @enyo-energy/sunspec-sdk - Versions diffs - 0.0.31 → 0.0.32 - Mend

@enyo-energy/sunspec-sdk 0.0.31 → 0.0.32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/dist/cjs/sunspec-devices.cjs +26 -1
package/dist/cjs/sunspec-devices.d.cts +10 -1
package/dist/cjs/sunspec-interfaces.cjs +82 -1
package/dist/cjs/sunspec-interfaces.d.cts +173 -0
package/dist/cjs/sunspec-modbus-client.cjs +538 -199
package/dist/cjs/sunspec-modbus-client.d.cts +18 -1
package/dist/cjs/version.cjs +1 -1
package/dist/cjs/version.d.cts +1 -1
package/dist/sunspec-devices.d.ts +10 -1
package/dist/sunspec-devices.js +26 -1
package/dist/sunspec-interfaces.d.ts +173 -0
package/dist/sunspec-interfaces.js +81 -0
package/dist/sunspec-modbus-client.d.ts +18 -1
package/dist/sunspec-modbus-client.js +539 -200
package/dist/version.d.ts +1 -1
package/dist/version.js +1 -1
package/package.json +1 -1

package/dist/sunspec-modbus-client.js CHANGED Viewed

@@ -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";
@@ -292,7 +292,7 @@ export class SunspecModbusClient {
             }
         }
         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}`);
     }
@@ -522,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'),
@@ -591,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;
         }
@@ -623,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
             };
         }
@@ -684,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
@@ -735,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) {
@@ -768,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');
@@ -777,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
@@ -790,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,
             };
@@ -900,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)
      */
@@ -934,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');
@@ -952,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,
@@ -1013,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,
@@ -1145,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');
@@ -1152,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) {
@@ -1230,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,
@@ -1282,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}`);
@@ -1361,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) {
@@ -1426,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;
         }