chrg/apps/chrg/applications/thread/chrg_roll_nor.c

/****************************************************************************
文件名称   : chrg_roll_nor.c
完成日期   : 
当前版本号 : V1.1.8
主要功能   : 实现北向通信轮巡请求命令。以独立线程处理。
版本历史   : 创建原始版本
说明      : 
******************************************************************************/

#include <stdlib.h>
#include <string.h>
#include <rtthread.h>

#include "chrg_gpio.h"
#include "chrg_led.h"
#include "chrg_thread.h"
#include "chrg_sink.h"
#include "chrg_source.h"
#include "chrg_roll_nor.h"
#include "chrg_roll_sou.h"
#include "chrg_comm.h"
#include "chrg_north.h"
#include "chrg_switch.h"
#include "chrg_utils.h"
#include "chrg_rel.h"
#include "chrg_wdt.h"
#define LOG_TAG "chrg.rollnor"
#include <rtdbg.h>

#define NORTH_RESPONSE_TIMEOUT_MS    50U  // 单次北向请求等待匹配回码的总时间
#define NORTH_REQUEST_MAX_RETRIES    2U   // 首次发送失败后最多重发2次，总发送次数为3次
#define NORTH_MEASURE_MAX_ATTEMPTS   1U   // 0x20量测查询失败后直接留给下一轮轮询重发
#define NORTH_RETRY_INTERVAL_MS      5U   // 相同请求两次发送之间的保护间隔
#define NORTH_POLL_INTERVAL_MS       10U  // 一个通道事务结束后到下一通道的轮询间隔
#define SOURCE_PROTOCOL_WAIT_MS      100U  // 每通道0xD0应答后的协议生效保护时间
#define SINK_CC_WAIT_MS             50U  // Sink设置目标CC应答后的非阻塞保护时间
#define SINK_HANDSHAKE_FIRST_QUERY_DELAY_MS 50U // 协议/CC回码后首条0x20的等待时间
#define SINK_HANDSHAKE_QUERY_INTERVAL_MS    50U // 握手未完成时后续0x20查询间隔
#define SOURCE_CHANNEL_BIT(ch)       ((rt_uint8_t)(1U << (ch)))
const rt_base_t sw_uart[TOTAL_NOR_CHS] = {
	IDX_GPO_UART_SW1,
	IDX_GPO_UART_SW2,
	IDX_GPO_UART_SW3,
	IDX_GPO_UART_SW4
};

struct chrg_rollnor_t chrgrollnor = {
	.run = RUN_CONSOLE, // RUN_AUTO,
	.ch = IDX_NOR_CH1,
//	.Set_Role = ID_SINK,
//	.group = 0,
};

/* 所有参与CC_CLOSE的通道共享300ms屏障；协议等待仍按通道独立计时。 */
static rt_uint8_t g_source_protocol_wait_mask = 0U;
static rt_tick_t g_source_protocol_wait_start[TOTAL_NOR_CHS] = {0};
static rt_uint8_t g_sink_cc_wait_mask = 0U;
static rt_tick_t g_sink_cc_wait_start[TOTAL_NOR_CHS] = {0};
/* Sink协议/CC握手期间的0x20查询节流记录，按通道独立计时。 */
static rt_bool_t g_sink_query_throttle[TOTAL_NOR_CHS] = {RT_FALSE};
static rt_bool_t g_sink_query_first_pending[TOTAL_NOR_CHS] = {RT_FALSE};
static rt_tick_t g_sink_query_tick[TOTAL_NOR_CHS] = {0};

/*****************************************************************
函数名称： chrg_roll_nor_sink_query_is_slow
函数描述： 判断当前Sink状态是否仍处于协议握手量测阶段
输入参数： pSW:当前负载通道控制结构体
输出参数： -
返回说明： RT_TRUE:0x20查询按握手节奏发送 RT_FALSE:使用正常轮询周期
其它说明： 只有协议/CC设置后等待协商电压的阶段限速；RUNING和低电流
          待机不受影响，避免影响正常量测刷新速度
*****************************************************************/
static rt_bool_t chrg_roll_nor_sink_query_is_slow(
	const struct chrg_switch_t *pSW)
{
	if (pSW == RT_NULL) {
		return RT_FALSE;
	}
	return (pSW->sink.work_mode == SINK_WORK_WAIT) ||
		(pSW->sink.work_mode == SINK_WORK_INIT_AUX_WAIT) ||
		(pSW->sink.work_mode == SINK_WORK_LOW_MONITOR);
}

/*****************************************************************
函数名称： chrg_roll_nor_sink_query_wait_start
函数描述： 启动Sink握手阶段的0x20查询节流计时
输入参数： ch:北向通道编号
输出参数： 记录当前tick并开启节流
返回说明： -
其它说明： 协议或CC回码成功后调用，避免下一轮立即查询协议板
*****************************************************************/
static void chrg_roll_nor_sink_query_wait_start(rt_uint8_t ch)
{
	if (ch >= TOTAL_NOR_CHS) {
		return;
	}
	g_sink_query_throttle[ch] = RT_TRUE;
	g_sink_query_first_pending[ch] = RT_TRUE;
	g_sink_query_tick[ch] = rt_tick_get();
}

/*****************************************************************
函数名称： chrg_roll_nor_source_switch_reset
函数描述： 清理指定Source通道的CC_CLOSE及协议等待记录
输入参数： ch:北向通道编号
输出参数： 清除对应通道的屏障位和协议等待计时
返回说明： -
其它说明： 调用者必须持有北向轮询线程互斥锁
*****************************************************************/
void chrg_roll_nor_source_switch_reset(rt_uint8_t ch)
{
	if (ch >= TOTAL_NOR_CHS) {
		return;
	}
	g_source_protocol_wait_mask &=
		(rt_uint8_t)~SOURCE_CHANNEL_BIT(ch);
	g_source_protocol_wait_start[ch] = 0U;
}

/*****************************************************************
函数名称： chrg_roll_nor_source_cc_close_register
函数描述： 将Source通道登记到本轮共享CC_CLOSE等待屏障
输入参数： ch:北向通道编号
输出参数： 设置pending位并清除该通道旧ACK和等待状态
返回说明： -
其它说明： 新通道加入已经开始的屏障时重新等待，保证所有登记通道共享完整保护时间
*****************************************************************/
static void chrg_roll_nor_source_protocol_wait_start(rt_uint8_t ch)
{
	if (ch >= TOTAL_NOR_CHS) {
		return;
	}
	g_source_protocol_wait_mask |= SOURCE_CHANNEL_BIT(ch);
	g_source_protocol_wait_start[ch] = rt_tick_get();
}

/*****************************************************************
函数名称： chrg_roll_nor_source_wait_process
函数描述： 处理Source共享CC_CLOSE等待和每通道协议生效等待
输入参数： ch:北向通道编号 pSW:通道状态
输出参数： CC_CLOSE等待到期进入0xD0，协议等待到期进入目标CC设置
返回说明： RT_TRUE:本轮仍处于等待，不发送命令 RT_FALSE:可继续发送
其它说明： CC_CLOSE使用共享300ms屏障，协议ACK后每通道独立等待100ms
*****************************************************************/
static rt_bool_t chrg_roll_nor_source_wait_process(rt_uint8_t ch,
	struct chrg_switch_t *pSW)
{
	rt_uint8_t bit;
	rt_tick_t elapsed;

