Fix MOD battery power sensors using correct register 31126

Based on official Growatt documentation and user feedback, the MOD series
inverters use register 31126 (signed INT32) for battery charge/discharge
power instead of the old registers 3178-3181 which always return zero.

Changes:
- Update MOD profile to use register 31126-31127 for battery power
  (positive = charging, negative = discharging)
- Add support for reading 31000-32000 register range (BDC/BMS data)
- Extend 3000 range read to 3250 to cover all MOD battery registers
- Update battery power reading logic to handle signed battery_power register
- Fix register naming for battery energy registers to match code expectations
- Maintain backward compatibility with SPH-style separate charge/discharge registers

This resolves the issue where MOD users reported battery charge/discharge
power sensors showing zero values.

Refs: User scan data showing register 31126 contains valid battery power data

Author: claude

custom_components/growatt_modbus/growatt_modbus.py

@@ -410,6 +410,7 @@ def read_all_data(self) -> Optional[GrowattData]:
         has_base_range = any(0 <= addr < 1000 for addr in addresses)
         has_storage_range = any(1000 <= addr < 2000 for addr in addresses)
         has_3000_range = any(3000 <= addr < 4000 for addr in addresses)
+        has_31000_range = any(31000 <= addr < 32000 for addr in addresses)
 
         # Read base range (0-124) if needed - SPH models
         if has_base_range:
@@ -435,18 +436,31 @@ def read_all_data(self) -> Optional[GrowattData]:
                 for i, value in enumerate(registers):
                     self._register_cache[1000 + i] = value
 
-        # Read 3000 range if needed - MIN models
+        # Read 3000 range if needed - MIN/MOD models
         if has_3000_range:
-            logger.debug("Reading 3000 range (3000-3110)")
-            registers = self.read_input_registers(3000, 111)
+            logger.debug("Reading 3000 range (3000-3250)")
+            # Extended range to cover MOD battery registers up to 3250
+            registers = self.read_input_registers(3000, 251)
             if registers is None:
                 logger.error("Failed to read main input register block")
                 return None
-            
+
             # Populate cache
             for i, value in enumerate(registers):
                 self._register_cache[3000 + i] = value
-        
+
+        # Read 31000 range if needed - MOD extended battery/BMS range
+        if has_31000_range:
+            logger.debug("Reading 31000 range (31100-31300)")
+            registers = self.read_input_registers(31100, 201)
+            if registers is None:
+                logger.warning("Failed to read extended battery register block (31100+)")
+                # Don't return None - continue with what we have
+            else:
+                # Populate cache
+                for i, value in enumerate(registers):
+                    self._register_cache[31100 + i] = value
+
         # Now extract values using the register map
         try:
             # Status
@@ -678,31 +692,53 @@ def _read_battery_data(self, data: GrowattData) -> None:
                 data.battery_temp = self._get_register_value(addr) or 0.0
                 logger.debug(f"Battery temp from reg {addr}: {data.battery_temp}°C")
 
-            # Charge power (try to read from registers first)
-            addr = self._find_register_by_name('charge_power_low')
+            # Battery power (signed: positive=charging, negative=discharging)
+            # Try new signed battery_power register first (MOD series @ 31126)
+            addr = self._find_register_by_name('battery_power_low')
             if addr:
                 raw_low = self._register_cache.get(addr, 0)
-                pair_addr = self._find_register_by_name('charge_power_high')
+                pair_addr = self._find_register_by_name('battery_power_high')
                 raw_high = self._register_cache.get(pair_addr, 0) if pair_addr else 0
-                data.charge_power = self._get_register_value(addr) or 0.0
-                logger.debug(f"Charge power: HIGH={raw_high} (reg {pair_addr}), LOW={raw_low} (reg {addr}) → {data.charge_power}W")
-            elif data.battery_voltage > 0 and data.battery_current < 0:
-                # Fallback: Calculate from V×I when charging (negative current)
-                data.charge_power = data.battery_voltage * abs(data.battery_current)
-                logger.debug(f"Charge power (calculated): {data.battery_voltage}V × {abs(data.battery_current)}A = {data.charge_power}W")
+                battery_power = self._get_register_value(addr) or 0.0
+                logger.debug(f"Battery power (signed): HIGH={raw_high} (reg {pair_addr}), LOW={raw_low} (reg {addr}) → {battery_power}W")
 
