989 lines
33 KiB
C
989 lines
33 KiB
C
/**
|
|
******************************************************************************
|
|
* @file alarm.c
|
|
* @author AMG Energy Solution Team
|
|
* @version V1.0.0
|
|
* @date 07-Feb-2022
|
|
* @brief This file provides all the codes of alarm process functions.
|
|
******************************************************************************
|
|
* @attention
|
|
*
|
|
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
|
|
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
|
|
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
|
|
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
|
|
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
|
|
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
|
|
*
|
|
* <h2><center>© COPYRIGHT 2022 AMG</center></h2>
|
|
******************************************************************************
|
|
*/
|
|
|
|
/** @addtogroup mBMS2
|
|
* @{
|
|
*/
|
|
|
|
/* Includes ------------------------------------------------------------------*/
|
|
#include "afe_comm.h"
|
|
#include "asutil.h"
|
|
#include "console.h"
|
|
#include "device_param.h"
|
|
#include "dflash_sf1.h"
|
|
#include "includes.h"
|
|
#include "temp.h"
|
|
#include "vi.h"
|
|
|
|
/* Private typedef -----------------------------------------------------------*/
|
|
/* Private define ------------------------------------------------------------*/
|
|
|
|
#define SLEEP_VOLTAGE 4500
|
|
#define WAKEUP_VOLTAGE 4600
|
|
#define SLEEP_MODE_TIME 60 * 1000
|
|
#define CELL_DEVIATION_CHECK_VOLTAGE 4500
|
|
#define CV_DIFF_PROTECT_HOLD_TIME \
|
|
(24UL * 60UL * 60UL * 1000UL) // 24 hours in ms (86,400,000 ms)
|
|
#define TEMP_DIFF_PROTECT_THRESHOLD 30 // 3.0C (0.1C unit)
|
|
#define TEMP_DIFF_PROTECT_HOLD_TIME \
|
|
(24UL * 60UL * 60UL * 1000UL) // 24 hours in ms
|
|
|
|
#define OCC_CRITICAL_CLEAR_TIME 60 * 1000
|
|
#define PRECHARGE_TIME_DEFAULT 2 * 1000
|
|
|
|
/* Private macro -------------------------------------------------------------*/
|
|
/* Private variables ---------------------------------------------------------*/
|
|
|
|
uint8_t SleepMode = false;
|
|
uint8_t DeepSleepMode = false;
|
|
uint32_t smode_tick = 60 * 1000;
|
|
|
|
uint32_t PreChargeTime = PRECHARGE_TIME_DEFAULT;
|
|
uint32_t OCCTime = 0;
|
|
uint32_t OCDTime = 0;
|
|
|
|
uint32_t CV_Diff_ProtectTime = CV_DIFF_PROTECT_HOLD_TIME;
|
|
uint32_t CV_Diff_ProtectHoldTime =
|
|
CV_DIFF_PROTECT_HOLD_TIME; // Default: 24 hours (configurable in RAM)
|
|
|
|
uint32_t Temp_Diff_ProtectTime = TEMP_DIFF_PROTECT_HOLD_TIME;
|
|
uint32_t Temp_Diff_ProtectHoldTime = TEMP_DIFF_PROTECT_HOLD_TIME;
|
|
uint16_t Temp_Diff_Threshold =
|
|
TEMP_DIFF_PROTECT_THRESHOLD; // Default: 30 (3.0 deg C)
|
|
|
|
int32_t OCC_Occur_Current;
|
|
int32_t OCD_Occur_Current;
|
|
|
|
uint32_t OCC_CRITICAL_Tick = 60 * 1000;
|
|
uint8_t OCC_Fail_Count = 0;
|
|
uint8_t OCC_3Times_Fail = false;
|
|
|
|
/* Private function prototypes -----------------------------------------------*/
|
|
void dec_precharge_time(uint32_t tick);
|
|
void dec_occ_time(uint32_t tick);
|
|
void dec_occ_critical_time(uint32_t tick);
|
|
void dec_ocd_time(uint32_t tick);
|
|
void dec_sleepmode_time(uint32_t tick);
|
|
void dec_cv_diff_time(uint32_t tick);
|
|
void dec_temp_diff_time(uint32_t tick);
|
|
|
|
void ProcessSafety_COV(void);
|
|
void ProcessSafety_CUV(void);
|
|
void ProcessSafety_OTA(void);
|
|
void ProcessSafety_LTA(void);
|
|
void ProcessSafety_OCC(void);
|
|
void ProcessSafety_OCD(void);
|
|
void ProcessSafety_SOC(void);
|
|
void ProcessSafety_CellVoltageDiff(void);
|
|
void ProcessSafety_TempDiff(void);
|
|
|
|
void Process_FetControl(void);
|
|
void ProcessStatusCheck(void);
|
|
|
|
/* Private functions ---------------------------------------------------------*/
|
|
|
|
void ClearODCTick(void) {
|
|
OCDTime = device_param.safety.current.OC_Dsg_Rec_Time * 1000;
|
|
}
|
|
|
|
void dec_alarm_tick(uint32_t tick) {
|
|
dec_precharge_time(tick);
|
|
dec_occ_time(tick);
|
|
dec_occ_critical_time(tick);
|
|
dec_ocd_time(tick);
|
|
dec_cv_diff_time(tick);
|
|
dec_temp_diff_time(tick);
|
|
dec_sleepmode_time(tick);
|
|
}
|
|
|
|
void dec_sleepmode_time(uint32_t tick) {
|
|
if (smode_tick > 0) {
|
|
if (smode_tick > tick)
|
|
smode_tick -= tick;
|
|
else
|
|
smode_tick = 0;
|
|
}
|
|
}
|
|
|
|
uint8_t GetSleepMode(void) { return SleepMode; }
|
|
|
|
void SetSleepMode(uint8_t mode) { SleepMode = mode; }
|
|
|
|
uint8_t GetDeepSleepMode(void) { return DeepSleepMode; }
|
|
|
|
void SetDeepSleepMode(uint8_t mode) { DeepSleepMode = mode; }
|
|
|
|
void CheckSleepMode(void) {
|
|
if (GetSleepMode() == 1) {
|
|
if (device_status.op_status == 1) {
|
|
SetSleepMode(0);
|
|
smode_tick = SLEEP_MODE_TIME;
|
|
}
|
|
} else {
|
|
if (((device_status.protect.bit.cell_under_voltage) ||
|
|
(device_status.protect.bit.under_voltage)) &&
|
|
(device_value.BatVoltage < SLEEP_VOLTAGE)) {
|
|
if (smode_tick == 0)
|
|
SetSleepMode(1);
|
|
} else {
|
|
smode_tick = SLEEP_MODE_TIME;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ProcessAlarm(void) {
|
|
if (device_status.battery_status.bit.INIT) {
|
|
device_status.protect.bit.afe_fail =
|
|
device_status.error.bit.AFE | device_status.error.bit.afe_fail;
|
|
|
|
if (device_status.error.bit.AFE == false) {
|
|
ProcessSafety_COV();
|
|
ProcessSafety_CUV();
|
|
}
|
|
ProcessSafety_OTA();
|
|
ProcessSafety_LTA();
|
|
ProcessSafety_OCC();
|
|
ProcessSafety_OCD();
|
|
ProcessSafety_SOC();
|
|
ProcessSafety_CellVoltageDiff();
|
|
ProcessSafety_TempDiff();
|
|
|
|
Process_FetControl();
|
|
|
|
// CheckSleepMode();
|
|
}
|
|
ProcessStatusCheck();
|
|
}
|
|
|
|
void dec_precharge_time(uint32_t tick) {
|
|
if (PreChargeTime > 0) {
|
|
if (PreChargeTime > tick)
|
|
PreChargeTime -= tick;
|
|
else
|
|
PreChargeTime = 0;
|
|
}
|
|
}
|
|
|
|
void ProcessSafety_COV(void) {
|
|
/* Cell Over Voltage Check */
|
|
for (int i = 0; i < DEVICE_MAX_CELL; i++) {
|
|
/* Cell Over Voltage Protection */
|
|
if (device_status.cov_protection_cell.uValue & BIT(i)) {
|
|
// Release check
|
|
if (device_value.Cell.voltage[i] <
|
|
device_param.safety.voltage.COV_Recovery)
|
|
device_status.cov_protection_cell.uValue &= ~BIT(i);
|
|
} else {
|
|
// Alarm check
|
|
if (device_value.Cell.voltage[i] >
|
|
device_param.safety.voltage.COV_Threshold)
|
|
device_status.cov_protection_cell.uValue |= BIT(i);
|
|
}
|
|
/* Cell Over Voltage Warning */
|
|
if (device_status.cov_warning_cell.uValue & BIT(i)) {
|
|
// Release check
|
|
if (device_value.Cell.voltage[i] <
|
|
device_param.safety.voltage.COV_Recovery)
|
|
device_status.cov_warning_cell.uValue &= ~BIT(i);
|
|
} else {
|
|
// Alarm check
|
|
if (device_value.Cell.voltage[i] >
|
|
device_param.safety.voltage.COV_Warning)
|
|
device_status.cov_warning_cell.uValue |= BIT(i);
|
|
}
|
|
}
|
|
if (device_status.cov_protection_cell.uValue != 0)
|
|
device_status.protect.bit.cell_over_voltage = true;
|
|
else
|
|
device_status.protect.bit.cell_over_voltage = false;
|
|
|
|
if (device_status.cov_warning_cell.uValue != 0)
|
|
device_status.warning.bit.cell_over_voltage = true;
|
|
else
|
|
device_status.warning.bit.cell_over_voltage = false;
|
|
|
|
/* System Over charge protection */
|
|
if (device_status.protect.bit.over_voltage) {
|
|
// Release check
|
|
if (device_value.BatVoltage < device_param.safety.voltage.SOV_Recovery)
|
|
device_status.protect.bit.over_voltage = false;
|
|
} else {
|
|
// Alarm check
|
|
if (device_value.BatVoltage > device_param.safety.voltage.SOV_Threshold)
|
|
device_status.protect.bit.over_voltage = true;
|
|
}
|
|
|
|
/* System Over Voltage Warning */
|
|
if (device_status.warning.bit.over_voltage) {
|
|
// Release check
|
|
if (device_value.BatVoltage < device_param.safety.voltage.SOV_Recovery)
|
|
device_status.warning.bit.over_voltage = false;
|
|
} else {
|
|
// Alarm check
|
|
if (device_value.BatVoltage > device_param.safety.voltage.SOV_Warning)
|
|
device_status.warning.bit.over_voltage = true;
|
|
}
|
|
}
|
|
|
|
void ProcessSafety_CUV(void) {
|
|
/* Cell under voltage check */
|
|
for (int i = 0; i < DEVICE_MAX_CELL; i++) {
|
|
/* Cell under voltage protection */
|
|
if (device_status.cuv_protection_cell.uValue & BIT(i)) {
|
|
// Recovery Check
|
|
// if (device_value.Cell.voltage[i] >
|
|
//device_param.safety.voltage.CUV_Recovery)
|
|
// device_status.cuv_protection_cell.uValue
|
|
//&= ~BIT(i);
|
|
} else {
|
|
// Protection Check
|
|
if (device_value.Cell.voltage[i] <
|
|
device_param.safety.voltage.CUV_Threshold)
|
|
device_status.cuv_protection_cell.uValue |= BIT(i);
|
|
}
|
|
|
|
/* Cell under voltage warning */
|
|
if (device_status.cuv_warning_cell.uValue & BIT(i)) {
|
|
// Recovery Check
|
|
if (device_value.Cell.voltage[i] >
|
|
device_param.safety.voltage.CUV_Recovery)
|
|
device_status.cuv_warning_cell.uValue &= ~BIT(i);
|
|
} else {
|
|
// Warning Check
|
|
if (device_value.Cell.voltage[i] <
|
|
device_param.safety.voltage.CUV_Warning)
|
|
device_status.cuv_warning_cell.uValue |= BIT(i);
|
|
}
|
|
}
|
|
|
|
if (device_status.cuv_protection_cell.uValue != 0)
|
|
device_status.protect.bit.cell_under_voltage = true;
|
|
else
|
|
device_status.protect.bit.cell_under_voltage = false;
|
|
|
|
if (device_status.cuv_warning_cell.uValue != 0)
|
|
device_status.warning.bit.cell_under_voltage = true;
|
|
else
|
|
device_status.warning.bit.cell_under_voltage = false;
|
|
|
|
/* Cell Voltage Fault Check (Below 1000mV or above 4500mV abnormal voltage
|
|
* cutoff charging) */
|
|
uint8_t cell_fault = false;
|
|
for (int i = 0; i < DEVICE_MAX_CELL; i++) {
|
|
if ((device_value.Cell.voltage[i] <= 1000) ||
|
|
(device_value.Cell.voltage[i] >= 4500)) {
|
|
cell_fault = true;
|
|
break;
|
|
}
|
|
}
|
|
if (cell_fault) {
|
|
device_status.error.bit.afe_fail = true;
|
|
device_status.protect.bit.afe_fail = true;
|
|
} else {
|
|
device_status.error.bit.afe_fail = false;
|
|
}
|
|
|
|
/* System under voltage protection */
|
|
if (device_status.protect.bit.under_voltage) {
|
|
// // Release check
|
|
// if (device_value.BatVoltage >
|
|
//device_param.safety.voltage.SUV_Recovery)
|
|
// device_status.protection.bit.under_voltage = false;
|
|
} else {
|
|
// Alarm check
|
|
if (device_value.BatVoltage < device_param.safety.voltage.SUV_Threshold)
|
|
device_status.protect.bit.under_voltage = true;
|
|
}
|
|
|
|
/* System under voltage warning */
|
|
if (device_status.warning.bit.under_voltage) {
|
|
// Release check
|
|
if (device_value.BatVoltage > device_param.safety.voltage.SUV_Recovery)
|
|
device_status.warning.bit.under_voltage = false;
|
|
} else {
|
|
// Alarm check
|
|
if (device_value.BatVoltage < device_param.safety.voltage.SUV_Warning)
|
|
device_status.warning.bit.under_voltage = true;
|
|
}
|
|
|
|
if (device_status.protect.bit.under_voltage) {
|
|
if (device_status.op_status == 0x0001) {
|
|
device_status.protect.bit.under_voltage = 0;
|
|
}
|
|
}
|
|
if (device_status.protect.bit.cell_under_voltage) {
|
|
if (device_status.op_status == 0x0001) {
|
|
device_status.protect.bit.cell_under_voltage = 0;
|
|
device_status.cuv_protection_cell.uValue = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ProcessSafety_OTA(void) {
|
|
/* Temperature Sensor Fault Check */
|
|
if (IsTempSensorFailed()) {
|
|
device_status.error.bit.temp_sensor = true;
|
|
} else {
|
|
device_status.error.bit.temp_sensor = false;
|
|
}
|
|
|
|
/* Charge High Temperature */
|
|
for (int i = 0; i < (DEVICE_MAX_TEMP - 2); i++) {
|
|
if (ADState(i) != AD_FAIL) {
|
|
int16_t aTemp = device_value.Temp.temperature[i];
|
|
|
|
/* Over Temperature Charge Protection */
|
|
if (device_status.otc_protection_temp.uValue & BIT(i)) {
|
|
// Recovery Check
|
|
if (aTemp < device_param.safety.temperature.OT_Chg_Recovery)
|
|
device_status.otc_protection_temp.uValue &= ~BIT(i);
|
|
} else {
|
|
// Protection Check, when charging
|
|
if (device_status.battery_status.bit.MD == 0) {
|
|
if (aTemp > device_param.safety.temperature.OT_Chg_Threshold)
|
|
device_status.otc_protection_temp.uValue |= BIT(i);
|
|
}
|
|
}
|
|
/* Over Temperature Charge Warning */
|
|
if (device_status.otc_warning_temp.uValue & BIT(i)) {
|
|
// Recovery Check
|
|
if (aTemp < device_param.safety.temperature.OT_Chg_Recovery)
|
|
device_status.otc_warning_temp.uValue &= ~BIT(i);
|
|
} else {
|
|
// Warning Check, when charging
|
|
if (device_status.battery_status.bit.MD == 0) {
|
|
if (aTemp > device_param.safety.temperature.OT_Chg_Warning)
|
|
device_status.otc_warning_temp.uValue |= BIT(i);
|
|
}
|
|
}
|
|
} else {
|
|
device_status.otc_warning_temp.uValue |= BIT(i);
|
|
device_status.otc_protection_temp.uValue &= ~BIT(i);
|
|
}
|
|
}
|
|
|
|
/* OTC Protection */
|
|
if (device_status.otc_protection_temp.uValue != 0)
|
|
device_status.protect.bit.chg_high_temp = true;
|
|
else
|
|
device_status.protect.bit.chg_high_temp = false;
|
|
|
|
/* OTC Warning */
|
|
if (device_status.otc_warning_temp.uValue != 0)
|
|
device_status.warning.bit.chg_high_temp = true;
|
|
else
|
|
device_status.warning.bit.chg_high_temp = false;
|
|
|
|
/* High Temperature Discharge */
|
|
for (int i = 0; i < (DEVICE_MAX_TEMP - 2); i++) {
|
|
if (ADState(i) != AD_FAIL) {
|
|
int16_t aTemp = device_value.Temp.temperature[i];
|
|
|
|
/* Over Temperature Discharge Protection */
|
|
if (device_status.otd_protection_temp.uValue & BIT(i)) {
|
|
// Recovery Check
|
|
if (aTemp < device_param.safety.temperature.OT_Dsg_Recovery)
|
|
device_status.otd_protection_temp.uValue &= ~BIT(i);
|
|
} else {
|
|
// Protection Check, when charging
|
|
if (device_status.battery_status.bit.MD == 1) {
|
|
if (aTemp > device_param.safety.temperature.OT_Dsg_Threshold)
|
|
device_status.otd_protection_temp.uValue |= BIT(i);
|
|
}
|
|
}
|
|
/* Over Temperature Charge Warning */
|
|
if (device_status.otd_warning_temp.uValue & BIT(i)) {
|
|
// Recovery Check
|
|
if (aTemp < device_param.safety.temperature.OT_Dsg_Recovery)
|
|
device_status.otd_warning_temp.uValue &= ~BIT(i);
|
|
} else {
|
|
// Warning Check, when charging
|
|
if (device_status.battery_status.bit.MD == 1) {
|
|
if (aTemp > device_param.safety.temperature.OT_Dsg_Warning)
|
|
device_status.otd_warning_temp.uValue |= BIT(i);
|
|
}
|
|
}
|
|
} else {
|
|
device_status.otd_warning_temp.uValue |= BIT(i);
|
|
device_status.otd_protection_temp.uValue &= ~BIT(i);
|
|
}
|
|
}
|
|
|
|
/* OTD Protection */
|
|
if (device_status.otd_protection_temp.uValue != 0)
|
|
device_status.protect.bit.dsg_high_temp = true;
|
|
else
|
|
device_status.protect.bit.dsg_high_temp = false;
|
|
|
|
/* OTD Warning */
|
|
if (device_status.otd_warning_temp.uValue != 0)
|
|
device_status.warning.bit.dsg_high_temp = true;
|
|
else
|
|
device_status.warning.bit.dsg_high_temp = false;
|
|
}
|
|
|
|
void ProcessSafety_LTA(void) {
|
|
/* Charge Low Temperature */
|
|
for (int i = 0; i < (DEVICE_MAX_TEMP - 2); i++) {
|
|
if (ADState(i) != AD_FAIL) {
|
|
int16_t aTemp = device_value.Temp.temperature[i];
|
|
|
|
/* Over Temperature Charge Protection */
|
|
if (device_status.ltc_protection_temp.uValue & BIT(i)) {
|
|
// Recovery Check
|
|
if (aTemp > device_param.safety.temperature.LT_Chg_Recovery)
|
|
device_status.ltc_protection_temp.uValue &= ~BIT(i);
|
|
} else {
|
|
// Protection Check, when charging
|
|
if (device_status.battery_status.bit.MD == 0) {
|
|
if (aTemp < device_param.safety.temperature.LT_Chg_Threshold)
|
|
device_status.ltc_protection_temp.uValue |= BIT(i);
|
|
}
|
|
}
|
|
/* Low Temperature Charge Warning */
|
|
if (device_status.ltc_warning_temp.uValue & BIT(i)) {
|
|
// Recovery Check
|
|
if (aTemp > device_param.safety.temperature.LT_Chg_Recovery)
|
|
device_status.ltc_warning_temp.uValue &= ~BIT(i);
|
|
} else {
|
|
// Warning Check, when charging
|
|
if (device_status.battery_status.bit.MD == 0) {
|
|
if (aTemp < device_param.safety.temperature.LT_Chg_Warning)
|
|
device_status.ltc_warning_temp.uValue |= BIT(i);
|
|
}
|
|
}
|
|
} else {
|
|
device_status.ltc_warning_temp.uValue |= BIT(i);
|
|
device_status.ltc_protection_temp.uValue &= ~BIT(i);
|
|
}
|
|
}
|
|
|
|
/* LTC Protection */
|
|
if (device_status.ltc_protection_temp.uValue != 0)
|
|
device_status.protect.bit.chg_low_temp = true;
|
|
else
|
|
device_status.protect.bit.chg_low_temp = false;
|
|
|
|
/* LTC Warning */
|
|
if (device_status.ltc_warning_temp.uValue != 0)
|
|
device_status.warning.bit.chg_low_temp = true;
|
|
else
|
|
device_status.warning.bit.chg_low_temp = false;
|
|
|
|
/* Low Temperature Discharge */
|
|
for (int i = 0; i < (DEVICE_MAX_TEMP - 2); i++) {
|
|
if (ADState(i) != AD_FAIL) {
|
|
int16_t aTemp = device_value.Temp.temperature[i];
|
|
|
|
/* Low Temperature Discharge Protection */
|
|
if (device_status.ltd_protection_temp.uValue & BIT(i)) {
|
|
// Recovery Check
|
|
if (aTemp > device_param.safety.temperature.LT_Dsg_Recovery)
|
|
device_status.ltd_protection_temp.uValue &= ~BIT(i);
|
|
} else {
|
|
// Protection Check, when charging
|
|
if (device_status.battery_status.bit.MD == 1) {
|
|
if (aTemp < device_param.safety.temperature.LT_Dsg_Threshold)
|
|
device_status.ltd_protection_temp.uValue |= BIT(i);
|
|
}
|
|
}
|
|
/* Over Temperature Charge Warning */
|
|
if (device_status.ltd_warning_temp.uValue & BIT(i)) {
|
|
// Recovery Check
|
|
if (aTemp > device_param.safety.temperature.LT_Dsg_Recovery)
|
|
device_status.ltd_warning_temp.uValue &= ~BIT(i);
|
|
} else {
|
|
// Warning Check, when charging
|
|
if (device_status.battery_status.bit.MD == 1) {
|
|
if (aTemp < device_param.safety.temperature.LT_Dsg_Warning)
|
|
device_status.ltd_warning_temp.uValue |= BIT(i);
|
|
}
|
|
}
|
|
} else {
|
|
device_status.ltd_warning_temp.uValue |= BIT(i);
|
|
device_status.ltd_protection_temp.uValue &= ~BIT(i);
|
|
}
|
|
}
|
|
|
|
/* LTD Protection */
|
|
if (device_status.ltd_protection_temp.uValue != 0)
|
|
device_status.protect.bit.dsg_low_temp = true;
|
|
else
|
|
device_status.protect.bit.dsg_low_temp = false;
|
|
|
|
/* LTD Warning */
|
|
if (device_status.ltd_warning_temp.uValue != 0)
|
|
device_status.warning.bit.dsg_low_temp = true;
|
|
else
|
|
device_status.warning.bit.dsg_low_temp = false;
|
|
}
|
|
|
|
void dec_occ_time(uint32_t tick) {
|
|
if (OCCTime > 0) {
|
|
if (OCCTime > tick)
|
|
OCCTime -= tick;
|
|
else
|
|
OCCTime = 0;
|
|
}
|
|
}
|
|
|
|
void dec_occ_critical_time(uint32_t tick) {
|
|
if (OCC_CRITICAL_Tick > 0) {
|
|
if (OCC_CRITICAL_Tick > tick)
|
|
OCC_CRITICAL_Tick -= tick;
|
|
else
|
|
OCC_CRITICAL_Tick = 0;
|
|
}
|
|
}
|
|
|
|
void ProcessSafety_OCC(void) {
|
|
/* Over charge current protection */
|
|
if (device_status.protect.bit.chg_over_current) {
|
|
// release check: DO NOT auto-recover if repeated OCC fail occurred
|
|
// (Latched)
|
|
if (OCC_3Times_Fail) {
|
|
device_status.protect.bit.chg_over_current = true;
|
|
} else {
|
|
if ((device_value.Current / 1) <
|
|
(device_param.safety.current.OC_Chg_Recovery * 10)) {
|
|
if (OCCTime == 0)
|
|
device_status.protect.bit.chg_over_current = false;
|
|
} else {
|
|
OCCTime = device_param.safety.current.OC_Chg_Rec_Time * 1000;
|
|
OCC_CRITICAL_Tick = OCC_CRITICAL_CLEAR_TIME;
|
|
}
|
|
}
|
|
} else {
|
|
// alarm check
|
|
if ((device_value.Current / 1) >
|
|
(device_param.safety.current.OC_Chg_Threshold * 10)) {
|
|
OCC_Occur_Current = device_value.Current;
|
|
device_status.protect.bit.chg_over_current = true;
|
|
OCCTime = device_param.safety.current.OC_Chg_Rec_Time * 1000;
|
|
|
|
if (OCC_Fail_Count < 3) {
|
|
OCC_Fail_Count++;
|
|
OCC_CRITICAL_Tick = OCC_CRITICAL_CLEAR_TIME;
|
|
}
|
|
if (OCC_Fail_Count >= 3) {
|
|
OCC_3Times_Fail = true;
|
|
OCC_CRITICAL_Tick = OCC_CRITICAL_CLEAR_TIME;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (OCC_3Times_Fail == false) {
|
|
if (OCC_Fail_Count > 0) {
|
|
if (OCC_CRITICAL_Tick == 0) {
|
|
OCC_Fail_Count = 0;
|
|
}
|
|
}
|
|
} else {
|
|
device_status.protect.bit.chg_over_current = true;
|
|
}
|
|
|
|
device_status.battery_status.bit.TCA = OCC_3Times_Fail;
|
|
device_status.protect.bit.critial_over_current = OCC_3Times_Fail;
|
|
|
|
/* Over current charge warning */
|
|
if (device_status.warning.bit.chg_over_current) {
|
|
// release check
|
|
if ((device_value.Current / 1) <
|
|
(device_param.safety.current.OC_Chg_Recovery * 10))
|
|
device_status.warning.bit.chg_over_current = false;
|
|
} else {
|
|
// alarm check
|
|
if ((device_value.Current / 1) >
|
|
(device_param.safety.current.OC_Chg_Warning * 10))
|
|
device_status.warning.bit.chg_over_current = true;
|
|
}
|
|
}
|
|
|
|
void dec_ocd_time(uint32_t tick) {
|
|
if (OCDTime > tick)
|
|
OCDTime -= tick;
|
|
else
|
|
OCDTime = 0;
|
|
}
|
|
|
|
void ProcessSafety_OCD(void) {
|
|
/* Over current discharge protection */
|
|
if (device_status.protect.bit.dsg_over_current) {
|
|
// release check
|
|
if ((device_value.Current / 1) >
|
|
(device_param.safety.current.OC_Dsg_Recovery * 10)) {
|
|
if (OCDTime == 0)
|
|
device_status.protect.bit.dsg_over_current = false;
|
|
} else
|
|
OCDTime = device_param.safety.current.OC_Dsg_Rec_Time * 1000;
|
|
} else {
|
|
// alarm check
|
|
if ((device_value.Current / 1) <
|
|
(device_param.safety.current.OC_Dsg_Threshold * 10)) {
|
|
OCD_Occur_Current = device_value.Current;
|
|
device_status.protect.bit.dsg_over_current = true;
|
|
OCDTime = device_param.safety.current.OC_Dsg_Rec_Time * 1000;
|
|
}
|
|
}
|
|
|
|
/* Over current discharge warning */
|
|
if (device_status.warning.bit.dsg_over_current) {
|
|
// release check
|
|
if ((device_value.Current / 1) >
|
|
(device_param.safety.current.OC_Dsg_Recovery * 10))
|
|
device_status.warning.bit.dsg_over_current = false;
|
|
} else {
|
|
// alarm check
|
|
if ((device_value.Current / 1) <
|
|
(device_param.safety.current.OC_Dsg_Warning * 10))
|
|
device_status.warning.bit.dsg_over_current = true;
|
|
}
|
|
}
|
|
|
|
void ProcessSafety_SOC(void) {
|
|
/* Low capacity warning */
|
|
if (device_status.warning.bit.low_capacity) {
|
|
// release check
|
|
if ((device_value.RelativeStateOfCharge) >
|
|
(device_param.safety.soc.Low_Soc_Recovery * 10))
|
|
device_status.warning.bit.low_capacity = false;
|
|
} else {
|
|
// alarm check
|
|
if ((device_value.RelativeStateOfCharge) <
|
|
(device_param.safety.soc.Low_Soc_Warning * 10))
|
|
device_status.warning.bit.low_capacity = true;
|
|
}
|
|
}
|
|
|
|
void dec_cv_diff_time(uint32_t tick) {
|
|
if (CV_Diff_ProtectTime > tick)
|
|
CV_Diff_ProtectTime -= tick;
|
|
else
|
|
CV_Diff_ProtectTime = 0;
|
|
}
|
|
|
|
uint32_t GetCvDiffTime(void)
|
|
{
|
|
return (CV_Diff_ProtectTime / 1000);
|
|
}
|
|
|
|
uint32_t GetTpDiffTime()
|
|
{
|
|
return (Temp_Diff_ProtectTime / 1000);
|
|
}
|
|
|
|
void ProcessSafety_CellVoltageDiff(void) {
|
|
device_status.warning.bit.cell_voltage_diff = 0;
|
|
|
|
if (device_value.BatVoltage >= CELL_DEVIATION_CHECK_VOLTAGE) {
|
|
/* Cell Voltage Diff protection (Cutoff charge if diff >= 200mV holds for
|
|
* 24h, latch until MCU reset) */
|
|
if (device_status.protect.bit.cell_voltage_diff) {
|
|
// KT Requirement: Once tripped, latch protection and do not auto-recover
|
|
// until MCU reset
|
|
} else {
|
|
// Alarm check: Cutoff charge if cell diff >= 200mV holds for
|
|
// CV_Diff_ProtectHoldTime (default 24h)
|
|
if (device_value.Cell.avg.diff >=
|
|
device_param.safety.cv_diff.Cell_Voltage_Diff_Threshold) {
|
|
if (CV_Diff_ProtectTime == 0) {
|
|
device_status.protect.bit.cell_voltage_diff = true;
|
|
}
|
|
} else {
|
|
CV_Diff_ProtectTime = CV_Diff_ProtectHoldTime;
|
|
}
|
|
}
|
|
} else {
|
|
if (device_status.protect.bit.cell_voltage_diff == false) {
|
|
CV_Diff_ProtectTime = CV_Diff_ProtectHoldTime;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Set_CV_Diff_ProtectHoldTime(uint32_t hold_time_ms) {
|
|
if (hold_time_ms == 0) {
|
|
CV_Diff_ProtectHoldTime = CV_DIFF_PROTECT_HOLD_TIME;
|
|
} else {
|
|
CV_Diff_ProtectHoldTime = hold_time_ms;
|
|
}
|
|
|
|
if (device_status.protect.bit.cell_voltage_diff == false) {
|
|
CV_Diff_ProtectTime = CV_Diff_ProtectHoldTime;
|
|
}
|
|
}
|
|
|
|
void dec_temp_diff_time(uint32_t tick) {
|
|
if (Temp_Diff_ProtectTime > tick)
|
|
Temp_Diff_ProtectTime -= tick;
|
|
else
|
|
Temp_Diff_ProtectTime = 0;
|
|
}
|
|
|
|
void ProcessSafety_TempDiff(void) {
|
|
/* Temp Diff protection (Cutoff charge if temp diff >= 3.0 deg C holds for
|
|
* 24h, latch until MCU reset) */
|
|
if (device_status.protect.bit.temp_diff) {
|
|
// KT Requirement: Once tripped, latch protection and do not auto-recover
|
|
// until MCU reset
|
|
} else {
|
|
// Alarm check: Cutoff charge if temp diff >= TEMP_DIFF_PROTECT_THRESHOLD
|
|
// (3.0 deg C) holds for Temp_Diff_ProtectHoldTime
|
|
if ((device_status.error.bit.temp_sensor == false) &&
|
|
(device_value.Temp.avg.diff >= Temp_Diff_Threshold)) {
|
|
if (Temp_Diff_ProtectTime == 0) {
|
|
device_status.protect.bit.temp_diff = true;
|
|
}
|
|
} else {
|
|
Temp_Diff_ProtectTime = Temp_Diff_ProtectHoldTime;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Set_Temp_Diff_ProtectHoldTime(uint32_t hold_time_ms) {
|
|
if (hold_time_ms == 0) {
|
|
Temp_Diff_ProtectHoldTime = TEMP_DIFF_PROTECT_HOLD_TIME;
|
|
} else {
|
|
Temp_Diff_ProtectHoldTime = hold_time_ms;
|
|
}
|
|
|
|
if (device_status.protect.bit.temp_diff == false) {
|
|
Temp_Diff_ProtectTime = Temp_Diff_ProtectHoldTime;
|
|
}
|
|
}
|
|
|
|
void Set_Temp_Diff_Threshold(uint16_t th) {
|
|
if (th == 0)
|
|
Temp_Diff_Threshold = TEMP_DIFF_PROTECT_THRESHOLD;
|
|
else
|
|
Temp_Diff_Threshold = th;
|
|
}
|
|
|
|
uint16_t Get_Temp_Diff_Threshold(void) { return Temp_Diff_Threshold; }
|
|
|
|
#define OP_STS_STANDBY 0x0000
|
|
#define OP_STS_CHARGING 0x0001
|
|
#define OP_STS_DISCHARGING 0x0002
|
|
#define OP_STS_FLOATING 0x0003
|
|
#define OP_STS_WARMINUP 0x0004
|
|
|
|
void Process_FetControl(void) {
|
|
if ((device_status.protect.bit.afe_fail) ||
|
|
(device_status.error.bit.temp_sensor)) {
|
|
device_status.battery_status.bit.CHG_C = false;
|
|
device_status.battery_status.bit.DSG_C = false;
|
|
device_status.battery_status.bit.ZVC_C = false;
|
|
return;
|
|
}
|
|
|
|
// Charge Protection Check
|
|
if (device_status.protect.bit.cell_over_voltage) // Cell Over Voltage
|
|
{
|
|
device_status.battery_status.bit.CHG_C = false;
|
|
// device_status.battery_status.bit.DSG_C = true;
|
|
device_status.battery_status.bit.ZVC_C = false;
|
|
} else if (device_status.protect.bit.over_voltage) // System Over Voltage
|
|
{
|
|
device_status.battery_status.bit.CHG_C = false;
|
|
// device_status.battery_status.bit.DSG_C = true;
|
|
device_status.battery_status.bit.ZVC_C = false;
|
|
} else if (device_status.protect.bit.chg_over_current) // Charge Over Current
|
|
{
|
|
device_status.battery_status.bit.CHG_C = false;
|
|
// device_status.battery_status.bit.DSG_C = true;
|
|
device_status.battery_status.bit.ZVC_C = false;
|
|
} else if (device_status.protect.bit.chg_high_temp) // Charge High Temperature
|
|
{
|
|
device_status.battery_status.bit.CHG_C = false;
|
|
// device_status.battery_status.bit.DSG_C = true;
|
|
device_status.battery_status.bit.ZVC_C = false;
|
|
} else if (device_status.protect.bit.chg_low_temp) // Charge Low Temperature
|
|
{
|
|
device_status.battery_status.bit.CHG_C = false;
|
|
// device_status.battery_status.bit.DSG_C = true;
|
|
device_status.battery_status.bit.ZVC_C = false;
|
|
}
|
|
// uint32_t OCC_CRITICAL_Tick = 60 * 1000;
|
|
// uint8_t OCC_Fail_Count = 0;
|
|
// uint8_t OCC_3Times_Fail = false;
|
|
else if (OCC_3Times_Fail || device_status.protect.bit.critial_over_current) {
|
|
device_status.battery_status.bit.CHG_C = false;
|
|
// device_status.battery_status.bit.DSG_C = true;
|
|
device_status.battery_status.bit.ZVC_C = false;
|
|
} else if (device_status.protect.bit.cell_voltage_diff ||
|
|
device_status.protect.bit
|
|
.temp_diff) // Cell Voltage Diff & Temp Diff Protection (Cutoff
|
|
// charge if held 24h)
|
|
{
|
|
device_status.battery_status.bit.CHG_C = false;
|
|
device_status.battery_status.bit.ZVC_C = false;
|
|
} else {
|
|
device_status.battery_status.bit.CHG_C = true;
|
|
device_status.battery_status.bit.ZVC_C = false;
|
|
}
|
|
|
|
// Dischare Protecion Check
|
|
if (device_status.protect.bit.cell_under_voltage) // Cell Under Voltage
|
|
{
|
|
// device_status.battery_status.bit.CHG_C = false;
|
|
device_status.battery_status.bit.DSG_C = false;
|
|
} else if (device_status.protect.bit.under_voltage) // System Under Voltage
|
|
{
|
|
// device_status.battery_status.bit.CHG_C = false;
|
|
device_status.battery_status.bit.DSG_C = false;
|
|
} else if (device_status.protect.bit
|
|
.dsg_over_current) // Discharge Over Current
|
|
{
|
|
// device_status.battery_status.bit.CHG_C = false;
|
|
device_status.battery_status.bit.DSG_C = false;
|
|
} else if (device_status.protect.bit
|
|
.dsg_high_temp) // Discharge High Temperature
|
|
{
|
|
// device_status.battery_status.bit.CHG_C = false;
|
|
device_status.battery_status.bit.DSG_C = false;
|
|
} else if (device_status.protect.bit
|
|
.dsg_low_temp) // Discharge Low Temperature
|
|
{
|
|
// device_status.battery_status.bit.CHG_C = false;
|
|
device_status.battery_status.bit.DSG_C = false;
|
|
} else // No Protection
|
|
{
|
|
device_status.battery_status.bit.DSG_C = true;
|
|
}
|
|
|
|
if (device_status.protect.bit.cell_voltage_diff ||
|
|
device_status.protect.bit.temp_diff) {
|
|
device_status.battery_status.bit.CHG_C = false;
|
|
device_status.battery_status.bit.ZVC_C = false;
|
|
}
|
|
}
|
|
|
|
void ProcessStatusCheck(void) {
|
|
// Alarm Status
|
|
if (device_status.battery_status.bit.INIT == false) {
|
|
device_status.alarm_status = 0x0003; // Warming Up
|
|
} else if (device_status.protect.value != 0) {
|
|
device_status.alarm_status = 0x0002; // Protection
|
|
} else if (device_status.warning.value != 0) {
|
|
device_status.alarm_status = 0x0001; // Warning
|
|
} else {
|
|
device_status.alarm_status = 0x0000; // Normal
|
|
}
|
|
|
|
// Operating Status
|
|
if (device_status.battery_status.bit.INIT == false) {
|
|
device_status.op_status = 0x0004; // Warming Up
|
|
} else {
|
|
if (device_status.battery_status.bit.RXM == false) {
|
|
switch (device_status.op_status) {
|
|
case OP_STS_STANDBY: // Standby
|
|
case OP_STS_FLOATING: // Floating
|
|
if (device_value.CCurrent >
|
|
(device_param.chg_ctrl.current_thr.Charge_Detection_Threshold /
|
|
100)) {
|
|
device_status.op_status = OP_STS_CHARGING;
|
|
} else if (device_value.DCurrent > (device_param.chg_ctrl.current_thr
|
|
.Discharge_Detection_Threshold /
|
|
100)) {
|
|
device_status.op_status = OP_STS_DISCHARGING;
|
|
}
|
|
break;
|
|
case OP_STS_CHARGING: // Charging
|
|
if (device_value.DCurrent >
|
|
(device_param.chg_ctrl.current_thr.Discharge_Detection_Threshold /
|
|
100)) {
|
|
device_status.op_status = OP_STS_DISCHARGING;
|
|
} else if ((device_value.CCurrent < ((device_param.chg_ctrl.current_thr
|
|
.Charge_Detection_Threshold -
|
|
1000) /
|
|
100)) ||
|
|
(device_status.battery_status.bit.CHG_C == false)) {
|
|
device_status.op_status = OP_STS_STANDBY;
|
|
}
|
|
break;
|
|
case OP_STS_DISCHARGING: // Discharging
|
|
if (device_value.CCurrent >
|
|
(device_param.chg_ctrl.current_thr.Charge_Detection_Threshold /
|
|
100)) {
|
|
device_status.op_status = OP_STS_CHARGING;
|
|
} else if (device_value.DCurrent <
|
|
((device_param.chg_ctrl.current_thr
|
|
.Discharge_Detection_Threshold -
|
|
1000) /
|
|
100)) {
|
|
device_status.op_status = OP_STS_STANDBY; // Standby
|
|
}
|
|
break;
|
|
case OP_STS_WARMINUP: // Warming Up
|
|
device_status.op_status = OP_STS_STANDBY; // Standby
|
|
break;
|
|
default:
|
|
device_status.op_status = OP_STS_STANDBY; // Standby
|
|
break;
|
|
}
|
|
|
|
// if (device_status.op_status == OP_STS_WARMINUP)
|
|
//{ device_status.op_status = OP_STS_STANDBY;
|
|
//// Standby } else { if (device_value.CCurrent >
|
|
//(device_param.chg_ctrl.current_thr.Charge_Detection_Threshold / 100)) {
|
|
// device_status.op_status =
|
|
//OP_STS_CHARGING; } else if (device_value.DCurrent >
|
|
//(device_param.chg_ctrl.current_thr.Discharge_Detection_Threshold / 100))
|
|
//{ device_status.op_status = OP_STS_DISCHARGING;
|
|
// }
|
|
// }
|
|
} else {
|
|
switch (device_status.op_status) {
|
|
case OP_STS_STANDBY: // Stand by
|
|
// if (device_value.BatVoltage >=
|
|
//(device_param.chg_ctrl.chg_cfg.ST_Chg_Voltage)) {
|
|
if (device_value.BatVoltage >= 5200) {
|
|
if (device_status.protect.value == 0) {
|
|
device_status.op_status = OP_STS_FLOATING; // Floating
|
|
}
|
|
}
|
|
break;
|
|
case OP_STS_FLOATING: // Float Charge
|
|
// if (device_value.BatVoltage <
|
|
//(device_param.chg_ctrl.chg_cfg.ST_Chg_Voltage -
|
|
//(device_param.chg_ctrl.term_cfg.Taper_Voltage / 10))) {
|
|
if (device_value.BatVoltage <= 5180) {
|
|
device_status.op_status = OP_STS_STANDBY; // Floating
|
|
}
|
|
break;
|
|
default:
|
|
if ((device_value.BatVoltage >= 5200) &&
|
|
(device_status.protect.value == 0)) {
|
|
device_status.op_status = OP_STS_FLOATING; // Floating
|
|
} else {
|
|
device_status.op_status = OP_STS_STANDBY; // Standby
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (device_status.op_status == OP_STS_DISCHARGING) {
|
|
device_status.battery_status.bit.CHG_C = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*******************(C)COPYRIGHT 2022 AMG ********************END OF FILE******/
|