	if ((ch >= TOTAL_NOR_CHS) || (pSW == RT_NULL)) {
		return RT_FALSE;
	}
	bit = SOURCE_CHANNEL_BIT(ch);

	if ((pSW->id != ID_SOURCE) || !pSW->source.On_Flag) {
		chrg_roll_nor_source_switch_reset(ch);
		return RT_FALSE;
	}
	if (pSW->source.work_mode == SOURCE_WORK_INIT_WAIT) {
		/* 南向初始化批次未完成时，禁止发送北向协议命令。 */
		return RT_TRUE;
	}

	if (pSW->sub == IDX_WAIT_SOURCE_PROTOCOL) {
		if ((g_source_protocol_wait_mask & bit) == 0U) {
			pSW->sub = IDX_SET_SOURCE_CC_SET;
			return RT_FALSE;
		}
		elapsed = (rt_tick_t)(rt_tick_get() -
			g_source_protocol_wait_start[ch]);
		if (elapsed < rt_tick_from_millisecond(SOURCE_PROTOCOL_WAIT_MS)) {
			return RT_TRUE;
		}
		g_source_protocol_wait_mask &= (rt_uint8_t)~bit;
		g_source_protocol_wait_start[ch] = 0U;
		pSW->sub = IDX_SET_SOURCE_CC_SET;
		return RT_FALSE;
	}
	return RT_FALSE;
}

/*****************************************************************
函数名称： chrg_roll_nor_sink_cc_wait_start
函数描述： Sink目标CC设置收到有效应答后启动该通道的稳定计时
输入参数： ch:北向通道编号
输出参数： 记录通道等待标志和起始tick
返回说明： -
其它说明： 每个通道独立计时，多个通道切换CC时等待时间不会串行累加
*****************************************************************/
static void chrg_roll_nor_sink_cc_wait_start(rt_uint8_t ch)
{
	if (ch >= TOTAL_NOR_CHS) {
		return;
	}
	g_sink_cc_wait_mask |= SOURCE_CHANNEL_BIT(ch);
	g_sink_cc_wait_start[ch] = rt_tick_get();
}

/*****************************************************************
函数名称： chrg_roll_nor_sink_wait_process
函数描述： 管理Sink安全卸载、南北并行握手和CC设置后的稳定等待
输入参数： ch:北向通道编号 pSW:通道实时控制结构体
输出参数： 南向批次完成后允许协议/CC；低电流和CC均满足后允许查询
返回说明： RT_TRUE:本轮仍需等待，不发送北向命令 RT_FALSE:可继续发送
其它说明： 完整重握手中，南向批次完成后协议/CC与低电流确认并行；
          进入GET_SINK_VC后，必须等低电流确认完成才允许发送0x20
*****************************************************************/
static rt_bool_t chrg_roll_nor_sink_wait_process(rt_uint8_t ch,
	struct chrg_switch_t *pSW)
{
	rt_uint8_t bit;
	rt_tick_t elapsed;

	if ((ch >= TOTAL_NOR_CHS) || (pSW == RT_NULL)) {
		return RT_FALSE;
	}
	bit = SOURCE_CHANNEL_BIT(ch);

	/* 关机必须先完成南向低电流确认和继电器批次，期间禁止北向发送。 */
	if ((pSW->sink.work_mode == SINK_WORK_STOP_WAIT) ||
		(pSW->sink.work_mode == SINK_WORK_STOP_RELAY) ||
		(pSW->sink.work_mode == SINK_WORK_STOP_RELAY_WAIT)) {
		return RT_TRUE;
	}

	if ((pSW->id != ID_SINK) || !pSW->sink.On_work) {
		g_sink_cc_wait_mask &= (rt_uint8_t)~bit;
		g_sink_cc_wait_start[ch] = 0U;
		g_sink_query_throttle[ch] = RT_FALSE;
		g_sink_query_first_pending[ch] = RT_FALSE;
		g_sink_query_tick[ch] = 0U;
		return RT_FALSE;
	}
	/* 普通软卸载和低电流恢复仍禁止北向；INIT_AUX_WAIT允许南北向并行。 */
	if ((pSW->sink.work_mode == SINK_WORK_UNLOAD_WAIT) ||
		(pSW->sink.work_mode == SINK_WORK_LOW_AUX_WAIT)) {
		return RT_TRUE;
	}

	/* 协议或CC切换必须先完成低电流确认；该过程保持南向继电器状态不变。 */
	if (pSW->sink.work_mode == SINK_WORK_HANDSHAKE_WAIT) {
		return RT_TRUE;
	}

	/* D0回码确认后先经过一个非发送状态，禁止把协议回码当成量测回码。 */
	if (pSW->sub == IDX_WAIT_SINK_PD_ACK) {
		pSW->sub = IDX_GET_SINK_VC;
		chrg_roll_nor_sink_query_wait_start(ch);
		return RT_TRUE;
	}

	if ((pSW->sub != IDX_WAIT_SINK_CC) &&
		(pSW->sub != IDX_WAIT_SINK_CC_BEFORE_PD)) {
		/* COM在等待期间提交新配置时，清理旧事务留下的CC计时记录。 */
		g_sink_cc_wait_mask &= (rt_uint8_t)~bit;
		g_sink_cc_wait_start[ch] = 0U;
		if (!chrg_roll_nor_sink_query_is_slow(pSW)) {
			g_sink_query_throttle[ch] = RT_FALSE;
			g_sink_query_first_pending[ch] = RT_FALSE;
			g_sink_query_tick[ch] = 0U;
		}
	} else {
		if ((g_sink_cc_wait_mask & bit) == 0U) {
			if (pSW->sub == IDX_WAIT_SINK_CC_BEFORE_PD) {
				pSW->sub = IDX_SET_SINK_PD;
			} else {
				pSW->sub = IDX_GET_SINK_VC;
				chrg_roll_nor_sink_query_wait_start(ch);
			}
			return RT_TRUE;
		}
		elapsed = (rt_tick_t)(rt_tick_get() - g_sink_cc_wait_start[ch]);
		if (elapsed < rt_tick_from_millisecond(SINK_CC_WAIT_MS)) {
			return RT_TRUE;
		}

		if (pSW->sub == IDX_WAIT_SINK_CC_BEFORE_PD) {
			/* CC先设置完成后进入协议设置，不立即查询电压。 */
			g_sink_query_throttle[ch] = RT_FALSE;
			g_sink_query_first_pending[ch] = RT_FALSE;
			g_sink_query_tick[ch] = 0U;
			g_sink_cc_wait_mask &= (rt_uint8_t)~bit;
			g_sink_cc_wait_start[ch] = 0U;
			pSW->sub = IDX_SET_SINK_PD;
			return RT_TRUE;
		}

		/* 协议已先设置；CC应答并完成保护等待后进入电压查询。 */
		g_sink_query_throttle[ch] = RT_TRUE;
		g_sink_query_first_pending[ch] = RT_TRUE;
		g_sink_query_tick[ch] = g_sink_cc_wait_start[ch];
		g_sink_cc_wait_mask &= (rt_uint8_t)~bit;
		g_sink_cc_wait_start[ch] = 0U;
		pSW->sub = IDX_GET_SINK_VC;
		return RT_TRUE;
	}

