宏定义 单体数组最大维度 及温度数组最大维度

ARMCC/Makefile

@@ -25,7 +25,7 @@ obj-y             += PLAT/project/$(TARGET)/apps/qx_app/src/app.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/AppTaskUart.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/AppTaskCan.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/AppTaskGps.o \
-						PLAT/project/$(TARGET)/apps/qx_app/src/BCU.o \
+						PLAT/project/$(TARGET)/apps/qx_app/src/EmbeddedCoder_src/BCU.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/EmbeddedCoder_src/TMS.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/EmbeddedCoder_src/SFM.o \
 						PLAT/project/$(TARGET)/apps/qx_app/src/EmbeddedCoder_src/SPM.o \

inc/EmbeddedCoder_inc/BCUCal.h

@@ -1,6 +1,7 @@
 
 #include "rtwtypes.h"
-
+#define cmnc_num_cellUNumMax  28
+#define cmnc_num_modTNumMax  8
 extern const uint16_T blcc_R_esr;                          /* 均衡电阻 */
 extern const uint16_T blcc_T_close;                         /* 均衡暂停温度； */
 extern const uint16_T blcc_T_open;                          /* 均衡暂停恢复温度； */

inc/EmbeddedCoder_inc/BCUDisp.h

@@ -1,14 +1,15 @@
 
 #include "rtwtypes.h"
+#include "BCUCal.h"
 
 extern uint8_T tmsd_st_heatAct;                          /*热管理请求状态； */
-extern uint16_T appv_V_cellU[28];                        /* 静态电压 */
+extern uint16_T appv_V_cellU[cmnc_num_cellUNumMax];                        /* 静态电压 */
 extern boolean_T ihd_flg_HVILFlt;                        /* 保护板上传的高压互锁故障 */
-extern uint16_T blcv_Q_reqCpEi[28];                      /*均衡需求容量 读取量（数组）； */
-extern uint16_T blcv_Q_reqCpEo[28];                      /*均衡需求容量 写入量（数组）； */
-extern uint32_T blcv_Q_totalCpEi[28];                    /*累计均衡容量 读取量（数组）； */
-extern uint32_T blcv_Q_totalCpEo[28];                    /*累计均衡容量 写入量（数组）； */
-extern boolean_T blcv_flg_excute[28];                    /*均衡执行请求标志位 （数组）； */
+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_DTCClear;                       /* 上位机发送的故障清楚指令；*/
 extern uint8_T ihd_st_authFaild;                         /* 底层诊断的认证失败故障；*/
@@ -42,8 +43,8 @@ extern uint16_T ihd_pct_soc;                             /*保护板SOC */
 extern uint16_T ihd_pct_soh;                             /*保护板SOH */
 extern uint8_T ihd_st_workStat;                          /*电池工作状态 */
 extern uint16_T ihd_tm_parkTime;                         /*驻车时间； */
-extern uint16_T ihv_T_modT[6];                           /*模组温度（数组）+40 */
-extern uint16_T ihv_V_cellU[28];                         /*电池单体电压（数组）； */
+extern uint16_T ihv_T_modT[cmnc_num_modTNumMax];                           /*模组温度（数组）+40 */
+extern uint16_T ihv_V_cellU[cmnc_num_cellUNumMax];                         /*电池单体电压（数组）； */
 extern boolean_T ihd_st_chrgMosControl;    
 extern boolean_T ihd_st_disChrgMosControl; 
 extern boolean_T ihd_st_relayControl;    
@@ -62,8 +63,8 @@ extern boolean_T sfmd_flg_modTDisable;                   /*模组温度有效标
 extern uint16_T sfmd_num_fltNum;                         /*故障数量 */
 extern uint8_T sfmd_st_fltAct;                           /*故障禁止指令 */
 extern uint8_T sfmd_st_fltLevel;                         /*故障等级 */
-extern uint16_T sfmv_T_modT[6];                          /*处理后模组温度 */
-extern uint16_T sfmv_V_cellU[28];                        /*处理后单体电压 */
+extern uint16_T sfmv_T_modT[cmnc_num_modTNumMax];                          /*处理后模组温度 */
+extern uint16_T sfmv_V_cellU[cmnc_num_cellUNumMax];                        /*处理后单体电压 */
 extern uint16_T sfmv_idx_fltCode[20];                    /*诊断故障码（数组） */
 extern uint16_T sfmd_V_battU;                            /* 处理过后的总电压 */
 extern boolean_T sfmd_flg_mainCirClosFltEi;              /*主回路常闭故障读取量 */  
