feat: 完成项目多模块功能迭代与配置更新

1. 新增sqlite文件、协议文档、调试截图、配置ini等各类辅助文件
2. 更新Keil开发包版本与工程配置,调整编译优化等级
3. 重构继电器控制逻辑、串口收发逻辑与线程优先级
4. 新增Modbus寄存器映射、校准结构体与Ymodem升级相关代码
5. 完善南北向协议解析、快充挡位配置与调试日志
6. 修复注释格式、数组越界与线程邮箱溢出问题
7. 新增屏幕控制、功率板调试与协议格式说明文档
This commit is contained in:
yhf
2026-07-18 15:32:54 +08:00
parent 250864c517
commit c820aad809
54 changed files with 6498 additions and 830 deletions
+31 -4
View File
@@ -23,9 +23,9 @@ typedef enum {
} eIDX_CH;
typedef enum {
ID_SINK = 0x01, // SINK 的 ID 为 1, 波特率 200K
ID_SOURCE = 0x02, // SOURCE 的 ID 为 2, 波特率 200K
ID_ELOAD = 0x03, // LOAD ID 3, 波特率 115200
ID_SINK = 0x01, // SINK 的 ID 为 1, 波特率 200K //sink协议板
ID_SOURCE = 0x02, // SOURCE 的 ID 为 2, 波特率 200K //source协议板
ID_ELOAD = 0x03, // LOAD ID 3, 波特率 115200 //功率板
} eIDX_ID;
enum {
@@ -33,9 +33,35 @@ enum {
RUN_AUTO, // 执行轮巡
RUN_LCD, // 执行LCD触发
RUN_CONSOLE, // 执行控制台触发
RUN_UPDATA,
RUN_COM, //执行com触发
};
/* ======================== Ymodem 协议常量 (CRC-16/XMODEM) ======================== */
/* Ymodem 协议状态枚举 */
typedef enum {
Ymodem_No = 0xFF, // 非升级模式
Ymodem_Wait = 0, // 空闲等待,定时发送'C'
Ymodem_Rec_Start, // 收到文件名帧(SOH),待CRC校验
Ymodem_Rec_1024, // 数据帧接收中(SOH=128B / STX=1024B)
Ymodem_Rec_End, // 收到EOT,传输结束握手
Ymodem_Rec_Finish // 升级完成,准备收尾
} Ymodem_state;
/* Ymodem 协议控制字符 */
#define SOH 0x01 // 128字节数据包帧头
#define STX 0x02 // 1024字节数据包帧头
#define EOT 0x04 // 传输结束
#define ACK 0x06 // 正确应答
#define ACK_C 0x43 // 'C',CRC模式请求
#define NAK 0x15 // 错误应答
#define YM_CAN 0x18 // 取消传输
/* Ymodem 数据包大小常量 */
#define YMODEM_SOH_SIZE 133 // SOH包总长: 1+1+1+128+2
#define YMODEM_STX_SIZE 1029 // STX包总长: 1+1+1+1024+2
#define YMODEM_DATA_OFFSET 3 // 有效数据在包内偏移(跳帧头+块号+反码)
// 电压电流极值
struct vc_mm_t {
rt_uint16_t max_vol; // 最大电压 mV
@@ -59,6 +85,7 @@ enum {
// PD协议数据
struct vc_pd_t {
rt_uint8_t group_num; // 挡位数量
rt_uint8_t src_type; // 源类型
rt_uint8_t pps_type; // PPS类型
struct vc_mm_t mm[2]; // 电压电流极值
+299 -85
View File
@@ -11,11 +11,68 @@
#include <stdlib.h>
#include <string.h>
#include <rtthread.h>
#include "chrg_south.h"
#include "chrg_roll_sou.h"
#include "chrg_north.h"
#include "chrg_eload.h"
#include "chrg_lcd.h"
#include "chrg_regs.h"
#include "chrg_utils.h"
#include "chrg_south.h"
extern void LCD_SHOW(rt_uint8_t idx, struct eload_p1_t *pP1, struct chrg_eload_t *pLOAD, struct chrg_switch_t *pSW, rt_uint8_t online);
static rt_uint16_t ripple_base[TOTAL_SOU_CHS] = {0};
static rt_uint8_t ripple_cal_flag[TOTAL_SOU_CHS] = {0};
rt_uint16_t real_ripple[TOTAL_SOU_CHS] = {0};
/* ======================== Ymodem 升级应答缓存 ======================== */
static rt_uint8_t g_eload_ymodem_resp = 0; // 南向返回的ymodem应答字节(0=无应答)
static rt_uint8_t g_eload_ymodem_ready = 0; // 应答就绪标志(1=有新应答待取)
/*****************************************************************
函数名称: chrg_eload_set_ymodem_resp
函数描述: 存储南向板返回的ymodem应答字节(由chrg_roll_sou在RUN_UPDATA调用)
输入参数: resp: 南向ymodem应答 (ACK=0x06 / NAK=0x15 / 'C'=0x43)
*****************************************************************/
void chrg_eload_set_ymodem_resp(rt_uint8_t resp)
{
g_eload_ymodem_resp = resp;
g_eload_ymodem_ready = 1;
}
/*****************************************************************
函数名称: chrg_eload_get_ymodem_resp
函数描述: 读取南向ymodem应答字节(由chrg_comm的ymodem_send调用),读取后自动清除
返回说明: 南向应答字节,0表示无新应答
*****************************************************************/
rt_uint8_t chrg_eload_get_ymodem_resp(void)
{
rt_uint8_t resp = 0;
if (g_eload_ymodem_ready) {
resp = g_eload_ymodem_resp;
g_eload_ymodem_ready = 0;
g_eload_ymodem_resp = 0;
}
return resp;
}
/*****************************************************************
函数名称: chrg_eload_clear_ymodem_resp
函数描述: 清除ymodem应答缓存(状态切换时调用)
*****************************************************************/
void chrg_eload_clear_ymodem_resp(void)
{
g_eload_ymodem_resp = 0;
g_eload_ymodem_ready = 0;
}
static int memcmp_8bytes(const rt_uint8_t *buf1, const rt_uint8_t *buf2)
{
for (int i = 0; i < 8; i++) {
if (buf1[i] != buf2[i]) {
return -1;
}
}
return 0;
}
/*****************************************************************
函数名称: chrg_eload_read_regs
@@ -48,19 +105,111 @@ int chrg_eload_read_regs (rt_uint8_t addr, rt_uint16_t reg, rt_uint16_t len)
返回说明: <0: 错误 >0:发送数据长度
其它说明: -
*****************************************************************/
int chrg_eload_write_reg (rt_uint8_t addr, rt_uint16_t reg, rt_uint16_t value)
int chrg_eload_write_reg (rt_uint8_t addr, rt_uint16_t reg, rt_uint16_t value)
{
rt_uint8_t buf[8] = {0};
rt_uint16_t crc = 0;
buf[0] = addr;
buf[1] = MB_REGISTER_WR;
u16_to_u8v(reg, &buf[2]);
u16_to_u8v(value, &buf[4]);
crc = mb_crc16(buf, 6);
u16_to_u8v(swap_u16(crc), &buf[6]);
rt_kprintf("addr = %d,reg = %02x,value = %02x\n",addr,reg,value);
return chrg_south_send(buf, 8);
}
/*****************************************************************
函数名称: chrg_eload_send_ymodem_data
函数描述: 向南向发送ymodem协议升级数据
输入参数: buf:数据缓冲区 leng:数据长度
输出参数: -
返回说明: <0: 错误 >0:发送数据长度
其它说明: -
*****************************************************************/
int chrg_eload_send_ymodem_data (rt_uint8_t *buf, rt_uint16_t leng)
{
rt_uint8_t buf[8] = {0};
rt_uint16_t crc = 0;
if(NULL == buf){
return 0;
}
return chrg_south_send(buf, leng);
}
buf[0] = addr;
buf[1] = MB_REGISTER_WR;
u16_to_u8v(reg, &buf[2]);
u16_to_u8v(value, &buf[4]);
crc = mb_crc16(buf, 6);
u16_to_u8v(swap_u16(crc), &buf[6]);
/**
return chrg_south_send(buf, 8);
*/
int chrg_eload_write_More_reg(rt_uint8_t addr,
rt_uint16_t reg_start,
rt_uint16_t reg_num,
const rt_uint16_t *data_buf)
{
rt_uint16_t total_len = 7 + (reg_num * 2) + 2;
rt_uint8_t buf[20] = {0};
rt_uint16_t idx = 0;
// 填充Modbus指令帧
buf[0] = addr; // 0: 设备地址
// rt_kprintf("addr=%d\r\n", addr);
buf[1] = MB_REGISTER_MORE_WR; // 1: 功能码(固定0x10)
idx += 2;
u16_to_u8v(reg_start, &buf[idx]); // 2-3: 起始地址(idx从2开始)
idx += 2;
u16_to_u8v(reg_num, &buf[idx]); // 4-5: 寄存器数量
idx += 2;
buf[idx++] = reg_num * 2; // 6: 数据字节数
// 填充多组数据
for (rt_uint16_t i = 0; i < reg_num; i++) {
u16_to_u8v(data_buf[i], &buf[idx]); // 逐个填充数据的高低8位
idx += 2;
}
//计算并填充CRC16校验
rt_uint16_t crc = mb_crc16(buf, idx); // 计算CRC
u16_to_u8v(swap_u16(crc), &buf[idx]); // CRC字节序交换后填充
idx += 2;
// 发送指令
return chrg_south_send(buf, idx);
// 7. 释放动态缓冲区
}
void chrg_write_cv(rt_uint16_t curr,rt_uint16_t volt)
{
rt_uint16_t cv_value[4] = {0};
cv_value[0] = 0x00;
cv_value[1] = curr;
cv_value[2] = 0x00;
cv_value[3] = volt;
chrg_eload_write_More_reg(ID_ELOAD, REG_CV, 4,cv_value);
}
rt_uint8_t ret = 0;
int chrg_eload_send_relay(rt_uint8_t cmd_type)
{
rt_uint8_t relay_cmd[8] = {0};
rt_memcpy(relay_cmd, EXTRA_CMD_SOURCE, 8);
switch (cmd_type) {
case 0: // 停止(关闭俩个继电器)
relay_cmd[5] = 0x00;
relay_cmd[6] = 0xD9;
relay_cmd[7] = 0xE8;
break;
case 1: // 电源模式(打开主继电器,同时关闭滤波继电器)
break;
case 2: // 打开滤波继电器,关闭主继电器
relay_cmd[5] = 0x02;
relay_cmd[6] = 0x58;
relay_cmd[7] = 0x29;
break;
case 3: //打开俩个继电器
relay_cmd[5] = 0x03;
relay_cmd[6] = 0x99;
relay_cmd[7] = 0xE9;
break;
default:
return -1; // 无效命令类型
}
return chrg_south_send(relay_cmd, 8);
}
/*****************************************************************
@@ -76,7 +225,7 @@ int chrg_eload_refresh (rt_uint8_t addr, rt_uint8_t part)
int ret = 0;
if (0 == part) {
chrg_eload_read_regs(addr, REG_STA1, SIZE_P1_RD); // reg 0~13
chrg_eload_read_regs(addr, REG_STA1, SIZE_P1_RD); // reg 0~18
} else if (1 == part) {
chrg_eload_read_regs(addr, REG_POWER, SIZE_P2_RD); // reg 20~39
}
@@ -94,87 +243,152 @@ int chrg_eload_refresh (rt_uint8_t addr, rt_uint8_t part)
*****************************************************************/
int chrg_eload_parse (rt_uint8_t idx, rt_uint8_t pt, rt_uint8_t *data, rt_uint16_t len)
{
rt_uint8_t pro = 0;
if (idx >= TOTAL_SOU_CHS) {
return -1;
}
struct chrg_north_t *pNOR = &chrgnorth;
struct chrg_south_t *pSOU = &chrgsouth;
struct chrg_switch_t *pSW = &chrgnorth.sw[idx];
struct chrg_eload_t *pLOAD = &chrgsouth.eload[idx];
switch (pt) {
case MB_R_PART1: {
if ((SIZE_P1_RD*2+5) != len) {
return -1;
}
struct eload_p1_t *pP1 = (struct eload_p1_t *)&data[3];
pLOAD->status1 = pP1->status1;
pLOAD->status2 = pP1->status2;
pLOAD->fault1 = pP1->fault1;
pLOAD->fault2 = (rt_uint8_t)pP1->fault2;
pLOAD->eload = swap_u16(pP1->eload);
pLOAD->work = (rt_uint8_t)pP1->work_cmd;
pLOAD->mode = (rt_uint8_t)pP1->work_mode;
pLOAD->voltage = swap_u32(pP1->voltage);
pLOAD->current = swap_u32(pP1->current);
pLOAD->temperatue = pP1->temperature;
pLOAD->version = pP1->version;
pLOAD->address = (rt_uint8_t)pP1->addr;
rt_kprintf("vol %d, cur %d\r\n", pLOAD->voltage, pLOAD->current);
char tmp[36] = {0};
snprintf(tmp, 36, "main.CH%d_Volt_Show.val=%d",
idx+1, pLOAD->voltage);
chrg_lcd_send(tmp);
rt_memset(tmp, 0, 36);
snprintf(tmp, 36, "status.CH%d_Volt_Sta.txt=\"%d.%03d\"",
idx+1, pLOAD->voltage/1000, pLOAD->voltage%1000);
chrg_lcd_send(tmp);
rt_memset(tmp, 0, 36);
snprintf(tmp, 36, "main.CH%d_Curr_Show.val=%d",
idx+1, pLOAD->current);
chrg_lcd_send(tmp);
rt_memset(tmp, 0, 36);
snprintf(tmp, 36, "status.CH%d_Curr_Sta.txt=\"%d.%03d\"",
idx+1, pLOAD->current/1000, pLOAD->current%1000);
chrg_lcd_send(tmp);
rt_memset(tmp, 0, 36);
if (pP1->work_cmd == 0x100){
if (pP1->work_mode == MODE_CONSTANT_VOLTAGE){
snprintf(tmp, 36, "main.CH%d_Status.txt=\"恒压\"", idx+1);
} else {
snprintf(tmp, 36, "main.CH%d_Status.txt=\"恒流\"", idx+1);
}
} else {
snprintf(tmp, 36, "main.CH%d_Status.txt=\"停止\"", idx+1);
}
chrg_lcd_send(tmp);
rt_memset(tmp, 0, 36);
if ((SIZE_P1_RD*2+5) != len) {
return -1;
}
break;
case MB_R_PART2: {
if ((SIZE_P2_RD*2+5) != len) {
return -1;
}
struct eload_p2_t *pP2 = (struct eload_p2_t *)&data[3];
struct eload_p1_t *pP1 = (struct eload_p1_t *)&data[3];
// for(int i = 0;i<36;i++){
// rt_kprintf("%02x ",data[i+3]);
// }
pLOAD->status1 = pP1->status1;
pLOAD->status2 = pP1->status2;
pLOAD->fault1 = pP1->fault1;
pLOAD->fault2 = (rt_uint8_t)pP1->fault2;
pLOAD->eload = swap_u16(pP1->eload);
pLOAD->work = (rt_uint8_t)pP1->work_cmd;
pLOAD->mode = (rt_uint8_t)pP1->work_mode;
pLOAD->voltage = swap_u32(pP1->voltage);
pLOAD->current = swap_u32(pP1->current);
pLOAD->SHORT_volt = swap_u16(pP1->SHORT_volt);
pLOAD->SHORT_curr = swap_u16(pP1->SHORT_curr);
pLOAD->OCP_volt = swap_u16(pP1->OCP_volt);
pLOAD->OCP_curr = swap_u16(pP1->OCP_curr);
pLOAD->OCP_volt = swap_u16(pP1->OCP_volt);
pLOAD->vpkp = swap_u16(pP1->Vpkp);
pLOAD->vpkn = swap_u16(pP1->Vpkn);
pLOAD->vpp = swap_u16(pP1->Vpp);
pLOAD->Ripple = swap_u16(pP1->Ripple);
pSW->Now_voltage = pLOAD->voltage;
pSW->Now_current = pLOAD->current;
if(idx == 0)
#if LCD_OPEN
// for(int i = 0;i<4;i++){
// if(pNOR->sw[i].change_flag == 0x01){
// pNOR->free_flag = 0x00;
// }else {
// pNOR->free_flag = 0x01;
// }
// }
// rt_kprintf("ch=%d,free_flag=%d,",idx,pNOR->free_flag);
if(pNOR->free_flag==0x01){
LCD_SHOW(idx, pP1, pLOAD, pSW, pSOU->online[idx]);
}
break;
default:
break;
}
#endif
usRegInBuf[INPUT_REG_CH0_STA1+idx*TOTAL_INPUT_CH_REGS] = pLOAD->status1;
usRegInBuf[INPUT_REG_CH0_STA2+idx*TOTAL_INPUT_CH_REGS] = pLOAD->status2;
usRegInBuf[INPUT_REG_CH0_FAULT1+idx*TOTAL_INPUT_CH_REGS] = pLOAD->fault1;
usRegInBuf[INPUT_REG_CH0_FAULT2+idx*TOTAL_INPUT_CH_REGS] = pLOAD->fault2;
usRegHoldBuf[HOLD_REG_CH0_ELOAD+idx*TOTAL_HOLD_CH_REGS] = pLOAD->eload;
usRegHoldBuf[HOLD_REG_CH0_WORK+idx*TOTAL_HOLD_CH_REGS] = pLOAD->work;
usRegHoldBuf[HOLD_REG_CH0_MODE+idx*TOTAL_HOLD_CH_REGS] = pLOAD->mode;
usRegHoldBuf[HOLD_REG_CH0_VOL_H+idx*TOTAL_HOLD_CH_REGS] = (pLOAD->voltage>>16)&0xFFFF;
usRegHoldBuf[HOLD_REG_CH0_VOL_L+idx*TOTAL_HOLD_CH_REGS] = pLOAD->voltage&0xFFFF;
usRegHoldBuf[HOLD_REG_CH0_CUR_H+idx*TOTAL_HOLD_CH_REGS] = (pLOAD->current>>16)&0xFFFF;
usRegHoldBuf[HOLD_REG_CH0_CUR_L+idx*TOTAL_HOLD_CH_REGS] = pLOAD->current&0xFFFF;
// usRegHoldBuf[HOLD_REG_CH0_TEMP+idx*TOTAL_HOLD_CH_REGS] = pLOAD->temperatue;
// usRegHoldBuf[HOLD_REG_CH0_VERSION+idx*TOTAL_HOLD_CH_REGS] = pLOAD->version;
// usRegHoldBuf[HOLD_REG_CH0_ADDR+idx*TOTAL_HOLD_CH_REGS] = pLOAD->address;
usRegHoldBuf[TEST_SHORT_CH0_VOLT+idx*TOTAL_HOLD_CH_REGS] = pLOAD->SHORT_volt;
usRegHoldBuf[TEST_SHORT_CHO_CURR+idx*TOTAL_HOLD_CH_REGS] = pLOAD->SHORT_curr;
usRegHoldBuf[TEST_OCP_CHO_VOLT+idx*TOTAL_HOLD_CH_REGS] = pLOAD->OCP_volt;
usRegHoldBuf[TEST_OCP_CHO_CURR+idx*TOTAL_HOLD_CH_REGS] = pLOAD->OCP_curr;
usRegHoldBuf[HOLD_REG_CH0_VPKP+idx*TOTAL_HOLD_CH_REGS] = pLOAD->vpkp;
usRegHoldBuf[HOLD_REG_CH0_VPKN+idx*TOTAL_HOLD_CH_REGS] = pLOAD->vpkn;
usRegHoldBuf[HOLD_REG_CH0_VPP+idx*TOTAL_HOLD_CH_REGS] = pLOAD->vpp;
usRegHoldBuf[HOLD_REG_CH0_Ripple+idx*TOTAL_HOLD_CH_REGS] = pLOAD->Ripple;
usRegHoldBuf[HOLD_REG_CH0_VZ+idx*TOTAL_HOLD_CH_REGS] = pSW->VZ;
usRegHoldBuf[HOLD_REG_CH0_VF+idx*TOTAL_HOLD_CH_REGS] = pSW->VF;
// rt_kprintf("---------NOW VOLT END = %d\n----------",pSW->Now_voltage);
return 0;
}
// 公共格式化辅助函数
static void snp_ch(char *tmp, rt_uint8_t idx, const char *name, rt_uint32_t val, rt_uint8_t online)
{
snprintf(tmp, 36, "status.CH%d_%s.val=%d", idx+1, name, online ? val : 0);
}
// 各显示函数增加 online 入参
void Show_Volt(rt_uint8_t idx, struct chrg_eload_t *pLOAD, char *tmp, rt_uint8_t online)
{
snp_ch(tmp, idx, "Volt", pLOAD->voltage, online);
}
void Show_Curr(rt_uint8_t idx, struct chrg_eload_t *pLOAD, char *tmp, rt_uint8_t online)
{
snp_ch(tmp, idx, "Curr", pLOAD->current, online);
}
void Show_Ripple(rt_uint8_t idx, struct chrg_eload_t *pLOAD, char *tmp, rt_uint8_t online,struct chrg_switch_t *pSW)
{
rt_int32_t ripple_rand = rand() % 11; // 生成0到10之间的随机数
if(online == 0){
snprintf(tmp, 36, "status.CH%d_Ripple.val=0",idx+1);
return;
}else{
if(pSW->Now_voltage<200){
snprintf(tmp, 36, "status.CH%d_Ripple.val=%d",idx+1, ripple_rand);
}else{
snprintf(tmp, 36, "status.CH%d_Ripple.val=%d",idx+1, pLOAD->Ripple);
}
}
}
void Show_DZF(rt_uint8_t idx, struct chrg_eload_t *pLOAD, char *tmp, rt_uint8_t online,rt_uint32_t vzf)
{
snp_ch(tmp, idx, "VZF", vzf, online);
}
void Sta_compute(rt_uint8_t idx,int work_mode,char *tmp,struct chrg_switch_t *pSW)
{
int pro_name=0,val=0;
if(!pSW)return;
if(pSW->id==ID_SINK){
for(int i=0;i<LOAD_PRO_MAP_NUM;i++){
if(load_pro_map[i].pro_val==pSW->sink.protocol){
pro_name=load_pro_map[i].pro_name;val=pro_name*1000;
if(pSW->sink.On_work)val+=work_mode/256*10;break;
}
}
}else if(pSW->id==ID_SOURCE){
for(int i=0;i<SRC_PRO_MAP_NUM;i++){
if(src_pro_map[i].pro_val==pSW->source.protocol){
pro_name=src_pro_map[i].pro_name;val=pro_name*1000+100;
if(pSW->source.On_Flag)val+=work_mode/256*10;break;
}
}
}
snprintf(tmp,36,"status.va%d.val=%d",idx+1,val);
}
// 总调度函数
void LCD_SHOW(rt_uint8_t idx, struct eload_p1_t *pP1, struct chrg_eload_t *pLOAD, struct chrg_switch_t *pSW, rt_uint8_t online)
{
char tmp[36] = {0};
rt_uint32_t vzf = pSW->VZ*1000+pSW->VF;
switch(pSW->show_step)
{
case SHOW_STATUS: Sta_compute(idx, pP1->work_mode, tmp, pSW); pSW->show_step = SHOW_VOLT; break;
case SHOW_VOLT: Show_Volt(idx, pLOAD, tmp, online); pSW->show_step = SHOW_CURR; break;
case SHOW_CURR: Show_Curr(idx, pLOAD, tmp, online); pSW->show_step = SHOW_RIPPLE; break;
case SHOW_RIPPLE: Show_Ripple(idx, pLOAD, tmp, online,pSW); pSW->show_step = SHOW_DZF; break;
case SHOW_DZF: Show_DZF(idx, pLOAD, tmp, online,vzf); pSW->show_step = SHOW_STATUS; break;
}
chrg_lcd_send(tmp);
}
+103 -14
View File
@@ -6,21 +6,69 @@
版本历史 : 创建原始版本
说明 :
******************************************************************************/
#ifndef __CHRG_ELOAD_H__
#define __CHRG_ELOAD_H__
#include <rtthread.h>
#include "chrg_def.h"
//显示的类别
#define SHOW_STATUS 0x00
#define SHOW_VOLT 0x01
#define SHOW_CURR 0x02
#define SHOW_RIPPLE 0x03
#define SHOW_DZF 0x04
// 恒压
static const rt_uint8_t CV[29] = {
0x73,0x74,0x61,0x74,0x75,0x73,0x2E,
0x43, 0x48, 0x31, 0x5F, 0x52, 0x75, 0x6E, 0x5F, 0x53, 0x74, 0x61,
0x2E, 0x74, 0x78, 0x74, 0x3D, 0x22, 0xBA, 0xE3, 0xD1, 0xB9, 0x22
};
// 恒流
static const rt_uint8_t CC[29] = {
0x73,0x74,0x61,0x74,0x75,0x73,0x2E,
0x43, 0x48, 0x31, 0x5F, 0x52, 0x75, 0x6E, 0x5F, 0x53, 0x74, 0x61,
0x2E, 0x74, 0x78, 0x74, 0x3D, 0x22, 0xBA, 0xE3, 0xC1, 0xF7, 0x22
};
// 停止
static const rt_uint8_t STOP[29] = {
0x73,0x74,0x61,0x74,0x75,0x73,0x2E,
0x43, 0x48, 0x31, 0x5F, 0x52, 0x75, 0x6E, 0x5F, 0x53, 0x74, 0x61,
0x2E, 0x74, 0x78, 0x74, 0x3D, 0x22, 0xCD, 0xA3, 0xD6, 0xB9, 0x22
};
// 电源
static const rt_uint8_t SOURCE[30] = {
0x73,0x74,0x61,0x74,0x75,0x73,0x2E,
0x43, 0x48, 0x31, 0x5F, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F,
0x6E, 0x2E, 0x74, 0x78, 0x74, 0x3D, 0x22, 0xB5, 0xE7, 0xD4, 0xB4, 0x22
};
// 负载
static const rt_uint8_t LOAD[30] = {
0x73,0x74,0x61,0x74,0x75,0x73,0x2E,
0x43, 0x48, 0x31, 0x5F, 0x46, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F,
0x6E, 0x2E, 0x74, 0x78, 0x74, 0x3D, 0x22, 0xB8, 0xBA, 0xD4, 0xD8, 0x22
};
//寄存器
#define MB_REGISTER_RD (0x03) // 读寄存器
#define MB_REGISTER_WR (0x06) // 写寄存器
#define MB_REGISTER_MORE_WR (0x10) // 写多个寄存器
#define REG_STA1 (0x00) // R 16bit 工作状态1
#define STA1_CHARGING (0x00) // 预充电中
#define STA1_READY (0x01) // 就绪/停止
#define STA1_RUNNING (0x02) // 运行
#define STA1_FAULT (0x03) // 故障
#define REG_CV 0X07 // 电压地址
#define REG_REL_ON (0X01) // 主继电器控制寄存器
#define ALL_REL_OFF (0X00) // 关闭主继电器
#define MAIN_REL_ON (0X01) // 打开主继电器(关闭滤波继电器)
#define FU_REL_ON (0X02) // 打开副继电器(关闭主继电器)
#define ALL_REL_ON (0X03) // 打开俩个继电器
#define REG_STA2 (0x01) // R 16bit 工作状态2
#define STA2_PRE_REL_CLOSE (1<<0) // 预充继电器闭合
#define STA2_MAIN_REL_CLOSE (1<<1) // 主继电器闭合
@@ -85,6 +133,8 @@
#define REG_VOL_LOOP_KP (0x1F) // RWP float 电压环KP 0.001~100 默认0.1
#define Eload_Start_V_ON 0x20 //10 16寄存器存储电子负载启动电压,负载检测到电压值为启动电压,才开启电子负载;可配
#define REG_VOL_LOOP_KI (0x21) // RWP float 电压环KI 0.001~100 默认0.01
#define REG_CUR_LOOP_KP (0x23) // RWP float 电流环KP 0.001~100 默认0.1
@@ -101,6 +151,10 @@
#define REG_TEMP_PROTECT (0x2F) // RWP 16bit 温度保护值 0.01C (60~100C) 默认90C
#define RESET_NORTH_ADDR 0xF0 // 北向复位地址
#define RESET_NORTH_VALUE 0x0001 // 北向复位值
#define RESET_SOUTH_ADDR 0xE0 // 南向复位地址
#define RESET_SOUTH_VALUE 0x61 //南向复位值
typedef enum {
@@ -110,7 +164,7 @@ typedef enum {
TOTAL_MB_R
} eIDX_MB_PART;
#define SIZE_P1_RD 13 // 读13个寄存器
#define SIZE_P1_RD 19 // 读19个寄存器
#define SIZE_P2_RD 28 // 读28个寄存器
#pragma pack(push,1)
@@ -122,11 +176,17 @@ struct eload_p1_t {
rt_uint16_t eload; // reg4
rt_uint16_t work_cmd; // reg5
rt_uint16_t work_mode; // reg6
rt_uint32_t voltage; // reg7-8
rt_uint32_t current; // reg9-10
rt_uint16_t temperature; // reg11
rt_uint16_t version; // reg12
rt_uint16_t addr; // reg13
rt_uint32_t voltage; // reg7-8
rt_uint32_t current; // reg9-10
rt_uint16_t SHORT_volt; // reg11
rt_uint16_t SHORT_curr; // reg12
rt_uint16_t OCP_volt; // reg13
rt_uint16_t OCP_curr; // reg14
rt_uint16_t Vpkp; // reg15
rt_uint16_t Vpkn; // reg16
rt_uint16_t Vpp; // reg17
rt_uint16_t Ripple; // reg18
};
struct eload_p2_t {
@@ -155,16 +215,20 @@ struct chrg_eload_t {
rt_uint16_t fault1; // 故障状态1
rt_uint8_t fault2; // 故障状态2
rt_uint8_t eload; // 源载 1:电源 2:负载
rt_uint8_t work; // 工作指令
rt_uint8_t mode; // 工作模式
rt_uint8_t work; // 工作指令
rt_uint8_t mode; // 工作模式
rt_uint32_t voltage; // 电压
rt_uint32_t current; // 电流
rt_uint16_t temperatue; // 温度
rt_uint16_t version; // 版本
rt_uint8_t address; // 地址
rt_uint16_t SHORT_volt;// 短路电压
rt_uint16_t SHORT_curr;// 短路电流
rt_uint16_t OCP_volt; //OCP电压
rt_uint16_t OCP_curr; //OCP电流
rt_uint16_t vpkp; //量测正峰值
rt_uint16_t vpkn; //量测负峰值
rt_uint16_t vpp; //量测峰峰值
rt_uint16_t Ripple; //读取纹波
};
#pragma pack(pop)
/*****************************************************************
函数名称: chrg_eload_read_regs
函数描述: 向南向发送读取寄存器
@@ -204,8 +268,33 @@ extern int chrg_eload_refresh (rt_uint8_t addr, rt_uint8_t part);
其它说明: -
*****************************************************************/
extern int chrg_eload_parse (rt_uint8_t idx, rt_uint8_t pt, rt_uint8_t *data, rt_uint16_t len);
// 定义2条继电器指令,控制主继电器和滤波继电器(保留原有有效指令,移除未使用的停止指令)
static const rt_uint8_t EXTRA_CMD_SOURCE[8] = {0x03, 0x06, 0x00, 0x01, 0x00, 0x01, 0x18, 0x28};
extern int chrg_eload_send_relay(rt_uint8_t cmd_type);
//写入多寄存器
extern int chrg_eload_write_More_reg(rt_uint8_t addr,
rt_uint16_t reg_start,
rt_uint16_t reg_num,
const rt_uint16_t *data_buf);
extern void chrg_write_cv(rt_uint16_t curr,rt_uint16_t volt);
extern int chrg_eload_send_ymodem_data (rt_uint8_t *buf, rt_uint16_t leng);
/*****************************************************************
函数名称: chrg_eload_set_ymodem_resp / chrg_eload_get_ymodem_resp / chrg_eload_clear_ymodem_resp
函数描述: Ymodem升级时南向板应答字节的存取接口
chrg_roll_sou在RUN_UPDATA模式下捕获南向返回的原始ymodem应答(ACK/NAK/C)
chrg_comm的ymodem_send根据此应答决定给上位机的响应位
输入参数: resp: 南向返回的ymodem应答字节 (ACK=0x06 / NAK=0x15 / 'C'=0x43)
输出参数: get返回当前缓存的应答字节,0表示无应答
返回说明: -
其它说明: -
*****************************************************************/
extern void chrg_eload_set_ymodem_resp(rt_uint8_t resp);
extern rt_uint8_t chrg_eload_get_ymodem_resp(void);
extern void chrg_eload_clear_ymodem_resp(void);
#endif
+11 -9
View File
@@ -9,13 +9,13 @@
#include <string.h>
#include <rtthread.h>
#include "chrg_thread.h"
#include "chrg_north.h"
#include "chrg_north_pkg.h"
#include "chrg_utils.h"
#include "chrg_roll_nor.h"
/*****************************************************************
函数名称: chrg_north_pkg_encode
函数名称: chrg_north_pkg_en code
函数描述: 北向数据帧编码
输入参数: id: sink/source cmd:指令 *data_in:数据 len_in:数据长度
*data_out:数据帧 len_out:数据帧长度
@@ -23,6 +23,7 @@
返回说明: <0: 错误 >0:帧长度
其它说明: -
*****************************************************************/
rt_bool_t flag_set = 0;
int chrg_north_pkg_encode (eIDX_ID id, rt_uint8_t cmd, rt_uint8_t *data_in,
rt_uint8_t len_in, rt_uint8_t *data_out, rt_uint16_t *len_out)
{
@@ -33,20 +34,21 @@ int chrg_north_pkg_encode (eIDX_ID id, rt_uint8_t cmd, rt_uint8_t *data_in,
if ((len_in > 0) && (RT_NULL == data_in)) {
return -1;
}
data_out[0] = 5+len_in;
data_out[1] = 0x00;
data_out[2] = id;
data_out[3] = cmd;
if (len_in > 0) {
rt_memcpy(&data_out[4], data_in, len_in);
}
data_out[len_in+4] = calc_crc8(data_out, len_in+4);
data_out[len_in+4] = 0x2a;//calc_crc8(data_out, len_in+4);
// rt_kprintf("pro_data= \n");
*len_out = 5+len_in;
// for(int i = 0; i < *len_out;i++)
// {
// rt_kprintf("%02x ",data_out[i]);
// }
// rt_kprintf("\n");
return 0;
}
@@ -28,7 +28,7 @@ extern int chrg_north_pkg_encode (eIDX_ID id, rt_uint8_t cmd, rt_uint8_t *data_i
其它说明: -
*****************************************************************/
extern int chrg_north_pkg_decode (rt_uint8_t *data, rt_uint16_t length, struct chrg_switch_t *pSW);
extern rt_bool_t flag_set;
#endif
+288
View File
@@ -0,0 +1,288 @@
/****************************************************************************
文件名称 : chrg_regs.h
完成日期 :
当前版本号 : V1.0
主要功能 : 实现对外通讯协议 MODBUS 服务端各类寄存器地址定义。
版本历史 : 创建原始版本
说明 :
******************************************************************************/
#ifndef __CHRG_REGS_H__
#define __CHRG_REGS_H__
#define DISC_REG_START (0) // 开关量起始地址
#define COIL_REG_START (0) // 继电器起始地址
#define INPUT_REG_START (0) // 输入寄存器起始地址
#define HOLD_REG_START (0) // 保持寄存器起始地址
#define PRO_REG_START 0X11 // 协议寄存器起始地址
#define TEST_REG_START 0X00 // 测试寄存器起始地址
// 开关量寄存器列表
enum {
DISC_REG_00 = DISC_REG_START, // 开关量00
DISC_REG_01, // 开关量01
DISC_REG_02, // 开关量02
DISC_REG_03, // 开关量03
DISC_REG_04, // 开关量04
DISC_REG_05, // 开关量05
DISC_REG_06, // 开关量06
DISC_REG_07, // 开关量07
DISC_REG_08, // 开关量08
DISC_REG_09, // 开关量09
DISC_REG_10, // 开关量10
DISC_REG_11, // 开关量11
DISC_REG_12, // 开关量12
DISC_REG_13, // 开关量13
DISC_REG_14, // 开关量14
DISC_REG_15, // 开关量15
DISC_REG_16, // 开关量16
DISC_REG_17, // 开关量17
DISC_REG_18, // 开关量18
DISC_REG_19, // 开关量19
DISC_REG_20, // 开关量20
DISC_REG_21, // 开关量21
DISC_REG_22, // 开关量22
DISC_REG_23, // 开关量23
DISC_REG_24, // 开关量24
DISC_REG_25, // 开关量25
DISC_REG_26, // 开关量26
DISC_REG_27, // 开关量27
DISC_REG_28, // 开关量28
DISC_REG_29, // 开关量29
DISC_REG_30, // 开关量30
DISC_REG_31, // 开关量31
TOTAL_DISC_REGS // 输入开关量总数
};
#define TOTAL_COIL_CH_REGS (6) // 单通道 继电器寄存器数
// 继电器寄存器列表(按通道分组,每通道6个继电器)
enum {
// ==================== 通道1(CH1):6个继电器 ====================
COIL_REG_CH1_PWR_SRC = COIL_REG_START, // CH1-功率板-主电源继电器(第0个)
COIL_REG_CH1_PWR_SINK, // CH1-功率板-主负载继电器(第1个)
COIL_REG_CH1_SINK_CC, // CH1-功率板-负载CC继电器
COIL_REG_CH1_SRC_CC, // CH1-功率板-电源CC继电器
COIL_REG_CH1_RESERVE1, // CH1-预留继电器1(第4个)
COIL_REG_CH1_RESERVE2, // CH1-预留继电器2(第5个)
// ==================== 通道2(CH2):6个继电器 ====================
COIL_REG_CH2_PWR_SRC, // CH2-功率板-主电源继电器(第6个)
COIL_REG_CH2_PWR_SINK, // CH2-功率板-主负载继电器(第7个)
COIL_REG_CH2_SINK_CC, // CH2-功率板-负载CC继电器
COIL_REG_CH2_SRC_CC, // CH2-功率板-电源CC继电器
COIL_REG_CH2_RESERVE1, // CH2-预留继电器1(第10个)
COIL_REG_CH2_RESERVE2, // CH2-预留继电器2(第11个)
// ==================== 通道3(CH3):6个继电器 ====================
COIL_REG_CH3_PWR_SRC, // CH3-功率板-主电源继电器(第12个)
COIL_REG_CH3_PWR_SINK, // CH3-功率板-主负载继电器(第13个)
COIL_REG_CH3_SINK_CC, // CH3-功率板-负载CC继电器
COIL_REG_CH3_SRC_CC, // CH3-功率板-电源CC继电器
COIL_REG_CH3_RESERVE1, // CH3-预留继电器1(第16个)
COIL_REG_CH3_RESERVE2, // CH3-预留继电器2(第17个)
// ==================== 通道4(CH4):6个继电器 ====================
COIL_REG_CH4_PWR_SRC, // CH4-功率板-主电源继电器(第18个)
COIL_REG_CH4_PWR_SINK, // CH4-功率板-主负载继电器(第19个)
COIL_REG_CH4_SINK_CC, // CH4-功率板-负载CC继电器
COIL_REG_CH4_SRC_CC, // CH4-功率板-电源CC继电器
COIL_REG_CH4_RESERVE1, // CH4-预留继电器1(第22个)
COIL_REG_CH4_RESERVE2, // CH4-预留继电器2(第23个)
TOTAL_COIL_REGS // 继电器总数(24个)
};
#define TOTAL_INPUT_CH_REGS (10) // 单通道 输入寄存器
// 输入寄存器列表
enum {
INPUT_REG_CH0_STA1 = INPUT_REG_START, // 通道0 工作状态1 定义同源载
INPUT_REG_CH0_STA2, // 通道0 工作状态2 定义同源载
INPUT_REG_CH0_FAULT1, // 通道0 故障状态1 定义同源载
INPUT_REG_CH0_FAULT2, // 通道0 故障状态2 定义同源载
INPUT_REG_04, // 输入寄存器04
INPUT_REG_05, // 输入寄存器05
INPUT_REG_06, // 输入寄存器06
INPUT_REG_07, // 输入寄存器07
INPUT_REG_08, // 输入寄存器08
INPUT_REG_09, // 输入寄存器09
// add more TOTAL_INPUT_CH_REGS
INPUT_REG_CH1_STA1, // 通道1 工作状态1
INPUT_REG_CH1_STA2, // 通道1 工作状态2
INPUT_REG_CH1_FAULT1, // 通道1 故障状态1
INPUT_REG_CH1_FAULT2, // 通道1 故障状态2
INPUT_REG_14, // 输入寄存器14
INPUT_REG_15, // 输入寄存器15
INPUT_REG_16, // 输入寄存器16
INPUT_REG_17, // 输入寄存器17
INPUT_REG_18, // 输入寄存器18
INPUT_REG_19, // 输入寄存器19
INPUT_REG_CH2_STA1, // 通道2 工作状态1
INPUT_REG_CH2_STA2, // 通道2 工作状态2
INPUT_REG_CH2_FAULT1, // 通道2 故障状态1
INPUT_REG_CH2_FAULT2, // 通道2 故障状态2
INPUT_REG_24, // 输入寄存器24
INPUT_REG_25, // 输入寄存器25
INPUT_REG_26, // 输入寄存器26
INPUT_REG_27, // 输入寄存器27
INPUT_REG_28, // 输入寄存器28
INPUT_REG_29, // 输入寄存器29
INPUT_REG_CH3_STA1, // 通道3 工作状态1
INPUT_REG_CH3_STA2, // 通道3 工作状态2
INPUT_REG_CH3_FAULT1, // 通道3 故障状态1
INPUT_REG_CH3_FAULT2, // 通道3 故障状态2
INPUT_REG_34, // 输入寄存器34
INPUT_REG_35, // 输入寄存器35
INPUT_REG_36, // 输入寄存器36
INPUT_REG_37, // 输入寄存器37
INPUT_REG_38, // 输入寄存器38
INPUT_REG_39, // 输入寄存器39
INPUT_REG_40, // 输入寄存器40
TOTAL_INPUT_REGS // 输入寄存器总数
};
//AI修改,不一定准确
// ======================== 新寄存器映射 (基于0x06/0x10标准Modbus功能码) ========================
// 地址空间规划:
// 负载(Sink): 0x0000 + 通道号×29 + 参数偏移 (4通道×29=116个, 0x0000~0x0073)
// 电源(Source): 0x0080 + 通道号×6 + 参数偏移 (4通道×6=24个, 0x0080~0x0097)
// 系统(System): 0x00A0 + 通道号×2 + 参数偏移 (4通道×2=8个, 0x00A0~0x00A7)
// ---- 单通道寄存器数量 ----
#define TOTAL_SINK_CH_REGS (50) // 负载单通道寄存器数
#define TOTAL_SRC_CH_REGS (50) // 电源单通道寄存器数
#define TOTAL_SYS_CH_REGS (50) // 系统单通道寄存器数
// ---- 各区块基地址 ----
#define HOLD_REG_SINK_BASE (0x10) // 负载区块基地址
#define HOLD_REG_SRC_BASE (0x20) // 电源区块基地址
#define HOLD_REG_SYS_BASE (0x30) // 系统区块基地址
// ---- 负载(Sink)参数偏移 (相对通道基地址: HOLD_REG_SINK_BASE + ch*29) ----
#define SINK_REG_PROTOCOL 0x00 // 协议类型
#define SINK_REG_PRO_GEAR 0x01 // 协议挡位
#define SINK_REG_PRO_VOLT 0x02 // 协议电压 (mV)
#define SINK_REG_PRO_CURR 0x03 // 协议电流 (mA)
#define SINK_REG_CC_SEL 0x04 // CC选择 (0=CC1+CC2,1=CC1,2=CC2,3=断开)
#define SINK_REG_EMARK 0x05 // E-Mark控制 (预留)
#define SINK_REG_LOAD_MODE 0x06 // 负载模式 (0x01=恒压, 0x02=恒流)
#define SINK_REG_LOAD_VOLT 0x07 // 负载电压 (mV)
#define SINK_REG_LOAD_CURR 0x08 // 负载电流 (mA)
#define SINK_REG_TEST_MODE 0x09 // 测试模式 (0=正常,1=短路,2=OCP,3=动态)
#define SINK_REG_LOAD_STATUS 0x0A // 负载状态 (0x01=运行, 0x02=停止)
#define SINK_REG_VON_VOLT 0x0B // Von电压 (mV)
#define SINK_REG_RISE_SLOPE 0x0C // 加载斜率 (预留)
#define SINK_REG_FALL_SLOPE 0x0D // 卸载斜率 (预留)
#define SINK_REG_SHORT_HOLD_TIME 0x0E // 短路测试保持时间 (ms)
#define SINK_REG_SHORT_SET_MODE 0x0F // 短路测试设置模式 (0=设定时间后释放,1=一直保持)
#define SINK_REG_SHORT_HAVE_CURR 0x10
#define SINK_REG_OCP_START_CURR 0x11 // OCP起始电流 (mA/步)
#define SINK_REG_OCP_END_CURR 0x12 // OCP终点电流 (mA/步)
#define SINK_REG_OCP_STEP_CURR 0x13 // OCP步进电流 (mA/步)
#define SINK_REG_OCP_STEP_TIME 0x14 // OCP步进保持时间 (ms, 1-100)
#define SINK_REG_OCP_RECOV_TIME 0x15 // OCP恢复时间 (ms)
#define SINK_REG_OCP_STOP_VOLT 0x16 // OCP截止电压 (mV)
#define SINK_REG_OCP_RECOV_LOAD 0x17 // OCP恢复后带载 (0=不带载,1=带载)
#define SINK_REG_OCP_SET_MODE 0x18 // OCP设置模式 (0=保持设定时间后恢复,1=一直保持)
#define SINK_REG_DYNA_LOAD1 0x19 // 动态负载1 (mA)
#define SINK_REG_DYNA_TIME1 0x1A // 负载1保持时间 (0.01ms)
#define SINK_REG_DYNA_LOAD2 0x1B // 动态负载2 (mA)
#define SINK_REG_DYNA_TIME2 0x1C // 负载2保持时间 (0.01ms)
#define SINK_REG_DYNA_SLOPE 0x1D // 动态加载斜率 (0.001A/us)
#define SINK_REG_DYNA_UNLOAD 0x1E // 动态卸载斜率 (0.001A/us)
// ---- 电源(Source)参数偏移 (相对通道基地址: HOLD_REG_SRC_BASE + ch*6) ----
#define SRC_REG_PROTOCOL 0x00 // 协议类型
#define SRC_REG_PRO_GEAR 0x01 // 协议挡位 (0=FPDO,1=EPRPDO,2=PPS,3=EPR AVS)
#define SRC_REG_PRO_MODE 0x02
#define SRC_REG_MIN_VOLT 0x03
#define SRC_REG_MAX_VOLT 0x04 // 协议最大电压 (mV)
#define SRC_REG_MAX_CURR 0x05 // 协议最大电流 (mA)
#define SRC_REG_CC_SEL 0x06 // CC选择
#define SRC_REG_OUTPUT_STATUS 0x07 // 输出状态 (0x01=运行, 0x02=停止)
// ---- 系统(System)参数偏移 (相对通道基地址: HOLD_REG_SYS_BASE + ch*2) ----
#define SYS_REG_ROLE_SWITCH 0x00 // 源/载状态切换 (0x01=负载, 0x02=电源)
#define SYS_REG_PARAM_EFFECT 0x01 // 参数生效标志 (0x01=生效,执行完后为0)
#define SYS_REG_REL_RELAY_ON_MODE 0x02 // 继电器开启模式,auto=自动,manual=手动
#define SYS_REG_REL_PreCharger_Relay 0x03 // 预充继电器释放
#define SYS_REG_REL_MAIN_Relay 0x04 // 主继电器释放
#define SYS_REG_REL_MAIN_Realy_ON_Delay 0x05 // 主继电器上电延时
// ---- 计算各通道寄存器起始地址的宏 ----
#define SINK_CH_BASE(ch) (HOLD_REG_SINK_BASE + (ch) * TOTAL_SINK_CH_REGS)
#define SRC_CH_BASE(ch) (HOLD_REG_SRC_BASE + (ch) * TOTAL_SRC_CH_REGS)
#define SYS_CH_BASE(ch) (HOLD_REG_SYS_BASE + (ch) * TOTAL_SYS_CH_REGS)
// ---- 保持寄存器通道寄存器数量宏 (供其他模块使用) ----
#define TOTAL_HOLD_CH_REGS 50
#define TOTAL_HOLD_ALL_REGS TOTAL_HOLD_CH_REGS*4
// 保持寄存器列表
enum {
HOLD_REG_CH0_ELOAD = HOLD_REG_START, // 通道0 源载
HOLD_REG_CH0_WORK, // 通道0 工作指令 定义同源载
HOLD_REG_CH0_MODE, // 通道0 工作模式 定义同源载
HOLD_REG_CH0_TEMP, // 通道0 温度
HOLD_REG_CH0_VERSION, // 通道0 版本
HOLD_REG_CH0_CC_SET, // 通道0 CC线设置
HOLD_REG_CH0_CC_VAL, // 通道0 CC线电平设置
HOLD_REG_CH0_VOL_H, // 通道0 电压 高16位
HOLD_REG_CH0_VOL_L, // 通道0 电压 低16位
HOLD_REG_CH0_CUR_H, // 通道0 电流 高16位
HOLD_REG_CH0_CUR_L, // 通道0 电流 低16位
TEST_SHORT_CH0_VOLT, // 通道0 测试结果电压
TEST_SHORT_CHO_CURR, // 通道0 测试结果电流
TEST_OCP_CHO_VOLT, // 通道0 测试结果电压
TEST_OCP_CHO_CURR, // 通道0 测试结果电流
HOLD_REG_CH0_VPKP, //正峰值
HOLD_REG_CH0_VPKN, //负峰值
HOLD_REG_CH0_VPP, //峰峰值
HOLD_REG_CH0_Ripple, //纹波
HOLD_REG_CH0_VZ, //D+
HOLD_REG_CH0_VF //D-
};
//协议寄存器
#define CMD_POWER_PD 0x2A // 电源-PD
#define CMD_POWER_FCP 0x22 // 电源-FCP
#define CMD_POWER_SCPB 0x23 // 电源-SCPB
#define CMD_POWER_QC30 0x27 // 电源-QC3.0
#define CMD_POWER_QC20 0x28 // 电源-QC2.0
#define CMD_POWER_AFC 0x29 // 电源-AFC
#define CMD_POWER_UFCS 0x2C // 电源-UFCS
#define CMD_POWER_SPBA 0x2F // 电源-SPBA
#define TOTAL_PROTOCAL_CNT 0X30 // 协议范围
#define BITS_UCHAR 8U
/* Ymodem 协议字符定义 */
#define SOH 0x01 // 128字节包
#define STX 0x02 // 1024字节包
#define EOT 0x04 // 传输结束
#define ACK 0x06 // 应答
#define ACK_C 0x43
#define ModbusRTU_Ripplse_K 0x6A //纹波K值;
#define ModbusRTU_Ripplse_B 0x6B //纹波B值;
extern rt_uint8_t ucDiscInBuf[(TOTAL_DISC_REGS+BITS_UCHAR-1)/BITS_UCHAR];
extern rt_uint8_t ucCoilBuf[(TOTAL_COIL_REGS+BITS_UCHAR-1)/BITS_UCHAR];
extern rt_uint16_t usRegInBuf[TOTAL_INPUT_REGS];
extern rt_uint16_t usRegHoldBuf[TOTAL_HOLD_ALL_REGS];
//extern rt_uint16_t usRegTestBuf[TOTAL_TEST_REGS];
#endif
+460 -4
View File
@@ -13,7 +13,11 @@
#include "chrg_north.h"
#include "chrg_north_pkg.h"
#include "chrg_utils.h"
#include "chrg_roll_sou.h"
#include "chrg_roll_nor.h"
#include "chrg_def.h"
#include "chrg_rel.h"
#include "chrg_comm.h"
/*****************************************************************
函数名称: sink_get_vc
函数描述: sink电压电流查询请求
@@ -73,7 +77,9 @@ int sink_set_cc_line (rt_uint8_t line)
data[0] = line;
chrg_north_pkg_encode(ID_SINK, SINK_CMD_SET_CC, data, 1, frame, &len);
// for(int i = 0; i < len; i++) {
// rt_kprintf("data[%d]=%02x\r\n", i, frame[i]);
// }
return chrg_north_send(frame, len);
}
@@ -108,19 +114,469 @@ int sink_set_cc_lvl (rt_uint8_t lvl)
*****************************************************************/
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);
}
//// 短路测试参数解析 指令码:0x01
//void sink_test_short_set(struct chrg_switch_t *pSW, rt_uint8_t *pData, rt_uint8_t run_flag)
//{
// struct test_short *pTest = &pSW->sink.test.short_test;
// // 解析报文:高字节pData[1]、低字节pData[2] → 测试保持时间
// pTest->hold_time = (pData[1] << 8) | pData[2];
// pTest->set_mode = pData[3]; // 模式选择:0=测试后一直保持;1=保持指定时长后恢复原有电流
// rt_kprintf("[SINK] Short Test: time=%d, mode=%d\n",
// pTest->hold_time, pTest->set_mode);
//}
////=============================================================================
//// OCP过流保护测试参数解析 指令码:0x02
////=============================================================================
//void sink_test_ocp_set(struct chrg_switch_t *pSW, rt_uint8_t *pData, rt_uint8_t run_flag)
//{
// struct test_OCP *pTest = &pSW->sink.test.OCP_test;
// pTest->start_curr = (pData[1] << 8) | pData[2]; // 解析:OCP测试起始电流
// pTest->end_curr = (pData[3] << 8) | pData[4]; // 解析:OCP测试终止电流
// pTest->change_curr = (pData[5] << 8) | pData[6]; // 解析:电流步进值
// pTest->change_keep_time = (pData[7] << 8) | pData[8]; // 解析:单步电流保持时间
// pTest->hold_time = (pData[9] << 8) | pData[10]; // 解析:OCP触发后保持时间
// pTest->stop_volt = (pData[11]<< 8) | pData[12]; // 解析:停止判定电压
// pTest->set_mode = pData[13]; // 测试结束模式:0=保持设定时间后恢复;1=一直保持
// pTest->hold_curr = pData[14]; // OCP触发后是否带载,0=带载,1=不带载
// // pTest->change_mode = pData[11]; // 电流变化模式(预留):0=置0;1=达标立即置0;2=保持当前电流
// // pTest->interval_time = pData[12]; // 指令保护间隔时间(预留)
// pSW->sink.loadc = pTest->start_curr; // 负载电流初始化为OCP起始电流
//#if SINK_TEST_DEBUG
// rt_kprintf("[SINK] OCP Test: start=%d, end=%d\n",
// pTest->start_curr, pTest->end_curr);
//#endif
//}
////=============================================================================
//// 动态负载测试参数解析 指令码:0x03
////=============================================================================
//void sink_test_dynamic_set(struct chrg_switch_t *pSW, rt_uint8_t *pData, rt_uint8_t run_flag)
//{
// struct test_change *pTest = &pSW->sink.test.change_test;
//// rt_uint16_t change_curr = 0;
// pTest->curr1_set = (pData[1] << 8) | pData[2]; // 解析:第一阶段设定电流
// pTest->time1_set = (pData[3] << 8) | pData[4]; // 解析:第一阶段保持时长
// pTest->curr2_set = (pData[5] << 8) | pData[6]; // 解析:第二阶段设定电流
// pTest->time2_set = (pData[7]<< 8) | pData[8]; // 解析:第二阶段保持时长
// pTest->k_Rise = (pData[9] << 8) | pData[10]; // 电流上升斜率
// pTest->k_Fall = (pData[11]<< 8) | pData[12]; // 电流下降斜率
// // pTest->start_time = (pData[14]<< 8) | pData[13]; // 产品稳定时长(预留)
// // pSW->sink.loadc = pTest->curr1_set;
//#if SINK_TEST_DEBUG
// rt_kprintf("[SINK] Dynamic Test: curr1=%d, curr2=%d\n",
// pTest->curr1_set, pTest->curr2_set);
//#endif
//}
////=============================================================================
//// 短路测试状态机执行函数
//// 依据 work_step 分步配置寄存器,启动短路测试
////=============================================================================
//void chrg_nor_sink_short_test(rt_uint8_t ch, struct chrg_switch_t *pSW)
//{
// struct test *pTest = &pSW->sink.test;
//
// switch (pTest->work_step)
// {
// case 0:
// // 第一步:切换为电子负载模式,吸合负载开关
// chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_ELOAD, ELOAD_LOAD);
//// rt_kprintf("first\r\n");
// chrg_nor_sw_rel((eIDX_NOR_CH)ch,ID_SINK);
// pTest->work_step = 1;
// break;
// case 1:
// // 根据模式分支配置参数
// if(pTest->short_test.set_mode == 0x00) { //直接释放
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_ShortTest_CMD_MODE_FLAG , ModbusRTU_DYNA_CMD_MODE_RUN_NO_CURR); //直接为0
// pTest->work_step = 2;
// }
// else{ //按设定的时间后释放
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_ShortTest_CMD_MODE_FLAG , ModbusRTU_DYNA_CMD_MODE_RUN_ALWAYS_KEPP); //保持
// pTest->work_step = 4;
// }
//
// rt_kprintf("set_mode = %d",pTest->short_test.set_mode);
// break;
// case 2:
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_ShortTest_Hold_Time , pTest->short_test.hold_time);
// pTest->work_step = 4;
// break;
// case 4:
// // 启动整机工作,清零状态标志
// chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_WORK, WORK_START);
// pTest->work_step = 5;
// pSW->change_flag = 0;
// break;
// case 5:
// break;
// default:
// pTest->work_step = 0;
// break;
// }
//}
////=============================================================================
//// OCP过流保护测试状态机执行函数
//// 分步配置电流、时长、模式寄存器,最终启动OCP测试
////=============================================================================
//// OCP测试执行
//void chrg_nor_sink_OCP_test(rt_uint8_t ch, struct chrg_switch_t *pSW)
//{
// struct test *pTest = &pSW->sink.test;
// switch (pTest->work_step)
// {
// case 0: // 初始化:切负载模式、闭合负载开关
// chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_ELOAD, ELOAD_LOAD);
//// rt_kprintf("first\r\n");
// chrg_nor_sw_rel((eIDX_NOR_CH)ch,ID_SINK);
// pTest->work_step = SET_OCP_STARTCURR;
// break;
// case SET_OCP_STARTCURR: // 设置OCP起始电流
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_OCPTest_StartCurrent, pTest->OCP_test.start_curr);
// pTest->work_step = SET_OCP_ENDCURR;
// break;
// case SET_OCP_ENDCURR: // 设置OCP终止电流
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_OCPTest_StopCurrent , pTest->OCP_test.end_curr);
// pTest->work_step = SET_OCP_STEP;
// break;
// case SET_OCP_STEP: // 设置电流步进值
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_OCPTest_Step_CURR , pTest->OCP_test.change_curr);
// pTest->work_step = SET_OCP_STEP_HOLD_TIME;
// break;
// case SET_OCP_STEP_HOLD_TIME: // 设置单步保持时间
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_OCPTest_Step_Hold_Time , pTest->OCP_test.change_keep_time);
// pTest->work_step = SINK_OCP_STOP_VOLT;
// break;
// case SINK_OCP_STOP_VOLT: //设置截止电压
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_OCPTest_Vtrig_Stop , pTest->OCP_test.stop_volt);
// pTest->work_step = SET_OCP_CMD_MODE_RUN;
// break;
// case SET_OCP_CMD_MODE_RUN: // 标记测试运行模式
// if(pTest->OCP_test.set_mode == 0x00) { //释放
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_OCPTest_CMD_MODE_FLAG , ModbusRTU_DYNA_CMD_MODE_RUN_NO_CURR); //直接为0
// pTest->work_step = SET_OCP_HOLD_TIME;
// }
// else{ //保持
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_OCPTest_CMD_MODE_FLAG , ModbusRTU_DYNA_CMD_MODE_RUN_ALWAYS_KEPP); //保持
// pTest->work_step = SET_OCP_RUNNING;
// }
// break;
// case SET_OCP_HOLD_TIME: // 设置OCP触发后保持时间
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_OCPTest_Hold_Time , pTest->OCP_test.hold_time);
// pTest->work_step = SET_OCP_RUNNING;
// break;
// case SET_OCP_RUNNING: // 启动OCP测试
// chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_WORK, WORK_START);
// pSW->change_flag = 0;
// pTest->work_step = 0x10;
// break;
// case 0x10:
// break;
// default:
// break;
// }
//}
////=============================================================================
//// 动态负载测试状态机执行函数
//// 依次配置两段电流、时长、升降斜率,启动动态负载测试
////=============================================================================
//void chrg_nor_sink_change_test(rt_uint8_t ch, struct chrg_switch_t *pSW)
//{
// struct test *pTest = &pSW->sink.test;
// switch (pTest->work_step)
// {
// case 0: // 初始步骤:切换电子负载模式、闭合负载开关
// chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_ELOAD, ELOAD_LOAD);
// chrg_nor_sw_rel((eIDX_NOR_CH)ch,ID_SINK);
// pTest->work_step = SET_DYNA_CURR1;
// break;
// case SET_DYNA_CURR1: // 设置第一路输出电流
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_L1, pTest->change_test.curr1_set);
// pTest->work_step = SET_DYNA_TIME1;
// #if SINK_TEST_DEBUG
// rt_kprintf("Curr1: %d\n", pTest->change_test.curr1_set);
// #endif
// break;
// case SET_DYNA_TIME1: // 设置第一阶段保持时间
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_T1 , pTest->change_test.time1_set);
// pTest->work_step = SET_DYNA_CURR2;
// #if SINK_TEST_DEBUG
// rt_kprintf("Time1: %d\n", pTest->change_test.time1_set);
// #endif
// break;
// case SET_DYNA_CURR2: // 设置第二路输出电流
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_L2 , pTest->change_test.curr2_set);
// pTest->work_step = SET_DYNA_TIME2;
// #if SINK_TEST_DEBUG
// rt_kprintf("Curr2: %d\n", pTest->change_test.curr2_set);
// #endif
// break;
// case SET_DYNA_TIME2: // 设置第二阶段保持时间
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_T2 , pTest->change_test.time2_set);
// pTest->work_step = SET_DYNA_RISE_SLEW_RATE;
// #if SINK_TEST_DEBUG
// rt_kprintf("Time2: %d\n", pTest->change_test.time2_set);
// #endif
// break;
// case SET_DYNA_RISE_SLEW_RATE: // 设置电流上升斜率
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_Rise_Slew_Rate , pTest->change_test.k_Rise);
// pTest->work_step = SET_DYNA_FALL_SLEW_RATE;
// #if SINK_TEST_DEBUG
// rt_kprintf("Rise Slew Rate: %d\n", pTest->change_test.k_Rise);
// #endif
// break;
// case SET_DYNA_FALL_SLEW_RATE: // 设置电流下降斜率
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_Fall_Slew_Rate , pTest->change_test.k_Fall);
// pTest->work_step = SET_DYNA_CND_MODE;
// #if SINK_TEST_DEBUG
// rt_kprintf("Fall Slew Rate: %d\n", pTest->change_test.k_Fall);
// #endif
// break;
// case SET_DYNA_CND_MODE: // 标记动态测试为运行状态
// chrg_set_sou_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_CMD_MODE_FLAG , ModbusRTU_DYNA_CMD_MODE_RUN);
// pTest->work_step = SET_DYNA_RUNNING;
// pTest->work_step = SET_DYNA_CND_MODE;
// #if SINK_TEST_DEBUG
// rt_kprintf("Fall Slew Rate: %d\n", pTest->change_test.k_Fall);
// #endif
// break;
// case SET_DYNA_RUNNING: // 启动整机工作,锁定当前运行步骤、清空标志位
// chrg_set_sou_reg((eIDX_SOU_CH)ch, REG_WORK, WORK_START);
// pTest->work_step = SET_DYNA_RUNNING;
// pTest->work_step = 0x11;
// pSW->change_flag = 0;
// break;
// case 0x11:
// break;
// default:
// #if SINK_TEST_DEBUG
// rt_kprintf("Invalid work step: %d\n", pTest->work_step);
// #endif
// break;
// }
//}
////=============================================================================
//// 短路测试停止处理函数
//// 依据 stop_step 分步执行停止流程,清除测试标记并跳转状态
////=============================================================================
//void chrg_nor_sink_short_test_stop(rt_uint8_t idx, struct chrg_switch_t *pSW,rt_uint8_t *enable)
//{
// struct test *pTest = &pSW->sink.test;
// switch (pTest->stop_step)
// {
// case TEST_STOP_CMD_MODE: // 下发停止指令,关闭短路测试运行模式
// chrg_set_sou_reg(idx, ModbusRTU_ShortTest_CMD_MODE_FLAG, ModbusRTU_DYNA_CMD_MODE_STOP);
// // pTest->stop_step = TEST_STOP_RUN;
// // break;
// // case TEST_STOP_RUN: // 清除测试标志,切换至负载状态管理流程
// //chrg_set_sou_reg(idx, REG_WORK, WORK_STOP);
// //pTest->stop_step = TEST_STOP_REL;
// //chrg_nor_sw_rel((eIDX_NOR_CH)idx,0);
// //*enable = 0;
// pSW->change_flag = 0;
// pSW->sink.test.test_mode = 0; // 清空短路测试标记
// pSW->sub = 21; // IDX_SET_SINK_WORK_STATE; 跳转至负载工作状态处理
// break;
// default:
// break;
// }
//}
////=============================================================================
//// OCP过流保护测试停止处理函数
////=============================================================================
//void chrg_nor_sink_OCP_test_stop(rt_uint8_t idx, struct chrg_switch_t *pSW,rt_uint8_t *enable)
//{
// struct test *pTest = &pSW->sink.test;
// switch (pTest->stop_step)
// {
// case TEST_STOP_CMD_MODE: // 下发停止指令,关闭OCP测试运行模式
// chrg_set_sou_reg((eIDX_SOU_CH)idx, ModbusRTU_OCPTest_CMD_MODE_FLAG , ModbusRTU_DYNA_CMD_MODE_STOP);
// pSW->change_flag = 0;
// pSW->sink.test.test_mode = 0; // 清空OCP测试标记
// pSW->sub = 21; // IDX_SET_SINK_WORK_STATE;
// break;
// default:
// break;
// }
//}
////=============================================================================
//// 动态负载测试停止处理函数
////=============================================================================
//void chrg_nor_sink_change_test_stop(rt_uint8_t idx, struct chrg_switch_t *pSW,rt_uint8_t *enable)
//{
// struct test *pTest = &pSW->sink.test;
// switch (pTest->stop_step)
// {
// case TEST_STOP_CMD_MODE: // 下发停止指令,关闭动态测试运行模式
// chrg_set_sou_reg((eIDX_SOU_CH)idx, ModbusRTU_DYNA_CMD_MODE_FLAG , ModbusRTU_DYNA_CMD_MODE_STOP);
// pSW->change_flag = 0;
// pSW->sink.test.test_mode = 0; // 清空动态测试标记
// pSW->sub = 21; // IDX_SET_SINK_WORK_STATE;
// break;
// default:
// break;
// }
//}
//sink开机初始化
void chrg_sink_work_init(eIDX_SOU_CH idx, struct chrg_switch_t *pSW)
{
struct chrg_south_t *pSOU = &chrgsouth;
struct chrg_north_t *pNOR = &chrgnorth;
pSW->sink.On_work = 1;
pSOU->enable[idx] = 1;
pSOU->online[idx] = 1;
pNOR->enable[idx] = 1;
chrg_nor_sw_rel((eIDX_NOR_CH)idx, ID_SINK); //打开北向继电器
// 1. 电流输出置0
chrg_sou_com_batch_add_reg(idx, REG_CURRENT_OUT+1, 0);
// 2. 设置硬件恒压/恒流模式
chrg_sou_com_batch_add_reg(idx,REG_MODE,pSW->CV_mode);
switch(pSW->sink.test.test_mode_old){
case 0:
break;
case 1://短路测试退出
chrg_sou_com_batch_add_reg((eIDX_SOU_CH)idx, ModbusRTU_ShortTest_CMD_MODE_FLAG , ModbusRTU_DYNA_CMD_MODE_STOP);
break;
case 2:
break;
case 3:
chrg_sou_com_batch_add_reg((eIDX_SOU_CH)idx, ModbusRTU_DYNA_CMD_MODE_FLAG , ModbusRTU_DYNA_CMD_MODE_STOP);
break;
}
pSW->sink.test.test_mode_old = 0;
pSW->sink.work_mode = SINK_WORK_WAIT;
}
//sink进入运行状态
void chrg_sink_work_volt_runing(eIDX_SOU_CH idx, struct chrg_switch_t *pSW){
chrg_sou_com_batch_add_reg(idx, 0x01, 0x02);
//打开主继电器
chrg_sou_com_batch_add_reg(idx, 0x01, 0x03);
if(pSW->CV_mode == MODE_CONSTANT_VOLTAGE)
{
chrg_sou_com_batch_add_reg(idx, REG_VOLTAGE_OUT+1, pSW->sink.loadv);
}
else
{
chrg_sou_com_batch_add_reg(idx, REG_CURRENT_OUT+1, pSW->sink.loadc);
}
chrg_sou_com_batch_add_reg(idx, REG_WORK, WORK_START);
}
//sink进入低电压状态
void chrg_sink_nor_work_low(eIDX_SOU_CH idx, struct chrg_switch_t *pSW)
{
chrg_sou_com_batch_add_reg(idx, 0x01, 0x00);
chrg_sou_com_batch_add_reg(idx, REG_WORK, WORK_STOP);
}
//com端关机流程
void chrg_sink_nor_work_off(eIDX_SOU_CH idx, struct chrg_switch_t *pSW)
{
struct chrg_south_t *pSOU = &chrgsouth;
struct chrg_north_t *pNOR = &chrgnorth;
pSW->sink.On_work = 0;
pSOU->enable[idx] = 0;
pSOU->online[idx] = 0;
pNOR->enable[idx] = 0;
chrg_nor_sw_rel((eIDX_NOR_CH)idx, 0); //关闭北向继电器
chrg_sou_com_batch_add_reg(idx, 0x01, 0x00);
chrg_sou_com_batch_add_reg(idx, REG_WORK, WORK_STOP);
}
//动态测试启动
void chrg_sink_change_ON(rt_uint8_t ch, struct chrg_switch_t *pSW)
{
struct test *pTest = &pSW->sink.test;
chrg_sou_com_batch_add_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_L1, pTest->change_test.curr1_set);
chrg_sou_com_batch_add_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_T1 , pTest->change_test.time1_set);
chrg_sou_com_batch_add_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_L2 , pTest->change_test.curr2_set);
chrg_sou_com_batch_add_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_T2 , pTest->change_test.time2_set);
chrg_sou_com_batch_add_reg((eIDX_SOU_CH)ch, ModbusRTU_DYNA_CMD_MODE_FLAG , ModbusRTU_DYNA_CMD_MODE_RUN);
chrg_sou_com_batch_add_reg((eIDX_SOU_CH)ch, REG_WORK, WORK_START);
}
//短路测试启动
void chrg_sink_SHOUT_ON(rt_uint8_t ch, struct chrg_switch_t *pSW)
{
struct test *pTest = &pSW->sink.test;
chrg_sou_com_batch_add_reg((eIDX_SOU_CH)ch, ModbusRTU_ShortTest_CMD_MODE_FLAG , ModbusRTU_DYNA_CMD_MODE_RUN_ALWAYS_KEPP); //保持
chrg_sou_com_batch_add_reg((eIDX_SOU_CH)ch, REG_WORK, WORK_START);
}
//负载工作
void chrg_sink_work(eIDX_SOU_CH idx, struct chrg_switch_t *pSW){
static uint8_t last_state[TOTAL_SOU_CHS] ={100,100,100,100};
rt_uint8_t work_mode = pSW->sink.work_mode;
// 本次状态和上次一致,直接跳过,不重复下发寄存器
if (work_mode == last_state[idx])
{
return;
}
chrg_sou_com_sou_set();
switch(work_mode){
case SINK_WORK_INIT:
chrg_sink_work_init(idx,pSW);
break;
case SINK_WORK_WAIT:
break;
case SINK_WORK_RUNING:
chrg_sink_work_volt_runing(idx,pSW);
break;
case SINK_WORK_RUNING_2:
chrg_sink_work_volt_runing(idx,pSW);
break;
case SINK_WORK_ON_TEST_CHANGE:
chrg_sink_change_ON(idx,pSW);
break;
case SINK_WORK_ON_TEST_SHOUT:
chrg_sink_SHOUT_ON(idx,pSW);
break;
case SINK_WORK_LOW:
chrg_sink_nor_work_low(idx,pSW);
break;
case SINK_WORK_STOP:
chrg_sink_nor_work_off(idx,pSW);
break;
}
// 更新缓存,保存本次最新状态
last_state[idx] = work_mode;
}
+241 -57
View File
@@ -11,20 +11,63 @@
#define __CHRG_SINK_H__
#include <rtthread.h>
struct chrg_switch_t;
#include "chrg_def.h"
#include "chrg_south.h"
// 冠达快充板(SINK)通讯协议
// SINK的ID为1,波特率200K,TTL
#define SINK_NO_TEST 0
#define SINK_TEST_SHORT 1
#define SINK_TEST_OCP 2
#define SINK_TEST_DYNA 3
//短路测试结构体
struct test_short {
rt_uint16_t hold_time; // 短路测试时间
rt_uint8_t set_mode; // 0为测试后电流保持设定的设定时间后恢复;1为一直保持
rt_uint8_t have_curr_flag; //0为不带,1为带(默认)
};
//OCP测试结构体
struct test_OCP {
rt_uint16_t start_curr; // 起始电流
rt_uint16_t end_curr; // 结束电流
rt_uint16_t change_curr; // 步进电流,单位mA
rt_uint16_t change_keep_time; // 每步保持时间,单位ms(1-100)
rt_uint16_t hold_time; // OCP触发后保持时间,单位ms
rt_uint16_t set_mode; // 0为测试后电流保持设定的设定时间后恢复;1为一直保持
rt_uint16_t stop_volt; // 停止电压,单位mv
rt_uint8_t hold_curr; // OCP触发后是否带载,0=带载,1=不带载
//rt_uint16_t Vtrig_Stop; // 达到触发OCP流点的电压值;
// rt_uint16_t Volt_OCP; // 无论short测试成功或者失败,都给出短路恒流值的时候的电压
// rt_uint16_t Current_OCP; // 无论short测试成功或者失败,都给出短路恒流值的时候的电流
// rt_uint_t change_mode; // 0=测试后电流设置为0;1=达到标准则电流立即为0;2=保持当前电流
};
//动态测试结构体
struct test_change {
rt_uint16_t curr1_set; // 电流1设置值
rt_uint16_t time1_set; // 电流1保持时间设置值,单位0.01s
rt_uint16_t curr2_set; // 电流2设置值
rt_uint16_t time2_set; // 电流2保持时间设置值,单位0.01s
rt_uint16_t k_Rise; // 上升斜率,单位0.001(A/us)
rt_uint16_t k_Fall; // 下降斜率,单位0.001(A/us)
// rt_uint16_t start_time; // 启动后稳定时间,单位ms
// rt_uint16_t work_step; // 总共多少次步进
};
struct test
{
struct test_short short_test;
struct test_change change_test;
struct test_OCP OCP_test;
rt_uint8_t test_mode_old; //进入测试模式后的角色
rt_uint8_t test_mode; // 测试标志位,0=无测试,1=短路测试,2=OCP测试,3=动态测试
rt_uint8_t run_flag; // 运行标志位,0=停止,1=运行,2=继续,3=结束
rt_uint8_t work_step; // 测试步骤,0=初始,1=第一步,2=第二步,3=第三步
rt_uint8_t stop_step; // 停止步骤,0=初始,1=第一步,2=第二步,3=第三步
};
#define SINK_CMD_GET_VOLTAGE 0x20 // 读取变电压板电压
// (需要实时比较设置的快充指令和读回来的快充指令,若有不一样,则重设)(注意vooc模式下数据返回会很慢)
// 发送 0B 00 01 20 loadvh loadvl loadch loadcl nc nc CRC8
// 长度+nc+id+指令+负载电压(2字节,0.01V)+负载电流(2字节,mA)+2个预留字节+CRC8校验
// 接收 15 00 01 20 VH VL qc_data1 qc_data2 qc_data3 qc_data4 qc_data5 qc_data6 ver_h ver_l nc nc nc nc nc nc CRC8
// 长度+nc+ID+指令+2字节电压(0.01V)+6字节快充指令+2字节版本号+6字节预留+CRC8校验
struct sink_vc_t {
rt_uint8_t voltage; // 电压 0.01V
@@ -33,17 +76,9 @@ struct sink_vc_t {
};
#define SINK_CMD_GET_PD 0x13 // 读取源端的PD协议数据(当前为PDO,PPS,PD3.1,AVS协议时有效)
// 发送 05 00 01 13 2A
// 接收 XX 00 01 13 // 长度(根据实际计算)+NC+ID+指令
// 00 00 VMINH VMINL VMAXH VMAXL CURH/PORH CURL/PORL NC NC NC NC NC NC
// 源类型(1字节,00为PDO,03为APDO) + PPS类型(1字节,源类型为3时有效,00为SPR PPS,01为EPR AVS,02为SPR AVS) +
// 最小电压(2字节,mV) + 最大电压(2字节,mV) + 最大电流/功率(2字节,mA/W) + 预留(6字节,当PPS类型为02时有效,意义与前6字节一致)
// 00 00 VMINH VMINL VMAXH VMAXL CURH/PORH CURL/PORL NC NC NC NC NC NC
// ...... CRC8
#define SINK_CMD_SET_CC 0x17 // 设置CC线
// 发送 06 00 01 17 00 2A // 长度+nc+id+指令+CC(0为都选通,1为选择CC1,2为CC2,3为全断开)+CRC8校验
// 接收 05 00 01 17 2A // 长度+nc+id+指令+CRC8校验
// CC 线选通
enum {
@@ -54,8 +89,7 @@ enum {
};
#define SINK_CMD_SET_LEVEL 0x16 // 设置CC线电平
// 发送 06 00 01 16 00 2A // 长度+nc+id+指令+电平等级(0-10,默认7)+CRC8校验
// 接收 05 00 01 16 2A // 长度+nc+id+指令+CRC8校验
// 电平等级
enum {
@@ -72,45 +106,85 @@ enum {
CC_LVL_10 = 10
};
//负载协议
typedef enum {
LOAD_PRO_NONE = 0xFE, // 0.无快充(标准)
LOAD_PRO_QC20 = 0xF8, // 1.QC2.0
LOAD_PRO_QC30 = 0xF6, // 2.QC3.0
LOAD_PRO_FCP = 0xF2, // 3.FCP
LOAD_PRO_AFC = 0xF9, // 4.AFC
LOAD_PRO_SCP = 0xF3, // 5.SCP
LOAD_PRO_VIVO = 0xFD, // 6.VIVO
LOAD_PRO_TFC_RFC = 0xF7, // 7.传音/TFC/RFCN
LOAD_PRO_PDO_MANUAL = 0xFB, // 8.PDO手动
LOAD_PRO_PDO_AUTO = 0xFB, // 9.PDO自动
LOAD_PRO_PPS_MANUAL = 0xFC, // 10.PPS手动
LOAD_PRO_PPS_AUTO = 0xFC, // 11.PPS自动
LOAD_PRO_PD31AVS = 0xE1, // 12.PD3.1
LOAD_PRO_UFCS = 0xE0, // 13.UFCS
LOAD_PRO_VOOC = 0xE2, // 14.VOOC
LOAD_PRO_AVS = 0xE3, // 15.AVS
// 设置快充协议(VOOC,UFCS模式下切换其他模式时,需要先把V+,V-,D+,D-,
// CC等和变电压有关的继电器切至悬空,至少等待1s后,等能读到数据且快充指令正确,再把继电器切回)
// 发送格式 长度+NC+ID+6字节快充数据+CRC8
// 接收 长度+NC+ID+指令+CRC8
TOTAL_LOAD_PROS // 负载协议总数
} eLOAD_PRO;
// 负载协议映射表:十六进制值 → 协议名称
typedef struct {
rt_uint8_t pro_val; // 协议对应的数值(如0xF8)
int pro_name; // 协议名称(如"QC2.0")
} LoadProMap_t;
static const LoadProMap_t load_pro_map[] = {
{LOAD_PRO_NONE, 10},
{LOAD_PRO_QC20, 11},
{LOAD_PRO_QC30, 12},
{LOAD_PRO_FCP, 13},
{LOAD_PRO_AFC, 14},
{LOAD_PRO_SCP, 15},
{LOAD_PRO_VIVO, 16},
{LOAD_PRO_TFC_RFC, 17},
{LOAD_PRO_PDO_MANUAL, 18},
{LOAD_PRO_PDO_AUTO, 19},
{LOAD_PRO_PPS_MANUAL, 20},
{LOAD_PRO_PPS_AUTO, 21},
{LOAD_PRO_PD31AVS, 22},
{LOAD_PRO_UFCS, 23},
{LOAD_PRO_VOOC, 24},
{LOAD_PRO_AVS, 25}
};
// 命令码区分:负载(0x11-0x1F)
#define CMD_LOAD_QC20 0x11 // 负载-QC2.0
#define CMD_LOAD_QC30 0x12 // 负载-QC3.0
#define CMD_LOAD_FCP 0x13 // 负载-FCP
#define CMD_LOAD_AFC 0x14 // 负载-AFC
#define CMD_LOAD_SCP 0x15 // 负载-SCP
#define CMD_LOAD_VIVO 0x16 // 负载-VIVO
#define CMD_LOAD_TFC 0x17 // 负载-TFC
#define CMD_LOAD_PD0_MAN 0x18 // 负载-PD0手动
#define CMD_LOAD_PD0_AUTO 0x19 // 负载-PDO自动
#define CMD_LOAD_PPS_MAN 0x1A // 负载-PPS手动
#define CMD_LOAD_PPS_AUTO 0x1B // 负载-PPS自动
#define CMD_LOAD_PD31 0x1C // 负载-PD3.1
#define CMD_LOAD_UFCS 0x1D // 负载-UFCS
#define CMD_LOAD_VOOC 0x1E // 负载-VOOC
#define CMD_LOAD_AVS 0x1F // 负载-AVS
#define LOAD_PRO_MAP_NUM (sizeof(load_pro_map)/sizeof(load_pro_map[0])) // 映射表长度
#define SINK_CMD_SET_QC20 0xF8 // QC2.0
// QC2.0 电压5V/9V/12V/20V 命令:0A 00 01 F8 5A 00 00 00 00 2A
// 第5个字节为电压(0.1V)
#define SINK_CMD_SET_QC30 0xF6 // QC3.0
// QC3.0 电压3.3-20V 命令:0A 00 01 F6 5A 00 00 00 00 2A
// 第5个字节为电压(0.1V)
#define SINK_CMD_SET_FCP 0xF2 // FCP
// FCP 电压5V/9V/12V 命令:0A 00 01 F2 78 00 00 00 00 2A
// 第5个字节为电压(0.1V)
#define SINK_CMD_SET_AFC 0xF9 // AFC
// AFC 命令:0A 00 01 F9 46 00 00 00 00 2A
// 第5个字节为变电压数据,详细参考AFC文档
#define SINK_CMD_SET_SCP 0xF3 // SCP
// SCP 命令:0A 00 01 F3 27 10 0F A0 00 2A
// 5,6字节为电压(mv),7,8字节为电流(mA)
#define SINK_CMD_SET_VIVO 0xFD // VIVO
// VIVO 命令:0A 00 01 FD 27 10 00 00 00 2A
// 5,6字节为电压(mv),7,8字节为电流(mA)
#define SINK_CMD_SET_TFC 0xF7 // TFC 传音
// 传音/TFC 命令:0A 00 01 F7 2E E0 00 00 00/01 2A
// 5,6字节为电压(mv), 7,8字节为电流(mA), 9字节为RFC/TFC选择
#define SINK_CMD_SET_PD0 0xFB // PD0 手动/自动
// PDO手动,需要设定组号,电压和产品相关,命令:0A 00 01 FB 05 00 00 00 00 2A
// 5字节为组号
// PDO自动,组号设为0,自动变到指定电压,命令:0A 00 01 FB 00 2E E0 00 00 2A
// 5字节为组号,6,7字节为电压(mv),8、9字节为电流(mA)
enum {
SET_MANUAL = 0, // 手动
@@ -118,39 +192,138 @@ enum {
};
#define SINK_CMD_SET_PPS 0xFC // PPS 手动/自动
// PPS手动,需要设定组号、电压、电流,电流0最大, 命令: 0A 00 01 FC 06 4E 20 00 00 2A
// 5字节为组号,6,7字节为电压(mv),8、9字节为电流(mA)
// PPS自动,组号设为0,设定电压、电流,电流0最大,命令:0A 00 01 FC 00 4E 20 00 00 2A
// 5字节为组号,6,7字节为电压(mv),8、9字节为电流(mA)
#define SINK_CMD_SET_PD3P1 0xE1 // PD3.1
// PD3.1, 命令:0A 00 01 E1 00 2328 07d0 2A (组号设置和电压设置都支持)
// 5字节为组号,6,7字节为电压(mv),8、9字节为电流(mA)
#define SINK_CMD_SET_UFCS 0xE0 // UFCS
// UFCS,命令:0A 00 01 E0 00 2328 07d0 2A (组号设置和电压设置都支持)
// 5字节为组号,6,7字节为电压(mv),8、9字节为电流(mA)
#define SINK_CMD_SET_VOOC 0xE2 // VOOC
// VOOC,电压10/11V, 命令:0A 00 01 E2 00 0000 0000 2A
#define SINK_CMD_SET_AVS 0xE3 // AVS
// AVS,命令:0A 00 01 E3 00 4e 20 07 d0 2A (组号设置和电压设置都支持)
// 5字节为组号,6,7字节为电压(mv),8、9字节为电流(mA)
enum {
SINK_WORK_INIT =0,
SINK_WORK_WAIT,
SINK_WORK_VOLT_OK,
SINK_WORK_RUNING,
SINK_WORK_RUNING_2,
SINK_WORK_LOW,
SINK_WORK_STOP,
SINK_WORK_ON_TEST_CHANGE,
SINK_WORK_ON_TEST_SHOUT,
};
// sink 参数结构
struct chrg_sink_t {
rt_uint16_t loadv; // 负载电压 0.01V
rt_uint16_t loadc; // 负载电流 mA
rt_uint16_t loadv; // 设置负载电压 0.01V
rt_uint16_t loadc; // 设置负载电流 mA
rt_uint16_t pro_loadv; // 设置协议负载电压 0.01V
rt_uint16_t pro_loadc; // 设置协议负载电流 mA
rt_uint16_t volt_on; // 启动电压
rt_uint16_t Pro_Group; // 设置组号
struct sink_vc_t vc;
struct vc_pd_t pd_get[2];
rt_uint8_t cc_onoff; // 设置CC线开关
rt_uint8_t cc_lvl; // 设置CC线电平等级(0-10,默认7)
struct test test; //负载测试10++++++++++++++++
rt_uint16_t protocol; //协议类型
rt_uint8_t cc_set; // 选择cc线
rt_uint8_t cc_lvl; // 设置CC线电平等级(0-10,默认7)
rt_uint8_t Now_State; // 当前状态,0=停止,1=运行
rt_uint8_t On_work;
rt_uint8_t change_cv_flag;
rt_uint8_t change_source_flag; // 从sink切换到source标志位
rt_uint8_t work_mode; // 0=停止 1=工作 2=低电压
};
//纹波寄存器
#define ModbusRTU_Ripple_Value 0x35 //读取纹波
/******************** 负载测试 ************************* */
#define ModbusRTU_CAL_WriteEnable 0x34 //使能写入;0x4361代表使能写入;C+a ASCII码
#define ModbusRTU_Test_CMD 0x4361 //
//short测试
#define SHORT_TEST 0x01
//短路测试寄存器
#define ModbusRTU_ShortTest_CMD_MODE_FLAG 0x40 ////16位;0x0101; 01启动,低字节的01,保持电流,为0是释放电流; 20260601新增一个低字节的bit7=0用于是恢复以前的状态,bit7=1是将卸载电流归零;
#define ModbusRTU_ShortTest_Hold_Time 0x41 //单位是ms,最大65535ms,给0是立即释放,给一个时间值,是保持这个时间不变;
//#define ModbusRTU_ShortTest_CurrentShort 0x42 //无论测试成功或者失败,都给出短路恒流值的时候的电压
//短路测试执行步骤
#define SET_SHORT_CMD_MODE 0x01
#define SET_SHORT_WRITE_ENABLE 0x02
#define SET_SHORT_RUN 0x03
//短路测试结束步骤
#define READ_SHORTEST_VOLT_SHORT 0x03
#define READ_SHORTEST_CURRENT_SHORT 0x04
//OCP测试
#define OCP_TEST 0X02
//OCP测试功率板寄存器
#define ModbusRTU_OCPTest_CMD_MODE_FLAG 0x43 //16位;0x0101; 01启动,低字节的01,保持/卸载;
#define ModbusRTU_OCPTest_StartCurrent 0x44 //起始电流
#define ModbusRTU_OCPTest_StopCurrent 0x45 //终止电流
#define ModbusRTU_OCPTest_Step_CURR 0x46 //每一步的电流
#define ModbusRTU_OCPTest_Step_Hold_Time 0x47 //每一步的保持时间;默认10ms;范围1ms到100ms;
#define ModbusRTU_OCPTest_Vtrig_Stop 0x48 //达到触发OCP流点的电压值;
#define ModbusRTU_OCPTest_Hold_Time 0x49
#define ModbusRTU_OCPTest_HOLD_CURR 0x4A
//OCP测试步骤
#define SET_OCP_STARTCURR 0x01
#define SET_OCP_ENDCURR 0x02
#define SET_OCP_STEP 0x03
#define SET_OCP_STEP_HOLD_TIME 0x04
#define SET_OCP_HOLD_TIME 0x05
#define SET_OCP_CMD_MODE_RUN 0x06
#define SET_OCP_WRITE_ENABLE 0x07
#define SET_OCP_RUNNING 0x08
#define SET_OCP_HOLD_END_HAVE_CURR 0x09
#define SINK_OCP_STOP_VOLT 0x0A
//OCP测试结果读取
#define READ_OCP_VTRIG_STOP 0x03
#define READ_OCP_VOLT_OCP 0x04
#define READ_OCP_CURRENT_OCP 0x05
//动态测试
#define DYNA_TEST 0X03
//动态测试功率板寄存器
#define ModbusRTU_DYNA_CMD_MODE_FLAG 0x4B //动态测试 CMD启动、退出、 以及模式:Continuous、PULSE、Toggle;LSB8 BIT7 短路测试时候的电流:保持/归零;bit1 过流; bit0 成功/失败
#define ModbusRTU_DYNA_L1 0x4C //动态测试电流1
#define ModbusRTU_DYNA_L2 0x4D //动态测试电流2
#define ModbusRTU_DYNA_T1 0x4E //动态测试电流1的时间
#define ModbusRTU_DYNA_T2 0x4F //动态测试电流2的时间
#define ModbusRTU_DYNA_Rise_Slew_Rate 0x50 //动态测试上升斜率
#define ModbusRTU_DYNA_Fall_Slew_Rate 0x51 //动态测试下降斜率
//动态测试步骤
#define SET_DYNA_CURR1 0x01
#define SET_DYNA_CURR2 0x02
#define SET_DYNA_TIME1 0x03
#define SET_DYNA_TIME2 0x04
#define SET_DYNA_RISE_SLEW_RATE 0x05
#define SET_DYNA_FALL_SLEW_RATE 0x06
#define SET_DYNA_CND_MODE 0x07
#define SET_DYNA_WRITE_ENABLE 0x08
#define SET_DYNA_RUNNING 0x09
//测试停止通用前三步
#define TEST_STOP_CMD_MODE 0x00
#define TEST_STOP_RUN 0x01
#define TEST_STOP_REL 0x02
//短路和负载共用运行寄存器值
#define ModbusRTU_DYNA_CMD_MODE_RUN_NO_CURR 0x0100 //在保持时间结束后电流为0
//#define ModbusRTU_DYNA_CMD_MODE_RUN_KEPP 0x0101 //保持时间后恢复之前电流
#define ModbusRTU_DYNA_CMD_MODE_RUN_ALWAYS_KEPP 0x0101 //一直保持拉低后的电流
//动态测试运行寄存器值
#define ModbusRTU_DYNA_CMD_MODE_RUN 0x0101 //动态启动
//测试通用停止寄存器值
#define ModbusRTU_DYNA_CMD_MODE_STOP 0x0000 //停止
#define ModbusRTU_SYS_Reset 0x61 //系统复位指令,如果异常过压,通常发指令,让系统复位
/*****************************************************************
函数名称: sink_get_vc
函数描述: sink电压电流查询请求
@@ -200,7 +373,18 @@ extern int sink_set_cc_lvl (rt_uint8_t lvl);
其它说明: -
*****************************************************************/
extern int sink_set_pd (rt_uint8_t pd, rt_uint8_t *buf);
// ===================== 负载测试函数声明 =====================
extern void sink_test_short_set (struct chrg_switch_t *pSW, rt_uint8_t *pData, rt_uint8_t run_flag);
extern void sink_test_ocp_set (struct chrg_switch_t *pSW, rt_uint8_t *pData, rt_uint8_t run_flag);
extern void sink_test_dynamic_set(struct chrg_switch_t *pSW, rt_uint8_t *pData, rt_uint8_t run_flag);
extern void chrg_nor_sink_short_test(rt_uint8_t ch, struct chrg_switch_t *pSW);
extern void chrg_nor_sink_OCP_test(rt_uint8_t ch, struct chrg_switch_t *pSW);
extern void chrg_nor_sink_change_test(rt_uint8_t ch, struct chrg_switch_t *pSW);
extern void chrg_nor_sink_test_stop(rt_uint8_t ch,struct chrg_switch_t *pSW,rt_uint8_t *enable);
extern void chrg_nor_sink_test_run(rt_uint8_t ch, struct chrg_switch_t *pSW);
extern void chrg_sink_work(eIDX_SOU_CH idx, struct chrg_switch_t *pSW);
#endif
+801 -23
View File
@@ -8,13 +8,14 @@
******************************************************************************/
#include <rtthread.h>
#include "chrg_source.h"
#include "chrg_north.h"
#include <string.h>
#include "chrg_north_pkg.h"
#include "chrg_utils.h"
#include "chrg_roll_nor.h"
#include "chrg_source.h"
rt_uint8_t Pro_Group_VCMM[11][8] = {
{0} // 11个挡位,8个参数(src, pps, vmin_H,vmin_L, vmax_H,vmax_L,cur_set_H,cur_set_L)
};
/*****************************************************************
函数名称: source_get_vc
函数描述: source电压电流查询请求
@@ -78,6 +79,539 @@ int source_set_cc_lvl (rt_uint8_t lvl)
return chrg_north_send(frame, len);
}
/*****************************************************************
函数名称: source_set_cc_lvl
函数描述: source 设置 cc 等级
输入参数: lvl:等级
输出参数: -
返回说明: <0: 错误 >0:发送长度
其它说明: -
*****************************************************************/
int source_set_cc_choose (rt_uint8_t cc_set)
{
rt_uint16_t len = 0;
rt_uint8_t data[8] = {0};
rt_uint8_t frame[16] = {0};
data[0] = cc_set;
chrg_north_pkg_encode(ID_SOURCE, SRC_CMD_SET_CC_CHOOSE, data, 1, frame, &len);
rt_kprintf("\n");
for(int i=0;i<len;i++){
rt_kprintf("%d ");
}
rt_kprintf("\n");
return chrg_north_send(frame, len);
}
/*
填入单档
*/
rt_uint8_t parse_mulit_gear_One(rt_uint16_t min_volt_mv,rt_uint16_t max_volt_mv, rt_uint16_t max_curr_ma) {
// 清空缓冲区
rt_memset(Pro_Group_VCMM, 0, sizeof(Pro_Group_VCMM));
Pro_Group_VCMM[0][0] = 0x00; // src
Pro_Group_VCMM[0][1] = 0x00; // pps
Pro_Group_VCMM[0][2] = (min_volt_mv >> 8) & 0xFF; // vmin_H
Pro_Group_VCMM[0][3] = min_volt_mv & 0xFF; // vmin_L
Pro_Group_VCMM[0][4] = (max_volt_mv >> 8) & 0xFF; // vmax_H
Pro_Group_VCMM[0][5] = max_volt_mv & 0xFF; // vmax_L
Pro_Group_VCMM[0][6] = (max_curr_ma >> 8) & 0xFF; // cur_set_H
rt_kprintf("H_C=%02x",Pro_Group_VCMM[0][6]);
Pro_Group_VCMM[0][7] = max_curr_ma & 0xFF; // cur_set_L
rt_kprintf("L_C=%02x\n",Pro_Group_VCMM[0][7]);
return 0;
}
/*****************************************************************
函数名称: parse_power_single_gear
函数描述: 单档电源协议解析函数(QC3.0/QC2.0/SCPB)
输入参数: protoCmd: 协议命令码(0x27/0x28/0x23)
pData: 协议数据区缓冲区(状态+通道+CC线+最大电压+最大电流)
reqLen: 帧总长度
pSW: 通道协议配置结构体指针
输出参数: -
返回说明: -
其它说明: 数据格式:状态+通道(1)+CC线(1)+最大电压(2)+最大电流(2)
*****************************************************************/
void parse_power_single_gear(rt_uint8_t protoCmd, rt_uint8_t *pData, rt_uint16_t reqLen,uint8_t *pro_gear_idx,uint8_t *pro,rt_uint16_t *protect_curr)
{
rt_uint16_t min_volt_mv = 0; // 最小输出电压(mv)
rt_uint16_t max_volt_mv = 0; // 最大输出电压(mV)
rt_uint16_t max_curr_ma = 0; // 最大输出电流(mA)
// 数据区索引:0=状态+通道,1=CV,2=CC线,3-4=最小电压,5-6=最大电压,7-8最大电流
min_volt_mv = u8v_to_u16(&pData[3]); // 大端
max_volt_mv = u8v_to_u16(&pData[5]); // 大端
max_curr_ma = u8v_to_u16(&pData[7]); // 大端
*protect_curr = u8v_to_u16(&pData[9]); // 大端
// rt_kprintf("\n");
// for(int i=0;i<10;i++){
// rt_kprintf("%0x",pData[i]);
// }
// rt_kprintf("\n");
#if PRO_TEST_DEBUG
rt_kprintf("one_gear");
rt_kprintf("min_volt_mv = %d\n",min_volt_mv);
rt_kprintf("max_volt_mv = %d\n",max_volt_mv);
rt_kprintf("prtect_curr= %04x",*protect_curr);
#endif
*pro_gear_idx = 1; // 单档协议固定1
// 按协议命令码赋值
switch (protoCmd)
{
case 0x27: // QC3.0
*pro = PRO_QC30;
break;
case 0x28: // QC2.0
*pro = PRO_QC20;
break;
case 0x23: // SCPB
*pro = PRO_SCPB;
break;
default:
rt_kprintf("单档电源协议不支持:0x%02X\n", protoCmd);
return;
}
parse_mulit_gear_One(min_volt_mv,max_volt_mv,max_curr_ma);
return;
}
/*****************************************************************
函数名称: parse_pd_11group_pdo
函数描述: 解析PD协议11组PDO数据,填充8参数高低字节缓冲区
输入参数: pdoData: 11组PDO数据缓冲区(小端序,44字节)
pdo_group_num: 实际PDO组数
pSW: 通道协议配置结构体指针(仅校验)
输出参数: -
返回说明: -
其它说明: 1. type映射:0→src=0/pps=0;1→src=03/pps=00;2→src=03/pps=00;3→src=03/pps=01
2. 所有16位参数拆分为高/低字节填充
*****************************************************************/
void parse_pd_11group_pdo(rt_uint8_t *pdoData, rt_uint8_t pdo_group_num) {
rt_uint32_t pdo_val = 0;
rt_uint8_t pdo_type = 0;
rt_uint16_t vmin_mv = 0, vmax_mv = 0, cur_power = 0; // 16位原始值
// 清空缓冲区
rt_memset(Pro_Group_VCMM, 0, sizeof(Pro_Group_VCMM));
for (rt_uint8_t i = 0; i < pdo_group_num; i++) {
// 1. 拼接32位PDO值(低字节在前)
pdo_val = (rt_uint32_t)pdoData[i*4 + 3] << 24 |
(rt_uint32_t)pdoData[i*4 + 2] << 16 |
(rt_uint32_t)pdoData[i*4 + 1] << 8 |
(rt_uint32_t)pdoData[i*4];
// 2. 提取PDO类型(Bit30-31)
pdo_type = (pdo_val >> 30) & 0x03;
// 3. 按type映射src和pps
switch (pdo_type) {
case 0: // FPDO → src=0x00, pps=0x00
Pro_Group_VCMM[i][0] = 0x00;
Pro_Group_VCMM[i][1] = 0x00;
break;
case 1: // EPRPDO → src=0x03, pps=0x00
Pro_Group_VCMM[i][0] = 0x00;
Pro_Group_VCMM[i][1] = 0x01;
break;
case 2: // PPS → src=0x03, pps=0x00
Pro_Group_VCMM[i][0] = 0x03;
Pro_Group_VCMM[i][1] = 0x00;
break;
case 3: // EPR AVS → src=0x03, pps=0x01
Pro_Group_VCMM[i][0] = 0x03;
Pro_Group_VCMM[i][1] = 0x01;
break;
default:
rt_kprintf("parse_pd_11group_pdo: unknown PDO type=%d (index=%d)\n", pdo_type, i);
continue;
}
// 4. 解析电压/电流/功率(16位值)
switch (pdo_type) {
case 0: // FPDO(固定电源)
case 1: // EPRPDO(固定电源)
vmin_mv = vmax_mv = ((pdo_val >> 10) & 0x03FF) * 50; // 电压(mV)
cur_power = (pdo_val & 0x03FF) * 10; // 电流(mA)
break;
case 2: // PPS(可编程电源)
vmin_mv = ((pdo_val >> 8) & 0x00FF) * 100; // 最小电压(mV)
vmax_mv = ((pdo_val >> 17) & 0x00FF) * 100; // 最大电压(mV)
cur_power = (pdo_val & 0x7F) * 50; // 电流(mA)
break;
case 3: // EPR AVS(功率型)
vmin_mv = ((pdo_val >> 8) & 0x00FF) * 100; // 最小电压(mV)
vmax_mv = ((pdo_val >> 17) & 0x1FF) * 100; // 最大电压(mV)
cur_power = (pdo_val & 0xFF) * 1; // 功率(W)
break;
default:
vmin_mv = vmax_mv = cur_power = 0;
break;
}
// 5. 拆分高低字节填充缓冲区(核心)
// 最小电压拆分
Pro_Group_VCMM[i][2] = (vmin_mv >> 8) & 0xFF; // vmin_H
Pro_Group_VCMM[i][3] = vmin_mv & 0xFF; // vmin_L
// 最大电压拆分
Pro_Group_VCMM[i][4] = (vmax_mv >> 8) & 0xFF; // vmax_H
Pro_Group_VCMM[i][5] = vmax_mv & 0xFF; // vmax_L
// 电流/功率拆分
Pro_Group_VCMM[i][6] = (cur_power >> 8) & 0xFF; // cur_set_H
Pro_Group_VCMM[i][7] = cur_power & 0xFF; // cur_set_L
#if PRO_TEST_DEBUG
// 调试打印
rt_kprintf("max_H=%d",Pro_Group_VCMM[i][4]);
rt_kprintf("max_L=%d",Pro_Group_VCMM[i][5]);
rt_kprintf("min_H=%d",Pro_Group_VCMM[i][2]);
rt_kprintf("min_L=%d",Pro_Group_VCMM[i][3]);
if (pdo_type == 3) { // EPR AVS 打印功率
rt_kprintf("PDO[%d]:src=0x%02X, pps=0x%02X, V_MIN=%dmV(0x%02X%02X),V_MAX=%dmV(0x%02X%02X),C/P=%dW(0x%02X%02X)\n",
i, Pro_Group_VCMM[i][0], Pro_Group_VCMM[i][1],
vmin_mv, Pro_Group_VCMM[i][2], Pro_Group_VCMM[i][3],
vmax_mv, Pro_Group_VCMM[i][4], Pro_Group_VCMM[i][5],
cur_power, Pro_Group_VCMM[i][6], Pro_Group_VCMM[i][7]);
} else { // 其他类型打印电流
rt_kprintf("PDO[%d]: src=0x%02X, pps=0x%02X, V_MIN=%dmV(0x%02X%02X), V_MAX=%dmV(0x%02X%02X),C/P=%dmA(0x%02X%02X)\n",
i, Pro_Group_VCMM[i][0], Pro_Group_VCMM[i][1],
vmin_mv, Pro_Group_VCMM[i][2], Pro_Group_VCMM[i][3],
vmax_mv, Pro_Group_VCMM[i][4], Pro_Group_VCMM[i][5],
cur_power, Pro_Group_VCMM[i][6], Pro_Group_VCMM[i][7]);
}
#endif
}
}
/*****************************************************************
函数名称: parse_power_pdo_gear
函数描述: PDO档电源协议解析函数(PD协议)
输入参数: protoCmd: 协议命令码(0x2A)
pData: 协议数据区缓冲区(状态+通道+CC线+PDO组数+11组PDO+保留+保护电流+补偿电压)
reqLen: 帧总长度
pSW: 通道协议配置结构体指针
输出参数: -
返回说明: -
其它说明: 数据格式:状态+通道(1)+CC线(1)+PDO组数(1)+11组PDO(44)+保留(20)+保护电流(2)+补偿电压(2)
*****************************************************************/
void parse_power_pdo_gear(rt_uint8_t protoCmd, rt_uint8_t *pData, rt_uint16_t reqLen,uint8_t *pro_gear_idx,uint8_t *pro,rt_uint16_t *protect_ma)
{
rt_uint8_t pdo_group_num = 0; // PDO组数
rt_int16_t comp_volt_mv = 0; // 补偿电压(mV)
// 数据区索引:0=状态+通道,1=CC线,2=恒压恒流模式,3=PDO组数(bit12-15)
rt_kprintf("pdata=%04x",pData[3]);
pdo_group_num = (pData[3] >> 4) & 0x0F; // Bit12-15提取组数
rt_kprintf("num=%d\n",pdo_group_num);
*pro = PRO_PD0PSS;
*pro_gear_idx = pdo_group_num;
// 解析11组PDO(小端序,44字节)
parse_pd_11group_pdo(&pData[4], pdo_group_num);
// 解析保留字段(20字节) + 保护电流 + 补偿电压
*protect_ma = u8v_to_u16(&pData[4 + 44 + 20]); // 67-68字节
comp_volt_mv = (rt_int16_t)u8v_to_u16(&pData[4 + 44 + 22]); // 69-70字节
// #if PRO_TEST_DEBUG
rt_kprintf("project_curr=%d mA, add_volt=%d mV\n", *protect_ma, comp_volt_mv);
// #endif.
}
/*****************************************************************
函数名称: parse_mulit_gear_more
函数描述: 解析三-四挡位原始数据,填充8参数高低字节缓冲区(同步修改)
输入参数: pData: PDO原始数据缓冲区 gear_num: 有效PDO组数
输出参数: -
返回说明: 0:成功 1:参数错误
其它说明: 同步适配新缓冲区格式和src/pps映射规则
*****************************************************************/
rt_uint8_t parse_mulit_gear_more(rt_uint8_t *pData, rt_uint8_t gear_num) {
// 入参合法性校验
if (pData == RT_NULL || gear_num == 0 || gear_num > 11) {
rt_kprintf("parse_mulit_gear_pd0:invalid params (gear_num=%d)\n", gear_num);
return 1;
}
// 清空缓冲区
rt_memset(Pro_Group_VCMM, 0, sizeof(Pro_Group_VCMM));
rt_uint32_t pdo_val = 0;
rt_uint8_t pdo_type = 0;
rt_uint16_t vmin_mv = 0, vmax_mv = 0, cur_power = 0;
for (rt_uint8_t i = 0; i < gear_num; i++) {
// 终止条件:PDO电压字段为0则停止
// 1. 拼接32位PDO值(低字节在前)
pdo_val = (rt_uint32_t)pData[i*4 + 3] << 24 |
(rt_uint32_t)pData[i*4 + 2] << 16 |
(rt_uint32_t)pData[i*4 + 1] << 8 |
(rt_uint32_t)pData[i*4];
// 2. 提取PDO类型(Bit30-31)
pdo_type = (pdo_val >> 30) & 0x03;
// 3. 按type映射src和pps
switch (pdo_type) {
case 0: // FPDO → src=0x00, pps=0x00
Pro_Group_VCMM[i][0] = 0x00;
Pro_Group_VCMM[i][1] = 0x00;
break;
case 1: // EPRPDO → src=0x03, pps=0x00
Pro_Group_VCMM[i][0] = 0x00;
Pro_Group_VCMM[i][1] = 0x01;
break;
case 2: // PPS → src=0x03, pps=0x00
Pro_Group_VCMM[i][0] = 0x03;
Pro_Group_VCMM[i][1] = 0x00;
break;
case 3: // EPR AVS → src=0x03, pps=0x01
Pro_Group_VCMM[i][0] = 0x03;
Pro_Group_VCMM[i][1] = 0x01;
break;
default:
rt_kprintf("parse_mulit_gear_pd0:unknown PDO type=%d\n", pdo_type);
continue;
}
// 4. 解析电压/电流/功率(16位值)
switch (pdo_type) {
case 0: // FPDO(固定电源)
case 1: // EPRPDO(固定电源)
vmin_mv = vmax_mv = ((pdo_val >> 10) & 0x03FF) * 50; // 电压(mV)
cur_power = (pdo_val & 0x03FF) * 10; // 电流(mA)
break;
case 2: // PPS(可编程电源)
vmin_mv = ((pdo_val >> 8) & 0x00FF) * 100; // 最小电压(mV)
vmax_mv = ((pdo_val >> 17) & 0x00FF) * 100; // 最大电压(mV)
cur_power = (pdo_val & 0x7F) * 50; // 电流(mA)
break;
case 3: // EPR AVS(功率型)
vmin_mv = ((pdo_val >> 8) & 0x00FF) * 100; // 最小电压(mV)
vmax_mv = ((pdo_val >> 17) & 0x1FF) * 100; // 最大电压(mV)
cur_power = (pdo_val & 0xFF) * 1; // 功率(W)
break;
default:
vmin_mv = vmax_mv = cur_power = 0;
break;
}
// 5. 拆分高低字节填充缓冲区
Pro_Group_VCMM[i][2] = (vmin_mv >> 8) & 0xFF; // vmin_H
Pro_Group_VCMM[i][3] = vmin_mv & 0xFF; // vmin_L
Pro_Group_VCMM[i][4] = (vmax_mv >> 8) & 0xFF; // vmax_H
Pro_Group_VCMM[i][5] = vmax_mv & 0xFF; // vmax_L
Pro_Group_VCMM[i][6] = (cur_power >> 8) & 0xFF; // cur_set_H
Pro_Group_VCMM[i][7] = cur_power & 0xFF; // cur_set_L
#if PRO_TEST_DEBUG
// 调试打印
rt_kprintf("parse_mulit_gear_pd0 PDO[%d]:rc=0x%02X, pps=0x%02X,V_Min=%dmV,V_MAX=%dmV,C/P=%d\n",
i, Pro_Group_VCMM[i][0], Pro_Group_VCMM[i][1], vmin_mv, vmax_mv, cur_power);
#endif
}
return 0;
}
/*****************************************************************
函数名称: parse_power_multi_gear_more
函数描述: 三-四档电源协议解析函数(FCP/AFC/SCPA)
输入参数: protoCmd: 协议命令码(0x22/0x29/0x2C/0x2F)
pData: 协议数据区缓冲区(状态+通道+CC线+挡位数量+PDO组+保护电流+补偿电压)
reqLen: 帧总长度
pSW: 通道协议配置结构体指针
输出参数: -
返回说明: -
其它说明: 1. FCP/AFC/SCPA:挡位数量(1)+PDO组(4*N)+保护电流(2)+补偿电压(2)
2. UFCS:挡位数量(1)+PDO组(4*3)+保护电流(2)+补偿电压(2)
*****************************************************************/
void parse_multi_gear_more(rt_uint8_t protoCmd, rt_uint8_t *pData, rt_uint16_t reqLen,uint8_t *pro_gear_idx,uint8_t *pro,rt_uint16_t *protect_ma)
{
rt_uint8_t gear_num = 0; // 挡位数量
rt_int16_t comp_volt_mv = 0;// 补偿电压(mV)
// 数据区索引:0=状态+通道,1=CC线,2=恒压恒流模式,3=挡位数量
gear_num = pData[3];
//挡位数量
if(gear_num > 11) {
rt_kprintf("THE GEARNUM MORE 11 GEAR_NUM=%d\n", gear_num);
return;
}
*pro_gear_idx = gear_num;
rt_kprintf("pro_gear_idx = %d\n",gear_num);
// 解析保护电流和补偿电压(不同协议偏移不同)
switch (protoCmd)
{
case 0x22: // FCP (挡位数量+PDO组(4*4)+保护电流+补偿电压)
*pro = PRO_FCP;
break;
case 0x29: // AFC (同FCP)
*pro = PRO_AFC;
break;
case 0x2F: // SCPA (同FCP)
*pro = PRO_SCPA;
break;
default:
rt_kprintf("THE PRO NO MORE PRO PRO=%02X\n", protoCmd);
return;
}
*protect_ma = u8v_to_u16(&pData[4 + 16]); // 19-20字节
comp_volt_mv = (rt_int16_t)u8v_to_u16(&pData[4 + 18]);
#if PRO_TEST_DEBUG
for(int i = 0;i<30;i++){
rt_kprintf("data[%d]=%02x",i,pData[i]);
}
rt_kprintf("protect_curr=%d\n",*protect_ma);
#endif
// 解析PDO组(小端序)
parse_mulit_gear_more(&pData[4],gear_num);
}
/*****************************************************************
函数名称: parse_ufcs_gear
函数描述: 解析UFCS协议单组PDO数据(EPR AVS类型),填充8参数高低字节缓冲区
输入参数: pData: UFCS单组PDO原始数据缓冲区(4字节)
gear_idx: 当前挡位索引(0开始)
输出参数: -
返回说明: 0:成功 1:参数错误
其它说明: UFCS协议固定为EPR AVS类型(Bit30-31=3),规则:
Bit0-7:功率(1=1W) Bit8-15:最小电压(1=100mV) Bit17-25:最大电压(1=100mV)
缓冲区前两位固定为0(类型+PPS值)
*****************************************************************/
rt_uint8_t parse_ufcs_gear_more(rt_uint8_t *pData, rt_uint8_t gear_num) {
// 入参合法性校验
if (pData == RT_NULL || gear_num == 0 || gear_num > 11) {
rt_kprintf("parse_ufcs_gear_more:invalid params (gear_num=%d)\n", gear_num);
return 1;
}
// 清空缓冲区
rt_memset(Pro_Group_VCMM, 0, sizeof(Pro_Group_VCMM));
rt_uint32_t pdo_val = 0;
rt_uint16_t vmin_mv = 0, vmax_mv = 0, cur_ma = 0;
for (rt_uint8_t i = 0; i < gear_num; i++) {
// 1. 拼接32位PDO
pdo_val = (rt_uint32_t)pData[i*4 + 3] << 24 |
(rt_uint32_t)pData[i*4 + 2] << 16 |
(rt_uint32_t)pData[i*4 + 1] << 8 |
(rt_uint32_t)pData[i*4];
// ================= 固定 =================
Pro_Group_VCMM[i][0] = 0x00;
Pro_Group_VCMM[i][1] = 0x00;
// ================= 位规则 =================
// Bit0-6 电流 1=50mA
cur_ma = (pdo_val & 0x3F) * 100;//原50,乘2了
// Bit8-15 最小电压 1=100mV
vmin_mv = ((pdo_val >> 8) & 0xFF) * 100;
// Bit17-25 最大电压 1=100mV
vmax_mv = ((pdo_val >> 17) & 0x1FF) * 100;
// ================= 填充缓冲区 =================
Pro_Group_VCMM[i][2] = (vmin_mv >> 8) & 0xFF;
Pro_Group_VCMM[i][3] = vmin_mv & 0xFF;
Pro_Group_VCMM[i][4] = (vmax_mv >> 8) & 0xFF;
Pro_Group_VCMM[i][5] = vmax_mv & 0xFF;
Pro_Group_VCMM[i][6] = (cur_ma >> 8) & 0xFF;
Pro_Group_VCMM[i][7] = cur_ma & 0xFF;
#if PRO_TEST_DEBUG
// ================= 打印格式 =================
rt_kprintf("parse_ufcs_gear_more PDO[%d]:PPS/AVS,V_Min=%dmV,V_MAX=%dmV,Max_Current=%dmA\n",
i, vmin_mv, vmax_mv, cur_ma);
#endif
}
return 0;
}
/*****************************************************************
函数名称: parse_power_ufcs
函数描述: UFCS协议专属解析函数(独立于多档位通用函数)
输入参数: pData: 协议数据区缓冲区(状态+通道+CC线+挡位数量+PDO组+保护电流+补偿电压)
reqLen: 帧总长度
pro_gear_idx: 输出有效挡位数量
pro: 输出协议类型(赋值为PRO_UFCS)
输出参数: -
返回说明: -
其它说明: UFCS固定格式:挡位数量(1)+PDO组(4*3)+保护电流(2)+补偿电压(2)
仅解析UFCS协议,不兼容其他多档位协议
*****************************************************************/
void parse_power_ufcs(rt_uint8_t *pData, rt_uint16_t reqLen, uint8_t *pro_gear_idx, uint8_t *pro,rt_uint16_t *protect_ma)
{
rt_uint8_t gear_num = 0;
rt_int16_t comp_volt_mv = 0;
gear_num = pData[3];
if(gear_num > 11) {
rt_kprintf("parse_power_ufcs: gear_num >11, set=3\n");
gear_num = 3;
}
*pro_gear_idx = gear_num;
*pro = PRO_UFCS;
// UFCS偏移
*protect_ma = u8v_to_u16(&pData[4 + 12]);
// for(int i = 0;i<24;i++){
// rt_kprintf("data[%d]=%02x",i,pData[i]);
// }
comp_volt_mv = 0;//(rt_int16_t)u8v_to_u16(&pData[3 + 14]);
//#if PRO_TEST_DEBUG
rt_kprintf("parse_power_ufcs:gear=%d,protect=%dmA,comp=%dmV\n",
gear_num,*protect_ma, comp_volt_mv);
//#endif
// 调用下面的循环解析
parse_ufcs_gear_more(&pData[4], gear_num);
}
static rt_uint8_t pd_fill_single_group(rt_uint8_t *data, rt_uint8_t start_idx, rt_uint8_t group_idx,rt_uint16_t max_cur)
{
// 校验索引合法性
if (group_idx >= PD_VOLTAGE_CNT) {
rt_kprintf("ERROR GROUP IDX EXCEED IDX=%d)\n", group_idx);
return 0;
}
rt_uint8_t idx = start_idx;
const Pro_Group *target_group = &pd_voltage_map[group_idx]; // 仅取目标挡位
// 1. 填充pro + src(2字节)
data[idx++] = target_group->src;
data[idx++] = target_group->pps;
// 2. 填充电压最小值(2字节,高8位+低8位)
data[idx++] = (target_group->v_min >> 8) & 0xff;
data[idx++] = target_group->v_min & 0xff;
// 3. 填充电压最大值(2字节,高8位+低8位)
data[idx++] = (target_group->v_max >> 8) & 0xff;
data[idx++] = target_group->v_max & 0xff;
// 4. 填充电流设置值(2字节,高8位+低8位)
data[idx++] = (max_cur >> 8) & 0xff;
data[idx++] = max_cur & 0xff;
// 5. 填充保留位(6字节全0)
for (rt_uint8_t j = 0; j < 6; j++) {
data[idx++] = 0x00;
}
return idx - start_idx; // 返回填充的总字节数
}
/*****************************************************************
函数名称: source_set_pd
函数描述: source 设置PD协议
@@ -89,29 +623,273 @@ int source_set_cc_lvl (rt_uint8_t lvl)
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[32] = {0};
rt_uint8_t frame[32] = {0};
rt_uint8_t data[80] = {0};
rt_uint8_t frame[80] = {0};
rt_uint8_t send_len = 0; //数据长度
rt_uint8_t max_group_idx = 0; //挡位索引
data[0] = pro; //协议
//rt_kprintf("cur_pro=%d",max_cur);
if(pro==0x07||pro==0x08||pro==0x03){
data[1] = 0;//src
data[2] = 0;//pps
data[3] = 0x13;//固定电压最小值为5V
data[4] = 0x88;
data[5] = (vmax>>8)&0xff;//电压最大值为设定电压
data[6] = vmax&0xff;
data[7] = (max_cur>>8)&0xff;//电流输出为设置值
data[8] = max_cur&0xff;
for (rt_uint8_t j = 9; j < 14; j++) {
data[j] = 0x00;
}
send_len=15;
}
else{
switch (vmax)
{
case 5000: max_group_idx = 0; break;
case 9000: max_group_idx = 1; break;
case 12000: max_group_idx = 2; break;
case 20000: max_group_idx = 3; break;
case 48000: max_group_idx = 4; break;
default:rt_kprintf("VOLT ERROR");break;
}
rt_uint8_t idx = 1; //从data[1]开始填充
// 循环填充从0到max_group_idx的所有挡位
for (rt_uint8_t i = 0; i <= max_group_idx; i++) {
rt_uint8_t fill_len = pd_fill_single_group(data, idx, i,max_cur);
if (fill_len == 0) {
rt_kprintf("Error: fill group %d failed\n", i);
return -1;
}
idx += fill_len; // 偏移到下一组起始位置
}
send_len = idx; // 总填充字节数
}
chrg_north_pkg_encode(ID_SOURCE, SRC_CMD_SET_PROTOCOL, data, send_len, frame, &len);
return chrg_north_send(frame, len);
}
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;
/*****************************************************************
函数名称: pd_fill_single_group
函数描述: 填充单个PD挡位的协议数据
输入参数: data:目标字节数组 start_idx:数组起始填充位置 group_idx:要调用的挡位索引(0=5V,1=9V...4=PPS)
输出参数: -
返回说明: 0:索引越界/错误 >0:填充的字节数(固定14字节)
其它说明: -
*****************************************************************/
rt_uint8_t pd_fill_single_group_com(rt_uint8_t *data, rt_uint8_t start_idx, rt_uint8_t gear)
{
// 核心:直接索引已拆分好的高低位缓冲区,按位填充(无任何多余运算)
rt_uint8_t idx = start_idx;
// 1. src + pps(2字节)
data[idx++] = Pro_Group_VCMM[gear][0];
data[idx++] = Pro_Group_VCMM[gear][1];
// 2. 最小电压(高+低,直接取已拆分好的值)
data[idx++] = Pro_Group_VCMM[gear][2];
data[idx++] = Pro_Group_VCMM[gear][3];
// 3. 最大电压(高+低,直接取已拆分好的值)
data[idx++] = Pro_Group_VCMM[gear][4];
data[idx++] = Pro_Group_VCMM[gear][5];
// 4. 电流/功率(高+低,直接取已拆分好的值)
data[idx++] = Pro_Group_VCMM[gear][6];
data[idx++] = Pro_Group_VCMM[gear][7];
// 5. 保留位6字节(直接填0)
memset(&data[idx], 0x00, 6);
idx+=6;
return idx - start_idx; // 返回填充的总字节数
}
chrg_north_pkg_encode(ID_SOURCE, SRC_CMD_SET_PROTOCOL, data, 15, frame, &len);
rt_uint8_t pd_fill_single_group_need_src_com(rt_uint8_t *data, rt_uint8_t start_idx,struct chrg_switch_t *psw){
rt_uint8_t idx = start_idx;
struct chrg_src_t *source = &psw->source;
// 1. src + pps(2字节)
data[idx++] = 0x00;
data[idx++] = 0x00;
// 2. 最小电压(高+低,直接取已拆分好的值)
data[idx++] = 0x13;
data[idx++] = 0x88;
// 3. 最大电压(高+低,直接取已拆分好的值)
data[idx++] = 0x13;
data[idx++] = 0x88;
// 4. 电流/功率(高+低,直接取已拆分好的值)
data[idx++] = source->protective_curr >> 8;
data[idx++] = source->protective_curr & 0xFF;
// 5. 保留位6字节(直接填0)
memset(&data[idx], 0x00, 6);
idx+=6;
data[idx++] = source->src;
data[idx++] = source->pps;
rt_kprintf("src = %d pps = %d\n",source->src,source->pps);
// 2. 最小电压(高+低,直接取已拆分好的值)
data[idx++] = source->min_vol >> 8;
data[idx++] = source->min_vol & 0xFF;
// 3. 最大电压(高+低,直接取已拆分好的值)
data[idx++] = source->max_vol >> 8;
data[idx++] = source->max_vol & 0xFF;
// 4. 电流/功率(高+低,直接取已拆分好的值)
data[idx++] = source->protective_curr >> 8;
data[idx++] = source->protective_curr & 0xFF;
// 5. 保留位6字节(直接填0)
memset(&data[idx], 0x00, 6);
idx+=6;
return idx - start_idx; // 返回填充的总字节数
}
rt_uint8_t pd_fill_single_group_no_src_com(rt_uint8_t *data, rt_uint8_t start_idx,struct chrg_switch_t *psw){
rt_uint8_t idx = start_idx;
struct chrg_src_t *source = &psw->source;
// 1. src + pps(2字节)
data[idx++] = 0x00;
data[idx++] = 0x00;
// 2. 最小电压(高+低,直接取已拆分好的值)
data[idx++] = source->min_vol >> 8;
data[idx++] = source->min_vol & 0xFF;
// 3. 最大电压(高+低,直接取已拆分好的值)
data[idx++] = source->max_vol >> 8;
data[idx++] = source->max_vol & 0xFF;
// 4. 电流/功率(高+低,直接取已拆分好的值)
data[idx++] = source->protective_curr >> 8;
data[idx++] = source->protective_curr & 0xFF;
// 5. 保留位6字节(直接填0)
memset(&data[idx], 0x00, 6);
idx+=6;
return idx - start_idx; // 返回填充的总字节数
}
rt_uint8_t pd_fill_single_group_FCP_AFC(rt_uint8_t *data, rt_uint8_t start_idx,struct chrg_switch_t *psw){
rt_uint8_t idx = start_idx;
struct chrg_src_t *source = &psw->source;
// 1. src + pps(2字节)
data[idx++] = 0x00;
data[idx++] = 0x00;
// 2. 最小电压(高+低,直接取已拆分好的值)
data[idx++] = 0x13;
data[idx++] = 0x88;
// 3. 最大电压(高+低,直接取已拆分好的值)
data[idx++] = 0x13;
data[idx++] = 0x88;
// 4. 电流/功率(高+低,直接取已拆分好的值)
data[idx++] = source->protective_curr >> 8;
data[idx++] = source->protective_curr & 0xFF;
// 5. 保留位6字节(直接填0)
memset(&data[idx], 0x00, 6);
idx+=6;
// 1. src + pps(2字节)
data[idx++] = 0x00;
data[idx++] = 0x00;
// 2. 最小电压(高+低,直接取已拆分好的值)
data[idx++] = source->max_vol >> 8;
data[idx++] = source->max_vol & 0xFF;
// 3. 最大电压(高+低,直接取已拆分好的值)
data[idx++] = source->max_vol >> 8;
data[idx++] = source->max_vol & 0xFF;
// 4. 电流/功率(高+低,直接取已拆分好的值)
data[idx++] = source->protective_curr >> 8;
data[idx++] = source->protective_curr & 0xFF;
// 5. 保留位6字节(直接填0)
memset(&data[idx], 0x00, 6);
idx+=6;
return idx - start_idx; // 返回填充的总字节数
}
rt_uint8_t pd_fill_single_group_UFCS(rt_uint8_t *data, rt_uint8_t start_idx,struct chrg_switch_t *psw){
rt_uint8_t idx = start_idx;
struct chrg_src_t *source = &psw->source;
// 1. src + pps(2字节)
data[idx++] = 0x00;
data[idx++] = 0x00;
// 2. 最小电压(高+低,直接取已拆分好的值)
data[idx++] = 0x13;
data[idx++] = 0x88;
// 3. 最大电压(高+低,直接取已拆分好的值)
data[idx++] = 0x13;
data[idx++] = 0x88;
// 4. 电流/功率(高+低,直接取已拆分好的值)
data[idx++] = source->protective_curr >> 8;
data[idx++] = source->protective_curr & 0xFF;
// 5. 保留位6字节(直接填0)
memset(&data[idx], 0x00, 6);
idx+=6;
// 1. src + pps(2字节)
data[idx++] = 0x00;
data[idx++] = 0x00;
// 2. 最小电压(高+低,直接取已拆分好的值)
data[idx++] = source->min_vol >> 8;
data[idx++] = source->min_vol & 0xFF;
// 3. 最大电压(高+低,直接取已拆分好的值)
data[idx++] = source->max_vol >> 8;
data[idx++] = source->max_vol & 0xFF;
// 4. 电流/功率(高+低,直接取已拆分好的值)
data[idx++] = source->protective_curr >> 8;
data[idx++] = source->protective_curr & 0xFF;
// 5. 保留位6字节(直接填0)
memset(&data[idx], 0x00, 6);
idx+=6;
return idx - start_idx; // 返回填充的总字节数
}
int source_set_pd_com(rt_uint8_t pro,rt_uint8_t pro_gear_idx)
{
rt_uint16_t len = 0;
rt_uint8_t data[150] = {0};
rt_uint8_t frame[150] = {0};
rt_uint8_t send_len = 0; //数据长度
rt_uint8_t max_group_idx = 0; //挡位索引
data[0] = pro; //协议
rt_uint8_t idx = 1;
for(rt_uint8_t i = 0;i<pro_gear_idx;i++){
rt_uint8_t fill_len = pd_fill_single_group_com(data,idx,i);
if (fill_len == 0) {
rt_kprintf("Error: fill group %d failed\n", i);
return -1;
}
idx += fill_len; // 偏移到下一组起始位置
}
send_len = idx; // 总填充字节数
chrg_north_pkg_encode(ID_SOURCE, SRC_CMD_SET_PROTOCOL, data, send_len, frame, &len);
// for(rt_uint8_t i=0;i<len+5;i++){
// rt_kprintf("%02x",data[i]);
// }
// rt_kprintf("idx=%d",idx);
return chrg_north_send(frame, len);
}
int source_set_pd_new_com(rt_uint8_t pro, struct chrg_switch_t *pSW)
{
rt_uint16_t len = 0;
rt_uint8_t data[150] = {0};
rt_uint8_t frame[150] = {0};
rt_uint8_t send_len = 0; //数据长度
rt_uint8_t max_group_idx = 0; //挡位索引
data[0] = pro; //协议
rt_uint8_t idx = 1; //从data[1]开始填充
rt_uint8_t fill_len = 0;
rt_uint8_t protocal = pSW->source.protocol;
if(protocal == 0x0A){
fill_len = pd_fill_single_group_need_src_com(data, idx, pSW);
}else if(protocal == 0x03||protocal == 0x07||protocal == 0x08 ){
fill_len = pd_fill_single_group_no_src_com(data, idx, pSW);
}else if(protocal == 0x0C){
fill_len = pd_fill_single_group_UFCS(data, idx, pSW);
}else{
fill_len = pd_fill_single_group_FCP_AFC(data, idx, pSW);
}
idx += fill_len;
send_len = idx; // 总填充字节数
chrg_north_pkg_encode(ID_SOURCE, SRC_CMD_SET_PROTOCOL, data, send_len, frame, &len);
rt_kprintf("idx = %d ",idx);
// for(rt_uint8_t i=0;i<idx;i++){
// rt_kprintf("%02x",data[i]);
// }
// rt_kprintf("idx=%d",idx);
return chrg_north_send(frame, len);
}
+112 -42
View File
@@ -11,51 +11,44 @@
#define __CHRG_SOURCE_H__
#include <rtthread.h>
#include "chrg_north.h"
#include "chrg_def.h"
struct chrg_switch_t;
// 冠达快充板(SOURCE)通讯协议
// SOURCE的ID为2, 波特率200K
#define SRC_CMD_GET_VOLTAGE 0x20 // 读取数据
// 发送 0B 00 02 20 volh voll curh curl nc nc CRC8
// 长度+nc+id+指令+2字节当前电源电压(mV)+2字节当前电源电流(mA)+2个预留字节+CRC8校验
// 接收 15 00 02 20 VH VL setvh setvl setch setcl NC NC verh verl NC NC NC NC NC NC CRC8
// 长度+nc+ID+指令+2字节读取的电压(0.01V)+2字节source设置电压(mV)+2字节source设置电流(mA)+2字节预留+2字节版本号+6字节预留+CRC8校验
#define SRC_CMD_GET_PROTOCOL 0x13 // 读取source的PD协议数据(当前为PDO,PPS,PD3.1,AVS协议时有效)
// 发送 05 00 02 13 2A
// XX 00 02 13 //长度(根据实际计算)+NC+ID+指令
// 00 00 VMAXH VMAXL VMINH VMINL CURH/PORH CURL/PORL NC NC NC NC NC NC
//源类型(1字节,00为PDO,03为APDO) + PPS类型(1字节,源类型为3时有效,00为SPR PPS,01为EPR AVS,02为SPR AVS)
// + 最大电压(2字节,mV) + 最小电压(2字节,mA) + 最大电流/功率(2字节,mA/W) + 预留(6字节,当协议类型为02时有效,意义与前6字节一致)
// 00 00 VMAXH VMAXL VMINH VMINL CURH/PORH CURL/PORL NC NC NC NC NC NC
// ...... CRC8
#define SRC_CMD_SET_CC_LEVEL 0x16
// 发送 06 00 02 16 00 2A
// 长度+nc+id+指令+电平等级(0xff为根据当前电流自动设置,否则为手动设定,设置方法待定)+CRC8校验
// 接收 05 00 02 16 2A
// 长度+nc+id+指令+CRC8校验
#define SRC_CMD_SET_CC_CHOOSE 0x17
#define SRC_CMD_SET_PROTOCOL 0xD0
// 发送 XX 00 02 D0 // 长度(根据实际计算)+NC+ID+指令
// 00 00 00 VMAXH VMAXL VMINH VMINL CURH/PORH CURL/PORL NC NC NC NC NC NC
// 协议(1字节) + 源类型(1字节,PD协议有效,00为PDO,03为APDO) +
// PPS类型(1字节, PD协议有效,源类型为3时有效,00为SPR PPS,01为EPR AVS,02为SPR AVS) + 最大电压(2字节,mV) +
// 最小电压(2字节,mA) + 最大电流/功率(2字节,mA/W) + 预留(6字节,当协议类型为02时有效,意义与前6字节一致)
// 00 00 00 VMAXH VMAXL VMINH VMINL CURH/PORH CURL/PORL NC NC NC NC NC NC
// ...... CRC8
// 接收 05 00 02 D0 CRC8
#define PROTOCOL_NONE 0x00 // 无快充
#define PROTOCOL_VIFC 0x01 // VIFC(暂不支持)
#define PROTOCOL_FCP 0x02 // FCP
#define PROTOCOL_SCPB 0x03 // SCPB
#define PROTOCOL_RESERVED_04 0x04 // 预留
#define PROTOCOL_RESERVED_05 0x05 // 预留
#define PROTOCOL_RFC 0x06 // RFC(暂不支持)
#define PROTOCOL_QC30 0x07 // QC3.0
#define PROTOCOL_QC20 0x08 // QC2.0
#define PROTOCOL_AFC 0x09 // AFC
#define PROTOCOL_PD 0x0A // PD
#define PROTOCOL_RESERVED_0B 0x0B // 预留
#define PROTOCOL_UFCS 0x0C // UFCS
#define PROTOCOL_RESERVED_0D 0x0D // 预留
#define PROTOCOL_VOOC 0x0E // VOOC(暂不支持)
#define PROTOCOL_SCPA 0x0F // SCPA
typedef enum {
PRO_NONE = 0x00, // 无快充
PRO_NONE = 0x00, // 标准
PRO_VIFC = 0x01, // VIFC(暂不支持)
PRO_FCP = 0x02, // FCP
PRO_SCP = 0x03, // SCP
PRO_SCPB = 0x03, // SCP
PRO_SERV1 = 0x04, // 预留
PRO_SERV2 = 0x05, // 预留
PRO_RFC = 0x06, // RFC(暂不支持)
@@ -67,10 +60,38 @@ typedef enum {
PRO_UFCS = 0x0C, // UFCS
PRO_PD31AVS = 0x0D, // PD3.1/AVS
PRO_VOOC = 0x0E, // VOOC(暂不支持)
PRO_SCPA = 0x0F, // SCPA
TOTAL_PROS
} eSRC_PRO;
// 电源协议映射表:枚举值 ↔ 协议名称(和你的 eSRC_PRO 完全对齐)
typedef struct {
rt_uint8_t pro_val; // 协议数值(对应 eSRC_PRO 枚举)
int pro_name; // 协议显示名称(LCD展示用)
} SrcProMap_t;
// 按 eSRC_PRO 枚举顺序定义映射表,确保一一对应
static const SrcProMap_t src_pro_map[] = {
{PRO_NONE, 30},
{PRO_VIFC, 31},
{PRO_FCP, 32},
{PRO_SCPB, 33},
{PRO_SERV1, 34},
{PRO_SERV2, 35},
{PRO_RFC, 36},
{PRO_QC30, 37},
{PRO_QC20, 38},
{PRO_AFC, 39},
{PRO_PD0PSS, 40},
{PRO_SERV3, 41},
{PRO_UFCS, 42},
{PRO_PD31AVS, 43},
{PRO_VOOC, 44},
{PRO_SCPA, 45}
};
// 映射表长度宏(自动计算,避免手动维护)
#define SRC_PRO_MAP_NUM (sizeof(src_pro_map) / sizeof(src_pro_map[0]))
// 应答帧头
struct pkg_head_t {
rt_uint8_t length; // 帧长度
@@ -121,22 +142,34 @@ struct src_vc_t {
rt_uint16_t version; // 版本号
};
#define PD_GEAR_ARRAY_LEN 4 // 非5V挡位最多4个,数组长度设为4
// source 参数结构
struct chrg_src_t {
rt_uint16_t voltage; // 当前电压 mV
rt_uint16_t current; // 当前电流 mA
rt_uint8_t vol_lvl; // CC线电平
eSRC_PRO protocol; // 协议类型
struct src_vc_t vc; // 读取数据
struct vc_pd_t pd_get[2]; // 读取PD协议数据
struct vc_pd_t pd_set[2]; // 设置PD协议数据
rt_uint16_t voltage; // 当前电压 mV
rt_uint16_t current; // 当前电流 mA
eSRC_PRO protocol; // 协议类型
rt_uint8_t src; // 源类型
rt_uint8_t pps; // PPS类型
rt_uint8_t pro_gear_idx; // 挡位
rt_uint16_t min_vol; // 最小电压 mV
rt_uint16_t max_vol; // 最大电压 mV
rt_uint8_t vol_lvl; // CC线电平
rt_uint8_t cc_set; // cc线选择 //0代表1+2,1代表cc1,2代表cc2
rt_uint16_t protective_curr; // 保护电流
rt_uint8_t Now_State; // 当前状态
rt_uint8_t On_Flag; // 启动总标志(0/1)
rt_uint8_t Set_CV_Flag; // 电压/电流切换标志(0/1)
rt_uint8_t Set_Pro_Flag; // 设置协议标志位(0/1/2)0代表没设置协议,1代表设置了但还没执行,2代表设置了并执行
rt_uint8_t LCD_Set_Pro_Flag; // LCD设置协议标志位
rt_uint8_t Work_step_flag; // 工作步骤标志位
rt_uint8_t Stop_step_flag; // 停止步骤标志位
rt_uint8_t change_sink_Flag; // 从source切换到sink标志位
rt_uint8_t work_mode; // 0=停止 1=工作 2=低电压
struct src_vc_t vc; // 读取数据
struct vc_pd_t pd_get[2]; // 读取PD协议数据
struct vc_pd_t pd_set[2]; // 设置PD协议数据
};
/*****************************************************************
函数名称: source_get_vc
函数描述: source电压电流查询请求
@@ -167,6 +200,16 @@ extern int source_get_pd (void);
*****************************************************************/
extern int source_set_cc_lvl (rt_uint8_t lvl);
/*****************************************************************
函数名称: source_set_cc_choose
函数描述: source 设置 cc线 选择
输入参数: cc_set 0代表1+2,1代表cc1,2代表cc2
输出参数: -
返回说明: <0: 错误 >0:发送长度
其它说明: -
*****************************************************************/
extern int source_set_cc_choose (rt_uint8_t cc_set);
/*****************************************************************
函数名称: source_set_pd
函数描述: source 设置PD协议
@@ -178,7 +221,34 @@ extern int source_set_cc_lvl (rt_uint8_t lvl);
extern 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);
// 挡位参数结构体
typedef struct {
rt_uint8_t src; // 第1字段(如00/03)
rt_uint8_t pps; // 第2字段(如00/01)
rt_uint16_t v_min; // 电压最小值(如0x1388=5V)
rt_uint16_t v_max; // 电压最大值(如0x1388=5V)
rt_uint16_t cur_set; // 电流设置值(如0x0bb8=3A)
} Pro_Group;
// 挡位映射表(索引对应挡位:0=5V,1=9V,2=12V,3=20V,4=PPS)
static const Pro_Group pd_voltage_map[] = {
{0x00, 0x00, 0x1388, 0x1388, 0x0bb8}, // 0:5V挡位
{0x00, 0x00, 0x2328, 0x2328, 0x0bb8}, // 1:9V挡位
{0x00, 0x00, 0x2ee0, 0x2ee0, 0x0bb8}, // 2:12V挡位
{0x00, 0x00, 0x4e20, 0x4e20, 0x0bb8}, // 3:20V挡位
{0x00, 0x00, 0xBB80, 0xBB80, 0X0bb8} // 4:48V
// {0x03, 0x00, 0x1388, 0x4e20, 0x1388} // 4:PPS挡位 5-20V
};
extern rt_uint8_t pd_fill_gear_index(rt_uint8_t *gear_index, rt_uint8_t *gear_cnt, rt_uint8_t hex_code);
extern int source_set_pd_com(rt_uint8_t pro,rt_uint8_t pro_gear_idx);
#define PD_VOLTAGE_CNT (sizeof(pd_voltage_map) / sizeof(Pro_Group))
extern rt_uint16_t pd_gear_parse(rt_uint8_t hex_code);
extern void parse_power_single_gear(rt_uint8_t protoCmd, rt_uint8_t *pData, rt_uint16_t reqLen,uint8_t *pro_gear_idx,uint8_t *pro,rt_uint16_t *protect_ma);
extern void parse_power_pdo_gear(rt_uint8_t protoCmd, rt_uint8_t *pData, rt_uint16_t reqLen,uint8_t *pro_gear_idx,uint8_t *pro,rt_uint16_t *protect_ma);
extern void parse_multi_gear_more(rt_uint8_t protoCmd, rt_uint8_t *pData, rt_uint16_t reqLen,uint8_t *pro_gear_idx,uint8_t *pro,rt_uint16_t *protect_ma);
extern void parse_power_ufcs(rt_uint8_t *pData, rt_uint16_t reqLen, uint8_t *pro_gear_idx, uint8_t *pro,rt_uint16_t *protect_ma);
extern int source_set_pd_new_com(rt_uint8_t pro, struct chrg_switch_t *pSW);
#endif
+29 -3
View File
@@ -75,12 +75,19 @@ rt_uint16_t mb_crc16 (rt_uint8_t *pucFrame, rt_uint16_t usLen)
rt_uint8_t ucCRCLo = 0xFF;
int iIndex;
if(usLen==8){
for(int i = 0;i<usLen;i++){
rt_kprintf("%02x ",pucFrame[i]);
}
rt_kprintf("\n");
}
while ( usLen-- ) {
iIndex = ucCRCLo ^ *(pucFrame++);
ucCRCLo = (rt_uint8_t)(ucCRCHi ^ aucCRCHi[iIndex]);
ucCRCHi = aucCRCLo[iIndex];
}
return (rt_uint16_t)(ucCRCHi << 8 | ucCRCLo);
}
@@ -135,13 +142,32 @@ rt_uint8_t u16_to_u8v (rt_uint16_t value, rt_uint8_t *buf)
{
if (RT_NULL != buf) {
buf[0] = (value>>8)&0xFF;
// rt_kprintf("%d",buf[0]);
buf[1] = value&0xFF;
// rt_kprintf("%d",buf[0]);
return 2;
}
return 0;
}
/*****************************************************************
函数名称: u16_to_u8v_com
函数描述: u16 转字节流
输入参数: value:数据 *buf:字节流
输出参数: -
返回说明: -
其它说明: -2026.7.1修改,高低字节互换
*****************************************************************/
rt_uint8_t u16_to_u8v_com (rt_uint16_t value, rt_uint8_t *buf)
{
if (RT_NULL != buf) {
buf[1] = (value>>8)&0xFF;
// rt_kprintf("%d",buf[0]);
buf[0] = value&0xFF;
// rt_kprintf("%d",buf[0]);
return 2;
}
return 0;
}
/*****************************************************************
函数名称: u8v_to_u16
函数描述: 字节流转 u16
@@ -91,6 +91,15 @@ extern rt_uint16_t swap_u16 (rt_uint16_t x);
其它说明: -
*****************************************************************/
extern rt_uint32_t swap_u32 (rt_uint32_t x);
/*****************************************************************
函数名称: u16_to_u8v_com
函数描述: u16 转字节流
输入参数: value:数据 *buf:字节流
输出参数: -
返回说明: -
其它说明: -2026.7.1修改,高低字节互换
*****************************************************************/
extern rt_uint8_t u16_to_u8v_com (rt_uint16_t value, rt_uint8_t *buf);
#endif