UART读取完成，编译通过。

inc/AppFunc.h

@@ -28,6 +28,10 @@ typedef struct _Fota_Type
 
 }Fota_Type;
 
+BOOL uartBattInfoDecode(UINT8* dataPtr);
+static UINT8 BmsErrorDecode(UINT32 battWarningState);
+UINT16 GetErrorNum(UINT16 *ErrorArray,UINT8 Errorlen);
+UINT8 PutErrorNum(UINT16 *ErrorArray,UINT8 Errorlen,UINT16 ErrorNum);
 
 void SaveAppData(void);
 void LoadAppData(void);

inc/AppSignal.h

@@ -49,7 +49,8 @@ extern UINT8    TcpSendLen;
 extern UINT8    CanMsgEnble;
 extern UINT8 	UDSSwitch;
 extern UINT8 	UDSSwitch ;
-extern UINT8 	PosFlag ;      
+extern UINT8 	PosFlag ;     
+extern UINT8    UartRecvFlag ;
 //declear the UINT16 vars
 extern UINT16	battCellU[28];
 extern UINT16	minCellVol;

src/AppFunc.c

@@ -7,13 +7,344 @@
  *
  ****************************************************************************/
 #include "AppFunc.h"
+#include "numeric.h"
 
-/*******
+/***********************************************************************************************************************
+ * Uart数据解码函数
+ * 输入：数据指针
+ * 输出：状态
+ * 处理：将uart数据进行解码，按照协议进行解码
+***********************************************************************************************************************/
+BOOL uartBattInfoDecode(UINT8* dataPtr)
+{
+	UINT8 	i = 0,temp=0;
+	INT8 	BattCurrentNegFlag = 1;
+    UINT8 	TEMP_NUM = 0;
+    UINT16 	Batt_current;
+	UINT8 	BATT_CELL_VOL_NUM = 0,BATT_TEMP_NUM = 0;
+	BATT_CELL_VOL_NUM =  (dataPtr[(0x00)*2] << 8) | (dataPtr[(0x00)*2 + 1]);
+	BATT_TEMP_NUM = (dataPtr[(0x01)*2] << 8) | (dataPtr[(0x01)*2 + 1])-BMS_OTHER_TEMP;
+	if(AppNVMData.BattCellCount!=BATT_CELL_VOL_NUM || AppNVMData.BattTempCount!=BATT_TEMP_NUM )
+	{
+		AppNVMData.appDataModify = TRUE;
+		AppNVMData.BattCellCount = BATT_CELL_VOL_NUM;
+		AppNVMData.BattTempCount = BATT_TEMP_NUM;
+	}
+    for(i=0;i<BATT_CELL_VOL_NUM;i++)
+    {
+		battCellU[i] = (dataPtr[(0x02+i)*2] << 8) | dataPtr[(0x02+i)*2 + 1];
+    }
+    battWorkState = (dataPtr[(0x03+BATT_CELL_VOL_NUM)*2+1])&0x03;//电池状态(原始数据)，0表示静置，1表示放电，2表示充电
+    TEMP_NUM = BATT_TEMP_NUM + BMS_OTHER_TEMP;
+    for(i=0; i<BATT_TEMP_NUM; i++)
+    {
+	    battCellTemp[i] = dataPtr[(0x06+BATT_CELL_VOL_NUM+i)*2+1];
+    }
+    MOSTemp = dataPtr[(0x06+BATT_CELL_VOL_NUM+BATT_TEMP_NUM)*2+1];
+   	packTemp = dataPtr[(0x06+BATT_CELL_VOL_NUM+BATT_TEMP_NUM+1)*2+1];
+    
+    Batt_current = (dataPtr[(0x02+BATT_CELL_VOL_NUM)*2]<<8)|(dataPtr[(0x02+BATT_CELL_VOL_NUM)*2+1]);
+    //原始数据：充电为负，放电为正
+	if(battWorkState == 0x02) //充电过程
+	{
+		if(Batt_current >0x8000)// 数据为负
+		{			
+			//求补码，结果为负
+			Batt_current = (UINT16)((UINT16)(~(Batt_current))+1);
+        	Batt_current = Batt_current/10;
+			BattCurrentNegFlag = -1;
+		}
+		else
+		{
+			//源码，结果为负
+			Batt_current = Batt_current/10;
+			BattCurrentNegFlag = -1;
+		}
+	}
+	else //放电过程
+	{
+		if(Batt_current >0x8000)// 数据为负
+		{
+			//求补码，结果为正
+			Batt_current = (UINT16)((UINT16)(~(Batt_current))+1);
+        	Batt_current = Batt_current/10;
+			BattCurrentNegFlag = 1;
+		}
+		else
+		{
+			//源码，结果为正
+			Batt_current = Batt_current/10;
+			BattCurrentNegFlag = 1;
+		}
+	}
+
+	battI = Batt_current*BattCurrentNegFlag + 0x2710;
+    //bit0 ~ bit31 represent cell0 ~ cell31
+    battBalanceoInfo  = dataPtr[(0x06+BATT_CELL_VOL_NUM+TEMP_NUM)*2+1] | (dataPtr[(0x06+BATT_CELL_VOL_NUM+TEMP_NUM)*2] <<8) + (dataPtr[(0x07+BATT_CELL_VOL_NUM+TEMP_NUM)*2+1]<<16) | (dataPtr[(0x07+BATT_CELL_VOL_NUM+TEMP_NUM)*2] <<24);
+
+    bmsHwVersion = dataPtr[(0x08+BATT_CELL_VOL_NUM+TEMP_NUM)*2+1]; 
+    bmsSwVersion = dataPtr[(0x08+BATT_CELL_VOL_NUM+TEMP_NUM)*2];    
+
+    temp = ((dataPtr[(0x09+BATT_CELL_VOL_NUM+TEMP_NUM)*2+1])>>1)&0x03;    
+    battMOSSwitchState = ((temp&0x01)<<1)|((temp&0x02)>>1);	
+    if(AppDataInfo.BattLock==TRUE)
+    {
+        battMOSSwitchState = battMOSSwitchState |(0x01<<2);
+    }
+    else
+    {
+        battMOSSwitchState = battMOSSwitchState |(0x00<<2);
+    }
+	battWarningState = (dataPtr[(0x09+BATT_CELL_VOL_NUM+TEMP_NUM)*2+0]<<16) | (dataPtr[(0x0A+BATT_CELL_VOL_NUM+TEMP_NUM)*2+0] << 8) |(dataPtr[(0x0A+BATT_CELL_VOL_NUM+TEMP_NUM)*2+1]);
+    battSOC = dataPtr[(0x0B+BATT_CELL_VOL_NUM+TEMP_NUM)*2+1];
+    battSOH = dataPtr[(0x0C+BATT_CELL_VOL_NUM+TEMP_NUM)*2+1];
+	Battdesigncap = (dataPtr[(0x0E+BATT_CELL_VOL_NUM+TEMP_NUM)*2])<<24|(dataPtr[(0x0E+BATT_CELL_VOL_NUM+TEMP_NUM)*2+1])<<16|(dataPtr[(0x0F+BATT_CELL_VOL_NUM+TEMP_NUM)*2])<<8|(dataPtr[(0x0F+BATT_CELL_VOL_NUM+TEMP_NUM)*2+1]);
+	battPackVol =((dataPtr[(0x18+BATT_CELL_VOL_NUM+TEMP_NUM)*2])<<8|(dataPtr[(0x18+BATT_CELL_VOL_NUM+TEMP_NUM)*2+1]))/10;  //uint 100mV
+	maxCellVol = (dataPtr[(0x19+BATT_CELL_VOL_NUM+TEMP_NUM)*2] << 8) | dataPtr[(0x19+BATT_CELL_VOL_NUM+TEMP_NUM)*2 + 1];
+	minCellVol = (dataPtr[(0x1A+BATT_CELL_VOL_NUM+TEMP_NUM)*2] << 8) | dataPtr[(0x1A+BATT_CELL_VOL_NUM+TEMP_NUM)*2 + 1];
+    battHeatEnableState = dataPtr[(0x1C+BATT_CELL_VOL_NUM+TEMP_NUM)*2+1]&0x01;
+
+	maxCellTemp = 0x00;
+	minCellTemp = 0xFF;
+	for(i=0;i<BATT_TEMP_NUM;i++)
+	{
+		maxCellTemp = max(maxCellTemp,battCellTemp[i]);
+		minCellTemp = min(minCellTemp,battCellTemp[i]);		
+	}
+	nbSwVersion = APPSWVERSION;
+	nbHwVersion = HWVERSION;
+	BmsErrorDecode(battWarningState);
+    return true;
+}
+/***********************************************************************************************************************
+ * BMS故障解码函数
+ * 输入：BMS故障编码
+ * 输出：状态参数
+ * 处理：将BMS故障编码依次解为标准故障码
+***********************************************************************************************************************/
+static UINT8 BmsErrorDecode(UINT32 battWarningState)
+{
+	UINT16 ErrorNumTemp;
+	UINT8 ret;
+	if(battWarningState==0)
+	{
+		return 0;
+	}
+	else
+	{
+		if(osOK==osMutexAcquire(Error_Mutex, 100))
+		{
+			ret = ((battWarningState) & 0x01) == 1 ;
+			if (ret)
+			{
+				ErrorNumTemp = 7;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在电芯过放告警故障！！\n";单体电压过低
+			}
+
+			ret = ((battWarningState >> 1) & 0x01) == 1 ;
+			if (ret)
+			{
+				ErrorNumTemp = 10;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在总电压过放告警故障！！\n";总电压过低
+			}
+
+			ret = ((battWarningState >> 2) & 0x01) == 1 ;
+			if (ret)
+			{
+				ErrorNumTemp = 8;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在电芯过压告警故障！！\n";
+			}
+
+			ret = ((battWarningState >> 3) & 0x01) == 1 ;
+			if (ret)
+			{
+				ErrorNumTemp = 11;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在总电压过压告警故障！！\n";
+			}
+
+			ret = ((battWarningState >> 4) & 0x01) == 1 ;
+			if (ret)
+			{
+				ErrorNumTemp = 12;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在放电过流告警故障！！\n";
+			}
+
+			ret = ((battWarningState >> 5) & 0x01) == 1 ;
+			if (ret)
+			{
+				ErrorNumTemp = 13;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在充电过流告警故障！！\n";
+			}
+
+			ret = ((battWarningState >> 6) & 0x01) == 1 ;
+			if (ret)
+			{
+				ErrorNumTemp = 2;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在放电过温告警故障！！\n";
+			}
+
+			ret = ((battWarningState >> 7) & 0x01) == 1 ;
+			if (ret)
+			{
+				ErrorNumTemp = 2;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在充电过温告警故障！！\n";
+			}
+
+			ret = ((battWarningState >> 8) & 0x01) == 1 ;
+			if (ret)
+			{
+				//str += "ERROR：存在环境高温告警故障！！\n";
+			}
+
+			ret = ((battWarningState >> 9) & 0x01) == 1 ;
+			if (ret)
+			{
+				//str += "ERROR：存在环境低温告警故障！！\n";
+			}
+
+			ret = ((battWarningState >> 10) & 0x01) == 1 ;
+			if (ret)
+			{
+				ErrorNumTemp = 27;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在battSOC低告警故障！！\n";
+			}
+
+			ret = ((battWarningState >> 11) & 0x01) == 1 ;
+			if (ret)
+			{
+				ErrorNumTemp = 3;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在MOS高温告警故障！！\n";
+			}
+
+			ret = ((battWarningState >> 16) & 0x01) == 1;
+			if (ret)
+			{
+				ErrorNumTemp = 18;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在温度采集失效/传感器故障！！\n";
+			}
+
+			ret = ((battWarningState >> 17) & 0x01) == 1;
+			if (ret)
+			{
+				ErrorNumTemp = 19;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在电压采集失效/断线故障！！\n";
+			}
+
+			ret = ((battWarningState >> 18) & 0x01) == 1;
+			if (ret)
+			{
+				ErrorNumTemp = 17;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在放电MOS失效故障！！\n";
+			}
+
+			ret = ((battWarningState >> 19) & 0x01) == 1;
+			if (ret)
+			{
+				ErrorNumTemp = 16;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在充电MOS失效故障！！\n";
+			}
+
+			ret = ((battWarningState >> 20) & 0x01) == 1;
+			if (ret)
+			{
+				ErrorNumTemp = 22;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在电芯不均衡告警！！\n";
+			}
+
+			ret = ((battWarningState >> 22) & 0x01) == 1;
+			if (ret)
+			{
+				ErrorNumTemp = 1;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在放电低温告警故障！！\n";
+			}
+
+			ret = ((battWarningState >> 23) & 0x01) == 1 ;
+			if (ret)
+			{
+				ErrorNumTemp = 1;
+				PutErrorNum((UINT16 *)ErrorNum,sizeof(ErrorNum),ErrorNumTemp);
+				//str += "ERROR：存在充电低温告警故障！！\n";
+			}
+		}
+		else
+		{
+			#ifdef USING_PRINTF
+				printf("get Muxtex error\n");
+			#endif
+		}
+		osMutexRelease(Error_Mutex);
+	}
+	return 1;
+}
+/***********************************************************************************************************************
+ * 获取故障码函数
+ * 输入：故障数组和长度
+ * 输出：故障代码
+ * 处理：从故障数组中获取故障码，并将之前的故障码向前移动
+***********************************************************************************************************************/
+UINT16 GetErrorNum(UINT16 *ErrorArray,UINT8 Errorlen)
+{
+	UINT16 OutNum;
+	OutNum = *(ErrorArray);
+	for(UINT8 i=0;i<Errorlen-1;i++)
+	{
+		*(ErrorArray+i) = *(ErrorArray+i+1);
+		if(*(ErrorArray+i+1)==0)
+			break;
+	}
+	return OutNum;
+}
+/***********************************************************************************************************************
+ * 故障码注入函数
+ * 输入：故障数组，故障长度，故障码
+ * 输出：状态
+ * 处理：将故障码写入到故障数组中，如果存在则不写入，如果存在则不写入
+***********************************************************************************************************************/
+UINT8 PutErrorNum(UINT16 *ErrorArray,UINT8 Errorlen,UINT16 ErrorNum)
+{
+	for(UINT8 i=0;i<Errorlen;i++)
+	{
+		if(*(ErrorArray+i)==0)
+		{
+			*(ErrorArray+i) = ErrorNum;
+			return 0;
+		}
+		else
+		{
+			if(*(ErrorArray+i)==ErrorNum)
+			{
+				return 1;
+			}
+			else
+			{
+				continue;
+			}
+		}
+	}
+	return 2;
+}
+/***********************************************************************************************************************
  * 运行数据保存函数
  * 输入：空
  * 输出：空
  * 处理：将运行数据进行保存
-*******/
+***********************************************************************************************************************/
 void SaveAppData(void)
 {
     OSAFILE fp = PNULL;
@@ -60,12 +391,12 @@ void SaveAppData(void)
     OsaFclose(fp);
     return;
 }
