更改为新版的BMS协议，VCU和EBC暂未接收

Project_Settings/Debugger/S32K146_4G_Debug_FLASH_PNE.launch

@@ -216,5 +216,5 @@
 </listAttribute>
 <stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#13;&#10;&lt;memoryBlockExpressionList context=&quot;reserved-for-future-use&quot;&gt;&#13;&#10;&lt;gdbmemoryBlockExpression address=&quot;536806032&quot; label=&quot;RX_Buffer[UART_LPUART2]&quot;/&gt;&#13;&#10;&lt;gdbmemoryBlockExpression address=&quot;536823956&quot; label=&quot;GpsBufferGet&quot;/&gt;&#13;&#10;&lt;gdbmemoryBlockExpression address=&quot;255&quot; label=&quot;SocketId&quot;/&gt;&#13;&#10;&lt;/memoryBlockExpressionList&gt;&#13;&#10;"/>
 <stringAttribute key="process_factory_id" value="org.eclipse.cdt.dsf.gdb.GdbProcessFactory"/>
-<stringAttribute key="saved_expressions&lt;seperator&gt;Unknown" value="0x1fff0100,0x1fff08d0,0x1fff4b48,0x1fff4b50,0x1fff0103,1fff3798,0x1fff3798,0x1fffab2c,0x1fffa82c,0x1fff01f3,0x1fff050e,0,0x14200,0x14000,0x0"/>
+<stringAttribute key="saved_expressions&lt;seperator&gt;Unknown" value="0x1fff08d0,0x1fff4b48,0x1fff4b50,0x1fff0103,1fff3798,0x1fff3798,0x1fffab2c,0x1fffa82c,0x1fff01f3,0x1fff050e,0,0x14200,0x14000,0x0,0x1fff051d"/>
 </launchConfiguration>

src/AppGlobalVar.c

@@ -3,7 +3,7 @@
  * @Date         : 2022-01-23 13:45:09
  * @Version      : V3.0
  * @LastEditors  : ChenJie
- * @LastEditTime : 2022-02-23 16:59:13
+ * @LastEditTime : 2022-05-17 18:46:11
  * @Description  : file content
  * @FilePath     : \S32K146_4G\src\AppGlobalVar.c
  */
@@ -21,8 +21,8 @@
 uint8 TcpbattSN[17] = {0x31}; //上传的SN编号
 uint8 VIN[17] = {0};
 volatile uint32 TimerCounter = 0; // ms单位
-uint32 BattTempR[4] = {0};//ADC查询的温度R值
-uint16 ErrorArray[10]={0};
+uint32 BattTempR[4] = {0};		  // ADC查询的温度R值
+uint16 ErrorArray[10] = {0};
 uint8 Fota_update_flag = 0;
 /*GPS*/
 QueueHandle_t GpsDataQueueHandle;
@@ -40,23 +40,22 @@ char IccidNum[20] = {0};
 uint8 CSQValue = 0;
 sint8 SocketId = -1;
 sint8 RegChkRet = 0;
-char WebSiteIp[15] = {0};
-//const char WebSiteName[] = "\"iotp.fast-fun.cn\"";
-//const uint16 WebSitePort = 8712;
-const char WebSiteName[] = "\"nas.fast-fun.cn\"";
-const uint16 WebSitePort = 8812;
+char WebSiteIp[20] = {0};
+uint8 TcpWorkState = 0;
+// const char WebSiteName[] = "\"iotp.fast-fun.cn\"";
+// const uint16 WebSitePort = 8712;
+const char WebSiteName[] = "\"oss.li-ai.com.cn\"";
+const uint16 WebSitePort = 8712;
 
 #define EEP_START_SEC_VAR_INIT_8_NO_CACHEABLE
 #include "Eep_MemMap.h"
-AppConfigBody AppConfigInfo={false,true,{defaultSn},{0}};
+AppConfigBody AppConfigInfo = {false, true, {defaultSn}, {0}};
 #define EEP_STOP_SEC_VAR_INIT_8_NO_CACHEABLE
 #include "Eep_MemMap.h"
 
 /*以下变量均为App_CAN相关变量*/
 #ifdef APP_CAN_ENABLE
 // VCU相关
-uint16 bmsHwVersion = 0;
-uint32 bmsSwVersion = 0;
 uint8 vehicleStatus = 0;
 uint8 bmsHVOn = 0;
 uint8 currentGearPosition = 0;
@@ -66,6 +65,9 @@ uint32 ODO = 0;
 uint8 dcdcWorkStatus = 0;
 uint8 numOfChrgableSubsys = 0;
 uint8 chrgableSubsysCode = 0;
+
+uint16 vcuDCVol = 0;
+// EBC相关
 uint8 ebcStatus = 0;
 uint8 ebcAskHVOn = 0;
 uint8 ebcAskHVOff = 0;
@@ -73,323 +75,224 @@ uint8 retainLockSignal = 0;
 uint8 dischargeLockSignal = 0;
 uint8 chargeLockSignal = 0;
 uint8 chargeFlag = 0;
-uint16 vcuDCVol = 0;
 // Bcu相关