@@ -95,13 +96,13 @@ extern uint16_T sohd_pct_bcuSoh;                         /*电池SOH； */
 extern uint16_T sohd_pct_bcuSoh_Delay;                   /*电池SOH延时； */
 extern uint16_T sohd_tm_chrgStartStatEi;                 /*充电前静置时间读取量； */
 extern uint16_T sohd_tm_chrgStartStatEo;                 /*充电前静置时间写入量； */
-extern uint16_T sohv_Q_cellCap[28];                      /*单体容量 */
-extern uint16_T sohv_Q_cellCapArrEi[28];                 /*单体容量（数组） 读取量 */
-extern uint16_T sohv_Q_cellCapArrEo[28];                 /*单体容量（数组） 写入量 */
+extern uint16_T sohv_Q_cellCap[cmnc_num_cellUNumMax];                      /*单体容量 */
+extern uint16_T sohv_Q_cellCapArrEi[cmnc_num_cellUNumMax];                 /*单体容量（数组） 读取量 */
+extern uint16_T sohv_Q_cellCapArrEo[cmnc_num_cellUNumMax];                 /*单体容量（数组） 写入量 */
 extern uint16_T sohv_Q_packCapArrEi[10];                 /*10次整包容量（数组）读取量； */
 extern uint16_T sohv_Q_packCapArrEo[10];                 /*10次整包容量（数组）写入量； */
-extern uint16_T sohv_V_chrgStartStatEi[28];              /*充电开始时刻的单体电压（数组）读取量； */
-extern uint16_T sohv_V_chrgStartStatEo[28];              /*充电开始时刻的单体电压（数组）写入量； */
+extern uint16_T sohv_V_chrgStartStatEi[cmnc_num_cellUNumMax];              /*充电开始时刻的单体电压（数组）读取量； */
+extern uint16_T sohv_V_chrgStartStatEo[cmnc_num_cellUNumMax];              /*充电开始时刻的单体电压（数组）写入量； */
 
 extern uint8_T cmd_st_chrgMod;                           /* 充电模式  */
 extern uint8_T cmd_st_chrgSt;                            /* 充电状态  */

inc/EmbeddedCoder_inc/SOC.h

@@ -3,12 +3,9 @@
 #include "BCUCal.h"
 #include "BCUDisp.h"
 extern boolean_T FirstRun_SOC;
-
 extern void SOC_Init(void);
 extern void SOC(void);
-extern boolean_T FirstRun_SOC;
-
-
+//
 extern real_T docvmath(real_T soc );
 extern uint16_T SOC_LookUp(uint16_T battsoc, uint16_T x[3], uint16_T y[3]);
 extern uint16_T SOCfitSystem(uint16_T SOC,uint16_T *SOCfit, uint16_T m);

inc/EmbeddedCoder_inc/SOH.h

@@ -3,5 +3,6 @@
 extern boolean_T FirstRun_SOH;
 extern void SOH_Init(void);
 extern void SOH(void);
+//
 extern uint16_T  ArrMax(uint16_T *Data, uint16_T m);
 extern uint16_T  ArrMin(uint16_T *Data, uint16_T m);

src/BCU.c

