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

Compare commits

base: pengsx:b98ba4a635e5a213edb43ca2d76f6acfca7159fc
Branches Tags
pengsx:master
pengsx:usart
pengsx:home
..
compare: pengsx:0288f9a9a64fa57ccca517225b9145723c5159d6
Branches Tags
pengsx:usart
pengsx:master
pengsx:home

No commits in common. "b98ba4a635e5a213edb43ca2d76f6acfca7159fc" and "0288f9a9a64fa57ccca517225b9145723c5159d6" have entirely different histories.
b98ba4a635 ... 0288f9a9a6

48 changed files with 131 additions and 3352 deletions
Show Stats Expand all files Collapse all files

16
.mxproject
View File

File diff suppressed because one or more lines are too long

14
.vscode/settings.json vendored
View File

@ -4,18 +4,6 @@
"parameter.h": "c",
"comm.h": "c",
"bl_chargcontrol.h": "c",
"comm_types.h": "c",
"hd_gpio.h": "c",
"inflash.h": "c",
"fm_tim.h": "c",
"timesliceoffset.h": "c",
"fm_gpio.h": "c",
"pdebug.h": "c",
"start.h": "c",
"bl_comm.h": "c",
"capture.h": "c",
"arm_math.h": "c",
"abnormalmanage.h": "c",
"stm32g431xx.h": "c"
"comm_types.h": "c"
}
}

1
APP/application/Inc/comm.h
View File

@ -3,7 +3,6 @@
#define APP_COMM_H_
#include "comm_types.h"
#include "bl_comm.h"
void uart_comm(void);

10
APP/application/Inc/task.h
View File

@ -1,10 +0,0 @@
#ifndef APP_TASK_H_
#define APP_TASK_H_
#include "timeSliceOffset.h"
#endif

12
APP/application/Src/chargControl.c
View File