-uint32 BcuInTable[130] = {
-	0x1801EFF4,
-	0x1801FBF4,
-	0x1802FBF4,
-	0x1803FBF4,
-	0x1804FBF4,
-	0x1805FBF4,
-	0x1806FBF4,
-	0x1807FBF4,
-	0x1808FBF4,
-	0x1809FBF4,
-	0x180AFBF4,
-	0x180BFBF4,
-	0x180CFBF4,
-	0x180DFBF4,
-	0x180EFBF4,
-	0x180FFBF4,
-	0x1810FBF4,
-	0x1811FBF4,
-	0x1812FBF4,
-	0x1813FBF4,
-	0x1814FBF4,
-	0x1815FBF4,
-	0x1816FBF4,
-	0x1817FBF4,
-	0x1818FBF4,
-	0x1819FBF4,
-	0x181AFBF4,
-	0x181BFBF4,
-	0x181CFBF4,
-	0x181DFBF4,
-	0x181EFBF4,
-	0x181FFBF4,
-	0x1820FBF4,
-	0x1821FBF4,
-	0x1822FBF4,
-	0x1823FBF4,
-	0x1824FBF4,
-	0x1825FBF4,
-	0x1826FBF4,
-	0x1827FBF4,
-	0x1828FBF4,
-	0x1829FBF4,
-	0x182AFBF4,
-	0x182BFBF4,
-	0x182CFBF4,
-	0x182DFBF4,
-	0x182EFBF4,
-	0x182FFBF4,
-	0x1830FBF4,
-	0x1831FBF4,
-	0x1832FBF4,
-	0x1833FBF4,
-	0x1834FBF4,
-	0x1835FBF4,
-	0x1836FBF4,
-	0x1837FBF4,
-	0x1838FBF4,
-	0x1839FBF4,
-	0x183AFBF4,
-	0x183BFBF4,
-	0x183CFBF4,
-	0x183DFBF4,
-	0x183EFBF4,
-	0x183FFBF4,
-	0x1840FBF4,
-	0x1841FBF4,
-	0x1842FBF4,
-	0x1843FBF4,
-	0x1844FBF4,
-	0x1845FBF4,
-	0x1846FBF4,
-	0x1847FBF4,
-	0x1848FBF4,
-	0x1849FBF4,
-	0x184AFBF4,
-	0x184BFBF4,
-	0x184CFBF4,
-	0x184DFBF4,
-	0x184EFBF4,
-	0x184FFBF4,
-	0x1850FBF4,
-	0x1851FBF4,
-	0x1852FBF4,
-	0x1853FBF4,
-	0x1854FBF4,
-	0x1855FBF4,
-	0x1856FBF4,
-	0x1857FBF4,
-	0x1858FBF4,
-	0x1859FBF4,
-	0x185AFBF4,
-	0x185BFBF4,
-	0x185CFBF4,
-	0x185DFBF4,
-	0x185EFBF4,
-	0x185FFBF4,
-	0x1860FBF4,
-	0x1881EFF4,
-	0x1882EFF4,
-	0x1883EFF4,
-	0x1884EFF4,
-	0x1885EFF4,
-	0x1886EFF4,
-	0x1887EFF4,
-	0x1888EFF4,
-	0x1889EFF4,
-	0x18A0FBF4,
-	0x18A1FBF4,
-	0x18A2FBF4,
-	0x18A3FBF4,
-	0x18A4FBF4,
-	0x18A5FBF4,
-	0x18A6FBF4,
-	0x18E1EFF4,
-	0x18E2EFF4,
-	0x18E3EFF4,
-	0x18E4EFF4,
-	0x18FEDAF4,
-	0x18FF23F4,
-	0x18FF24F4,
-	0x18FF25F4,
-	0x18FF30F4,
+UINT32 BcuInTable[28] = {
+	0x1801D0F3,
+	0x1801D8F3,
+	0x1880D0F3,
+	0x1881D0F3,
+	0x1882D0F3,
+	0x1883D0F3,
+	0x1884D0F3,
+	0x1885D0F3,
+	0x1886D0F3,
+	0x1887D0F3,
+	0x1888D0F3,
+	0x1889D0F3,
+	0x188AD0F3,
+	0x18C1D0F3,
+	0x18C2D0F3,
+	0x18E1D0F3,
+	0x18E2D0F3,
+	0x18E3D0F3,
+	0x18E4D0F3,
+	0x18E5D0F3,
+	0x18E6D0F3,
+	0x18F1D0F3,
+	0x18F2D0F3,
+	0x18F3D0F3,
+	0x18F4D0F3,
+	0x18F5D0F3,
 	0x18FF45F4,
 	0x18FFC13A,
-	0x18FFD4F4,
-	0x18FFD5F4,
-	0x18FFD6F4,
-	0x18FFD7F4,
-	0x18FFD8F4,
-	0x18FFD9F4,
 };
-bool BcuRxShortError[130];
-bool BcuRxLongError[130];
-uint8 BcuRxErrorCounter[130];
-uint8 BcuRxFlag[130];
+BOOL BcuRxShortError[28];
+BOOL BcuRxLongError[28];
+UINT8 BcuRxErrorCounter[28];
+UINT8 BcuRxFlag[28];
 /************************************************************
  *BCU->4G解码变量存放区
  ************************************************************/
-uint8 BMS13_ReqVIN = 0x00;						   // BMS请求VIN码标志，0-无请求 1-请求，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_DelTemp = 0x00;				   //电芯温差异常报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-3级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_OverTemp = 0x00;				   //电芯温度过高报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-3级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_PackOverHVolt = 0x00;			   // PACK过压报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-3级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_PackLowHVolt = 0x00;			   // PACK欠压报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-4级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_LowSOC = 0x00;				   // SOC过低报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-5级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_OverUcell = 0x00;				   //单体电压过高报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-6级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_LowUcell = 0x00;				   //单体电压欠压报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-7级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_LowInsRes = 0x00;				   //绝缘报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-8级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_UcellUniformity = 0x00;		   //电池一致性差报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-9级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_OverChg = 0x00;				   //车载储能装置过充报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-10级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_OverSOC = 0x00;				   // SOC过高报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-11级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_SOCChangeFast = 0x00;			   // SOC跳变报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_BatSysNotMatch = 0x00;		   //可充电储能系统不匹配报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS11_Fult1_HVILFault = 0x00;				   //高压互锁报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_FaultNum = 0x00;				   // BMS当前发生的故障总数目（包括GB32960中规定的故障数目） 精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_CellOverDischrg = 0x00;		   //电芯过放故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_CellLowTemp = 0x00;			   //电芯低温报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_PackFireWarning = 0x00;		   //电池包火灾报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_OverDischrgCurr = 0x00;		   //放电电流超限报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-11级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_OverChrgCurrInTheDrive = 0x00;   //回充电流超限报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-11级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_CurrSensorErr = 0x00;			   //电流传感器故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_PowerSupplyErr = 0x00;		   // BMS低压供电电压异常报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_TMSErr = 0x00;				   //热管理机组故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_HeatingFilmErr = 0x00;		   //加热膜加热回路故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_PackSelfProtect = 0x00;		   //电池包自保护故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_MainLoopPrechrgErr = 0x00;	   //主回路预充或预检故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_AuxLoopPrechrgErr = 0x00;		   //辅件回路预充或预检故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_ChrgInsLowErr = 0x00;			   //充电绝缘阻值低，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_ACANLost = 0x00;				   // ACAN通讯故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_InnerCommunicationErr = 0x00;	   // BMS内部通信故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_DCDCErr = 0x00;				   // BMS-DC-DC故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_BranchBreakErr = 0x00;		   //支路断路故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_HeatRelayOpenErr = 0x00;		   //加热膜或TMS接触器故障无法闭合报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_HeatRelayWeldErr = 0x00;		   //加热膜或TMS接触器故障无法断开报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_MainPosRelayOpenErr = 0x00;	   //主正接触器无法闭合故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_MainPosRelayWeldErr = 0x00;	   //主正接触器无法断开故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_MainNegRelayOpenErr = 0x00;	   //主负接触器无法闭合故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_MainNegRelayWeldErr = 0x00;	   //主负接触器无法断开故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_DCChrgPos1RelayOpenErr = 0x00;   //直流充电A正接触器无法闭合故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_DCChrgPos1RelayWeldErr = 0x00;   //直流充电A正接触器无法断开故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_DCChrgNeg1RelayOpenErr = 0x00;   //直流充电A负接触器无法闭合故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_DCChrgNeg1RelayWeldErr = 0x00;   //直流充电A负接触器无法断开故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_DCChrgPos2RelayOpenErr = 0x00;   //直流充电B正接触器无法闭合故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_DCChrgPos2RelayWeldErr = 0x00;   //直流充电B正接触器无法断开故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_DCChrgNeg2RelayOpenErr = 0x00;   //直流充电B负接触器无法闭合故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_DCChrgNeg2RelayWeldErr = 0x00;   //直流充电B负接触器无法断开故障报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_ChrgConnectErr = 0x00;		   //插枪连接信号异常，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_ult2_OverDischrgCurrWhenInChrg = 0x00; //充电时放电电流过大，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_OverChrgCurrInTheChrg = 0x00;	   //充电电流超限报警，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_ChrgNTCErr = 0x00;			   //充电插座NTC故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_ChrgNTCTempOver = 0x00;		   //充电插座过温报警，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-3级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_ELockErr = 0x00;				   //电子锁故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_FireDetectorEr = 0x00;		   //火警探测器故障，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_ContiDischrgCurrOverLoad = 0x00; //持续回充过流故障，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-11级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_SOCDifferErr = 0x00;			   // SOC差异过大，0-正常  1-故障，精度_1，偏移量_0，单位_
-uint8 BMS12_Fult2_ContiChrgCurrOverLoad = 0x00;	   //持续放电过流故障，0-正常  1-1级 轻微故障 2-2级 较严重故障 3-11级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS1_MainPosRelaySt = 0x00;				   //主正继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-uint8 BMS1_MainNegRelaySt = 0x00;				   //主负继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-uint8 BMS1_PreChgRelaySt = 0x00;				   //预充继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-uint8 BMS1_DCChrgPos1RelaySt = 0x00;			   //直流充正继电器1状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-uint8 BMS1_DCChrgNeg1RelaySt = 0x00;			   //直流充负继电器1状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-uint8 BMS1_DCChrgPos2RelaySt = 0x00;			   //直流充正继电器2状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-uint8 BMS1_DCChrgNeg2RelaySt = 0x00;			   //直流充负继电器2状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-uint8 BMS1_HeatPosRelaySt = 0x00;				   //加热正继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-uint8 BMS1_HeatNegRelaySt = 0x00;				   //加热负继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-uint8 BMS1_SysSts = 0x00;						   //电池管理系统工作状态，0-初始化 1-自检完成允许上电 2-运行状态 3-高压切断 4-故障状态，精度_1，偏移量_0，单位_
-uint8 BMS1_Life = 0x00;							   // BMS生命信号 精度_1，偏移量_1，单位_
-uint8 BMS1_BalanceStatus = 0x00;				   // BMS当前均衡状态，0-未均衡 1-均衡中，精度_1，偏移量_0，单位_
-uint8 BMS1_DCChrgConnectSt = 0x00;				   //直流充电枪连接状态，0-未连接 1-单枪连接 2-双枪连接 3-无效，精度_1，偏移量_0，单位_
-uint8 BMS1_ChrgMode = 0x00;						   // BMS当前充电模式，0-未充电 1-直流充电 2-交流充电 3-其他充电模式，精度_1，偏移量_0，单位_
-uint8 BMS1_ChrgStatus = 0x00;					   //充电状态，0-未充电 1-充电中 2-充电已完成 3-充电错误故障，精度_1，偏移量_0，单位_
-uint8 BMS1_HeatingStatus = 0x00;				   //当前加热状态，0-未加热 1-加热中，精度_1，偏移量_0，单位_
-uint8 BMS1_CoolingStatus = 0x00;				   //当前冷却状态，0-未冷却 1-冷却中，精度_1，偏移量_0，单位_
-uint8 BMS2_SOC = 0x00;							   //电池包SOC 精度_0.4，偏移量_0，单位_
-uint8 BMS2_SOH = 0x00;							   //电池包SOH 精度_0.4，偏移量_0，单位_
-uint8 BMS2_FaultCode = 0x00;					   //故障码，见BMS_ErrCode，精度_1，偏移量_0，单位_
-uint8 BMS2_FaultLevel = 0x00;					   //当前最高故障等级，0-正常 1-1级 轻微故障 2-2级 较严重故障 3-3级 最严重故障，精度_1，偏移量_0，单位_
-uint8 BMS2_RqHVPoerOff = 0x00;					   // BMS下高压请求，0-无效 1-请求下高压 2-不请求下高压 3-无效，精度_1，偏移量_0，单位_
-uint8 BMS2_Life = 0x00;							   // BMS生命信号 精度_1，偏移量_0，单位_
-uint8 BMS4_InsDetectorSt = 0x00;				   // BMS绝缘检测状态，0-停止检测  1-激活检测，精度_1，偏移量_0，单位_
-uint8 BMS8_Max_Temp = 0x00;						   //单体最高温度 精度_1，偏移量_-40，单位_℃
-uint8 BMS8_Min_Temp = 0x00;						   //单体最低温度 精度_1，偏移量_-40，单位_℃
-uint8 BMS8_Avg_Temp = 0x00;						   //单体平均温度 精度_1，偏移量_-40，单位_℃
-uint8 BMS8_MaxTempSysNr = 0x00;					   //最高温度子系统号 精度_1，偏移量_0，单位_
-uint8 BMS8_MaxTempNr = 0x00;					   //最高温度探针单体代号 精度_1，偏移量_0，单位_
-uint8 BMS8_MinTempSysNr = 0x00;					   //最低温度子系统号 精度_1，偏移量_0，单位_
-uint8 BMS8_MinTempNr = 0x00;					   //最低温度探针子系统代号 精度_1，偏移量_0，单位_
-uint8 BMS7_MaxUcellSysNr = 0x00;				   //最高电压电池子系统号 精度_1，偏移量_0，单位_
-uint8 BMS7_MinUcellSysNr = 0x00;				   //最低电压电池子系统号 精度_1，偏移量_0，单位_
-uint8 BMS23_Gun1DCPosTemp = 0x00;				   // A枪DC+温度传感器温度 精度_1，偏移量_-40，单位_℃
-uint8 BMS23_Gun1DCNegTemp = 0x00;				   // A枪DC-温度传感器温度 精度_1，偏移量_-40，单位_℃
-uint8 BMS23_Gun2DCPosTemp = 0x00;				   // B枪DC+温度传感器温度 精度_1，偏移量_-40，单位_℃
-uint8 BMS23_Gun2DCNegTemp = 0x00;				   // B枪DC-温度传感器温度 精度_1，偏移量_-40，单位_℃
-uint8 BMS_Cell_TempN[BMS_TEMP_MAX_NUM] = {0x00};				   //电池温度编号
-uint8 BMS_SN_SysCode[24] = {0x00};				   //电池实际SN
-uint8 BMS21_BattType = 0x00;					   //电池类型，1 -铅酸电池 2 -镍氢电池 3 -磷酸铁锂电池  4 -锰酸锂电池 5 -钴酸锂电池 6 -三元材料电池  7 -聚合物锂离子电池 8 -钛酸锂电池  9-超级电容 15-其他车载储能装置，精度_1，偏移量_0，单位_
-uint8 BMS21_CoolType = 0x00;					   //电池冷却方式，0-其他冷却方式 1-自然冷却 2-风扇冷却 3-水冷却，精度_1，偏移量_0，单位_
-uint8 BMS21_Manufacture = 0x00;					   //电池厂家，1-CATL 2-LS 3-MGL 4-SAMSUN 5-LG 6-GXGK 7-SUNWODA 8-Others，精度_1，偏移量_0，单位_
-uint8 BMS21_ProtocolEditionH = 0x00;			   //通讯协议版本高位（例 - 版本为3 .1，则此处发3） 精度_1，偏移量_0，单位_
-uint8 BMS21_ProtocolEditionL = 0x00;			   //通讯协议版本低位（例 - 版本为3 .1，则此处发1） 精度_1，偏移量_0，单位_
-uint8 BMS9_TotCSCNum = 0x00;					   //电池系统中CSC总的数目 精度_1，偏移量_0，单位_
-uint8 BMS9_PackTotTempNum = 0x00;				   // PACK中电芯温度点(探针)的总数目 精度_1，偏移量_0，单位_
-uint8 BMS9_HVBranchNum = 0x00;					   //电池系统高压支路数 精度_1，偏移量_0，单位_
-uint8 BMS9_SingleHVBranchCellNum = 0x00;		   //电池系统单支路电芯数 精度_1，偏移量_0，单位_
-uint8 BMS9_BattSysNum = 0x00;					   //可充电储能系统数目（EV默认1，满足GB32960要求） 精度_1，偏移量_0，单位_
-uint8 BMS9_BattSysSeqNum = 0x00;				   //可充电储能系统序号（EV默认1，满足GB32960要求） 精度_1，偏移量_0，单位_
-uint8 BMS22_AvaiMaxSOC = 0x00;					   // PACK可用最高SOC(根据技术协议) 精度_0.4，偏移量_0，单位_
-uint8 BMS22_AvaiMinSOC = 0x00;					   // PACK可用最低SOC(根据技术协议) 精度_0.4，偏移量_0，单位_
-uint8 BMS22_AvaiMaxTemp = 0x00;					   // PACK可用温度上限(根据技术协议) 精度_1，偏移量_-40，单位_℃
-uint8 BMS22_AvaiMinTemp = 0x00;					   // PACK可用温度下限(根据技术协议) 精度_1，偏移量_-40，单位_℃
-uint8 BMS10_SubSysEncodingLen = 0x00;			   //可充电储能系统编码长度 精度_1，偏移量_0，单位_
-uint8 BMS10_SubSysIdx = 0x00;					   //可充电储能系统编码 精度_1，偏移量_0，单位_
-uint8 BMS10_SubSysErrNum = 0x00;				   //可充电储能装置故障总数 精度_1，偏移量_0，单位_
-uint8 BMS28_ReqMode = 0x00;						   // BMS请求设定模式，0-关机模式 1-制冷模式 2-制热模式 3-自循环模式，精度_1，偏移量_0，单位_
-uint8 BMS28_HVCmd = 0x00;						   //高压请求，0-请求上高压 1-请求下高压，精度_1，偏移量_0，单位_
-uint8 BMS28_ChgSts = 0x00;						   //充电状态，0-非充电 1-充电，精度_1，偏移量_0，单位_
-uint8 BMS28_HVRelaySts = 0x00;					   // BMS高压继电器状态，0-断开状态 1-闭合状态，精度_1，偏移量_0，单位_
-uint8 BMS28_SetTemp = 0x00;						   //设定温度 精度_1，偏移量_-40，单位_
-uint8 BMS28_Life = 0x00;						   // BMS生命帧 精度_1，偏移量_0，单位_
-uint8 BMS28_CRC = 0x00;							   // CRC校验值 精度_1，偏移量_0，单位_
-uint8 TMS_WorkStatus = 0x00;					   // TMS工作状态，0-关机模式 1-制冷模式 2-制热模式 3-自循环模式，精度_1，偏移量_0，单位_
-uint8 TMS_HVRelayST = 0x00;						   // TMS高压继电器状态，0-断开状态 1-闭合状态，精度_1，偏移量_0，单位_
-uint8 TMS_OutletTemp = 0x00;					   //出水温度（机组到电池） 精度_1，偏移量_-40，单位_
-uint8 TMS_InletTemp = 0x00;						   //回水温度（电池到机组） 精度_1，偏移量_-40，单位_
-uint8 TMS_Version = 0x00;						   // TMS软件版本 精度_0.1，偏移量_0，单位_
-uint8 TMS_ErrCode = 0x00;						   // TMS故障码，见附件，精度_1，偏移量_0，单位_
-uint8 TMS_FaultLevel = 0x00;					   // TMS故障码等级，0-无效 1-1级故障 2-2级故障 3-3级故障，精度_1，偏移量_0，单位_
-uint8 BCU_SnMsgFlag = 0x00;						   // SN码收全标志位
-uint16 BMS_Cell_Volt[BMS_CELL_MAX_NUM] = {0x00};				   //电芯电压
-uint16 BMS11_PackOutsideVolt = 0x00;			   //电池包外侧电压 精度_0.1，偏移量_0，单位_V
-uint16 BMS2_PackCurrent = 0x00;					   //电池包总电流，充电为负值，放电为正值 精度_0.1，偏移量_-1000，单位_A
-uint16 BMS2_PackInsideVolt = 0x00;				   //电池包内侧电压 精度_0.1，偏移量_0，单位_V
-uint16 BMS4_PosIsolation = 0x00;				   //母线正对车体绝缘电阻 精度_1，偏移量_0，单位_KΩ
-uint16 BMS4_NegIsolation = 0x00;				   //母线负对车体绝缘电阻 精度_1，偏移量_0，单位_KΩ
-uint16 BMS4_SysInsRes = 0x00;					   //系统绝缘电阻 精度_1，偏移量_0，单位_KΩ
-uint16 BMS6_Max_Ucell = 0x00;					   //单体最高电压值 精度_0.001，偏移量_0，单位_V
-uint16 BMS6_Min_Ucell = 0x00;					   //单体最低电压值 精度_0.001，偏移量_0，单位_V
-uint16 BMS6_Avg_Ucell = 0x00;					   //电体电压平均值 精度_0.001，偏移量_0，单位_V
-uint16 BMS6_SOE = 0x00;							   //剩余电量电量(SOE) 精度_0.01，偏移量_0，单位_Kwh
-uint16 BMS7_MaxUcellNr = 0x00;					   //最高电压电池单体代号 精度_1，偏移量_0，单位_
-uint16 BMS7_MinUcellNr = 0x00;					   //最低电压电池单体代号 精度_1，偏移量_0，单位_
-uint16 BMS23_RemainChgTi = 0x00;				   //剩余充电时间 精度_1，偏移量_0，单位_min
-uint16 BMS21_RateCap = 0x00;					   //电池包额定容量 精度_0.1，偏移量_0，单位_Ah
-uint16 BMS21_RateHVolt = 0x00;					   //电池包额定电压 精度_0.1，偏移量_0，单位_V
-uint16 BMS21_RatePower = 0x00;					   //电池包额定总能量 精度_0.1，偏移量_0，单位_kWh
-uint16 BMS9_PackTotCellNum = 0x00;				   // PACK中单体电芯的总数目 精度_1，偏移量_0，单位_
-uint16 BMS22_PackAvaiMaxVolt = 0x00;			   // PACK可用电压上限(根据技术协议) 精度_0.1，偏移量_0，单位_V
-uint16 BMS22_PackAvaiMinVolt = 0x00;			   // PACK可用电压下限(根据技术协议) 精度_0.1，偏移量_0，单位_V
-uint16 BMS_SoftwareVersion = 0x00;				   //软件版本 精度_0.1，偏移量_0，单位_
-uint16 BMS_HardwareVersion = 0x00;				   //硬件版本 精度_0.1，偏移量_0，单位_
-uint16 BMS3_MaxDischgPow = 0x00;				   //最大允许放电功率 精度_0.1，偏移量_0，单位_Kw
-uint16 BMS3_MaxChgPow = 0x00;					   //最大允许充电功率 精度_0.1，偏移量_0，单位_Kw
-uint16 BMS3_MaxInstantDischgPow = 0x00;			   //最大允许瞬时放电功率 精度_0.1，偏移量_0，单位_Kw
-uint16 BMS3_MaxiInstantChgPow = 0x00;			   //最大允许瞬时充电功率 精度_0.1，偏移量_0，单位_Kw
-uint16 BMS5_DischgCurMaxAllw = 0x00;			   //电池最大允许放电电流 精度_0.1，偏移量_-1000，单位_A
-uint16 BMS5_ChrgCurMaxAllw = 0x00;				   //电池最大允许充电电流 精度_0.1，偏移量_-1000，单位_A
-uint16 BMS5_InstChrgCurMaxAllw = 0x00;			   //动力电池允许最大瞬时充电电流 精度_0.1，偏移量_-1000，单位_A
-uint16 BMS5_InstDischrgCurMaxAllw = 0x00;		   //电池允许最大瞬时放电电流 精度_0.1，偏移量_-1000，单位_A
-uint16 BMS26_Bat_InstantConsume = 0x00;			   //动力电池瞬时能耗 精度_0.1，偏移量_0，单位_Wh
-uint16 BMS26_Bat_TotalConsume = 0x00;			   //动力电池总能量能耗 精度_0.1，偏移量_0，单位_Wh
-uint16 BMS26_ChgReqVoltage = 0x00;				   //充电所需电压 精度_0.1，偏移量_0，单位_V
-uint16 BMS26_ChgReqCurrent = 0x00;				   //充电所需电流 精度_0.1，偏移量_-1000，单位_A
-uint16 BMS28_HVVolt = 0x00;						   // BMS当前电压 精度_1，偏移量_0，单位_
-uint16 TMS_ReqPow = 0x00;						   // TMS需求功率 精度_0.1，偏移量_0，单位_Kw
-uint32 BMS1_RechrgCycels = 0x00;				   //充电次数 精度_1，偏移量_0，单位_
-uint32 BMS14_TotalChargeAh = 0x00;				   //累积充入Ah 数 精度_0.1，偏移量_0，单位_Ah
-uint32 BMS14_TotalDischargeAh = 0x00;			   //累积放出Ah 数 精度_0.1，偏移量_0，单位_Ah
-uint32 BMS15_TotalChargeKwh = 0x00;				   //累计充入kWh 数 精度_0.1，偏移量_0，单位_KWh
-uint32 BMS15_TotalDischargeKwh = 0x00;			   //累计放出kWh 数 精度_0.1，偏移量_0，单位_KWh
-uint32 BMS16_TotalEneryECOChargeAh = 0x00;		   //累计动能回馈充入Ah 数 精度_0.1，偏移量_0，单位_Ah
-uint32 BMS16_TotalEneryECOChargeKwh = 0x00;		   //累计动能回馈充入kWh 数 精度_0.1，偏移量_0，单位_KWh
-uint32 BMS17_TotalStationChargeAh = 0x00;		   //累计换电站充入Ah 数 精度_0.1，偏移量_0，单位_Ah
-uint32 BMS17_TotalStationChargeKwh = 0x00;		   //累计换电站充入kWh 数 精度_0.1，偏移量_0，单位_KWh
-uint32 BMS18_TotalPoleChargeAh = 0x00;			   //累计插枪充电充入Ah 数 精度_0.1，偏移量_0，单位_Ah
-uint32 BMS18_TotalPoleChargeKwh = 0x00;			   //累计插枪充电充入kWh 数 精度_0.1，偏移量_0，单位_KWh
-uint32 BMS19_SingleChargeAh = 0x00;				   //单次充电Ah 数 精度_0.1，偏移量_0，单位_Ah
-uint32 BMS19_SingleChargeKwh = 0x00;			   //单次充电kWh 数 精度_0.1，偏移量_0，单位_KWh
+UINT8 BMS_ReqVIN = 0x00;					  //是否请求VIN码,0:预留;1:请求VIN;2:不请求VIN;3:无效;,Re-1,Off-0,
+UINT8 BMS_ReqHVOff = 0x00;					  //是否请求下高压,0:预留;1:请求下高压;2:不请求下高压;3:无效;,Re-1,Off-0,
+UINT8 BMS_ProtocolEditionH = 0x00;			  //通讯协议版本高位(例 : 版本为3 .1, 则此处发3),	, Re - 1, Off - 0,
+UINT8 BMS_ProtocolEditionL = 0x00;			  //通讯协议版本低位(例 : 版本为3 .1, 则此处发1),	, Re - 1, Off - 0,
+UINT8 BMS_CharDevNum = 0x00;				  //可充电装置系统序号(BMS是整车中可充电装置系统中的第几个, 需要整车告知),1,Re-1,Off-0,
+UINT8 BMS_FtPosRly = 0x00;					  //主正继电器粘连故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtNegRly = 0x00;					  //主负继电器粘连故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtPosCharRly1 = 0x00;				  //充正1继电器粘连故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtNegCharRly1 = 0x00;				  //充负1继电器粘连故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtPosCharRly2 = 0x00;				  //充正2继电器粘连故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtNegCharRly2 = 0x00;				  //充负2继电器粘连故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtHeatRly1 = 0x00;				  //加热1/正继电器粘连故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtHeatRly2 = 0x00;				  //加热2/负继电器粘连故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_StPosRly = 0x00;					  //主正继电器状态(如继电器状态由BMS检测),0:预留;1:开启;2:闭合;3:无效;,Re-1,Off-0,
+UINT8 BMS_StNegRly = 0x00;					  //主负继电器状态(如继电器状态由BMS检测),0:预留;1:开启;2:闭合;3:无效;,Re-1,Off-0,
+UINT8 BMS_StPreCharRly = 0x00;				  //预充继电器状态,0:预留;1:开启;2:闭合;3:无效;,Re-1,Off-0,
+UINT8 BMS_StPosCharRly1 = 0x00;				  //直流充正继电器1状态,0:预留;1:开启;2:闭合;3:无效;,Re-1,Off-0,
+UINT8 BMS_StNegCharRly1 = 0x00;				  //直流充负继电器1状态,0:预留;1:开启;2:闭合;3:无效;,Re-1,Off-0,
+UINT8 BMS_StPosCharRly2 = 0x00;				  //直流充正继电器2状态,0:预留;1:开启;2:闭合;3:无效;,Re-1,Off-0,
+UINT8 BMS_StNegCharRly2 = 0x00;				  //直流充负继电器2状态,0:预留;1:开启;2:闭合;3:无效;,Re-1,Off-0,
+UINT8 BMS_FtAuxRelayWeld = 0x00;			  //附件继电器粘连故障(保留),0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_BraOpenCirc = 0x00;				  //支路断路故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtBackCharCurrOutLim = 0x00;		  //回充电流超限报警,0:正常1 : 1级 轻微故障 2 : 2级 较严重故障 3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtPosRlyOpen = 0x00;				  //主正继电器无法闭合报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtNegRlyOpen = 0x00;				  //主负继电器无法闭合报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtPosCharRly1Open = 0x00;			  //直流充电正1继电器无法闭合报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtPosCharRly2Open = 0x00;			  //直流充电正2继电器无法闭合报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtNegCharRly1Open = 0x00;			  //直流充电负1继电器无法闭合报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtNegCharRly2Open = 0x00;			  //直流充电负2继电器无法闭合报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtTMSContClose = 0x00;			  //加热膜或TMS接触器无法断开报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtTMSContOpen = 0x00;				  //加热膜或TMS接触器无法闭合报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtTMS = 0x00;						  //热管理系统故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_Ft24VSpy = 0x00;					  // BMS 24V供电异常报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtPACKSelfProt = 0x00;			  //电池包自保护报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtCharSockTempOver = 0x00;		  //充电插座过温报警,0:正常1 : 1级 轻微故障 2 : 2级 较严重故障 3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtTempOutCtrl = 0x00;				  //热失控报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_StPosHeatRly = 0x00;				  //加热正继电器状态,0:保留;1:开启;2:闭合;3:无效,Re-1,Off-0,
+UINT8 BMS_StNegHeatRly = 0x00;				  //加热负继电器状态,0:保留;1:开启;2:闭合;3:无效,Re-1,Off-0,
+UINT8 BMS_CharSysNum = 0x00;				  //可充电储能子系统总数(保留),,Re-1,Off-0,
+UINT8 BMS_FtCode = 0x00;					  //电池系统故障码,详见附表电池系统故障码列表,Re-1,Off-0,
+UINT8 BMS_ST1CheckSum = 0x00;				  // B2V_ST1的CheckSum,Byte0=Byte1 XOR Byte2 XOR Byte3 XOR Byte4 XOR Byte5 XOR Byte6 XOR Byte7,Re-1,Off-0,
+UINT8 BMS_ST1Counter = 0x00;				  // B2V_ST1的生命信号,0~14循环,15:信号无效,Re-1,Off-0,
+UINT8 BMS_Mode = 0x00;						  // BMS当前状态,0:预留;1:高压上电;2:高压下电;3:无效;,Re-1,Off-0,
+UINT8 BMS_AuxRlySt = 0x00;					  //附件继电器状态,0:开启;1:闭合;,Re-1,Off-0,
+UINT8 BMS_BattBalaSt = 0x00;				  // BMS当前均衡状态,0:未开启均衡;1:开启均衡;,Re-1,Off-0,
+UINT8 BMS_CharGunSt = 0x00;					  //直流充电枪连接状态,0:未连接1 : 连接, Re - 1, Off - 0,
+UINT8 BMS_CharMode = 0x00;					  // BMS当前充电模式,0:预留1 : 直流充电 2 : 交流充电 3 : 其他充电, Re - 1, Off - 0,
+UINT8 BMS_CharSt = 0x00;					  //充电状态,0:可以充电1 : 正在充电 2 : 充电结束 3 : 充电故障, Re - 1, Off - 0,
+UINT8 BMS_FtLvl = 0x00;						  //当前最高故障等级,0:正常1 : 1级 轻微故障 2 : 2级 较严重故障 3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtCellTempDiff = 0x00;			  //电芯温差异常报警,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtCellTempHigh = 0x00;			  //电芯温度过高报警,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtPACKOverVolt = 0x00;			  // PACK过压报警,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtPACKUndeVolt = 0x00;			  // PACK欠压报警,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtSOCLow = 0x00;					  // SOC过低报警,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtCellOverVolt = 0x00;			  //单体电压过高报警,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtCellUndeVolt = 0x00;			  //单体电压欠压报警,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtIns = 0x00;						  //绝缘报警,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtCellOverVoltDiff = 0x00;		  //单体压差过大,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtCharCurrOver = 0x00;			  //充电电流过大报警,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtDisCharCurrOver = 0x00;			  //放电电流过大报警,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtCellTempLow = 0x00;				  //电芯温度过低报警,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtBranVoltDifOver = 0x00;			  //支路压差过大报警(存在并联支路的系统),0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtBMSHardWare = 0x00;				  // BMS硬件故障,0:无故障; 1:1级 轻微故障; 2:2级 较严重故障3 : 3级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtSOCHigh = 0x00;					  // SOC过高报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtSOCJump = 0x00;					  // SOC跳变报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtInCom = 0x00;					  // BMS内部通信故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtSysMism = 0x00;					  // BMS/可充电储能系统不匹配报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtHvIntLock = 0x00;				  //高压互锁报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtSmoke = 0x00;					  //火警探测器故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtFire = 0x00;					  //电池包火灾报警,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtNum = 0x00;						  // BMS当前发生的故障总数目(包括GB32960中规定的故障数目),,Re-1,Off-0,
+UINT8 BMS_PackSOC = 0x00;					  //电池包SOC,,Re-0.4,Off-0,
+UINT8 BMS_PackSOH = 0x00;					  //电池包SOH,,Re-0.4,Off-0,
+UINT8 BMS_MaxCellTemp = 0x00;				  //单体最高温度,,Re-1,Off--50,℃
+UINT8 BMS_MinCellTemp = 0x00;				  //单体最低温度,,Re-1,Off--50,℃
+UINT8 BMS_AverCellTemp = 0x00;				  //单体平均温度,,Re-1,Off--50,℃
+UINT8 BMS_MaxCellTempCSC = 0x00;			  //最高温度电芯所在子系统(CSC)编号,范围(1~255),Re-1,Off-0,
+UINT8 BMS_MaxCellTempNum = 0x00;			  //最高温度电芯所在子系统(CSC)内温度探针编号,范围(1~255),Re-1,Off-0,
+UINT8 BMS_MinCellTempCSC = 0x00;			  //最低温度电芯所在子系统(CSC)编号,范围(1~255),Re-1,Off-0,
+UINT8 BMS_MinCellTempNum = 0x00;			  //最低温度电芯所在子系统(CSC)内温度探针编号,范围(1~255),Re-1,Off-0,
+UINT8 BMS_MaxCellVoltCSC = 0x00;			  //最高电压电芯所在子系统(CSC)编号,范围(1~255),Re-1,Off-0,
+UINT8 BMS_MaxCellVoltNum = 0x00;			  //最高电压电芯所在子系统(CSC)内单体编号,范围(1~255),Re-1,Off-0,
+UINT8 BMS_MinCellVoltCSC = 0x00;			  //最低电压电芯所在子系统(CSC)编号,范围(1~255),Re-1,Off-0,
+UINT8 BMS_MinCellVoltNum = 0x00;			  //最低电压电芯所在子系统(CSC)内单体编号,范围(1~255),Re-1,Off-0,
+UINT8 BMS_InsDeteSt = 0x00;					  // BMS绝缘检测状态,0:停止检测;1:激活检测;,Re-1,Off-0,
+UINT8 BMS_FtCharInsLow = 0x00;				  //充电绝缘阻值低,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtCurrSenr = 0x00;				  //电流传感器故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtHeatingFilm = 0x00;				  //加热膜加热回路故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtMainLoopPreChar = 0x00;			  //主回路预充或预检故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtAuxLoopPreChar = 0x00;			  //辅件回路预充或预检故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtACANLost = 0x00;				  // ACAN/整车CAN通讯故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtDCDC = 0x00;					  // BMS-DC-DC故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtSOCDif = 0x00;					  // SOC差异过大,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtCellOverDisChar = 0x00;			  //电芯过放故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtCharOver = 0x00;				  //车载储能装置过充报警,0:正常;1:1级 轻微故障;2:2级 较严重故障3 : 10级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtContDisCharCurrOverLoad = 0x00;	  //持续回充过流故障,0:正常;1:1级 轻微故障;2:2级 较严重故障3 : 10级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_FtContCharCurrOverLoad = 0x00;	  //持续放电过流故障,0:正常;1:1级 轻微故障;2:2级 较严重故障3 : 10级 最严重故障, Re - 1, Off - 0,
+UINT8 BMS_Gun1DCNegTemp = 0x00;				  //充电口1负温感值,,Re-1,Off--40,℃
+UINT8 BMS_Gun1DCPosTemp = 0x00;				  //充电口1正温感值,,Re-1,Off--40,℃
+UINT8 BMS_Gun2DCNegTemp = 0x00;				  //充电口2负温感值,,Re-1,Off--40,℃
+UINT8 BMS_Gun2DCPosTemp = 0x00;				  //充电口2正温感值,,Re-1,Off--40,℃
+UINT8 BMS_CurrHeatSt = 0x00;				  //当前加热状态,0:未加热;1:加热中;2:预留;3:无效;,Re-1,Off-0,
+UINT8 BMS_CurrCoolSt = 0x00;				  //当前冷却状态,0:未冷却;1:冷却中;2:预留;3:无效;,Re-1,Off-0,
+UINT8 BMS_FtCharCnct = 0x00;				  //插枪连接信号异常,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtOverDisCharCurrDuringChar = 0x00; //充电时放电电流过大,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtCharNTC = 0x00;					  //充电插座NTC故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_FtELock = 0x00;					  //电子锁故障,0:正常; 1:故障,Re-1,Off-0,
+UINT8 BMS_CellVoltFramNum = 0x00;			  //单体电压帧序号,有效值1~255,Re-1,Off-0,
+UINT8 BMS_CellTempFramNum = 0x00;			  //温度帧序号,有效值1~255,Re-1,Off-0,
+UINT8 BMS_CSC_Code = 0x00;					  //子系统编号CSC,有效值1~255,Re-1,Off-0,
+UINT8 BMS_CellTemp[BMS_TEMP_MAX_NUM] = {0x00};			  //当前CSC下的第N个探针的温度,255 "Invalid" 0xFF 无效有效值 0 ~254, 单位 ℃, 范围(-50 ~204)℃, , Re - 1, Off-- 50,℃
+UINT8 BMS_Checksum = 0x00;					  //电池编码信息1的CheckSum,Byte0=Byte1 XOR Byte2 XOR Byte3 XOR Byte4 XOR Byte5 XOR Byte6 XOR Byte7,Re-1,Off-0,
+UINT8 BMS_PackComp = 0x00;					  //电池厂家,1:"CATL" 2:"Li Shen" 3:"MGL" 4:"SAMSUN" 5:"LG",Re-1,Off-0,
+UINT8 BMS_BattCodeLeng = 0x00;				  //电池编码长度,0:Do not transmit this Code,Re-1,Off-0,
+UINT8 BMS_SN[27] = {0x00};					  //电池编码(SN)字符1(ASCII),,Re-1,Off-0,
+UINT8 BMS_BattType = 0x00;					  //电池类型,1:铅酸电池; 2:镍氢电池; 3:磷酸铁锂电池; 4:锰酸锂电池; 5:钴酸锂电池; 6:三元材料电池; 7:聚合物锂离子电池; 8:钛酸锂电池; 9:超级电容; 10~13:保留; 14:燃料电池;15:保留,Re-1,Off-0,
+UINT8 BMS_CoolType = 0x00;					  //电池冷却方式,0:其他冷却方式1 : 自然冷却 2 : 风扇冷却 3 : 水冷却, Re - 1, Off - 0,
+UINT8 BMS_CSC_Total = 0x00;					  //电池系统中CSC总的数目,,Re-1,Off-0,
+UINT8 BMS_CellVoltLevel = 0x00;				  //单体平台电压(非实时变化的值),有效值0~5V;  255 "Signal Invalid" 0xFF 无效,Re-0.1,Off-0,V
+UINT8 BMS_CellMinVolt = 0x00;				  //单体可用最低电压(非实时变化的值),有效值0~5V;  255 "Signal Invalid" 0xFF 无效,Re-0.1,Off-0,V
+UINT8 BMS_CellMaxVolt = 0x00;				  //单体可用最高电压(非实时变化的值),有效值0~5V;  255 "Signal Invalid" 0xFF 无效,Re-0.1,Off-0,V
+UINT8 BMS_HVBranNum = 0x00;					  //电池系统高压支路数,,Re-1,Off-0,
+UINT8 BMS_SingleHVBranchCellNum = 0x00;		  //电池系统单支路电芯数,,Re-1,Off-0,
+UINT8 BMS_ReqMode = 0x00;					  // BMS请求设定模式,0:关机模式1 : 制冷模式 2 : 制热模式 3 : 自循环模式, Re - 1, Off - 0,
+UINT8 BMS_HVCmd = 0x00;						  //高压请求,0:请求上高压1 : 请求下高压, Re - 1, Off - 0,
+UINT8 BMS_ChgSts = 0x00;					  //充电状态,0:非充电1 : 充电, Re - 1, Off - 0,
+UINT8 BMS_HVRelaySts = 0x00;				  // BMS高压继电器状态,0:断开状态; 1:闭合状态; 2~3:无效,Re-1,Off-0,
+UINT8 BMS_SetTemp = 0x00;					  //设定温度,,Re-1,Off--40,
+UINT8 BMS_Life = 0x00;						  // BMS生命帧,,Re-1,Off-0,
+UINT8 BMS_CRC = 0x00;						  // CRC校验值,,Re-1,Off-0,
+UINT8 TMS_WorkStatus = 0x00;				  // TMS工作状态,0:关机模式1 : 制冷模式 2 : 制热模式 3 : 自循环模式, Re - 1, Off - 0,
+UINT8 TMS_HVRelayST = 0x00;					  // TMS高压继电器状态,0:断开状态; 1:闭合状态; 2~3:无效,Re-1,Off-0,
+UINT8 TMS_OutletTemp = 0x00;				  //出水温度(机组到电池),255:无效,Re-1,Off--40,
+UINT8 TMS_InletTemp = 0x00;					  //回水温度(电池到机组),255:无效,Re-1,Off--40,
+UINT8 TMS_ErrCode = 0x00;					  // TMS故障码,0:无故障; 出现 1 种以上循环发送,Re-1,Off-0,
+UINT8 TMS_FaultLevel = 0x00;				  // TMS故障码等级,0:无效1 : 1级故障 2 : 2级故障 3 : 3级故障, Re - 1, Off - 0,
+UINT16 BMS_SoftwareVersion = 0x00;			  //软件版本号:RyyyBzzz(R为软件版本、B为测试版本、正式版本不带B)  ,yyy:0~254,精度1,255:无效,不显示;zzz:0~254,精度1,255:无效,不显示;
+UINT16 BMS_HardwareVersion = 0x00;			  //硬件版本号:VyyyBzzz(V为硬件版本、B为测试版本、正式版本不带B)  ,,Re-1,Off-0,
+UINT16 BMS_PackCurr = 0x00;					  //电池包总电流,充电为负值,放电为正值,,Re-0.1,Off--1000,A
+UINT16 BMS_MaxCharCurr = 0x00;				  //电池包最大回充电流,,Re-0.1,Off--1000,A
+UINT16 BMS_MaxDisCharCurr = 0x00;			  //电池包最大放电电流,,Re-0.1,Off--1000,A
+UINT16 BMS_PosIns = 0x00;					  //母线正对车体绝缘电阻,,Re-1,Off-0,KΩ
+UINT16 BMS_NegIns = 0x00;					  //母线负对车体绝缘电阻,,Re-1,Off-0,KΩ
+UINT16 BMS_BattVolt = 0x00;					  //电池包内侧电压,,Re-0.1,Off-0,V
+UINT16 BMS_LinkVolt = 0x00;					  //电池包外侧电压,,Re-0.1,Off-0,V
+UINT16 BMS_MaxCellVolt = 0x00;				  //单体最高电压值,,Re-0.001,Off-0,V
+UINT16 BMS_AverCellVolt = 0x00;				  //电芯电压平均值,,Re-0.001,Off-0,V
+UINT16 BMS_MinCellVolt = 0x00;				  //电芯最低电压值,,Re-0.001,Off-0,V
+UINT16 BMS_ContChrgCurr = 0x00;				  // BMS允许的持续回充电流,,Re-0.1,Off-0,A
+UINT16 BMS_ContDisCharCurr = 0x00;			  // BMS允许的持续放电电流,,Re-0.1,Off--1000,A
+UINT16 BMS_CharReqVolt = 0x00;				  //充电所需电压(交流),,Re-0.1,Off-0,V
+UINT16 BMS_CharReqCurr = 0x00;				  //充电所需电流(交流),,Re-0.1,Off--1000,A
+UINT16 BMS_SysInsRes = 0x00;				  //系统绝缘电阻,,Re-1,Off-0,KΩ
+UINT16 BMS_MaxDisCharPwr = 0x00;			  //最大允许放电功率,,Re-0.1,Off-0,kw
+UINT16 BMS_MaxCharPwr = 0x00;				  //最大允许充电功率,,Re-0.1,Off-0,kw
+UINT16 BMS_ContDisCharPwr = 0x00;			  // BMS允许的持续放电功率,,Re-0.1,Off-0,kw
+UINT16 BMS_ContCharPwr = 0x00;				  // BMS允许的持续充电功率,,Re-0.1,Off-0,kw
+UINT16 BMS_InstEngyCons = 0x00;				  //动力电池瞬时百公里能耗,,Re-0.1,Off-0,kwh
+UINT16 BMS_TotalEngyCons = 0x00;			  //动力电池总/平均百公里能耗,,Re-0.1,Off-0,kwh
+UINT16 BMS_SOE = 0x00;						  //剩余电量,,Re-0.01,Off-0,kwh
+UINT16 BMS_RmanCharTime = 0x00;				  //剩余充电时间,,Re-1,Off-0,min
+UINT16 BMS_CharNum = 0x00;					  //充电次数,,Re-1,Off-0,
+UINT16 BMS_CellVolt[BMS_CELL_MAX_NUM] = {0x00};			  //电芯的电压,65535 "Invalid" 0xFFFF 无效有效值 0 ~65534, 范围(0 ~65.534) V, Re - 0.001, Off - 0, V
+UINT16 BMS_BattRateCap = 0x00;				  //电池包额定容量,有效值 0~65534,65535 "Signal Invalid" 无效,Re-1,Off-0,Ah
+UINT16 BMS_BattRateVolt = 0x00;				  //电池包额定电压,有效值 0~6553.4,65535 "Signal Invalid" 无效,Re-0.1,Off-0,V
+UINT16 BMS_BattRateEngy = 0x00;				  //电池包额定能量,有效值 0~6553.4,65535 "Signal Invalid" 无效,Re-0.1,Off-0,kWh
+UINT16 BMS_CellTotal = 0x00;				  // PACK中单体电芯的总数目,,Re-1,Off-0,
+UINT16 BMS_TempTotal = 0x00;				  // PACK中电芯温度点(探针)的总数目,,Re-1,Off-0,
+UINT16 BMS_SingleCharEngy = 0x00;			  //单次充电kWh 数,,Re-0.1,Off-0,KWh
+UINT16 BMS_SingleCharCapy = 0x00;			  //单次充电Ah 数,,Re-0.1,Off-0,Ah
+UINT16 BMS_HVVolt = 0x00;					  // BMS当前电压,,Re-1,Off-0,
+UINT16 TMS_ReqPow = 0x00;					  // TMS需求功率,65535:无效,Re-0.1,Off-0,Kw
+UINT32 BMS_TotalCharEngy = 0x00;			  //累计充入kWh 数,,Re-0.1,Off-0,KWh
+UINT32 BMS_TotalDisCharEngy = 0x00;			  //累计放出kWh 数,,Re-0.1,Off-0,KWh
+UINT32 BMS_TotalBackCharEngy = 0x00;		  //累计动能回馈充入kWh 数,,Re-0.1,Off-0,KWh
+UINT32 BMS_TotalStaCharEngy = 0x00;			  //累计换电站充入kWh 数,,Re-0.1,Off-0,KWh
+UINT32 BMS_TotalGunCharEngy = 0x00;			  //累计插枪充电充入kWh 数,,Re-0.1,Off-0,KWh
+UINT32 BMS_TotalGunCharCapy = 0x00;			  //累计插枪充电充入Ah 数,,Re-0.1,Off-0,Ah
+UINT32 BMS_TotalCharCapy = 0x00;			  //累计充入Ah 数,,Re-0.1,Off-0,Ah
+UINT32 BMS_TotalDisCharCapy = 0x00;			  //累计放出Ah 数,,Re-0.1,Off-0,Ah
+UINT32 BMS_TotalBackCharCapy = 0x00;		  //累计动能回馈充入Ah 数,,Re-0.1,Off-0,Ah
+UINT32 BMS_TotalStaCharCapy = 0x00;			  //累计换电站充入Ah 数,,Re-0.1,Off-0,Ah
 #endif

src/AppGlobalVar.h

@@ -3,7 +3,7 @@
  * @Date         : 2022-01-23 13:45:09
  * @Version      : V3.0
  * @LastEditors  : ChenJie
- * @LastEditTime : 2022-02-23 17:02:37
+ * @LastEditTime : 2022-05-17 18:37:07
  * @Description  : file content
  * @FilePath     : \S32K146_4G\src\AppGlobalVar.h
  */
@@ -71,25 +71,23 @@ typedef struct _Fota_Type
 extern uint8 CSQValue;
 extern sint8 SocketId;
 extern sint8 RegChkRet;
-extern char WebSiteIp[15];
+extern char WebSiteIp[20];
 extern const char WebSiteName[];
 extern const uint16 WebSitePort;
 extern char ImeiNum[15];
 extern char IccidNum[20];
-
+extern uint8 TcpWorkState;
 typedef struct _AppConfigType
 {
-	bool appSaveFlg;
-	bool eolFlg;
-	uint8 deviceSn[17];
-	uint8 re[20];
+    bool appSaveFlg;
+    bool eolFlg;
+    uint8 deviceSn[17];
+    uint8 re[20];
 } AppConfigBody;
 extern AppConfigBody AppConfigInfo;
 
 /*以下变量均为App_CAN相关变量*/
 #ifdef APP_CAN_ENABLE
-extern uint16 bmsHwVersion;
-extern uint32 bmsSwVersion;
 extern uint8 vehicleStatus;
 extern uint8 bmsHVOn;
 extern uint8 currentGearPosition;
@@ -99,6 +97,8 @@ extern uint32 ODO;
 extern uint8 dcdcWorkStatus;
 extern uint8 numOfChrgableSubsys;
 extern uint8 chrgableSubsysCode;
+extern uint16 vcuDCVol;
+// EBC
 extern uint8 ebcStatus;
 extern uint8 ebcAskHVOn;
 extern uint8 ebcAskHVOff;
@@ -106,190 +106,193 @@ extern uint8 retainLockSignal;
 extern uint8 dischargeLockSignal;
 extern uint8 chargeLockSignal;
 extern uint8 chargeFlag;
-extern uint16 vcuDCVol;
 // BCU解码变量
-extern uint32 BcuInTable[130];
-extern bool BcuRxShortError[130];
-extern bool BcuRxLongError[130];
-extern uint8 BcuRxErrorCounter[130];
-extern uint8 BcuRxFlag[130];
-extern uint8 BMS13_ReqVIN;
-extern uint8 BMS11_Fult1_DelTemp;
-extern uint8 BMS11_Fult1_OverTemp;
-extern uint8 BMS11_Fult1_PackOverHVolt;
-extern uint8 BMS11_Fult1_PackLowHVolt;
-extern uint8 BMS11_Fult1_LowSOC;
-extern uint8 BMS11_Fult1_OverUcell;
-extern uint8 BMS11_Fult1_LowUcell;
-extern uint8 BMS11_Fult1_LowInsRes;
-extern uint8 BMS11_Fult1_UcellUniformity;
-extern uint8 BMS11_Fult1_OverChg;
-extern uint8 BMS11_Fult1_OverSOC;
-extern uint8 BMS11_Fult1_SOCChangeFast;
-extern uint8 BMS11_Fult1_BatSysNotMatch;
-extern uint8 BMS11_Fult1_HVILFault;
-extern uint8 BMS12_Fult2_FaultNum;
-extern uint8 BMS12_Fult2_CellOverDischrg;
-extern uint8 BMS12_Fult2_CellLowTemp;
-extern uint8 BMS12_Fult2_PackFireWarning;
-extern uint8 BMS12_Fult2_OverDischrgCurr;
-extern uint8 BMS12_Fult2_OverChrgCurrInTheDrive;
-extern uint8 BMS12_Fult2_CurrSensorErr;
-extern uint8 BMS12_Fult2_PowerSupplyErr;
-extern uint8 BMS12_Fult2_TMSErr;
-extern uint8 BMS12_Fult2_HeatingFilmErr;
-extern uint8 BMS12_Fult2_PackSelfProtect;
-extern uint8 BMS12_Fult2_MainLoopPrechrgErr;
-extern uint8 BMS12_Fult2_AuxLoopPrechrgErr;
-extern uint8 BMS12_Fult2_ChrgInsLowErr;
-extern uint8 BMS12_Fult2_ACANLost;
-extern uint8 BMS12_Fult2_InnerCommunicationErr;
-extern uint8 BMS12_Fult2_DCDCErr;
-extern uint8 BMS12_Fult2_BranchBreakErr;
-extern uint8 BMS12_Fult2_HeatRelayOpenErr;
-extern uint8 BMS12_Fult2_HeatRelayWeldErr;
-extern uint8 BMS12_Fult2_MainPosRelayOpenErr;
-extern uint8 BMS12_Fult2_MainPosRelayWeldErr;
-extern uint8 BMS12_Fult2_MainNegRelayOpenErr;
-extern uint8 BMS12_Fult2_MainNegRelayWeldErr;
-extern uint8 BMS12_Fult2_DCChrgPos1RelayOpenErr;
-extern uint8 BMS12_Fult2_DCChrgPos1RelayWeldErr;
-extern uint8 BMS12_Fult2_DCChrgNeg1RelayOpenErr;
-extern uint8 BMS12_Fult2_DCChrgNeg1RelayWeldErr;
-extern uint8 BMS12_Fult2_DCChrgPos2RelayOpenErr;
-extern uint8 BMS12_Fult2_DCChrgPos2RelayWeldErr;
-extern uint8 BMS12_Fult2_DCChrgNeg2RelayOpenErr;
-extern uint8 BMS12_Fult2_DCChrgNeg2RelayWeldErr;
-extern uint8 BMS12_Fult2_ChrgConnectErr;
-extern uint8 BMS12_ult2_OverDischrgCurrWhenInChrg;
-extern uint8 BMS12_Fult2_OverChrgCurrInTheChrg;
-extern uint8 BMS12_Fult2_ChrgNTCErr;
-extern uint8 BMS12_Fult2_ChrgNTCTempOver;
-extern uint8 BMS12_Fult2_ELockErr;
-extern uint8 BMS12_Fult2_FireDetectorEr;
-extern uint8 BMS12_Fult2_ContiDischrgCurrOverLoad;
-extern uint8 BMS12_Fult2_SOCDifferErr;
-extern uint8 BMS12_Fult2_ContiChrgCurrOverLoad;
-extern uint8 BMS1_MainPosRelaySt;
-extern uint8 BMS1_MainNegRelaySt;
-extern uint8 BMS1_PreChgRelaySt;
-extern uint8 BMS1_DCChrgPos1RelaySt;
-extern uint8 BMS1_DCChrgNeg1RelaySt;
-extern uint8 BMS1_DCChrgPos2RelaySt;
-extern uint8 BMS1_DCChrgNeg2RelaySt;
-extern uint8 BMS1_HeatPosRelaySt;
-extern uint8 BMS1_HeatNegRelaySt;
-extern uint8 BMS1_SysSts;
-extern uint8 BMS1_Life;
-extern uint8 BMS1_BalanceStatus;
-extern uint8 BMS1_DCChrgConnectSt;
-extern uint8 BMS1_ChrgMode;
-extern uint8 BMS1_ChrgStatus;
-extern uint8 BMS1_HeatingStatus;
-extern uint8 BMS1_CoolingStatus;
-extern uint8 BMS2_SOC;
-extern uint8 BMS2_SOH;
-extern uint8 BMS2_FaultCode;
-extern uint8 BMS2_FaultLevel;
-extern uint8 BMS2_RqHVPoerOff;
-extern uint8 BMS2_Life;
-extern uint8 BMS4_InsDetectorSt;
-extern uint8 BMS8_Max_Temp;
-extern uint8 BMS8_Min_Temp;
-extern uint8 BMS8_Avg_Temp;
-extern uint8 BMS8_MaxTempSysNr;
-extern uint8 BMS8_MaxTempNr;
-extern uint8 BMS8_MinTempSysNr;
-extern uint8 BMS8_MinTempNr;
-extern uint8 BMS7_MaxUcellSysNr;
-extern uint8 BMS7_MinUcellSysNr;
-extern uint8 BMS23_Gun1DCPosTemp;
-extern uint8 BMS23_Gun1DCNegTemp;
-extern uint8 BMS23_Gun2DCPosTemp;
-extern uint8 BMS23_Gun2DCNegTemp;
-extern uint8 BMS_Cell_TempN[64];
-extern uint8 BMS_SN_SysCode[24];
-extern uint8 BMS21_BattType;
-extern uint8 BMS21_CoolType;
-extern uint8 BMS21_Manufacture;
-extern uint8 BMS21_ProtocolEditionH;
-extern uint8 BMS21_ProtocolEditionL;
-extern uint8 BMS9_TotCSCNum;
-extern uint8 BMS9_PackTotTempNum;
-extern uint8 BMS9_HVBranchNum;
-extern uint8 BMS9_SingleHVBranchCellNum;
-extern uint8 BMS9_BattSysNum;
-extern uint8 BMS9_BattSysSeqNum;
-extern uint8 BMS22_AvaiMaxSOC;
-extern uint8 BMS22_AvaiMinSOC;
-extern uint8 BMS22_AvaiMaxTemp;
-extern uint8 BMS22_AvaiMinTemp;
-extern uint8 BMS10_SubSysEncodingLen;
-extern uint8 BMS10_SubSysIdx;
-extern uint8 BMS10_SubSysErrNum;
-extern uint8 BMS28_ReqMode;
-extern uint8 BMS28_HVCmd;
-extern uint8 BMS28_ChgSts;
-extern uint8 BMS28_HVRelaySts;
-extern uint8 BMS28_SetTemp;
-extern uint8 BMS28_Life;
-extern uint8 BMS28_CRC;
-extern uint8 TMS_WorkStatus;
-extern uint8 TMS_HVRelayST;
-extern uint8 TMS_OutletTemp;
-extern uint8 TMS_InletTemp;
-extern uint8 TMS_Version;
-extern uint8 TMS_ErrCode;
-extern uint8 TMS_FaultLevel;
-extern uint8 BCU_SnMsgFlag;
-extern uint16 BMS_Cell_Volt[384];
-extern uint16 BMS11_PackOutsideVolt;
-extern uint16 BMS2_PackCurrent;
-extern uint16 BMS2_PackInsideVolt;
-extern uint16 BMS4_PosIsolation;
-extern uint16 BMS4_NegIsolation;
-extern uint16 BMS4_SysInsRes;
-extern uint16 BMS6_Max_Ucell;
-extern uint16 BMS6_Min_Ucell;
-extern uint16 BMS6_Avg_Ucell;
-extern uint16 BMS6_SOE;
-extern uint16 BMS7_MaxUcellNr;
-extern uint16 BMS7_MinUcellNr;
-extern uint16 BMS23_RemainChgTi;
-extern uint16 BMS21_RateCap;
-extern uint16 BMS21_RateHVolt;
-extern uint16 BMS21_RatePower;
-extern uint16 BMS9_PackTotCellNum;
-extern uint16 BMS22_PackAvaiMaxVolt;
-extern uint16 BMS22_PackAvaiMinVolt;
-extern uint16 BMS_SoftwareVersion;
-extern uint16 BMS_HardwareVersion;
-extern uint16 BMS3_MaxDischgPow;
-extern uint16 BMS3_MaxChgPow;
-extern uint16 BMS3_MaxInstantDischgPow;
-extern uint16 BMS3_MaxiInstantChgPow;
-extern uint16 BMS5_DischgCurMaxAllw;
-extern uint16 BMS5_ChrgCurMaxAllw;
-extern uint16 BMS5_InstChrgCurMaxAllw;
-extern uint16 BMS5_InstDischrgCurMaxAllw;
-extern uint16 BMS26_Bat_InstantConsume;
-extern uint16 BMS26_Bat_TotalConsume;
-extern uint16 BMS26_ChgReqVoltage;
-extern uint16 BMS26_ChgReqCurrent;
-extern uint16 BMS28_HVVolt;
-extern uint16 TMS_ReqPow;
-extern uint32 BMS1_RechrgCycels;
-extern uint32 BMS14_TotalChargeAh;
-extern uint32 BMS14_TotalDischargeAh;
-extern uint32 BMS15_TotalChargeKwh;
-extern uint32 BMS15_TotalDischargeKwh;
-extern uint32 BMS16_TotalEneryECOChargeAh;
-extern uint32 BMS16_TotalEneryECOChargeKwh;
-extern uint32 BMS17_TotalStationChargeAh;
-extern uint32 BMS17_TotalStationChargeKwh;
-extern uint32 BMS18_TotalPoleChargeAh;
-extern uint32 BMS18_TotalPoleChargeKwh;
-extern uint32 BMS19_SingleChargeAh;
-extern uint32 BMS19_SingleChargeKwh;
+extern UINT32 BcuInTable[28];
+extern BOOL BcuRxShortError[28];
+extern BOOL BcuRxLongError[28];
+extern UINT8 BcuRxErrorCounter[28];
+extern UINT8 BcuRxFlag[28];
+extern UINT8 BMS_ReqVIN;
+extern UINT8 BMS_ReqHVOff;
+extern UINT8 BMS_ProtocolEditionH;
+extern UINT8 BMS_ProtocolEditionL;
+extern UINT8 BMS_CharDevNum;
+extern UINT8 BMS_FtPosRly;
+extern UINT8 BMS_FtNegRly;
+extern UINT8 BMS_FtPosCharRly1;
+extern UINT8 BMS_FtNegCharRly1;
+extern UINT8 BMS_FtPosCharRly2;
+extern UINT8 BMS_FtNegCharRly2;
+extern UINT8 BMS_FtHeatRly1;
+extern UINT8 BMS_FtHeatRly2;
+extern UINT8 BMS_StPosRly;
+extern UINT8 BMS_StNegRly;
+extern UINT8 BMS_StPreCharRly;
+extern UINT8 BMS_StPosCharRly1;
+extern UINT8 BMS_StNegCharRly1;
+extern UINT8 BMS_StPosCharRly2;
+extern UINT8 BMS_StNegCharRly2;
+extern UINT8 BMS_FtAuxRelayWeld;
+extern UINT8 BMS_BraOpenCirc;
+extern UINT8 BMS_FtBackCharCurrOutLim;
+extern UINT8 BMS_FtPosRlyOpen;
+extern UINT8 BMS_FtNegRlyOpen;
+extern UINT8 BMS_FtPosCharRly1Open;
+extern UINT8 BMS_FtPosCharRly2Open;
+extern UINT8 BMS_FtNegCharRly1Open;
+extern UINT8 BMS_FtNegCharRly2Open;
+extern UINT8 BMS_FtTMSContClose;
+extern UINT8 BMS_FtTMSContOpen;
+extern UINT8 BMS_FtTMS;
+extern UINT8 BMS_Ft24VSpy;
+extern UINT8 BMS_FtPACKSelfProt;
+extern UINT8 BMS_FtCharSockTempOver;
+extern UINT8 BMS_FtTempOutCtrl;
+extern UINT8 BMS_StPosHeatRly;
+extern UINT8 BMS_StNegHeatRly;
+extern UINT8 BMS_CharSysNum;
+extern UINT8 BMS_FtCode;
+extern UINT8 BMS_ST1CheckSum;
+extern UINT8 BMS_ST1Counter;
+extern UINT8 BMS_Mode;
+extern UINT8 BMS_AuxRlySt;
+extern UINT8 BMS_BattBalaSt;
+extern UINT8 BMS_CharGunSt;
+extern UINT8 BMS_CharMode;
+extern UINT8 BMS_CharSt;
+extern UINT8 BMS_FtLvl;
+extern UINT8 BMS_FtCellTempDiff;
+extern UINT8 BMS_FtCellTempHigh;
+extern UINT8 BMS_FtPACKOverVolt;
+extern UINT8 BMS_FtPACKUndeVolt;
+extern UINT8 BMS_FtSOCLow;
+extern UINT8 BMS_FtCellOverVolt;
+extern UINT8 BMS_FtCellUndeVolt;
+extern UINT8 BMS_FtIns;
+extern UINT8 BMS_FtCellOverVoltDiff;
+extern UINT8 BMS_FtCharCurrOver;
+extern UINT8 BMS_FtDisCharCurrOver;
+extern UINT8 BMS_FtCellTempLow;
+extern UINT8 BMS_FtBranVoltDifOver;
+extern UINT8 BMS_FtBMSHardWare;
+extern UINT8 BMS_FtSOCHigh;
+extern UINT8 BMS_FtSOCJump;
+extern UINT8 BMS_FtInCom;
+extern UINT8 BMS_FtSysMism;
+extern UINT8 BMS_FtHvIntLock;
+extern UINT8 BMS_FtSmoke;
+extern UINT8 BMS_FtFire;
+extern UINT8 BMS_FtNum;
+extern UINT8 BMS_PackSOC;
+extern UINT8 BMS_PackSOH;
+extern UINT8 BMS_MaxCellTemp;
+extern UINT8 BMS_MinCellTemp;
+extern UINT8 BMS_AverCellTemp;
+extern UINT8 BMS_MaxCellTempCSC;
+extern UINT8 BMS_MaxCellTempNum;
+extern UINT8 BMS_MinCellTempCSC;
+extern UINT8 BMS_MinCellTempNum;
+extern UINT8 BMS_MaxCellVoltCSC;
+extern UINT8 BMS_MaxCellVoltNum;
+extern UINT8 BMS_MinCellVoltCSC;
+extern UINT8 BMS_MinCellVoltNum;
+extern UINT8 BMS_InsDeteSt;
+extern UINT8 BMS_FtCharInsLow;
+extern UINT8 BMS_FtCurrSenr;
+extern UINT8 BMS_FtHeatingFilm;
+extern UINT8 BMS_FtMainLoopPreChar;
+extern UINT8 BMS_FtAuxLoopPreChar;
+extern UINT8 BMS_FtACANLost;
+extern UINT8 BMS_FtDCDC;
+extern UINT8 BMS_FtSOCDif;
+extern UINT8 BMS_FtCellOverDisChar;
+extern UINT8 BMS_FtCharOver;
+extern UINT8 BMS_FtContDisCharCurrOverLoad;
+extern UINT8 BMS_FtContCharCurrOverLoad;
+extern UINT8 BMS_Gun1DCNegTemp;
+extern UINT8 BMS_Gun1DCPosTemp;
+extern UINT8 BMS_Gun2DCNegTemp;
+extern UINT8 BMS_Gun2DCPosTemp;
+extern UINT8 BMS_CurrHeatSt;
+extern UINT8 BMS_CurrCoolSt;
+extern UINT8 BMS_FtCharCnct;
+extern UINT8 BMS_FtOverDisCharCurrDuringChar;
+extern UINT8 BMS_FtCharNTC;
+extern UINT8 BMS_FtELock;
+extern UINT8 BMS_CellVoltFramNum;
+extern UINT8 BMS_CellTempFramNum;
+extern UINT8 BMS_CSC_Code;
+extern UINT8 BMS_CellTemp[BMS_TEMP_MAX_NUM];
+extern UINT8 BMS_Checksum;
+extern UINT8 BMS_PackComp;
+extern UINT8 BMS_BattCodeLeng;
+extern UINT8 BMS_SN[27];
+extern UINT8 BMS_BattType;
+extern UINT8 BMS_CoolType;
+extern UINT8 BMS_CSC_Total;
+extern UINT8 BMS_CellVoltLevel;
+extern UINT8 BMS_CellMinVolt;
+extern UINT8 BMS_CellMaxVolt;
+extern UINT8 BMS_HVBranNum;
+extern UINT8 BMS_SingleHVBranchCellNum;
+extern UINT8 BMS_ReqMode;
+extern UINT8 BMS_HVCmd;
+extern UINT8 BMS_ChgSts;
+extern UINT8 BMS_HVRelaySts;
+extern UINT8 BMS_SetTemp;
+extern UINT8 BMS_Life;
+extern UINT8 BMS_CRC;
+extern UINT8 TMS_WorkStatus;
+extern UINT8 TMS_HVRelayST;
+extern UINT8 TMS_OutletTemp;
+extern UINT8 TMS_InletTemp;
+extern UINT8 TMS_ErrCode;
+extern UINT8 TMS_FaultLevel;
+extern UINT16 BMS_SoftwareVersion;
+extern UINT16 BMS_HardwareVersion;
+extern UINT16 BMS_PackCurr;
+extern UINT16 BMS_MaxCharCurr;
+extern UINT16 BMS_MaxDisCharCurr;
+extern UINT16 BMS_PosIns;
+extern UINT16 BMS_NegIns;
+extern UINT16 BMS_BattVolt;
+extern UINT16 BMS_LinkVolt;
+extern UINT16 BMS_MaxCellVolt;
+extern UINT16 BMS_AverCellVolt;
+extern UINT16 BMS_MinCellVolt;
+extern UINT16 BMS_ContChrgCurr;
+extern UINT16 BMS_ContDisCharCurr;
+extern UINT16 BMS_CharReqVolt;
+extern UINT16 BMS_CharReqCurr;
+extern UINT16 BMS_SysInsRes;
+extern UINT16 BMS_MaxDisCharPwr;
+extern UINT16 BMS_MaxCharPwr;
+extern UINT16 BMS_ContDisCharPwr;
+extern UINT16 BMS_ContCharPwr;
+extern UINT16 BMS_InstEngyCons;
+extern UINT16 BMS_TotalEngyCons;
+extern UINT16 BMS_SOE;
+extern UINT16 BMS_RmanCharTime;
+extern UINT16 BMS_CharNum;
+extern UINT16 BMS_CellVolt[BMS_CELL_MAX_NUM];
+extern UINT16 BMS_BattRateCap;
+extern UINT16 BMS_BattRateVolt;
+extern UINT16 BMS_BattRateEngy;
+extern UINT16 BMS_CellTotal;
+extern UINT16 BMS_TempTotal;
+extern UINT16 BMS_SingleCharEngy;
+extern UINT16 BMS_SingleCharCapy;
+extern UINT16 BMS_HVVolt;
+extern UINT16 TMS_ReqPow;
+extern UINT32 BMS_TotalCharEngy;
+extern UINT32 BMS_TotalDisCharEngy;
+extern UINT32 BMS_TotalBackCharEngy;
+extern UINT32 BMS_TotalStaCharEngy;
+extern UINT32 BMS_TotalGunCharEngy;
+extern UINT32 BMS_TotalGunCharCapy;
+extern UINT32 BMS_TotalCharCapy;
+extern UINT32 BMS_TotalDisCharCapy;
+extern UINT32 BMS_TotalBackCharCapy;
+extern UINT32 BMS_TotalStaCharCapy;
 #endif
 #endif /* APPGLOBALVAR_H_ */

src/AppTaskUart1.c

@@ -3,7 +3,7 @@
  * @Date         : 2022-02-10 11:43:56
  * @Version      : V3.0
  * @LastEditors  : ChenJie
- * @LastEditTime : 2022-02-23 15:51:23
+ * @LastEditTime : 2022-05-17 17:49:46
  * @Description  : file content
  * @FilePath     : \S32K146_4G\src\AppTaskUart1.c
  */
@@ -38,7 +38,8 @@ sint8 TcpRegisterChkFunc(void);
 void TcpDataEncode(uint32 *PtrSendAddr, uint16 *SendLen);
 void GetUtc8Time(UTC8TimeType *UTC8TimeTcp);
 static void AtcmdTransmit(sint8 CmdIdx, uint8 *SetValuePtr, uint16 SetValueLen, sint8 *retFunc);
-static void TcpDataInfoRecvHandle(uint8 *DataRecv,uint16 DataRecvLen);
+static void TcpDataInfoRecvHandle(uint8 *DataRecv, uint16 DataRecvLen);
+static void GetCSQValue(uint8 *out);
 void Uart_4G_Task(void *pvParameters)
 {
 	(void)pvParameters;
@@ -59,20 +60,21 @@ void Uart_4G_Task(void *pvParameters)
 		{
 		case PROCESS_TCP_IDLE: //空闲状态
 		{
-			vTaskDelay(pdMS_TO_TICKS(10));
+			Dio_WriteChannel(DioConf_DioChannel_PTE0_GPIO_OUT_MCU_LED1,STD_OFF);
+			memset(RX_Buffer[UART_LPUART1], 0x00, sizeof(RX_Buffer[UART_LPUART1]));
+			UART_Receive_Data(UART_LPUART1, RX_Buffer[UART_LPUART1], &pReadLen, 50);//10ms检测
 			if (SocketId < 0)
 			{
 				PROC_TCP_STATE_SWITCH(PROCESS_TCP_REGCHK);
 			}
-			else if ((TimerCounter -SendTimerCounter)>1000 && AppConfigInfo.eolFlg==1)
+			else if (pReadLen>0)
 			{
-				SendTimerCounter = TimerCounter;
-				PROC_TCP_STATE_SWITCH(PROCESS_TCP_SEND);
-				//Dio_FlipChannel(DioConf_DioChannel_PTE7_GPIO_OUT_MCU_LED3);
+				PROC_TCP_STATE_SWITCH(PROCESS_TCP_RECV);
 			}
-			else if (TimerCounter % 100 == 0)
+			else if (AppConfigInfo.eolFlg == 1 && (TimerCounter - SendTimerCounter) >= 1000 && TcpWorkState==0)
 			{
-				PROC_TCP_STATE_SWITCH(PROCESS_TCP_RECV);
+				SendTimerCounter = TimerCounter;
+				PROC_TCP_STATE_SWITCH(PROCESS_TCP_SEND);
 			}
 			break;
 		}
@@ -122,6 +124,7 @@ void Uart_4G_Task(void *pvParameters)
 		}
 		case PROCESS_TCP_SEND: //网络数据发送
 		{
+			Dio_WriteChannel(DioConf_DioChannel_PTE0_GPIO_OUT_MCU_LED1,STD_ON);
 			sint8 SendRet = -1;
 			SendRet = TcpDataSendFunc(SocketId);
 			if (SendRet == 0)
@@ -137,11 +140,9 @@ void Uart_4G_Task(void *pvParameters)
 		}
 		case PROCESS_TCP_RECV: //网络数据接收,100ms空闲状态下即可接收
 		{
-			memset(RX_Buffer[UART_LPUART1],0x00,sizeof(RX_Buffer[UART_LPUART1]));
-			UART_Receive_Data(UART_LPUART1,RX_Buffer[UART_LPUART1],&pReadLen,100);
-			if(pReadLen>0&&SocketId>=0)
+			if (pReadLen > 0 && SocketId >= 0)
 			{
-				TcpDataInfoRecvHandle(RX_Buffer[UART_LPUART1],pReadLen);
+				TcpDataInfoRecvHandle(RX_Buffer[UART_LPUART1], pReadLen);
 			}
 			PROC_TCP_STATE_SWITCH(PROCESS_TCP_IDLE);
 			break;
@@ -156,10 +157,10 @@ void Uart_4G_Task(void *pvParameters)
 		}
 		case PROCESS_TCP_ERROR: //错误状态
 		{
-//			Dio_WriteChannel(DioConf_DioChannel_PTA7_GPIO_OUT_MCU_4G_PWRKEY, STD_OFF);
-//			vTaskDelay(pdMS_TO_TICKS(100));
+			//			Dio_WriteChannel(DioConf_DioChannel_PTA7_GPIO_OUT_MCU_4G_PWRKEY, STD_OFF);
+			//			vTaskDelay(pdMS_TO_TICKS(100));
 			PROC_TCP_STATE_SWITCH(PROCESS_TCP_IDLE);
-//			Dio_WriteChannel(DioConf_DioChannel_PTA7_GPIO_OUT_MCU_4G_PWRKEY, STD_ON);
+			//			Dio_WriteChannel(DioConf_DioChannel_PTA7_GPIO_OUT_MCU_4G_PWRKEY, STD_ON);
 			break;
 		}
 		}
@@ -176,7 +177,7 @@ sint8 TcpDataSendFunc(sint8 ConnectId)
 	{
 		return 0; //暂时无数据可以发
 	}
-	outValue = tcpipConnectionSend(ConnectId,(uint8 *)pSendDataAddr,DataSendLen);//发送函数
+	outValue = tcpipConnectionSend(ConnectId, (uint8 *)pSendDataAddr, DataSendLen); //发送函数
 	if (pSendDataAddr != 0)
 	{
 		free((uint8 *)(pSendDataAddr));
@@ -271,7 +272,7 @@ sint8 TcpConnectFunc(sint8 *ConnectId)
 		}
 		case 4: //创建连接
 		{
-			char AtCmdSend[20] = {0};
+			char AtCmdSend[40] = {0};
 			uint8 AtCmdSendTotalLen = 0;
 			*ConnectId = 0;
 			sprintf(AtCmdSend, "%d,\"TCP\",%s,%d\r\n", *ConnectId, WebSiteIp, WebSitePort); //此处需要优化
@@ -596,7 +597,7 @@ sint8 at_callbackFunc(char *PSendStr, char *pReadStr, uint8 CmdIdx, uint16 pRead
 			{
 				if (*(retptr - i) == ',')
 				{
-					memcpy(WebSiteIp, retptr - i + 1, 15);
+					memcpy(WebSiteIp, retptr - i + 1, i-5);
 					OutValue = 0;
 					break;
 				}
@@ -767,12 +768,12 @@ void TcpDataEncode(uint32 *PtrSendAddr, uint16 *SendLen)
 		VerMsgToTcpInfo.VerInfo.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF;
 		memcpy(VerMsgToTcpInfo.VerInfo.ICCID, IccidNum, 20);
 		memcpy(VerMsgToTcpInfo.VerInfo.IMEI, ImeiNum, 15);
-		VerMsgToTcpInfo.VerInfo.BMSHwVersion[0] = bmsHwVersion>>8;
-		VerMsgToTcpInfo.VerInfo.BMSHwVersion[1] = bmsHwVersion;
-		VerMsgToTcpInfo.VerInfo.BMSSwVersion[0] = bmsSwVersion>>24;
-		VerMsgToTcpInfo.VerInfo.BMSSwVersion[1] = bmsSwVersion>>16;
-		VerMsgToTcpInfo.VerInfo.BMSSwVersion[2] = bmsSwVersion>>8;
-		VerMsgToTcpInfo.VerInfo.BMSSwVersion[3] = bmsSwVersion;
+		VerMsgToTcpInfo.VerInfo.BMSHwVersion[0] = BMS_HardwareVersion >> 8;
+		VerMsgToTcpInfo.VerInfo.BMSHwVersion[1] = BMS_HardwareVersion;
+		VerMsgToTcpInfo.VerInfo.BMSSwVersion[0] = BMS_SoftwareVersion >> 24;
+		VerMsgToTcpInfo.VerInfo.BMSSwVersion[1] = BMS_SoftwareVersion >> 16;
+		VerMsgToTcpInfo.VerInfo.BMSSwVersion[2] = BMS_SoftwareVersion >> 8;
+		VerMsgToTcpInfo.VerInfo.BMSSwVersion[3] = BMS_SoftwareVersion;
 		VerMsgToTcpInfo.VerInfo.HwVersion[0] = (HWVERSION >> 8) & 0xFF;
 		VerMsgToTcpInfo.VerInfo.HwVersion[1] = (HWVERSION)&0xFF;
 		VerMsgToTcpInfo.VerInfo.BLVersion[0] = (BLSWVERSION >> 24) & 0xFF;
@@ -831,19 +832,19 @@ void TcpDataEncode(uint32 *PtrSendAddr, uint16 *SendLen)
 		*(SendBuffer + 0x3C) = ((ODO >> 16) & 0xFF);
 		*(SendBuffer + 0x3D) = ((ODO >> 8) & 0xFF);
 		*(SendBuffer + 0x3E) = (ODO & 0xFF);
-		*(SendBuffer + 0x3F) = (dcdcWorkStatus & 0xFF);			// uint8 DCDC状态
-		*(SendBuffer + 0x40) = (numOfChrgableSubsys & 0xFF);	// uint8	可充电子系统数
-		*(SendBuffer + 0x41) = (chrgableSubsysCode & 0xFF);		// uint8	可充电储能子系统号
-		*(SendBuffer + 0x42) = (BMS8_MaxTempSysNr & 0xFF);		// uint8	最高温度子系统号 精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x43) = (BMS8_MaxTempNr & 0xFF);			// uint8	最高温度探针单体代号 精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x44) = (BMS8_MinTempSysNr & 0xFF);		// uint8	最低温度子系统号 精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x45) = (BMS8_MinTempNr & 0xFF);			// uint8	最低温度探针子系统代号 精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x46) = (BMS7_MaxUcellSysNr & 0xFF);		// uint8	最高电压电池子系统号 精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x47) = ((BMS7_MaxUcellNr >> 8) & 0xFF); // uint16	最高电压电池单体代号 精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x48) = (BMS7_MaxUcellNr & 0xFF);
-		*(SendBuffer + 0x49) = (BMS7_MinUcellSysNr & 0xFF);		// uint8	最低电压电池子系统号 精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x4A) = ((BMS7_MinUcellNr >> 8) & 0xFF); // uint16	最低电压电池单体代号 精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x4B) = (BMS7_MinUcellNr & 0xFF);
+		*(SendBuffer + 0x3F) = (dcdcWorkStatus & 0xFF);			   // uint8 DCDC状态
+		*(SendBuffer + 0x40) = (numOfChrgableSubsys & 0xFF);	   // uint8	可充电子系统数
+		*(SendBuffer + 0x41) = (chrgableSubsysCode & 0xFF);		   // uint8	可充电储能子系统号
+		*(SendBuffer + 0x42) = (BMS_MaxCellTempCSC & 0xFF);		   // uint8	最高温度子系统号 精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x43) = (BMS_MaxCellTempNum & 0xFF);		   // uint8	最高温度探针单体代号 精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x44) = (BMS_MinCellTempCSC & 0xFF);		   // uint8	最低温度子系统号 精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x45) = (BMS_MinCellTempNum & 0xFF);		   // uint8	最低温度探针子系统代号 精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x46) = (BMS_MaxCellVoltCSC & 0xFF);		   // uint8	最高电压电池子系统号 精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x47) = ((BMS_MaxCellVoltNum >> 8) & 0xFF); // uint16	最高电压电池单体代号 精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x48) = (BMS_MaxCellVoltNum & 0xFF);
+		*(SendBuffer + 0x49) = (BMS_MinCellVoltCSC & 0xFF);		   // uint8	最低电压电池子系统号 精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x4A) = ((BMS_MinCellVoltNum >> 8) & 0xFF); // uint16	最低电压电池单体代号 精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x4B) = (BMS_MinCellVoltNum & 0xFF);
 		*(SendBuffer + 0x4C) = (ebcStatus & 0xFF); // uint8 换电控制器状态
 		*(SendBuffer + 0x4D) = (uint8)((ebcAskHVOn & 0x01) | ((ebcAskHVOff & 0x01) << 1) | ((retainLockSignal & 0x01) << 3) | ((dischargeLockSignal & 0x01) << 5) | ((chargeLockSignal & 0x01) << 6));
 		*(SendBuffer + 0x4E) = (chargeFlag & 0xFF);		 // uint8 充电标志位
@@ -855,7 +856,16 @@ void TcpDataEncode(uint32 *PtrSendAddr, uint16 *SendLen)
 	}
 	case 0x91:
 	{
-		*SendLen = 0x54 + 384 * 2 + 64;
+		GetCSQValue(&CSQValue);
+		if (BMS_Mode == 1)
+		{
+			BMS_Mode = 2;
+		}
+		else
+		{
+			BMS_Mode = 1;
+		}
+		*SendLen = 0x54 + BMS_CELL_MAX_NUM * 2 + BMS_TEMP_MAX_NUM;
 		SendBuffer = malloc(*SendLen);
 		*(SendBuffer + 0) = TCP_START_SYM1;
 		*(SendBuffer + 1) = TCP_START_SYM2;
@@ -863,56 +873,61 @@ void TcpDataEncode(uint32 *PtrSendAddr, uint16 *SendLen)
 		*(SendBuffer + 3) = TCP_ANS_SYM;
 		memcpy(SendBuffer + 4, TcpbattSN, BATT_SN_LEN);
 		*(SendBuffer + 0x15) = (TCP_ENCPT_DISABLE & 0xFF); // uint8	TCP_ENCPT_DISABLE
-		uint16 DataLen = 0x3B + 384 * 2 + 64;
+		uint16 DataLen = 0x3B + BMS_CELL_MAX_NUM * 2 + BMS_TEMP_MAX_NUM;
 		*(SendBuffer + 0x16) = ((DataLen >> 8) & 0xFF); // uint16	DataLen
 		*(SendBuffer + 0x17) = (DataLen & 0xFF);
-		*(SendBuffer + 0x18) = ((UTC8TimeTcp.year) & 0xFF);		  // uint8	year
-		*(SendBuffer + 0x19) = (UTC8TimeTcp.month & 0xFF);		  // uint8	month
-		*(SendBuffer + 0x1A) = (UTC8TimeTcp.day & 0xFF);		  // uint8	day
-		*(SendBuffer + 0x1B) = (UTC8TimeTcp.hour & 0xFF);		  // uint8	hour
-		*(SendBuffer + 0x1C) = (UTC8TimeTcp.minute & 0xFF);		  // uint8	minute
-		*(SendBuffer + 0x1D) = (UTC8TimeTcp.second & 0xFF);		  // uint8	second
-		*(SendBuffer + 0x1E) = (DataIdx & 0xFF);				  // uint8	BATTMSG
-		*(SendBuffer + 0x1F) = ((UTC8TimeTcp.year) & 0xFF);		  // uint8	year
-		*(SendBuffer + 0x20) = (UTC8TimeTcp.month & 0xFF);		  // uint8	month
-		*(SendBuffer + 0x21) = (UTC8TimeTcp.day & 0xFF);		  // uint8	day
-		*(SendBuffer + 0x22) = (UTC8TimeTcp.hour & 0xFF);		  // uint8	hour
-		*(SendBuffer + 0x23) = (UTC8TimeTcp.minute & 0xFF);		  // uint8	minute
-		*(SendBuffer + 0x24) = (UTC8TimeTcp.second & 0xFF);		  // uint8	second
-		*(SendBuffer + 0x25) = (CSQValue & 0xFF);				  // uint8	csq
-		*(SendBuffer + 0x26) = (BMS1_SysSts & 0xFF);			  // uint8	电池管理系统工作状态，0-初始化 1-自检完成允许上电 2-运行状态 3-高压切断 4-故障状态，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x27) = (BMS1_DCChrgConnectSt & 0xFF);	  // uint8	直流充电枪连接状态，0-未连接 1-单枪连接 2-双枪连接 3-无效，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x28) = (BMS2_FaultLevel & 0xFF);		  // uint8	当前最高故障等级，0-正常 1-1级 轻微故障 2-2级 较严重故障 3-3级 最严重故障，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x29) = (BMS2_FaultCode & 0xFF);			  // uint8	故障码，见BMS_ErrCode，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x2A) = (BMS2_RqHVPoerOff & 0xFF);		  // uint8	BMS下高压请求，0-无效 1-请求下高压 2-不请求下高压 3-无效，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x2B) = (BMS1_ChrgStatus & 0xFF);		  // uint8	充电状态，0-未充电 1-充电中 2-充电已完成 3-充电错误故障，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x2C) = (BMS2_SOC & 0xFF);				  // uint8	电池包SOC 精度_0.4，偏移量_0，单位_*(SendBuffer+0x2D)	=	(BMS2_SOH&0xFF);		//uint8	电池包SOH 精度_0.4，偏移量_0，单位_*(SendBuffer+0x2E)	=	((BMS2_PackInsideVolt>>8)&0xFF);		//uint16	电池包内侧电压 精度_0.1，偏移量_0，单位_V
-		*(SendBuffer + 0x2D) = (BMS2_SOH / 25 * 10) & 0xFF;		  // SOH 精度1%
-		*(SendBuffer + 0x2E) = (BMS2_PackInsideVolt >> 8) & 0xFF; //电池包总电压
-		*(SendBuffer + 0x2F) = (BMS2_PackInsideVolt & 0xFF);
-		*(SendBuffer + 0x30) = ((BMS2_PackCurrent >> 8) & 0xFF); // uint16	电池包总电流，充电为负值，放电为正值 精度_0.1，偏移量_-1000，单位_A
-		*(SendBuffer + 0x31) = (BMS2_PackCurrent & 0xFF);
-		*(SendBuffer + 0x32) = ((BMS4_SysInsRes >> 8) & 0xFF); // uint16	系统绝缘电阻 精度_1，偏移量_0，单位_KΩ
-		*(SendBuffer + 0x33) = (BMS4_SysInsRes & 0xFF);
-		*(SendBuffer + 0x34) = (BMS1_MainPosRelaySt & 0xFF);	// uint8	主正继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x35) = (BMS1_PreChgRelaySt & 0xFF);		// uint8	预充继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x36) = (BMS1_MainNegRelaySt & 0xFF);	// uint8	主负继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x37) = (BMS1_DCChrgPos1RelaySt & 0xFF); // uint8	直流充正继电器1状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x38) = (BMS1_DCChrgNeg1RelaySt & 0xFF); // uint8	直流充负继电器1状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x39) = (BMS1_DCChrgPos2RelaySt & 0xFF); // uint8	直流充正继电器2状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x3A) = (BMS1_DCChrgNeg2RelaySt & 0xFF); // uint8	直流充负继电器2状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x3B) = (BMS1_HeatPosRelaySt & 0xFF);	// uint8	加热正继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-		*(SendBuffer + 0x3C) = (BMS1_HeatNegRelaySt & 0xFF);	// uint8	加热负继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
-
-		*(SendBuffer + 0x50) = ((BMS9_PackTotCellNum >> 8) & 0xFF); // uint16	PACK中单体电芯的总数目
-		*(SendBuffer + 0x51) = (BMS9_PackTotCellNum & 0xFF);
-		for (uint16 index = 0; index < BMS9_PackTotCellNum; index++)
+		*(SendBuffer + 0x18) = ((UTC8TimeTcp.year) & 0xFF);	   // uint8	year
+		*(SendBuffer + 0x19) = (UTC8TimeTcp.month & 0xFF);	   // uint8	month
+		*(SendBuffer + 0x1A) = (UTC8TimeTcp.day & 0xFF);	   // uint8	day
+		*(SendBuffer + 0x1B) = (UTC8TimeTcp.hour & 0xFF);	   // uint8	hour
+		*(SendBuffer + 0x1C) = (UTC8TimeTcp.minute & 0xFF);	   // uint8	minute
+		*(SendBuffer + 0x1D) = (UTC8TimeTcp.second & 0xFF);	   // uint8	second
+		*(SendBuffer + 0x1E) = (DataIdx & 0xFF);			   // uint8	BATTMSG
+		*(SendBuffer + 0x1F) = ((UTC8TimeTcp.year) & 0xFF);	   // uint8	year
+		*(SendBuffer + 0x20) = (UTC8TimeTcp.month & 0xFF);	   // uint8	month
+		*(SendBuffer + 0x21) = (UTC8TimeTcp.day & 0xFF);	   // uint8	day
+		*(SendBuffer + 0x22) = (UTC8TimeTcp.hour & 0xFF);	   // uint8	hour
+		*(SendBuffer + 0x23) = (UTC8TimeTcp.minute & 0xFF);	   // uint8	minute
+		*(SendBuffer + 0x24) = (UTC8TimeTcp.second & 0xFF);	   // uint8	second
+		*(SendBuffer + 0x25) = (CSQValue & 0xFF);			   // uint8	csq
+		*(SendBuffer + 0x26) = (BMS_Mode & 0xFF);			   // uint8	电池管理系统工作状态，0-初始化 1-自检完成允许上电 2-运行状态 3-高压切断 4-故障状态，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x27) = (BMS_CharGunSt & 0xFF);		   // uint8	直流充电枪连接状态，0-未连接 1-单枪连接 2-双枪连接 3-无效，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x28) = (BMS_FtLvl & 0xFF);			   // uint8	当前最高故障等级，0-正常 1-1级 轻微故障 2-2级 较严重故障 3-3级 最严重故障，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x29) = (BMS_FtCode & 0xFF);			   // uint8	故障码，见BMS_ErrCode，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x2A) = (BMS_ReqHVOff & 0xFF);		   // uint8	BMS下高压请求，0-无效 1-请求下高压 2-不请求下高压 3-无效，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x2B) = (BMS_CharSt & 0xFF);			   // uint8	充电状态，0-未充电 1-充电中 2-充电已完成 3-充电错误故障，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x2C) = (BMS_PackSOC & 0xFF);		   // uint8	电池包SOC 精度_0.4，偏移量_0，单位_
+		*(SendBuffer + 0x2D) = (BMS_PackSOH / 25 * 10) & 0xFF; // SOH 精度1%
+		*(SendBuffer + 0x2E) = (BMS_BattVolt >> 8) & 0xFF;	   //电池包总电压
+		*(SendBuffer + 0x2F) = (BMS_BattVolt & 0xFF);
+		*(SendBuffer + 0x30) = ((BMS_PackCurr >> 8) & 0xFF); // uint16	电池包总电流，充电为负值，放电为正值 精度_0.1，偏移量_-1000，单位_A
+		*(SendBuffer + 0x31) = (BMS_PackCurr & 0xFF);
+		*(SendBuffer + 0x32) = ((BMS_SysInsRes >> 8) & 0xFF); // uint16	系统绝缘电阻 精度_1，偏移量_0，单位_KΩ
+		*(SendBuffer + 0x33) = (BMS_SysInsRes & 0xFF);
+		/*28 Byte 继电器状态*/
+		*(SendBuffer + 0x34) = (BMS_StPosRly & 0xFF);	   // uint8	主正继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x35) = (BMS_StPreCharRly & 0xFF);  // uint8	预充继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x36) = (BMS_StNegRly & 0xFF);	   // uint8	主负继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x37) = 0;						   // 三合一
+		*(SendBuffer + 0x38) = 0;						   // PTC
+		*(SendBuffer + 0x39) = 0;						   // 空调
+		*(SendBuffer + 0x3A) = (BMS_StPosCharRly1 & 0xFF); // uint8	直流充正继电器1状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x3B) = (BMS_StNegCharRly1 & 0xFF); // uint8	直流充负继电器1状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x3C) = (BMS_StPosCharRly2 & 0xFF); // uint8	直流充正继电器2状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x3D) = (BMS_StNegCharRly2 & 0xFF); // uint8	直流充负继电器2状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x3E) = (BMS_StPosHeatRly & 0xFF);  // uint8	加热正继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x3F) = (BMS_StNegHeatRly & 0xFF);  // uint8	加热负继电器状态，0-预留 1-断开 2-吸合  ，精度_1，偏移量_0，单位_
+		*(SendBuffer + 0x40) = 0;
+		/*28-Byte继电器状态结束*/
+		*(SendBuffer + 0x50) = ((BMS_CellTotal >> 8) & 0xFF); // uint16	PACK中单体电芯的总数目
+		*(SendBuffer + 0x51) = (BMS_CellTotal & 0xFF);
+		for (uint16 index = 0; index < min(BMS_CellTotal,BMS_CELL_MAX_NUM); index++)
 		{
-			*(SendBuffer + 0x52 + index * 2) = ((BMS_Cell_Volt[index] >> 8) & 0xFF);
-			*(SendBuffer + 0x52 + index * 2 + 1) = ((BMS_Cell_Volt[index]) & 0xFF);
+			*(SendBuffer + 0x52 + index * 2) = ((BMS_CellVolt[index] >> 8) & 0xFF);
+			*(SendBuffer + 0x52 + index * 2 + 1) = ((BMS_CellVolt[index]) & 0xFF);
 		}
-		*(SendBuffer + 0x352) = (BMS9_PackTotTempNum & 0xFF); //  uint8	PACK中电芯温度点(探针)的总数目
-		memcpy(SendBuffer + 0x353, BMS_Cell_TempN, BMS9_PackTotTempNum);
+		*(SendBuffer + 0x352) = (BMS_TempTotal & 0xFF); //  uint8	PACK中电芯温度点(探针)的总数目
+		memcpy(SendBuffer + 0x353, BMS_CellTemp, min(BMS_TempTotal,BMS_TEMP_MAX_NUM));
 		*(SendBuffer + 0x393) = bcc_chk(SendBuffer, 0x393);
 		*PtrSendAddr = (uint32)SendBuffer;
 		break;
@@ -930,59 +945,59 @@ void TcpDataEncode(uint32 *PtrSendAddr, uint16 *SendLen)
 		uint16 DataLen = 0x35;
 		*(SendBuffer + 0x16) = ((DataLen >> 8) & 0xFF); // uint16	DataLen
 		*(SendBuffer + 0x17) = (DataLen & 0xFF);
-		*(SendBuffer + 0x18) = ((UTC8TimeTcp.year) & 0xFF);			 // uint8	year
-		*(SendBuffer + 0x19) = (UTC8TimeTcp.month & 0xFF);			 // uint8	month
-		*(SendBuffer + 0x1A) = (UTC8TimeTcp.day & 0xFF);			 // uint8	day
-		*(SendBuffer + 0x1B) = (UTC8TimeTcp.hour & 0xFF);			 // uint8	hour
-		*(SendBuffer + 0x1C) = (UTC8TimeTcp.minute & 0xFF);			 // uint8	minute
-		*(SendBuffer + 0x1D) = (UTC8TimeTcp.second & 0xFF);			 // uint8	second
-		*(SendBuffer + 0x1E) = (DataIdx & 0xFF);					 // uint8
-		*(SendBuffer + 0x1F) = ((UTC8TimeTcp.year) & 0xFF);			 // uint8	year
-		*(SendBuffer + 0x20) = (UTC8TimeTcp.month & 0xFF);			 // uint8	month
-		*(SendBuffer + 0x21) = (UTC8TimeTcp.day & 0xFF);			 // uint8	day
-		*(SendBuffer + 0x22) = (UTC8TimeTcp.hour & 0xFF);			 // uint8	hour
-		*(SendBuffer + 0x23) = (UTC8TimeTcp.minute & 0xFF);			 // uint8	minute
-		*(SendBuffer + 0x24) = (UTC8TimeTcp.second & 0xFF);			 // uint8	second
-		*(SendBuffer + 0x25) = ((BMS14_TotalChargeAh >> 24) & 0xFF); // uint32	累积充入Ah 数 精度_0.1，偏移量_0，单位_Ah
-		*(SendBuffer + 0x26) = ((BMS14_TotalChargeAh >> 16) & 0xFF);
-		*(SendBuffer + 0x27) = ((BMS14_TotalChargeAh >> 8) & 0xFF);
-		*(SendBuffer + 0x28) = (BMS14_TotalChargeAh & 0xFF);
-		*(SendBuffer + 0x29) = ((BMS14_TotalDischargeAh >> 24) & 0xFF); // uint32	累积放出Ah 数 精度_0.1，偏移量_0，单位_Ah
-		*(SendBuffer + 0x2A) = ((BMS14_TotalDischargeAh >> 16) & 0xFF);
-		*(SendBuffer + 0x2B) = ((BMS14_TotalDischargeAh >> 8) & 0xFF);
-		*(SendBuffer + 0x2C) = (BMS14_TotalDischargeAh & 0xFF);
-		*(SendBuffer + 0x2D) = ((BMS15_TotalChargeKwh >> 24) & 0xFF); // uint32	累计充入kWh 数 精度_0.1，偏移量_0，单位_KWh
-		*(SendBuffer + 0x2E) = ((BMS15_TotalChargeKwh >> 16) & 0xFF);
-		*(SendBuffer + 0x2F) = ((BMS15_TotalChargeKwh >> 8) & 0xFF);
-		*(SendBuffer + 0x30) = (BMS15_TotalChargeKwh & 0xFF);
-		*(SendBuffer + 0x31) = ((BMS15_TotalDischargeKwh >> 24) & 0xFF); // uint32	累计放出kWh 数 精度_0.1，偏移量_0，单位_KWh
-		*(SendBuffer + 0x32) = ((BMS15_TotalDischargeKwh >> 16) & 0xFF);
-		*(SendBuffer + 0x33) = ((BMS15_TotalDischargeKwh >> 8) & 0xFF);
-		*(SendBuffer + 0x34) = (BMS15_TotalDischargeKwh & 0xFF);
-		*(SendBuffer + 0x35) = ((BMS16_TotalEneryECOChargeAh >> 24) & 0xFF); // uint32	累计动能回馈充入Ah 数 精度_0.1，偏移量_0，单位_Ah
-		*(SendBuffer + 0x36) = ((BMS16_TotalEneryECOChargeAh >> 16) & 0xFF);
-		*(SendBuffer + 0x37) = ((BMS16_TotalEneryECOChargeAh >> 8) & 0xFF);
-		*(SendBuffer + 0x38) = (BMS16_TotalEneryECOChargeAh & 0xFF);
-		*(SendBuffer + 0x39) = ((BMS16_TotalEneryECOChargeKwh >> 24) & 0xFF); // uint32	累计动能回馈充入kWh 数 精度_0.1，偏移量_0，单位_KWh
-		*(SendBuffer + 0x3A) = ((BMS16_TotalEneryECOChargeKwh >> 16) & 0xFF);
-		*(SendBuffer + 0x3B) = ((BMS16_TotalEneryECOChargeKwh >> 8) & 0xFF);
-		*(SendBuffer + 0x3C) = (BMS16_TotalEneryECOChargeKwh & 0xFF);
-		*(SendBuffer + 0x3D) = ((BMS17_TotalStationChargeAh >> 24) & 0xFF); // uint32	累计换电站充入Ah 数 精度_0.1，偏移量_0，单位_Ah
-		*(SendBuffer + 0x3E) = ((BMS17_TotalStationChargeAh >> 16) & 0xFF);
-		*(SendBuffer + 0x3F) = ((BMS17_TotalStationChargeAh >> 8) & 0xFF);
-		*(SendBuffer + 0x40) = (BMS17_TotalStationChargeAh & 0xFF);
-		*(SendBuffer + 0x41) = ((BMS17_TotalStationChargeKwh >> 24) & 0xFF); // uint32	累计换电站充入kWh 数 精度_0.1，偏移量_0，单位_KWh
-		*(SendBuffer + 0x42) = ((BMS17_TotalStationChargeKwh >> 16) & 0xFF);
-		*(SendBuffer + 0x43) = ((BMS17_TotalStationChargeKwh >> 8) & 0xFF);
-		*(SendBuffer + 0x44) = (BMS17_TotalStationChargeKwh & 0xFF);
-		*(SendBuffer + 0x45) = ((BMS18_TotalPoleChargeAh >> 24) & 0xFF); // uint32	累计插枪充电充入Ah 数 精度_0.1，偏移量_0，单位_Ah
-		*(SendBuffer + 0x46) = ((BMS18_TotalPoleChargeAh >> 16) & 0xFF);
-		*(SendBuffer + 0x47) = ((BMS18_TotalPoleChargeAh >> 8) & 0xFF);
-		*(SendBuffer + 0x48) = (BMS18_TotalPoleChargeAh & 0xFF);
-		*(SendBuffer + 0x49) = ((BMS18_TotalPoleChargeKwh >> 24) & 0xFF); // uint32	累计插枪充电充入kWh 数 精度_0.1，偏移量_0，单位_KWh
-		*(SendBuffer + 0x4A) = ((BMS18_TotalPoleChargeKwh >> 16) & 0xFF);
-		*(SendBuffer + 0x4B) = ((BMS18_TotalPoleChargeKwh >> 8) & 0xFF);
-		*(SendBuffer + 0x4C) = (BMS18_TotalPoleChargeKwh & 0xFF);
+		*(SendBuffer + 0x18) = ((UTC8TimeTcp.year) & 0xFF);		   // uint8	year
+		*(SendBuffer + 0x19) = (UTC8TimeTcp.month & 0xFF);		   // uint8	month
+		*(SendBuffer + 0x1A) = (UTC8TimeTcp.day & 0xFF);		   // uint8	day
+		*(SendBuffer + 0x1B) = (UTC8TimeTcp.hour & 0xFF);		   // uint8	hour
+		*(SendBuffer + 0x1C) = (UTC8TimeTcp.minute & 0xFF);		   // uint8	minute
+		*(SendBuffer + 0x1D) = (UTC8TimeTcp.second & 0xFF);		   // uint8	second
+		*(SendBuffer + 0x1E) = (DataIdx & 0xFF);				   // uint8
+		*(SendBuffer + 0x1F) = ((UTC8TimeTcp.year) & 0xFF);		   // uint8	year
+		*(SendBuffer + 0x20) = (UTC8TimeTcp.month & 0xFF);		   // uint8	month
+		*(SendBuffer + 0x21) = (UTC8TimeTcp.day & 0xFF);		   // uint8	day
+		*(SendBuffer + 0x22) = (UTC8TimeTcp.hour & 0xFF);		   // uint8	hour
+		*(SendBuffer + 0x23) = (UTC8TimeTcp.minute & 0xFF);		   // uint8	minute
+		*(SendBuffer + 0x24) = (UTC8TimeTcp.second & 0xFF);		   // uint8	second
+		*(SendBuffer + 0x25) = ((BMS_TotalCharCapy >> 24) & 0xFF); // uint32	累积充入Ah 数 精度_0.1，偏移量_0，单位_Ah
+		*(SendBuffer + 0x26) = ((BMS_TotalCharCapy >> 16) & 0xFF);
+		*(SendBuffer + 0x27) = ((BMS_TotalCharCapy >> 8) & 0xFF);
+		*(SendBuffer + 0x28) = (BMS_TotalCharCapy & 0xFF);
+		*(SendBuffer + 0x29) = ((BMS_TotalDisCharCapy >> 24) & 0xFF); // uint32	累积放出Ah 数 精度_0.1，偏移量_0，单位_Ah
+		*(SendBuffer + 0x2A) = ((BMS_TotalDisCharCapy >> 16) & 0xFF);
+		*(SendBuffer + 0x2B) = ((BMS_TotalDisCharCapy >> 8) & 0xFF);
+		*(SendBuffer + 0x2C) = (BMS_TotalDisCharCapy & 0xFF);
+		*(SendBuffer + 0x2D) = ((BMS_TotalCharEngy >> 24) & 0xFF); // uint32	累计充入kWh 数 精度_0.1，偏移量_0，单位_KWh
+		*(SendBuffer + 0x2E) = ((BMS_TotalCharEngy >> 16) & 0xFF);
+		*(SendBuffer + 0x2F) = ((BMS_TotalCharEngy >> 8) & 0xFF);
+		*(SendBuffer + 0x30) = (BMS_TotalCharEngy & 0xFF);
+		*(SendBuffer + 0x31) = ((BMS_TotalDisCharEngy >> 24) & 0xFF); // uint32	累计放出kWh 数 精度_0.1，偏移量_0，单位_KWh
+		*(SendBuffer + 0x32) = ((BMS_TotalDisCharEngy >> 16) & 0xFF);
+		*(SendBuffer + 0x33) = ((BMS_TotalDisCharEngy >> 8) & 0xFF);
+		*(SendBuffer + 0x34) = (BMS_TotalDisCharEngy & 0xFF);
+		*(SendBuffer + 0x35) = ((BMS_TotalBackCharCapy >> 24) & 0xFF); // uint32	累计动能回馈充入Ah 数 精度_0.1，偏移量_0，单位_Ah
+		*(SendBuffer + 0x36) = ((BMS_TotalBackCharCapy >> 16) & 0xFF);
+		*(SendBuffer + 0x37) = ((BMS_TotalBackCharCapy >> 8) & 0xFF);
+		*(SendBuffer + 0x38) = (BMS_TotalBackCharCapy & 0xFF);
+		*(SendBuffer + 0x39) = ((BMS_TotalBackCharEngy >> 24) & 0xFF); // uint32	累计动能回馈充入kWh 数 精度_0.1，偏移量_0，单位_KWh
+		*(SendBuffer + 0x3A) = ((BMS_TotalBackCharEngy >> 16) & 0xFF);
+		*(SendBuffer + 0x3B) = ((BMS_TotalBackCharEngy >> 8) & 0xFF);
+		*(SendBuffer + 0x3C) = (BMS_TotalBackCharEngy & 0xFF);
+		*(SendBuffer + 0x3D) = ((BMS_TotalStaCharCapy >> 24) & 0xFF); // uint32	累计换电站充入Ah 数 精度_0.1，偏移量_0，单位_Ah
+		*(SendBuffer + 0x3E) = ((BMS_TotalStaCharCapy >> 16) & 0xFF);
+		*(SendBuffer + 0x3F) = ((BMS_TotalStaCharCapy >> 8) & 0xFF);
+		*(SendBuffer + 0x40) = (BMS_TotalStaCharCapy & 0xFF);
+		*(SendBuffer + 0x41) = ((BMS_TotalStaCharEngy >> 24) & 0xFF); // uint32	累计换电站充入kWh 数 精度_0.1，偏移量_0，单位_KWh
+		*(SendBuffer + 0x42) = ((BMS_TotalStaCharEngy >> 16) & 0xFF);
+		*(SendBuffer + 0x43) = ((BMS_TotalStaCharEngy >> 8) & 0xFF);
+		*(SendBuffer + 0x44) = (BMS_TotalStaCharEngy & 0xFF);
+		*(SendBuffer + 0x45) = ((BMS_TotalGunCharCapy >> 24) & 0xFF); // uint32	累计插枪充电充入Ah 数 精度_0.1，偏移量_0，单位_Ah
+		*(SendBuffer + 0x46) = ((BMS_TotalGunCharCapy >> 16) & 0xFF);
+		*(SendBuffer + 0x47) = ((BMS_TotalGunCharCapy >> 8) & 0xFF);
+		*(SendBuffer + 0x48) = (BMS_TotalGunCharCapy & 0xFF);
+		*(SendBuffer + 0x49) = ((BMS_TotalGunCharEngy >> 24) & 0xFF); // uint32	累计插枪充电充入kWh 数 精度_0.1，偏移量_0，单位_KWh
+		*(SendBuffer + 0x4A) = ((BMS_TotalGunCharEngy >> 16) & 0xFF);
+		*(SendBuffer + 0x4B) = ((BMS_TotalGunCharEngy >> 8) & 0xFF);
+		*(SendBuffer + 0x4C) = (BMS_TotalGunCharEngy & 0xFF);
 		*(SendBuffer + 0x4D) = bcc_chk(SendBuffer, 0x4D);
 		*PtrSendAddr = (uint32)SendBuffer;
 		break;
@@ -1013,70 +1028,99 @@ void GetUtc8Time(UTC8TimeType *UTC8TimeTcp)
 		}
 	}
 }
-static void TcpDataInfoRecvHandle(uint8 *DataRecv,uint16 DataRecvLen)
+static void GetCSQValue(uint8 *out)
 {
-    uint8 Tcp_Cmd;
-    uint8 *Ptr=NULL,*retptr=NULL;
-    uint8 TcpCmdAnswer[31];
-    uint16 TcpDataLen = 0;
-    uint16 NumCalTemp = 1;
-    retptr = (uint8 *)strstr((char *)DataRecv, (char *)("\r\n##"));
-    if(retptr==NULL)return;
-    for(uint8 i=0;i<5;i++)
-    {
-    	if(*(retptr - i - 1)=='D')
+	char *AtCmdAsk = (char *)("AT+CSQ\r\n");
+	uint8 AtCmdLen = mstrlen(AtCmdAsk);
+	uint8 ReadLen = 0;
+	uint8 *retptr = NULL;
+	memset(RX_Buffer[UART_LPUART1], 0x00, sizeof(RX_Buffer[UART_LPUART1]));
+	UART_Query_Data(UART_LPUART1, UART_LPUART1, AtCmdAsk, AtCmdLen, RX_Buffer[UART_LPUART1], &ReadLen, 100);
+	*out = 99;
+	if (ReadLen > 0)
+	{
+		if ((uint8 *)strstr((char *)RX_Buffer[UART_LPUART1], (char *)("OK")))
+		{
+			*out = 0;
+			retptr = (uint8 *)strstr((char *)RX_Buffer[UART_LPUART1], (char *)("+CSQ:"));
+			char CsqStr[5];
+			for (uint8 i = 0; i < 5; i++)
+			{
+				if (*(retptr+i+6) == ',')
+				{
+					break;
+				}
+				memcpy((CsqStr+i),(retptr+i+6),1);
+			}
+			*out = atoi(CsqStr);
+		}
+	}
+	return;
+}
+static void TcpDataInfoRecvHandle(uint8 *DataRecv, uint16 DataRecvLen)
+{
+	uint8 Tcp_Cmd;
+	uint8 *Ptr = NULL, *retptr = NULL;
+	uint8 TcpCmdAnswer[31];
+	uint16 TcpDataLen = 0;
+	uint16 NumCalTemp = 1;
+	retptr = (uint8 *)strstr((char *)DataRecv, (char *)("\r\n##"));
+	if (retptr == NULL)
+		return;
+	for (uint8 i = 0; i < 5; i++)
+	{
+		if (*(retptr - i - 1) == 'D')
 		{
 			break;
 		}
-    	TcpDataLen = TcpDataLen + CharToHex(*(retptr - i - 1))*NumCalTemp;
-    	NumCalTemp = NumCalTemp*10;
-    }
-    if (TcpDataLen>0)
-    {
-        Ptr = retptr + 2;
-        if ((*(Ptr + 0) == TCP_START_SYM1) && (*(Ptr + 1) == TCP_START_SYM2)) //服务器起始信息
-        {
-            Tcp_Cmd = *(Ptr + 2); //命令标志
-            if (*(Ptr + 3) == 0xFE)
-            {
-//                TCPWorkState = 0x01;//需要暂停发送，进行命令应答的标志
-            }
-            switch (Tcp_Cmd)
-            {
-            case TCP_QUERY_SYM:
-                break;
-            case TCP_SETCMD_SYM:
-                break;
-            case TCP_CONCMD_SYM:
-            {
-                TcpCmdAnswer[0] = TCP_START_SYM1;
-                TcpCmdAnswer[1] = TCP_START_SYM1;
-                TcpCmdAnswer[2] = TCP_CONCMD_SYM;
-                if (*(Ptr + 30) == 0x01)//远程升级指令
-                {
-
-                }
-                else
-                {
-                    TcpCmdAnswer[3] = 0x0f;
-                    memcpy(&TcpCmdAnswer[4], (Ptr + 4), BATT_SN_LEN);
-                    TcpCmdAnswer[21] = TCP_ENCPT_DISABLE;
-                    TcpCmdAnswer[22] = 0x00;
-                    TcpCmdAnswer[23] = 0x06;
-                    memcpy(&TcpCmdAnswer[24], (Ptr + 24), 6);
-                    TcpCmdAnswer[30] = bcc_chk(TcpCmdAnswer, 30);
-                    tcpipConnectionSend(SocketId, TcpCmdAnswer, 31);
-                }
-            }
-            default:
-            {
-                break;
-            }
-            }
-        }
-    }
+		TcpDataLen = TcpDataLen + CharToHex(*(retptr - i - 1)) * NumCalTemp;
+		NumCalTemp = NumCalTemp * 10;
+	}
+	if (TcpDataLen > 0)
+	{
+		Ptr = retptr + 2;
+		if ((*(Ptr + 0) == TCP_START_SYM1) && (*(Ptr + 1) == TCP_START_SYM2)) //服务器起始信息
+		{
+			Tcp_Cmd = *(Ptr + 2); //命令标志
+			if (*(Ptr + 3) == 0xFE)
+			{
+				TcpWorkState = 0x01;//需要暂停发送，进行命令应答的标志
+			}
+			switch (Tcp_Cmd)
+			{
+			case TCP_QUERY_SYM:
+				break;
+			case TCP_SETCMD_SYM:
+				break;
+			case TCP_CONCMD_SYM:
+			{
+				TcpCmdAnswer[0] = TCP_START_SYM1;
+				TcpCmdAnswer[1] = TCP_START_SYM1;
+				TcpCmdAnswer[2] = TCP_CONCMD_SYM;
+				if (*(Ptr + 30) == 0x01) //远程升级指令
+				{
+				}
+				else
+				{
+					TcpCmdAnswer[3] = 0x0f;
+					memcpy(&TcpCmdAnswer[4], (Ptr + 4), BATT_SN_LEN);
+					TcpCmdAnswer[21] = TCP_ENCPT_DISABLE;
+					TcpCmdAnswer[22] = 0x00;
+					TcpCmdAnswer[23] = 0x06;
+					memcpy(&TcpCmdAnswer[24], (Ptr + 24), 6);
+					TcpCmdAnswer[30] = bcc_chk(TcpCmdAnswer, 30);
+					tcpipConnectionSend(SocketId, TcpCmdAnswer, 31);
+				}
+			}
+			default:
+			{
+				break;
+			}
+			}
+		}
+	}
 }
-sint8 tcpipConnectionSend(uint8 TcpConnectId,uint8 * SendDataPtr,uint16 SendDataLen)
+sint8 tcpipConnectionSend(uint8 TcpConnectId, uint8 *SendDataPtr, uint16 SendDataLen)
 {
 	sint8 outValue = -1;
 	sint8 ATRet = -1;

src/AppTaskUart1.h

@@ -3,7 +3,7 @@
  * @Date         : 2022-02-10 11:44:08
  * @Version      : V3.0
  * @LastEditors  : ChenJie
- * @LastEditTime : 2022-02-14 15:48:07
+ * @LastEditTime : 2022-05-17 16:22:56
  * @Description  : file content
  * @FilePath     : \S32K146_4G\src\AppTaskUart1.h
  */
@@ -62,98 +62,98 @@ typedef struct GPSMsgtoTcpType
 } GPSMsgtoTcpType;
 typedef struct _VerInfoType
 {
-	uint8	sendTimeUTC[6];
-	uint8	msgMark;
-	uint8	msgCollectionTimeUTC[6];
-	uint8	ICCID[20];
-	uint8	IMEI[15];
-	uint8	BMSHwVersion[2];
-	uint8	BMSSwVersion[4];
-	uint8	HwVersion[2];
-	uint8	BLVersion[4];
-	uint8	DRVVersion[4];
-	uint8	APPVersion[4];
-	uint8	BmsType;
-	uint8	BmsInfo;
-	uint8   DataModuleType;
-}VerInfoType;
+	uint8 sendTimeUTC[6];
+	uint8 msgMark;
+	uint8 msgCollectionTimeUTC[6];
+	uint8 ICCID[20];
+	uint8 IMEI[15];
+	uint8 BMSHwVersion[2];
+	uint8 BMSSwVersion[4];
+	uint8 HwVersion[2];
+	uint8 BLVersion[4];
+	uint8 DRVVersion[4];
+	uint8 APPVersion[4];
+	uint8 BmsType;
+	uint8 BmsInfo;
+	uint8 DataModuleType;
+} VerInfoType;
 typedef struct VersionMsgtoTcpType
 {
-	uint8 	startSymbol[2];
-	uint8	cmdSymbol;
-	uint8	ansSymbol;
-	uint8	SN[BATT_SN_LEN];
-	uint8	encryptMethod;
-	uint8	dataLength[2];
+	uint8 startSymbol[2];
+	uint8 cmdSymbol;
+	uint8 ansSymbol;
+	uint8 SN[BATT_SN_LEN];
+	uint8 encryptMethod;
+	uint8 dataLength[2];
 	VerInfoType VerInfo;
-	uint8	CRC;
-}VersionMsgtoTcpType;
+	uint8 CRC;
+} VersionMsgtoTcpType;
 typedef struct StorageInfoType
 {
-	uint8	sendTimeUTC[6];
-	uint8	msgMark;
-	uint8	msgCollectionTimeUTC[6];
-	uint8 	RelayState;
-	uint8   FanState;
-	uint8	HeatState;
-	uint8 	ConvertState;
-}StorageInfo;
+	uint8 sendTimeUTC[6];
+	uint8 msgMark;
+	uint8 msgCollectionTimeUTC[6];
+	uint8 RelayState;
+	uint8 FanState;
+	uint8 HeatState;
+	uint8 ConvertState;
+} StorageInfo;
 typedef struct StorageInfoToTcpType
 {
-	uint8 	startSymbol[2];
-	uint8	cmdSymbol;
-	uint8	ansSymbol;
-	uint8	SN[BATT_SN_LEN];
-	uint8	encryptMethod;
-	uint8	dataLength[2];
+	uint8 startSymbol[2];
+	uint8 cmdSymbol;
+	uint8 ansSymbol;
+	uint8 SN[BATT_SN_LEN];
+	uint8 encryptMethod;
+	uint8 dataLength[2];
 	StorageInfo StorageMsg;
-	uint8	CRC;
-}StorageInfoToTcp;
+	uint8 CRC;
+} StorageInfoToTcp;
 typedef struct UTC8Time_Type
 {
-    uint8 year;
-    uint8 month;
-    uint8 day;
-    uint8 hour;
-    uint8 minute;
-    uint8 second;
+	uint8 year;
+	uint8 month;
+	uint8 day;
+	uint8 hour;
+	uint8 minute;
+	uint8 second;
 } UTC8TimeType;
 typedef enum
 {
-    AT_CMD_TEST = 0,
-    AT_SIMREADY,
-    AT_GETICCID,
-    AT_CGREG,
-    AT_CSQ,
-    AT_NETOPEN,
-    AT_CGIP,
-    AT_CONNECT,
-    AT_CONNECTCHK,
-    AT_SEND,
-    AT_DISCON,
-    AT_NETCLOSE,
+	AT_CMD_TEST = 0,
+	AT_SIMREADY,
+	AT_GETICCID,
+	AT_CGREG,
+	AT_CSQ,
+	AT_NETOPEN,
+	AT_CGIP,
+	AT_CONNECT,
+	AT_CONNECTCHK,
+	AT_SEND,
+	AT_DISCON,
+	AT_NETCLOSE,
 	AT_CGNSSPWR
 } ATCmd;
 typedef sint8 (*pFunc)(char *PSendStr, char *pReadStr, uint8 CmdIdx, uint16 pReadLen);
 sint8 at_callbackFunc(char *PSendStr, char *pReadStr, uint8 CmdIdx, uint16 pReadLen);
 typedef struct
 {
-    ATCmd cmd; /*指令序号*/
-    char *str; /*指令内容*/
-    pFunc cb;  /*对应的执行*/
+	ATCmd cmd; /*指令序号*/
+	char *str; /*指令内容*/
+	pFunc cb;  /*对应的执行*/
 } ATCmdFunc;
 typedef enum
 {
-    PROCESS_TCP_IDLE = 0,
-    PROCESS_TCP_ATSYS,
-    PROCESS_TCP_REGCHK,
-    PROCESS_TCP_CONNECT,
-    PROCESS_TCP_SEND,
-    PROCESS_TCP_RECV,
-    PROCESS_TCP_HEART,
-    PROCESS_TCP_SLEEP,
-    PROCESS_TCP_ERROR
+	PROCESS_TCP_IDLE = 0,
+	PROCESS_TCP_ATSYS,
+	PROCESS_TCP_REGCHK,
+	PROCESS_TCP_CONNECT,
+	PROCESS_TCP_SEND,
+	PROCESS_TCP_RECV,
+	PROCESS_TCP_HEART,
+	PROCESS_TCP_SLEEP,
+	PROCESS_TCP_ERROR
 } process_Tcp;
 void Uart_4G_Task(void *pvParameters);