@@ -1,194 +0,0 @@
-
-#include "BCU.h"
-
-static StaticTask_t gProcess_Bcu_Task_t;
-static UINT8 gProcess_Bcu_TaskStack[PROC_BCU_TASK_STACK_SIZE];
-static osThreadId_t BcuTaskId = NULL;
-static process_Bcu gProcess_Bcu_Task;
-#define PROC_BCU_STATE_SWITCH(a) (gProcess_Bcu_Task = a)
-
-//======================================================
-void BCU(void)
-{
-    uint16_T i;
-
-    UINT32 locateTimeCounter = 0;
-    osDelay(5000);
-    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)
-            {
-                //osDelay(100);
-                //if (locateTimeCounter != TimeCounter)
-                if (TimeCounter%10==0)
-                {
-                    printf("TimeCounter:%d\n",TimeCounter);
-                    //locateTimeCounter = TimeCounter;
-			
-                    if (gProcess_app == LISTEN)
-                    {
-                        PROC_BCU_STATE_SWITCH(PROCESS_STATE_SLEEP);
-                        break;
-                    }
-
-                    //=============================================================================
-                    if (BattWorkStateDelay == 0 && battI == 10000)
-                    {
-                        memcpy(appv_V_cellU, battCellU, sizeof(appv_V_cellU));
-                    }
-
-                    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_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_chrgMosControl    = ChargeForbiddenControl == 0;
-					ihd_st_disChrgMosControl = DisChargeForbiddenControl  == 0;
-				    ihd_st_relayControl      = RelayForbiddenControl  == 0;
-				    ihd_flg_DTCClear = ihd_flg_disChrgMosClosFlt;  /////
-
-                    //=============================================================================
-                    SFM();
-                    TMS();
-					//CM();
-
-					
-                    SPM();
-			
-                    //==============================shi shi cun chu=======
-                    if (socd_flg_EEsave == 1 || ihd_flg_DTCClear)
-                    {
-                        BCUEEDataSave();
-						ihd_flg_DTCClear = false;
-                    }
-                }
-                osDelay(100);
-            }
-            break;
-        }
-        //----------------------------------------------------------------------------------------------------
-        case PROCESS_STATE_SLEEP:
-        {
-            BCUEEDataSave();
-            //
-            ihd_tm_parkTime = 0;
-            while (TRUE)
-            {
-                osDelay(1000);
-                ihd_tm_parkTime++;
-                if (gProcess_app == WORK)
-                {
-                    PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
-                    break;
-                }
-            }
-            break;
-        }
-        default:
-        {
-            PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
-            break;
-        }
-        }
-    }
-}
-
-//=================================================================================
-void BCU_Init(void)
-{
-    SFM_Init();
-    TMS_Init();
-	//CM_Init();
-    SPM_Init();
-}
-
-//================================================================================
-void AppTaskBcuInit(void *arg)
-{
-    osThreadAttr_t task_attr;
-    memset(&task_attr, 0, sizeof(task_attr));
-    memset(gProcess_Bcu_TaskStack, 0xA5, PROC_BCU_TASK_STACK_SIZE);
-    task_attr.name = "Bcu_Task";
-    task_attr.stack_mem = gProcess_Bcu_TaskStack;
-    task_attr.stack_size = PROC_BCU_TASK_STACK_SIZE;
-    task_attr.priority = osPriorityBelowNormal7;
-    task_attr.cb_mem = &gProcess_Bcu_Task_t;
-    task_attr.cb_size = sizeof(StaticTask_t);
-    BcuTaskId = osThreadNew(BCU, NULL, &task_attr);
-}
-//=================================================================================
-void BCUEEDataSave(void)
-{
-    memcpy(BcuDataInfo.blcv_Q_totalCpE, blcv_Q_totalCpEo, sizeof(blcv_Q_totalCpEo));
-    memcpy(BcuDataInfo.blcv_Q_reqCpE, blcv_Q_reqCpEo, sizeof(blcv_Q_reqCpEo));
-    BcuDataInfo.socd_pct_bcuSocE = socd_pct_bcuSocEo;
-    BcuDataInfo.socd_pct_battSocE = socd_pct_battSocEo;
-    BcuDataInfo.sohd_tm_chrgStartStatE = sohd_tm_chrgStartStatEo;
-    BcuDataInfo.sohd_flg_chrgEndE = sohd_flg_chrgEndEo;
-    memcpy(BcuDataInfo.sohv_V_chrgStartStatE, sohv_V_chrgStartStatEo, sizeof(sohv_V_chrgStartStatEo));
-    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));
-    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.appDataModify = TRUE;
-}

src/EmbeddedCoder_src/BCU.c

