using Common.Attributes;
using DeviceCommand.Base;
using Model.Models;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;

namespace DeviceCommand.Devices
{
    /// <summary>
    /// ANEVH 操作模式枚举（兼容旧接口，映射到功能模式 SOUR:MOD）
    /// </summary>
    public enum ANEVH操作模式_枚举
    {
        /// <summary>定值模式（常规界面，SOUR:MOD 0）</summary>
        FIXED,
        /// <summary>序列测试模式（SOUR:MOD 1）</summary>
        LIST
    }

    /// <summary>ANEVH 输出状态（MEASure:COND? 返回值：1=非启动 3=CV 4=CC 5=CP 6=CR）</summary>
    public enum ANEVH输出状态_枚举
    {
        /// <summary>非启动状态（OFF）</summary>
        非启动 = 1,
        /// <summary>恒压 CV 状态</summary>
        CV = 3,
        /// <summary>恒流 CC 状态</summary>
        CC = 4,
        /// <summary>恒功率 CP 状态</summary>
        CP = 5,
        /// <summary>恒阻 CR 状态</summary>
        CR = 6
    }

    /// <summary>ANEVH 功能界面（[SOURce:]MODe 取值）</summary>
    public enum ANEVH功能模式_枚举
    {
        /// <summary>常规界面</summary>
        常规 = 0,
        /// <summary>序列测试（Program）</summary>
        序列测试 = 1,
        /// <summary>光伏 SAS 模拟</summary>
        光伏SAS = 2,
        /// <summary>光伏 EN50530 模拟</summary>
        光伏EN50530 = 3,
        /// <summary>光伏 SANDIA 模拟</summary>
        光伏SANDIA = 4,
        /// <summary>内阻模式</summary>
        内阻模式 = 5,
        /// <summary>固定电池模拟</summary>
        固定电池模拟 = 6,
        /// <summary>其他界面</summary>
        其他 = 7,
        /// <summary>电池测试（充放电）</summary>
        电池测试 = 10,
        /// <summary>电子负载</summary>
        电子负载 = 12
    }

    /// <summary>ANEVH 电子负载操作模式（SINK:MODe 取值，仅待机态可切换）</summary>
    public enum ANEVH负载模式_枚举
    {
        /// <summary>定电压 CV</summary>
        CV = 0,
        /// <summary>定电流 CC</summary>
        CC = 1,
        /// <summary>定功率 CP</summary>
        CP = 2,
        /// <summary>定电阻 CR</summary>
        CR = 3,
        /// <summary>CV+CC 复合模式</summary>
        CV_CC = 4,
        /// <summary>CV+CR 复合模式</summary>
        CV_CR = 5,
        /// <summary>CC+CR 复合模式</summary>
        CC_CR = 6,
        /// <summary>CV+CC+CP+CR 复合模式（Auto）</summary>
        Auto = 7
    }

    /// <summary>ANEVH 序列测试状态（PROGram:STATus? 返回值）</summary>
    public enum ANEVH序列状态_枚举
    {
        /// <summary>序列测试已完成（非启动状态）</summary>
        已完成 = 0,
        /// <summary>序列测试正在运行</summary>
        运行 = 1,
        /// <summary>序列测试暂停</summary>
        暂停 = 2
    }

    /// <summary>ANEVH 电池模拟电池类型（[BATTery:]FUNCtion:TYPE 取值）</summary>
    public enum ANEVH电池类型_枚举
    {
        /// <summary>锰酸锂</summary>
        锰酸锂 = 0,
        /// <summary>钴酸锂</summary>
        钴酸锂 = 1,
        /// <summary>磷酸铁锂</summary>
        磷酸铁锂 = 2,
        /// <summary>铅酸电池</summary>
        铅酸 = 3,
        /// <summary>镍氢电池</summary>
        镍氢 = 4,
        /// <summary>三元锂</summary>
        三元锂 = 5,
        /// <summary>钛酸锂</summary>
        钛酸锂 = 6
    }

    /// <summary>ANEVH 电池测试工作模式（[BATTery:]TEST:MODe 取值）</summary>
    public enum ANEVH电池测试模式_枚举
    {
        /// <summary>静态充电</summary>
        静态充电 = 0,
        /// <summary>静态放电</summary>
        静态放电 = 1,
        /// <summary>动态测试</summary>
        动态测试 = 2
    }

    /// <summary>
    /// 艾诺 ANEVH 系列双向可编程直流电源（一拖三），基于 TCP 通信，使用 SCPI 指令集。
    /// 作为高压源载一体机使用：同时具备直流电源输出(SOURce)与电子负载(SINK)能力。
    /// 参考文档：艾诺 ANEVH 系列双向电源用户手册 附录B 直流电源通讯协议（SCPI）。
    /// 功能覆盖：常规输出(CV/CC/CP)、内阻模式、电子负载(8种模式+短路)、光伏模拟(SAS/EN50530/SANDIA)、
    /// 序列测试(50组×20步)、固定电池模拟(含电能计量)、电池测试(静态充放电/动态测试)。
    /// 注意：*RST 会复位限值/报警/斜率等参数并停止输出；网口 SCPI 端口以设备「通讯设置-网口参数配置」为准。
    /// </summary>
    [ACPCommand]
    public class ANEVH80 : Tcp
    {
        // SCPI 指令默认使用 \n 作为结束符
        private const string ScpiDelimiter = "\n";

        /// <summary>
        /// 构造函数，初始化 TCP 连接配置。
        /// </summary>
        /// <param name="config">TCP 连接配置（IP、端口等）</param>
        public ANEVH80(TcpConfig config) : base(config)
        {
        }

        #region 底层辅助

        /// <summary>数值格式化为 SCPI 参数（不变文化，避免区域设置导致小数点变成逗号）</summary>
        private static string Fmt(double v) => v.ToString(CultureInfo.InvariantCulture);

        /// <summary>
        /// 从设备返回的 SCPI 响应字符串中提取数值部分并转换为 double。
        /// 支持科学计数法（如 2.48E-03），结果保留两位小数。
        /// </summary>
        /// <param name="raw">设备返回的原始字符串</param>
        /// <returns>提取到的数值（保留两位小数），解析失败时返回 0</returns>
        private static double ExtractDouble(string raw)
        {
            if (string.IsNullOrWhiteSpace(raw)) return 0;

            // 从响应中提取第一个数值（含正负号、小数点、科学计数法），可自动忽略单位后缀与命令头
            var match = Regex.Match(raw, @"[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?");
            return match.Success && double.TryParse(match.Value, NumberStyles.Float, CultureInfo.InvariantCulture, out double val)
                ? Math.Round(val, 2)
                : 0;
        }

        /// <summary>发送设定类命令（只发不读，自动追加结束符；基类 _commLock 已保证串行）</summary>
        protected async Task SendCmdAsync(string command, CancellationToken ct)
            => await base.SendAsync($"{command}{ScpiDelimiter}", ct).ConfigureAwait(false);

        /// <summary>发送查询类命令并返回去除首尾空白的响应字符串</summary>
        protected async Task<string> QueryAsync(string command, CancellationToken ct)
            => (await WriteReadAsync($"{command}{ScpiDelimiter}", ScpiDelimiter, ct).ConfigureAwait(false)).Trim();

        /// <summary>发送查询类命令并把响应解析为 double（解析失败返回 0）</summary>
        protected async Task<double> QueryDoubleAsync(string command, CancellationToken ct)
            => ExtractDouble(await QueryAsync(command, ct).ConfigureAwait(false));

        /// <summary>发送查询类命令并把响应解析为 int（解析失败返回 0）</summary>
        protected async Task<int> QueryIntAsync(string command, CancellationToken ct)
            => (int)ExtractDouble(await QueryAsync(command, ct).ConfigureAwait(false));

        /// <summary>发送查询类命令并把响应解析为逗号分隔的 double 数组</summary>
        protected async Task<double[]> QueryDoubleArrayAsync(string command, CancellationToken ct)
        {
            string resp = await QueryAsync(command, ct).ConfigureAwait(false);
            if (string.IsNullOrWhiteSpace(resp)) return Array.Empty<double>();
            var parts = resp.Split(',');
            var result = new double[parts.Length];
            for (int i = 0; i < parts.Length; i++) result[i] = ExtractDouble(parts[i]);
            return result;
        }

        /// <summary>发送查询类命令并把响应解析为开关状态（ON/1 为 true）</summary>
        protected async Task<bool> QueryOnOffAsync(string command, CancellationToken ct)
        {
            string r = await QueryAsync(command, ct).ConfigureAwait(false);
            return r.Equals("ON", StringComparison.OrdinalIgnoreCase) || r == "1";
        }

        #endregion

        #region 1. 系统与公共指令（手册 B2.2/B2.3）