	/* 首条0x20等待200ms；握手未稳定时，后续查询间隔缩短为100ms。 */
	if (chrg_roll_nor_sink_query_is_slow(pSW) &&
		(pSW->sub == IDX_GET_SINK_VC)) {
		rt_uint32_t query_interval_ms;

		if (!g_sink_query_throttle[ch]) {
			chrg_roll_nor_sink_query_wait_start(ch);
			return RT_TRUE;
		}
		query_interval_ms = g_sink_query_first_pending[ch] ?
			SINK_HANDSHAKE_FIRST_QUERY_DELAY_MS :
			SINK_HANDSHAKE_QUERY_INTERVAL_MS;
		elapsed = (rt_tick_t)(rt_tick_get() - g_sink_query_tick[ch]);
		if (elapsed < rt_tick_from_millisecond(query_interval_ms)) {
			return RT_TRUE;
		}
		g_sink_query_first_pending[ch] = RT_FALSE;
		g_sink_query_tick[ch] = rt_tick_get();
	}
	return RT_FALSE;
}
/*****************************************************************
函数名称： sink_fill_pd_buf
函数描述： 根据快充协议类型填充PD指令的5字节数据缓冲区
输入参数： 
    pd_val: 快充协议类型（如0xC1/0xF8/0xFB等）
    pd_volt: 电压值（mV，16位）
    pd_curr: 电流值（mA，16位）
    buf: 输出缓冲区
输出参数： buf: 填充后的5字节协议数据
返回说明： 0:成功 -1:参数错误
*****************************************************************/
int sink_fill_pd_buf(rt_uint8_t group,rt_uint8_t pd_val, rt_uint16_t pd_volt, rt_uint16_t pd_curr,rt_uint8_t *buf)
{
    // 参数合法性校验
    if (buf == RT_NULL) {
        rt_kprintf("sink_fill_pd_buf: buf is a null pointer!\n");
        return -1;
    }

    // 先清空缓冲区（默认全0）
    rt_memset(buf, 0, 5);

    // 按协议类型填充buf
    switch(pd_val) {
        // 标准/QC2.0/QC3.0/FCP（仅电压，第五位=电压）
        case 0xFE:  // 标准协议
        case 0xF8:  // QC2.0协议
        case 0xF6:  // QC3.0协议
        case 0xF2:  // FCP协议
          buf[0] = pd_volt / 100; // 第5字节=电压(0.1V)
					buf[1] = 0x00;//pd_curr / 100; // 第6字节=电流(0.1A)
				#if NORTH_SINK_DEBUG
					rt_kprintf("type: %02X, Voltage(0.1V)=%d\n", pd_val, pd_volt/100);
					rt_kprintf("type: %02x, Curr(0.1A)=%d\n",pd_curr,pd_curr/100);
				#endif
            break;

        // PDO/PPS/PD3.1/UFCS/AVS（组号+电压+电流）
        case 0xFC:  // PPS手动/自动
        case 0xE3:  // AVS协议
            buf[0] = group; // 第5字节=组号（默认0）
            buf[1] = (pd_volt >> 8) & 0xFF; // 第6字节=电压高8位(mV)
            buf[2] = pd_volt & 0xFF; // 第7字节=电压低8位(mV)
            buf[3] = (pd_curr >> 8) & 0xFF; // 第8字节=电流高8位(mA)
            buf[4] = pd_curr & 0xFF; // 第9字节=电流低8位(mA)
				#if NORTH_SINK_DEBUG
            rt_kprintf("type: %02X, Group=0, Voltage=%d mV, Current=%d mA\n", pd_val, pd_volt, pd_curr);
				#endif
            break;
				case 0xE0:  // UFCS协议
				case 0xE1:  // PD3.1协议
				case 0xFB:  // PDO手动
				
            buf[0] = 0x00; // 第5字节=组号（默认0）
            buf[1] = (pd_volt >> 8) & 0xFF; // 第6字节=电压高8位(mV)
            buf[2] = pd_volt & 0xFF; // 第7字节=电压低8位(mV)
            buf[3] = (pd_curr >> 8) & 0xFF; // 第8字节=电流高8位(mA)
            buf[4] = pd_curr & 0xFF; // 第9字节=电流低8位(mA)
				#if NORTH_SINK_DEBUG
            rt_kprintf("type: %02X, Group=0, Voltage=%d mV, Current=%d mA\n", pd_val, pd_volt, pd_curr);
				#endif
            break;					
				
        // SCP/VIVO/传音（电压+电流）
        case 0xF3:  // SCP协议
        case 0xFD:  // VIVO协议
        case 0xF7:  // 传音/TFC协议
            buf[0] = (pd_volt >> 8) & 0xFF; // 第6字节=电压高8位(mV)
            buf[1] = pd_volt & 0xFF; // 第7字节=电压低8位(mV)
            buf[2] = (pd_curr >> 8) & 0xFF; // 第8字节=电流高8位(mA)
            buf[3] = pd_curr & 0xFF; // 第9字节=电流低8位(mA)
            buf[4] = 0x00;
				#if NORTH_SINK_DEBUG
            rt_kprintf("type: %02X, Voltage=%d mV, Current=%d mA\n", pd_val, pd_volt, pd_curr);
				#endif
            break;

        // VOOC（无参数）
        case 0xE2:  // VOOC协议
				#if NORTH_SINK_DEBUG
            rt_kprintf("type: VOOC(0xE2), No parameters\n");
        #endif    
					break;

		case 0xF9:  // AFC协议
		{
			// 1. 电压转HEX
			rt_uint8_t volt_hex = 0;
			if (pd_volt >= 5000 && pd_volt <= 20000) { // 电压范围：5V(5000mV)~20V(20000mV)
				rt_uint8_t volt_v = pd_volt / 1000; // 转成V（5000mV→5V）
				volt_hex = volt_v - 5; // 5V对应0，20V对应15（0xF）
			} else {
				#if NORTH_SINK_DEBUG
					rt_kprintf("AFC VOLT ERROR VOLT=:%d mV Set 5000~20000\n", pd_volt);
				#endif
				return -1;
			}

			// 2. 电流转HEX
			rt_uint8_t curr_hex = 0;
			if (pd_curr >= 750 && pd_curr <= 3000) { // 电流范围：0.75A(750mA)~3.0A(3000mA)
				rt_uint16_t curr_ma_step = (pd_curr - 750) / 150; // 步长150mA（0.75→1.5→...→3.0）
				curr_hex = curr_ma_step; // 0.75A对应0，3.0A对应15（0xF）
#if NORTH_SINK_DEBUG
				rt_kprintf("curr_ma_step = %d",curr_ma_step);
#endif
			} else {
			#if NORTH_SINK_DEBUG
				rt_kprintf("AFC CURR ERROR%d mA SET 750~3000 \n", pd_curr);
			#endif	
				return -1;
			}

			// 3. 合并电压Hex（高4位）和电流Hex（低4位）→ 填充第五字节
			buf[0] = (volt_hex << 4) | curr_hex;
#if NORTH_SINK_DEBUG
			rt_kprintf("type: AFC(0xF9), Voltage=%d V, Current=%.2f A, volaue=0x%X\n",
					pd_volt/1000, pd_curr/1000.0, buf[0]);
#endif
		}
		break;
        // 未知类型
        default:
//            rt_kprintf("Unknown fast charge type: %02X, Parameters cleared\n", pd_val);
            break;
    }

    return 0;
}

