nor / sou roll

apps/chrg/applications/thread/chrg_lcd.c

@@ -76,10 +76,10 @@ static int chrg_lcd_parse (rt_uint8_t *recv, rt_uint16_t len)
 		pSW = &pNOR->sw[ch];
 		if (1 == recv[LCD_IDX_VAL]) {
 			pSW->id = ID_SOURCE;
-			chrg_set_sou_mode((eIDX_SOU_CH)ch, REG_ELOAD, ELOAD_SOURCE);
+			chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_ELOAD, ELOAD_SOURCE);
 		} else {
 			pSW->id = ID_SINK;
-			chrg_set_sou_mode((eIDX_SOU_CH)ch, REG_ELOAD, ELOAD_LOAD);
+			chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_ELOAD, ELOAD_LOAD);
 		}
 	}
 	break;
@@ -94,9 +94,9 @@ static int chrg_lcd_parse (rt_uint8_t *recv, rt_uint16_t len)
 		if (Flag_R3 == 1 && ch == 2) return 0;
 		if (Flag_R4 == 1 && ch == 3) return 0;
 		if (1 == recv[LCD_IDX_VAL]) {
-			chrg_set_sou_mode((eIDX_SOU_CH)ch, REG_MODE, MODE_CONSTANT_VOLTAGE);
+			chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_MODE, MODE_CONSTANT_VOLTAGE);
 		} else {
-			chrg_set_sou_mode((eIDX_SOU_CH)ch, REG_MODE, MODE_CONSTANT_CURRENT);
+			chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_MODE, MODE_CONSTANT_CURRENT);
 		}
 	}
 	break;
@@ -115,7 +115,7 @@ static int chrg_lcd_parse (rt_uint8_t *recv, rt_uint16_t len)
 					case 2: Flag_R3 = 1; break;
 					case 3: Flag_R4 = 1; break;
 			}
-			chrg_set_sou_mode((eIDX_SOU_CH)ch, REG_WORK,WORK_START);
+			chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_WORK, WORK_START);
 		} else {
 			//pNOR->enable[ch] = 1;
 			//pSOU->enable[ch] = 1;
@@ -125,7 +125,7 @@ static int chrg_lcd_parse (rt_uint8_t *recv, rt_uint16_t len)
 					case 2: Flag_R3 = 0; break;
 					case 3: Flag_R4 = 0; break;
 			}
-			chrg_set_sou_mode((eIDX_SOU_CH)ch, REG_WORK,WORK_STOP);
+			chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_WORK, WORK_STOP);
 		}
 
 	}
@@ -138,7 +138,7 @@ static int chrg_lcd_parse (rt_uint8_t *recv, rt_uint16_t len)
 		ch = recv[LCD_IDX_CMD] - 0x51;
 		Recv_Data = recv[LCD_IDX_VAL+1]<<8|recv[LCD_IDX_VAL];//get lower Reg_Data
 		//Recv_Data = swap_u16(Recv_Data);
-		chrg_set_sou_mode((eIDX_SOU_CH)ch, REG_VOLTAGE_OUT+1,Recv_Data);//plus 1，set voltage lower REG
+		chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_VOLTAGE_OUT+1, Recv_Data);//plus 1，set voltage lower REG
 	}
 	break;
 	case 0x61:
@@ -148,7 +148,7 @@ static int chrg_lcd_parse (rt_uint8_t *recv, rt_uint16_t len)
 		ch = recv[LCD_IDX_CMD] - 0x61;
 		Recv_Data = recv[LCD_IDX_VAL+1]<<8|recv[LCD_IDX_VAL];//get lower Reg_Data
 		//Recv_Data = swap_u16(Recv_Data);
-		chrg_set_sou_mode((eIDX_SOU_CH)ch, REG_CURRENT_OUT+1,Recv_Data);//plus 1，set current lower REG
+		chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_CURRENT_OUT+1,Recv_Data);//plus 1，set current lower REG
 	break;
 	}
 

apps/chrg/applications/thread/chrg_north.c