-            # Discharge power (try to read from registers first)
-            addr = self._find_register_by_name('discharge_power_low')
-            if addr:
-                raw_low = self._register_cache.get(addr, 0)
-                pair_addr = self._find_register_by_name('discharge_power_high')
-                raw_high = self._register_cache.get(pair_addr, 0) if pair_addr else 0
-                data.discharge_power = self._get_register_value(addr) or 0.0
-                logger.debug(f"Discharge power: HIGH={raw_high} (reg {pair_addr}), LOW={raw_low} (reg {addr}) → {data.discharge_power}W")
-            elif data.battery_voltage > 0 and data.battery_current > 0:
-                # Fallback: Calculate from V×I when discharging (positive current)
-                data.discharge_power = data.battery_voltage * data.battery_current
-                logger.debug(f"Discharge power (calculated): {data.battery_voltage}V × {data.battery_current}A = {data.discharge_power}W")
+                # Split into charge/discharge based on sign
+                if battery_power > 0:
+                    data.charge_power = battery_power
+                    data.discharge_power = 0.0
+                    logger.debug(f"  → Charging: {data.charge_power}W")
+                elif battery_power < 0:
+                    data.charge_power = 0.0
+                    data.discharge_power = abs(battery_power)
+                    logger.debug(f"  → Discharging: {data.discharge_power}W")
+                else:
+                    data.charge_power = 0.0
+                    data.discharge_power = 0.0
+            else:
+                # Fallback: Try old separate charge/discharge registers (SPH series)
+                addr = self._find_register_by_name('charge_power_low')
+                if addr:
+                    raw_low = self._register_cache.get(addr, 0)
+                    pair_addr = self._find_register_by_name('charge_power_high')
+                    raw_high = self._register_cache.get(pair_addr, 0) if pair_addr else 0
+                    data.charge_power = self._get_register_value(addr) or 0.0
+                    logger.debug(f"Charge power: HIGH={raw_high} (reg {pair_addr}), LOW={raw_low} (reg {addr}) → {data.charge_power}W")
+                elif data.battery_voltage > 0 and data.battery_current < 0:
+                    # Fallback: Calculate from V×I when charging (negative current)
+                    data.charge_power = data.battery_voltage * abs(data.battery_current)
+                    logger.debug(f"Charge power (calculated): {data.battery_voltage}V × {abs(data.battery_current)}A = {data.charge_power}W")
+
+                addr = self._find_register_by_name('discharge_power_low')
+                if addr:
+                    raw_low = self._register_cache.get(addr, 0)
+                    pair_addr = self._find_register_by_name('discharge_power_high')
+                    raw_high = self._register_cache.get(pair_addr, 0) if pair_addr else 0
+                    data.discharge_power = self._get_register_value(addr) or 0.0
+                    logger.debug(f"Discharge power: HIGH={raw_high} (reg {pair_addr}), LOW={raw_low} (reg {addr}) → {data.discharge_power}W")
+                elif data.battery_voltage > 0 and data.battery_current > 0:
+                    # Fallback: Calculate from V×I when discharging (positive current)
+                    data.discharge_power = data.battery_voltage * data.battery_current
+                    logger.debug(f"Discharge power (calculated): {data.battery_voltage}V × {data.battery_current}A = {data.discharge_power}W")
 
             # Charge energy today
             addr = self._find_register_by_name('charge_energy_today_low')

custom_components/growatt_modbus/profiles/mod.py

@@ -108,14 +108,14 @@
         3086: {'name': 'battery_derating_mode', 'scale': 1, 'unit': ''},
 
         # Battery - Discharge/Charge Energy