-/*******
+/***********************************************************************************************************************
  * 运行数据加载函数
  * 输入：空
  * 输出：空
  * 处理：将运行数据进行加载，若新增了数据项，则保持前面数据项不动
-*******/
+***********************************************************************************************************************/
 void LoadAppData(void)
 {
     OSAFILE fp = PNULL;
@@ -131,12 +462,12 @@ void LoadAppData(void)
     OsaFclose(fp);
     return;
 }
-/*******
+/***********************************************************************************************************************
  * 配置文件保存函数
  * 输入：空
  * 输出：空
  * 处理：将全局配置文件进行保存
-*******/
+***********************************************************************************************************************/
 void SaveAppConfig(void)
 {
     OSAFILE fp = PNULL;
@@ -189,12 +520,12 @@ void SaveAppConfig(void)
     OsaFclose(fp);
     return;
 }
-/*******
+/***********************************************************************************************************************
  * 配置文件加载函数
  * 输入：空
  * 输出：空
  * 处理：将全局配置文件进行加载
-*******/
+***********************************************************************************************************************/
 void LoadAppConfig(void)
 {
     OSAFILE fp = PNULL;
@@ -275,13 +606,13 @@ void LoadAppConfig(void)
     OsaFclose(fp);
     return;
 }
-/*******
+/***********************************************************************************************************************
  * 配置文件初始化函数
  * 输入：空
  * 输出：空
  * 处理：将全局配置文件进行初始化
  * 注意：配置数据不增加数据项，若增加数据项，需要修改加载函数
-*******/
+***********************************************************************************************************************/
 static void setDefaultAppConfigData(void)
 {
     UINT8  i = 0;
@@ -294,13 +625,13 @@ static void setDefaultAppConfigData(void)
 	AppNVMData.BattTempCount = 5;//默认5个温度
     return;
 }