        /// <summary>清除错误队列，清除问题状态事件寄存器、错误信息及报警状态 (*CLS)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 清除错误队列Async(CancellationToken ct = default)
            => await SendCmdAsync("*CLS", ct).ConfigureAwait(false);

        /// <summary>重设仪器为出厂默认状态，会复位限值/报警/斜率参数、清除报警并停止输出 (*RST)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 复位Async(CancellationToken ct = default)
            => await SendCmdAsync("*RST", ct).ConfigureAwait(false);

        /// <summary>查询仪器识别码：制造商、产品标号、出厂编号、软件版本 (*IDN?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>设备标识字符串（厂商,型号,序列号,固件版本）</returns>
        public virtual async Task<string> 查询设备信息Async(CancellationToken ct = default)
            => await QueryAsync("*IDN?", ct).ConfigureAwait(false);

        /// <summary>查询标准事件状态寄存器 (*ESR?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>事件状态寄存器值</returns>
        public virtual async Task<string> 查询事件状态Async(CancellationToken ct = default)
            => await QueryAsync("*ESR?", ct).ConfigureAwait(false);

        /// <summary>查询错误信息，0=无错误 -101=无效字符 -102=语法错误 -106=非法参数 -200=无效分隔符 -222=参数超电源限值 (SYSTem:ERR?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>错误信息字符串</returns>
        public virtual async Task<string> 查询错误信息Async(CancellationToken ct = default)
            => await QueryAsync("SYSTem:ERR?", ct).ConfigureAwait(false);

        /// <summary>
        /// 逐条取空 SCPI 错误队列并返回全部错误码（SYSTem:ERR? 为 FIFO，每次只弹出最早的一条）。
        /// 用于定位"到底是哪条命令报的错"：在多命令流程中每发完一条就调用一次，即可把错误精确归因到该命令。
        /// </summary>
        /// <param name="maxCount">最多读取条数，防止异常时无限循环</param>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>错误码列表，空列表表示无错误</returns>
        public virtual async Task<List<string>> 读取并清空错误队列Async(int maxCount = 20, CancellationToken ct = default)
        {
            var errors = new List<string>();
            for (int i = 0; i < maxCount; i++)
            {
                string e = await 查询错误信息Async(ct).ConfigureAwait(false);
                if (e.Split(',')[0].Trim() == "0") break;
                errors.Add(e);
            }
            return errors;
        }

        #endregion

        #region 2. 输出控制（手册 B2.5，OUTPut/INPUT 子系统）

        /// <summary>设置电源输出开关状态 (OUTP ON|OFF)</summary>
        /// <param name="isOn">true: 开启输出, false: 关闭输出</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置输出开关Async(bool isOn, CancellationToken ct = default)
            => await SendCmdAsync($"OUTP {(isOn ? "ON" : "OFF")}", ct).ConfigureAwait(false);

        /// <summary>设置电子负载输入开关状态，负载模式下才有效 (INPUT ON|OFF)</summary>
        /// <param name="isOn">true: 开启输入, false: 关闭输入</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置输入开关Async(bool isOn, CancellationToken ct = default)
            => await SendCmdAsync($"INPUT {(isOn ? "ON" : "OFF")}", ct).ConfigureAwait(false);

        /// <summary>启动电源输出 (OUTP ON)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 启动输出Async(CancellationToken ct = default)
            => await 设置输出开关Async(true, ct).ConfigureAwait(false);

        /// <summary>停止电源输出 (OUTP OFF)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 停止输出Async(CancellationToken ct = default)
            => await 设置输出开关Async(false, ct).ConfigureAwait(false);

        /// <summary>启动负载输入 (INPUT ON)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 启动负载Async(CancellationToken ct = default)
            => await 设置输入开关Async(true, ct).ConfigureAwait(false);

        /// <summary>停止负载输入 (INPUT OFF)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 停止负载Async(CancellationToken ct = default)
            => await 设置输入开关Async(false, ct).ConfigureAwait(false);

        /// <summary>查询电源输出开关状态 (OUTP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>true: 输出已开启</returns>
        public virtual async Task<bool> 查询输出状态Async(CancellationToken ct = default)
            => await QueryOnOffAsync("OUTP?", ct).ConfigureAwait(false);

        /// <summary>查询负载输入开关状态 (INPUT?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>true: 输入已开启</returns>
        public virtual async Task<bool> 查询负载输入状态Async(CancellationToken ct = default)
            => await QueryOnOffAsync("INPUT?", ct).ConfigureAwait(false);

        /// <summary>清除报警状态，返回待机状态 (OUTP:PROT:CLE)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 清除报警Async(CancellationToken ct = default)
            => await SendCmdAsync("OUTP:PROT:CLE", ct).ConfigureAwait(false);

        /// <summary>设置操作模式（兼容旧接口：FIXED→常规界面，LIST→序列测试界面）(SOUR:MOD)</summary>
        /// <param name="mode">操作模式枚举 (FIXED: 定值 | LIST: 序列测试)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置操作模式Async(ANEVH操作模式_枚举 mode, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:MOD {(int)(mode == ANEVH操作模式_枚举.LIST ? ANEVH功能模式_枚举.序列测试 : ANEVH功能模式_枚举.常规)}", ct).ConfigureAwait(false);

        #endregion

        #region 3. 测量查询（手册 B2.4，MEASure 子系统）

        /// <summary>查询测量电压 (MEAS:VOLT:DC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>实际输出电压 (单位: V，保留两位小数)</returns>
        public virtual async Task<double> 读取电压Async(CancellationToken ct = default)
            => await QueryDoubleAsync("MEAS:VOLT:DC?", ct).ConfigureAwait(false);

        /// <summary>查询测量电流，正向为正、反向为负 (MEAS:CURR:DC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>实际输出电流 (单位: A，保留两位小数，正值为源模式，负值为负载模式)</returns>
        public virtual async Task<double> 读取电流Async(CancellationToken ct = default)
            => await QueryDoubleAsync("MEAS:CURR:DC?", ct).ConfigureAwait(false);

        /// <summary>查询测量功率 (MEAS:POW:DC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>实际输出功率 (单位: W，保留两位小数)</returns>
        public virtual async Task<double> 读取功率Async(CancellationToken ct = default)
            => await QueryDoubleAsync("MEAS:POW:DC?", ct).ConfigureAwait(false);

        /// <summary>一次性查询输出电压(V)、电流(A)、功率(W) (MEAS:ARR:DC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>(电压, 电流, 功率) 元组</returns>
        public virtual async Task<(double 电压, double 电流, double 功率)> 查询输出测量值Async(CancellationToken ct = default)
        {
            var arr = await QueryDoubleArrayAsync("MEAS:ARR:DC?", ct).ConfigureAwait(false);
            return arr.Length >= 3 ? (arr[0], arr[1], arr[2]) : (0, 0, 0);
        }

        /// <summary>查询输出电阻，用于内阻模式和电子负载 (MEAS:RES:DC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>输出电阻 (单位: Ω)</returns>
        public virtual async Task<double> 查询输出电阻Async(CancellationToken ct = default)
            => await QueryDoubleAsync("MEAS:RES:DC?", ct).ConfigureAwait(false);

        /// <summary>查询电源输出状态：1=非启动 3=CV 4=CC 5=CP 6=CR (MEAS:COND?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>输出状态枚举</returns>
        public virtual async Task<ANEVH输出状态_枚举> 查询输出条件Async(CancellationToken ct = default)
            => (ANEVH输出状态_枚举)await QueryIntAsync("MEAS:COND?", ct).ConfigureAwait(false);

        /// <summary>查询报警代码，16进制值，0x00=无报警，详见手册 B2.4 报警代码表 (MEAS:SYST?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>报警代码</returns>
        public virtual async Task<int> 查询报警代码Async(CancellationToken ct = default)
            => await QueryIntAsync("MEAS:SYST?", ct).ConfigureAwait(false);

        /// <summary>查询是否处于报警状态，即报警代码 != 0 (MEAS:SYST?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>true: 存在报警</returns>
        public virtual async Task<bool> 是否报警Async(CancellationToken ct = default)
            => await 查询报警代码Async(ct).ConfigureAwait(false) != 0;

        /// <summary>查询电池模拟运行 SOC (MEAS:SOC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>SOC (单位: %)</returns>
        public virtual async Task<double> 查询SOCAsync(CancellationToken ct = default)
            => await QueryDoubleAsync("MEAS:SOC?", ct).ConfigureAwait(false);

        #endregion

        #region 4. 源模式——电压（手册 B2.6，SOURce 子系统）

        /// <summary>设置源输出电压 (SOUR:VOLT)</summary>
        /// <param name="voltage">电压值 (单位: V)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电压Async(double voltage, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:VOLT {Fmt(voltage)}", ct).ConfigureAwait(false);

