pengsx
/
chargeController
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

修改串口解析方式为状态机

This commit is contained in:
起床就犯困 2025-01-04 17:50:05 +08:00
parent 8053971109
commit 688f925657
17 changed files with 2214 additions and 3838 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.vscode/settings.json vendored
View File

@ -35,6 +35,9 @@
"rtc.h": "c",
"soe.h": "c",
"hd_rtc.h": "c",
"flash.h": "c"
"flash.h": "c",
"configparameter.h": "c",
"usart.h": "c",
"w25qxx.h": "c"
}
}

1
APP/businessLogic/Inc/SOE.h
View File

@ -15,5 +15,4 @@ void insertEventsOrderRecord(eventsOrderRecordMode mode);
#endif

44
APP/businessLogic/Inc/bl_usart.h Normal file
View File

@ -0,0 +1,44 @@
#ifndef BL_USART_H_
#define BL_USART_H_
#include "comm_types.h"
#include "chargControlTypes.h"
#include "uart_dev.h"
/* SL协议读取寄存器最大地址 */
#define maxReadRegAddrMacro 0x0120
/* SL协议读取寄存器最小地址 */
#define minReadRegAddrMacro 0x0100
/* SL协议读取寄存器最大长度 */
#define maxReadRegAddrNumMacro 10
/* SL协议写入寄存器最大地址 */
#define maxWriteRegAddrMacro 0x0120
/* SL协议写入寄存器最小地址 */
#define minWriteRegAddrMacro 0x0100
/* SL协议写入寄存器最大长度 */
#define maxWriteRegAddrNumMacro 10
/* SL协议寄存器长度 */
#define RegAddrNumMacro 32
uint16_t checkModebusCrc(uint8_t *arr_buff, uint8_t len);
void gw485DataAnalysis(device_handle device);
#endif

12
APP/businessLogic/Inc/cfg_protocol.h
View File

@ -1,12 +0,0 @@
#ifndef BL_CFG_PROTOCOL_H_
#define BL_CFG_PROTOCOL_H_
#include "comm_types.h"
void inConfigBuff(uint8_t c);
void zeroConfigBuff(void);
uint16_t checkModebusCrc(uint8_t *arr_buff, uint8_t len);
void read_and_process_config_data(void);
#endif

14
APP/businessLogic/Inc/hy_protocol.h
View File

@ -1,14 +0,0 @@
#ifndef BL_HY_PROTOCOL_H_
#define BL_HY_PROTOCOL_H_
#include "uart_dev.h"
BOOL getHYconfigModeState(void);
void setHYconfigModeState(BOOL state);
void HY_read_and_process_uart_data(device_handle device);
#endif

1
APP/businessLogic/Inc/inFlash.h
View File

@ -5,6 +5,7 @@
#include "flash.h"
#include "stm32g431xx.h"
#include "chargControlTypes.h"
#include "bl_usart.h"
#pragma pack(push, 1)

3
APP/businessLogic/Inc/parameter.h
View File

@ -4,8 +4,7 @@
#include "main.h"
#include "comm_types.h"
#include "chargControlTypes.h"
#define softVer "SV01_24101501"
#include "configParameter.h"
// #pragma pack(push,1)

4
APP/businessLogic/Inc/task.h
View File

@ -10,8 +10,8 @@ void task_Init(void);
void beginStartControlTask(void);
void beginSoftStartTask(void);
void beginHYconfigMode(void);
void uartTaskInit(void);
// void beginHYconfigMode(void);
// void uartTaskInit(void);
void startShortCircuitProtection(void);
void stopShortCircuitProtection(void);

22
APP/businessLogic/Src/SOE.c
View File

