【V3.1.0.40】新增内短路算法和BCU更改

Merge remote-tracking branch 'QX/V3-7250-QTF' into V3-V31XX-7250

# Conflicts:
#	src/EmbeddedCoder_src/SFM.c

ARMCC/Makefile

@@ -34,6 +34,7 @@ obj-y             += PLAT/project/$(TARGET)/apps/qx_app/src/app.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/EmbeddedCoder_src/BLC.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/EmbeddedCoder_src/CM.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/EmbeddedCoder_src/CDM.o \
+						PLAT/project/$(TARGET)/apps/qx_app/src/EmbeddedCoder_src/ISC.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/EmbeddedCoder_src/look1_is16lu16n16tu16_binlcase.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/EmbeddedCoder_src/look1_iu16lu16n16tu16_binlcase.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/EmbeddedCoder_src/BCUCal.o \

inc/AppConfig.h

@@ -2,7 +2,7 @@
  * @Author       : ChenJie
  * @Date         : 2021-10-14 09:27:15
  * @LastEditors  : ChenJie
- * @LastEditTime : 2021-11-12 16:05:14
+ * @LastEditTime : 2021-11-12 16:38:44
  * @Description  : App Config H file 配置文件，可以针对不同参数进行更改
  * @FilePath     : \PLAT\project\ec616_0h00\apps\qx_app\inc\AppConfig.h
  */
@@ -14,7 +14,7 @@
 #define DATA_MODULE_TYPE (1)           //1表示NB模块，2表示4G cat1
 #define EOLSTATE (0)                   //1表示下线检测跳过，使用默认值，0表示使用下线检测
 #define DEFAULT_SN "RLTEST00000000001" //默认上传的SN编码
-#define APPSWVERSION 0x03010027        //数据模块软件版本号
+#define APPSWVERSION 0x03010028        //数据模块软件版本号
 #define RELAYCONFIG 1                  //继电器配置
 #define TCP_ADD "iotp.fast-fun.cn"     //数据上传的地址
 #define TCP_PORT 8712                  //数据上传的端口
@@ -123,6 +123,9 @@ typedef struct _AppAlgorithmType
     UINT16 sohd_Q_chrgE;              //充入容量读取量；
     UINT16 sohv_Q_packCapArrE[10];    //10次整包容量（数组）读取量；
     UINT16 sohv_Q_cellCapArrE[28];    //
+    UINT16 iscv_Q_remainCpEE[28];
+    UINT32 iscd_tm_totalEE;
+    BOOL sfmd_flg_iscFltEE;
     BOOL sfmd_flg_mainCirClosFltE;
     BOOL sfmd_flg_heatCirClosFltE;
     BOOL sfmd_flg_heatCirOpenFltE;

inc/AppFunc.h

@@ -23,6 +23,7 @@
 #include "AppConfig.h"
 #include "ec_tcpip_api.h"
 #include "AppSignal.h"
+#include "BCUCal.h"
 typedef struct _Fota_Type
 {
     BOOL Fota_update_error;

inc/EmbeddedCoder_inc/BCUDisp.h

@@ -2,15 +2,16 @@
 #include "rtwtypes.h"
 #include "BCUCal.h"
 
-extern uint8_T tmsd_st_heatAct;                          /*热管理请求状态； */
 extern uint16_T appv_V_cellU[cmnc_num_cellUNumMax];                        /* 静态电压 */
-extern boolean_T ihd_flg_HVILFlt;                        /* 保护板上传的高压互锁故障 */
+extern uint8_T appd_st_preCyc;
+
 extern uint16_T blcv_Q_reqCpEi[cmnc_num_cellUNumMax];                      /*均衡需求容量 读取量（数组）； */
 extern uint16_T blcv_Q_reqCpEo[cmnc_num_cellUNumMax];                      /*均衡需求容量 写入量（数组）； */
 extern uint32_T blcv_Q_totalCpEi[cmnc_num_cellUNumMax];                    /*累计均衡容量 读取量（数组）； */
 extern uint32_T blcv_Q_totalCpEo[cmnc_num_cellUNumMax];                    /*累计均衡容量 写入量（数组）； */
 extern boolean_T blcv_flg_excute[cmnc_num_cellUNumMax];                    /*均衡执行请求标志位 （数组）； */
 
+extern boolean_T ihd_flg_HVILFlt;                        /* 保护板上传的高压互锁故障 */
 extern boolean_T ihd_flg_DTCClear;                       /* 上位机发送的故障清楚指令；*/
 extern uint8_T ihd_st_authFaild;                         /* 底层诊断的认证失败故障；*/
 extern int16_T ihd_I_curr;                               /*电池包电流； */
@@ -80,6 +81,8 @@ extern boolean_T sfmd_flg_heatCirOpenFltEi;              /*加热回路常开故
 extern boolean_T sfmd_flg_heatCirOpenFltEo;              /*加热回路常开故障写入量 */  
 extern boolean_T sfmd_flg_heatRunFltEi;
 extern boolean_T sfmd_flg_heatRunFltEo;
+extern boolean_T sfmd_flg_iscFltEi;
+extern boolean_T sfmd_flg_iscFltEo;
 
 extern uint16_T socd_pct_ahSoc;                          /*安时SOC； */
 extern uint16_T socd_pct_estSoc;                         /*估算SOC；*/
@@ -94,6 +97,7 @@ extern uint16_T socd_pct_bcuSocEo;                       /*电池显示SOC写入
 extern uint16_T socd_pct_bcuSoc_Delay;                   /*电池显示SOC延时； */
 extern uint16_T socv_pct_cellSoc[cmnc_num_cellUNumMax];
 extern uint16_T socd_pct_cellBattSoc;
+extern boolean_T socd_flg_cellSocDisable;
 
 extern uint16_T sohd_Q_chrgEi;                           /*充入容量读取量； */
 extern uint16_T sohd_Q_chrgEo;                           /*充入容量写入量； */
@@ -111,6 +115,14 @@ extern uint16_T sohv_Q_packCapArrEo[10];                 /*10次整包容量（
 extern uint16_T sohv_V_chrgStartStatEi[cmnc_num_cellUNumMax];              /*充电开始时刻的单体电压（数组）读取量； */
 extern uint16_T sohv_V_chrgStartStatEo[cmnc_num_cellUNumMax];              /*充电开始时刻的单体电压（数组）写入量； */
 
+extern boolean_T iscd_flg_flt;
+extern uint16_T iscv_Q_remainCpEi[cmnc_num_cellUNumMax];
+extern uint32_T iscd_tm_totalEi;
+extern uint16_T iscv_Q_remainCpEo[cmnc_num_cellUNumMax];
+extern uint32_T iscd_tm_totalEo;
+
+extern uint8_T tmsd_st_heatAct;                          /*热管理请求状态； */
+
 extern uint8_T cmd_st_chrgMod;                           /* 充电模式  */
 extern uint8_T cmd_st_chrgSt;                            /* 充电状态  */
 extern int16_T cmd_I_chrgCurrReq;                       /* 充电需求电流  */

inc/EmbeddedCoder_inc/ISC.h

@@ -0,0 +1,8 @@
+#include <math.h>
+#include "BCUCal.h"
+#include "BCUDisp.h"
+extern boolean_T FirstRun_ISC;
+extern void ISC_Init(void);
+extern void ISC(void);
+
+extern int16_T ArrMean(int16_T *Data, uint16_T m);

src/AppFunc.c

@@ -3,7 +3,7 @@
  * @Date         : 2021-11-09 12:08:17
  * @Version      : V3.0
  * @LastEditors  : ChenJie
- * @LastEditTime : 2021-11-12 15:41:17
+ * @LastEditTime : 2021-11-12 18:25:36
  * @Description  : file content
  * @FilePath     : \PLAT\project\ec616_0h00\apps\qx_app\src\AppFunc.c
  */
@@ -113,7 +113,7 @@ void BmsProtectStateDecode(UINT8 *DischargeProtect, UINT8 *ChargeProtect)
 	ret = getbit(battProtectState, 28);
 	if (ret) //充满保护--28
 	{
-		*ChargeProtect = (*ChargeProtect) + 1;
+		//*ChargeProtect = (*ChargeProtect) + 1;
 		//printf("protect[%d]\n", __LINE__);
 	}
 }
