Update profiles and integration from dev branch + add MOD battery_power support

Merged changes from origin/dev:
- Updated MOD profile with corrected battery power registers (31126-31127)
- Updated SPH TL3 profile with AC register aliases for compatibility
- Updated integration logic (growatt_modbus.py, device_profiles.py, manifest.json)

Key MOD profile changes:
- Fixed battery power registers: moved from 3178-3181 (broken) to 31126-31127 (working)
- Renamed battery energy registers to match SPH TL3 naming convention:
  - battery_discharge_today_* → discharge_energy_today_*
  - battery_charge_today_* → charge_energy_today_*
- Added 'alias' fields to AC registers for generic compatibility

Emulator changes:
- Added battery_power_high/low handler for MOD series (register 31126-31127)
- Supports signed 32-bit values (positive=charging, negative=discharging)
- Properly handles two's complement for negative values

This ensures the emulator correctly simulates the MOD series with the
updated, working battery power registers confirmed by Growatt.

Author: claude

custom_components/growatt_modbus/device_profiles.py

@@ -59,9 +59,10 @@
 }
 
 THREE_PHASE_SENSORS: Set[str] = {
+    "ac_voltage_r", "ac_voltage_s", "ac_voltage_t",  # Phase voltages
     "ac_voltage_rs", "ac_voltage_st", "ac_voltage_tr",  # Line-to-line voltages
-    "ac_current_r", "ac_current_s", "ac_current_t",
-    "ac_power_r", "ac_power_s", "ac_power_t",
+    "ac_current_r", "ac_current_s", "ac_current_t",  # Phase currents
+    "ac_power_r", "ac_power_s", "ac_power_t",  # Phase powers
     "ac_frequency",
 }
 

custom_components/growatt_modbus/growatt_modbus.py

@@ -72,11 +72,27 @@ class GrowattData:
     pv3_power: float = 0.0            # W
     pv_total_power: float = 0.0       # W
 
-    # AC Output
+    # AC Output (generic - usually Phase R for 3-phase)
     ac_voltage: float = 0.0           # V
     ac_current: float = 0.0           # A
     ac_power: float = 0.0             # W
     ac_frequency: float = 0.0         # Hz
+
+    # Three-Phase AC Output (individual phases)
+    ac_voltage_r: float = 0.0         # V (Phase R/L1)
+    ac_current_r: float = 0.0         # A (Phase R/L1)
+    ac_power_r: float = 0.0           # W (Phase R/L1)
+    ac_voltage_s: float = 0.0         # V (Phase S/L2)
+    ac_current_s: float = 0.0         # A (Phase S/L2)
+    ac_power_s: float = 0.0           # W (Phase S/L2)
+    ac_voltage_t: float = 0.0         # V (Phase T/L3)
+    ac_current_t: float = 0.0         # A (Phase T/L3)
+    ac_power_t: float = 0.0           # W (Phase T/L3)
+
+    # Line-to-Line Voltages (3-phase only)
+    ac_voltage_rs: float = 0.0        # V
+    ac_voltage_st: float = 0.0        # V
+    ac_voltage_tr: float = 0.0        # V
 
     # Power Flow (storage/hybrid models)
     power_to_user: float = 0.0        # W
@@ -410,6 +426,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 +452,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
@@ -496,12 +526,12 @@ def read_all_data(self) -> Optional[GrowattData]:
                 # Calculate from strings if not available
                 data.pv_total_power = data.pv1_power + data.pv2_power + data.pv3_power
 
-            # AC Output
+            # AC Output (generic - will use Phase R via alias for 3-phase)
             ac_voltage_addr = self._find_register_by_name('ac_voltage')
             ac_current_addr = self._find_register_by_name('ac_current')
             ac_power_addr = self._find_register_by_name('ac_power_low')
             ac_freq_addr = self._find_register_by_name('ac_frequency')
-            
+
             if ac_voltage_addr:
                 data.ac_voltage = self._get_register_value(ac_voltage_addr) or 0.0
             if ac_current_addr:
