@enyo-energy/sunspec-sdk 0.0.39 → 0.0.41

package/dist/sunspec-modbus-client.js

@@ -363,6 +363,42 @@ export class SunspecModbusClient {
     cleanString(value) {
         return value.replace(/\u0000/g, '').trim();
     }
+    /**
+     * Read an entire model's register block in a single Modbus call.
+     * Returns a Buffer containing all registers for the model.
+     */
+    async readModelBlock(model) {
+        if (!this.faultTolerantReader) {
+            throw new Error('Fault-tolerant reader not initialized');
+        }
+        // Read model.length + 2 registers: the 2-register header (ID + length) plus all data registers.
+        // This way buffer offsets match the convention used throughout: offset 0 = model ID,
+        // offset 1 = model length, offset 2 = first data register, etc.
+        const totalRegisters = model.length + 2;
+        const result = await this.faultTolerantReader.readHoldingRegisters(model.address, totalRegisters);
+        if (!result.success || !result.value) {
+            throw new Error(`Failed to read model block ${model.id} at address ${model.address}: ${result.error?.message || 'Unknown error'}`);
+        }
+        this.connectionHealth.recordSuccess();
+        return result.value;
+    }
+    /**
+     * Extract a typed value from a model block buffer at a given register offset.
+     * @param buffer - The buffer returned by readModelBlock
+     * @param offset - Register offset within the model (0-based)
+     * @param dataType - The data type to convert to
+     * @param quantity - Number of registers to read (default: auto from dataType for strings, 1 otherwise)
+     */
+    extractValue(buffer, offset, dataType, quantity = 1) {
+        const byteOffset = offset * 2;
+        const byteLength = quantity * 2;
+        const sliced = buffer.subarray(byteOffset, byteOffset + byteLength);
+        const value = this.modbusDataTypeConverter.convertFromBuffer(sliced, dataType, undefined, quantity);
+        if (dataType === 'string') {
+            return this.cleanString(value);
+        }
+        return value;
+    }
     /**
      * Helper to read register value(s) using the fault-tolerant reader with data type conversion
      */
@@ -451,64 +487,63 @@ export class SunspecModbusClient {
             return this.readSinglePhaseInverterData(singlePhaseModel);
         }
         console.log(`Found 3-phase inverter model 103 at address ${model.address} with length ${model.length}`);
-        const baseAddr = model.address;
         try {
-            // Read all scale factors first using fault-tolerant reader
-            console.log(`Reading Inverter Data from Model ${model.id} at base address: ${baseAddr}`);
-            const scaleFactors = await this.readInverterScaleFactors(baseAddr);
-            // Read values using fault-tolerant reader with proper data types
-            // Read raw voltage values to check for unimplemented phases
-            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');
+            // Read entire model block in a single Modbus call
+            console.log(`Reading Inverter Data from Model ${model.id} at base address: ${model.address}`);
+            const buffer = await this.readModelBlock(model);
+            // Extract all scale factors from buffer
+            const scaleFactors = this.extractInverterScaleFactors(buffer);
+            // Extract raw values from buffer
+            const acCurrentRaw = this.extractValue(buffer, 2, 'uint16');
+            const voltageANRaw = this.extractValue(buffer, 10, 'uint16');
+            const voltageBNRaw = this.extractValue(buffer, 11, 'uint16');
+            const voltageCNRaw = this.extractValue(buffer, 12, 'uint16');
+            const acPowerRaw = this.extractValue(buffer, 14, 'int16');
+            const dcCurrentRaw = this.extractValue(buffer, 27, 'uint16');
+            const dcVoltageRaw = this.extractValue(buffer, 28, 'uint16');
+            const dcPowerRaw = this.extractValue(buffer, 30, 'int16');
             const data = {
                 blockNumber: 103,
                 blockAddress: model.address,
                 blockLength: model.length,
                 // AC Current values - Offsets 2-5
                 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),
+                phaseACurrent: this.applyScaleFactor(this.extractValue(buffer, 3, 'uint16'), scaleFactors.A_SF, 'uint16', 'Phase A Current', 3, 103),
+                phaseBCurrent: this.applyScaleFactor(this.extractValue(buffer, 4, 'uint16'), scaleFactors.A_SF, 'uint16', 'Phase B Current', 4, 103),
+                phaseCCurrent: this.applyScaleFactor(this.extractValue(buffer, 5, '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', 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),
+                voltageAB: this.applyScaleFactor(this.extractValue(buffer, 7, 'uint16'), scaleFactors.V_SF, 'uint16', 'Voltage AB', 7, 103),
+                voltageBC: this.applyScaleFactor(this.extractValue(buffer, 8, 'uint16'), scaleFactors.V_SF, 'uint16', 'Voltage BC', 8, 103),
+                voltageCA: this.applyScaleFactor(this.extractValue(buffer, 9, '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(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),
+                apparentPower: this.applyScaleFactor(this.extractValue(buffer, 18, 'uint16'), scaleFactors.VA_SF, 'uint16', 'Apparent Power', 18, 103),
+                reactivePower: this.applyScaleFactor(this.extractValue(buffer, 20, 'int16'), scaleFactors.VAr_SF, 'int16', 'Reactive Power', 20, 103),
+                powerFactor: this.applyScaleFactor(this.extractValue(buffer, 22, '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', 16, 103),
+                frequency: this.applyScaleFactor(this.extractValue(buffer, 16, 'uint16'), scaleFactors.Hz_SF, 'uint16', 'Frequency', 16, 103),
                 // DC values - Offsets 27, 28, 30
                 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', 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),
+                cabinetTemperature: this.applyScaleFactor(this.extractValue(buffer, 32, 'int16'), scaleFactors.Tmp_SF, 'int16', 'Cabinet Temperature', 32, 103),
+                heatSinkTemperature: this.applyScaleFactor(this.extractValue(buffer, 34, 'int16'), scaleFactors.Tmp_SF, 'int16', 'Heat Sink Temperature', 34, 103),
+                transformerTemperature: this.applyScaleFactor(this.extractValue(buffer, 35, 'int16'), scaleFactors.Tmp_SF, 'int16', 'Transformer Temperature', 35, 103),
+                otherTemperature: this.applyScaleFactor(this.extractValue(buffer, 36, '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'),
+                operatingState: this.extractValue(buffer, 38, 'uint16'),
+                vendorState: this.extractValue(buffer, 39, 'uint16'),
                 // Event bitfields - Offsets 40-51
-                events: await this.readRegisterValue(baseAddr + 40, 2, 'uint32'),
-                events2: await this.readRegisterValue(baseAddr + 42, 2, 'uint32'),
-                vendorEvents1: await this.readRegisterValue(baseAddr + 44, 2, 'uint32'),
-                vendorEvents2: await this.readRegisterValue(baseAddr + 46, 2, 'uint32'),
-                vendorEvents3: await this.readRegisterValue(baseAddr + 48, 2, 'uint32'),
-                vendorEvents4: await this.readRegisterValue(baseAddr + 50, 2, 'uint32')
+                events: this.extractValue(buffer, 40, 'uint32', 2),
+                events2: this.extractValue(buffer, 42, 'uint32', 2),
+                vendorEvents1: this.extractValue(buffer, 44, 'uint32', 2),
+                vendorEvents2: this.extractValue(buffer, 46, 'uint32', 2),
+                vendorEvents3: this.extractValue(buffer, 48, 'uint32', 2),
+                vendorEvents4: this.extractValue(buffer, 50, 'uint32', 2)
             };
             // Log non-scaled fields
             this.logRegisterRead(103, 38, 'Operating State', data.operatingState, 'enum16');
@@ -520,11 +555,12 @@ export class SunspecModbusClient {
             this.logRegisterRead(103, 48, 'Vendor Events 3', data.vendorEvents3, 'bitfield32');
             this.logRegisterRead(103, 50, 'Vendor Events 4', data.vendorEvents4, 'bitfield32');
             // Read AC Energy (32-bit accumulator) - Offset 24-25
-            const acEnergy = await this.readRegisterValue(baseAddr + 24, 2, 'uint32');
+            const acEnergy = this.extractValue(buffer, 24, 'uint32', 2);
             this.logRegisterRead(103, 24, 'AC Energy', acEnergy, 'acc32');
             data.acEnergy = !this.isUnimplementedValue(acEnergy, 'acc32')
                 ? acEnergy * Math.pow(10, scaleFactors.WH_SF)
                 : undefined;
+            console.debug('[Model 103] Inverter Data:', data);
             return data;
         }
         catch (error) {
@@ -536,20 +572,19 @@ export class SunspecModbusClient {
      * Read single phase inverter data (Model 101)
      */
     async readSinglePhaseInverterData(model) {
-        // Similar to 3-phase but with fewer phase-specific values
-        // Implementation would be similar but simplified
-        const baseAddr = model.address;
         try {
-            console.log(`Reading Single-Phase Inverter Data from Model 101 at base address: ${baseAddr}`);
-            // Read scale factors for single phase model
+            console.log(`Reading Single-Phase Inverter Data from Model 101 at base address: ${model.address}`);
+            // Read entire model block in a single Modbus call
+            const buffer = await this.readModelBlock(model);
+            // Extract scale factors from buffer
             const scaleFactors = {
-                A_SF: await this.readRegisterValue(baseAddr + 6, 1, 'int16'),
-                V_SF: await this.readRegisterValue(baseAddr + 13, 1, 'int16'),
-                W_SF: await this.readRegisterValue(baseAddr + 10, 1, 'int16'),
-                Hz_SF: await this.readRegisterValue(baseAddr + 12, 1, 'int16'),
-                DCA_SF: await this.readRegisterValue(baseAddr + 18, 1, 'int16'),
-                DCV_SF: await this.readRegisterValue(baseAddr + 19, 1, 'int16'),
-                DCW_SF: await this.readRegisterValue(baseAddr + 21, 1, 'int16')
+                A_SF: this.extractValue(buffer, 6, 'int16'),
+                V_SF: this.extractValue(buffer, 13, 'int16'),
+                W_SF: this.extractValue(buffer, 10, 'int16'),
+                Hz_SF: this.extractValue(buffer, 12, 'int16'),
+                DCA_SF: this.extractValue(buffer, 18, 'int16'),
+                DCV_SF: this.extractValue(buffer, 19, 'int16'),
+                DCW_SF: this.extractValue(buffer, 21, 'int16')
             };
             this.logRegisterRead(101, 6, 'A_SF', scaleFactors.A_SF, 'int16');
             this.logRegisterRead(101, 13, 'V_SF', scaleFactors.V_SF, 'int16');
@@ -558,17 +593,17 @@ export class SunspecModbusClient {
             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');
+            // Extract raw values from buffer
+            const acCurrentRaw = this.extractValue(buffer, 2, 'uint16');
+            const voltageRaw = this.extractValue(buffer, 7, 'uint16');
+            const acPowerRaw = this.extractValue(buffer, 9, 'int16');
+            const freqRaw = this.extractValue(buffer, 11, 'uint16');
+            const dcCurrentRaw = this.extractValue(buffer, 14, 'uint16');
+            const dcVoltageRaw = this.extractValue(buffer, 15, 'uint16');
+            const dcPowerRaw = this.extractValue(buffer, 20, 'int16');
+            const stateRaw = this.extractValue(buffer, 24, 'uint16');
             this.logRegisterRead(101, 24, 'Operating State', stateRaw, 'enum16');
-            return {
+            const data = {
                 blockNumber: 101,
                 voltageAN: this.applyScaleFactor(voltageRaw, scaleFactors.V_SF, 'uint16', 'Voltage AN', 7, 101),
                 acCurrent: this.applyScaleFactor(acCurrentRaw, scaleFactors.A_SF, 'uint16', 'AC Current', 2, 101),
@@ -579,6 +614,8 @@ export class SunspecModbusClient {
                 dcPower: this.applyScaleFactor(dcPowerRaw, scaleFactors.DCW_SF, 'int16', 'DC Power', 20, 101),
                 operatingState: stateRaw
             };
+            console.debug('[Model 101] Single Phase Inverter Data:', data);
+            return data;
         }
         catch (error) {
             console.error(`Error reading single phase inverter data: ${error}`);
@@ -586,22 +623,22 @@ export class SunspecModbusClient {
         }
     }
     /**
-     * Read inverter scale factors
+     * Extract inverter scale factors from a pre-read model buffer
      */
-    async readInverterScaleFactors(baseAddr) {
+    extractInverterScaleFactors(buffer) {
         const scaleFactors = {
-            A_SF: await this.readRegisterValue(baseAddr + 6, 1, 'int16'), // Offset 6
-            V_SF: await this.readRegisterValue(baseAddr + 13, 1, 'int16'), // Offset 13
-            W_SF: await this.readRegisterValue(baseAddr + 15, 1, 'int16'), // Offset 15
-            Hz_SF: await this.readRegisterValue(baseAddr + 17, 1, 'int16'), // Offset 17
-            VA_SF: await this.readRegisterValue(baseAddr + 19, 1, 'int16'), // Offset 19
-            VAr_SF: await this.readRegisterValue(baseAddr + 21, 1, 'int16'), // Offset 21
-            PF_SF: await this.readRegisterValue(baseAddr + 23, 1, 'int16'), // Offset 23
-            WH_SF: await this.readRegisterValue(baseAddr + 26, 1, 'int16'), // Offset 26
-            DCA_SF: await this.readRegisterValue(baseAddr + 28, 1, 'int16'), // Offset 28
-            DCV_SF: await this.readRegisterValue(baseAddr + 29, 1, 'int16'), // Offset 29
-            DCW_SF: await this.readRegisterValue(baseAddr + 31, 1, 'int16'), // Offset 31
-            Tmp_SF: await this.readRegisterValue(baseAddr + 36, 1, 'int16') // Offset 36
+            A_SF: this.extractValue(buffer, 6, 'int16'), // Offset 6
+            V_SF: this.extractValue(buffer, 13, 'int16'), // Offset 13
+            W_SF: this.extractValue(buffer, 15, 'int16'), // Offset 15
+            Hz_SF: this.extractValue(buffer, 17, 'int16'), // Offset 17
+            VA_SF: this.extractValue(buffer, 19, 'int16'), // Offset 19
+            VAr_SF: this.extractValue(buffer, 21, 'int16'), // Offset 21
+            PF_SF: this.extractValue(buffer, 23, 'int16'), // Offset 23
+            WH_SF: this.extractValue(buffer, 26, 'int16'), // Offset 26
+            DCA_SF: this.extractValue(buffer, 28, 'int16'), // Offset 28
+            DCV_SF: this.extractValue(buffer, 29, 'int16'), // Offset 29
+            DCW_SF: this.extractValue(buffer, 31, 'int16'), // Offset 31
+            Tmp_SF: this.extractValue(buffer, 36, 'int16') // Offset 36
         };
         this.logRegisterRead(103, 6, 'A_SF', scaleFactors.A_SF, 'int16');
         this.logRegisterRead(103, 13, 'V_SF', scaleFactors.V_SF, 'int16');
@@ -663,38 +700,91 @@ export class SunspecModbusClient {
      *
      * @returns Object containing all scale factors or null if model not found
      */
+    /**
+     * Extract MPPT scale factors from a pre-read model buffer
+     */
+    extractMPPTScaleFactors(buffer) {
+        const scaleFactors = {
+            DCA_SF: this.extractValue(buffer, 2, 'int16'),
+            DCV_SF: this.extractValue(buffer, 3, 'int16'),
+            DCW_SF: this.extractValue(buffer, 4, 'int16'),
+            DCWH_SF: this.extractValue(buffer, 5, 'int16'),
+        };
+        this.logRegisterRead(160, 2, 'DCA_SF', scaleFactors.DCA_SF, 'int16');
+        this.logRegisterRead(160, 3, 'DCV_SF', scaleFactors.DCV_SF, 'int16');
+        this.logRegisterRead(160, 4, 'DCW_SF', scaleFactors.DCW_SF, 'int16');
+        this.logRegisterRead(160, 5, 'DCWH_SF', scaleFactors.DCWH_SF, 'int16');
+        return scaleFactors;
+    }
     async readMPPTScaleFactors() {
         const model = this.findModel(SunspecModelId.MPPT);
         if (!model) {
             console.log('MPPT model 160 not found');
             return null;
         }
-        const baseAddr = model.address;
         try {
-            // MPPT modules are repeating blocks, calculate offset for specific module
-            const moduleAddr = baseAddr;
-            // Read scale factors at their specific offsets
-            const DCA_SF = await this.readRegisterValue(moduleAddr + 2, 1, 'int16');
-            const DCV_SF = await this.readRegisterValue(moduleAddr + 3, 1, 'int16');
-            const DCW_SF = await this.readRegisterValue(moduleAddr + 4, 1, 'int16');
-            const DCWH_SF = await this.readRegisterValue(moduleAddr + 5, 1, 'int16');
-            const scaleFactors = {
-                DCA_SF, // Current Scale Factor
-                DCV_SF, // Voltage Scale Factor
-                DCW_SF, // Power Scale Factor
-                DCWH_SF, // Energy Scale Factor
-            };
-            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;
+            const buffer = await this.readModelBlock(model);
+            return this.extractMPPTScaleFactors(buffer);
         }
         catch (error) {
             console.error(`Error reading MPPT scale factors: ${error}`);
             return null;
         }
     }
+    /**
+     * Extract MPPT module data from a pre-read model buffer
+     */
+    extractMPPTModuleData(buffer, model, moduleId, scaleFactors) {
+        const fixedBlockScaleFactorsOffset = 10;
+        const moduleSize = 20;
+        const offset = (moduleId - 1) * moduleSize;
+        const moduleOffset = fixedBlockScaleFactorsOffset + offset;
+        const id = this.extractValue(buffer, moduleOffset, 'uint16');
+        const idString = this.extractValue(buffer, moduleOffset + 1, 'string', 8);
+        const dcCurrentRaw = this.extractValue(buffer, moduleOffset + 9, 'uint16');
+        const dcVoltageRaw = this.extractValue(buffer, moduleOffset + 10, 'uint16');
+        const dcPowerRaw = this.extractValue(buffer, moduleOffset + 11, 'uint16');
+        const dcEnergyRaw = this.extractValue(buffer, moduleOffset + 12, 'uint32', 2);
+        const temperatureRaw = this.extractValue(buffer, moduleOffset + 16, 'int16');
+        const dcst = this.extractValue(buffer, moduleOffset + 17, 'uint16');
+        this.logRegisterRead(160, 0, `MPPT ${moduleId} ID`, id, 'uint16');
+        this.logRegisterRead(160, 1, `MPPT ${moduleId} String ID`, idString, 'string');
+        if (this.isUnimplementedValue(id, 'uint16') &&
+            this.isUnimplementedValue(dcCurrentRaw, 'uint16') &&
+            this.isUnimplementedValue(dcVoltageRaw, 'uint16') &&
+            this.isUnimplementedValue(dcPowerRaw, 'uint16')) {
+            console.log(`MPPT module ${moduleId} appears to be unconnected (all values are 0xFFFF)`);
+            return null;
+        }
+        const temperatureScaleFactor = -1;
+        this.logRegisterRead(160, 12, `MPPT ${moduleId} DC Energy`, dcEnergyRaw, 'acc32');
+        const timestampRaw = this.extractValue(buffer, moduleOffset + 14, 'uint32', 2);
+        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`, 9, 160),
+            dcCurrentSF: scaleFactors.DCA_SF,
+            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`, 11, 160),
+            dcPowerSF: scaleFactors.DCW_SF,
+            dcEnergy: !this.isUnimplementedValue(dcEnergyRaw, 'acc32')
+                ? dcEnergyRaw * Math.pow(10, scaleFactors.DCWH_SF)
+                : undefined,
+            dcEnergySF: scaleFactors.DCWH_SF,
+            timestamp: timestampRaw,
+            temperature: this.applyScaleFactor(temperatureRaw, temperatureScaleFactor, 'int16', `MPPT ${moduleId} Temperature`, 16, 160),
+            temperatureSF: temperatureScaleFactor,
+            operatingState: dcst,
+        };
+        console.debug(`[Model 160] MPPT Module ${moduleId} Data:`, data);
+        return data;
+    }
     /**
      * Read MPPT data from Model 160
      */
@@ -704,68 +794,11 @@ export class SunspecModbusClient {
             console.log('MPPT model 160 not found');
             return null;
         }
-        const baseAddr = model.address;
         try {
-            const fixedBlockScaleFactorsOffset = 10;
-            // MPPT modules are repeating blocks, calculate offset for specific module
-            const moduleSize = 20; // Size of each MPPT module based on CSV (offsets 0-20)
-            const offset = (moduleId - 1) * moduleSize;
-            const moduleAddr = baseAddr + fixedBlockScaleFactorsOffset + offset;
-            // Read scale factors using dedicated method
-            const scaleFactors = await this.readMPPTScaleFactors();
-            if (!scaleFactors) {
-                console.error(`Failed to read scale factors for MPPT module ${moduleId}`);
-                return null;
-            }
-            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');
-            const dcVoltageRaw = await this.readRegisterValue(moduleAddr + 10, 1, 'uint16');
-            const dcPowerRaw = await this.readRegisterValue(moduleAddr + 11, 1, 'uint16');
-            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
-            if (this.isUnimplementedValue(id, 'uint16') &&
-                this.isUnimplementedValue(dcCurrentRaw, 'uint16') &&
-                this.isUnimplementedValue(dcVoltageRaw, 'uint16') &&
-                this.isUnimplementedValue(dcPowerRaw, 'uint16')) {
-                console.log(`MPPT module ${moduleId} appears to be unconnected (all values are 0xFFFF)`);
-                return null;
-            }
-            // 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`, 9, 160),
-                dcCurrentSF: scaleFactors.DCA_SF,
-                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`, 11, 160),
-                dcPowerSF: scaleFactors.DCW_SF,
-                dcEnergy: !this.isUnimplementedValue(dcEnergyRaw, 'acc32')
-                    ? dcEnergyRaw * Math.pow(10, scaleFactors.DCWH_SF)
-                    : undefined,
-                dcEnergySF: scaleFactors.DCWH_SF,
-                timestamp: timestampRaw,
-                temperature: this.applyScaleFactor(temperatureRaw, temperatureScaleFactor, 'int16', `MPPT ${moduleId} Temperature`, 16, 160),
-                temperatureSF: temperatureScaleFactor,
-                operatingState: dcst,
-            };
-            return data;
+            // Read entire model block in a single Modbus call
+            const buffer = await this.readModelBlock(model);
+            const scaleFactors = this.extractMPPTScaleFactors(buffer);
+            return this.extractMPPTModuleData(buffer, model, moduleId, scaleFactors);
         }
         catch (error) {
             console.error(`Error reading MPPT data for module ${moduleId}: ${error}`);
@@ -777,24 +810,18 @@ export class SunspecModbusClient {
      */
     async readAllMPPTData() {
         const mpptData = [];
-        // Find the MPPT model first
         const model = this.findModel(SunspecModelId.MPPT);
         if (!model) {
             console.log('MPPT model 160 not found');
             return [];
         }
-        const scaleFactors = await this.readMPPTScaleFactors();
-        if (!scaleFactors) {
-            console.error(`Failed to read scale factors for MPPT`);
-            return [];
-        }
-        // Read the module count from register 8
-        let moduleCount = 4; // Default fallback value
         try {
-            const baseAddr = model.address;
-            // Register 8 contains the number of modules
-            const count = await this.readRegisterValue(baseAddr + 8, 1, 'uint16');
-            // Validate the module count
+            // Read entire model block in a single Modbus call
+            const buffer = await this.readModelBlock(model);
+            const scaleFactors = this.extractMPPTScaleFactors(buffer);
+            // Read the module count from register 8
+            let moduleCount = 4; // Default fallback value
+            const count = this.extractValue(buffer, 8, 'uint16');
             if (!this.isUnimplementedValue(count, 'uint16') && count > 0 && count <= 20) {
                 moduleCount = count;
                 console.log(`MPPT module count from register 8: ${moduleCount}`);
@@ -802,27 +829,25 @@ export class SunspecModbusClient {
             else {
                 console.log(`Invalid or unimplemented module count (${count}), using default: ${moduleCount}`);
             }
-        }
-        catch (error) {
-            console.error(`Error reading module count from register 8: ${error}, using default: ${moduleCount}`);
-        }
-        // Read each MPPT module based on the actual count
-        for (let i = 1; i <= moduleCount; i++) {
-            try {
-                const data = await this.readMPPTData(i);
-                console.log(`MPPT ${i} has id ${data?.id} (${data?.stringId}) with ${data?.dcPower}W`);
-                // Only include if we got valid data (not null) and it has actual values
-                if (data &&
-                    (data.dcCurrent !== undefined ||
-                        data.dcVoltage !== undefined ||
-                        data.dcPower !== undefined)) {
-                    mpptData.push(data);
+            // Extract each MPPT module from the same buffer
+            for (let i = 1; i <= moduleCount; i++) {
+                try {
+                    const data = this.extractMPPTModuleData(buffer, model, i, scaleFactors);
+                    console.log(`MPPT ${i} has id ${data?.id} (${data?.stringId}) with ${data?.dcPower}W`);
+                    if (data &&
+                        (data.dcCurrent !== undefined ||
+                            data.dcVoltage !== undefined ||
+                            data.dcPower !== undefined)) {
+                        mpptData.push(data);
+                    }
+                }
+                catch (error) {
+                    console.debug(`Could not read MPPT module ${i}: ${error}`);
                 }
             }
-            catch (error) {
-                console.debug(`Could not read MPPT module ${i}: ${error}`);
-                // Continue to try other modules
-            }
+        }
+        catch (error) {
+            console.error(`Error reading all MPPT data: ${error}`);
         }
         return mpptData;
     }
@@ -919,22 +944,22 @@ export class SunspecModbusClient {
         }
     }
     /**
-     * Read Model 802 scale factors (offsets 52-63)
+     * Extract Model 802 scale factors from a pre-read buffer (offsets 52-63)
      */
-    async readBatteryBaseScaleFactors(baseAddr) {
+    extractBatteryBaseScaleFactors(buffer) {
         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'),
+            AHRtg_SF: this.extractValue(buffer, 52, 'int16'),
+            WHRtg_SF: this.extractValue(buffer, 53, 'int16'),
+            WChaDisChaMax_SF: this.extractValue(buffer, 54, 'int16'),
+            DisChaRte_SF: this.extractValue(buffer, 55, 'int16'),
+            SoC_SF: this.extractValue(buffer, 56, 'int16'),
+            DoD_SF: this.extractValue(buffer, 57, 'int16'),
+            SoH_SF: this.extractValue(buffer, 58, 'int16'),
+            V_SF: this.extractValue(buffer, 59, 'int16'),
+            CellV_SF: this.extractValue(buffer, 60, 'int16'),
+            A_SF: this.extractValue(buffer, 61, 'int16'),
+            AMax_SF: this.extractValue(buffer, 62, 'int16'),
+            W_SF: this.extractValue(buffer, 63, 'int16'),
         };
         this.logRegisterRead(802, 52, 'AHRtg_SF', scaleFactors.AHRtg_SF, 'int16');
         this.logRegisterRead(802, 53, 'WHRtg_SF', scaleFactors.WHRtg_SF, 'int16');
@@ -959,51 +984,52 @@ export class SunspecModbusClient {
             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}`);
+        console.log(`Reading Battery Base Data from Model 802 at base address: ${model.address}`);
         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');
+            // Read entire model block in a single Modbus call
+            const buffer = await this.readModelBlock(model);
+            // Extract scale factors from buffer (offsets 52-63)
+            const sf = this.extractBatteryBaseScaleFactors(buffer);
+            // Extract raw values from buffer
+            const ahRtgRaw = this.extractValue(buffer, 2, 'uint16');
+            const whRtgRaw = this.extractValue(buffer, 3, 'uint16');
+            const wChaRteMaxRaw = this.extractValue(buffer, 4, 'uint16');
+            const wDisChaRteMaxRaw = this.extractValue(buffer, 5, 'uint16');
+            const disChaRteRaw = this.extractValue(buffer, 6, 'uint16');
+            const soCMaxRaw = this.extractValue(buffer, 7, 'uint16');
+            const soCMinRaw = this.extractValue(buffer, 8, 'uint16');
+            const soCRsvMaxRaw = this.extractValue(buffer, 9, 'uint16');
+            const soCRsvMinRaw = this.extractValue(buffer, 10, 'uint16');
+            const soCRaw = this.extractValue(buffer, 11, 'uint16');
+            const doDRaw = this.extractValue(buffer, 12, 'uint16');
+            const soHRaw = this.extractValue(buffer, 13, 'uint16');
+            const nCycRaw = this.extractValue(buffer, 14, 'uint32', 2);
+            const chaStRaw = this.extractValue(buffer, 16, 'uint16');
+            const locRemCtlRaw = this.extractValue(buffer, 17, 'uint16');
+            const typRaw = this.extractValue(buffer, 21, 'uint16');
+            const stateRaw = this.extractValue(buffer, 22, 'uint16');
+            const evt1Raw = this.extractValue(buffer, 26, 'uint32', 2);
+            const evt2Raw = this.extractValue(buffer, 28, 'uint32', 2);
+            const evtVnd1Raw = this.extractValue(buffer, 30, 'uint32', 2);
+            const evtVnd2Raw = this.extractValue(buffer, 32, 'uint32', 2);
+            const vRaw = this.extractValue(buffer, 34, 'uint16');
+            const vMaxRaw = this.extractValue(buffer, 35, 'uint16');
+            const vMinRaw = this.extractValue(buffer, 36, 'uint16');
+            const cellVMaxRaw = this.extractValue(buffer, 37, 'uint16');
+            const cellVMaxStrRaw = this.extractValue(buffer, 38, 'uint16');
+            const cellVMaxModRaw = this.extractValue(buffer, 39, 'uint16');
+            const cellVMinRaw = this.extractValue(buffer, 40, 'uint16');
+            const cellVMinStrRaw = this.extractValue(buffer, 41, 'uint16');
+            const cellVMinModRaw = this.extractValue(buffer, 42, 'uint16');
+            const cellVAvgRaw = this.extractValue(buffer, 43, 'uint16');
+            const aRaw = this.extractValue(buffer, 44, 'int16');
+            const aChaMaxRaw = this.extractValue(buffer, 45, 'uint16');
+            const aDisChaMaxRaw = this.extractValue(buffer, 46, 'uint16');
+            const wRaw = this.extractValue(buffer, 47, 'int16');
+            const reqInvStateRaw = this.extractValue(buffer, 48, 'uint16');
+            const reqWRaw = this.extractValue(buffer, 49, 'int16');
+            const setOpRaw = this.extractValue(buffer, 50, 'uint16');
+            const setInvStateRaw = this.extractValue(buffer, 51, 'uint16');
             // Map enum fields
             const chaStName = this.mapBatteryChargeState(chaStRaw);
             const typName = this.mapBatteryType(typRaw);
@@ -1079,6 +1105,7 @@ export class SunspecModbusClient {
                 setOp: !this.isUnimplementedValue(setOpRaw, 'enum16') ? setOpRaw : undefined,
                 setInvState: !this.isUnimplementedValue(setInvStateRaw, 'enum16') ? setInvStateRaw : undefined,
             };
+            console.debug('[Model 802] Battery Base Data:', data);
             return data;
         }
         catch (error) {
@@ -1103,22 +1130,23 @@ export class SunspecModbusClient {
             console.log('No battery model found');
             return null;
         }
-        const baseAddr = model.address;
-        console.log(`Reading Battery Data from Model ${model.id} at base address: ${baseAddr}`);
+        console.log(`Reading Battery Data from Model ${model.id} at base address: ${model.address}`);
         try {
             if (model.id === 124) {
                 // Model 124: Basic Storage Controls
                 console.log('Using Model 124 (Basic Storage Controls)');
-                // Read scale factors first (offsets 18-25)
+                // Read entire model block in a single Modbus call
+                const buffer = await this.readModelBlock(model);
+                // Extract scale factors from buffer (offsets 18-25)
                 const scaleFactors = {
-                    WChaMax_SF: await this.readRegisterValue(baseAddr + 18, 1, 'int16'),
-                    WChaDisChaGra_SF: await this.readRegisterValue(baseAddr + 19, 1, 'int16'),
-                    VAChaMax_SF: await this.readRegisterValue(baseAddr + 20, 1, 'int16'),
-                    MinRsvPct_SF: await this.readRegisterValue(baseAddr + 21, 1, 'int16'),
-                    ChaState_SF: await this.readRegisterValue(baseAddr + 22, 1, 'int16'),
-                    StorAval_SF: await this.readRegisterValue(baseAddr + 23, 1, 'int16'),
-                    InBatV_SF: await this.readRegisterValue(baseAddr + 24, 1, 'int16'),
-                    InOutWRte_SF: await this.readRegisterValue(baseAddr + 25, 1, 'int16')
+                    WChaMax_SF: this.extractValue(buffer, 18, 'int16'),
+                    WChaDisChaGra_SF: this.extractValue(buffer, 19, 'int16'),
+                    VAChaMax_SF: this.extractValue(buffer, 20, 'int16'),
+                    MinRsvPct_SF: this.extractValue(buffer, 21, 'int16'),
+                    ChaState_SF: this.extractValue(buffer, 22, 'int16'),
+                    StorAval_SF: this.extractValue(buffer, 23, 'int16'),
+                    InBatV_SF: this.extractValue(buffer, 24, 'int16'),
+                    InOutWRte_SF: this.extractValue(buffer, 25, 'int16')
                 };
                 this.logRegisterRead(124, 18, 'WChaMax_SF', scaleFactors.WChaMax_SF, 'int16');
                 this.logRegisterRead(124, 19, 'WChaDisChaGra_SF', scaleFactors.WChaDisChaGra_SF, 'int16');
@@ -1128,23 +1156,23 @@ export class SunspecModbusClient {
                 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');
-                const wDisChaGraRaw = await this.readRegisterValue(baseAddr + 4, 1, 'uint16');
-                const storCtlModRaw = await this.readRegisterValue(baseAddr + 5, 1, 'uint16');
-                const vaChaMaxRaw = await this.readRegisterValue(baseAddr + 6, 1, 'uint16');
-                const minRsvPctRaw = await this.readRegisterValue(baseAddr + 7, 1, 'uint16');
-                const chaStateRaw = await this.readRegisterValue(baseAddr + 8, 1, 'uint16');
-                const storAvalRaw = await this.readRegisterValue(baseAddr + 9, 1, 'uint16');
-                const inBatVRaw = await this.readRegisterValue(baseAddr + 10, 1, 'uint16');
-                const chaStRaw = await this.readRegisterValue(baseAddr + 11, 1, 'uint16');
-                const outWRteRaw = await this.readRegisterValue(baseAddr + 12, 1, 'int16');
-                const inWRteRaw = await this.readRegisterValue(baseAddr + 13, 1, 'int16');
-                const inOutWRteWinTmsRaw = await this.readRegisterValue(baseAddr + 14, 1, 'uint16');
-                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');
+                // Extract raw values from buffer
+                const wChaMaxRaw = this.extractValue(buffer, 2, 'uint16');
+                const wChaGraRaw = this.extractValue(buffer, 3, 'uint16');
+                const wDisChaGraRaw = this.extractValue(buffer, 4, 'uint16');
+                const storCtlModRaw = this.extractValue(buffer, 5, 'uint16');
+                const vaChaMaxRaw = this.extractValue(buffer, 6, 'uint16');
+                const minRsvPctRaw = this.extractValue(buffer, 7, 'uint16');
+                const chaStateRaw = this.extractValue(buffer, 8, 'uint16');
+                const storAvalRaw = this.extractValue(buffer, 9, 'uint16');
+                const inBatVRaw = this.extractValue(buffer, 10, 'uint16');
+                const chaStRaw = this.extractValue(buffer, 11, 'uint16');
+                const outWRteRaw = this.extractValue(buffer, 12, 'int16');
+                const inWRteRaw = this.extractValue(buffer, 13, 'int16');
+                const inOutWRteWinTmsRaw = this.extractValue(buffer, 14, 'uint16');
+                const inOutWRteRvrtTmsRaw = this.extractValue(buffer, 15, 'uint16');
+                const inOutWRteRmpTmsRaw = this.extractValue(buffer, 16, 'uint16');
+                const chaGriSetRaw = this.extractValue(buffer, 17, 'uint16');
                 // Map charge state and log non-scaled fields
                 const chaStName = this.mapBatteryChargeState(chaStRaw);
                 this.logRegisterRead(124, 5, 'storCtlMod', storCtlModRaw, 'bitfield16');
@@ -1203,6 +1231,7 @@ export class SunspecModbusClient {
                     data.dischargePower = Math.abs((data.outWRte / 100) * data.wChaMax);
                     console.log(`Calculated Discharge Power (inWRte: ${data.outWRte}, wChaMax: ${data.wChaMax}): ${data.dischargePower?.toFixed(2)} W`);
                 }
+                console.debug('[Model 124] Battery Data:', data);
                 return data;
             }
             else if (model.id === 802) {
@@ -1225,7 +1254,7 @@ export class SunspecModbusClient {
                         dischargePower = Math.abs(baseData.w);
                     }
                 }
-                return {
+                const result = {
                     blockNumber: 802,
                     blockAddress: model.address,
                     blockLength: model.length,
@@ -1239,6 +1268,8 @@ export class SunspecModbusClient {
                     chargePower,
                     dischargePower,
                 };
+                console.debug('[Model 802] Battery Data:', result);
+                return result;
             }
             else {
                 // Handle other battery models (803) if needed
@@ -1363,29 +1394,30 @@ export class SunspecModbusClient {
             console.log('Battery model 124 not found');
             return null;
         }
-        const baseAddr = model.address;
-        console.log(`Reading Battery Controls from Model 124 at base address: ${baseAddr}`);
+        console.log(`Reading Battery Controls from Model 124 at base address: ${model.address}`);
         try {
-            // Read scale factors
+            // Read entire model block in a single Modbus call
+            const buffer = await this.readModelBlock(model);
+            // Extract scale factors from buffer
             const scaleFactors = {
-                WChaMax_SF: await this.readRegisterValue(baseAddr + 18, 1, 'int16'),
-                MinRsvPct_SF: await this.readRegisterValue(baseAddr + 21, 1, 'int16'),
-                InOutWRte_SF: await this.readRegisterValue(baseAddr + 25, 1, 'int16')
+                WChaMax_SF: this.extractValue(buffer, 18, 'int16'),
+                MinRsvPct_SF: this.extractValue(buffer, 21, 'int16'),
+                InOutWRte_SF: this.extractValue(buffer, 25, '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');
-            const minRsvPctRaw = await this.readRegisterValue(baseAddr + 7, 1, 'uint16');
-            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');
+            // Extract raw values from buffer
+            const wChaMaxRaw = this.extractValue(buffer, 2, 'uint16');
+            const storCtlModRaw = this.extractValue(buffer, 5, 'uint16');
+            const minRsvPctRaw = this.extractValue(buffer, 7, 'uint16');
+            const outWRteRaw = this.extractValue(buffer, 12, 'int16');
+            const inWRteRaw = this.extractValue(buffer, 13, 'int16');
+            const chaGriSetRaw = this.extractValue(buffer, 17, 'uint16');
             this.logRegisterRead(124, 5, 'storCtlMod', storCtlModRaw, 'bitfield16');
             this.logRegisterRead(124, 17, 'chaGriSet', chaGriSetRaw, 'enum16');
             // Apply scale factors and return control settings
-            return {
+            const controls = {
                 storCtlMod: !this.isUnimplementedValue(storCtlModRaw, 'bitfield16') ? storCtlModRaw : undefined,
                 chaGriSet: !this.isUnimplementedValue(chaGriSetRaw, 'enum16') ? chaGriSetRaw : undefined,
                 wChaMax: this.applyScaleFactor(wChaMaxRaw, scaleFactors.WChaMax_SF, 'uint16', 'Max Charge Power', 2, 124),
@@ -1393,6 +1425,8 @@ export class SunspecModbusClient {
                 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)
             };
+            console.debug('[Model 124] Battery Controls:', controls);
+            return controls;
         }
         catch (error) {
             console.error(`Error reading battery controls: ${error}`);
@@ -1414,8 +1448,7 @@ export class SunspecModbusClient {
             console.log('No meter model found');
             return null;
         }
-        const baseAddr = model.address;
-        console.log(`Reading Meter Data from Model ${model.id} at base address: ${baseAddr}`);
+        console.log(`Reading Meter Data from Model ${model.id} at base address: ${model.address}`);
         try {
             // Different meter models have different register offsets
             console.log(`Meter is Model ${model.id}`);
@@ -1458,18 +1491,20 @@ export class SunspecModbusClient {
                     importOffset = 46; // TotWhImp - Total Wh Imported (acc32)
                     energySFOffset = 54; // TotWh_SF - Total Energy scale factor
             }
-            // Read scale factors
-            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');
+            // Read entire model block in a single Modbus call
+            const buffer = await this.readModelBlock(model);
+            // Extract scale factors from buffer
+            const powerSF = this.extractValue(buffer, powerSFOffset, 'int16');
+            const freqSF = this.extractValue(buffer, freqSFOffset, 'int16');
+            const energySF = this.extractValue(buffer, energySFOffset, 'int16');
             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 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');
+            // Extract raw values from buffer
+            const powerRaw = this.extractValue(buffer, powerOffset, 'int16');
+            const freqRaw = this.extractValue(buffer, freqOffset, 'uint16');
+            const exportRaw = this.extractValue(buffer, exportOffset, 'uint32', 2);
+            const importRaw = this.extractValue(buffer, importOffset, 'uint32', 2);
             this.logRegisterRead(model.id, exportOffset, 'TotWhExp', exportRaw, 'acc32');
             this.logRegisterRead(model.id, importOffset, 'TotWhImp', importRaw, 'acc32');
             // Calculate final values with scale factors
@@ -1477,13 +1512,15 @@ export class SunspecModbusClient {
             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 {
+            const data = {
                 blockNumber: model.id,
                 totalPower,
                 frequency,
                 exportedEnergy,
                 importedEnergy
             };
+            console.debug(`[Model ${model.id}] Meter Data:`, data);
+            return data;
         }
         catch (error) {
             console.error(`Error reading meter data: ${error}`);
@@ -1499,30 +1536,28 @@ export class SunspecModbusClient {
             console.error('Common block model not found');
             return null;
         }
-        const baseAddr = model.address + 2; // Skip ID and Length
-        console.log(`Reading Common Block - Model address: ${model.address}, Base address for data: ${baseAddr}`);
+        console.log(`Reading Common Block - Model address: ${model.address}`);
         try {
-            // Read all strings using fault-tolerant reader with proper data type conversion
-            // Common block offsets are relative to the start of the data (after ID and Length)
-            const manufacturerAddr = baseAddr; // Offset 0-15 (16 registers) from data start
-            const modelAddr = baseAddr + 16; // Offset 16-31 (16 registers) from data start
-            const optionsAddr = baseAddr + 32; // Offset 32-39 (8 registers) from data start
-            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
-            const manufacturer = await this.readRegisterValue(manufacturerAddr, 16, 'string');
+            // Read entire model block in a single Modbus call
+            const buffer = await this.readModelBlock(model);
+            // Common block offsets are relative to the model start (after ID and Length header,
+            // but readModelBlock reads from model.address which includes the data area).
+            // The offsets below are relative to the data start within the model block.
+            // Since model.address points to the first data register (after the 2-register header
+            // is already accounted for in model discovery), offset 0 = first data register.
+            const manufacturer = this.extractValue(buffer, 2, 'string', 16);
             this.logRegisterRead(1, 0, 'Manufacturer', manufacturer, 'string');
-            const modelName = await this.readRegisterValue(modelAddr, 16, 'string');
+            const modelName = this.extractValue(buffer, 18, 'string', 16);
             this.logRegisterRead(1, 16, 'Model', modelName, 'string');
-            const options = await this.readRegisterValue(optionsAddr, 8, 'string');
+            const options = this.extractValue(buffer, 34, 'string', 8);
             this.logRegisterRead(1, 32, 'Options', options, 'string');
-            const version = await this.readRegisterValue(versionAddr, 8, 'string');
+            const version = this.extractValue(buffer, 42, 'string', 8);
             this.logRegisterRead(1, 40, 'Version', version, 'string');
-            const serialNumber = await this.readRegisterValue(serialAddr, 16, 'string');
+            const serialNumber = this.extractValue(buffer, 50, 'string', 16);
             this.logRegisterRead(1, 48, 'Serial Number', serialNumber, 'string');
-            const deviceAddress = await this.readRegisterValue(deviceAddrAddr, 1, 'uint16');
+            const deviceAddress = this.extractValue(buffer, 66, 'uint16');
             this.logRegisterRead(1, 64, 'Device Address', deviceAddress, 'uint16');
-            return {
+            const data = {
                 manufacturer,
                 model: modelName,
                 options,
@@ -1530,6 +1565,8 @@ export class SunspecModbusClient {
                 serialNumber,
                 deviceAddress
             };
+            console.debug('[Model 1] Common Block:', data);
+            return data;
         }
         catch (error) {
             console.error(`Error reading common block: ${error}`);
@@ -1570,20 +1607,21 @@ export class SunspecModbusClient {
             console.log('Settings model 121 not found');
             return null;
         }
-        const baseAddr = model.address;
         try {
-            // Read scale factors first (offsets 22-31)
+            // Read entire model block in a single Modbus call
+            const buffer = await this.readModelBlock(model);
+            // Extract scale factors from buffer (offsets 22-31)
             const scaleFactors = {
-                WMax_SF: await this.readRegisterValue(baseAddr + 22, 1, 'int16'),
-                VRef_SF: await this.readRegisterValue(baseAddr + 23, 1, 'int16'),
-                VRefOfs_SF: await this.readRegisterValue(baseAddr + 24, 1, 'int16'),
-                VMinMax_SF: await this.readRegisterValue(baseAddr + 25, 1, 'int16'),
-                VAMax_SF: await this.readRegisterValue(baseAddr + 26, 1, 'int16'),
-                VArMax_SF: await this.readRegisterValue(baseAddr + 27, 1, 'int16'),
-                WGra_SF: await this.readRegisterValue(baseAddr + 28, 1, 'int16'),
-                PFMin_SF: await this.readRegisterValue(baseAddr + 29, 1, 'int16'),
-                MaxRmpRte_SF: await this.readRegisterValue(baseAddr + 30, 1, 'int16'),
-                ECPNomHz_SF: await this.readRegisterValue(baseAddr + 31, 1, 'int16')
+                WMax_SF: this.extractValue(buffer, 22, 'int16'),
+                VRef_SF: this.extractValue(buffer, 23, 'int16'),
+                VRefOfs_SF: this.extractValue(buffer, 24, 'int16'),
+                VMinMax_SF: this.extractValue(buffer, 25, 'int16'),
+                VAMax_SF: this.extractValue(buffer, 26, 'int16'),
+                VArMax_SF: this.extractValue(buffer, 27, 'int16'),
+                WGra_SF: this.extractValue(buffer, 28, 'int16'),
+                PFMin_SF: this.extractValue(buffer, 29, 'int16'),
+                MaxRmpRte_SF: this.extractValue(buffer, 30, 'int16'),
+                ECPNomHz_SF: this.extractValue(buffer, 31, 'int16')
             };
             this.logRegisterRead(121, 22, 'WMax_SF', scaleFactors.WMax_SF, 'int16');
             this.logRegisterRead(121, 23, 'VRef_SF', scaleFactors.VRef_SF, 'int16');
@@ -1595,55 +1633,57 @@ export class SunspecModbusClient {
             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');
+            // Extract non-scaled fields from buffer
+            const vArActRaw = this.extractValue(buffer, 17, 'uint16');
+            const clcTotVARaw = this.extractValue(buffer, 18, 'uint16');
+            const connPhRaw = this.extractValue(buffer, 21, 'uint16');
             this.logRegisterRead(121, 17, 'VArAct', vArActRaw, 'enum16');
             this.logRegisterRead(121, 18, 'ClcTotVA', clcTotVARaw, 'enum16');
             this.logRegisterRead(121, 21, 'ConnPh', connPhRaw, 'enum16');
-            return {
+            const settings = {
                 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', 2, 121),
+                WMax: this.applyScaleFactor(this.extractValue(buffer, 2, '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', 3, 121),
+                VRef: this.applyScaleFactor(this.extractValue(buffer, 3, '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', 4, 121),
+                VRefOfs: this.applyScaleFactor(this.extractValue(buffer, 4, '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', 5, 121),
-                VMin: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 6, 1, 'uint16'), scaleFactors.VMinMax_SF, 'uint16', 'Min Voltage', 6, 121),
+                VMax: this.applyScaleFactor(this.extractValue(buffer, 5, 'uint16'), scaleFactors.VMinMax_SF, 'uint16', 'Max Voltage', 5, 121),
+                VMin: this.applyScaleFactor(this.extractValue(buffer, 6, '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', 7, 121),
+                VAMax: this.applyScaleFactor(this.extractValue(buffer, 7, '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', 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),
+                VArMaxQ1: this.applyScaleFactor(this.extractValue(buffer, 8, 'int16'), scaleFactors.VArMax_SF, 'int16', 'Max Reactive Power Q1', 8, 121),
+                VArMaxQ2: this.applyScaleFactor(this.extractValue(buffer, 9, 'int16'), scaleFactors.VArMax_SF, 'int16', 'Max Reactive Power Q2', 9, 121),
+                VArMaxQ3: this.applyScaleFactor(this.extractValue(buffer, 10, 'int16'), scaleFactors.VArMax_SF, 'int16', 'Max Reactive Power Q3', 10, 121),
+                VArMaxQ4: this.applyScaleFactor(this.extractValue(buffer, 11, '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', 12, 121),
+                WGra: this.applyScaleFactor(this.extractValue(buffer, 12, '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', 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),
+                PFMinQ1: this.applyScaleFactor(this.extractValue(buffer, 13, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q1', 13, 121),
+                PFMinQ2: this.applyScaleFactor(this.extractValue(buffer, 14, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q2', 14, 121),
+                PFMinQ3: this.applyScaleFactor(this.extractValue(buffer, 15, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q3', 15, 121),
+                PFMinQ4: this.applyScaleFactor(this.extractValue(buffer, 16, 'int16'), scaleFactors.PFMin_SF, 'int16', 'Min Power Factor Q4', 16, 121),
                 PFMin_SF: scaleFactors.PFMin_SF,
                 // Other settings - Offsets 17-21
                 VArAct: vArActRaw,
                 ClcTotVA: clcTotVARaw,
-                MaxRmpRte: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 19, 1, 'uint16'), scaleFactors.MaxRmpRte_SF, 'uint16', 'Max Ramp Rate', 19, 121),
+                MaxRmpRte: this.applyScaleFactor(this.extractValue(buffer, 19, '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', 20, 121),
+                ECPNomHz: this.applyScaleFactor(this.extractValue(buffer, 20, 'uint16'), scaleFactors.ECPNomHz_SF, 'uint16', 'Nominal Frequency', 20, 121),
                 ECPNomHz_SF: scaleFactors.ECPNomHz_SF,
                 ConnPh: connPhRaw
             };
+            console.debug('[Model 121] Inverter Settings:', settings);
+            return settings;
         }
         catch (error) {
             console.error(`Error reading inverter settings: ${error}`);
@@ -1659,34 +1699,35 @@ export class SunspecModbusClient {
             console.log('Controls model 123 not found');
             return null;
         }
-        const baseAddr = model.address;
         try {
-            // Read scale factors first (offsets 21-23)
+            // Read entire model block in a single Modbus call
+            const buffer = await this.readModelBlock(model);
+            // Extract scale factors from buffer (offsets 21-23)
             const scaleFactors = {
-                WMaxLimPct_SF: await this.readRegisterValue(baseAddr + 21, 1, 'int16'),
-                OutPFSet_SF: await this.readRegisterValue(baseAddr + 22, 1, 'int16'),
-                VArPct_SF: await this.readRegisterValue(baseAddr + 23, 1, 'int16')
+                WMaxLimPct_SF: this.extractValue(buffer, 21, 'int16'),
+                OutPFSet_SF: this.extractValue(buffer, 22, 'int16'),
+                VArPct_SF: this.extractValue(buffer, 23, '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');
+            // Extract non-scaled fields from buffer
+            const connWinTmsRaw = this.extractValue(buffer, 0, 'uint16');
+            const connRvrtTmsRaw = this.extractValue(buffer, 1, 'uint16');
+            const connRaw = this.extractValue(buffer, 2, 'uint16');
+            const wMaxLimPctWinTmsRaw = this.extractValue(buffer, 4, 'uint16');
+            const wMaxLimPctRvrtTmsRaw = this.extractValue(buffer, 5, 'uint16');
+            const wMaxLimPctRmpTmsRaw = this.extractValue(buffer, 6, 'uint16');
+            const wMaxLimEnaRaw = this.extractValue(buffer, 7, 'uint16');
+            const outPFSetWinTmsRaw = this.extractValue(buffer, 9, 'uint16');
+            const outPFSetRvrtTmsRaw = this.extractValue(buffer, 10, 'uint16');
+            const outPFSetRmpTmsRaw = this.extractValue(buffer, 11, 'uint16');
+            const outPFSetEnaRaw = this.extractValue(buffer, 12, 'uint16');
+            const vArPctWinTmsRaw = this.extractValue(buffer, 16, 'uint16');
+            const vArPctRvrtTmsRaw = this.extractValue(buffer, 17, 'uint16');
+            const vArPctRmpTmsRaw = this.extractValue(buffer, 18, 'uint16');
+            const vArPctModRaw = this.extractValue(buffer, 19, 'uint16');
+            const vArPctEnaRaw = this.extractValue(buffer, 20, 'uint16');
             this.logRegisterRead(123, 0, 'Conn_WinTms', connWinTmsRaw, 'uint16');
             this.logRegisterRead(123, 1, 'Conn_RvrtTms', connRvrtTmsRaw, 'uint16');
             this.logRegisterRead(123, 2, 'Conn', connRaw, 'enum16');
@@ -1712,23 +1753,23 @@ export class SunspecModbusClient {
                 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', 3, 123),
+                WMaxLimPct: this.applyScaleFactor(this.extractValue(buffer, 3, 'uint16'), scaleFactors.WMaxLimPct_SF, 'uint16', 'Power Limit Percentage', 3, 123),
                 WMaxLimPct_SF: scaleFactors.WMaxLimPct_SF,
                 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', 8, 123),
+                OutPFSet: this.applyScaleFactor(this.extractValue(buffer, 8, 'int16'), scaleFactors.OutPFSet_SF, 'int16', 'Output Power Factor Set', 8, 123),
                 OutPFSet_SF: scaleFactors.OutPFSet_SF,
                 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 %', 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),
+                VArWMaxPct: this.applyScaleFactor(this.extractValue(buffer, 13, 'int16'), scaleFactors.VArPct_SF, 'int16', 'Reactive Power at Max Power %', 13, 123),
+                VArMaxPct: this.applyScaleFactor(this.extractValue(buffer, 14, 'int16'), scaleFactors.VArPct_SF, 'int16', 'Max Reactive Power %', 14, 123),
+                VArAvalPct: this.applyScaleFactor(this.extractValue(buffer, 15, 'int16'), scaleFactors.VArPct_SF, 'int16', 'Available Reactive Power %', 15, 123),
                 VArPct_SF: scaleFactors.VArPct_SF,
                 VArPct_WinTms: vArPctWinTmsRaw,
                 VArPct_RvrtTms: vArPctRvrtTmsRaw,
@@ -1736,6 +1777,7 @@ export class SunspecModbusClient {
                 VArPct_Mod: vArPctModRaw,
                 VArPct_Ena: vArPctEnaRaw
             };
+            console.debug('[Model 123] Inverter Controls:', controls);
             return controls;
         }
         catch (error) {