@ -3,24 +3,18 @@
#include "parameter.h"
#include "comm_types.h"
/**
* @brief 完成充电控制
* @param
* @retval
*
*/
void chargControl(void)
{
getCVData();
judgeYNBattery();
chargControlMode();
g_otherParameter.MPPT_Mode = chargControlMode();
if (getMPPT_Mode() == noWork) {
if (g_otherParameter.MPPT_Mode == noWork) {
return;
}
if (getBatteryState()) {
if (g_otherParameter.batteryState) {
BatteryChargControl();
} else {
noBatteryChargControl();

6
APP/application/Src/start.c
View File

@ -1,14 +1,12 @@
#include "start.h"
#include "inFlash.h"
#include "TimeSliceOffset.h"
void start(void)
{
config_info_start();
TimeSliceOffset_Start();
}

9
APP/application/Src/task.c
View File

@ -1,9 +0,0 @@
#include "task.h"

11
APP/businessLogic/Inc/Init.h
View File

@ -1,11 +0,0 @@
#ifndef BL_PARAMETER_H_
#define BL_PARAMETER_H_
void Init(void);
#endif

15
APP/businessLogic/Inc/abnormalManage.h
View File

@ -1,15 +0,0 @@
#ifndef BL_ABNORMAL_MANAGE_H_
#define BL_ABNORMAL_MANAGE_H_
#include "FM_TIM.h"
void checkAbnormal(void);
#endif

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

@ -2,11 +2,10 @@
#define BL_CHARG_CONTROL_H_
#include "chargControlEnum.h"
#include "FM_TIM.h"
void getCVData(void);
void judgeYNBattery(void);
void chargControlMode(void);
int chargControlMode(void);
void BatteryChargControl(void);
void noBatteryChargControl(void);

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

@ -1,110 +0,0 @@
#ifndef BL_IN_FLASH_H_
#define BL_IN_FLASH_H_
#include "flash.h"
#include "stm32g431xx.h"
#pragma pack(push, 1)
/* 高字节在前，低字节在后 */
typedef struct _recv_config_info{
uint8_t start_Flag[2]; /* 开始标志 */
/* SL */
uint8_t address[7]; /* 地址 */
uint8_t Access_Node_Type[2]; /* 接入节点类型 */
uint8_t Communication_Methods[2]; /* 通信方式 */
uint8_t gw485_Baud[4]; /* 串口波特率 */
uint8_t bat485_Baud[4]; /* 串口波特率,为0代表bms不支持通信 */
/* HY */
uint8_t hardwareID[6]; /* 硬件ID */
uint8_t communicationID[4]; /* 通信ID */
uint8_t protocolType; /* 协议类型; 0x01表示：汇源协议(波特率9600) 0x02表示：南瑞协议(波特率115200)*/
// uint8_t CommunicationProtocolType; /* 0x00:SL
// 0x01:HY*/
uint8_t onlyPower; /* 是否只充当电源板：0x00:不是
0x01：是*/
uint8_t ConstantVoltageV[2]; /* 高于该(电压 / 100)且电流大于FloatI * 100进行恒压充电 */
uint8_t FloatI[2]; /* 高于该(电压 / 100)且电流低于FloatI * 100进行浮充充电 */
uint8_t startSolarOpenCircuitV[2]; /* 高于该(电压 / 100)开始充电 */
uint8_t stopSolarOpenCircuitV[2]; /* 太阳能板开路电压高于该电压停止充电 (V) */
uint8_t constantVoltageChargeV[2]; /* 恒压充电时的输出电压 (V) */
uint8_t FloatChargeV[2]; /* 浮充充电时的输出电压 (V) */
uint8_t HighSideMosTemperature_stop[2]; /* 当上桥温度达到该值时，停止输出 (°C) */
uint8_t HighSideMosTemperature_end[2]; /* 当上桥温度上升到该值时，降低功率运行 (°C) */
uint8_t HighSideMosTemperature_start[2];/* 当上桥温度降低到该值时，按照正常情况输出 (°C) */
uint8_t checkSolarOpenCircuitVTime[2]; /* 启动任务中太阳能板开路电压检测间隔时间 (S) */
uint8_t sensorEnableBroadcastTime[2]; /* 传感器运行再次注册的间隔 (S) */
uint8_t outputAgainFlagTime[2]; /* 出现短路保护后延长该段时间再次检测是否短路，仍然短路则关闭输出 (S) */
uint8_t excessiveLoadFlagTime[2]; /* 出现过载后，在该间隔时间中多次（2次）出现过载，则关闭输出 (S) */
uint8_t eLAgainTime[2]; /* 出现过载过载保护后，在该间隔段时间后，再次尝试输出 (S) */
uint8_t crc[2]; /* 校验 */
uint8_t end_Flag; /* 结束标志 */
}recv_config_info;
#define RECV_CONFIG_INFO sizeof(recv_config_info)
typedef struct _config_info{
/* SL */
uint8_t address[7]; /* 地址 */
uint16_t Access_Node_Type; /* 接入节点类型 */
uint16_t Communication_Methods; /* 通信方式 */
uint32_t gw485_Baud; /* 串口波特率,为0代表bms不支持通信 */
uint32_t bat485_Baud; /* 串口波特率 */
/* HY */
uint8_t hardwareID[6]; /* 硬件ID */
uint8_t communicationID[4]; /* 通信ID */
uint8_t protocolType; /* 协议类型; 0x01表示：汇源协议(波特率9600) 0x02表示：南瑞协议(波特率115200)*/
// uint8_t CommunicationProtocolType; /* 0x00:SL
// 0x01:HY*/
uint8_t onlyPower; /* 是否只充当电源板：0x00:不是
0x01：是*/
float constantVoltageV; /* 电压高于ConstantVoltageV且电流大于FloatI + 0.1）进行恒压充电 */
float floatI; /* 电压高于ConstantVoltageV且电流低于FloatI进行浮充充电 */
float startSolarOpenCircuitV; /* 太阳能板开路电压高于该电压开始充电 */
float stopSolarOpenCircuitV; /* 太阳能板开路电压高于该电压 停止充电 */
float constantVoltageChargeV; /* 恒压充电时的输出电压 */
float FloatChargeV; /* 浮充电压 */
float HighSideMosTemperature_stop; /* 当上桥温度达到该值时，停止输出 */
float HighSideMosTemperature_end; /* 当上桥温度上升到该值时，降低功率运行 */
float HighSideMosTemperature_start; /* 当上桥温度降低到该值时，按照正常情况输出 */
uint16_t checkSolarOpenCircuitVTime; /* 启动任务中太阳能板开路电压检测时间 */
uint16_t sensorEnableBroadcastTime; /* 传感器运行再次注册的间隔 */
uint16_t outputAgainFlagTime; /* 出现短路保护后延长该段时间再次检测是否短路，仍然短路则关闭输出 */
uint16_t excessiveLoadFlagTime; /* 出现过载后，在该段时间中再次出现过载，则关闭输出 */
uint16_t eLAgainTime; /* 出现过载过载保护后，该段时间后，再次尝试输出 */
uint16_t crc; /* 校验 */
}config_info;
#define CONFIG_INFO_SIZE (sizeof(config_info))
#pragma pack(pop)
#define CONFIG_SAVE_addr (0)
#define CONFIG_SAVE_ADDR_BEGIN (CONFIG_INFO_SIZE)
#define CONFIG_SAVE_ADDR_END (CONFIG_INFO_SIZE + CONFIG_INFO_SIZE)
#define LoopImpedance_SAVE_addr (CONFIG_INFO_SIZE + CONFIG_INFO_SIZE + 10)
#define totalElectricityConsumption_SAVE_addr (CONFIG_INFO_SIZE + CONFIG_INFO_SIZE + 20)
#define totalChargCapacity_SAVE_addr (CONFIG_INFO_SIZE + CONFIG_INFO_SIZE + 30)
void save_config_info(config_info *save_config_info);
void read_config_info(config_info *output_config_info);
void config_info_start(void);
// void read_and_process_config_data(void);
void saveLoopImpedance(float *loopImpedance);
void readLoopImpedance(float *loopImpedance);
void savetotalElectricityConsumption(float *totalElectricityConsumption);
void readtotalElectricityConsumption(float *totalElectricityConsumption);
void savetotalChargCapacity(float *totalChargCapacity);
void readtotalChargCapacity(float *totalChargCapacity);
#endif

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

@ -1,12 +1,12 @@
#ifndef BL_PARAMETER_H_
#define BL_PARAMETER_H_
#include "main.h"
#include "comm_types.h"
#define softVer "SV01_24101501"
// #pragma pack(push,1)
#pragma pack(push,1)
/* 主要有配置文件读取出来的数据 */
typedef struct _config_parameter{
@ -30,10 +30,10 @@ typedef struct _config_parameter{
uint32_t collectOpenCircuitVoltageTime; /* 开路电压采集时间间隔 */
/* SL */
uint8_t address[7]; /* 地址 */
uint16_t Access_Node_Type; /* 接入节点类型 */
uint16_t Communication_Methods; /* 通信方式 */
uint16_t Registration_Status; /* 注册状态 */
uint8_t address[7]; /* 地址 */
uint8_t startFlagSL[2]; /* 起始标志 */
uint8_t endFlagSL; /* 结束标志 */
@ -51,6 +51,7 @@ typedef struct _config_parameter{
uint32_t bat485_Baud; /* 串口波特率,为0代表bms不支持通信 */
} config_parameter;
extern config_parameter g_cfgParameter;
typedef struct _otherParameter{
float Battery_Voltage; /* 电池电压 (V) */
float Output_Voltage; /* 输出电压 */
@ -61,57 +62,27 @@ typedef struct _otherParameter{
float HighSideMos_Temperature; /* 高端mos的温度 (°C) */
float Solar_In_Circuit_Voltage; /* 太阳能板输入电压 (V) */
float Charg_BatteryCurrent; /* 电池充电电流（流向电池） (A) */
float totalElectricityConsumption; /* 总电量消耗(W*H) */
float totalChargCapacity; /* 总充电电量(W*H) */
float SOC; /* 剩余电量 */
uint16_t MPPT_Mode; /* 工作模式 */
uint16_t chargMos_State; /* 充电开关状态 */
uint16_t DischargMos_State; /* 放电mos的状态 */
uint16_t MPPT_Mode; /* 工作模式 */
uint8_t versionInformation[13]; /* 软件版本信息 */
uint8_t versionInformation[13]; /* 软件版本信息 */
uint8_t batteryState; /* 有无电池（估计） */
float dutyRatio; /* 占空比 */
}otherParameter;
// #pragma pack(pop)
extern otherParameter g_otherParameter;
BOOL getBatteryState(void);
void setBatteryState(BOOL state);
float getDutyRatio(void);
void setDutyRatio(float DutyRatio);
void setDutyRatioToZero(void);
float getBatteryVoltage(void);
void setBatteryVoltage(void);
float getOutputVoltage(void);
void setOutputVoltage(void);
float getChargCurrent(void);
void setChargCurrent(void);
float getDischargCurrent(void);
void setDischargCurrent(void);
float getInputVoltage(void);
void setInputVoltage(void);
float getSolarOpenCircuitVoltage(void);
void setSolarOpenCircuitVoltage(void);
float getHighSideMosTemperature(void);
void setHighSideMosTemperature(void);
float getSolarInCircuitVoltage(void);
void setSolarInCircuitVoltage(void);
float getTotalElectricityConsumption(void);
void setTotalElectricityConsumption(void);
void totalElectricityConsumptionInt(float totalPower);
float getTotalChargCapacity(void);
void setTotalChargCapacity(void);
void totalChargCapacityInt(float totalPower);
float getSOC(void);
void setSOC(void);
int getMPPT_Mode(void);
void setMPPT_Mode(int MPPT_Mode);
float getChargBatteryCurrent(void);
BOOL getChargMosState(void);
void setChargMosState(BOOL state);
BOOL getDischargMosState(void);
uint8_t *getVersionInformation(void);
#endif

21
APP/businessLogic/Src/Init.c
View File

@ -1,21 +0,0 @@
#include "Init.h"
#include "capture.h"
#include "FM_GPIO.h"
#include "inFlash.h"
#include "parameter.h"
#include "FM_GPIO.h"
#include "FM_TIM.h"
void Init(void)
{
config_info_start();
ADC_Capture_Init();
proportionalInt(getMPPT_Mode());
FM_GPIO_Init();
tim_Init();
}

25
APP/businessLogic/Src/abnormalManage.c
View File

@ -1,25 +0,0 @@
#include "abnormalManage.h"
#include "parameter.h"
#include "capture.h"
void checkAbnormal(void)
{
/* 滤波 */
adcCaptureFir();
/* 转换 */
setChargCurrent();
setDischargCurrent();
setOutputVoltage();
setSolarInCircuitVoltage();
/* 判断异常状态 */
}

29
APP/businessLogic/Src/bl_chargControl.c
View File

@ -4,10 +4,10 @@
#include "comm_types.h"
static void stopChargWork(void);
static BOOL stopChargConditions(void);
static BOOL floatChargConditions(void);
static BOOL mpptChargConditions(void);
static BOOL constantVChargConditions(void);
static int stopChargConditions(void);
static int floatChargConditions(void);
static int mpptChargConditions(void);
static int constantVChargConditions(void);
static void mpptCharge(void);
static void constantVoltageCharge(void);
static void floatCharge(void);
@ -79,26 +79,26 @@ BOOL constantVChargConditions(void)
/**
* @brief 判断充电控制的模式
* @param
* @retval
* @retval 返回充电控制器的模式
*
*/
void chargControlMode(void)
int chargControlMode(void)
{
if (stopChargConditions()) {
stopChargWork();
setMPPT_Mode(noWork);
return noWork;
}
if (floatChargConditions()) {
setMPPT_Mode(floatCharg);
return floatCharg;
}
if (mpptChargConditions()) {
setMPPT_Mode(MPPT);
return MPPT;
}
if (constantVChargConditions()) {
setMPPT_Mode(constantVoltage);
return constantVoltage;
}
}
@ -177,22 +177,21 @@ void constantVoltageCharge(void)
*/
void BatteryChargControl(void)
{
switch(getMPPT_Mode()) {
switch(g_otherParameter.MPPT_Mode) {
case MPPT:
case CONSTANTCURRENT:
mpptCharge();
break;
case constantVoltage:
case CONSTANTVOLTAGE:
constantVoltageCharge();
break;
case floatCharg:
case FLOAT:
floatCharge();
break;
default:
setMPPT_Mode(noWork);
stopChargWork();
break;
}

3
APP/businessLogic/Src/bl_comm.c
View File

@ -5,6 +5,9 @@
void GW485_comm(void)
{

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

@ -1,607 +0,0 @@
#include "inFlash.h"
#include "parameter.h"
#include "pDebug.h"
// static uint8_t config_buff[200];
// static uint8_t config_buff_pos = 0;
/**
* @brief 校验算法, modebus
* @param
* @retval
*/
static uint16_t configCheckFunc(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 save_config_info 需要保存的配置信息
* @retval None
*/
void save_config_info(config_info *save_config_info)
{
write_Flash((uint8_t *)save_config_info, CONFIG_SAVE_ADDR_BEGIN, CONFIG_INFO_SIZE);
}
/**
* @brief 保存配置信息到备份区
* @param save_config_info 需要保存的配置信息
* @retval None
*/
static void save_backups_config_info(config_info *save_config_info)
{
write_Flash((uint8_t *)save_config_info, CONFIG_SAVE_addr, CONFIG_INFO_SIZE);
}
/**
* @brief 读取配置信息
* @param read_config_info 读取配置信息并保存在output_config_info中
* @retval None
*/
void read_config_info(config_info *output_config_info)
{
read_Flash((uint8_t *)output_config_info, CONFIG_SAVE_ADDR_BEGIN, CONFIG_INFO_SIZE);
}
/**
* @brief 读取备份的配置信息
* @param read_config_info 读取配置信息并保存在output_config_info中
* @retval None
*/
static void read_backups_config_info(config_info *output_config_info)
{
read_Flash((uint8_t *)output_config_info, CONFIG_SAVE_addr, CONFIG_INFO_SIZE);
}
/**
* @brief 检测flash中是否有配置文件或者文件是否有损坏,若两处flash中都损坏则使用默认文件
* @param config_info 读取的配置信息
* @retval None
*
*/
static void readFlashContent(config_info *config_info)
{
read_config_info(config_info);
/* 配置文件正确就返回 */
if (config_info->crc == configCheckFunc((uint8_t *)config_info, CONFIG_INFO_SIZE - 2)) {
return;
}
/* 更深处的配置文件正确就返回 */
read_backups_config_info(config_info);
if (config_info->crc == configCheckFunc((uint8_t *)config_info, CONFIG_INFO_SIZE - 2)) {
save_config_info(config_info);
return;
}
/* 配置文件错误使用默认配置 */
config_info->address[0] = 0x11;
config_info->address[1] = 0x11;
config_info->address[2] = 0x11;
config_info->address[3] = 0x11;
config_info->address[4] = 0x11;
config_info->address[5] = 0x11;
config_info->address[6] = 0x11;
config_info->Access_Node_Type = 0x01;
config_info->Communication_Methods = 0x02;
config_info->gw485_Baud = 9600;
config_info->bat485_Baud = 115200;
config_info->hardwareID[0] = 0x48;
config_info->hardwareID[1] = 0x59;
config_info->hardwareID[2] = 0x30;
config_info->hardwareID[3] = 0x30;
config_info->hardwareID[4] = 0x30;
config_info->hardwareID[5] = 0x31;
config_info->communicationID[0] = 0x00;
config_info->communicationID[1] = 0x00;
config_info->communicationID[2] = 0x00;
config_info->communicationID[3] = 0x01;
config_info->protocolType = 0x01;
// config_info->CommunicationProtocolType = 0x00;
config_info->onlyPower = 0x01;
config_info->constantVoltageV = 14;
config_info->floatI = 0.02;
config_info->startSolarOpenCircuitV = 17;
config_info->stopSolarOpenCircuitV = 15;
config_info->constantVoltageChargeV = 14.4;
config_info->FloatChargeV = 14;
config_info->HighSideMosTemperature_stop = 100;
config_info->HighSideMosTemperature_end = 90;
config_info->HighSideMosTemperature_start = 50;
config_info->checkSolarOpenCircuitVTime = 10;
config_info->sensorEnableBroadcastTime = 20;
config_info->outputAgainFlagTime = 10;
config_info->excessiveLoadFlagTime = 60;
config_info->eLAgainTime = 1800;
}
/**
* @brief 通过配置文件初始化系统参数
* @param None
* @retval None
*
*/
void config_info_start(void)
{
Flash_Init();
config_info temp_configInfo;
readFlashContent(&temp_configInfo);
g_cfgParameter.constantVoltageV = temp_configInfo.constantVoltageV;
g_cfgParameter.floatI = temp_configInfo.floatI;
g_cfgParameter.startSolarOpenCircuitV = temp_configInfo.startSolarOpenCircuitV;
g_cfgParameter.stopSolarOpenCircuitV = temp_configInfo.stopSolarOpenCircuitV;
g_cfgParameter.constantVoltageChargeV = temp_configInfo.constantVoltageChargeV;
g_cfgParameter.FloatV = temp_configInfo.FloatChargeV;
g_cfgParameter.HighSideMosTemperature_stop = temp_configInfo.HighSideMosTemperature_stop;
g_cfgParameter.HighSideMosTemperature_end = temp_configInfo.HighSideMosTemperature_end;
g_cfgParameter.HighSideMosTemperature_start = temp_configInfo.HighSideMosTemperature_start;
g_cfgParameter.sensorEnableBroadcastTime = temp_configInfo.sensorEnableBroadcastTime;
g_cfgParameter.checkSolarOpenCircuitVTime = temp_configInfo.checkSolarOpenCircuitVTime;
g_cfgParameter.outputAgainFlagTime = temp_configInfo.outputAgainFlagTime;
g_cfgParameter.excessiveLoadFlagTime = temp_configInfo.excessiveLoadFlagTime;
g_cfgParameter.eLAgainTime = temp_configInfo.eLAgainTime;
g_cfgParameter.collectOpenCircuitVoltageTime= 3600;
g_cfgParameter.address[0] = temp_configInfo.address[0];
g_cfgParameter.address[1] = temp_configInfo.address[1];
g_cfgParameter.address[2] = temp_configInfo.address[2];
g_cfgParameter.address[3] = temp_configInfo.address[3];
g_cfgParameter.address[4] = temp_configInfo.address[4];
g_cfgParameter.address[5] = temp_configInfo.address[5];
g_cfgParameter.address[6] = temp_configInfo.address[6];
g_cfgParameter.Access_Node_Type = temp_configInfo.Access_Node_Type;
g_cfgParameter.Communication_Methods = temp_configInfo.Communication_Methods;
g_cfgParameter.hardwareID[0] = temp_configInfo.hardwareID[0];
g_cfgParameter.hardwareID[1] = temp_configInfo.hardwareID[1];
g_cfgParameter.hardwareID[2] = temp_configInfo.hardwareID[2];
g_cfgParameter.hardwareID[3] = temp_configInfo.hardwareID[3];
g_cfgParameter.hardwareID[4] = temp_configInfo.hardwareID[4];
g_cfgParameter.hardwareID[5] = temp_configInfo.hardwareID[5];
g_cfgParameter.communicationID[0] = temp_configInfo.communicationID[0];
g_cfgParameter.communicationID[1] = temp_configInfo.communicationID[1];
g_cfgParameter.communicationID[2] = temp_configInfo.communicationID[2];
g_cfgParameter.communicationID[3] = temp_configInfo.communicationID[3];
g_cfgParameter.protocolType = temp_configInfo.protocolType;
// g_cfgParameter.CommunicationProtocolType = temp_configInfo.CommunicationProtocolType;
g_cfgParameter.onlyPower = temp_configInfo.onlyPower;
g_cfgParameter.startFlagSL[0] = 'S';
g_cfgParameter.startFlagSL[1] = 'L';
g_cfgParameter.endFlagSL = 0x16;
g_cfgParameter.startFlagHY = 0x68;
g_cfgParameter.endFlagHY = 0x16;
// if (g_cfgParameter.CommunicationProtocolType == 0x00) {
// g_cfgParameter.gw485_Baud = temp_configInfo.gw485_Baud;
// g_cfgParameter.bat485_Baud = temp_configInfo.bat485_Baud;
// } else if (g_cfgParameter.CommunicationProtocolType == 0x01) {
// g_cfgParameter.bat485_Baud = temp_configInfo.bat485_Baud;
// if (g_cfgParameter.protocolType == 0x01) {
// g_cfgParameter.gw485_Baud = 9600;
// } else if (g_cfgParameter.protocolType == 0x02) {
// g_cfgParameter.gw485_Baud = 115200;
// }
// }
g_cfgParameter.gw485_Baud = 9600;
g_cfgParameter.gw485_Baud = 115200;
float fTemp;
readLoopImpedance(&fTemp);
/* 读取的回路阻抗偏差过大则不使用 */
if (fTemp > (float)0.005 && fTemp < (float)1) {
g_cfgParameter.loopImpedance = fTemp;
}
else {
g_cfgParameter.loopImpedance = 0;
saveLoopImpedance(&g_cfgParameter.loopImpedance);
}
readtotalElectricityConsumption(&fTemp);
totalElectricityConsumptionInt(fTemp);
readtotalChargCapacity(&fTemp);
totalChargCapacityInt(fTemp);
}
/**
* @brief 判断接收到的配置文件数据是否正确，正确的话存入flash中
* @param None
* @retval None
*
*/
// #define enlargeScale 100
// BOOL read_and_process_config_data(uint8_t *config_buff[])
// {
// recv_config_info *pack = (recv_config_info *)*config_buff;
// config_info save_configInfo;
// while (config_buff_pos >= RECV_CONFIG_INFO) {
// /* 判断起始标志是否正确 */
// 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];
// // debug(" Access_Node_Type : 0x%x \n", save_configInfo.Access_Node_Type);
// if (save_configInfo.Access_Node_Type != POWERBOX) {
// goto err;
// }
// /* 判断通信方式是否正确 */
// save_configInfo.Communication_Methods = (uint16_t)pack->Communication_Methods[0] << 8
// | (uint16_t)pack->Communication_Methods[1];
// // debug(" Communication_Methods : 0x%x \n", save_configInfo.Communication_Methods);
// // if (temp_u16 != RS485 || temp_u16 != RJ45) {
// if (save_configInfo.Communication_Methods != RS485) {
// 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) {
// // if (save_configInfo.gw485_Baud != 0x2580 || save_configInfo.gw485_Baud != 115200) {
// // debug(" error : %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];
// // debug(" bat485_Baud : 0x%x, %d \n", save_configInfo.bat485_Baud, save_configInfo.bat485_Baud);
// if (save_configInfo.bat485_Baud != 9600 && save_configInfo.bat485_Baud!= 115200 && save_configInfo.bat485_Baud!= 0) {
// goto err;
// }
// /* 判断协议类型是否正确 */
// if (pack->protocolType != 0x01 && pack->protocolType != 0x02) {
// goto err;
// }
// // debug(" protocolType : 0x%x \n", pack->protocolType);
/* 判断通信协议类型是否正确 */
/*
if (pack->CommunicationProtocolType != 0x00 && pack->CommunicationProtocolType != 0x01) {
goto err;
}
// debug(" CommunicationProtocolType : 0x%x \n", pack->CommunicationProtocolType);
*/
// /* 判断电源盒类型是否正确 */
// if (pack->onlyPower != 0x00 && pack->onlyPower != 0x01) {
// goto err;
// }
// // debug(" onlyPower : 0x%x \n", pack->onlyPower);
// /* 判断恒压充电阈值是否正确 */
// save_configInfo.constantVoltageV =
// (float)(pack->ConstantVoltageV[0] << 8 | pack->ConstantVoltageV[1]) / enlargeScale;
// // debug(" constantVoltageV : %f \n", save_configInfo.constantVoltageV);
// if (save_configInfo.constantVoltageV > (float)14.4 || save_configInfo.constantVoltageV < (float)13.5) {
// goto err;
// }
// /* 判断浮充充电阈值是否正确 */
// save_configInfo.floatI = (float)(pack->FloatI[0] << 8 | pack->FloatI[1]) / enlargeScale;
// // debug(" floatI : %f \n", save_configInfo.floatI);
// if (save_configInfo.floatI > (float)0.2 || save_configInfo.floatI < (float)0) {
// goto err;
// }
// /* 判断太阳能板开路启动电压是否正确 */
// save_configInfo.startSolarOpenCircuitV =
// (float)(pack->startSolarOpenCircuitV[0] << 8 | pack->startSolarOpenCircuitV[1]) / enlargeScale;
// // debug(" startSolarOpenCircuitV : %f \n", save_configInfo.startSolarOpenCircuitV);
// if (save_configInfo.startSolarOpenCircuitV > 24 || save_configInfo.startSolarOpenCircuitV < 14) {
// goto err;
// }
// /* 判断太阳能板关闭电压是否正确 */
// save_configInfo.stopSolarOpenCircuitV =
// (float)(pack->stopSolarOpenCircuitV[0] << 8 | pack->stopSolarOpenCircuitV[1]) / enlargeScale;
// // debug(" stopSolarOpenCircuitV : %f \n", save_configInfo.stopSolarOpenCircuitV);
// if (save_configInfo.stopSolarOpenCircuitV > 17 || save_configInfo.stopSolarOpenCircuitV < 13) {
// goto err;
// }
// /* 判断恒压充电时的输出电压是否正确 */
// save_configInfo.constantVoltageChargeV =
// (float)(pack->constantVoltageChargeV[0] << 8 | pack->constantVoltageChargeV[1]) / enlargeScale;
// // debug(" constantVoltageChargeV : %f \n", save_configInfo.constantVoltageChargeV);
// if (save_configInfo.constantVoltageChargeV > (float)14.6 || save_configInfo.constantVoltageChargeV < (float)14) {
// goto err;
// }
// /* 判断浮充充电时的输出电压是否正确 */
// save_configInfo.FloatChargeV =
// (float)(pack->FloatChargeV[0] << 8 | pack->FloatChargeV[1]) / enlargeScale;
// // debug(" FloatChargeV : %f \n", save_configInfo.FloatChargeV);
// if (save_configInfo.FloatChargeV > (float)14.4 || save_configInfo.FloatChargeV < (float)13.8) {
// goto err;
// }
// /* 判断mos管停止工作温度是否正确 */
// save_configInfo.HighSideMosTemperature_stop =
// (float)(pack->HighSideMosTemperature_stop[0] << 8 | pack->HighSideMosTemperature_stop[1]) / enlargeScale;
// // debug(" HighSideMosTemperature_stop : %f \n", save_configInfo.HighSideMosTemperature_stop);
// if (save_configInfo.HighSideMosTemperature_stop < 60) {
// goto err;
// }
// /* 判断mos管降低工作功率工作温度是否正确 */
// save_configInfo.HighSideMosTemperature_end =
// (float)(pack->HighSideMosTemperature_end[0] << 8 | pack->HighSideMosTemperature_end[1]) / enlargeScale;
// // debug(" HighSideMosTemperature_end : %f \n", save_configInfo.HighSideMosTemperature_end));
// if (save_configInfo.HighSideMosTemperature_end < 50) {
// goto err;
// }
// /* 判断mos管完全恢复工作温度是否正确 */
// save_configInfo.HighSideMosTemperature_start =
// (float)(pack->HighSideMosTemperature_start[0] << 8 | pack->HighSideMosTemperature_start[1]) / enlargeScale;
// // debug(" HighSideMosTemperature_start : %d \n", save_configInfo.HighSideMosTemperature_start);
// if (save_configInfo.HighSideMosTemperature_start < 40) {
// goto err;
// }
// /* 判断启动任务中太阳能板开路电压检测间隔时间是否正确 */
// save_configInfo.checkSolarOpenCircuitVTime =
// pack->checkSolarOpenCircuitVTime[0] << 8 | pack->checkSolarOpenCircuitVTime[1];
// // debug(" checkSolarOpenCircuitVTime : %d \n", save_configInfo.checkSolarOpenCircuitVTime);
// if (save_configInfo.checkSolarOpenCircuitVTime > 1800 || save_configInfo.checkSolarOpenCircuitVTime < 5) {
// goto err;
// }
// /* 判断传感器运行再次注册的间隔是否正确 */
// save_configInfo.sensorEnableBroadcastTime =
// pack->sensorEnableBroadcastTime[0] << 8 | pack->sensorEnableBroadcastTime[1];
// // debug(" sensorEnableBroadcastTime : %d \n", save_configInfo.sensorEnableBroadcastTime);
// if (save_configInfo.sensorEnableBroadcastTime > 60 || save_configInfo.sensorEnableBroadcastTime < 10) {
// goto err;
// }
// /* 判断出现短路保护后延长该段时间再次检测是否短路，仍然短路则关闭输出的间隔是否正确 */
// save_configInfo.outputAgainFlagTime =
// pack->outputAgainFlagTime[0] << 8 | pack->outputAgainFlagTime[1];
// // debug(" outputAgainFlagTime : %d \n", save_configInfo.outputAgainFlagTime);
// if (save_configInfo.sensorEnableBroadcastTime > 30 || save_configInfo.sensorEnableBroadcastTime < 5) {
// goto err;
// }
// /* 判断出现过载后，在该间隔时间中多次（2次）出现过载，则关闭输出的间隔是否正确 */
// save_configInfo.excessiveLoadFlagTime =
// pack->excessiveLoadFlagTime[0] << 8 | pack->excessiveLoadFlagTime[1];
// // debug(" excessiveLoadFlagTime : %d \n", save_configInfo.excessiveLoadFlagTime);
// if (save_configInfo.excessiveLoadFlagTime > 90 || save_configInfo.excessiveLoadFlagTime < 30) {
// goto err;
// }
// /* 判断出现过载过载保护后，在该间隔段时间后，再次尝试输出的间隔是否正确 */
// save_configInfo.eLAgainTime = pack->eLAgainTime[0] << 8 | pack->eLAgainTime[1];
// // debug(" eLAgainTime : %d \n", save_configInfo.eLAgainTime);
// if (save_configInfo.eLAgainTime > 3000 || save_configInfo.eLAgainTime < 1000) {
// goto err;
// }
// /* crc校验 */
// save_configInfo.crc = pack->crc[0] << 8 | pack->crc[1];
// // debug(" crc : %x%x \n", pack->crc[0], pack->crc[1]);
// if (save_configInfo.crc != configCheckFunc(config_buff, RECV_CONFIG_INFO - 3)) {
// // debug(" configCheckFunc : %x \n", configCheckFunc(config_buff, RECV_CONFIG_INFO));
// goto err;
// }
// /* 结束标志 */
// // debug(" end_Flag : %x \n", pack->end_Flag);
// if (pack->end_Flag != 0x16) {
// 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 = configCheckFunc((uint8_t *)&save_configInfo, CONFIG_INFO_SIZE - 2);
// save_backups_config_info(&save_configInfo);
// save_config_info(&save_configInfo);
// memset(config_buff, 0, sizeof(config_buff));
// // /* 返回更改配置文件成功 */
// // 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());
// // }
// /* 复位 */
// NVIC_SystemReset();
// return;
// err:
// config_buff_pos--;
// memcpy(config_buff, config_buff + 1, sizeof(config_buff) - 1);
// }
// }
/**
* @brief 保存回路阻抗在flash中
* @param
*/
void saveLoopImpedance(float *loopImpedance)
{
write_Flash((uint8_t *)loopImpedance, LoopImpedance_SAVE_addr, sizeof(float));
}
/**
* @brief 读取flash中的回路阻抗
* @param
*/
void readLoopImpedance(float *loopImpedance)
{
read_Flash((uint8_t *)loopImpedance, LoopImpedance_SAVE_addr, sizeof(float));
}
/**
* @brief 保存放电量在flash中
* @param
*/
void savetotalElectricityConsumption(float *totalElectricityConsumption)
{
write_Flash((uint8_t *)totalElectricityConsumption, totalElectricityConsumption_SAVE_addr, sizeof(float));
}
/**
* @brief 读取flash中的放电量
* @param
*/
void readtotalElectricityConsumption(float *totalElectricityConsumption)
{
read_Flash((uint8_t *)totalElectricityConsumption, totalElectricityConsumption_SAVE_addr, sizeof(float));
}
/**
* @brief 保存充电量在flash中
* @param
*/
void savetotalChargCapacity(float *totalChargCapacity)
{
write_Flash((uint8_t *)totalChargCapacity, totalChargCapacity_SAVE_addr, sizeof(float));
}
/**
* @brief 读取flash中的充电量
* @param
*/
void readtotalChargCapacity(float *totalChargCapacity)
{
read_Flash((uint8_t *)totalChargCapacity, totalChargCapacity_SAVE_addr, sizeof(float));
}

403
APP/businessLogic/Src/parameter.c
View File

@ -1,408 +1,7 @@
#include "parameter.h"
#include "FM_TIM.h"
#include "FM_GPIO.h"
#include "capture.h"
config_parameter g_cfgParameter = {0};
static otherParameter g_otherParameter = {0};
static BOOL batteryState = FALSE; /* 有无电池（估计） */
static float dutyRatio; /* 占空比 */
otherParameter g_otherParameter = {0};
/**
* @brief 获取电池状态
* @param
* @retval batteryState电池状态 FALSE：无
* TRUE： 有
*/
BOOL getBatteryState(void)
{
return batteryState;
}
/**
* @brief 设置电池状态
* @param state 电池状态
* @retval
*
*/
void setBatteryState(BOOL state)
{
if (state != TRUE && state != FALSE) {
return;
}
batteryState = state;
}
/**
* @brief 获取占空比大小
* @param
* @retval dutyRatio 占空比
*/
float getDutyRatio(void)
{
return dutyRatio;
}
/**
* @brief 设置占空比大小,在一个范围内，不能设置为0，1等
* @param dutyRatio 占空比
* @retval
*/
void setDutyRatio(float DutyRatio)
{
if (DutyRatio > 0.9f) {
dutyRatio = 0.9f;
}
else if (DutyRatio < 0.05f) {
dutyRatio = 0.05f;
}
else {
dutyRatio = DutyRatio;
}
set_pwmDutyRatio(dutyRatio);
}
/**
* @brief 设置占空比大小为0，同时关闭pwm下桥的输出
* @param
* @retval
*/
void setDutyRatioToZero(void)
{
EN_PWMOUT_Diseable();
dutyRatio = 0;
set_pwmDutyRatio(dutyRatio);
}
/**
* @brief 得到电池电压
* @param
* @retval 电池电压
*/
float getBatteryVoltage(void)
{
return g_otherParameter.Battery_Voltage;
}
/**
* @brief 设置电池电压
* @param
* @retval
*/
void setBatteryVoltage(void)
{
g_otherParameter.Battery_Voltage = g_otherParameter.Output_Voltage
+ getChargBatteryCurrent() * g_cfgParameter.loopImpedance;
}
/**
* @brief 得到输出电压
* @param
* @retval 输出电压
*/
float getOutputVoltage(void)
{
return g_otherParameter.Output_Voltage;
}
/**
* @brief 设置输出电压
* @param
* @retval
*/
void setOutputVoltage(void)
{
g_otherParameter.Output_Voltage = get_PV_VOLT_OUT() ;
}
/**
* @brief 得到充电电流
* @param
* @retval 充电电流
*/
float getChargCurrent(void)
{
return g_otherParameter.Charg_Current;
}
/**
* @brief 设置充电电流
* @param
* @retval
*/
void setChargCurrent(void)
{
g_otherParameter.Charg_Current = get_CHG_CURR();
}
/**
* @brief 得到放电电流
* @param
* @retval 放电电流
*/
float getDischargCurrent(void)
{
return g_otherParameter.Discharg_Current;
}
/**
* @brief 设置放电电流
* @param
* @retval
*/
void setDischargCurrent(void)
{
g_otherParameter.Discharg_Current = get_DSG_CURR();
}
/**
* @brief 得到系统输入电压
* @param
* @retval 系统输入电压
*/
float getInputVoltage(void)
{
return g_otherParameter.Input_Voltage;
}
/**
* @brief 设置系统输入电压
* @param
* @retval
*/
void setInputVoltage(void)
{
g_otherParameter.Discharg_Current = get_PV_VOLT_IN1();
}
/**
* @brief 返回太阳能开路电压（不具备实时性）
* @param
* @retval 太阳能开路电压
*/
float getSolarOpenCircuitVoltage(void)
{
return g_otherParameter.Solar_Open_Circuit_Voltage;
}
/**
* @brief 设置太阳能开路电压（特定情况下才能测量）
* @param
* @retval
*/
void setSolarOpenCircuitVoltage(void)
{
g_otherParameter.Solar_Open_Circuit_Voltage = get_PV1_VOLT_IN();
}
/**
* @brief 返回mos管的温度
* @param
* @retval mos管的温度
*/
float getHighSideMosTemperature(void)
{
return g_otherParameter.HighSideMos_Temperature;
}
/**
* @brief 设置mos管温度
* @param
* @retval
*/
void setHighSideMosTemperature(void)
{
g_otherParameter.HighSideMos_Temperature = get_MOSFET_Temper();
}
/**
* @brief 返回太阳能板输出电压
* @param
* @retval 太阳能板输出电压
*/
float getSolarInCircuitVoltage(void)
{
return g_otherParameter.Solar_In_Circuit_Voltage;
}
/**
* @brief 设置太阳能板输出电压
* @param
* @retval
*/
void setSolarInCircuitVoltage(void)
{
g_otherParameter.Solar_In_Circuit_Voltage = get_PV1_VOLT_IN();
}
/**
* @brief 得到总用电量
* @param
* @retval 总用电量
*/
float getTotalElectricityConsumption(void)
{
return g_otherParameter.totalElectricityConsumption;
}
/**
* @brief 设置总用电量
* @param
* @retval
*/
void setTotalElectricityConsumption(void)
{
g_otherParameter.totalElectricityConsumption += g_otherParameter.Discharg_Current * g_otherParameter.Output_Voltage;
}
/**
* @brief 初始化总用电量
* @param totalPower 初始值
* @retval
*/
void totalElectricityConsumptionInt(float totalPower)
{
g_otherParameter.totalElectricityConsumption = totalPower;
}
/**
* @brief 得到总充电量
* @param
* @retval 总用电量
*/
float getTotalChargCapacity(void)
{
return g_otherParameter.totalChargCapacity;
}
/**
* @brief 设置总充电量
* @param
* @retval
*/
void setTotalChargCapacity(void)
{
g_otherParameter.totalChargCapacity += g_otherParameter.Charg_Current * g_otherParameter.Output_Voltage;
}
/**
* @brief 初始化总充电量
* @param totalPower 初始值
* @retval
*/
void totalChargCapacityInt(float totalPower)
{
g_otherParameter.totalChargCapacity = totalPower;
}
/**
* @brief 得到电池电量
* @param
* @retval 电池电量
*/
float getSOC(void)
{
return g_otherParameter.SOC;
}
/**
* @brief 设置电池电量
* @param
* @retval
*/
void setSOC(void)
{
}
/**
* @brief 得到工作模式
* @param
* @retval 工作模式
*/
int getMPPT_Mode(void)
{
return g_otherParameter.MPPT_Mode;
}
/**
* @brief 设置工作模式
* @param
* @retval
*/
void setMPPT_Mode(int MPPT_Mode)
{
g_otherParameter.MPPT_Mode = MPPT_Mode;
}
/**
* @brief 得到流向电池的电流
* @param
* @retval 流向电池的电流
*/
float getChargBatteryCurrent(void)
{
return (g_otherParameter.Charg_Current - g_otherParameter.Discharg_Current);
}
/**
* @brief 得到充电开关状态
* @param
* @retval 充电开关状态
*/
BOOL getChargMosState(void)
{
if (getDutyRatio() > 0 && getDutyRatio() < 1) {
return TRUE;
} else {
return FALSE;
}
}
/**
* @brief 设置充电开关状态
* @param state 开关状态，FALSE 关闭
* @retval
*/
void setChargMosState(BOOL state)
{
if (state == FALSE) {
/* 关闭充电 */
} else if (state == TRUE) {
/* 打开充电 */
}
}
/**
* @brief 得到放电状态
* @param
* @retval state 状态，FALSE 关闭
*/
BOOL getDischargMosState(void)
{
if (g_cfgParameter.onlyPower) {
return readOnlyPowerOutputState();
} else {
return readOutputState();
}
}
/**
* @brief 得到软件版本号
* @param
* @retval softVer 软件版本号
*/
uint8_t *getVersionInformation(void)
{
return softVer;
}

29
APP/functionalModule/Inc/FM_GPIO.h
View File

@ -1,29 +0,0 @@
#ifndef FM_GPIO_H_
#define FM_GPIO_H_
#include "HD_GPIO.h"
void FM_GPIO_Init(void);
void POW_FF_PCON_Open(void);
void POW_FF_PCON_Close(void);
void POW_OUT_PCON_Open(void);
void POW_OUT_PCON_Close(void);
void RUN_LEN_Open(void);
void RUN_LEN_Close(void);
void FFMOS_CON_Open(void);
void FFMOS_CON_Close(void);
void EN_PWMOUT_Eable(void);
void EN_PWMOUT_Diseable(void);
BOOL readOnlyPowerOutputState(void);
BOOL readOutputState(void);
// extern void WORK_VOLT_Interrupt(void);
// extern void DSG_PROT_Interrupt(void);
#endif

15
APP/functionalModule/Inc/FM_TIM.h
View File

@ -1,15 +0,0 @@
#ifndef FM_PWM_CONTORL_H_
#define FM_PWM_CONTORL_H_
#include "HD_TIM.h"
void tim_Init(void);
void pwm_Stop(void);
void set_pwmDutyRatio(float DutyRatio);
void set_pwmPulse(uint32_t Pulse);
extern void chargControl(void);
extern void checkAbnormal(void);
#endif

33
APP/functionalModule/Inc/capture.h
View File

@ -1,33 +0,0 @@
#ifndef FM_CAPTURE_H_
#define FM_CAPTURE_H_
#include "arm_math.h"
#pragma pack(push,4)
typedef struct _adcCapture
{
float32_t inDataF[6];
int16_t outData;
}adcCapture;
#pragma pack(pop)
extern adcCapture WORK_VOLT_capture;
extern adcCapture DSG_CURR_capture;
extern adcCapture PV_VOLT_IN_capture;
extern adcCapture CHG_CURR_capture;
void ADC_Capture_Init(void);
void proportionalInt(uint8_t mode);
float get_CHG_CURR(void);
float get_PV_VOLT_OUT(void);
float get_DSG_CURR(void);
float get_PV1_VOLT_IN(void);
float get_PV_VOLT_IN1(void);
float get_MOSFET_Temper(void);
void adcCaptureFir();
#endif

13
APP/functionalModule/Inc/flash.h
View File

@ -1,13 +0,0 @@
#ifndef FM_FLASH_H_
#define FM_FLASH_H_
#include "main.h"
#include "w25qxx.h"
void Flash_Init(void);
void read_Flash(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead);
void write_Flash(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);
#endif

157
APP/functionalModule/Src/FM_GPIO.c
View File

@ -1,157 +0,0 @@
#include "FM_GPIO.h"
void FM_GPIO_Init(void)
{
HD_GPIO_Init();
}
/**
* @brief 打开输出防反mos管
* @param None
* @retval None
*/
void POW_FF_PCON_Open(void)
{
HAL_GPIO_WritePin(POW_FF_CON_GPIO_Port, POW_FF_CON_Pin, GPIO_PIN_SET);
}
/**
* @brief 关闭输出防反mos管
* @param None
* @retval None
*/
void POW_FF_PCON_Close(void)
{
HAL_GPIO_WritePin(POW_FF_CON_GPIO_Port, POW_FF_CON_Pin, GPIO_PIN_RESET);
}
/**
* @brief 打开输出mos管
* @param None
* @retval None
*/
void POW_OUT_PCON_Open(void)
{
HAL_GPIO_WritePin(POW_OUT_CON_GPIO_Port, POW_OUT_CON_Pin, GPIO_PIN_SET);
}
/**
* @brief 关闭输出mos管
* @param None
* @retval None
*/
void POW_OUT_PCON_Close(void)
{
HAL_GPIO_WritePin(POW_OUT_CON_GPIO_Port, POW_OUT_CON_Pin, GPIO_PIN_RESET);
}
/**
* @brief 打开LED灯
* @param None
* @retval None
*/
void RUN_LEN_Open(void)
{
HAL_GPIO_WritePin(RUN_LED_GPIO_Port, RUN_LED_Pin, GPIO_PIN_SET);
}
/**
* @brief 关闭LED灯
* @param None
* @retval None
*/
void RUN_LEN_Close(void)
{
HAL_GPIO_WritePin(RUN_LED_GPIO_Port, RUN_LED_Pin, GPIO_PIN_RESET);
}
/**
* @brief 打开mppt电感后的输出mos管
* @param None
* @retval None
*/
void FFMOS_CON_Open(void)
{
HAL_GPIO_WritePin(FFMOS_CON_GPIO_Port, FFMOS_CON_Pin, GPIO_PIN_RESET);
}
/**
* @brief 关闭mppt电感后的输出mos管
* @param None
* @retval None
*/
void FFMOS_CON_Close(void)
{
HAL_GPIO_WritePin(FFMOS_CON_GPIO_Port, FFMOS_CON_Pin, GPIO_PIN_SET);
}
/**
* @brief 下桥的mos管使能pwm输出
* @param None
* @retval None
*/
void EN_PWMOUT_Eable(void)
{
HAL_GPIO_WritePin(EN_PWMOUT_GPIO_Port, EN_PWMOUT_Pin, GPIO_PIN_RESET);
}
/**
* @brief 下桥的mos管关闭pwm输出
* @param None
* @retval None
*/
void EN_PWMOUT_Diseable(void)
{
HAL_GPIO_WritePin(EN_PWMOUT_GPIO_Port, EN_PWMOUT_Pin, GPIO_PIN_SET);
}
/**
* @brief 仅有充电控制器时，判断输出开关是否打开
* @param None
* @retval None
*/
BOOL readOnlyPowerOutputState(void)
{
if (HAL_GPIO_ReadPin(POW_FF_CON_GPIO_Port, POW_FF_CON_Pin)
&& HAL_GPIO_ReadPin(POW_OUT_CON_GPIO_Port, POW_OUT_CON_Pin)
&& HAL_GPIO_ReadPin(DSG_PROT_GPIO_Port, DSG_PROT_Pin)) {
return TRUE;
}
return FALSE;
}
/**
* @brief 带网关时，判断输出开关是否打开
* @param None
* @retval None
*/
BOOL readOutputState(void)
{
if (1) {
return TRUE;
}
return FALSE;
}
/**
* @brief GPIO外部中断的回调函数
* @param GPIO_Pin 引发外部中断的引脚
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if (GPIO_Pin == WORK_VOLT_Pin) {
// WORK_VOLT_Interrupt();
}
else if (GPIO_Pin == DSG_PROT_Pin) {
// DSG_PROT_Interrupt();
}
}

92
APP/functionalModule/Src/FM_TIM.c
View File

@ -1,92 +0,0 @@
#include "FM_TIM.h"
#include "timeSliceOffset.h"
#include "capture.h"
static int PWM_RESOLUTION;
/**
* @brief 定时器初始化
* @param None
* @retval None
*/
void tim_Init(void)
{
HD_PWM_Init();
/* 得到pwm的分辨率 */
PWM_RESOLUTION = HAL_RCC_GetHCLKFreq() / 100000;
HD_controlTim_Init();
HD_taskBaseTim_Init();
HD_checkAbnormalTim_Init();
}
void pwm_Stop(void)
{
set_pwmPulse(0);
// HAL_TIM_OC_MspDeInit(&htim3);
HAL_TIM_PWM_MspDeInit(&htim3);
}
/**
* @brief 设置占空比的大小
* @param Pulse 高电平所占的数
* @retval None
*/
void set_pwmPulse(uint32_t Pulse)
{
if (Pulse > PWM_RESOLUTION) {
return;
}
__HAL_TIM_SetCompare(&htim3, TIM_CHANNEL_4, Pulse);
}
/**
* @brief 设置占空比的大小
* @param DutyRatio 占空比
* @retval None
*/
void set_pwmDutyRatio(float DutyRatio)
{
uint32_t Pulse = (int)(DutyRatio * PWM_RESOLUTION);
set_pwmPulse(Pulse);
}
/**
* @brief Period elapsed callback in non blocking mode
* @note This function is called when TIM1 interrupt took place, inside
* HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment
* a global variable "uwTick" used as application time base.
* @param htim : TIM handle
* @retval None
*/
/**
* @brief 回调函数
* @param htim 产生中断定时器
* @retval None
*/
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* USER CODE BEGIN Callback 0 */
/* USER CODE END Callback 0 */
if (htim->Instance == TIM1) {
HAL_IncTick();
}
/* USER CODE BEGIN Callback 1 */
if (htim->Instance == TIM7) {
chargControl();
}
if (htim->Instance == TIM16) {
TimeSliceOffset_Produce();
}
if (htim->Instance == TIM17) {
checkAbnormal();
}
/* USER CODE END Callback 1 */
}

446
APP/functionalModule/Src/capture.c
View File

@ -1,446 +0,0 @@
#include "capture.h"
#include "HD_ADC.h"
/* 温度的adc值的个数 */
#define mosTemperADCLen 241
///* 3.3V参考电压温度adc值 */
//const uint16_t mosTemperADC[mosTemperADCLen] = {
// 3707, 3697, 3687, 3676, 3665, 3654, 3643, 3632, 3620, 3608, /* -20 - -15.5 ℃ */
// 3596, 3584, 3571, 3559, 3546, 3533, 3519, 3506, 3492, 3478, /* -15 - -10.5 ℃ */
// 3464, 3449, 3434, 3419, 3404, 3389, 3373, 3358, 3341, 3325, /* -10 - -5.5 ℃ */
// 3309, 3292, 3275, 3258, 3241, 3223, 3205, 3187, 3169, 3151, /* -5 - -0.5 ℃ */
// 3132, 3114, 3095, 3075, 3056, 3037, 3017, 2997, 2977, 2957, /* 0 - 4.5 ℃ */
// 2936, 2916, 2895, 2874, 2854, 2832, 2811, 2790, 2768, 2747, /* 9 - 9.5 ℃ */
// 2725, 2703, 2681, 2659, 2637, 2615, 2592, 2570, 2548, 2525, /* 10 - 14.5 ℃ */
// 2503, 2480, 2457, 2435, 2412, 2389, 2366, 2343, 2321, 2298, /* 15 - 19.5 ℃ */
// 2275, 2252, 2229, 2207, 2184, 2161, 2138, 2116, 2093, 2071, /* 20 - 24.5 ℃ */
// 2048, 2026, 2003, 1981, 1959, 1937, 1914, 1893, 1871, 1849, /* 25 - 29.5 ℃ */
// 1827, 1806, 1784, 1763, 1742, 1721, 1700, 1679, 1658, 1638, /* 30 - 34.5 ℃ */
// 1617, 1597, 1577, 1557, 1537, 1518, 1498, 1479, 1460, 1441, /* 35 - 39.5 ℃ */
// 1422, 1403, 1385, 1366, 1348, 1330, 1312, 1295, 1277, 1260, /* 40 - 44.5 ℃ */
// 1243, 1226, 1209, 1192, 1176, 1160, 1144, 1128, 1112, 1097, /* 45 - 49.5 ℃ */
// 1081, 1066, 1051, 1036, 1022, 1007, 993, 979, 965, 951, /* 50 - 54.5 ℃ */
// 938, 924, 911, 898, 885, 872, 860, 848, 835, 823, /* 55 - 59.5 ℃ */
// 811, 800, 788, 777, 765, 754, 743, 732, 722, 711, /* 60 - 64.5 ℃ */
// 701, 691, 681, 671, 661, 651, 642, 632, 623, 614, /* 65 - 69.5 ℃ */
// 605, 596, 588, 579, 571, 562, 554, 546, 538, 530, /* 70 - 74.5 ℃ */
// 522, 515, 507, 500, 493, 486, 478, 471, 465, 458, /* 75 - 79.5 ℃ */
// 451, 445, 438, 432, 426, 420, 414, 408, 402, 396, /* 80 - 84.5 ℃ */
// 390, 385, 379, 374, 368, 363, 358, 353, 348, 343, /* 85 - 89.5 ℃ */
// 338, 333, 328, 324, 319, 315, 310, 306, 301, 297, /* 90 - 94.5 ℃ */
// 293, 289, 285, 281, 277, 273, 269, 266, 262, 258, /* 95 - 99.5 ℃ */
// 255 /* 100 ℃ */
//};
/* 3.0V参考电压温度adc值 */
const uint16_t mosTemperADC[mosTemperADCLen] = {
4077, 4066, 4055, 4043, 4031, 4019, 4007, 3994, 3982, 3969, /* -20 - -15.5 ℃ */
3955, 3942, 3928, 3914, 3900, 3885, 3871, 3856, 3841, 3825, /* -15 - -10.5 ℃ */
3809, 3794, 3777, 3761, 3744, 3727, 3710, 3693, 3675, 3657, /* -10 - -5.5 ℃ */
3639, 3621, 3602, 3583, 3564, 3545, 3525, 3506, 3486, 3465, /* -5 - -0.5 ℃ */
3445, 3424, 3404, 3383, 3361, 3340, 3318, 3296, 3274, 3252, /* 0 - 4.5 ℃ */
3230, 3207, 3184, 3162, 3138, 3115, 3092, 3068, 3045, 3021, /* 5 - 9.5 ℃ */
2997, 2973, 2949, 2925, 2900, 2876, 2851, 2827, 2802, 2777, /* 10 - 14.5 ℃ */
2752, 2728, 2703, 2678, 2653, 2628, 2602, 2577, 2552, 2527, /* 15 - 19.5 ℃ */
2502, 2477, 2452, 2427, 2402, 2377, 2352, 2327, 2302, 2277, /* 20 - 24.5 ℃ */
2253, 2228, 2203, 2179, 2154, 2130, 2106, 2082, 2057, 2034, /* 25 - 29.5 ℃ */
2010, 1986, 1962, 1939, 1916, 1893, 1869, 1847, 1824, 1801, /* 30 - 34.5 ℃ */
1779, 1757, 1734, 1713, 1691, 1669, 1648, 1626, 1605, 1584, /* 35 - 39.5 ℃ */
1564, 1543, 1523, 1503, 1483, 1463, 1443, 1424, 1405, 1386, /* 40 - 44.5 ℃ */
1367, 1348, 1330, 1312, 1293, 1276, 1258, 1241, 1223, 1206, /* 45 - 49.5 ℃ */
1189, 1173, 1156, 1140, 1124, 1108, 1092, 1077, 1061, 1046, /* 50 - 54.5 ℃ */
1031, 1017, 1002, 988, 974, 960, 946, 932, 919, 905, /* 55 - 59.5 ℃ */
892, 879, 867, 854, 842, 829, 817, 806, 794, 782, /* 60 - 64.5 ℃ */
771, 760, 749, 738, 727, 716, 706, 696, 685, 675, /* 65 - 69.5 ℃ */
666, 656, 646, 637, 627, 618, 609, 600, 592, 583, /* 70 - 74.5 ℃ */
575, 566, 558, 550, 542, 534, 526, 519, 511, 504, /* 75 - 79.5 ℃ */
496, 489, 482, 475, 468, 461, 455, 448, 442, 435, /* 80 - 84.5 ℃ */
429, 423, 417, 411, 405, 399, 394, 388, 382, 377, /* 85 - 89.5 ℃ */
372, 366, 361, 356, 351, 346, 341, 336, 332, 327, /* 90 - 94.5 ℃ */
322, 318, 313, 309, 305, 300, 296, 292, 288, 284, /* 95 - 99.5 ℃ */
280 /* 100 ℃ */
};
// /* 2.5V参考电压温度adc值 */
// const uint16_t mosTemperADC[mosTemperADCLen] = {
// 4893, 4879, 4866, 4852, 4838, 4823, 4808, 4793, 4778, 4762, /* -20 - -15.5 ℃ */
// 4746, 4730, 4714, 4697, 4680, 4663, 4645, 4627, 4609, 4590, /* -15 - -10.5 ℃ */
// 4571, 4552, 4533, 4513, 4493, 4473, 4452, 4431, 4410, 4389, /* -10 - -5.5 ℃ */
// 4367, 4345, 4323, 4300, 4277, 4254, 4231, 4207, 4183, 4159, /* -5 - -0.5 ℃ */
// 4134, 4109, 4084, 4059, 4034, 4008, 3982, 3956, 3929, 3903, /* 0 - 4.5 ℃ */
// 3876, 3849, 3821, 3794, 3766, 3738, 3710, 3682, 3654, 3625, /* 5 - 9.5 ℃ */
// 3596, 3568, 3539, 3510, 3480, 3451, 3422, 3392, 3362, 3333, /* 10 - 14.5 ℃ */
// 3303, 3273, 3243, 3213, 3183, 3153, 3123, 3093, 3063, 3033, /* 15 - 19.5 ℃ */
// 3003, 2972, 2942, 2912, 2882, 2852, 2822, 2792, 2762, 2733, /* 20 - 24.5 ℃ */
// 2703, 2673, 2644, 2614, 2585, 2556, 2527, 2498, 2469, 2440, /* 25 - 29.5 ℃ */
// 2412, 2383, 2355, 2327, 2299, 2271, 2243, 2216, 2189, 2162, /* 30 - 34.5 ℃ */
// 2135, 2108, 2081, 2055, 2029, 2003, 1977, 1952, 1926, 1901, /* 35 - 39.5 ℃ */
// 1876, 1852, 1827, 1803, 1779, 1755, 1732, 1709, 1686, 1663, /* 40 - 44.5 ℃ */
// 1640, 1618, 1596, 1574, 1552, 1531, 1510, 1489, 1468, 1447, /* 45 - 49.5 ℃ */
// 1427, 1407, 1387, 1368, 1349, 1330, 1311, 1292, 1274, 1256, /* 50 - 54.5 ℃ */
// 1238, 1220, 1203, 1185, 1168, 1151, 1135, 1119, 1102, 1086, /* 55 - 59.5 ℃ */
// 1071, 1055, 1040, 1025, 1010, 995, 981, 967, 953, 939, /* 60 - 64.5 ℃ */
// 925, 912, 898, 885, 872, 860, 847, 835, 822, 810, /* 65 - 69.5 ℃ */
// 799, 787, 775, 764, 753, 742, 731, 721, 710, 700, /* 70 - 74.5 ℃ */
// 690, 679, 670, 660, 650, 641, 631, 622, 613, 604, /* 75 - 79.5 ℃ */
// 596, 587, 578, 570, 562, 554, 546, 538, 530, 523, /* 80 - 84.5 ℃ */
// 515, 508, 500, 493, 486, 479, 472, 466, 459, 452, /* 85 - 89.5 ℃ */
// 446, 440, 433, 427, 421, 415, 409, 404, 398, 392, /* 90 - 94.5 ℃ */
// 387, 381, 376, 371, 366, 361, 355, 350, 346, 341, /* 95 - 99.5 ℃ */
// 336 /* 100 ℃ */
// };
enum {
WORK_VOLT_NUM = 0,
DSG_CURR_NUM = 1,
PV_VOLT_IN_NUM = 2,
CHG_CURR_NUM = 3,
};
int16_t adcBuff[4];
adcCapture WORK_VOLT_capture = {0};
adcCapture DSG_CURR_capture = {0};
adcCapture PV_VOLT_IN_capture = {0};
adcCapture CHG_CURR_capture = {0};
/* 电流电压采集转换的 */
static float P_CHG_CURR = 0;
static float P_PV_VOLT_OUT = 0;
static float P_DSG_CURR = 0;
static float P_PV1_VOLT_IN = 0;
static float P_PV_VOLT_IN1 = 0;
/* 2.5为adc的电压，4095是2^adc的位数 - 1 */
// const float32_t Proportion = 2.5 / 4095;
const float32_t Proportion = 3.0 / 4095.0;
/* matlab生成的5阶滤波器系数 */
const int firLen = 6;
const float firLP[6] = {
0.01861755922, -0.1146286726, 0.5962908864, 0.5962908864, -0.1146286726,
0.01861755922
};
/**
* @brief 初始化adc
* @param
* @retval None
*/
void ADC_Capture_Init(void)
{
HD_adc_Init();
/* 将回调函数与dma的转换完成中断绑定 */
// hdma_adc1.XferCpltCallback = dmaFerCpltCallback;
HAL_Delay(100);
/* adc校准 */
HAL_ADCEx_Calibration_Start(&hadc1, ADC_SINGLE_ENDED);
HAL_ADCEx_Calibration_Start(&hadc2, ADC_SINGLE_ENDED);
HAL_TIM_Base_Start(&htim6);
HAL_ADC_Start_DMA(&hadc1, (uint32_t *)adcBuff, 4);
// /* 光伏充电输出电流比例，放大倍数*电阻 */
// P_CHG_CURR = (1.0 / (50 * (1 / (1 / 0.01 + 1 / 0.002)))) * Proportion;
// /* 充电控制盒输出电压比例，分压系数 */
// P_PV_VOLT_OUT = ((47.0 + 10.0) / 10.0) * Proportion;
// /* 放电电流采集电流倍数 */
// P_DSG_CURR = (1.0 / (50 * (1 / (1 / 0.002 * 2)))) * Proportion;
// /* 光伏板输出电压比例 */
// P_PV1_VOLT_IN = ((47.0 + 4.7) / 4.7) * Proportion;
// /* 系统电源电压比例 */
// P_PV_VOLT_IN1 = ((47 + 4.7) / 4.7) * Proportion;
}
/**
* @brief 初始化电流电压转换的比例（及放大或者缩小倍数）
* @param
* @retval None
*/
void proportionalInt(uint8_t mode)
{
/* 仅充当电源盒 */
if (mode) {
/* 光伏充电输出电流比例，放大倍数*电阻 */
P_CHG_CURR = (1.0 / (50 * (1 / (1 / 0.01 + 1 / 0.002)))) * Proportion;
/* 充电控制盒输出电压比例，分压系数 */
P_PV_VOLT_OUT = ((47.0 + 10.0) / 10.0) * Proportion;
/* 放电电流采集电流倍数 */
P_DSG_CURR = (1.0 / (50 * (1 / (1 / 0.002 * 2)))) * Proportion;
/* 光伏板输出电压比例 */
P_PV1_VOLT_IN = ((47.0 + 4.7) / 4.7) * Proportion;
/* 系统电源电压比例 */
P_PV_VOLT_IN1 = ((47 + 4.7) / 4.7) * Proportion;
}
/* 电源盒外还有网关功能 */
else {
/* 光伏充电输出电流比例，放大倍数*电阻 */
P_CHG_CURR = (1.0 / (50 * 0.005)) * Proportion;
/* 光伏充电输出电压比例，分压系数 */
P_PV_VOLT_OUT = ((47.0 + 4.7) / 4.7) * Proportion;
/* 放电电流采集电流倍数 */
P_DSG_CURR = (1.0 / (50 * 0.005)) * Proportion;
/* 光伏1开路输出电压比例 */
P_PV1_VOLT_IN = ((47.0 + 4.7) / 4.7) * Proportion;
/* 系统电源电压比例 */
P_PV_VOLT_IN1 = ((47 + 4.7) / 4.7) * Proportion;
}
}
#define N 4
/**
* @brief 中位值平均滤波
* @param funtion 获取ADC的函数
* @param ADC_Channel ADC通道
* @retval None
*/
static int16_t middleAverageFilter(int16_t funtion(uint32_t Channel), uint32_t ADC_Channel)
{
int16_t i,j,k;
int16_t temp,sum = 0;
int16_t value_buf[N];
for (i = 0; i < N; ++i) {
value_buf[i] = funtion(ADC_Channel);
}
/*从小到大冒泡排序*/
for(j = 0; j < N-1; ++j) {
for (k = 0; k < N-j-1; ++k) {
if(value_buf[k] > value_buf[k+1]) {
temp = value_buf[k];
value_buf[k] = value_buf[k+1];
value_buf[k+1] = temp;
}
}
}
for(i = 1; i < N-1; ++i) {
sum += value_buf[i];
}
return sum / (N-2);
}
/**
* @brief 获取adc2的采集值
* @param Channel ADC通道
* @retval None
*/
static int16_t ADC2_Capture(uint32_t Channel)
{
return middleAverageFilter(get_adc2Value, Channel);
}
// /**
// * @brief 获取adc1的采集值
// * @param Channel ADC通道
// * @retval None
// */
// static int16_t ADC1_Capture(uint32_t Channel)
// {
// return middleAverageFilter(get_adc1Value, Channel);
// }
/**
* @brief 得到充电电流
* @param
* @retval I 电流值
*/
float get_CHG_CURR(void)
{
float I;
I = CHG_CURR_capture.outData * P_CHG_CURR;
// I = ADC1_Capture(ADC_CHANNEL_11) * P_CHG_CURR;
#ifdef enable_Printf_VI
debug("\n CHG_CURR ADC : %d \n", (int)CHG_CURR_capture.outDataF);
debug(" CHG_CURR I : %f \n", I);
#endif
return I;
}
/**
* @brief 得到光伏输出电压
* @param
* @retval V 电压值
*/
float get_PV_VOLT_OUT(void)
{
float V;
V = WORK_VOLT_capture.outData * P_PV_VOLT_OUT;
// V = ADC1_Capture(ADC_CHANNEL_7) * P_PV_VOLT_OUT;
#ifdef enable_Printf_VI
debug("\n PV_VOLT_OUT ADC : %d \n", (int)WORK_VOLT_capture.outDataF);
debug(" PV_VOLT_OUT V : %f \n", V);
#endif
return V;
}
/**
* @brief 得到放电电流
* @param
* @retval I 电流值
*/
float get_DSG_CURR(void)
{
float I;
I = DSG_CURR_capture.outData * P_DSG_CURR;
// I = ADC1_Capture(ADC_CHANNEL_8) * P_DSG_CURR;
#ifdef enable_Printf_VI
debug("\n DSG_CURR ADC : %d \n", (int)DSG_CURR_capture.outDataF);
debug(" DSG_CURR I : %f \n", I);
#endif
return I;
}
/**
* @brief 得到光伏电压
* @param
* @retval V 电压值
*/
float get_PV1_VOLT_IN(void)
{
float V;
V = PV_VOLT_IN_capture.outData * P_PV1_VOLT_IN;
// V = ADC1_Capture(ADC_CHANNEL_15) * P_PV1_VOLT_IN;
#ifdef enable_Printf_VI
debug("\n PV1_VOLT_IN ADC : %d \n", (int)PV_VOLT_IN_capture.outDataF);
debug(" PV1_VOLT_IN V1 : %f \n", V);
#endif
return V;
}
/**
* @brief 得到系统电压电压
* @param
* @retval V 电压值
*/
float get_PV_VOLT_IN1(void)
{
float V;
uint16_t V_ADC;
V_ADC = ADC2_Capture(SYS_VOLT_IN_CHANNEL);
V = (float)(V_ADC) * P_PV_VOLT_IN1;
#ifdef enable_Printf_VI
debug("\n PV_VOLT_IN1 ADC : %d \n", V_ADC);
debug(" PV_VOLT_IN1 V : %f \n", V);
#endif
return V;
}
//const float Rp = 10000.0; //10K
//const float T2 = (273.15+25.0);//T2
//const float Bx = 3950.0;//B
//const float Bx = 3435.0;//B
//const float Ka = 273.15;
/**
* @brief 得到温度
* @param
* @retval V 电压值
*/
float get_MOSFET_Temper(void)
{
float T = 0;
uint16_t T_ADC;
T_ADC = ADC2_Capture(MOSFET_Temper_CHANNEL);
for (int i = 0; i < mosTemperADCLen; ++i) {
if (T_ADC >= mosTemperADC[i]) {
T = -20 + i * 0.5;
break;
}
}
#ifdef enable_Printf_VI
debug("\n MOSFET_Temper ADC : %d \n", T_ADC);
debug(" MOSFET_Temper T : %f \n", T);
#endif
return T;
}
/**
* @brief adc转换并传输完成后进入该回调函数
* @param hdma dma
* @retval None
*/
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hdma)
{
if (hdma->Instance == ADC1) {
arm_copy_f32(WORK_VOLT_capture.inDataF, WORK_VOLT_capture.inDataF + 1, 5);
arm_copy_f32(DSG_CURR_capture.inDataF, DSG_CURR_capture.inDataF + 1, 5);
arm_copy_f32(PV_VOLT_IN_capture.inDataF, PV_VOLT_IN_capture.inDataF + 1, 5);
arm_copy_f32(CHG_CURR_capture.inDataF, CHG_CURR_capture.inDataF + 1, 5);
WORK_VOLT_capture.inDataF[5] = (float32_t)adcBuff[WORK_VOLT_NUM];
DSG_CURR_capture.inDataF[5] = (float32_t)adcBuff[DSG_CURR_NUM];
PV_VOLT_IN_capture.inDataF[5] = (float32_t)adcBuff[PV_VOLT_IN_NUM];
CHG_CURR_capture.inDataF[5] = (float32_t)adcBuff[CHG_CURR_NUM];
}
}
/**
* @brief 将采集得到的adc进行滤波
* @param None
* @retval None
*/
void adcCaptureFir(void)
{
static arm_fir_instance_f32 armFirInstanceF32;
static float32_t *inputF32, *outputF32;
static uint32_t blockSize = 1;
static float32_t firStateF32[6]; /* 状态缓存 */
static float32_t outputf;
/* 初始化结构体 */
arm_fir_init_f32(&armFirInstanceF32,
firLen,
(float_t *)&firLP[0],
&firStateF32[0],
blockSize);
/* 初始化输入输出缓存指针 */
inputF32 = &WORK_VOLT_capture.inDataF[0];
outputF32 = &outputf;
arm_fir_f32(&armFirInstanceF32, inputF32, outputF32, blockSize);
WORK_VOLT_capture.outData = (int16_t)outputf;
/* 初始化输入输出缓存指针 */
inputF32 = &DSG_CURR_capture.inDataF[0];
outputF32 = &outputf;
arm_fir_f32(&armFirInstanceF32, inputF32, outputF32, blockSize);
DSG_CURR_capture.outData = (int16_t)outputf;
/* 初始化输入输出缓存指针 */
inputF32 = &PV_VOLT_IN_capture.inDataF[0];
outputF32 = &outputf;
arm_fir_f32(&armFirInstanceF32, inputF32, outputF32, blockSize);
PV_VOLT_IN_capture.outData = (int16_t)outputf;
/* 初始化输入输出缓存指针 */
inputF32 = &CHG_CURR_capture.inDataF[0];
outputF32 = &outputf;
arm_fir_f32(&armFirInstanceF32, inputF32, outputF32, blockSize);
CHG_CURR_capture.outData = (int16_t)outputf;
}

43
APP/functionalModule/Src/flash.c
View File

@ -1,43 +0,0 @@
#include "flash.h"
/**
* @brief flash初始化
* @param
*/
void Flash_Init(void)
{
__HAL_RCC_GPIOA_CLK_ENABLE();
HAL_GPIO_WritePin(FLASH_CS_GPIO_Port, FLASH_CS_Pin, GPIO_PIN_RESET);
GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = FLASH_CS_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
W25QXX_Init();
}
/**
* @brief 读取flash中的数据
* @param pBuffer 保存读取的数据
* @param ReadAddr 读取数据的位置
* @param NumByteToRead 读取数据的长度
*/
void read_Flash(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)
{
W25QXX_Read(pBuffer, ReadAddr, NumByteToRead);
}
/**
* @brief 将数据写入到flash中
* @param pBuffer 要写入的数据
* @param ReadAddr 要写入数据的位置
* @param NumByteToRead 要写入数据的长度
*/
void write_Flash(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
{
W25QXX_Write(pBuffer, WriteAddr, NumByteToWrite);
}

20
APP/hardwareDriver/Inc/HD_ADC.h
View File

@ -1,20 +0,0 @@
#ifndef HD_ADC_H_
#define HD_ADC_H_
#include "main.h"
#include "adc.h"
#include "dma.h"
#include "tim.h"
#include "comm_types.h"
#include "stm32g431xx.h"
#define SYS_VOLT_IN_CHANNEL ADC_CHANNEL_1
#define MOSFET_Temper_CHANNEL ADC_CHANNEL_15
void HD_adc_Init(void);
int16_t get_adc1Value(uint32_t Channel);
int16_t get_adc2Value(uint32_t Channel);
#endif

12
APP/hardwareDriver/Inc/HD_GPIO.h
View File

@ -1,12 +0,0 @@
#ifndef HD_GPIO_H_
#define HD_GPIO_H_
#include "main.h"
#include "gpio.h"
#include "stm32g431xx.h"
#include "comm_types.h"
void HD_GPIO_Init(void);
#endif

15
APP/hardwareDriver/Inc/HD_TIM.h
View File

@ -1,15 +0,0 @@
#ifndef HD_TIM_H_
#define HD_TIM_H_
#include "main.h"
#include "tim.h"
#include "stm32g431xx.h"
void HD_PWM_Init(void);
void HD_controlTim_Init(void);
void HD_taskBaseTim_Init(void);
void HD_checkAbnormalTim_Init(void);
#endif

67
APP/hardwareDriver/Inc/w25qxx.h
View File

@ -1,67 +0,0 @@
#ifndef __W25QXX_H
#define __W25QXX_H
#include <main.h>
#define W25QXX_SPI_Handle (&hspi1)
//W25X系列/Q系列芯片列表
//W25Q80 ID 0XEF13
//W25Q16 ID 0XEF14
//W25Q32 ID 0XEF15
//W25Q64 ID 0XEF16
//W25Q128 ID 0XEF17
#define W25Q80 0XEF13
#define W25Q16 0XEF14
#define W25Q32 0XEF15
#define W25Q64 0XEF16
#define W25Q128 0XEF17
#define W25QXX_CS_L() HAL_GPIO_WritePin(FLASH_CS_GPIO_Port, FLASH_CS_Pin, GPIO_PIN_RESET)
#define W25QXX_CS_H() HAL_GPIO_WritePin(FLASH_CS_GPIO_Port, FLASH_CS_Pin, GPIO_PIN_SET)
extern uint16_t W25QXX_TYPE;
extern uint32_t W25QXX_SIZE;
extern uint8_t W25QXX_UID[8];
//
//指令表
#define W25X_WriteEnable 0x06
#define W25X_WriteDisable 0x04
#define W25X_ReadStatusReg 0x05
#define W25X_WriteStatusReg 0x01
#define W25X_ReadData 0x03
#define W25X_FastReadData 0x0B
#define W25X_FastReadDual 0x3B
#define W25X_PageProgram 0x02
#define W25X_BlockErase 0xD8
#define W25X_SectorErase 0x20
#define W25X_ChipErase 0xC7
#define W25X_PowerDown 0xB9
#define W25X_ReleasePowerDown 0xAB
#define W25X_DeviceID 0xAB
#define W25X_ManufactDeviceID 0x90
#define W25X_JedecDeviceID 0x9F
int W25QXX_Init(void);
void W25QXX_ReadUniqueID(uint8_t UID[8]);
uint16_t W25QXX_ReadID(void); //读取FLASH ID
uint8_t W25QXX_ReadSR(void); //读取状态寄存器
void W25QXX_Write_SR(uint8_t sr); //写状态寄存器
void W25QXX_Write_Enable(void); //写使能
void W25QXX_Write_Disable(void); //写保护
void W25QXX_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);
void W25QXX_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead); //读取flash
void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//写入flash
void W25QXX_Erase_Chip(void); //整片擦除
void W25QXX_Erase_Sector(uint32_t Dst_Addr); //扇区擦除
void W25QXX_Wait_Busy(void); //等待空闲
void W25QXX_PowerDown(void); //进入掉电模式
void W25QXX_WAKEUP(void); //唤醒
uint32_t W25QXX_ReadCapacity(void);
#endif

61
APP/hardwareDriver/Src/HD_ADC.c
View File

@ -1,61 +0,0 @@
#include "HD_ADC.h"
#define ADC_SAMPLETIME ADC_SAMPLETIME_2CYCLES_5 //采样时间
void HD_adc_Init(void)
{
MX_DMA_Init();
MX_TIM6_Init();
MX_ADC1_Init();
MX_ADC2_Init();
}
/**
* @brief 获取adc1中某通道的值
* @param Channel 通道
*/
int16_t get_adc1Value(uint32_t Channel)
{
ADC_ChannelConfTypeDef sConfig;
/* 更改读取的adc的通道 */
sConfig.Channel = Channel;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME;
sConfig.SingleDiff = ADC_SINGLE_ENDED;
sConfig.OffsetNumber = ADC_OFFSET_NONE;
sConfig.Offset = 0;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
/* 启动转换 */
HAL_ADC_Start(&hadc1);
/* 等待转化结束 */
HAL_ADC_PollForConversion(&hadc1, 30);
u_int16_t adcValue = HAL_ADC_GetValue(&hadc1);
return adcValue;
}
int16_t get_adc2Value(uint32_t Channel)
{
ADC_ChannelConfTypeDef sConfig;
/* 更改读取的adc的通道 */
sConfig.Channel = Channel;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME;
sConfig.SingleDiff = ADC_SINGLE_ENDED;
sConfig.OffsetNumber = ADC_OFFSET_NONE;
sConfig.Offset = 0;
HAL_ADC_ConfigChannel(&hadc2, &sConfig);
/* 启动转换 */
HAL_ADC_Start(&hadc2);
/* 等待转化结束 */
HAL_ADC_PollForConversion(&hadc2, 30);
u_int16_t adcValue = HAL_ADC_GetValue(&hadc2);
return adcValue;
}

58
APP/hardwareDriver/Src/HD_GPIO.c
View File

@ -1,58 +0,0 @@
#include "HD_GPIO.h"
void HD_GPIO_Init(void)
{
// MX_GPIO_Init();
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOF_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
/*Configure GPIO pin Output Level */
// HAL_GPIO_WritePin(FLASH_CS_GPIO_Port, FLASH_CS_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOB, WDI_INPUT_Pin|RUN_LED_Pin|POW_FF_CON_Pin|POW_OUT_CON_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOA, EN_PWMOUT_Pin|FFMOS_CON_Pin, GPIO_PIN_SET);
/*Configure GPIO pin : DSG_PROT_Pin */
GPIO_InitStruct.Pin = DSG_PROT_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(DSG_PROT_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pins : FLASH_CS_Pin EN_PWMOUT_Pin FFMOS_CON_Pin */
// GPIO_InitStruct.Pin = FLASH_CS_Pin|EN_PWMOUT_Pin|FFMOS_CON_Pin;
// GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
// GPIO_InitStruct.Pull = GPIO_NOPULL;
// GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
// HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Pin = EN_PWMOUT_Pin|FFMOS_CON_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pins : WDI_INPUT_Pin RUN_LED_Pin POW_FF_CON_Pin POW_OUT_CON_Pin */
GPIO_InitStruct.Pin = WDI_INPUT_Pin|RUN_LED_Pin|POW_FF_CON_Pin|POW_OUT_CON_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pin : WORK_VOLT_INT_Pin */
GPIO_InitStruct.Pin = WORK_VOLT_INT_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(WORK_VOLT_INT_GPIO_Port, &GPIO_InitStruct);
/* EXTI interrupt init*/
HAL_NVIC_SetPriority(EXTI15_10_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
}

41
APP/hardwareDriver/Src/HD_TIM.c
View File

@ -1,41 +0,0 @@
#include "HD_TIM.h"
/**
* @brief 控制pwm的定时器初始化
* @param None
* @retval None
*/
void HD_PWM_Init(void)
{
MX_TIM3_Init();
}
/**
* @brief 该定时器中断中完成充电控制器的控制
* @param None
* @retval None
*/
void HD_controlTim_Init(void)
{
MX_TIM7_Init();
}
/**
* @brief 该定时器中断中设置普通任务的时间基准
* @param None
* @retval None
*/
void HD_taskBaseTim_Init(void)
{
MX_TIM16_Init();
}
/**
* @brief 该定时器中断中检测异常情况，并完成数据的采集
* @param None
* @retval None
*/
void HD_checkAbnormalTim_Init(void)
{
MX_TIM17_Init();
}

334
APP/hardwareDriver/Src/w25qxx.c
View File

@ -1,334 +0,0 @@
/**
* @file w25qxx.c
*
* @brief Create by AnKun on 2020/6/18
*
*/
#include "w25qxx.h"
#include "spi.h"
uint16_t W25QXX_TYPE = 0;
uint32_t W25QXX_SIZE = 0;
uint8_t W25QXX_UID[8];
static void delay_us(uint32_t us)
{
uint32_t delay = (HAL_RCC_GetHCLKFreq() / 4000000 * us);
while (delay--)
{
;
}
}
//SPI读写一个字节
//TxData:要写入的字节
//返回值:读取到的字节
static uint8_t W25QXX_SPI_ReadWriteByte(uint8_t TxData)
{
uint8_t RxData = 0X00;
if(HAL_SPI_TransmitReceive(W25QXX_SPI_Handle, &TxData, &RxData, 1, 10) != HAL_OK)
{
RxData = 0XFF;
}
return RxData;
}
//4Kbytes为一个Sector
//16个扇区为1个Block
//W25Q128
//容量为16M字节,共有128个Block,4096个Sector
//初始化SPI FLASH的IO口
int W25QXX_Init(void)
{
MX_SPI1_Init();
W25QXX_CS_L(); /* 拉低选中 */
W25QXX_SPI_ReadWriteByte(0XFF);
W25QXX_CS_H(); /* 拉高取消 */
W25QXX_TYPE = W25QXX_ReadID(); // 读取FLASH ID.
W25QXX_SIZE = W25QXX_ReadCapacity(); // 读取容量
W25QXX_ReadUniqueID(W25QXX_UID); // 读取唯一ID
if((W25QXX_TYPE & 0XEF00) != 0XEF00)
{
return -1;
}
return 0;
}
//读取W25QXX的状态寄存器
//BIT7 6 5 4 3 2 1 0
//SPR RV TB BP2 BP1 BP0 WEL BUSY
//SPR:默认0,状态寄存器保护位,配合WP使用
//TB,BP2,BP1,BP0:FLASH区域写保护设置
//WEL:写使能锁定
//BUSY:忙标记位(1,忙;0,空闲)
//默认:0x00
uint8_t W25QXX_ReadSR(void)
{
uint8_t byte = 0;
W25QXX_CS_L(); //使能器件
W25QXX_SPI_ReadWriteByte(W25X_ReadStatusReg); //发送读取状态寄存器命令
byte = W25QXX_SPI_ReadWriteByte(0Xff); //读取一个字节
W25QXX_CS_H(); //取消片选
return byte;
}
//写W25QXX状态寄存器
//只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
void W25QXX_Write_SR(uint8_t sr)
{
W25QXX_CS_L(); //使能器件
W25QXX_SPI_ReadWriteByte(W25X_WriteStatusReg); //发送写取状态寄存器命令
W25QXX_SPI_ReadWriteByte(sr); //写入一个字节
W25QXX_CS_H(); //取消片选
}
//W25QXX写使能
//将WEL置位
void W25QXX_Write_Enable(void)
{
W25QXX_CS_L(); //使能器件
W25QXX_SPI_ReadWriteByte(W25X_WriteEnable); //发送写使能
W25QXX_CS_H(); //取消片选
}
//W25QXX写禁止
//将WEL清零
void W25QXX_Write_Disable(void)
{
W25QXX_CS_L(); //使能器件
W25QXX_SPI_ReadWriteByte(W25X_WriteDisable); //发送写禁止指令
W25QXX_CS_H(); //取消片选
}
//读取芯片ID
//返回值如下:
//0XEF13,表示芯片型号为W25Q80
//0XEF14,表示芯片型号为W25Q16
//0XEF15,表示芯片型号为W25Q32
//0XEF16,表示芯片型号为W25Q64
//0XEF17,表示芯片型号为W25Q128
uint16_t W25QXX_ReadID(void)
{
uint16_t Temp = 0;
W25QXX_CS_L();
W25QXX_SPI_ReadWriteByte(0x90); //发送读取ID命令
W25QXX_SPI_ReadWriteByte(0x00);
W25QXX_SPI_ReadWriteByte(0x00);
W25QXX_SPI_ReadWriteByte(0x00);
Temp |= W25QXX_SPI_ReadWriteByte(0xFF) << 8;
Temp |= W25QXX_SPI_ReadWriteByte(0xFF);
W25QXX_CS_H();
return Temp;
}
uint32_t W25QXX_ReadCapacity(void)
{
int i = 0;
uint8_t arr[4] = {0,0,0,0};
W25QXX_CS_L();
W25QXX_SPI_ReadWriteByte(0x5A);
W25QXX_SPI_ReadWriteByte(0x00);
W25QXX_SPI_ReadWriteByte(0x00);
W25QXX_SPI_ReadWriteByte(0x84);
W25QXX_SPI_ReadWriteByte(0x00);
for(i = 0; i < sizeof(arr); i++)
{
arr[i] = W25QXX_SPI_ReadWriteByte(0xFF);
}
W25QXX_CS_H();
return ((((*(uint32_t *)arr)) + 1) >> 3);
}
void W25QXX_ReadUniqueID(uint8_t UID[8])
{
int i = 0;
W25QXX_CS_L();
W25QXX_SPI_ReadWriteByte(0x4B);
W25QXX_SPI_ReadWriteByte(0x00);
W25QXX_SPI_ReadWriteByte(0x00);
W25QXX_SPI_ReadWriteByte(0x00);
W25QXX_SPI_ReadWriteByte(0x00);
for(i = 0; i < 8; i++)
{
UID[i] = W25QXX_SPI_ReadWriteByte(0xFF);
}
W25QXX_CS_H();
}
//读取SPI FLASH
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
{
uint16_t i;
W25QXX_CS_L(); //使能器件
W25QXX_SPI_ReadWriteByte(W25X_ReadData); //发送读取命令
W25QXX_SPI_ReadWriteByte((uint8_t)((ReadAddr) >> 16)); //发送24bit地址
W25QXX_SPI_ReadWriteByte((uint8_t)((ReadAddr) >> 8));
W25QXX_SPI_ReadWriteByte((uint8_t)ReadAddr);
for (i = 0; i < NumByteToRead; i++)
{
pBuffer[i] = W25QXX_SPI_ReadWriteByte(0XFF); //循环读数
}
W25QXX_CS_H();
}
//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
void W25QXX_Write_Page(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
uint16_t i;
W25QXX_Write_Enable(); //SET WEL
W25QXX_CS_L(); //使能器件
W25QXX_SPI_ReadWriteByte(W25X_PageProgram); //发送写页命令
W25QXX_SPI_ReadWriteByte((uint8_t)((WriteAddr) >> 16)); //发送24bit地址
W25QXX_SPI_ReadWriteByte((uint8_t)((WriteAddr) >> 8));
W25QXX_SPI_ReadWriteByte((uint8_t)WriteAddr);
for (i = 0; i < NumByteToWrite; i++)
W25QXX_SPI_ReadWriteByte(pBuffer[i]); //循环写数
W25QXX_CS_H(); //取消片选
W25QXX_Wait_Busy(); //等待写入结束
}
//无检验写SPI FLASH
//必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
//具有自动换页功能
//在指定地址开始写入指定长度的数据,但是要确保地址不越界!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
//CHECK OK
void W25QXX_Write_NoCheck(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
uint16_t pageremain;
pageremain = 256 - WriteAddr % 256; //单页剩余的字节数
if (NumByteToWrite <= pageremain)
pageremain = NumByteToWrite; //不大于256个字节
while (1)
{
W25QXX_Write_Page(pBuffer, WriteAddr, pageremain);
if (NumByteToWrite == pageremain)
break; //写入结束了
else //NumByteToWrite>pageremain
{
pBuffer += pageremain;
WriteAddr += pageremain;
NumByteToWrite -= pageremain; //减去已经写入了的字节数
if (NumByteToWrite > 256)
pageremain = 256; //一次可以写入256个字节
else
pageremain = NumByteToWrite; //不够256个字节了
}
};
}
//写SPI FLASH
//在指定地址开始写入指定长度的数据
//该函数带擦除操作!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
uint8_t W25QXX_BUFFER[4096];
void W25QXX_Write(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
uint32_t secpos;
uint16_t secoff;
uint16_t secremain;
uint16_t i;
uint8_t *W25QXX_BUF;
W25QXX_BUF = W25QXX_BUFFER;
secpos = WriteAddr / 4096; //扇区地址
secoff = WriteAddr % 4096; //在扇区内的偏移
secremain = 4096 - secoff; //扇区剩余空间大小
if (NumByteToWrite <= secremain)
secremain = NumByteToWrite; //不大于4096个字节
while (1)
{
W25QXX_Read(W25QXX_BUF, secpos * 4096, 4096); //读出整个扇区的内容
for (i = 0; i < secremain; i++) //校验数据
{
if (W25QXX_BUF[secoff + i] != 0XFF)
break; //需要擦除
}
if (i < secremain) //需要擦除
{
W25QXX_Erase_Sector(secpos); //擦除这个扇区
for (i = 0; i < secremain; i++) //复制
{
W25QXX_BUF[i + secoff] = pBuffer[i];
}
W25QXX_Write_NoCheck(W25QXX_BUF, secpos * 4096, 4096); //写入整个扇区
}
else
W25QXX_Write_NoCheck(pBuffer, WriteAddr, secremain); //写已经擦除了的,直接写入扇区剩余区间.
if (NumByteToWrite == secremain)
break; //写入结束了
else //写入未结束
{
secpos++; //扇区地址增1
secoff = 0; //偏移位置为0
pBuffer += secremain; //指针偏移
WriteAddr += secremain; //写地址偏移
NumByteToWrite -= secremain; //字节数递减
if (NumByteToWrite > 4096)
secremain = 4096; //下一个扇区还是写不完
else
secremain = NumByteToWrite; //下一个扇区可以写完了
}
};
}
//擦除整个芯片
//等待时间超长...
void W25QXX_Erase_Chip(void)
{
W25QXX_Write_Enable(); //SET WEL
W25QXX_Wait_Busy();
W25QXX_CS_L(); //使能器件
W25QXX_SPI_ReadWriteByte(W25X_ChipErase); //发送片擦除命令
W25QXX_CS_H(); //取消片选
W25QXX_Wait_Busy(); //等待芯片擦除结束
}
//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个山区的最少时间:150ms
void W25QXX_Erase_Sector(uint32_t Dst_Addr)
{
//监视falsh擦除情况,测试用
Dst_Addr *= 4096;
W25QXX_Write_Enable(); //SET WEL
W25QXX_Wait_Busy();
W25QXX_CS_L(); //使能器件
W25QXX_SPI_ReadWriteByte(W25X_SectorErase); //发送扇区擦除指令
W25QXX_SPI_ReadWriteByte((uint8_t)((Dst_Addr) >> 16)); //发送24bit地址
W25QXX_SPI_ReadWriteByte((uint8_t)((Dst_Addr) >> 8));
W25QXX_SPI_ReadWriteByte((uint8_t)Dst_Addr);
W25QXX_CS_H(); //取消片选
W25QXX_Wait_Busy(); //等待擦除完成
}
//等待空闲
void W25QXX_Wait_Busy(void)
{
while ((W25QXX_ReadSR() & 0x01) == 0x01); // 等待BUSY位清空
}
//进入掉电模式
void W25QXX_PowerDown(void)
{
W25QXX_CS_L(); //使能器件
W25QXX_SPI_ReadWriteByte(W25X_PowerDown); //发送掉电命令
W25QXX_CS_H(); //取消片选
delay_us(3); //等待TPD
}
//唤醒
void W25QXX_WAKEUP(void)
{
W25QXX_CS_L(); //使能器件
W25QXX_SPI_ReadWriteByte(W25X_ReleasePowerDown); // send W25X_PowerDown command 0xAB
W25QXX_CS_H(); //取消片选
delay_us(3); //等待TRES1
}

2
Core/Inc/stm32g4xx_it.h
View File

@ -57,12 +57,10 @@ void PendSV_Handler(void);
void SysTick_Handler(void);
void DMA1_Channel1_IRQHandler(void);
void TIM1_UP_TIM16_IRQHandler(void);
void TIM1_TRG_COM_TIM17_IRQHandler(void);
void USART2_IRQHandler(void);
void USART3_IRQHandler(void);
void EXTI15_10_IRQHandler(void);
void TIM6_DAC_IRQHandler(void);
void TIM7_IRQHandler(void);
/* USER CODE BEGIN EFP */
/* USER CODE END EFP */

6
Core/Inc/tim.h
View File

@ -38,10 +38,6 @@ extern TIM_HandleTypeDef htim6;
extern TIM_HandleTypeDef htim7;
extern TIM_HandleTypeDef htim16;
extern TIM_HandleTypeDef htim17;
/* USER CODE BEGIN Private defines */
/* USER CODE END Private defines */
@ -49,8 +45,6 @@ extern TIM_HandleTypeDef htim17;
void MX_TIM3_Init(void);
void MX_TIM6_Init(void);
void MX_TIM7_Init(void);
void MX_TIM16_Init(void);
void MX_TIM17_Init(void);
void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);

22
Core/Src/main.c
View File

@ -101,8 +101,6 @@ int main(void)
MX_USART2_UART_Init();
MX_USART3_UART_Init();
MX_TIM7_Init();
MX_TIM16_Init();
MX_TIM17_Init();
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
@ -175,18 +173,18 @@ void SystemClock_Config(void)
* @param htim : TIM handle
* @retval None
*/
// void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
// {
// /* USER CODE BEGIN Callback 0 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
/* USER CODE BEGIN Callback 0 */
// /* USER CODE END Callback 0 */
// if (htim->Instance == TIM1) {
// HAL_IncTick();
// }
// /* USER CODE BEGIN Callback 1 */
/* USER CODE END Callback 0 */
if (htim->Instance == TIM1) {
HAL_IncTick();
}
/* USER CODE BEGIN Callback 1 */
// /* USER CODE END Callback 1 */
// }
/* USER CODE END Callback 1 */
}
/**
* @brief This function is executed in case of error occurrence.

40
Core/Src/stm32g4xx_it.c
View File

@ -57,9 +57,6 @@
/* External variables --------------------------------------------------------*/
extern DMA_HandleTypeDef hdma_adc1;
extern TIM_HandleTypeDef htim6;
extern TIM_HandleTypeDef htim7;
extern TIM_HandleTypeDef htim16;
extern TIM_HandleTypeDef htim17;
extern UART_HandleTypeDef huart2;
extern UART_HandleTypeDef huart3;
extern TIM_HandleTypeDef htim1;
@ -228,33 +225,12 @@ void TIM1_UP_TIM16_IRQHandler(void)
/* USER CODE BEGIN TIM1_UP_TIM16_IRQn 0 */
/* USER CODE END TIM1_UP_TIM16_IRQn 0 */
if (htim1.Instance != NULL)
{
HAL_TIM_IRQHandler(&htim1);
}
if (htim16.Instance != NULL)
{
HAL_TIM_IRQHandler(&htim16);
}
HAL_TIM_IRQHandler(&htim1);
/* USER CODE BEGIN TIM1_UP_TIM16_IRQn 1 */
/* USER CODE END TIM1_UP_TIM16_IRQn 1 */
}
/**
* @brief This function handles TIM1 trigger and commutation interrupts and TIM17 global interrupt.
*/
void TIM1_TRG_COM_TIM17_IRQHandler(void)
{
/* USER CODE BEGIN TIM1_TRG_COM_TIM17_IRQn 0 */
/* USER CODE END TIM1_TRG_COM_TIM17_IRQn 0 */
HAL_TIM_IRQHandler(&htim17);
/* USER CODE BEGIN TIM1_TRG_COM_TIM17_IRQn 1 */
/* USER CODE END TIM1_TRG_COM_TIM17_IRQn 1 */
}
/**
* @brief This function handles USART2 global interrupt / USART2 wake-up interrupt through EXTI line 26.
*/
@ -312,20 +288,6 @@ void TIM6_DAC_IRQHandler(void)
/* USER CODE END TIM6_DAC_IRQn 1 */
}
/**
* @brief This function handles TIM7 global interrupt.
*/
void TIM7_IRQHandler(void)
{
/* USER CODE BEGIN TIM7_IRQn 0 */
/* USER CODE END TIM7_IRQn 0 */
HAL_TIM_IRQHandler(&htim7);
/* USER CODE BEGIN TIM7_IRQn 1 */
/* USER CODE END TIM7_IRQn 1 */
}
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */

123
Core/Src/tim.c
View File

@ -27,8 +27,6 @@
TIM_HandleTypeDef htim3;
TIM_HandleTypeDef htim6;
TIM_HandleTypeDef htim7;
TIM_HandleTypeDef htim16;
TIM_HandleTypeDef htim17;
/* TIM3 init function */
void MX_TIM3_Init(void)
@ -90,7 +88,7 @@ void MX_TIM6_Init(void)
htim6.Instance = TIM6;
htim6.Init.Prescaler = 71;
htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
htim6.Init.Period = 29;
htim6.Init.Period = 499;
htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim6) != HAL_OK)
{
@ -139,60 +137,6 @@ void MX_TIM7_Init(void)
/* USER CODE END TIM7_Init 2 */
}
/* TIM16 init function */
void MX_TIM16_Init(void)
{
/* USER CODE BEGIN TIM16_Init 0 */
/* USER CODE END TIM16_Init 0 */
/* USER CODE BEGIN TIM16_Init 1 */
/* USER CODE END TIM16_Init 1 */
htim16.Instance = TIM16;
htim16.Init.Prescaler = 71;
htim16.Init.CounterMode = TIM_COUNTERMODE_UP;
htim16.Init.Period = 999;
htim16.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim16.Init.RepetitionCounter = 0;
htim16.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim16) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM16_Init 2 */
/* USER CODE END TIM16_Init 2 */
}
/* TIM17 init function */
void MX_TIM17_Init(void)
{
/* USER CODE BEGIN TIM17_Init 0 */
/* USER CODE END TIM17_Init 0 */
/* USER CODE BEGIN TIM17_Init 1 */
/* USER CODE END TIM17_Init 1 */
htim17.Instance = TIM17;
htim17.Init.Prescaler = 71;
htim17.Init.CounterMode = TIM_COUNTERMODE_UP;
htim17.Init.Period = 199;
htim17.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim17.Init.RepetitionCounter = 0;
htim17.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim17) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM17_Init 2 */
/* USER CODE END TIM17_Init 2 */
}
void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef* tim_pwmHandle)
@ -236,44 +180,10 @@ void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
/* USER CODE END TIM7_MspInit 0 */
/* TIM7 clock enable */
__HAL_RCC_TIM7_CLK_ENABLE();
/* TIM7 interrupt Init */
HAL_NVIC_SetPriority(TIM7_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(TIM7_IRQn);
/* USER CODE BEGIN TIM7_MspInit 1 */
/* USER CODE END TIM7_MspInit 1 */
}
else if(tim_baseHandle->Instance==TIM16)
{
/* USER CODE BEGIN TIM16_MspInit 0 */
/* USER CODE END TIM16_MspInit 0 */
/* TIM16 clock enable */
__HAL_RCC_TIM16_CLK_ENABLE();
/* TIM16 interrupt Init */
HAL_NVIC_SetPriority(TIM1_UP_TIM16_IRQn, 15, 0);
HAL_NVIC_EnableIRQ(TIM1_UP_TIM16_IRQn);
/* USER CODE BEGIN TIM16_MspInit 1 */
/* USER CODE END TIM16_MspInit 1 */
}
else if(tim_baseHandle->Instance==TIM17)
{
/* USER CODE BEGIN TIM17_MspInit 0 */
/* USER CODE END TIM17_MspInit 0 */
/* TIM17 clock enable */
__HAL_RCC_TIM17_CLK_ENABLE();
/* TIM17 interrupt Init */
HAL_NVIC_SetPriority(TIM1_TRG_COM_TIM17_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(TIM1_TRG_COM_TIM17_IRQn);
/* USER CODE BEGIN TIM17_MspInit 1 */
/* USER CODE END TIM17_MspInit 1 */
}
}
void HAL_TIM_MspPostInit(TIM_HandleTypeDef* timHandle)
{
@ -343,41 +253,10 @@ void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
/* USER CODE END TIM7_MspDeInit 0 */
/* Peripheral clock disable */
__HAL_RCC_TIM7_CLK_DISABLE();
/* TIM7 interrupt Deinit */
HAL_NVIC_DisableIRQ(TIM7_IRQn);
/* USER CODE BEGIN TIM7_MspDeInit 1 */
/* USER CODE END TIM7_MspDeInit 1 */
}
else if(tim_baseHandle->Instance==TIM16)
{
/* USER CODE BEGIN TIM16_MspDeInit 0 */
/* USER CODE END TIM16_MspDeInit 0 */
/* Peripheral clock disable */
__HAL_RCC_TIM16_CLK_DISABLE();
/* TIM16 interrupt Deinit */
HAL_NVIC_DisableIRQ(TIM1_UP_TIM16_IRQn);
/* USER CODE BEGIN TIM16_MspDeInit 1 */
/* USER CODE END TIM16_MspDeInit 1 */
}
else if(tim_baseHandle->Instance==TIM17)
{
/* USER CODE BEGIN TIM17_MspDeInit 0 */
/* USER CODE END TIM17_MspDeInit 0 */
/* Peripheral clock disable */
__HAL_RCC_TIM17_CLK_DISABLE();
/* TIM17 interrupt Deinit */
HAL_NVIC_DisableIRQ(TIM1_TRG_COM_TIM17_IRQn);
/* USER CODE BEGIN TIM17_MspDeInit 1 */
/* USER CODE END TIM17_MspDeInit 1 */
}
}
/* USER CODE BEGIN 1 */