@ -3,7 +3,7 @@
#include "stdio.h"
#include "parameter.h"
#include "FM_RTC.h"
#include "flash.h"
#define eventsOrderRecordStartAddr 4096
@ -46,7 +46,7 @@ void eventsOrderRecordStartInit(void)
soeInfo.outData = NULL;
soeInfo.insertData = &soeInfo.data[soeInfo.insertPos];
read_Flash((uint8_t *)(&soeParameters), sizeof(soeParameters));
// read_Flash((uint8_t *)(&soeParameters), sizeof(soeParameters));
}
/**
@ -72,35 +72,35 @@ void insertEventsOrderRecord(eventsOrderRecordMode mode)
}
soeInfo.count--;
soeInfo.insertData->data.mode = mode;
soeInfo.insertData->mode = mode;
getRTC_Time(&soeInfo.insertData->time);
if (mode == firstStageProtection) {
soeInfo.insertData->data.temp = getDischargCurrent();
soeInfo.insertData->temp = getDischargCurrent();
}
else if (mode == secondStageProtection) {
soeInfo.insertData->data.temp = getDischargCurrent();
soeInfo.insertData->temp = getDischargCurrent();
}
else if (mode == thirdStageProtection) {
soeInfo.insertData->data.temp = getDischargCurrent();
soeInfo.insertData->temp = getDischargCurrent();
}
else if (mode == lowInputLoad) {
soeInfo.insertData->data.temp = getOutputVoltage();
soeInfo.insertData->temp = getOutputVoltage();
}
else if (mode == overTemperature) {
soeInfo.insertData->data.temp = getHighSideMosTemperature();
soeInfo.insertData->temp = getHighSideMosTemperature();
}
else if (mode == stopTemperature) {
soeInfo.insertData->data.temp = getHighSideMosTemperature();
soeInfo.insertData->temp = getHighSideMosTemperature();
}
else if (mode == overchargCurr) {
soeInfo.insertData->data.temp = getChargCurrent();
soeInfo.insertData->temp = getChargCurrent();
}
@ -109,7 +109,7 @@ void insertEventsOrderRecord(eventsOrderRecordMode mode)
soeInfo.insertPos = 0;
}
if (count <= 0) {
if (soeInfo.count <= 0) {
soeInfo.insertData = NULL;
} else {
soeInfo.insertData = &soeInfo.data[soeInfo.insertPos];

679
APP/businessLogic/Src/bl_usart.c Normal file
View File

@ -0,0 +1,679 @@
#include "bl_usart.h"
#include "parameter.h"
#include "chargControlTypes.h"
#include "configParameter.h"
#include "string.h"
#include "pDebug.h"
typedef enum {
wait = 0, /* 串口状态机初始状态 */
startFlagSL, /* 接收到SL帧头 */
addressSL, /* 接收到设备地址 */
functionCodeSL, /* 接收到SL功能码 */
readRegStartAddressSL, /* 接收到SL读取寄存器起始地址 */
readRegStartNumberSL, /* 接收到SL读取寄存器个数 */
crcCheckBitSL, /* 接收到SL校验位 */
endFlagSL, /* 接收到SL帧尾 */
writeRegStartAddressSL, /* 接收到SL写入寄存器起始地址 */
writeRegStartNumberSL, /* 接收到SL写入寄存器个数 */
regLengthSL, /* 接收到SL寄存器长度 */
regStatusSL, /* 接收到SL寄存器状态 */
} uartStateMachine;
/* 功能码 */
typedef enum
{
SL_Function_Code_Read_Register = 0x30, /* 读寄存器数据 */
SL_Function_Code_Write_Register = 0x10, /* 写寄存器数据 */
SL_Function_Code_Broadcast_Scan = 0xA0, /* 广播扫描 */
SL_Function_Code_Registration_request = 0xA1, /* 注册请求 */
SL_Function_Code_Distribution_Profile = 0xD0, /* 配置文件下发 */
SL_Function_Code_Read_Profile = 0xD1, /* 配置文件读取 */
}SL_MsgFunctionCode;
#define gw485RxBufferSize 256
/* 计时参数，一秒后没解析出数据，丢掉当前数据 */
static uint32_t gw485RxTime = 0;
/* 储存gw485数据 */
static uint8_t gw485RxBuffer[gw485RxBufferSize];
static uint16_t gw485RxBufferIndex = 0;
/* 状态机状态机变量 */
static uartStateMachine state = wait;
static uint16_t frameLength = 0;
static void stateMachine(device_handle device);
/* 状态机函数 */
static BOOL analysisWait(void);
static BOOL analysisStartFlagSL(void);
static BOOL analysisAddressSL(void);
static BOOL analysisFunctionCodeSL(void);
static BOOL analysisReadRegStartAddressSL(void);
static BOOL analysisReadRegStartNumberSL(void);
static BOOL analysisCrcCheckBitSL(void);
static void analysisEndFlagSL(device_handle device);
static BOOL analysisWriteRegStartAddressSL(void);
static BOOL analysisWriteRegStartNumberSL(void);
static BOOL analysisRegLengthSL(void);
static BOOL analysisRegStatusSL(void);
/* 解析出来指令对应函数 */
static void SL_MsgProcFunc_Read_Register(device_handle device, void *pMsg, uint32_t MsgLen);
static void SL_MsgProcFunc_Write_Register(device_handle device, void *pMsg, uint32_t MsgLen);
static void SL_MsgProcFunc_Broadcast_Scan(device_handle device, void *pMsg, uint32_t MsgLen);
static void SL_MsgProcFunc_Registration_request(device_handle device, void *pMsg, uint32_t MsgLen);
static void SL_MsgProcFunc_Distribution_Profile(device_handle device, void *pMsg, uint32_t MsgLen);
static void SL_MsgProcFunc_Read_Profile(device_handle device, void *pMsg, uint32_t MsgLen);
/**
* @brief modbus的crc校验
* @param *arr_buff 需要校验的数据
* len 数据长度
* @retval crc 校验的结果
*/
uint16_t checkModebusCrc(uint8_t *arr_buff, uint8_t len)
{
uint16_t crc = 0xFFFF;
uint16_t i, j;
for (j = 0; j < len; ++j) {
crc = crc ^ (*arr_buff++);
for (i = 0; i < 8; ++i) {
if ((crc&0x0001) > 0) {
crc = crc >> 1;
crc = crc ^ 0xa001;
}
else {
crc = crc >> 1;
}
}
}
return crc;
}
/**
* @brief 状态机函数
* @param
* @retval
*/
void stateMachine(device_handle device)
{
if (state == wait) {
if (analysisWait() == TRUE) {
gw485RxTime = 0;
}
}
else if (state == startFlagSL) {
analysisStartFlagSL();
}
else if (state == addressSL) {
analysisAddressSL();
}
else if (state == functionCodeSL) {
analysisFunctionCodeSL();
}
else if (state == readRegStartAddressSL) {
analysisReadRegStartAddressSL();
}
else if (state == readRegStartNumberSL) {
analysisReadRegStartNumberSL();
}
else if (state == crcCheckBitSL) {
analysisCrcCheckBitSL();
}
else if (state == endFlagSL) {
analysisEndFlagSL(device);
}
else if (state == writeRegStartAddressSL) {
analysisWriteRegStartAddressSL();
}
else if (state == writeRegStartNumberSL) {
analysisWriteRegStartNumberSL();
}
else if (state == regLengthSL) {
analysisRegLengthSL();
}
else if (state == regStatusSL) {
analysisRegStatusSL();
}
}
void gw485DataAnalysis(device_handle device)
{
/* 1S未解析出来一帧数据，将数据清零 */
gw485RxTime++;
if (gw485RxTime == 10) {
gw485RxTime = 0;
gw485RxBufferIndex = 0;
state = wait;
}
while (uart_dev_char_present(device) == 1) {
gw485RxBuffer[gw485RxBufferIndex++] = uart_dev_in_char(device);
stateMachine(device);
}
stateMachine(device);
}
/**
* @brief 状态 wait
* @param
* @retval TRUE:解析成功 FALSE:解析失败
*/
BOOL analysisWait(void)
{
static uint16_t maxLen = 2;
/* 解析SL协议的包头 */
if (gw485RxBufferIndex >= 2) {
if (gw485RxBuffer[0] == 'S' && gw485RxBuffer[1] == 'L') {
state = startFlagSL;
return TRUE;
}
}
if (gw485RxBufferIndex < maxLen) {
return FALSE;
}
state = wait;
gw485RxBufferIndex--;
memcpy(gw485RxBuffer, gw485RxBuffer + 1, gw485RxBufferIndex);
return FALSE;
}
/**
* @brief 状态 StartFlagSL
* @param
* @retval TRUE:解析成功 FALSE:解析失败
*/
BOOL analysisStartFlagSL(void)
{
static uint16_t maxLen = 9;
/* 解析SL协议设备地址 */
if (gw485RxBufferIndex >= 9) {
if (gw485RxBuffer[2] == g_cfgParameter.address[0]
&& gw485RxBuffer[3] == g_cfgParameter.address[1]
&& gw485RxBuffer[4] == g_cfgParameter.address[2]
&& gw485RxBuffer[5] == g_cfgParameter.address[3]
&& gw485RxBuffer[6] == g_cfgParameter.address[4]
&& gw485RxBuffer[7] == g_cfgParameter.address[5]
&& gw485RxBuffer[8] == g_cfgParameter.address[6]) {
state = addressSL;
return TRUE;
}
if (gw485RxBuffer[2] == 0xFF
&& gw485RxBuffer[3] == 0xFF
&& gw485RxBuffer[4] == 0xFF
&& gw485RxBuffer[5] == 0xFF
&& gw485RxBuffer[6] == 0xFF
&& gw485RxBuffer[7] == 0xFF
&& gw485RxBuffer[8] == 0xFF) {
state = addressSL;
return TRUE;
}
}
if (gw485RxBufferIndex < maxLen) {
return FALSE;
}
state = wait;
gw485RxBufferIndex--;
memcpy(gw485RxBuffer, gw485RxBuffer + 1, gw485RxBufferIndex);
return FALSE;
}
/**
* @brief 状态 addressSL
* @param
* @retval TRUE:解析成功 FALSE:解析失败
*/
BOOL analysisAddressSL(void)
{
static uint16_t maxLen = 10;
/* 解析SL功能码 */
if (gw485RxBufferIndex >= 10) {
/* 判断地址是否为广播ID */
uint8_t temp = 0;
if (gw485RxBuffer[2] == 0xFF
&& gw485RxBuffer[3] == 0xFF
&& gw485RxBuffer[4] == 0xFF
&& gw485RxBuffer[5] == 0xFF
&& gw485RxBuffer[6] == 0xFF
&& gw485RxBuffer[7] == 0xFF
&& gw485RxBuffer[8] == 0xFF) {
temp = 1;
} else {
temp = 0;
}
/* 判断功能码类型 */
if (temp == 0) {
if (gw485RxBuffer[9] == SL_Function_Code_Read_Register
|| gw485RxBuffer[9] == SL_Function_Code_Write_Register
|| gw485RxBuffer[9] == SL_Function_Code_Registration_request
|| gw485RxBuffer[9] == SL_Function_Code_Distribution_Profile
|| gw485RxBuffer[9] == SL_Function_Code_Read_Profile ) {
state = functionCodeSL;
return TRUE;
}
}
else {
if (gw485RxBuffer[9] == SL_Function_Code_Broadcast_Scan) {
state = functionCodeSL;
frameLength = 13;
return TRUE;
}
}
}
if (gw485RxBufferIndex < maxLen) {
return FALSE;
}
state = wait;
gw485RxBufferIndex--;
memcpy(gw485RxBuffer, gw485RxBuffer + 1, gw485RxBufferIndex);
return FALSE;
}
/**
* @brief 状态 functionCodeSL
* @param
* @retval TRUE:解析成功 FALSE:解析失败
*/
BOOL analysisFunctionCodeSL(void)
{
static uint16_t maxLen = 12;
/* 解析读取寄存器起始位置 */
if ((gw485RxBufferIndex >= 12) && (gw485RxBuffer[9] == SL_Function_Code_Read_Register)) {
uint32_t tempAddrStart = 0;
tempAddrStart = (gw485RxBuffer[10] << 8) | gw485RxBuffer[11];
if (tempAddrStart >= minReadRegAddrMacro && tempAddrStart <= maxReadRegAddrMacro) {
state = readRegStartAddressSL;
return TRUE;
}
}
/* 解析写入寄存器起始位置 */
if ((gw485RxBufferIndex >= 12) && (gw485RxBuffer[9] == SL_Function_Code_Write_Register)) {
uint32_t tempAddrStart = 0;
tempAddrStart = (gw485RxBuffer[10] << 8) | gw485RxBuffer[11];
if (tempAddrStart >= minWriteRegAddrMacro && tempAddrStart <= maxWriteRegAddrMacro) {
state = writeRegStartAddressSL;
return TRUE;
}
}
/* 解析扫描广播帧crc校验 */
if ((gw485RxBufferIndex >= 12) && (gw485RxBuffer[9] == SL_Function_Code_Broadcast_Scan)) {
uint32_t tempCrc = 0;
tempCrc = (gw485RxBuffer[frameLength - 3] << 8) | gw485RxBuffer[frameLength - 2];
if (tempCrc == checkModebusCrc(gw485RxBuffer, frameLength - 3)) {
state = crcCheckBitSL;
return TRUE;
}
log_info("tempCrc:%d", tempCrc);
log_info("checkModebusCrc:%d", checkModebusCrc(gw485RxBuffer, frameLength - 3));
}
/* 解析注册回复帧寄存器长度 */
if ((gw485RxBufferIndex >= 12) && (gw485RxBuffer[9] == SL_Function_Code_Registration_request)) {
uint32_t tempRegLen = 0;
tempRegLen = (gw485RxBuffer[10] << 8) | gw485RxBuffer[11];
if (tempRegLen < RegAddrNumMacro && tempRegLen > 0) {
state = regLengthSL;
frameLength = 17;
return TRUE;
}
}
if (gw485RxBufferIndex < maxLen) {
return FALSE;
}
state = wait;
gw485RxBufferIndex--;
memcpy(gw485RxBuffer, gw485RxBuffer + 1, gw485RxBufferIndex);
return FALSE;
}
/**
* @brief 状态 readRegStartAddressSL
* @param
* @retval TRUE:解析成功 FALSE:解析失败
*/
BOOL analysisReadRegStartAddressSL(void)
{
static uint16_t maxLen = 12;
/* 解析读取寄存器长度 */
if (gw485RxBufferIndex >= 14) {
uint32_t tempAddrNumber = 0;
tempAddrNumber = (gw485RxBuffer[12] << 8) | gw485RxBuffer[13];
if (tempAddrNumber >= 1 && tempAddrNumber <= maxReadRegAddrNumMacro) {
state = readRegStartNumberSL;
frameLength = 17;
return TRUE;
}
}
if (gw485RxBufferIndex < maxLen) {
return FALSE;
}
state = wait;
gw485RxBufferIndex--;
memcpy(gw485RxBuffer, gw485RxBuffer + 1, gw485RxBufferIndex);
return FALSE;
}
/**
* @brief 状态 readRegStartNumberSL
* @param
* @retval TRUE:解析成功 FALSE:解析失败
*/
BOOL analysisReadRegStartNumberSL(void)
{
static uint16_t maxLen = 16;
/* crc校验 */
if (gw485RxBufferIndex >= 16) {
uint32_t tempCrc = 0;
tempCrc = (gw485RxBuffer[14] << 8) | gw485RxBuffer[15];
if (tempCrc == checkModebusCrc(gw485RxBuffer, 14)) {
state = crcCheckBitSL;
return TRUE;
}
}
if (gw485RxBufferIndex < maxLen) {
return FALSE;
}
state = wait;
gw485RxBufferIndex--;
memcpy(gw485RxBuffer, gw485RxBuffer + 1, gw485RxBufferIndex);
return FALSE;
}
/**
* @brief 状态 crcCheckBitSL
* @param
* @retval TRUE:解析成功 FALSE:解析失败
*/
BOOL analysisCrcCheckBitSL(void)
{
/* 结束标志校验校验 */
if (gw485RxBufferIndex == frameLength) {
if (gw485RxBuffer[frameLength - 1] == 0x16) {
state = endFlagSL;
return TRUE;
}
}
state = wait;
gw485RxBufferIndex--;
memcpy(gw485RxBuffer, gw485RxBuffer + 1, gw485RxBufferIndex);
return FALSE;
}
/**
* @brief 状态 endFlagSL
* @param device 串口设备
* @retval TRUE:解析成功 FALSE:解析失败
*/
void analysisEndFlagSL(device_handle device)
{
/* 数据为读取寄存器 */
if (gw485RxBuffer[9] == SL_Function_Code_Read_Register) {
SL_MsgProcFunc_Read_Register(device, gw485RxBuffer, frameLength);
}
/* 数据为写入寄存器 */
else if (gw485RxBuffer[9] == SL_Function_Code_Write_Register) {
SL_MsgProcFunc_Write_Register(device, gw485RxBuffer, frameLength);
}
/* 数据为扫描广播帧 */
else if (gw485RxBuffer[9] == SL_Function_Code_Broadcast_Scan) {
SL_MsgProcFunc_Broadcast_Scan(device, gw485RxBuffer, frameLength);
}
/* 数据为注册回复帧 */
else if (gw485RxBuffer[9] == SL_Function_Code_Registration_request) {
SL_MsgProcFunc_Registration_request(device, gw485RxBuffer, frameLength);
}
/* 数据为下发配置文件 */
else if (gw485RxBuffer[9] == SL_Function_Code_Distribution_Profile) {
SL_MsgProcFunc_Distribution_Profile(device, gw485RxBuffer, frameLength);
}
/* 数据为读取配置文件 */
else if (gw485RxBuffer[9] == SL_Function_Code_Read_Profile) {
SL_MsgProcFunc_Read_Profile(device, gw485RxBuffer, frameLength);
}
state = wait;
gw485RxBufferIndex = 0;
// memcpy(gw485RxBuffer, gw485RxBuffer + gw485RxBufferIndex, );
}
/**
* @brief 状态 writeRegStartAddressSL
* @param
* @retval TRUE:解析成功 FALSE:解析失败
*/
BOOL analysisWriteRegStartAddressSL(void)
{
static uint16_t maxLen = 14;
/* 解析写入寄存器长度 */
if (gw485RxBufferIndex >= 14) {
uint32_t tempAddrNumber = 0;
tempAddrNumber = (gw485RxBuffer[12] << 8) | gw485RxBuffer[13];
if (tempAddrNumber >= 1 && tempAddrNumber <= maxWriteRegAddrNumMacro) {
state = writeRegStartNumberSL;
frameLength = 17 + tempAddrNumber * 2;
return TRUE;
}
}
if (gw485RxBufferIndex < maxLen) {
return FALSE;
}
state = wait;
gw485RxBufferIndex--;
memcpy(gw485RxBuffer, gw485RxBuffer + 1, gw485RxBufferIndex);
return FALSE;
}
/**
* @brief 状态 writeRegStartNumberSL
* @param
* @retval TRUE:解析成功 FALSE:解析失败
*/
BOOL analysisWriteRegStartNumberSL(void)
{
static uint16_t maxLen = 16;
/* crc校验 */
if (gw485RxBufferIndex >= 16) {
uint32_t tempCrc = 0;
tempCrc = (gw485RxBuffer[frameLength - 3] << 8) | gw485RxBuffer[frameLength - 2];
if (tempCrc == checkModebusCrc(gw485RxBuffer, frameLength - 3)) {
state = crcCheckBitSL;
return TRUE;
}
}
if (gw485RxBufferIndex < maxLen) {
return FALSE;
}
state = wait;
gw485RxBufferIndex--;
memcpy(gw485RxBuffer, gw485RxBuffer + 1, gw485RxBufferIndex);
return FALSE;
}
/**
* @brief 状态 regLengthSL
* @param
* @retval TRUE:解析成功 FALSE:解析失败
*/
BOOL analysisRegLengthSL(void)
{
static uint16_t maxLen = 12;
/* crc校验 */
if (gw485RxBufferIndex >= 12) {
uint32_t tempRegStatus = 0;
tempRegStatus = (gw485RxBuffer[12] << 8) | gw485RxBuffer[13];
if (tempRegStatus == UNREGISTER
|| tempRegStatus == REGISTER_FAIL
|| tempRegStatus == REGISTER_SUCCESS) {
state = regStatusSL;
return TRUE;
}
}
if (gw485RxBufferIndex < maxLen) {
return FALSE;
}
state = wait;
gw485RxBufferIndex--;
memcpy(gw485RxBuffer, gw485RxBuffer + 1, gw485RxBufferIndex);
return FALSE;
}
/**
* @brief 状态 regStatusSL
* @param
* @retval TRUE:解析成功 FALSE:解析失败
*/
BOOL analysisRegStatusSL(void)
{
static uint16_t maxLen = 16;
/* crc校验 */
if (gw485RxBufferIndex >= 16) {
uint32_t tempCrc = 0;
tempCrc = (gw485RxBuffer[frameLength - 3] << 8) | gw485RxBuffer[frameLength - 2];
if (tempCrc == checkModebusCrc(gw485RxBuffer, frameLength - 3)) {
state = crcCheckBitSL;
return TRUE;
}
}
if (gw485RxBufferIndex < maxLen) {
return FALSE;
}
state = wait;
gw485RxBufferIndex--;
memcpy(gw485RxBuffer, gw485RxBuffer + 1, gw485RxBufferIndex);
return FALSE;
}
/**
* @brief 赛联协议读取寄存器
* @param device 串口设备
* pMsg 数据内容
* MsgLen 数据长度
* @retval
*/
void SL_MsgProcFunc_Read_Register(device_handle device, void *pMsg, uint32_t MsgLen)
{
debug_printf("SL_MsgProcFunc_Read_Register\n");
}
/**
* @brief 赛联协议写入寄存器
* @param device 串口设备
* pMsg 数据内容
* MsgLen 数据长度
* @retval
*/
void SL_MsgProcFunc_Write_Register(device_handle device, void *pMsg, uint32_t MsgLen)
{
debug_printf("SL_MsgProcFunc_Write_Register\n");
}
/**
* @brief 赛联协议扫描广播帧
* @param device 串口设备
* pMsg 数据内容
* MsgLen 数据长度
* @retval
*/
void SL_MsgProcFunc_Broadcast_Scan(device_handle device, void *pMsg, uint32_t MsgLen)
{
debug_printf("SL_MsgProcFunc_Broadcast_Scan\n");
}
/**
* @brief 赛联协议写入寄存器
* @param device 串口设备
* pMsg 数据内容
* MsgLen 数据长度
* @retval
*/
void SL_MsgProcFunc_Registration_request(device_handle device, void *pMsg, uint32_t MsgLen)
{
debug_printf("SL_MsgProcFunc_Registration_request\n");
}
/**
* @brief 赛联协议写入配置文件
* @param device 串口设备
* pMsg 数据内容
* MsgLen 数据长度
* @retval
*/
void SL_MsgProcFunc_Distribution_Profile(device_handle device, void *pMsg, uint32_t MsgLen)
{
debug_printf("SL_MsgProcFunc_Distribution_Profile\n");
}
/**
* @brief 赛联协议读取配置文件
* @param device 串口设备
* pMsg 数据内容
* MsgLen 数据长度
* @retval
*/
void SL_MsgProcFunc_Read_Profile(device_handle device, void *pMsg, uint32_t MsgLen)
{
debug_printf("SL_MsgProcFunc_Read_Profile\n");
}

