wrh/chrg
1
0
Fork 0
forked from chrg/chrg
Code Pull Requests Activity

nor / sou roll

Browse Source
This commit is contained in:
wmano
2025-11-23 00:56:55 +08:00
parent 7e463e56ad
commit 3a413f56a3
12 changed files with 665 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/chrg/applications/thread/chrg_lcd.c
+8 -8
View File
@@ -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
+1 -1
View File
@@ -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
+380 -47
View File
@@ -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 crc = 0;
rt_uint8_t index = 0, idx = 0, i = 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) {
chrg_north_switch((eIDX_NOR_CH)nor_ch);
source_get_vc(5000, 1000);
} else {
if (0 == nor_run) {
rt_thread_mdelay(1000);
continue;
}
switch (run) {
case RUN_AUTO: {
idx = index%TOTAL_NOR_CHS;
pNOR->idx = idx%TOTAL_NOR_CHS;
if (0 == pNOR->enable[pNOR->idx]) {
idx++;
rt_thread_mdelay(1);
if (0 == pNOR->enable[idx]) {
index++;
rt_thread_mdelay(10);
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 (MANU_AUTO != manu) {
if (crc == pMB_R->payload[pMB_R->length-1]) { // 数据正确
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);
pNOR->manual = MANU_AUTO;
rt_mutex_release(pTHR->mutex);
if (RUN_AUTO != run) { // 非自动轮巡
rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
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 ch = 0;
if (2 != argc) {
rt_kprintf("help : %s [0-3]\r\n", argv[0]);
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;
}
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;
pNOR->manual = MANU_CMD;
if (strcmp(argv[3], "vc") == 0) {
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
+40 -2
View File
@@ -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
+79 -61
View File
@@ -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;
rt_uint8_t sou_ch = IDX_SOU_CH1;
rt_uint8_t sou_pt = MB_R_PART1;
rt_uint8_t sou_mode = 0;
rt_uint8_t sou_reg = 0;
rt_uint16_t sou_mode_value = 0;
struct chrg_rollsou_t chrgrollsou = {
.run = RUN_AUTO,
.ch = IDX_SOU_CH1,
.part = MB_R_PART1,
};
/*****************************************************************
函数名称： chrg_set_sou_mode
函数描述： 南向通道插入设置请求命令
输入参数： idx:通道 mode:设置模式
函数名称： chrg_set_sou_reg
函数描述： 南向通道设置寄存器请求命令
输入参数： 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;
sou_run = 0;
sou_ch = idx;
sou_reg = reg;
sou_mode_value = mode_value;
struct chrg_rollsou_t *pROLL = &chrgrollsou;
pROLL->ch = idx;
pROLL->reg = reg;
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) {
chrg_south_switch((eIDX_SOU_CH)sou_ch);
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;
}
switch (run) {
case RUN_AUTO: {
idx = index%(TOTAL_SOU_CHS); // [0, 3]
if (0 == pSOU->enable[idx]) {
pSOU->idx = (eIDX_SOU_CH)idx;
if (0 == chrgsouth.enable[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) {
pSOU->idx = (eIDX_SOU_CH)idx;
chrg_south_switch(pSOU->idx);
if (idx != (rt_uint8_t)pROLL->idx) {
pROLL->idx = (eIDX_SOU_CH)idx;
chrg_south_switch((eIDX_SOU_CH)idx);
pROLL->part = MB_R_PART1;
}
pt = MB_R_PART1;
chrg_eload_refresh(ID_ELOAD, MB_R_PART1);
chrg_eload_refresh(ID_ELOAD, pROLL->part);
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;
sou_run = 1;
pROLL->run = RUN_AUTO;
rt_mutex_release(pTHR->mutex);
} else {
chrg_eload_parse(idx, pt, pMB_R->payload, pMB_R->length);
} else { // 自动轮巡态，分析接收的数据
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 {
if (MANU_AUTO != manu) {
} else { // 设备应答超时
if (RUN_AUTO != run) { // 非自动轮巡
rt_mutex_take(pTHR->mutex, RT_WAITING_FOREVER);
pSOU->manual = MANU_AUTO;
sou_run = 1;
pROLL->run = RUN_AUTO; // 切换会自动轮巡
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;
sou_pt = (rt_uint8_t)pt;
pSOU->manual = MANU_CMD;
struct chrg_rollsou_t *pROLL = &chrgrollsou;
pROLL->run = RUN_CONSOLE;
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
+18 -6
View File
@@ -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
函数描述： 南向通道插入设置请求命令
输入参数： idx:通道 mode:设置模式
函数名称： chrg_set_sou_reg
函数描述： 南向通道设置寄存器请求命令
输入参数： 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
-2
View File
@@ -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
+2 -2
View File
@@ -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:插入设置模式
eIDX_SOU_CH idx; // 当前通路
//rt_uint8_t manual; // 0: 程序自动 1:手动插入命令 2:插入设置模式
//eIDX_SOU_CH idx; // 当前通路
eIDX_MB_PART part;
struct chrg_eload_t eload[TOTAL_SOU_CHS]; // 负载
apps/chrg/applications/utils/chrg_def.h
+4 -3
View File
@@ -29,9 +29,10 @@ typedef enum {
} eIDX_ID;
enum {
MANU_AUTO = 0, // 自动
MANU_CMD, // 命令插入
MANU_INSERT, // 程序插入
RUN_NONE = 0,
RUN_AUTO, // 执行轮巡
RUN_LCD, // 执行LCD触发
RUN_CONSOLE, // 执行控制台触发
};
apps/chrg/applications/utils/chrg_sink.c
+84
View File
@@ -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
+40
View File
@@ -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
+9 -4
View File
@@ -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 frame[16] = {0};
rt_uint8_t data[32] = {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);
}