更新波特率，防止波特率导致的wifi无法对话，解决soc掉电问题

.gitignore

@@ -19,6 +19,7 @@
 Objects/
 Listings/
 Exe/
+prj/
 
 
 # 忽略用户设置文件，通常包含调试和布局等信息

app/stm32fxxx_app/app/adc_manager.c

@@ -15,14 +15,14 @@
 uint16_t adc_dma_buf[kAdcDataEnd * ADC_SAMPLE_CNT];
 uint32_t adc_value[kAdcDataEnd];
 const AdcArray adc_array[kAdcDataEnd] =
-{
+    {
-    kAdcChannel_1, kAdcSampleTime_480,  // 开关电源5v电压
+        kAdcChannel_1, kAdcSampleTime_480,  // 开关电源5v电压
-    kAdcChannel_10, kAdcSampleTime_480, // T1
+        kAdcChannel_10, kAdcSampleTime_480, // T1
-    kAdcChannel_11, kAdcSampleTime_480, // T2
+        kAdcChannel_11, kAdcSampleTime_480, // T2
-    kAdcChannel_12, kAdcSampleTime_480, // T3
+        kAdcChannel_12, kAdcSampleTime_480, // T3
-    kAdcChannel_13, kAdcSampleTime_480, // T4
+        kAdcChannel_13, kAdcSampleTime_480, // T4
-    kAdcChannel_8, kAdcSampleTime_480,  // HALL1
+        kAdcChannel_8, kAdcSampleTime_480,  // HALL1
-    kAdcChannel_9, kAdcSampleTime_480,  // HALL2
+        kAdcChannel_9, kAdcSampleTime_480,  // HALL2
 };
 
 void bms_init_adc(void)
@@ -61,8 +61,8 @@ void bms_poll_adc(uint32_t base_time)
         case kAdcData_Hall1:
         case kAdcData_Hall2:
             // 扩大100倍，
-            //adc_value[i] = tmp * (4 * 100 / 3);
+            // adc_value[i] = tmp * (4 * 100 / 3);
-            adc_value[i] = tmp * 3 / 4;//先获取电压值
+            adc_value[i] = tmp * 3 / 4; // 先获取电压值
             break;
         }
     }

app/stm32fxxx_app/app/bmu_adbms1818.c

@@ -10,18 +10,18 @@
 BmuItem bmu_data;
 
 static uint8_t adapt_falg = 0;