-/*******
+/***********************************************************************************************************************
  * 运行数据初始化函数
  * 输入：空
  * 输出：空
  * 处理：将运行数据进行初始化
  * 注：每增加一项数据项，需要增加默认值
-*******/
+***********************************************************************************************************************/
 static void setDefaultAppDataInfo(void)
 {
     memset(&AppDataInfo, 0x00, sizeof(AppDataInfo));
@@ -318,12 +649,12 @@ static void setDefaultAppDataInfo(void)
 	AppDataInfo.BattStolenFlag = 0;
     return;
 }
-/*******
- * Fota升级处理函数
- * 输入：网络接收的数据，网络链接ID
- * 输出：0x00表示数据未准备完成，0x01表示数据模块OTA数据准备完成，0x88表示BMS的OTA数据准备完成
- * 处理：将接收的数据进行校验，搬运至升级区域，并进行应答
-*******/
+/***********************************************************************************************************************
+ * 认证加密函数
+ * 输入：明文
+ * 输出：密文
+ * 处理：将明文加密为译文
+***********************************************************************************************************************/
 UINT16  encryptionAlgorithm (UINT16 plainText)
 {
 	UINT16 cipherText = 1; 
@@ -341,6 +672,12 @@ UINT16  encryptionAlgorithm (UINT16 plainText)
 	}
 	return cipherText;
 }