/*****************************************************************
函数名称： chrg_roll_nor_sw_uart
函数描述： 北向通道切换 sink/source 串口
输入参数： ch: 通道  id: sink/source
输出参数： -
返回说明： -
其它说明： -
*****************************************************************/
static void chrg_roll_nor_sw_uart (eIDX_NOR_CH ch, eIDX_ID id)
{
	if (ch >= TOTAL_NOR_CHS) {
		return ;
	}

	if (ID_SOURCE == id) {
		rt_pin_write(chrgios[sw_uart[ch]].base, PIN_HIGH);
	} else if (ID_SINK == id) {
		rt_pin_write(chrgios[sw_uart[ch]].base, PIN_LOW);
	}

}

/*****************************************************************
函数名称： chrg_roll_nor_sink_pro_set
函数描述： 根据当前负载协议参数组帧并下发负载协议设置命令
输入参数： pSW:当前通道控制结构体
输出参数： -
返回说明： >0:发送长度 <0:参数组帧或串口发送失败
其它说明： 本函数只负责发送，不修改pSW->sub，状态由有效回码确认后推进
*****************************************************************/
static int chrg_roll_nor_sink_pro_set(struct chrg_switch_t *pSW)
{
			rt_uint8_t buf[6] = {0};
			if (sink_fill_pd_buf(pSW->sink.Pro_Group, pSW->sink.protocol,
				pSW->sink.pro_loadv, pSW->sink.pro_loadc, buf) != 0) {
				return -1;
			}
#if NORTH_SINK_DEBUG
			rt_kprintf("set_pro\r\n");
#endif
			return sink_set_pd(pSW->sink.protocol, buf);
}

/*****************************************************************
函数名称： chrg_roll_nor_source_pro_set
函数描述： 根据当前电源协议参数组帧并下发电源协议设置命令
输入参数： pSW:当前通道控制结构体
输出参数： -
返回说明： >0:发送长度 <0:参数组帧或串口发送失败
其它说明： 本函数只负责发送，不修改pSW->sub，状态由有效回码确认后推进
*****************************************************************/
static int chrg_roll_nor_source_pro_set(struct chrg_switch_t *pSW)
{
	return source_set_pro(pSW->source.protocol, pSW);
}

/*****************************************************************
函数名称： chrg_roll_nor_expected_cmd
函数描述： 根据当前角色和sub状态取得本次北向请求期望的回码命令
输入参数： pSW:当前通道控制结构体
输出参数： -
返回说明： 非0:期望命令码 0:当前状态没有可识别的北向请求
其它说明： 必须在chrg_roll_nor_set发送命令前调用，确保保存的期望命令
          与实际发送命令一致
*****************************************************************/
static rt_uint8_t chrg_roll_nor_expected_cmd(const struct chrg_switch_t *pSW)
{
	if (pSW == RT_NULL) {
		return 0;
	}

	if (pSW->id == ID_SOURCE) {
		switch (pSW->sub) {
		case IDX_GET_SOURCE_VC:
			return SRC_CMD_GET_VOLTAGE;
		case IDX_GET_SOURCE_PD:
			return SRC_CMD_GET_PROTOCOL;
		case IDX_SET_SOURCE_PD:
			return SRC_CMD_SET_PROTOCOL;
		case IDX_SET_SOURCE_RESET:
			return SRC_CMD_RESET;
		case IDX_SET_SOURCE_CC_SET:
			return SRC_CMD_SET_CC_CHOOSE;
		case IDX_SET_SOURCE_CCLVL:
			return SRC_CMD_SET_CC_LEVEL;
		default:
			return 0;
		}
	}

	if (pSW->id == ID_SINK) {
		switch (pSW->sub) {
		case IDX_GET_SINK_VC:
			return SINK_CMD_GET_VOLTAGE;
		case IDX_GET_SINK_PD:
			return SINK_CMD_GET_PD;
		case IDX_SET_SINK_PD:
		case IDX_SET_SINK_PD_ONLY:
#if 0
		case IDX_SET_SINK_PD_BEFORE_CC:
#endif
			return pSW->sink.protocol;
		case IDX_SET_SINK_CCLINE:
		case IDX_SET_SINK_CC_BEFORE_PD:
			return SINK_CMD_SET_CC;
		case IDX_SET_SINK_CCLVL:
			return SINK_CMD_SET_LEVEL;
		default:
			return 0;
		}
	}

	return 0;
}

/*****************************************************************
函数名称： chrg_roll_nor_response_matches
函数描述： 校验北向回码与当前请求的通道角色、命令和固定长度是否匹配
输入参数： pMB:已通过north.c结构及CRC校验的回码 expected_idx:请求通道
          expected_id:请求角色 expected_cmd:请求命令
输出参数： -
返回说明： 0:回码匹配 <0:参数错误或回码与请求不匹配
其它说明： 本函数只判断请求归属，业务解析在配置版本复核通过后执行
*****************************************************************/
static int chrg_roll_nor_response_matches(const struct mb_msg_t *pMB,
	rt_uint8_t expected_idx, eIDX_ID expected_id, rt_uint8_t expected_cmd)
{
	if ((pMB == RT_NULL) || (pMB->payload == RT_NULL) ||
		(pMB->length < MIN_FRAME_LENGTH) ||
		(expected_idx >= TOTAL_NOR_CHS) || (expected_cmd == 0U)) {
		return -1;
	}

	if ((pMB->payload[2] != (rt_uint8_t)expected_id) ||
		(pMB->payload[3] != expected_cmd)) {
		LOG_W("north response mismatch: ch=%d id=%02x/%02x cmd=%02x/%02x",
			expected_idx + 1U, pMB->payload[2], expected_id,
			pMB->payload[3], expected_cmd);
		return -2;
	}

	if ((expected_cmd == SRC_CMD_GET_VOLTAGE) && (pMB->length != 21U)) {
		return -3;
	}
	if ((expected_cmd != SRC_CMD_GET_VOLTAGE) &&
		(expected_cmd != SRC_CMD_GET_PROTOCOL) &&
		(pMB->length != MIN_FRAME_LENGTH)) {
		return -4;
	}
	return 0;
}