-sint8 tcpipConnectionSend(uint8 TcpConnectId,uint8 * SendDataPtr,uint16 SendDataLen);
+sint8 tcpipConnectionSend(uint8 TcpConnectId, uint8 *SendDataPtr, uint16 SendDataLen);
 #endif /* APPTASKUART1_H_ */

src/hal_adapter.c

@@ -6,603 +6,593 @@
  */
 #include "hal_adapter.h"
 #include "AppGlobalVar.h"
- uint8_t __attribute__((section(".non_cacheable_data"))) RX_Buffer[3][BUFFER_SIZE];
- uint32_t bufferIdx[3] = {0};
- volatile uint32 VarNotification_0 = 0;
- volatile uint32 VarNotification_1 = 0;
- TP_Value_Type    ConvertedBuffer[NUM_RESULTS];
- Adc_ValueGroupType    ResultBuffer[NUM_RESULTS];
- Std_ReturnType  ADC_Converter(Adc_ValueGroupType* Buffer, TP_Value_Type* ConvertedValueR);
- Std_ReturnType UART_Query_Data(uint8 transChannel, uint8 recvChannel, const uint8 *txBuffer, uint32 sendLength, uint8 *rxBuffer, uint16 *rxlen,uint32 T_timeout)
- {
-     volatile Std_ReturnType R_Uart_Status;
-     volatile Std_ReturnType T_Uart_Status;
-     volatile Uart_StatusType Uart_ReceiveStatus = UART_STATUS_TIMEOUT;
-     volatile Uart_StatusType Uart_TransmitStatus = UART_STATUS_TIMEOUT;
-     uint32 T_bytesRemaining;
-     uint32 R_bytesRemaining;
-     uint32 timeout = T_timeout;
-     uint32 retVal = E_NOT_OK;
-     bufferIdx[recvChannel]=0;
-	 switch(recvChannel)
-	 {
-		case 0:
-			IP_LPUART0->CTRL |= LPUART_CTRL_ILIE(1);
-			break;
-		case 1:
-			IP_LPUART1->CTRL |= LPUART_CTRL_ILIE(1);
-			break;
-		case 2:
-			IP_LPUART2->CTRL |= LPUART_CTRL_ILIE(1);
-			break;
-		default:
-			break;
-	 }
-	 if (txBuffer == NULL || rxBuffer == NULL)
-	 {
-		 return retVal;
-	 }
-
-	 /* Uart_AsyncSend transmit data */
-	 Uart_SetBuffer(transChannel, txBuffer, sendLength, UART_SEND);
-	 T_Uart_Status = Uart_AsyncSend(transChannel, txBuffer, sendLength);
-	 if (E_OK != T_Uart_Status)
-	 {
-		 Uart_Abort(transChannel, UART_SEND);
-		 return E_NOT_OK;
-	 }
-	 Uart_SetBuffer(recvChannel, &RX_Buffer[recvChannel][0], DMA_SIZE, UART_RECEIVE);
-	 R_Uart_Status = Uart_AsyncReceive(recvChannel, rxBuffer, DMA_SIZE);
-	 if (E_OK != R_Uart_Status)
-	 {
-		 Uart_Abort(recvChannel, UART_RECEIVE);
-		 return E_NOT_OK;
-	 }
-	 /* Check for no on-going transmission */
-	 do
-	 {
-		 if(Uart_TransmitStatus != UART_STATUS_NO_ERROR)
-		 {
-			 Uart_TransmitStatus = Uart_GetStatus(transChannel, &T_bytesRemaining, UART_SEND);
-		 }
-		 if(Uart_ReceiveStatus != UART_STATUS_NO_ERROR)
-		 {
-			 Uart_ReceiveStatus = Uart_GetStatus(recvChannel, &R_bytesRemaining, UART_RECEIVE);
-		 }
-		 vTaskDelay(pdMS_TO_TICKS(1));
-	 } while (((UART_STATUS_NO_ERROR != Uart_TransmitStatus || UART_STATUS_NO_ERROR != Uart_ReceiveStatus) && 0 < --timeout));
-	 if ((UART_STATUS_NO_ERROR != Uart_TransmitStatus))
-	 {
-		 Uart_Abort(transChannel, UART_SEND);
-		 retVal = E_NOT_OK;
-	 }
-	 else
-	 {
-		 retVal = E_OK;
-	 }
-	 if ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus))
-	 {
-		 Uart_Abort(recvChannel, UART_RECEIVE);
-		 *rxlen = bufferIdx[recvChannel];
-		 retVal = E_NOT_OK;
-	 }
-	 else
-	 {
-		 *rxlen = bufferIdx[recvChannel];
-		 retVal = E_OK;
-	 }
-	 return retVal;
- }
-
- Std_ReturnType UART_Send_Data(uint8 transChannel, const uint8 *txBuffer, uint32 sendLength, uint32 T_timeout)
- {
-
-     volatile Std_ReturnType T_Uart_Status;
-     volatile Uart_StatusType Uart_TransmitStatus = UART_STATUS_TIMEOUT;
-     uint32 T_bytesRemaining;
-     uint32 timeout = T_timeout;
-     uint32 retVal = E_NOT_OK;
-     if (txBuffer == NULL)
-     {
-         return retVal;
-     }
-
-     /* Uart_AsyncSend transmit data */
-     T_Uart_Status = Uart_AsyncSend(transChannel, txBuffer, sendLength);
-     if (E_OK != T_Uart_Status)
-     {
-         Uart_Abort(transChannel, UART_SEND);
-         return E_NOT_OK;
-     }
-     /* Check for no on-going transmission */
-     do
-     {
-         Uart_TransmitStatus = Uart_GetStatus(transChannel, &T_bytesRemaining, UART_SEND);
-         vTaskDelay(pdMS_TO_TICKS(1));
-     } while ((UART_STATUS_NO_ERROR != Uart_TransmitStatus && 0 < --timeout));
-
-     if ((UART_STATUS_NO_ERROR != Uart_TransmitStatus))
-     {
-         retVal = E_NOT_OK;
-     }
-     else
-     {
-         retVal = E_OK;
-     }
-     return retVal;
- }
-
- Std_ReturnType UART_Receive_Data(uint8 recvChannel, uint8 *rxBuffer, uint16 *rxlen,sint32 T_timeout)
- {
-     volatile Std_ReturnType R_Uart_Status=E_NOT_OK;
-     volatile Uart_StatusType Uart_ReceiveStatus = UART_STATUS_TIMEOUT;
-     uint32 T_bytesRemaining = 0;
-     uint32 retVal = E_NOT_OK;
-     //    uint8 Rx_Buffer[MSG_LEN];
-     bufferIdx[recvChannel]=0;
-     *rxlen = 0;
-     if (rxBuffer == NULL)
-     {
-         return retVal;
-     }
-     /* Uart_AsyncReceive transmit data */
-	switch(recvChannel)
-	{
-		case 0:
-			IP_LPUART0->CTRL |= LPUART_CTRL_ILIE(1);
-			break;
-		case 1:
-			IP_LPUART1->CTRL |= LPUART_CTRL_ILIE(1);
-			break;
-		case 2:
-			IP_LPUART2->CTRL |= LPUART_CTRL_ILIE(1);
-			break;
-		default:
-			break;
-	}
-     Uart_SetBuffer(recvChannel, rxBuffer, DMA_SIZE, UART_RECEIVE);
-     R_Uart_Status = Uart_AsyncReceive(recvChannel, rxBuffer, DMA_SIZE);
-     if (E_OK != R_Uart_Status)
-     {
-         Uart_Abort(recvChannel, UART_RECEIVE);
-         return E_NOT_OK;
-     }
-     /* Check for no on-going transmission */
-     do
-     {
-         Uart_ReceiveStatus = Uart_GetStatus(recvChannel, &T_bytesRemaining, UART_RECEIVE);
-         vTaskDelay(pdMS_TO_TICKS(1));
-
-     } while ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus)&& 0<T_timeout--);
-     if ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus))
-     {
-         Uart_Abort(recvChannel, UART_RECEIVE);
-         *rxlen = bufferIdx[recvChannel];
-         retVal = E_NOT_OK;
-     }
-     else
-     {
-    	 *rxlen = bufferIdx[recvChannel];
-         retVal = E_OK;
-     }
-     return retVal;
- }
- extern Lpuart_Uart_Ip_StateStructureType * Lpuart_Uart_Ip_apStateStructuresArray[LPUART_UART_IP_NUMBER_OF_INSTANCES];
- void UART_Callback(uint32 hwInstance, Lpuart_Uart_Ip_EventType event )
- {
- //    (void)userData;
-     uint32_t temp;
-     /* Check the event type */
-     if (event == LPUART_UART_IP_EVENT_RX_FULL)
-     {
-         /* The reception stops when receiving idle is detected or the buffer is full */
-		 if (bufferIdx[hwInstance] <= (BUFFER_SIZE - DMA_SIZE))
-		 {
-			 /* Update the buffer index and the rx buffer */
-			 bufferIdx[hwInstance] += DMA_SIZE;
-			Uart_SetBuffer(hwInstance,&RX_Buffer[hwInstance][bufferIdx[hwInstance]],DMA_SIZE,UART_RECEIVE);
-			 //Lpuart_Uart_Ip_SetRxBuffer(hwInstance, &RX_Buffer[bufferIdx], DMA_SIZE);
-		 }
-     }
-     if (event == LPUART_UART_IP_EVENT_ERROR)
-     {
-//     	/*Get the transfered data size. DMA Channel 1 is used for LPUART DMA receiving, please modify accordingly.*/
-//     	temp = DMA_SIZE - (uint32_t)IP_DMA->TCD->CITER.ELINKNO;
-//     	/*Add the remaining data size to the sum of the received size*/
-//     	bufferIdx[hwInstance] += temp;
+uint8_t __attribute__((section(".non_cacheable_data"))) RX_Buffer[3][BUFFER_SIZE];
+uint32_t bufferIdx[3] = {0};
+volatile uint32 VarNotification_0 = 0;
+volatile uint32 VarNotification_1 = 0;
+TP_Value_Type ConvertedBuffer[NUM_RESULTS];
+Adc_ValueGroupType ResultBuffer[NUM_RESULTS];
+Std_ReturnType ADC_Converter(Adc_ValueGroupType *Buffer, TP_Value_Type *ConvertedValueR);
+Std_ReturnType UART_Query_Data(uint8 transChannel, uint8 recvChannel, const uint8 *txBuffer, uint32 sendLength, uint8 *rxBuffer, uint16 *rxlen, uint32 T_timeout)
+{
+    volatile Std_ReturnType R_Uart_Status;
+    volatile Std_ReturnType T_Uart_Status;
+    volatile Uart_StatusType Uart_ReceiveStatus = UART_STATUS_TIMEOUT;
+    volatile Uart_StatusType Uart_TransmitStatus = UART_STATUS_TIMEOUT;
+    uint32 T_bytesRemaining;
+    uint32 R_bytesRemaining;
+    uint32 timeout = T_timeout;
+    uint32 retVal = E_NOT_OK;
+    bufferIdx[recvChannel] = 0;
+    switch (recvChannel)
+    {
+    case 0:
+        IP_LPUART0->CTRL |= LPUART_CTRL_ILIE(1);
+        break;
+    case 1:
+        IP_LPUART1->CTRL |= LPUART_CTRL_ILIE(1);
+        break;
+    case 2:
+        IP_LPUART2->CTRL |= LPUART_CTRL_ILIE(1);
+        break;
+    default:
+        break;
+    }
+    if (txBuffer == NULL || rxBuffer == NULL)
+    {
+        return retVal;
+    }
+
+    /* Uart_AsyncSend transmit data */
+    Uart_SetBuffer(transChannel, txBuffer, sendLength, UART_SEND);
+    T_Uart_Status = Uart_AsyncSend(transChannel, txBuffer, sendLength);
+    if (E_OK != T_Uart_Status)
+    {
+        Uart_Abort(transChannel, UART_SEND);
+        return E_NOT_OK;
+    }
+    Uart_SetBuffer(recvChannel, &RX_Buffer[recvChannel][0], DMA_SIZE, UART_RECEIVE);
+    R_Uart_Status = Uart_AsyncReceive(recvChannel, rxBuffer, DMA_SIZE);
+    if (E_OK != R_Uart_Status)
+    {
+        Uart_Abort(recvChannel, UART_RECEIVE);
+        return E_NOT_OK;
+    }
+    /* Check for no on-going transmission */
+    do
+    {
+        if (Uart_TransmitStatus != UART_STATUS_NO_ERROR)
+        {
+            Uart_TransmitStatus = Uart_GetStatus(transChannel, &T_bytesRemaining, UART_SEND);
+        }
+        if (Uart_ReceiveStatus != UART_STATUS_NO_ERROR)
+        {
+            Uart_ReceiveStatus = Uart_GetStatus(recvChannel, &R_bytesRemaining, UART_RECEIVE);
+        }
+        vTaskDelay(pdMS_TO_TICKS(1));
+    } while (((UART_STATUS_NO_ERROR != Uart_TransmitStatus || UART_STATUS_NO_ERROR != Uart_ReceiveStatus) && 0 < --timeout));
+    if ((UART_STATUS_NO_ERROR != Uart_TransmitStatus))
+    {
+        Uart_Abort(transChannel, UART_SEND);
+        retVal = E_NOT_OK;
+    }
+    else
+    {
+        retVal = E_OK;
+    }
+    if ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus))
+    {
+        Uart_Abort(recvChannel, UART_RECEIVE);
+        *rxlen = bufferIdx[recvChannel];
+        retVal = E_NOT_OK;
+    }
+    else
+    {
+        *rxlen = bufferIdx[recvChannel];
+        retVal = E_OK;
+    }
+    return retVal;
+}
+
+Std_ReturnType UART_Send_Data(uint8 transChannel, const uint8 *txBuffer, uint32 sendLength, uint32 T_timeout)
+{
+
+    volatile Std_ReturnType T_Uart_Status;
+    volatile Uart_StatusType Uart_TransmitStatus = UART_STATUS_TIMEOUT;
+    uint32 T_bytesRemaining;
+    uint32 timeout = T_timeout;
+    uint32 retVal = E_NOT_OK;
+    if (txBuffer == NULL)
+    {
+        return retVal;
+    }
+
+    /* Uart_AsyncSend transmit data */
+    T_Uart_Status = Uart_AsyncSend(transChannel, txBuffer, sendLength);
+    if (E_OK != T_Uart_Status)
+    {
+        Uart_Abort(transChannel, UART_SEND);
+        return E_NOT_OK;
+    }
+    /* Check for no on-going transmission */
+    do
+    {
+        Uart_TransmitStatus = Uart_GetStatus(transChannel, &T_bytesRemaining, UART_SEND);
+        vTaskDelay(pdMS_TO_TICKS(1));
+    } while ((UART_STATUS_NO_ERROR != Uart_TransmitStatus && 0 < --timeout));
+
+    if ((UART_STATUS_NO_ERROR != Uart_TransmitStatus))
+    {
+        retVal = E_NOT_OK;
+    }
+    else
+    {
+        retVal = E_OK;
+    }
+    return retVal;
+}
+
+Std_ReturnType UART_Receive_Data(uint8 recvChannel, uint8 *rxBuffer, uint16 *rxlen, sint32 T_timeout)
+{
+    volatile Std_ReturnType R_Uart_Status = E_NOT_OK;
+    volatile Uart_StatusType Uart_ReceiveStatus = UART_STATUS_TIMEOUT;
+    uint32 T_bytesRemaining = 0;
+    uint32 retVal = E_NOT_OK;
+    //    uint8 Rx_Buffer[MSG_LEN];
+    bufferIdx[recvChannel] = 0;
+    *rxlen = 0;
+    if (rxBuffer == NULL)
+    {
+        return retVal;
+    }
+    /* Uart_AsyncReceive transmit data */
+    switch (recvChannel)
+    {
+    case 0:
+        IP_LPUART0->CTRL |= LPUART_CTRL_ILIE(1);
+        break;
+    case 1:
+        IP_LPUART1->CTRL |= LPUART_CTRL_ILIE(1);
+        break;
+    case 2:
+        IP_LPUART2->CTRL |= LPUART_CTRL_ILIE(1);
+        break;
+    default:
+        break;
+    }
+    Uart_SetBuffer(recvChannel, rxBuffer, DMA_SIZE, UART_RECEIVE);
+    R_Uart_Status = Uart_AsyncReceive(recvChannel, rxBuffer, DMA_SIZE);
+    if (E_OK != R_Uart_Status)
+    {
+        Uart_Abort(recvChannel, UART_RECEIVE);
+        return E_NOT_OK;
+    }
+    /* Check for no on-going transmission */
+    do
+    {
+        Uart_ReceiveStatus = Uart_GetStatus(recvChannel, &T_bytesRemaining, UART_RECEIVE);
+        vTaskDelay(pdMS_TO_TICKS(1));
+
+    } while ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus) && 0 < T_timeout--);
+    if ((UART_STATUS_NO_ERROR != Uart_ReceiveStatus))
+    {
+        Uart_Abort(recvChannel, UART_RECEIVE);
+        *rxlen = bufferIdx[recvChannel];
+        retVal = E_NOT_OK;
+    }
+    else
+    {
+        *rxlen = bufferIdx[recvChannel];
+        retVal = E_OK;
+    }
+    return retVal;
+}
+extern Lpuart_Uart_Ip_StateStructureType *Lpuart_Uart_Ip_apStateStructuresArray[LPUART_UART_IP_NUMBER_OF_INSTANCES];
+void UART_Callback(uint32 hwInstance, Lpuart_Uart_Ip_EventType event)
+{
+    //    (void)userData;
+    uint32_t temp;
+    /* Check the event type */
+    if (event == LPUART_UART_IP_EVENT_RX_FULL)
+    {
+        /* The reception stops when receiving idle is detected or the buffer is full */
+        if (bufferIdx[hwInstance] <= (BUFFER_SIZE - DMA_SIZE))
+        {
+            /* Update the buffer index and the rx buffer */
+            bufferIdx[hwInstance] += DMA_SIZE;
+            Uart_SetBuffer(hwInstance, &RX_Buffer[hwInstance][bufferIdx[hwInstance]], DMA_SIZE, UART_RECEIVE);
+            // Lpuart_Uart_Ip_SetRxBuffer(hwInstance, &RX_Buffer[bufferIdx], DMA_SIZE);
+        }
+    }
+    if (event == LPUART_UART_IP_EVENT_ERROR)
+    {
+        //     	/*Get the transfered data size. DMA Channel 1 is used for LPUART DMA receiving, please modify accordingly.*/
+        //     	temp = DMA_SIZE - (uint32_t)IP_DMA->TCD->CITER.ELINKNO;
+        //     	/*Add the remaining data size to the sum of the received size*/
+        //     	bufferIdx[hwInstance] += temp;
+        /*Abort the receiving after detecting IDLE receiving*/
+        Lpuart_Uart_Ip_AbortReceivingData(hwInstance);
+        Lpuart_Uart_Ip_AbortSendingData(hwInstance);
+        //    	bufferIdx = 0;
+    }
+    if (event == LPUART_UART_IP_EVENT_RECV_IDLE)
+    {
+        /*Get the transfered data size. DMA Channel 1 is used for LPUART DMA receiving, please modify accordingly.*/
+        temp = DMA_SIZE - (uint32_t)IP_DMA->TCD[hwInstance].CITER.ELINKNO;
+        /*Add the remaining data size to the sum of the received size*/
+        bufferIdx[hwInstance] += temp;
         /*Abort the receiving after detecting IDLE receiving*/
-     	Lpuart_Uart_Ip_AbortReceivingData(hwInstance);
-     	Lpuart_Uart_Ip_AbortSendingData(hwInstance);
- //    	bufferIdx = 0;
-     }
-     if( event == LPUART_UART_IP_EVENT_RECV_IDLE)
-     {
-     	/*Get the transfered data size. DMA Channel 1 is used for LPUART DMA receiving, please modify accordingly.*/
- 		temp = DMA_SIZE - (uint32_t)IP_DMA->TCD[hwInstance].CITER.ELINKNO;
- 		/*Add the remaining data size to the sum of the received size*/
- 		bufferIdx[hwInstance] += temp;
- 		/*Abort the receiving after detecting IDLE receiving*/
-
- 		Lpuart_Uart_Ip_StateStructureType * UartState;
- 		UartState = (Lpuart_Uart_Ip_StateStructureType *)Lpuart_Uart_Ip_apStateStructuresArray[hwInstance];
- 		UartState->IsRxBusy = FALSE;
- 		UartState->ReceiveStatus = LPUART_UART_IP_STATUS_SUCCESS;
- 		Lpuart_Uart_Ip_CompleteReceiveUsingDma(hwInstance);
- //		rxSuccess = true;
-     }
- }
-
- /*CAN*/
- Can_PduType Can_CreatePduInfo(Can_IdType id, CAN_IdFrameType idFrame, PduIdType swPduHandle, uint8 length, uint8 *sdu)
- {
-     Can_PduType PduInfo;
-     switch (idFrame)
-     {
-     case CAN_STANDARD_ID_TYPE:
-         id = id & 0x7FF;
-         break;
-     case CANFD_STANDARD_ID_TYPE:
-         id = (id & 0x7FF) | 0x40000000;
-         break;
-     case CAN_EXTENDED_ID_TYPE:
-         id = id | 0x80000000;
-         break;
-     case CANFD_EXTENDED_ID_TYPE:
-         id = id | 0xC0000000;
-         break;
-     default:
-         id = id & 0x7FF;
-         break;
-     }
-     PduInfo.id = id;
-     PduInfo.swPduHandle = swPduHandle;
-     PduInfo.length = length;
-     PduInfo.sdu = sdu;
-     return PduInfo;
- }
- Std_ReturnType CanIf_SendMessage(uint8 ControllerId, Can_Msg_Type CanMsg)
- {
-     volatile Can_PduType Can_PduInfo;
-     volatile Std_ReturnType CAN_Write_Status;
-     Std_ReturnType retVal = E_NOT_OK;
-     uint32 u8TimeOut = 100*100;
-     Can_HwHandleType Hth = Can0HardwareObject_TX + (Can_HwHandleType)ControllerId; // controller 0 --> Can0HardwareObject_TX
-
-     Can_PduInfo = Can_CreatePduInfo(CanMsg.id, CanMsg.idFrame, 0, CanMsg.length, CanMsg.sdu);
-
-     CAN_Write_Status = Can_Write(Hth, &Can_PduInfo);
-
-     CanIf_bTxFlag = FALSE;
-     if (CAN_Write_Status == E_OK)
-     {
-         while ((!CanIf_bTxFlag) && (u8TimeOut != 0U))
-         {
-             Can_MainFunction_Write();
-             u8TimeOut--;
-         }
-     }
-
-     if (CanIf_bTxFlag == TRUE)
-     {
-         retVal = E_OK;
-     }
-     else
-     {
-         retVal = E_NOT_OK;
-     }
-     return retVal;
- }
- Can_Msg_Type Can_GetMsgInfo(Can_IdType id, uint8 length, uint8 *sdu)
- {
-     Can_Msg_Type CanMsgInfo;
-
-     CanMsgInfo.idFrame = (CAN_IdFrameType)((id >> 30) & 0x03);
-     if (CanMsgInfo.idFrame & 0x01)
-     {
-         CanMsgInfo.id = id & 0x7FF;
-     }
-     else
-     {
-         CanMsgInfo.id = id & 0x1FFFFFFF;
-     }
-     CanMsgInfo.length = length;
-     CanMsgInfo.sdu = sdu;
-
-     return CanMsgInfo;
- }
-
- void CanIf_ControllerBusOff(uint8 ControllerId)
- {
-     (void)ControllerId;
- }
-
- void CanIf_ControllerModeIndication(uint8 ControllerId, Can_ControllerStateType ControllerMode)
- {
-     (void)ControllerId;
-     (void)ControllerMode;
- }
- void CanIf_TxConfirmation(PduIdType CanTxPduId)
- {
-     CanIf_u8TxConfirmCnt++;
-     CanIf_bTxFlag = TRUE;
-     (void)CanTxPduId;
- }
- void CanIf_RxIndication(const Can_HwType *Mailbox, const PduInfoType *PduInfoPtr)
- {
-	 Can_Msg_Type canRxMsg_Buff;
-	 Can_Msg_Type_Data canRxMsgQueueData;
-     CanIf_bRxFlag = TRUE; // should not be delete
-     // should put the msg into message queue
-     canRxMsg_Buff = Can_GetMsgInfo(Mailbox->CanId, PduInfoPtr->SduLength, PduInfoPtr->SduDataPtr);
-     canRxMsgQueueData.id = canRxMsg_Buff.id;
-     canRxMsgQueueData.length = canRxMsg_Buff.length;
-     memcpy(canRxMsgQueueData.data,canRxMsg_Buff.sdu,canRxMsgQueueData.length);
-     xQueueSend(CanRecvQueueHandle,&canRxMsgQueueData,0);
- }
-
- void CanIf_CurrentIcomConfiguration(uint8 ControllerId, IcomConfigIdType ConfigurationId, IcomSwitch_ErrorType Error)
- {
-     (void)ControllerId;
-     (void)ConfigurationId;
-     (void)Error;
- }
-
-
- void Notification_0(void)
- {
-	 ADC_Converter(ResultBuffer,ConvertedBuffer);
-	 memcpy(BattTempR,&ConvertedBuffer[3],4*sizeof(uint32));
- }
-
- void Notification_1(void)
- {
-     VarNotification_1++;
- }
-
- Std_ReturnType  ADC_Converter(Adc_ValueGroupType* Buffer, TP_Value_Type* ConvertedValueR)
- {
-	 Adc_ValueGroupType REFH,REFL;
-	 REFH = Buffer[0];
-	 REFL = Buffer[2];
-	 for(int i = 3; i < NUM_RESULTS; i++)
-	 {
-		if(Buffer[i] >= REFH)
-		{
-		 ConvertedValueR[i] = 40930000;
-		}
-		else if(Buffer[i] <=REFL)
-		{
-			ConvertedValueR[i] = 0x00;
-		}
-		else
-		{
-		 ConvertedValueR[i] = (TP_Value_Type)((float)(10000 * (Buffer[i] - REFL)/(float)(REFH - REFL))/(1-(float)((Buffer[i]- REFL)/(float)(REFH - REFL))));
-		}
-	 }
- }
-
- Std_ReturnType  ADC_ReadValue()
- {
-	 Std_ReturnType ret = E_NOT_OK;
-	 Adc_ValueGroupType    AdcReadGroupBuffer[NUM_RESULTS];
-	 volatile Std_ReturnType Status = TRUE;
-	 for(int i = 0; i<NUM_RESULTS; i++)
-	 {
-		 ResultBuffer[i] = 0xFFFF;
-		 AdcReadGroupBuffer[i] = 0xFFFE;
-		 ConvertedBuffer[i] = 0x00;
-	 }
-	 Adc_SetupResultBuffer(AdcGroupSoftwareOneShot, ResultBuffer);
-	 Adc_EnableGroupNotification(AdcGroupSoftwareOneShot);
-	 VarNotification_0 = 0;
-	 Adc_StartGroupConversion(AdcGroupSoftwareOneShot);
-//	 uint32 TimeOut = 0;
-//	 while(VarNotification_0 == 0 && VarNotification_1==0 && TimeOut<0xFFFF)
-//	 {
-//		 TimeOut++;
-//	 }
-//	 AdcStates = Adc_ReadGroup(AdcGroupSoftwareOneShot, AdcReadGroupBuffer);
-//	 if(AdcStates == E_NOT_OK)
-//	 {
-//		 return AdcStates;
-//	 }
-//	 else
-//	 {
-//		 ret = E_OK;
-//	 }
-	 return ret;
- }
-
- /*EEP*/
- static Std_ReturnType TestEep_FlexNvmProgramPartCmd
- (
-     VAR(TestEep_CsecKeySize, AUTOMATIC) eepKeysize,
-     VAR(TestEep_SfeType, AUTOMATIC) eepSecurityFlagExtension,
-     VAR(TestEep_LoadFlexRamType, AUTOMATIC) eepLoadFlexRamAtReset,
-     VAR(TestEep_Eeprom_FlexRamPartitionType, AUTOMATIC) eepFlexRamPartition,
-     VAR(TestEep_Eeprom_FlexNvmPartitionType, AUTOMATIC) eepFlexNvmPartition
- )
- {
-      Std_ReturnType u8RetVal = (Std_ReturnType)E_OK;
-      uint32 u32Addr=0;
-      uint32 u32FlexNvmPartSize = 0;
-
-     uint32 u32RegSimFcfg1      = 0UL;
-
-     u32RegSimFcfg1 = IP_SIM->FCFG1;
-
-     /*get DEPART value */
-     u32FlexNvmPartSize = (uint32)( (u32RegSimFcfg1 & SIM_FCFG1_DEPART_MASK) >> SIM_FCFG1_DEPART_SHIFT );
-
-     /* check that it was not partitioned before */
-     if (u32FlexNvmPartSize == 0xF)
-     {
-//         /* if error flags are set the cmd is not executed */
-//         REG_WRITE8(TEST_EEP_EEPROM_FSTAT_ADDR32, TEST_EEP_EEPROM_FSTAT_ACCERR_U8 | TEST_EEP_EEPROM_FSTAT_FPVIOL_U8);
-//
-//         /*erase DF 0 sector*/
-//         u32Addr=(TEST_EEP_DEEPROM_SECTOR_0_ADDR32 - D_EEPROM_BASE_ADDR) + 0x800000UL;
-//
-//         REG_WRITE8(TEST_EEP_EEPROM_FCCOB0_ADDR32, TEST_EEP_EEPROM_CMD_ERASE_SECTOR);
-//         REG_WRITE8(TEST_EEP_EEPROM_FCCOB1_ADDR32, (uint8)(u32Addr >> 16UL));
-//         REG_WRITE8(TEST_EEP_EEPROM_FCCOB2_ADDR32, (uint8)(u32Addr >> 8UL));
-//         REG_WRITE8(TEST_EEP_EEPROM_FCCOB3_ADDR32, (uint8)(u32Addr >> 0UL));
-//         REG_WRITE8(TEST_EEP_EEPROM_FSTAT_ADDR32 , TEST_EEP_EEPROM_FSTAT_CCIF_U8);
-//         while((0U == REG_BIT_GET8(TEST_EEP_EEPROM_FSTAT_ADDR32, TEST_EEP_EEPROM_FSTAT_CCIF_U8)))
-//         {
-//         }
-//
-         if(0U==REG_BIT_GET8(TEST_EEP_EEPROM_FSTAT_ADDR32,TEST_EEP_EEPROM_FSTAT_ACCERR_U8 | TEST_EEP_EEPROM_FSTAT_FPVIOL_U8))
-         {
-             /* run program partition command */
-             REG_WRITE8(TEST_EEP_EEPROM_FCCOB0_ADDR32,EEPROM_CMD_PROGRAM_PARTITION);
-             REG_WRITE8(TEST_EEP_EEPROM_FCCOB1_ADDR32, (uint8)eepKeysize);
-             REG_WRITE8(TEST_EEP_EEPROM_FCCOB2_ADDR32, (uint8)eepSecurityFlagExtension);
-             REG_WRITE8(TEST_EEP_EEPROM_FCCOB3_ADDR32, (uint8)eepLoadFlexRamAtReset);
-             REG_WRITE8(TEST_EEP_EEPROM_FCCOB4_ADDR32, (uint8)eepFlexRamPartition);
-             REG_WRITE8(TEST_EEP_EEPROM_FCCOB5_ADDR32, (uint8)eepFlexNvmPartition);
-             REG_WRITE8(TEST_EEP_EEPROM_FSTAT_ADDR32 , TEST_EEP_EEPROM_FSTAT_CCIF_U8);
-             while((0U == REG_BIT_GET8(TEST_EEP_EEPROM_FSTAT_ADDR32, TEST_EEP_EEPROM_FSTAT_CCIF_U8)))
-             {
-             /* wait for operation to finish */
-             }
-             /* check if errors occured  */
-             if(REG_BIT_GET8(TEST_EEP_EEPROM_FSTAT_ADDR32,TEST_EEP_EEPROM_FSTAT_ACCERR_U8 | TEST_EEP_EEPROM_FSTAT_FPVIOL_U8))
-             {
-                 /* NOK, error flags are set */
-                 u8RetVal = (Std_ReturnType)E_NOT_OK;
-             }
-         }
-         else
-         {
-             /* NOK, error flags are set */
-             u8RetVal = (Std_ReturnType)E_NOT_OK;
-         }
-     }
-     else
-     {
-         /* NOK, partitioned already */
-         u8RetVal = (Std_ReturnType)E_NOT_OK;
-     }
-     return u8RetVal;
- }
-
- void Eep_DepartParitition(TestEep_Eeprom_FlexNvmPartitionType T_EEP_SIZE)
- {
-     uint32 u32FlexNvmPartSize = 0;
-
-     uint32 u32RegSimFcfg1      = 0UL;
-
-     u32RegSimFcfg1 = IP_SIM->FCFG1;
-
-     /*get DEPART value */
-     u32FlexNvmPartSize = (uint32)( (u32RegSimFcfg1 & SIM_FCFG1_DEPART_MASK) >> SIM_FCFG1_DEPART_SHIFT );
-     if (u32FlexNvmPartSize == 0xF) /* We just partition again if curent size different with expected */
-     {
-         /* partition for EERAM 64K with NOT loading EERAM at reset in hardware */
-         TestEep_FlexNvmProgramPartCmd(EEP_FTFC_KEY_SIZE_0_BYTES, EEP_FTFC_VERIFY_ONLY_DISABLED, \
-                                                EEP_FTFC_LOAD_AT_RESET_ENABLED, EEP_FTFC_EERAM_SIZE_4K, T_EEP_SIZE);
-     }
- }
- /* Erase memory by writing erase value */
- Std_ReturnType HAL_EEP_Erase(uint32 eepEraseStartAddr,uint32 eepEraseSize)
- {
-	 Std_ReturnType retReturnType = E_OK;
-	 MemIf_JobResultType retJobResultType;
-     retReturnType = Eep_Erase(eepEraseStartAddr, eepEraseSize);
-     if(E_OK != retReturnType)
-     {
-         return E_NOT_OK;
-     }
-     while(MEMIF_IDLE != Eep_GetStatus())
-     {
-         Eep_MainFunction();
-     }
-     retJobResultType = Eep_GetJobResult();
-     if(MEMIF_JOB_OK != retJobResultType)
-     {
-         return E_NOT_OK;
-     }
-     return E_OK;
- }
-
-  /* Write one or more complete eeprom pages to the eeprom device */
-  Std_ReturnType HAL_EEP_Write(uint32 eepWriteStartAddr,uint8* pDataNeedtoWrite,uint32 dataSize)
-  {
-	  Std_ReturnType retReturnType = E_OK;
-	  MemIf_JobResultType retJobResultType;
-
-	  /*Erase the EEP before write*/
-	  retReturnType = HAL_EEP_Erase(eepWriteStartAddr,dataSize);
-	  if(E_OK != retReturnType)
-	  {
-		  return E_NOT_OK;
-	  }
-
-      retReturnType = Eep_Write(eepWriteStartAddr, pDataNeedtoWrite, dataSize);
-      if(E_OK != retReturnType)
-      {
-          return E_NOT_OK;
-      }
-      while(MEMIF_IDLE != Eep_GetStatus())
-      {
-          Eep_MainFunction();
-      }
-      retJobResultType = Eep_GetJobResult();
-      if(MEMIF_JOB_OK != retJobResultType)
-      {
-          return E_NOT_OK;
-      }
-      return E_OK;
-  }
-
-
- /* Reads from eeprom memory */
- Std_ReturnType HAL_EEP_Read(uint32 eepReadStartAddr,uint8* pDataBuffer,uint32 dataSize)
- {
-	 Std_ReturnType retReturnType = E_OK;
-	 MemIf_JobResultType retJobResultType;
-     retReturnType = Eep_Read(eepReadStartAddr, pDataBuffer, dataSize);
-     if(E_OK != retReturnType)
-     {
-         return E_NOT_OK;
-     }
-     while(MEMIF_IDLE != Eep_GetStatus())
-     {
-         Eep_MainFunction();
-     }
-     retJobResultType = Eep_GetJobResult();
-     if(MEMIF_JOB_OK != retJobResultType)
-     {
-         return E_NOT_OK;
-     }
-     return E_OK;
- }
-
- /* Compares a eeprom memory area with an application data buffer */
- Std_ReturnType HAL_EEP_Compare(uint32 eepCompareStartAddr,uint8* pDataNeedtoCompare,uint32 dataSize)
- {
-	 Std_ReturnType retReturnType = E_OK;
-	 MemIf_JobResultType retJobResultType;
-	 retReturnType = Eep_Compare(eepCompareStartAddr, pDataNeedtoCompare, dataSize);
-     if(E_OK != retReturnType)
-     {
-         return E_NOT_OK;
-     }
-     while(MEMIF_IDLE != Eep_GetStatus())
-     {
-         Eep_MainFunction();
-     }
-     retJobResultType = Eep_GetJobResult();
-     if(MEMIF_JOB_OK != retJobResultType)
-     {
-         return E_NOT_OK;
-     }
-     return E_OK;
- }
-
-
-
-
-
 