72
EWARM/chargeController.ewd
View File

@ -36,7 +36,7 @@
</option>
<option>
<name>MacFile</name>
<state />
<state></state>
</option>
<option>
<name>MemOverride</name>
@ -60,7 +60,7 @@
</option>
<option>
<name>CExtraOptions</name>
<state />
<state></state>
</option>
<option>
<name>CFpuProcessor</name>
@ -68,7 +68,7 @@
</option>
<option>
<name>OCDDFArgumentProducer</name>
<state />
<state></state>
</option>
<option>
<name>OCDownloadSuppressDownload</name>
@ -104,7 +104,7 @@
</option>
<option>
<name>MacFile2</name>
<state />
<state></state>
</option>
<option>
<name>CDevice</name>
@ -120,7 +120,7 @@
</option>
<option>
<name>OCImagesPath1</name>
<state />
<state></state>
</option>
<option>
<name>OCImagesSuppressCheck2</name>
@ -128,7 +128,7 @@
</option>
<option>
<name>OCImagesPath2</name>
<state />
<state></state>
</option>
<option>
<name>OCImagesSuppressCheck3</name>
@ -136,7 +136,7 @@
</option>
<option>
<name>OCImagesPath3</name>
<state />
<state></state>
</option>
<option>
<name>OverrideDefFlashBoard</name>
@ -148,11 +148,11 @@
</option>
<option>
<name>OCImagesOffset2</name>
<state />
<state></state>
</option>
<option>
<name>OCImagesOffset3</name>
<state />
<state></state>
</option>
<option>
<name>OCImagesUse1</name>
@ -184,15 +184,15 @@
</option>
<option>
<name>OCMulticoreWorkspace</name>
<state />
<state></state>
</option>
<option>
<name>OCMulticoreSlaveProject</name>
<state />
<state></state>
</option>
<option>
<name>OCMulticoreSlaveConfiguration</name>
<state />
<state></state>
</option>
<option>
<name>OCDownloadExtraImage</name>
@ -216,7 +216,7 @@
</option>
<option>
<name>OCMulticoreSessionFile</name>
<state />
<state></state>
</option>
<option>
<name>OCTpiuBaseOption</name>
@ -228,7 +228,7 @@
</option>
<option>
<name>OCOverrideSlavePath</name>
<state />
<state></state>
</option>
<option>
<name>C_32_64Device</name>
@ -244,11 +244,11 @@
</option>
<option>
<name>AuthSdmManifest</name>
<state />
<state></state>
</option>
<option>
<name>AuthSdmExplicitLib</name>
<state />
<state></state>
</option>
<option>
<name>AuthEnforce</name>
@ -277,7 +277,7 @@
</option>
<option>
<name>OCSimPspConfigFile</name>
<state />
<state></state>
</option>
</data>
</settings>
@ -294,7 +294,7 @@
</option>
<option>
<name>Fast Model</name>
<state />
<state></state>
</option>
<option>
<name>CCADILogFileCheck</name>
@ -461,7 +461,7 @@
</option>
<option>
<name>OCProbeConfig</name>
<state />
<state></state>
</option>
<option>
<name>CMSISDAPProbeConfigRadio</name>
@ -473,7 +473,7 @@
</option>
<option>
<name>ICpuName</name>
<state />
<state></state>
</option>
<option>
<name>OCJetEmuParams</name>
@ -481,7 +481,7 @@
</option>
<option>
<name>CCCMSISDAPUsbSerialNo</name>
<state />
<state></state>
</option>
<option>
<name>CCCMSISDAPUsbSerialNoSelect</name>
@ -502,7 +502,7 @@
</option>
<option>
<name>CE2UsbSerialNo</name>
<state />
<state></state>
</option>
<option>
<name>CE2IdCodeEditB</name>
@ -642,7 +642,7 @@
</option>
<option>
<name>IjetCpuClockEdit</name>
<state />
<state></state>
</option>
<option>
<name>IjetSwoPrescalerList</name>
@ -735,7 +735,7 @@
</option>
<option>
<name>OCProbeConfig</name>
<state />
<state></state>
</option>
<option>
<name>IjetProbeConfigRadio</name>
@ -755,7 +755,7 @@
</option>
<option>
<name>ICpuName</name>
<state />
<state></state>
</option>
<option>
<name>OCJetEmuParams</name>
@ -781,7 +781,7 @@
</option>
<option>
<name>CCIjetUsbSerialNo</name>
<state />
<state></state>
</option>
<option>
<name>CCIjetUsbSerialNoSelect</name>
@ -1004,7 +1004,7 @@
</option>
<option>
<name>CCJLinkUsbSerialNo</name>
<state />
<state></state>
</option>
<option>
<name>CCTcpIpAlt</name>
@ -1013,11 +1013,11 @@
</option>
<option>
<name>CCJLinkTcpIpSerialNo</name>
<state />
<state></state>
</option>
<option>
<name>CCCpuClockEdit</name>
<state />
<state></state>
</option>
<option>
<name>CCSwoClockAuto</name>
@ -1074,7 +1074,7 @@
</option>
<option>
<name>CCLmiftdiUsbSerialNo</name>
<state />
<state></state>
</option>
<option>
<name>CCLmiftdiUsbSerialNoSelect</name>
@ -1227,7 +1227,7 @@
</option>
<option>
<name>CCSTLinkUsbSerialNo</name>
<state />
<state></state>
</option>
<option>
<name>CCSTLinkUsbSerialNoSelect</name>
@ -1240,7 +1240,7 @@
</option>
<option>
<name>CCSTLinkDAPNumber</name>
<state />
<state></state>
</option>
<option>
<name>CCSTLinkDebugAccessPortRadio</name>
@ -1378,11 +1378,11 @@
</option>
<option>
<name>TIPackage</name>
<state />
<state></state>
</option>
<option>
<name>BoardFile</name>
<state />
<state></state>
</option>
<option>
<name>DoLogfile</name>
@ -1474,7 +1474,7 @@
</option>
<option>
<name>CCXds100CpuClockEdit</name>
<state />
<state></state>
</option>
<option>
<name>CCXds100SwoClockAuto</name>
@ -1495,7 +1495,7 @@
</option>
<option>
<name>CCXds100UsbSerialNo</name>
<state />
<state></state>
</option>
<option>
<name>CCXds100UsbSerialNoSelect</name>