@@ -510,6 +540,51 @@ def read_all_data(self) -> Optional[GrowattData]:
                 data.ac_power = self._get_register_value(ac_power_addr) or 0.0
             if ac_freq_addr:
                 data.ac_frequency = self._get_register_value(ac_freq_addr) or 0.0
+
+            # Three-Phase AC Output (individual phases)
+            # Phase R
+            ac_voltage_r_addr = self._find_register_by_name('ac_voltage_r')
+            ac_current_r_addr = self._find_register_by_name('ac_current_r')
+            ac_power_r_addr = self._find_register_by_name('ac_power_r_low')
+            if ac_voltage_r_addr:
+                data.ac_voltage_r = self._get_register_value(ac_voltage_r_addr) or 0.0
+            if ac_current_r_addr:
+                data.ac_current_r = self._get_register_value(ac_current_r_addr) or 0.0
+            if ac_power_r_addr:
+                data.ac_power_r = self._get_register_value(ac_power_r_addr) or 0.0
+
+            # Phase S
+            ac_voltage_s_addr = self._find_register_by_name('ac_voltage_s')
+            ac_current_s_addr = self._find_register_by_name('ac_current_s')
+            ac_power_s_addr = self._find_register_by_name('ac_power_s_low')
+            if ac_voltage_s_addr:
+                data.ac_voltage_s = self._get_register_value(ac_voltage_s_addr) or 0.0
+            if ac_current_s_addr:
+                data.ac_current_s = self._get_register_value(ac_current_s_addr) or 0.0
+            if ac_power_s_addr:
+                data.ac_power_s = self._get_register_value(ac_power_s_addr) or 0.0
+
+            # Phase T
+            ac_voltage_t_addr = self._find_register_by_name('ac_voltage_t')
+            ac_current_t_addr = self._find_register_by_name('ac_current_t')
+            ac_power_t_addr = self._find_register_by_name('ac_power_t_low')
+            if ac_voltage_t_addr:
+                data.ac_voltage_t = self._get_register_value(ac_voltage_t_addr) or 0.0
+            if ac_current_t_addr:
+                data.ac_current_t = self._get_register_value(ac_current_t_addr) or 0.0
+            if ac_power_t_addr:
+                data.ac_power_t = self._get_register_value(ac_power_t_addr) or 0.0
+
+            # Line-to-Line Voltages
+            ac_voltage_rs_addr = self._find_register_by_name('line_voltage_rs')
+            ac_voltage_st_addr = self._find_register_by_name('line_voltage_st')
+            ac_voltage_tr_addr = self._find_register_by_name('line_voltage_tr')
+            if ac_voltage_rs_addr:
+                data.ac_voltage_rs = self._get_register_value(ac_voltage_rs_addr) or 0.0
+            if ac_voltage_st_addr:
+                data.ac_voltage_st = self._get_register_value(ac_voltage_st_addr) or 0.0
+            if ac_voltage_tr_addr:
+                data.ac_voltage_tr = self._get_register_value(ac_voltage_tr_addr) or 0.0
 
             # Power Flow (if available - storage/hybrid models)
             power_to_user_addr = self._find_register_by_name('power_to_user_low')
@@ -611,11 +686,15 @@ def write_register(self, register: int, value: int) -> bool:
 
 
     def _find_register_by_name(self, name: str) -> Optional[int]:
-        """Find register address by its name"""
+        """Find register address by its name or alias"""
         input_regs = self.register_map['input_registers']
         for addr, reg_info in input_regs.items():
+            # Check exact name match
             if reg_info['name'] == name:
                 return addr
+            # Check alias match (for 3-phase compatibility)
+            if reg_info.get('alias') == name:
+                return addr
         return None
 
     def _read_energy_breakdown(self, data: GrowattData) -> None:
@@ -678,31 +757,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")
-
-            # 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")
+                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")
+
+                # 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/manifest.json

