2648 lines
55 KiB
C
2648 lines
55 KiB
C
/**
|
|
******************************************************************************
|
|
* @file Status.c
|
|
* @author
|
|
* @version
|
|
* @date
|
|
* @brief
|
|
******************************************************************************
|
|
* @attention
|
|
*
|
|
*
|
|
******************************************************************************
|
|
*/
|
|
|
|
/* Includes ------------------------------------------------------------------*/
|
|
#include "stm32f10x.h"
|
|
#include "global.h"
|
|
#include "string.h"
|
|
|
|
/*电压*/
|
|
uint8_t cellov_alarmcount; //单体过压告警的延时计数
|
|
uint8_t celluv_alarmcount; //单体欠压告警的延时计数
|
|
uint8_t packov_alarmcount; //总体过压告警的延时计数
|
|
uint8_t packuv_alarmcount; //总体欠压告警的延时计数
|
|
uint8_t cellovr_alarmcount; //单体过压告警释放的延时计数
|
|
uint8_t celluvr_alarmcount; //单体欠压告警释放的延时计数
|
|
uint8_t packovr_alarmcount; //总体过压告警释放的延时计数
|
|
uint8_t packuvr_alarmcount; //总体欠压告警释放的延时计数
|
|
|
|
uint8_t cellov_count; //单体过压保护的延时计数
|
|
uint8_t celluv_count; //单体欠压保护的延时计数
|
|
uint8_t packov_count; //总体过压保护的延时计数
|
|
uint8_t packuv_count; //总体欠压保护的延时计数
|
|
uint8_t cellovr_count; //单体过压保护释放的延时计数
|
|
uint8_t celluvr_count; //单体欠压保护释放的延时计数
|
|
uint8_t packovr_count; //总体过压保护释放的延时计数
|
|
uint8_t packuvr_count; //总体欠压保护释放的延时计数
|
|
|
|
uint16_t cell_OV; //单体过压值
|
|
uint16_t cell_UV; //单体欠压值
|
|
uint16_t cell_OVT; //单体过压延时参数，对应表格1s~40s
|
|
uint16_t cell_UVT; //单体欠压延时参数，对应表格1s~40s
|
|
uint16_t cell_OVR; //单体过压释放值
|
|
uint16_t cell_UVR; //单体欠压释放值
|
|
|
|
uint8_t cellovr_alarmcount2; //单体过压告警特殊释放的延时计数
|
|
uint8_t celluvr_alarmcount2; //单体欠压告警特殊释放的延时计数
|
|
uint8_t packovr_alarmcount2; //总体过压告警特殊释放的延时计数
|
|
uint8_t packuvr_alarmcount2; //总体欠压告警特殊释放的延时计数
|
|
|
|
uint8_t cellovr_alarmcount3; //单体过压告警特殊释放的延时计数
|
|
uint8_t celluvr_alarmcount3; //单体欠压告警特殊释放的延时计数
|
|
uint8_t packovr_alarmcount3; //总体过压告警特殊释放的延时计数
|
|
uint8_t packuvr_alarmcount3; //总体欠压告警特殊释放的延时计数
|
|
|
|
uint8_t cellovr_count2; //单体过压保护特殊释放的延时计数
|
|
uint8_t celluvr_count2; //单体欠压保护特殊释放的延时计数
|
|
uint8_t packovr_count2; //总体过压保护特殊释放的延时计数
|
|
uint8_t packuvr_count2; //总体欠压保护特殊释放的延时计数
|
|
|
|
uint8_t cellovr_count3; //单体过压保护特殊释放的延时计数
|
|
uint8_t celluvr_count3; //单体欠压保护特殊释放的延时计数
|
|
uint8_t packovr_count3; //总体过压保护特殊释放的延时计数
|
|
uint8_t packuvr_count3; //总体欠压保护特殊释放的延时计数
|
|
|
|
uint8_t cellovr_alarmflag; //单体过压告警特殊释放的标志(因为过压会校准SOC，不考虑SOC<96%条件)
|
|
uint8_t packovr_alarmflag; //总体过压告警特殊释放的标志(因为过压会校准SOC，不考虑SOC<96%条件)
|
|
uint8_t celluvr_alarmflag; //单体欠压告警特殊释放的标志
|
|
uint8_t packuvr_alarmflag; //总体欠压告警特殊释放的标志
|
|
|
|
uint8_t cellovr_flag; //单体过压保护特殊释放的标志(因为过压会校准SOC，不考虑SOC<96%条件)
|
|
uint8_t packovr_flag; //总体过压保护特殊释放的标志(因为过压会校准SOC，不考虑SOC<96%条件)
|
|
uint8_t celluvr_flag; //单体欠压保护特殊释放的标志
|
|
uint8_t packuvr_flag; //总体欠压保护特殊释放的标志
|
|
|
|
/*电流*/
|
|
uint8_t occ_alarmcount; //充电过流告警的延时计数
|
|
uint8_t ocd1_alarmcount; //放电过流1告警的延时计数
|
|
uint8_t occr_alarmcount; //充电过流告警恢复的延时计数
|
|
uint8_t occr_alarmcount2;
|
|
uint8_t ocd1r_alarmcount; //放电过流1告警恢复的延时计数
|
|
uint8_t ocd1r_alarmcount2;
|
|
|
|
uint8_t scr_count; //浪涌短路保护释放的延时计数
|
|
|
|
uint8_t occ_count; //充电过流保护的延时计数
|
|
uint8_t ocd_count; //放电过流1保护的延时计数
|
|
uint8_t ocr_count; //电流保护释放的延时计数
|
|
|
|
uint8_t occ_OccurFlag; //充电过流出现过的标志
|
|
uint8_t ocd1_OccurFlag; //放电过流1出现过的标志
|
|
uint8_t ocd2_OccurFlag; //放电过流1出现过的标志
|
|
|
|
uint8_t occ_RepeatFlag; //持续出现的标志
|
|
uint8_t occ_RepeatTime; //等待倒计时，最大60s =>消失后60s内未再次出现，说明正常
|
|
uint8_t occ_RepeatCount; //重复的计数，最大5次 =>连续5次出现，会在第五次短路将标志位置1，控制MOS关闭
|
|
|
|
uint8_t ocd1_RepeatFlag; //持续出现的标志
|
|
uint8_t ocd1_RepeatTime; //等待倒计时，最大60s =>消失后60s内未再次出现，说明正常
|
|
uint8_t ocd1_RepeatCount; //重复的计数，最大5次 =>连续5次出现，会在第五次短路将标志位置1，控制MOS关闭
|
|
|
|
uint8_t ocd2_RepeatFlag; //持续出现的标志
|
|
uint8_t ocd2_RepeatTime; //等待倒计时，最大60s =>消失后60s内未再次出现，说明正常
|
|
uint8_t ocd2_RepeatCount; //重复的计数，最大5次 =>连续5次出现，会在第五次短路将标志位置1，控制MOS关闭
|
|
|
|
/*温度*/
|
|
uint8_t mcuotc_alarmcount; //电芯充电高温告警的延时计数
|
|
uint8_t mcuutc_alarmcount; //电芯充电低温告警的延时计数
|
|
uint8_t mcuotd_alarmcount; //电芯放电高温告警的延时计数
|
|
uint8_t mcuutd_alarmcount; //电芯放电低温告警的延时计数
|
|
uint8_t mcuotcr_alarmcount; //电芯充电高温告警释放的延时计数
|
|
uint8_t mcuutcr_alarmcount; //电芯充电低温告警释放的延时计数
|
|
uint8_t mcuotdr_alarmcount; //电芯放电高温告警释放的延时计数
|
|
uint8_t mcuutdr_alarmcount; //电芯放电低温告警释放的延时计数
|
|
|
|
uint8_t dsg_htp_count;
|
|
uint8_t dsg_ltp_count;
|
|
uint8_t chg_htp_count;
|
|
uint8_t chg_ltp_count;
|
|
uint8_t dsg_htpr_count;
|
|
uint8_t dsg_ltpr_count;
|
|
uint8_t chg_htpr_count;
|
|
uint8_t chg_ltpr_count;
|
|
|
|
uint8_t am_otc_alarmcount;
|
|
uint8_t am_utc_alarmcount;
|
|
uint8_t am_otd_alarmcount;
|
|
uint8_t am_utd_alarmcount;
|
|
uint8_t am_otcr_alarmcount;
|
|
uint8_t am_utcr_alarmcount;
|
|
uint8_t am_otdr_alarmcount;
|
|
uint8_t am_utdr_alarmcount;
|
|
|
|
uint8_t am_otc_count;
|
|
uint8_t am_otcr_count;
|
|
uint8_t am_otd_count;
|
|
uint8_t am_otdr_count;
|
|
uint8_t am_utc_count;
|
|
uint8_t am_utcr_count;
|
|
uint8_t am_utd_count;
|
|
uint8_t am_utdr_count;
|
|
|
|
uint8_t afeotc_alarmcount; //MOS温度告警的延时计数
|
|
//uint8_t afeutc_alarmcount;
|
|
uint8_t afeotd_alarmcount;
|
|
//uint8_t afeutd_alarmcount;
|
|
uint8_t afeotcr_alarmcount;
|
|
//uint8_t afeutcr_alarmcount;
|
|
uint8_t afeotdr_alarmcount;
|
|
//uint8_t afeutdr_alarmcount;
|
|
|
|
uint8_t afeotc_count; //MOS温度保护的延时计数
|
|
//uint8_t afeutc_count;
|
|
uint8_t afeotd_count;
|
|
//uint8_t afeutd_count;
|
|
uint8_t afeotcr_count;
|
|
//uint8_t afeutcr_count;
|
|
uint8_t afeotdr_count;
|
|
//uint8_t afeutdr_count;
|
|
|
|
/****出现告警/保护/故障/状态事件的上传****/
|
|
#define MaxSaveNum 50
|
|
|
|
uint8_t incident_flag; //4G上报_要执行上报事件的标志
|
|
uint8_t incident_DataInf; //4G上报_要上报发生事件的类型
|
|
uint8_t incident_DataFlg; //4G上报_要上报发生事件时的数据的标志 2:保护 1:其他 0:不用记录
|
|
|
|
uint8_t staChange[MaxSaveNum+5]; //4G上报_最多同时存储50条
|
|
uint32_t staChange_time[MaxSaveNum+5]; //4G上报_发生时间，最多同时存储50条
|
|
uint8_t staChange_num; //4G上报_当前存储待上报状态的总个数 若总个数到达最大，就不再放入，直到全部发送后才清零重新计数
|
|
uint8_t staChange_index; //4G上报_目前上报对应的序号
|
|
|
|
/*状态改变*/
|
|
//常见状态
|
|
uint16_t NomalStatus; //1~8bit -> 有0x01~0x08 无不算事件 (这个从0x01开始表示)
|
|
//特殊状态
|
|
uint16_t SpecialStatus; //0~8bit -> 有0x10~0x19 无+0x80
|
|
//保护
|
|
uint16_t Protect_Vol; //0~5bit -> 有0x20~0x25 无+0x80
|
|
uint16_t Protect_Cur; //0~4bit -> 有0x30~0x34 无+0x80
|
|
uint16_t Protect_Temp; //0~11bit -> 有0x40~0x4B 无+0x80
|
|
//报警
|
|
uint16_t Warning_Vol; //0~3bit -> 有0x50~0x53 无+0x80
|
|
uint16_t Warning_Cur; //0~1bit -> 有0x60~0x61 无+0x80
|
|
uint16_t Warning_Temp; //0~11bit -> 有0x70~0x7B 无+0x80
|
|
|
|
uint16_t status_New[8]; //当前状态拷贝
|
|
uint16_t status_Old[8]; //当上报过出现的报警/保护后，置位对应位
|
|
|
|
|
|
const uint8_t VP_Time[16-6]=
|
|
{
|
|
1, 2, 3, 4, 6, 8, 10, 20, 30, 40
|
|
};
|
|
|
|
|
|
//过压的告警
|
|
void Trigger_OVAlarm(void)
|
|
{
|
|
//单体过压告警判断
|
|
if((bmsMem.bStatus3 & 0x0100) == 0)
|
|
{
|
|
if(cellVoltageMax >= paraMem.alarm_cov)
|
|
{
|
|
if(cellovr_alarmflag == 0) //特殊释放不会因为电压重复触发
|
|
{
|
|
cellov_alarmcount++;
|
|
if(cellov_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus3 |= 0x0100;
|
|
cellov_alarmcount = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cellovr_alarmflag = 0;
|
|
|
|
cellov_alarmcount = 0;
|
|
}
|
|
|
|
if(bDSGING == 0)
|
|
{
|
|
cellovr_alarmflag = 0;
|
|
}
|
|
}
|
|
|
|
//总体过压告警判断
|
|
if((bmsMem.bStatus3 & 0x0400) == 0)
|
|
{
|
|
if(bmsMem.packVoltage >= paraMem.alarm_pov * 100)
|
|
{
|
|
if(packovr_alarmflag == 0)
|
|
{
|
|
packov_alarmcount++;
|
|
if(packov_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus3 |= 0x0400;
|
|
packov_alarmcount = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packovr_alarmflag = 0;
|
|
packov_alarmcount = 0;
|
|
}
|
|
|
|
if(bDSGING == 0)
|
|
{
|
|
packovr_alarmflag = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//欠压的告警
|
|
void Trigger_UVAlarm(void)
|
|
{
|
|
//单体欠压告警判断
|
|
if((bmsMem.bStatus3 & 0x0200) == 0)
|
|
{
|
|
if(cellVoltageMin <= paraMem.alarm_cuv)
|
|
{
|
|
if(celluvr_alarmflag == 0)
|
|
{
|
|
celluv_alarmcount++;
|
|
if(celluv_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus3 |= 0x0200;
|
|
celluv_alarmcount = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
celluvr_alarmflag = 0;
|
|
celluv_alarmcount = 0;
|
|
}
|
|
|
|
if(bCHGING == 0)
|
|
{
|
|
celluvr_alarmflag = 0;
|
|
}
|
|
}
|
|
|
|
//总体欠压告警判断
|
|
if((bmsMem.bStatus3 & 0x0800) == 0)
|
|
{
|
|
if(bmsMem.packVoltage <= paraMem.alarm_puv * 100)
|
|
{
|
|
if(packuvr_alarmflag == 0)
|
|
{
|
|
packuv_alarmcount++;
|
|
if(packuv_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus3 |= 0x0800;
|
|
packuv_alarmcount = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packuvr_alarmflag = 0;
|
|
packuv_alarmcount = 0;
|
|
}
|
|
|
|
if(bCHGING == 0)
|
|
{
|
|
packuvr_alarmflag = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//过压的告警释放
|
|
void Release_OVAlarm(void)
|
|
{
|
|
//单体过压恢复值
|
|
cell_OVR = ( (bmsMem.ee_uvt_ovrh & 0x03) <<8 | bmsMem.ee_ovrl ) * 5;
|
|
|
|
//单体过压告警恢复判断
|
|
if((bmsMem.bStatus3 & 0x0100) != 0)
|
|
{
|
|
if(cellVoltageMax < cell_OVR)
|
|
{
|
|
cellovr_alarmcount++;
|
|
if(cellovr_alarmcount > 1)
|
|
{
|
|
bmsMem.bStatus3 &= ~0x0100;
|
|
cellovr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cellovr_alarmcount = 0;
|
|
}
|
|
|
|
if(bmsMem.soc < paraMem.cellovr_soc) //特殊解除项：①SOC<96%
|
|
{
|
|
cellovr_alarmcount2++;
|
|
if(cellovr_alarmcount2 > 1)
|
|
{
|
|
bmsMem.bStatus3 &= ~0x0100;
|
|
cellovr_alarmcount2 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cellovr_alarmcount2 = 0;
|
|
}
|
|
|
|
if(bmsMem.packCurrent < -3000) //特殊解除项：②放电电流>3A
|
|
{
|
|
cellovr_alarmcount3++;
|
|
if(cellovr_alarmcount3 > 1)
|
|
{
|
|
cellovr_alarmflag = 1;
|
|
|
|
bmsMem.bStatus3 &= ~0x0100;
|
|
cellovr_alarmcount3 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cellovr_alarmcount3 = 0;
|
|
}
|
|
}
|
|
|
|
//总体过压告警恢复判断
|
|
if((bmsMem.bStatus3 & 0x0400) != 0)
|
|
{
|
|
if(bmsMem.packVoltage < paraMem.pack_ovrv * 100)
|
|
{
|
|
packovr_alarmcount++;
|
|
if(packovr_alarmcount > 1)
|
|
{
|
|
bmsMem.bStatus3 &= ~0x0400;
|
|
packovr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packovr_alarmcount = 0;
|
|
}
|
|
|
|
if(bmsMem.soc < paraMem.packovr_soc) //特殊解除项：①SOC<96%
|
|
{
|
|
packovr_alarmcount2++;
|
|
if(packovr_alarmcount2 > 1)
|
|
{
|
|
bmsMem.bStatus3 &= ~0x0400;
|
|
packovr_alarmcount2 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packovr_alarmcount2 = 0;
|
|
}
|
|
|
|
if(bmsMem.packCurrent < -3000) //特殊解除项：②放电电流>3A
|
|
{
|
|
packovr_alarmcount3++;
|
|
if(packovr_alarmcount3 > 1)
|
|
{
|
|
packovr_alarmflag = 1;
|
|
|
|
bmsMem.bStatus3 &= ~0x0400;
|
|
packovr_alarmcount3 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packovr_alarmcount3 = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//欠压的告警释放
|
|
void Release_UVAlarm(void)
|
|
{
|
|
//单体欠压恢复值
|
|
cell_UVR = bmsMem.ee_uvr * 20;
|
|
|
|
//单体欠压告警恢复判断
|
|
if((bmsMem.bStatus3 & 0x0200) != 0)
|
|
{
|
|
if(cellVoltageMin > cell_UVR)
|
|
{
|
|
celluvr_alarmcount++;
|
|
if(celluvr_alarmcount > 1)
|
|
{
|
|
bmsMem.bStatus3 &= ~0x0200;
|
|
celluvr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
celluvr_alarmcount = 0;
|
|
}
|
|
|
|
if(bmsMem.packCurrent > 200) //特殊解除项：接入充电器 0.2A
|
|
{
|
|
celluvr_alarmcount2++;
|
|
if(celluvr_alarmcount2 > 1)
|
|
{
|
|
celluvr_alarmflag = 1;
|
|
|
|
bmsMem.bStatus3 &= ~0x0200;
|
|
celluvr_alarmcount2 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
celluvr_alarmcount2 = 0;
|
|
}
|
|
}
|
|
|
|
//总体欠压告警恢复判断
|
|
if((bmsMem.bStatus3 & 0x0800) != 0)
|
|
{
|
|
if(bmsMem.packVoltage > paraMem.pack_uvrv * 100)
|
|
{
|
|
packuvr_alarmcount++;
|
|
if(packuvr_alarmcount > 1)
|
|
{
|
|
bmsMem.bStatus3 &= ~0x0800;
|
|
packuvr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packuvr_alarmcount = 0;
|
|
}
|
|
|
|
if(bmsMem.packCurrent > 200) //特殊解除项：接入充电器 0.2A
|
|
{
|
|
packuvr_alarmcount2++;
|
|
if(packuvr_alarmcount2 > 1)
|
|
{
|
|
packuvr_alarmflag = 1;
|
|
|
|
bmsMem.bStatus3 &= ~0x0800;
|
|
packuvr_alarmcount2 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packuvr_alarmcount2 = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//过压的保护
|
|
void Trigger_OVProtect(void)
|
|
{
|
|
uint8_t temp;
|
|
|
|
//单体过压值
|
|
cell_OV = ( (bmsMem.ee_ovt_ldrt_ovh & 0x03) <<8 | bmsMem.ee_ovl ) * 5;
|
|
|
|
//单体过压的延时，单位1s
|
|
temp = bmsMem.ee_ovt_ldrt_ovh >> 4;
|
|
temp = temp>=6?(temp-6):0;
|
|
cell_OVT = VP_Time[temp];
|
|
|
|
//单体过压判断
|
|
if((bmsMem.bStatus1 & 0x0001) == 0)
|
|
{
|
|
if(cellVoltageMax >= cell_OV)
|
|
{
|
|
if(cellovr_flag == 0)
|
|
{
|
|
cellov_count++;
|
|
if(cellov_count > cell_OVT)
|
|
{
|
|
bmsMem.bStatus1 |= 0x0001;
|
|
cellov_count = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cellovr_flag = 0;
|
|
cellov_count = 0;
|
|
}
|
|
|
|
if(bDSGING == 0)
|
|
{
|
|
cellovr_flag = 0;
|
|
}
|
|
}
|
|
|
|
//总体过压判断
|
|
if((bmsMem.bStatus1 & 0x0100) == 0)
|
|
{
|
|
if(bmsMem.packVoltage >= paraMem.pack_ovv * 100)
|
|
{
|
|
if(packovr_flag == 0)
|
|
{
|
|
packov_count++;
|
|
if(packov_count > paraMem.pack_ovt)
|
|
{
|
|
bmsMem.bStatus1 |= 0x0100;
|
|
packov_count = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packovr_flag = 0;
|
|
packov_count = 0;
|
|
}
|
|
|
|
if(bDSGING == 0)
|
|
{
|
|
packovr_flag = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//欠压的保护
|
|
void Trigger_UVProtect(void)
|
|
{
|
|
uint8_t temp;
|
|
|
|
//单体欠压值
|
|
cell_UV = bmsMem.ee_uv * 20;
|
|
|
|
//单体欠压的延时，单位1s
|
|
temp = bmsMem.ee_uvt_ovrh >> 4;
|
|
temp = temp>=6?(temp-6):0;
|
|
cell_UVT = VP_Time[temp];
|
|
|
|
//单体欠压判断
|
|
if((bmsMem.bStatus1 & 0x0002) == 0)
|
|
{
|
|
if(cellVoltageMin <= cell_UV)
|
|
{
|
|
if(celluvr_flag == 0)
|
|
{
|
|
celluv_count++;
|
|
if(celluv_count > cell_UVT)
|
|
{
|
|
bmsMem.bStatus1 |= 0x0002;
|
|
celluv_count = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
celluvr_flag = 0;
|
|
celluv_count = 0;
|
|
}
|
|
|
|
if(bCHGING == 0)
|
|
{
|
|
celluvr_flag = 0;
|
|
}
|
|
}
|
|
|
|
//总体欠压判断
|
|
if((bmsMem.bStatus1 & 0x0200) == 0)
|
|
{
|
|
if(bmsMem.packVoltage <= paraMem.pack_uvv * 100)
|
|
{
|
|
if(packuvr_flag == 0)
|
|
{
|
|
packuv_count++;
|
|
if(packuv_count > paraMem.pack_uvt)
|
|
{
|
|
bmsMem.bStatus1 |= 0x0200;
|
|
packuv_count = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packuvr_flag = 0;
|
|
packuv_count = 0;
|
|
}
|
|
|
|
if(bCHGING == 0)
|
|
{
|
|
packuvr_flag = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//过压的保护释放
|
|
void Release_OVProtect(void)
|
|
{
|
|
//单体过压恢复判断
|
|
if((bmsMem.bStatus1 & 0x0001) != 0)
|
|
{
|
|
if(cellVoltageMax < cell_OVR)
|
|
{
|
|
cellovr_count++;
|
|
if(cellovr_count > 1)
|
|
{
|
|
bmsMem.bStatus1 &= ~0x0001;
|
|
cellovr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cellovr_count = 0;
|
|
}
|
|
|
|
if(bmsMem.soc < paraMem.cellovr_soc) //特殊解除项：①SOC<96%
|
|
{
|
|
cellovr_count2++;
|
|
if(cellovr_count2 > 1)
|
|
{
|
|
bmsMem.bStatus1 &= ~0x0001;
|
|
cellovr_count2 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cellovr_count2 = 0;
|
|
}
|
|
if(bmsMem.packCurrent < -3000) //特殊解除项：②放电电流>3A
|
|
{
|
|
cellovr_count3++;
|
|
if(cellovr_count3 > 1)
|
|
{
|
|
cellovr_flag = 1;
|
|
|
|
bmsMem.bStatus1 &= ~0x0001;
|
|
cellovr_count3 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cellovr_count3 = 0;
|
|
}
|
|
}
|
|
|
|
//总体过压恢复判断
|
|
if((bmsMem.bStatus1 & 0x0100) != 0)
|
|
{
|
|
if(bmsMem.packVoltage < paraMem.pack_ovrv * 100)
|
|
{
|
|
packovr_count++;
|
|
if(packovr_count > 1)
|
|
{
|
|
bmsMem.bStatus1 &= ~0x0100;
|
|
packovr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packovr_count = 0;
|
|
}
|
|
|
|
if(bmsMem.soc < paraMem.packovr_soc) //特殊解除项：①SOC<96%
|
|
{
|
|
packovr_count2++;
|
|
if(packovr_count2 > 1)
|
|
{
|
|
bmsMem.bStatus1 &= ~0x0100;
|
|
packovr_count2 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packovr_count2 = 0;
|
|
}
|
|
if(bmsMem.packCurrent < -3000) //特殊解除项：②放电电流>3A
|
|
{
|
|
packovr_count3++;
|
|
if(packovr_count3 > 1)
|
|
{
|
|
packovr_flag = 1;
|
|
|
|
bmsMem.bStatus1 &= ~0x0100;
|
|
packovr_count3 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packovr_count3 = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//欠压的保护释放
|
|
void Release_UVProtect(void)
|
|
{
|
|
//单体欠压恢复判断
|
|
if((bmsMem.bStatus1 & 0x0002) != 0)
|
|
{
|
|
if(cellVoltageMin > cell_UVR)
|
|
{
|
|
celluvr_count++;
|
|
if(celluvr_count > 1)
|
|
{
|
|
bmsMem.bStatus1 &= ~0x0002;
|
|
celluvr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
celluvr_count = 0;
|
|
}
|
|
|
|
if(bmsMem.packCurrent > 200) //特殊解除项：接入充电器 0.2A
|
|
{
|
|
celluvr_count2++;
|
|
if(celluvr_count2 > 1)
|
|
{
|
|
celluvr_flag = 1;
|
|
|
|
bmsMem.bStatus1 &= ~0x0002;
|
|
celluvr_count2 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
celluvr_count2 = 0;
|
|
}
|
|
}
|
|
|
|
//总体欠压恢复判断
|
|
if((bmsMem.bStatus1 & 0x0200) != 0)
|
|
{
|
|
if(bmsMem.packVoltage > paraMem.pack_uvrv * 100)
|
|
{
|
|
packuvr_count++;
|
|
if(packuvr_count > 1)
|
|
{
|
|
bmsMem.bStatus1 &= ~0x0200;
|
|
packuvr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packuvr_count = 0;
|
|
}
|
|
|
|
if(bmsMem.packCurrent > 200) //特殊解除项：接入充电器 0.2A
|
|
{
|
|
packuvr_count2++;
|
|
if(packuvr_count2 > 1)
|
|
{
|
|
packuvr_flag = 1;
|
|
|
|
bmsMem.bStatus1 &= ~0x0200;
|
|
packuvr_count2 = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packuvr_count2 = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//电流的告警
|
|
void Trigger_CurAlarm(void)
|
|
{
|
|
uint32_t current;
|
|
uint32_t alarm_occ,alarm_ocd1;
|
|
|
|
if(bmsMem.packCurrent >=0)
|
|
{
|
|
current = bmsMem.packCurrent;
|
|
}
|
|
else
|
|
{
|
|
current = -bmsMem.packCurrent;
|
|
}
|
|
alarm_occ = paraMem.alarm_occ * 1000;
|
|
alarm_ocd1 = paraMem.alarm_ocd1 * 1000;
|
|
|
|
|
|
//充电过流告警
|
|
if((bmsMem.bStatus3 & BIT12) == 0)
|
|
{
|
|
if((current > alarm_occ) && (bCHGING==1)) //充电状态
|
|
{
|
|
occ_alarmcount++;
|
|
if(occ_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus3 |= BIT12;
|
|
occ_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
occ_alarmcount = 0;
|
|
}
|
|
}
|
|
//放电过流1告警
|
|
if((bmsMem.bStatus3 & BIT13) == 0)
|
|
{
|
|
if((current > alarm_ocd1) && (bDSGING==1)) //放电状态
|
|
{
|
|
ocd1_alarmcount++;
|
|
if(ocd1_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus3 |= BIT13;
|
|
ocd1_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ocd1_alarmcount = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//电流的告警释放
|
|
void Release_CurAlarm(void)
|
|
{
|
|
uint32_t current;
|
|
uint32_t alarm_occ,alarm_ocd1;
|
|
|
|
if(bmsMem.packCurrent >=0)
|
|
{
|
|
current = bmsMem.packCurrent;
|
|
}
|
|
else
|
|
{
|
|
current = -bmsMem.packCurrent;
|
|
}
|
|
alarm_occ = paraMem.alarm_occ * 1000;
|
|
alarm_ocd1 = paraMem.alarm_ocd1 * 1000;
|
|
|
|
|
|
//充电过流告警释放
|
|
if((bmsMem.bStatus3 & BIT12) != 0)
|
|
{
|
|
if(current <= alarm_occ)
|
|
{
|
|
if(((current <= alarm_occ) && (bCHGING == 1)) || (bmsMem.packCurrent < -2000)) //特殊解除项：放电电流>2A
|
|
{
|
|
occr_alarmcount++;
|
|
if(occr_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus3 &= ~BIT12;
|
|
occr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
occr_alarmcount = 0;
|
|
}
|
|
|
|
//[定时恢复]
|
|
if(bmsMem.mcu_ocr_t != 0xFF) // 255 - 不自动恢复
|
|
{
|
|
occr_alarmcount2++;
|
|
if(occr_alarmcount2 > bmsMem.mcu_ocr_t)
|
|
{
|
|
bmsMem.bStatus3 &= ~BIT12;
|
|
occr_alarmcount2 = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//放电过流1告警释放
|
|
if((bmsMem.bStatus3 & BIT13) != 0)
|
|
{
|
|
if(current <= alarm_ocd1)
|
|
{
|
|
if(((current <= alarm_ocd1) && (bDSGING == 1)) || (bmsMem.packCurrent > 2000)) //特殊解除项：充电电流>2A
|
|
{
|
|
ocd1r_alarmcount++;
|
|
if(ocd1r_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus3 &= ~BIT13;
|
|
ocd1r_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ocd1r_alarmcount = 0;
|
|
}
|
|
|
|
//[定时恢复]
|
|
if(bmsMem.mcu_ocr_t != 0xFF) // 255 - 不自动恢复
|
|
{
|
|
ocd1r_alarmcount2++;
|
|
if(ocd1r_alarmcount2 > bmsMem.mcu_ocr_t)
|
|
{
|
|
bmsMem.bStatus3 &= ~BIT13;
|
|
ocd1r_alarmcount2 = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//电流的保护
|
|
void Trigger_CurProtect(void)
|
|
{
|
|
uint32_t current;
|
|
uint32_t occ,ocd;
|
|
|
|
if(bmsMem.packCurrent >=0)
|
|
{
|
|
current = bmsMem.packCurrent;
|
|
}
|
|
else
|
|
{
|
|
current = -bmsMem.packCurrent;
|
|
}
|
|
|
|
occ = bmsMem.mcu_occ * 1000;
|
|
ocd = bmsMem.mcu_ocd * 1000;
|
|
|
|
|
|
//充电过流
|
|
if((bmsMem.temperaStatus & BIT4) == 0)
|
|
{
|
|
if((current > occ) && (bCHGING==1))
|
|
{
|
|
occ_count++;
|
|
if(occ_count > bmsMem.mcu_occ_t)
|
|
{
|
|
bmsMem.temperaStatus |= BIT4;
|
|
occ_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
occ_count = 0;
|
|
}
|
|
}
|
|
//放电过流1
|
|
if((bmsMem.temperaStatus & BIT5) == 0)
|
|
{
|
|
if((current > ocd) && (bDSGING==1))
|
|
{
|
|
ocd_count++;
|
|
if(ocd_count > bmsMem.mcu_ocd_t)
|
|
{
|
|
bmsMem.temperaStatus |= BIT5;
|
|
ocd_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ocd_count = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//电流的保护释放
|
|
void Release_CurProtect(void)
|
|
{
|
|
uint8_t scr_t = (bmsMem.ee_most_ocrt_pft >> 2) & 0x03; //取bit2-3
|
|
if(scr_t == 0) scr_t = 8;
|
|
else if(scr_t == 1) scr_t = 16;
|
|
else if(scr_t == 2) scr_t = 32;
|
|
else if(scr_t == 3) scr_t = 64;
|
|
|
|
//短路保护自恢复
|
|
if(((bmsMem.bStatus1 & BIT5) != 0) && (sc_close_flag == 0))
|
|
{
|
|
scr_count++;
|
|
if(scr_count > scr_t)
|
|
{
|
|
sc_close_flag = 1;
|
|
scr_count = 0;
|
|
}
|
|
}
|
|
//充电过流/放电过流1/放电过流2保护释放[定时恢复]
|
|
if(((bmsMem.temperaStatus & BIT4) != 0) || ((bmsMem.temperaStatus & BIT5) != 0) || ((bmsMem.bStatus1 & BIT10) != 0))
|
|
{
|
|
if(bmsMem.mcu_ocr_t != 0xFF) // 255 - 不自动恢复
|
|
{
|
|
ocr_count++;
|
|
if(ocr_count > bmsMem.mcu_ocr_t)
|
|
{
|
|
//充电过流释放
|
|
bmsMem.temperaStatus &= ~BIT4;
|
|
//放电过流1释放
|
|
bmsMem.temperaStatus &= ~BIT5;
|
|
//放电过流2释放
|
|
bmsMem.bStatus1 &= ~BIT10;
|
|
|
|
ocr_count = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//充电过流保护释放[放电解除]
|
|
if((bmsMem.temperaStatus & BIT4) != 0)
|
|
{
|
|
if(bmsMem.packCurrent < -2000) //特殊解除项：充电电流>2A
|
|
{
|
|
//充电过流释放
|
|
bmsMem.temperaStatus &= ~BIT4;
|
|
}
|
|
}
|
|
//放电过流1保护释放[充电解除]
|
|
if((bmsMem.temperaStatus & BIT5) != 0)
|
|
{
|
|
if(bmsMem.packCurrent > 2000) //特殊解除项：充电电流>2A
|
|
{
|
|
//放电过流1释放
|
|
bmsMem.temperaStatus &= ~BIT5;
|
|
}
|
|
}
|
|
//放电过流2保护释放[充电解除]
|
|
if((bmsMem.bStatus1 & BIT10) != 0)
|
|
{
|
|
if(bmsMem.packCurrent > 2000) //特殊解除项：充电电流>2A
|
|
{
|
|
//放电过流2释放
|
|
bmsMem.bStatus1 &= ~BIT10;
|
|
}
|
|
}
|
|
}
|
|
|
|
//电流保护的次数超限锁定
|
|
void Trigger_CurProtectLock(void)
|
|
{
|
|
// //充电过流保护出现
|
|
// if((bmsMem.temperaStatus & BIT4) != 0)
|
|
// {
|
|
// //刚出现时
|
|
// if(occ_OccurFlag == 0)
|
|
// {
|
|
// occ_OccurFlag = 1;
|
|
//
|
|
// //分析是否满足锁定条件
|
|
// if(occ_RepeatFlag == 0) //此前并未连续出现
|
|
// {
|
|
// occ_RepeatFlag = 1; //“充电过流保护60s内出现过”的标志，用于在消失后的计时判断
|
|
// }
|
|
// else
|
|
// {
|
|
// occ_RepeatCount++; //充电过流保护持续60s不出现的话，occ_OccurFlag会置0，所以这时候存在值1，说明是在60s内出现的，计数次数+1
|
|
// }
|
|
//
|
|
// if(occ_RepeatCount+1 >= 10) //当计数达到9时(即连续发生了十次充电过流保护)，直接锁定，“充电过流保护”持续显示，持续关闭MOS
|
|
// {
|
|
// occ_RepeatCount = 0;
|
|
// bmsMem.balanceStatus |= BIT10; //充电过流保护锁定启用，只有重启和写MOS控制可清零
|
|
// }
|
|
// }
|
|
// }
|
|
// //充电过流保护消失
|
|
// else
|
|
// {
|
|
// occ_OccurFlag = 0;
|
|
//
|
|
// //充电过流保护出现后又消失，若在60s内监测到充电过流保护不开启则计数恢复0，否则计数+1
|
|
// if(occ_RepeatFlag == 1)
|
|
// {
|
|
// occ_RepeatTime++;
|
|
// if(occ_RepeatTime > 60) //持续60s
|
|
// {
|
|
// occ_RepeatFlag = 0; //“充电过流保护60s内出现过”的标志置0
|
|
// occ_RepeatCount = 0; //连续出现计数清零
|
|
// occ_RepeatTime = 0; //倒计时清零
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// occ_RepeatTime = 0;
|
|
// }
|
|
// }
|
|
//
|
|
// //放电过流1保护出现
|
|
// if((bmsMem.temperaStatus & BIT5) != 0)
|
|
// {
|
|
// //刚出现时
|
|
// if(ocd1_OccurFlag == 0)
|
|
// {
|
|
// ocd1_OccurFlag = 1;
|
|
//
|
|
// //分析是否满足锁定条件
|
|
// if(ocd1_RepeatFlag == 0) //此前并未连续出现
|
|
// {
|
|
// ocd1_RepeatFlag = 1; //“放电过流1保护60s内出现过”的标志，用于在消失后的计时判断
|
|
// }
|
|
// else
|
|
// {
|
|
// ocd1_RepeatCount++; //放电过流1保护持续60s不出现的话，ocd1_OccurFlag会置0，所以这时候存在值1，说明是在60s内出现的，计数次数+1
|
|
// }
|
|
//
|
|
// if(ocd1_RepeatCount+1 >= 10) //当计数达到9时(即连续发生了十次放电过流1保护)，直接锁定，“放电过流1保护”持续显示，持续关闭MOS
|
|
// {
|
|
// ocd1_RepeatCount = 0;
|
|
// bmsMem.balanceStatus |= BIT9; //放电过流1保护锁定启用，只有重启和写MOS控制可清零
|
|
// }
|
|
// }
|
|
// }
|
|
// //放电过流1保护消失
|
|
// else
|
|
// {
|
|
// ocd1_OccurFlag = 0;
|
|
//
|
|
// //放电过流1保护出现后又消失，若在60s内监测到放电过流1保护不开启则计数恢复0，否则计数+1
|
|
// if(ocd1_RepeatFlag == 1)
|
|
// {
|
|
// ocd1_RepeatTime++;
|
|
// if(ocd1_RepeatTime > 60) //持续60s
|
|
// {
|
|
// ocd1_RepeatFlag = 0; //“放电过流1保护60s内出现过”的标志置0
|
|
// ocd1_RepeatCount = 0; //连续出现计数清零
|
|
// ocd1_RepeatTime = 0; //倒计时清零
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// ocd1_RepeatTime = 0;
|
|
// }
|
|
// }
|
|
//
|
|
// //放电过流2保护出现
|
|
// if((bmsMem.bStatus1 & BIT10) != 0)
|
|
// {
|
|
// //刚出现时
|
|
// if(ocd2_OccurFlag == 0)
|
|
// {
|
|
// ocd2_OccurFlag = 1;
|
|
//
|
|
// //分析是否满足锁定条件
|
|
// if(ocd2_RepeatFlag == 0) //此前并未连续出现
|
|
// {
|
|
// ocd2_RepeatFlag = 1; //“放电过流2保护60s内出现过”的标志，用于在消失后的计时判断
|
|
// }
|
|
// else
|
|
// {
|
|
// ocd2_RepeatCount++; //放电过流2保护持续60s不出现的话，ocd2_OccurFlag会置0，所以这时候存在值1，说明是在60s内出现的，计数次数+1
|
|
// }
|
|
//
|
|
// if(ocd2_RepeatCount+1 >= 3) //当计数达到2时(即连续发生了三次放电过流2保护)，直接锁定，“放电过流2保护”持续显示，持续关闭MOS
|
|
// {
|
|
// ocd2_RepeatCount = 0;
|
|
// bmsMem.balanceStatus |= BIT8; //放电过流2保护锁定启用，只有重启和写MOS控制可清零
|
|
// }
|
|
// }
|
|
// }
|
|
// //放电过流2保护消失
|
|
// else
|
|
// {
|
|
// ocd2_OccurFlag = 0;
|
|
//
|
|
// //放电过流2保护出现后又消失，若在60s内监测到放电过流2保护不开启则计数恢复0，否则计数+1
|
|
// if(ocd2_RepeatFlag == 1)
|
|
// {
|
|
// ocd2_RepeatTime++;
|
|
// if(ocd2_RepeatTime > 60) //持续60s
|
|
// {
|
|
// ocd2_RepeatFlag = 0; //“放电过流2保护60s内出现过”的标志置0
|
|
// ocd2_RepeatCount = 0; //连续出现计数清零
|
|
// ocd2_RepeatTime = 0; //倒计时清零
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// ocd2_RepeatTime = 0;
|
|
// }
|
|
// }
|
|
|
|
//浪涌短路和真短路，与预充相关，次数计算在别处执行
|
|
}
|
|
|
|
//电芯温度的告警
|
|
void Trigger_mcuTAlarm(void)
|
|
{
|
|
uint16_t alarm_otc,alarm_utc,alarm_otd,alarm_utd;
|
|
|
|
alarm_otc = paraMem.alarm_mcu_otc * 10 + 2731;
|
|
alarm_utc = paraMem.alarm_mcu_utc * 10 + 2731;
|
|
alarm_otd = paraMem.alarm_mcu_otd * 10 + 2731;
|
|
alarm_utd = paraMem.alarm_mcu_utd * 10 + 2731;
|
|
|
|
if(bmsMem.packCurrent > (-500)) //非放电状态下
|
|
{
|
|
//电芯充电高温告警
|
|
if((bmsMem.bStatus2 & BIT12) == 0)
|
|
{
|
|
if(TemperatureMax > alarm_otc)
|
|
{
|
|
mcuotc_alarmcount++;
|
|
if(mcuotc_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 |= BIT12;
|
|
mcuotc_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mcuotc_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
//电芯充电低温告警
|
|
if((bmsMem.bStatus2 & BIT14) == 0)
|
|
{
|
|
if(TemperatureMin < alarm_utc)
|
|
{
|
|
mcuutc_alarmcount++;
|
|
if(mcuutc_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 |= BIT14;
|
|
mcuutc_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mcuutc_alarmcount = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT12;
|
|
bmsMem.bStatus2 &= ~BIT14;
|
|
}
|
|
|
|
if(bmsMem.packCurrent < 500) //非充电状态下
|
|
{
|
|
//电芯放电高温告警
|
|
if((bmsMem.bStatus2 & BIT13) == 0)
|
|
{
|
|
if(TemperatureMax > alarm_otd)
|
|
{
|
|
mcuotd_alarmcount++;
|
|
if(mcuotd_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 |= BIT13;
|
|
mcuotd_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mcuotd_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
//电芯放电低温告警
|
|
if((bmsMem.bStatus2 & BIT15) == 0)
|
|
{
|
|
if(TemperatureMin < alarm_utd)
|
|
{
|
|
mcuutd_alarmcount++;
|
|
if(mcuutd_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 |= BIT15;
|
|
mcuutd_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mcuutd_alarmcount = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT13;
|
|
bmsMem.bStatus2 &= ~BIT15;
|
|
}
|
|
}
|
|
|
|
//电芯温度的告警释放
|
|
void Release_mcuTAlarm(void)
|
|
{
|
|
uint16_t otcr,utcr,otdr,utdr;
|
|
|
|
otcr = bmsMem.mcu_otcr * 10 + 2731;
|
|
utcr = bmsMem.mcu_utcr * 10 + 2731;
|
|
otdr = bmsMem.mcu_otdr * 10 + 2731;
|
|
utdr = bmsMem.mcu_utdr * 10 + 2731;
|
|
|
|
|
|
//电芯充电高温告警恢复判断
|
|
if((bmsMem.bStatus2 & BIT12) != 0)
|
|
{
|
|
if(TemperatureMax <= otcr)
|
|
{
|
|
mcuotcr_alarmcount++;
|
|
if(mcuotcr_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT12;
|
|
mcuotcr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mcuotcr_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
//电芯充电低温告警恢复判断
|
|
if((bmsMem.bStatus2 & BIT14) != 0)
|
|
{
|
|
if(TemperatureMin >= utcr)
|
|
{
|
|
mcuutcr_alarmcount++;
|
|
if(mcuutcr_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT14;
|
|
mcuutcr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mcuutcr_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
//电芯放电高温告警恢复判断
|
|
if((bmsMem.bStatus2 & BIT13) != 0)
|
|
{
|
|
if(TemperatureMax <= otdr)
|
|
{
|
|
mcuotdr_alarmcount++;
|
|
if(mcuotdr_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT13;
|
|
mcuotdr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mcuotdr_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
//电芯放电低温告警恢复判断
|
|
if((bmsMem.bStatus2 & BIT15) != 0)
|
|
{
|
|
if(TemperatureMin >= utdr)
|
|
{
|
|
mcuutdr_alarmcount++;
|
|
if(mcuutdr_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT15;
|
|
mcuutdr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mcuutdr_alarmcount = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//电芯温度的保护
|
|
void Trigger_mcuTProtect(void)
|
|
{
|
|
uint16_t otc,utc,otd,utd;
|
|
|
|
otc = bmsMem.mcu_otc * 10 + 2731;
|
|
utc = bmsMem.mcu_utc * 10 + 2731;
|
|
otd = bmsMem.mcu_otd * 10 + 2731;
|
|
utd = bmsMem.mcu_utd * 10 + 2731;
|
|
|
|
|
|
if(bmsMem.packCurrent > (-500)) //非放电状态下
|
|
{
|
|
//充电高温保护
|
|
if((bmsMem.temperaStatus & BIT0) == 0) // 没有发生充电高温保护
|
|
{
|
|
if(TemperatureMax > otc)
|
|
{
|
|
chg_htp_count++;
|
|
if(chg_htp_count > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT0; //连续发生过温，保护
|
|
chg_htp_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
chg_htp_count = 0;
|
|
}
|
|
}
|
|
|
|
//充电低温保护
|
|
if((bmsMem.temperaStatus & BIT2) == 0) // 没有发生充电低温保护
|
|
{
|
|
#if DO2_Warm
|
|
if((TemperatureMin < utc) && (bCHGING == 1))
|
|
#else
|
|
if(TemperatureMin < utc)
|
|
#endif
|
|
{
|
|
chg_ltp_count++;
|
|
if(chg_ltp_count > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT2; //连续发生低温，保护
|
|
chg_ltp_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
chg_ltp_count = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT0;
|
|
bmsMem.temperaStatus &= ~BIT2;
|
|
}
|
|
|
|
if(bmsMem.packCurrent < 500) //非充电状态下
|
|
{
|
|
//放电高温保护
|
|
if((bmsMem.temperaStatus & BIT1) == 0) // 没有发生放电高温保护
|
|
{
|
|
if(TemperatureMax > otd)
|
|
{
|
|
dsg_htp_count++;
|
|
if(dsg_htp_count > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT1; //连续发生过温，保护
|
|
dsg_htp_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dsg_htp_count = 0;
|
|
}
|
|
}
|
|
|
|
//放电低温保护
|
|
if((bmsMem.temperaStatus & BIT3) == 0) // 没有发生放电低温保护
|
|
{
|
|
if(TemperatureMin < utd)
|
|
{
|
|
dsg_ltp_count++;
|
|
if(dsg_ltp_count > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT3; //连续发生低温，保护
|
|
dsg_ltp_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dsg_ltp_count = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT1;
|
|
bmsMem.temperaStatus &= ~BIT3;
|
|
}
|
|
}
|
|
|
|
//电芯温度的保护释放
|
|
void Release_mcuTProtect(void)
|
|
{
|
|
uint16_t otcr,utcr,otdr,utdr;
|
|
|
|
otcr = bmsMem.mcu_otcr * 10 + 2731;
|
|
utcr = bmsMem.mcu_utcr * 10 + 2731;
|
|
otdr = bmsMem.mcu_otdr * 10 + 2731;
|
|
utdr = bmsMem.mcu_utdr * 10 + 2731;
|
|
|
|
|
|
//充电高温保护释放
|
|
if((bmsMem.temperaStatus & BIT0) != 0) // 发生充电高温保护
|
|
{
|
|
if(TemperatureMax < otcr)
|
|
{
|
|
chg_htpr_count++;
|
|
if(chg_htpr_count > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT0;
|
|
chg_htpr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
chg_htpr_count = 0;
|
|
}
|
|
}
|
|
|
|
//充电低温保护释放
|
|
if((bmsMem.temperaStatus & BIT2) != 0) // 发生充电低温保护
|
|
{
|
|
if(TemperatureMin > utcr)
|
|
{
|
|
chg_ltpr_count++;
|
|
if(chg_ltpr_count > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT2;
|
|
chg_ltpr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
chg_ltpr_count = 0;
|
|
}
|
|
}
|
|
|
|
//放电高温保护释放
|
|
if((bmsMem.temperaStatus & BIT1) != 0) // 发生放电高温保护
|
|
{
|
|
if(TemperatureMax < otdr)
|
|
{
|
|
dsg_htpr_count++;
|
|
if(dsg_htpr_count > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT1; //连续发生过温，保护
|
|
dsg_htpr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dsg_htpr_count = 0;
|
|
}
|
|
}
|
|
|
|
//放电低温保护释放
|
|
if((bmsMem.temperaStatus & BIT3) != 0) // 发生放电低温保护
|
|
{
|
|
if(TemperatureMin > utdr)
|
|
{
|
|
dsg_ltpr_count++;
|
|
if(dsg_ltpr_count > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT3;
|
|
dsg_ltpr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dsg_ltpr_count = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//环境温度的告警
|
|
void Trigger_amTAlarm(void)
|
|
{
|
|
uint16_t alarm_otc,alarm_utc,alarm_otd,alarm_utd;
|
|
|
|
//针对bmsMem.afe_T3，进行环境温度告警和告警释放
|
|
alarm_otc = paraMem.alarm_am_otc * 10 + 2731;
|
|
alarm_utc = paraMem.alarm_am_utc * 10 + 2731;
|
|
alarm_otd = paraMem.alarm_am_otd * 10 + 2731;
|
|
alarm_utd = paraMem.alarm_am_utd * 10 + 2731;
|
|
|
|
if(bmsMem.packCurrent > (-500)) //非放电状态下
|
|
{
|
|
//环境充电高温告警
|
|
if((bmsMem.temperaStatus & BIT12) == 0)
|
|
{
|
|
if(bmsMem.afe_T3 > alarm_otc)
|
|
{
|
|
am_otc_alarmcount++;
|
|
if(am_otc_alarmcount > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT12;
|
|
am_otc_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_otc_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
//环境充电低温告警
|
|
if((bmsMem.temperaStatus & BIT14) == 0)
|
|
{
|
|
if(bmsMem.afe_T3 < alarm_utc)
|
|
{
|
|
am_utc_alarmcount++;
|
|
if(am_utc_alarmcount > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT14;
|
|
am_utc_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_utc_alarmcount = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT12;
|
|
bmsMem.temperaStatus &= ~BIT14;
|
|
}
|
|
|
|
if(bmsMem.packCurrent < 500) //非充电状态下
|
|
{
|
|
//环境放电高温告警
|
|
if((bmsMem.temperaStatus & BIT13) == 0) // 没有发生放电高温保护
|
|
{
|
|
if(bmsMem.afe_T3 > alarm_otd)
|
|
{
|
|
am_otd_alarmcount++;
|
|
if(am_otd_alarmcount > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT13; //连续发生过温，保护
|
|
am_otd_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_otd_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
//环境放电低温告警
|
|
if((bmsMem.temperaStatus & BIT15) == 0) // 没有发生放电低温保护
|
|
{
|
|
if(bmsMem.afe_T3 < alarm_utd)
|
|
{
|
|
am_utd_alarmcount++;
|
|
if(am_utd_alarmcount > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT15; //连续发生低温，保护
|
|
am_utd_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_utd_alarmcount = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT13;
|
|
bmsMem.temperaStatus &= ~BIT15;
|
|
}
|
|
}
|
|
|
|
//环境温度的告警释放
|
|
void Release_amTAlarm(void)
|
|
{
|
|
uint16_t otcr,utcr,otdr,utdr;
|
|
|
|
otcr = paraMem.am_otcr * 10 + 2731;
|
|
utcr = paraMem.am_utcr * 10 + 2731;
|
|
otdr = paraMem.am_otdr * 10 + 2731;
|
|
utdr = paraMem.am_utdr * 10 + 2731;
|
|
|
|
|
|
//环境充电高温告警
|
|
if((bmsMem.temperaStatus & BIT12) !=0)
|
|
{
|
|
if(bmsMem.afe_T3 <= otcr)
|
|
{
|
|
am_otcr_alarmcount++;
|
|
if(am_otcr_alarmcount > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT12;
|
|
am_otcr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_otcr_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
//环境充电低温告警
|
|
if((bmsMem.temperaStatus & BIT14) !=0)
|
|
{
|
|
if(bmsMem.afe_T3 >= utcr)
|
|
{
|
|
am_utcr_alarmcount++;
|
|
if(am_utcr_alarmcount > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT14;
|
|
am_utcr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_utcr_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
//环境放电高温告警
|
|
if((bmsMem.temperaStatus & BIT13) !=0) // 没有发生放电高温保护
|
|
{
|
|
if(bmsMem.afe_T3 <= otdr)
|
|
{
|
|
am_otdr_alarmcount++;
|
|
if(am_otdr_alarmcount > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT13; //连续发生过温，保护
|
|
am_otdr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_otdr_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
//环境放电低温告警
|
|
if((bmsMem.temperaStatus & BIT15) !=0) // 没有发生放电低温保护
|
|
{
|
|
if(bmsMem.afe_T3 >= utdr)
|
|
{
|
|
am_utdr_alarmcount++;
|
|
if(am_utdr_alarmcount > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT15; //连续发生低温，保护
|
|
am_utdr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_utdr_alarmcount = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//环境温度的保护
|
|
void Trigger_amTProtect(void)
|
|
{
|
|
uint16_t otc,utc,otd,utd;
|
|
|
|
otc = paraMem.am_otc * 10 + 2731;
|
|
utc = paraMem.am_utc * 10 + 2731;
|
|
otd = paraMem.am_otd * 10 + 2731;
|
|
utd = paraMem.am_utd * 10 + 2731;
|
|
|
|
if(bmsMem.packCurrent > (-500)) //非放电状态下
|
|
{
|
|
//充电高温保护
|
|
if((bmsMem.temperaStatus & BIT8) == 0) // 没有发生充电高温保护
|
|
{
|
|
if(bmsMem.afe_T3 > otc)
|
|
{
|
|
am_otc_count++;
|
|
if(am_otc_count > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT8;
|
|
am_otc_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_otc_count = 0;
|
|
}
|
|
}
|
|
|
|
//充电低温保护
|
|
if((bmsMem.temperaStatus & BIT10) == 0) // 没有发生充电低温保护
|
|
{
|
|
if(bmsMem.afe_T3 < utc)
|
|
{
|
|
am_utc_count++;
|
|
if(am_utc_count > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT10;
|
|
am_utc_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_utc_count = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT8;
|
|
bmsMem.temperaStatus &= ~BIT10;
|
|
}
|
|
|
|
if(bmsMem.packCurrent < 500) //非充电状态下
|
|
{
|
|
//放电高温保护
|
|
if((bmsMem.temperaStatus & BIT9) == 0) // 没有发生放电高温保护
|
|
{
|
|
if(bmsMem.afe_T3 > otd)
|
|
{
|
|
am_otd_count++;
|
|
if(am_otd_count > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT9;
|
|
am_otd_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_otd_count = 0;
|
|
}
|
|
}
|
|
|
|
//放电低温保护
|
|
if((bmsMem.temperaStatus & BIT11) == 0) // 没有发生放电低温保护
|
|
{
|
|
if(bmsMem.afe_T3 < utd)
|
|
{
|
|
am_utd_count++;
|
|
if(am_utd_count > 3)
|
|
{
|
|
bmsMem.temperaStatus |= BIT11;
|
|
am_utd_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_utd_count = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT9;
|
|
bmsMem.temperaStatus &= ~BIT11;
|
|
}
|
|
}
|
|
|
|
//环境温度的保护释放
|
|
void Release_amTProtect(void)
|
|
{
|
|
uint16_t otcr,utcr,otdr,utdr;
|
|
|
|
otcr = paraMem.am_otcr * 10 + 2731;
|
|
utcr = paraMem.am_utcr * 10 + 2731;
|
|
otdr = paraMem.am_otdr * 10 + 2731;
|
|
utdr = paraMem.am_utdr * 10 + 2731;
|
|
|
|
|
|
//充电高温保护释放
|
|
if((bmsMem.temperaStatus & BIT8) != 0) // 发生充电高温保护
|
|
{
|
|
if(bmsMem.afe_T3 < otcr)
|
|
{
|
|
am_otcr_count++;
|
|
if(am_otcr_count > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT8;
|
|
am_otcr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_otcr_count = 0;
|
|
}
|
|
}
|
|
|
|
//充电低温保护释放
|
|
if((bmsMem.temperaStatus & BIT10) != 0) // 发生充电低温保护
|
|
{
|
|
if(bmsMem.afe_T3 > utcr)
|
|
{
|
|
am_utcr_count++;
|
|
if(am_utcr_count > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT10;
|
|
am_utcr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_utcr_count = 0;
|
|
}
|
|
}
|
|
|
|
//放电高温保护释放
|
|
if((bmsMem.temperaStatus & BIT9) != 0) // 发生放电高温保护
|
|
{
|
|
if(bmsMem.afe_T3 < otdr)
|
|
{
|
|
am_otdr_count++;
|
|
if(am_otdr_count > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT9;
|
|
am_otdr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_otdr_count = 0;
|
|
}
|
|
}
|
|
|
|
//放电低温保护释放
|
|
if((bmsMem.temperaStatus & BIT11) != 0) // 发生放电低温保护
|
|
{
|
|
if(bmsMem.afe_T3 > utdr)
|
|
{
|
|
am_utdr_count++;
|
|
if(am_utdr_count > 3)
|
|
{
|
|
bmsMem.temperaStatus &= ~BIT11;
|
|
am_utdr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
am_utdr_count = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//MOS温度的告警
|
|
void Trigger_afeTAlarm(void)
|
|
{
|
|
uint16_t alarm_afe_otc; //,alarm_afe_utc;
|
|
uint16_t alarm_afe_otd; //,alarm_afe_utd;
|
|
|
|
alarm_afe_otc = paraMem.alarm_afe_otc * 10 + 2731;
|
|
//alarm_afe_utc = paraMem.alarm_afe_utc * 10 + 2731;
|
|
alarm_afe_otd = paraMem.alarm_afe_otd * 10 + 2731;
|
|
//alarm_afe_utd = paraMem.alarm_afe_utd * 10 + 2731;
|
|
|
|
if(bmsMem.packCurrent > (-500)) //非放电状态下
|
|
{
|
|
//MOS充电高温告警
|
|
if((bmsMem.bStatus2 & BIT8) == 0)
|
|
{
|
|
if((bmsMem.afe_T1 > alarm_afe_otc) || (bmsMem.afe_T2 > alarm_afe_otc))
|
|
{
|
|
afeotc_alarmcount++;
|
|
if(afeotc_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 |= BIT8;
|
|
afeotc_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
afeotc_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
// //MOS充电低温告警
|
|
// if((bmsMem.bStatus2 & BIT10) == 0)
|
|
// {
|
|
// if((bmsMem.afe_T1 < alarm_afe_utc) || (bmsMem.afe_T2 < alarm_afe_utc))
|
|
// {
|
|
// afeutc_alarmcount++;
|
|
// if(afeutc_alarmcount > 3)
|
|
// {
|
|
// bmsMem.bStatus2 |= BIT10;
|
|
// afeutc_alarmcount = 0;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// afeutc_alarmcount = 0;
|
|
// }
|
|
// }
|
|
}
|
|
else
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT8;
|
|
// bmsMem.bStatus2 &= ~BIT10;
|
|
}
|
|
|
|
if(bmsMem.packCurrent < 500) //非充电状态下
|
|
{
|
|
//MOS放电高温告警
|
|
if((bmsMem.bStatus2 & BIT9) == 0) // 没有发生放电高温保护
|
|
{
|
|
if((bmsMem.afe_T1 > alarm_afe_otd) || (bmsMem.afe_T2 > alarm_afe_otd))
|
|
{
|
|
afeotd_alarmcount++;
|
|
if(afeotd_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 |= BIT9; //连续发生过温，保护
|
|
afeotd_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
afeotd_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
// //MOS放电低温告警
|
|
// if((bmsMem.bStatus2 & BIT11) == 0) // 没有发生放电低温保护
|
|
// {
|
|
// if((bmsMem.afe_T1 < alarm_afe_utd) || (bmsMem.afe_T2 < alarm_afe_utd))
|
|
// {
|
|
// afeutd_alarmcount++;
|
|
// if(afeutd_alarmcount > 3)
|
|
// {
|
|
// bmsMem.bStatus2 |= BIT11; //连续发生低温，保护
|
|
// afeutd_alarmcount = 0;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// afeutd_alarmcount = 0;
|
|
// }
|
|
// }
|
|
}
|
|
else
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT9;
|
|
// bmsMem.bStatus2 &= ~BIT11;
|
|
}
|
|
}
|
|
|
|
//MOS温度的告警释放
|
|
void Release_afeTAlarm(void)
|
|
{
|
|
uint16_t afe_otcr; //,afe_utcr;
|
|
uint16_t afe_otdr; //,afe_utdr;
|
|
|
|
afe_otcr = bmsMem.otcr * 10 + 2731;
|
|
//afe_utcr = bmsMem.utcr * 10 + 2731;
|
|
afe_otdr = bmsMem.otdr * 10 + 2731;
|
|
//afe_utdr = bmsMem.utdr * 10 + 2731;
|
|
|
|
|
|
//MOS充电高温告警恢复
|
|
if((bmsMem.bStatus2 & BIT8) != 0)
|
|
{
|
|
if((bmsMem.afe_T1 <= afe_otcr) && (bmsMem.afe_T2 <= afe_otcr))
|
|
{
|
|
afeotcr_alarmcount++;
|
|
if(afeotcr_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT8;
|
|
afeotcr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
afeotcr_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
// //MOS充电低温告警恢复
|
|
// if((bmsMem.bStatus2 & BIT10) != 0)
|
|
// {
|
|
// if((bmsMem.afe_T1 >= afe_utcr) && (bmsMem.afe_T2 >= afe_utcr))
|
|
// {
|
|
// afeutcr_alarmcount++;
|
|
// if(afeutcr_alarmcount > 3)
|
|
// {
|
|
// bmsMem.bStatus2 &= ~BIT10;
|
|
// afeutcr_alarmcount = 0;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// afeutcr_alarmcount = 0;
|
|
// }
|
|
// }
|
|
|
|
//MOS放电高温告警恢复
|
|
if((bmsMem.bStatus2 & BIT9) != 0) // 没有发生放电高温保护
|
|
{
|
|
if((bmsMem.afe_T1 <= afe_otdr) && (bmsMem.afe_T2 <= afe_otdr))
|
|
{
|
|
afeotdr_alarmcount++;
|
|
if(afeotdr_alarmcount > 3)
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT9; //连续发生过温，保护
|
|
afeotdr_alarmcount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
afeotdr_alarmcount = 0;
|
|
}
|
|
}
|
|
|
|
// //MOS放电低温告警恢复
|
|
// if((bmsMem.bStatus2 & BIT11) != 0) // 没有发生放电低温保护
|
|
// {
|
|
// if((bmsMem.afe_T1 >= afe_utdr) && (bmsMem.afe_T2 >= afe_utdr))
|
|
// {
|
|
// afeutdr_alarmcount++;
|
|
// if(afeutdr_alarmcount > 3)
|
|
// {
|
|
// bmsMem.bStatus2 &= ~BIT11; //连续发生低温，保护
|
|
// afeutdr_alarmcount = 0;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// afeutdr_alarmcount = 0;
|
|
// }
|
|
// }
|
|
}
|
|
|
|
//MOS温度的保护
|
|
void Trigger_afeTProtect(void)
|
|
{
|
|
uint16_t afe_otc;
|
|
uint16_t afe_otd;
|
|
|
|
afe_otc = bmsMem.otc * 10 + 2731;
|
|
afe_otd = bmsMem.otd * 10 + 2731;
|
|
|
|
if(bmsMem.packCurrent > (-500)) //非放电状态下
|
|
{
|
|
//MOS充电高温保护
|
|
if((bmsMem.bStatus2 & BIT1) == 0)
|
|
{
|
|
if((bmsMem.afe_T1 > afe_otc) || (bmsMem.afe_T2 > afe_otc))
|
|
{
|
|
afeotc_count++;
|
|
if(afeotc_count > 3)
|
|
{
|
|
bmsMem.bStatus2 |= BIT1;
|
|
afeotc_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
afeotc_count = 0;
|
|
}
|
|
}
|
|
// //MOS充电低温保护
|
|
// if((bmsMem.bStatus2 & BIT0) == 0)
|
|
// {
|
|
// if((bmsMem.afe_T1 < afe_utc) || (bmsMem.afe_T2 < afe_utc))
|
|
// {
|
|
// afeutc_count++;
|
|
// if(afeutc_count > 3)
|
|
// {
|
|
// bmsMem.bStatus2 |= BIT0;
|
|
// afeutc_count = 0;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// afeutc_count = 0;
|
|
// }
|
|
// }
|
|
}
|
|
else
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT1;
|
|
// bmsMem.bStatus2 &= ~BIT0;
|
|
}
|
|
|
|
if(bmsMem.packCurrent < 500) //非充电状态下
|
|
{
|
|
//MOS放电高温保护
|
|
if((bmsMem.bStatus2 & BIT3) == 0) // 没有发生放电高温保护
|
|
{
|
|
if((bmsMem.afe_T1 > afe_otd) || (bmsMem.afe_T2 > afe_otd))
|
|
{
|
|
afeotd_count++;
|
|
if(afeotd_count > 3)
|
|
{
|
|
bmsMem.bStatus2 |= BIT3; //连续发生过温，保护
|
|
afeotd_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
afeotd_count = 0;
|
|
}
|
|
}
|
|
// //MOS放电低温保护
|
|
// if((bmsMem.bStatus2 & BIT2) == 0) // 没有发生放电低温保护
|
|
// {
|
|
// if((bmsMem.afe_T1 < afe_utd) || (bmsMem.afe_T2 < afe_utd))
|
|
// {
|
|
// afeutd_count++;
|
|
// if(afeutd_count > 3)
|
|
// {
|
|
// bmsMem.bStatus2 |= BIT2; //连续发生低温，保护
|
|
// afeutd_count = 0;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// afeutd_count = 0;
|
|
// }
|
|
// }
|
|
}
|
|
else
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT3;
|
|
// bmsMem.bStatus2 &= ~BIT2;
|
|
}
|
|
}
|
|
|
|
//MOS温度的保护释放
|
|
void Release_afeTProtect(void)
|
|
{
|
|
uint16_t afe_otcr;
|
|
uint16_t afe_otdr;
|
|
|
|
afe_otcr = bmsMem.otcr * 10 + 2731;
|
|
afe_otdr = bmsMem.otdr * 10 + 2731;
|
|
|
|
|
|
//MOS充电高温保护恢复
|
|
if((bmsMem.bStatus2 & BIT1) != 0)
|
|
{
|
|
if((bmsMem.afe_T1 <= afe_otcr) && (bmsMem.afe_T2 <= afe_otcr))
|
|
{
|
|
afeotcr_count++;
|
|
if(afeotcr_count > 3)
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT1;
|
|
afeotcr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
afeotcr_count = 0;
|
|
}
|
|
}
|
|
|
|
//MOS放电高温保护恢复
|
|
if((bmsMem.bStatus2 & BIT3) != 0) // 没有发生放电高温保护
|
|
{
|
|
if((bmsMem.afe_T1 <= afe_otdr) && (bmsMem.afe_T2 <= afe_otdr))
|
|
{
|
|
afeotdr_count++;
|
|
if(afeotdr_count > 3)
|
|
{
|
|
bmsMem.bStatus2 &= ~BIT3; //连续发生过温，保护
|
|
afeotdr_count = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
afeotdr_count = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if LTE_Conn
|
|
//存放事件记录：广泛可用，又防止意外写错
|
|
uint8_t Protect[21] =
|
|
{
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
|
|
0x30, 0x31, 0x32, 0x33, 0x34,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49
|
|
};
|
|
|
|
void Write_Change(uint8_t code)
|
|
{
|
|
uint8_t i;
|
|
|
|
staChange_time[staChange_num] = timecount;
|
|
staChange[staChange_num] = code;
|
|
staChange_num++;
|
|
|
|
//确认该次事件的优先级
|
|
incident_DataInf = 1;
|
|
for(i=0;i<21;i++)
|
|
{
|
|
if(code == Protect[i]) //遍历保护
|
|
{
|
|
incident_DataInf = 2;
|
|
}
|
|
}
|
|
|
|
//保存此时的属性，若连续发生多个，只能记住第1个
|
|
//优先级：保护触发>其他
|
|
if((incident_DataFlg < 2) && (incident_DataInf == 2))
|
|
{
|
|
incident_DataFlg = 2;
|
|
LTE_Record_pubData();
|
|
}
|
|
else if((incident_DataFlg < 1) && (incident_DataInf == 1))
|
|
{
|
|
incident_DataFlg = 1;
|
|
LTE_Record_pubData();
|
|
}
|
|
}
|
|
|
|
//事件[发生和释放]的判断与记录
|
|
//code: 记录事件的对应码
|
|
void Check_Change(uint8_t STA_i, uint16_t BIT_n, uint8_t code)
|
|
{
|
|
if((status_Old[STA_i] & BIT_n) == 0)
|
|
{
|
|
if((status_New[STA_i] & BIT_n) != 0) //事件触发，未记录
|
|
{
|
|
status_Old[STA_i] |= BIT_n;
|
|
Write_Change(code);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if((status_New[STA_i] & BIT_n) == 0) //事件消失，恢复标志位
|
|
{
|
|
status_Old[STA_i] &= ~BIT_n;
|
|
Write_Change(code+0x80);
|
|
}
|
|
}
|
|
}
|
|
|
|
//事件[发生]的判断与记录，释放直接释放
|
|
//code: 记录事件的对应码
|
|
void Check_OnlyOn(uint8_t STA_i, uint16_t BIT_n, uint8_t code)
|
|
{
|
|
if((status_Old[STA_i] & BIT_n) == 0)
|
|
{
|
|
if((status_New[STA_i] & BIT_n) != 0) //事件触发，未记录
|
|
{
|
|
status_Old[STA_i] |= BIT_n;
|
|
Write_Change(code);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if((status_New[STA_i] & BIT_n) == 0) //事件消失，恢复标志位
|
|
{
|
|
status_Old[STA_i] &= ~BIT_n;
|
|
}
|
|
}
|
|
}
|
|
|
|
//应上报的状态转变的判断
|
|
void Check_staChange(void)
|
|
{
|
|
//Check_OnlyOn(0, BIT1, 0x01); //充电状态
|
|
//Check_OnlyOn(0, BIT2, 0x02); //放电状态
|
|
Check_Change(0, BIT3, 0x03); //预充状态
|
|
Check_Change(0, BIT4, 0x04); //充电MOS状态
|
|
Check_Change(0, BIT5, 0x05); //放电MOS状态
|
|
//Check_Change(0, BIT6, 0x06); //预充MOS状态
|
|
Check_Change(0, BIT7, 0x07); //充电限流状态
|
|
//Check_Change(0, BIT8, 0x08); //均衡控制状态
|
|
|
|
Check_OnlyOn(1, BIT0, 0x10); //充电过流保护多次锁定
|
|
Check_OnlyOn(1, BIT1, 0x11); //放电过流1保护多次锁定
|
|
Check_OnlyOn(1, BIT2, 0x12); //放电过流2保护多次锁定
|
|
Check_OnlyOn(1, BIT3, 0x13); //浪涌保护多次锁定
|
|
Check_OnlyOn(1, BIT4, 0x14); //短路保护多次锁定
|
|
Check_Change(1, BIT5, 0x15); //充电MOS故障
|
|
Check_Change(1, BIT6, 0x16); //放电MOS故障
|
|
Check_Change(1, BIT7, 0x17); //DO脱扣器功能
|
|
Check_Change(1, BIT8, 0x18); //强制关闭欠压保护功能
|
|
}
|
|
|
|
//应上报的的判断
|
|
void Check_protectChange(void)
|
|
{
|
|
Check_Change(2, BIT0, 0x20); //总体过压保护
|
|
Check_Change(2, BIT1, 0x21); //总体欠压保护
|
|
Check_Change(2, BIT2, 0x22); //单体过压保护
|
|
Check_Change(2, BIT3, 0x23); //单体欠压保护
|
|
Check_OnlyOn(2, BIT4, 0x24); //异常高压保护
|
|
Check_OnlyOn(2, BIT5, 0x25); //低电压禁止充电
|
|
|
|
Check_Change(3, BIT0, 0x30); //充电过流保护
|
|
Check_Change(3, BIT1, 0x31); //放电过流1保护
|
|
Check_Change(3, BIT2, 0x32); //放电过流2保护
|
|
Check_Change(3, BIT3, 0x33); //浪涌保护
|
|
Check_Change(3, BIT4, 0x34); //短路保护
|
|
|
|
Check_Change(4, BIT0, 0x40); //电芯充电高温保护
|
|
Check_Change(4, BIT1, 0x41); //电芯放电高温保护
|
|
Check_Change(4, BIT2, 0x42); //电芯充电低温保护
|
|
Check_Change(4, BIT3, 0x43); //电芯放电低温保护
|
|
Check_Change(4, BIT4, 0x44); //环境充电高温保护
|
|
Check_Change(4, BIT5, 0x45); //环境放电高温保护
|
|
Check_Change(4, BIT6, 0x46); //环境充电低温保护
|
|
Check_Change(4, BIT7, 0x47); //环境放电低温保护
|
|
Check_Change(4, BIT8, 0x48); //MOS充电高温保护
|
|
Check_Change(4, BIT9, 0x49); //MOS放电高温保护
|
|
//Check_Change(4, BIT10, 0x4A); //MOS充电低温保护
|
|
//Check_Change(4, BIT11, 0x4B); //MOS放电低温保护
|
|
}
|
|
|
|
//应上报的报警的判断
|
|
void Check_warningChange(void)
|
|
{
|
|
// Check_Change(5, BIT0, 0x50); //总体过压报警
|
|
// Check_Change(5, BIT1, 0x51); //总体欠压报警
|
|
// Check_Change(5, BIT2, 0x52); //单体过压报警
|
|
// Check_Change(5, BIT3, 0x53); //单体欠压报警
|
|
//
|
|
// Check_Change(6, BIT0, 0x60); //充电过流报警
|
|
// Check_Change(6, BIT1, 0x61); //放电过流报警
|
|
//
|
|
// Check_Change(7, BIT0, 0x70); //电芯充电高温报警
|
|
// Check_Change(7, BIT1, 0x71); //电芯放电高温报警
|
|
// Check_Change(7, BIT2, 0x72); //电芯充电低温报警
|
|
// Check_Change(7, BIT3, 0x73); //电芯放电低温报警
|
|
// Check_Change(7, BIT4, 0x74); //环境充电高温报警
|
|
// Check_Change(7, BIT5, 0x75); //环境放电高温报警
|
|
// Check_Change(7, BIT6, 0x76); //环境充电低温报警
|
|
// Check_Change(7, BIT7, 0x77); //环境放电低温报警
|
|
// Check_Change(7, BIT8, 0x78); //MOS充电高温报警
|
|
// Check_Change(7, BIT9, 0x79); //MOS放电高温报警
|
|
// //Check_Change(7, BIT10, 0x7A); //MOS充电低温报警
|
|
// //Check_Change(7, BIT11, 0x7B); //MOS放电低温报警
|
|
}
|
|
|
|
//应上报的告警/保护/故障/加热/状态，转变的判断 每1s执行1次
|
|
void Check_eventChange(void)
|
|
{
|
|
//清零
|
|
NomalStatus = 0;
|
|
SpecialStatus = 0;
|
|
Protect_Vol = 0;
|
|
Protect_Cur = 0;
|
|
Protect_Temp = 0;
|
|
Warning_Vol = 0;
|
|
Warning_Cur = 0;
|
|
Warning_Temp = 0;
|
|
|
|
/*更新标志*/
|
|
//常见状态
|
|
NomalStatus |= ChargeStatus<<1;
|
|
NomalStatus |= DischargeStatus<<2;
|
|
NomalStatus |= PreChargeStatus<<3;
|
|
//NomalStatus |= ChgMosStatus<<4;
|
|
//NomalStatus |= DsgMosStatus<<5;
|
|
//NomalStatus |= PchgMosStatus<<6;
|
|
NomalStatus |= ChgLimitStatus<<7;
|
|
NomalStatus |= BalanceStatus<<8;
|
|
//特殊状态
|
|
SpecialStatus |= LockOCC<<0;
|
|
SpecialStatus |= LockOCD1<<1;
|
|
SpecialStatus |= LockOCD2<<2;
|
|
SpecialStatus |= LockSP<<3;
|
|
SpecialStatus |= LockSC<<4;
|
|
SpecialStatus |= ChgMosFault<<5;
|
|
SpecialStatus |= DsgMosFault<<6;
|
|
SpecialStatus |= DOStatus<<7;
|
|
SpecialStatus |= ForceOffUV<<8;
|
|
//保护
|
|
Protect_Vol |= PackOV<<0;
|
|
Protect_Vol |= PackUV<<1;
|
|
Protect_Vol |= CellOV<<2;
|
|
Protect_Vol |= CellUV<<3;
|
|
Protect_Vol |= PF<<4;
|
|
Protect_Vol |= L0V<<5;
|
|
Protect_Cur |= OCC<<0;
|
|
Protect_Cur |= OCD1<<1;
|
|
Protect_Cur |= OCD2<<2;
|
|
Protect_Cur |= SP<<3;
|
|
Protect_Cur |= SC<<4;
|
|
Protect_Temp |= McuOTC<<0;
|
|
Protect_Temp |= McuOTD<<1;
|
|
Protect_Temp |= McuUTC<<2;
|
|
Protect_Temp |= McuUTD<<3;
|
|
Protect_Temp |= AmbientOTC<<4;
|
|
Protect_Temp |= AmbientOTD<<5;
|
|
Protect_Temp |= AmbientUTC<<6;
|
|
Protect_Temp |= AmbientUTD<<7;
|
|
Protect_Temp |= MosOTC<<8;
|
|
Protect_Temp |= MosOTD<<9;
|
|
Protect_Temp |= MosUTC<<10;
|
|
Protect_Temp |= MosUTD<<11;
|
|
//报警
|
|
Warning_Vol |= PackOVWarning<<0;
|
|
Warning_Vol |= PackUVWarning<<1;
|
|
Warning_Vol |= CellOVWarning<<2;
|
|
Warning_Vol |= CellUVWarning<<3;
|
|
Warning_Cur |= OCCWarning<<0;
|
|
Warning_Cur |= OCDWarning<<1;
|
|
Warning_Temp |= McuOTCWarning<<0;
|
|
Warning_Temp |= McuOTDWarning<<1;
|
|
Warning_Temp |= McuUTCWarning<<2;
|
|
Warning_Temp |= McuUTDWarning<<3;
|
|
Warning_Temp |= AmbientOTCWarning<<4;
|
|
Warning_Temp |= AmbientOTDWarning<<5;
|
|
Warning_Temp |= AmbientUTCWarning<<6;
|
|
Warning_Temp |= AmbientUTDWarning<<7;
|
|
Warning_Temp |= MosOTCWarning<<8;
|
|
Warning_Temp |= MosOTDWarning<<9;
|
|
//Warning_Temp |= MosUTCWarning<<10;
|
|
//Warning_Temp |= MosUTDWarning<<11;
|
|
|
|
status_New[0] = NomalStatus;
|
|
status_New[1] = SpecialStatus;
|
|
status_New[2] = Protect_Vol;
|
|
status_New[3] = Protect_Cur;
|
|
status_New[4] = Protect_Temp;
|
|
status_New[5] = Warning_Vol;
|
|
status_New[6] = Warning_Cur;
|
|
status_New[7] = Warning_Temp;
|
|
|
|
//检查新变动
|
|
if(staChange_num < MaxSaveNum) //超出个数后不再记录，直到发完
|
|
{
|
|
Check_staChange();
|
|
Check_protectChange();
|
|
Check_warningChange();
|
|
}
|
|
}
|
|
|
|
//解析的固定格式
|
|
void To_incident(uint8_t flag, const char* str, uint8_t len)
|
|
{
|
|
incident_str = str; //事件名称
|
|
incident_len = len; //事件名称长度
|
|
incident_flag = flag; //上报true/false
|
|
}
|
|
|
|
//4G模块上报事件的解析
|
|
//code: 记录事件的对应码
|
|
//str: 事件名称
|
|
//len: 事件名称的长度
|
|
void Explain_incident(uint8_t code, const char* str, uint8_t len)
|
|
{
|
|
if(staChange[staChange_index] == code)
|
|
{
|
|
To_incident(1, str, len); //上报true
|
|
}
|
|
else if(staChange[staChange_index] == code+0x80)
|
|
{
|
|
To_incident(2, str, len); //上报false
|
|
}
|
|
}
|
|
|
|
//4G模块上报[事件]
|
|
void Transmit_incident(void)
|
|
{
|
|
//判断是否要上传事件
|
|
if(incident_flag == 0) //1次只上传1条，若之前有事件还在上传，不进行处理
|
|
{
|
|
if(staChange_num != 0) //存在事件
|
|
{
|
|
//if(staChange[staChange_index] == 0x01)
|
|
//{
|
|
// To_incident(1, "ChargeStatus", 12);
|
|
//}
|
|
//else if(staChange[staChange_index] == 0x02)
|
|
//{
|
|
// To_incident(1, "DischargeStatus", 15);
|
|
//}
|
|
|
|
Explain_incident(0x03, "PreChargeStatus", 15); //预充状态
|
|
Explain_incident(0x04, "ChgMosStatus", 12); //充电MOS状态
|
|
Explain_incident(0x05, "DsgMosStatus", 12); //放电MOS状态
|
|
//Explain_incident(0x06, "PchgMosStatus", 13); //预充MOS状态
|
|
Explain_incident(0x07, "ChgLimitStatus", 14); //充电限流状态
|
|
//Explain_incident(0x08, "BalanceStatus", 13); //均衡控制状态
|
|
|
|
Explain_incident(0x10, "LockOCC", 7); //充电过流保护多次锁定
|
|
Explain_incident(0x11, "LockOCD1", 8); //放电过流1保护多次锁定
|
|
Explain_incident(0x12, "LockOCD2", 8); //放电过流2保护多次锁定
|
|
Explain_incident(0x13, "LockSP", 6); //浪涌保护多次锁定
|
|
Explain_incident(0x14, "LockSC", 6); //短路保护多次锁定
|
|
Explain_incident(0x15, "ChgMosFault", 11); //充电MOS故障
|
|
Explain_incident(0x16, "DsgMosFault", 11); //放电MOS故障
|
|
Explain_incident(0x17, "DOStatus", 8); //DO脱扣器功能
|
|
Explain_incident(0x18, "ForceOffUV", 10); //强制关闭欠压保护功能
|
|
|
|
Explain_incident(0x20, "PackOV", 6); //总体过压保护
|
|
Explain_incident(0x21, "PackUV", 6); //总体欠压保护
|
|
Explain_incident(0x22, "CellOV", 6); //单体过压保护
|
|
Explain_incident(0x23, "CellUV", 6); //单体欠压保护
|
|
Explain_incident(0x24, "PF", 2); //异常高压保护
|
|
Explain_incident(0x25, "L0V", 2); //低电压禁止充电
|
|
Explain_incident(0x30, "OCC", 3); //充电过流保护
|
|
Explain_incident(0x31, "OCD1", 4); //放电过流1保护
|
|
Explain_incident(0x32, "OCD2", 4); //放电过流2保护
|
|
Explain_incident(0x33, "SP", 2); //浪涌保护
|
|
Explain_incident(0x34, "SC", 2); //短路保护
|
|
Explain_incident(0x40, "McuOTC", 6); //电芯充电高温保护
|
|
Explain_incident(0x41, "McuOTD", 6); //电芯放电高温保护
|
|
Explain_incident(0x42, "McuUTC", 6); //电芯充电低温保护
|
|
Explain_incident(0x43, "McuUTD", 6); //电芯放电低温保护
|
|
Explain_incident(0x44, "AmbientOTC", 10); //环境充电高温保护
|
|
Explain_incident(0x45, "AmbientOTD", 10); //环境放电高温保护
|
|
Explain_incident(0x46, "AmbientUTC", 10); //环境充电低温保护
|
|
Explain_incident(0x47, "AmbientUTD", 10); //环境放电低温保护
|
|
Explain_incident(0x48, "MosOTC", 6); //MOS充电高温保护
|
|
Explain_incident(0x49, "MosOTD", 6); //MOS放电高温保护
|
|
//Explain_incident(0x4A, "MosUTC", 6); //MOS充电低温保护
|
|
//Explain_incident(0x4B, "MosUTD", 6); //MOS放电低温保护
|
|
|
|
// Explain_incident(0x50, "PackOVWarning", 6+7); //总体过压报警
|
|
// Explain_incident(0x51, "PackUVWarning", 6+7); //总体欠压报警
|
|
// Explain_incident(0x52, "CellOVWarning", 6+7); //单体过压报警
|
|
// Explain_incident(0x53, "CellUVWarning", 6+7); //单体欠压报警
|
|
// Explain_incident(0x60, "OCCWarning", 3+7); //充电过流报警
|
|
// Explain_incident(0x61, "OCDWarning", 3+7); //放电过流报警
|
|
// Explain_incident(0x70, "McuOTCWarning", 6+7); //电芯充电高温报警
|
|
// Explain_incident(0x71, "McuOTDWarning", 6+7); //电芯放电高温报警
|
|
// Explain_incident(0x72, "McuUTCWarning", 6+7); //电芯充电低温报警
|
|
// Explain_incident(0x73, "McuUTDWarning", 6+7); //电芯放电低温报警
|
|
// Explain_incident(0x74, "AmbientOTCWarning", 10+7); //环境充电高温报警
|
|
// Explain_incident(0x75, "AmbientOTDWarning", 10+7); //环境放电高温报警
|
|
// Explain_incident(0x76, "AmbientUTCWarning", 10+7); //环境充电低温报警
|
|
// Explain_incident(0x77, "AmbientUTDWarning", 10+7); //环境放电低温报警
|
|
// Explain_incident(0x78, "MosOTCWarning", 6+7); //MOS充电高温报警
|
|
// Explain_incident(0x79, "MosOTDWarning", 6+7); //MOS放电高温报警
|
|
// //Explain_incident(0x7A, "MosUTCWarning", 6+7); //MOS充电低温报警
|
|
// //Explain_incident(0x7B, "MosUTDWarning", 6+7); //MOS放电低温报警
|
|
|
|
|
|
//发生时间
|
|
incident_time = staChange_time[staChange_index];
|
|
incident_len += uint_str_len(incident_time);
|
|
|
|
|
|
//发送完最后一个，清空数组
|
|
staChange_index++;
|
|
if((staChange_index >= staChange_num) || (staChange_num > MaxSaveNum)) //当存储事件全部上报，清零重新积累 //总个数最大50，存在异常先清零
|
|
{
|
|
staChange_index = 0;
|
|
staChange_num = 0;
|
|
memset(staChange, 0, MaxSaveNum+5); //清零数组
|
|
memset(staChange_time, 0, MaxSaveNum+5);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|