82
EWARM/chargeController.ewp
View File

@ -358,14 +358,13 @@
<state>$PROJ_DIR$/../Drivers/STM32G4xx_HAL_Driver/Inc/Legacy</state>
<state>$PROJ_DIR$/../Drivers/CMSIS/Device/ST/STM32G4xx/Include</state>
<state>$PROJ_DIR$/../Drivers/CMSIS/Include</state>
<state>$PROJ_DIR$/../Middlewares/ST/ARM/DSP/Inc</state>
<state>$PROJ_DIR$\..\APP\application\Inc</state>
<state>$PROJ_DIR$\..\APP\businessLogic\Inc</state>
<state>$PROJ_DIR$\..\APP\functionalModule\Inc</state>
<state>$PROJ_DIR$\..\APP\hardwareDriver\Inc</state>
<state>$PROJ_DIR$\..\tools\RingQueue</state>
<state>$PROJ_DIR$\..\tools</state>
<state>$PROJ_DIR$\..\tools\TimeSliceOffset</state>
<state>$PROJ_DIR$/../Middlewares/ST/ARM/DSP/Inc</state>
</option>
<option>
<name>CCStdIncCheck</name>
@ -617,7 +616,7 @@
</option>
<option>
<name>AOutputFile</name>
<state>$FILE_BNAME$.o</state>
<state></state>
</option>
<option>
<name>ALimitErrorsCheck</name>
@ -1011,7 +1010,7 @@
</option>
<option>
<name>IlinkTrustzoneImportLibraryOut</name>
<state>chargeController_import_lib.o</state>
<state></state>
</option>
<option>
<name>OILinkExtraOption</name>
@ -1103,72 +1102,6 @@
<data />
</settings>
</configuration>
<group>
<name>APP</name>
<group>
<name>application</name>
<file>
<name>$PROJ_DIR$\..\APP\application\Src\chargControl.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\application\Src\comm.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\application\Src\start.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\application\Src\task.c</name>
</file>
</group>
<group>
<name>businessLogic</name>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\abnormalManage.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\bl_chargControl.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\bl_comm.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\inFlash.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\parameter.c</name>
</file>
</group>
<group>
<name>functionalModule</name>
<file>
<name>$PROJ_DIR$\..\APP\functionalModule\Src\capture.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\functionalModule\Src\flash.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\functionalModule\Src\FM_GPIO.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\functionalModule\Src\FM_TIM.c</name>
</file>
</group>
<group>
<name>hardwareDriver</name>
<file>
<name>$PROJ_DIR$\..\APP\hardwareDriver\Src\HD_ADC.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\hardwareDriver\Src\HD_GPIO.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\hardwareDriver\Src\HD_TIM.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\hardwareDriver\Src\w25qxx.c</name>
</file>
</group>
</group>
<group>
<name>Application</name>
<group>
@ -1304,13 +1237,4 @@
</group>
</group>
</group>
<group>
<name>tools</name>
<file>
<name>$PROJ_DIR$\..\tools\RingQueue\ring_queue.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\tools\TimeSliceOffset\timeSliceOffset.c</name>
</file>
</group>
</project>