422
APP/businessLogic/Src/cfg_protocol.c
View File

@ -1,422 +0,0 @@
#include "cfg_protocol.h"
#include "uart_dev.h"
#include "inFlash.h"
#include "parameter.h"
#include "string.h"
#include "chargControlTypes.h"
#include "pDebug.h"
#define cfgBuffLen 200
static uint8_t configBuff[cfgBuffLen];
static uint8_t cfigLen = 0;
/* 配置文件中的部分数据放大倍数 */
#define enlargeScale 100
/**
* @brief 向配置文件buff中存入一个数据
* @param c 数据
* @retval
*
*/
void inConfigBuff(uint8_t c)
{
if (cfigLen < cfgBuffLen) {
configBuff[cfigLen] = c;
cfigLen++;
}
}
/**
* @brief 向配置文件buff中丢掉一个数据
* @param
* @retval
*
*/
void outConfigBuff(void)
{
if (cfigLen > 0) {
cfigLen--;
memcpy(configBuff, configBuff + 1, cfigLen);
// memcpy(configBuff, configBuff + 1, sizeof(configBuff) - 1);
}
}
/**
* @brief modbus的crc校验
* @param *arr_buff 需要校验的数据
* len 数据长度
* @retval crc 校验的结果
*/
uint16_t checkModebusCrc(uint8_t *arr_buff, uint8_t len)
{
uint16_t crc = 0xFFFF;
uint16_t i, j;
for (j = 0; j < len; ++j) {
crc = crc ^ (*arr_buff++);
for (i = 0; i < 8; ++i) {
if ((crc&0x0001) > 0) {
crc = crc >> 1;
crc = crc ^ 0xa001;
}
else {
crc = crc >> 1;
}
}
}
return crc;
}
/**
* @brief 清空配置文件buff
* @param
* @retval
*
*/
void zeroConfigBuff(void)
{
cfigLen = 0;
}
/**
* @brief 判断接收到的配置文件数据是否正确，正确的话存入flash中
* @param None
* @retval None
*
*/
void read_and_process_config_data(void)
{
static config_info save_configInfo = {0};
recv_config_info *pack = (recv_config_info *)configBuff;
while (cfigLen >= RECV_CONFIG_INFO) {
/* 判断起始标志是否正确 */
// debug_printf(" start_Flag : 0x%x, 0x%x \n", pack->start_Flag[0], pack->start_Flag[1]);
if (pack->start_Flag[0] != g_cfgParameter.startFlagSL[0]
|| pack->start_Flag[1] != g_cfgParameter.startFlagSL[1]) {
debug(" start_Flag : 0x%x, 0x%x \n", pack->start_Flag[0], pack->start_Flag[1]);
goto err;
}
// /* 判断接入节点类型是否正确 */
// save_configInfo.Access_Node_Type = (uint16_t)pack->Access_Node_Type[0] << 8
// | (uint16_t)pack->Access_Node_Type[1];
// if (save_configInfo.Access_Node_Type != POWERBOX) {
// // debug(" Access_Node_Type : 0x%x \n", save_configInfo.Access_Node_Type);
// goto err;
// }
// /* 判断通信方式是否正确 */
// save_configInfo.Communication_Methods = (uint16_t)pack->Communication_Methods[0] << 8
// | (uint16_t)pack->Communication_Methods[1];
// // if (temp_u16 != RS485 || temp_u16 != RJ45) {
// if (save_configInfo.Communication_Methods != RS485) {
// debug(" Communication_Methods : 0x%x \n", save_configInfo.Communication_Methods);
// goto err;
// }
/* 判断波特率是否正确 */
save_configInfo.gw485_Baud = (uint32_t)pack->gw485_Baud[0] << 24
| (uint32_t)pack->gw485_Baud[1] << 16
| (uint32_t)pack->gw485_Baud[2] << 8
| (uint32_t)pack->gw485_Baud[3];
// debug(" gw485_Baud : 0x%x, %d \n", save_configInfo.gw485_Baud, save_configInfo.gw485_Baud);
if (save_configInfo.gw485_Baud != 9600
&& save_configInfo.gw485_Baud != 115200) {
debug(" gw485_Baud : %d\n", save_configInfo.gw485_Baud);
goto err;
}
save_configInfo.bat485_Baud = (uint32_t)pack->bat485_Baud[0] << 24
| (uint32_t)pack->bat485_Baud[1] << 16
| (uint32_t)pack->bat485_Baud[2] << 8
| (uint32_t)pack->bat485_Baud[3];
if (save_configInfo.bat485_Baud != 9600
&& save_configInfo.bat485_Baud!= 115200
&& save_configInfo.bat485_Baud!= 0) {
debug(" bat485_Baud : 0x%x, %d \n", save_configInfo.bat485_Baud, save_configInfo.bat485_Baud);
goto err;
}
/* 判断汇源协议类型是否正确 */
if (pack->protocolType != 0x01 && pack->protocolType != 0x02) {
debug(" protocolType : 0x%x \n", pack->protocolType);
goto err;
}
/* 判断通信协议类型是否正确 */
if (pack->CommunicationProtocolType != 0x00
&& pack->CommunicationProtocolType != 0x01) {
debug(" CommunicationProtocolType : 0x%x \n", pack->CommunicationProtocolType);
goto err;
}
/* 判断电源盒类型是否正确 */
if (pack->onlyPower != 0x00 && pack->onlyPower != 0x01) {
debug(" onlyPower : 0x%x \n", pack->onlyPower);
goto err;
}
/* 判断恒压充电阈值是否正确 */
save_configInfo.constantVoltageV =
(float)(pack->ConstantVoltageV[0] << 8 | pack->ConstantVoltageV[1]) / enlargeScale;
if (!((save_configInfo.constantVoltageV < 14.4f && save_configInfo.constantVoltageV > 13.5f)
|| save_configInfo.constantVoltageV == 0)) {
debug(" constantVoltageV : %f \n", save_configInfo.constantVoltageV);
goto err;
}
/* 判断浮充充电阈值是否正确 */
save_configInfo.floatI = (float)(pack->FloatI[0] << 8 | pack->FloatI[1]) / enlargeScale;
if (save_configInfo.floatI > 0.2f || save_configInfo.floatI < 0) {
debug(" floatI : %f \n", save_configInfo.floatI);
goto err;
}
/* 判断太阳能板开路启动电压是否正确 */
save_configInfo.startSolarOpenCircuitV =
(float)(pack->startSolarOpenCircuitV[0] << 8 | pack->startSolarOpenCircuitV[1]) / enlargeScale;
if (!((save_configInfo.startSolarOpenCircuitV < 24 && save_configInfo.startSolarOpenCircuitV > 14)
|| save_configInfo.startSolarOpenCircuitV == 0)) {
debug(" startSolarOpenCircuitV : %f \n", save_configInfo.startSolarOpenCircuitV);
goto err;
}
/* 判断太阳能板关闭电压是否正确 */
save_configInfo.stopSolarOpenCircuitV =
(float)(pack->stopSolarOpenCircuitV[0] << 8 | pack->stopSolarOpenCircuitV[1]) / enlargeScale;
if (!((save_configInfo.stopSolarOpenCircuitV < 17 && save_configInfo.stopSolarOpenCircuitV > 13)
|| save_configInfo.stopSolarOpenCircuitV == 0)) {
debug(" stopSolarOpenCircuitV : %f \n", save_configInfo.stopSolarOpenCircuitV);
goto err;
}
/* 判断恒压充电时的输出电压是否正确 */
save_configInfo.constantVoltageChargeV =
(float)(pack->constantVoltageChargeV[0] << 8 | pack->constantVoltageChargeV[1]) / enlargeScale;
if (!((save_configInfo.constantVoltageChargeV < 14.6f && save_configInfo.constantVoltageChargeV > 14)
|| save_configInfo.constantVoltageChargeV == 0)) {
debug(" constantVoltageChargeV : %f \n", save_configInfo.constantVoltageChargeV);
goto err;
}
/* 判断浮充充电时的输出电压是否正确 */
save_configInfo.FloatChargeV =
(float)(pack->FloatChargeV[0] << 8 | pack->FloatChargeV[1]) / enlargeScale;
if (!((save_configInfo.FloatChargeV < 14.4f && save_configInfo.FloatChargeV > 13.8f)
|| save_configInfo.FloatChargeV == 0)) {
debug(" FloatChargeV : %f \n", save_configInfo.FloatChargeV);
goto err;
}
/* 判断mos管停止工作温度是否正确 */
save_configInfo.HighSideMosTemperature_stop =
(float)(pack->HighSideMosTemperature_stop[0] << 8 | pack->HighSideMosTemperature_stop[1]) / enlargeScale;
if (save_configInfo.HighSideMosTemperature_stop < 50 && save_configInfo.HighSideMosTemperature_stop != 0) {
debug(" HighSideMosTemperature_stop : %f \n", save_configInfo.HighSideMosTemperature_stop);
goto err;
}
/* 判断mos管降低工作功率工作温度是否正确 */
save_configInfo.HighSideMosTemperature_end =
(float)(pack->HighSideMosTemperature_end[0] << 8 | pack->HighSideMosTemperature_end[1]) / enlargeScale;
if (save_configInfo.HighSideMosTemperature_end < 40 && save_configInfo.HighSideMosTemperature_end != 0) {
debug(" HighSideMosTemperature_end : %f \n", save_configInfo.HighSideMosTemperature_end);
goto err;
}
/* 判断mos管完全恢复工作温度是否正确 */
save_configInfo.HighSideMosTemperature_start =
(float)(pack->HighSideMosTemperature_start[0] << 8 | pack->HighSideMosTemperature_start[1]) / enlargeScale;
if (save_configInfo.HighSideMosTemperature_start > 70 && save_configInfo.HighSideMosTemperature_start != 0) {
debug(" HighSideMosTemperature_start : %d \n", save_configInfo.HighSideMosTemperature_start);
goto err;
}
// /* 判断启动任务中太阳能板开路电压检测间隔时间是否正确 */
// save_configInfo.checkSolarOpenCircuitVTime =
// pack->checkSolarOpenCircuitVTime[0] << 8 | pack->checkSolarOpenCircuitVTime[1];
// if (save_configInfo.checkSolarOpenCircuitVTime > 1800 || save_configInfo.checkSolarOpenCircuitVTime < 5) {
// debug(" checkSolarOpenCircuitVTime : %d \n", save_configInfo.checkSolarOpenCircuitVTime);
// goto err;
// }
// /* 判断传感器运行再次注册的间隔是否正确 */
// save_configInfo.sensorEnableBroadcastTime =
// pack->sensorEnableBroadcastTime[0] << 8 | pack->sensorEnableBroadcastTime[1];
// if (save_configInfo.sensorEnableBroadcastTime > 60 || save_configInfo.sensorEnableBroadcastTime < 10) {
// debug(" sensorEnableBroadcastTime : %d \n", save_configInfo.sensorEnableBroadcastTime);
// goto err;
// }
/* 判断出现短路保护后延长该段时间再次检测是否短路，仍然短路则关闭输出的间隔是否正确 */
save_configInfo.outputAgainFlagTime =
pack->outputAgainFlagTime[0] << 8 | pack->outputAgainFlagTime[1];
if (!((save_configInfo.outputAgainFlagTime < 30 && save_configInfo.outputAgainFlagTime > 5)
|| save_configInfo.outputAgainFlagTime == 0)) {
debug(" outputAgainFlagTime : %d \n", save_configInfo.outputAgainFlagTime);
goto err;
}
/* 判断出现过载后，在该间隔时间中多次（2次）出现过载，则关闭输出的间隔是否正确 */
save_configInfo.excessiveLoadFlagTime =
pack->excessiveLoadFlagTime[0] << 8 | pack->excessiveLoadFlagTime[1];
if (!((save_configInfo.excessiveLoadFlagTime < 90 && save_configInfo.excessiveLoadFlagTime > 20)
|| save_configInfo.excessiveLoadFlagTime == 0)) {
debug(" excessiveLoadFlagTime : %d \n", save_configInfo.excessiveLoadFlagTime);
goto err;
}
/* 判断出现过载过载保护后，在该间隔段时间后，再次尝试输出的间隔是否正确 */
save_configInfo.eLAgainTime = pack->eLAgainTime[0] << 8 | pack->eLAgainTime[1];
if (save_configInfo.eLAgainTime > 3000 || save_configInfo.eLAgainTime < 1000) {
debug(" eLAgainTime : %d \n", save_configInfo.eLAgainTime);
goto err;
}
/* crc校验 */
save_configInfo.crc = pack->crc[0] << 8 | pack->crc[1];
if (save_configInfo.crc != checkModebusCrc(configBuff, RECV_CONFIG_INFO - 3)) {
debug(" crc : %x%x \n", pack->crc[0], pack->crc[1]);
debug(" checkModebusCrc : %x \n", checkModebusCrc(configBuff, RECV_CONFIG_INFO));
goto err;
}
/* 结束标志 */
if (pack->end_Flag != 0x16) {
debug(" end_Flag : %x \n", pack->end_Flag);
goto err;
}
// debug("address : 0x %x %x %x %x %x %x %x\n", pack->address[0]
// , pack->address[1], pack->address[2], pack->address[3]
// , pack->address[4], pack->address[5], pack->address[6]);
config_info temp_configInfo;
read_config_info(&temp_configInfo);
if (pack->address[0] != 0xFF
|| pack->address[1] != 0xFF
|| pack->address[2] != 0xFF
|| pack->address[3] != 0xFF
|| pack->address[4] != 0xFF
|| pack->address[5] != 0xFF
|| pack->address[6] != 0xFF) {
save_configInfo.address[0] = pack->address[0];
save_configInfo.address[1] = pack->address[1];
save_configInfo.address[2] = pack->address[2];
save_configInfo.address[3] = pack->address[3];
save_configInfo.address[4] = pack->address[4];
save_configInfo.address[5] = pack->address[5];
save_configInfo.address[6] = pack->address[6];
// debug("address : 0x %x %x %x %x %x %x %x\n", save_configInfo.address[0]
// , save_configInfo.address[1], save_configInfo.address[2], save_configInfo.address[3]
// , save_configInfo.address[4], save_configInfo.address[5], save_configInfo.address[6]);
} else {
save_configInfo.address[0] = temp_configInfo.address[0];
save_configInfo.address[1] = temp_configInfo.address[1];
save_configInfo.address[2] = temp_configInfo.address[2];
save_configInfo.address[3] = temp_configInfo.address[3];
save_configInfo.address[4] = temp_configInfo.address[4];
save_configInfo.address[5] = temp_configInfo.address[5];
save_configInfo.address[6] = temp_configInfo.address[6];
}
if (pack->hardwareID[0] != 0xFF
|| pack->hardwareID[1] != 0xFF
|| pack->hardwareID[2] != 0xFF
|| pack->hardwareID[3] != 0xFF
|| pack->hardwareID[4] != 0xFF
|| pack->hardwareID[5] != 0xFF) {
save_configInfo.hardwareID[0] = pack->hardwareID[0];
save_configInfo.hardwareID[1] = pack->hardwareID[1];
save_configInfo.hardwareID[2] = pack->hardwareID[2];
save_configInfo.hardwareID[3] = pack->hardwareID[3];
save_configInfo.hardwareID[4] = pack->hardwareID[4];
save_configInfo.hardwareID[5] = pack->hardwareID[5];
} else {
save_configInfo.hardwareID[0] = temp_configInfo.hardwareID[0];
save_configInfo.hardwareID[1] = temp_configInfo.hardwareID[1];
save_configInfo.hardwareID[2] = temp_configInfo.hardwareID[2];
save_configInfo.hardwareID[3] = temp_configInfo.hardwareID[3];
save_configInfo.hardwareID[4] = temp_configInfo.hardwareID[4];
save_configInfo.hardwareID[5] = temp_configInfo.hardwareID[5];
}
if (pack->communicationID[0] != 0xFF
|| pack->communicationID[1] != 0xFF
|| pack->communicationID[2] != 0xFF
|| pack->communicationID[3] != 0xFF) {
save_configInfo.communicationID[0] = pack->communicationID[0];
save_configInfo.communicationID[1] = pack->communicationID[1];
save_configInfo.communicationID[2] = pack->communicationID[2];
save_configInfo.communicationID[3] = pack->communicationID[3];
} else {
save_configInfo.communicationID[0] = temp_configInfo.communicationID[0];
save_configInfo.communicationID[1] = temp_configInfo.communicationID[1];
save_configInfo.communicationID[2] = temp_configInfo.communicationID[2];
save_configInfo.communicationID[3] = temp_configInfo.communicationID[3];
}
save_configInfo.protocolType = pack->protocolType;
save_configInfo.CommunicationProtocolType = pack->CommunicationProtocolType;
save_configInfo.onlyPower = pack->onlyPower;
save_configInfo.crc = checkModebusCrc((uint8_t *)&save_configInfo, CONFIG_INFO_SIZE - 2);
// save_backups_config_info(&save_configInfo);
// save_config_info(&save_configInfo);
saveConfigInfo(&save_configInfo);
// memset(config_buff, 0, sizeof(config_buff));
zeroConfigBuff();
// /* 返回更改配置文件成功 */
// SL_Mppt_SOther_pack SUpdateProfile_pack = {0};
// SUpdateProfile_pack.start_Flag[0] = g_otherParameter.startFlagSL[0];
// SUpdateProfile_pack.start_Flag[1] = g_otherParameter.startFlagSL[1];
// SUpdateProfile_pack.address[0] = save_configInfo.address[0];
// SUpdateProfile_pack.address[1] = save_configInfo.address[1];
// SUpdateProfile_pack.address[2] = save_configInfo.address[2];
// SUpdateProfile_pack.address[3] = save_configInfo.address[3];
// SUpdateProfile_pack.address[4] = save_configInfo.address[4];
// SUpdateProfile_pack.address[5] = save_configInfo.address[5];
// SUpdateProfile_pack.address[6] = save_configInfo.address[6];
// SUpdateProfile_pack.function_Code = SL_Function_Code_Update_Profile;
// SUpdateProfile_pack.state = 0x01;
// uint16_t crc = CheckFuncSL((uint8_t *)&SUpdateProfile_pack, SL_MPPT_SOTHER_PACK_SIZE - 3);
// SUpdateProfile_pack.check_Bit_H = crc >> 8;
// SUpdateProfile_pack.check_Bit_L = crc;
// SUpdateProfile_pack.end_Flag = g_otherParameter.endFlagSL;
// while (1) {
// if (!Check_485_bus_busy(g_gw485_uart4_handle)) {
// uart_dev_write(g_gw485_uart4_handle, (uint8_t *)&SUpdateProfile_pack, SL_MPPT_SOTHER_PACK_SIZE);
// USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
// break;
// }
// Delay_Ms(randomDelay());
// }
uart_dev_write(g_gw485_uart2_handle, "hello world\n", sizeof("hello world\n"));
HAL_Delay(1000);
/* 复位 */
NVIC_SystemReset();
err:
// config_buff_pos--;
// memcpy(config_buff, config_buff + 1, sizeof(config_buff) - 1);
outConfigBuff();
}
}