+        Lpuart_Uart_Ip_StateStructureType *UartState;
+        UartState = (Lpuart_Uart_Ip_StateStructureType *)Lpuart_Uart_Ip_apStateStructuresArray[hwInstance];
+        UartState->IsRxBusy = FALSE;
+        UartState->ReceiveStatus = LPUART_UART_IP_STATUS_SUCCESS;
+        Lpuart_Uart_Ip_CompleteReceiveUsingDma(hwInstance);
+        //		rxSuccess = true;
+    }
+}
+
+/*CAN*/
+Can_PduType Can_CreatePduInfo(Can_IdType id, CAN_IdFrameType idFrame, PduIdType swPduHandle, uint8 length, uint8 *sdu)
+{
+    Can_PduType PduInfo;
+    switch (idFrame)
+    {
+    case CAN_STANDARD_ID_TYPE:
+        id = id & 0x7FF;
+        break;
+    case CANFD_STANDARD_ID_TYPE:
+        id = (id & 0x7FF) | 0x40000000;
+        break;
+    case CAN_EXTENDED_ID_TYPE:
+        id = id | 0x80000000;
+        break;
+    case CANFD_EXTENDED_ID_TYPE:
+        id = id | 0xC0000000;
+        break;
+    default:
+        id = id & 0x7FF;
+        break;
+    }
+    PduInfo.id = id;
+    PduInfo.swPduHandle = swPduHandle;
+    PduInfo.length = length;
+    PduInfo.sdu = sdu;
+    return PduInfo;
+}
+Std_ReturnType CanIf_SendMessage(uint8 ControllerId, Can_Msg_Type CanMsg)
+{
+    volatile Can_PduType Can_PduInfo;
+    volatile Std_ReturnType CAN_Write_Status;
+    Std_ReturnType retVal = E_NOT_OK;
+    uint32 u8TimeOut = 100 * 100;
+    Can_HwHandleType Hth = Can0HardwareObject_TX + (Can_HwHandleType)ControllerId; // controller 0 --> Can0HardwareObject_TX
+
+    Can_PduInfo = Can_CreatePduInfo(CanMsg.id, CanMsg.idFrame, 0, CanMsg.length, CanMsg.sdu);
+
+    CAN_Write_Status = Can_Write(Hth, &Can_PduInfo);
+
+    CanIf_bTxFlag = FALSE;
+    if (CAN_Write_Status == E_OK)
+    {
+        while ((!CanIf_bTxFlag) && (u8TimeOut != 0U))
+        {
+            Can_MainFunction_Write();
+            u8TimeOut--;
+        }
+    }
+
+    if (CanIf_bTxFlag == TRUE)
+    {
+        retVal = E_OK;
+    }
+    else
+    {
+        retVal = E_NOT_OK;
+    }
+    return retVal;
+}
+Can_Msg_Type Can_GetMsgInfo(Can_IdType id, uint8 length, uint8 *sdu)
+{
+    Can_Msg_Type CanMsgInfo;
+
+    CanMsgInfo.idFrame = (CAN_IdFrameType)((id >> 30) & 0x03);
+    if (CanMsgInfo.idFrame & 0x01)
+    {
+        CanMsgInfo.id = id & 0x7FF;
+    }
+    else
+    {
+        CanMsgInfo.id = id & 0x1FFFFFFF;
+    }
+    CanMsgInfo.length = length;
+    CanMsgInfo.sdu = sdu;
+
+    return CanMsgInfo;
+}
+
+void CanIf_ControllerBusOff(uint8 ControllerId)
+{
+    (void)ControllerId;
+}
+
+void CanIf_ControllerModeIndication(uint8 ControllerId, Can_ControllerStateType ControllerMode)
+{
+    (void)ControllerId;
+    (void)ControllerMode;
+}
+void CanIf_TxConfirmation(PduIdType CanTxPduId)
+{
+    CanIf_u8TxConfirmCnt++;
+    CanIf_bTxFlag = TRUE;
+    (void)CanTxPduId;
+}
+void CanIf_RxIndication(const Can_HwType *Mailbox, const PduInfoType *PduInfoPtr)
+{
+    Can_Msg_Type canRxMsg_Buff;
+    Can_Msg_Type_Data canRxMsgQueueData;
+    CanIf_bRxFlag = TRUE; // should not be delete
+    // should put the msg into message queue
+    canRxMsg_Buff = Can_GetMsgInfo(Mailbox->CanId, PduInfoPtr->SduLength, PduInfoPtr->SduDataPtr);
+    canRxMsgQueueData.id = canRxMsg_Buff.id;
+    canRxMsgQueueData.length = canRxMsg_Buff.length;
+    memcpy(canRxMsgQueueData.data, canRxMsg_Buff.sdu, canRxMsgQueueData.length);
+    xQueueSend(CanRecvQueueHandle, &canRxMsgQueueData, 0);
+}
+
+void CanIf_CurrentIcomConfiguration(uint8 ControllerId, IcomConfigIdType ConfigurationId, IcomSwitch_ErrorType Error)
+{
+    (void)ControllerId;
+    (void)ConfigurationId;
+    (void)Error;
+}
+
+void Notification_0(void)
+{
+    ADC_Converter(ResultBuffer, ConvertedBuffer);
+    memcpy(BattTempR, &ConvertedBuffer[3], 4 * sizeof(uint32));
+}
+
+void Notification_1(void)
+{
+    VarNotification_1++;
+}
+
+Std_ReturnType ADC_Converter(Adc_ValueGroupType *Buffer, TP_Value_Type *ConvertedValueR)
+{
+    Adc_ValueGroupType REFH, REFL;
+    REFH = Buffer[0];
+    REFL = Buffer[2];
+    for (int i = 3; i < NUM_RESULTS; i++)
+    {
+        if (Buffer[i] >= REFH)
+        {
+            ConvertedValueR[i] = 40930000;
+        }
+        else if (Buffer[i] <= REFL)
+        {
+            ConvertedValueR[i] = 0x00;
+        }
+        else
+        {
+            ConvertedValueR[i] = (TP_Value_Type)((float)(10000 * (Buffer[i] - REFL) / (float)(REFH - REFL)) / (1 - (float)((Buffer[i] - REFL) / (float)(REFH - REFL))));
+        }
+    }
+}
+
+Std_ReturnType ADC_ReadValue()
+{
+    Std_ReturnType ret = E_NOT_OK;
+    Adc_ValueGroupType AdcReadGroupBuffer[NUM_RESULTS];
+    volatile Std_ReturnType Status = TRUE;
+    for (int i = 0; i < NUM_RESULTS; i++)
+    {
+        ResultBuffer[i] = 0xFFFF;
+        AdcReadGroupBuffer[i] = 0xFFFE;
+        ConvertedBuffer[i] = 0x00;
+    }
+    Adc_SetupResultBuffer(AdcGroupSoftwareOneShot, ResultBuffer);
+    Adc_EnableGroupNotification(AdcGroupSoftwareOneShot);
+    VarNotification_0 = 0;
+    Adc_StartGroupConversion(AdcGroupSoftwareOneShot);
+    //	 uint32 TimeOut = 0;
+    //	 while(VarNotification_0 == 0 && VarNotification_1==0 && TimeOut<0xFFFF)
+    //	 {
+    //		 TimeOut++;
+    //	 }
+    //	 AdcStates = Adc_ReadGroup(AdcGroupSoftwareOneShot, AdcReadGroupBuffer);
+    //	 if(AdcStates == E_NOT_OK)
+    //	 {
+    //		 return AdcStates;
+    //	 }
+    //	 else
+    //	 {
+    //		 ret = E_OK;
+    //	 }
+    return ret;
+}
+
+/*EEP*/
+static Std_ReturnType TestEep_FlexNvmProgramPartCmd(
+    VAR(TestEep_CsecKeySize, AUTOMATIC) eepKeysize,
+    VAR(TestEep_SfeType, AUTOMATIC) eepSecurityFlagExtension,
+    VAR(TestEep_LoadFlexRamType, AUTOMATIC) eepLoadFlexRamAtReset,
+    VAR(TestEep_Eeprom_FlexRamPartitionType, AUTOMATIC) eepFlexRamPartition,
+    VAR(TestEep_Eeprom_FlexNvmPartitionType, AUTOMATIC) eepFlexNvmPartition)
+{
+    Std_ReturnType u8RetVal = (Std_ReturnType)E_OK;
+    uint32 u32Addr = 0;
+    uint32 u32FlexNvmPartSize = 0;
+
+    uint32 u32RegSimFcfg1 = 0UL;
+
+    u32RegSimFcfg1 = IP_SIM->FCFG1;
+
+    /*get DEPART value */
+    u32FlexNvmPartSize = (uint32)((u32RegSimFcfg1 & SIM_FCFG1_DEPART_MASK) >> SIM_FCFG1_DEPART_SHIFT);
+
+    /* check that it was not partitioned before */
+    if (u32FlexNvmPartSize == 0xF)
+    {
+        //         /* if error flags are set the cmd is not executed */
+        //         REG_WRITE8(TEST_EEP_EEPROM_FSTAT_ADDR32, TEST_EEP_EEPROM_FSTAT_ACCERR_U8 | TEST_EEP_EEPROM_FSTAT_FPVIOL_U8);
+        //
+        //         /*erase DF 0 sector*/
+        //         u32Addr=(TEST_EEP_DEEPROM_SECTOR_0_ADDR32 - D_EEPROM_BASE_ADDR) + 0x800000UL;
+        //
+        //         REG_WRITE8(TEST_EEP_EEPROM_FCCOB0_ADDR32, TEST_EEP_EEPROM_CMD_ERASE_SECTOR);
+        //         REG_WRITE8(TEST_EEP_EEPROM_FCCOB1_ADDR32, (uint8)(u32Addr >> 16UL));
+        //         REG_WRITE8(TEST_EEP_EEPROM_FCCOB2_ADDR32, (uint8)(u32Addr >> 8UL));
+        //         REG_WRITE8(TEST_EEP_EEPROM_FCCOB3_ADDR32, (uint8)(u32Addr >> 0UL));
+        //         REG_WRITE8(TEST_EEP_EEPROM_FSTAT_ADDR32 , TEST_EEP_EEPROM_FSTAT_CCIF_U8);
+        //         while((0U == REG_BIT_GET8(TEST_EEP_EEPROM_FSTAT_ADDR32, TEST_EEP_EEPROM_FSTAT_CCIF_U8)))
+        //         {
+        //         }
+        //
+        if (0U == REG_BIT_GET8(TEST_EEP_EEPROM_FSTAT_ADDR32, TEST_EEP_EEPROM_FSTAT_ACCERR_U8 | TEST_EEP_EEPROM_FSTAT_FPVIOL_U8))
+        {
+            /* run program partition command */
+            REG_WRITE8(TEST_EEP_EEPROM_FCCOB0_ADDR32, EEPROM_CMD_PROGRAM_PARTITION);
+            REG_WRITE8(TEST_EEP_EEPROM_FCCOB1_ADDR32, (uint8)eepKeysize);
+            REG_WRITE8(TEST_EEP_EEPROM_FCCOB2_ADDR32, (uint8)eepSecurityFlagExtension);
+            REG_WRITE8(TEST_EEP_EEPROM_FCCOB3_ADDR32, (uint8)eepLoadFlexRamAtReset);
+            REG_WRITE8(TEST_EEP_EEPROM_FCCOB4_ADDR32, (uint8)eepFlexRamPartition);
+            REG_WRITE8(TEST_EEP_EEPROM_FCCOB5_ADDR32, (uint8)eepFlexNvmPartition);
+            REG_WRITE8(TEST_EEP_EEPROM_FSTAT_ADDR32, TEST_EEP_EEPROM_FSTAT_CCIF_U8);
+            while ((0U == REG_BIT_GET8(TEST_EEP_EEPROM_FSTAT_ADDR32, TEST_EEP_EEPROM_FSTAT_CCIF_U8)))
+            {
+                /* wait for operation to finish */
+            }
+            /* check if errors occured  */
+            if (REG_BIT_GET8(TEST_EEP_EEPROM_FSTAT_ADDR32, TEST_EEP_EEPROM_FSTAT_ACCERR_U8 | TEST_EEP_EEPROM_FSTAT_FPVIOL_U8))
+            {
+                /* NOK, error flags are set */
+                u8RetVal = (Std_ReturnType)E_NOT_OK;
+            }
+        }
+        else
+        {
+            /* NOK, error flags are set */
+            u8RetVal = (Std_ReturnType)E_NOT_OK;
+        }
+    }
+    else
+    {
+        /* NOK, partitioned already */
+        u8RetVal = (Std_ReturnType)E_NOT_OK;
+    }
+    return u8RetVal;
+}
+
+void Eep_DepartParitition(TestEep_Eeprom_FlexNvmPartitionType T_EEP_SIZE)
+{
+    uint32 u32FlexNvmPartSize = 0;
+
+    uint32 u32RegSimFcfg1 = 0UL;
+
+    u32RegSimFcfg1 = IP_SIM->FCFG1;
+
+    /*get DEPART value */
+    u32FlexNvmPartSize = (uint32)((u32RegSimFcfg1 & SIM_FCFG1_DEPART_MASK) >> SIM_FCFG1_DEPART_SHIFT);
+    if (u32FlexNvmPartSize == 0xF) /* We just partition again if curent size different with expected */
+    {
+        /* partition for EERAM 64K with NOT loading EERAM at reset in hardware */
+        TestEep_FlexNvmProgramPartCmd(EEP_FTFC_KEY_SIZE_0_BYTES, EEP_FTFC_VERIFY_ONLY_DISABLED,
+                                      EEP_FTFC_LOAD_AT_RESET_ENABLED, EEP_FTFC_EERAM_SIZE_4K, T_EEP_SIZE);
+    }
+}
+/* Erase memory by writing erase value */
+Std_ReturnType HAL_EEP_Erase(uint32 eepEraseStartAddr, uint32 eepEraseSize)
+{
+    Std_ReturnType retReturnType = E_OK;
+    MemIf_JobResultType retJobResultType;
+    retReturnType = Eep_Erase(eepEraseStartAddr, eepEraseSize);
+    if (E_OK != retReturnType)
+    {
+        return E_NOT_OK;
+    }
+    while (MEMIF_IDLE != Eep_GetStatus())
+    {
+        Eep_MainFunction();
+    }
+    retJobResultType = Eep_GetJobResult();
+    if (MEMIF_JOB_OK != retJobResultType)
+    {
+        return E_NOT_OK;
+    }
+    return E_OK;
+}
+
+/* Write one or more complete eeprom pages to the eeprom device */
+Std_ReturnType HAL_EEP_Write(uint32 eepWriteStartAddr, uint8 *pDataNeedtoWrite, uint32 dataSize)
+{
+    Std_ReturnType retReturnType = E_OK;
+    MemIf_JobResultType retJobResultType;
+
+    /*Erase the EEP before write*/
+    retReturnType = HAL_EEP_Erase(eepWriteStartAddr, dataSize);
+    if (E_OK != retReturnType)
+    {
+        return E_NOT_OK;
+    }
+
+    retReturnType = Eep_Write(eepWriteStartAddr, pDataNeedtoWrite, dataSize);
+    if (E_OK != retReturnType)
+    {
+        return E_NOT_OK;
+    }
+    while (MEMIF_IDLE != Eep_GetStatus())
+    {
+        Eep_MainFunction();
+    }
+    retJobResultType = Eep_GetJobResult();
+    if (MEMIF_JOB_OK != retJobResultType)
+    {
+        return E_NOT_OK;
+    }
+    return E_OK;
+}
+
+/* Reads from eeprom memory */
+Std_ReturnType HAL_EEP_Read(uint32 eepReadStartAddr, uint8 *pDataBuffer, uint32 dataSize)
+{
+    Std_ReturnType retReturnType = E_OK;
+    MemIf_JobResultType retJobResultType;
+    retReturnType = Eep_Read(eepReadStartAddr, pDataBuffer, dataSize);
+    if (E_OK != retReturnType)
+    {
+        return E_NOT_OK;
+    }
+    while (MEMIF_IDLE != Eep_GetStatus())
+    {
+        Eep_MainFunction();
+    }
+    retJobResultType = Eep_GetJobResult();
+    if (MEMIF_JOB_OK != retJobResultType)
+    {
+        return E_NOT_OK;
+    }
+    return E_OK;
+}
+
+/* Compares a eeprom memory area with an application data buffer */
+Std_ReturnType HAL_EEP_Compare(uint32 eepCompareStartAddr, uint8 *pDataNeedtoCompare, uint32 dataSize)
+{
+    Std_ReturnType retReturnType = E_OK;
+    MemIf_JobResultType retJobResultType;
+    retReturnType = Eep_Compare(eepCompareStartAddr, pDataNeedtoCompare, dataSize);
+    if (E_OK != retReturnType)
+    {
+        return E_NOT_OK;
+    }
+    while (MEMIF_IDLE != Eep_GetStatus())
+    {
+        Eep_MainFunction();
+    }
+    retJobResultType = Eep_GetJobResult();
+    if (MEMIF_JOB_OK != retJobResultType)
+    {
+        return E_NOT_OK;
+    }
+    return E_OK;
+}