@@ -12,5 +12,5 @@
     "pymodbus>=3.0.0",
     "pyserial>=3.4"
   ],
-  "version": "0.0.7-beta.1"
+  "version": "0.0.7-beta.2"
 }

custom_components/growatt_modbus/profiles/mod.py

@@ -37,12 +37,13 @@
         # === AC OUTPUT - THREE PHASE ===
         # Grid Frequency (shared across all phases)
         37: {'name': 'ac_frequency', 'scale': 0.01, 'unit': 'Hz', 'desc': 'AC output frequency'},
-        
-        # Phase R (L1) - AC Output
-        38: {'name': 'ac_voltage_r', 'scale': 0.1, 'unit': 'V', 'desc': 'Phase R AC voltage'},
-        39: {'name': 'ac_current_r', 'scale': 0.1, 'unit': 'A', 'desc': 'Phase R AC current'},
-        40: {'name': 'ac_power_r_high', 'scale': 1, 'unit': '', 'pair': 41},
-        41: {'name': 'ac_power_r_low', 'scale': 1, 'unit': '', 'pair': 40, 'combined_scale': 0.1, 'combined_unit': 'VA'},
+
+        # Generic AC aliases (point to Phase R for compatibility with generic code)
+        # These allow the standard ac_voltage/current/power fields to work
+        38: {'name': 'ac_voltage_r', 'scale': 0.1, 'unit': 'V', 'desc': 'Phase R AC voltage', 'alias': 'ac_voltage'},
+        39: {'name': 'ac_current_r', 'scale': 0.1, 'unit': 'A', 'desc': 'Phase R AC current', 'alias': 'ac_current'},
+        40: {'name': 'ac_power_r_high', 'scale': 1, 'unit': '', 'pair': 41, 'alias': 'ac_power_high'},
+        41: {'name': 'ac_power_r_low', 'scale': 1, 'unit': '', 'pair': 40, 'combined_scale': 0.1, 'combined_unit': 'VA', 'alias': 'ac_power_low'},
 
         # Phase S (L2) - AC Output
         42: {'name': 'ac_voltage_s', 'scale': 0.1, 'unit': 'V', 'desc': 'Phase S AC voltage'},
@@ -108,14 +109,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 +125,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

custom_components/growatt_modbus/profiles/sph_tl3.py

@@ -33,11 +33,11 @@
         # AC Grid Frequency
         37: {'name': 'ac_frequency', 'scale': 0.01, 'unit': 'Hz'},
 
-        # Three-Phase AC Output - Phase R
-        38: {'name': 'ac_voltage_r', 'scale': 0.1, 'unit': 'V', 'desc': 'Phase R voltage'},
-        39: {'name': 'ac_current_r', 'scale': 0.1, 'unit': 'A', 'desc': 'Phase R current'},
-        40: {'name': 'ac_power_r_high', 'scale': 1, 'unit': '', 'pair': 41},
-        41: {'name': 'ac_power_r_low', 'scale': 1, 'unit': '', 'pair': 40, 'combined_scale': 0.1, 'combined_unit': 'W'},
+        # Three-Phase AC Output - Phase R (with generic aliases for compatibility)
+        38: {'name': 'ac_voltage_r', 'scale': 0.1, 'unit': 'V', 'desc': 'Phase R voltage', 'alias': 'ac_voltage'},
+        39: {'name': 'ac_current_r', 'scale': 0.1, 'unit': 'A', 'desc': 'Phase R current', 'alias': 'ac_current'},
+        40: {'name': 'ac_power_r_high', 'scale': 1, 'unit': '', 'pair': 41, 'alias': 'ac_power_high'},
+        41: {'name': 'ac_power_r_low', 'scale': 1, 'unit': '', 'pair': 40, 'combined_scale': 0.1, 'combined_unit': 'W', 'alias': 'ac_power_low'},
 
         # Three-Phase AC Output - Phase S
         42: {'name': 'ac_voltage_s', 'scale': 0.1, 'unit': 'V', 'desc': 'Phase S voltage'},