@@ -41,7 +41,7 @@ struct chrg_north_t chrgnorth = {
 	.sw[IDX_NOR_CH4] = {
 		.id = ID_SINK,
 	},
-	.manual = MANU_AUTO,
+
 };
 
 /*****************************************************************

apps/chrg/applications/thread/chrg_roll_nor.c

@@ -24,8 +24,6 @@
 #define LOG_TAG "chrg.rollnor"
 #include <rtdbg.h>
 
-rt_uint8_t nor_run = 1;
-rt_uint8_t nor_ch = IDX_NOR_CH1;
 
 const rt_base_t sw_uart[TOTAL_NOR_CHS] = {
 	IDX_GPO_UART_SW1,
@@ -34,6 +32,12 @@ const rt_base_t sw_uart[TOTAL_NOR_CHS] = {
 	IDX_GPO_UART_SW4
 };
 
+struct chrg_rollnor_t chrgrollnor = {
+	.run = RUN_AUTO,
+	.ch = IDX_NOR_CH1,
+	
+};
+
 /*****************************************************************
 函数名称： chrg_roll_nor_sw_uart
 函数描述： 北向通道切换 sink/source 串口
@@ -56,6 +60,154 @@ static void chrg_roll_nor_sw_uart (eIDX_NOR_CH ch, eIDX_ID id)
 
 }
 
+static int chrg_roll_nor_cmd (struct chrg_rollnor_t *pROLL)
+{
+	if (RT_NULL == pROLL) {
+		return -1;
+	}
+
+	chrg_north_switch((eIDX_NOR_CH)pROLL->ch);
+
+	if (1 == pROLL->type) {
+		chrg_roll_nor_sw_uart((eIDX_NOR_CH)pROLL->ch, ID_SOURCE);
+
+		switch (pROLL->sub) {
+		case IDX_GET_SOURCE_VC: {
+			source_get_vc(5000, 1000);
+		}
+		break;
+
+		case IDX_GET_SOURCE_PD: {
+			source_get_pd();
+		}
+		break;
+
+		case IDX_SET_SOURCE_PD: {
+			source_set_pd(pROLL->pd, pROLL->src, pROLL->pps, 
+				pROLL->max_vol, pROLL->min_vol, pROLL->max_curr);
+		}
+		break;
+
+		case IDX_SET_SOURCE_CCLVL: {
+			source_set_cc_lvl(pROLL->cc_level);
+		}
+		break;
+
+		default:
+			return -1;
+		break;
+		}
+	} else if (0 == pROLL->type) {
+		chrg_roll_nor_sw_uart((eIDX_NOR_CH)pROLL->ch, ID_SINK);
+
+		switch (pROLL->sub) {
+		case IDX_GET_SINK_VC: {
+			sink_get_vc(pROLL->voltage, pROLL->current);
+		}
+		break;
+
+		case IDX_GET_SINK_PD: {
+			sink_get_pd();
+		}
+		break;
+
+		case IDX_SET_SINK_PD: {
+			rt_uint8_t buf[5] = {0};
+			sink_set_pd(pROLL->pd, buf);
+		}
+		break;
+
+		case IDX_SET_SINK_CCLINE: {
+			sink_set_cc_line(pROLL->cc_line);
+		}
+		break;
+
+		case IDX_SET_SINK_CCLVL: {
+			sink_set_cc_lvl(pROLL->cc_level);
+		}
+		break;
+
+		default:
+			return -1;
+		}
+	} else {
+		return -1;
+	}
+
+	return 0;
+}
+
+static int chrg_roll_nor_parse (struct chrg_rollnor_t *pROLL, rt_uint8_t *data)
+{
+	if ((RT_NULL == pROLL)||(RT_NULL == data)) {
+		return -1;
+	}
+
+	if (1 == pROLL->type) {
+		switch (pROLL->sub) {
+		case IDX_GET_SOURCE_VC: {
+
+		}
+		break;
+
+		case IDX_GET_SOURCE_PD: {
+
+		}
+		break;
+
+		case IDX_SET_SOURCE_PD: {
+
+		}
+		break;
+
+		case IDX_SET_SOURCE_CCLVL: {
+
+		}
+		break;
+
+		default:
+			return -1;
+		break;
+		}
+
+	} else if (0 == pROLL->type) {
+		switch (pROLL->sub) {
+		case IDX_GET_SINK_VC: {
+
+		}
+		break;
+
+		case IDX_GET_SINK_PD: {
+
+		}
+		break;
+
+		case IDX_SET_SINK_PD: {
+
+		}
+		break;
+
+		case IDX_SET_SINK_CCLINE: {
+
+		}
+		break;
+
+		case IDX_SET_SINK_CCLVL: {
+
+		}
+		break;
+
+		default:
+			return -1;
+		}
+	} else {
+		return -1;
+	}
+
+	return 0;
+}
+
+
 /*****************************************************************
 函数名称： chrg_roll_nor_thread_entry
 函数描述： 北向通道轮巡请求数据线程体
@@ -72,9 +224,10 @@ void chrg_roll_nor_thread_entry (void *data)
 		return ;
 	}
 
-	rt_uint8_t idx = 0, i = 0, manu = 0;
+	rt_uint8_t index = 0, idx = 0, i = 0;
-	rt_uint8_t crc = 0;
+	rt_uint8_t run = 0, crc = 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;
@@ -86,55 +239,68 @@ void chrg_roll_nor_thread_entry (void *data)
 
 	while (1) {
 		rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
-		manu = pNOR->manual;
+		run = pROLL->run;
 		rt_mutex_release(pTHR->mutex);
 
-		if (MANU_CMD == manu) {
+		switch (run) {
-			chrg_north_switch((eIDX_NOR_CH)nor_ch);
+		case RUN_AUTO: {
-			source_get_vc(5000, 1000);
+			idx = index%TOTAL_NOR_CHS;
-		} else {
-			if (0 == nor_run) {
-				rt_thread_mdelay(1000);
-				continue;
-			}
 
-			pNOR->idx = idx%TOTAL_NOR_CHS;
+			if (0 == pNOR->enable[idx]) {
-
+				index++;
-			if (0 == pNOR->enable[pNOR->idx]) {
+				rt_thread_mdelay(10);
-				idx++;
-				rt_thread_mdelay(1);
 				continue;
 			} else {
 				chrg_led_flashing(IDX_LED2, TIMES_ONE, PULSE_TIME*2, PULSE_TIME*2);
-				chrg_north_switch(pNOR->idx);
+				chrg_north_switch((eIDX_NOR_CH)idx);
 
-				pSW = &pNOR->sw[pNOR->idx];
+				pROLL->idx = idx;
+				pSW = &pNOR->sw[idx];
 				if (ID_SOURCE == pSW->id) {
-					chrg_roll_nor_sw_uart(pNOR->idx, ID_SOURCE);
+					chrg_roll_nor_sw_uart((eIDX_NOR_CH)idx, ID_SOURCE);
 					source_get_vc(pSW->source.voltage, pSW->source.current);
 				} else if (ID_SINK == pSW->id) {
-					chrg_roll_nor_sw_uart(pNOR->idx, ID_SINK);
+					chrg_roll_nor_sw_uart((eIDX_NOR_CH)idx, ID_SINK);
 					sink_get_vc(pSW->sink.loadv, pSW->sink.loadc);
 				}
 
-				//rt_kprintf("Nor[%d].%d\r\n", pNOR->idx, pSW->id);
+				//rt_kprintf("Nor[%d].%d\r\n", idx, pSW->id);
 			}
 
-			idx++;
+			index++;
+		}
+		break;
+
+		case RUN_LCD: {
+			chrg_roll_nor_cmd(pROLL);
+		}
+		break;
+
+		case RUN_CONSOLE: {
+			chrg_roll_nor_cmd(pROLL);
+		}
+		break;
+
+		case RUN_NONE:
+		default:
+			rt_thread_mdelay(100);
+			continue;
+		break;
 		}
 
 		ret = rt_mb_recv(pTN->mb, (rt_uint32_t *)&pMB_R, 200); // 超时 200ms
-		if ((RT_EOK == ret)&&(RT_NULL != pMB_R)) {
+		if ((RT_EOK == ret)&&(RT_NULL != pMB_R)) {	// 存在返回数据
 			crc = calc_crc8(pMB_R->payload, pMB_R->length-1);
-			if (crc == pMB_R->payload[pMB_R->length-1]) {
+			if (crc == pMB_R->payload[pMB_R->length-1]) { // 数据正确
-				if (MANU_AUTO != manu) {
+				if (RUN_AUTO != run) {	// 恢复自动轮巡
 					rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
-					pNOR->manual = MANU_AUTO;
+					pROLL->run = RUN_AUTO;
 					rt_mutex_release(pTHR->mutex);
 				} else {
-					// todo
+					chrg_roll_nor_parse(pROLL, pMB_R->payload);
-
 				}
+			} else {
+				LOG_E("crc failed.");
 			}
 
 			if (RT_NULL != pMB_R->payload) {
@@ -149,9 +315,11 @@ void chrg_roll_nor_thread_entry (void *data)
 
 			rt_thread_mdelay(200);	// 间隔 200ms
 		} else {
-			rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
+			if (RUN_AUTO != run) {			// 非自动轮巡
-			pNOR->manual = MANU_AUTO;
+				rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
-			rt_mutex_release(pTHR->mutex);
+				pROLL->run = RUN_AUTO;		// 切换会自动轮巡
+				rt_mutex_release(pTHR->mutex);
+			}
 		}
 
 	}
@@ -159,29 +327,192 @@ void chrg_roll_nor_thread_entry (void *data)
 }
 
 #if 1
-static int north_send(rt_uint8_t argc, char **argv)
+
+
+static int sink (int argc, char **argv)
 {
-	struct chrg_north_t *pNOR = &chrgnorth;
+	int ret = 0;
-	int ch = 0;
+	if (argc < 4) {
-
+		rt_kprintf("help : %s get|set [0-3] vc|pd|ccline|cclvl <data>\r\n", argv[0]);
-	if (2 != argc) {
-		rt_kprintf("help : %s [0-3]\r\n", argv[0]);
 		return -1;
 	}
 
-	ch = (rt_uint8_t)atoi(argv[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 [0-3]\r\n", argv[0]);
+		rt_kprintf("help : %s get|set [0-3] vc|pd|ccline|cclvl <data>\r\n", argv[0]);
 		return -1;
 	}
 
-	nor_ch = (rt_uint8_t)ch;
+	if (strcmp(argv[3], "vc") == 0) {
-	pNOR->manual = MANU_CMD;
+		if (0 == gset) {
+			pROLL->sub = IDX_GET_SINK_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_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;
+	}
 
-	return 0;
+	if (0 == ret) {
+		pROLL->ch = ch;
+		pROLL->type = 0; // sink
+	} else {
+		rt_kprintf("help : %s get|set [0-3] vc|pd|ccline|cclvl\r\n", argv[0]);
+	}
+
+	return ret;
 }
 
-MSH_CMD_EXPORT(north_send, north send test);
+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) {
+				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
+	} 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);
 
 static int north_run (int argc, char **argv)
 {
@@ -190,10 +521,12 @@ static int north_run (int argc, char **argv)
 		return -1;
 	}
 
+	struct chrg_rollnor_t *pROLL = &chrgrollnor;
+
 	if (rt_strcmp(argv[1], "start") == 0) {
-		nor_run = 1;
+		pROLL->run = RUN_AUTO;
 	} else if (rt_strcmp(argv[1], "stop") == 0) {
-		nor_run = 0;
+		pROLL->run = RUN_NONE;
 	} else {
 		rt_kprintf("help : %s start|stop\r\n", argv[0]);
 		return -1;

apps/chrg/applications/thread/chrg_roll_nor.h

@@ -14,8 +14,46 @@
 
 #define THR_NAME_ROLL_NOR		"thr.rollnor"
 
-extern rt_uint8_t nor_run;
+
-extern rt_uint8_t nor_ch;
+enum {
+	IDX_GET_SOURCE_VC = 0,
+	IDX_GET_SOURCE_PD,
+	IDX_SET_SOURCE_PD,
+	IDX_SET_SOURCE_CCLVL,
+
+	IDX_GET_SINK_VC,
+	IDX_GET_SINK_PD,
+	IDX_SET_SINK_PD,
+	IDX_SET_SINK_CCLINE,
+	IDX_SET_SINK_CCLVL,
+};
+
+struct chrg_rollnor_t {
+	rt_uint8_t		run;		// 下一轮运行方式 1:自动轮巡 2:LCD触发插入 3:控制台触发插入
+	rt_uint8_t		part;		// 自动轮巡时，多条命令序号（若存在多条命令时）
+
+	rt_uint8_t		idx;		// 自动轮巡时，通道序号
+	rt_uint8_t		ch;			// 触发插入时，切换的通道
+	rt_uint8_t		type;		// 1=source/0=sink
+	rt_uint8_t		sub;		// 子类型
+
+	rt_uint8_t		cc_line;	// cc 线
+	rt_uint8_t		cc_level;	// cc 电平
+	rt_uint8_t		pd;
+	rt_uint8_t		src;
+	rt_uint8_t		pps;
+	rt_uint16_t		voltage;	// 触发插入时，当前电压 mV
+	rt_uint16_t		current;	// 触发插入时，当前电流 mA
+
+
+	rt_uint16_t		max_vol;	// 触发插入时，最大电压 mV
+	rt_uint16_t		min_vol;	// 触发插入时，最小电压 mV
+	rt_uint16_t		max_curr;	// 触发插入时，最大电流 mA
+
+
+};
+
+extern struct chrg_rollnor_t chrgrollnor;
 
 /*****************************************************************
 函数名称： chrg_roll_nor_thread_entry

apps/chrg/applications/thread/chrg_roll_sou.c

@@ -11,6 +11,7 @@
 #include <string.h>
 #include <rtthread.h>
 
+#include "chrg_def.h"
 #include "chrg_led.h"
 #include "chrg_thread.h"
 #include "chrg_roll_sou.h"
@@ -20,31 +21,33 @@
 #define LOG_TAG "chrg.rollsou"
 #include <rtdbg.h>
 
-rt_uint8_t sou_run = 1;
+struct chrg_rollsou_t chrgrollsou = {
-rt_uint8_t sou_ch = IDX_SOU_CH1;
+	.run = RUN_AUTO,
-rt_uint8_t sou_pt = MB_R_PART1;
+	.ch = IDX_SOU_CH1,
-rt_uint8_t sou_mode = 0;
+	.part = MB_R_PART1,
-rt_uint8_t sou_reg = 0;
+	
-rt_uint16_t sou_mode_value = 0;
+};
+
 
 /*****************************************************************
-函数名称： chrg_set_sou_mode
+函数名称： chrg_set_sou_reg
-函数描述： 南向通道插入设置请求命令
+函数描述： 南向通道设置寄存器请求命令
-输入参数： idx:通道 mode:设置模式
+输入参数： idx:通道 reg:寄存器地址 value:寄存器值
 输出参数： -
 返回说明： -
 其它说明： -
 *****************************************************************/