/*****************************************************************
函数名称： chrg_roll_nor_free_response
函数描述： 释放北向邮箱回码及其payload
输入参数： pMB:待释放邮箱消息
输出参数： -
返回说明： -
其它说明： 统一匹配成功、失配和手动模式下的消息释放路径
*****************************************************************/
static void chrg_roll_nor_free_response(struct mb_msg_t *pMB)
{
	if (pMB == RT_NULL) {
		return;
	}
	if (pMB->payload != RT_NULL) {
		rt_free(pMB->payload);
	}
	rt_free(pMB);
}

/*****************************************************************
函数名称： chrg_roll_nor_drain_mailbox
函数描述： 非阻塞清理上一事务遗留在北向邮箱中的回码
输入参数： pTN:北向接收线程信息
输出参数： -
返回说明： -
其它说明： 必须在发送新请求前调用，避免旧回码被误认为本次请求回码
*****************************************************************/
static void chrg_roll_nor_drain_mailbox(struct chrg_thread_t *pTN)
{
	struct mb_msg_t *pMB = RT_NULL;

	if ((pTN == RT_NULL) || (pTN->mb == RT_NULL)) {
		return;
	}
	while (rt_mb_recv(pTN->mb, (rt_uint32_t *)&pMB, 0) == RT_EOK) {
		chrg_roll_nor_free_response(pMB);
		pMB = RT_NULL;
	}
}

/*****************************************************************
函数名称： chrg_roll_nor_wait_response
函数描述： 在统一截止时间内等待与当前角色和命令匹配的北向回码
输入参数： pTN:北向接收线程 expected_idx:请求通道 expected_id:请求角色
          expected_cmd:请求命令 matched_response:匹配回码输出指针
输出参数： matched_response返回匹配消息，所有权交给调用者
返回说明： 0:收到匹配回码 <0:参数错误或等待超时
其它说明： 不匹配但CRC正确的旧回码会释放，并继续等待至本次总超时
*****************************************************************/
static int chrg_roll_nor_wait_response(struct chrg_thread_t *pTN,
	rt_uint8_t expected_idx, eIDX_ID expected_id, rt_uint8_t expected_cmd,
	struct mb_msg_t **matched_response)
{
	rt_tick_t start_tick;
	rt_tick_t timeout_tick;
	rt_tick_t elapsed;
	rt_tick_t remaining;
	rt_err_t ret;
	struct mb_msg_t *pMB = RT_NULL;

	if ((pTN == RT_NULL) || (pTN->mb == RT_NULL) ||
		(matched_response == RT_NULL)) {
		return -1;
	}
	*matched_response = RT_NULL;
	start_tick = rt_tick_get();
	timeout_tick = rt_tick_from_millisecond(NORTH_RESPONSE_TIMEOUT_MS);

	while (1) {
		elapsed = (rt_tick_t)(rt_tick_get() - start_tick);
		if (elapsed >= timeout_tick) {
			return -1;
		}
		remaining = timeout_tick - elapsed;
		ret = rt_mb_recv(pTN->mb, (rt_uint32_t *)&pMB, remaining);
		if (ret != RT_EOK) {
			return -1;
		}
		if (pMB == RT_NULL) {
			continue;
		}

		if (chrg_roll_nor_response_matches(pMB, expected_idx,
			expected_id, expected_cmd) == 0) {
			*matched_response = pMB;
			return 0;
		}

		/* CRC正确但不属于本次请求的旧回码不能结束当前等待。 */
		chrg_roll_nor_free_response(pMB);
		pMB = RT_NULL;
	}
}
/*****************************************************************
函数名称： chrg_roll_nor_cmd
函数描述： 执行北向手动插入命令的入口检查
输入参数： pROLL:北向轮询控制结构体
输出参数： -
返回说明： 0:参数有效 <0:参数为空
其它说明： 当前仅保留入口，具体手动命令由后续功能扩展
*****************************************************************/
static int chrg_roll_nor_cmd (struct chrg_rollnor_t *pROLL)
{
	if (RT_NULL == pROLL) {
		return -1;
	}
	return 0;
}
/*****************************************************************
函数名称： chrg_roll_nor_set
函数描述： 按当前角色和sub状态发送一条北向协议命令
输入参数： ch:北向通道编号 pSW:通道控制结构体 next_sub:候选下一状态输出指针
输出参数： next_sub保存正确回码后应进入的状态，不直接修改pSW->sub
返回说明： >0:发送长度 <0:发送失败或状态不支持
	其它说明： Source按差异执行协议、CC或组合命令；涉及PD的运行中切换先发送CC_CLOSE；
	          停止状态启动和主动停止均不额外发送CC_CLOSE；
	          Sink完整握手依次执行协议设置、目标CC线选择、稳定等待和VC查询
*****************************************************************/
static int chrg_roll_nor_set(rt_uint8_t ch, struct chrg_switch_t *pSW,
	rt_uint8_t *next_sub)
{
	if ((pSW == RT_NULL) || (next_sub == RT_NULL)) {
		return -1;
	}
	*next_sub = pSW->sub;

	if(pSW->id==ID_SOURCE){ 			//电源
		chrg_roll_nor_sw_uart((eIDX_NOR_CH)ch, ID_SOURCE);
		switch(pSW->sub){		
			case IDX_SET_SOURCE_RESET:
				*next_sub = IDX_SET_SOURCE_PD;
				return source_reset();
			case IDX_SET_SOURCE_PD:
				*next_sub = IDX_WAIT_SOURCE_PROTOCOL;
				return chrg_roll_nor_source_pro_set(pSW);
			case IDX_SET_SOURCE_CC_SET:
				*next_sub = IDX_GET_SOURCE_VC;
				return source_set_cc_choose(pSW->source.CC_Set);
			case IDX_GET_SOURCE_VC:
				return source_get_vc(pSW->source.set_volt,
					pSW->source.set_curr);
			case IDX_GET_SOURCE_PD:
				*next_sub = IDX_GET_SOURCE_VC;
				return source_get_pd();
			default:
				return -1;
		}
	}
	else if (pSW->id == ID_SINK) {
		chrg_roll_nor_sw_uart((eIDX_NOR_CH)ch, ID_SINK);
			switch(pSW->sub){				
				case IDX_GET_SINK_VC:							//查询
					return sink_get_vc(pSW->sink.pro_loadv,
						pSW->sink.pro_loadc);
				case IDX_GET_SINK_PD:
					*next_sub = IDX_GET_SINK_VC;
					return sink_get_pd();
				case IDX_SET_SINK_CCLINE:							//CC线选择
					*next_sub = IDX_WAIT_SINK_CC;
					return sink_set_cc_line(pSW->sink.cc_set);
				case IDX_SET_SINK_CC_BEFORE_PD:
					*next_sub = IDX_WAIT_SINK_CC_BEFORE_PD;
					return sink_set_cc_line(pSW->sink.cc_set);
				case IDX_SET_SINK_CCLVL:							//CC电平
					return sink_set_cc_lvl(pSW->sink.cc_lvl);
				case IDX_SET_SINK_PD:
					/* 只有协议回码确认后，下一轮才允许进入电压查询。 */
					*next_sub = IDX_WAIT_SINK_PD_ACK;
					return chrg_roll_nor_sink_pro_set(pSW);
				case IDX_SET_SINK_PD_ONLY:
					*next_sub = IDX_WAIT_SINK_PD_ACK;
					return chrg_roll_nor_sink_pro_set(pSW);
#if 0
				case IDX_SET_SINK_PD_BEFORE_CC:
					/* 协议回码确认后再设置CC，不提前查询电压。 */
					*next_sub = IDX_SET_SINK_CCLINE;
					return chrg_roll_nor_sink_pro_set(pSW);
#endif
				default:
					return -1;
			}
	}

	return -1;
}