@@ -1403,17 +1403,19 @@ static void setDefaultBcuDataInfo(void)
 {
 	memset(&BcuDataInfo, 0x00, sizeof(BcuDataInfo));
 	BcuDataInfo.appDataModify = false;
-	memset(BcuDataInfo.blcv_Q_totalCpE, 0x00, 28 * sizeof(UINT32));
-	memset(BcuDataInfo.blcv_Q_reqCpE, 0x00, 28 * sizeof(UINT16));
+	memset(BcuDataInfo.blcv_Q_totalCpE, 0x00, cmnc_num_cellUNumMax * sizeof(UINT32));
+	memset(BcuDataInfo.blcv_Q_reqCpE, 0x00, cmnc_num_cellUNumMax * sizeof(UINT16));
 	BcuDataInfo.socd_pct_bcuSocE = 1200;
 	BcuDataInfo.socd_pct_battSocE = 1200;
 	BcuDataInfo.sohd_tm_chrgStartStatE = 0;
 	BcuDataInfo.sohd_flg_chrgEndE = 0;
-	BcuDataInfo.sohv_Q_cellCapArrE[28];
-	memset(BcuDataInfo.sohv_Q_cellCapArrE, 0, 28 * sizeof(UINT16));
-	memset(BcuDataInfo.sohv_V_chrgStartStatE, 0, 28 * sizeof(UINT16));
+	memset(BcuDataInfo.sohv_Q_cellCapArrE, 0, cmnc_num_cellUNumMax * sizeof(UINT16));
+	memset(BcuDataInfo.sohv_V_chrgStartStatE, 0, cmnc_num_cellUNumMax * sizeof(UINT16));
 	BcuDataInfo.sohd_Q_chrgE = 0;
 	memset(BcuDataInfo.sohv_Q_packCapArrE, 0, 10 * sizeof(UINT16));
+	memset(BcuDataInfo.iscv_Q_remainCpEE, 0, cmnc_num_cellUNumMax * sizeof(UINT16));
+	BcuDataInfo.iscd_tm_totalEE = 0;
+	BcuDataInfo.sfmd_flg_iscFltEE = 0;
 	BcuDataInfo.sfmd_flg_mainCirClosFltE = 0;
 	BcuDataInfo.sfmd_flg_heatCirClosFltE = 0;
 	BcuDataInfo.sfmd_flg_heatCirOpenFltE = 0;

src/EmbeddedCoder_src/BCU.c

@@ -17,8 +17,8 @@ void BCU(void)
     while (TRUE)
     {
         if (UartRecvFlag == 1 || RecvCounter >= 15)
-        {   
-            //osDelay(1000);
+        {
+            RecvCounter = 0;
             break;
         }
         else
@@ -26,132 +26,166 @@ void BCU(void)
             RecvCounter++;
             osDelay(1000);
         }
-		//printf("RecvCounter:%d\n ",RecvCounter);
+        //printf("RecvCounter:%d\n ",RecvCounter);
     }
-	
+    
     PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
     while (TRUE)
     {
         switch (gProcess_Bcu_Task)
         {
-        //=========================初始化===============================
-        case PROCESS_STATE_INIT:
-        {
-            BCU_Init();
-            memcpy(blcv_Q_totalCpEi, BcuDataInfo.blcv_Q_totalCpE, sizeof(blcv_Q_totalCpEi));
-            memcpy(blcv_Q_reqCpEi, BcuDataInfo.blcv_Q_reqCpE, sizeof(blcv_Q_reqCpEi));
-            socd_pct_bcuSocEi = BcuDataInfo.socd_pct_bcuSocE;
-            socd_pct_battSocEi = BcuDataInfo.socd_pct_battSocE;
-            sohd_tm_chrgStartStatEi = BcuDataInfo.sohd_tm_chrgStartStatE;
-            sohd_flg_chrgEndEi = BcuDataInfo.sohd_flg_chrgEndE;
-            memcpy(sohv_V_chrgStartStatEi, BcuDataInfo.sohv_V_chrgStartStatE, sizeof(sohv_V_chrgStartStatEi));
-            sohd_Q_chrgEi = BcuDataInfo.sohd_Q_chrgE;
-            memcpy(sohv_Q_packCapArrEi, BcuDataInfo.sohv_Q_packCapArrE, sizeof(sohv_Q_packCapArrEi));
-            memcpy(sohv_Q_cellCapArrEi, BcuDataInfo.sohv_Q_cellCapArrE, sizeof(sohv_Q_cellCapArrEi));
-            sfmd_flg_mainCirClosFltEi = BcuDataInfo.sfmd_flg_mainCirClosFltE;
-            sfmd_flg_heatCirClosFltEi = BcuDataInfo.sfmd_flg_heatCirClosFltE;
-            sfmd_flg_heatCirOpenFltEi = BcuDataInfo.sfmd_flg_heatCirOpenFltE;
-            sfmd_flg_heatRunFltEi = BcuDataInfo.sfmd_flg_heatRunFltE;
-            ihd_st_EOLState = AppNVMData.EOLState;
-
-            PROC_BCU_STATE_SWITCH(PROCESS_STATE_WORK);
-            break;
-        }
-        //============================工作模式==========================
-        case PROCESS_STATE_WORK:
-        {
-            while (TRUE)
+            //=========================初始化===============================
+            case PROCESS_STATE_INIT:
             {
-                if (TimeCounter % 10 == 0)
-                {
-                    if (gProcess_app == LISTEN)
-                    {
-                        PROC_BCU_STATE_SWITCH(PROCESS_STATE_SLEEP);
-                        break;
-                    }
-                    //数据获取
-                    if (BattWorkStateDelay == 0 && battI == 10000)
+                BCU_Init();
+                memcpy(blcv_Q_totalCpEi, BcuDataInfo.blcv_Q_totalCpE, sizeof(blcv_Q_totalCpEi));
+                memcpy(blcv_Q_reqCpEi, BcuDataInfo.blcv_Q_reqCpE, sizeof(blcv_Q_reqCpEi));
+                socd_pct_bcuSocEi = BcuDataInfo.socd_pct_bcuSocE;
+                socd_pct_battSocEi = BcuDataInfo.socd_pct_battSocE;
+                sohd_tm_chrgStartStatEi = BcuDataInfo.sohd_tm_chrgStartStatE;
+                sohd_flg_chrgEndEi = BcuDataInfo.sohd_flg_chrgEndE;
+                memcpy(sohv_V_chrgStartStatEi, BcuDataInfo.sohv_V_chrgStartStatE, sizeof(sohv_V_chrgStartStatEi));
+                sohd_Q_chrgEi = BcuDataInfo.sohd_Q_chrgE;
+                memcpy(sohv_Q_packCapArrEi, BcuDataInfo.sohv_Q_packCapArrE, sizeof(sohv_Q_packCapArrEi));
+                memcpy(sohv_Q_cellCapArrEi, BcuDataInfo.sohv_Q_cellCapArrE, sizeof(sohv_Q_cellCapArrEi));
+                memcpy((iscv_Q_remainCpEi), BcuDataInfo.iscv_Q_remainCpEE, sizeof(iscv_Q_remainCpEi));
+                iscd_tm_totalEi = BcuDataInfo.iscd_tm_totalEE;
+                sfmd_flg_mainCirClosFltEi = BcuDataInfo.sfmd_flg_mainCirClosFltE;
+                sfmd_flg_heatCirClosFltEi = BcuDataInfo.sfmd_flg_heatCirClosFltE;
+                sfmd_flg_heatCirOpenFltEi = BcuDataInfo.sfmd_flg_heatCirOpenFltE;
+                sfmd_flg_heatRunFltEi = BcuDataInfo.sfmd_flg_heatRunFltE;
+                sfmd_flg_iscFltEi = BcuDataInfo.sfmd_flg_iscFltEE;
+                ihd_st_EOLState = AppNVMData.EOLState;
+                
+                
+                PROC_BCU_STATE_SWITCH(PROCESS_STATE_WORK);
+                break;
+            }
+            //============================工作模式==========================
+            case PROCESS_STATE_WORK:
+            {
+                 while (TRUE)
+                 {
+                      if (UartRecvFlag == 1 || RecvCounter >= 15)
+                      {
+                           RecvCounter = 0;
+                           break;
+                       }
+                      else
+                     {
+                          RecvCounter++;
+                          osDelay(1000);
+                     }
+                 }
+			
+                while (TRUE)
+                {   			    
+                    if (TimeCounter % 10 == 0)
                     {
-                        memcpy(appv_V_cellU, battCellU, sizeof(appv_V_cellU));
+                        if (gProcess_app == LISTEN)
+                        {
+                            PROC_BCU_STATE_SWITCH(PROCESS_STATE_SLEEP);
+                            break;
+                        }
+                        //
+                        
+                        //数据获取
+                        ihd_I_curr = (int16_T)(-(battI - 10000));
+                        memcpy(ihv_V_cellU, battCellU, sizeof(battCellU));
+                        for (i = 0; i < cmnc_num_modTNum; i++)
+                        {
+                            ihv_T_modT[i] = battCellTemp[i];
+                        }
+                        ihd_T_mosT = MOSTemp;
+                        ihd_T_DCPlugT = fastChargeTemp;
+                        ihd_T_ACPlugT = normalChargeTemp;
+                        ihd_T_heatPanT1 = heatTemp1;
+                        ihd_T_heatPanT2 = heatTemp2;
+                        ihd_pct_soc = battSOC * 10;
+                        ihd_pct_soh = battSOH * 10;
+                        ihd_flg_HVILFlt = Lockstatus;
+                        ihd_st_workStat = BattWorkStateDelay;
+                        ihd_flg_urtRecFlt = UartErrorFlag;
+                        ihd_flg_urtRecFlg = UartRecvFlag;
+                        ihd_st_chrgConnect = chargerConnectState;
+                        ihd_flg_cellULowFlt = ((battWarningState)&0x01) == 1;
+                        ihd_flg_battULowFlt = ((battWarningState >> 1) & 0x01) == 1;
+                        ihd_flg_cellUOverFlt = ((battWarningState >> 2) & 0x01) == 1;
+                        ihd_flg_battUOverFlt = ((battWarningState >> 3) & 0x01) == 1;
+                        ihd_flg_disChrgCurrOverFlt = ((battWarningState >> 4) & 0x01) == 1;
+                        ihd_flg_chrgCurrOverFlt = ((battWarningState >> 5) & 0x01) == 1;
+                        ihd_flg_disChrgModTOverFlt = ((battWarningState >> 6) & 0x01) == 1;
+                        ihd_flg_chrgModTOverFlt = ((battWarningState >> 7) & 0x01) == 1;
+                        ihd_flg_chrgMosTOverFlt = ((battWarningState >> 11) & 0x01) == 1;
+                        ihd_flg_disChrgMosClosFlt = ((battWarningState >> 18) & 0x01) == 1;
+                        ihd_flg_chrgMosClosFlt = ((battWarningState >> 19) & 0x01) == 1;
+                        ihd_flg_disChrgModTLowFlt = ((battWarningState >> 22) & 0x01) == 1;
+                        ihd_flg_chrgModTLowFlt = ((battWarningState >> 23) & 0x01) == 1;
+                        ihd_flg_currOpenFlt = 0;
+                        ihd_st_heatForceControl = HeatForceControl;
+                        ihd_st_chrgMosControl = ChargeForbiddenControl == 0;
+                        ihd_st_disChrgMosControl = DisChargeForbiddenControl == 0;
+                        ihd_st_relayControl = RelayForbiddenControl == 0;
+                        //ihd_flg_DTCClear = 1;   //////clear
+                        //调用算法
+                        SFM();
+                        TMS();
+                        CM();
+                        SPM();
+                        ISC();
+                        //实时存储
+                        if (socd_flg_EEsave == 1 || ihd_flg_DTCClear)
+                        {
+                            BCUEEDataSave();
+                            ihd_flg_DTCClear = false;
+                        }
+
+						//
+                        if (BattWorkStateDelay == 0 && battI == 10000)
+                        {
+                            memcpy(appv_V_cellU, battCellU, sizeof(appv_V_cellU));
+                        }
+                        
+                        if (ihd_tm_parkTime >= cmnc_tm_parkTime && battI == 10000)
+                        {
+                            appd_st_preCyc = 1 ;
+                        }
+                        else
+                        {
+                            appd_st_preCyc = 0;
+                        }
+     
                     }
-                    ihd_I_curr = (int16_T)(-(battI - 10000));
-                    memcpy(ihv_V_cellU, battCellU, sizeof(battCellU));
-                    for (i = 0; i < cmnc_num_modTNum; i++)
+                    osDelay(100);
+                }
+                break;
+            }
+            //======================休眠模式===============================
+            case PROCESS_STATE_SLEEP:
+            {
+                BCUEEDataSave();
+                ihd_tm_parkTime = 0;
+                while (TRUE)
+                {
+                    if (TimeCounter % 10 == 0)
                     {
-                        ihv_T_modT[i] = battCellTemp[i];
+                        ihd_tm_parkTime++;
+                       
                     }
-                    ihd_T_mosT = MOSTemp;
-                    ihd_T_DCPlugT = fastChargeTemp;
-                    ihd_T_ACPlugT = normalChargeTemp;
-                    ihd_T_heatPanT1 = heatTemp1;
-                    ihd_T_heatPanT2 = heatTemp2;
-                    ihd_pct_soc = battSOC * 10;
-                    ihd_pct_soh = battSOH * 10;
-                    ihd_flg_HVILFlt = Lockstatus;
-                    ihd_st_workStat = BattWorkStateDelay;
-                    ihd_flg_urtRecFlt = UartErrorFlag;
-					ihd_flg_urtRecFlg = UartRecvFlag;
-                    ihd_st_chrgConnect = chargerConnectState;
-                    ihd_flg_cellULowFlt = ((battWarningState)&0x01) == 1;
-                    ihd_flg_battULowFlt = ((battWarningState >> 1) & 0x01) == 1;
-                    ihd_flg_cellUOverFlt = ((battWarningState >> 2) & 0x01) == 1;
-                    ihd_flg_battUOverFlt = ((battWarningState >> 3) & 0x01) == 1;
-                    ihd_flg_disChrgCurrOverFlt = ((battWarningState >> 4) & 0x01) == 1;
-                    ihd_flg_chrgCurrOverFlt = ((battWarningState >> 5) & 0x01) == 1;
-                    ihd_flg_disChrgModTOverFlt = ((battWarningState >> 6) & 0x01) == 1;
-                    ihd_flg_chrgModTOverFlt = ((battWarningState >> 7) & 0x01) == 1;
-                    ihd_flg_chrgMosTOverFlt = ((battWarningState >> 11) & 0x01) == 1;
-                    ihd_flg_disChrgMosClosFlt = ((battWarningState >> 18) & 0x01) == 1;
-                    ihd_flg_chrgMosClosFlt = ((battWarningState >> 19) & 0x01) == 1;
-                    ihd_flg_disChrgModTLowFlt = ((battWarningState >> 22) & 0x01) == 1;
-                    ihd_flg_chrgModTLowFlt = ((battWarningState >> 23) & 0x01) == 1;
-                    ihd_flg_currOpenFlt = 0;
-                    ihd_st_heatForceControl = HeatForceControl;
-                    ihd_st_chrgMosControl = ChargeForbiddenControl == 0;
-                    ihd_st_disChrgMosControl = DisChargeForbiddenControl == 0;
-                    ihd_st_relayControl = RelayForbiddenControl == 0;
-                    //ihd_flg_DTCClear = 1;   //////clear
-                    //调用算法
-                    SFM();
-                    TMS();
-                    CM();
-                    SPM();
-                    //实时存储
-                    if (socd_flg_EEsave == 1 || ihd_flg_DTCClear)
+                    if (gProcess_app == WORK)
                     {
-                        BCUEEDataSave();
-                        ihd_flg_DTCClear = false;
+                        PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
+                        break;
                     }
+                    osDelay(100);
                 }
-                osDelay(100);
+                break;
             }
-            break;
-        }
-        //======================休眠模式===============================
-        case PROCESS_STATE_SLEEP:
-        {
-            BCUEEDataSave();
-            ihd_tm_parkTime = 0;
-            while (TRUE)
+            default:
             {
-                if (TimeCounter % 10 == 0)
-                {
-                    ihd_tm_parkTime++;
-                }
-                if (gProcess_app == WORK)
-                {
-                    PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
-                    break;
-                }
-                osDelay(100);
+                PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
+                break;
             }
-            break;
-        }
-        default:
-        {
-            PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
-            break;
-        }
         }
     }
 }
@@ -163,6 +197,7 @@ void BCU_Init(void)
     TMS_Init();
     CM_Init();
     SPM_Init();
+    ISC_Init();
 }
 
 //==========================主线程调用======================================