        /// <summary>查询源设定电压 (SOUR:VOLT?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>设定电压值 (单位: V)</returns>
        public virtual async Task<double> 查询设定电压Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:VOLT?", ct).ConfigureAwait(false);

        /// <summary>设置电压斜率，不允许为 0，范围 0~2000，仅常规功能有效，配合启动命令与在线切换电压使用 (SOUR:VOLT:SLEW)</summary>
        /// <param name="voltsPerMs">电压斜率 (单位: V/ms)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电压斜率Async(double voltsPerMs, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:VOLT:SLEW {Fmt(voltsPerMs)}", ct).ConfigureAwait(false);

        /// <summary>查询电压斜率 (SOUR:VOLT:SLEW?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>电压斜率 (单位: V/ms)</returns>
        public virtual async Task<double> 查询电压斜率Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:VOLT:SLEW?", ct).ConfigureAwait(false);

        /// <summary>设置过压保护值 OVP (SOUR:VOLT:PROT:HIGH)</summary>
        /// <param name="voltage">过压保护阈值 (单位: V)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置过压保护Async(double voltage, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:VOLT:PROT:HIGH {Fmt(voltage)}", ct).ConfigureAwait(false);

        /// <summary>查询过压保护值 OVP (SOUR:VOLT:PROT:HIGH?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>过压保护阈值 (单位: V)</returns>
        public virtual async Task<double> 查询过压保护Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:VOLT:PROT:HIGH?", ct).ConfigureAwait(false);

        /// <summary>设置电压设定值上限，限制电压设置范围 (SOUR:VOLT:LIM:HIGH)</summary>
        /// <param name="volts">电压上限 (单位: V)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电压上限Async(double volts, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:VOLT:LIM:HIGH {Fmt(volts)}", ct).ConfigureAwait(false);

        /// <summary>查询电压设定值上限 (SOUR:VOLT:LIM:HIGH?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>电压上限 (单位: V)</returns>
        public virtual async Task<double> 查询电压上限Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:VOLT:LIM:HIGH?", ct).ConfigureAwait(false);

        /// <summary>设置电压设定值下限，限制电压设置范围 (SOUR:VOLT:LIM:LOW)</summary>
        /// <param name="volts">电压下限 (单位: V)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电压下限Async(double volts, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:VOLT:LIM:LOW {Fmt(volts)}", ct).ConfigureAwait(false);

        /// <summary>查询电压设定值下限 (SOUR:VOLT:LIM:LOW?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>电压下限 (单位: V)</returns>
        public virtual async Task<double> 查询电压下限Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:VOLT:LIM:LOW?", ct).ConfigureAwait(false);

        #endregion

        #region 5. 源模式——电流（手册 B2.6，SOURce 子系统）

        /// <summary>设置源正向限流 (SOUR:CURR)</summary>
        /// <param name="current">电流值 (单位: A，正值)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电流Async(double current, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:CURR {Fmt(current)}", ct).ConfigureAwait(false);

        /// <summary>查询源设定电流 (SOUR:CURR?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>设定电流值 (单位: A)</returns>
        public virtual async Task<double> 查询设定电流Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:CURR?", ct).ConfigureAwait(false);

        /// <summary>设置电流斜率，不允许为 0，范围 0~2000，仅常规功能和电子负载模式有效 (SOUR:CURR:SLEW)</summary>
        /// <param name="ampsPerMs">电流斜率 (单位: A/ms)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电流斜率Async(double ampsPerMs, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:CURR:SLEW {Fmt(ampsPerMs)}", ct).ConfigureAwait(false);

        /// <summary>查询电流斜率 (SOUR:CURR:SLEW?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>电流斜率 (单位: A/ms)</returns>
        public virtual async Task<double> 查询电流斜率Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:CURR:SLEW?", ct).ConfigureAwait(false);

        /// <summary>设置正向过流报警值 (SOUR:CURR:PROT:HIGH)</summary>
        /// <param name="current">过流报警阈值 (单位: A)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置过流保护Async(double current, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:CURR:PROT:HIGH {Fmt(current)}", ct).ConfigureAwait(false);

        /// <summary>查询正向过流报警值 (SOUR:CURR:PROT:HIGH?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>过流报警阈值 (单位: A)</returns>
        public virtual async Task<double> 查询过流保护Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:CURR:PROT:HIGH?", ct).ConfigureAwait(false);

        /// <summary>设置反向（负载）过流报警值 (SINK:CURR:PROT:HIGH)</summary>
        /// <param name="amps">过流报警阈值 (单位: A)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置负载过流保护Async(double amps, CancellationToken ct = default)
            => await SendCmdAsync($"SINK:CURR:PROT:HIGH {Fmt(amps)}", ct).ConfigureAwait(false);

        /// <summary>查询反向（负载）过流报警值 (SINK:CURR:PROT:HIGH?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>过流报警阈值 (单位: A)</returns>
        public virtual async Task<double> 查询负载过流保护Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SINK:CURR:PROT:HIGH?", ct).ConfigureAwait(false);

        /// <summary>设置过流报警延时时间，电流持续超限达到该时间后报警 (SOUR:CURR:PROT:DEL)</summary>
        /// <param name="seconds">延时时间 (单位: s)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置过流报警延时Async(double seconds, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:CURR:PROT:DEL {Fmt(seconds)}", ct).ConfigureAwait(false);

        /// <summary>查询过流报警延时时间 (SOUR:CURR:PROT:DEL?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>延时时间 (单位: s)</returns>
        public virtual async Task<double> 查询过流报警延时Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:CURR:PROT:DEL?", ct).ConfigureAwait(false);

        /// <summary>设置电流设定值上限 (SOUR:CURR:LIM:HIGH)</summary>
        /// <param name="amps">电流上限 (单位: A)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电流上限Async(double amps, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:CURR:LIM:HIGH {Fmt(amps)}", ct).ConfigureAwait(false);

        /// <summary>查询电流设定值上限 (SOUR:CURR:LIM:HIGH?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>电流上限 (单位: A)</returns>
        public virtual async Task<double> 查询电流上限Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:CURR:LIM:HIGH?", ct).ConfigureAwait(false);

        /// <summary>设置电流设定值下限 (SOUR:CURR:LIM:LOW)</summary>
        /// <param name="amps">电流下限 (单位: A)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电流下限Async(double amps, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:CURR:LIM:LOW {Fmt(amps)}", ct).ConfigureAwait(false);

        /// <summary>查询电流设定值下限 (SOUR:CURR:LIM:LOW?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>电流下限 (单位: A)</returns>
        public virtual async Task<double> 查询电流下限Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:CURR:LIM:LOW?", ct).ConfigureAwait(false);

        #endregion

        #region 6. 源模式——功率与电阻（手册 B2.6）

        /// <summary>
        /// 设置源正向限功率 (SOUR:POW)。单位 W（面板以 kW 显示，分辨率 0.001kW）。
        /// 可设上界 = min(机型额定功率, 电压设定值×电流设定值)，低电压工况下设不到额定功率，需先抬高电压/电流设定值；
        /// 另受功率上限(SOUR:POW:LIM:HIGH)限制，超限时设备蜂鸣并拒收（SYSTem:ERR? 返回 -222），必须回读确认。
        /// </summary>
        /// <param name="power">功率值 (单位: W，正值)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置功率Async(double power, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:POW {Fmt(power)}", ct).ConfigureAwait(false);

        /// <summary>查询源设定功率 (SOUR:POW?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>设定功率值 (单位: W)</returns>
        public virtual async Task<double> 查询设定功率Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:POW?", ct).ConfigureAwait(false);

        /// <summary>设置正向过功率报警值，0~电源最大功率 (SOUR:POW:PROT:HIGH)</summary>
        /// <param name="watts">过功率报警阈值 (单位: W)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置过功率保护Async(double watts, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:POW:PROT:HIGH {Fmt(watts)}", ct).ConfigureAwait(false);

        /// <summary>查询正向过功率报警值 (SOUR:POW:PROT:HIGH?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>过功率报警阈值 (单位: W)</returns>
        public virtual async Task<double> 查询过功率保护Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:POW:PROT:HIGH?", ct).ConfigureAwait(false);

        /// <summary>设置过功率报警延时时间，范围 0~99.999s (SOUR:POW:PROT:DEL)</summary>
        /// <param name="seconds">延时时间 (单位: s)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置过功率报警延时Async(double seconds, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:POW:PROT:DEL {Fmt(seconds)}", ct).ConfigureAwait(false);

        /// <summary>查询过功率报警延时时间 (SOUR:POW:PROT:DEL?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>延时时间 (单位: s)</returns>
        public virtual async Task<double> 查询过功率报警延时Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:POW:PROT:DEL?", ct).ConfigureAwait(false);