/*****************************************************************
函数名称： chrg_roll_nor_auto_request
函数描述： 执行一次自动北向请求事务，并在超时后有限次数重发
输入参数： idx:通道 pSW:通道状态 pTHR:轮询线程 pTN:北向接收线程
          pNOR:北向共享状态
输出参数： -
返回说明： 0:请求成功 1:等待期间COM配置变化，旧事务已取消 <0:重试后失败
其它说明： 匹配回码有效且配置版本未变化时解析量测值并提交next_sub；
          发送时不修改实时sub，CRC错误帧由north.c丢弃并表现为本次等待超时
*****************************************************************/
static int chrg_roll_nor_auto_request(rt_uint8_t idx,
	struct chrg_switch_t *pSW, struct chrg_thread_t *pTHR,
	struct chrg_thread_t *pTN, struct chrg_north_t *pNOR)
{
	rt_bool_t advance_sub = RT_TRUE;
	rt_uint8_t attempt;                  // 当前发送序号：0为首次，1~2为重发
	rt_uint8_t request_sub = 0;          // 本次请求实际使用的sub快照
	rt_uint8_t next_sub = 0;             // 正确回码后准备提交的候选sub
	rt_uint8_t expected_cmd = 0;         // 本次请求期望收到的命令码
	rt_uint8_t max_attempts;              // 本次请求允许的总发送次数
	eIDX_ID expected_id = ID_SINK;       // 本次请求发送时的角色快照
	rt_uint32_t request_version = 0;     // 本次请求发送时的COM配置版本
	int send_ret;                        // 当前命令的串口发送结果
	int wait_ret;                        // 当前命令的回码等待结果
	struct mb_msg_t *pMB = RT_NULL;      // 已匹配回码，处理后统一释放

	if ((idx >= TOTAL_NOR_CHS) || (pSW == RT_NULL) ||
		(pTHR == RT_NULL) || (pTN == RT_NULL) || (pNOR == RT_NULL)) {
		return -1;
	}

	/* 默认保留设置命令的3次发送；首轮取得实际命令码后，0x20会改为
	 * 单次发送并留给下一轮轮询重试，避免量测无回码时长期占用通道。 */
	max_attempts = NORTH_REQUEST_MAX_RETRIES + 1U;
	for (attempt = 0; attempt < max_attempts; attempt++) {
		rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
		if (attempt == 0U) {
			/* 首次发送固定请求状态，后续重发必须继续使用同一份请求上下文。 */
			request_sub = pSW->sub;
			expected_id = pSW->id;
			expected_cmd = chrg_roll_nor_expected_cmd(pSW);
			if (expected_cmd == SRC_CMD_GET_VOLTAGE) {
				max_attempts = NORTH_MEASURE_MAX_ATTEMPTS;
			}
			request_version = pNOR->config_version[idx];
			/* 新事务发送前清理已结束或已超时事务遗留的邮箱回码。 */
			chrg_roll_nor_drain_mailbox(pTN);
		} else if ((pNOR->config_version[idx] != request_version) ||
			(pSW->id != expected_id) || (pSW->sub != request_sub)) {
			/* COM或其它控制入口已修改配置，禁止继续重发旧命令。 */
			rt_mutex_release(pTHR->mutex);
			return 1;
		}

		if (expected_cmd == 0U) {
			rt_mutex_release(pTHR->mutex);
			return -1;
		}
		send_ret = chrg_roll_nor_set(idx, pSW, &next_sub);
		rt_mutex_release(pTHR->mutex);

		if (send_ret > 0) {
			wait_ret = chrg_roll_nor_wait_response(pTN, idx,
				expected_id, expected_cmd, &pMB);
			if ((wait_ret == 0) && (pMB != RT_NULL)) {
				rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
				if ((pNOR->config_version[idx] != request_version) ||
					(pSW->id != expected_id) || (pSW->sub != request_sub)) {
					/* 回码到达前配置已变化，该回码属于旧事务，只释放不解析。 */
					rt_mutex_release(pTHR->mutex);
					chrg_roll_nor_free_response(pMB);
					return 1;
				}

				/* 只有固定21字节的0x20量测回码需要进入Source/Sink业务解析。 */
				if ((expected_cmd == SRC_CMD_GET_VOLTAGE) &&
					(pMB->length == 21U)) {
					if (expected_id == ID_SOURCE) {
						(void)chrg_source_parse(pMB->payload,
							(eIDX_SOU_CH)idx, pSW, pNOR);
					} else {
						chrg_sink_parse(pMB->payload,
							(eIDX_SOU_CH)idx, pSW, pNOR);
					}
				}
				/* ID、命令、CRC和配置版本均确认有效后，才正式推进实时sub。 */
				if ((expected_id == ID_SOURCE) &&
					(request_sub == IDX_SET_SOURCE_RESET)) {
					/* 复位回码后重新执行Source INIT，初始化完成后再推进到PD。 */
					pSW->source.work_mode = SOURCE_WORK_INIT;
					advance_sub = RT_FALSE;
					/* INIT完成前保持当前sub，禁止通用逻辑提前推进到PD。 */
				} else if ((expected_id == ID_SOURCE) &&
					(request_sub == IDX_SET_SOURCE_PD)) {
					/* 0xD0应答后每通道独立等待100ms，再连接目标CC。 */
					chrg_roll_nor_source_protocol_wait_start(idx);
					chrg_comm_source_protocol_ack(idx,
						(rt_uint8_t)pSW->source.protocol);
				} else if ((expected_id == ID_SINK) &&
					((request_sub == IDX_SET_SINK_CCLINE) ||
					 (request_sub == IDX_SET_SINK_CC_BEFORE_PD))) {
					/* 北向Sink继电器保持接通，仅等待目标CC配置稳定。 */
					chrg_roll_nor_sink_cc_wait_start(idx);
				} else if ((expected_id == ID_SINK) &&
					(request_sub == IDX_SET_SINK_PD_ONLY)) {
					/* 仅重发协议时没有CC回码作为节流入口，直接启动200ms计时。 */
					chrg_roll_nor_sink_query_wait_start(idx);
				}
				/* 业务解析可能主动切换sub，例如掉电恢复后要求重新设置协议。
				 * 只有sub仍属于本次请求时，才应用请求函数计算出的next_sub。 */
				if (advance_sub && (pSW->sub == request_sub)) {
					pSW->sub = next_sub;
				}
				rt_mutex_release(pTHR->mutex);
				chrg_roll_nor_free_response(pMB);
				return 0;
			}
		}

		if ((attempt + 1U) < max_attempts) {
			/* 本次发送失败或等待超时，保持request_sub并准备重发同一命令。 */
			rt_thread_mdelay(NORTH_RETRY_INTERVAL_MS);
		}
	}