75
EWARM/chargeController.ewt
View File

@ -1426,72 +1426,6 @@
</data>
</settings>
</configuration>
<group>
<name>APP</name>
<group>
<name>application</name>
<file>
<name>$PROJ_DIR$\..\APP\application\Src\chargControl.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\application\Src\comm.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\application\Src\start.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\application\Src\task.c</name>
</file>
</group>
<group>
<name>businessLogic</name>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\abnormalManage.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\bl_chargControl.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\bl_comm.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\inFlash.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\businessLogic\Src\parameter.c</name>
</file>
</group>
<group>
<name>functionalModule</name>
<file>
<name>$PROJ_DIR$\..\APP\functionalModule\Src\capture.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\functionalModule\Src\flash.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\functionalModule\Src\FM_GPIO.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\functionalModule\Src\FM_TIM.c</name>
</file>
</group>
<group>
<name>hardwareDriver</name>
<file>
<name>$PROJ_DIR$\..\APP\hardwareDriver\Src\HD_ADC.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\hardwareDriver\Src\HD_GPIO.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\hardwareDriver\Src\HD_TIM.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\APP\hardwareDriver\Src\w25qxx.c</name>
</file>
</group>
</group>
<group>
<name>Application</name>
<group>
@ -1627,13 +1561,4 @@
</group>
</group>
</group>
<group>
<name>tools</name>
<file>
<name>$PROJ_DIR$\..\tools\RingQueue\ring_queue.c</name>
</file>
<file>
<name>$PROJ_DIR$\..\tools\TimeSliceOffset\timeSliceOffset.c</name>
</file>
</group>
</project>