@@ -0,0 +1,184 @@
+
+#include "BCU.h"
+
+static StaticTask_t gProcess_Bcu_Task_t;
+static UINT8 gProcess_Bcu_TaskStack[PROC_BCU_TASK_STACK_SIZE];
+static osThreadId_t BcuTaskId = NULL;
+static process_Bcu gProcess_Bcu_Task;
+#define PROC_BCU_STATE_SWITCH(a) (gProcess_Bcu_Task = a)
+
+//=========================================================================
+//=========================================================================
+//=========================================================================
+void BCU(void)
+{
+    uint16_T i;
+    osDelay(5000);
+    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)
+                {
+                    if (TimeCounter%10==0)
+                    {
+                        if (gProcess_app == LISTEN)
+                        {
+                            PROC_BCU_STATE_SWITCH(PROCESS_STATE_SLEEP);
+                            break;
+                        }
+                        //数据获取
+                        if (BattWorkStateDelay == 0 && battI == 10000)
+                        {
+                            memcpy(appv_V_cellU, battCellU, sizeof(appv_V_cellU));
+                        }
+                        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_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_chrgMosControl    = ChargeForbiddenControl == 0;
+                        ihd_st_disChrgMosControl = DisChargeForbiddenControl  == 0;
+                        ihd_st_relayControl      = RelayForbiddenControl  == 0;
+                        ihd_flg_DTCClear = ihd_flg_disChrgMosClosFlt;
+                        
+                        //调用算法
+                        SFM();
+                        TMS();
+                        CM();
+                        SPM();
+                        //实时存储
+                        if (socd_flg_EEsave == 1 || ihd_flg_DTCClear)
+                        {
+                            BCUEEDataSave();
+                            ihd_flg_DTCClear = false;
+                        }
+                    }
+                    osDelay(100);
+                }
+                break;
+            }
+            //======================休眠模式===============================
+            case PROCESS_STATE_SLEEP:
+            {
+                BCUEEDataSave();
+                ihd_tm_parkTime = 0;
+                while (TRUE)
+                {
+                    if (TimeCounter%10==0)
+                    {
+                        ihd_tm_parkTime++;
+                    }
+                    if (gProcess_app == WORK)
+                    {
+                        PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
+                        break;
+                    }
+                    osDelay(100);
+                }
+                break;
+            }
+            default:
+            {
+                PROC_BCU_STATE_SWITCH(PROCESS_STATE_INIT);
+                break;
+            }
+        }
+    }
+}
+
+//========================算法初始化========================================
+void BCU_Init(void)
+{
+    SFM_Init();
+    TMS_Init();
+    CM_Init();
+    SPM_Init();
+}
+
+//==========================主线程调用======================================
+void AppTaskBcuInit(void *arg)
+{
+    osThreadAttr_t task_attr;
+    memset(&task_attr, 0, sizeof(task_attr));
+    memset(gProcess_Bcu_TaskStack, 0xA5, PROC_BCU_TASK_STACK_SIZE);
+    task_attr.name = "Bcu_Task";
+    task_attr.stack_mem = gProcess_Bcu_TaskStack;
+    task_attr.stack_size = PROC_BCU_TASK_STACK_SIZE;
+    task_attr.priority = osPriorityBelowNormal7;
+    task_attr.cb_mem = &gProcess_Bcu_Task_t;
+    task_attr.cb_size = sizeof(StaticTask_t);
+    BcuTaskId = osThreadNew(BCU, NULL, &task_attr);
+}
+//=========================数据存储========================================
+void BCUEEDataSave(void)
+{
+    memcpy(BcuDataInfo.blcv_Q_totalCpE, blcv_Q_totalCpEo, sizeof(blcv_Q_totalCpEo));
+    memcpy(BcuDataInfo.blcv_Q_reqCpE, blcv_Q_reqCpEo, sizeof(blcv_Q_reqCpEo));
+    BcuDataInfo.socd_pct_bcuSocE = socd_pct_bcuSocEo;
+    BcuDataInfo.socd_pct_battSocE = socd_pct_battSocEo;
+    BcuDataInfo.sohd_tm_chrgStartStatE = sohd_tm_chrgStartStatEo;
+    BcuDataInfo.sohd_flg_chrgEndE = sohd_flg_chrgEndEo;
+    memcpy(BcuDataInfo.sohv_V_chrgStartStatE, sohv_V_chrgStartStatEo, sizeof(sohv_V_chrgStartStatEo));
+    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));
+    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.appDataModify = TRUE;
+}

src/EmbeddedCoder_src/BCUCal.c

@@ -83,8 +83,8 @@ const uint16_T sfmc_flg_cellUDiffThrFlt2 = 300U; /* 压差过大2级故障诊断
 const uint16_T sfmc_flg_cellUDiffThrRec1 = 250U; /* 压差过大1级故障恢复阈值 */
 const uint16_T sfmc_flg_cellUDiffThrRec2 = 250U; /* 压差过大2级故障恢复阈值 */
 
-const uint16_T sohc_Q_countThr = 60U;       /*                    */
-const uint16_T sohc_Q_updateDeltThr = 200U; /*                    */
+const uint16_T sohc_Q_countThr = 60U;            /*soh计算需充入电量阈值*/
+const uint16_T sohc_Q_updateDeltThr = 200U;      /*soh更新 偏差允许阈值*/
 
 const uint16_T socc_pct_battSocLow = 0U;                     /* SOC下限值； */
 const uint16_T socc_pct_battSocUp = 1000U;                   /* SOC上限值； */