@@ -192,9 +227,12 @@ void BCUEEDataSave(void)
     BcuDataInfo.sohd_Q_chrgE = sohd_Q_chrgEo;
     memcpy(BcuDataInfo.sohv_Q_packCapArrE, sohv_Q_packCapArrEo, sizeof(sohv_Q_packCapArrEo));
     memcpy(BcuDataInfo.sohv_Q_cellCapArrE, sohv_Q_cellCapArrEo, sizeof(sohv_Q_cellCapArrEo));
+    memcpy(BcuDataInfo.iscv_Q_remainCpEE, iscv_Q_remainCpEo, sizeof(iscv_Q_remainCpEo));
+    BcuDataInfo.iscd_tm_totalEE = iscd_tm_totalEo;
     BcuDataInfo.sfmd_flg_mainCirClosFltE = sfmd_flg_mainCirClosFltEo;
     BcuDataInfo.sfmd_flg_heatCirClosFltE = sfmd_flg_heatCirClosFltEo;
     BcuDataInfo.sfmd_flg_heatCirOpenFltE = sfmd_flg_heatCirOpenFltEo;
     BcuDataInfo.sfmd_flg_heatRunFltE = sfmd_flg_heatRunFltEo;
+    BcuDataInfo.sfmd_flg_iscFltEE = sfmd_flg_iscFltEo;
     BcuDataInfo.appDataModify = TRUE;
 }