-void chrg_set_sou_mode (eIDX_SOU_CH idx,rt_uint8_t reg, rt_uint16_t mode_value)
+void chrg_set_sou_reg (eIDX_SOU_CH idx, rt_uint16_t reg, rt_uint16_t value)
 {
 	struct chrg_thread_t *pTHR = &chrgthr[IDX_THR_ROLL_SOU];
-	struct chrg_south_t *pSOU = &chrgsouth;
+	struct chrg_rollsou_t *pROLL = &chrgrollsou;
-	sou_run = 0;
+
-	sou_ch = idx;
+	pROLL->ch = idx;
-	sou_reg = reg;
+	pROLL->reg = reg;
-	sou_mode_value = mode_value;
+	pROLL->value = value;
+
 	rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
-	pSOU->manual = MANU_INSERT;
+	pROLL->run = RUN_LCD;
 	rt_mutex_release(pTHR->mutex);
 }
 
@@ -64,62 +67,75 @@ void chrg_roll_sou_thread_entry (void *data)
 		return ;
 	}
 
-	rt_uint8_t index = 0, idx = 0, pt = 0, manu = 0;
+	rt_uint8_t run = 0;
+	rt_uint8_t index = 0, idx = 0;
 	rt_err_t ret = RT_EOK;
-	struct chrg_south_t *pSOU = &chrgsouth;
+	struct chrg_rollsou_t *pROLL = &chrgrollsou;
 	struct chrg_thread_t *pTS = &chrgthr[IDX_THR_SOUTH];
 	struct mb_msg_t *pMB_R = RT_NULL;
 
 	while (1) {
 		rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
-		manu = pSOU->manual;
+		run = pROLL->run;
 		rt_mutex_release(pTHR->mutex);
 
-		if (MANU_CMD == manu) {
+		switch (run) {
-			chrg_south_switch((eIDX_SOU_CH)sou_ch);
+		case RUN_AUTO: {
-			pt = sou_pt;
-			chrg_eload_refresh(ID_ELOAD, sou_pt);
-		} else if (MANU_INSERT == manu) {
-			chrg_south_switch((eIDX_SOU_CH)sou_ch);
-			chrg_eload_write_reg(ID_ELOAD, sou_reg, sou_mode_value);
-
-		} else { // 轮巡4个通道
-			if (0 == sou_run) {
-				rt_thread_mdelay(1000);
-				continue;
-			}
-
 			idx = index%(TOTAL_SOU_CHS); // [0, 3]
 
-			if (0 == pSOU->enable[idx]) {
+			if (0 == chrgsouth.enable[idx]) {	// 通道未启用
-				pSOU->idx = (eIDX_SOU_CH)idx;
 				index++;
 				rt_thread_mdelay(10);
 				continue;
-			} else {
+			} else {						// 通道启用
 				chrg_led_flashing(IDX_LED3, TIMES_ONE, PULSE_TIME*2, PULSE_TIME*2);
-				if (idx != (rt_uint8_t)pSOU->idx) {
+				if (idx != (rt_uint8_t)pROLL->idx) {
-					pSOU->idx = (eIDX_SOU_CH)idx;
+					pROLL->idx = (eIDX_SOU_CH)idx;
-					chrg_south_switch(pSOU->idx);
+					chrg_south_switch((eIDX_SOU_CH)idx);
+					pROLL->part = MB_R_PART1;
 				}
 
-				pt = MB_R_PART1;
+				chrg_eload_refresh(ID_ELOAD, pROLL->part);
-				chrg_eload_refresh(ID_ELOAD, MB_R_PART1);
+				if (pROLL->part < TOTAL_MB_R) {
+					pROLL->part++;
+					if (pROLL->part > MB_R_PART1) { // 仅1条，若需轮巡全部，注释此条件
+						index++;
+					}
+				} else {
+					index++;
+				}
 			}
+		}
+		break;
 
-			index++;
+		case RUN_LCD: {
+			chrg_south_switch((eIDX_SOU_CH)pROLL->ch);
+			chrg_eload_write_reg(ID_ELOAD, pROLL->reg, pROLL->value);
+		}
+		break;
+
+		case RUN_CONSOLE: {
+			chrg_south_switch((eIDX_SOU_CH)pROLL->ch);
+			chrg_eload_refresh(ID_ELOAD, pROLL->part);
+		}
+		break;
+
+		case RUN_NONE:
+		default:
+			rt_thread_mdelay(100);
+			continue;
+		break;
 		}
 
 		ret = rt_mb_recv(pTS->mb, (rt_uint32_t *)&pMB_R, 200); // 超时 200ms
-		if ((RT_EOK == ret)&&(RT_NULL != pMB_R)) {
+		if ((RT_EOK == ret)&&(RT_NULL != pMB_R)) {	// 存在返回数据
 			if (0 == mb_crc16(pMB_R->payload, pMB_R->length)) {
-				if (MANU_AUTO != manu) {
+				if (RUN_AUTO != run) {	// 恢复自动轮巡
 					rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
-					pSOU->manual = MANU_AUTO;
+					pROLL->run = RUN_AUTO;
-					sou_run = 1;
 					rt_mutex_release(pTHR->mutex);
-				} else {
+				} else {	// 自动轮巡态，分析接收的数据
-					chrg_eload_parse(idx, pt, pMB_R->payload, pMB_R->length);
+					chrg_eload_parse(idx, pROLL->part, pMB_R->payload, pMB_R->length);
 				}
 			} else {
 				LOG_E("crc failed.");
@@ -136,11 +152,10 @@ void chrg_roll_sou_thread_entry (void *data)
 			}
 
 			rt_thread_mdelay(200);	// 间隔 200ms
-		} else {
+		} else {	// 设备应答超时
-			if (MANU_AUTO != manu) {
+			if (RUN_AUTO != run) {			// 非自动轮巡
 				rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
-				pSOU->manual = MANU_AUTO;
+				pROLL->run = RUN_AUTO;		// 切换会自动轮巡
-				sou_run = 1;
 				rt_mutex_release(pTHR->mutex);
 			}
 		}
@@ -152,29 +167,30 @@ void chrg_roll_sou_thread_entry (void *data)
 #if 1
 static int south_send(rt_uint8_t argc, char **argv)
 {
-	struct chrg_south_t *pSOU = &chrgsouth;
 	int ch = 0, pt = 0;
 
 	if (3 != argc) {
-		rt_kprintf("help : %s [0-3] [0-2]\r\n", argv[0]);
+		rt_kprintf("help : %s [0-3] [0-1]\r\n", argv[0]);
 		return -1;
 	}
 
 	ch = (rt_uint8_t)atoi(argv[1]);
 	if ((ch < 0)||(ch >= TOTAL_SOU_CHS)) {
-		rt_kprintf("help : %s [0-3] [0-2]\r\n", argv[0]);
+		rt_kprintf("help : %s [0-3] [0-1]\r\n", argv[0]);
 		return -1;
 	}
 
 	pt = (rt_uint8_t)atoi(argv[2]);
 	if ((pt < 0)||(pt >= TOTAL_MB_R)) {
-		rt_kprintf("help : %s [0-3] [0-2]\r\n", argv[0]);
+		rt_kprintf("help : %s [0-3] [0-1]\r\n", argv[0]);
 		return -1;
 	}
 
-	sou_ch = (rt_uint8_t)ch;
+	struct chrg_rollsou_t *pROLL = &chrgrollsou;
-	sou_pt = (rt_uint8_t)pt;
+	pROLL->run = RUN_CONSOLE;
-	pSOU->manual = MANU_CMD;
+	pROLL->ch = (rt_uint8_t)ch;
+	pROLL->part = (rt_uint8_t)pt;
+
 
 	return 0;
 }
@@ -188,10 +204,12 @@ static int south_run (int argc, char **argv)
 		return -1;
 	}
 
+	struct chrg_rollsou_t *pROLL = &chrgrollsou;
+
 	if (rt_strcmp(argv[1], "start") == 0) {
-		sou_run = 1;
+		pROLL->run = RUN_AUTO;
 	} else if (rt_strcmp(argv[1], "stop") == 0) {
-		sou_run = 0;
+		pROLL->run = RUN_NONE;
 	} else {
 		rt_kprintf("help : %s start|stop\r\n", argv[0]);
 		return -1;

apps/chrg/applications/thread/chrg_roll_sou.h

@@ -15,18 +15,30 @@
 
 #define THR_NAME_ROLL_SOU		"thr.rollsou"
 
-extern rt_uint8_t sou_run;
+
-extern rt_uint8_t sou_ch;
+struct chrg_rollsou_t {
+	rt_uint8_t		run;		// 下一轮运行方式 1:自动轮巡 2:LCD触发插入 3:控制台触发插入
+	rt_uint8_t		part;		// 自动轮巡时，多条命令序号（若存在多条命令时）
+
+	rt_uint8_t		idx;		// 自动轮巡时，通道序号
+	rt_uint8_t		ch;			// 触发插入时，切换的通道
+
+	rt_uint16_t		reg;		// LCD 触发时，寄存器地址
+	rt_uint16_t		value;		// LCD 触发时，寄存器值
+
+};
+
+extern struct chrg_rollsou_t chrgrollsou;
 
 /*****************************************************************
-函数名称： chrg_set_sou_mode
+函数名称： chrg_set_sou_reg
-函数描述： 南向通道插入设置请求命令
+函数描述： 南向通道设置寄存器请求命令
-输入参数： idx:通道 mode:设置模式
+输入参数： idx:通道 reg:寄存器地址 value:寄存器值
 输出参数： -
 返回说明： -
 其它说明： -
 *****************************************************************/
-extern void chrg_set_sou_mode (eIDX_SOU_CH idx,rt_uint8_t reg, rt_uint16_t mode_value);
+extern void chrg_set_sou_reg (eIDX_SOU_CH idx, rt_uint16_t reg, rt_uint16_t value);
 
 /*****************************************************************
 函数名称： chrg_roll_sou_thread_entry

apps/chrg/applications/thread/chrg_south.c

@@ -29,8 +29,6 @@ struct chrg_south_t chrgsouth = {
 	.tty = RT_NULL,
 	.rb = RT_NULL,
 	.enable = {1, 1, 1, 1},
-	.idx = IDX_SOU_CH1,
-	.manual = MANU_AUTO,
 };
 
 /*****************************************************************

apps/chrg/applications/thread/chrg_south.h

@@ -39,8 +39,8 @@ struct chrg_south_t {
 	rt_uint8_t				rx_buf[SIZE_BUF_TTY];
 
 	rt_uint8_t				enable[TOTAL_SOU_CHS];	// 通路使能
-	rt_uint8_t				manual;	// 0: 程序自动 1:手动插入命令 2:插入设置模式
+	//rt_uint8_t				manual;	// 0: 程序自动 1:手动插入命令 2:插入设置模式
-	eIDX_SOU_CH				idx;	// 当前通路
+	//eIDX_SOU_CH				idx;	// 当前通路
 	eIDX_MB_PART			part;
 
 	struct chrg_eload_t		eload[TOTAL_SOU_CHS];	// 负载

apps/chrg/applications/utils/chrg_def.h

@@ -29,9 +29,10 @@ typedef enum {
 } eIDX_ID;
 
 enum {
-	MANU_AUTO = 0,	// 自动
+	RUN_NONE = 0,
-	MANU_CMD,		// 命令插入
+	RUN_AUTO,				// 执行轮巡
-	MANU_INSERT,	// 程序插入
+	RUN_LCD,				// 执行LCD触发
+	RUN_CONSOLE,			// 执行控制台触发
 
 };
 

apps/chrg/applications/utils/chrg_sink.c

@@ -38,5 +38,89 @@ int sink_get_vc (rt_uint16_t vol, rt_uint16_t cur)
 	return chrg_north_send(frame, len);
 }
 
+/*****************************************************************
+函数名称： sink_get_pd
+函数描述： sink pd 协议查询请求
+输入参数： -
+输出参数： -
+返回说明：  <0: 错误 >0:发送长度
+其它说明： -
+*****************************************************************/
+int sink_get_pd (void)
+{
+	rt_uint16_t len = 0;
+	rt_uint8_t frame[16] = {0};
+
+	chrg_north_pkg_encode(ID_SINK, SINK_CMD_GET_PD, RT_NULL, 0, frame, &len);
+
+	return chrg_north_send(frame, len);
+}
+
+/*****************************************************************
+函数名称： sink_set_cc_line
+函数描述： sink 设置 cc 线
+输入参数： line:线
+输出参数： -
+返回说明：  <0: 错误 >0:发送长度
+其它说明： -
+*****************************************************************/
+int sink_set_cc_line (rt_uint8_t line)
+{
+	rt_uint16_t len = 0;
+	rt_uint8_t data[8] = {0};
+	rt_uint8_t frame[16] = {0};
+
+	data[0] = line;
+
+	chrg_north_pkg_encode(ID_SINK, SINK_CMD_SET_CC, data, 1, frame, &len);
+
+	return chrg_north_send(frame, len);
+}
+
+/*****************************************************************
+函数名称： sink_set_cc_lvl
+函数描述： sink 设置 cc 等级
+输入参数： lvl:等级
+输出参数： -
+返回说明：  <0: 错误 >0:发送长度
+其它说明： -
+*****************************************************************/
+int sink_set_cc_lvl (rt_uint8_t lvl)
+{
+	rt_uint16_t len = 0;
+	rt_uint8_t data[8] = {0};
+	rt_uint8_t frame[16] = {0};
+
+	data[0] = lvl;
+
+	chrg_north_pkg_encode(ID_SINK, SINK_CMD_SET_LEVEL, data, 1, frame, &len);
+
+	return chrg_north_send(frame, len);
+}
+
+/*****************************************************************
+函数名称： sink_set_pd
+函数描述： sink 设置 PD 协议
+输入参数： pd:协议命令号 *buf:协议数据，5字节
+输出参数： -
+返回说明：  <0: 错误 >0:发送长度
+其它说明： -
+*****************************************************************/
+int sink_set_pd (rt_uint8_t pd, rt_uint8_t *buf)
+{
+	rt_uint16_t len = 0;
+	rt_uint8_t data[8] = {0};
+	rt_uint8_t frame[16] = {0};
+	int i = 0;
+
+	for (i = 0; i < 5; i++) {
+		data[i] = buf[i];
+	}
+
+	chrg_north_pkg_encode(ID_SINK, pd, data, 5, frame, &len);
+
+	return chrg_north_send(frame, len);
+}
+
 
 

apps/chrg/applications/utils/chrg_sink.h

@@ -161,6 +161,46 @@ struct chrg_sink_t {
 *****************************************************************/
 extern int sink_get_vc (rt_uint16_t vol, rt_uint16_t cur);
 
+/*****************************************************************
+函数名称： sink_get_pd
+函数描述： sink pd 协议查询请求
+输入参数： -
+输出参数： -
+返回说明：  <0: 错误 >0:发送长度
+其它说明： -
+*****************************************************************/
+extern int sink_get_pd (void);
+
+/*****************************************************************
+函数名称： sink_set_cc_line
+函数描述： sink 设置 cc 线
+输入参数： line:线
+输出参数： -
+返回说明：  <0: 错误 >0:发送长度
+其它说明： -
+*****************************************************************/
+extern int sink_set_cc_line (rt_uint8_t line);
+
+/*****************************************************************
+函数名称： sink_set_cc_lvl
+函数描述： sink 设置 cc 等级
+输入参数： lvl:等级
+输出参数： -
+返回说明：  <0: 错误 >0:发送长度
+其它说明： -
+*****************************************************************/
+extern int sink_set_cc_lvl (rt_uint8_t lvl);
+
+/*****************************************************************
+函数名称： sink_set_pd
+函数描述： sink 设置 PD 协议
+输入参数： pd:协议命令号 *buf:协议数据，5字节
+输出参数： -
+返回说明：  <0: 错误 >0:发送长度
+其它说明： -
+*****************************************************************/
+extern int sink_set_pd (rt_uint8_t pd, rt_uint8_t *buf);
+
 #endif
 
 

apps/chrg/applications/utils/chrg_source.c

@@ -90,18 +90,23 @@ int source_set_pd (rt_uint8_t pro, rt_uint8_t src, rt_uint8_t pps,
 	rt_uint16_t vmax, rt_uint16_t vmin, rt_int16_t max_cur)
 {
 	rt_uint16_t len = 0;
-	rt_uint8_t data[8] = {0};
+	rt_uint8_t data[32] = {0};
-	rt_uint8_t frame[16] = {0};
+	rt_uint8_t frame[32] = {0};
 
 	data[0] = pro;
 	data[1] = src;
 	data[2] = pps;
-
 	u16_to_u8v(vmax, &data[3]);
 	u16_to_u8v(vmin, &data[5]);
 	u16_to_u8v(max_cur, &data[7]);
+	data[9] = 0x00;
+	data[10] = 0x00;
+	data[11] = 0x00;
+	data[12] = 0x00;
+	data[13] = 0x00;
+	data[14] = 0x00;
 
-	chrg_north_pkg_encode(ID_SOURCE, SRC_CMD_SET_CC_LEVEL, data, 9, frame, &len);
+	chrg_north_pkg_encode(ID_SOURCE, SRC_CMD_SET_PROTOCOL, data, 15, frame, &len);
 
 	return chrg_north_send(frame, len);
 }