@@ -92,8 +92,8 @@ const int16_T socm_I_chrgCor[3] = {50, 100, 150};            /* 充电CCV对应
 const int16_T socm_I_disChrgCor[3] = {-300, -100, -60};      /* 放电CCV对应的电流数据； */
 const uint16_T socm_V_chrgCor[3] = {4160U, 4175U, 4188U};    /* 充电CCV对应的电压； */
 const uint16_T socm_V_disChrgCor[3] = {3303U, 3359U, 3368U}; /* 放电CCV对应的电压； */
-const uint16_T socc_pct_chrgCor = 980;
-const uint16_T socc_pct_disChrgCor = 50;
+const uint16_T socc_pct_chrgCor = 980;                       /* 充电CCV对应的SOC； */   
+const uint16_T socc_pct_disChrgCor = 50;                     /* 放电CCV对应的SOC； */   
 const int16_T cmm_T_ChrgCurr[3] = {40,60,80};
 const int16_T cmm_V_ChrgCurr[6] = {3200,3201,3900,3901,4100,4101};
 const int16_T cmm_I_ChrgCurr[3][6] = {{0,100,100,100,100,50},{50,400,400,200,200,100},{40,300,300,150,150,80}};

src/EmbeddedCoder_src/BCUDisp.c

@@ -3,13 +3,13 @@
 #include "BCUDisp.h"
 
 uint8_T tmsd_st_heatAct;                          /*热管理请求状态； */
-uint16_T appv_V_cellU[28];
+uint16_T appv_V_cellU[cmnc_num_cellUNumMax];
 boolean_T ihd_flg_HVILFlt;
-uint16_T blcv_Q_reqCpEi[28];                      /*均衡需求容量 读取量（数组）； */
-uint16_T blcv_Q_reqCpEo[28];                      /*均衡需求容量 写入量（数组）； */
-uint32_T blcv_Q_totalCpEi[28];                    /*累计均衡容量 读取量（数组）； */
-uint32_T blcv_Q_totalCpEo[28];                    /*累计均衡容量 写入量（数组）； */
-boolean_T blcv_flg_excute[28];                    /*均衡执行请求标志位 （数组） */
+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_DTCClear;
 uint8_T ihd_st_authFaild;                         
@@ -43,13 +43,13 @@ uint16_T ihd_pct_soc;                             /*保护板SOC */
 uint16_T ihd_pct_soh;                             /*保护板SOH */
 uint8_T ihd_st_workStat;                          /*电池工作状态 */
 uint16_T ihd_tm_parkTime;                         /*驻车时间； */
-uint16_T ihv_T_modT[6];                           /*模组温度（数组）+40 */
-uint16_T ihv_V_cellU[28];                         /*电池单体电压（数组）； */
-boolean_T ihd_st_chrgMosControl;    
+uint16_T ihv_T_modT[cmnc_num_modTNumMax];                           /*模组温度（数组）+40 */
+uint16_T ihv_V_cellU[cmnc_num_cellUNumMax];                         /*电池单体电压（数组）； */
+boolean_T ihd_st_chrgMosControl;                  /* Mos控制指令 ;0-断开，1-导通*/
 boolean_T ihd_st_disChrgMosControl; 
 boolean_T ihd_st_relayControl;    
 uint8_T ihd_st_heatForceControl;             
-uint8_T ihd_st_EOLState;
+uint8_T ihd_st_EOLState;                   
 
 int16_T sfmd_I_curr;                              /*处理后整包电流 */
 uint16_T sfmd_T_modTMax;                          /*处理后模组温度最小 */
@@ -63,8 +63,8 @@ boolean_T sfmd_flg_modTDisable;                   /*模组温度有效标志位
 uint16_T sfmd_num_fltNum;                         /*故障数量 */
 uint8_T sfmd_st_fltAct;                           /*故障禁止指令 */
 uint8_T sfmd_st_fltLevel;                         /*故障等级 */
-uint16_T sfmv_T_modT[6];                          /*处理后模组温度 */
-uint16_T sfmv_V_cellU[28];                        /*处理后单体电压 */
+uint16_T sfmv_T_modT[cmnc_num_modTNumMax];                          /*处理后模组温度 */
+uint16_T sfmv_V_cellU[cmnc_num_cellUNumMax];                        /*处理后单体电压 */
 uint16_T sfmv_idx_fltCode[20];                    /*诊断故障码（数组） */
 uint16_T sfmd_V_battU;  
 boolean_T sfmd_flg_mainCirClosFltEi;              /*主回路常闭故障读取量 */  