src/hal_adapter.h

@@ -3,9 +3,9 @@
  * @Date         : 2022-01-23 13:52:10
  * @Version      : V3.0
  * @LastEditors  : ChenJie
- * @LastEditTime : 2022-01-23 16:10:21
+ * @LastEditTime : 2022-05-17 16:22:16
  * @Description  : file content
- * @FilePath     : \PLAT\project\ec616_0h00\apps\qx_app\src\AT_CMD\hal_adapter.h
+ * @FilePath     : \S32K146_4G\src\hal_adapter.h
  */
 /*
  * hal_adapter.h
@@ -16,189 +16,197 @@
 
 #ifndef HAL_ADAPTER_H_
 #define HAL_ADAPTER_H_
- #include "Mcal.h"
- #include "CAN.h"
- #include "SchM_Can.h"
- #include "Mcu.h"
- #include "Mcl.h"
- #include "Port.h"
- #include "Dio.h"
- #include "Uart.h"
- #include "Platform.h"
- #include "Lpuart_Uart_Ip_Irq.h"
- #include "Flexio_Uart_Ip_Irq.h"
- #include <string.h>
- #include <stdlib.h>
- #include "Dma_Ip.h"
- #include "Dma_Ip_Irq.h"
- #include "Lpuart_Uart_Ip.h"
- #include "FreeRTOS.h"
- #include "timers.h"
- #include "task.h"
- #include "semphr.h"
- #include "Adc.h"
- #include "Eep.h"
- #include "Fls.h"
- #include "SchM_Fls.h"
- #include "SL_Sc7a20_Driver.h"
+#include "Mcal.h"
+#include "CAN.h"
+#include "SchM_Can.h"
+#include "Mcu.h"
+#include "Mcl.h"
+#include "Port.h"
+#include "Dio.h"
+#include "Uart.h"
+#include "Platform.h"
+#include "Lpuart_Uart_Ip_Irq.h"
+#include "Flexio_Uart_Ip_Irq.h"
+#include <string.h>
+#include <stdlib.h>
+#include "Dma_Ip.h"
+#include "Dma_Ip_Irq.h"
+#include "Lpuart_Uart_Ip.h"
+#include "FreeRTOS.h"
+#include "timers.h"
+#include "task.h"
+#include "semphr.h"
+#include "Adc.h"
+#include "Eep.h"
+#include "Fls.h"
+#include "SchM_Fls.h"
+#include "SL_Sc7a20_Driver.h"
+/*适应性定义*/
+typedef unsigned char UINT8;
+typedef unsigned short UINT16;
+typedef unsigned long UINT32;
+typedef unsigned char BOOL;
+typedef signed char INT8;
+typedef signed short INT16;
+typedef signed long INT32;
+
 #define CAN0 0
 #define CAN1 1