+/***********************************************************************************************************************
+ * 认证解密函数
+ * 输入：密文
+ * 输出：明文
+ * 处理：将明文解密为译文
+***********************************************************************************************************************/
 // UINT8  decryptionAlgorithm (UINT16 cipherText)
 // {
 // 	UINT16 plainText = 1;	
@@ -358,3 +695,9 @@ UINT16  encryptionAlgorithm (UINT16 plainText)
 // 	}
 // 	return (UINT8)plainText;
 // }
+/***********************************************************************************************************************
+ * Fota升级处理函数
+ * 输入：网络接收的数据，网络链接ID
+ * 输出：0x00表示数据未准备完成，0x01表示数据模块OTA数据准备完成，0x88表示BMS的OTA数据准备完成
+ * 处理：将接收的数据进行校验，搬运至升级区域，并进行应答
+***********************************************************************************************************************/

src/AppSignal.c

@@ -47,6 +47,7 @@ UINT8 	TcpSendLen = 0;             //Tcp send status Tcp发送状态
 UINT8   CanMsgEnble = 0;            //Can send status Can中断状态
 UINT8 	UDSSwitch = 0;              //下线检测标志位
 UINT8 	PosFlag = 0;                //定位信息是否有效标志位
+UINT8   UartRecvFlag = 0;           //Uart收到消息标志位0表示未收到，1表示收到
 /**declear the uint16 vars**/
 UINT16	battCellU[28] = {0xFFFF};    //电池包单体电压
 UINT16	minCellVol = 0xFFFF;    //最小单体电压