@@ -75,6 +75,7 @@ boolean_T sfmd_flg_heatCirOpenFltEi;              /*加热回路常开故障读
 boolean_T sfmd_flg_heatCirOpenFltEo;              /*加热回路常开故障写入量 */  
 boolean_T sfmd_flg_heatRunFltEi;
 boolean_T sfmd_flg_heatRunFltEo;
+
 uint16_T socd_pct_ahSoc;                          /*安时SOC； */
 uint16_T socd_pct_estSoc;                         /*估算SOC；*/
 uint16_T socd_flg_EEsave;                         /*实时存储标志位；*/
@@ -95,13 +96,13 @@ uint16_T sohd_pct_bcuSoh;                         /*电池SOH； */
 uint16_T sohd_pct_bcuSoh_Delay;                   /*电池SOH延时； */
 uint16_T sohd_tm_chrgStartStatEi;                 /*充电前静置时间读取量； */
 uint16_T sohd_tm_chrgStartStatEo;                 /*充电前静置时间写入量； */
-uint16_T sohv_Q_cellCap[28];                      /*单体容量 */
-uint16_T sohv_Q_cellCapArrEi[28];                 /*单体容量（数组） 读取量 */
-uint16_T sohv_Q_cellCapArrEo[28];                 /*单体容量（数组） 写入量 */
+uint16_T sohv_Q_cellCap[cmnc_num_cellUNumMax];                      /*单体容量 */
+uint16_T sohv_Q_cellCapArrEi[cmnc_num_cellUNumMax];                 /*单体容量（数组） 读取量 */
+uint16_T sohv_Q_cellCapArrEo[cmnc_num_cellUNumMax];                 /*单体容量（数组） 写入量 */
 uint16_T sohv_Q_packCapArrEi[10];                 /*10次整包容量（数组）读取量； */
 uint16_T sohv_Q_packCapArrEo[10];                 /*10次整包容量（数组）写入量； */
-uint16_T sohv_V_chrgStartStatEi[28];              /*充电开始时刻的单体电压（数组）读取量； */
-uint16_T sohv_V_chrgStartStatEo[28];              /*充电开始时刻的单体电压（数组）写入量； */
+uint16_T sohv_V_chrgStartStatEi[cmnc_num_cellUNumMax];              /*充电开始时刻的单体电压（数组）读取量； */
+uint16_T sohv_V_chrgStartStatEo[cmnc_num_cellUNumMax];              /*充电开始时刻的单体电压（数组）写入量； */
 
 uint8_T cmd_st_chrgMod;                           /* 充电模式  */
 uint8_T cmd_st_chrgSt;                            /* 充电状态  */

src/EmbeddedCoder_src/BLC.c