src/EmbeddedCoder_src/BCUDisp.c

@@ -2,15 +2,16 @@
 
 #include "BCUDisp.h"
 
-uint8_T tmsd_st_heatAct;                          /*热管理请求状态； */
 uint16_T appv_V_cellU[cmnc_num_cellUNumMax];
-boolean_T ihd_flg_HVILFlt;
+uint8_T appd_st_preCyc;
+
 uint16_T blcv_Q_reqCpEi[cmnc_num_cellUNumMax];                      /*均衡需求容量 读取量（数组）； */
 uint16_T blcv_Q_reqCpEo[cmnc_num_cellUNumMax];                      /*均衡需求容量 写入量（数组）； */
 uint32_T blcv_Q_totalCpEi[cmnc_num_cellUNumMax];                    /*累计均衡容量 读取量（数组）； */
 uint32_T blcv_Q_totalCpEo[cmnc_num_cellUNumMax];                    /*累计均衡容量 写入量（数组）； */
 boolean_T blcv_flg_excute[cmnc_num_cellUNumMax];                    /*均衡执行请求标志位 （数组） */
 
+boolean_T ihd_flg_HVILFlt;
 boolean_T ihd_flg_DTCClear;
 uint8_T ihd_st_authFaild;                         
 int16_T ihd_I_curr;                               /*电池包电流； */