32
chargeController.ioc
View File

@ -67,11 +67,9 @@ Mcu.CPN=STM32G431RBT6
Mcu.Family=STM32G4
Mcu.IP0=ADC1
Mcu.IP1=ADC2
Mcu.IP10=TIM16
Mcu.IP11=TIM17
Mcu.IP12=UART4
Mcu.IP13=USART2
Mcu.IP14=USART3
Mcu.IP10=UART4
Mcu.IP11=USART2
Mcu.IP12=USART3
Mcu.IP2=DMA
Mcu.IP3=NVIC
Mcu.IP4=RCC
@ -80,7 +78,7 @@ Mcu.IP6=SYS
Mcu.IP7=TIM3
Mcu.IP8=TIM6
Mcu.IP9=TIM7
Mcu.IPNb=15
Mcu.IPNb=13
Mcu.Name=STM32G431R(6-8-B)Tx
Mcu.Package=LQFP64
Mcu.Pin0=PC13
@ -112,16 +110,14 @@ Mcu.Pin31=VP_SYS_VS_tim1
Mcu.Pin32=VP_SYS_VS_DBSignals
Mcu.Pin33=VP_TIM6_VS_ClockSourceINT
Mcu.Pin34=VP_TIM7_VS_ClockSourceINT
Mcu.Pin35=VP_TIM16_VS_ClockSourceINT
Mcu.Pin36=VP_TIM17_VS_ClockSourceINT
Mcu.Pin37=VP_STMicroelectronics.X-CUBE-ALGOBUILD_VS_DSPOoLibraryJjLibrary_1.4.0_1.4.0
Mcu.Pin35=VP_STMicroelectronics.X-CUBE-ALGOBUILD_VS_DSPOoLibraryJjLibrary_1.4.0_1.4.0
Mcu.Pin4=PC2
Mcu.Pin5=PA0
Mcu.Pin6=PA1
Mcu.Pin7=PA2
Mcu.Pin8=PA3
Mcu.Pin9=PA4
Mcu.PinsNb=38
Mcu.PinsNb=36
Mcu.ThirdParty0=STMicroelectronics.X-CUBE-ALGOBUILD.1.4.0
Mcu.ThirdPartyNb=1
Mcu.UserConstants=
@ -140,10 +136,8 @@ NVIC.PendSV_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false
NVIC.PriorityGroup=NVIC_PRIORITYGROUP_4
NVIC.SVCall_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false
NVIC.SysTick_IRQn=true\:15\:0\:false\:false\:true\:false\:true\:false
NVIC.TIM1_TRG_COM_TIM17_IRQn=true\:0\:0\:false\:false\:true\:true\:true\:true
NVIC.TIM1_UP_TIM16_IRQn=true\:15\:0\:false\:false\:true\:false\:true\:true
NVIC.TIM6_DAC_IRQn=true\:0\:0\:false\:false\:true\:true\:true\:true
NVIC.TIM7_IRQn=true\:0\:0\:false\:false\:true\:true\:true\:true
NVIC.TimeBase=TIM1_UP_TIM16_IRQn
NVIC.TimeBaseIP=TIM1
NVIC.USART2_IRQn=true\:0\:0\:false\:false\:true\:true\:true\:true
@ -304,7 +298,7 @@ ProjectManager.ToolChainLocation=
ProjectManager.UAScriptAfterPath=
ProjectManager.UAScriptBeforePath=
ProjectManager.UnderRoot=false
ProjectManager.functionlistsort=1-SystemClock_Config-RCC-false-HAL-false,2-MX_GPIO_Init-GPIO-false-HAL-true,3-MX_DMA_Init-DMA-false-HAL-true,4-MX_ADC1_Init-ADC1-false-HAL-true,5-MX_ADC2_Init-ADC2-false-HAL-true,6-MX_SPI1_Init-SPI1-false-HAL-true,7-MX_TIM3_Init-TIM3-false-HAL-true,8-MX_TIM6_Init-TIM6-false-HAL-true,9-MX_UART4_Init-UART4-false-HAL-true,10-MX_USART2_UART_Init-USART2-false-HAL-true,11-MX_USART3_UART_Init-USART3-false-HAL-true,12-MX_TIM7_Init-TIM7-false-HAL-true,13-MX_TIM16_Init-TIM16-false-HAL-true
ProjectManager.functionlistsort=1-SystemClock_Config-RCC-false-HAL-false,2-MX_GPIO_Init-GPIO-false-HAL-true,3-MX_DMA_Init-DMA-false-HAL-true,4-MX_ADC1_Init-ADC1-false-HAL-true,5-MX_ADC2_Init-ADC2-false-HAL-true,6-MX_SPI1_Init-SPI1-false-HAL-true,7-MX_TIM3_Init-TIM3-false-HAL-true,8-MX_TIM6_Init-TIM6-false-HAL-true,9-MX_UART4_Init-UART4-false-HAL-true,10-MX_USART2_UART_Init-USART2-false-HAL-true,11-MX_USART3_UART_Init-USART3-false-HAL-true,12-MX_TIM7_Init-TIM7-false-HAL-true
RCC.ADC12Freq_Value=72000000
RCC.AHBFreq_Value=72000000
RCC.APB1Freq_Value=72000000
@ -368,17 +362,11 @@ STMicroelectronics.X-CUBE-ALGOBUILD.1.4.0.DSPOoLibraryJjLibrary_Checked=true
STMicroelectronics.X-CUBE-ALGOBUILD.1.4.0.IPParameters=LibraryCcDSPOoLibraryJjDSPOoLibrary
STMicroelectronics.X-CUBE-ALGOBUILD.1.4.0.LibraryCcDSPOoLibraryJjDSPOoLibrary=true
STMicroelectronics.X-CUBE-ALGOBUILD.1.4.0_SwParameter=LibraryCcDSPOoLibraryJjDSPOoLibrary\:true;
TIM16.IPParameters=Prescaler,PeriodNoDither
TIM16.PeriodNoDither=999
TIM16.Prescaler=71
TIM17.IPParameters=Prescaler,PeriodNoDither
TIM17.PeriodNoDither=199
TIM17.Prescaler=71
TIM3.Channel-PWM\ Generation4\ CH4=TIM_CHANNEL_4
TIM3.IPParameters=PeriodNoDither,Channel-PWM Generation4 CH4
TIM3.PeriodNoDither=720
TIM6.IPParameters=Prescaler,PeriodNoDither,TIM_MasterOutputTrigger
TIM6.PeriodNoDither=29
TIM6.PeriodNoDither=499
TIM6.Prescaler=71
TIM6.TIM_MasterOutputTrigger=TIM_TRGO_UPDATE
TIM7.IPParameters=Prescaler,PeriodNoDither,TIM_MasterOutputTrigger
@ -397,10 +385,6 @@ VP_SYS_VS_DBSignals.Mode=DisableDeadBatterySignals
VP_SYS_VS_DBSignals.Signal=SYS_VS_DBSignals
VP_SYS_VS_tim1.Mode=TIM1
VP_SYS_VS_tim1.Signal=SYS_VS_tim1
VP_TIM16_VS_ClockSourceINT.Mode=Enable_Timer
VP_TIM16_VS_ClockSourceINT.Signal=TIM16_VS_ClockSourceINT
VP_TIM17_VS_ClockSourceINT.Mode=Enable_Timer
VP_TIM17_VS_ClockSourceINT.Signal=TIM17_VS_ClockSourceINT
VP_TIM6_VS_ClockSourceINT.Mode=Enable_Timer
VP_TIM6_VS_ClockSourceINT.Signal=TIM6_VS_ClockSourceINT
VP_TIM7_VS_ClockSourceINT.Mode=Enable_Timer