	LOG_W("north request failed: ch=%d id=%02x cmd=%02x sub=%d attempts=%d",
		idx + 1U, expected_id, expected_cmd, request_sub,
		max_attempts);
	return -1;
}

/*****************************************************************
函数名称： chrg_roll_nor_thread_entry
函数描述： 北向通道轮巡请求数据线程体
输入参数： *data: 本线程信息
输出参数： -
返回说明： -
其它说明： -
*****************************************************************/
void chrg_roll_nor_thread_entry (void *data)
{
	struct chrg_thread_t *pTHR = (struct chrg_thread_t *)data;

	if (RT_NULL == pTHR) {
		return ;
	}

	rt_uint8_t index = 0, idx = 0, i = 0;
	rt_uint8_t run = 0;
	rt_bool_t source_waiting = RT_FALSE;
	rt_bool_t sink_waiting = RT_FALSE;
	int state_work_ret = 0;
	rt_err_t ret = RT_EOK;
	struct chrg_rollnor_t *pROLL = &chrgrollnor;
	struct chrg_thread_t *pTN = &chrgthr[IDX_THR_NORTH];
	struct chrg_north_t *pNOR = &chrgnorth;
	struct chrg_switch_t *pSW = RT_NULL;
	struct mb_msg_t *pMB_R = RT_NULL;
	for (i = 0; i < TOTAL_NOR_CHS; i++) {
		chrg_roll_nor_sw_uart((eIDX_NOR_CH)i, ID_SINK);
	}
	while (1) {
    chrg_wdt_feed();
		rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
		run = pROLL->run;
		rt_mutex_release(pTHR->mutex);		
		switch (run) {
		case RUN_AUTO: {
			idx = index%TOTAL_NOR_CHS;
			pSW = &pNOR->sw[idx];
			source_waiting = RT_FALSE;
			sink_waiting = RT_FALSE;
			state_work_ret = 0;
			rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
			/*
			 * INIT/STOP必须在enable过滤前执行：STOP会把enable清零，而COM
			 * 启动时只改变work_mode。若先判断enable，停机通道会直接continue，
			 * INIT永远没有机会把enable重新置1，也就无法恢复北向轮询。
			 * Source->Sink切换后的SINK_WORK_INIT同样从这里首次执行。
			 */
			if ((pSW->id == ID_SOURCE) &&
				((pSW->source.work_mode == SOURCE_WORK_INIT) ||
				 (pSW->source.work_mode == SOURCE_WORK_STOP) ||
				 (pSW->source.work_mode == SOURCE_WORK_PROTOCOL_SWITCH) ||
				 (pSW->source.work_mode == SOURCE_WORK_FULL_RESET) ||
				 (pSW->source.work_mode == SOURCE_WORK_FULL_RESET_WAIT) ||
				 (pSW->source.work_mode == SOURCE_WORK_FULL_RESET_RELAY) ||
				 (pSW->source.work_mode == SOURCE_WORK_FULL_RESET_RELAY_WAIT) ||
				 (pSW->source.work_mode == SOURCE_WORK_INIT_WAIT))) {
				state_work_ret = chrg_source_work_state(idx, pSW);
			} else if ((pSW->id == ID_SINK) &&
				((pSW->sink.work_mode == SINK_WORK_INIT) ||
				 (pSW->sink.work_mode == SINK_WORK_INIT_AUX_WAIT) ||
				 (pSW->sink.work_mode == SINK_WORK_UNLOAD_WAIT) ||
				 (pSW->sink.work_mode == SINK_WORK_LOW) ||
					 (pSW->sink.work_mode == SINK_WORK_LOW_AUX_WAIT) ||
					 (pSW->sink.work_mode == SINK_WORK_HANDSHAKE_PREPARE) ||
					 (pSW->sink.work_mode == SINK_WORK_HANDSHAKE_WAIT) ||
					 (pSW->sink.work_mode == SINK_WORK_STOP_WAIT) ||
					 (pSW->sink.work_mode == SINK_WORK_STOP_RELAY) ||
					 (pSW->sink.work_mode == SINK_WORK_STOP_RELAY_WAIT))) {
				state_work_ret = chrg_sink_work((eIDX_SOU_CH)idx, pSW);
			}
			/*
			 * 协议切换等待只推进时间状态，不发送串口命令。该检查位于enable
			 * 过滤前，使停止或角色切换后的通道也能及时清理残留事务记录。
			 */
			source_waiting = chrg_roll_nor_source_wait_process(idx, pSW);
			sink_waiting = chrg_roll_nor_sink_wait_process(idx, pSW);
			rt_mutex_release(pTHR->mutex);
			if (state_work_ret != 0) {
				/* 南向状态动作未成功入队时保留原状态，下轮重试且禁止北向先行。 */
				index++;
				rt_thread_mdelay(2);
				continue;
			}
			if (source_waiting || sink_waiting) {
				index++;
				rt_thread_mdelay(2);
				continue;
			}
			if (0 == pNOR->enable[idx]) {
				index++;
				rt_thread_mdelay(2);
				continue;
			} else {
				chrg_led_flashing(IDX_LED2, TIMES_ONE, PULSE_TIME*2, PULSE_TIME*2);
				chrg_north_switch((eIDX_NOR_CH)idx);
				chrgnorth.idx = idx;
				pROLL->idx = idx;
				(void)chrg_roll_nor_auto_request(idx, pSW,
					pTHR, pTN, pNOR);
			}
			index++;
			rt_thread_mdelay(NORTH_POLL_INTERVAL_MS);
			continue;
		}
		break;

		case RUN_LCD: {
			chrg_roll_nor_cmd(pROLL);
		}
		break;
		case RUN_CONSOLE: {
			chrg_roll_nor_cmd(pROLL);
		}
		break;
		case RUN_COM:
//		{
//			chrg_roll_nor_cmd(pROLL);
//		}
		break;
		case RUN_NONE:
		default:
			rt_thread_mdelay(5);
			continue;
		break;
		}

		ret = rt_mb_recv(pTN->mb, (rt_uint32_t *)&pMB_R, 50); // 1kHz tick下超时约50ms
		if ((RT_EOK == ret)&&(RT_NULL != pMB_R)) {	// 存在返回数据
			/* north.c只会向邮箱提交已经通过结构和CRC校验的完整帧。 */
			if (RUN_AUTO != run) {	// 恢复自动轮巡
				rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
				pROLL->run = RUN_AUTO;
				rt_mutex_release(pTHR->mutex);
			}

			chrg_roll_nor_free_response(pMB_R);
			pMB_R = RT_NULL;

			rt_thread_mdelay(10);	// 相邻北向请求间隔50ms
		} else {
			if (RUN_AUTO != run) {			// 非自动轮巡
				rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
//todo				
				pROLL->run = RUN_AUTO;		// 切换会自动轮巡
				rt_mutex_release(pTHR->mutex);
			}
		}
	}
}

