/**
  ******************************************************************************
  * @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