src/AppTaskCan.c

@@ -36,12 +36,14 @@ void AppTaskCanInit(void* arg)
 
 static void Can_Receive()
 {    
+	PROC_CAN_STATE_SWITCH(PROCESS_CAN_STATE_IDLE);
     while(true)
     {	
 		switch(gProcess_CAN_Task)
 		{
 			case PROCESS_CAN_STATE_IDLE:
 			{
+				osDelay(100);
 				break;				
 			}
 			case PROCESS_CAN_STATE_WORK:

src/AppTaskMain.c

@@ -19,6 +19,8 @@ static volatile BOOL SleepTimerEnd = FALSE;
 void monitor_timer_callback(TimerHandle_t xTimer);
 void work_timer_callback(TimerHandle_t xTimer);
 void sleep_timer_callback(TimerHandle_t xTimer);
+
+UINT8 MainSlpHandler          = 0xff;//主线程睡眠句柄
 static void MainTask(void* arg)
 {
     
@@ -26,22 +28,24 @@ static void MainTask(void* arg)
     TimerHandle_t work_timer = NULL;
     TimerHandle_t sleep_timer = NULL;
     monitor_timer = xTimerCreate("monitor_timer", 100 / portTICK_RATE_MS, pdTRUE, NULL, monitor_timer_callback);
-    work_timer    = xTimerCreate("work_timer", 5*60*1000 / portTICK_RATE_MS, pdTRUE, NULL, work_timer_callback);
-    sleep_timer   = xTimerCreate("sleep_timer", 60*60*1000 / portTICK_RATE_MS, pdTRUE, NULL, sleep_timer_callback);
-    NetSocDisplay(LED_SOC_0,LED_TURN_OFF);
-	NetSocDisplay(LED_SOC_1,LED_TURN_OFF);
-	NetSocDisplay(LED_SOC_2,LED_TURN_OFF);
-	NetSocDisplay(LED_SOC_3,LED_TURN_OFF);
-	FaultDisplay(LED_TURN_OFF);
+    work_timer    = xTimerCreate("work_timer", 1*60*1000 / portTICK_RATE_MS, pdTRUE, NULL, work_timer_callback);
+    sleep_timer   = xTimerCreate("sleep_timer", 2*60*1000 / portTICK_RATE_MS, pdTRUE, NULL, sleep_timer_callback);
+    NetSocDisplay(LED_SOC_0,LED_TURN_ON);
+	NetSocDisplay(LED_SOC_1,LED_TURN_ON);
+	NetSocDisplay(LED_SOC_2,LED_TURN_ON);
+	NetSocDisplay(LED_SOC_3,LED_TURN_ON);
+	FaultDisplay(LED_TURN_ON);
     PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
-    xTimerStart(monitor_timer, 0);
-
+    slpManSetPmuSleepMode(true,SLP_HIB_STATE,false);
+    slpManApplyPlatVoteHandle("MainSlp",&MainSlpHandler);
+    slpManPlatVoteDisableSleep(MainSlpHandler, SLP_SLP2_STATE);//禁用SLEEP2休眠
     //配置文件及运行数据加载
     LoadAppConfig();
     LoadAppData();
+    //
+    xTimerStart(monitor_timer, 0);
     while(true)
     {
-        osDelay(100);
         switch(gProcess_Main_Task)
         {
             case PROCESS_STATE_IDLE:
@@ -53,19 +57,29 @@ static void MainTask(void* arg)
             }
             case PROCESS_STATE_WORK:
             {
+                osDelay(100);
                 PROC_APP_STATE_SWITCH(WORK);
                 if(WorkTimerEnd)
                 {
                     PROC_MAIN_STATE_SWITCH(PROCESS_STATE_LISTEN);
                     xTimerStop(work_timer,0);
+                    xTimerStart(sleep_timer, 0);
                     WorkTimerEnd = FALSE;
                 }
                 break;
             }
             case PROCESS_STATE_LISTEN:
             {
+                osDelay(100);
                 PROC_APP_STATE_SWITCH(LISTEN);
-                xTimerStart(sleep_timer, 0);
+                if(AppDataInfo.appDataModify)
+                {
+                    SaveAppData();
+                }
+                if(AppNVMData.appDataModify)
+                {
+                    SaveAppConfig();
+                }
                 if(SleepTimerEnd)
                 {
                     PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
@@ -85,17 +99,23 @@ static void MainTask(void* arg)
 void monitor_timer_callback(TimerHandle_t xTimer)
 {
     TimeCounter++;
-    if(TimeCounter>100000*100)
+    if(TimeCounter>0xFFFFFFF0)
     {
         TimeCounter=0;
     }
 }
 void work_timer_callback(TimerHandle_t xTimer)
 {
+    #ifndef USING_PRINTF
+        printf("work_timer_callback\n")
+    #endif
     WorkTimerEnd = true;
 }
 void sleep_timer_callback(TimerHandle_t xTimer)
 {
+    #ifndef USING_PRINTF
+        printf("sleep_timer_callback\n")
+    #endif
     SleepTimerEnd = true;
 }
 void AppTaskMainInit(void *arg)

src/AppTaskUart.c

@@ -23,7 +23,7 @@ volatile BOOL isRecvComplete = false;
 void USART_callback(uint32_t event);
 static UINT16 crc_chk(UINT8* data, UINT8 length);
 UINT8 Uart_Encrypt_Send(void);
-
+static UINT8 Uart_DataRecv_func(UartQueryType Uart_Read_Msg_Fun,UINT8* Uart_Recv_Buffer_Fun);
 static void UartTask(void* arg)
 {
     USARTdrv->Initialize(USART_callback);
@@ -37,11 +37,15 @@ static void UartTask(void* arg)
 	{
 		UartWriteCmdHandle = osMessageQueueNew(3,sizeof(UartWriteData_S), NULL);
 	}
+    UINT16  Uart_Uds_LEN;
+    UINT16  Reg_Num = 0;
+    UINT16  Uart_Recv_LEN;
+    UartQueryType Uart_Read_Msg;//发送结构体初始化
+    memset(&(Uart_Read_Msg),0x00,sizeof(Uart_Read_Msg));
     UartAnswerData_S UartAnswerData;//应答数据初始化
 	memset(&(UartAnswerData),0x00,sizeof(UartAnswerData_S));
     UartWriteData_S UartWriteData; //Uart控制命令初始化
 	memset(&(UartWriteData),0x00,sizeof(UartWriteData_S));
-
     PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_ENCRYPT);
     while (1)
     {
@@ -62,13 +66,8 @@ static void UartTask(void* arg)
             }
             case PROCESS_UART_STATE_IDLE:
             {
-                osDelay(100);
-                if(BMS_Fota_update_flag)
-                {
-					PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_UPDATE);
-                    break;
-                }
-                else if(TimeCounter%10==0)
+                osDelay(50);
+                if(TimeCounter%10==0 && gProcess_app==WORK)
                 {
                     if(osMessageQueueGet(UartWriteCmdHandle,&UartWriteData,0,0)==osOK)
                     {
@@ -79,6 +78,11 @@ static void UartTask(void* arg)
                         PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_READ);
                     }
                 }
+                else if (gProcess_app==LISTEN)
+                {
+                    PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_SLEEP);
+                    break;
+                }
                 if(AppDataInfo.BattLock==TRUE && ((UartAnswerData.data[(0x09 + AppNVMData.BattCellCount + AppNVMData.BattTempCount + BMS_OTHER_TEMP)*2+1])>>1)&0x03!=0x00 && TimeCounter%10==0)//try to lock
 				{
 					UartWriteData.WriteCmd = 0x01;
@@ -95,22 +99,75 @@ static void UartTask(void* arg)
 					osMessageQueuePut(UartWriteCmdHandle,&UartWriteData,0,1000);
 					PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_READ);
 				}
+                if(BMS_Fota_update_flag)
+                {
+					PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_UPDATE);
+                    break;
+                }
                 break;
             }
             case PROCESS_UART_STATE_READ:
             {
+                UINT16 CRC_chk_buffer;
+                Reg_Num = 0x21 + AppNVMData.BattCellCount + AppNVMData.BattTempCount + BMS_OTHER_TEMP ;//按照协议里面的0x21+X+N的结束地址
+                Uart_Read_Msg.Bms_Address = BMS_ADDRESS_CODE;
+                Uart_Read_Msg.Bms_Funcode = UART_READ_CODE;
+                Uart_Read_Msg.Reg_Begin_H = 0x00;
+                Uart_Read_Msg.Reg_Begin_L = 0x00;
+                Uart_Read_Msg.Reg_Num_H   = Reg_Num>>8;
+                Uart_Read_Msg.Reg_Num_L   = Reg_Num;
+                Uart_Uds_LEN = Reg_Num*2;
+                memset(UartAnswerData.Header,0x00,Uart_Uds_LEN);
+				CRC_chk_buffer = crc_chk((UINT8 *)&Uart_Read_Msg,6);
+				Uart_Read_Msg.CRC_L = CRC_chk_buffer;
+				Uart_Read_Msg.CRC_H = CRC_chk_buffer>>8;
+				Uart_Recv_LEN = Uart_DataRecv_func(Uart_Read_Msg,(UINT8*)(UartAnswerData.Header));
+                if(Uart_Recv_LEN>0)
+                {
+                    UartRecvFlag = 1;
+                    UartAnswerData.len = Uart_Recv_LEN;
+                    uartBattInfoDecode(UartAnswerData.data);
+                }
+                else
+                {
+                    UartRecvFlag = 0;
+                }
+
+                PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_IDLE);
+                #ifdef USING_PRINTF
+					printf("\nUart_Recv_buffer:  ");
+					for(int i=0;i<Uart_Recv_LEN;i++)
+					{
+						printf("%x ",*((UINT8 *)&UartAnswerData.Header+i));
+					}
+					printf("\n");
+				#endif
                 break;
             }
             case PROCESS_UART_STATE_WRITE:
             {
+
+                PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_IDLE);
                 break;
             }
             case PROCESS_UART_STATE_UPDATE:
             {
+
+                PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_IDLE);
                 break;
             }
             case PROCESS_UART_STATE_SLEEP:
             {
+                USARTdrv->PowerControl(ARM_POWER_OFF);
+                #ifdef USING_PRINTF
+                    printf("Uart silence begin\n");
+                #endif
+                while (gProcess_app==LISTEN)
+                {
+                    osDelay(1000);
+                }
+                PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_IDLE);
+                USARTdrv->PowerControl(ARM_POWER_FULL);
                 break;
             }
             default:
@@ -122,6 +179,75 @@ static void UartTask(void* arg)
         }
     }
 }
+//Uart发送接收函数
+static UINT8 Uart_DataRecv_func(UartQueryType Uart_Read_Msg_Fun,UINT8* Uart_Recv_Buffer_Fun)
+{
+    UINT16 CRC_Rece_buffer = 0x00;
+    UINT16 CRC_chk_buffer = 0xff;
+    UINT16 Data_Len = 0 ;
+    UINT8 timeout = 0x00;
+	UINT8 pSendCmd[8];
+	memcpy(pSendCmd,(UINT8*)(&Uart_Read_Msg_Fun),8);
+	Data_Len  = ((Uart_Read_Msg_Fun.Reg_Num_H<<8)|(Uart_Read_Msg_Fun.Reg_Num_L))*2+5;
+	USARTdrv->Send(pSendCmd,8);
+    USARTdrv->Receive(Uart_Recv_Buffer_Fun,Data_Len);
+	while(true)
+    {
+        timeout++;
+        if((isRecvTimeout == true) || (isRecvComplete == true))
+        {
+            break;
+        }
+        else
+        {
+            osDelay(100);
+            if (timeout>=10)
+            {
+                timeout =0;
+                isRecvTimeout = true;
+            }
+        } 
+    }
+    if (isRecvComplete == true)
+    {
+        isRecvComplete = false;
+        CRC_Rece_buffer =*(Uart_Recv_Buffer_Fun+Data_Len-1)<<8|*(Uart_Recv_Buffer_Fun+Data_Len-2);
+        CRC_chk_buffer = crc_chk(Uart_Recv_Buffer_Fun,Data_Len-2);
+	    #ifdef USING_PRINTF1
+	         printf("Uart_Rece_buffer after Crc: ");
+	         for(int i=0;i<Data_Len;i++)
+	         {
+	         	printf("%x ",*(Uart_Recv_Buffer_Fun+i));
+	   	     }
+	         printf("\tcrcchk:%x,%x\n ",CRC_chk_buffer,CRC_Rece_buffer);
+	    #endif
+        if (CRC_Rece_buffer == CRC_chk_buffer)//满足校验
+        {
+            return Data_Len;
+        }
+        else //接收数据的校验不过
+        {
+            USARTdrv->Uninitialize();
+            osDelay(1000);
+            USARTdrv->Initialize(USART_callback);
+            USARTdrv->PowerControl(ARM_POWER_FULL);
+            USARTdrv->Control(ARM_USART_MODE_ASYNCHRONOUS |
+                      ARM_USART_DATA_BITS_8 |
+                      ARM_USART_PARITY_NONE |
+                      ARM_USART_STOP_BITS_1 |
+                      ARM_USART_FLOW_CONTROL_NONE, 9600);
+            memset(Uart_Recv_Buffer_Fun,0xff,Data_Len);
+            return 0;
+        }
+    }
+    else
+    {
+        memset(Uart_Recv_Buffer_Fun,0x00,Data_Len);
+        isRecvTimeout = false;
+        return 0;
+    }
+	return 0;
+}
 UINT8 Uart_Encrypt_Send()
 {
 	UINT8 SeedNumberArrray[4]={0x38,0x56,0xfe,0xac};