vanminh/phoenix-regression-test
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: add CV group regression test script

Browse Source
This commit is contained in:
vanminh
2026-08-12 09:37:58 +08:00
parent e12ba2dda1
commit 9db1f93927
1 changed files with 373 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_cv.py
+373
View File
@@ -0,0 +1,373 @@
import argparse
import csv
import sys
import time
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
from common.error_codes import RpuErrorCode
from drivers.eload import Eload
from drivers.rpu import Rpu
from drivers.tpu import Tpu
RESULTS_DIR = Path(__file__).resolve().parent.parent / "results"
# Vac (AC source input, 230V) is set manually by the test operator before
# running this script - not controlled here.
# Jig position (0,0,40) is skipped for now - no jig available; re-add
# jig.move_to_position() once one is connected.
VREF = 55.0
IREF = 30.0
SWEEP_ELOAD_VOLTAGES = [50.0, 52.0, 54.0, 54.5, 54.7, 54.9, 55.0]
EXTENDED_VOLTAGE_LIMIT = 55.5
EXTENDED_VOLTAGE_STEP = 0.1
LOW_CURRENT_THRESHOLD_A = 1.0
STEP_WAIT_S = 20
HIGH_VOLTAGE_THRESHOLD = 52.0
HIGH_VOLTAGE_STEP_WAIT_S = 30
TOGGLE_HIGH_VOLTAGE_STEP_WAIT_S = 45
START_CHARGING_WAIT_S = 1
STOP_CHARGING_SETTLE_WAIT_S = 3
# RPU is powered from the eload (battery terminal) - the eload must be
# outputting voltage before RPU's Modbus port comes up, or connecting to it
# fails outright.
RPU_POWER_UP_ELOAD_VOLTAGE = 50.0
RPU_POWER_UP_WAIT_S = 1
POWER_LIMITS_W = [1500, 1000, 500]
POWER_LIMIT_ELOAD_VOLTAGE = 50.0
POWER_LIMIT_SETTLE_WAIT_S = 20
POWER_LIMIT_TOLERANCE_PCT = 0.05
PRECHARGE_ELOAD_VOLTAGE = 53.0
PRECHARGE_CV_CURRENT_LIMITS = [5.0, 10.0]
PRECHARGE_WAIT_S = 60
PRECHARGE_CV_CURRENT_TOLERANCE_PCT = 0.05
EXPECTED_RPU_CV_LOW_CURRENT = RpuErrorCode.CV_LOW_CURRENT
CASE_NAMES = [
"cv_sweep_continuous_enable",
"cv_sweep_toggle_enable",
"power_limit_sweep",
"precharge_cv_current_limit",
]
class CvTestSystem:
def __init__(self, tpu_port, rpu_port, eload_resource):
# Eload powers RPU (via the battery terminal) - it must be on before
# RPU's Modbus port is reachable, so connect/enable it first.
print(f"Powering up RPU via eload {eload_resource} at {RPU_POWER_UP_ELOAD_VOLTAGE}V...")
self.eload = Eload(eload_resource)
self.eload.set_remote()
self.eload.set_mode_cv()
self.eload.set_voltage(RPU_POWER_UP_ELOAD_VOLTAGE)
self.eload.output_on()
time.sleep(RPU_POWER_UP_WAIT_S)
print(f"Connecting TPU ({tpu_port}) and RPU ({rpu_port})...")
self.tpu = Tpu(tpu_port)
self.rpu = Rpu(rpu_port)
RESULTS_DIR.mkdir(exist_ok=True)
csv_path = RESULTS_DIR / f"cv_{time.strftime('%Y%m%d_%H%M%S')}.csv"
self.csv_file = open(csv_path, "w", newline="", encoding="utf-8")
self.writer = csv.writer(self.csv_file)
self.writer.writerow(
["phase", "setting_label", "setting_value", "rpu_output_voltage", "rpu_output_current", "note"]
)
print(f"Logging to {csv_path}")
self.rpu.set_charging(False)
print(f"Setting Voltage_setting_Q128={VREF}V, Current_setting_Q128={IREF}A for the whole test group...")
self.rpu.wait_until_config_writable()
self.default_voltage_setting_raw = self.rpu.read("Voltage_setting_Q128")
self.default_current_setting_raw = self.rpu.read("Current_setting_Q128")
self.rpu.write_q128("Voltage_setting_Q128", VREF)
self.rpu.write_q128("Current_setting_Q128", IREF)
self.rpu.rewrite_config()
def close(self):
print("Closing: restoring Voltage_setting_Q128/Current_setting_Q128 defaults...")
self.rpu.set_charging(False)
time.sleep(STOP_CHARGING_SETTLE_WAIT_S)
self.rpu.wait_until_config_writable()
self.rpu.write("Voltage_setting_Q128", self.default_voltage_setting_raw)
self.rpu.write("Current_setting_Q128", self.default_current_setting_raw)
self.rpu.rewrite_config()
self.eload.set_voltage(RPU_POWER_UP_ELOAD_VOLTAGE)
self.eload.set_local()
self.csv_file.close()
self.tpu.close()
self.rpu.close()
self.eload.disconnect()
print("Closed.")
def log_row(self, phase, setting_label, setting_value, note=""):
rpu_voltage = self.tpu.read("RPU_output_voltage")
rpu_current = self.tpu.read("RPU_output_current")
self.writer.writerow([phase, setting_label, setting_value, rpu_voltage, rpu_current, note])
self.csv_file.flush()
return rpu_voltage, rpu_current
def stop_charging_and_wait_config_writable(self):
print("Stopping charging, waiting for config-writable state...")
self.rpu.set_charging(False)
time.sleep(STOP_CHARGING_SETTLE_WAIT_S)
self.rpu.wait_until_config_writable()
def _sweep_step(self, phase, voltage, toggle_charger_per_step):
"""Set eload to `voltage`, wait, record, and check for the CV_LOW_CURRENT
cutoff. Returns (low_current_triggered, protection_ok) for this step."""
rpu = self.rpu
eload = self.eload
print(f"[{phase}] Setting eload to {voltage}V...")
eload.set_voltage(voltage)
if toggle_charger_per_step:
print(f"[{phase}] Enabling charger...")
rpu.set_charging(True)
time.sleep(START_CHARGING_WAIT_S)
if voltage > HIGH_VOLTAGE_THRESHOLD:
step_wait = TOGGLE_HIGH_VOLTAGE_STEP_WAIT_S if toggle_charger_per_step else HIGH_VOLTAGE_STEP_WAIT_S
else:
step_wait = STEP_WAIT_S
print(f"[{phase}] Waiting {step_wait}s to settle...")
time.sleep(step_wait)
rpu_current = self.tpu.read("RPU_output_current")
print(f"[{phase}] Vout_load={voltage}V -> Iout={rpu_current:.2f}A")
low_current_triggered = False
protection_ok = False
note = ""
if rpu_current < LOW_CURRENT_THRESHOLD_A:
low_current_triggered = True
print(f"[{phase}] Iout below {LOW_CURRENT_THRESHOLD_A}A, checking protection...")
charging_enabled = rpu.read("Enable_charger")
rpu_error = rpu.read_error_code()
rpu_shadow_error = rpu.read_shadow_error_code()
protection_ok = (not charging_enabled) and (
rpu_error == EXPECTED_RPU_CV_LOW_CURRENT or rpu_shadow_error == EXPECTED_RPU_CV_LOW_CURRENT
)
note = (f"low-current check: charging_enabled={charging_enabled}, rpu_error=0x{rpu_error:08X}, "
f"rpu_shadow_error=0x{rpu_shadow_error:08X}")
print(f"[{phase}] low-current check: charging_enabled={charging_enabled}, "
f"rpu_error=0x{rpu_error:08X}, rpu_shadow_error=0x{rpu_shadow_error:08X}")
self.log_row(phase, "Vout_load", voltage, note=note)
if toggle_charger_per_step:
print(f"[{phase}] Disabling charger...")
rpu.set_charging(False)
time.sleep(STOP_CHARGING_SETTLE_WAIT_S)
return low_current_triggered, protection_ok
def _run_voltage_sweep(self, phase, toggle_charger_per_step):
rpu = self.rpu
eload = self.eload
low_current_seen = False
protection_ok = False
if not toggle_charger_per_step:
print(f"[{phase}] Setting eload to {SWEEP_ELOAD_VOLTAGES[0]}V and enabling charger for the whole sweep...")
eload.set_voltage(SWEEP_ELOAD_VOLTAGES[0])
rpu.set_charging(True)
time.sleep(START_CHARGING_WAIT_S)
for voltage in SWEEP_ELOAD_VOLTAGES:
triggered, ok = self._sweep_step(phase, voltage, toggle_charger_per_step)
if triggered and not low_current_seen:
low_current_seen = True
protection_ok = ok
# If current never dropped below threshold even at 55V, keep nudging
# the eload voltage up by 0.1V until it does or 55.5V is reached.
voltage = SWEEP_ELOAD_VOLTAGES[-1]
while not low_current_seen and voltage < EXTENDED_VOLTAGE_LIMIT - 1e-9:
voltage = round(voltage + EXTENDED_VOLTAGE_STEP, 1)
triggered, ok = self._sweep_step(phase, voltage, toggle_charger_per_step)
if triggered:
low_current_seen = True
protection_ok = ok
if not (toggle_charger_per_step and not low_current_seen):
rpu.set_charging(False)
if not low_current_seen:
raise AssertionError(
f"[{phase}] output current never dropped below {LOW_CURRENT_THRESHOLD_A}A "
f"even up to {EXTENDED_VOLTAGE_LIMIT}V"
)
if not protection_ok:
raise AssertionError(f"[{phase}] CV_LOW_CURRENT protection did not trigger correctly")
def _set_cutoff_minimum_current_for_sweep(self):
self.stop_charging_and_wait_config_writable()
default_value = self.rpu.read_q128("Cutoff_minimum_current_Q128")
print(f"Setting Cutoff_minimum_current_Q128={LOW_CURRENT_THRESHOLD_A}A (default was {default_value}A)...")
self.rpu.write_q128("Cutoff_minimum_current_Q128", LOW_CURRENT_THRESHOLD_A)
self.rpu.rewrite_config()
return default_value
def _restore_cutoff_minimum_current(self, default_value):
self.stop_charging_and_wait_config_writable()
print(f"Restoring Cutoff_minimum_current_Q128={default_value}A...")
self.rpu.write_q128("Cutoff_minimum_current_Q128", default_value)
self.rpu.rewrite_config()
def run_cv_sweep_continuous_enable(self):
default_cutoff_min_current = self._set_cutoff_minimum_current_for_sweep()
try:
self._run_voltage_sweep("cv_sweep_continuous_enable", toggle_charger_per_step=False)
finally:
self.rpu.set_charging(False)
self._restore_cutoff_minimum_current(default_cutoff_min_current)
def run_cv_sweep_toggle_enable(self):
default_cutoff_min_current = self._set_cutoff_minimum_current_for_sweep()
try:
self._run_voltage_sweep("cv_sweep_toggle_enable", toggle_charger_per_step=True)
finally:
self.rpu.set_charging(False)
self._restore_cutoff_minimum_current(default_cutoff_min_current)
def run_power_limit_sweep(self):
rpu = self.rpu
eload = self.eload
default_power_limit = rpu.read("Power_limit_ref")
failures = []
try:
print(f"Setting eload to {POWER_LIMIT_ELOAD_VOLTAGE}V and enabling charger...")
eload.set_voltage(POWER_LIMIT_ELOAD_VOLTAGE)
rpu.set_charging(True)
time.sleep(START_CHARGING_WAIT_S)
for power_limit in POWER_LIMITS_W:
print(f"Setting Power_limit_ref={power_limit}W, waiting {POWER_LIMIT_SETTLE_WAIT_S}s to settle...")
rpu.write("Power_limit_ref", power_limit)
time.sleep(POWER_LIMIT_SETTLE_WAIT_S)
rpu_voltage, rpu_current = self.log_row("power_limit_sweep", "Power_limit_ref", power_limit)
pout = rpu_voltage * rpu_current
error_pct = abs(pout - power_limit) / power_limit
print(f"Power_limit_ref={power_limit}W -> Vout={rpu_voltage:.2f}V, Iout={rpu_current:.2f}A, "
f"Pout={pout:.1f}W ({error_pct * 100:.1f}% error)")
if error_pct > POWER_LIMIT_TOLERANCE_PCT:
failures.append(f"Power_limit_ref={power_limit}W -> Pout={pout:.1f}W "
f"({error_pct * 100:.1f}% error, allowed {POWER_LIMIT_TOLERANCE_PCT * 100:.0f}%)")
finally:
print(f"Disabling charger, restoring Power_limit_ref={default_power_limit}W...")
rpu.set_charging(False)
rpu.write("Power_limit_ref", default_power_limit)
if failures:
raise AssertionError("power_limit_sweep: " + "; ".join(failures))
def run_precharge_cv_current_limit(self):
rpu = self.rpu
eload = self.eload
self.stop_charging_and_wait_config_writable()
default_precharge_enable = rpu.read("Precharge enable")
default_cv_current_limit = rpu.read_q128("CV current limit")
print("Enabling Precharge enable...")
rpu.write("Precharge enable", True)
rpu.rewrite_config()
failures = []
try:
print(f"Setting eload to {PRECHARGE_ELOAD_VOLTAGE}V...")
eload.set_voltage(PRECHARGE_ELOAD_VOLTAGE)
for cv_limit in PRECHARGE_CV_CURRENT_LIMITS:
self.stop_charging_and_wait_config_writable()
print(f"Setting CV current limit={cv_limit}A...")
rpu.write_q128("CV current limit", cv_limit)
rpu.rewrite_config()
print(f"Enabling charger, waiting {START_CHARGING_WAIT_S + PRECHARGE_WAIT_S}s for precharge...")
rpu.set_charging(True)
time.sleep(START_CHARGING_WAIT_S + PRECHARGE_WAIT_S)
charging_state = rpu.read("Charging_state")
_, rpu_current = self.log_row(
"precharge", "CV_current_limit", cv_limit, note=f"charging_state={charging_state}"
)
error_pct = abs(rpu_current - cv_limit) / cv_limit
print(f"CV_current_limit={cv_limit}A -> Charging_state={charging_state}, Iout={rpu_current:.2f}A "
f"({error_pct * 100:.1f}% error)")
if error_pct > PRECHARGE_CV_CURRENT_TOLERANCE_PCT:
failures.append(f"CV_current_limit={cv_limit}A -> Iout={rpu_current:.2f}A "
f"({error_pct * 100:.1f}% error, allowed {PRECHARGE_CV_CURRENT_TOLERANCE_PCT * 100:.0f}%)")
finally:
self.stop_charging_and_wait_config_writable()
print(f"Restoring Precharge enable={default_precharge_enable}, "
f"CV current limit={default_cv_current_limit}A...")
rpu.write("Precharge enable", default_precharge_enable)
rpu.write_q128("CV current limit", default_cv_current_limit)
rpu.rewrite_config()
if failures:
raise AssertionError("precharge_cv_current_limit: " + "; ".join(failures))
def run_all(self):
cases = [
("cv_sweep_continuous_enable", self.run_cv_sweep_continuous_enable),
("cv_sweep_toggle_enable", self.run_cv_sweep_toggle_enable),
("power_limit_sweep", self.run_power_limit_sweep),
("precharge_cv_current_limit", self.run_precharge_cv_current_limit),
]
results = {}
for name, func in cases:
print(f"\n=== Running {name} ===")
try:
func()
results[name] = "PASS"
except AssertionError as exc:
results[name] = f"FAIL: {exc}"
except Exception as exc:
results[name] = f"ERROR: {exc}"
print("\n=== CV test summary ===")
for name, result in results.items():
print(f"{name}: {result}")
return results
def main():
parser = argparse.ArgumentParser(description="CV group regression tests")
parser.add_argument("--tpu-port", default="COM15")
parser.add_argument("--rpu-port", default="COM16")
parser.add_argument("--eload-resource", default="ASRL5::INSTR")
parser.add_argument("--case", choices=CASE_NAMES + ["all"], default="all")
args = parser.parse_args()
system = CvTestSystem(args.tpu_port, args.rpu_port, args.eload_resource)
try:
if args.case == "all":
system.run_all()
else:
getattr(system, f"run_{args.case}")()
finally:
system.close()
if __name__ == "__main__":
main()