        /// <summary>
        /// 设置功率设定值上限，限制所有功能的正/反向功率设置范围，须在设置功率之前下发 (SOUR:POW:LIM:HIGH)。
        /// 可填最大值 = 本机额定功率（并机时为单机功率×台数），超限会被蜂鸣拒收（SYSTem:ERR? 返回 -222）；
        /// 需保证功率下限不大于上限，建议待机态(OUTP OFF)修改。
        /// </summary>
        /// <param name="watts">功率上限 (单位: W)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置功率上限Async(double watts, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:POW:LIM:HIGH {Fmt(watts)}", ct).ConfigureAwait(false);

        /// <summary>查询功率设定值上限 (SOUR:POW:LIM:HIGH?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>功率上限 (单位: W)</returns>
        public virtual async Task<double> 查询功率上限Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:POW:LIM:HIGH?", ct).ConfigureAwait(false);

        /// <summary>设置功率设定值下限，不得大于功率上限，否则上限/功率设置均会被拒收 (SOUR:POW:LIM:LOW)</summary>
        /// <param name="watts">功率下限 (单位: W)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置功率下限Async(double watts, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:POW:LIM:LOW {Fmt(watts)}", ct).ConfigureAwait(false);

        /// <summary>查询功率设定值下限 (SOUR:POW:LIM:LOW?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>功率下限 (单位: W)</returns>
        public virtual async Task<double> 查询功率下限Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:POW:LIM:LOW?", ct).ConfigureAwait(false);

        /// <summary>设置电阻设定值，内阻模式与电子负载 CR 模式使用 (SINK:RES)</summary>
        /// <param name="ohms">电阻值 (单位: Ω)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电阻Async(double ohms, CancellationToken ct = default)
            => await SendCmdAsync($"SINK:RES {Fmt(ohms)}", ct).ConfigureAwait(false);

        /// <summary>查询电阻设定值 (SINK:RES?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>电阻设定值 (单位: Ω)</returns>
        public virtual async Task<double> 查询电阻设定值Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SINK:RES?", ct).ConfigureAwait(false);

        /// <summary>设置电阻设定值上限 (SINK:RES:LIM:HIGH)</summary>
        /// <param name="ohms">电阻上限 (单位: Ω)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电阻上限Async(double ohms, CancellationToken ct = default)
            => await SendCmdAsync($"SINK:RES:LIM:HIGH {Fmt(ohms)}", ct).ConfigureAwait(false);

        /// <summary>查询电阻设定值上限 (SINK:RES:LIM:HIGH?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>电阻上限 (单位: Ω)</returns>
        public virtual async Task<double> 查询电阻上限Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SINK:RES:LIM:HIGH?", ct).ConfigureAwait(false);

        /// <summary>设置电阻设定值下限 (SINK:RES:LIM:LOW)</summary>
        /// <param name="ohms">电阻下限 (单位: Ω)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电阻下限Async(double ohms, CancellationToken ct = default)
            => await SendCmdAsync($"SINK:RES:LIM:LOW {Fmt(ohms)}", ct).ConfigureAwait(false);

        /// <summary>查询电阻设定值下限 (SINK:RES:LIM:LOW?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>电阻下限 (单位: Ω)</returns>
        public virtual async Task<double> 查询电阻下限Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SINK:RES:LIM:LOW?", ct).ConfigureAwait(false);

        #endregion

        #region 7. 负载模式参数（SINK 子系统）

        /// <summary>设置负载吸收电流（反向电流） (SINK:CURR)</summary>
        /// <param name="current">负载电流值 (单位: A)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置负载电流Async(double current, CancellationToken ct = default)
            => await SendCmdAsync($"SINK:CURR {Fmt(current)}", ct).ConfigureAwait(false);

        /// <summary>查询负载设定电流 (SINK:CURR?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>负载电流设定值 (单位: A)</returns>
        public virtual async Task<double> 查询负载电流Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SINK:CURR?", ct).ConfigureAwait(false);

        /// <summary>设置负载吸收功率（反向功率），限值设置中的「功率」行同时限制正反向功率，超限蜂鸣拒收 (SINK:POWer)</summary>
        /// <param name="power">负载功率值 (单位: W)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置负载功率Async(double power, CancellationToken ct = default)
            => await SendCmdAsync($"SINK:POWer {Fmt(power)}", ct).ConfigureAwait(false);

        /// <summary>查询负载设定功率 (SINK:POWer?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>负载功率设定值 (单位: W)</returns>
        public virtual async Task<double> 查询负载功率Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SINK:POWer?", ct).ConfigureAwait(false);

        /// <summary>设置反向过功率报警值，0~电源最大功率 (SINK:POW:PROT:HIGH)</summary>
        /// <param name="watts">过功率报警阈值 (单位: W)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置负载过功率保护Async(double watts, CancellationToken ct = default)
            => await SendCmdAsync($"SINK:POW:PROT:HIGH {Fmt(watts)}", ct).ConfigureAwait(false);

        /// <summary>查询反向过功率报警值 (SINK:POW:PROT:HIGH?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>过功率报警阈值 (单位: W)</returns>
        public virtual async Task<double> 查询负载过功率保护Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SINK:POW:PROT:HIGH?", ct).ConfigureAwait(false);

        #endregion

        #region 8. 功能模式切换（手册 B2.6/B2.8）

        /// <summary>切换功能界面：0常规/1序列/2SAS/3EN50530/4SANDIA/5内阻/6固定电池模拟/10电池测试/12电子负载 (SOUR:MOD)</summary>
        /// <param name="mode">功能模式枚举</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置功能模式Async(ANEVH功能模式_枚举 mode, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:MOD {(int)mode}", ct).ConfigureAwait(false);

        /// <summary>查询当前功能界面 (SOUR:MOD?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>功能模式枚举</returns>
        public virtual async Task<ANEVH功能模式_枚举> 查询功能模式Async(CancellationToken ct = default)
            => (ANEVH功能模式_枚举)await QueryIntAsync("SOUR:MOD?", ct).ConfigureAwait(false);

        /// <summary>选择电子负载操作模式：0CV/1CC/2CP/3CR/4CV+CC/5CV+CR/6CC+CR/7Auto，仅待机态可切换 (SINK:MOD)</summary>
        /// <param name="mode">负载模式枚举</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置负载模式Async(ANEVH负载模式_枚举 mode, CancellationToken ct = default)
            => await SendCmdAsync($"SINK:MOD {(int)mode}", ct).ConfigureAwait(false);

        /// <summary>查询当前电子负载模式 (SINK:MOD?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>负载模式枚举</returns>
        public virtual async Task<ANEVH负载模式_枚举> 查询负载模式Async(CancellationToken ct = default)
            => (ANEVH负载模式_枚举)await QueryIntAsync("SINK:MOD?", ct).ConfigureAwait(false);

        /// <summary>
        /// 设置电子负载短路模式，需先进入电子负载界面，OUTP OFF 后再退出 (INPUT:SHORt ON|OFF)。
        /// 命令必须全写 INPUT:SHORt：手册 B2.8 仅以举例形式给出该命令，固件不展开 SHOR 缩写，缩写会报 -101/-102。
        /// </summary>
        /// <param name="enable">true: 短路开启, false: 短路关闭</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置负载短路Async(bool enable, CancellationToken ct = default)
            => await SendCmdAsync($"INPUT:SHORt {(enable ? "ON" : "OFF")}", ct).ConfigureAwait(false);

        #endregion

        #region 9. 光伏模拟（手册 B2.9，需先 SOUR:MOD 2|3|4 进入光伏界面）

        /// <summary>设置光伏 Voc 缓升时间，范围 1~99.999s，配合启动命令使用 (SOUR:RAMP)</summary>
        /// <param name="seconds">缓升时间 (单位: s)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置光伏缓升时间Async(double seconds, CancellationToken ct = default)
            => await SendCmdAsync($"SOUR:RAMP {Fmt(seconds)}", ct).ConfigureAwait(false);

        /// <summary>查询光伏 Voc 缓升时间 (SOUR:RAMP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>缓升时间 (单位: s)</returns>
        public virtual async Task<double> 查询光伏缓升时间Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOUR:RAMP?", ct).ConfigureAwait(false);

        /// <summary>设置光伏运行调节速度：0最快/1快/2中/3慢/4最慢，掉电保存 (SOL:SPEE)</summary>
        /// <param name="speed">调节速度档位</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置光伏调节速度Async(int speed, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SPEE {speed}", ct).ConfigureAwait(false);

        /// <summary>查询光伏运行调节速度 (SOL:SPEE?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>调节速度档位</returns>
        public virtual async Task<int> 查询光伏调节速度Async(CancellationToken ct = default)
            => await QueryIntAsync("SOL:SPEE?", ct).ConfigureAwait(false);