-//adapt ic number
+// adapt ic number
 void bmu_adapt_ic_num(void)
 {
     uint8_t i = 0;
-    for(i = 0; i < 10; i++)
+    for (i = 0; i < 10; i++)
     {
-        run_command(1,BMU_MAX_NUM*BMU_MAX_IC_NUM);
+        run_command(1, BMU_MAX_NUM * BMU_MAX_IC_NUM);
     }
 
-    for(i = 0; i < BMU_MAX_NUM*BMU_MAX_IC_NUM; i++)
+    for (i = 0; i < BMU_MAX_NUM * BMU_MAX_IC_NUM; i++)
     {
-        if(bmu_data.ic[i].config.rx_pec_match == 1)
+        if (bmu_data.ic[i].config.rx_pec_match == 1)
         {
             bmu_data.total_ic_adapt_num = i + 1;
             break;
@@ -31,20 +31,19 @@ void bmu_adapt_ic_num(void)
     bmu_data.total_ic_num = bmu_data.total_ic_adapt_num;
 }
 
-
 //
 void bmu_adapt_volt_temp(void)
 {
-    uint16_t icIdx = 0,_cellIdx = 0,_ntcIdx = 0,i = 0;
+    uint16_t icIdx = 0, _cellIdx = 0, _ntcIdx = 0, i = 0;
-    if(bmu_data.cellntc_nomatch == 1 || adapt_falg == 1)
+    if (bmu_data.cellntc_nomatch == 1 || adapt_falg == 1)
     {
-        for(icIdx = 0; icIdx < BMU_MAX_IC_NUM * BMU_MAX_NUM; icIdx++)
+        for (icIdx = 0; icIdx < BMU_MAX_IC_NUM * BMU_MAX_NUM; icIdx++)
         {
-            for(i = 0; i < IC_MAX_CELL_NUM; i++)
+            for (i = 0; i < IC_MAX_CELL_NUM; i++)
             {
-                if(bmu_data.ic[icIdx].cells.c_codes[i] / 10 < IC_CROSS_CELL_VOLT)
+                if (bmu_data.ic[icIdx].cells.c_codes[i] / 10 < IC_CROSS_CELL_VOLT)
                 {
-                    //This condition indicates a crossover point
+                    // This condition indicates a crossover point
                 }
                 else
                 {
@@ -57,14 +56,14 @@ void bmu_adapt_volt_temp(void)
 
         bmu_data.total_cell_num = _cellIdx;
 
-        //calc temp data
+        // calc temp data
-        for(icIdx = 0; icIdx < BMU_MAX_IC_NUM * BMU_MAX_NUM; icIdx++)
+        for (icIdx = 0; icIdx < BMU_MAX_IC_NUM * BMU_MAX_NUM; icIdx++)
         {
-            for(i = 0; i < IC_MAX_NTC_NUM; i++)
+            for (i = 0; i < IC_MAX_NTC_NUM; i++)
             {
-                if(bmu_data.ic[icIdx].aux.a_codes[i] / 10 > IC_CROSS_TEMP_FLOAT)
+                if (bmu_data.ic[icIdx].aux.a_codes[i] / 10 > IC_CROSS_TEMP_FLOAT)
                 {
-                    //This condition indicates a crossover point
+                    // This condition indicates a crossover point
                 }
                 else
                 {
@@ -78,12 +77,11 @@ void bmu_adapt_volt_temp(void)
         bmu_data.total_temp_num = _ntcIdx;
     }
 
-    //bmu_ic_num is must be config right
+    // bmu_ic_num is must be config right
     bmu_data.bmu_ic_num = get_eeprom_data(kEep_AfeNum_CellNum, kEepromDataType_High);
 
     bmu_data.bmu_cell_num = bmu_data.total_cell_num / bmu_data.bmu_ic_num;
     bmu_data.bmu_temp_num = bmu_data.total_temp_num / bmu_data.bmu_ic_num;
-
 }
 
 void bmu_init_isoSpi(void)
@@ -92,33 +90,31 @@ void bmu_init_isoSpi(void)
     ADBMS1818_init(bmu_data.bmu_num * bmu_data.bmu_ic_num, bmu_data.ic);
 }
 
-
+// 初始化bmu
-
-//初始化bmu
 void bmu_config_init(void)
 {
-    uint8_t idx = 0;//,NtcNum = 0;
+    uint8_t idx = 0; //,NtcNum = 0;
-    uint16_t cell_num =0, temp_num = 0;
+    uint16_t cell_num = 0, temp_num = 0;
 
     drv_gpio_set_pin_status(kGpioType_SP1_Cs_En2, kGpioStatus_Low);
-    //drv_gpio_set_pin_status(kGpioType_SP1_Cs_En1, kGpioStatus_Low);
+    // drv_gpio_set_pin_status(kGpioType_SP1_Cs_En1, kGpioStatus_Low);
     bmu_data.bmu_num = get_eeprom_data(kEep_DevAddr_SlaverNum, kEepromDataType_Low);
-    //bmu_data.bmu_num = 1;
+    // bmu_data.bmu_num = 1;
     if (bmu_data.bmu_num > BMU_MAX_NUM || bmu_data.bmu_num == 0)
     {
         bmu_data.bmu_num = BMU_MAX_NUM;
     }
-    //NtcNum = get_eeprom_data(kEep_reserver_NtcNum, kEepromDataType_Low);
+    // NtcNum = get_eeprom_data(kEep_reserver_NtcNum, kEepromDataType_Low);
     bmu_data.bmu_ic_num = get_eeprom_data(kEep_AfeNum_CellNum, kEepromDataType_High);
     bmu_data.total_ic_num = bmu_data.bmu_num * bmu_data.bmu_ic_num;
     bmu_data.ic = bsp_adbms1818_global();
     bmu_data.total_cell_num = get_eeprom_data(kEep_CellNum, kEepromDataType_Full);
     bmu_data.total_temp_num = get_eeprom_data(kEep_TempNum, kEepromDataType_Full);
 
-    //bmu_data.total_cell_num = 16;
+    // bmu_data.total_cell_num = 16;
-    //bmu_data.total_temp_num = 8;
+    // bmu_data.total_temp_num = 8;
 
-    //set num from hmi =>adapt num for furture
+    // set num from hmi =>adapt num for furture
     cell_num = bmu_data.total_cell_num / bmu_data.bmu_num;
     temp_num = bmu_data.total_temp_num / bmu_data.bmu_num;
 
@@ -126,28 +122,28 @@ void bmu_config_init(void)
     bmu_data.bmu_temp_num = temp_num;
 
     uint8_t i = 0;
-    cell_num =0, temp_num = 0;
+    cell_num = 0, temp_num = 0;
 
-    //统计ic中的电压和ntc对应的真实序号
+    // 统计ic中的电压和ntc对应的真实序号
-    uint32_t cell_actual_pos[IC_MAX_CELL_NUM] = {0},ntc_actual_pos[IC_MAX_CELL_NUM] = {0},low_value = 0,high_value = 0,order = 0;
+    uint32_t cell_actual_pos[IC_MAX_CELL_NUM] = {0}, ntc_actual_pos[IC_MAX_CELL_NUM] = {0}, low_value = 0, high_value = 0, order = 0;
-    for(idx = 0; idx < bmu_data.bmu_ic_num; idx++)
+    for (idx = 0; idx < bmu_data.bmu_ic_num; idx++)
     {
         low_value = get_eeprom_data(kEep_FirstIAfe_CellPos + idx * 2, kEepromDataType_Full);
         high_value = get_eeprom_data(kEep_FirstIAfe_CellPos + idx * 2 + 1, kEepromDataType_Full);
-        cell_actual_pos[idx] =  low_value + (high_value << 16);
+        cell_actual_pos[idx] = low_value + (high_value << 16);
 
-        for(i = 0; i < IC_MAX_CELL_NUM; i++)
+        for (i = 0; i < IC_MAX_CELL_NUM; i++)
         {
-            if(KIT_GET_BIT_VAL(cell_actual_pos[idx],i) == 1)
+            if (KIT_GET_BIT_VAL(cell_actual_pos[idx], i) == 1)
             {
                 bmu_data.cell_actual_pos[order] = i;
                 bmu_data.cell_actual_ic[order] = idx;
                 order++;
             }
         }
-        //cell num of crossover configuration >= The configured number of cell
+        // cell num of crossover configuration >= The configured number of cell
-        //then Based on the configured number of voltages.
+        // then Based on the configured number of voltages.
-        if(order > bmu_data.bmu_cell_num)
+        if (order > bmu_data.bmu_cell_num)
         {
             bmu_data.cellntc_nomatch = 1;
             break;
@@ -156,26 +152,26 @@ void bmu_config_init(void)
 
     order = 0; //@wkun 刚才发现order没有给默认值0，受到上面处理影响
 
-    //统计ic中的电压和ntc对应的真实序号
+    // 统计ic中的电压和ntc对应的真实序号
-    for(idx = 0; idx < bmu_data.bmu_ic_num; idx++)
+    for (idx = 0; idx < bmu_data.bmu_ic_num; idx++)
     {
         //@wkun 此处注意是需要上位机下发配置，告诉bms哪个位置接了温感，刚才发现次数全是ff所以不影响结果，最好上位机需要设置下，
         low_value = get_eeprom_data(kEep_FirstIAfe_NtcPos + idx * 2, kEepromDataType_Full);
         high_value = get_eeprom_data(kEep_FirstIAfe_NtcPos + idx * 2 + 1, kEepromDataType_Full);
-        ntc_actual_pos[idx] =  low_value + (high_value << 16);
+        ntc_actual_pos[idx] = low_value + (high_value << 16);
 
-        for(i = 0; i < IC_MAX_NTC_NUM; i++)
+        for (i = 0; i < IC_MAX_NTC_NUM; i++)
         {
-            if(KIT_GET_BIT_VAL(ntc_actual_pos[idx],i) == 1)
+            if (KIT_GET_BIT_VAL(ntc_actual_pos[idx], i) == 1)
             {
                 bmu_data.ntc_actual_pos[order] = i;
                 bmu_data.ntc_actual_ic[order] = idx;
                 order++;
             }
         }
-        //ntc num of crossover configuration >= The configured number of ntc
+        // ntc num of crossover configuration >= The configured number of ntc
-        //then Based on the configured number of ntc.
+        // then Based on the configured number of ntc.
-        if(order > bmu_data.bmu_temp_num)
+        if (order > bmu_data.bmu_temp_num)
         {
             bmu_data.cellntc_nomatch = 1;
             break;
@@ -189,7 +185,7 @@ void bmu_unit_data_handler()
     uint16_t cell_pos = 0, temp_pos = 0;
     for (i = 0; i < bmu_data.bmu_num; i++)
     {
-        BmuUnit* pBmu = NULL;
+        BmuUnit *pBmu = NULL;
         pBmu = &bmu_data.bmu_unit[i];
         pBmu->ic_num = get_eeprom_data(kEep_AfeNum_CellNum, kEepromDataType_High);
 
@@ -206,7 +202,6 @@ void bmu_unit_data_handler()
     bmu_data.pole_temp_buf = &bmu_data.cell_temp_total_buf[temp_pos];
 }
 
-
 void bmu_comm_offline_check(uint32_t base_time)
 {
     uint8_t i = 0;
@@ -214,7 +209,7 @@ void bmu_comm_offline_check(uint32_t base_time)
     for (i = 0; i < bmu_data.bmu_num; i++)
     {
         uint8_t *buf = bmu_data.ic[i].cells.pec_match;
-        if(kit_check_sum8(buf, 6) == 0)
+        if (kit_check_sum8(buf, 6) == 0)
         {
             bmu_data.bmu_unit[i].comm_fault = 1;
             bmu_data.bmu_unit[i].timeout += base_time;
@@ -225,8 +220,8 @@ void bmu_comm_offline_check(uint32_t base_time)
             bmu_data.bmu_unit[i].comm_fault = 1;
             bmu_data.bmu_unit[i].timeout += base_time;
 
-            timeout = get_eeprom_data(kEep_MSCommAlarm1Dly,kEepromDataType_Full);
+            timeout = get_eeprom_data(kEep_MSCommAlarm1Dly, kEepromDataType_Full);
-            if(bmu_data.bmu_unit[i].timeout > timeout)
+            if (bmu_data.bmu_unit[i].timeout > timeout)
             {
                 KIT_CLR_BIT_32(bmu_data.bmu_unit[i].data[kBmuData_Status], kBmuStatus_Online);
             }
@@ -234,31 +229,27 @@ void bmu_comm_offline_check(uint32_t base_time)
     }
 }
 
-
 void bmu_vlot_breakline_check()
 {
-
-
 }
 
 static int tempJudge_cnt[26][9] = {0};
-//static int tempCellErr_cnt = 0;
+// static int tempCellErr_cnt = 0;
 //@wkun the here can add temp line break or connect
 void bmu_temp_breakline_check(int value, int bmuIdx, int tempIdx)
 {
-    //核心逻辑是通过每个bmu中的温度是否大于60000来确定温感排线是否有问题，通过for循环，然后将故障塞入kFaultCode_TempCable对应的故障中
+    // 核心逻辑是通过每个bmu中的温度是否大于60000来确定温感排线是否有问题，通过for循环，然后将故障塞入kFaultCode_TempCable对应的故障中
-    //bms_get_bmu_fault_bit(kBmuFaultBit_TempCable)，将这个接口中的数据，如果有则置1，否则为0
+    // bms_get_bmu_fault_bit(kBmuFaultBit_TempCable)，将这个接口中的数据，如果有则置1，否则为0
     if (value > 6000)
     {
         tempJudge_cnt[bmuIdx][tempIdx]++;
     }
-    if(tempJudge_cnt[bmuIdx][tempIdx] > 1)
+    if (tempJudge_cnt[bmuIdx][tempIdx] > 1)
     {
-        //bms_set_bmu_fault_bit(kBmuFaultBit_TempCable, 1);
+        // bms_set_bmu_fault_bit(kBmuFaultBit_TempCable, 1);
     }
 }
 
-
 bool bmu_is_cell_volt_valid(uint16_t value)
 {
     bool res = false;
@@ -273,32 +264,32 @@ static void bmu_statistic_cell_volt(uint16_t bmuIdx)
 {
     uint32_t i, sum_value = 0, valid_num = 0;
     uint16_t value, max_value = 0, min_value = 0xFFFF, max_idx = 0, min_idx = 0;
-    for (i = 0; i < bmu_data.bmu_cell_num; i++) //最高、最低温度
+    for (i = 0; i < bmu_data.bmu_cell_num; i++) // 最高、最低温度
     {
         value = bmu_data.bmu_unit[bmuIdx].cell_volt_buf[i];
 
-        //实时计算防止个别电芯真放空为0，或者充满
+        // 实时计算防止个别电芯真放空为0，或者充满
-        if(value > 1000 && value < 4000)
+        if (value > 1000 && value < 4000)
         {
             sum_value += value;
             valid_num++;
         }
-        if(max_value < value)
+        if (max_value < value)
         {
             max_idx = i;
             max_value = value;
         }
 
-        if(min_value > value)
+        if (min_value > value)
         {
             min_idx = i;
             min_value = value;
         }
     }
 
-    bmu_data.bmu_unit[bmuIdx].statistic_data[kBmuStatistic_TotalVolt] =  sum_value;
+    bmu_data.bmu_unit[bmuIdx].statistic_data[kBmuStatistic_TotalVolt] = sum_value;
 
-    if(valid_num > 0)
+    if (valid_num > 0)
     {
         sum_value /= valid_num;
     }
@@ -313,15 +304,14 @@ static void bmu_statistic_cell_volt(uint16_t bmuIdx)
 bool bmu_is_cell_temp_valid(uint16_t value)
 {
     bool res = false;
-    //if ((value >= 60000) || (value <= KIT_NTC_TEMP_OPEN_VALUE))
+    // if ((value >= 60000) || (value <= KIT_NTC_TEMP_OPEN_VALUE))
-    if ((value <= 60000))  //大于60000，不参与故障统计
+    if ((value <= 60000)) // 大于60000，不参与故障统计
     {
         res = true;
     }
     return res;
 }
 
-
 static void bmu_statistic_cell_temp(uint16_t bmuIdx)
 {
     uint32_t i, sum_value = 0, valid_num = 0;
@@ -337,12 +327,12 @@ static void bmu_statistic_cell_temp(uint16_t bmuIdx)
 
         sum_value += value;
         valid_num++;
-        if(max_value < value)
+        if (max_value < value)
         {
             max_idx = i;
             max_value = value;
         }
-        if(min_value > value)
+        if (min_value > value)
         {
             min_idx = i;
             min_value = value;
@@ -351,12 +341,12 @@ static void bmu_statistic_cell_temp(uint16_t bmuIdx)
 
     bmu_data.bmu_unit[bmuIdx].statistic_data[kBmuStatistic_TotalTemp] = sum_value;
 
-    if(valid_num > 0)
+    if (valid_num > 0)
     {
         sum_value /= valid_num;
     }
 
-    //bms_set_ex_data(kExType_CellTemp, ex_st);
+    // bms_set_ex_data(kExType_CellTemp, ex_st);
     bmu_data.bmu_unit[bmuIdx].statistic_data[kBmuStatistic_AvgTemp] = sum_value;
     bmu_data.bmu_unit[bmuIdx].statistic_data[kBmuStatistic_MaxTemp] = max_value;
     bmu_data.bmu_unit[bmuIdx].statistic_data[kBmuStatistic_MaxTempIdx] = max_idx;
@@ -364,98 +354,88 @@ static void bmu_statistic_cell_temp(uint16_t bmuIdx)
     bmu_data.bmu_unit[bmuIdx].statistic_data[kBmuStatistic_MinTempIdx] = min_idx;
 }
 
-
+// real-time calc bmu data
-//real-time calc bmu data
 void bmu_data_handler(uint32_t base_time)
 {
-    uint8_t bmuIdx = 0,cellIdx = 0,_cellIdx = 0,_bmuIdx = 0,_ntcIdx = 0;
+    uint8_t bmuIdx = 0, cellIdx = 0, _cellIdx = 0, _bmuIdx = 0, _ntcIdx = 0;
-    uint16_t current = 0,load = 0, tempJudge = 0;
+    uint16_t current = 0, load = 0, tempJudge = 0;
-    //calc cell volt
+    // calc cell volt
-    for(bmuIdx = 0; bmuIdx < bmu_data.total_ic_num; bmuIdx++)
+    for (bmuIdx = 0; bmuIdx < bmu_data.total_ic_num; bmuIdx++)
     {
-        for(cellIdx = 0; cellIdx < bmu_data.bmu_cell_num; cellIdx++)
+        for (cellIdx = 0; cellIdx < bmu_data.bmu_cell_num; cellIdx++)
         {
             _cellIdx = bmu_data.cell_actual_pos[cellIdx];
-            _bmuIdx  = bmu_data.cell_actual_ic[cellIdx];
+            _bmuIdx = bmu_data.cell_actual_ic[cellIdx];
             bmu_data.bmu_unit[bmuIdx].cell_volt_buf[cellIdx] = bmu_data.ic[bmuIdx].cells.c_codes[_cellIdx] / 10;
         }
-        //统计电压
+        // 统计电压
         bmu_statistic_cell_volt(bmuIdx);
     }
 
-    //calc temp data
+    // calc temp data
-    for(bmuIdx = 0; bmuIdx < bmu_data.total_ic_num; bmuIdx++)
+    for (bmuIdx = 0; bmuIdx < bmu_data.total_ic_num; bmuIdx++)
     {
-        for(cellIdx = 0; cellIdx < bmu_data.bmu_temp_num; cellIdx++)
+        for (cellIdx = 0; cellIdx < bmu_data.bmu_temp_num; cellIdx++)
         {
             _ntcIdx = bmu_data.ntc_actual_pos[cellIdx]; //@wkun 此处还是全0，不对，继续排查
-            _bmuIdx  = bmu_data.ntc_actual_ic[cellIdx];
+            _bmuIdx = bmu_data.ntc_actual_ic[cellIdx];
-            current = KIT_MAX((3000 - (bmu_data.ic[bmuIdx].aux.a_codes[_ntcIdx] / 10)),0) / 10; //ma
+            current = KIT_MAX((3000 - (bmu_data.ic[bmuIdx].aux.a_codes[_ntcIdx] / 10)), 0) / 10; // ma
-            if(KIT_ABS_DIFF(current,0) < 0.0001)
+            if (KIT_ABS_DIFF(current, 0) < 0.0001)
             {
                 current = 1;
             }
-            load = (bmu_data.ic[bmuIdx].aux.a_codes[_ntcIdx] / 10) * 1000 / current; //修订索引错误
+            load = (bmu_data.ic[bmuIdx].aux.a_codes[_ntcIdx] / 10) * 1000 / current; // 修订索引错误
             tempJudge = (bms_get_linear_temp(load, kNtcType_CWFH708_H713) - 500) / 10;
             bmu_data.bmu_unit[bmuIdx].cell_temp_buf[cellIdx] = tempJudge;
             bmu_temp_breakline_check(tempJudge, bmuIdx, _ntcIdx);
         }
-        //统计温度
+        // 统计温度
         bmu_statistic_cell_temp(bmuIdx);
     }
-    //alarm monitor
+    // alarm monitor
-    //bmu_comm_offline_check(base_time);
+    // bmu_comm_offline_check(base_time);
     bmu_vlot_breakline_check();
-
 }
 
-
-
 void bms_bmu_init()
 {
     bmu_config_init();
     bmu_init_isoSpi();
     bmu_unit_data_handler();
 
-    //Automatic Recognition
+    // Automatic Recognition
-    if(adapt_falg == 1)
+    if (adapt_falg == 1)
     {
         bmu_adapt_ic_num();
         bmu_adapt_volt_temp();
         bmu_unit_data_handler();
     }
-
 }
 
-
-
 void bms_poll_bmu(uint32_t base_time)
 {
-    //Automatic Recognition
+    // Automatic Recognition
-    if(adapt_falg == 1)
+    if (adapt_falg == 1)
     {
         bmu_adapt_ic_num();
         bmu_adapt_volt_temp();
         bmu_unit_data_handler();
     }
-    run_command(3,bmu_data.bmu_num*bmu_data.bmu_ic_num);
+    run_command(3, bmu_data.bmu_num * bmu_data.bmu_ic_num);
-    run_command(4,bmu_data.bmu_num*bmu_data.bmu_ic_num);
+    run_command(4, bmu_data.bmu_num * bmu_data.bmu_ic_num);
     bmu_data_handler(base_time);
 
-    run_command(5,bmu_data.bmu_num*bmu_data.bmu_ic_num);
+    run_command(5, bmu_data.bmu_num * bmu_data.bmu_ic_num);
-    run_command(6,bmu_data.bmu_num*bmu_data.bmu_ic_num);
+    run_command(6, bmu_data.bmu_num * bmu_data.bmu_ic_num);
     bmu_data_handler(base_time);
 
-    //温感检测是否脱落，加上了防抖，需要两次大于6000，才设置温感排线错误，温感排线错误显示的有点慢
+    // 温感检测是否脱落，加上了防抖，需要两次大于6000，才设置温感排线错误，温感排线错误显示的有点慢
-    //温感的值最开始全是大于6000的，第二次才是采集值
+    // 温感的值最开始全是大于6000的，第二次才是采集值
     memset(tempJudge_cnt, 0, sizeof(tempJudge_cnt));
-    //2-5 @wangk add this line bcu statistic data is show
+    // 2-5 @wangk add this line bcu statistic data is show
-    bms_poll_statistic(0);
+    //	bms_poll_statistic(0);
-    //2-6 @wangk
+    //	//2-6 @wangk
-    bms_poll_run_status(base_time);
+    //	bms_poll_run_status(base_time);
-    //2-10 @wangk
+    //	//2-10 @wangk
-    task_dido_ctrl_handle(1000);
+    //	task_dido_ctrl_handle(1000);
 }
-
-
-

app/stm32fxxx_app/app/comm_manager.c

@@ -17,8 +17,8 @@
 #include "drv_w5500.h"
 #include "drv_eg25gminipice.h"
 
-#define APP_HMI_BUF_SIZE    (1024 * 4)
+#define APP_HMI_BUF_SIZE (1024 * 4)
-uint8_t hmi_buf[4][APP_HMI_BUF_SIZE] __attribute__((section (".CCM_RAM")));
+uint8_t hmi_buf[4][APP_HMI_BUF_SIZE] __attribute__((section(".CCM_RAM")));
 
 /************************************************ETH接口***************************************************/
 static void w5500_rcv_call(uint8_t socket, uint8_t *buf, uint16_t len);
@@ -28,10 +28,8 @@ W5500_STATIC_INIT(w5500, kSpiDev_3, kGpioType_W5500Cs, w5500_rcv_call);
 
 static void eth_ctrl_rx_int(uint8_t comm_dev, bool is_en)
 {
-
 }
 
-
 static bool w5500_tcp_send(uint8_t comm_dev, uint8_t *buf, int32_t len)
 {
     uint32_t cnt;
@@ -39,15 +37,15 @@ static bool w5500_tcp_send(uint8_t comm_dev, uint8_t *buf, int32_t len)
     uint16_t addr, tmp;
     uint8_t rcv_buf[2], socket_reg;
 
-    if(comm_dev < 8)
+    if (comm_dev < 8)
     {
         tmp = cnt = 0;
         socket_reg = W5500_CREAT_SOCKET_REG(comm_dev);
-        while(cnt++ < 10)
+        while (cnt++ < 10)
         {
             drv_w5500_read_socket_reg(&w5500, socket_reg, Sn_TX_FSR_0x20, rcv_buf, 2);
             tmp = READ_BT_INT16U_BY_CONST_POS(rcv_buf, 0);
-            if(len < tmp)
+            if (len < tmp)
             {
                 drv_w5500_read_socket_reg(&w5500, socket_reg, Sn_TX_WR_0x24, rcv_buf, 2);
                 addr = READ_BT_INT16U_BY_CONST_POS(rcv_buf, 0);
@@ -71,7 +69,7 @@ static bool w5500_tcp_send(uint8_t comm_dev, uint8_t *buf, int32_t len)
 bool w5500_tcp_close(uint8_t socket)
 {
     bool res = false;
-    if(socket < W5500_MODBUS_NUM)
+    if (socket < W5500_MODBUS_NUM)
     {
         res = drv_w5500_close_socket(&w5500, socket);
     }
@@ -80,14 +78,11 @@ bool w5500_tcp_close(uint8_t socket)
 
 void w5500_tcp_close_call(uint8_t socket)
 {
-    if(socket < W5500_MODBUS_NUM)
+    if (socket < W5500_MODBUS_NUM)
     {
-
     }
 }
 
-
-
 void w5500_rcv_call(uint8_t socket, uint8_t *buf, uint16_t len)
 {
     bsp_modbus_push_data(&w5500_modbus_tcp_array[socket], buf, len);
@@ -98,7 +93,7 @@ void bms_poll_w5500(void)
     drv_w5500_poll(&w5500);
 }
 
-#define STM32_ID_ADDR   0x1FFF7A10
+#define STM32_ID_ADDR 0x1FFF7A10
 
 void bms_w5500_net_protocol(void)
 {
@@ -112,8 +107,6 @@ void bms_w5500_net_protocol(void)
     drv_w5500_init(&w5500, ip, port_array, gateway_ip, net_mask, (uint8_t *)(STM32_ID_ADDR + 4), 40000);
 }
 
-
-
 /**************************************************CAN接口**************************************************/
 QUEUE_STATIC_INIT_CCM(inter_can_queue, 50, sizeof(CanMsg));
 QUEUE_STATIC_INIT_CCM(exter_can_queue, 150, sizeof(CanMsg));
@@ -123,7 +116,6 @@ static void can_ctrl_rx_int(uint8_t comm_dev, bool is_en)
     drv_can_ctrl_interrupt((can_dev_e)comm_dev, kcan_interrupt_e_Rx, is_en);
 }
 
-
 static void inter_can_tx_it_call(kit_ret_e res, void *data)
 {
     OS_TRACE_ISR_ENTER();
@@ -139,9 +131,9 @@ static void exter_can_tx_it_call(kit_ret_e res, void *data)
 }
 
 /************************************************UART接口***************************************************/
-//const GpioType rs485_tx_en_map[3] = {kGpioType_RS485_Ch1_Tx_En, kGpioType_RS485_Ch2_Tx_En, kGpioType_Rs485_Ch2_TxEn2};
+// const GpioType rs485_tx_en_map[3] = {kGpioType_RS485_Ch1_Tx_En, kGpioType_RS485_Ch2_Tx_En, kGpioType_Rs485_Ch2_TxEn2};
-//const GpioType rs485_tx_en_map[3] = {kGpioType_RS485_Ch1_Tx_En, kGpioType_RS485_Ch2_Tx_En,kGpioType_RS485_Ch3_Tx_En};
+// const GpioType rs485_tx_en_map[3] = {kGpioType_RS485_Ch1_Tx_En, kGpioType_RS485_Ch2_Tx_En,kGpioType_RS485_Ch3_Tx_En};
-const GpioType rs485_tx_en_map[4] = {kGpioType_RS485_Ch1_Tx_En,kGpioType_RS485_Ch2_Tx_En,kGpioType_RS485_Ch2_Tx_En,kGpioType_RS485_Ch3_Tx_En};
+const GpioType rs485_tx_en_map[4] = {kGpioType_RS485_Ch1_Tx_En, kGpioType_RS485_Ch2_Tx_En, kGpioType_RS485_Ch2_Tx_En, kGpioType_RS485_Ch3_Tx_En};
 static void uart_ctrl_rx_int(uint8_t comm_dev, bool is_en)
 {
     drv_uart_ctrl_interrupt((UartDev)comm_dev, kUartInterrupt_Rx, is_en);
@@ -150,7 +142,7 @@ static void uart_ctrl_rx_int(uint8_t comm_dev, bool is_en)
 static bool uart_async_send(uint8_t comm_dev, uint8_t *buf, int32_t len)
 {
     bool res = false;
-    if((comm_dev < 4) && ((len < APP_HMI_BUF_SIZE)))
+    if ((comm_dev < 4) && ((len < APP_HMI_BUF_SIZE)))
     {
         drv_gpio_set_pin_status(rs485_tx_en_map[comm_dev], kGpioStatus_High);
         drv_uart_int_async_send((UartDev)comm_dev, buf, len);
@@ -177,12 +169,12 @@ static void exter_can_rx_it_call(kit_ret_e res, void *data)
 /*********************************************MODBUS实例***************************************************/
 extern EEpromItem eeprom_item;
 GATE_STATIC_INIT2_CCM(modbus_gate, 200, (kEep_GateDataEnd - kEep_GateDataStart));
-//参数配置和设置中断条件
+// 参数配置和设置中断条件
-MODBUS_RTU_STATIC_INIT_CCM(inter_uart_modbus,  0x01, INTER_UART_PORT, uart_async_send,  uart_ctrl_rx_int, &modbus_gate);
+MODBUS_RTU_STATIC_INIT_CCM(inter_uart_modbus, 0x01, INTER_UART_PORT, uart_async_send, uart_ctrl_rx_int, &modbus_gate);
 MODBUS_RTU_STATIC_INIT_CCM(exter_uart1_modbus, 0x01, EXTER_UART1_PORT, uart_async_send, uart_ctrl_rx_int, &modbus_gate);
 MODBUS_RTU_STATIC_INIT_CCM(exter_uart2_modbus, 0x01, EXTER_UART2_PORT, uart_async_send, uart_ctrl_rx_int, &modbus_gate);
 
-ModbusItem *modbus_rtu_array[kModbusIdx_End] = {&inter_uart_modbus, &exter_uart1_modbus,&exter_uart2_modbus};
+ModbusItem *modbus_rtu_array[kModbusIdx_End] = {&inter_uart_modbus, &exter_uart1_modbus, &exter_uart2_modbus};
 
 uint16_t bms_get_gate_read_data_idx(void)
 {
@@ -199,14 +191,13 @@ uint16_t bms_get_gate_read_data(uint16_t addr)
     return modbus_gate.read_buf[addr];
 }
 
-
 uint16_t bms_set_gate_write_data(uint16_t addr, uint16_t value)
 {
     uint32_t cnt;
-    if(bsp_gate_set_data(&modbus_gate, addr, value) == true)
+    if (bsp_gate_set_data(&modbus_gate, addr, value) == true)
     {
         cnt = 0;
-        while((bsp_gate_has_data_change(&modbus_gate, addr) == true) && (cnt++ < 300))
+        while ((bsp_gate_has_data_change(&modbus_gate, addr) == true) && (cnt++ < 300))
         {
             bsp_task_delay_ms(10);
         }
@@ -230,7 +221,7 @@ uint32_t bms_fill_gate_write_data(uint8_t *buf)
 
 static uint8_t buff[8] = {0};
 static uint8_t pos = 0;
-//中断回调函数
+// 中断回调函数
 static void inter_uart_rx_it_call(kit_ret_e res, void *data)
 {
     OS_TRACE_ISR_ENTER();
@@ -259,12 +250,11 @@ static void exter_uart2_rx_it_call(kit_ret_e res, void *data)
     OS_TRACE_ISR_EXIT();
 }
 
-
 static void uart_tx_it_call(kit_ret_e res, void *data)
 {
     uint8_t dev = *(uint8_t *)data;
     OS_TRACE_ISR_ENTER();
-    if(dev < 4)
+    if (dev < 4)
     {
         drv_gpio_set_pin_status(rs485_tx_en_map[dev], kGpioStatus_Low);
     }
@@ -279,9 +269,9 @@ typedef enum
     kUartParity_End,
 } UartParity;
 
-
 const uint16_t uart_parity[kUartParity_End] = {0x0000, 0x0007, 0x0005};
 const uint32_t uart_baudrate[kR485BaudRateEnd] = {4800, 9600, 19200, 38400, 115200};
+const uint32_t can_baudrate[kCanBaudRateEnd] = {125, 250, 500, 1000};
 void bms_init_comm(void)
 {
     uint32_t i, tmp, prop;
@@ -290,30 +280,32 @@ void bms_init_comm(void)
     modbus_gate.is_write_check = true;
     modbus_gate.write_buf = &eeprom_item.data_buf[kEep_GateDataStart];
 
-    bsp_eeprom_set_data(kEep_Inter485Parity_Baudrate,1,kEepromDataType_Low);
+    bsp_eeprom_set_data(kEep_Inter485Parity_Baudrate, 1, kEepromDataType_Low);
-    bsp_eeprom_set_data(kEep_Exter485_2Parity_Baudrate,1,kEepromDataType_Low);
+    bsp_eeprom_set_data(kEep_Exter485_2Parity_Baudrate, 1, kEepromDataType_Low);
 
-    for(i = 0; i < BMS_485_CHANNEL; i++)
+    for (i = 0; i < BMS_485_CHANNEL; i++)
     {
         tmp = get_eeprom_data(kEep_Inter485Parity_Baudrate + i, kEepromDataType_Low);
-        if(tmp >= kR485BaudRateEnd)
+        if (tmp >= kR485BaudRateEnd)
         {
             tmp = 0;
         }
 
         prop = get_eeprom_data(kEep_Inter485Parity_Baudrate + i, kEepromDataType_High);
         prop = (prop < kUartParity_End) ? uart_parity[prop] : 0;
-
+        uint32_t tmpBaud = uart_baudrate[prop];
         drv_uart_init((UartDev)modbus_rtu_array[i]->comm_dev, 115200, 0 | UART_CFG_STOP_BIT_1, kGpioType_Rs485_Ch1_Tx + (i << 1), kGpioType_Rs485_Ch1_Rx + (i << 1));
-        drv_uart_set_interrupt((UartDev)modbus_rtu_array[i]->comm_dev, kUartInterrupt_Tx, APP_CFG_INT_PRIO_UART2_RX, uart_tx_it_call);//设置中断回调
+        drv_uart_set_interrupt((UartDev)modbus_rtu_array[i]->comm_dev, kUartInterrupt_Tx, APP_CFG_INT_PRIO_UART2_RX, uart_tx_it_call); // 设置中断回调
     }
 
-    drv_uart_set_interrupt(INTER_UART_PORT,  kUartInterrupt_Rx, APP_CFG_INT_PRIO_UART2_RX, inter_uart_rx_it_call);
+    uint32_t tmpIndex = get_eeprom_data(kEep_InterCanProtocol_Baudrate + i, kEepromDataType_Low);
+    uint32_t tmpCanBaud = can_baudrate[tmpIndex];
+    drv_uart_set_interrupt(INTER_UART_PORT, kUartInterrupt_Rx, APP_CFG_INT_PRIO_UART2_RX, inter_uart_rx_it_call);
     drv_uart_set_interrupt(EXTER_UART1_PORT, kUartInterrupt_Rx, APP_CFG_INT_PRIO_UART2_RX, exter_uart1_rx_it_call);
     drv_uart_set_interrupt(EXTER_UART2_PORT, kUartInterrupt_Rx, APP_CFG_INT_PRIO_UART2_RX, exter_uart2_rx_it_call);
 
-	//设置接收回调函数
+    // 设置接收回调函数
-    //drv_uart_set_interrupt(SIM_UART_PORT, kUartInterrupt_Rx, APP_CFG_INT_PRIO_UART2_RX, sim_uart_rx_it_call);//#define SIM_UART_PORT     	kUartDev_2
+    // drv_uart_set_interrupt(SIM_UART_PORT, kUartInterrupt_Rx, APP_CFG_INT_PRIO_UART2_RX, sim_uart_rx_it_call);//#define SIM_UART_PORT     	kUartDev_2
 
     drv_can_init(INTER_CAN_PORT, 250, kGpioType_Can_Ch1_Rx, kGpioType_Can_Ch1_Tx);
     drv_can_set_interrupt(INTER_CAN_PORT, kcan_interrupt_e_Rx, APP_CFG_INT_PRIO_CAN1_RX, inter_can_rx_it_call);
@@ -323,7 +315,7 @@ void bms_init_comm(void)
     drv_can_set_interrupt(EXTER_CAN_PORT, kcan_interrupt_e_Rx, APP_CFG_INT_PRIO_CAN2_RX, exter_can_rx_it_call);
     drv_can_set_interrupt(EXTER_CAN_PORT, kcan_interrupt_e_Tx, APP_CFG_INT_PRIO_CAN2_TX, exter_can_tx_it_call);
 
-    for(i = 0; i < W5500_MODBUS_NUM; i++)
+    for (i = 0; i < W5500_MODBUS_NUM; i++)
     {
         w5500_modbus_tcp_array[i].type = kModbusType_TCP;
         w5500_modbus_tcp_array[i].comm_dev = i;
@@ -334,7 +326,7 @@ void bms_init_comm(void)
     };
     drv_w5500_set_close_call(&w5500, w5500_tcp_close_call);
     drv_spi_init(kSpiDev_3, kSpiFreq_Div2, kSpiMode_C0E0, SpiFrame_MSBFirst, kGpioType_W5500Clk, kGpioType_W5500Miso, kGpioType_W5500Mosi);
-    //drv_spi_set_dma(kSpiDev_3, true, true);
+    // drv_spi_set_dma(kSpiDev_3, true, true);
 
     drv_gpio_set_pin_status(kGpioType_W5500Rst, kGpioStatus_Low);
     kit_time_dly_ms(500);

app/stm32fxxx_app/app/eeprom_manager.c

@@ -875,10 +875,10 @@ static const EepromDataFormat data_format[kEEDataIdx_End] =
     STATIC_UNCHECK_MAX_MIN,   0x0000,      				0x0000,      					0xFFFF, 		//预留10
     //eeeprom
     //soc
-    STATIC_CHECK,             0,         	   0,         	   1,		//电池循环次数更新标志
+    DAYNMIC_CHECK,             0,         	   0,         	   1,		//电池循环次数更新标志
-    STATIC_CHECK,             0,         	   0x0000,         0xFFFF,	//电池循环次数
+    DAYNMIC_CHECK,             0,         	   0x0000,         0xFFFF,	//电池循环次数
-    STATIC_CHECK,             5000,           0,         	   10000,	//SOC
+    DAYNMIC_CHECK,             5000,           0,         	   10000,	//SOC
-    STATIC_CHECK,             5000,           0,         	   10000,	//SOE
+    DAYNMIC_CHECK,             5000,           0,         	   10000,	//SOE
 
     DAYNMIC_UNCHECK_MAX_MIN,           0x0000,         0x0000,         0xFFFF,	//日充放电累计时间
     DAYNMIC_UNCHECK_MAX_MIN,           0x0000,         0x0000,         0xFFFF,

app/stm32fxxx_app/app/fault_manager.c

@@ -14,28 +14,27 @@
 #include "kit_data.h"
 #include "kit_debug.h"
 
-
 typedef struct
 {
-    bool        is_bsu_fault;
+    bool is_bsu_fault;
-    uint8_t     fault_cur_rate[2];
+    uint8_t fault_cur_rate[2];
-    uint16_t    fault_bit[8];
+    uint16_t fault_bit[8];
-    FaultLevel  max_level[2];
+    FaultLevel max_level[2];
-    FaultLevel  min_level[2];
+    FaultLevel min_level[2];
-    uint8_t  	fault_res[2][kFaultCode_End]; //高4位为故障bit,低4位为故障最高等级
+    uint8_t fault_res[2][kFaultCode_End]; // 高4位为故障bit,低4位为故障最高等级
-    ExStatus 	fault_ex[kExType_End];
+    ExStatus fault_ex[kExType_End];
-    uint16_t 	fault_data[kFaultData_End];
+    uint16_t fault_data[kFaultData_End];
-    uint64_t    relay_off_bit[2][kFaultLevel_End - 1];
+    uint64_t relay_off_bit[2][kFaultLevel_End - 1];
 } FaultItem;
-FaultItem fault_item  __attribute__((section (".CCM_RAM")));
+FaultItem fault_item __attribute__((section(".CCM_RAM")));
 
 uint8_t is_afe_happen = 0;
 void bms_update_fault_data(uint32_t base_time)
 {
-//    uint16_t tmp;
+    //    uint16_t tmp;
     int16_t acc_tv = 0, sample_tv = 0;
 
-    if(true)
+    if (true)
     {
         fault_item.fault_data[kFaultData_SOC] = bms_get_soc() / 100;
         fault_item.fault_data[kFaultData_Current] = KIT_ABS(bms_get_current());
@@ -45,8 +44,8 @@ void bms_update_fault_data(uint32_t base_time)
         fault_item.fault_data[kFaultData_MaxTemp] = bms_get_statistic_data(kStatisticData_MaxTemp) * 10 + 500;
         fault_item.fault_data[kFaultData_MinTemp] = bms_get_statistic_data(kStatisticData_MinTemp) * 10 + 500;
         fault_item.fault_data[kFaultData_TempDiff] = bms_get_statistic_data(kStatisticData_TempDiff);
-        fault_item.fault_data[kFaultData_EnviTemp] = bms_get_statistic_data(kStatisticData_EnviTemp);		//环境温度
+        fault_item.fault_data[kFaultData_EnviTemp] = bms_get_statistic_data(kStatisticData_EnviTemp); // 环境温度
-        fault_item.fault_data[kFaultData_TempRise] = fault_item.fault_ex[kExType_TempRise];	                //温升
+        fault_item.fault_data[kFaultData_TempRise] = fault_item.fault_ex[kExType_TempRise];           // 温升
         fault_item.fault_data[kFaultData_TotalVolt] = bms_get_statistic_data(kStatisticData_TotalVolt);
 
         fault_item.fault_data[kFaultData_Insulation] = bms_get_iso_data(kIsoData_Value);
@@ -54,14 +53,14 @@ void bms_update_fault_data(uint32_t base_time)
         fault_item.fault_data[kFaultData_VoltCable] = (bms_get_bmu_fault_bit(kBmuFaultBit_VoltCable) != 0);
         fault_item.fault_data[kFaultData_TempCable] = (bms_get_bmu_fault_bit(kBmuFaultBit_TempCable) != 0);
 
-        //fault_item.fault_data[kFaultData_SupplyVolt] = bms_get_adc_data(kAdcData_PwrVolt);
+        // fault_item.fault_data[kFaultData_SupplyVolt] = bms_get_adc_data(kAdcData_PwrVolt);
-        //tmp = (get_eeprom_data(kEep_EnTempChannel_NtcType, kEepromDataType_High) & 0x01) << 1;
+        // tmp = (get_eeprom_data(kEep_EnTempChannel_NtcType, kEepromDataType_High) & 0x01) << 1;
         fault_item.fault_data[kFaultData_T1Temp] = bms_get_en_temp((EnTemp)(kEnTemp_T1)) / 10 * 10;
         fault_item.fault_data[kFaultData_T2Temp] = bms_get_en_temp((EnTemp)(kEnTemp_T2)) / 10 * 10;
 
         acc_tv = bms_get_statistic_data(kStatisticData_TotalVolt);
         sample_tv = bms_get_high_volt(kHvType_Bat);
-        fault_item.fault_data[kFaultData_HighVoltDiffer] = KIT_ABS_DIFF(acc_tv, sample_tv);//高压异常
+        fault_item.fault_data[kFaultData_HighVoltDiffer] = KIT_ABS_DIFF(acc_tv, sample_tv); // 高压异常
 
         fault_item.fault_data[kFaultData_CmdHeart] = (bms_get_cmd_heartbeat() >= 5000);
 
@@ -69,13 +68,13 @@ void bms_update_fault_data(uint32_t base_time)
         fault_item.fault_data[kFaultData_MaxPackVolt] = bms_get_statistic_data(kStatisticData_MaxPackVolt);
         fault_item.fault_data[kFaultData_MinPackVolt] = bms_get_statistic_data(kStatisticData_MaxPackVolt);
 
-        if(bms_get_bmu_fault_bit(kBmuFaultBit_Afe) != 0)
+        if (bms_get_bmu_fault_bit(kBmuFaultBit_Afe) != 0)
         {
             is_afe_happen = 4;
-            //bms_set_fault_level(kFaultCode_AFE, kFaultLevel_Third, kFaultHandle_CutRlyIdx);
+            // bms_set_fault_level(kFaultCode_AFE, kFaultLevel_Third, kFaultHandle_CutRlyIdx);
         }
 
-        if(bms_get_bmu_fault_bit(kBmuFaultBit_Msd) != 0)
+        if (bms_get_bmu_fault_bit(kBmuFaultBit_Msd) != 0)
         {
             bms_set_fault_level(kFaultCode_MSD, kFaultLevel_Third, kFaultHandle_CutRlyIdx);
         }
@@ -93,31 +92,30 @@ bool bms_is_bsu_fault(void)
 }
 
 const uint16_t cell_limit_value[kCellType_End][2] =
-{
+    {
-    {1500, 3800},   //铁锂极限值
+        {1500, 3800}, // 铁锂极限值
-    {2000, 4300},   //三元极限值
+        {2000, 4300}, // 三元极限值
-    {1000, 3000},   //钛酸锂极限值
+        {1000, 3000}, // 钛酸锂极限值
-    {1000, 3000},   //铅酸极限值
+        {1000, 3000}, // 铅酸极限值
-    {0,    3000},   //超级电容极限值
+        {0, 3000},    // 超级电容极限值
 };
 
-//极限故障
+// 极限故障
 void bms_analyse_exterme_fault(RunStatus status, uint32_t base_time)
 {
     static uint16_t volt_dly = 0, temp_dly = 0;
-    //uint16_t cell_type = get_eeprom_data(kEep_TempType_BatteryType, kEepromDataType_Low);
+    // uint16_t cell_type = get_eeprom_data(kEep_TempType_BatteryType, kEepromDataType_Low);
     uint16_t cell_type = 1;
 
-    if(cell_type >= kCellType_End)
+    if (cell_type >= kCellType_End)
     {
         cell_type = kCellType_kLiFePO4;
     }
 
-    if((fault_item.fault_data[kFaultData_MaxVolt] >= cell_limit_value[cell_type][1])
+    if ((fault_item.fault_data[kFaultData_MaxVolt] >= cell_limit_value[cell_type][1]) || (fault_item.fault_data[kFaultData_MinVolt] <= cell_limit_value[cell_type][0]))
-            || (fault_item.fault_data[kFaultData_MinVolt] <= cell_limit_value[cell_type][0]))
     {
         volt_dly += base_time;
-        if(volt_dly >= KIT_SECOND_CONVERT(2))
+        if (volt_dly >= KIT_SECOND_CONVERT(2))
         {
             bms_set_fault_level_by_status(status, kFaultCode_Exterme, (FaultLevel)(kFaultLevel_End - 1), kFaultHandle_CutNoRelIdx);
             bms_cut_all_relay();
@@ -128,11 +126,10 @@ void bms_analyse_exterme_fault(RunStatus status, uint32_t base_time)
         volt_dly = 0;
     }
 
-    if((fault_item.fault_data[kFaultData_MaxTemp] >= KIT_TEMP_CONVERT(65))
+    if ((fault_item.fault_data[kFaultData_MaxTemp] >= KIT_TEMP_CONVERT(65)) || (fault_item.fault_data[kFaultData_MinTemp] <= KIT_TEMP_CONVERT(-30)))
-            || (fault_item.fault_data[kFaultData_MinTemp] <= KIT_TEMP_CONVERT(-30)))
     {
         temp_dly += base_time;
-        if(temp_dly >= KIT_SECOND_CONVERT(2))
+        if (temp_dly >= KIT_SECOND_CONVERT(2))
         {
             bms_set_fault_level_by_status(status, kFaultCode_Exterme, kFaultLevel_Third, kFaultHandle_CutNoRelIdx);
             bms_cut_all_relay();
@@ -149,7 +146,7 @@ FaultLevel bms_get_max_fault_level(void)
     FaultLevel level1, level2;
     level1 = fault_item.max_level[kRunStatus_Dis];
     level2 = fault_item.max_level[kRunStatus_Chg];
-    if(level1 < level2)
+    if (level1 < level2)
     {
         level1 = level2;
     }
@@ -160,20 +157,19 @@ FaultLevel bms_get_max_fault_level_by_status(RunStatus status)
 {
     FaultLevel level = kFaultLevel_Normal;
 
-    if(status < 2)
+    if (status < 2)
     {
         level = fault_item.max_level[status];
     }
     return level;
 }
 
-
 FaultLevel bms_get_min_fault_level(void)
 {
     FaultLevel level1, level2;
     level1 = fault_item.min_level[kRunStatus_Dis];
     level2 = fault_item.min_level[kRunStatus_Chg];
-    if(level1 > level2)
+    if (level1 > level2)
     {
         level1 = level2;
     }
@@ -182,23 +178,23 @@ FaultLevel bms_get_min_fault_level(void)
 
 uint32_t bms_get_total_alarm(uint16_t input)
 {
-	FaultLevel level;
+    FaultLevel level;
-	level = bms_get_max_fault_level() == kFaultLevel_First || bms_get_max_fault_level() == kFaultLevel_Second;
+    level = bms_get_max_fault_level() == kFaultLevel_First || bms_get_max_fault_level() == kFaultLevel_Second;
-	return level;
+    return level;
 }
 
 uint32_t bms_get_total_fault(uint16_t input)
 {
-	FaultLevel level;
+    FaultLevel level;
-	level = bms_get_max_fault_level() == kFaultLevel_Third;
+    level = bms_get_max_fault_level() == kFaultLevel_Third;
-	return level;
+    return level;
 }
 
 uint8_t bms_get_fault_cur_rate(RunStatus status)
 {
     uint8_t rate = 100;
 
-    if(status < 2)
+    if (status < 2)
     {
         rate = fault_item.fault_cur_rate[status];
     }
@@ -208,11 +204,11 @@ uint8_t bms_get_fault_cur_rate(RunStatus status)
 FaultLevel bms_get_fault_level(FaultCode idx)
 {
     FaultLevel level1 = kFaultLevel_Normal, level2;
-    if(idx < kFaultCode_End)
+    if (idx < kFaultCode_End)
     {
         level1 = (FaultLevel)(fault_item.fault_res[kRunStatus_Dis][idx] & 0x0F);
         level2 = (FaultLevel)(fault_item.fault_res[kRunStatus_Chg][idx] & 0x0F);
-        if(level1 < level2)
+        if (level1 < level2)
         {
             level1 = level2;
         }
@@ -224,9 +220,9 @@ FaultLevel bms_get_fault_level(FaultCode idx)
 FaultLevel bms_get_fault_level_by_status(RunStatus status, FaultCode idx)
 {
     FaultLevel level = kFaultLevel_Normal;
-    if(idx < kFaultCode_End)
+    if (idx < kFaultCode_End)
     {
-        if(status < 2)
+        if (status < 2)
         {
             level = (FaultLevel)(fault_item.fault_res[status][idx] & 0x0F);
         }
@@ -248,22 +244,22 @@ void bms_set_fault_level(FaultCode idx, FaultLevel level, FaultHandle handle)
 void bms_set_fault_level_by_status(RunStatus status, FaultCode idx, FaultLevel level, FaultHandle handle)
 {
     uint16_t tmp;
-    if((idx < kFaultCode_End) && (status < 2) && (level < kFaultLevel_End))
+    if ((idx < kFaultCode_End) && (status < 2) && (level < kFaultLevel_End))
     {
-        if(level > kFaultLevel_Normal)
+        if (level > kFaultLevel_Normal)
         {
             tmp = level;
             KIT_SET_BIT_MASK_32(tmp, (level + 3));
             fault_item.fault_res[status][idx] = tmp;
 
-            if(handle >= kFaultHandle_CutRlyIdx)
+            if (handle >= kFaultHandle_CutRlyIdx)
             {
                 tmp = get_eeprom_data(kEep_FaultCntStart + idx, kEepromDataType_Full);
                 bsp_eeprom_save_data(kEep_FaultCntStart + idx, tmp++, kEepromDataType_Full);
                 KIT_SET_BIT_MASK_64(fault_item.relay_off_bit[status][level - 1], idx);
             }
         }
-        else if(handle < kFaultHandle_CutNoRelIdx)
+        else if (handle < kFaultHandle_CutNoRelIdx)
         {
             fault_item.fault_res[status][idx] = 0;
             KIT_CLR_BIT_64(fault_item.relay_off_bit[status][0], idx);
@@ -276,7 +272,7 @@ void bms_set_fault_level_by_status(RunStatus status, FaultCode idx, FaultLevel l
 uint16_t bms_get_fault_bit(uint8_t idx)
 {
     uint16_t res = 0;
-    if(idx < 8)
+    if (idx < 8)
     {
         res = fault_item.fault_bit[idx];
     }
@@ -285,17 +281,17 @@ uint16_t bms_get_fault_bit(uint8_t idx)
 
 uint16_t bms_get_fault_single_bit(uint8_t index, FaultLevel level)
 {
-    uint8_t i, offset, value,pos;
+    uint8_t i, offset, value, pos;
     uint16_t fault = 0;
 
-    for(i = (index << 4); i < ((index << 4) + 16); i++)
+    for (i = (index << 4); i < ((index << 4) + 16); i++)
     {
-        if(i < kFaultCode_End)
+        if (i < kFaultCode_End)
         {
             pos = i >> 3;
             offset = (i % 8) << 1;
-            value = (bms_get_fault_bit(pos) >> offset) &0x0003;
+            value = (bms_get_fault_bit(pos) >> offset) & 0x0003;
-            if(value == level)
+            if (value == level)
                 KIT_SET_BIT_MASK_32(fault, i - (index << 4));
             else
                 KIT_CLR_BIT_32(fault, i - (index << 4));
@@ -328,7 +324,7 @@ uint64_t bms_get_fault_relay_off_bit(void)
 
 void bms_clear_fault_relay_off_bit_by_status(RunStatus status, FaultCode idx)
 {
-    if(status < 2)
+    if (status < 2)
     {
         KIT_CLR_BIT_64(fault_item.relay_off_bit[status][0], idx);
         KIT_CLR_BIT_64(fault_item.relay_off_bit[status][1], idx);
@@ -339,7 +335,7 @@ void bms_clear_fault_relay_off_bit_by_status(RunStatus status, FaultCode idx)
 uint64_t bms_get_fault_relay_off_bit_by_status(RunStatus status)
 {
     uint64_t res = 0;
-    if(status < 2)
+    if (status < 2)
     {
         res = fault_item.relay_off_bit[status][0] | fault_item.relay_off_bit[status][1] | fault_item.relay_off_bit[status][2];
     }
@@ -350,9 +346,9 @@ void bms_clear_fault_code(RunStatus status)
 {
     uint32_t i;
 
-    if(status < 2)
+    if (status < 2)
     {
-        for(i = 0; i < kFaultCode_End; i++)
+        for (i = 0; i < kFaultCode_End; i++)
         {
             fault_item.fault_res[status][i] = 0;
         }
@@ -365,7 +361,7 @@ void bms_clear_fault_code(RunStatus status)
 ExStatus bms_get_ex_data(ExType idx)
 {
     ExStatus tmp = kExStatus_None;
-    if(idx < kExType_End)
+    if (idx < kExType_End)
     {
         tmp = fault_item.fault_ex[idx];
     }
@@ -377,24 +373,29 @@ void bms_set_ex_data(ExType idx, ExStatus st)
 {
     KIT_ASSERT_PARAM((idx < kExType_End) && (st < kExStatus_End));
 
-    if(idx < kExType_End)
+    if (idx < kExType_End)
     {
         fault_item.fault_ex[idx] = st;
     }
 }
 
+#define FAULT_ARARM_THRESHOLD_ADDR(x) (x)
+#define FAULT_ARARM_DLY_THRESHOLD_ADDR(x) (x + 1)
+#define FAULT_RELEASE_THRESHOLD_ADDR(x) (x + 2)
+#define FAULT_RELEASE_DLY_THRESHOLD_ADDR(x) (x + 3)
+#define FAULT_ALARM_HANDLER_ADDR(x) (x + 4)
 
-#define FAULT_ARARM_THRESHOLD_ADDR(x)           (x)
+// 确认任务调度时间与故障时间是否匹配
-#define FAULT_ARARM_DLY_THRESHOLD_ADDR(x)       (x + 1)
-#define FAULT_RELEASE_THRESHOLD_ADDR(x)         (x + 2)
-#define FAULT_RELEASE_DLY_THRESHOLD_ADDR(x)     (x + 3)
-#define FAULT_ALARM_HANDLER_ADDR(x)             (x + 4)
-
-//确认任务调度时间与故障时间是否匹配
 const FaultLevel alarm_level_map[8] =
-{
+    {
-    kFaultLevel_Normal, kFaultLevel_First, kFaultLevel_Second, kFaultLevel_Second,
+        kFaultLevel_Normal,
-    kFaultLevel_Third,  kFaultLevel_Third, kFaultLevel_Third,  kFaultLevel_Third,
+        kFaultLevel_First,
+        kFaultLevel_Second,
+        kFaultLevel_Second,
+        kFaultLevel_Third,
+        kFaultLevel_Third,
+        kFaultLevel_Third,
+        kFaultLevel_Third,
 };
 void bms_analyse_fault(RunStatus status, FaultArray *fault_array)
 {
@@ -405,35 +406,35 @@ void bms_analyse_fault(RunStatus status, FaultArray *fault_array)
     uint16_t idx, tmp, data, threshold[2], handler, fault_bit[16];
     FaultLevel alarm_level, min_level, max_level;
     const FaultProp *prop_array = fault_array->fault_prop_arr;
-    FaultParam * param_array = fault_array->fault_param_arr;
+    FaultParam *param_array = fault_array->fault_param_arr;
 
-    if(status < 2)
+    if (status < 2)
     {
         min_level = kFaultLevel_End;
         max_level = kFaultLevel_Normal;
         kit_set_buf(fault_bit, 16, 0);
-        for(i = 0; i < fault_array->fault_cnt; i++)
+        for (i = 0; i < fault_array->fault_cnt; i++)
         {
             idx = prop_array[i].fauld_code;
             alarm_bit = (fault_item.fault_res[status][idx] >> 4);
             level = prop_array[i].level;
             cur_rate[kFaultLevel_Normal] = 100;
-            for(j = 0; j < level; j++)
+            for (j = 0; j < level; j++)
             {
                 tmp = prop_array[i].threshold_idx + j * 5;
                 handler = get_eeprom_data(FAULT_ALARM_HANDLER_ADDR(tmp), kEepromDataType_Full);
                 alarm_handle = handler & 0x0003;
                 cur_rate[j + kFaultLevel_End - level] = handler >> 8;
-                if(alarm_handle == kFaultHandle_ForbidIdx)//禁用
+                if (alarm_handle == kFaultHandle_ForbidIdx) // 禁用
                 {
                     continue;
                 }
-                else if(alarm_handle != kFaultHandle_ForbidIdx)
+                else if (alarm_handle != kFaultHandle_ForbidIdx)
                 {
                     data = fault_item.fault_data[prop_array[i].data_idx];
                     threshold[kCondType_Alarm] = get_eeprom_data(FAULT_ARARM_THRESHOLD_ADDR(tmp), kEepromDataType_Full);
                     threshold[kCondType_Release] = get_eeprom_data(FAULT_RELEASE_THRESHOLD_ADDR(tmp), kEepromDataType_Full);
-                    if(prop_array[i].other_cond == NULL) //如果没有其他故障判断策略，默认模版策略
+                    if (prop_array[i].other_cond == NULL) // 如果没有其他故障判断策略，默认模版策略
                     {
                         check_type = prop_array[i].check_type & 0x03;
                         cond[kCheckType_MoreThan] = (data >= threshold[kCondType_Alarm]);
@@ -445,28 +446,28 @@ void bms_analyse_fault(RunStatus status, FaultArray *fault_array)
                         cond[kCondType_Release] = cond[check_type];
                         cond[kCondType_Alarm] = tmp_cond;
                     }
-                    else //其他故障判断策略
+                    else // 其他故障判断策略
                     {
                         prop_array[i].other_cond(j, data, cond, threshold);
                     }
 
-                    if(cond[kCondType_Alarm] == true)
+                    if (cond[kCondType_Alarm] == true)
                     {
                         param_array[i].release_tick[j] = 0;
-                        param_array[i].alarm_tick[j] ++;
+                        param_array[i].alarm_tick[j]++;
                         data = get_eeprom_data(FAULT_ARARM_DLY_THRESHOLD_ADDR(tmp), kEepromDataType_Full);
-                        if(param_array[i].alarm_tick[j] >= data)
+                        if (param_array[i].alarm_tick[j] >= data)
                         {
-                            //对于只有一个等级的故障，需要置最高等级
+                            // 对于只有一个等级的故障，需要置最高等级
                             KIT_SET_BIT_MASK_32(alarm_bit, j + kFaultLevel_End - 1 - level);
-                            //KIT_SET_BIT_MASK_32(alarm_bit, j);
+                            // KIT_SET_BIT_MASK_32(alarm_bit, j);
                             param_array[i].alarm_tick[j] = data;
-                            if((KIT_GET_BIT_64(fault_item.relay_off_bit[status][j], idx) == 0) && (alarm_handle >= kFaultHandle_CutRlyIdx))
+                            if ((KIT_GET_BIT_64(fault_item.relay_off_bit[status][j], idx) == 0) && (alarm_handle >= kFaultHandle_CutRlyIdx))
                             {
-                                //data = get_eeprom_data(kEep_FaultCntStart + idx, kEepromDataType_Full);
+                                // data = get_eeprom_data(kEep_FaultCntStart + idx, kEepromDataType_Full);
-                                //bsp_eeprom_save_data(kEep_FaultCntStart + idx, ++data, kEepromDataType_Full);
+                                // bsp_eeprom_save_data(kEep_FaultCntStart + idx, ++data, kEepromDataType_Full);
                                 KIT_SET_BIT_MASK_64(fault_item.relay_off_bit[status][j], idx);
-                                if((prop_array[i].check_type & FAULT_RELAY_BOTH_OFF) == FAULT_RELAY_BOTH_OFF)
+                                if ((prop_array[i].check_type & FAULT_RELAY_BOTH_OFF) == FAULT_RELAY_BOTH_OFF)
                                 {
                                     KIT_SET_BIT_MASK_64(fault_item.relay_off_bit[1 - status][j], idx);
                                 }
@@ -476,21 +477,20 @@ void bms_analyse_fault(RunStatus status, FaultArray *fault_array)
                     else
                     {
                         param_array[i].alarm_tick[j] = 0;
-                        if((alarm_handle != kFaultHandle_CutNoRelIdx)
+                        if ((alarm_handle != kFaultHandle_CutNoRelIdx) && (KIT_GET_BIT_32(alarm_bit, j + kFaultLevel_End - 1 - level) != 0))
-                                && (KIT_GET_BIT_32(alarm_bit, j + kFaultLevel_End - 1 - level) != 0 ))
                         {
-                            if(cond[kCondType_Release]== true)
+                            if (cond[kCondType_Release] == true)
                             {
-                                param_array[i].release_tick[j] ++;
+                                param_array[i].release_tick[j]++;
                                 data = get_eeprom_data(FAULT_RELEASE_DLY_THRESHOLD_ADDR(tmp), kEepromDataType_Full);
-                                if(param_array[i].release_tick[j] >= data)
+                                if (param_array[i].release_tick[j] >= data)
                                 {
                                     KIT_CLR_BIT_32(alarm_bit, j + kFaultLevel_End - 1 - level);
                                     param_array[i].release_tick[j] = data;
-                                    if(alarm_handle < kFaultHandle_CutNoRelIdx)
+                                    if (alarm_handle < kFaultHandle_CutNoRelIdx)
                                     {
                                         KIT_CLR_BIT_64(fault_item.relay_off_bit[status][j], idx);
-                                        if((prop_array[i].check_type & FAULT_RELAY_BOTH_OFF) == FAULT_RELAY_BOTH_OFF)
+                                        if ((prop_array[i].check_type & FAULT_RELAY_BOTH_OFF) == FAULT_RELAY_BOTH_OFF)
                                         {
                                             KIT_CLR_BIT_64(fault_item.relay_off_bit[1 - status][j], idx);
                                         }
@@ -509,26 +509,26 @@ void bms_analyse_fault(RunStatus status, FaultArray *fault_array)
             alarm_level = alarm_level_map[alarm_bit & 0x07];
             fault_item.fault_res[status][idx] = ((alarm_bit << 4) | (alarm_level & 0x07));
 
-            if(cur_rate[alarm_level] < max_cur_rate)
+            if (cur_rate[alarm_level] < max_cur_rate)
             {
                 max_cur_rate = cur_rate[alarm_level];
             }
         }
 
-        for(i = 0; i < kFaultCode_End; i++)
+        for (i = 0; i < kFaultCode_End; i++)
         {
             alarm_level = (FaultLevel)(fault_item.fault_res[status][i] & 0x0F);
-            if(max_level < alarm_level)
+            if (max_level < alarm_level)
             {
                 max_level = alarm_level;
             }
-            else if(min_level > alarm_level)
+            else if (min_level > alarm_level)
             {
                 min_level = alarm_level;
             }
-            //判断另外运行状态中对应故障是否大于次状态故障
+            // 判断另外运行状态中对应故障是否大于次状态故障
             tmp = fault_item.fault_res[1 - status][i] & 0x0F;
-            if(alarm_level < tmp)
+            if (alarm_level < tmp)
             {
                 alarm_level = (FaultLevel)tmp;
             }
@@ -544,62 +544,79 @@ void bms_analyse_fault(RunStatus status, FaultArray *fault_array)
 
         kit_copy_buf(fault_item.fault_bit, fault_bit, 16);
 
-        if(max_cur_rate == 0)
+        if (max_cur_rate == 0)
         {
-            if(status == kRunStatus_Chg)
+            if (status == kRunStatus_Chg)
             {
                 bms_set_chg_forbid_status();
             }
-            else if(status == kRunStatus_Dis)
+            else if (status == kRunStatus_Dis)
             {
                 bms_set_dis_forbid_status();
             }
         }
-
     }
     bms_analyse_exterme_fault(status, FAULT_PERIOD);
 }
 
-#define PWR_ON_FAULT_CHECK_MAP_LEN  22
+#define PWR_ON_FAULT_CHECK_MAP_LEN 22
 const uint8_t fault_bit_res[3] = {0x11, 0x32, 0x73};
 const FaultCode pwr_on_fault_check_map[PWR_ON_FAULT_CHECK_MAP_LEN] =
-{
+    {
-    kFaultCode_HighTotalVolt, kFaultCode_LowTotalVolt, kFaultCode_HighCellVolt, kFaultCode_LowCellVolt, kFaultCode_HighCellTemp, kFaultCode_LowCellTemp,
+        kFaultCode_HighTotalVolt,
-    kFaultCode_HighVoltDiff, kFaultCode_HighTempDiff, kFaultCode_HvDiffErr, kFaultCode_DoAdhesion, kFaultCode_SupplyHighVolt, kFaultCode_SupplyLowVolt,
+        kFaultCode_LowTotalVolt,
-    kFaultCode_AFE, kFaultCode_Eeprom, kFaultCode_Rtc, kFaultCode_Adc, kFaultCode_SD, kFaultCode_Feedback, kFaultCode_Stop, kFaultCode_Fire,
+        kFaultCode_HighCellVolt,
-    kFaultCode_HighPackVolt, kFaultCode_LowPackVolt,
+        kFaultCode_LowCellVolt,
+        kFaultCode_HighCellTemp,
+        kFaultCode_LowCellTemp,
+        kFaultCode_HighVoltDiff,
+        kFaultCode_HighTempDiff,
+        kFaultCode_HvDiffErr,
+        kFaultCode_DoAdhesion,
+        kFaultCode_SupplyHighVolt,
+        kFaultCode_SupplyLowVolt,
+        kFaultCode_AFE,
+        kFaultCode_Eeprom,
+        kFaultCode_Rtc,
+        kFaultCode_Adc,
+        kFaultCode_SD,
+        kFaultCode_Feedback,
+        kFaultCode_Stop,
+        kFaultCode_Fire,
+        kFaultCode_HighPackVolt,
+        kFaultCode_LowPackVolt,
 };
 void bms_analyse_pwr_on_fault(RunStatus status, FaultArray *fault_array, uint32_t enable_bit)
 {
     uint32_t i, j;
     uint16_t idx, tmp, data, threshold[2];
-    bool     cond[kCheckType_End];
+    bool cond[kCheckType_End];
     uint8_t pos, offset, fault_bit[16];
-    bool     enable_check[kFaultCode_End];
+    bool enable_check[kFaultCode_End];
     const FaultProp *prop_array = fault_array->fault_prop_arr;
 
     kit_set_buf(fault_bit, 16, 0);
     kit_set_buf(enable_check, kFaultCode_End, false);
-    for(i = 0; i < PWR_ON_FAULT_CHECK_MAP_LEN; i++)
+    for (i = 0; i < PWR_ON_FAULT_CHECK_MAP_LEN; i++)
     {
         idx = pwr_on_fault_check_map[i];
-        if(KIT_GET_BIT_32(enable_bit, i) != 0)
+        if (KIT_GET_BIT_32(enable_bit, i) != 0)
         {
             enable_check[idx] = true;
         }
     }
 
-    for(i = 0; i < fault_array->fault_cnt; i++)
+    for (i = 0; i < fault_array->fault_cnt; i++)
     {
         idx = prop_array[i].fauld_code;
         j = prop_array[i].level - 1;
 
         tmp = prop_array[i].threshold_idx + j * 5;
-        if(enable_check[idx] == true)
+        if (enable_check[idx] == true)
         {
             data = fault_item.fault_data[prop_array[i].data_idx];
             threshold[kCondType_Alarm] = get_eeprom_data(FAULT_ARARM_THRESHOLD_ADDR(tmp), kEepromDataType_Full);
-            if(prop_array[i].other_cond == NULL)
+            if (prop_array[i].other_cond == NULL)
             {
                 cond[kCheckType_MoreThan] = (data >= threshold[kCondType_Alarm]);
                 cond[kCheckType_LessThan] = (data <= threshold[kCondType_Alarm]);
@@ -610,7 +627,7 @@ void bms_analyse_pwr_on_fault(RunStatus status, FaultArray *fault_array, uint32_
                 prop_array[i].other_cond(j, data, cond, threshold);
             }
 
-            if((cond[kCondType_Alarm] == true) && (KIT_GET_BIT_64(fault_item.relay_off_bit[status][j], idx) == 0))
+            if ((cond[kCondType_Alarm] == true) && (KIT_GET_BIT_64(fault_item.relay_off_bit[status][j], idx) == 0))
             {
                 fault_item.fault_res[status][idx] = 0x43;
                 fault_item.max_level[status] = (FaultLevel)(kFaultLevel_End - 1);
@@ -619,11 +636,10 @@ void bms_analyse_pwr_on_fault(RunStatus status, FaultArray *fault_array, uint32_
                 pos = i >> 3;
                 offset = (i % 8) << 1;
                 fault_bit[pos] |= 3 << offset;
-                //data = get_eeprom_data(kEep_FaultCntStart + idx, kEepromDataType_Full);
+                // data = get_eeprom_data(kEep_FaultCntStart + idx, kEepromDataType_Full);
-                //bsp_eeprom_save_data(kEep_FaultCntStart + idx, ++data, kEepromDataType_Full);
+                // bsp_eeprom_save_data(kEep_FaultCntStart + idx, ++data, kEepromDataType_Full);
             }
         }
     }
     kit_copy_buf(fault_item.fault_bit, fault_bit, 16);
 }
-

app/stm32fxxx_app/app/hv_adc_manager.c

@@ -10,7 +10,7 @@
 #include "hv_adc_manager.h"
 #include "table_comm.h"
 
-//#include "drv_mcp3208.h"
+// #include "drv_mcp3208.h"
 #include "drv_ads8688.h"
 
 #define CUR_FILTER_ENABLE (0u)
@@ -176,7 +176,7 @@ uint32_t HighResCurTrans(int32_t voldata)
     uint16_t Rsense = 39;
     uint32_t highResCurdata = 0;
 
-    highResCurdata = voldata * Rsense * 100;//扩大100倍
+    highResCurdata = voldata * Rsense * 100; // 扩大100倍
 
     return highResCurdata;
 }
@@ -187,7 +187,7 @@ int16_t bms_caculate_current(uint32_t base_time)
 #if CUR_FILTER_ENABLE
     static uint16_t dly = 0;
 #endif
-    int32_t tmp, tmp1, current,volval = 0;
+    int32_t tmp, tmp1, current, volval = 0;
     CurProp *prop;
     if (cur_item.channel < kCurChannel_End)
     {
@@ -197,26 +197,27 @@ int16_t bms_caculate_current(uint32_t base_time)
         case kCurSensor_Shunt:
             // 分流器 cur_hv_item.cur_volt_avg / cur_prop.shunt_volt * cur_prop.cur_scale;
             current = (int32_t)cur_hv_item.value[kAdIc_Cur] * prop->scale / cur_item.shunt_volt;
-            //current = HighResCurTrans(cur_hv_item.value[kAdIc_Cur]);
+            // current = HighResCurTrans(cur_hv_item.value[kAdIc_Cur]);
             break;
         case kCurSensor_SigHall:
             // 霍尔电流
             tmp = bms_get_adc_data(kAdcData_Hall1);
-            if(tmp<20)tmp = 0;
+            if (tmp < 20)
-            volval = tmp * 3300 /4095;
+                tmp = 0;
-            //current = (int32_t)(tmp - 250000) * prop->scale / cur_item.swing_volt;
+            volval = tmp * 3300 / 4095;
+            // current = (int32_t)(tmp - 250000) * prop->scale / cur_item.swing_volt;
             current = tmp;
             break;
         case kCurSensor_DualHall:
             // 霍尔电流
             tmp = bms_get_adc_data(kAdcData_Hall1);
-            volval = tmp * 3300 /4095;
+            volval = tmp * 3300 / 4095;
-            //current = (int32_t)(tmp - 250000) * prop->scale / cur_item.swing_volt;
+            // current = (int32_t)(tmp - 250000) * prop->scale / cur_item.swing_volt;
             current = tmp;
             if (KIT_ABS(current) > (int32_t)prop->scale * 90)
             {
                 tmp = bms_get_adc_data(kAdcData_Hall2);
-                //current = (int32_t)(tmp - 250000) * cur_item.prop[1].scale / cur_item.swing_volt;
+                // current = (int32_t)(tmp - 250000) * cur_item.prop[1].scale / cur_item.swing_volt;
                 current = tmp;
             }
             break;
@@ -230,8 +231,8 @@ int16_t bms_caculate_current(uint32_t base_time)
             break;
         }
     }
-    //测试用 SFJ 7.30,2-18,注释
+    // 测试用 SFJ 7.30,2-18,注释
-    //current = volval * 100 / 10;
+    // current = volval * 100 / 10;
 
     // 电流方向
     current *= prop->dir;
@@ -244,10 +245,10 @@ int16_t bms_caculate_current(uint32_t base_time)
     }
     current = (int64_t)current * get_eeprom_data(kEep_Hall1CalFactor, kEepromDataType_Full) / 1000;
 
-    //调试
+    // 调试
     bms_integral_soc(current, base_time);
 
-    cur_hv_item.current = current / 10;//转为 0.1
+    cur_hv_item.current = current / 10; // 转为 0.1
 
 #if CUR_FILTER_ENABLE
     dly += base_time;
@@ -279,17 +280,20 @@ uint32_t HighVolTrans(uint16_t voldata)
     return highvoldata;
 }
 
-
 AdjustValue adIc_adjust_value[kAdIc_End];
 uint16_t adIc_reg_map[kAdIc_End] = {MAN_Ch_0, MAN_Ch_1, MAN_Ch_2, MAN_Ch_3, MAN_Ch_4};
 
 uint16_t zero_calc(uint16_t value)
 {
-    if(value > 32700 && value < 32788)
+    if (value > 32700 && value < 32788)
     {
         return 0;
     }
-    else if(value < 20)
+    else if (value < 20)
+    {
+        return 0;
+    }
+    else if (value > 60000)
     {
         return 0;
     }
@@ -302,11 +306,11 @@ uint16_t zero_calc(uint16_t value)
 void get_ad_sample(void)
 {
     static uint16_t outputdata[16] = {0};
-    int32_t i =0,dir = 1;
+    int32_t i = 0, dir = 1;
-    //uint16_t ad =0;
+    // uint16_t ad =0;
-    uint16_t ad = 0,value = 0;
+    uint16_t ad = 0, value = 0;
 #if ADC_AUTO_MODE
-    //auto scan mode
+    // auto scan mode
     drv_enter_auto_rst_mode_Data(outputdata, 6);
 #else
 
@@ -326,9 +330,9 @@ void get_ad_sample(void)
 
     for (i = 0; i < kAdIc_End; i++)
     {
-        //ad = drv_get_ads8688_ch_data(adIc_reg_map[i]);
+        // ad = drv_get_ads8688_ch_data(adIc_reg_map[i]);
-        //0漂处理
+        // 0漂处理
-        if(i == kAdIc_Cur)
+        if (i == kAdIc_Cur)
         {
             outputdata[i] = zero_calc(outputdata[i]);
         }
@@ -336,7 +340,7 @@ void get_ad_sample(void)
         cur_hv_item.ad_buf[i][cur_hv_item.ad_buf_pos[i]++] = drv_ads8688_value(outputdata[i]);
         cur_hv_item.ad_avg[i] = kit_get_int32_avg_filter_max_min(cur_hv_item.ad_buf[i], ADCIC_SAMPLE_CNT);
 
-        if(cur_hv_item.ad_avg[i] < 0)
+        if (cur_hv_item.ad_avg[i] < 0)
         {
             dir = -1;
         }
@@ -345,35 +349,34 @@ void get_ad_sample(void)
 
         if (i == kAdIc_HvIso)
         {
-            //cur_hv_item.value[i] = HighVolTrans2(ad)/100;
+            // cur_hv_item.value[i] = HighVolTrans2(ad)/100;
             bms_set_iso_volt_ad(kIsoVolt_Other, dir * ad);
         }
-        if(i == kAdIc_HvIsoNagtive)
+        if (i == kAdIc_HvIsoNagtive)
         {
-
         }
         if (i == kAdIc_HvBat)
         {
-            cur_hv_item.value[i] = dir * (376 * ad * 512 * 10 / (0x01 << 15)) / 100; //单位是mv
+            cur_hv_item.value[i] = dir * (376 * ad * 512 * 10 / (0x01 << 15)) / 100; // 单位是mv
             bms_set_iso_volt_ad(kIsoVolt_TotalVolt, cur_hv_item.value[i]);
         }
-        if(i == kAdIc_Hv1)
+        if (i == kAdIc_Hv1)
         {
-            cur_hv_item.value[i] = dir * (376 * ad * 512 * 10 / (0x01 << 15)) / 100; //单位是mv
+            cur_hv_item.value[i] = dir * (376 * ad * 512 * 10 / (0x01 << 15)) / 100; // 单位是mv
         }
-        if(i == kAdIc_Cur)
+        if (i == kAdIc_Cur)
         {
-            //ad = ad - adIc_adjust_value[i].zero;
+            // ad = ad - adIc_adjust_value[i].zero;
 
-            //ad = (ad * 5120 * 10 / (0x01 << 15)) / 82;  //单位是mv
+            // ad = (ad * 5120 * 10 / (0x01 << 15)) / 82;  //单位是mv
-            ad = (ad * 2560 * 10 * 100 / (0x01 << 15)) / 82;  //单位是0.1 mv
+            ad = (ad * 2560 * 10 * 100 / (0x01 << 15)) / 82; // 单位是0.1 mv
 
             // 防止eeprom中没有设置电压校准系数
             if (get_eeprom_data(kEep_Volt1CalFactor, kEepromDataType_Full) <= 900 || get_eeprom_data(kEep_Volt1CalFactor, kEepromDataType_Full) >= 1100)
             {
                 bsp_eeprom_save_data(kEep_Volt1CalFactor, 1000, kEepromDataType_Full);
             }
-            cur_hv_item.value[i] = ad * dir;/// 1000 * adIc_adjust_value[i].rate *get_eeprom_data(kEep_Volt1CalFactor, kEepromDataType_Full) / 1000;//转为V
+            cur_hv_item.value[i] = ad * dir; /// 1000 * adIc_adjust_value[i].rate *get_eeprom_data(kEep_Volt1CalFactor, kEepromDataType_Full) / 1000;//转为V
         }
 
         if (cur_hv_item.ad_buf_pos[i] >= ADCIC_SAMPLE_CNT)
@@ -383,7 +386,6 @@ void get_ad_sample(void)
     }
 }
 
-
 int16_t bms_poll_cur_hv(uint32_t base_time)
 {
     get_ad_sample();
@@ -482,7 +484,7 @@ void bms_init_cur_hv(void)
     static uint8_t errcnt = 0;
     uint32_t i = 0, cnt = 30;
 #ifdef ADS_8688_EN
-    while(drv_ads8688_Init() && errcnt < 30)
+    while (drv_ads8688_Init() && errcnt < 30)
     {
         errcnt++;
         OSTimeDly(20);

app/stm32fxxx_app/app/logic_di.c

@@ -15,20 +15,19 @@ typedef struct
 
 DiParamItem di_param_item[kDiType_End];
 
-
+// 辅助触点1
-//辅助触点1
+// di_signal->di_item.status,  di->di_iteml.type
-//di_signal->di_item.status,  di->di_iteml.type
 void ord_di_do_feedback_func(uint32_t base_time, DiStatus di_signal, DiType di)
 {
-    if(di < kDiType_End)
+    if (di < kDiType_End)
     {
-        if(bms_get_do_status_by_idx(di - kDiType_Do1Feedback) != di_signal)
+        if (bms_get_do_status_by_idx(di - kDiType_Do1Feedback) != di_signal)
         {
-            //I don't know what's the meaning of this line.Whatever I change the 5000 to what , it is always enter the " if " and set the fault level.
+            // I don't know what's the meaning of this line.Whatever I change the 5000 to what , it is always enter the " if " and set the fault level.
-            //di_param_item[di].dly += base_time;
+            di_param_item[di].dly += base_time;
-            if(di_param_item[di].dly >= 5000)
+            if (di_param_item[di].dly >= 5000)
             {
-                //这里会写进错误--反馈异常，这里的一级代表三级错误
+                // 这里会写进错误--反馈异常，这里的一级代表三级错误
                 bms_set_fault_level(kFaultCode_Feedback, kFaultLevel_First, kFaultHandle_AlarmIdx);
             }
         }
@@ -39,64 +38,62 @@ void ord_di_do_feedback_func(uint32_t base_time, DiStatus di_signal, DiType di)
     }
 }
 
-//消防火警 报故障，断继电器
+// 消防火警 报故障，断继电器
 void ord_di_fire_alarm1_func(uint32_t base_time, DiStatus di_signal, DiType di)
 {
-    if((di < kDiType_End) && (di_signal == kDiStatus_Trigger))
+    if ((di < kDiType_End) && (di_signal == kDiStatus_Trigger))
     {
         di_param_item[di].dly += base_time;
         bms_set_fault_level(kFaultCode_Fire, kFaultLevel_Third, kFaultHandle_CutNoRelIdx);
     }
 }
 
-
+// 急停信号
-//急停信号
 void ord_di_emerge_stop_func(uint32_t base_time, DiStatus di_signal, DiType di)
 {
-    if(di_signal == kDiStatus_Trigger)
+    if (di_signal == kDiStatus_Trigger)
     {
         bms_set_fault_level(kFaultCode_Stop, kFaultLevel_Third, kFaultHandle_CutNoRelIdx);
     }
 }
 
-
+// 自锁信号-解除休眠
-//自锁信号-解除休眠
 void ord_di_self_lock_func(uint32_t base_time, DiStatus di_signal, DiType di)
 {
     bool is_lock_enable_off = false;
-    if(di_signal == kDiStatus_Trigger)
+    if (di_signal == kDiStatus_Trigger)
     {
-        bms_set_signal(kSignalIdx_LowVoltSleep,(SignalStatus)is_lock_enable_off);
+        bms_set_signal(kSignalIdx_LowVoltSleep, (SignalStatus)is_lock_enable_off);
-        bms_set_signal(kSignalIdx_StandbySleep,(SignalStatus)is_lock_enable_off);
+        bms_set_signal(kSignalIdx_StandbySleep, (SignalStatus)is_lock_enable_off);
     }
 }
 
-//水浸故障1
+// 水浸故障1
 void ord_di_water1_fun(uint32_t base_time, DiStatus di_signal, DiType di)
 {
-    if((di < kDiType_End) && (di_signal == kDiStatus_Trigger))
+    if ((di < kDiType_End) && (di_signal == kDiStatus_Trigger))
     {
         di_param_item[di].dly += base_time;
         bms_set_fault_level(kFaultCode_Water, kFaultLevel_Third, kFaultHandle_CutNoRelIdx);
     }
 }
 
-//熔断器故障1
+// 熔断器故障1
 void ord_di_fuse1_fun(uint32_t base_time, DiStatus di_signal, DiType di)
 {
-    if((di < kDiType_End) && (di_signal == kDiStatus_Trigger))
+    if ((di < kDiType_End) && (di_signal == kDiStatus_Trigger))
     {
         di_param_item[di].dly += base_time;
         bms_set_fault_level(kFaultCode_FuseStatus, kFaultLevel_Third, kFaultHandle_CutNoRelIdx);
     }
 }
 
-//断路器反馈信号1
+// 断路器反馈信号1
 void ord_di_breaker1_fun(uint32_t base_time, DiStatus di_signal, DiType di)
 {
-    if((di < kDiType_End) && (di_signal == kDiStatus_Trigger))
+    if ((di < kDiType_End) && (di_signal == kDiStatus_Trigger))
     {
-        //这里会写进错误--反馈异常，这里的三级代表一级错误
+        // 这里会写进错误--反馈异常，这里的三级代表一级错误
         di_param_item[di].dly += base_time;
         bms_set_fault_level(kFaultCode_Feedback, kFaultLevel_Third, kFaultHandle_CutNoRelIdx);
     }
@@ -105,28 +102,26 @@ void ord_di_breaker1_fun(uint32_t base_time, DiStatus di_signal, DiType di)
 /*无，消防1，消防2，消防3，DO1反馈信号，DO2反馈信号，DO3反馈信号，DO4反馈信号，DO5反馈信号，
 DO6反馈信号，门禁，水浸，保险丝故障信号，PCS故障信号，空调故障信号，隔离开关反馈信号，气体检测故障信号，
 UPS故障信号，EMS故障信号，*/
-//DI策略对应函数，注意应与枚举DiStrategy顺序一致
+// DI策略对应函数，注意应与枚举DiStrategy顺序一致
-const DiFun di_func[kDiType_End]= {
+const DiFun di_func[kDiType_End] = {
     NULL,
-    ord_di_emerge_stop_func, //急停，
+    ord_di_emerge_stop_func, // 急停，
-    ord_di_fire_alarm1_func,//消防1
+    ord_di_fire_alarm1_func, // 消防1
-    ord_di_fire_alarm1_func,//消防2
+    ord_di_fire_alarm1_func, // 消防2
-    ord_di_fire_alarm1_func,//消防3
+    ord_di_fire_alarm1_func, // 消防3
-    ord_di_do_feedback_func,//DO1反馈信号
+    ord_di_do_feedback_func, // DO1反馈信号
-    ord_di_do_feedback_func,//DO2反馈信号
+    ord_di_do_feedback_func, // DO2反馈信号
-    ord_di_do_feedback_func,//DO3反馈信号
+    ord_di_do_feedback_func, // DO3反馈信号
-    ord_di_do_feedback_func,//DO4反馈信号
+    ord_di_do_feedback_func, // DO4反馈信号
-    ord_di_do_feedback_func,//DO5反馈信号
+    ord_di_do_feedback_func, // DO5反馈信号
-    ord_di_do_feedback_func,//DO6反馈信号
+    ord_di_do_feedback_func, // DO6反馈信号
-    NULL,//门禁
+    NULL,                    // 门禁
-    ord_di_water1_fun,//水浸
+    ord_di_water1_fun,       // 水浸
-    ord_di_fuse1_fun,//保险丝故障信号
+    ord_di_fuse1_fun,        // 保险丝故障信号
-    NULL,//PCS故障信号
+    NULL,                    // PCS故障信号
-    NULL,//空调故障信号
+    NULL,                    // 空调故障信号
-    NULL,//隔离开关反馈信号
+    NULL,                    // 隔离开关反馈信号
-    NULL,//气体检测故障信号
+    NULL,                    // 气体检测故障信号
-    NULL,//UPS故障信号
+    NULL,                    // UPS故障信号
-    NULL//EMS故障信号
+    NULL                     // EMS故障信号
 };
-
-

app/stm32fxxx_app/app/logic_ems_ctrl.c

@@ -7,10 +7,10 @@
 DoLogicStatus logic_cmd_ctrl(uint32_t base_time)
 {
     static DoLogicStatus status = kDoLogicStatus_Off;
-    switch(status)
+    switch (status)
     {
     case kDoLogicStatus_Off:
-        if(bms_get_circuit_cmd_status()== kCircuitStatus_On && bms_is_dis_allow() == true && bms_is_chg_allow() == true)
+        if (bms_get_circuit_cmd_status() == kCircuitStatus_On && bms_is_dis_allow() == true && bms_is_chg_allow() == true)
         {
             bms_crtl_do_status(kDoType_Positive, kDoCtrlStatus_On, 100);
             bms_crtl_do_status(kDoType_Negative, kDoCtrlStatus_On, 100);
@@ -18,7 +18,7 @@ DoLogicStatus logic_cmd_ctrl(uint32_t base_time)
         }
         break;
     case kDoLogicStatus_On:
-        if(((bms_is_dis_allow() == false || bms_is_chg_allow() == false)) && (KIT_ABS(bms_get_current()) < 30))
+        if (((bms_is_dis_allow() == false || bms_is_chg_allow() == false)) && (KIT_ABS(bms_get_current()) < 30))
         {
             bms_crtl_do_status(kDoType_PreChg, kDoCtrlStatus_Off, RELAY_CTRL_NO_DLY);
             bms_crtl_do_status(kDoType_Positive, kDoCtrlStatus_Off, 100);
@@ -44,4 +44,3 @@ void logic_cmd_ctrl_poll(uint32_t base_time, uint8_t idx)
     bms_set_circuit_status(kCircuitType_Chg, circuit_status);
     bms_set_circuit_status(kCircuitType_Main, circuit_status);
 }
-

app/stm32fxxx_app/app/logic_same_circuit_ctrl.c

@@ -7,35 +7,34 @@
 #include "hv_adc_manager.h"
 #include "logic_ctrl.h"
 
-
+// 确保在继电器断开时调用
-//确保在继电器断开时调用
 bool logic_adhesion_check(uint32_t base_time, DoType type)
 {
     static uint16_t adhesion_dly = 0;
     bool is_chekc = true;
     uint16_t tv, hv, rate;
-    FaultLevel  fault = kFaultLevel_Normal;
+    FaultLevel fault = kFaultLevel_Normal;
     DoErrSrc do_err_src = bms_get_do_err_src(type);
 
-    //do_err_src += 1;
+    // do_err_src += 1;
 
-    if(bms_get_run_status() == kRunStatus_Init)
+    if (bms_get_run_status() == kRunStatus_Init)
     {
         return false;
     }
-    switch(do_err_src)
+    switch (do_err_src)
     {
     case kDoErrSrc_HV1:
     case kDoErrSrc_HV2:
-        //母线簇用电压检测粘连
+        // 母线簇用电压检测粘连
         tv = bms_get_high_volt(kHvType_Bat);
-        if((tv >= 300) && (bms_get_circuit_cmd_status() == kCircuitStatus_On))
+        if ((tv >= 300) && (bms_get_circuit_cmd_status() == kCircuitStatus_On))
         {
-            if(bms_get_bus_bar_bcu() == bms_get_tag_data(kTagData_DevAddr))
+            if (bms_get_bus_bar_bcu() == bms_get_tag_data(kTagData_DevAddr))
             {
                 hv = bms_get_high_volt((HvType)(kHvType_Hv1 + do_err_src - 1));
                 rate = get_eeprom_data(kEep_HV2_HV1VoltRate, (EepromDataType)(kEepromDataType_Low + do_err_src - 1));
-                if(hv >= ((uint32_t)tv * rate / 100))
+                if (hv >= ((uint32_t)tv * rate / 100))
                 {
                     fault = kFaultLevel_Third;
                 }
@@ -55,8 +54,8 @@ bool logic_adhesion_check(uint32_t base_time, DoType type)
     case kDoErrSrc_DI7:
     case kDoErrSrc_DI8:
     case kDoErrSrc_DI9:
-        //if(bms_get_signal((SignalIdx)(do_err_src - kDoErrSrc_DI1)) == kSignalStatus_High)
+        // if(bms_get_signal((SignalIdx)(do_err_src - kDoErrSrc_DI1)) == kSignalStatus_High)
-        if(bms_get_signal((SignalIdx)(do_err_src - kDoErrSrc_DI1)) != bms_get_di_polarity(do_err_src - kDoErrSrc_DI1))
+        if (bms_get_signal((SignalIdx)(do_err_src - kDoErrSrc_DI1)) != bms_get_di_polarity(do_err_src - kDoErrSrc_DI1))
         {
             fault = kFaultLevel_Third;
         }
@@ -64,18 +63,18 @@ bool logic_adhesion_check(uint32_t base_time, DoType type)
     default:
         break;
     }
-    //通过电流判断粘连
+    // 通过电流判断粘连
-    if((fault != kFaultLevel_Third) && (KIT_ABS(bms_get_current()) > 50))
+    if ((fault != kFaultLevel_Third) && (KIT_ABS(bms_get_current()) > 50))
     {
         fault = kFaultLevel_Third;
     }
 
-    //gary 增加连续3秒粘连问题在报粘连故障
+    // gary 增加连续3秒粘连问题在报粘连故障
-    if(fault == kFaultLevel_Third && is_chekc == true)
+    if (fault == kFaultLevel_Third && is_chekc == true)
     {
         adhesion_dly += base_time;
 
-        if(adhesion_dly > 3000)
+        if (adhesion_dly > 3000)
         {
             adhesion_dly = 0;
             bms_set_do_fault(type, kDoStatus_Adhesion);
@@ -93,20 +92,20 @@ void logic_open_check(uint32_t base_time)
 {
     uint16_t tv, hv, rate;
     DoErrSrc do_err_src = bms_get_do_err_src(kDoType_Chg);
-    FaultLevel  fault = kFaultLevel_Normal;
+    FaultLevel fault = kFaultLevel_Normal;
     static uint16_t dly;
 
-    switch(do_err_src)
+    switch (do_err_src)
     {
     case kDoErrSrc_HV1:
     case kDoErrSrc_HV2:
         tv = bms_get_high_volt(kHvType_Bat);
         hv = bms_get_high_volt((HvType)(kHvType_Hv1 + do_err_src - 1));
         rate = get_eeprom_data(kEep_HV2_HV1VoltRate, (EepromDataType)(kEepromDataType_Low + do_err_src - 1));
-        if((tv >= 300 && (hv + 200 <= ((uint32_t)tv * rate / 100))) || (tv<100))
+        if ((tv >= 300 && (hv + 200 <= ((uint32_t)tv * rate / 100))) || (tv < 100))
         {
             dly += base_time;
-            if(dly >= 1000)
+            if (dly >= 1000)
             {
                 fault = kFaultLevel_Third;
             }
@@ -126,8 +125,8 @@ void logic_open_check(uint32_t base_time)
     case kDoErrSrc_DI7:
     case kDoErrSrc_DI8:
     case kDoErrSrc_DI9:
-        //if(bms_get_signal((SignalIdx)(do_err_src - kDoErrSrc_DI1)) == kSignalStatus_High)
+        // if(bms_get_signal((SignalIdx)(do_err_src - kDoErrSrc_DI1)) == kSignalStatus_High)
-        if(bms_get_signal((SignalIdx)(do_err_src - kDoErrSrc_DI1)) == bms_get_di_polarity(do_err_src - kDoErrSrc_DI1))
+        if (bms_get_signal((SignalIdx)(do_err_src - kDoErrSrc_DI1)) == bms_get_di_polarity(do_err_src - kDoErrSrc_DI1))
         {
             fault = kFaultLevel_Third;
         }
@@ -138,7 +137,6 @@ void logic_open_check(uint32_t base_time)
     bms_set_fault_level(kFaultCode_DoOpen, fault, kFaultHandle_CutNoRelIdx);
 }
 
-
 void logic_same_circuit_ctrl(uint32_t base_time)
 {
     HvType prechg_type;
@@ -151,15 +149,14 @@ void logic_same_circuit_ctrl(uint32_t base_time)
     uint8_t prechg_max_cnt = prechg_time & 0x00FF;
     prechg_time = (prechg_time >> 8) * 1000;
 
-    switch(status)
+    switch (status)
     {
     case kDoLogicStatus_Reset:
-        if((get_eeprom_data(kEep_IsSoftReset, kEepromDataType_High) == 1)
+        if ((get_eeprom_data(kEep_IsSoftReset, kEepromDataType_High) == 1) && (get_eeprom_data(kEep_IsSoftReset, kEepromDataType_Low) != 0))
-                && (get_eeprom_data(kEep_IsSoftReset, kEepromDataType_Low) != 0))
         {
             dly += base_time;
-            //kEep_IsSoftReset高低只能清楚一个，否则断电下带无法保存0
+            // kEep_IsSoftReset高低只能清楚一个，否则断电下带无法保存0
-            if(((bms_get_run_status() != kRunStatus_Init) && (bms_get_circuit_cmd_status() == kCircuitStatus_On)) || (dly >= 10000))
+            if (((bms_get_run_status() != kRunStatus_Init) && (bms_get_circuit_cmd_status() == kCircuitStatus_On)) || (dly >= 10000))
             {
                 bms_crtl_do_status(kDoType_Chg, kDoCtrlStatus_On, RELAY_CTRL_NO_DLY);
                 bms_crtl_do_status(kDoType_Dis, kDoCtrlStatus_On, 100);
@@ -174,10 +171,10 @@ void logic_same_circuit_ctrl(uint32_t base_time)
         }
         break;
     case kDoLogicStatus_Init:
-        //增加init状态，防止预充中反复检测粘连 建议增加多次检测
+        // 增加init状态，防止预充中反复检测粘连 建议增加多次检测
-        //Gary 2024-07-25 连续粘连3秒才报粘连故障
+        // Gary 2024-07-25 连续粘连3秒才报粘连故障
         dly += base_time;
-        if(logic_adhesion_check(base_time, kDoType_Chg) == true)
+        if (logic_adhesion_check(base_time, kDoType_Chg) == true)
         {
             dly = 0;
             status = kDoLogicStatus_Off;
@@ -186,21 +183,20 @@ void logic_same_circuit_ctrl(uint32_t base_time)
     case kDoLogicStatus_Off:
         if ((bms_is_dis_allow() == true) && (bms_is_chg_allow() == true))
         {
-            if (prechg_max_cnt == 0)	//读取配置：不预充
+            if (prechg_max_cnt == 0) // 读取配置：不预充
             {
                 status = kDoLogicStatus_On;
                 bms_crtl_do_status(kDoType_Dis, kDoCtrlStatus_On, RELAY_CTRL_NO_DLY);
                 bms_crtl_do_status(kDoType_Chg, kDoCtrlStatus_On, 100);
             }
-            else //读取配置：预充
+            else // 读取配置：预充
             {
-                if (prechg_cnt++ < prechg_max_cnt) //判断预充次数
+                if (prechg_cnt++ < prechg_max_cnt) // 判断预充次数
                 {
                     status = kDoLogicStatus_Prechg;
-                    //bms_crtl_do_status(kDoType_Chg, kDoCtrlStatus_On, RELAY_CTRL_NO_DLY); //闭合总正继电器
+                    // bms_crtl_do_status(kDoType_Chg, kDoCtrlStatus_On, RELAY_CTRL_NO_DLY); //闭合总正继电器
                     bms_crtl_do_status(kDoType_Dis, kDoCtrlStatus_On, RELAY_CTRL_NO_DLY);
                     bms_crtl_do_status(kDoType_PreChg, kDoCtrlStatus_On, 100);
-
                 }
                 else
                 {
@@ -219,7 +215,7 @@ void logic_same_circuit_ctrl(uint32_t base_time)
             bms_crtl_do_status(kDoType_PreChg, kDoCtrlStatus_Off, RELAY_CTRL_NO_DLY);
             bms_crtl_do_status(kDoType_Dis, kDoCtrlStatus_Off, 100);
         }
-        else if (dly >= prechg_time)//预充超时
+        else if (dly >= prechg_time) // 预充超时
         {
             dly = 0;
             status = kDoLogicStatus_PrechgFail;
@@ -227,18 +223,18 @@ void logic_same_circuit_ctrl(uint32_t base_time)
         }
         else
         {
-            prechg_volt = bms_get_high_volt(kHvType_Bat);//sfj 获取B+B-电压
+            prechg_volt = bms_get_high_volt(kHvType_Bat); // sfj 获取B+B-电压
             if (prechg_volt >= 300)
             {
-                prechg_type = (HvType)get_eeprom_data(kEep_PreChgVoltType_Rate,kEepromDataType_High);
+                prechg_type = (HvType)get_eeprom_data(kEep_PreChgVoltType_Rate, kEepromDataType_High);
-                prechg_volt = prechg_volt * get_eeprom_data(kEep_PreChgVoltType_Rate,kEepromDataType_Low) / 100;
+                prechg_volt = prechg_volt * get_eeprom_data(kEep_PreChgVoltType_Rate, kEepromDataType_Low) / 100;
-                if(bms_get_high_volt(prechg_type) >= prechg_volt)
+                if (bms_get_high_volt(prechg_type) >= prechg_volt)
                 {
                     dly = 0;
                     prechg_cnt = 0;
                     status = kDoLogicStatus_On;
-                    bms_crtl_do_status(kDoType_Chg, kDoCtrlStatus_On, RELAY_CTRL_NO_DLY); //闭合总正继电器
+                    bms_crtl_do_status(kDoType_Chg, kDoCtrlStatus_On, RELAY_CTRL_NO_DLY); // 闭合总正继电器
-                    bms_crtl_do_status(kDoType_PreChg, kDoCtrlStatus_Off, 500); //延时500ms断开预充继电器
+                    bms_crtl_do_status(kDoType_PreChg, kDoCtrlStatus_Off, 500);           // 延时500ms断开预充继电器
                 }
             }
         }
@@ -253,12 +249,12 @@ void logic_same_circuit_ctrl(uint32_t base_time)
         break;
     case kDoLogicStatus_On:
         dly += base_time;
-        if(dly >= 10000)
+        if (dly >= 10000)
         {
             dly = 10000;
             logic_open_check(base_time);
         }
-        if((bms_is_dis_allow() == false) || (bms_is_chg_allow() == false))
+        if ((bms_is_dis_allow() == false) || (bms_is_chg_allow() == false))
         {
             dly = 0;
             status = kDoLogicStatus_WaitOff;
@@ -266,8 +262,8 @@ void logic_same_circuit_ctrl(uint32_t base_time)
         break;
     case kDoLogicStatus_WaitOff:
         dly += base_time;
-        if ((KIT_ABS(bms_get_current() / 10) <= get_eeprom_data(kEep_CutOffCurrent, kEepromDataType_Full)) //电流阈值可配置，分辨率 1A
+        if ((KIT_ABS(bms_get_current() / 10) <= get_eeprom_data(kEep_CutOffCurrent, kEepromDataType_Full)) // 电流阈值可配置，分辨率 1A
-                && (dly >= get_eeprom_data(kEep_PwrOffDly_MinOnlineCluster, kEepromDataType_High) * 1000)) //高压下电延迟
+            && (dly >= get_eeprom_data(kEep_PwrOffDly_MinOnlineCluster, kEepromDataType_High) * 1000))     // 高压下电延迟
         {
             dly = 0;
             status = kDoLogicStatus_WaitAdhesion;
@@ -277,7 +273,7 @@ void logic_same_circuit_ctrl(uint32_t base_time)
         break;
     case kDoLogicStatus_WaitAdhesion:
         dly += base_time;
-        if(dly >= KIT_SECOND_CONVERT(5))
+        if (dly >= KIT_SECOND_CONVERT(5))
         {
             dly = 0;
             status = kDoLogicStatus_Init;
@@ -298,10 +294,9 @@ void logic_same_circuit_poll(uint32_t base_time, uint8_t idx)
     logic_same_circuit_ctrl(base_time);
     pos_rly_st = bms_get_do_status_by_type(kDoType_Chg);
     neg_rly_st = (bms_is_do_config(kDoType_Dis) == true) ? bms_get_do_status_by_type(kDoType_Dis) : kDoStatus_On;
-    //neg_rly_st = kDoStatus_On;
+    // neg_rly_st = kDoStatus_On;
 
-    if(((pos_rly_st != kDoStatus_On) && (pos_rly_st != kDoStatus_ForceOn))
+    if (((pos_rly_st != kDoStatus_On) && (pos_rly_st != kDoStatus_ForceOn)) || ((neg_rly_st != kDoStatus_On) && (neg_rly_st != kDoStatus_ForceOn)))
-            || ((neg_rly_st != kDoStatus_On) && (neg_rly_st != kDoStatus_ForceOn)))
     {
         circuit_st = kCircuitStatus_Off;
     }

app/stm32fxxx_app/app/soc_calculate.c

@@ -12,17 +12,17 @@
 #include "run_status.h"
 #include "hv_adc_manager.h"
 
-#define SOX_CHG_kEep_SOC            (9900u)
+#define SOX_CHG_kEep_SOC (9900u)
-#define SOX_DIS_kEep_SOC            (100u)
+#define SOX_DIS_kEep_SOC (100u)
-#define SOX_MAX_SOC_VALUE           (10000u)
+#define SOX_MAX_SOC_VALUE (10000u)
-#define SOX_MIN_SOC_VALUE           (0u)
+#define SOX_MIN_SOC_VALUE (0u)
-#define SOX_MAX_SOH_VALUE           (10000u)
+#define SOX_MAX_SOH_VALUE (10000u)
-#define SOX_MIN_SOH_VALUE           (0u)
+#define SOX_MIN_SOH_VALUE (0u)
-#define SOX_CYCLE_UP_SOC_VALUE      (9000u)
+#define SOX_CYCLE_UP_SOC_VALUE (9000u)
-#define SOX_CYCLE_DOWN_SOC_VALUE    (3000u)
+#define SOX_CYCLE_DOWN_SOC_VALUE (3000u)
-#define SOX_MAX_SIGNAL_INTEGRAL     (20000u) 	//单次积分最大值(2000A*10ms)
+#define SOX_MAX_SIGNAL_INTEGRAL (20000u)      // 单次积分最大值(2000A*10ms)
-#define SOX_SIGNAL_ACC_CAP_VALUE    (360000u) 	//1Ams - 0.1Ah
+#define SOX_SIGNAL_ACC_CAP_VALUE (360000u)    // 1Ams - 0.1Ah
-#define SOX_SIGNAL_ACC_ENERGY_VALUE (360000u) 	//1kWms - 0.1kWh
+#define SOX_SIGNAL_ACC_ENERGY_VALUE (360000u) // 1kWms - 0.1kWh
 
 typedef enum
 {
@@ -48,19 +48,19 @@ typedef struct
     uint8_t chg_adjust_rate;
     uint8_t stat_day;
 
-    uint8_t  soc_run_diff;
+    uint8_t soc_run_diff;
-    uint8_t  soc_run_min;
+    uint8_t soc_run_min;
     uint16_t req_soc;
 
-    uint16_t   show_soc;
+    uint16_t show_soc;
-    uint32_t   calculate_cap; //积分计算容量(单位Ams)
+    uint32_t calculate_cap; // 积分计算容量(单位Ams)
-    uint32_t rated_cap;     //额定容量(单位Ams)
+    uint32_t rated_cap;     // 额定容量(单位Ams)
-    uint32_t soc_1_cap;     //soc 1%对应容量(单位Ams)
+    uint32_t soc_1_cap;     // soc 1%对应容量(单位Ams)
-    uint32_t soc_99_cap;    //soc 99%对应容量(单位Ams)
+    uint32_t soc_99_cap;    // soc 99%对应容量(单位Ams)
 
     uint32_t last_tick;
-    uint32_t tmp_dis_cap;   //存储临时放电容量 (单位Ams)
+    uint32_t tmp_dis_cap; // 存储临时放电容量 (单位Ams)
-    uint32_t tmp_chg_cap;   //存储临时充电容量 (单位Ams)
+    uint32_t tmp_chg_cap; // 存储临时充电容量 (单位Ams)
 
     uint32_t tmp_dis_energy;
     uint32_t tmp_chg_energy;
@@ -126,7 +126,7 @@ void bms_set_soc_status(SocStatus st)
 uint32_t bms_get_cumulate_data(CumulateData idx)
 {
     uint32_t tmp = 0;
-    if(idx < kCumulateData_End)
+    if (idx < kCumulateData_End)
     {
         tmp = sox_item.data[idx];
     }
@@ -136,7 +136,7 @@ uint32_t bms_get_cumulate_data(CumulateData idx)
 
 void bms_set_cumulate_data(CumulateData idx, uint32_t value)
 {
-    if(idx < kCumulateData_End)
+    if (idx < kCumulateData_End)
     {
         sox_item.data[idx] = value;
     }
@@ -144,24 +144,24 @@ void bms_set_cumulate_data(CumulateData idx, uint32_t value)
 
 uint16_t soh_init(uint16_t cycle, uint32_t dis_cap, uint32_t charge_cap)
 {
-    uint16_t soh_loss1 = 0; //充放电次数计算出的SOH损耗百分比
+    uint16_t soh_loss1 = 0;                                                          // 充放电次数计算出的SOH损耗百分比
-    uint16_t soh_loss2 = 0; //累计放电安时计算出的SOH损耗百分比
+    uint16_t soh_loss2 = 0;                                                          // 累计放电安时计算出的SOH损耗百分比
-    uint32_t rated_cap = get_eeprom_data(kEep_RatedCapacity, kEepromDataType_Full);  //2800
+    uint32_t rated_cap = get_eeprom_data(kEep_RatedCapacity, kEepromDataType_Full);  // 2800
-    uint16_t cycle_70 = get_eeprom_data(kEep_SOHSeventyCycle, kEepromDataType_Full);//3000
+    uint16_t cycle_70 = get_eeprom_data(kEep_SOHSeventyCycle, kEepromDataType_Full); // 3000
 
-    if(cycle <= 10)
+    if (cycle <= 10)
     {
         return 10000;
     }
-    //单位0.0001/bit
+    // 单位0.0001/bit
-    //公式(0.3 / cycle_70) * cycle * 10000
+    // 公式(0.3 / cycle_70) * cycle * 10000
     soh_loss1 = (uint32_t)cycle * 3000 / cycle_70;
     if (soh_loss1 >= 3000)
     {
         return 7000;
     }
 
-    soh_loss2 = (uint16_t)((3000.0 / cycle_70)*(1.0*(dis_cap+charge_cap) / (2*rated_cap)));
+    soh_loss2 = (uint16_t)((3000.0 / cycle_70) * (1.0 * (dis_cap + charge_cap) / (2 * rated_cap)));
 
     if (soh_loss2 >= 3000)
     {
@@ -186,11 +186,11 @@ void cap_data_update(uint16_t base_time)
 
     uint16_t soc;
     RunStatus run_status;
-    int32_t  year, mon, day;
+    int32_t year, mon, day;
     int16_t cur = bms_get_current();
 
     dly += base_time;
-    if(dly >= KIT_SECOND_CONVERT(1))//1S任务
+    if (dly >= KIT_SECOND_CONVERT(1)) // 1S任务
     {
         bms_set_signal(kSignalIdx_SocFull, (SignalStatus)((sox_item.soc_st & kSocStatus_Full) != 0));
         bms_set_signal(kSignalIdx_SocEmpty, (SignalStatus)((sox_item.soc_st & kSocStatus_Empty) != 0));
@@ -198,16 +198,16 @@ void cap_data_update(uint16_t base_time)
         dly = 0;
         run_status = bms_get_run_status();
         soc = bms_check_run_ocv(KIT_SECOND_CONVERT(1), sox_item.soc);
-        if(soc != sox_item.soc)
+        if (soc != sox_item.soc)
         {
             bms_set_soc(soc);
         }
 
-        //累计时间更新
+        // 累计时间更新
         if (run_status == kRunStatus_Chg)
         {
             chg_dly += KIT_SECOND_CONVERT(1);
-            if(chg_dly >= KIT_MINUTE_CONVERT(6))//
+            if (chg_dly >= KIT_MINUTE_CONVERT(6)) //
             {
                 chg_dly -= KIT_MINUTE_CONVERT(6);
 
@@ -217,10 +217,10 @@ void cap_data_update(uint16_t base_time)
             }
             sox_item.data[kCumulateData_SigDisTime] = 0;
         }
-        else if(run_status == kRunStatus_Dis)
+        else if (run_status == kRunStatus_Dis)
         {
             dis_dly += KIT_SECOND_CONVERT(1);
-            if(dis_dly >= KIT_MINUTE_CONVERT(6))
+            if (dis_dly >= KIT_MINUTE_CONVERT(6))
             {
                 dis_dly -= KIT_MINUTE_CONVERT(6);
 
@@ -230,7 +230,7 @@ void cap_data_update(uint16_t base_time)
             }
             sox_item.data[kCumulateData_SigChgTime] = 0;
         }
-        //充放电循环次数更新 <30%  >90%
+        // 充放电循环次数更新 <30%  >90%
         if ((sox_item.soc <= SOX_CYCLE_DOWN_SOC_VALUE) && (sox_item.cyc_flag == 0))
         {
             sox_item.cycle++;
@@ -241,7 +241,7 @@ void cap_data_update(uint16_t base_time)
             sox_item.cyc_flag = 0;
         }
 
-        //累计容量更新 0.1Ah 更新一次
+        // 累计容量更新 0.1Ah 更新一次
         if (sox_item.tmp_dis_cap >= SOX_SIGNAL_ACC_CAP_VALUE)
         {
             sox_item.data[kCumulateData_SigDisCap]++;
@@ -259,9 +259,9 @@ void cap_data_update(uint16_t base_time)
         }
 
         drv_rtc_get_date(&year, &mon, &day);
-        if(sox_item.stat_day != day)
+        if (sox_item.stat_day != day)
         {
-            if(count++ > 5)
+            if (count++ > 5)
             {
                 count = 0;
                 sox_item.stat_day = day;
@@ -275,7 +275,7 @@ void cap_data_update(uint16_t base_time)
             count = 0;
         }
 
-        //累计能量更新 0.1kWh 更新一次
+        // 累计能量更新 0.1kWh 更新一次
         while (sox_item.tmp_dis_energy >= SOX_SIGNAL_ACC_ENERGY_VALUE)
         {
             sox_item.data[kCumulateData_SigDisEnergy]++;
@@ -294,9 +294,9 @@ void cap_data_update(uint16_t base_time)
     }
 }
 
-#define SOC_RUN_CALIBRATE_RATE_MAX	200
+#define SOC_RUN_CALIBRATE_RATE_MAX 200
-#define SOC_RUN_CALIBRATE_RATE_DEF	100
+#define SOC_RUN_CALIBRATE_RATE_DEF 100
-#define SOC_RUN_CALIBRATE_RATE_MIN	50
+#define SOC_RUN_CALIBRATE_RATE_MIN 50
 
 void soc_run_calibrate(int16_t current, uint16_t base_time)
 {
@@ -304,39 +304,39 @@ void soc_run_calibrate(int16_t current, uint16_t base_time)
     static uint16_t chg_dly = 0;
     uint8_t temp = 0;
 
-    //放电
+    // 放电
-    if((current < 0) && (sox_item.dis_adjust_flag == false) &&
+    if ((current < 0) && (sox_item.dis_adjust_flag == false) &&
-            (bms_get_statistic_data(kStatisticData_MinVolt) <= 3000) &&
+        (bms_get_statistic_data(kStatisticData_MinVolt) <= 3000) &&
-            (bms_get_ex_data(kExType_CellVolt) == kExStatus_None))
+        (bms_get_ex_data(kExType_CellVolt) == kExStatus_None))
     {
         chg_dly = 0;
         dis_dly += base_time;
-        if(dis_dly >= KIT_SECOND_CONVERT(5))
+        if (dis_dly >= KIT_SECOND_CONVERT(5))
         {
             sox_item.dis_adjust_flag = true;
             temp = sox_item.soc * 100 / 2000;
-            if(temp > SOC_RUN_CALIBRATE_RATE_MAX)
+            if (temp > SOC_RUN_CALIBRATE_RATE_MAX)
                 temp = SOC_RUN_CALIBRATE_RATE_MAX;
-            else if(temp < SOC_RUN_CALIBRATE_RATE_MIN)
+            else if (temp < SOC_RUN_CALIBRATE_RATE_MIN)
                 temp = SOC_RUN_CALIBRATE_RATE_MIN;
 
             sox_item.dis_adjust_rate = temp;
         }
     }
-    //充电
+    // 充电
-    else if((current > 0) && (sox_item.chg_adjust_flag == false) &&
+    else if ((current > 0) && (sox_item.chg_adjust_flag == false) &&
-            (bms_get_statistic_data(kStatisticData_MaxVolt) >= 3450) &&
+             (bms_get_statistic_data(kStatisticData_MaxVolt) >= 3450) &&
-            (bms_get_ex_data(kExType_CellVolt) == kExStatus_None))
+             (bms_get_ex_data(kExType_CellVolt) == kExStatus_None))
     {
         dis_dly = 0;
         chg_dly += base_time;
-        if(chg_dly >= KIT_SECOND_CONVERT(5))
+        if (chg_dly >= KIT_SECOND_CONVERT(5))
         {
             sox_item.chg_adjust_flag = true;
             temp = 8000 * 100 / sox_item.soc;
-            if(temp > SOC_RUN_CALIBRATE_RATE_MAX)
+            if (temp > SOC_RUN_CALIBRATE_RATE_MAX)
                 temp = SOC_RUN_CALIBRATE_RATE_MAX;
-            else if(temp < SOC_RUN_CALIBRATE_RATE_MIN)
+            else if (temp < SOC_RUN_CALIBRATE_RATE_MIN)
                 temp = SOC_RUN_CALIBRATE_RATE_MIN;
 
             sox_item.chg_adjust_rate = temp;
@@ -348,7 +348,7 @@ void soc_run_calibrate(int16_t current, uint16_t base_time)
     }
 }
 
-#define SOC_SMOOTH_ADJUST		0
+#define SOC_SMOOTH_ADJUST 0
 void soc_exterme_calibrate(int16_t current, uint16_t base_time)
 {
     static uint16_t full_dly = 0;
@@ -356,24 +356,19 @@ void soc_exterme_calibrate(int16_t current, uint16_t base_time)
     uint16_t avg_volt, total_volt;
     uint32_t tmp_soc = sox_item.soc;
 
-    if((bms_get_ex_data(kExType_CellVolt) != kExStatus_None)
+    if ((bms_get_ex_data(kExType_CellVolt) != kExStatus_None) || (bms_get_bmu_fault_bit(kBmuFaultBit_Offline) != 0))
-            || (bms_get_bmu_fault_bit(kBmuFaultBit_Offline) != 0))
     {
         empty_dly = 0;
         full_dly = 0;
         return;
     }
 
-    switch(sox_item.adjust_step)
+    switch (sox_item.adjust_step)
     {
     case kSocAdjustStep_Wait:
         avg_volt = bms_get_statistic_data(kStatisticData_AvgVolt);
-        total_volt = bms_get_statistic_data(kStatisticData_AccVolt)/ 100;
+        total_volt = bms_get_statistic_data(kStatisticData_AccVolt) / 100;
-        if (((bms_get_statistic_data(kStatisticData_MinVolt) <= get_eeprom_data(kEep_FullDisVolt, kEepromDataType_Full))
+        if (((bms_get_statistic_data(kStatisticData_MinVolt) <= get_eeprom_data(kEep_FullDisVolt, kEepromDataType_Full)) && (avg_volt <= get_eeprom_data(kEep_FullDisAvgVolt, kEepromDataType_Full)) && (bms_get_ex_data(kExType_CellVolt) == kExStatus_None)) || (total_volt <= get_eeprom_data(kEep_FullDisTotalVolt, kEepromDataType_Full) / 100) || ((sox_item.soc_req_st == kSocStatus_Empty) && (sox_item.is_bsu_adjust == false)))
-                && (avg_volt <= get_eeprom_data(kEep_FullDisAvgVolt, kEepromDataType_Full))
-                && (bms_get_ex_data(kExType_CellVolt) == kExStatus_None))
-                || (total_volt <= get_eeprom_data(kEep_FullDisTotalVolt, kEepromDataType_Full)/100)
-                || ((sox_item.soc_req_st == kSocStatus_Empty) && (sox_item.is_bsu_adjust == false)))
         {
             full_dly = 0;
             empty_dly += base_time;
@@ -390,14 +385,9 @@ void soc_exterme_calibrate(int16_t current, uint16_t base_time)
 #else
                 tmp_soc = SOX_MIN_SOC_VALUE;
 #endif
-
             }
         }
-        else if (((bms_get_statistic_data(kStatisticData_MaxVolt) >= get_eeprom_data(kEep_FullChgVolt, kEepromDataType_Full))
+        else if (((bms_get_statistic_data(kStatisticData_MaxVolt) >= get_eeprom_data(kEep_FullChgVolt, kEepromDataType_Full)) && (avg_volt >= get_eeprom_data(kEep_FullChgAvgVolt, kEepromDataType_Full)) && (bms_get_ex_data(kExType_CellVolt) == kExStatus_None)) || (total_volt >= get_eeprom_data(kEep_FullChgTotalVolt, kEepromDataType_Full)) || ((sox_item.soc_req_st == kSocStatus_Full) && (sox_item.is_bsu_adjust == false)))
-                  && (avg_volt >= get_eeprom_data(kEep_FullChgAvgVolt, kEepromDataType_Full))
-                  && (bms_get_ex_data(kExType_CellVolt) == kExStatus_None))
-                 || (total_volt >= get_eeprom_data(kEep_FullChgTotalVolt, kEepromDataType_Full))
-                 || ((sox_item.soc_req_st == kSocStatus_Full) && (sox_item.is_bsu_adjust == false)))
         {
             empty_dly = 0;
             full_dly += base_time;
@@ -415,7 +405,6 @@ void soc_exterme_calibrate(int16_t current, uint16_t base_time)
 #else
                 tmp_soc = SOX_MAX_SOC_VALUE;
 #endif
-
             }
         }
         else
@@ -431,8 +420,8 @@ void soc_exterme_calibrate(int16_t current, uint16_t base_time)
         {
             full_dly = 0;
 
-            tmp_soc++ ;
+            tmp_soc++;
-            if(tmp_soc >= SOX_MAX_SOC_VALUE)
+            if (tmp_soc >= SOX_MAX_SOC_VALUE)
                 sox_item.adjust_step = kSocAdjustStep_Wait;
         }
         break;
@@ -441,9 +430,9 @@ void soc_exterme_calibrate(int16_t current, uint16_t base_time)
         if (empty_dly >= 1000)
         {
             empty_dly = 0;
-            if(tmp_soc > SOX_MIN_SOC_VALUE)
+            if (tmp_soc > SOX_MIN_SOC_VALUE)
             {
-                tmp_soc-- ;
+                tmp_soc--;
             }
             else
                 sox_item.adjust_step = kSocAdjustStep_Wait;
@@ -457,16 +446,14 @@ void soc_exterme_calibrate(int16_t current, uint16_t base_time)
     sox_item.soc = tmp_soc;
 }
 
-
-
 void bms_init_soc(void)
 {
     uint32_t soc;
     uint64_t tmp_64u;
-    int32_t  year, mon, day;
+    int32_t year, mon, day;
 
     soc = get_eeprom_data(kEep_SOC, kEepromDataType_Full);
-    //soc = bms_check_pwr_on_ocv(soc);
+    // soc = bms_check_pwr_on_ocv(soc);
     sox_item.soc_kEep_99 = true;
     sox_item.soc_kEep_1 = true;
 
@@ -490,7 +477,7 @@ void bms_init_soc(void)
     sox_item.soc = soc;
     year = get_eeprom_data(kEep_SOCRunMax_Min, kEepromDataType_Low);
     mon = get_eeprom_data(kEep_SOCRunMax_Min, kEepromDataType_High);
-    if((year < mon) && (year >= 0) && (mon <= 100))
+    if ((year < mon) && (year >= 0) && (mon <= 100))
     {
         sox_item.soc_run_min = year;
         sox_item.soc_run_diff = mon - year;
@@ -513,7 +500,7 @@ void bms_init_soc(void)
     sox_item.stat_day = get_eeprom_data(kEep_StatDay_CycleTimesFlag, kEepromDataType_High);
 
     drv_rtc_get_date(&year, &mon, &day);
-    if(sox_item.stat_day == day)
+    if (sox_item.stat_day == day)
     {
         sox_item.data[kCumulateData_DayDisCap] = get_eeprom_data(kEep_DayDisCapL, kEepromDataType_Double);
         sox_item.data[kCumulateData_DayChgCap] = get_eeprom_data(kEep_DayChgCapL, kEepromDataType_Double);
@@ -529,7 +516,7 @@ void bms_init_soc(void)
     sox_item.data[kCumulateData_AccChgEnergy] = get_eeprom_data(kEep_AccChgEnergyL, kEepromDataType_Double);
     sox_item.data[kCumulateData_AccDisEnergy] = get_eeprom_data(kEep_AccDisEnergyL, kEepromDataType_Double);
 
-    sox_item.soh = soh_init(sox_item.cycle, sox_item.data[kCumulateData_AccDisCap],sox_item.data[kCumulateData_AccChgCap]);
+    sox_item.soh = soh_init(sox_item.cycle, sox_item.data[kCumulateData_AccDisCap], sox_item.data[kCumulateData_AccChgCap]);
 
     sox_item.last_tick = kit_time_get_tick();
 }
@@ -540,10 +527,10 @@ void bms_poll_soh(uint32_t base_time)
 
     dlysoh += base_time;
 
-    if(dlysoh >= 5000)
+    if (dlysoh >= 5000)
     {
         dlysoh = 0;
-        sox_item.soh = soh_init(sox_item.cycle, sox_item.data[kCumulateData_AccDisCap],sox_item.data[kCumulateData_AccChgCap]);
+        sox_item.soh = soh_init(sox_item.cycle, sox_item.data[kCumulateData_AccDisCap], sox_item.data[kCumulateData_AccChgCap]);
     }
 }
 
@@ -558,27 +545,26 @@ void bms_integral_soc(int32_t current, uint16_t base_time)
 
     cap_data_update(base_time);
     soc_exterme_calibrate(current, base_time);
-    if(sox_item.adjust_step != kSocAdjustStep_Wait)
+    if (sox_item.adjust_step != kSocAdjustStep_Wait)
         return;
 
-//	/*soc test add 2-19
+    //	/*soc test add 2-19
-//	current = 168;
+    //	current = 168;
-//	soc_run_calibrate(168, base_time);
+    //	soc_run_calibrate(168, base_time);
-//	*/
+    //	*/
     tmp_32u = kit_time_get_tick();
     integral_time = kit_time_get_interval(sox_item.last_tick, tmp_32u);
     sox_item.last_tick = tmp_32u;
 
     total_volt = bms_get_high_volt(kHvType_Bat);
 
-    if(sox_item.soc_req_st == kSocStatus_Normal)
+    if (sox_item.soc_req_st == kSocStatus_Normal)
     {
         sox_item.is_bsu_adjust = false;
     }
 
 #if 1
-    if((sox_item.soc >= 1000)
+    if ((sox_item.soc >= 1000) || (bms_get_statistic_data(kStatisticData_MinVolt) >= get_eeprom_data(kEep_ForbidDisRelVolt, kEepromDataType_Full)))
-            || (bms_get_statistic_data(kStatisticData_MinVolt) >= get_eeprom_data(kEep_ForbidDisRelVolt, kEepromDataType_Full)))
     {
         sox_item.soc_kEep_1 = true;
         sox_item.dis_adjust_flag = false;
@@ -587,31 +573,31 @@ void bms_integral_soc(int32_t current, uint16_t base_time)
         KIT_CLR_BIT_32(sox_item.soc_st, 1);
     }
 
-    //充电积分
+    // 充电积分
-    if(current > 0)
+    if (current > 0)
     {
-        //单位Ams
+        // 单位Ams
-        //公式 (current / 100 * integral_time) * (sox_item.chg_adjust_rate / 100)
+        // 公式 (current / 100 * integral_time) * (sox_item.chg_adjust_rate / 100)
-        //tmp_32u = current * integral_time * sox_item.chg_adjust_rate / 10000;
+        // tmp_32u = current * integral_time * sox_item.chg_adjust_rate / 10000;
         tmp_32u = current * integral_time * sox_item.chg_adjust_rate / 100;
         if (tmp_32u > SOX_MAX_SIGNAL_INTEGRAL)
             tmp_32u = SOX_MAX_SIGNAL_INTEGRAL;
 
         sox_item.tmp_chg_cap += tmp_32u;
-        //单位 kWms
+        // 单位 kWms
-        //tmp_32少除了100，这里应该多除个100--2.20
+        // tmp_32少除了100，这里应该多除个100--2.20
-        sox_item.tmp_chg_energy +=  tmp_32u * total_volt / 1000000;
+        sox_item.tmp_chg_energy += tmp_32u * total_volt / 1000000;
 
-        if(sox_item.calculate_cap < sox_item.rated_cap)
+        if (sox_item.calculate_cap < sox_item.rated_cap)
         {
             tmp_32u += sox_item.calculate_cap;
-            if(tmp_32u > sox_item.soc_99_cap)
+            if (tmp_32u > sox_item.soc_99_cap)
             {
                 if (sox_item.soc_kEep_99 == true)
                 {
                     sox_item.calculate_cap = sox_item.soc_99_cap;
                 }
-                else if(tmp_32u > sox_item.rated_cap)
+                else if (tmp_32u > sox_item.rated_cap)
                 {
                     sox_item.calculate_cap = sox_item.rated_cap;
                 }
@@ -627,9 +613,7 @@ void bms_integral_soc(int32_t current, uint16_t base_time)
         }
     }
 
-
+    if ((sox_item.soc <= 9500) || (bms_get_statistic_data(kStatisticData_MaxVolt) <= get_eeprom_data(kEep_ForbidChgRelVolt, kEepromDataType_Full)))
-    if((sox_item.soc <= 9500)
-            || (bms_get_statistic_data(kStatisticData_MaxVolt) <= get_eeprom_data(kEep_ForbidChgRelVolt, kEepromDataType_Full)))
     {
         sox_item.soc_kEep_99 = true;
         sox_item.chg_adjust_flag = false;
@@ -637,18 +621,18 @@ void bms_integral_soc(int32_t current, uint16_t base_time)
         KIT_CLR_BIT_32(sox_item.soc_st, 0);
     }
 
-    //放电积分
+    // 放电积分
-    if(current < 0)
+    if (current < 0)
     {
         tmp_32u = KIT_ABS(current) * integral_time * sox_item.dis_adjust_rate / 100;
         if (tmp_32u > SOX_MAX_SIGNAL_INTEGRAL)
             tmp_32u = SOX_MAX_SIGNAL_INTEGRAL;
 
         sox_item.tmp_dis_cap += tmp_32u;
-        //单位 kWms
+        // 单位 kWms
-        sox_item.tmp_dis_energy +=  tmp_32u * total_volt / 1000000;
+        sox_item.tmp_dis_energy += tmp_32u * total_volt / 10000;
 
-        if(sox_item.calculate_cap > 0)
+        if (sox_item.calculate_cap > 0)
         {
             if (sox_item.calculate_cap < (sox_item.soc_1_cap + tmp_32u))
             {
@@ -656,7 +640,7 @@ void bms_integral_soc(int32_t current, uint16_t base_time)
                 {
                     sox_item.calculate_cap = sox_item.soc_1_cap;
                 }
-                else if(tmp_32u >= sox_item.calculate_cap)
+                else if (tmp_32u >= sox_item.calculate_cap)
                 {
                     sox_item.calculate_cap = 0;
                 }
@@ -673,7 +657,7 @@ void bms_integral_soc(int32_t current, uint16_t base_time)
     }
     if (sox_item.req_soc == 0xFFFF)
     {
-        soc = (((uint64_t)sox_item.calculate_cap * SOX_MAX_SOC_VALUE * 10 / sox_item.rated_cap + 5)/10); //四舍五入
+        soc = (((uint64_t)sox_item.calculate_cap * SOX_MAX_SOC_VALUE * 10 / sox_item.rated_cap + 5) / 10); // 四舍五入
     }
     else
     {
@@ -682,21 +666,19 @@ void bms_integral_soc(int32_t current, uint16_t base_time)
             soc = sox_item.req_soc;
             sox_item.calculate_cap = ((uint64_t)soc * sox_item.rated_cap) / SOX_MAX_SOC_VALUE;
 
-            if(sox_item.req_soc == SOX_MAX_SOC_VALUE)
+            if (sox_item.req_soc == SOX_MAX_SOC_VALUE)
                 sox_item.soc_kEep_99 = false;
-            else if(sox_item.req_soc == SOX_MIN_SOC_VALUE)
+            else if (sox_item.req_soc == SOX_MIN_SOC_VALUE)
                 sox_item.soc_kEep_1 = false;
         }
         sox_item.req_soc = 0xFFFF;
     }
-    if(soc > SOX_MAX_SOC_VALUE)
+    if (soc > SOX_MAX_SOC_VALUE)
     {
         soc = SOX_MAX_SOC_VALUE;
     }
     sox_item.soc = soc;
-    //计算显示soc
+    // 计算显示soc
     sox_item.show_soc = (uint32_t)sox_item.soc_run_diff * soc / 100 + sox_item.soc_run_min * 100;
 #endif
 }
-
-

app/stm32fxxx_app/app/task_register.c

@@ -1,19 +1,17 @@
 /******************************************************************************
  * @file     	cmsis_armcc.h
- * @brief     任务初始化注册框架
+ * @brief     ?????????????
  * @version   V5.0.4
  * @copyright
  ******************************************************************************/
 #include "task_register.h"
 
-
+task_array_t tcp_server_task[W5500_MODBUS_NUM]; // __attribute__((section (".CCM_RAM")));
-task_array_t tcp_server_task[W5500_MODBUS_NUM];// __attribute__((section (".CCM_RAM")));
 OS_STK tcp_server_stk[W5500_MODBUS_NUM][300];
 extern const UintArgFunCall tcp_server_poll[W5500_MODBUS_NUM];
 const uint8_t tcp_server_task_name[W5500_MODBUS_NUM][14] =
-{
+    {
-    "tcp_server1", "tcp_server2"
+        "tcp_server1", "tcp_server2"};
-};
 
 void poll_1ms_task_init(void);
 void poll_10ms_task_init(void);
@@ -50,42 +48,41 @@ void bms_poll_bmu_handler(uint32_t base_time)
 
 void task_mqtt_handler(uint32_t base_time)
 {
-	mqtt_publish_bms_data(base_time);
+    mqtt_publish_bms_data(base_time);
 }
 
-
 void task_100ms_handler(uint32_t base_time)
 {
     static uint32_t cout100ms = 0;
     cout100ms++;
     bms_poll_iso(base_time);
-    //bms_poll_adc(); THis was originally commented.
+    // bms_poll_adc(); THis was originally commented.
     bms_poll_adc(base_time);
     bms_poll_statistic(base_time);
     bms_poll_run_status(base_time);
     bms_poll_sop(base_time);
     bms_poll_soh(base_time);
+		task_mqtt_handler(base_time);
     is_first_run = true;
 }
 
+GLOBAL_TASK_VARS_CCM(poll_1ms_task, 4, 1, 5000, 400, poll_1ms_task_init, task_1ms_handler, NULL);
+GLOBAL_TASK_VARS_CCM(poll_100ms_task, 1, 100, 2000, 400, NULL, task_100ms_handler, NULL);
 
-GLOBAL_TASK_VARS_CCM(poll_1ms_task,		4,  1,   	5000,    400, poll_1ms_task_init,		task_1ms_handler,			NULL);
+GLOBAL_TASK_VARS_CCM(poll_10ms_task, 3, 100, 2000, 400, poll_10ms_task_init, task_10ms_handler, NULL);
-GLOBAL_TASK_VARS_CCM(poll_100ms_task,	1,  100,   	2000,    400, NULL,               		task_100ms_handler,			NULL);
+GLOBAL_TASK_VARS_CCM(ord_ctrl_task, 2, 100, 2000, 400, NULL, task_dido_ctrl_handle, NULL);
 
-GLOBAL_TASK_VARS_CCM(poll_10ms_task,	3,  100,   	2000,    400, poll_10ms_task_init,   	task_10ms_handler,			NULL);
+GLOBAL_TASK_VARS(modbus_rtu_task1, 6, 50, 5000, 400, NULL, modbus_rtu_inter_handler, NULL);
-GLOBAL_TASK_VARS_CCM(ord_ctrl_task,	    2,  100,   	2000,    400, NULL,					 	task_dido_ctrl_handle,		NULL);
+GLOBAL_TASK_VARS_CCM(modbus_rtu_task2, 7, 50, 5000, 400, NULL, modbus_rtu_extern_handler, NULL);
+GLOBAL_TASK_VARS_CCM(modbus_rtu_task3, 8, 50, 5000, 400, NULL, modbus_rtu_externII_handler, NULL);
 
-GLOBAL_TASK_VARS(modbus_rtu_task1,		6,  50,   	5000,    400, NULL,           			modbus_rtu_inter_handler,	NULL);
+GLOBAL_TASK_VARS_CCM(ord_comm_can_task, 5, 100, 5000, 400, NULL, task_can1_handler, NULL);
-GLOBAL_TASK_VARS_CCM(modbus_rtu_task2,	7,  50,   	5000,    400, NULL,           			modbus_rtu_extern_handler,	NULL);
+GLOBAL_TASK_VARS_CCM(bms_poll_bmu_task, 9, 100, 5000, 400, bms_bmu_init, bms_poll_bmu_handler, NULL);
-GLOBAL_TASK_VARS_CCM(modbus_rtu_task3,	8,  50,   	5000,    400, NULL,           			modbus_rtu_externII_handler,	NULL);
 
-GLOBAL_TASK_VARS_CCM(ord_comm_can_task, 5,  100,   	5000,    400, NULL,       	 			task_can1_handler,     			NULL);
+GLOBAL_TASK_VARS_CCM(bms_poll_mqtt_task, 9, 1000, 5000, 400, poll_mqtt_init, task_mqtt_handler, NULL);
-GLOBAL_TASK_VARS_CCM(bms_poll_bmu_task, 9,  100,   	5000,    400, bms_bmu_init,  			bms_poll_bmu_handler,   		NULL);
 
-GLOBAL_TASK_VARS_CCM(bms_poll_mqtt_task, 9,  1000,   	5000,    400, poll_mqtt_init,  			task_mqtt_handler,   		NULL);
+#define BMU_FINISH_BIT (0u)
-
+#define SIGNAL_FINISH_BIT (1u)
-#define BMU_FINISH_BIT      (0u)
-#define SIGNAL_FINISH_BIT   (1u)
 
 uint8_t is_data_ok = 0;
 extern const DoLogic doLogicArray[kDoType_End];
@@ -102,42 +99,42 @@ void poll_1ms_task_init(void)
 
     bms_init_gpio();
     bms_init_eeprom();
-    //bms_init_adc(); THis was originally commented.
+    // bms_init_adc(); THis was originally commented.
-    //bms_init_adc();
+    // bms_init_adc();
     bms_init_tag();
     bms_init_run();
     bms_init_comm();
 
-    //2-17 new add
+    // 2-17 new add
-    //task_dido_ctrl_handle(1000);
+    // task_dido_ctrl_handle(1000);
 
     bms_init_di_do(bmsCircuitCtrl, kDoCtrlStrategy_End, doLogicArray);
     bsp_create_task(&poll_10ms_task, (uint8_t *)"10ms");
 
-    //KIT_PRINTF("cur_hv init start \r\n");
+    // KIT_PRINTF("cur_hv init start \r\n");
 
-    //debug here  is no more run
+    // debug here  is no more run
     bms_init_cur_hv();
 
-    //KIT_PRINTF("cur_hv init ok \r\n");
+    // KIT_PRINTF("cur_hv init ok \r\n");
 
-    while(KIT_GET_BIT_32(is_data_ok, BMU_FINISH_BIT) == 0)
+    while (KIT_GET_BIT_32(is_data_ok, BMU_FINISH_BIT) == 0)
     {
         bsp_task_delay_ms(10);
     }
-    //耗时初始化 ≈300ms 确保信号正常
+    // ???????? ??300ms ??????????
-    //KIT_PRINTF("signal init start \r\n");
+    // KIT_PRINTF("signal init start \r\n");
 
     bms_poll_statistic(0);
 
     bms_init_signal();
-    //刷新信号策略 确保例如常闭等需要立即闭合do输出
+    // ????????? ??????¼V?????????????do???
     task_dido_ctrl_handle(1000);
-    //KIT_PRINTF("signal init ok \r\n");
+    // KIT_PRINTF("signal init ok \r\n");
     KIT_SET_BIT_MASK_32(is_data_ok, SIGNAL_FINISH_BIT);
     bsp_create_task(&ord_ctrl_task, (uint8_t *)"ctrl");
-
+		
-
+		poll_mqtt_init();
 }
 
 void poll_10ms_task_init(void)
@@ -145,19 +142,19 @@ void poll_10ms_task_init(void)
 
     uint8_t i = 0;
     bms_init_fdb();
-    //耗时初始化 等待从机上电并初始化完成 ≈500ms，且请求两轮数据 ≈1300ms(最大)
+    // ???????? ????????ôÒ???????? ??500ms???????????????? ??1300ms(???)
     KIT_PRINTF("bmu init start \r\n");
-    //bms_init_chain_bmu();
+    // bms_init_chain_bmu();
     KIT_PRINTF("bmu init ok \r\n");
     bms_poll_statistic(0);
-    //SOC初始化需要统计数据
+    // SOC???????????????
     bms_init_soc();
-    //掉电中断在SOC初始化完成后打开防止存入未初始化值
+    // ?????§Ø???SOC????????????????¦Ä??????
     drv_misc_cfg_pwr_off_interrupt(APP_CFG_INT_PRIO_PWR_OFF, kPwrOffVolt_2_9, bms_pwr_off_save);
 
     KIT_SET_BIT_MASK_32(is_data_ok, BMU_FINISH_BIT);
-    //next line is originally commented.
+    // next line is originally commented.
-    while(KIT_GET_BIT_32(is_data_ok, SIGNAL_FINISH_BIT) == 0)
+    while (KIT_GET_BIT_32(is_data_ok, SIGNAL_FINISH_BIT) == 0)
     {
         bsp_task_delay_ms(10);
     }
@@ -167,7 +164,7 @@ void poll_10ms_task_init(void)
 
     bms_init_sop();
     bms_init_iso();
-    //bsp_create_task(&poll_100ms_task, (uint8_t *)"100ms");,THis was originally commented.
+    // bsp_create_task(&poll_100ms_task, (uint8_t *)"100ms");,THis was originally commented.
     bsp_create_task(&poll_100ms_task, (uint8_t *)"100ms");
     bsp_create_task(&bms_poll_bmu_task, (uint8_t *)"100ms");
     bsp_create_task(&ord_comm_can_task, (uint8_t *)"100ms");
@@ -175,9 +172,8 @@ void poll_10ms_task_init(void)
     bsp_create_task(&modbus_rtu_task2, (uint8_t *)"exter1_modbus");
     bsp_create_task(&modbus_rtu_task3, (uint8_t *)"exter2_modbus");
 
-
     bms_w5500_net_protocol();
-    for(i = 0; i < W5500_MODBUS_NUM; i++)
+    for (i = 0; i < W5500_MODBUS_NUM; i++)
     {
         tcp_server_task[i].task_id = i + 10;
         tcp_server_task[i].stk_size = 300;
@@ -185,33 +181,32 @@ void poll_10ms_task_init(void)
         tcp_server_task[i].interval = 100;
         tcp_server_task[i].timeout = 1000;
         tcp_server_task[i].handler_func = tcp_server_poll[i];
-        bsp_create_task(&tcp_server_task[i], (uint8_t *)&tcp_server_task_name[i][0]);
+        bsp_create_task(&tcp_server_task[i], (uint8_t *)&tcp_server_task_name[i][0]);    
     }
-
 }
 
 void poll_mqtt_init(void)
 {
-	static uint16_t qfc41d_init_count = 0;
+    static uint16_t qfc41d_init_count = 0;
-	static uint16_t mqtt_init_count = 0;
+    static uint16_t mqtt_init_count = 0;
-	while(drv_qfc41d_init() && qfc41d_init_count < 10)
+    while (drv_qfc41d_init() && qfc41d_init_count < 10)
-	{
+    {
-		drv_wdog_feed();
+        drv_wdog_feed();
-		kit_time_dly_ms(100);
+        kit_time_dly_ms(100);
-		qfc41d_init_count++;
+        qfc41d_init_count++;
-	}
+    }
 
-	// MQTT 初始化
+    // MQTT ?????
-	while(drv_mqtt_init()&& mqtt_init_count < 10)
+    while (drv_mqtt_init() && mqtt_init_count < 10)
-	{
+    {
-		drv_wdog_feed();
+        drv_wdog_feed();
-		kit_time_dly_ms(100);
+        kit_time_dly_ms(100);
-		mqtt_init_count++;
+        mqtt_init_count++;
-	}
+    }
 }
 /*****************************************************************************
- * @brief       ucos系统中断回调
+ * @brief       ucos???§Ø???
- * @param[in]   void: 无
+ * @param[in]   void: ??
  * @return      void
  *****************************************************************************/
 void ucos_irq_handler(void)

app/stm32fxxx_app/app/version_manager.h

@@ -2,7 +2,8 @@
 #define BMS_TAG_H_
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 #include <stdint.h>
@@ -10,77 +11,79 @@ extern "C" {
 
 #include "bsp_number.h"
 
-typedef enum
+    typedef enum
-{
+    {
-    kAppArea_I, //一体机
+        kAppArea_I, // 一体机
-    kAppArea_P, //保护板
+        kAppArea_P, // 保护板
-    kAppArea_U, //二级架构
+        kAppArea_U, // 二级架构
-    kAppArea_T, //三级架构
+        kAppArea_T, // 三级架构
-    kAppArea_End,
+        kAppArea_End,
-} AppArea;
+    } AppArea;
 
-#define TAG_PROJECT_ID_ADDR           APP_CFG_E_TAG_ADDR
+#define TAG_PROJECT_ID_ADDR APP_CFG_E_TAG_ADDR
-#define TAG_UUID_ADDR                 (TAG_PROJECT_ID_ADDR + 4)
+#define TAG_UUID_ADDR (TAG_PROJECT_ID_ADDR + 4)
-#define TAG_SOFTWARE_VER_ADDR         (TAG_UUID_ADDR + 6)
+#define TAG_SOFTWARE_VER_ADDR (TAG_UUID_ADDR + 6)
-#define TAG_BOOT_VER_ADDR             (TAG_SOFTWARE_VER_ADDR + 2)
+#define TAG_BOOT_VER_ADDR (TAG_SOFTWARE_VER_ADDR + 2)
-#define TAG_HARDWARE_VER_ADDR         (TAG_BOOT_VER_ADDR + 2)
+#define TAG_HARDWARE_VER_ADDR (TAG_BOOT_VER_ADDR + 2)
-#define TAG_DEVICE_MODE_ADDR          (TAG_HARDWARE_VER_ADDR + 2)
+#define TAG_DEVICE_MODE_ADDR (TAG_HARDWARE_VER_ADDR + 2)
-#define TAG_COMPANY_NAME_ADDR         (TAG_DEVICE_MODE_ADDR + 10)
+#define TAG_COMPANY_NAME_ADDR (TAG_DEVICE_MODE_ADDR + 10)
-#define TAG_PROJECT_NAME_ADDR         (TAG_COMPANY_NAME_ADDR + 100)
+#define TAG_PROJECT_NAME_ADDR (TAG_COMPANY_NAME_ADDR + 100)
-#define TAG_ORDER_ID_ADDR             (TAG_PROJECT_NAME_ADDR + 100)
+#define TAG_ORDER_ID_ADDR (TAG_PROJECT_NAME_ADDR + 100)
-#define TAG_TEST_RESULT_ADDR          (TAG_ORDER_ID_ADDR + 20)
+#define TAG_TEST_RESULT_ADDR (TAG_ORDER_ID_ADDR + 20)
-#define TAG_DEVICE_TYPE_ADDR          (TAG_TEST_RESULT_ADDR + 20)
+#define TAG_DEVICE_TYPE_ADDR (TAG_TEST_RESULT_ADDR + 20)
-#define TAG_CRC_ADDR                  (TAG_DEVICE_TYPE_ADDR + 2)
+#define TAG_CRC_ADDR (TAG_DEVICE_TYPE_ADDR + 2)
 
-
+// 5+5+6 16位
-//5+5+6 16位
 /*******************************硬件设备版本号***********************************/
-#define DEVICE_HW_MAJOR_VER     (1u) //5
+#define DEVICE_HW_MAJOR_VER (1u) // 5
-#define DEVICE_HW_MINOR_VER     (0u) //5
+#define DEVICE_HW_MINOR_VER (0u) // 5
-#define DEVICE_HW_BUILD_VER     (0u) //6
+#define DEVICE_HW_BUILD_VER (0u) // 6
-#define DEVICE_HW_VERSION       (((DEVICE_HW_MAJOR_VER&0x1f)<<11)+((DEVICE_HW_MINOR_VER&0x1f)<<6)+(DEVICE_HW_BUILD_VER&0x3f))
+// #define DEVICE_HW_VERSION       (((DEVICE_HW_MAJOR_VER&0x1f)<<11)+((DEVICE_HW_MINOR_VER&0x1f)<<6)+(DEVICE_HW_BUILD_VER&0x3f))
 
 /*********************************软件版本号*************************************/
-#define DEVICE_V_MAJOR_VER     (2u) //4
+#define DEVICE_V_MAJOR_VER (2u)        // 4
-#define DEVICE_V_MINOR_VER     (1u) //4
+#define DEVICE_V_MINOR_VER (1u)        // 4
-#define DEVICE_V_APPL_VER      (kAppArea_U) //4
+#define DEVICE_V_APPL_VER (kAppArea_U) // 4
-#define DEVICE_R_MAJOR_VER     (1u) //4  
+#define DEVICE_R_MAJOR_VER (1u)        // 4
-#define DEVICE_R_MINOR_VER     (0u) //6
+#define DEVICE_R_MINOR_VER (0u)        // 6
-#define DEVICE_C_MAJOR_VER     (1u) //8
+#define DEVICE_C_MAJOR_VER (1u)        // 8
-#define DEVICE_C_MINOR_VER     (3u) //4
+#define DEVICE_C_MINOR_VER (3u)        // 4
 
-//主干默认版本B0 上述记录即可
+// 主干默认版本B0 上述记录即可
-#define DEVICE_SW_BUILD_VER    (1u)
+#define DEVICE_SW_BUILD_VER (1u)
 
-#define DEVICE_SW_VERSION      ((DEVICE_V_MAJOR_VER << 8) | (DEVICE_V_MINOR_VER))
+// #define DEVICE_SW_VERSION      ((DEVICE_V_MAJOR_VER << 8) | (DEVICE_V_MINOR_VER))
-#define DEVICE_R_VERSION       ((DEVICE_R_MAJOR_VER << 8) | (DEVICE_R_MINOR_VER))
+#define DEVICE_SW_VERSION 1
-#define DEVICE_C_VERSION       ((DEVICE_C_MAJOR_VER << 8) | (DEVICE_C_MINOR_VER))
+#define DEVICE_SW_BUILD_VER (0u)
-typedef enum
+#define DEVICE_HW_VERSION 1
-{
-    kSoftType_Boot,
-    kSoftType_Test,
-    kSoftType_App,
-    kSoftType_End,
-} SoftType;
 
-typedef enum
+#define DEVICE_R_VERSION ((DEVICE_R_MAJOR_VER << 8) | (DEVICE_R_MINOR_VER))
-{
+#define DEVICE_C_VERSION ((DEVICE_C_MAJOR_VER << 8) | (DEVICE_C_MINOR_VER))
-    kTagData_DevAddr,
+    typedef enum
-    kTagData_DevType,
+    {
-    kTagData_SoftVer,
+        kSoftType_Boot,
-    kTagData_HardVer,
+        kSoftType_Test,
-    kTagData_BootVer,
+        kSoftType_App,
-    kTagData_ProductNumber,
+        kSoftType_End,
-    kTagData_ProductTime,
+    } SoftType;
-    kTagData_GateIdx,
-    kTagData_End,
-} TagData;
 
+    typedef enum
+    {
+        kTagData_DevAddr,
+        kTagData_DevType,
+        kTagData_SoftVer,
+        kTagData_HardVer,
+        kTagData_BootVer,
+        kTagData_ProductNumber,
+        kTagData_ProductTime,
+        kTagData_GateIdx,
+        kTagData_End,
+    } TagData;
 
-void     bms_init_tag(void);
+    void bms_init_tag(void);
-uint64_t bms_get_uuid(void);
+    uint64_t bms_get_uuid(void);
-uint32_t bms_get_tag_data(TagData idx);
+    uint32_t bms_get_tag_data(TagData idx);
-void     bms_set_tag_data(TagData idx, uint32_t data);
+    void bms_set_tag_data(TagData idx, uint32_t data);
 
 #ifdef __cplusplus
 }

app/stm32fxxx_app/prj/BCU_APP.uvprojx

@@ -10,14 +10,14 @@
       <TargetName>stm32f407</TargetName>
       <ToolsetNumber>0x4</ToolsetNumber>
       <ToolsetName>ARM-ADS</ToolsetName>
-      <pArmCC>5050106::V5.05 update 1 (build 106)::ARMCC</pArmCC>
+      <pArmCC>5060750::V5.06 update 6 (build 750)::ARMCC</pArmCC>
-      <pCCUsed>5050106::V5.05 update 1 (build 106)::ARMCC</pCCUsed>
+      <pCCUsed>5060750::V5.06 update 6 (build 750)::ARMCC</pCCUsed>
       <uAC6>0</uAC6>
       <TargetOption>
         <TargetCommonOption>
           <Device>STM32F407ZGTx</Device>
           <Vendor>STMicroelectronics</Vendor>
-          <PackID>Keil.STM32F4xx_DFP.2.16.0</PackID>
+          <PackID>Keil.STM32F4xx_DFP.2.14.0</PackID>
           <PackURL>http://www.keil.com/pack/</PackURL>
           <Cpu>IRAM(0x20000000,0x00020000) IRAM2(0x10000000,0x00010000) IROM(0x08000000,0x00100000) CPUTYPE("Cortex-M4") FPU2 CLOCK(12000000) ELITTLE</Cpu>
           <FlashUtilSpec></FlashUtilSpec>
@@ -186,8 +186,6 @@
             <uocXRam>0</uocXRam>
             <RvdsVP>2</RvdsVP>
             <RvdsMve>0</RvdsMve>
-            <RvdsCdeCp>0</RvdsCdeCp>
-            <nBranchProt>0</nBranchProt>
             <hadIRAM2>1</hadIRAM2>
             <hadIROM2>0</hadIROM2>
             <StupSel>8</StupSel>
@@ -354,7 +352,7 @@
             <NoWarn>0</NoWarn>
             <uSurpInc>0</uSurpInc>
             <useXO>0</useXO>
-            <ClangAsOpt>4</ClangAsOpt>
+            <uClangAs>0</uClangAs>
             <VariousControls>
               <MiscControls></MiscControls>
               <Define></Define>
@@ -473,7 +471,7 @@
                 <NoWarn>2</NoWarn>
                 <uSurpInc>2</uSurpInc>
                 <useXO>2</useXO>
-                <ClangAsOpt>0</ClangAsOpt>
+                <uClangAs>2</uClangAs>
                 <VariousControls>
                   <MiscControls></MiscControls>
                   <Define></Define>
@@ -684,11 +682,6 @@
               <FileType>1</FileType>
               <FilePath>..\app\dido_manager.c</FilePath>
             </File>
-            <File>
-              <FileName>eeprom_manager.c</FileName>
-              <FileType>1</FileType>
-              <FilePath>..\app\eeprom_manager.c</FilePath>
-            </File>
             <File>
               <FileName>fault_manager.c</FileName>
               <FileType>1</FileType>
@@ -704,16 +697,16 @@
               <FileType>1</FileType>
               <FilePath>..\app\fault_register.c</FilePath>
             </File>
-            <File>
-              <FileName>gpio_manager.c</FileName>
-              <FileType>1</FileType>
-              <FilePath>..\app\gpio_manager.c</FilePath>
-            </File>
             <File>
               <FileName>hv_adc_manager.c</FileName>
               <FileType>1</FileType>
               <FilePath>..\app\hv_adc_manager.c</FilePath>
             </File>
+            <File>
+              <FileName>gpio_manager.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\app\gpio_manager.c</FilePath>
+            </File>
             <File>
               <FileName>iso_check.c</FileName>
               <FileType>1</FileType>
@@ -744,6 +737,11 @@
               <FileType>1</FileType>
               <FilePath>..\app\logic_same_circuit_ctrl.c</FilePath>
             </File>
+            <File>
+              <FileName>eeprom_manager.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\app\eeprom_manager.c</FilePath>
+            </File>
             <File>
               <FileName>run_status.c</FileName>
               <FileType>1</FileType>
@@ -882,7 +880,7 @@
                 <NoWarn>2</NoWarn>
                 <uSurpInc>2</uSurpInc>
                 <useXO>2</useXO>
-                <ClangAsOpt>0</ClangAsOpt>
+                <uClangAs>2</uClangAs>
                 <VariousControls>
                   <MiscControls></MiscControls>
                   <Define></Define>
@@ -1068,7 +1066,7 @@
         <TargetCommonOption>
           <Device>STM32F407VGTx</Device>
           <Vendor>STMicroelectronics</Vendor>
-          <PackID>Keil.STM32F4xx_DFP.2.16.0</PackID>
+          <PackID>Keil.STM32F4xx_DFP.2.14.0</PackID>
           <PackURL>http://www.keil.com/pack/</PackURL>
           <Cpu>IRAM(0x20000000,0x00020000) IRAM2(0x10000000,0x00010000) IROM(0x08000000,0x00100000) CPUTYPE("Cortex-M4") FPU2 CLOCK(12000000) ELITTLE</Cpu>
           <FlashUtilSpec></FlashUtilSpec>
@@ -1237,8 +1235,6 @@
             <uocXRam>0</uocXRam>
             <RvdsVP>2</RvdsVP>
             <RvdsMve>0</RvdsMve>
-            <RvdsCdeCp>0</RvdsCdeCp>
-            <nBranchProt>0</nBranchProt>
             <hadIRAM2>1</hadIRAM2>
             <hadIROM2>0</hadIROM2>
             <StupSel>8</StupSel>
@@ -1405,7 +1401,7 @@
             <NoWarn>0</NoWarn>
             <uSurpInc>0</uSurpInc>
             <useXO>0</useXO>
-            <ClangAsOpt>4</ClangAsOpt>
+            <uClangAs>0</uClangAs>
             <VariousControls>
               <MiscControls></MiscControls>
               <Define></Define>
@@ -1666,11 +1662,6 @@
               <FileType>1</FileType>
               <FilePath>..\app\dido_manager.c</FilePath>
             </File>
-            <File>
-              <FileName>eeprom_manager.c</FileName>
-              <FileType>1</FileType>
-              <FilePath>..\app\eeprom_manager.c</FilePath>
-            </File>
             <File>
               <FileName>fault_manager.c</FileName>
               <FileType>1</FileType>
@@ -1686,16 +1677,16 @@
               <FileType>1</FileType>
               <FilePath>..\app\fault_register.c</FilePath>
             </File>
-            <File>
-              <FileName>gpio_manager.c</FileName>
-              <FileType>1</FileType>
-              <FilePath>..\app\gpio_manager.c</FilePath>
-            </File>
             <File>
               <FileName>hv_adc_manager.c</FileName>
               <FileType>1</FileType>
               <FilePath>..\app\hv_adc_manager.c</FilePath>
             </File>
+            <File>
+              <FileName>gpio_manager.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\app\gpio_manager.c</FilePath>
+            </File>
             <File>
               <FileName>iso_check.c</FileName>
               <FileType>1</FileType>
@@ -1726,6 +1717,11 @@
               <FileType>1</FileType>
               <FilePath>..\app\logic_same_circuit_ctrl.c</FilePath>
             </File>
+            <File>
+              <FileName>eeprom_manager.c</FileName>
+              <FileType>1</FileType>
+              <FilePath>..\app\eeprom_manager.c</FilePath>
+            </File>
             <File>
               <FileName>run_status.c</FileName>
               <FileType>1</FileType>
@@ -1985,13 +1981,4 @@
     </files>
   </RTE>
 
-  <LayerInfo>
-    <Layers>
-      <Layer>
-        <LayName>BCU_APP</LayName>
-        <LayPrjMark>1</LayPrjMark>
-      </Layer>
-    </Layers>
-  </LayerInfo>
-
 </Project>

app/stm32fxxx_app/protocol/protocol_can_bcu.c

@@ -270,6 +270,429 @@ void protocol_can_bcu_init(can_dev_e can)
     protocol_can_set_call(can, bcu_can_receive, bcu_can_send,NULL);
 }
 
-
+/*********************pylon can*********************/
+/*********************pylon can*********************/
+/*********************pylon can*********************/
+void bcu_send_0x42100000(can_dev_e can)
+{
+    uint8_t len = 0, buf[8];
+	uint16_t tmp_16u;
+	uint8_t tmp_8u;
+	
+	//电池组总电压
+	tmp_16u = bms_get_statistic_data(kStatisticData_TotalVolt);
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//电池组充/放电总电流
+	tmp_16u = bms_get_current();
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//主控温度--我们点表中没有，用单体平均温度替代
+	tmp_16u = bms_get_statistic_data(kStatisticData_AvgTemp);
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//电池模块SOC
+	tmp_8u = (uint8_t )(bms_get_soc()/100);
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//电池模块SOH
+	tmp_8u = (uint8_t)(bms_get_soh()/100);
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+    bsp_can_ext_data_sync_send(can, 0x00004210, buf, len);
+}
+
+void bcu_send_0x42200000(can_dev_e can)
+{
+    uint8_t len = 0, buf[8];
+	uint16_t tmp_16u;
+
+	//充电截止电压
+	tmp_16u = get_eeprom_data(kEep_ChgHTVoltHTAlarm1, kEepromDataType_Full);
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//放点截止电压
+	tmp_16u = get_eeprom_data(kEep_DisLTVoltHTAlarm1, kEepromDataType_Full);
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最大充电电流
+	tmp_16u = bms_get_sop_data(kSopData_ChgCur);
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最大放电电流
+	tmp_16u = bms_get_sop_data(kSopData_DisCur);
+	WRITE_LT_INT16U(buf, len, tmp_16u);	
+    bsp_can_ext_data_sync_send(can, 0x00004220, buf, len);
+}
+
+void bcu_send_0x42300000(can_dev_e can)
+{
+    uint8_t len = 0, buf[8];
+	uint16_t tmp_16u;
+
+	//最高单体电池电压 
+	tmp_16u = bms_get_statistic_data(kStatisticData_MaxVolt);
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最低单体电池电压
+	tmp_16u = bms_get_statistic_data(kStatisticData_MinVolt);
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最高单体电池电压编号 
+	tmp_16u = bms_get_statistic_data(kStatisticData_MaxVoltIdx) + 1;
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最低单体电池电压编号 
+	tmp_16u = bms_get_statistic_data(kStatisticData_MinVoltIdx) + 1;
+	WRITE_LT_INT16U(buf, len, tmp_16u);	
+    bsp_can_ext_data_sync_send(can, 0x00004230, buf, len);
+}
+
+void bcu_send_0x42400000(can_dev_e can)
+{
+    uint8_t len = 0, buf[8];
+	uint16_t tmp_16u;
+
+	//最高单体电池温度 
+	tmp_16u = bms_get_statistic_data(kStatisticData_MaxTemp);
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最低单体电池温度 
+	tmp_16u = bms_get_statistic_data(kStatisticData_MinTemp);
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最高单体电池温度编号
+	tmp_16u = bms_get_statistic_data(kStatisticData_MaxTempIdx) + 1;
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最低单体电池温度编号
+	tmp_16u = bms_get_statistic_data(kStatisticData_MinTempIdx) + 1;
+	WRITE_LT_INT16U(buf, len, tmp_16u);	
+    bsp_can_ext_data_sync_send(can, 0x00004240, buf, len);
+}
+
+void bcu_send_0x42500000(can_dev_e can)
+{
+    uint8_t len = 0, buf[8];
+		uint16_t tmp_16u;
+		uint8_t tmp_8u, status;
+		uint16_t temp_second;
+		uint16_t temp_third;
+	
+	/*	基本状态
+		pylon  bluesun
+	0	休眠	初始化
+	1	充电	待机
+	2	放电	充电
+	3	搁置	放电
+	*/
+	switch(bms_get_run_status())
+	{
+		case kRunStatus_Standby:
+			status = 0;	
+			break;
+		case kRunStatus_Chg:
+			status = 1;
+			break;
+		case kRunStatus_Dis:
+			status = 2;
+			break;
+		case kRunStatus_PwrOff:
+			status = 3;
+		default:
+			break;
+	}
+
+	//基本状态
+	tmp_8u = status;
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//循环周期 
+	tmp_16u = bms_get_cycle();
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//故障--无
+	tmp_8u = 0;
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//告警--二三级放入告警中
+	//每个告警的位的位置需要测一下
+	
+	temp_second = set_bit_based_on_source_pylon(status, kFaultLevel_Second);
+	temp_third = set_bit_based_on_source_pylon(status, kFaultLevel_Third);
+	
+	tmp_16u = temp_second | temp_third;
+	WRITE_LT_INT16U(buf, len, tmp_16u);	
+	//保护--一级放入保护中
+	//每个告警的位的位置需要测一下
+	
+	tmp_16u = set_bit_based_on_source_pylon(status, kFaultLevel_First);
+	
+	WRITE_LT_INT16U(buf, len, tmp_16u);	
+    bsp_can_ext_data_sync_send(can, 0x00004250, buf, len);
+}
+
+void bcu_send_0x42600000(can_dev_e can)
+{
+    uint8_t len = 0, buf[8];
+	uint16_t tmp_16u;
+
+	//最高电池模块电压--无,用单体平均电压×16代替
+	tmp_16u = bms_get_statistic_data(kStatisticData_AvgVolt) * 16;
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最低电池模块电压--无，用单体平均电压×16代替
+	tmp_16u = bms_get_statistic_data(kStatisticData_AvgVolt) * 16;
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最高电池模块电压编号--无，用单体从机号代替 
+	tmp_16u = bms_get_statistic_data(kStatisticData_MaxVoltBmuIdx) + 1;
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最低电池模块电压编号--无，用单体从机号代替   
+	tmp_16u = bms_get_statistic_data(kStatisticData_MinVoltBmuIdx) + 1;
+	WRITE_LT_INT16U(buf, len, tmp_16u);	
+    bsp_can_ext_data_sync_send(can, 0x00004260, buf, len);
+}
+
+void bcu_send_0x42700000(can_dev_e can)
+{
+    uint8_t len = 0, buf[8];
+	uint16_t tmp_16u;
+
+	//最高电池模块温度--无,用最高单体温度代替
+	tmp_16u = bms_get_statistic_data(kStatisticData_MaxTemp);
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最低电池模块温度--无,用最低单体温度代替 
+	tmp_16u = bms_get_statistic_data(kStatisticData_MinTemp);
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最高电池模块温度编号--无，用单体从机号代替 
+	tmp_16u = bms_get_statistic_data(kStatisticData_MaxTempBmuIdx) + 1;
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//最低电池模块温度编号--无，用单体从机号代替 
+	tmp_16u = bms_get_statistic_data(kStatisticData_MinTempBmuIdx) + 1;
+	WRITE_LT_INT16U(buf, len, tmp_16u);	
+    bsp_can_ext_data_sync_send(can, 0x00004270, buf, len);
+}
+
+void bcu_send_0x42800000(can_dev_e can)
+{
+    uint8_t len = 0, buf[8];
+	uint16_t tmp_16u;
+	uint8_t tmp_8u;
+	uint16_t bms_stu = 0;
+
+    if(bms_get_run_status() == kRunStatus_Init)
+    {
+        bms_stu = 0;
+    }
+    else if(bms_get_run_status() == kRunStatus_Standby)
+    {
+        bms_stu |= 0x1;
+    }
+    else if(bms_get_run_status() == kRunStatus_Chg)
+    {
+        bms_stu |= 0x2;
+    }
+    else if(bms_get_run_status() == kRunStatus_Dis)
+    {
+        bms_stu |= 0x3;
+    }
+    if(bms_get_signal(kSignalIdx_ForbidChg) == kSignalStatus_High)
+    {
+        bms_stu |= 0x10;
+    }
+    if(bms_get_signal(kSignalIdx_ForbidDis) == kSignalStatus_High)
+    {
+        bms_stu |= 0x20;
+    }
+	
+	//禁止充电标志
+	
+	if ((bms_stu & 0x10) >> 4 == 1)
+	{
+		tmp_8u = 0xAA;
+	}
+	else
+	{
+		tmp_8u = 0;
+	}
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//禁止放电标志
+	if ((bms_stu & 0x10) >> 5 == 1)
+	{
+		tmp_8u = 0xAA;
+	}
+	else
+	{
+		tmp_8u = 0;
+	}
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//预留
+	tmp_16u = 0;
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//预留
+	tmp_16u = 0;
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	//预留
+	tmp_16u = 0;
+	WRITE_LT_INT16U(buf, len, tmp_16u);
+	
+    bsp_can_ext_data_sync_send(can, 0x00004280, buf, len);
+}
+
+void bcu_send_0x73100000(can_dev_e can)
+{
+    uint8_t len = 0, buf[8];
+	uint16_t tmp_16u;
+	uint8_t tmp_8u;
+	
+	//Hardware Version 
+	tmp_8u = 1;
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//预留
+	tmp_8u = 1;
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//硬件版本-V 
+	tmp_8u = 1;
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//硬件版本-R 
+	tmp_8u = 1;
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//软件版本-V（主版本Major） 
+	tmp_8u = 1;
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//软件版本-V（子版本Minor） 
+	tmp_8u = 1;
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//开发主版本 
+	tmp_8u = 1;
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	//开发子版本 
+	tmp_8u = 1;
+	WRITE_LT_INT8U(buf, len, tmp_8u);
+	
+    bsp_can_ext_data_sync_send(can, 0x00007310, buf, len);
+}
+
+void bcu_can_send_pylon(uint32_t base_time,can_dev_e can)
+{
+	static uint32_t dly = 0;
+	
+    dly += base_time;
+	if((dly % 100) == 0)
+	{
+		dly = 0;
+    bcu_send_0x42100000(can);
+		bcu_send_0x42200000(can);
+		bcu_send_0x42300000(can);
+		bcu_send_0x42400000(can);
+		bcu_send_0x42500000(can);
+		bcu_send_0x42600000(can);
+		bcu_send_0x42700000(can);
+		bcu_send_0x42800000(can);
+		bcu_send_0x73100000(can);
+	}
+}
+
+uint16_t set_bit_based_on_source_pylon(uint8_t status, FaultLevel alarmLevel) 
+{
+	uint16_t tmp_16u = 0;
+  if (KIT_GET_BIT_32(bms_get_fault_single_bit(0 , alarmLevel), 0)) //一级总压过压--电池组充电高压保护
+	{
+		if (status == 1)
+		{
+			KIT_SET_BIT_MASK_32(tmp_16u, 3);
+			//tmp_16u = set_bit_based_on_source_pylon(bms_get_fault_single_bit(0 , kFaultLevel_First), 0, tmp_16u, 3);
+		}
+	}
+	if (KIT_GET_BIT_32(bms_get_fault_single_bit(0 , alarmLevel), 1)) //一级总压欠压--电池组放电低压保护
+	{
+		if (status == 2)
+		{
+			KIT_SET_BIT_MASK_32(tmp_16u, 2);
+			//tmp_16u = set_bit_based_on_source_pylon(bms_get_fault_single_bit(0 , kFaultLevel_First), 1, tmp_16u, 2);
+		}
+	}
+	
+	if (KIT_GET_BIT_32(bms_get_fault_single_bit(0 , alarmLevel), 2)) //一级单体过压--电池单体高压保护
+	{
+		KIT_SET_BIT_MASK_32(tmp_16u, 1);
+			//tmp_16u = set_bit_based_on_source_pylon(bms_get_fault_single_bit(0 , kFaultLevel_First), 2, tmp_16u, 1);
+	}
+	if (KIT_GET_BIT_32(bms_get_fault_single_bit(0 , alarmLevel), 3)) //一级单体欠压--电池单体低压保护
+	{
+		KIT_SET_BIT_MASK_32(tmp_16u, 0);
+			//tmp_16u = set_bit_based_on_source_pylon(bms_get_fault_single_bit(0 , kFaultLevel_First), 3, tmp_16u, 0);
+	}
+	
+	if (KIT_GET_BIT_32(bms_get_fault_single_bit(0 , alarmLevel), 4)) //一级单体过温--充电高温保护 && 放电高温保护
+	{
+		if (status == 1)
+		{
+			KIT_SET_BIT_MASK_32(tmp_16u, 5);
+			//tmp_16u = set_bit_based_on_source_pylon(bms_get_fault_single_bit(0 , kFaultLevel_First), 4, tmp_16u, 5);
+		}
+		else if (status == 2)
+		{
+			KIT_SET_BIT_MASK_32(tmp_16u, 7);
+			//tmp_16u = set_bit_based_on_source_pylon(bms_get_fault_single_bit(0 , kFaultLevel_First), 4, tmp_16u, 7);
+		}
+	}
+	if (KIT_GET_BIT_32(bms_get_fault_single_bit(0 , alarmLevel), 5)) //一级单体低温--充电低温保护 && 放电低温保护
+	{
+		if (status == 1)
+		{
+			KIT_SET_BIT_MASK_32(tmp_16u, 4);
+			//tmp_16u = set_bit_based_on_source_pylon(bms_get_fault_single_bit(0 , kFaultLevel_First), 5, tmp_16u, 4);
+		}
+		else if (status == 2)
+		{
+			KIT_SET_BIT_MASK_32(tmp_16u, 6);
+			//tmp_16u = set_bit_based_on_source_pylon(bms_get_fault_single_bit(0 , kFaultLevel_First), 5, tmp_16u, 6);
+		}
+	}
+	
+	if (KIT_GET_BIT_32(bms_get_fault_single_bit(0 , alarmLevel), 8)) //一级电流过大--电池组充电过流保护 && 电池组放电过流保护
+	{
+		if (status == 1)
+		{
+			KIT_SET_BIT_MASK_32(tmp_16u, 8);
+			//tmp_16u = set_bit_based_on_source_pylon(bms_get_fault_single_bit(0 , kFaultLevel_First), 8, tmp_16u, 8);
+		}
+		else if (status == 2)
+		{
+			KIT_SET_BIT_MASK_32(tmp_16u, 9);
+			//tmp_16u = set_bit_based_on_source_pylon(bms_get_fault_single_bit(0 , kFaultLevel_First), 8, tmp_16u, 9);
+		}
+	}
+	
+	return tmp_16u;
+}
+
+//pylon接收函数，休眠和唤醒控制，充电放电命令
+void bcu_can_receive_pylon(CanMsg *msg, can_dev_e can)
+{
+		uint8_t code = 0,value = 0, statusChg = 0, statusDischg = 0;
+    if(msg->id.value == 0x620)
+    {	
+			code = msg->data.byte[0];
+			if(code == 0x55)
+			{
+				//控制设备进入休眠状态，断开总正总负继电器
+				bms_crtl_do_status(kDoType_Positive, kDoCtrlStatus_Off, 100);
+				bms_crtl_do_status(kDoType_Negative, kDoCtrlStatus_Off, 100);
+			}
+			else if (code == 0xAA)
+			{
+				//控制设备退出休眠状态，闭合总正总负继电器
+				bms_crtl_do_status(kDoType_Positive, kDoCtrlStatus_On, 100);
+				bms_crtl_do_status(kDoType_Negative, kDoCtrlStatus_On, 100);
+			}
+    }
+		
+		if(msg->id.value == 0x621)
+    {	
+			statusChg = msg->data.byte[0];
+			statusDischg = msg->data.byte[1];
+			if(statusChg == 0xAA)
+			{
+				//充电命令，闭合总正总负继电器
+				bms_crtl_do_status(kDoType_Positive, kDoCtrlStatus_On, 100);
+				bms_crtl_do_status(kDoType_Negative, kDoCtrlStatus_On, 100);
+			}
+			else if (statusDischg == 0xAA)
+			{
+				//放电命令，闭合总正总负继电器
+				bms_crtl_do_status(kDoType_Positive, kDoCtrlStatus_On, 100);
+				bms_crtl_do_status(kDoType_Negative, kDoCtrlStatus_On, 100);
+			}
+    }
+}
+
+void protocol_pylon_can_init(can_dev_e can)
+{
+	protocol_can_set_call(can, bcu_can_receive_pylon, bcu_can_send_pylon, NULL);
+}
 
 

app/stm32fxxx_app/protocol/protocol_comm.c

@@ -25,7 +25,7 @@ typedef enum
 {
     kCanProtocal_None,   //使用CAN并机的时候需要将外can协议设置为闲置
 	kCanProtocal_Bcu,
-	kCanProtocal_Bcu_invt,  //英威腾协议
+	kCanProtocal_Bcu_Pylon,  //pylon协议
     kCanProtocal_End,
 }CanProtocal;
 
@@ -61,6 +61,7 @@ CanProtocalCall protocol_can_init_array[kCanProtocal_End] =
 {
 	protocol_can_none_init,
 	protocol_can_bcu_init,
+	protocol_pylon_can_init,
 };
 
 /************************************************modbus*****************************************************/
@@ -141,7 +142,7 @@ void protocol_comm_init(void)
 	{
 		protocol = get_eeprom_data(kEep_InterCanProtocol_Baudrate + i, kEepromDataType_High);
 		//测试
-		protocol = 1;
+		//protocol = 1;
 		if((protocol < kCanProtocal_End) && (protocol_can_init_array[protocol] != NULL))
 		{
 			protocol_can_init_array[protocol](i);

app/stm32fxxx_app/protocol/protocol_comm.h

@@ -10,6 +10,7 @@ extern "C" {
 #include "bsp_modbus.h"
 
 #include "drv_can.h"
+#include "fault_manager.h"
 
 
 typedef void (*CanCommReceive)(CanMsg *msg, can_dev_e can);
@@ -30,8 +31,11 @@ void protocol_can_set_call(can_dev_e can, CanCommReceive rx, CanCommSend tx, Can
 void protocol_modbus_bcu_init(void * const mb_item,uint16_t addr);
 void protocol_modbus_demo(void * const mb_item,uint16_t addr);
 void protocol_can_bcu_init(can_dev_e can);
+void protocol_pylon_can_init(can_dev_e can);
 void protocol_can_invt_pcs_init(can_dev_e can);
 
+//根据位，转换告警的位
+uint16_t set_bit_based_on_source_pylon(uint8_t status, FaultLevel alarmLevel);
 
 void bms_analyse_model_data(void);
 uint16_t bms_read_model_data(uint8_t *buf);

app/stm32fxxx_app/protocol/protocol_modbus_bcu.c

@@ -102,9 +102,7 @@ uint16_t bcu_total_msg_fill(uint16_t start_addr, uint8_t reg_num, uint8_t *buf)
 		READ_FC03_F04_BEGIN();
 		//1 动力电池组总电压
 		READ_FC03_F04_ITEM(1, bms_get_statistic_data(kStatisticData_TotalVolt));
-		//READ_FC03_F04_ITEM(1, 5000);
+
-			
-		//READ_FC03_F04_ITEM(1, test99+=10);
 		//2 动力电池组总电流
 		READ_FC03_F04_ITEM(2, bms_get_show_current());
 		//3 SOC
@@ -782,10 +780,10 @@ BspMdExCode bcu_modbus_485_0x03_fun(uint16_t start_addr, uint16_t reg_num, uint8
 {
     BspMdExCode err = kBspMdEx_None;
     //kit_time_dly_ms(50);
-    if((start_addr >=  3000) && (start_addr + reg_num <= 3169))
+			if((start_addr >=  3000) && (start_addr + reg_num <= 3169))
-	{
+		{
-        *len = bcu_total_cfg_fill(start_addr, reg_num, buf);
+					*len = bcu_total_cfg_fill(start_addr, reg_num, buf);
-	} 
+		} 
     else if((start_addr >= 4000) && ((start_addr + reg_num ) <= 4999))
     {
         hmi_fill_modbus_cfg(fill_buf);

app/stm32fxxx_app/protocol/protocol_mqtt_bcu.c

@@ -850,8 +850,6 @@ const devCellPointMap bms_temp_points[] =
 const int bms_volt_count = sizeof(bms_volt_points) / sizeof(devCellPointMap);
 const int bms_temp_count = sizeof(bms_temp_points) / sizeof(devCellPointMap);
 
-
-
 void protocol_build_json(uint16_t groupId)
 {
     int val = 0;
@@ -871,6 +869,8 @@ void protocol_build_json(uint16_t groupId)
     cJSON_AddStringToObject(deviceObj, "devName", "BCU");
     cJSON_AddStringToObject(deviceObj, "devId", "001");
     cJSON_AddStringToObject(deviceObj, "sn", "SN123456");
+		cJSON_AddNumberToObject(deviceObj, "currentPack", groupId);  // 当前包数
+    cJSON_AddNumberToObject(deviceObj, "totalPack", 16);   			 //总包数
 
     // 构建 data 对象
     cJSON* dataObj = cJSON_CreateObject();
@@ -926,6 +926,8 @@ void protocol_build_volt_json(uint8_t i)
     cJSON_AddStringToObject(deviceObj, "devName", "BCU");
     cJSON_AddStringToObject(deviceObj, "devId", "001");
     cJSON_AddStringToObject(deviceObj, "sn", "SN123456");
+		cJSON_AddNumberToObject(deviceObj, "currentPack", i + 3);  // 当前包数
+    cJSON_AddNumberToObject(deviceObj, "totalPack", 16);       // 总包数
 
     // 构建 data 对象
     cJSON* dataObj = cJSON_CreateObject();
@@ -978,6 +980,8 @@ void protocol_build_temp_json(uint8_t i)
     cJSON_AddStringToObject(deviceObj, "devName", "BCU");
     cJSON_AddStringToObject(deviceObj, "devId", "001");
     cJSON_AddStringToObject(deviceObj, "sn", "SN123456");
+		cJSON_AddNumberToObject(deviceObj, "currentPack", i + 13);  // 当前包数
+    cJSON_AddNumberToObject(deviceObj, "totalPack", 16);       // 总包数
 
     // 构建 data 对象
     cJSON* dataObj = cJSON_CreateObject();

app/stm32fxxx_boot/prj/JLinkSettings.ini

@@ -1,40 +1,45 @@
 [BREAKPOINTS]
-ForceImpTypeAny = 0
+FForceImpTypeAny = 0
-ShowInfoWin = 1
+ShowInfoWin = 1
-EnableFlashBP = 2
+EnableFlashBP = 2
-BPDuringExecution = 0
+BPDuringExecution = 0
+orceImpTypeAny = 0
 [CFI]
-CFISize = 0x00
+CCFISize = 0x00
-CFIAddr = 0x00
+CFIAddr = 0x00
+FISize = 0x00
 [CPU]
-MonModeVTableAddr = 0xFFFFFFFF
+MOverrideMemMap = 0
+AllowSimulation = 1
+ScriptFile=""
+onModeVTableAddr = 0xFFFFFFFF
 MonModeDebug = 0
 MaxNumAPs = 0
 LowPowerHandlingMode = 0
-OverrideMemMap = 0
-AllowSimulation = 1
-ScriptFile=""
 [FLASH]
-EraseType = 0x00
+ECacheExcludeSize = 0x00
-CacheExcludeSize = 0x00
+CacheExcludeAddr = 0x00
-CacheExcludeAddr = 0x00
+MinNumBytesFlashDL = 0
-MinNumBytesFlashDL = 0
+SkipProgOnCRCMatch = 1
-SkipProgOnCRCMatch = 1
+VerifyDownload = 1
-VerifyDownload = 1
+AllowCaching = 1
-AllowCaching = 1
+EnableFlashDL = 2
-EnableFlashDL = 2
+Override = 1
-Override = 0
+Device="Unspecified"
-Device="ARM7"
+raseType = 0x00
 [GENERAL]
-WorkRAMSize = 0x00
+WWorkRAMSize = 0x00
-WorkRAMAddr = 0x00
+WorkRAMAddr = 0x00
-RAMUsageLimit = 0x00
+RAMUsageLimit = 0x00
+orkRAMSize = 0x00
 [SWO]
-SWOLogFile=""
+SSWOLogFile=""
+WOLogFile=""
 [MEM]
-RdOverrideOrMask = 0x00
+RRdOverrideOrMask = 0x00
-RdOverrideAndMask = 0xFFFFFFFF
+RdOverrideAndMask = 0xFFFFFFFF
-RdOverrideAddr = 0xFFFFFFFF
+RdOverrideAddr = 0xFFFFFFFF
-WrOverrideOrMask = 0x00
+WrOverrideOrMask = 0x00
-WrOverrideAndMask = 0xFFFFFFFF
+WrOverrideAndMask = 0xFFFFFFFF
-WrOverrideAddr = 0xFFFFFFFF
+WrOverrideAddr = 0xFFFFFFFF
+dOverrideOrMask = 0x00

app/stm32fxxx_boot/prj/bcu_bootloader.uvprojx

@@ -10,15 +10,15 @@
       <TargetName>stm32f407</TargetName>
       <ToolsetNumber>0x4</ToolsetNumber>
       <ToolsetName>ARM-ADS</ToolsetName>
-      <pArmCC>5060960::V5.06 update 7 (build 960)::.\ARM_Compiler_5.06u7</pArmCC>
+      <pArmCC>5050106::V5.05 update 1 (build 106)::ARMCC</pArmCC>
-      <pCCUsed>5060960::V5.06 update 7 (build 960)::.\ARM_Compiler_5.06u7</pCCUsed>
+      <pCCUsed>5050106::V5.05 update 1 (build 106)::ARMCC</pCCUsed>
       <uAC6>0</uAC6>
       <TargetOption>
         <TargetCommonOption>
           <Device>STM32F407VGTx</Device>
           <Vendor>STMicroelectronics</Vendor>
-          <PackID>Keil.STM32F4xx_DFP.3.0.0</PackID>
+          <PackID>Keil.STM32F4xx_DFP.2.16.0</PackID>
-          <PackURL>https://www.keil.com/pack/</PackURL>
+          <PackURL>http://www.keil.com/pack/</PackURL>
           <Cpu>IRAM(0x20000000,0x00020000) IRAM2(0x10000000,0x00010000) IROM(0x08000000,0x00100000) CPUTYPE("Cortex-M4") FPU2 CLOCK(12000000) ELITTLE</Cpu>
           <FlashUtilSpec></FlashUtilSpec>
           <StartupFile></StartupFile>

library/core/system_stm32f4xx.c

@@ -518,8 +518,8 @@ void SystemInit(void)
          
   /* Configure the System clock source, PLL Multiplier and Divider factors, 
      AHB/APBx prescalers and Flash settings ----------------------------------*/
-  //SetSysClock();
+  SetSysClock();
-	SystemClock_Config();
+	//SystemClock_Config();
 
   /* Configure the Vector Table location add offset address ------------------*/
 #ifdef VECT_TAB_SRAM

library/drv_peripheral/drv_qfc41d.c

@@ -87,11 +87,13 @@ int drv_at_send_cmd(const char *cmd, const char *response, uint32_t timeout)
 static uint8_t drv_wifi_init()
 {
     // 1. 设置模组波特率
+	/*
     if (!drv_at_send_cmd(QFC41D_SET_BATE, "OK", WIFI_TIMEOUT))
     {
         KIT_PRINTF("WiFi Module not responding!\r\n");
         return 1 ;
     }
+	*/
 	
     // 2. 测试 AT 指令
     if (!drv_at_send_cmd("AT", "OK", WIFI_TIMEOUT))
@@ -187,16 +189,17 @@ static uint8_t drv_ble_init()
 uint8_t drv_qfc41d_init(void)
 {
     //初始化串口
-    drv_uart_init((UartDev)qfc41dItem.dev, 115200, 0 | UART_CFG_STOP_BIT_1, kGpioType_WIRELESSUart_Tx, kGpioType_WIRELESSUart_Rx);
+    drv_uart_init((UartDev)qfc41dItem.dev, 9600, 0 | UART_CFG_STOP_BIT_1, kGpioType_WIRELESSUart_Tx, kGpioType_WIRELESSUart_Rx);
-
+	
+	USART2->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_RXNEIE | USART_CR1_UE;
     //设置接收回调函数
     drv_uart_set_interrupt(QFC41D_UART_PORT, kUartInterrupt_Rx, APP_CFG_INT_PRIO_UART2_RX, drv_qf41d_uart_rx_it_call);//#define SIM_UART_PORT     	kUartDev_2
 
-	//³õʼ»¯wifi
+		//³õʼ»¯wifi
-	if(drv_wifi_init() != 0)
+		if(drv_wifi_init() != 0)
-	{
+		{
-		return 1;
+			return 1;
-	}
+		}
 
 	/* 蓝牙预留 
 	//初始化蓝牙（BLE）

library/drv_stm32f4xx/drv_uart.c

@@ -150,6 +150,7 @@ static kit_ret_e drv_uart_set_clock_gpio(UartDev dev, uint16_t tx_idx, uint16_t
         
         case kUartDev_2:
 			RCC->APB1ENR |= RCC_APB1Periph_USART2;
+			RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN; // 使能GPIOA时钟
             if((tx_io == GPIO_PORT_PIN(kGpioPort_A, 2)) && (rx_io == GPIO_PORT_PIN(kGpioPort_A, 3))) 
             {
 				drv_gpio_set_af(kGpioPort_A, 2, 7);
@@ -298,6 +299,7 @@ kit_ret_e drv_uart_init(UartDev dev, uint32_t baudrate, uint32_t uart_config,  u
 		reg->BRR = stm32_uart[dev].base_baudrate / (baudrate / 2400);
 		//使能收、发和uart
 		tmp = USER_CR1_UE | USART_Mode_Rx | USART_Mode_Tx;
+		tmp = USART_CR1_TE | USART_CR1_RE | USART_CR1_RXNEIE;
 		//设置数据长度
 		tmp |= (uart_config & 0x0001) << 12;
 		//设置校验
@@ -410,6 +412,7 @@ static void uart_irq_handler(UartDev dev)
             item->call[kUartInterrupt_Rx](kKit_Ret_Ok, &data);
         }
     }
+	//发送中断回调
     else if((reg->SR & USER_SR1_TCIE) != 0)
     {
         //清除标志位