@@ -80,6 +81,8 @@ boolean_T sfmd_flg_heatCirOpenFltEi;              /*加热回路常开故障读
 boolean_T sfmd_flg_heatCirOpenFltEo;              /*加热回路常开故障写入量 */  
 boolean_T sfmd_flg_heatRunFltEi;
 boolean_T sfmd_flg_heatRunFltEo;
+boolean_T sfmd_flg_iscFltEi;
+boolean_T sfmd_flg_iscFltEo;
 
 uint16_T socd_pct_ahSoc;                          /*安时SOC； */
 uint16_T socd_pct_estSoc;                         /*估算SOC；*/
@@ -94,6 +97,7 @@ uint16_T socd_pct_bcuSocEo;                       /*电池显示SOC写入量；
 uint16_T socd_pct_bcuSoc_Delay;                   /*电池显示SOC延时； */
 uint16_T socv_pct_cellSoc[cmnc_num_cellUNumMax];
 uint16_T socd_pct_cellBattSoc;
+boolean_T socd_flg_cellSocDisable;
 
 uint16_T sohd_Q_chrgEi;                           /*充入容量读取量； */
 uint16_T sohd_Q_chrgEo;                           /*充入容量写入量； */
@@ -111,6 +115,14 @@ uint16_T sohv_Q_packCapArrEo[10];                 /*10次整包容量（数组
 uint16_T sohv_V_chrgStartStatEi[cmnc_num_cellUNumMax];              /*充电开始时刻的单体电压（数组）读取量； */
 uint16_T sohv_V_chrgStartStatEo[cmnc_num_cellUNumMax];              /*充电开始时刻的单体电压（数组）写入量； */
 
+boolean_T iscd_flg_flt;
+uint16_T iscv_Q_remainCpEi[cmnc_num_cellUNumMax];
+uint32_T iscd_tm_totalEi;
+uint16_T iscv_Q_remainCpEo[cmnc_num_cellUNumMax];
+uint32_T iscd_tm_totalEo;
+
+uint8_T tmsd_st_heatAct;                          /*热管理请求状态； */
+
 uint8_T cmd_st_chrgMod;                           /* 充电模式  */
 uint8_T cmd_st_chrgSt;                            /* 充电状态  */
 int16_T cmd_I_chrgCurrReq;                       /* 充电需求电流  */

src/EmbeddedCoder_src/BLC.c

@@ -66,7 +66,7 @@ void BLC(void)
     //=========================================================================
     if(FirstRun_BLC)
     {
-		blcn_flg_judge	= (ihd_tm_parkTime > cmnc_tm_parkTime)&& !sfmd_flg_cellUDisable && (sfmd_I_curr > -10 && sfmd_I_curr < 10);
+		blcn_flg_judge	= (ihd_tm_parkTime >= cmnc_tm_parkTime)&& !sfmd_flg_cellUDisable && (sfmd_I_curr > -10 && sfmd_I_curr < 10);
     }
     blcn_flg_enable = ((sfmd_st_fltAct >> 7) & 0x01) != 1;
 

src/EmbeddedCoder_src/CDM.c

@@ -16,32 +16,39 @@ void CDM(void)
     static real_T P[4][cmnc_num_cellUNumMax];
     static real_T deltaE[cmnc_num_cellUNumMax];
     static real_T deltaR[cmnc_num_cellUNumMax];
+	static real_T deltaES[cmnc_num_cellUNumMax];
+    static real_T deltaRS[cmnc_num_cellUNumMax];
     static real_T Lambda;
     real_T K[2];
     real_T arf[cmnc_num_cellUNumMax];
     uint16_T i;
     static uint8_T ihd_st_workStat_Delay;
+	static uint8_T Cnt;
     //
-    if(ihd_st_workStat_Delay != 1 && ihd_st_workStat == 1)
+    if(ihd_st_workStat_Delay == 2 && ihd_st_workStat != 2)
     {
         FirstRun_CDM = true;
     }
     ihd_st_workStat_Delay = ihd_st_workStat;
+	//
     if (FirstRun_CDM)
     {
         for (i = 0;i < cmnc_num_cellUNum;i++)
         {
-            P[0][i] = 0.001;
+            P[0][i] = 10;
             P[1][i] = 0;
             P[2][i] = 0;
-            P[3][i] = 0.001;
-            Lambda = 1;
-            deltaE[i] = 0;
-            deltaR[i] = 0;
+            P[3][i] = 10;
+            Lambda = 0.991;
+            deltaE[i] =  0;
+            deltaR[i] =  0;
+			deltaES[i] = 0;
+            deltaRS[i] = 0;
+			Cnt = 0;
         }
     }
-    
-    if(ihd_st_workStat == 1)
+    //
+    if(ihd_st_workStat != 2)
     {
         for (i = 0;i < cmnc_num_cellUNum;i++)
         {
@@ -49,7 +56,7 @@ void CDM(void)
         }
         cdmn_I_curr = (real_T) sfmd_I_curr * 0.1;
         //
-   
+        cdmd_flg_deltOCVDisable = false;
         for (i = 0;i < cmnc_num_cellUNum;i++)
         {
             K[0] = (P[0][i]  + cdmn_I_curr * P[1][i])/(Lambda + P[0][i] + cdmn_I_curr * P[2][i] + ( P[1][i] + cdmn_I_curr * P[3][i]) * cdmn_I_curr);
@@ -61,23 +68,39 @@ void CDM(void)
             P[1][i] = ((1 -K[0])* P[1][i] -P[3][i] * K[0] * cdmn_I_curr) /Lambda;
             P[2][i] = (-K[1] *P[0][i] +P[2][i] * (1 - K[1] * cdmn_I_curr))/Lambda;
             P[3][i] = (-K[1] *P[1][i] +P[3][i] * (1 - K[1] * cdmn_I_curr))/Lambda;
+			
+			if(arf[i] > 0.04 || arf[i] < -0.04)
+            {
+                cdmd_flg_deltOCVDisable = true;
+			   
+            }
 	    }
         //
-        cdmd_flg_deltOCVDisable = false;
+		Cnt = Cnt + 1;
+
         for (i = 0;i < cmnc_num_cellUNum;i++)
         {   
-            cdmv_V_deltOCV[i] = (int16_T) (deltaE[i]  * 1000);
-            cdmv_ohm_deltR[i] = (int16_T) (deltaR[i]  * 1000 * 1000);
-            if(arf[i] > 0.05 && arf[i] < -0.05)
-            {
-                cdmd_flg_deltOCVDisable = true;
-            }
+            deltaES[i] = deltaES[i] + deltaE[i];
+			deltaRS[i] = deltaRS[i] + deltaR[i];
         }
+
+		if (Cnt >= 10)
+		{
+             for (i = 0;i < cmnc_num_cellUNum;i++)
+             {   
+                 cdmv_V_deltOCV[i] = (int16_T) (deltaES[i]/Cnt  * 1000);
+                 cdmv_ohm_deltR[i] = (int16_T) (deltaRS[i]/Cnt  * 1000 * 1000);
+			     deltaES[i] = 0;
+                 deltaRS[i] = 0;
+             }
+		     Cnt = 0;
+		}
     }
     else
     {
         cdmd_flg_deltOCVDisable = false;
     }