@@ -12,26 +12,26 @@ void BLC_Init(void)
 void BLC(void)
 {   
     uint16_T i;
-    static uint16_T blcn_Q_reqCpEE[28];
-    static uint32_T blcn_Q_totalCpEE[28];
+    static uint16_T blcn_Q_reqCpEE[cmnc_num_cellUNumMax];
+    static uint32_T blcn_Q_totalCpEE[cmnc_num_cellUNumMax];
     uint16_T MaxCp;
     
     static boolean_T blcn_flg_judge;
     boolean_T blcn_flg_enable;
 
     
-    uint16_T blcn_pct_cellSoc[28];
+    uint16_T blcn_pct_cellSoc[cmnc_num_cellUNumMax];
     uint16_T blcn_pct_cellSocMin;
-    static uint16_T blcn_Q_reqCpNow[28];
+    static uint16_T blcn_Q_reqCpNow[cmnc_num_cellUNumMax];
     real_T Qmin;
     real_T QL;
     real_T reqCp;
     
-    static uint16_T blcn_Q_reqCpEo_Delay[28];
-    boolean_T blcn_flg_stop[28];
-	boolean_T blcn_flg_pause[28];
-    static real_T temp[28];
-    uint16_T blcn_Q_impleCp[28];
+    static uint16_T blcn_Q_reqCpEo_Delay[cmnc_num_cellUNumMax];
+    boolean_T blcn_flg_stop[cmnc_num_cellUNumMax];
+	boolean_T blcn_flg_pause[cmnc_num_cellUNumMax];
+    static real_T temp[cmnc_num_cellUNumMax];
+    uint16_T blcn_Q_impleCp[cmnc_num_cellUNumMax];
 
 	if(FirstRun_BLC)
 	{

src/EmbeddedCoder_src/SFM.c

@@ -28,30 +28,30 @@ void SFM(void)
     static uint16_T SumT2;
     
     static uint8_T  Cntl;
-    static uint16_T CellUArry[4][28];
-    static uint8_T  ErrNr[28];
-    static uint8_T  RecNr[28];
-    static boolean_T sfmv_flg_cellUOpenFlt[28];
-    static boolean_T ErrUFlg[28];
+    static uint16_T CellUArry[4][cmnc_num_cellUNumMax];
+    static uint8_T  ErrNr[cmnc_num_cellUNumMax];
+    static uint8_T  RecNr[cmnc_num_cellUNumMax];
+    static boolean_T sfmv_flg_cellUOpenFlt[cmnc_num_cellUNumMax];
+    static boolean_T ErrUFlg[cmnc_num_cellUNumMax];
     uint32_T  SumU ;
     uint16_T  UNum ;
     boolean_T sfmd_flg_volFlt;
     boolean_T Enable1;
 	boolean_T Enable2;
 	
-    static uint8_T modTOpenNr[6];
-    static uint8_T modTRationNr[6];
+    static uint8_T modTOpenNr[cmnc_num_modTNumMax];
+    static uint8_T modTRationNr[cmnc_num_modTNumMax];
     boolean_T sfmd_flg_modTOpenFlt;
-    boolean_T sfmv_flg_modTOpenFlt[6];
+    boolean_T sfmv_flg_modTOpenFlt[cmnc_num_modTNumMax];
     boolean_T sfmd_flg_chrgMosTOpenFlt;
     boolean_T sfmd_flg_DCPlugTOpenFlt;
     boolean_T sfmd_flg_ACPlugTOpenFlt;
     static boolean_T sfmd_flg_heatPanT1OpenFlt;
     static boolean_T sfmd_flg_heatPanT2OpenFlt;
     boolean_T sfmd_flg_modTRationFlt;
-    boolean_T sfmv_flg_modTRationFlt[6];
+    boolean_T sfmv_flg_modTRationFlt[cmnc_num_modTNumMax];
     
-    static uint16_T modTArr[6];
+    static uint16_T modTArr[cmnc_num_modTNumMax];
     uint16_T Tnum;
     uint32_T SumT;
     boolean_T sfmd_flg_chrgMosTRationFlt;
@@ -135,7 +135,7 @@ void SFM(void)
     static boolean_T sfmd_flg_heatclear;
     static boolean_T sfmd_flg_volFlt_keep;
     static uint16_T CntA;
-    static uint16_T ModTStor[4][6];
+    static uint16_T ModTStor[4][cmnc_num_modTNumMax];
     static boolean_T sfmd_flg_Tup;
     static boolean_T sfmd_flg_modTOpenFlt_keep;
     static uint16_T CntB;

src/EmbeddedCoder_src/SOH.c

@@ -1,7 +1,6 @@
 #include "SOH.h"
 #include "look1_iu16lu16n16tu16_binlcase.h"
 
-
 boolean_T FirstRun_SOH;
 
 void SOH_Init(void)
@@ -16,26 +15,26 @@ void SOH(void)
     uint16_T cellCapArr_Max;
     uint16_T packCapArr_Min;
     uint16_T packCapArr_Max;
-    static uint16_T sohn_V_chrgStartStatEE[28];
-    static uint16_T sohn_Q_cellCapArrEE[28];
+    static uint16_T sohn_V_chrgStartStatEE[cmnc_num_cellUNumMax];
+    static uint16_T sohn_Q_cellCapArrEE[cmnc_num_cellUNumMax];
     static uint16_T sohn_Q_packCapArrEE[10];
     static uint16_T sohn_Q_chrgEE;
     static uint16_T sohn_tm_chrgStartStatEE;
     static uint16_T sohn_flg_chrgEndEE;
     //
     boolean_T sohn_flg_countEn;
-    uint16_T soc1[28];
-    uint16_T soc2[28];
-    uint16_T deltSoc[28];
-    uint16_T temp[28];
-    uint16_T chrgCellCapArr[28];
-    uint16_T disChrgCellCapArr[28];
+    uint16_T soc1[cmnc_num_cellUNumMax];
+    uint16_T soc2[cmnc_num_cellUNumMax];
+    uint16_T deltSoc[cmnc_num_cellUNumMax];
+    uint16_T temp[cmnc_num_cellUNumMax];
+    uint16_T chrgCellCapArr[cmnc_num_cellUNumMax];
+    uint16_T disChrgCellCapArr[cmnc_num_cellUNumMax];
     boolean_T sohn_flg_update;
     uint16_T chrgCap_Min;
     uint16_T disChrgCap_Min;
     uint16_T SumQ;
     //
-    static uint16_T sohn_V_chrgStartStat[28];
+    static uint16_T sohn_V_chrgStartStat[cmnc_num_cellUNumMax];
     static uint8_T ihd_st_workStat_Delay;
     static boolean_T sohn_flg_chrgEnd_Delay;
     boolean_T sohn_flg_chrgEnd;

src/EmbeddedCoder_src/SPM.c

@@ -1,6 +1,5 @@
 #include "SPM.h"
 
-
 boolean_T FirstRun_SPM;
 
 void SPM_Init(void)
@@ -11,10 +10,8 @@ void SPM_Init(void)
   FirstRun_SPM = true;
 }
 
-
 void SPM(void)
 {
-
   static uint16_T spmd_Nr_cellNr;
   uint8_T Feq = 10;
   if (FirstRun_SPM)
@@ -35,15 +32,14 @@ void SPM(void)
   {
     cand_Nr_cellNr = 1;
   }
-
+  //调用SOX算法
   SOH();
   BLC();
   if (!ihd_flg_urtRecFlt || sfmd_V_cellUMax == 0)
   {
       SOC();
   }
-
-  
+  // 循环发送数组
   cand_Q_cellCap = sohv_Q_cellCapArrEo[cand_Nr_cellNr-1];
   cand_V_chrgStartStat = sohv_V_chrgStartStatEo[cand_Nr_cellNr-1];
   cand_Q_reqCp   = blcv_Q_reqCpEo[cand_Nr_cellNr-1];

src/EmbeddedCoder_src/TMS.c

@@ -1,12 +1,4 @@
-/*
- * @Author       : ChenJie
- * @Date         : 2021-10-19 10:17:10
- * @Version      : V3.0
- * @LastEditors  : ChenJie
- * @LastEditTime : 2021-10-19 12:09:12
- * @Description  : file content
- * @FilePath     : \PLAT\project\ec616_0h00\apps\qx_app\src\EmbeddedCoder_src\TMS.c
- */
+
 #include "TMS.h"
 
 boolean_T FirstRun_TMS;
@@ -20,7 +12,7 @@ void TMS(void)
     static uint8_T TminLowNr;
     static uint8_T TminOverNr;
     static uint8_T TmaxOverNr;
-
+    
     //初始值
     if (FirstRun_TMS)
     {
@@ -29,7 +21,7 @@ void TMS(void)
         TminOverNr = 0;
         TmaxOverNr = 0;
     }
-
+    
     //
     if (sfmd_T_modTMin < tmsc_T_openThr)
     {
@@ -57,29 +49,29 @@ void TMS(void)
     {
         TmaxOverNr = 0;
     }
-
+    
     //================================温度判定 开关热管理状态===============================
     if (tmsd_st_heatAct == 0)
     {
-        if (TminLowNr >= 20 && ((ihd_st_chrgConnect == 0 && socd_pct_battSoc > 100) || ihd_st_chrgConnect == 1))
+        if (TminLowNr >= 5 && ( socd_pct_battSoc > 100 || ihd_st_chrgConnect == 1))
         {
             tmsd_st_heatAct = 1;
         }
     }
     else
     {
-        if (TmaxOverNr >= 20 || TminOverNr >= 20 || (ihd_st_chrgConnect == 0 && socd_pct_battSoc < 50))
+        if (TmaxOverNr >= 5 || TminOverNr >= 5 || (ihd_st_chrgConnect == 0 && socd_pct_battSoc < 50))
         {
             tmsd_st_heatAct = 0;
         }
     }
-
+    
     //因故障关闭热管理
     if (((sfmd_st_fltAct >> 4) & 0x01) == 1)
     {
         tmsd_st_heatAct = 0;
     }
-
+    
     //强制控制加热回路
     if (ihd_st_heatForceControl == 1)
     {
@@ -89,7 +81,6 @@ void TMS(void)
     {
         tmsd_st_heatAct = 0;
     }
-
+    
     FirstRun_TMS = false;
-    //printf("TminLowNr:%d,TmaxOverNr:%d,TminOverNr:%d,ihd_st_chrgConnect:%d,socd_pct_battSoc:%d,sfmd_st_fltAct:%d,HeatForceControl:%d,tmsd_st_heatAct:%d\n",TminLowNr,TmaxOverNr,TminOverNr,ihd_st_chrgConnect,socd_pct_battSoc,sfmd_st_fltAct,HeatForceControl,tmsd_st_heatAct);
-}
+}