        /// <summary>设置光伏模型计算方式：false基础/true高级（高级算法更贴合设置的 VMP/IMP），掉电保存 (SOL:CALC)</summary>
        /// <param name="advanced">true: 高级算法</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置光伏计算方式Async(bool advanced, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:CALC {(advanced ? "1" : "0")}", ct).ConfigureAwait(false);

        /// <summary>查询光伏模型计算方式 (SOL:CALC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>0基础/1高级</returns>
        public virtual async Task<int> 查询光伏计算方式Async(CancellationToken ct = default)
            => await QueryIntAsync("SOL:CALC?", ct).ConfigureAwait(false);

        /// <summary>触发光伏参数生效，设置完光伏参数后必须执行 (SOL:TRIG)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 触发光伏参数Async(CancellationToken ct = default)
            => await SendCmdAsync("SOL:TRIG", ct).ConfigureAwait(false);

        /// <summary>查询当前计算出的实际 Pmp (SOL:PMP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>实际 Pmp (单位: W)</returns>
        public virtual async Task<double> 查询光伏实际PmpAsync(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:PMP?", ct).ConfigureAwait(false);

        /// <summary>查询当前计算出的实际 Vmp (SOL:VMP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>实际 Vmp (单位: V)</returns>
        public virtual async Task<double> 查询光伏实际VmpAsync(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:VMP?", ct).ConfigureAwait(false);

        /// <summary>查询当前计算出的实际 Imp (SOL:IMP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>实际 Imp (单位: A)</returns>
        public virtual async Task<double> 查询光伏实际ImpAsync(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:IMP?", ct).ConfigureAwait(false);

        /// <summary>查询当前计算出的实际 Voc (SOL:VOC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>实际 Voc (单位: V)</returns>
        public virtual async Task<double> 查询光伏实际VocAsync(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:VOC?", ct).ConfigureAwait(false);

        /// <summary>查询当前计算出的实际 Isc (SOL:ISC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>实际 Isc (单位: A)</returns>
        public virtual async Task<double> 查询光伏实际IscAsync(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:ISC?", ct).ConfigureAwait(false);

        /// <summary>设置 SAS 模式开路电压 Voc (SOL:SAS:VOC)</summary>
        /// <param name="volts">开路电压 (单位: V)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SAS开路电压Async(double volts, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAS:VOC {Fmt(volts)}", ct).ConfigureAwait(false);

        /// <summary>查询 SAS 模式开路电压 Voc (SOL:SAS:VOC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>开路电压 (单位: V)</returns>
        public virtual async Task<double> 查询SAS开路电压Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:SAS:VOC?", ct).ConfigureAwait(false);

        /// <summary>设置 SAS 模式最大功率点电压 Vmp，须小于 Voc 且 Vmp*Imp 不超过电源最大功率 (SOL:SAS:VMP)</summary>
        /// <param name="volts">最大功率点电压 (单位: V)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SAS最大功率点电压Async(double volts, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAS:VMP {Fmt(volts)}", ct).ConfigureAwait(false);

        /// <summary>查询 SAS 模式最大功率点电压 Vmp (SOL:SAS:VMP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>最大功率点电压 (单位: V)</returns>
        public virtual async Task<double> 查询SAS最大功率点电压Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:SAS:VMP?", ct).ConfigureAwait(false);

        /// <summary>设置 SAS 模式短路电流 Isc (SOL:SAS:ISC)</summary>
        /// <param name="amps">短路电流 (单位: A)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SAS短路电流Async(double amps, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAS:ISC {Fmt(amps)}", ct).ConfigureAwait(false);

        /// <summary>查询 SAS 模式短路电流 Isc (SOL:SAS:ISC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>短路电流 (单位: A)</returns>
        public virtual async Task<double> 查询SAS短路电流Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:SAS:ISC?", ct).ConfigureAwait(false);

        /// <summary>设置 SAS 模式最大功率点电流 Imp，须小于 Isc (SOL:SAS:IMP)</summary>
        /// <param name="amps">最大功率点电流 (单位: A)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SAS最大功率点电流Async(double amps, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAS:IMP {Fmt(amps)}", ct).ConfigureAwait(false);

        /// <summary>查询 SAS 模式最大功率点电流 Imp (SOL:SAS:IMP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>最大功率点电流 (单位: A)</returns>
        public virtual async Task<double> 查询SAS最大功率点电流Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:SAS:IMP?", ct).ConfigureAwait(false);

        /// <summary>设置 EN50530 模式最大功率点电压 Vmp (SOL:EN:VMP)</summary>
        /// <param name="volts">最大功率点电压 (单位: V)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置EN50530最大功率点电压Async(double volts, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:EN:VMP {Fmt(volts)}", ct).ConfigureAwait(false);

        /// <summary>查询 EN50530 模式最大功率点电压 Vmp (SOL:EN:VMP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>最大功率点电压 (单位: V)</returns>
        public virtual async Task<double> 查询EN50530最大功率点电压Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:EN:VMP?", ct).ConfigureAwait(false);

        /// <summary>设置 EN50530 模式最大功率点功率 Pmp，须小于电源最大功率 (SOL:EN:PMP)</summary>
        /// <param name="watts">最大功率点功率 (单位: W)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置EN50530最大功率点功率Async(double watts, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:EN:PMP {Fmt(watts)}", ct).ConfigureAwait(false);

        /// <summary>查询 EN50530 模式最大功率点功率 Pmp (SOL:EN:PMP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>最大功率点功率 (单位: W)</returns>
        public virtual async Task<double> 查询EN50530最大功率点功率Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:EN:PMP?", ct).ConfigureAwait(false);

        /// <summary>设置 EN50530 模式填充系数 FF：CSI=硅晶/TF=薄膜，具记忆功能 (SOL:EN:TECH)</summary>
        /// <param name="tech">技术类型字符串（CSI 或 TF）</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置EN50530填充系数Async(string tech, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:EN:TECH {tech}", ct).ConfigureAwait(false);

        /// <summary>查询 EN50530 模式填充系数 FF (SOL:EN:TECH?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>技术类型字符串</returns>
        public virtual async Task<string> 查询EN50530填充系数Async(CancellationToken ct = default)
            => await QueryAsync("SOL:EN:TECH?", ct).ConfigureAwait(false);

        /// <summary>设置 EN50530 模式光照强度，0~3000 整数，具记忆功能 (SOL:EN:IRR)</summary>
        /// <param name="irr">光照强度 (单位: W/m2)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置EN50530光照强度Async(int irr, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:EN:IRR {irr}", ct).ConfigureAwait(false);

        /// <summary>查询 EN50530 模式光照强度 (SOL:EN:IRR?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>光照强度 (单位: W/m2)</returns>
        public virtual async Task<int> 查询EN50530光照强度Async(CancellationToken ct = default)
            => await QueryIntAsync("SOL:EN:IRR?", ct).ConfigureAwait(false);

        /// <summary>设置 SANDIA 模式参考光照强度，0~3000 整数 (SOL:SAND:IRRREF)</summary>
        /// <param name="irr">参考光照强度 (单位: W/m2)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SANDIA参考光照Async(int irr, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAND:IRRREF {irr}", ct).ConfigureAwait(false);

        /// <summary>查询 SANDIA 模式参考光照强度 (SOL:SAND:IRRREF?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>参考光照强度 (单位: W/m2)</returns>
        public virtual async Task<int> 查询SANDIA参考光照Async(CancellationToken ct = default)
            => await QueryIntAsync("SOL:SAND:IRRREF?", ct).ConfigureAwait(false);

        /// <summary>设置 SANDIA 模式参考温度，-40~85 度 (SOL:SAND:TMPREF)</summary>
        /// <param name="temp">参考温度 (单位: ℃)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SANDIA参考温度Async(int temp, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAND:TMPREF {temp}", ct).ConfigureAwait(false);

        /// <summary>查询 SANDIA 模式参考温度 (SOL:SAND:TMPREF?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>参考温度 (单位: ℃)</returns>
        public virtual async Task<int> 查询SANDIA参考温度Async(CancellationToken ct = default)
            => await QueryIntAsync("SOL:SAND:TMPREF?", ct).ConfigureAwait(false);

        /// <summary>设置 SANDIA 模式 BETA 值，0.00~-2.00（薄膜-0.25/标准晶硅-0.38/高效晶硅-0.5） (SOL:SAND:BETA)</summary>
        /// <param name="beta">BETA 值</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SANDIABetaAsync(double beta, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAND:BETA {Fmt(beta)}", ct).ConfigureAwait(false);

        /// <summary>查询 SANDIA 模式 BETA 值 (SOL:SAND:BETA?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>BETA 值</returns>
        public virtual async Task<double> 查询SANDIABetaAsync(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:SAND:BETA?", ct).ConfigureAwait(false);

        /// <summary>设置 SANDIA 模式填充系数 FF，0.4~0.95（薄膜0.55/标准晶硅0.68/高效晶硅0.8） (SOL:SAND:TECH)</summary>
        /// <param name="ff">填充系数</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SANDIA填充系数Async(double ff, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAND:TECH {Fmt(ff)}", ct).ConfigureAwait(false);

        /// <summary>查询 SANDIA 模式填充系数 FF (SOL:SAND:TECH?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>填充系数</returns>
        public virtual async Task<double> 查询SANDIA填充系数Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:SAND:TECH?", ct).ConfigureAwait(false);

        /// <summary>设置 SANDIA 模式光照强度，0~3000 整数 (SOL:SAND:IRR)</summary>
        /// <param name="irr">光照强度 (单位: W/m2)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SANDIA光照强度Async(int irr, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAND:IRR {irr}", ct).ConfigureAwait(false);

        /// <summary>查询 SANDIA 模式光照强度 (SOL:SAND:IRR?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>光照强度 (单位: W/m2)</returns>
        public virtual async Task<int> 查询SANDIA光照强度Async(CancellationToken ct = default)
            => await QueryIntAsync("SOL:SAND:IRR?", ct).ConfigureAwait(false);

        /// <summary>设置 SANDIA 模式温度，-40~85 度 (SOL:SAND:TMP)</summary>
        /// <param name="temp">温度 (单位: ℃)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SANDIA温度Async(int temp, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAND:TMP {temp}", ct).ConfigureAwait(false);

        /// <summary>查询 SANDIA 模式温度 (SOL:SAND:TMP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>温度 (单位: ℃)</returns>
        public virtual async Task<int> 查询SANDIA温度Async(CancellationToken ct = default)
            => await QueryIntAsync("SOL:SAND:TMP?", ct).ConfigureAwait(false);

        /// <summary>设置 SANDIA 模式最大功率点功率 Pmp，须小于电源最大功率 (SOL:SAND:PMP)</summary>
        /// <param name="watts">最大功率点功率 (单位: W)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SANDIA最大功率点功率Async(double watts, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAND:PMP {Fmt(watts)}", ct).ConfigureAwait(false);

        /// <summary>查询 SANDIA 模式最大功率点功率 Pmp (SOL:SAND:PMP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>最大功率点功率 (单位: W)</returns>
        public virtual async Task<double> 查询SANDIA最大功率点功率Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:SAND:PMP?", ct).ConfigureAwait(false);

        /// <summary>设置 SANDIA 模式最大功率点电压 Vmp (SOL:SAND:VMP)</summary>
        /// <param name="volts">最大功率点电压 (单位: V)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置SANDIA最大功率点电压Async(double volts, CancellationToken ct = default)
            => await SendCmdAsync($"SOL:SAND:VMP {Fmt(volts)}", ct).ConfigureAwait(false);

        /// <summary>查询 SANDIA 模式最大功率点电压 Vmp (SOL:SAND:VMP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>最大功率点电压 (单位: V)</returns>
        public virtual async Task<double> 查询SANDIA最大功率点电压Async(CancellationToken ct = default)
            => await QueryDoubleAsync("SOL:SAND:VMP?", ct).ConfigureAwait(false);

        #endregion

        #region 10. 序列测试（手册 B2.10，需先 SOUR:MOD 1 进入序列界面）

        /// <summary>设置当前序列号，0~49 (PROG:INIT)</summary>
        /// <param name="program">序列号 (0~49)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置序列号Async(int program, CancellationToken ct = default)
            => await SendCmdAsync($"PROG:INIT {program}", ct).ConfigureAwait(false);

        /// <summary>查询当前序列号，0~49 (PROG:INIT?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>序列号</returns>
        public virtual async Task<int> 查询序列号Async(CancellationToken ct = default)
            => await QueryIntAsync("PROG:INIT?", ct).ConfigureAwait(false);

        /// <summary>启动指定序列号的序列测试，0~49 (PROG:TRIG)</summary>
        /// <param name="program">序列号 (0~49)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 启动序列测试Async(int program, CancellationToken ct = default)
            => await SendCmdAsync($"PROG:TRIG {program}", ct).ConfigureAwait(false);

        /// <summary>停止序列测试 (PROG:ABOR)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 停止序列测试Async(CancellationToken ct = default)
            => await SendCmdAsync("PROG:ABOR", ct).ConfigureAwait(false);

        /// <summary>暂停序列测试 (PROG:ABOR:STEP)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 暂停序列测试Async(CancellationToken ct = default)
            => await SendCmdAsync("PROG:ABOR:STEP", ct).ConfigureAwait(false);

        /// <summary>继续序列测试 (PROG:ABOR:INIT)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 继续序列测试Async(CancellationToken ct = default)
            => await SendCmdAsync("PROG:ABOR:INIT", ct).ConfigureAwait(false);

        /// <summary>查询序列测试状态：0=已完成(未启动)/1=运行/2=暂停 (PROG:STAT?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>序列状态枚举</returns>
        public virtual async Task<ANEVH序列状态_枚举> 查询序列状态Async(CancellationToken ct = default)
            => (ANEVH序列状态_枚举)await QueryIntAsync("PROG:STAT?", ct).ConfigureAwait(false);

        /// <summary>
        /// 定义某一步的序列测试参数，共 12 个参数 (PROG:DEF)。
        /// step=序列步数(0-19)；mode=0 VI模式/1 电压斜率/2 电流斜率；enable=使能；
        /// operation=0无/1循环起始/2循环停止/3暂停；nextOrLink=0下一步/1链接；linkProgram=链接序列号(0-49)；
        /// loopCount=循环次数；seconds/millis=步进时间；volts/amps/watts=对应模式下的电压(V)/电流(A)/功率(W)。
        /// </summary>
        /// <param name="step">序列步数 (0-19)</param>
        /// <param name="mode">步进模式 (0 VI模式/1 电压斜率/2 电流斜率)</param>
        /// <param name="enable">是否使能 (0/1)</param>
        /// <param name="operation">操作 (0无/1循环起始/2循环停止/3暂停)</param>
        /// <param name="nextOrLink">下一步或链接 (0下一步/1链接)</param>
        /// <param name="linkProgram">链接序列号 (0-49)</param>
        /// <param name="loopCount">循环次数</param>
        /// <param name="seconds">步进时间秒部分</param>
        /// <param name="millis">步进时间毫秒部分</param>
        /// <param name="volts">电压 (单位: V)</param>
        /// <param name="amps">电流 (单位: A)</param>
        /// <param name="watts">功率 (单位: W)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 定义序列步Async(int step, int mode, int enable, int operation, int nextOrLink, int linkProgram,
            int loopCount, int seconds, int millis, double volts, double amps, double watts, CancellationToken ct = default)
            => await SendCmdAsync(
                $"PROG:DEF {step},{mode},{enable},{operation},{nextOrLink},{linkProgram},{loopCount},{seconds},{millis},{Fmt(volts)},{Fmt(amps)},{Fmt(watts)}", ct).ConfigureAwait(false);

        /// <summary>删除某一步序列数据，0-19 (PROG:DEF:DEL)</summary>
        /// <param name="step">序列步数 (0-19)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 删除序列步Async(int step, CancellationToken ct = default)
            => await SendCmdAsync($"PROG:DEF:DEL {step}", ct).ConfigureAwait(false);

        /// <summary>复制某一步的序列数据，0-19 (PROG:DEF:STEP)</summary>
        /// <param name="step">序列步数 (0-19)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 复制序列步Async(int step, CancellationToken ct = default)
            => await SendCmdAsync($"PROG:DEF:STEP {step}", ct).ConfigureAwait(false);

        /// <summary>粘贴序列数据到某一步，0-19，与复制序列步配合使用 (PROG:DEF:SAVE)</summary>
        /// <param name="step">序列步数 (0-19)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 粘贴序列步Async(int step, CancellationToken ct = default)
            => await SendCmdAsync($"PROG:DEF:SAVE {step}", ct).ConfigureAwait(false);

        /// <summary>在某一步序列前插入一步新序列，0-19 (PROG:DEF:NEXT)</summary>
        /// <param name="step">序列步数 (0-19)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 插入序列步Async(int step, CancellationToken ct = default)
            => await SendCmdAsync($"PROG:DEF:NEXT {step}", ct).ConfigureAwait(false);

        #endregion

        #region 11. 固定电池模拟（手册 B2.11，需先 SOUR:MOD 6 进入电池模拟界面）

        /// <summary>选择电池类型：0锰酸锂/1钴酸锂/2磷酸铁锂/3铅酸/4镍氢/5三元锂/6钛酸锂 (FUNC:TYPE)</summary>
        /// <param name="type">电池类型枚举</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电池类型Async(ANEVH电池类型_枚举 type, CancellationToken ct = default)
            => await SendCmdAsync($"FUNC:TYPE {(int)type}", ct).ConfigureAwait(false);

        /// <summary>查询电池类型 (FUNC:TYPE?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>电池类型枚举</returns>
        public virtual async Task<ANEVH电池类型_枚举> 查询电池类型Async(CancellationToken ct = default)
            => (ANEVH电池类型_枚举)await QueryIntAsync("FUNC:TYPE?", ct).ConfigureAwait(false);

        /// <summary>设置电池串联数 (FUNC:SERI)</summary>
        /// <param name="series">串联数</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电池串联数Async(int series, CancellationToken ct = default)
            => await SendCmdAsync($"FUNC:SERI {series}", ct).ConfigureAwait(false);

        /// <summary>查询电池串联数 (FUNC:SERI?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>串联数</returns>
        public virtual async Task<int> 查询电池串联数Async(CancellationToken ct = default)
            => await QueryIntAsync("FUNC:SERI?", ct).ConfigureAwait(false);

        /// <summary>设置电池并联数，1~999 (FUNC:PARA)</summary>
        /// <param name="parallel">并联数</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电池并联数Async(int parallel, CancellationToken ct = default)
            => await SendCmdAsync($"FUNC:PARA {parallel}", ct).ConfigureAwait(false);

        /// <summary>查询电池并联数 (FUNC:PARA?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>并联数</returns>
        public virtual async Task<int> 查询电池并联数Async(CancellationToken ct = default)
            => await QueryIntAsync("FUNC:PARA?", ct).ConfigureAwait(false);

        /// <summary>设置单体电池容量 Q1，范围 0.1~1000.0 (FUNC:CAP)</summary>
        /// <param name="capacity">单体电池容量 (单位: Ah)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置单体电池容量Async(double capacity, CancellationToken ct = default)
            => await SendCmdAsync($"FUNC:CAP {Fmt(capacity)}", ct).ConfigureAwait(false);

        /// <summary>查询单体电池容量 Q1 (FUNC:CAP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>单体电池容量 (单位: Ah)</returns>
        public virtual async Task<double> 查询单体电池容量Async(CancellationToken ct = default)
            => await QueryDoubleAsync("FUNC:CAP?", ct).ConfigureAwait(false);

        /// <summary>设置初始 SOC，范围 0~100 (FUNC:SOC)</summary>
        /// <param name="soc">初始 SOC (单位: %)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置初始SOCAsync(double soc, CancellationToken ct = default)
            => await SendCmdAsync($"FUNC:SOC {Fmt(soc)}", ct).ConfigureAwait(false);

        /// <summary>查询初始 SOC (FUNC:SOC?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>初始 SOC (单位: %)</returns>
        public virtual async Task<double> 查询初始SOCAsync(CancellationToken ct = default)
            => await QueryDoubleAsync("FUNC:SOC?", ct).ConfigureAwait(false);

        /// <summary>下发电池模拟参数，设置完类型/串并联/容量/SOC 后必须执行 (FUNC:TRIG)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 下发电池模拟参数Async(CancellationToken ct = default)
            => await SendCmdAsync("FUNC:TRIG", ct).ConfigureAwait(false);

        /// <summary>查询特征参数：并联容量Qn(Ah)、串联电压E0(V)、单体上限/下限/标准电压(V) (FUNC:FEAT?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>(并联容量Qn, 串联电压E0, 单体上限电压, 单体下限电压, 单体标准电压) 元组</returns>
        public virtual async Task<(double 并联容量Qn, double 串联电压E0, double 单体上限电压, double 单体下限电压, double 单体标准电压)> 查询电池特征参数Async(CancellationToken ct = default)
        {
            var arr = await QueryDoubleArrayAsync("FUNC:FEAT?", ct).ConfigureAwait(false);
            return arr.Length >= 5 ? (arr[0], arr[1], arr[2], arr[3], arr[4]) : (0, 0, 0, 0, 0);
        }

        /// <summary>设置电能计量开关，必须在电池模拟运行界面使用 (FUNC:CALC:ENER)</summary>
        /// <param name="enable">true: 开启电能计量</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电能计量Async(bool enable, CancellationToken ct = default)
            => await SendCmdAsync($"FUNC:CALC:ENER {(enable ? "1" : "0")}", ct).ConfigureAwait(false);

        /// <summary>查询电能计量开关状态 (FUNC:CALC:ENER?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>true: 电能计量已开启</returns>
        public virtual async Task<bool> 查询电能计量状态Async(CancellationToken ct = default)
            => await QueryOnOffAsync("FUNC:CALC:ENER?", ct).ConfigureAwait(false);

        /// <summary>查询电能计量耗能 (FUNC:DISC:ENER?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>耗能 (单位: kWh)</returns>
        public virtual async Task<double> 查询耗能Async(CancellationToken ct = default)
            => await QueryDoubleAsync("FUNC:DISC:ENER?", ct).ConfigureAwait(false);

        /// <summary>查询电能计量馈能 (FUNC:CHAR:ENER?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>馈能 (单位: kWh)</returns>
        public virtual async Task<double> 查询馈能Async(CancellationToken ct = default)
            => await QueryDoubleAsync("FUNC:CHAR:ENER?", ct).ConfigureAwait(false);

        /// <summary>查询电能计量安时 (FUNC:AMP:HOUR?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>安时 (单位: Ah)</returns>
        public virtual async Task<double> 查询安时Async(CancellationToken ct = default)
            => await QueryDoubleAsync("FUNC:AMP:HOUR?", ct).ConfigureAwait(false);

        /// <summary>查询电能计量运行时间，原始返回 时,分,秒 (FUNC:RUN:TIM?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>运行时间字符串（时,分,秒）</returns>
        public virtual async Task<string> 查询电池模拟运行时间Async(CancellationToken ct = default)
            => await QueryAsync("FUNC:RUN:TIM?", ct).ConfigureAwait(false);

        #endregion

        #region 12. 电池测试-充放电（手册 B2.12，需先 SOUR:MOD 10 进入电池测试界面，设置命令在 OFF 状态有效）

        /// <summary>选择电池测试工作模式：0静态充电/1静态放电/2动态测试 (TEST:MOD)</summary>
        /// <param name="mode">电池测试模式枚举</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置电池测试模式Async(ANEVH电池测试模式_枚举 mode, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:MOD {(int)mode}", ct).ConfigureAwait(false);

        /// <summary>查询电池测试工作模式 (TEST:MOD?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>电池测试模式枚举</returns>
        public virtual async Task<ANEVH电池测试模式_枚举> 查询电池测试模式Async(CancellationToken ct = default)
            => (ANEVH电池测试模式_枚举)await QueryIntAsync("TEST:MOD?", ct).ConfigureAwait(false);

        /// <summary>查询电池测试状态：工作模式(0静态充电/1静态放电/2动态测试)、动态测试是否运行(0停止/1运行)、动态测试当前模式(0充电/1放电) (TEST:STAT?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>(工作模式, 动态运行, 动态当前模式) 元组</returns>
        public virtual async Task<(int 工作模式, int 动态运行, int 动态当前模式)> 查询电池测试状态Async(CancellationToken ct = default)
        {
            var arr = await QueryDoubleArrayAsync("TEST:STAT?", ct).ConfigureAwait(false);
            return arr.Length >= 3 ? ((int)arr[0], (int)arr[1], (int)arr[2]) : (0, 0, 0);
        }

        /// <summary>查询当前总运行时间，动态测试包括休息时间 (TEST:TIM?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>运行时间 (单位: s)</returns>
        public virtual async Task<double> 查询电池测试运行时间Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:TIM?", ct).ConfigureAwait(false);

        /// <summary>查询当前运行容量 (TEST:CAP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>运行容量 (单位: Ah)</returns>
        public virtual async Task<double> 查询电池测试运行容量Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:CAP?", ct).ConfigureAwait(false);

        /// <summary>查询当前运行能量 (TEST:ENER?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>运行能量 (单位: kWh)</returns>
        public virtual async Task<double> 查询电池测试运行能量Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:ENER?", ct).ConfigureAwait(false);

        /// <summary>重置电池测试：清除当前运行时间、容量和能量 (TEST:CLE)</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 重置电池测试参数Async(CancellationToken ct = default)
            => await SendCmdAsync("TEST:CLE", ct).ConfigureAwait(false);

        /// <summary>设置充电电压 (TEST:CHAR:VOLT)</summary>
        /// <param name="volts">充电电压 (单位: V)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置充电电压Async(double volts, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:CHAR:VOLT {Fmt(volts)}", ct).ConfigureAwait(false);

        /// <summary>查询充电电压 (TEST:CHAR:VOLT?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>充电电压 (单位: V)</returns>
        public virtual async Task<double> 查询充电电压Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:CHAR:VOLT?", ct).ConfigureAwait(false);

        /// <summary>设置充电电流 (TEST:CHAR:CURR)</summary>
        /// <param name="amps">充电电流 (单位: A)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置充电电流Async(double amps, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:CHAR:CURR {Fmt(amps)}", ct).ConfigureAwait(false);

        /// <summary>查询充电电流 (TEST:CHAR:CURR?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>充电电流 (单位: A)</returns>
        public virtual async Task<double> 查询充电电流Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:CHAR:CURR?", ct).ConfigureAwait(false);

        /// <summary>设置充电停止电流 (TEST:CHAR:ABOR:CURR)</summary>
        /// <param name="amps">充电停止电流 (单位: A)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置充电停止电流Async(double amps, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:CHAR:ABOR:CURR {Fmt(amps)}", ct).ConfigureAwait(false);

        /// <summary>查询充电停止电流 (TEST:CHAR:ABOR:CURR?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>充电停止电流 (单位: A)</returns>
        public virtual async Task<double> 查询充电停止电流Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:CHAR:ABOR:CURR?", ct).ConfigureAwait(false);

        /// <summary>设置充电停止容量 (TEST:CHAR:ABOR:CAP)</summary>
        /// <param name="capacity">充电停止容量 (单位: Ah)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置充电停止容量Async(double capacity, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:CHAR:ABOR:CAP {Fmt(capacity)}", ct).ConfigureAwait(false);

        /// <summary>查询充电停止容量 (TEST:CHAR:ABOR:CAP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>充电停止容量 (单位: Ah)</returns>
        public virtual async Task<double> 查询充电停止容量Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:CHAR:ABOR:CAP?", ct).ConfigureAwait(false);

        /// <summary>设置充电停止时间，范围 0~36000 (TEST:CHAR:ABOR:TIM)</summary>
        /// <param name="seconds">充电停止时间 (单位: s)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置充电停止时间Async(double seconds, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:CHAR:ABOR:TIM {Fmt(seconds)}", ct).ConfigureAwait(false);

        /// <summary>查询充电停止时间 (TEST:CHAR:ABOR:TIM?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>充电停止时间 (单位: s)</returns>
        public virtual async Task<double> 查询充电停止时间Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:CHAR:ABOR:TIM?", ct).ConfigureAwait(false);

        /// <summary>设置放电运行模式：CC恒流(放电功率自动设为最大值)/CP恒功率(放电电流自动设为最大值) (TEST:DISC:MOD)</summary>
        /// <param name="constantPower">true: CP 恒功率, false: CC 恒流</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置放电模式Async(bool constantPower, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:DISC:MOD {(constantPower ? "CP" : "CC")}", ct).ConfigureAwait(false);

        /// <summary>查询放电运行模式，返回 CC|CP (TEST:DISC:MOD?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>放电模式字符串（CC 或 CP）</returns>
        public virtual async Task<string> 查询放电模式Async(CancellationToken ct = default)
            => await QueryAsync("TEST:DISC:MOD?", ct).ConfigureAwait(false);

        /// <summary>设置放电电流 (TEST:DISC:CURR)</summary>
        /// <param name="amps">放电电流 (单位: A)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置放电电流Async(double amps, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:DISC:CURR {Fmt(amps)}", ct).ConfigureAwait(false);

        /// <summary>查询放电电流 (TEST:DISC:CURR?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>放电电流 (单位: A)</returns>
        public virtual async Task<double> 查询放电电流Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:DISC:CURR?", ct).ConfigureAwait(false);

        /// <summary>设置放电功率 (TEST:DISC:POW)</summary>
        /// <param name="watts">放电功率 (单位: W)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置放电功率Async(double watts, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:DISC:POW {Fmt(watts)}", ct).ConfigureAwait(false);

        /// <summary>查询放电功率 (TEST:DISC:POW?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>放电功率 (单位: W)</returns>
        public virtual async Task<double> 查询放电功率Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:DISC:POW?", ct).ConfigureAwait(false);

        /// <summary>设置放电停止电压 (TEST:DISC:ABOR:VOLT)</summary>
        /// <param name="volts">放电停止电压 (单位: V)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置放电停止电压Async(double volts, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:DISC:ABOR:VOLT {Fmt(volts)}", ct).ConfigureAwait(false);

        /// <summary>查询放电停止电压 (TEST:DISC:ABOR:VOLT?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>放电停止电压 (单位: V)</returns>
        public virtual async Task<double> 查询放电停止电压Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:DISC:ABOR:VOLT?", ct).ConfigureAwait(false);

        /// <summary>设置放电停止容量 (TEST:DISC:ABOR:CAP)</summary>
        /// <param name="capacity">放电停止容量 (单位: Ah)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置放电停止容量Async(double capacity, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:DISC:ABOR:CAP {Fmt(capacity)}", ct).ConfigureAwait(false);

        /// <summary>查询放电停止容量 (TEST:DISC:ABOR:CAP?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>放电停止容量 (单位: Ah)</returns>
        public virtual async Task<double> 查询放电停止容量Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:DISC:ABOR:CAP?", ct).ConfigureAwait(false);

        /// <summary>设置放电停止时间，范围 0~36000 (TEST:DISC:ABOR:TIM)</summary>
        /// <param name="seconds">放电停止时间 (单位: s)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置放电停止时间Async(double seconds, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:DISC:ABOR:TIM {Fmt(seconds)}", ct).ConfigureAwait(false);

        /// <summary>查询放电停止时间 (TEST:DISC:ABOR:TIM?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>放电停止时间 (单位: s)</returns>
        public virtual async Task<double> 查询放电停止时间Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:DISC:ABOR:TIM?", ct).ConfigureAwait(false);

        /// <summary>设置动态测试初始模式：false=充电/true=放电 (TEST:DYN:INIT)</summary>
        /// <param name="dischargeFirst">true: 先放电, false: 先充电</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置动态测试初始模式Async(bool dischargeFirst, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:DYN:INIT {(dischargeFirst ? "1" : "0")}", ct).ConfigureAwait(false);

        /// <summary>查询动态测试初始模式，返回 0=充电/1=放电 (TEST:DYN:INIT?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>0=充电/1=放电</returns>
        public virtual async Task<int> 查询动态测试初始模式Async(CancellationToken ct = default)
            => await QueryIntAsync("TEST:DYN:INIT?", ct).ConfigureAwait(false);

        /// <summary>设置动态测试循环次数，0~65535，0 为无限循环 (TEST:DYN:CYCL)</summary>
        /// <param name="cycles">循环次数</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置动态测试循环次数Async(int cycles, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:DYN:CYCL {cycles}", ct).ConfigureAwait(false);

        /// <summary>查询动态测试循环次数 (TEST:DYN:CYCL?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>循环次数</returns>
        public virtual async Task<int> 查询动态测试循环次数Async(CancellationToken ct = default)
            => await QueryIntAsync("TEST:DYN:CYCL?", ct).ConfigureAwait(false);

        /// <summary>设置动态测试休息时间，范围 0~36000 (TEST:DYN:TIM)</summary>
        /// <param name="seconds">休息时间 (单位: s)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 设置动态测试休息时间Async(double seconds, CancellationToken ct = default)
            => await SendCmdAsync($"TEST:DYN:TIM {Fmt(seconds)}", ct).ConfigureAwait(false);

        /// <summary>查询动态测试休息时间 (TEST:DYN:TIM?)</summary>
        /// <param name="ct">异步取消令牌</param>
        /// <returns>休息时间 (单位: s)</returns>
        public virtual async Task<double> 查询动态测试休息时间Async(CancellationToken ct = default)
            => await QueryDoubleAsync("TEST:DYN:TIM?", ct).ConfigureAwait(false);

        #endregion

        #region 13. 组合便捷方法

        /// <summary>进入常规界面并以 CV 方式启动输出：依次设置功能模式、电压、正向电流限，然后启动输出</summary>
        /// <param name="volts">输出电压 (单位: V)</param>
        /// <param name="currentLimit">正向限流 (单位: A)</param>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 启动CV输出Async(double volts, double currentLimit, CancellationToken ct = default)
        {
            await 设置功能模式Async(ANEVH功能模式_枚举.常规, ct).ConfigureAwait(false);
            await 设置电压Async(volts, ct).ConfigureAwait(false);
            await 设置电流Async(currentLimit, ct).ConfigureAwait(false);
            await 启动输出Async(ct).ConfigureAwait(false);
        }

        /// <summary>安全停止输出：先将电压设为 0（利用电压斜率缓降），再关闭输出</summary>
        /// <param name="ct">异步取消令牌</param>
        public virtual async Task 缓降停止Async(CancellationToken ct = default)
        {
            await 设置电压Async(0, ct).ConfigureAwait(false);
            await 停止输出Async(ct).ConfigureAwait(false);
        }

        #endregion
    }
}