+	
     FirstRun_CDM = false;
 	
 }

src/EmbeddedCoder_src/ISC.c

@@ -0,0 +1,189 @@
+#include "ISC.h"
+#include "look1_is16lu16n16tu16_binlcase.h"
+
+boolean_T FirstRun_ISC;
+
+void ISC_Init(void)
+{
+    FirstRun_ISC = true;
+}
+//-------------------------------------------------------------------------
+
+void ISC(void)
+{
+    uint16_T i;
+    static uint32_T iscd_tm_totalEE;
+    static uint16_T iscv_Q_remainCpEE[cmnc_num_cellUNumMax];
+    uint16_T iscn_pct_cellSoc1[cmnc_num_cellUNumMax];
+    uint16_T iscn_pct_cellSoc2[cmnc_num_cellUNumMax];
+    int16_T iscn_Q_deltAh[cmnc_num_cellUNumMax];
+    uint16_T iscn_Q_cellAh[cmnc_num_cellUNumMax];
+    static uint16_T iscn_Q_cellAh0[cmnc_num_cellUNumMax];
+    static boolean_T iscd_flg_timedWakeUpFlt;
+    static boolean_T iscd_flg_disChrgFlt;
+    static uint16_T TimeCtn;
+    static uint16_T RunCtn;
+    static uint16_T iscn_N_fltNr[cmnc_num_cellUNumMax];
+    static boolean_T iscd_flg_fulStat;
+    //初值
+    if(FirstRun_ISC)
+    {
+        iscd_flg_timedWakeUpFlt = false;
+        iscd_flg_disChrgFlt = false;
+        memset(iscn_Q_cellAh0,0, sizeof(iscn_Q_cellAh0));
+		memset(iscn_pct_cellSoc1,0, sizeof(iscn_pct_cellSoc1));
+		memset(iscn_pct_cellSoc2,0, sizeof(iscn_pct_cellSoc2));
+		memset(iscn_Q_cellAh,0, sizeof(iscn_Q_cellAh));
+		memset(iscn_Q_deltAh,0, sizeof(iscn_Q_deltAh));
+        memset(iscn_N_fltNr,0, sizeof(iscn_N_fltNr));
+        TimeCtn = 0;
+        RunCtn = 0;
+    }
+    //=====================================================================
+    //================高端SOC点诊断=================================== 0.1A
+    //=====================================================================
+    RunCtn = (RunCtn + 1) > 60000 ? 60000 : (RunCtn + 1);
+    if(FirstRun_ISC)
+    {
+        //
+        if(ArrMax(iscv_Q_remainCpEi,cmnc_num_cellUNum) > cmnc_Q_ratedCp)
+        {
+            memset(iscv_Q_remainCpEE,0, sizeof(iscv_Q_remainCpEi));
+            iscd_tm_totalEE =  0;
+        }
+        else
+        {
+            memcpy(iscv_Q_remainCpEE,iscv_Q_remainCpEi, sizeof(iscv_Q_remainCpEi));
+            iscd_tm_totalEE = iscd_tm_totalEi;
+        }
+        //
+        if((iscd_tm_totalEE + ihd_tm_parkTime >= 20 * 3600 || iscd_tm_totalEE == 0) && ihd_tm_parkTime >= cmnc_tm_parkTime && socd_pct_battSoc > 900 && sfmd_I_curr > -10 && sfmd_I_curr < 10)
+        {
+            for(i = 0; i < cmnc_num_cellUNum;i++)
+            {
+                iscn_pct_cellSoc1[i] = look1_iu16lu16n16tu16_binlcase(sfmv_V_cellU[i], (&(cmnm_V_ocv[0])), (&(cmnm_pct_soc[0])), 12U);
+                iscn_Q_cellAh[i] = (uint16_T)((uint16_T)((uint32_T) iscn_pct_cellSoc1[i]  * sohv_Q_cellCap[i] / 2000U) << 1);
+                iscn_Q_deltAh[i] = (int16_T) (iscn_Q_cellAh[i] - iscv_Q_remainCpEE[i]);
+            }
+            for(i = 0; i < cmnc_num_cellUNum;i++)
+            {
+                if((real_T)(ArrMean(&iscn_Q_deltAh[0],cmnc_num_cellUNum) -  iscn_Q_deltAh[i]) * 0.1/(iscd_tm_totalEE + ihd_tm_parkTime) * 3600 > 0.1)
+                {
+                    iscd_flg_fulStat = true && iscd_tm_totalEE !=0;
+                }
+            }
+            memcpy(iscv_Q_remainCpEo,iscn_Q_cellAh, sizeof(iscn_Q_cellAh));
+            iscd_tm_totalEE = 0 ;
+        }
+        else
+        {
+            memcpy(iscv_Q_remainCpEo,iscv_Q_remainCpEi, sizeof(iscv_Q_remainCpEi));
+            iscd_tm_totalEE = iscd_tm_totalEE + ihd_tm_parkTime;
+        }
+    }
+	if(iscv_Q_remainCpEo[0] != 0)
+	{
+        iscd_tm_totalEo = iscd_tm_totalEE + RunCtn;
+	}
+	
+    //=====================================================================
+    //================定时唤醒诊断======================================1A
+    //=====================================================================
+    if(appd_st_preCyc == 1 && ihd_tm_parkTime >= cmnc_tm_parkTime && sfmd_I_curr < 10 && sfmd_I_curr > -10 && FirstRun_ISC)
+    {
+        for (i = 0; i < cmnc_num_cellUNum;i++)
+        {
+            iscn_pct_cellSoc1[i] = look1_iu16lu16n16tu16_binlcase(appv_V_cellU[i], (&(cmnm_V_ocv[0])), (&(cmnm_pct_soc[0])), 12U);
+            iscn_pct_cellSoc2[i] = look1_iu16lu16n16tu16_binlcase(sfmv_V_cellU[i], (&(cmnm_V_ocv[0])), (&(cmnm_pct_soc[0])), 12U);
+            iscn_Q_deltAh[i] = (int16_T)((uint16_T)((uint32_T) iscn_pct_cellSoc2[i]  * sohv_Q_cellCap[i] / 2000U) << 1) - (int16_T)((uint16_T)((uint32_T) iscn_pct_cellSoc1[i]  * sohv_Q_cellCap[i] / 2000U) << 1);
+        }
+        for (i = 0; i < cmnc_num_cellUNum;i++)
+        {
+            if(ArrMean(&iscn_Q_deltAh[0],cmnc_num_cellUNum) -  iscn_Q_deltAh[i] > 10)
+            {
+                iscd_flg_timedWakeUpFlt = true;
+            }
+        }
+		
+    }
+   
+	
+    
+    //=====================================================================
+    //================放电过程中诊断=================================== 2A
+    //=====================================================================
+    if(!socd_flg_cellSocDisable)
+    {
+        TimeCtn = TimeCtn + 1;
+        for (i = 0; i < cmnc_num_cellUNum;i++)
+        {
+            //Ah[i] =(int16_T)((uint16_T)((uint32_T) socv_pct_cellSoc[i]  * sohv_Q_cellCap[i] / 2000U) << 1);
+            iscn_Q_cellAh[i]=(uint16_T) ((real_T)( socv_pct_cellSoc[i] * 0.1) * (real_T)( sohv_Q_cellCap[i] * 0.1)/100 * 100);
+        }
+        if (TimeCtn == 60)
+        {
+            memcpy(iscn_Q_cellAh0,iscn_Q_cellAh, sizeof(iscn_Q_cellAh));
+        }
+        if (TimeCtn > 60 + 360)
+        {
+            for (i = 0; i < cmnc_num_cellUNum;i++)
+            {
+                iscn_Q_deltAh[i] = (int16_T)(iscn_Q_cellAh[i] - iscn_Q_cellAh0[i]);
+            }
+            for (i = 0; i < cmnc_num_cellUNum;i++)
+            {
+                if((real_T)(ArrMean(&iscn_Q_deltAh[0],cmnc_num_cellUNum) -  iscn_Q_deltAh[i]) * 0.01/(TimeCtn - 60) * 3600 > 2 )
+                {
+                    iscn_N_fltNr[i] =  (iscn_N_fltNr[i] + 1) > 60000 ? 60000 : (iscn_N_fltNr[i] + 1);
+                }
+                else
+                {
+                    iscn_N_fltNr[i] = 0;
+                }
+                if (iscn_N_fltNr[i] > 600)
+                {
+                    iscd_flg_disChrgFlt = true;
+                }
+            }
+        }
+		if(TimeCtn > 3600)
+		{
+		   TimeCtn =60;
+		}
+    }
+    else
+    {
+        TimeCtn = 0;
+    }
+	
+    /////
+    iscd_flg_flt = iscd_flg_disChrgFlt||iscd_flg_timedWakeUpFlt ||iscd_flg_fulStat;
+  /*
+    printf("R-%d,%d,%d\n",cdmv_ohm_deltR[0],cdmv_ohm_deltR[1],cdmv_ohm_deltR[2]);
+	printf("E-%d,%d,%d\n",cdmv_V_deltOCV[0],cdmv_V_deltOCV[1],cdmv_V_deltOCV[2]);
+	printf("S-%d,%d,%d\n",socv_pct_cellSoc[0],socv_pct_cellSoc[1],socv_pct_cellSoc[2]);
+	printf("a-%d,%d,%d\n",iscn_Q_cellAh[0],iscn_Q_cellAh[1],iscn_Q_cellAh[2]);
+    printf("a-%d,%d,%d\n",iscn_Q_cellAh0[0],iscn_Q_cellAh0[1],iscn_Q_cellAh0[2]);
+	for(i=0;i<3;i++)
+		{
+	 printf("%f    ",(real_T)(ArrMean(&iscn_Q_deltAh[0],cmnc_num_cellUNum) -  iscn_Q_deltAh[i]) * 0.01/(TimeCtn - 60) * 3600);
+		}
+    printf("\nTimeCtn:%d\n\n",TimeCtn);
+    */
+	FirstRun_ISC = false;
+}
+
+/////////////////////////////////////////////////////////////////////////////////
+int16_T ArrMean(int16_T *Data, uint16_T m)
+{
+    uint16_T i;
+    int32_T Sum = 0;
+    int16_T DataMean;
+    
+    for (i = 0;i < m ;i++)
+    {
+        Sum = Sum + Data[i];
+    }
+    DataMean = (int16_T)Sum /m;
+    return DataMean;
+}

