Nice unit, hacker-friendly desig
Review will focus on remote management, as I’m interested mostly in automation and dashboards, not pushing the 2000W inverter to test its limits to power something like a whole RV, though I should note the wired remote control/display module is quite nice for a setup like an RV where the inverter sits in a utility cabinet, or for something like a solar cart.

Opening the housing for the remote control/display (which is, thankfully, straightforward), I note substantial flux residue left behind; *probably* not a big deal, but I furrow my brow at it anyway. I didn’t try the debug pins except to use the easy-access ground.

A quick note here that following the proceeding instructions almost certainly voids whatever warranty Aeternalsol offers; I’m not recommending you do this; I’m just trying to relay this unit is hacker-friendly if you should be so inclined.

You can connect to pin 1 (where the divot is) on the SP485EE chip to get readout data, which I sent to a Xiao ESP32C6 (pin D7); this gives us the data going to the LCD screen (maybe there’s a better way, but this struck me as reasonably straightforward). The ESP32C6 is small enough to fit inside the enclosure, and you could power it over remote display board rails if you like; this would permit a pretty easy mod to give you the data over WiFi/BT/whatever-you-like, hidden inside the remote display enclosure; an ESP32C6 (and C3) is more than capable of running a basic web server. Note you cannot switch the panel on/off this way, as that must use the physical button (wellllll… it doesn’t “must”, but I’m not going to cover bypassing it).

Here’s the Micropython script as I presently have it (the lookup table is only accurate-ish up to 107W; you must measure what LCD outputs and compare to raw byte outputs to update higher values in LUT beyond that):

from machine import UART, Pin
import time
import struct

# High rxbuf ensures we catch every spike
uart = UART(1, baudrate=19200, tx=16, rx=17, timeout=10, rxbuf=1024)

print(“Inverter sniff script start.”)

HEADER = b’xFCxFCxFCxFCx37′
PACKET_LENGTH = 15
buffer = bytearray()

# — HARDWARE CALIBRATION CURVE (LUT) —
# Format: (Raw_ADC_Value, LCD_Displayed_Watts)
# For useful readings above 107W, you must compare what the LCD displays to what script outputs, then add the (RAW[8:9]_Decimal, LCD_Watts) to table.
# Byte outputs are little-endian, so you must take byte 9 first, then byte 8 after, then convert that hexadecimal value to decimal (e.g. if byte 8 reads 3B, and byte 9 reads 00; you need to reverse the order to get 003B, which converts to 59 in decimal).
# Because the LCD updates when it wants to and we update when we want to, you want to use data for the LUT only when power output levels off somewhere. Dunno where you get a 2KW adjustable AC load, but that’d be ideal.
# Ensure they stay in ascending order (smallest RAW to largest RAW).

POWER_CURVE = [
(0, 0),
(15, 7),
(59, 13),
(71, 19),
(116, 26),
(191, 47),
(768, 63),
(828, 80),
(952, 107),
(2000, 225) # Fake/extrapolated datapoint
]

def interpolate_power(adc_val):
# Find which segment of the curve the raw value falls into
for i in range(len(POWER_CURVE) – 1):
x0, y0 = POWER_CURVE[i]
x1, y1 = POWER_CURVE[i+1]

if x0 <= adc_val <= x1: # Linear interpolation formula return y0 + (y1 - y0) * ((adc_val - x0) / (x1 - x0)) # If the load is higher than our table has real data, make a guess with last known slope x0, y0 = POWER_CURVE[-2] x1, y1 = POWER_CURVE[-1] slope = (y1 - y0) / (x1 - x0) return y1 + slope * (adc_val - x1) def parse_inverter_packet(pkt): if len(pkt) < PACKET_LENGTH: return # --- 1. BATTERY VOLTAGE & BARS --- batt_v_sag = struct.unpack('b', bytes([pkt[10]]))[0] batt_volts = 12.80 + ((batt_v_sag + 1) * 0.04615) bars = 1 if batt_volts >= 13.0: bars = 5
elif batt_volts >= 12.5: bars = 4
elif batt_volts >= 12.0: bars = 3
elif batt_volts >= 11.5: bars = 2

# — 2. AC POWER (W) —
real_power_adc = pkt[8] + (pkt[9] << 8) ac_watts = interpolate_power(real_power_adc) # --- 3. AC VOLTAGE & STATUS --- ac_volts_raw = pkt[11] status_flag = pkt[12] # My assumptions here are likely wrong; I exclude the data from print lcd_ac_volts = 121 if (110 <= ac_volts_raw <= 130) else ac_volts_raw # Create Raw Hex string for debug & LUT additions raw_hex = " ".join(f"{b:02X}" for b in pkt) # Print formatted output matched to LCD print("="*50) print(f"RAW : {raw_hex}") print(f"BATT : {batt_volts:.2f} V [{'#' * bars}{'-' * (5-bars)}] ({bars}/5 Bars)") print(f"OUTPUT : {ac_watts:5.1f} W") # likely incorrect | print(f"AC OUT : {lcd_ac_volts} V (Real Internal: {ac_volts_raw}V)") # no idea what the codes are supposed to be or if I'm looking at right byte | print(f"STATUS : Hex 0x{status_flag:02X}") print("="*50) while True: if uart.any(): buffer += uart.read() while len(buffer) >= PACKET_LENGTH:
idx = buffer.find(HEADER)

if idx == -1:
buffer = buffer[-(len(HEADER)-1):]
break

if idx > 0:
buffer = buffer[idx:]

if len(buffer) < PACKET_LENGTH: break packet = buffer[0:PACKET_LENGTH] buffer = buffer[PACKET_LENGTH:] parse_inverter_packet(packet) time.sleep_ms(10) HTH. It's a pretty nice unit, easy to work with the connectors and they include nice, beefy cables with reasonable hookups (again, not that I'd recommend it, but I note the lugs can friction-slot around common 12 LFP batteries' F2 terminals, which would be a terrible way to connect them long-term). Obviously I'd love if they documented their firmware publicly instead of making me reverse-engineer, but I'd also love a herd of intelligent dairy cows who can milk themselves and make cheese to bring to my door each day.