//******************************************************************** // Ver 1.0 // 2021.11.19 1、新建文件。 // 2021.12.11 2、增加充电器连接且关机状态，清除欠压计数。 // 3、增加充电器未连接且开机状态，清除过压计数。 // 2022.03.23 4、增加短路SWDIO到地进入测试模式，自动打开MOS，禁止休眠。 // 2022.03.28 5、增加关闭LDO后打开LED，加速余电的放电过程。 // 2022.07.06 6、增加充放电MOS信号失效检测。 // 2022.07.16 7、修改过放电压为2.8V。 // 2022.08.19 8、修正充电器连接状态，清除充电温度标志。 //******************************************************************** #include "config.h" BATT_Str BATT_Info; FLASH_Str FLASH_Info __attribute__((at(FLASH_INFO_ADDR))); //FLASH数据初始化 void BATT_FlashInfoInit(void) { if ((BATT_FLASH_HWVersion == __VER_HW__) && (BATT_FLASH_SWVersion == __VER_SW__) && (__VER_SW__ != 0)) { return; } AFE_FlashInfoInit(); //AFE芯片配置信息初始化 #if (CHIP_SIZE == 1) BATT_Info.Flash.DeviceID = 1; #endif //FLASH_Read(FLASH_UID_ADDR, (INT16U *)&BATT_Info.Flash.UID, 12/2); BATT_Info.Flash.DesignCapacity = 32000; //设计容量 BATT_Info.Flash.FullChargeCapacity = 32000; //满充容量 BATT_Info.Flash.DesignVoltage = 3600UL * CELL_SIZE; //设计电压 BATT_Info.Flash.CrgV = 4200UL * CELL_SIZE; //充电电压 BATT_Info.Flash.CrgC = 20000; //充电电流 BATT_Info.Flash.CycleThreshold = 0; //循环 BATT_Info.Flash.NearFull = 0; // BATT_Info.Flash.LearnLowTemperature = -5; //低温 BATT_Info.Flash.SelfDischargeRate = 1; //自放电率 BATT_Info.Flash.DFilter = 100; //滤波电流 BATT_Info.Flash.ShutDownTime = 30 * 60; //掉电时间 BATT_Info.Flash.IdleTime = 30 * 60; //空闲时间 BATT_Info.Flash.CommOffTime = 30 * 60; //无通信时间 BATT_Info.Flash.ChargeTimeMax = 10 * 60; //充电时间 BATT_Info.Flash.DsgcMin = -500; //放电最小电流 BATT_Info.Flash.ChgcMin = 500; //充电结束电流 BATT_Info.Flash.RtcBackupTime = 60; //RTC备份时间 BATT_Info.Flash.SWVersion = __VER_SW__; //软件版本 BATT_Info.Flash.HWVersion = __VER_HW__; //硬件版本 if ((BATT_Info.Flash.CBLLock != CBL_LOCK) && //非锁定状态 (BATT_Info.Flash.CBLLock != CBL_NOLOCK)) //非默认状态 { BATT_Info.Flash.CBLLock = CBL_NOLOCK; } if ((BATT_Info.Flash.Pwr5VLock != PWR5V_ON) && //非锁定状态 (BATT_Info.Flash.Pwr5VLock != PWR5V_OFF)) //非默认状态 { BATT_Info.Flash.Pwr5VLock = PWR5V_OFF; } if ((BATT_Info.Flash.RunMode != RUN_MODE_USER) && //非锁定状态 (BATT_Info.Flash.RunMode != RUN_MODE_FACT)) //非默认状态 { BATT_Info.Flash.RunMode = RUN_MODE_FACT; } BATT_Info.Flash.PreDischargeCurrentMin = -500; //预放最小电流， BATT_Info.Flash.PreDischargeTime = 1500; //预放结束时间， BATT_Info.Flash.Storage.Time0 = 24 * 60; //满电存储时间，超过此时间对电池放电 BATT_Info.Flash.Storage.Time1 = 24 * 60; //电量1存储时间，超过此时间对电池放电 BATT_Info.Flash.Storage.Time2 = 24 * 60; //电量2存储时间，超过此时间对电池放电 BATT_Info.Flash.Storage.Time3 = 24 * 60; //电量3存储时间，超过此时间对电池放电 BATT_Info.Flash.Storage.Soc1 = 90; //存储电量1， BATT_Info.Flash.Storage.Soc2 = 80; //存储电量2， BATT_Info.Flash.Storage.Soc3 = 70; //存储电量3， BATT_Info.Flash.Storage.Soc4 = 60; //存储电量4， MEM_Fill((INT8U *) & (BATT_Info.Flash.DeviceName), 0, 32); MEM_Copy((INT8U *)"PT-1724V1(14S13P)", (INT8U *) & (BATT_Info.Flash.DeviceName), 17); //电池类型 MEM_Fill((INT8U *) & (BATT_Info.Flash.DeviceInfo), 0, 16); MEM_Copy((INT8U *)"LION 14S13P", (INT8U *) & (BATT_Info.Flash.DeviceInfo), 11); //电池信息 MEM_Fill((INT8U *) & (BATT_Info.Flash.ManufactureName), 0, 32); MEM_Copy((INT8U *)"PowerTech", (INT8U *) & (BATT_Info.Flash.ManufactureName), 9); //制造商信息 MEM_Fill((INT8U *) & (BATT_Info.Flash.ManufactureDate), 0, 16); MEM_Copy((INT8U *)"202201211622", (INT8U *) & (BATT_Info.Flash.ManufactureDate), 12); //制造商日期 MEM_Fill((INT8U *) & (BATT_Info.Flash.CellInfo), 0, 16); MEM_Copy((INT8U *)"SAMSUNG", (INT8U *) & (BATT_Info.Flash.CellInfo), 7); //电芯品牌 BATT_Info.Flash.ManufactureNumber = 20211; MEM_Fill((INT8U *) & (BATT_Info.Flash.SN[0]), 0x00, 16); MEM_Copy((INT8U *)DataStr, (INT8U *) & (BATT_Info.Flash.SN[0]), 8); //序列号 MEM_Copy((INT8U *)TimeStr, (INT8U *) & (BATT_Info.Flash.SN[8]), 6); MEM_Fill((INT8U *) & (BATT_Info.Flash.SWVer[0]), 0x00, 32); MEM_Copy((INT8U *)DataStr, (INT8U *) & (BATT_Info.Flash.SWVer[0]), 8); //软件版本 MEM_Copy((INT8U *)TimeStr, (INT8U *) & (BATT_Info.Flash.SWVer[8]), 6); BATT_Info.Flash.SWVer[14] = HEX2ASCII_Tab[__VER_SW__ / 100]; BATT_Info.Flash.SWVer[15] = HEX2ASCII_Tab[(__VER_SW__ % 100) / 10]; BATT_Info.Flash.SWVer[16] = HEX2ASCII_Tab[__VER_SW__ % 10]; //BATT_Info.Flash.SerialNumber = ((INT16U)FLASH_Info.UID[9] | (((INT16U)FLASH_Info.UID[8]) << 8)); //序列号 //BATT_Info.Flash.DeviceChemistry = (INT16U)(BATT_Info.Flash.CpuID1); //设备号 //BATT_Info.Flash.SerialNumber = BATT_Info.Flash.UID[0]; //RS485设备ID if ((BATT_Info.Flash.SerialNumber == 0xffff) || (BATT_Info.Flash.SerialNumber == 0) || (BATT_Info.Flash.SerialNumber == 255)) { BATT_Info.Flash.SerialNumber = 0xf8f7; //ID禁止为0xff和0x00 } BATT_Info.Flash.BattChemistryID = 1; //电池ID if((BATT_Info.Flash.CcGain == 0) || (BATT_Info.Flash.CcGain == -1)) { BATT_Info.Flash.CycleCount = 0; //循环周期 BATT_Info.Flash.CrgvGain = ((330UL + 10) * 100) / 10; BATT_Info.Flash.CcOffset = 0; //电流静态偏移 //2022.07.14 增加offset值校准 BATT_Info.Flash.AfeOffset = ADCOFFSET; #ifdef __SH367306__H BATT_Info.Flash.CcGain = 300; //1000UL/5; //采样电阻值分辨率1uR #endif #ifdef __BQ769x0__H //BATT_Info.Flash.CcGain = 8440L * 4 / 2; //采样电阻值分辨率1uR, R002 // 4 BATT_Info.Flash.CcGain = 8440L * 4 * 10 / 4; //采样电阻值分辨率1uR, R0.4 // 4 #endif } if (BATT_Info.Flash.DeviceID == 0) { BATT_Info.Flash.TempNum = NTC_SIZE_CHIP1; //温度探头个数 BATT_Info.Flash.TempMask = NTC_MASK_CHIP1; //温度探头有效掩码 BATT_Info.Flash.CellNum = CELL_SIZE_CHIP1; //电池串数 BATT_Info.Flash.CellMask = CELL_MASK_CHIP1; //电池有效掩码 } else { BATT_Info.Flash.TempNum = NTC_SIZE; //温度探头个数 BATT_Info.Flash.TempMask = NTC_MASK; //温度探头有效掩码 BATT_Info.Flash.CellNum = CELL_SIZE; //电池串数 BATT_Info.Flash.CellMask = CELL_MASK; //电池有效掩码 } BATT_Info.Flash.CellParal = 13; //电芯并数 BATT_Info.Flash.CellCode = 0x01; //电芯代码 BATT_Info.Flash.HWVer = __VER_HW__; //硬件版本 BATT_Info.Flash.FullSoc = 100; //默认允许充电到100% #ifdef __LFP__ //LFP 磷酸铁锂 BATT_Info.Flash.Ocv[0] = 2850; //电量0% 开路电压值 BATT_Info.Flash.Ocv[1] = 3114; //电量10% 开路电压值 BATT_Info.Flash.Ocv[2] = 3160; //电量20% 开路电压值 BATT_Info.Flash.Ocv[3] = 3160; //电量30% 开路电压值 BATT_Info.Flash.Ocv[4] = 3199; //电量40% 开路电压值 BATT_Info.Flash.Ocv[5] = 3207; //电量50% 开路电压值 BATT_Info.Flash.Ocv[6] = 3212; //电量60% 开路电压值 BATT_Info.Flash.Ocv[7] = 3221; //电量70% 开路电压值 BATT_Info.Flash.Ocv[8] = 3238; //电量80% 开路电压值 BATT_Info.Flash.Ocv[9] = 3243; //电量90% 开路电压值 BATT_Info.Flash.Ocv[10] = 3400; //电量100% 开路电压值 BATT_Info.Flash.Rt[0] = 1987; //电量0% 电池组内阻 BATT_Info.Flash.Rt[1] = 1908; //电量10% 电池组内阻 BATT_Info.Flash.Rt[2] = 1865; //电量20% 电池组内阻 BATT_Info.Flash.Rt[3] = 1787; //电量30% 电池组内阻 BATT_Info.Flash.Rt[4] = 1756; //电量40% 电池组内阻 BATT_Info.Flash.Rt[5] = 1791; //电量50% 电池组内阻 BATT_Info.Flash.Rt[6] = 1575; //电量60% 电池组内阻 BATT_Info.Flash.Rt[7] = 1567; //电量70% 电池组内阻 BATT_Info.Flash.Rt[8] = 1554; //电量80% 电池组内阻 BATT_Info.Flash.Rt[9] = 1554; //电量90% 电池组内阻 BATT_Info.Flash.Rt[10] = 1554; //电量100% 电池组内阻 #endif #ifdef __NCM__ //NCM 镍钴锰 BATT_Info.Flash.Ocv[0] = 2917; //电量0% 开路电压值 BATT_Info.Flash.Ocv[1] = 3403; //电量10% 开路电压值 BATT_Info.Flash.Ocv[2] = 3519; //电量20% 开路电压值 BATT_Info.Flash.Ocv[3] = 3591; //电量30% 开路电压值 BATT_Info.Flash.Ocv[4] = 3640; //电量40% 开路电压值 BATT_Info.Flash.Ocv[5] = 3701; //电量50% 开路电压值 BATT_Info.Flash.Ocv[6] = 3799; //电量60% 开路电压值 BATT_Info.Flash.Ocv[7] = 3893; //电量70% 开路电压值 BATT_Info.Flash.Ocv[8] = 3982; //电量80% 开路电压值 BATT_Info.Flash.Ocv[9] = 4086; //电量90% 开路电压值 BATT_Info.Flash.Ocv[10] = 4125; //电量100% 开路电压值 BATT_Info.Flash.Rt[0] = 4872; //电量0% 电池组内阻 BATT_Info.Flash.Rt[1] = 2678; //电量10% 电池组内阻 BATT_Info.Flash.Rt[2] = 2429; //电量20% 电池组内阻 BATT_Info.Flash.Rt[3] = 2376; //电量30% 电池组内阻 BATT_Info.Flash.Rt[4] = 2356; //电量40% 电池组内阻 BATT_Info.Flash.Rt[5] = 2369; //电量50% 电池组内阻 BATT_Info.Flash.Rt[6] = 2472; //电量60% 电池组内阻 BATT_Info.Flash.Rt[7] = 2492; //电量70% 电池组内阻 BATT_Info.Flash.Rt[8] = 2544; //电量80% 电池组内阻 BATT_Info.Flash.Rt[9] = 2564; //电量90% 电池组内阻 BATT_Info.Flash.Rt[10] = 2664; //电量100% 电池组内阻 #endif #ifdef __NCA__ //NCA 镍钴铝 BATT_Info.Flash.Ocv[0] = 3000; //电量0% 开路电压值 BATT_Info.Flash.Ocv[1] = 3467; //电量10% 开路电压值 BATT_Info.Flash.Ocv[2] = 3549; //电量20% 开路电压值 BATT_Info.Flash.Ocv[3] = 3609; //电量30% 开路电压值 BATT_Info.Flash.Ocv[4] = 3674; //电量40% 开路电压值 BATT_Info.Flash.Ocv[5] = 3756; //电量50% 开路电压值 BATT_Info.Flash.Ocv[6] = 3829; //电量60% 开路电压值 BATT_Info.Flash.Ocv[7] = 3902; //电量70% 开路电压值 BATT_Info.Flash.Ocv[8] = 3972; //电量80% 开路电压值 BATT_Info.Flash.Ocv[9] = 4033; //电量90% 开路电压值 BATT_Info.Flash.Ocv[10] = 4150; //电量100% 开路电压值 BATT_Info.Flash.Rt[0] = 1987; //电量0% 电池组内阻 BATT_Info.Flash.Rt[1] = 1908; //电量10% 电池组内阻 BATT_Info.Flash.Rt[2] = 1865; //电量20% 电池组内阻 BATT_Info.Flash.Rt[3] = 1787; //电量30% 电池组内阻 BATT_Info.Flash.Rt[4] = 1756; //电量40% 电池组内阻 BATT_Info.Flash.Rt[5] = 1791; //电量50% 电池组内阻 BATT_Info.Flash.Rt[6] = 1575; //电量60% 电池组内阻 BATT_Info.Flash.Rt[7] = 1567; //电量70% 电池组内阻 BATT_Info.Flash.Rt[8] = 1554; //电量80% 电池组内阻 BATT_Info.Flash.Rt[9] = 1554; //电量90% 电池组内阻 BATT_Info.Flash.Rt[10] = 1554; //电量100% 电池组内阻 #endif BATT_Info.Flash.Pov1 = 4160 * CELL_SIZE; //总电压过压1级， BATT_Info.Flash.Pov2 = 4200 * CELL_SIZE; //总电压过压2级， BATT_Info.Flash.PovRel = 4050 * CELL_SIZE; //总电压过压解除， BATT_Info.Flash.PovDly = 1000 / TimeBaseCnt; //总电压过压检测延时 BATT_Info.Flash.Puv1 = 2900 * CELL_SIZE; //总电压欠压1级， //BATT_Info.Flash.Puv2 = 2600 * CELL_SIZE; //总电压欠压2级， BATT_Info.Flash.Puv2 = 2800 * CELL_SIZE; //总电压欠压2级，2022.07.15 修改过放电压为2.8V BATT_Info.Flash.PuvRel = 3000 * CELL_SIZE; //总电压欠压解除， BATT_Info.Flash.PuvDly = 1000 / TimeBaseCnt; //总电压过压检测延时 BATT_Info.Flash.Ov1 = 4160; //过充1 BATT_Info.Flash.Ov2 = 4200; //过充2 BATT_Info.Flash.OvRel = 4050; //过充解除 BATT_Info.Flash.OvDly = 1000 / TimeBaseCnt; //过充、解除延时1S,计时时钟为10ms BATT_Info.Flash.Uv1 = 2900; //过放1 //BATT_Info.Flash.Uv2 = 2600; //过放2 BATT_Info.Flash.Uv2 = 2800; //过放2，2022.07.15 修改过放电压为2.8V BATT_Info.Flash.UvRel = 3000; //过放解除 BATT_Info.Flash.UvDly = 1000 / TimeBaseCnt; //过放、解除延时2S BATT_Info.Flash.BalEnVolt = 3700; //3.8V开始允许开启均衡 BATT_Info.Flash.BalDisVolt = 4150; //4.15V放电状态关闭均衡电压 BATT_Info.Flash.BalV1 = 150; //电压不均衡1 BATT_Info.Flash.BalV2 = 250; //电压不均衡2 BATT_Info.Flash.BalRel = 50; //电压不均衡解除 BATT_Info.Flash.BalDly = 1000 / TimeBaseCnt; //电压不均衡置位、解除延时2S BATT_Info.Flash.Ocd1 = -140000; //放电过流1 BATT_Info.Flash.Ocd2 = -150000; //放电过流2 BATT_Info.Flash.OcdRel = -130000; //放电过流解除 BATT_Info.Flash.OcdDly = 1000 / TimeBaseCnt; //放电过流、解除延时200mS BATT_Info.Flash.Occ1 = 23000; //充电过流1 BATT_Info.Flash.Occ2 = 25000; //充电过流2 BATT_Info.Flash.OccRel = 10000; //充电过流解除 BATT_Info.Flash.OccDly = 1000 / TimeBaseCnt; //充电过流、解除延时200mS BATT_Info.Flash.Otc1 = 43 * 10; //充电高温 BATT_Info.Flash.Otc2 = 45 * 10; //充电高温 BATT_Info.Flash.OtcRel = 40 * 10; //充电高温解除 BATT_Info.Flash.OtcDly = 2000 / TimeBaseCnt; //充电高温、解除延时2S BATT_Info.Flash.Utc1 = 2 * 10; //充电低温 BATT_Info.Flash.Utc2 = 0 * 10; //充电低温 BATT_Info.Flash.UtcRel = 5 * 10; //充电低温解除 BATT_Info.Flash.UtcDly = 2000 / TimeBaseCnt; //充电低温、解除延时2S BATT_Info.Flash.Otd1 = 65 * 10; //放电高温1 BATT_Info.Flash.Otd2 = 70 * 10; //放电高温2 BATT_Info.Flash.OtdRel = 60 * 10; //放电高温解除 BATT_Info.Flash.OtdDly = 2000 / TimeBaseCnt; //放电高温、解除延时2S BATT_Info.Flash.Utd1 = -18 * 10; //放电低温1 BATT_Info.Flash.Utd2 = -20 * 10; //放电低温2 BATT_Info.Flash.UtdRel = -15 * 10; //放电低温解除 BATT_Info.Flash.UtdDly = 2000 / TimeBaseCnt; //充放电低温、解除延时2S BATT_Info.Flash.Otf1 = 90 * 10; //放电高温1 BATT_Info.Flash.Otf2 = 98 * 10; //放电高温2 BATT_Info.Flash.OtfRel = 75 * 10; //放电高温解除 BATT_Info.Flash.OtfDly = 2000 / TimeBaseCnt; //放电高温、解除延时2S BATT_Info.Flash.CFetf1 = 100; //充电MOS失效电流1 BATT_Info.Flash.CFetf2 = 200; //充电MOS失效电流1 BATT_Info.Flash.CFetfRel = 50; //充电MOS失效解除电流 BATT_Info.Flash.CFetfDly = 2000 / TimeBaseCnt; //充电MOS失效、解除延时2S BATT_Info.Flash.DFetf1 = -100; //充电MOS失效电流1 BATT_Info.Flash.DFetf2 = -200; //充电MOS失效电流1 BATT_Info.Flash.DFetfRel = -50; //充电MOS失效解除电流 BATT_Info.Flash.DFetfDly = 2000 / TimeBaseCnt; //充电MOS失效、解除延时2S //BATT_Info.Flash.CAN1_Baud = 3; //CAN1默认波特率 //BATT_Info.Flash.CAN2_Baud = 3; //CAN2默认波特率 //BATT_Info.Flash.UART1_Baud = 3; //UART1默认波特率 //BATT_Info.Flash.UART2_Baud = 3; //UART2默认波特率 //BATT_Info.Flash.UART3_Baud = 3; //UART3默认波特率 //BATT_Info.Flash.UART4_Baud = 3; //UART3默认波特率 BATT_FlashInfoSave(); } //保存FLASH数据 void BATT_FlashInfoSave(void) { BATT_Info.Flash.Crc = CRC8((INT8U *) & (BATT_Info.Flash), sizeof(FLASH_Str) - 2); FLASH_Write(FLASH_INFO_ADDR, (INT8U *) & (BATT_Info.Flash), sizeof(FLASH_Str)); } /* //参数校准 INT8U BATT_CaliPara(INT8U Para,INT32S Value) { switch(Para) { case SCP_CALI_CCOFFSET: BATT_Info.Flash.CcOffset = AFE_CcReg; break; case SCP_CALI_CCGAIN: BATT_Info.Flash.CcGain = (Value * 100 * AFE_CcReg) / AFE_RsnsGain; break; case SCP_CALI_CRGV: //BATT_Info.Flash.CrgvGain=(Value*100)/ADC_ReadVolt(ADC_VOLT_CRG); break; case SCP_CALI_RST: FLASH_Info.DeviceID = 0; BATT_FlashInfoInit(); break; default: return(SCP_ERR_CALI); //break; } BATT_FlashInfoSave(); //保存数据 return(1); } */ void BATT_Init(void) { INT8U i; BATT_GpioInit(); BATT_InfoInit(); BATT_FlashInfoInit(); EEPROM_Init(); SCP_Init(); ADC_Init(); AFE_Init(); for (i = 0; i < 50; i++) { BATT_ReadInfo(); DELAY_Ms(20); } SOC_Init(); BATT_SleepDelayTime(10); BATT_CrgOffLineCntReset(9); BATT_FLAG_INIT = 1; if(BATT_Info.Flash.RunMode == RUN_MODE_FACT) { BATT_FLAG_RUNMODE = 2; } BATT_AlarmLogWrite(ALARM_START); //记录开机标志 BATT_P5vOnTime(10); if(SYS_CTRL2_DSG_ON != 0) { BATT_FetEn((CFET | DFET), ENABLE); BATT_PowerOn(POWERON_KEY, ENABLE); } } //BATT电压检测 void BATT_VoltCheck(void) { //总电压过压 if (BATT_Voltage > BATT_FLASH_Pov2) //过充2 { if (BATT_FLAG_POV == 0) //如果过压标志为0，先设置过压标志1级 { BATT_FLAG_POV = 1; //设置过压1级标志 BATT_PovCnt = BATT_FLASH_PovDly; } else if ((BATT_FLASH_PovDly * 2) > BATT_PovCnt) { BATT_PovCnt++; } else { if (BATT_FLAG_POV != 2) { BATT_FLAG_POV = 2; BATT_AlarmLogWrite(ALARM_POV); } BATT_FLAG_CRGLOCK = 1; BATT_SetAlarmFlag(POV); } } else if (BATT_Voltage > BATT_FLASH_Pov1) //过充1 { if (BATT_FLASH_PovDly > BATT_PovCnt) { BATT_PovCnt++; } else if (BATT_FLASH_PovDly < BATT_PovCnt) { BATT_PovCnt--; } else { BATT_FLAG_POV = 1; } } else if (BATT_Voltage < BATT_FLASH_PovRel) //过充恢复 { if (BATT_PovCnt > 0) { BATT_PovCnt--; } else { BATT_FLAG_POV = 0; //清除过压标志 if(BATT_FLAG_STA == STA_DSG) //2022.07.27 增加放电清除过压标志 { BATT_ClrAlarmFlag(POV); } } } //总电压欠压 if (BATT_Voltage < BATT_FLASH_Puv2) //过放2 { if (BATT_FLAG_PUV == 0) { BATT_FLAG_PUV = 1; BATT_PuvCnt = BATT_FLASH_PuvDly; } else if ((BATT_FLASH_PuvDly * 2) > BATT_PuvCnt) { BATT_PuvCnt++; } else { if (BATT_FLAG_PUV != 2) { BATT_FLAG_PUV = 2; BATT_AlarmLogWrite(ALARM_PUV); } BATT_SetAlarmFlag(PUV); } #ifdef __BATT_AFE_UV__ if (BATT_FLAG_AUV != 0) //2020.12.30 增加AFE欠压标志 { BATT_FLAG_PUV = 2; BATT_PuvCnt = BATT_FLASH_PuvDly * 2; } #endif } else if (BATT_Voltage < BATT_FLASH_Puv1) //过放1 { if (BATT_FLASH_PuvDly > BATT_PuvCnt) { BATT_PuvCnt++; } else if (BATT_FLASH_PuvDly < BATT_PuvCnt) { BATT_PuvCnt--; } else { BATT_FLAG_PUV = 1; } } else if (BATT_Voltage >= BATT_FLASH_PuvRel) //过放恢复 { if (BATT_PuvCnt > 0) { BATT_PuvCnt--; } else { BATT_FLAG_PUV = 0; if(BATT_FLAG_STA == STA_CHG) //2022.07.27 增加充电清除欠压标志 { BATT_ClrAlarmFlag(PUV); } } } //单体过压 if (BATT_VcMax > BATT_FLASH_Ov2) //过压2 { if (BATT_FLAG_OV == 0) //如果过压标志为0，先设置过压标志1级 { BATT_FLAG_OV = 1; //设置过压1级标志 BATT_OvCnt = BATT_FLASH_OvDly; } else if ((BATT_FLASH_OvDly * 2) > BATT_OvCnt) { BATT_OvCnt++; } else { if (BATT_FLAG_OV != 2) { BATT_FLAG_OV = 2; BATT_AlarmLogWrite(ALARM_COV); } BATT_FLAG_CRGLOCK = 1; BATT_SetAlarmFlag(COV); } #ifdef __BATT_AFE_OV__ if (BATT_FLAG_AOV != 0) //2021.01.03 增加硬件检测到充放后，设置过充保护 { BATT_FLAG_OV = 2; BATT_OvCnt = BATT_FLASH_OvDly * 2; } #endif } else if (BATT_VcMax > BATT_FLASH_Ov1) //过压1 { if (BATT_FLASH_OvDly > BATT_OvCnt) { BATT_OvCnt++; } else if (BATT_FLASH_OvDly < BATT_OvCnt) { BATT_OvCnt--; } else { BATT_FLAG_OV = 1; } } else if (BATT_VcMax < BATT_FLASH_OvRel) //过充恢复 { if (BATT_OvCnt > 0) { BATT_OvCnt--; } else { BATT_FLAG_OV = 0; //清除过压标志 if(BATT_FLAG_STA == STA_DSG) //2022.07.27 增加放电清除单体过压标志 { BATT_ClrAlarmFlag(COV); BATT_ClrAlarmFlag(COV2F); } } } //单体欠压 if (BATT_VcMin < BATT_FLASH_Uv2) //过放2 { if (BATT_FLAG_UV == 0) { BATT_FLAG_UV = 1; BATT_UvCnt = BATT_FLASH_UvDly; } else if ((BATT_FLASH_UvDly * 2) > BATT_UvCnt) { BATT_UvCnt++; } else { if (BATT_FLAG_UV != 2) { BATT_FLAG_UV = 2; BATT_AlarmLogWrite(ALARM_CUV); } BATT_SetAlarmFlag(CUV); } if (BATT_FLAG_AUV != 0) //2021.01.03 增加检测到硬件保护后，设置过放状态 { BATT_FLAG_UV = 2; BATT_UvCnt = BATT_FLASH_UvDly * 2; } #ifdef __BATT_LOW_LOCK__ //2021.01.08 增加电池低电压锁定,禁止充电 if ((BATT_VcMin < 1500) && (BATT_VcMin > 500)) { if (BATT_CblCnt < (BATT_FLASH_PovDly * 3)) { BATT_CblCnt ++; } else if (BATT_FLAG_CBL == 0) { BATT_FLAG_CBL = 1; BATT_FlashCmdProcess(SCP_CMD_SAVE_CBL, (INT8U *)&BATT_Voltage); } } #endif } else if (BATT_VcMin < BATT_FLASH_Uv1) //过放1 { if (BATT_FLASH_UvDly > BATT_UvCnt) { BATT_UvCnt++; } else if (BATT_FLASH_UvDly < BATT_UvCnt) { BATT_UvCnt--; } else { BATT_FLAG_UV = 1; } } else if (BATT_VcMin > BATT_FLASH_UvRel) //过放恢复 { if (BATT_UvCnt > 0) { BATT_UvCnt--; } else { BATT_FLAG_UV = 0; if(BATT_FLAG_STA == STA_CHG) //2022.07.27 增加充电清除单体欠压标志 { BATT_ClrAlarmFlag(CUV); } } } //2021.12.11 增加充电器无连接状态，清除过压计数 if((BATT_FLAG_CRGLINK == 0) && (BATT_PowerOnState(POWERON_KEY) != 0)) { BATT_OvCnt = 0; BATT_PovCnt = 0; } //2021.12.11 增加充电器连接状态，清除欠压计数 else if((BATT_FLAG_CRGLINK == 2) && (BATT_PowerOnState(POWERON_KEY) == 0)) { BATT_UvCnt = 0; BATT_PuvCnt = 0; } } //不均衡检测 void BATT_BalCheck(void) { if (BATT_VcBal > BATT_FLASH_BalV2) //电压不均衡2级 { if (BATT_FLAG_BAL == 0) { BATT_FLAG_BAL = 1; BATT_BalCnt = BATT_FLASH_BalDly; } else if ((BATT_FLASH_BalDly * 2) > BATT_BalCnt) { BATT_BalCnt++; } else { if (BATT_FLAG_BAL != 2) { BATT_FLAG_BAL = 2; BATT_AlarmLogWrite(ALARM_BAL); } BATT_SetAlarmFlag(BAL); } } else if (BATT_VcBal > BATT_FLASH_BalV1) //电压不均衡1级 { if (BATT_FLASH_BalDly > BATT_BalCnt) { BATT_BalCnt++; } else if (BATT_FLASH_BalDly < BATT_BalCnt) { BATT_BalCnt--; } else { BATT_FLAG_BAL = 1; } } else if (BATT_VcBal < BATT_FLASH_BalRel) //电压不均衡恢复 { if (BATT_BalCnt > 0) { BATT_BalCnt--; } else { BATT_FLAG_BAL = 0; if(BATT_FLAG_STA == STA_DSG) //2022.07.27 增加放电清除电芯不均衡标志 { BATT_ClrAlarmFlag(BAL); } } } } //过流检测 void BATT_CurrentCheck(void) { //充电过流检测 if (BATT_Current > BATT_FLASH_Occ2) //过流2 { if (BATT_FLAG_OCC == 0) //如果过流标志为0，先设置过流标志1级 { BATT_FLAG_OCC = 1; //设置过流1级标志 BATT_OccCnt = BATT_FLASH_OccDly; } else if ((BATT_FLASH_OccDly * 2) > BATT_OccCnt) { BATT_OccCnt++; } else { if (BATT_FLAG_OCC != 2) { BATT_FLAG_OCC = 2; BATT_AlarmLogWrite(ALARM_OCC); } BATT_FetLock(CFET, Lock); //过流锁定 BATT_SetAlarmFlag(OCC); } } else if (BATT_Current > BATT_FLASH_Occ1) //过流1 { if (BATT_FLASH_OccDly > BATT_OccCnt) { BATT_OccCnt++; } else if (BATT_FLASH_OccDly < BATT_OccCnt) { BATT_OccCnt--; } else { BATT_FLAG_OCC = 1; } } else if (BATT_Current < BATT_FLASH_OccRel) //过流恢复 { if (BATT_OccCnt > 0) { BATT_OccCnt--; } else { BATT_FLAG_OCC = 0; /*if(BATT_FLAG_STA == STA_DSG) //2022.07.27 增加放电清除充电过流标志 { BATT_ClrAlarmFlag(OCC); }*/ } } //放电过流检测 if (BATT_Current < BATT_FLASH_Ocd2) //过流2 { if (BATT_FLAG_OCD == 0) //如果过流标志为0，先设置过流标志1级 { BATT_FLAG_OCD = 1; //设置过流1级标志 BATT_OcdCnt = BATT_FLASH_OcdDly; } else if ((BATT_FLASH_OcdDly * 2) > BATT_OcdCnt) { BATT_OcdCnt++; } else { if (BATT_FLAG_OCD != 2) { BATT_FLAG_OCD = 2; BATT_AlarmLogWrite(ALARM_OCD); } BATT_FetLock(DFET, Lock); //过流锁定， BATT_SetAlarmFlag(OCD); } } else if (BATT_Current < BATT_FLASH_Ocd1) //过流1 { if (BATT_FLASH_OcdDly > BATT_OcdCnt) { BATT_OcdCnt++; } else if (BATT_FLASH_OcdDly < BATT_OcdCnt) { BATT_OcdCnt--; } else { BATT_FLAG_OCD = 1; } } else if (BATT_Current > BATT_FLASH_OcdRel) //过流恢复 { if (BATT_OcdCnt > 0) { BATT_OcdCnt--; } else { BATT_FLAG_OCD = 0; /*if(BATT_FLAG_STA == STA_CHG) //2022.07.27 增加充电清除放电过流标志 { BATT_ClrAlarmFlag(OCD); BATT_ClrAlarmFlag(SD); }*/ } } } //温度检测 void BATT_TempCheck(void) { //充电高温 if (BATT_TsMax > BATT_FLASH_Otc2) //检测高温2 { if (BATT_FLAG_OTC == 0) //高温标志为0，设置为1 { BATT_FLAG_OTC = 1; BATT_OtcCnt = BATT_FLASH_OtcDly; } else if ((BATT_FLASH_OtcDly * 2) > BATT_OtcCnt) //检测高温2延时计数 { BATT_OtcCnt++; } else { if (BATT_FLAG_OTC != 2) { BATT_FLAG_OTC = 2; //检测高温2延时计数到达，设置为2 BATT_AlarmLogWrite(ALARM_OTC); } if(BATT_FLAG_CRG != 0) { BATT_SetAlarmFlag(OTC); } else { BATT_ClrAlarmFlag(OTC); } } } else if (BATT_TsMax > BATT_FLASH_Otc1) //检测高温1 { if (BATT_FLASH_OtcDly > BATT_OtcCnt) //检测高温1延时计数 { BATT_OtcCnt++; } else if (BATT_FLASH_OtcDly < BATT_OtcCnt) //检测高温1延时计数 { BATT_OtcCnt--; } else { BATT_FLAG_OTC = 1; } } else if (BATT_TsMax < BATT_FLASH_OtcRel) //高温解除 { if (BATT_OtcCnt > 0) //高温解除计数 { BATT_OtcCnt--; } else { BATT_FLAG_OTC = 0; //if(BATT_FLAG_STA == STA_DSG) //2022.07.27 增加放电清除充电过温标志 { BATT_ClrAlarmFlag(OTC); } } } //充电低温检测 if (BATT_TsMin < BATT_FLASH_Utc2) //检测低温2 { if (BATT_FLAG_UTC == 0) //低温标志为0，设置为1 { BATT_FLAG_UTC = 1; BATT_UtcCnt = BATT_FLASH_UtcDly; } else if ((BATT_FLASH_UtcDly * 2) > BATT_UtcCnt) //检测低温2延时计数 { BATT_UtcCnt++; } else { if (BATT_FLAG_UTC != 2) { BATT_FLAG_UTC = 2; //检测低温2延时计数到达，设置为2 BATT_AlarmLogWrite(ALARM_UTC); } if(BATT_FLAG_CRG != 0) //2022.08.29 充电温度标志在充电器连接状态才置位 { BATT_SetAlarmFlag(UTC); } else { BATT_ClrAlarmFlag(UTC); } } } else if (BATT_TsMin < BATT_FLASH_Utc1) //检测低温1 { if (BATT_FLASH_UtcDly > BATT_UtcCnt) //检测低温1延时计数 { BATT_UtcCnt++; } else if (BATT_FLASH_UtcDly < BATT_UtcCnt) //检测低温1延时计数 { BATT_UtcCnt--; } else { BATT_FLAG_UTC = 1; } } else if (BATT_TsMin > BATT_FLASH_UtcRel) //低温解除 { if (BATT_UtcCnt > 0) //低温解除计数 { BATT_UtcCnt--; } else { BATT_FLAG_UTC = 0; //if(BATT_FLAG_CRGLINK == 0) //2022.07.27 增加放电清除充电低温标志 { BATT_ClrAlarmFlag(UTC); } } } //放电高温 if (BATT_TsMax > BATT_FLASH_Otd2) //检测高温2 { if (BATT_FLAG_OTD == 0) //高温标志为0，设置为1 { BATT_FLAG_OTD = 1; BATT_OtdCnt = BATT_FLASH_OtdDly; } else if ((BATT_FLASH_OtdDly * 2) >= BATT_OtdCnt) //检测高温2延时计数 { BATT_OtdCnt++; } else { if (BATT_FLAG_OTD != 2) { BATT_FLAG_OTD = 2; //检测高温2延时计数到达，设置为2 BATT_AlarmLogWrite(ALARM_OTD); } BATT_SetAlarmFlag(OTD); } } else if (BATT_TsMax > BATT_FLASH_Otd1) //检测高温1 { if (BATT_FLASH_OtdDly > BATT_OtdCnt) //检测高温1延时计数 { BATT_OtdCnt++; } else if (BATT_FLASH_OtdDly < BATT_OtdCnt) //检测高温1延时计数 { BATT_OtdCnt--; } else { BATT_FLAG_OTD = 1; } } else if (BATT_TsMax < BATT_FLASH_OtdRel) //高温解除 { if (BATT_OtdCnt > 0) //高温解除计数 { BATT_OtdCnt--; } else { BATT_FLAG_OTD = 0; //if(BATT_FLAG_STA == STA_CHG) //2022.07.27 增加充电清除放电过温标志 { BATT_ClrAlarmFlag(OTD); //2022.08.29 放电高温标志实时清除 } } } //放电低温 if (BATT_TsMin < BATT_FLASH_Utd2) //检测低温2 { if (BATT_FLAG_UTD == 0) //低温标志为0，设置为1 { BATT_FLAG_UTD = 1; BATT_UtdCnt = BATT_FLASH_UtdDly; } else if ((BATT_FLASH_UtdDly * 2) > BATT_UtdCnt) //检测低温2延时计数 { BATT_UtdCnt++; } else { if (BATT_FLAG_UTD != 2) { BATT_FLAG_UTD = 2; //检测低温2延时计数到达，设置为2 BATT_AlarmLogWrite(ALARM_UTD); } BATT_SetAlarmFlag(UTD); } } else if (BATT_TsMin < BATT_FLASH_Utd1) //检测低温1 { if (BATT_FLASH_UtdDly > BATT_UtdCnt) //检测低温1延时计数 { BATT_UtdCnt++; } else if (BATT_FLASH_UtdDly < BATT_UtdCnt) //检测低温1延时计数 { BATT_UtdCnt--; } else { BATT_FLAG_UTD = 1; } } else if (BATT_TsMin > BATT_FLASH_UtdRel) //低温解除 { if (BATT_UtdCnt > 0) //低温解除计数 { BATT_UtdCnt--; } else { BATT_FLAG_UTD = 0; //if(BATT_FLAG_STA == STA_CHG) //2022.07.27 增加充电清除放电低温标志 { BATT_ClrAlarmFlag(UTD); //2022.08.29 低温放电实时清除 } } } //OTF if (BATT_TsFet > BATT_FLASH_Otf2) //检测高温2 { if (BATT_FLAG_OTF == 0) //高温标志为0，设置为1 { BATT_FLAG_OTF = 1; BATT_OtfCnt = BATT_FLASH_UtdDly; } else if ((BATT_FLASH_UtdDly * 2) >= BATT_OtfCnt) //检测高温2延时计数 { BATT_OtfCnt++; } else { if (BATT_FLAG_OTF != 2) { BATT_FLAG_OTF = 2; //检测高温2延时计数到达，设置为2 BATT_AlarmLogWrite(ALARM_OTF); } BATT_SetAlarmFlag(OTF); //SBS_AlarmSetFlag(OTF); } } else if (BATT_TsFet > BATT_FLASH_Otf1) //检测高温1 { if (BATT_FLASH_UtdDly > BATT_OtfCnt) //检测高温1延时计数 { BATT_OtfCnt++; } else if (BATT_FLASH_UtdDly < BATT_OtfCnt) //检测高温1延时计数 { BATT_OtfCnt--; } else { BATT_FLAG_OTF = 1; } } else if (BATT_TsFet < BATT_FLASH_OtfRel) //高温解除 { if (BATT_OtfCnt > 0) //高温解除计数 { BATT_OtfCnt--; } else { BATT_FLAG_OTF = 0; //if(BATT_FLAG_STA == STA_CHG) //2022.07.27 增加充电清除MOS过温标志 { BATT_ClrAlarmFlag(OTF); //2022.08.29 MOS高温实时清除 } } } /* if((BATT_FLAG_OTD == 2) || (BATT_FLAG_OTC == 2)) { BATT_FLAG_OT = 1; } else { BATT_FLAG_OT = 0; } if((BATT_FLAG_UTD == 2) || (BATT_FLAG_UTC == 2)) { BATT_FLAG_UT = 1; } else { BATT_FLAG_UT = 0; } */ } //均衡控制，5秒一个周期 INT8U BATT_Balance(void) { INT16U tBl = 0; INT8U i; //记录非均衡状态时电芯压差 if ((BATT_FLAG_BALE == 0) && (BATT_VcBal > 50)) //2021.12.3 记录电芯压差大于50mV { if (BATT_Info.Info.BalanceStats.CellMinNum != BATT_VcMinNum) { BATT_Info.Info.BalanceStats.CellMinNum = BATT_VcMinNum; if (BATT_Info.Info.BalanceStats.CellVoltLowCnt[BATT_VcMinNum] < 65000) { BATT_Info.Info.BalanceStats.CellVoltLowCnt[BATT_VcMinNum] ++; } } } //电池最高电压小于均衡电压，非充电状态，不开启均衡 if ((BATT_VcMax < BATT_FLASH_BalEnVolt) || ((BATT_FLAG_CHG == 0) && (BATT_VcMax < BATT_FLASH_BalDisVolt)) || (BATT_VcBal < BATT_FLASH_BalRel)) { if (BATT_FLAG_BALE != 0) //均衡开启状态，则关闭均衡 { AFE_Balance(0x0000); BATT_FLAG_BALE = 0; } return (0); } //检查电芯压差是否达到开启均衡条件 if (BATT_VcBal > BATT_FLASH_BalV2) { BATT_FLAG_BALE = 1; } else if (BATT_VcBal < BATT_FLASH_BalRel) { BATT_FLAG_BALE = 0; return(0); } for (i = 0; i < CELL_SIZE; i++) { if (BATT_VcAvg < BATT_Vc[i]) //单体电压大于平均电压，允许均衡开启 { tBl |= (1 << i); //均衡时间计数 if((BATT_FLAG_BALF == 0) && ((i & 0x01) == 0)) { BATT_Info.Info.BalanceStats.CellBalanceSec[i] ++; } else if((BATT_FLAG_BALF != 0) && ((i & 0x01) != 0)) { BATT_Info.Info.BalanceStats.CellBalanceSec[i] ++; } if(BATT_Info.Info.BalanceStats.CellBalanceSec[i] >= 12) { if(BATT_Info.Info.BalanceStats.CellBalanceMin[i] < 65000) { BATT_Info.Info.BalanceStats.CellBalanceMin[i] ++; } BATT_Info.Info.BalanceStats.CellBalanceSec[i] = 0; } } } BATT_FLAG_BALF ^= 0x01; //均衡串数切换 if (BATT_FLAG_BALF & 0x01) { tBl &= 0x5555; //奇数串开启均衡 } else { tBl &= 0xaaaa; //偶数串开启均衡 } AFE_Balance(tBl); //写入均衡开启掩码 return (1); } //电池电压处理，计算最大值、最小值、平均值、总电压 void BATT_CellVoltageProcess(void) { INT8U i; INT32U tVoltage; BATT_VcMax = 0; //清空电池电压最大值 BATT_VcMin = 0xffff; //清空电池电压最小值 BATT_VcMaxNum = 0; //清空最高电压电芯编号 BATT_VcMinNum = 0; //清空最低电压电芯编号 tVoltage = 0; //if(BATT_Vc[5] < BATT_VcAvg) BATT_Vc[5] = BATT_VcAvg; //2021.11.25 补偿板子第6串的电压采样不对 for (i = 0; i < BATT_FLASH_CellNum; i++) //搜索电芯电压的最高、最低值和编号 { if (BATT_Vc[i] > BATT_VcMax) { BATT_VcMax = BATT_Vc[i]; BATT_VcMaxNum = i; } if (BATT_Vc[i] < BATT_VcMin) { BATT_VcMin = BATT_Vc[i]; BATT_VcMinNum = i; } tVoltage += BATT_Vc[i]; } BATT_VcBal = BATT_VcMax - BATT_VcMin; //计算不均衡电压 BATT_VcAvg = tVoltage / BATT_FLASH_CellNum; //计算平均电压 BATT_Voltage = tVoltage; if ((BATT_VcMax > 4500) || (BATT_VcMin < 1500)) //单体电压超出1500mV~4500mV范围认为电芯故障 { BATT_FLAG_CELLERR = 1; //PACK_FetLock(STA_CFET|STA_DFET, ENABLE); } else { BATT_FLAG_CELLERR = 0; } if (BATT_VcMax >= 5000) //单体电压超出5000mV范围认为采样线故障 { BATT_FLAG_LINEERR = 1; //PACK_FetLock(STA_CFET|STA_DFET, ENABLE); } else { BATT_FLAG_LINEERR = 0; } } //电池温度处理，计算最高温度、最低温度，平均温度、电池包温度 void BATT_CellTempProcess(void) { INT8U i; INT16S tTemp; BATT_TsMax = -400; //清空温度最大值 BATT_TsMin = 1000; //清空温度最小值 BATT_TsMaxNum = 0; BATT_TsMinNum = 0; tTemp = 0; #ifdef __SH367306__H for (i = 0; i < (BATT_FLASH_TempNum / 2); i++) #endif #ifdef __BQ769x0__H for (i = 0; i < (BATT_FLASH_TempNum - NTC_SIZE_EXT); i++) #endif { if (BATT_Ts[i] > BATT_TsMax) { BATT_TsMax = BATT_Ts[i]; BATT_TsMaxNum = i; } if (BATT_Ts[i] < BATT_TsMin) { BATT_TsMin = BATT_Ts[i]; BATT_TsMinNum = i; } tTemp += BATT_Ts[i]; } BATT_TsBal = BATT_TsMax - BATT_TsMin; #ifdef __SH367306__H BATT_TsAve = tTemp / (BATT_FLASH_TempNum / 2); #endif #ifdef __BQ769x0__H BATT_TsAve = tTemp / (BATT_FLASH_TempNum - NTC_SIZE_EXT); #endif if ((BATT_TsMax > 1000) || (BATT_TsMin < -400)) //温度超出-40~100度范围，认为温度检测点异常 { BATT_FLAG_NTCERR = 1; } else { BATT_FLAG_NTCERR = 0; } //温度最大值高于40度，返回最高温度作为电池包温度， //温度最小值低于10度，返回最低温度作为电池包温度， //在此范围之外，返回平均温度作为电池包温度， if (BATT_TsMax > 400) { BATT_Temp = BATT_TsMax; } else if (BATT_TsMin < 100) { BATT_Temp = BATT_TsMin; } else { BATT_Temp = BATT_TsAve; } } //MOSFET失效检测 void BATT_MosfetFailCheck(void) { if ((BATT_FLAG_DFET == 0) && (BATT_FLAG_PCFET == 0)) { if (BATT_Current < BATT_FLASH_DFetf2) { if (BATT_DFetFailCnt < BATT_FLASH_DFetfDly) { BATT_DFetFailCnt ++; } else if (BATT_FLAG_DFETFAIL != 2) { BATT_FLAG_DFETFAIL = 2; BATT_AlarmLogWrite(ALARM_FETF); BATT_SetAlarmFlag(DFETF); } } else if (BATT_Current > BATT_FLASH_DFetfRel) { if (BATT_DFetFailCnt > 0) { BATT_DFetFailCnt --; } else { BATT_FLAG_DFETFAIL = 0; } } } else { BATT_DFetFailCnt = 0; } if (BATT_FLAG_CFET == 0) { if (BATT_Current > BATT_FLASH_CFetf2) { if (BATT_CFetFailCnt < BATT_FLASH_CFetfDly) { BATT_CFetFailCnt ++; } else if (BATT_FLAG_CFETFAIL != 2) { BATT_FLAG_CFETFAIL = 2; BATT_AlarmLogWrite(ALARM_FETF); BATT_SetAlarmFlag(CFETF); } } else if (BATT_Current < BATT_FLASH_CFetfRel) { if (BATT_CFetFailCnt > 0) { BATT_CFetFailCnt --; } else { BATT_FLAG_CFETFAIL = 0; } } } else { BATT_CFetFailCnt = 0; } //2022.07.06 增加充放电MOS信号失效检测 if(BATT_FLAG_CFETOUT != BATT_FLAG_CFET) { if(BATT_CFetOutFailCnt < BATT_FLASH_CFetfDly) { BATT_CFetOutFailCnt ++; } else { BATT_FLAG_CFETOUTFAIL = 1; } } else { if(BATT_CFetOutFailCnt > 0) { BATT_CFetOutFailCnt --; } else { BATT_FLAG_CFETOUTFAIL = 0; } } if(BATT_FLAG_DFETOUT != BATT_FLAG_DFET) { if(BATT_DFetOutFailCnt < BATT_FLASH_DFetfDly) { BATT_DFetOutFailCnt ++; } else { BATT_FLAG_DFETOUTFAIL = 1; } } else { if(BATT_DFetOutFailCnt > 0) { BATT_DFetOutFailCnt --; } else { BATT_FLAG_DFETOUTFAIL = 0; } } } //限制容量充电 void BATT_ChargeCheck(void) { if ((BATT_FLAG_CRGLINK != 0) && (BATT_FLAG_LCCHG == 1) && (BATT_Rsoc >= (INT8U)BATT_ChargeEndSoc)) //限制容量充电检测标志有效 { BATT_FLAG_LCCHG = 2; BATT_FetLock(CFET, Lock); BATT_FLAG_FC = 1; SOC_FLAG_CYCLE |= 0x02; } } //预放功能 void BATT_PreDischargeCheck(void) { switch (FET_FLAG_PREDISCHARGE) { case PREDISCHARGE_START: BQ769x0_Pdsg(ENABLE); //打开预充MOS BATT_PFetOffTime(BATT_FLASH_PreDischargeTime); BATT_PreDischarge(PREDISCHARGE_ON); BATT_PreFailCnt = 0; BATT_PreDischargeCurrent[6] = 0; break; case PREDISCHARGE_ON: if (BATT_Current < BATT_PreDischargeCurrentMin) { BATT_PreDischargeCurrent[BATT_PreFailCnt] = BATT_Current; BATT_PreDischargeCurrent[6] = BATT_PreFailCnt; if (BATT_PreFailCnt < 5) { BATT_PreFailCnt++; } } if (BATT_PFetState() == 0) { BATT_PreDischarge(PREDISCHARGE_END); if(BATT_PreFailCnt < 5) { BATT_PowerOn(POWERON_KEY, ENABLE); BATT_PFetOffTime(1000); //预放MOS延迟1秒关闭 BATT_OvCnt = 0; //按键开机清除过充计数和标志位 BATT_PovCnt = 0; BATT_FLAG_POV = 0; BATT_FLAG_OV = 0; } } break; case PREDISCHARGE_END: if (BATT_PFetState() == 0) { BQ769x0_Pdsg(DISABLE); //关闭预充MOS } if((BATT_PreFailCnt >= 5) && (BATT_FLAG_CFET != 0)) { BATT_PowerOn(POWERON_KEY, DISABLE); } BATT_PreDischarge(PREDISCHARGE_OFF); break; default: break; } } //限制容量放电，2022.04.06 此功能取消了 void BATT_DischargeCheck(void) { if (BATT_FLAG_LCDSG != 0) //限制容量充放电检测标志有效 { if (BATT_Rsoc <= (INT8U)BATT_DischargeEndSoc) { BATT_FLAG_LCDSG = 0; BATT_FetLock(DFET, Lock); BATT_AlarmLogWrite(ALARM_DSGCAP); //2022.08.05 增加放电容量限制关闭记录 } } } //存储放电 void BATT_StorageDischarge(void) { switch (BATT_StorageStep) { case 1: if (BATT_Rsoc < BATT_FLASH_StorageSoc1) { PDSGRLE_Off(); } break; case 2: if (BATT_Rsoc < BATT_FLASH_StorageSoc2) { PDSGRLE_Off(); } break; case 3: if (BATT_Rsoc < BATT_FLASH_StorageSoc3) { PDSGRLE_Off(); } break; case 4: if (BATT_Rsoc < BATT_FLASH_StorageSoc4) { PDSGRLE_Off(); } break; default: break; } } //存储放电状态检查 void BATT_StorageDischargeCheck(void) { switch (BATT_StorageStep) { case 0: if ((BATT_Rsoc >= BATT_FLASH_StorageSoc1) && (BATT_StorageCnt >= BATT_FLASH_StorageTime0)) { BATT_FLAG_WAKEUP = WAKEUP_STOREAGEDSG; BATT_StorageStep = 1; PDSGRLE_On(); } break; case 1: if ((BATT_Rsoc >= BATT_FLASH_StorageSoc2) && (BATT_StorageCnt >= BATT_FLASH_StorageTime1)) { BATT_FLAG_WAKEUP = WAKEUP_STOREAGEDSG; BATT_StorageStep = 2; PDSGRLE_On(); } break; case 2: if ((BATT_Rsoc >= BATT_FLASH_StorageSoc3) && (BATT_StorageCnt >= BATT_FLASH_StorageTime2)) { BATT_FLAG_WAKEUP = WAKEUP_STOREAGEDSG; BATT_StorageStep = 3; PDSGRLE_On(); } break; case 3: if ((BATT_Rsoc >= BATT_FLASH_StorageSoc4) && (BATT_StorageCnt >= BATT_FLASH_StorageTime3)) { BATT_FLAG_WAKEUP = WAKEUP_STOREAGEDSG; BATT_StorageStep = 4; PDSGRLE_On(); } break; default: PDSGRLE_Off(); break; } } //告警标志检测，输出控制信号 void BATT_AlarmCheck(void) { BATT_CellVoltageProcess(); BATT_CellTempProcess(); BATT_VoltCheck(); //电压检测 BATT_CurrentCheck(); //电流检测 BATT_TempCheck(); //温度检测 BATT_BalCheck(); //电压不均衡检测 BATT_ChargeCheck(); //限制容量充电检测 BATT_DischargeCheck(); //限制容量放电检测 BATT_MosfetFailCheck(); //MOS失效检测 BATT_PreDischargeCheck(); //预放检查 //通信超时，清0数据 if ((BATT_FLAG_COMMERR != 0) && (BATT_FLASH_DeviceID == 0) && (CHIP_SIZE != 1)) { MEM_Fill((INT8U *) & (BATT_Vc[BATT_FLASH_CellNum / 2]), 0, BATT_FLASH_CellNum); } /* //低电时芯片进入掉电模式 if (BATT_FLAG_WAKEUP == WAKEUP_PD) { AFE_PowerDown(); } */ #ifdef DSG_NOCHARGE //充电接口未检测到充电器，充电电流大于600mA，设置充电过流标志 if ((KEY_ReadFlag(CRG, Press) == 0) && (BATT_Current > BATT_FLASH_ChgcMin * 2)) { if (BATT_FLAG_CRGE < 2) { BATT_FLAG_CRGE++; } else if (BATT_FLAG_OCC != 2) { BATT_FLAG_OCC = 2; BATT_FetLock(CFET, Lock); } } else if (KEY_ReadFlag(CRG, Press) != 0) //充电器插入，解除充电MOS锁定 { BATT_FLAG_CRGE = 0; BATT_FetLock(CFET, UnLock); } #endif if (BATT_FLAG_CHG != 0) { if ((FET_FLAG_LOCK & DFET) != UnLock) { BATT_FetLock(DFET, UnLock); } BATT_FLAG_UV = 0; BATT_FLAG_PUV = 0; BATT_FLAG_OTD = 0; BATT_FLAG_UTD = 0; BATT_PuvCnt = 0; //2021.01.18 充电清除放电计数 BATT_ClrAlarmFlag(SD); } else { //if(BATT_PowerOnState(POWERON_CRG) == 0) /*if(BATT_FLAG_CRGLINK == 0) //2022.08.19 修正充电器非连接状态，清除充电温度标志 { BATT_FLAG_OTC = 0; BATT_FLAG_UTC = 0; }*/ if (BATT_FLAG_DSG != 0) { BATT_FLAG_OV = 0; BATT_FLAG_POV = 0; BATT_FLAG_OTC = 0; BATT_FLAG_UTC = 0; BATT_PovCnt = 0; //2021.01.18 放电清除放电计数 BATT_OvCnt = 0; BATT_OtcCnt = 0; BATT_UtcCnt = 0; if ((FET_FLAG_LOCK & CFET) != UnLock) { BATT_FetLock(CFET, UnLock); BATT_FLAG_CRGERR = 0; } } else if (BATT_FLAG_CHG != 0) { BATT_PuvCnt = 0; //2021.01.18 充电清除放电计数 BATT_PovCnt = 0; //2021.01.18 放电清除放电计数 BATT_FLAG_POV = 0; BATT_FLAG_PUV = 0; } } //2022.07.06 增加工厂模式，默认开机模式，禁止休眠 //if(BATT_Info.Flash.RunMode == RUN_MODE_FACT) if(BATT_FLAG_RUNMODE == 2) { BATT_FetEn(ALLFET, ENABLE); BATT_PowerOn(POWERON_KEY, ENABLE); } //检测所有标志位，无问题错误打开MOS if ((BATT_FetLockState(DFET) == UnLock) && (BATT_FetEnState(DFET) != 0) && (BATT_PowerOnState(POWERON_ALL) != 0) && //(BATT_FLAG_CRGLOCK == 0) && //(BATT_FLAG_CELL == 0) && (BATT_FLAG_OTD == 0) && (BATT_FLAG_OTF == 0) && (BATT_FLAG_UTD == 0) && (BATT_FLAG_UV == 0) && (BATT_FLAG_PUV == 0) && (BATT_FLAG_OCD == 0) && (BATT_FLAG_AOCD == 0) && (BATT_FLAG_ASCD == 0)) { AFE_Fet(DFET, ENABLE); } else if ((BATT_FetLockState(DFET) != UnLock) || (BATT_FetEnState(DFET) == 0) || (BATT_PowerOnState(POWERON_ALL) == 0) || //(BATT_FLAG_CRGLOCK ==1) || //(BATT_FLAG_CELL != 0) || (BATT_FLAG_OTD == 2) || (BATT_FLAG_OTF == 2) || (BATT_FLAG_UTD == 2) || (BATT_FLAG_UV == 2) || (BATT_FLAG_PUV == 2) || (BATT_FLAG_OCD == 2) || (BATT_FLAG_ASCD != 0) || (BATT_FLAG_AOCD != 0)) { AFE_Fet(DFET, DISABLE); } if ((BATT_FetLockState(CFET) == UnLock) && (BATT_FetEnState(CFET) != 0) && (BATT_PowerOnState(POWERON_ALL) != 0) && //(BATT_FLAG_CRGLOCK == 0) && //(BATT_FLAG_CELL == 0) && #ifdef __BATT_LOW_LOCK__ (BATT_FLAG_CBL == 0) && #endif (BATT_FLAG_OTC == 0) && (BATT_FLAG_OTF == 0) && (BATT_FLAG_UTC == 0) && (BATT_FLAG_OV == 0) && //(BATT_FLAG_POV == 0) && (BATT_FLAG_OCC == 0)) { AFE_Fet(CFET, ENABLE); } else if ((BATT_FetLockState(CFET) != UnLock) || (BATT_FetEnState(CFET) == 0) || (BATT_PowerOnState(POWERON_ALL) == 0) || //(BATT_FLAG_CRGLOCK == 1) || //(BATT_FLAG_CELL != 0) || #ifdef __BATT_LOW_LOCK__ (BATT_FLAG_CBL != 0) || #endif (BATT_FLAG_OTC == 2) || (BATT_FLAG_OTF == 2) || (BATT_FLAG_UTC == 2) || (BATT_FLAG_OV == 2) || //(BATT_FLAG_POV == 2) || (BATT_FLAG_OCC == 2)) { AFE_Fet(CFET, DISABLE); } //通信中断复位芯片 if (AFE_CommCntState() == 2) { AFE_ResetChip(); } } void BATT_ReadInfo(void) { AFE_CommCount(); //读取状态信息 AFE_ReadFlag(); //读取电流 if (AFE_FLAG_CADC != 0) { AFE_ReadCurrent(); //读电流 #ifdef __SH3673060__H AFE_FLAG_CADC = 0; #endif } //开启均衡后，500ms关闭均衡，检测一次电压， if (AFE_BlaCnt < 10) { AFE_BlaCnt++; } else if (AFE_BlaCnt < 15) { AFE_Balance(0x0000); AFE_BlaCnt++; } else if (BATT_FLAG_BALCV != 0) { //AFE_Balance(0x0000); BATT_FLAG_BALCV = 0; AFE_FLAG_VADC = 0; } //读取电压、温度值 if ((AFE_FLAG_VADC != 0) && (BATT_FLAG_BALCV == 0)) { AFE_ReadVoltage(); //读电压 AFE_ReadTemp(); //读温度 BATT_CellVoltageProcess(); BATT_CellTempProcess(); AFE_FLAG_VADC = 0; if (BATT_FLAG_CHG != 0) { BATT_Balance(); //均衡 BATT_FLAG_BALCV = BATT_FLAG_BALE; //均衡使能状态 AFE_BlaCnt = 0; } AFE_ResetCommCnt(); } #if (CHIP_SIZE != 1) //主芯片发送读取从芯片电量的命令 if (BATT_FLASH_DeviceID == 0) { if (AFE_SlaveCommCnt < 5) { AFE_SlaveCommCnt++; } else { AFE_ReadSlaveChip(); AFE_SlaveCommCnt = 0; } } #endif AFE_ClrFlag(); //读取充电器电压，未使用 #if 1 //ADC_Conversion(); if (ADC_FLAG_OK != 0) //CRG电压,0.01V { //BATT_CrgV=(ADC_ReadVolt(ADC_VOLT_CRG)*ADC_CRGV_GAIN)/1000; #if (__VER_HW__ == 1) BATT_TsFet = NTC_Temperature(ADC_ReadVolt(0), ADC_MCU_VREF); #else BATT_Ts[0] = NTC_Temperature(ADC_ReadVolt(0), ADC_MCU_VREF); BATT_Ts[1] = NTC_Temperature(ADC_ReadVolt(1), ADC_MCU_VREF); BATT_Ts[2] = NTC_Temperature(ADC_ReadVolt(2), ADC_MCU_VREF); BATT_TsFet = NTC_Temperature(ADC_ReadVolt(3), ADC_MCU_VREF); #endif } #endif } INT8U BATT_CmdProcess(INT8U Cmd, INT8U *ptr) { INT16U_Str tValue; INT32U_Str tValue1; INT8U tWriteFlash = 0; //INT8U i = 0; IRQ_Disable(); WDT_Clr(); MEM_Copy((INT8U *)&FLASH_Info, (INT8U *) & (BATT_Info.Flash), sizeof(FLASH_Str)); switch (Cmd) { case SCP_CMD_CALI_RES: //校准采样电阻 MEM_Copy(ptr, tValue1.BYTES, 4); //2022.07.16 校准电流升级为32位数，修正校准电流不能大于32A问题。 AFE_CurrentCalibration((INT32S)tValue1.WORDS); tWriteFlash = 1; break; case SCP_CMD_CALI_OFFSET: //校准OFFSET BATT_Info.Flash.CcOffset = CC; //AFE_VoltageOffsetCalibration(); MEM_Copy(ptr, tValue1.BYTES, 4); AFE_VoltageOffsetCalibration((INT32S)tValue1.WORDS); tWriteFlash = 1; break; case SCP_CMD_RST_FLASH: //FLASH数据恢复出厂设置 BQ769x0_FlashInfoInit(); BQ769x0_Init(); break; case SCP_CMD_RST_AFE: //复位前端芯片 BQ769x0_Init(); break; case SCP_CMD_SET_SN: //重新设置SN MEM_Copy(ptr, BATT_Info.Flash.SN, 16); tWriteFlash = 1; break; case SCP_CMD_RST_SOC: //重新计算SOC //BQ769x0_INIT_Flg = 1; SOC_Init(); tWriteFlash = 0; break; case SCP_CMD_SET_RES: //重新设置采样电阻阻值 MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.CcGain, 4); tWriteFlash = 1; break; case SCP_CMD_SET_CYCLE: //重新设置循环次数 case SCP_CMD_SAVE_CYCLE: MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.CycleCount, 2); BATT_Cycle = BATT_Info.Flash.CycleCount; tWriteFlash = 1; break; case SCP_CMD_SAVE_FCC: //2020.04.16 保存容量，不需要调整大小端 BATT_Info.Flash.CycleCount = BATT_Cycle; case SCP_CMD_SET_FCC: //重新设置满充容量 MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.FullChargeCapacity, 2); BATT_FCC = BATT_Info.Flash.FullChargeCapacity; tWriteFlash = 1; break; case SCP_CMD_SET_ID: //重新设置ID条码 MEM_Copy(ptr, BATT_Info.Flash.ManufactureDate, 16); tWriteFlash = 1; break; case SCP_CMD_SET_PARA: //重新设置参数 //i=0; //过充保护电压 MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Ov1, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Ov2, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.OvRel, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Uv1, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Uv2, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.UvRel, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Otc2, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.OtcRel, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Utc2, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.UtcRel, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Otd2, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.OtdRel, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Utd2, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.UtdRel, 2); ptr += 2; //MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Occ1); MEM_Copy(ptr, tValue.BYTES, 2); BATT_Info.Flash.Occ1 = ((INT16S)tValue.HALFWORDS) * 10L; BATT_Info.Flash.OccRel = BATT_Info.Flash.Occ1 / 2; ptr += 2; //MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Occ2); MEM_Copy(ptr, tValue.BYTES, 2); BATT_Info.Flash.Occ2 = ((INT16S)tValue.HALFWORDS) * 10L; ptr += 2; //MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Ocd1); MEM_Copy(ptr, tValue.BYTES, 2); BATT_Info.Flash.Ocd1 = ((INT16S)tValue.HALFWORDS) * 10L; BATT_Info.Flash.OcdRel = BATT_Info.Flash.Ocd1 / 2; ptr += 2; MEM_Copy(ptr, tValue.BYTES, 2); BATT_Info.Flash.Ocd2 = ((INT16S)tValue.HALFWORDS) * 10L; ptr += 2; MEM_Copy(ptr, tValue.BYTES, 2); BATT_Info.Flash.DesignCapacity = tValue.HALFWORDS * 10L; tWriteFlash = 1; break; case SCP_CMD_SAVE_CVLL: //保存低电锁定记录 BATT_Info.Flash.CBLLock = CBL_LOCK; tWriteFlash = 1; break; case SCP_CMD_CLR_CVLL: //清除低电锁定记录 BATT_Info.Flash.CBLLock = CBL_NOLOCK; tWriteFlash = 1; break; case SCP_CMD_PWR5VON: //清除低电锁定记录 BATT_Info.Flash.Pwr5VLock = PWR5V_ON; tWriteFlash = 1; break; case SCP_CMD_PWR5VOFF: //清除低电锁定记录 BATT_Info.Flash.Pwr5VLock = PWR5V_OFF; tWriteFlash = 1; break; case SCP_CMD_RST_VER: //刷新软件版本号 BATT_Info.Flash.HWVersion = __VER_HW__; BATT_Info.Flash.SWVersion = __VER_SW__; tWriteFlash = 1; break; case SCP_CMD_FACT_MODE: //切换到工厂模式 BATT_Info.Flash.RunMode = RUN_MODE_FACT; tWriteFlash = 1; break; case SCP_CMD_NORMOL_MODE: //切换到用户模式 BATT_Info.Flash.RunMode = RUN_MODE_USER; BATT_Info.Flash.Pwr5VLock = PWR5V_OFF; tWriteFlash = 1; break; case SCP_CMD_RST_MCU: //复位MCU进入bootloader RTC_Info.AlarmTime.alarmww = BKP_VAR_IAP; BATT_AlarmLogWrite(ALARM_RST); BATT_EepromInfoSave(); RTC_SetAlarmValue(&RTC_Info.AlarmTime); NVIC_SystemReset(); break; case SCP_CMD_SHUTDOWN: BATT_State = SYS_STA_CMD_SHUTDOWN; BATT_SleepDelayTime(0); BATT_CrgOffLineCntReset(0); break; case SCP_CMD_SETPDSG: //设置预放电流和时间 MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.PreDischargeCurrentMin, 2); ptr += 2; MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.PreDischargeTime, 2); tWriteFlash = 1; break; case SCP_CMD_SETSTRGDSG: //设置存储放电设置 MEM_Copy(ptr, (INT8U *)&BATT_Info.Flash.Storage.Time0, 16); tWriteFlash = 1; break; default: break; } if (tWriteFlash != 0) { BATT_FlashInfoSave(); //数据保存到FLASH } IRQ_Enable(); return (1); } void BATT_PowerDown(void) { INT8U i; for (i = 0; i < 3; i++) { AFE_PowerDown(); //LED_CapDisplay(100, 3); //DELAY_Ms(500); //LED_CapDisplay(0xff, 3); DELAY_Ms(500); } } void BATT_Sleep(void) { INT8U i; if((BATT_FLAG_RUNMODE != 0) || (KEY_ReadFlag(S1, Lpress) != 0)) //2022.03.23 增加短路SWDIO到地进入测试模式，禁止休眠 { BATT_SleepDelayReset(); //禁止进入休眠状态 } if (BATT_SleepSta() != 0) { BATT_UserInfoLog(0); return; } TASK_Tick(DISABLE); //停止任务调度器定时器 //BATT_AlarmLogWrite(ALARM_OFF); BATT_UserInfoLog(1); BATT_EepromInfoSave(); LED_Sleep(); BATT_FetLock(DFET, UnLock); //2019.11.13 增加进入休眠解锁放电MOS if(BATT_PowerOnState(POWERON_KEY) == 0) { AFE_Fet(ALLFET, DISABLE); } TSEN_Off(); if(BATT_Info.Flash.Pwr5VLock == PWR5V_OFF) { PWR5V_Freed(); } BQ769x0_WriteByte(UV_THRESH_ADDR, FLASH_UV_THRESH); //0x0a //低电时芯片进入掉电模式 if ((BATT_FLAG_UV == 2) || (BATT_State == SYS_STA_CMD_SHUTDOWN)) { BATT_State = SYS_STA_SHUTDOWN; BATT_PowerDown(); PWR3V3_Off(); LED_D1On(); //2022.03.28 增加关闭LDO后打开LED，加速余电的放电过程 DELAY_Ms(500); } else if (BATT_FLAG_UV == 0) { BATT_State = SYS_STA_INIT; } //OSC_Sleep(); ADC_Module(DISABLE); KEY_Wakeup(ENABLE); //按键电平唤醒 UART0_Wakeup(ENABLE); //BATT_FLAG_CRGLOCK=0; //BATT_StorageCnt = 0; BATT_FLAG_CRGLINK = 0; BATT_StorageStep = 0; BATT_FLAG_ON = 0; BATT_FLAG_WAKEUP = 0; //清除唤醒标志 do { I2CS_Pull1Up(DISABLE); SLEEP(); //进入休眠 WDT_Clr(); //清看门狗 I2CS_Pull1Up(ENABLE); DELAY_Us(50); if (SOC_Idle < (2 * 60 * 60UL) / 3) //2小时重新计算一次容量 { SOC_Idle ++; } if (BATT_State != SYS_STA_SHUTDOWN) { AFE_ReadFlag(); //读标志位 } if(i < 5) { i++; AFE_FLAG_CADC = 0; AFE_FLAG_VADC = 0; } else { i = 0; } if (AFE_FLAG_CADC != 0) { AFE_ReadCurrent(); //读电流 if ((BATT_Current > BATT_FLASH_ChgcMin) || (BATT_Current < BATT_FLASH_DsgcMin)) { BATT_FLAG_WAKEUP = WAKEUP_CURRENT; } #ifdef __SH367306__H AFE_FLAG_CADC = 0; #endif } if ((AFE_FLAG_VADC != 0) && (BATT_FLAG_UV != 2)) { AFE_ReadVoltage(); //读电压 AFE_ReadTemp(); //读温度 BATT_CellVoltageProcess(); BATT_CellTempProcess(); if ((BATT_VcMin < BATT_FLASH_Uv2) && //单体过放，唤醒MCU (BATT_FLAG_UV != 2)) { BATT_FLAG_WAKEUP = WAKEUP_UV; } if ((BATT_VcMax > BATT_FLASH_Ov2) && //单体过放，唤醒MCU (BATT_FLAG_OV != 2)) { BATT_FLAG_WAKEUP = WAKEUP_OV; } /* if (BATT_VcMin < (BATT_FLASH_Uv2 - 200)) //单体过放，唤醒MCU { BATT_FLAG_WAKEUP = WAKEUP_PD; } */ if ((BATT_TsMin < BATT_FLASH_Utd2) && (BATT_FLAG_UTD != 2)) { BATT_FLAG_WAKEUP = WAKEUP_UT; } if ((BATT_TsMax > BATT_FLASH_Otd2) && (BATT_FLAG_OTD != 2)) { BATT_FLAG_WAKEUP = WAKEUP_OT; } AFE_FLAG_VADC = 0; if (AFE_CommCntState() == 2) { BATT_FLAG_WAKEUP = WAKEUP_PD; } } /* KEY_ReadState(); if ((KEY_ReadFlag(CRG, New) != 0) || (KEY_ReadFlag(S1, New) != 0) ) { BATT_FLAG_WAKEUP = WAKEUP_KEY; } if((BATT_State == SYS_STA_SHUTDOWN) && (KEY_ReadFlag(CRG, New) == 0)) //PD模式 ,仅充电器可以唤醒 { BATT_FLAG_WAKEUP = 0; } */ BATT_StorageDischargeCheck(); //AFE_FetCheck(); } while (BATT_FLAG_WAKEUP == 0); UART0_Wakeup(DISABLE); //关闭串口唤醒中断 //RS485_Mode(RS485_RxMode); //RS485切换到接收模式 KEY_Wakeup(DISABLE); //PWR5V_On(); PWR3V3_On(); TSEN_On(); ADC_Module(ENABLE); //打开ADC if ((BATT_State == SYS_STA_SHUTDOWN) && (BATT_FLAG_WAKEUP == WAKEUP_CRG)) { //BATT_FLAG_PD = 0; AFE_Init(); } BQ769x0_WriteByte(UV_THRESH_ADDR, FLASH_UV3_THRESH); //0x0a BATT_State = SYS_STA_INIT; BATT_PovCnt = 0; BATT_OvCnt = 0; BATT_PuvCnt = 0; BATT_UvCnt = 0; BATT_SleepDelayTime(10); TASK_Tick(ENABLE); //恢复任务调度器定时器 } //option : 0 = 正常记录，1 = 关机记录 void BATT_UserInfoLog(INT8U option) { RTC_BeiJinTimeToTimestamp(); //计算时间戳 if(option == 1) //关机记录关机时间、容量和电压信息 { BATT_Info.Info.UseInfoLog.LastOffTimeStamp = RTC_Info.Timestamp; BATT_Info.Info.UseInfoLog.LastOffCapacity = BATT_RC / 10; BATT_Info.Info.UseInfoLog.LastOffBattVolt = BATT_Voltage / 10; return; } if(BATT_Info.Info.UseInfoLog.ActivationTimeStamp == 0) { BATT_Info.Info.UseInfoLog.ActivationTimeStamp = RTC_Info.Timestamp; } if(BATT_FLAG_STA == STA_CHG) //记录充电时间 { BATT_Info.Info.UseInfoLog.ChargeTimeCount ++; BATT_Info.Info.UseInfoLog.LastChargeTimeStamp = RTC_Info.Timestamp; BATT_Info.Info.UseInfoLog.LastChargeCapacity = BATT_RC / 10; BATT_Info.Info.UseInfoLog.LastChargeBattVolt = BATT_Voltage / 10; } BATT_Info.Info.UseInfoLog.PowerOnTimeCount ++; //记录开机时间 if(BATT_Current > BATT_Info.Info.UseInfoLog.MaxChargeCurrent) //记录最大充电电流 { BATT_Info.Info.UseInfoLog.MaxChargeCurrent = BATT_Current; } if(BATT_Current < BATT_Info.Info.UseInfoLog.MaxDischargeCurrent) //记录最大放电电流 { BATT_Info.Info.UseInfoLog.MaxDischargeCurrent = BATT_Current; } } //记录报警信息log void BATT_AlarmLogWrite(Alarm_t AlarmNum) { INT16U oldAlarmNum; INT16U oldTimestamp; RTC_BeiJinTimeToTimestamp(); if ((BATT_Info.Info.AlarmLog.Index >= BATT_ALARMLOG_SIZE) || (BATT_Info.Info.AlarmLog.Index == 0)) { BATT_Info.Info.AlarmLog.Index = 0; oldAlarmNum = BATT_Info.Info.AlarmLog.AlarmTimeStamp[BATT_ALARMLOG_SIZE - 1].AlarmNum; oldTimestamp = BATT_Info.Info.AlarmLog.AlarmTimeStamp[BATT_ALARMLOG_SIZE - 1].UTC[0]; } else { oldAlarmNum = BATT_Info.Info.AlarmLog.AlarmTimeStamp[BATT_Info.Info.AlarmLog.Index - 1].AlarmNum; oldTimestamp = BATT_Info.Info.AlarmLog.AlarmTimeStamp[BATT_Info.Info.AlarmLog.Index - 1].UTC[0]; } if((AlarmNum == oldAlarmNum) || ((INT16U)RTC_Info.Timestamp == oldTimestamp)) { return; } BATT_Info.Info.AlarmLog.AlarmTimeStamp[BATT_Info.Info.AlarmLog.Index].AlarmNum = AlarmNum; MEM_Copy((INT8U *)&RTC_Info.Timestamp, (INT8U *) & (BATT_Info.Info.AlarmLog.AlarmTimeStamp[BATT_Info.Info.AlarmLog.Index].UTC[0]), 4); BATT_Info.Info.AlarmLog.Index ++; if(BATT_Info.Info.AlarmLog.AlarmCnt[AlarmNum] < 65000) //报警次数统计 { BATT_Info.Info.AlarmLog.AlarmCnt[AlarmNum]++; } } INT16U BATT_AlarmNumread(void) { INT8U tIndex = BATT_Info.Info.AlarmLog.Index; if(tIndex > 0) { tIndex = tIndex - 1; } return(BATT_Info.Info.AlarmLog.AlarmTimeStamp[tIndex].AlarmNum); } //保存EEPROM数据 void BATT_EepromInfoSave(void) { EEPROM_Write(EEPROM_ADDR_BALANECE_INFO, (INT8U *) & (BATT_Info.Info.BalanceStats), sizeof(BalanceStats_Str)); EEPROM_Write(EEPROM_ADDR_USE_INFO, (INT8U *) & (BATT_Info.Info.UseInfoLog), sizeof(UseInfoLog_Str)); EEPROM_Write(EEPROM_ADDR_ALARMCNT_INFO, (INT8U *) & (BATT_Info.Info.AlarmCount), sizeof(AlarmCount_Str)); EEPROM_Write(EEPROM_ADDR_ALARMLOG_INFO, (INT8U *) & (BATT_Info.Info.AlarmLog), sizeof(AlarmLog_Str)); } void IT_Handler(void) { INTC_ClearPendingIRQ(IT_IRQn); NVIC_ClearPendingIRQ(IT_IRQn); } //5V使能时间单位1S void BATT_P5vOnTime(INT32U Value) { BATT_P5vCnt = Value * (1000 / BATT_P5VON_TIME_BASE); PWR5V_On(); } void BATT_P5vCount(void) { if(BATT_P5vCnt > 0) { BATT_P5vCnt --; } else if(BATT_Info.Flash.Pwr5VLock == PWR5V_OFF) { PWR5V_Freed(); } } //充电器移除延时时间单位1S void BATT_CrgOffLineCntReset(INT32U Value) { BATT_CrgCnt = Value * (1000 / BATT_CRGOFFLINE_TIME_BASE); } void BATT_CrgOffLineCount(void) { if(BATT_CrgCnt > 0) { BATT_CrgCnt--; } else if(BATT_FLAG_CRGLINK == 1) { BATT_FLAG_CRGLINK = 2; BATT_PowerOn(POWERON_CRG, DISABLE); if(BATT_Info.Flash.Pwr5VLock == PWR5V_OFF) { PWR5V_Freed(); } } } //休眠延时时间单位1S void BATT_SleepDelayTime(INT32U Value) { BATT_Info.SleepCnt = Value * (1000 / BATT_SLEEP_TIME_BASE); } void BATT_SleepCount(void) { if(BATT_Info.SleepCnt > 0) { BATT_Info.SleepCnt--; } } //设置时间单位1ms void BATT_PFetOffTime(INT32U Value) { BATT_PFetCnt = Value / BATT_PFET_TIME_BASE; } void BATT_PFetCount(void) { if(BATT_PFetCnt > 0) { BATT_PFetCnt --; } else if(BATT_FLAG_PCFET != 0) { BATT_FLAG_PCFET = 0; } } //设置时间单位1ms void BATT_AlarmDelayTime(INT32U Value) { BATT_FLAG_ALARM = 1; BATT_AlarmCnt = Value / BATT_ALARM_TIME_BASE; } void BATT_AlarmCount(void) { if(BATT_AlarmCnt > 0) { BATT_AlarmCnt--; } else { BATT_FLAG_ALARM = 0; } } void BATT_PwrReleaseCntReset(INT16U Value) { BATT_PwrReleaseCnt = Value * 10; } void BATT_PwrReleaseCount(void) { if(BATT_PwrReleaseCnt > 0) { BATT_PwrReleaseCnt --; } }