-
 #ifndef min
-#define min(A,B) ((A) <= (B) ? (A) : (B))
+#define min(A, B) ((A) <= (B) ? (A) : (B))
 #endif
 #ifndef max
-#define max(A,B) ((A) < (B) ? (B) : (A))
+#define max(A, B) ((A) < (B) ? (B) : (A))
 #endif
-#define getbit(x,y)     ((x) >> (y)&1)                        //获取x的第y位的数值
-#define setbit(x,y)     x|=(1<<y)                             //x的第y位置1
-#define clrbit(x,y)     x&=~(1<<y)                            //x的第y位置0
- #define UART_LPUART0 0
- #define UART_LPUART1 1
- #define UART_LPUART2 2
- #define FLEXIO_RX 3
- #define FLEXIO_TX 4
- #define main_TASK_PRIORITY                ( tskIDLE_PRIORITY + 7 )
-
- #define MSG_LEN 50U
- #define TJA1153_START_ID (uint32_t)(0x555u)
- #define TJA1153_CONFIG_ID (uint32_t)(0x18DA00F1u)
-#define NUM_RESULTS             ADC_CFGSET_VS_0_GROUP_0_CHANNELS
- #define BUFFER_SIZE 1000
- #define DMA_SIZE 20
- extern uint8_t RX_Buffer[3][BUFFER_SIZE];
-
- typedef enum
- {
-	 SystemTPChannel = 0,
-	 SlowChargeTPChannel,
-	 QuickChargeTPChannel,
-	 CC1TPChannel,
-	 ChannelCounter = 4,
- }ADC_TP_Channel_Type;
-
- typedef uint32 TP_Value_Type;
- Std_ReturnType  ADC_ReadValue(void);
+#define getbit(x, y) ((x) >> (y)&1) //获取x的第y位的数值
+#define setbit(x, y) x |= (1 << y)  // x的第y位置1
+#define clrbit(x, y) x &= ~(1 << y) // x的第y位置0
+#define UART_LPUART0 0
+#define UART_LPUART1 1
+#define UART_LPUART2 2
+#define FLEXIO_RX 3
+#define FLEXIO_TX 4
+#define main_TASK_PRIORITY (tskIDLE_PRIORITY + 7)
+
+#define MSG_LEN 50U
+#define TJA1153_START_ID (uint32_t)(0x555u)
+#define TJA1153_CONFIG_ID (uint32_t)(0x18DA00F1u)
+#define NUM_RESULTS ADC_CFGSET_VS_0_GROUP_0_CHANNELS
+#define BUFFER_SIZE 1000
+#define DMA_SIZE 20
+extern uint8_t RX_Buffer[3][BUFFER_SIZE];
+
+typedef enum
+{
+    SystemTPChannel = 0,
+    SlowChargeTPChannel,
+    QuickChargeTPChannel,
+    CC1TPChannel,
+    ChannelCounter = 4,
+} ADC_TP_Channel_Type;
+
+typedef uint32 TP_Value_Type;
+Std_ReturnType ADC_ReadValue(void);
 // extern uint8 GpsBufferGet[GPSBUFFER_SIZE];