-        3125: {'name': 'battery_discharge_today_high', 'scale': 1, 'unit': '', 'pair': 3126},
-        3126: {'name': 'battery_discharge_today_low', 'scale': 1, 'unit': '', 'pair': 3125, 'combined_scale': 0.1, 'combined_unit': 'kWh'},
-        3127: {'name': 'battery_discharge_total_high', 'scale': 1, 'unit': '', 'pair': 3128},
-        3128: {'name': 'battery_discharge_total_low', 'scale': 1, 'unit': '', 'pair': 3127, 'combined_scale': 0.1, 'combined_unit': 'kWh'},
-        3129: {'name': 'battery_charge_today_high', 'scale': 1, 'unit': '', 'pair': 3130},
-        3130: {'name': 'battery_charge_today_low', 'scale': 1, 'unit': '', 'pair': 3129, 'combined_scale': 0.1, 'combined_unit': 'kWh'},
-        3131: {'name': 'battery_charge_total_high', 'scale': 1, 'unit': '', 'pair': 3132},
-        3132: {'name': 'battery_charge_total_low', 'scale': 1, 'unit': '', 'pair': 3131, 'combined_scale': 0.1, 'combined_unit': 'kWh'},
+        3125: {'name': 'discharge_energy_today_high', 'scale': 1, 'unit': '', 'pair': 3126},
+        3126: {'name': 'discharge_energy_today_low', 'scale': 1, 'unit': '', 'pair': 3125, 'combined_scale': 0.1, 'combined_unit': 'kWh'},
+        3127: {'name': 'discharge_energy_total_high', 'scale': 1, 'unit': '', 'pair': 3128},
+        3128: {'name': 'discharge_energy_total_low', 'scale': 1, 'unit': '', 'pair': 3127, 'combined_scale': 0.1, 'combined_unit': 'kWh'},
+        3129: {'name': 'charge_energy_today_high', 'scale': 1, 'unit': '', 'pair': 3130},
+        3130: {'name': 'charge_energy_today_low', 'scale': 1, 'unit': '', 'pair': 3129, 'combined_scale': 0.1, 'combined_unit': 'kWh'},
+        3131: {'name': 'charge_energy_total_high', 'scale': 1, 'unit': '', 'pair': 3132},
+        3132: {'name': 'charge_energy_total_low', 'scale': 1, 'unit': '', 'pair': 3131, 'combined_scale': 0.1, 'combined_unit': 'kWh'},
 
         # Battery State
         3144: {'name': 'priority_mode', 'scale': 1, 'unit': '', 'desc': '0=Load, 1=Battery, 2=Grid'},
@@ -124,13 +124,12 @@
         3171: {'name': 'battery_soc', 'scale': 1, 'unit': '%'},
         3176: {'name': 'battery_temp', 'scale': 0.1, 'unit': '°C'},
 
-        # NOTE: Registers 3178-3180 don't exist on some MOD hardware
-        # If your inverter doesn't have these, battery power will be calculated from V×I
-        # Battery Power (32-bit) - OPTIONAL, may not exist on all MOD hardware
-        3178: {'name': 'discharge_power_high', 'scale': 1, 'unit': '', 'pair': 3179},
-        3179: {'name': 'discharge_power_low', 'scale': 1, 'unit': '', 'pair': 3178, 'combined_scale': 0.1, 'combined_unit': 'W'},
-        3180: {'name': 'charge_power_high', 'scale': 1, 'unit': '', 'pair': 3181},
-        3181: {'name': 'charge_power_low', 'scale': 1, 'unit': '', 'pair': 3180, 'combined_scale': 0.1, 'combined_unit': 'W'},
+        # NOTE: Old registers 3178-3181 don't work on most MOD hardware (always return 0)
+        # Growatt confirmed the correct register is 31126 (BDC/BMS Battery Information range)
+        # Battery Power (32-bit, signed) - Register 31126
+        # Positive = charging, Negative = discharging
+        31126: {'name': 'battery_power_high', 'scale': 1, 'unit': '', 'pair': 31127},
+        31127: {'name': 'battery_power_low', 'scale': 1, 'unit': '', 'pair': 31126, 'combined_scale': 0.1, 'combined_unit': 'W', 'signed': True},
     },
     'holding_registers': {
         # Basic control