1925
APP/businessLogic/Src/hy_protocol.c
View File

File diff suppressed because it is too large Load Diff

2
APP/businessLogic/Src/inFlash.c
View File

@ -2,7 +2,7 @@
#include "inFlash.h"
#include "parameter.h"
#include "pDebug.h"
#include "cfg_protocol.h"
//#include "cfg_protocol.h"
#include "configParameter.h"
static void save_config_info(config_info *save_config_info);

246
APP/businessLogic/Src/task.c
View File

@ -5,16 +5,20 @@
#include "FM_GPIO.h"
#include "chargControlTypes.h"
#include "bl_chargControl.h"
#include "hy_protocol.h"
#include "cfg_protocol.h"
//#include "hy_protocol.h"
//#include "cfg_protocol.h"
#include "uart_dev.h"
#include "abnormalManage.h"
#include "interruptSend.h"
#include "configParameter.h"
#include "capture.h"
#include "bl_usart.h"
#include <stdio.h>
/* 控制运行指示灯和喂狗 */
#define runled_reloadVal 2000 /* 任务执行间隔 */
// static uint16_t runled_reloadVal = 1000; /* 任务执行间隔 */
@ -58,31 +62,31 @@ static void Task_impedanceCalculation(void);
STR_TimeSliceOffset m_collectOpenCircuitVoltage;
void Task_collectOpenCircuitVoltage(void);
/* 限时开启HY协议配置模式 */
#define beginHYconfigMode_reloadVal 1000 /* 任务执行间隔 */
#define beginHYconfigMode_offset 0 /* 任务执行偏移量 */
static STR_TimeSliceOffset m_beginHYconfigMode;
static void Task_beginHYconfigMode(void);
// /* 限时开启HY协议配置模式 */
// #define beginHYconfigMode_reloadVal 1000 /* 任务执行间隔 */
// #define beginHYconfigMode_offset 0 /* 任务执行偏移量 */
// static STR_TimeSliceOffset m_beginHYconfigMode;
// static void Task_beginHYconfigMode(void);
/* 串口数据接收判断 */
#define usartJudge_reloadVal 100 /* 任务执行间隔 */
#define usartJudge_offset 0 /* 任务执行偏移量 */
static STR_TimeSliceOffset m_usartJudge;
static void Task_usartJudge(void);
// /* 串口数据接收判断 */
// #define usartJudge_reloadVal 100 /* 任务执行间隔 */
// #define usartJudge_offset 0 /* 任务执行偏移量 */
// static STR_TimeSliceOffset m_usartJudge;
// static void Task_usartJudge(void);
/* 串口数据解析和处理 */
#define usartHandle_reloadVal 20 /* 任务执行间隔 */
#define usartHandle_offset 0 /* 任务执行偏移量 */
static STR_TimeSliceOffset m_usartHandle;
static void Task_usartHandle(void);
typedef void (*uartJudgeHandle)(device_handle device);
static uartJudgeHandle uart_judge_handle;
// /* 串口数据解析和处理 */
// #define usartHandle_reloadVal 20 /* 任务执行间隔 */
// #define usartHandle_offset 0 /* 任务执行偏移量 */
// static STR_TimeSliceOffset m_usartHandle;
// static void Task_usartHandle(void);
// typedef void (*uartJudgeHandle)(device_handle device);
// static uartJudgeHandle uart_judge_handle;
/* 配置文件数据解析和处理 */
#define usartCfg_reloadVal 200 /* 任务执行间隔 */
#define usartCfg_offset 0 /* 任务执行偏移量 */
static STR_TimeSliceOffset m_usartCfg;
static void Task_usartCfg(void);
// /* 配置文件数据解析和处理 */
// #define usartCfg_reloadVal 200 /* 任务执行间隔 */
// #define usartCfg_offset 0 /* 任务执行偏移量 */
// static STR_TimeSliceOffset m_usartCfg;
// static void Task_usartCfg(void);
/* 短路保护 */
#define shortCircuitProtection_reloadVal 1000 /* 任务执行间隔 */
@ -120,6 +124,13 @@ void Task_busFree(void);
STR_TimeSliceOffset m_softShortCircuit;
void Task_softShortCircuit(void);
/* 串口任务 */
#define uart_reloadVal 100 /* 任务执行间隔 */
#define uart_offset 0 /* 任务执行偏移量 */
STR_TimeSliceOffset m_uart;
void Task_uart(void);
/**
* @brief 启动时初始化各任务
* @param None
@ -136,9 +147,7 @@ void task_Init(void)
TimeSliceOffset_Register(&m_collectOpenCircuitVoltage, Task_collectOpenCircuitVoltage
, collectOpenCircuitVoltage_reloadVal, collectOpenCircuitVoltage_offset);
uartTaskInit();
TimeSliceOffset_Register(&m_usartJudge, Task_usartJudge, usartJudge_reloadVal, usartJudge_offset);
TimeSliceOffset_Register(&m_usartCfg, Task_usartCfg, usartCfg_reloadVal, usartCfg_offset);
TimeSliceOffset_Register(&m_uart, Task_uart, uart_reloadVal, uart_offset);
TimeSliceOffset_Register(&m_busFree, Task_busFree, busFree_reloadVal, busFree_offset);
}
@ -179,17 +188,17 @@ void Task_wdi(void)
{
feedDog();
debug_printf("chargCurrent:%f \n", getChargCurrent());
debug_printf("outputVoltage:%f \n", getOutputVoltage());
debug_printf("BatteryVoltage:%f \n", getBatteryVoltage());
debug_printf("dischargCurrent:%f \n", getDischargCurrent());
debug_printf("solarInCircuitVoltage:%f \n", getSolarInCircuitVoltage());
debug_printf("HighSideMosTemperature:%f \n", getHighSideMosTemperature());
debug_printf("InputVoltage:%f \n", getInputVoltage());
debug_printf("DischargMosState:%d \n", getDischargMosState());
debug_printf("MPPT_Mode:%d \n", getMPPT_Mode());
debug_printf("loopImpedance:%f \n", g_cfgParameter.loopImpedance);
debug_printf("DutyRatio:%f \n", getDutyRatio());
// debug_printf("chargCurrent:%f \n", getChargCurrent());
// debug_printf("outputVoltage:%f \n", getOutputVoltage());
// debug_printf("BatteryVoltage:%f \n", getBatteryVoltage());
// debug_printf("dischargCurrent:%f \n", getDischargCurrent());
// debug_printf("solarInCircuitVoltage:%f \n", getSolarInCircuitVoltage());
// debug_printf("HighSideMosTemperature:%f \n", getHighSideMosTemperature());
// debug_printf("InputVoltage:%f \n", getInputVoltage());
// debug_printf("DischargMosState:%d \n", getDischargMosState());
// debug_printf("MPPT_Mode:%d \n", getMPPT_Mode());
// debug_printf("loopImpedance:%f \n", g_cfgParameter.loopImpedance);
// debug_printf("DutyRatio:%f \n", getDutyRatio());
// char buf[100];
// sprintf(buf, "chargCurrent:%f \n", getChargCurrent());
@ -502,86 +511,86 @@ void Task_collectOpenCircuitVoltage(void)
}
}
/**
* @brief 开启HY配置模式后，配置完成后120S后自动退出
* @param
* @retval
*/
void Task_beginHYconfigMode(void)
{
static uint8_t num = 0;
num++;
if (num >= 120) {
TimeSliceOffset_Unregister(&m_beginHYconfigMode);
m_beginHYconfigMode.runFlag = 0;
num = 0;
setHYconfigModeState(FALSE);
}
}
// /**
// * @brief 开启HY配置模式后，配置完成后120S后自动退出
// * @param
// * @retval
// */
// void Task_beginHYconfigMode(void)
// {
// static uint8_t num = 0;
// num++;
// if (num >= 120) {
// TimeSliceOffset_Unregister(&m_beginHYconfigMode);
// m_beginHYconfigMode.runFlag = 0;
// num = 0;
// setHYconfigModeState(FALSE);
// }
// }
/**
* @brief 开启HY配置模式后启动退出任务
* @param
* @retval
*/
void beginHYconfigMode(void)
{
setHYconfigModeState(TRUE);
TimeSliceOffset_Register(&m_beginHYconfigMode, Task_beginHYconfigMode
, beginHYconfigMode_reloadVal, beginHYconfigMode_offset);
}
// /**
// * @brief 开启HY配置模式后启动退出任务
// * @param
// * @retval
// */
// void beginHYconfigMode(void)
// {
// setHYconfigModeState(TRUE);
// TimeSliceOffset_Register(&m_beginHYconfigMode, Task_beginHYconfigMode
// , beginHYconfigMode_reloadVal, beginHYconfigMode_offset);
// }
/**
* @brief 初始化串口任务，确定使用的协议
* @param
* @retval
*/
void uartTaskInit(void)
{
// if (g_cfgParameter.CommunicationProtocolType == 0x00) {
// uart_judge_handle = read_and_process_uart_data;
// } else if (g_cfgParameter.CommunicationProtocolType == 0x01) {
// uart_judge_handle = HY_read_and_process_uart_data;
// }
// /**
// * @brief 初始化串口任务，确定使用的协议
// * @param
// * @retval
// */
// void uartTaskInit(void)
// {
// // if (g_cfgParameter.CommunicationProtocolType == 0x00) {
// // uart_judge_handle = read_and_process_uart_data;
// // } else if (g_cfgParameter.CommunicationProtocolType == 0x01) {
// // uart_judge_handle = HY_read_and_process_uart_data;
// // }
uart_judge_handle = HY_read_and_process_uart_data;
}
// uart_judge_handle = HY_read_and_process_uart_data;
// }
/**
* @brief 检测有无通信数据传来
* @param
* @retval
*/
void Task_usartJudge(void)
{
/* 检测到对上通信串口有数据启动读取并解析任务 */
if (uart_dev_char_present(g_gw485_uart2_handle)) {
TimeSliceOffset_Register(&m_usartHandle, Task_usartHandle
, usartHandle_reloadVal, usartHandle_offset);
}
}
// /**
// * @brief 检测有无通信数据传来
// * @param
// * @retval
// */
// void Task_usartJudge(void)
// {
// /* 检测到对上通信串口有数据启动读取并解析任务 */
// if (uart_dev_char_present(g_gw485_uart2_handle)) {
// TimeSliceOffset_Register(&m_usartHandle, Task_usartHandle
// , usartHandle_reloadVal, usartHandle_offset);
// }
// }
/**
* @brief 读取并解析对上通讯的数据
* @param
* @retval
*/
void Task_usartHandle(void)
{
TimeSliceOffset_Unregister(&m_usartHandle);
m_usartHandle.runFlag = 0;
uart_judge_handle(g_gw485_uart2_handle);
}
// /**
// * @brief 读取并解析对上通讯的数据
// * @param
// * @retval
// */
// void Task_usartHandle(void)
// {
// TimeSliceOffset_Unregister(&m_usartHandle);
// m_usartHandle.runFlag = 0;
// uart_judge_handle(g_gw485_uart2_handle);
// }
/**
* @brief 读取并解析配置文件的数据
* @param
* @retval
*/
void Task_usartCfg(void)
{
read_and_process_config_data();
}
// /**
// * @brief 读取并解析配置文件的数据
// * @param
// * @retval
// */
// void Task_usartCfg(void)
// {
// read_and_process_config_data();
// }
/**
* @brief 短路保护任务，短路后启动该任务
@ -774,4 +783,15 @@ void startSoftShortCircuitProtection(void)
{
TimeSliceOffset_Register(&m_softShortCircuit, Task_softShortCircuit
, softShortCircuit_reloadVal, softShortCircuit_offset);
}
}
/**
* @brief 启动软件解析任务
* @param
* @retval
*/
void Task_uart(void)
{
gw485DataAnalysis(g_gw485_uart2_handle);
}

2659
EWARM/chargeController.ewp
View File

File diff suppressed because it is too large Load Diff

8
EWARM/chargeController.ewt
View File

@ -1449,10 +1449,7 @@
<name>$PROJ_DIR$\..\APP\businessLogic\Src\bl_comm.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\cfg_protocol.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\hy_protocol.c</name>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\bl_usart.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\inFlash.c</name>
@ -1466,6 +1463,9 @@
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\parameter.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\SOE.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\task.c</name>
</file>

5
tools/configParameter.h
View File

@ -4,6 +4,7 @@
#include "comm_types.h"
#define softVer "SV01_24101501"
// /* 第一段保护的延时时间（单位100uS） */
// const uint32_t firstStageProtectionDelay = 2; // 200uS
@ -64,4 +65,8 @@
/* 最大充电电压（V） */
#define maxOpenSolarOpenCircuitVMacro 25.0f
#endif