- Std_ReturnType UART_Query_Data(uint8 transChannel, uint8 recvChannel, const uint8 *txBuffer, uint32 sendLength, uint8 *rxBuffer, uint16 *rxlen,uint32 T_timeout);
- Std_ReturnType UART_Send_Data(uint8 transChannel, const uint8 *txBuffer, uint32 sendLength, uint32 T_timeout);
- Std_ReturnType UART_Receive_Data(uint8 recvChannel, uint8 *rxBuffer,uint16 *rxlen, sint32 T_timeout);
- void UART_Callback(uint32 hwInstance, Lpuart_Uart_Ip_EventType event);
-
- /*CAN*/
- typedef enum
- {
-     CAN_STANDARD_ID_TYPE = 0x00,   /**< * -00b CAN message with Standard CAN ID  */
-     CANFD_STANDARD_ID_TYPE = 0x01, /**< * -01b CAN FD frame with Standard CAN ID  */
-     CAN_EXTENDED_ID_TYPE = 0x02,   /**< * -10b CAN message with Extended CAN ID  */
-     CANFD_EXTENDED_ID_TYPE = 0x03, /**< * -11b CAN FD frame with Extended CAN ID  */
- } CAN_IdFrameType;
-
- typedef struct
- {
-     Can_IdType id;
-
-     CAN_IdFrameType idFrame;
-
-     uint8 length; /**< @brief DLC = Data Length Code (part of L-PDU that describes
-                                             the SDU length). */
-     uint8 *sdu;   /**< @brief CAN L-SDU = Link Layer Service Data
-                                                            Unit. Data that is transported inside
-                                                            the L-PDU. */
- } Can_Msg_Type;
- typedef struct
- {
-	 Can_IdType id;
-	 uint8 length;
-	 uint8 data[8];
- }Can_Msg_Type_Data;
- extern Std_ReturnType CanIf_SendMessage(uint8 ControllerId, Can_Msg_Type CanMsg);
-
- /*EEP*/
-
- typedef enum
- {
-     EEP_FTFC_KEY_SIZE_0_BYTES   = 0x0,  /**< @brief control code for key size 0 bytes, used for the partitioning command */
-     EEP_FTFC_KEY_SIZE_128_BYTES = 0x1,  /**< @brief control code for key size 128 bytes, used for the partitioning command */
-     EEP_FTFC_KEY_SIZE_256_BYTES = 0x2,  /**< @brief control code for key size 256 bytes, used for the partitioning command */
-     EEP_FTFC_KEY_SIZE_512_BYTES = 0x3   /**< @brief control code for key size 512 bytes, used for the partitioning command */
- } TestEep_CsecKeySize;
-
- /**
-     @brief FlexRamPartition Type used for the partitioning command
- */
- typedef enum
- {
-     EEP_FTFC_EERAM_SIZE_0K  = 0xF,   /**< @brief control code for flexram partitioned as sram, used for the partitioning command */
-     EEP_FTFC_EERAM_SIZE_4K  = 0x2,   /**< @brief control code for flexram partitioned as eeram, used for the partitioning command */
-     EEP_FTFC_EERAM_SIZE_2K  = 0x3    /**< @brief control code for flexram partitioned as eeram, used for the partitioning command */
- } TestEep_Eeprom_FlexRamPartitionType;
-
- /**
-     @brief FlexNvmPartition Type used for the partitioning command
- */
- typedef enum
- {
-     EEP_FTFC_EEEPROM_SIZE_0K_V1   =  0x0,   /**< @brief control code to partition EEPROM backup size as 0K, used for the partitioning command */
-     EEP_FTFC_EEEPROM_SIZE_0K_V2   =  0xC,   /**< @brief control code to partition EEPROM backup size as 0K, used for the partitioning command */
-     EEP_FTFC_EEEPROM_SIZE_0K_V3   =  0x0F,  /**< @brief control code to partition EEPROM backup size as 0K, used for the partitioning command */
-     EEP_FTFC_EEEPROM_SIZE_32K_V1  = 0x3,    /**< @brief control code to partition EEPROM backup size as 32K, used for the partitioning command */
-     EEP_FTFC_EEEPROM_SIZE_32K_V2  = 0xB,    /**< @brief control code to partition EEPROM backup size as 32K, used for the partitioning command */
-     EEP_FTFC_EEEPROM_SIZE_48K_V1  = 0xA,    /**< @brief control code to partition EEPROM backup size as 48K, used for the partitioning command */
-     EEP_FTFC_EEEPROM_SIZE_64K_V1  = 0x8,    /**< @brief control code to partition EEPROM backup size as 64K, used for the partitioning command */
-     EEP_FTFC_EEEPROM_SIZE_64K_V2  = 0x4,    /**< @brief control code to partition EEPROM backup size as 64K, used for the partitioning command */
-     EEP_FTFC_EEEPROM_SIZE_24K_V2  = 0x9     /**< @brief control code to partition EEPROM backup size as 24K, used for the partitioning command */
- } TestEep_Eeprom_FlexNvmPartitionType;
- /**
-     @brief Sfe Type used for the partitioning command
- */
- typedef enum
- {
-     EEP_FTFC_VERIFY_ONLY_DISABLED  = 0x0,    /**< @brief control code for sfe verify only disabled, used for the partitioning command */
-     EEP_FTFC_VERIFY_ONLY_ENABLED   = 0x1     /**< @brief control code for sfe verify only enabled, used for the partitioning command */
- } TestEep_SfeType;
-
- /**
-     @brief LoadFlexRam at reset Type used for the partitioning command
- */
- typedef enum
- {
-     EEP_FTFC_LOAD_AT_RESET_ENABLED  = 0x0,  /**< @brief control code for loading flexram at reset, used for the partitioning command */
-     EEP_FTFC_LOAD_AT_RESET_DISABLED = 0x1   /**< @brief control code for not loading flexram at reset, used for the partitioning command */
- } TestEep_LoadFlexRamType;
-
-#define EEP_ERASE_START_ADD         (0U)
-#define EEP_WRTESTPATT_SIZE         (33U)
-#define EEP_RDTESTPATT_SIZE         (33U)
-
-#define REG_WRITE8(address, value)        							(*((volatile uint8*)(address)) = (value))
-#define REG_BIT_GET8(address, mask)       							((*(volatile uint8*)(address))& (mask))
-
-#define T_EEEPROM_SIZE                     							EEP_FTFC_EEEPROM_SIZE_32K_V2
-#define TEST_EEP_EEPROM_FSTAT_ADDR32                               ((uint32)(IP_FTFC_BASE + (uint32)0x00UL)) /**< @brief Eeprom Status Register (FTFE_FSTAT) */
-#define TEST_EEP_EEPROM_FCCOB3_ADDR32                              ((uint32)(IP_FTFC_BASE + (uint32)0x04UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB3) */
-#define TEST_EEP_EEPROM_FCCOB2_ADDR32                              ((uint32)(IP_FTFC_BASE + (uint32)0x05UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB2) */
-#define TEST_EEP_EEPROM_FCCOB1_ADDR32                              ((uint32)(IP_FTFC_BASE + (uint32)0x06UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB1) */
-#define TEST_EEP_EEPROM_FCCOB0_ADDR32                              ((uint32)(IP_FTFC_BASE + (uint32)0x07UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB0) */
-#define TEST_EEP_EEPROM_FCCOB7_ADDR32                              ((uint32)(IP_FTFC_BASE + (uint32)0x08UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB7) */
-#define TEST_EEP_EEPROM_FCCOB6_ADDR32                              ((uint32)(IP_FTFC_BASE + (uint32)0x09UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB6) */
-#define TEST_EEP_EEPROM_FCCOB5_ADDR32                              ((uint32)(IP_FTFC_BASE + (uint32)0x0AUL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB5) */
-#define TEST_EEP_EEPROM_FCCOB4_ADDR32                              ((uint32)(IP_FTFC_BASE + (uint32)0x0BUL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB4) */
-
-#define TEST_EEP_EEPROM_FSTAT_CCIF_U8                              (0x0080U)
-#define TEST_EEP_EEPROM_FSTAT_ACCERR_U8                            (0x0020U)
-#define TEST_EEP_EEPROM_FSTAT_FPVIOL_U8                            (0x0010U)
+Std_ReturnType UART_Query_Data(uint8 transChannel, uint8 recvChannel, const uint8 *txBuffer, uint32 sendLength, uint8 *rxBuffer, uint16 *rxlen, uint32 T_timeout);
+Std_ReturnType UART_Send_Data(uint8 transChannel, const uint8 *txBuffer, uint32 sendLength, uint32 T_timeout);
+Std_ReturnType UART_Receive_Data(uint8 recvChannel, uint8 *rxBuffer, uint16 *rxlen, sint32 T_timeout);
+void UART_Callback(uint32 hwInstance, Lpuart_Uart_Ip_EventType event);
+
+/*CAN*/
+typedef enum
+{
+    CAN_STANDARD_ID_TYPE = 0x00,   /**< * -00b CAN message with Standard CAN ID  */
+    CANFD_STANDARD_ID_TYPE = 0x01, /**< * -01b CAN FD frame with Standard CAN ID  */
+    CAN_EXTENDED_ID_TYPE = 0x02,   /**< * -10b CAN message with Extended CAN ID  */
+    CANFD_EXTENDED_ID_TYPE = 0x03, /**< * -11b CAN FD frame with Extended CAN ID  */
+} CAN_IdFrameType;
+
+typedef struct
+{
+    Can_IdType id;
+
+    CAN_IdFrameType idFrame;
+
+    uint8 length; /**< @brief DLC = Data Length Code (part of L-PDU that describes
+                                            the SDU length). */
+    uint8 *sdu;   /**< @brief CAN L-SDU = Link Layer Service Data
+                                                           Unit. Data that is transported inside
+                                                           the L-PDU. */
+} Can_Msg_Type;
+typedef struct
+{
+    Can_IdType id;
+    uint8 length;
+    uint8 data[8];
+} Can_Msg_Type_Data;
+extern Std_ReturnType CanIf_SendMessage(uint8 ControllerId, Can_Msg_Type CanMsg);
+
+/*EEP*/
+
+typedef enum
+{
+    EEP_FTFC_KEY_SIZE_0_BYTES = 0x0,   /**< @brief control code for key size 0 bytes, used for the partitioning command */
+    EEP_FTFC_KEY_SIZE_128_BYTES = 0x1, /**< @brief control code for key size 128 bytes, used for the partitioning command */
+    EEP_FTFC_KEY_SIZE_256_BYTES = 0x2, /**< @brief control code for key size 256 bytes, used for the partitioning command */
+    EEP_FTFC_KEY_SIZE_512_BYTES = 0x3  /**< @brief control code for key size 512 bytes, used for the partitioning command */
+} TestEep_CsecKeySize;
+
+/**
+    @brief FlexRamPartition Type used for the partitioning command
+*/
+typedef enum
+{
+    EEP_FTFC_EERAM_SIZE_0K = 0xF, /**< @brief control code for flexram partitioned as sram, used for the partitioning command */
+    EEP_FTFC_EERAM_SIZE_4K = 0x2, /**< @brief control code for flexram partitioned as eeram, used for the partitioning command */
+    EEP_FTFC_EERAM_SIZE_2K = 0x3  /**< @brief control code for flexram partitioned as eeram, used for the partitioning command */
+} TestEep_Eeprom_FlexRamPartitionType;
+
+/**
+    @brief FlexNvmPartition Type used for the partitioning command
+*/
+typedef enum
+{
+    EEP_FTFC_EEEPROM_SIZE_0K_V1 = 0x0,  /**< @brief control code to partition EEPROM backup size as 0K, used for the partitioning command */
+    EEP_FTFC_EEEPROM_SIZE_0K_V2 = 0xC,  /**< @brief control code to partition EEPROM backup size as 0K, used for the partitioning command */
+    EEP_FTFC_EEEPROM_SIZE_0K_V3 = 0x0F, /**< @brief control code to partition EEPROM backup size as 0K, used for the partitioning command */
+    EEP_FTFC_EEEPROM_SIZE_32K_V1 = 0x3, /**< @brief control code to partition EEPROM backup size as 32K, used for the partitioning command */
+    EEP_FTFC_EEEPROM_SIZE_32K_V2 = 0xB, /**< @brief control code to partition EEPROM backup size as 32K, used for the partitioning command */
+    EEP_FTFC_EEEPROM_SIZE_48K_V1 = 0xA, /**< @brief control code to partition EEPROM backup size as 48K, used for the partitioning command */
+    EEP_FTFC_EEEPROM_SIZE_64K_V1 = 0x8, /**< @brief control code to partition EEPROM backup size as 64K, used for the partitioning command */
+    EEP_FTFC_EEEPROM_SIZE_64K_V2 = 0x4, /**< @brief control code to partition EEPROM backup size as 64K, used for the partitioning command */
+    EEP_FTFC_EEEPROM_SIZE_24K_V2 = 0x9  /**< @brief control code to partition EEPROM backup size as 24K, used for the partitioning command */
+} TestEep_Eeprom_FlexNvmPartitionType;
+/**
+    @brief Sfe Type used for the partitioning command
+*/
+typedef enum
+{
+    EEP_FTFC_VERIFY_ONLY_DISABLED = 0x0, /**< @brief control code for sfe verify only disabled, used for the partitioning command */
+    EEP_FTFC_VERIFY_ONLY_ENABLED = 0x1   /**< @brief control code for sfe verify only enabled, used for the partitioning command */
+} TestEep_SfeType;
+
+/**
+    @brief LoadFlexRam at reset Type used for the partitioning command
+*/
+typedef enum
+{
+    EEP_FTFC_LOAD_AT_RESET_ENABLED = 0x0, /**< @brief control code for loading flexram at reset, used for the partitioning command */
+    EEP_FTFC_LOAD_AT_RESET_DISABLED = 0x1 /**< @brief control code for not loading flexram at reset, used for the partitioning command */
+} TestEep_LoadFlexRamType;
+
+#define EEP_ERASE_START_ADD (0U)
+#define EEP_WRTESTPATT_SIZE (33U)
+#define EEP_RDTESTPATT_SIZE (33U)
+
+#define REG_WRITE8(address, value) (*((volatile uint8 *)(address)) = (value))
+#define REG_BIT_GET8(address, mask) ((*(volatile uint8 *)(address)) & (mask))
+
+#define T_EEEPROM_SIZE EEP_FTFC_EEEPROM_SIZE_32K_V2
+#define TEST_EEP_EEPROM_FSTAT_ADDR32 ((uint32)(IP_FTFC_BASE + (uint32)0x00UL))  /**< @brief Eeprom Status Register (FTFE_FSTAT) */
+#define TEST_EEP_EEPROM_FCCOB3_ADDR32 ((uint32)(IP_FTFC_BASE + (uint32)0x04UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB3) */
+#define TEST_EEP_EEPROM_FCCOB2_ADDR32 ((uint32)(IP_FTFC_BASE + (uint32)0x05UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB2) */
+#define TEST_EEP_EEPROM_FCCOB1_ADDR32 ((uint32)(IP_FTFC_BASE + (uint32)0x06UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB1) */
+#define TEST_EEP_EEPROM_FCCOB0_ADDR32 ((uint32)(IP_FTFC_BASE + (uint32)0x07UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB0) */
+#define TEST_EEP_EEPROM_FCCOB7_ADDR32 ((uint32)(IP_FTFC_BASE + (uint32)0x08UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB7) */
+#define TEST_EEP_EEPROM_FCCOB6_ADDR32 ((uint32)(IP_FTFC_BASE + (uint32)0x09UL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB6) */
+#define TEST_EEP_EEPROM_FCCOB5_ADDR32 ((uint32)(IP_FTFC_BASE + (uint32)0x0AUL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB5) */
+#define TEST_EEP_EEPROM_FCCOB4_ADDR32 ((uint32)(IP_FTFC_BASE + (uint32)0x0BUL)) /**< @brief Eeprom Common Command Object Registers(FTFE_FCCOB4) */
+
+#define TEST_EEP_EEPROM_FSTAT_CCIF_U8 (0x0080U)
+#define TEST_EEP_EEPROM_FSTAT_ACCERR_U8 (0x0020U)
+#define TEST_EEP_EEPROM_FSTAT_FPVIOL_U8 (0x0010U)
 /* Start address for DFLASH sector 0 */