src/EmbeddedCoder_src/SOC.c

@@ -123,7 +123,7 @@ void SOC(void)
     if (FirstRun_SOC)
     { //
         if (socd_pct_battSocEi > 1000 || socd_pct_bcuSocEi > 1000 || ihd_st_EOLState == 0 ||
-                (((int16_T)(socd_pct_battSocEi - socd_pct_bcuSocEi) > 300 || (int16_T)(socd_pct_battSocEi - socd_pct_bcuSocEi) < -300) && ihd_tm_parkTime > cmnc_tm_parkTime))
+                (((int16_T)(socd_pct_battSocEi - socd_pct_bcuSocEi) > 300 || (int16_T)(socd_pct_battSocEi - socd_pct_bcuSocEi) < -300) && ihd_tm_parkTime >= cmnc_tm_parkTime))
         {
             socn_pct_battSocEE = look1_iu16lu16n16tu16_binlcase(sfmd_V_cellUAvrg, (&(cmnm_V_ocv[0])), (&(cmnm_pct_soc[0])), 12U);
             socn_pct_bcuSocEE  = look1_iu16lu16n16tu16_binlcase(sfmd_V_cellUAvrg, (&(cmnm_V_ocv[0])), (&(cmnm_pct_soc[0])), 12U);
@@ -134,7 +134,7 @@ void SOC(void)
             socn_pct_bcuSocEE = socd_pct_bcuSocEi;
         }
         //
-        if (ihd_tm_parkTime > cmnc_tm_parkTime)
+        if (ihd_tm_parkTime >= cmnc_tm_parkTime)
         {
             socn_pct_battSocEE = look1_iu16lu16n16tu16_binlcase(sfmd_V_cellUAvrg, (&(cmnm_V_ocv[0])), (&(cmnm_pct_soc[0])), 12U);
         }
@@ -210,8 +210,8 @@ void SOC(void)
     //输出
     EKFSOCMin = (uint16_T)(soc_Min_Delay * 10);
     socn_flg_ekfInvalidMin = (deltU > 0.01) || (deltU < -0.01);