#if 1


static int sink (int argc, char **argv)
{
	int ret = 0;
	if (argc < 4) {
		rt_kprintf("help : %s get|set [0-3] vc|pd|ccline|cclvl <data>\r\n", argv[0]);
		return -1;
	}

	int gset = 0;
	struct chrg_rollnor_t *pROLL = &chrgrollnor;

	if (strcmp(argv[1], "get") == 0) {
		gset = 0;
	} else if (strcmp(argv[1], "set") == 0) {
		gset = 1;
	} else {
		rt_kprintf("help : %s get|set [0-3] vc|pd|ccline|cclvl <data>\r\n", argv[0]);
		return -1;
	}

	rt_uint8_t ch = (rt_uint8_t)atoi(argv[2]);
	if ((ch < 0)||(ch >= TOTAL_NOR_CHS)) {
		rt_kprintf("help : %s get|set [0-3] vc|pd|ccline|cclvl <data>\r\n", argv[0]);
		return -1;
	}

	if (strcmp(argv[3], "vc") == 0) {
		if (0 == gset) {
			pROLL->sub = IDX_SET_SINK_WORK_STATE;
		} else {
			ret = -1;
			rt_kprintf("sink vc can't set.\r\n");
			return -1;
		}
	} else if (strcmp(argv[3], "pd") == 0) {
		if (0 == gset) {
			pROLL->sub = IDX_GET_SINK_PD;
		} else {
			//长度
			if (argc != 5) {
				rt_kprintf("help : %s set 0-3 ccline 0-3.\r\n", argv[0]);
				return -1;
				// sink_set_pd
			} else { // sink set 0 pd 0
				int type = atoi(argv[4]);
				pROLL->pd = (rt_uint8_t)type;
				pROLL->sub = IDX_SET_SINK_PD;				
			}
		}
	} else if (strcmp(argv[3], "ccline") == 0) {
		if (1 == gset) {
			if (argc != 5) {
				rt_kprintf("help : %s set 0-3 ccline 0-3.\r\n", argv[0]);
				return -1;
			} else {	// sink set 0 ccline 0-3
				int line = atoi(argv[4]);
				if ((line >= 0)&&(line <= 3)) {
					pROLL->sub = IDX_SET_SINK_CCLINE;
					pROLL->cc_line = (rt_uint8_t)line;
				} else {
					rt_kprintf("help : %s set 0-3 ccline 0-3.\r\n", argv[0]);
					return -1;
				}
			}
		} else {
			ret = -1;
			rt_kprintf("sink cc line can't get.\r\n");
		}
	} else if (strcmp(argv[3], "cclvl") == 0) {
		if (1 == gset) {
			if (argc != 5) {
				rt_kprintf("help : %s set 0-3 cclvl 0-3.\r\n", argv[0]);
				return -1;
			} else {	// sink set 0 cclvl 0-3
				int line = atoi(argv[4]);
				if ((line >= 0)&&(line <= 3)) {
					pROLL->sub = IDX_SET_SINK_CCLVL;
					pROLL->cc_line = (rt_uint8_t)line;
				} else {
					rt_kprintf("help : %s set 0-3 cclvl 0-3.\r\n", argv[0]);
					return -1;
				}
			}
		} else {
			ret = -1;
			rt_kprintf("sink cc level can't get.\r\n");
		}
	} else {
		ret = -1;
	}

	if (0 == ret) {
		pROLL->ch = ch;
		pROLL->type = 0; // sink
		pROLL->run = RUN_CONSOLE;
	} else {
		rt_kprintf("help : %s get|set [0-3] vc|pd|ccline|cclvl\r\n", argv[0]);
	}

	return ret;
}

MSH_CMD_EXPORT(sink, north sink test);

static int source (int argc, char **argv)
{
	int ret = 0;
	if (argc < 4) {
		rt_kprintf("help : %s get|set [0-3] vc|pd|cclvl <data>\r\n", argv[0]);
		return -1;
	}

	int gset = 0;
	struct chrg_rollnor_t *pROLL = &chrgrollnor;

	if (strcmp(argv[1], "get") == 0) {
		gset = 0;
	} else if (strcmp(argv[1], "set") == 0) {
		gset = 1;
	} else {
		rt_kprintf("help : %s get|set [0-3] vc|pd|cclvl <data>\r\n", argv[0]);
		return -1;
	}

	rt_uint8_t ch = (rt_uint8_t)atoi(argv[2]);
	if ((ch < 0)||(ch >= TOTAL_NOR_CHS)) {
		rt_kprintf("help : %s get|set [0-3] vc|pd|cclvl <data>\r\n", argv[0]);
		return -1;
	}

	if (strcmp(argv[3], "vc") == 0) {
		if (0 == gset) {
			pROLL->sub = IDX_GET_SOURCE_VC;
		} else {
			ret = -1;
			rt_kprintf("sink vc can't set.\r\n");
			return -1;
		}
	} else if (strcmp(argv[3], "pd") == 0) {
		if (0 == gset) {
			pROLL->sub = IDX_GET_SOURCE_PD;
		} else {
			if (argc != 5) {
			//if (argc != 5) {
				rt_kprintf("help : %s set 0-3 pd 0-.\r\n", argv[0]);
				return -1;
				// sink_set_pd
			} else { // sink set 0 pd 0
				int type = atoi(argv[4]);
				//协议
				pROLL->pd = (rt_uint8_t)type;
				//子命令
				pROLL->sub = IDX_SET_SOURCE_PD;				
			}
		}
	} else if (strcmp(argv[3], "cclvl") == 0) {
		if (1 == gset) {
			if (argc != 5) {
				rt_kprintf("help : %s set 0-3 cclvl 0-3.\r\n", argv[0]);
				return -1;
			} else {	// sink set 0 cclvl 0-3
				int line = atoi(argv[4]);
				if ((line >= 0)&&(line <= 3)) {
					pROLL->sub = IDX_SET_SOURCE_CCLVL;
					pROLL->cc_line = (rt_uint8_t)line;
				} else {
					rt_kprintf("help : %s set 0-3 cclvl 0-3.\r\n", argv[0]);
					return -1;
				}
			}
		} else {
			ret = -1;
			rt_kprintf("sink cc level can't get.\r\n");
		}
	} else {
		ret = -1;
	}

	if (0 == ret) {
		pROLL->ch = ch;
		pROLL->type = 1; // source
		pROLL->run = RUN_CONSOLE;
	} else {
		rt_kprintf("help : %s get|set [0-3] vc|pd|cclvl\r\n", argv[0]);
	}

	return ret;
}

MSH_CMD_EXPORT(source, north source test);

#endif