-#define TEST_EEP_DEEPROM_SECTOR_0_ADDR32                           0x10000000
-#define D_EEPROM_BASE_ADDR                                         (0x10000000UL)
-#define TEST_EEP_EEPROM_CMD_ERASE_SECTOR                           (0x09UL)
+#define TEST_EEP_DEEPROM_SECTOR_0_ADDR32 0x10000000
+#define D_EEPROM_BASE_ADDR (0x10000000UL)
+#define TEST_EEP_EEPROM_CMD_ERASE_SECTOR (0x09UL)
 
-#define EEPROM_CMD_PROGRAM_PARTITION                               (0x80UL)
+#define EEPROM_CMD_PROGRAM_PARTITION (0x80UL)
 
- void Eep_DepartParitition(TestEep_Eeprom_FlexNvmPartitionType T_EEP_SIZE);
- Std_ReturnType HAL_EEP_Erase(uint32 eepEraseStartAddr,uint32 eepEraseSize);
- Std_ReturnType HAL_EEP_Read(uint32 eepReadStartAddr,uint8* pDataBuffer,uint32 dataSize);
- Std_ReturnType HAL_EEP_Write(uint32 eepWriteStartAddr,uint8* pDataNeedtoWrite,uint32 dataSize);
- Std_ReturnType HAL_EEP_Compare(uint32 eepCompareStartAddr,uint8* pDataNeedtoCompare,uint32 dataSize);
+void Eep_DepartParitition(TestEep_Eeprom_FlexNvmPartitionType T_EEP_SIZE);
+Std_ReturnType HAL_EEP_Erase(uint32 eepEraseStartAddr, uint32 eepEraseSize);
+Std_ReturnType HAL_EEP_Read(uint32 eepReadStartAddr, uint8 *pDataBuffer, uint32 dataSize);
+Std_ReturnType HAL_EEP_Write(uint32 eepWriteStartAddr, uint8 *pDataNeedtoWrite, uint32 dataSize);
+Std_ReturnType HAL_EEP_Compare(uint32 eepCompareStartAddr, uint8 *pDataNeedtoCompare, uint32 dataSize);
 
 #endif /* HAL_ADAPTER_H_ */