-    //printf("2----socmin:%f,Up:%f,U1:%d,sfmd_V_cellUMin:%d,deltU:%f,flg:%d,soc1:%f,K[0]:%f,K[1]:%f\n",soc_Min_Delay,Up_Min_Delay,ihv_V_cellU[0],sfmd_V_cellUMin,deltU,socn_flg_ekfInvalidMin,soc1,K[0],K[1]);
-    //------------------------EKFSOCmax-----------------------------------
+    //printf("2----soc:%f,Up:%f,U:%d,deltU:%f,K[0]:%f,K[1]:%f\n",soc_Min_Delay,Up_Min_Delay,sfmd_V_cellUMin,deltU,K[0],K[1]);  
+	//------------------------EKFSOCmax-----------------------------------
     if (FirstRun_SOC)
     {
         soc_Max_Delay = (real_T)socn_pct_battSocEE * 0.1;
@@ -273,7 +273,7 @@ void SOC(void)
     //输出
     EKFSOCMax = (uint16_T)(soc_Max_Delay * 10);
     socn_flg_ekfInvalidMax = (deltU > 0.01) || (deltU < -0.01);
-    //printf("3----socmax:%f,Up:%f,sfmd_V_cellUMax:%d,deltU:%f,flg:%d\n",soc_Max_Delay,Up_Max_Delay,sfmd_V_cellUMax,deltU,socn_flg_ekfInvalidMax);
+    //printf("4----soc:%f,Up:%f,U:%d,deltU:%f,K[0]:%f,K[1]:%f\n",soc_Max_Delay,Up_Max_Delay,sfmd_V_cellUMax,deltU,K[0],K[1]);
     //-----------------------EKFSOC----------------------------------------
     socn_flg_ekfInvalid = socn_flg_ekfInvalidMax || socn_flg_ekfInvalidMin;
     if (EKFSOCMax > 800)
@@ -303,10 +303,10 @@ void SOC(void)
         P_avrg_Delay[3] = 10;
     }
     //参数查表
-    ocv = (real_T)look1_iu16lu16n16tu16_binlcase((uint16_T)(soc_Min_Delay * 10), (&(cmnm_pct_soc[0])), (&(cmnm_V_ocv[0])),   12U) * 0.001;
-    Ro  = (real_T)look1_iu16lu16n16tu16_binlcase((uint16_T)(soc_Min_Delay * 10), (&(cmnm_pct_soc[0])), (&(cmnm_R_ohm[0])),   12U) * 0.001 * 0.001;
-    Rp  = (real_T)look1_iu16lu16n16tu16_binlcase((uint16_T)(soc_Min_Delay * 10), (&(cmnm_pct_soc[0])), (&(cmnm_R_polar[0])), 12U) * 0.001 * 0.001;
-    C   = (real_T)look1_iu16lu16n16tu16_binlcase((uint16_T)(soc_Min_Delay * 10), (&(cmnm_pct_soc[0])), (&(cmnm_F_polar[0])), 12U) * 0.001 * 1000;
+    ocv = (real_T)look1_iu16lu16n16tu16_binlcase((uint16_T)(soc_Avrg_Delay * 10), (&(cmnm_pct_soc[0])), (&(cmnm_V_ocv[0])),   12U) * 0.001;
+    Ro  = (real_T)look1_iu16lu16n16tu16_binlcase((uint16_T)(soc_Avrg_Delay * 10), (&(cmnm_pct_soc[0])), (&(cmnm_R_ohm[0])),   12U) * 0.001 * 0.001;
+    Rp  = (real_T)look1_iu16lu16n16tu16_binlcase((uint16_T)(soc_Avrg_Delay * 10), (&(cmnm_pct_soc[0])), (&(cmnm_R_polar[0])), 12U) * 0.001 * 0.001;
+    C   = (real_T)look1_iu16lu16n16tu16_binlcase((uint16_T)(soc_Avrg_Delay * 10), (&(cmnm_pct_soc[0])), (&(cmnm_F_polar[0])), 12U) * 0.001 * 1000;
     A[0] = 1;
     A[1] = 0;
     A[2] = 0;
@@ -354,12 +354,13 @@ void SOC(void)
     //输出
     EKFSOCAvrg = (uint16_T)(soc_Avrg_Delay * 10);
     socn_flg_ekfInvalidAvrg = (deltU > 0.01) || (deltU < -0.01);
+	//printf("4----soc:%f,Up:%f,U:%d,deltU:%f,K[0]:%f,K[1]:%f\n\n",soc_Avrg_Delay,Up_Avrg_Delay,sfmd_V_cellUAvrg,deltU,K[0],K[1]);
     //
     for(i = 0;i < cmnc_num_cellUNum;i++)
     {
         socv_pct_cellSoc[i] = look1_iu16lu16n16tu16_binlcase((look1_iu16lu16n16tu16_binlcase(EKFSOCAvrg, (&(cmnm_pct_soc[0])), (&(cmnm_V_ocv[0])), 12U) + cdmv_V_deltOCV[i]), (&(cmnm_V_ocv[0])),(&(cmnm_pct_soc[0])),12U);
     }
-    //socn_flg_ekfInvalid = socn_flg_ekfInvalidAvrg || cdmd_flg_deltOCVDisable;
+    socd_flg_cellSocDisable = socn_flg_ekfInvalidAvrg || cdmd_flg_deltOCVDisable;
     cellSocMax = ArrMax(&socv_pct_cellSoc[0],cmnc_num_cellUNum);
     cellSocMin = ArrMin(&socv_pct_cellSoc[0],cmnc_num_cellUNum);
     if (cellSocMax > 800)

src/EmbeddedCoder_src/SOH.c

@@ -95,7 +95,7 @@ void SOH(void)
  		//=======================================================================================
         //--------------------------计算使能-------------------------------------------------------
         //=======================================================================================
-        if(ihd_tm_parkTime > cmnc_tm_parkTime && sohn_flg_chrgEndEE && sohn_Q_chrgEE > sohc_Q_countThr && !sfmd_flg_cellUDisable && sfmd_I_curr < 10 && sfmd_I_curr > -10)
+        if(ihd_tm_parkTime >= cmnc_tm_parkTime && sohn_flg_chrgEndEE && sohn_Q_chrgEE > sohc_Q_countThr && !sfmd_flg_cellUDisable && sfmd_I_curr < 10 && sfmd_I_curr > -10)
         {
             sohn_flg_countEn = true;
         }
@@ -152,7 +152,8 @@ void SOH(void)
              memcpy(sohv_Q_packCapArrEo,sohn_Q_packCapArrEE, sizeof(sohv_Q_packCapArrEo));
              memcpy(sohv_Q_cellCapArrEo,sohn_Q_cellCapArrEE, sizeof(sohv_Q_cellCapArrEo));
          }
- 
+		 memcpy(sohv_Q_cellCap,sohv_Q_cellCapArrEo, sizeof(sohv_Q_cellCapArrEo));
+
  
          SumQ = 0;
          for(i = 0; i < 10;i++)