30
tools/RingQueue/ring_queue.c
View File

@ -1,12 +1,12 @@
/*
* ring_queue.c
*
* Created on: 2024年6月21日
* Created on: 2024年6月21日
* Author: psx
*/
//循环队列
//循环队列
#include <stdio.h>
#include <stdlib.h>
#include "ring_queue.h"
@ -19,7 +19,7 @@
//void rq_debug(const char *fmt, ...){};
//#endif
//初始化队列
//初始化队列
int InitRingQueue(RingQueue *q, RQ_ElementType *buff, int size)
{
q->elems = buff;
@ -28,8 +28,8 @@ int InitRingQueue(RingQueue *q, RQ_ElementType *buff, int size)
return RQ_OK;
}
//遍历队列,
//消费者使用，故对生产者可能修改的rear先读取缓存
//遍历队列,
//消费者使用，故对生产者可能修改的rear先读取缓存
int ShowRingQueue(RingQueue *q)
{
//int i;
@ -37,25 +37,25 @@ int ShowRingQueue(RingQueue *q)
if(q->front == rear)
{
//rq_debug("队列为空\n");
//rq_debug("队列为空\n");
return RQ_ERROR;
}
//rq_debug("队列中的元素为:\n");
//rq_debug("队列中的元素为:\n");
//for(i=((q->front)%q->size); i != rear; i=((i+1)%q->size))
//rq_debug(" %c\n",q->elems[i]);
//rq_debug("\n");
//rq_debug("队首元素为%c\n",q->elems[q->front]);
//rq_debug("队尾元素为%c\n",q->elems[rear - 1]);
//rq_debug("队首元素为%c\n",q->elems[q->front]);
//rq_debug("队尾元素为%c\n",q->elems[rear - 1]);
return RQ_OK;
}
//向队尾插入元素e
//向队尾插入元素e
int InRingQueue(RingQueue *q,RQ_ElementType e)
{
if(RingQueueFull(q))
{
//rq_debug("空间不足\n");
//rq_debug("空间不足\n");
return(RQ_OVERFLOW);
}
q->elems[q->rear] = e;
@ -64,21 +64,21 @@ int InRingQueue(RingQueue *q,RQ_ElementType e)
return RQ_OK;
}
//从队首取回并删除元素
//从队首取回并删除元素
int OutRingQueue(RingQueue *q, RQ_ElementType *e)
{
if(RingQueueEmpty(q))
{
//rq_debug("队列为空\n");
//rq_debug("队列为空\n");
return RQ_ERROR;
}
*e = q->elems[q->front];
//rq_debug("被删除的队首元素为%c\n",q->elems[q->front]);
//rq_debug("被删除的队首元素为%c\n",q->elems[q->front]);
q->front = (q->front+1) % q->size;
return RQ_OK;
}
//队列中的元素个数
//队列中的元素个数
int RingQueueLength(RingQueue *q)
{
return ((q->rear - q->front) + q->size) % q->size;

149
tools/TimeSliceOffset/timeSliceOffset.c
View File

@ -1,149 +0,0 @@
/*
* timeSliceOffset.c
*
* Created on: 2024年6月22日
* Author: psx
*/
#include "TimeSliceOffset.h"
static STR_TimeSliceOffset* pTimeSliceList = NULL; /**< 时间片链表入口(仅入口，最终直接指向设备实体，所需无需申请空间。链表是单向线性链表) */
/**
* @brief 注册
* @param[in] pTSlice 时间片对象指针
* @param[in] taskFunc 任务函数的函数指针
* @param[in] reloadVal 时间片重载值*tick基准即为任务执行间隔
* @param[in] offset 偏移量，这是错位的精髓
* @return 配置是否成功
* - 0 注册成功
* - 1 配置完成，但对象已存在，无需加入链表
* - -1 pTSlice为空指针，无效对象
* @par 注意事项：
* - reloadVal设置为零即非定时任务，则offset偏移量无效
* @par 示例:
* @code
*
* TimeSliceOffset_Register(&m_timeSlice_1, Task_1, 0, 0); //0，即非定时任务(每次轮询都会执行)
* TimeSliceOffset_Register(&m_timeSlice_2, Task_2, 10, 0); //10*1ms，即10ms运行一次
* TimeSliceOffset_Register(&m_timeSlice_3, Task_3, 10, 5); //10*1ms，即10ms运行一次，与Task_2错开5ms，这样就不会集中到同一个10ms的时间点上
*
* @endcode
*/
int TimeSliceOffset_Register(STR_TimeSliceOffset* pTSlice, \
void (*taskFunc)(void), \
unsigned short reloadVal, \
unsigned short offset)
{
if(NULL == pTSlice)return -1; /* 返回错误：无效对象 */
pTSlice->reloadVal = reloadVal;
pTSlice->count = reloadVal + offset; /* 添加偏移量，使得同一数值的时间片错开 */
pTSlice->taskFunc = taskFunc;
if(0 == reloadVal) /* 非定时任务 */
{
pTSlice->runFlag = 1; /* 非定时任务可运行标志默认为一 */
}
else /* 定时任务 */
{
pTSlice->runFlag = 0; /* 定时任务可运行标志默认为零 */
}
/*遍历链表，防止添加重复*/
for(STR_TimeSliceOffset* pTemp = pTimeSliceList; pTemp != NULL; pTemp = pTemp->pNext)
{
if(pTemp == pTSlice)
{
return 1; /* 返回成功：配置完成，但对象已存在，无需加入链表 */
}
}
/*加入链表*/
pTSlice->pNext = pTimeSliceList;
pTimeSliceList = pTSlice; /* 把对象加入到链表头部 */
return 0; /* 返回成功：注册成功 */
}
/**
* @brief 取消注册
* @return 取消配置是否成功
* - 0 取消配置成功
* - 1 取消配置成功，但对象不存在，无需从链表中删除
* - -1 pTSlice为空指针，无效对象
* @endcode
*/
int TimeSliceOffset_Unregister(STR_TimeSliceOffset* pTSlice)
{
if (NULL == pTSlice) return -1; /* 返回错误：无效对象 */
/* 遍历链表 */
for (STR_TimeSliceOffset* pTemp = pTimeSliceList; pTemp != NULL; pTemp = pTemp->pNext) {
if (pTemp->pNext == pTSlice) {
pTemp->pNext = pTemp->pNext->pNext;
return 0; /* 返回成功：取消注册 */
} else if (pTemp == pTSlice) {
pTimeSliceList = pTemp->pNext;
// pTimeSliceList->pNext = pTemp->pNext->pNext;
return 0; /* 返回成功：取消注册 */
}
}
return 1; /* 返回成功：对象不存在于链表中 */
}
/**
* @brief 启动时间片错位轮询(代替main的while循环)
* @param null
* @return null
* @par 注意事项：
* - null
*/
void TimeSliceOffset_Start(void)
{
while(1) /* 代替main的while循环 */
{
/*遍历时间片链表*/
for(STR_TimeSliceOffset* pTemp = pTimeSliceList; pTemp != NULL; pTemp = pTemp->pNext)
{
if(pTemp->runFlag) /* 可运行则调用任务函数 */
{
if(pTemp->reloadVal) /* 重载值不为0，即定时任务 */
{
pTemp->runFlag = 0; /* 可运行标志清零，开启新一轮倒计时 */
}
pTemp->taskFunc();
}
}
// __WFI();
}
}
/**
* @brief 时间片生成(放到systick或定时器中断处理函数内)
* @param null
* @return null
* @par 注意事项：
* - null
*/
void TimeSliceOffset_Produce(void)
{
/*遍历时间片链表*/
for(STR_TimeSliceOffset* pTemp = pTimeSliceList; pTemp != NULL; pTemp = pTemp->pNext)
{
if(pTemp->reloadVal) /* 重载值不为0，即定时任务 */
{
--pTemp->count; /* 计数器递减 */
if(0 == pTemp->count) /* 计数器递减到零 */
{
pTemp->runFlag = 1; /* 允许执行 */
pTemp->count = pTemp->reloadVal; /* 计数器重载 */
}
}
}
}

42
tools/TimeSliceOffset/timeSliceOffset.h
View File

@ -1,42 +0,0 @@
/*
* timeSliceOffset.h
*
* Created on: 2024年6月22日
* Author: psx
*/
#ifndef DRIVERS_TIMESLICEOFFSET_TIMESLICEOFFSET_H_
#define DRIVERS_TIMESLICEOFFSET_TIMESLICEOFFSET_H_
#include "pdebug.h"
/**时间片类*/
typedef struct _STR_TimeSliceOffset{
volatile unsigned char runFlag; /**< 可运行标志(1:可运行/0:不可运行) */
volatile unsigned short count; /**< 计数器 */
unsigned short reloadVal; /**< 重载值 */
void (*taskFunc)(void); /**< 任务函数的函数指针 */
struct _STR_TimeSliceOffset* pNext; /**< 指向下一个对象 */
}STR_TimeSliceOffset;
/********************************************函数声明********************************************/
/* 注册 */
int TimeSliceOffset_Register(STR_TimeSliceOffset* pTSlice, \
void (*taskFunc)(void), \
unsigned short reloadVal, \
unsigned short offset);
/* 取消注册 */
int TimeSliceOffset_Unregister(STR_TimeSliceOffset* pTSlice);
/* 启动时间片错位轮询(代替main的while循环) */
void TimeSliceOffset_Start(void);
/* 时间片生成(放到systick或定时器中断处理函数内) */
void TimeSliceOffset_Produce(void);
#endif /* DRIVERS_TIMESLICEOFFSET_TIMESLICEOFFSET_H_ */

2
tools/chargControlEnum.h
View File

@ -7,7 +7,7 @@ typedef enum {
MPPT = 1, /* 最大功率充电 */
constantVoltage = 2, /* 恒压充电 */
floatCharg = 3 /* 浮充充电 */
}_chargControlMode;
}chargControlMode;
#endif

8
tools/pDebug.h
View File

@ -4,18 +4,18 @@
#include <stdio.h>
#include <string.h>
// #include "uart_dev.h"
// #include "pdebug.h"
#include "uart_dev.h"
#include "pdebug.h"
/* Comment out this define to include debug messages */
#define NDEBUG
//#define NDEBUG
#define log_info_enable 1
#define log_warn_enable 0
#define log_error_enable 0
/* Comment out this define to include log messages */
#define NLOG
//#define NLOG
#ifdef NDEBUG
#define debug(M, ...) do {}while(0)