EC600G/components/ql-application/socket/socket_demo.c

/*================================================================
  Copyright (c) 2020 Quectel Wireless Solution, Co., Ltd.  All Rights Reserved.
  Quectel Wireless Solution Proprietary and Confidential.
=================================================================*/
/*=================================================================

                        EDIT HISTORY FOR MODULE

This section contains comments describing changes made to the module.
Notice that changes are listed in reverse chronological order.

WHEN              WHO         WHAT, WHERE, WHY
------------     -------     -------------------------------------------------------------------------------

=================================================================*/



#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "ql_api_osi.h"
#include "ql_api_nw.h"

#include "ql_log.h"
#include "ql_api_datacall.h"
#include "sockets.h"
#include "lwip/ip_addr.h"
#include "lwip/ip6_addr.h"

#include "lwip/netdb.h"
#include "lwip/netif.h"
#include "lwip/inet.h"
#include "lwip/tcp.h"

#include "ql_ssl.h"

#include "ip4_addr.h"
#include "inet.h"


#define QL_SOCKET_LOG_LEVEL	                QL_LOG_LEVEL_INFO
#define QL_SOCKET_LOG(msg, ...)			    QL_LOG(QL_SOCKET_LOG_LEVEL, "ql_Sock", msg, ##__VA_ARGS__)
#define QL_SOCKET_LOG_PUSH(msg, ...)	    QL_LOG_PUSH("ql_SSL", msg, ##__VA_ARGS__)

#define QL_SOCKET_DEMO_CHANGE_DEMO 0

#if QL_SOCKET_DEMO_CHANGE_DEMO
#define QL_SOCKET_DEMO_URL "www.baidu.com"
#else
#define QL_SOCKET_DEMO_URL "nas.fast-fun.cn"//"220.180.239.212"
#endif

/* 
#define SERVER_PORT 8085
#define SERVER_IP   "47.107.99.203"
#define SERVER_URL  "nas.fast-fun.cn"//"220.180.239.212"
*/
 
 
u32_t my_ipaddr_addr(const char *cp)
{
  ip4_addr_t val;

  if (ip4addr_aton(cp, &val)) {
    return ip4_addr_get_u32(&val);
  }
  return (IPADDR_NONE);
}
 


static ql_task_t socket_demo_task = NULL;
static char send_buf[128]={0};
static int  send_len = 0;
static char recv_buf[128]={0};
static int  recv_len = 0;


//获取socket接收缓存的剩余大小
int ql_socket_get_free_size(int s,void *value)
{
    int ret = ERR_OK;
    if (s < 0||value==NULL)
    {
        return -1;
    }
    *((int32_t *)value) =lwip_getRecvBufSize(s)-lwip_getRecvAvailSize(s);
    QL_SOCKET_LOG("socket free size:%d", *((int32_t *)value));
    if(*((int32_t *)value)<0)
    {
        ret = ERR_VAL;
    }
    return ret;
}

//获取socket发送缓存中已发送但未收到回应的数据大小
int ql_socket_get_unacked_size(int s,void *value)
{
    int ret = ERR_OK;
    if (s < 0||value==NULL)
    {
        return -1;
    }
    *((int32_t *)value) =lwip_getSentSize(s)-lwip_getAckedSize(s);
    QL_SOCKET_LOG("socket unacked size:%d", *((int32_t *)value));
    if(*((int32_t *)value)<0)
    {
        ret = ERR_VAL;
    }
    return ret;
}

#if 1
static void socket_app_thread(void * arg)
{
	int ret = 0;
	int i = 0;
	int profile_idx = 1;
    ql_data_call_info_s info;
	char ip4_addr_str[16] = {0};
	fd_set read_fds;
	fd_set write_fds;
	fd_set exp_fds;
	int socket_fd = -1;
	int flags = 0;
	int fd_changed = 0;
	int connected = 0;
	int closing = false;
	struct sockaddr_in local4, server_ipv4;	
	struct addrinfo *pres = NULL;	
	struct addrinfo *temp = NULL;
	uint8_t nSim = 0;
	ql_nw_data_count_info_s data_count_info = {0};
#if QL_SOCKET_DEMO_CHANGE_DEMO
	ql_datacall_dns_info_s dns_pri = {0};
	ql_datacall_dns_info_s dns_sec = {0};
#endif	

	ql_rtos_task_sleep_s(10);
	QL_SOCKET_LOG("========== socket demo start ==========");
	QL_SOCKET_LOG("wait for network register done");
	
	while((ret = ql_network_register_wait(nSim, 120)) != 0 && i < 10){
    	i++;
		ql_rtos_task_sleep_s(1);
	}
	if(ret == 0){
		i = 0;
		QL_SOCKET_LOG("====network registered!!!!====");
	}else{
		QL_SOCKET_LOG("====network register failure!!!!!====");
		goto exit;
	}

	ql_set_data_call_asyn_mode(nSim, profile_idx, 0);

	QL_SOCKET_LOG("===start data call====");
	ret=ql_start_data_call(nSim, profile_idx, QL_PDP_TYPE_IP, "cmnet", NULL, NULL, 0); 
	QL_SOCKET_LOG("===data call result:%d", ret);
	if(ret != 0){
		QL_SOCKET_LOG("====data call failure!!!!=====");
	}
	memset(&info, 0x00, sizeof(ql_data_call_info_s));
	
	ret = ql_get_data_call_info(nSim, profile_idx, &info);
	if(ret != 0){
		QL_SOCKET_LOG("ql_get_data_call_info ret: %d", ret);
		ql_stop_data_call(nSim, profile_idx);
		goto exit;
	}
    QL_SOCKET_LOG("info->profile_idx: %d", info.profile_idx);
	QL_SOCKET_LOG("info->ip_version: %d", info.ip_version);
            
	QL_SOCKET_LOG("info->v4.state: %d", info.v4.state); 
	inet_ntop(AF_INET, &info.v4.addr.ip, ip4_addr_str, sizeof(ip4_addr_str));
	QL_SOCKET_LOG("info.v4.addr.ip: %s\r\n", ip4_addr_str);

	inet_ntop(AF_INET, &info.v4.addr.pri_dns, ip4_addr_str, sizeof(ip4_addr_str));
	QL_SOCKET_LOG("info.v4.addr.pri_dns: %s\r\n", ip4_addr_str);

	inet_ntop(AF_INET, &info.v4.addr.sec_dns, ip4_addr_str, sizeof(ip4_addr_str));
	QL_SOCKET_LOG("info.v4.addr.sec_dns: %s\r\n", ip4_addr_str);

#if QL_SOCKET_DEMO_CHANGE_DEMO
	ql_datacall_get_dns_addr(nSim, profile_idx, &dns_pri, &dns_sec);
	QL_SOCKET_LOG("get_dns_pri:[%d][%s]", dns_pri.type, ip4addr_ntoa(&dns_pri.ip4));
	QL_SOCKET_LOG("get_dns_sec:[%d][%s]", dns_sec.type, ip4addr_ntoa(&dns_sec.ip4));

	memset(&dns_pri, 0x00, sizeof(ql_datacall_dns_info_s));
	dns_pri.type = QL_PDP_TYPE_IP;
	dns_sec.type = QL_PDP_TYPE_IP;
	ip4addr_aton("114.114.114.114", &(dns_pri.ip4));
	ip4addr_aton("8.8.8.8", &(dns_sec.ip4));
	ql_datacall_set_dns_addr(nSim, profile_idx, &dns_pri, &dns_sec);

	memset(&dns_pri, 0x00, sizeof(ql_datacall_dns_info_s));
	ql_datacall_get_dns_addr(nSim, profile_idx, &dns_pri, &dns_sec);
	QL_SOCKET_LOG("get_dns_pri:[%d][%s]", dns_pri.type, ip4addr_ntoa(&dns_pri.ip4));
	QL_SOCKET_LOG("get_dns_sec:[%d][%s]", dns_sec.type, ip4addr_ntoa(&dns_sec.ip4));
#endif

	memset(&local4, 0x00, sizeof(struct sockaddr_in));
	local4.sin_family = AF_INET;
	local4.sin_port = 0;
	inet_aton(ip4addr_ntoa(&info.v4.addr.ip), &local4.sin_addr);	
loop:
	ret = getaddrinfo_with_pcid(QL_SOCKET_DEMO_URL, NULL, NULL, &pres, (uint32)profile_idx);
	if (ret < 0 || pres == NULL) 
	{
		QL_SOCKET_LOG("DNS getaddrinfo failed! ret=%d; pres=%p!\n",ret,pres);
		goto exit;
	}

	FD_ZERO(&read_fds);
	FD_ZERO(&write_fds);
	FD_ZERO(&exp_fds);
	flags = 0;
	connected = 0;
	closing = false;
	i = 0;
	for(temp = pres; temp != NULL; temp = temp->ai_next){
		//struct sockaddr_in * sin_res = (struct sockaddr_in *)temp->ai_addr;
		if(temp->ai_family == AF_INET){
			socket_fd = socket(temp->ai_family, SOCK_STREAM, 0);
			if(socket_fd < 0){
				continue;
			}

			ret = bind(socket_fd,(struct sockaddr *)&local4,sizeof(struct sockaddr));
			if(ret < 0){
				close(socket_fd);
				socket_fd = -1;
				continue;
			}
			
			flags |= O_NONBLOCK;
			fcntl(socket_fd, F_SETFL,flags);

			memset(&server_ipv4, 0x00, sizeof(struct sockaddr_in));
			server_ipv4.sin_family = AF_INET;
			server_ipv4.sin_port = htons(7780);	 			
			server_ipv4.sin_addr.s_addr = my_ipaddr_addr("47.107.99.203");    			
			ret = connect(socket_fd, (struct sockaddr *)&server_ipv4, sizeof(struct sockaddr_in));	
			
			if(ret == 0){
				connected = 1;
				break;
			}else{
				if(lwip_get_error(socket_fd) != EINPROGRESS){
					close(socket_fd);
					socket_fd = -1;
					continue;
				}else{
					break;
				}
			}
		}
	}
	if(socket_fd < 0){
		goto exit;
	}
	if(connected == 1){
		FD_SET(socket_fd, &read_fds);	
		QL_SOCKET_LOG("=====connect to my_server success=====");
		memset(send_buf, 0x00, 128);
		send_len = snprintf(send_buf, 128,"%d%s%d\r\n",i,"startAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAend",i);
		
		if(write(socket_fd, send_buf, send_len) != send_len){
			FD_SET(socket_fd, &write_fds);	
		}else{
			i++;
		}
	}else{
		FD_SET(socket_fd, &write_fds);	
	}	
	FD_SET(socket_fd, &exp_fds);

	while(1){
		fd_changed = select(socket_fd+1, &read_fds, &write_fds, &exp_fds, NULL);
		if(fd_changed > 0){
			if(FD_ISSET(socket_fd, &write_fds)){
				FD_CLR(socket_fd, &write_fds);
				if(connected== 0){
					int value = 0;
					int len = 0;
						
					len = sizeof(value);
					getsockopt(socket_fd, SOL_SOCKET, SO_ERROR, &value, &len);
						
					QL_SOCKET_LOG("errno: %d", value);
					if(value == 0 || value == EISCONN ){
						QL_SOCKET_LOG("=====connect to \"220.180.239.212:8252\" success=====");
						connected = 1;						
						FD_SET(socket_fd, &read_fds);	

						memset(send_buf, 0x00, 128);
						send_len = snprintf(send_buf, 128,"%d%s%d\r\n",i,"startAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAend",i);
						write(socket_fd, send_buf, send_len);
						i++;
					}else{
						QL_SOCKET_LOG("=====connect to \"220.180.239.212:8252\" failed=====");
						close(socket_fd);
						socket_fd = -1;
						break;
					}
				}else{
					memset(send_buf, 0x00, 128);
					send_len = snprintf(send_buf, 128,"%d%s%d\r\n",i,"startAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAend",i);
					write(socket_fd, send_buf, send_len);
					i++;
				}						
			}else if(FD_ISSET(socket_fd, &read_fds)){
				FD_CLR(socket_fd, &read_fds);
			    memset(recv_buf,0x00, 128);
				recv_len = read(socket_fd, recv_buf, 128);
				if(recv_len > 0){
					for(int i = 0;i < recv_len;i++)
						QL_SOCKET_LOG(">>>>Recv: %x \n", recv_buf[i]);

					QL_SOCKET_LOG("chengwei recv ok\n");	
					memset(send_buf, 0x00, 128);
					send_len = snprintf(send_buf, 128,"%d%s%d\r\n",i,"startAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAend",i);
					write(socket_fd, send_buf, send_len);
					i++;
					FD_SET(socket_fd, &read_fds);
					if(ql_nw_get_data_count(nSim, &data_count_info) == 0)
					{
						QL_SOCKET_LOG("data count: uplink %llu, downlink %llu", data_count_info.uplink_data_count, data_count_info.downlink_data_count);
					}
				}else if(recv_len == 0){
					if(closing == false){
						QL_SOCKET_LOG("===passive close!!!!");
						shutdown(socket_fd, SHUT_WR);
						closing = true;
						FD_SET(socket_fd, &read_fds);	
					}else{
						close(socket_fd);
						socket_fd = -1;
						break;
					}
				}else{
					if(lwip_get_error(socket_fd) == EAGAIN){
						FD_SET(socket_fd, &read_fds);	
					}else{
						close(socket_fd);
						socket_fd = -1;
						break;
					}
				}
			}else if(FD_ISSET(socket_fd, &exp_fds)){
				FD_CLR(socket_fd, &exp_fds);
				close(socket_fd);
				socket_fd = -1;
				break;
			}
			
		}
	}
    if(pres!=NULL)
    {
        freeaddrinfo(pres);
        pres = NULL;
    }
	goto loop;
exit:  
   ql_rtos_task_delete(socket_demo_task);	
	
   return;	
}
#endif

int ql_socket_app_init(void)
{
	QlOSStatus err = QL_OSI_SUCCESS;
	
    err = ql_rtos_task_create(&socket_demo_task, 16*1024, APP_PRIORITY_ABOVE_NORMAL, "QsocketApp", socket_app_thread, NULL, 5);
	if(err != QL_OSI_SUCCESS)
    {
		QL_SOCKET_LOG("socket_app init failed");
	}

	return err;
}

#if 0

/*********************************************************************************************/
/*********************************************************************************************/
/*********************************************************************************************/

#define sint32 s32_t
#define sint16 s16_t
#define sint8  s8_t

#define uint32  u32_t
#define uint16  u16_t
#define uint8   u8_t

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 CRLF "\r\n"
#define BATT_SN_LEN 17
#define BMS_SN_LEN	12
#define TCP_START_SYM1 	0x23
#define TCP_START_SYM2 	0x23
#define TCP_CMD_SYM 	0x02   	// 瀹炴椂淇℃伅涓婃姤鏄�0x02
#define TCP_HEART_SYM 	0x07 	// 蹇冭烦鍖呮爣蹇�
#define TCP_TIMING		0x08	//缁堢鏍℃椂

#define TCP_QUERY_SYM 	0x80	//鏌ヨ鎸囦护锛堜笅琛岋級
#define TCP_SETCMD_SYM 	0x81	//璁剧疆鍛戒护锛堜笅琛岋級
#define TCP_CONCMD_SYM 	0x82	//鎺у埗鍛戒护锛堜笅琛岋級
#define TCP_UDSCMD_SYM 	0x83	//杩滅▼璇婃柇鍛戒护锛堜笅琛岋級
//Answer symbol
#define TCP_ANS_SYM 0xFE
#define TCP_ENCPT_ENABLE 0x00
#define TCP_ENCPT_DISABLE 0x01

//瀹炴椂涓婃姤淇℃伅浣擄紙鍚岃ˉ鍙戜笂鎶ワ級
#define TimeCali		0x01
#define DebugMsg 		0x8C
#define VerMsg 			0xA0
#define GPSMsg 			0xA2
#define DeviceStateMsg	0xA4
#define BattStaticMsg 	0xB0
#define BattDynamicMsg	0xB2
#define TruckVehiMsg	0xB4
#define EngyStoreSysMsg	0xB8
#define BattAccuMsg		0xBA
#define BattSceneMsg	0xBC
#define BattHighFeqMsg 	0xC0
#define BattAlgthMsg	0xC2




#define BATT_DYNAMIC_MSG_REVERS_BYTE 20
#define BATT_CHRG_TEMP_NUM 4
#define BATT_CONN_TEMP_NUM 4
#define BATT_BSC_LOCK_NUM  4




typedef struct _GPSInfo
{
	uint8 locateMark;
	uint8 satelliteNum;
	uint8 direction[2];
	uint8 speed[2];
	uint8 altitude[2];
	uint8 latitude[4];
	uint8 longitude[4];
	uint8 AccMileage[4];
} GPSInfo;


typedef struct _DebugInfoType
{
	UINT8 sendTimeUTC[6];
	UINT8 msgMark;
	UINT8 DebugLen[2];
} DebugInfoType;
typedef struct DebugMsgtoTcp_Type
{
	UINT8 startSymbol[2];
	UINT8 cmdSymbol;
	UINT8 ansSymbol;
	UINT8 SN[BATT_SN_LEN];
	UINT8 encryptMethod;
	UINT8 dataLength[2];
	DebugInfoType DebugInfo;
	UINT8 _CRC;
} DebugMsgtoTcpType;

typedef struct _VerInfoType		//0xA0
{
	uint8 sendTimeUTC[6];
	uint8 msgMark;
	uint8 msgCollectionTimeUTC[6];
	uint8 tcpProtocolVer[2];
	uint8 deviceType;
	uint8 deviceGenerationInfo;
	uint8 ICCID[20];
	uint8 IMEI[15];
	uint8 deviceHwVersion[2];
	uint8 deviceKernelVersion[4];
	uint8 deviceDriverSWVersion[4];
	uint8 deviceAppSWVersion[4];
	uint8 BleMacAddr[6];
	uint8 deviceProduceDate[3];
} VerInfoType;
typedef struct VersionMsgtoTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	VerInfoType VerInfo;
	uint8 CRC;
} VersionMsgtoTcpType;

typedef struct _GPSInfoType		//0xA2
{
	uint8 sendTimeUTC[6];
	uint8 msgMark;
	uint8 msgCollectionTimeUTC[6];
	GPSInfo GpsInfoData;
	uint8 Tac[2];
	uint8 CellID[4];
} GPSInfoType;

typedef struct _GPSMsgtoTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	GPSInfoType gpsInfo;
	uint8 CRC;
} GPSMsgtoTcpType;


typedef struct _DeviceStateInfoType	//0xA4
{
	uint8 sendTimeUTC[6];
	uint8 msgMark;
	uint8 msgCollectionTimeUTC[6];
	uint8 deviceErrorCode;
	uint8 deviceTcpCSQValue;
	uint8 deviceLockBattState;
	uint8 deviceBeepState;
	uint8 deviceAuthState;
	uint8 deviceInstallElevation;
	uint8 deviceInstallRollAngle;
	uint8 deviceXAxisAccVal[2];
	uint8 deviceYAxisAccVal[2];
	uint8 deviceZAxisAccVal[2];
	uint8 deviceFFT_X_FreData[5];
	uint8 deviceFFT_X_AmpData[5];
	uint8 deviceFFT_Y_FreData[5];
	uint8 deviceFFT_Y_AmpData[5];
	uint8 deviceFFT_Z_FreData[5];
	uint8 deviceFFT_Z_AmpData[5];
	uint8 deviceUpsSOC;
	uint8 deviceUpsVolt[2];
	uint8 deviceUpsTemp;
	uint8 deviceTempNum;
	uint8 deviceTemp[10];
} DeviceStateInfoType;
typedef struct _DeviceStateMsgtoTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	DeviceStateInfoType DeviceState;
	uint8 CRC;
} DeviceStateMsgtoTcpType;

/*************0xB0**********/
typedef struct _BattStaticMsgType
{
	uint8 sendTimeUTC[6];
	uint8 msgMark;
	uint8 msgCollectionTimeUTC[6];
	uint8 battCustomCode[2];	//string ascii
	uint8 battPackManuCode[2];	//string ascii
	uint8 battCellManuCode[2];	//string ascii
	uint8 battCellTypeCode;		//N/L
	uint8 battCellVoltNum[2];
	uint8 battCellTempNum[2];
	uint8 battBMSSNLen;
	uint8 battBMSSN[BMS_SN_LEN];
	uint8 battRelatedCapacity[2];	//0.1Ah
	uint8 battRelatedEnergy[2];	//0.1kwh
	uint8 battRelatedVolt[2];		//0.1V
	uint8 battProduceDate[3];
	uint8 battRelatedCellVolt[2];	//1mv
	uint8 battRelatedMaxCellVolt[2];	//1mv
	uint8 battRelatedMinCellVolt[2];	//1mv
	uint8 battThermalManagType;		//0-none,1-water heater and colder,2-water colder and ptc heater,3-ptc with air colder
	uint8 battConstMaxchrgCurr[2];//0.1A
	uint8 battConstMaxDischrgCurr[2]; //0.1A
	uint8 bmsHwVersion[4];
	uint8 bmsSwVersion[4];
}BattStaticMsgType;

typedef struct _BattStaticMsgToTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	BattStaticMsgType battStaticInfo;
	uint8 CRC;
} BattStaticMsgToTcpType;

/*************0xB2**********/
typedef struct _BattDynamicMsgType1
{
	uint8 sendTimeUTC[6];
	uint8 msgMark;
	uint8 msgCollectionTimeUTC[6];
	uint8 battBmsErrLv;
	uint8 battBmsErrCode[2];
	uint8 battPackCurr[2];		//鐢垫睜鎬荤數娴�	0~40000,re:0.1A,off:-2000
	uint8 battLinkVolt[2];		//鐢垫睜鍖呭唴渚х數鍘�    0.1V
	uint8 battPackVolt[2];		//鐢垫睜鍖呭渚х數鍘�	0.1V
	uint8 battWorkState;		//0-闈欑疆锛�1-鏀剧數锛�2-鎱㈠厖锛�3-蹇厖
	uint8 battRelayState[4];
	uint8 battHVState;			//0-鍒濆鍖栵紝1-楂樺帇涓婄數锛�2-楂樺帇涓嬬數锛�3-鏃犳晥
	uint8 battChrgSt;			//0-鏈厖鐢碉紝1-鍏呯數涓紝2-鍏呯數瀹屾垚锛�3-鍏呯數鏁呴殰
	uint8 battChrgGunSt;		//0-鏈繛鎺ワ紝1-宸茶繛鎺�
	uint8 battChrgMode;			//0-鎻掓灙鍏呯數锛�1-绔欏唴鍏呯數
	uint8 battBMSSOC;			//0.4%
	uint8 battBMSSOH;			//1%
	uint8 battBalanceSt;		//0-鏈潎琛★紝1-宸插紑鍚潎琛�
	uint8 battInsR[2];			//1k惟
	uint8 battTMSSt;		//0-鍏虫満锛�1-鍙惊鐜紝2-鍔犵儹锛�3-鍒跺喎锛屽叾浣欓鐣�
	uint8 battTMSErrCode;	//璇﹁鏁呴殰浠ｇ爜琛�
	uint8 battTMSReqPWR[2];//0.1kw
	uint8 battTMSOutletTemp;	//鍑烘按鍙ｆ俯搴︼紝1鈩冿紝-40鈩�
	uint8 battTMSInjectTemp;	//杩涙按鍙ｆ俯搴︼紝1鈩冿紝-40鈩�
	uint8 reverseVar[BATT_DYNAMIC_MSG_REVERS_BYTE];		//棰勭暀绌洪棿锛岄粯璁や负0
}BattDynamicMsgType1;

 
typedef struct _BattDynamicMsgType2
{
	uint8 battMaxCellVolt[2];			//1mV
	uint8 battMaxCellVolOrderNum[2];	//搴忓彿
	uint8 battMinCellVolt[2];			//1mV
	uint8 battMinCellVoltOrderNum[2];	//搴忓彿
	uint8 battMaxCellTemp;			//1mV
	uint8 battMaxCellTempOrderNum[2];	//搴忓彿
	uint8 battMinCellTemp;			//1mV
	uint8 battMinCellTempOrderNum[2];	//搴忓彿
	uint8 battMaxRechrgCurr[2];//0.1A
	uint8 battMaxDischrgCurr[2]; //0.1A

}BattDynamicMsgType2;

typedef struct _BattDynamicMsgToTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	//battDynamicMsg
	//uint8 CRC;
} BattDynamicMsgToTcpType;



/***********0xB4************/
typedef struct _TruckVehiMsgType1
{
	uint8 sendTimeUTC[6];
	uint8 msgMark;
	uint8 msgCollectionTimeUTC[6];
	uint8 VIN[17];				//ASCII
	uint8 vehiSpeed[2];			//0.1km/h
	uint8 vehiErrCode[2];		//鏁磋溅鏁呴殰浠ｇ爜
	uint8 bscSystemErrCode;		//鎹㈢數绯荤粺鏁呴殰浠ｇ爜
	uint8 vehiSt;				//鏁磋溅鐘舵�侊紝0-绛夊緟锛�1-ready
	uint8 bmsHvReq;				//bms涓婇珮鍘嬭姹傦紙vcu to bms锛夛紝0-涓嬮珮鍘嬶紝1-涓婇珮鍘�
	uint8 vehiCurrGearSt;		//0-绌烘尅锛�		1-12锛欴1-D12锛�	13-24锛歁1-M12锛�	25锛歊锛�	26锛歅
	uint8 vehiBreakSt;			//鍒跺姩寮�鍏筹紝0-鍏抽棴锛屾湭鍒跺姩锛�		1-鎵撳紑锛屽埗鍔ㄤ腑
	uint8 vehilRelaySt[10];		//鏁村悎鐩稿叧缁х數鍣ㄧ姸鎬佽〃		棰勭暀
	uint8 bscSt;				//鎹㈢數鎺у埗鍣ㄧ姸鎬�	0-琛岃溅鐘舵��	1-閫氫俊鐘舵��	2-鎹㈢數鐘舵��

	uint8 battBSCConTempNum;
	uint8 battBSCConTemp[BATT_CONN_TEMP_NUM];	//鎹㈢數杩炴帴鍣ㄦ俯搴�  1,-40
	//鎹㈢數閿佹満鏋勭姸鎬�
	uint8 battBSCLockNum;
	uint8 battBSCLockSt[BATT_BSC_LOCK_NUM];	//閿佹満鏋勭姸鎬侊紝0-閿佺揣锛�1-鏈攣绱ф湭瑙ｉ攣锛�2-瑙ｉ攣

	//鎹㈢數杩炴帴鍣�
	uint8 bscConnType;			//1-鍗曡繛鎺ュ櫒锛�	4-鍥涜繛鎺ュ櫒
	uint8 bscConnSt;			//0-瀹屽叏杩炴帴锛�	1-鏈畬鍏ㄨ繛鎺ワ紝	2-瀹屽叏鑴辩锛堟湭杩炴帴锛�
	uint8 bscChangeCount[2];	//杞﹁締鎹㈢數娆℃暟
}TruckVehiMsgType1;





typedef struct _TruckVehiMsgToTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	TruckVehiMsgType1 truckVehiInfo;
	uint8 CRC;
} TruckVehiMsgToTcpType;



/**************0xB8************/
typedef struct _EngyStoreSysMsgType
{
	uint8 sendTimeUTC[6];
	uint8 msgMark;
	uint8 msgCollectionTimeUTC[6];
	uint8 inverterSt;			//閫嗗彉鍣ㄧ姸鎬侊紝		0-闂悎	1-鏂紑
	uint8 battRelaySt;			//鐢垫睜缁х數鍣ㄧ姸鎬�		0-闂悎	1-鏂紑
	uint8 battTMSFanSt;			//鐢垫睜鏁ｇ儹椋庢墖鐘舵��	0-闂悎	1-鏂紑
	uint8 battTMSHeaterRelaySt;	//鐢垫睜鍔犵儹缁х數鍣ㄧ姸鎬�	0-闂悎	1-鏂紑
}EngyStoreSysMsgType;
typedef struct _EngyStoreSysMsgToTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	EngyStoreSysMsgType energyStoreSysInfo;
	uint8 CRC;
} EngyStoreSysMsgToTcpType;

 
/**************0xBA************/
typedef struct AccInfoType
{
	uint8 sendTimeUTC[6];
	uint8 msgMark;
	uint8 msgCollectionTimeUTC[6];
	uint8 accOnlineDays[2];
	uint8 vehiODO[4];
	uint8 accBattCycTimes[2];
	uint8 accOverChrgTimes[2];
	uint8 accOverDischrgTimes[2];
	uint8 accChrgTimes[2];
	uint8 accDischrgTimes[2];
	uint8 bmsTotalChrgCapy[4];		//0.1Ah
	uint8 bmsTotalChrgEngy[4];		//0.1kwh
	uint8 bmsTotalDischrgCapy[4];	//0.1Ah
	uint8 bmsTotalDischrgEngy[4];	//0.1kwh
	uint8 bmsTotalStaCharCapy[4];	//0.1Ah
	uint8 bmsTotalStaCharEngy[4];	//0.1kwh
	uint8 bmsTotalBackCharCapy[4];	//0.1Ah
	uint8 bmsTotalBackCharEngy[4];	//0.1kwh
	uint8 bmsTotalGunCharCapy[4];	//0.1Ah
	uint8 bmsTotalGunCharEngy[4];	//0.1kwh
} AccInfoType;
typedef struct AccInfoToTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	AccInfoType AccInfo;
	uint8 CRC;
} AccInfoToTcpType;

/*********** BattSceneMsg	0xBC**********/
typedef struct _BattSceneInfoType
{
	uint8 sendTimeUTC[6];
	uint8 msgMark;
	uint8 msgCollectionTimeUTC[6];
	uint8 sceneType;	//0-鏃犱笟鍔★紝	1-鍑哄敭锛�	2-绉熻祦
	uint8 sceneSt;		//0-鏈璧�		1-宸茬璧�
	uint8 sceneStartDate[6];
	uint8 sceneAvalibleTime[2];		//澶�
	uint8 sceneDeadTime[2];			//澶�
} BattSceneInfoType;
typedef struct _BattSceneMsgtoTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	BattSceneInfoType battSceneInfo;
	uint8 CRC;
} BattSceneMsgtoTcpType;

/***********  BattHighFeqMsg 	0xC0**********/
typedef struct _BattHighFeqInfoType
{
	uint8 sendTimeUTC[6];
	uint8 msgMark;
	uint8 msgCollectionTimeUTC[6];
	uint8 battPackVolt[2];			//0.1v
	uint8 battPackCurr[2];			//0-20000, -1000A~1000A,0.1A
	uint8 battMaxCellVolt[2];	//1mv
	uint8 battMinCellVolt[2];	//1mv
	uint8 battMaxCellTemp[2];	//1,-40
	uint8 battMinCellTemp[2];	//1,-40
} BattHighFeqInfoType;
typedef struct _BattHighFeqMsgtoTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	BattHighFeqInfoType battHighFeqInfo;
	uint8 CRC;
} BattHighFeqMsgtoTcpType;

/***********  BattAlgthMsg	0xC2**********/
typedef struct _BattAlgthInfoType
{
	uint8 sendTimeUTC[6];
	uint8 msgMark;
	uint8 msgCollectionTimeUTC[6];
	uint8 bmsPackSOC;			//0.4%
	uint8 bmsPackSOH;			//1%
	uint8 bboxCalSOC;			//0.4%
	uint8 bboxCalSOH;		//1%
	uint8 bboxCalTotalDischrgCapy[4];
	uint8 bboxCalTotalBackchrgCapy[4];
	uint8 bboxCalTotalChrgCapy[4];
	uint8 bboxCalTotalDischrgEngy[4];
	uint8 bboxCalTotalBackchrgEngy[4];
	uint8 bboxCalTotalChrgEngy[4];
	uint8 BBox_Dq_Dv_MAX[4];
	uint8 BBox_Dq_Dv_MIN[4];
} BattAlgthInfoType;
typedef struct _BattAlgthMsgtoTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	BattAlgthInfoType battAlgthInfo;
	uint8 CRC;
} BattAlgthMsgtoTcpType;


 
/********************0x83 TCP_UDSCMD_SYM 涓嬭鎺у埗鎸囦护*******************/
typedef struct _UdsCmdInfoType			//download infomation
{
	uint8 udsCmdLen;
	uint8 udsSID;
	uint8 udsDID_H;
	uint8 udsDID_L;
	uint8 udsCmdData[10];
}UdsCmdInfoType;

typedef struct _UdsCmdPosAnsInfoType
{
	uint8 udsAnsLen;
	uint8 udsAnsDID_POS;
	uint8 udsAnsDID_H;
	uint8 udsAnsDID_L;
}UdsCmdPosAnsInfoType;

typedef struct _UdsCmdNegAnsInfoType
{
	uint8 udsAnsLen;
	uint8 udsAnsDID_Neg;
	uint8 udsAnsDID_H;
	uint8 udsAnsDID_L;
	uint8 udsAnsNegCode;
}UdsCmdNegAnsInfoType;

typedef struct _UdsCmdNegAnsMsgtoTcpType
{
	uint8 startSymbol[2];
	uint8 cmdSymbol;
	uint8 ansSymbol;
	uint8 SN[BATT_SN_LEN];
	uint8 encryptMethod;
	uint8 dataLength[2];
	UdsCmdNegAnsInfoType udsCmdNegAnsInfo;
	uint8 CRC;
} UdsCmdNegAnsMsgtoTcpType;


typedef struct UTC8Time_Type
{
	uint8 year;
	uint8 month;
	uint8 day;
	uint8 hour;
	uint8 minute;
	uint8 second;
} UTC8TimeType;

typedef struct
{
	sint16 TimeCaliFeqCng[3];			//0x01
	sint16 DebugMsgFeqCnt[3]; 			//0x8C
	sint16 VerMsgFeqCnt[3]; 			//0xA0
	sint16 GPSMsgFeqCnt[3]; 			//0xA2
	sint16 DeviceStateMsgFeqCnt[3];		//0xA4
	sint16 BattStaticMsgFeqCnt[3]; 		//0xB0
	sint16 BattDynamicMsgFeqCnt[3];		//0xB2
	sint16 TruckVehiMsgFeqCnt[3];		//0xB4
	sint16 EngyStoreSysMsgFeqCnt[3];	//0xB8
	sint16 BattAccuMsgFeqCnt[3];		//0xBA
	sint16 BattSceneMsgFeqCnt[3];		//0xBC
	sint16 BattHighFeqMsgFeqCnt[3]; 	//0xC0
	sint16 BattAlgthMsgFeqCnt[3];		//0xC2
}TcpFeq_type;


typedef struct
{
	uint8 year;
	uint8 month;
	uint8 day;
	uint8 hour;
	uint8 minute;
	uint8 second;
} UTC8TimeType;


static void vTimer1000msCallback(TimerHandle_t pxTimer);
static void tcpEncodeDebugMsg(uint32* PtrSendAddr, uint16* SendLen);
static void tcpEncodeVerMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpEncodeGPSMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpEncodeDeviceStMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpBattStaticMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpBattDynamicMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpTruckVehiMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpEngyStoreSysMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpBattAccInfoMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpBattSceneInfoMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpBattHighFeqInfoMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpBattAlgthInfoMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpUdsCmdNegAnsMsg(uint32* PtrSendAddr,uint16* SendLen);
static void tcpUdsCmdPosAnsMsg(uint32* PtrSendAddr,uint16* SendLen);


//////////////////////////////////////////////////////////////////////////////////////////////
typedef float real32_T;
real32_T ihd_I_battCurr_T2;
real32_T ihd_V_battU_T2;
real32_T ihd_V_cellUAvrg;
real32_T ihd_V_cellUMax;
real32_T ihd_V_cellUMin;
real32_T socd_pct_ahSoc;
real32_T socd_pct_battSoc;
real32_T socd_pct_battSocEi;
real32_T socd_pct_battSocEo;
real32_T socd_pct_bcuSoc;
real32_T socd_pct_bcuSocEi;
real32_T socd_pct_bcuSocEo;
real32_T socd_pct_ekfSoc;
real32_T sohd_pct_bcuSoh;


QueueHandle_t GpsDataQueueHandle;
typedef long  BaseType_t;

#define pdFALSE  ( ( BaseType_t ) 0 )
#define pdTRUE   ( ( BaseType_t ) 1 )
#define pdPASS   ( pdTRUE )
#define pdFAIL   ( pdFALSE )




#define BATT_SN_LEN 17
#define TCP_PROTOL_VER 			0x0302
#define	DEVICE_TYPE				0x02
#define DEVICE_GENERATION		0x01
#define DEVICE_KERNEL_VER		0x01000001
#define DEVICE_HW_VERSION		0x0102
#define DEVICE_DRIVER_SW_VER	0x01010003
#define DEVICE_APP_SW_VER		0x01010301
#define OTHER_TEMP_NUM			4
#define BMS_CELL_MAX_NUM 		384
#define BMS_TEMP_MAX_NUM        64

typedef unsigned char boolean_T;

sint16 xyzData[3] = {0};
uint8 TcpbattSN[BATT_SN_LEN] = {0x31};
uint8 DeviceErrNum = 0;
uint8 BLEMAC[6] = {0x45,0x56,0x67,0x78,0x89,0x90};
uint8 DEVICE_PRO_DATE[3] = {23,01,01};
uint8 BATT_PRO_DATE[3] = {23,01,01};
char ImeiNum[15] = {0};
char IccidNum[20] = {0};
boolean_T rtev_flg_EESt[4];
/************************************************************
 *BCU->4G解码变量存放区
 ************************************************************/
UINT8 BMS_CellRecvFlg = 0;						//电压收取标志位
UINT8 canRecvFramNum[BMS_CELL_MAX_NUM/3] = {0};
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-未上高压，2-上高压
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] = {0};							// 电池编码(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 = BMS_CELL_MAX_NUM;		// PACK中单体电芯的总数目,,Re-1,Off-0,//
UINT16 BMS_TempTotal = BMS_TEMP_MAX_NUM;		// 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


uint8 BATT_SYS_ERROR_NUM_BBox_To_TCP = 0x00;				//电池系统故障数量
uint8* BATT_SYS_ERROR_CODE_ARRAY_BBox_To_TCP = NULL;	//电池系统故障代码

/************************************************************
 *BBox计算变量定义区
 ************************************************************/
UINT8 BBox_DataReadyFlag = 0;
UINT8 BBox_VCUConSt = 0x01;						//VCU 连接状态，用于判断电池连接与车或站的连接状态，1为站，0为车
UINT8 BBox_PackSOC = 0x00;						//BBox计算SOC,Re-0.4,Off-0;
UINT8 BBox_PackSOH = 0x00;						//BBox计算SOH,Re-1,Off-0;
UINT32 BBox_TotalCharEngy = 0x00;				// 累计充入kWh 数,,Re-0.1,Off-0,KWh
UINT32 BBox_TotalDischarEngy = 0x00;				// 累计放出kWh 数,,Re-0.1,Off-0,KWh
UINT32 BBox_TotalBackCharEngy = 0x00;			// 累计动能回馈充入kWh 数,,Re-0.1,Off-0,KWh
UINT32 BBox_TotalStaCharEngy = 0x00;				// 累计换电站充入kWh 数,,Re-0.1,Off-0,KWh
UINT32 BBox_TotalGunCharEngy = 0x00;				// 累计插枪充电充入kWh 数,,Re-0.1,Off-0,KWh
UINT32 BBox_TotalGunCharCapy = 0x00;				// 累计插枪充电充入Ah 数,,Re-0.1,Off-0,Ah
UINT32 BBox_TotalCharCapy = 0x00;				// 累计充入Ah 数,,Re-0.1,Off-0,Ah
UINT32 BBox_TotalDischarCapy = 0x00;				// 累计放出Ah 数,,Re-0.1,Off-0,Ah
UINT32 BBox_TotalBackCharCapy = 0x00;			// 累计动能回馈充入Ah 数,,Re-0.1,Off-0,Ah
UINT32 BBox_TotalStaCharCapy = 0x00;				// 累计换电站充入Ah 数,,Re-0.1,Off-0,Ah
UINT32 BBox_Dq_Dv_MAX = 0x00;					//BBox计算dq/dv_MAX,Re-0.001,Off-0,Ah/10mV
UINT32 BBox_Dq_Dv_MIN = 0x00;					//BBox计算dq/dv_MIN,Re-0.001,Off-0,Ah/10mV

float BBox_SocCorrectionValue = 0x00;			//BBox的SOC修正量，平台下发，Re-0.1,0ff-100,1bit std for 0.1% -100~100
float BBox_SohCorrectionValue = 0x00;			//BBox的SOHC修正量，平台下发，Re-0.1,0ff-0,1bit std for 0.1% 1~100
//////////////////////////////////////////////////////////////////////////////////////////////

volatile TcpFeq_type TcpDataFeq={
		{TimeCali,			60*60*2,0},  	//time calib
		{DebugMsg,			10,		0},  	//debug msg feq
		{VerMsg,			60*60,	0},		//Version feq
		{GPSMsg,			10,		0},		//gps msg feq
		{DeviceStateMsg,	10,		0},		//device state msg feq
		{BattStaticMsg,		60,		0},		//
		{BattDynamicMsg,	60,		0},		//
		{TruckVehiMsg,		10,		0},		//trunk vehil msg feq
		{EngyStoreSysMsg,	30,		0},		//
		{BattAccuMsg,		30,		0},		//trunk vehil&batt acc msg feq
		{BattSceneMsg,		60*60,	0},		//
		{BattHighFeqMsg,	10,		0},		//
		{BattAlgthMsg,		10,		0},		//
};

static UTC8TimeType UTC8TimeTcp;

static void vTimer1000msCallback(TimerHandle_t pxTimer)
{
	uint32 ulTimerID;
	ulTimerID = (uint32)pvTimerGetTimerID(pxTimer);
	sint16 *TcpDataFeqPtr =NULL;
	TcpDataFeqPtr = (sint16 *)&TcpDataFeq;
	if (ulTimerID == 0)
	{
		if(SocketId>=0)
		{
			for(uint8 i=2;i<sizeof(TcpDataFeq)/sizeof(sint16);i=i+3)
			{
				*(TcpDataFeqPtr+i) = (*(TcpDataFeqPtr+i)-1)<0 ? 0 : (*(TcpDataFeqPtr+i)-1);
			}
		}
		TimeUpdate(&UTC8TimeTcp);
	}
}




void TimeUpdate(UTC8TimeType *UTC8TimeTcpPtr)
{
	int year = 0, month = 0, day = 0, hour = 0,minute = 0,second = 0;
	int lastday = 0;

	year = UTC8TimeTcpPtr->year + 2000;
	month = UTC8TimeTcpPtr->month;
	day = UTC8TimeTcpPtr->day;
	hour = UTC8TimeTcpPtr->hour;
	minute = UTC8TimeTcpPtr->minute;
	second = UTC8TimeTcpPtr->second;
	second+=1;
	if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
	{
		lastday = 31;
	}
	else if (month == 4 || month == 6 || month == 9 || month == 11)
	{
		lastday = 30;
	}
	else
	{
		if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0))
			lastday = 29;
		else
			lastday = 28;
	}
	if(second >=60)
	{
		second -=60;
		minute +=1;
		if(minute >=60)
		{
			minute -=60;
			hour +=1;
		}
	}
	if (hour >= 24)
	{
		hour -= 24;
		day += 1;
		if (day > lastday)
		{
			day -= lastday;
			month += 1;
			if (month > 12)
			{
				month -= 12;
				year += 1;
			}
		}
	}
	UTC8TimeTcpPtr->year = year - 2000;
	UTC8TimeTcpPtr->month = month;
	UTC8TimeTcpPtr->day = day;
	UTC8TimeTcpPtr->hour = hour;
	UTC8TimeTcpPtr->minute = minute;
	UTC8TimeTcpPtr->second = second;
}





/********************************平台协议3.0应用层***********************************/
static void tcpEncodeDebugMsg(uint32* PtrSendAddr, uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	char rbuf[512]={0};
	char tmp[13] = {0};
	memcpy(tmp,BMS_SN,12);
	DebugMsgtoTcpType DebugMsgInfo;
	UINT16 DataLen = 0;
	UINT16 BufferLen = 0;

	sprintf((char *)rbuf, "%s,%d,\
							{%.2f,%.2f,%.2f,%.2f},\
							{%d,%d,%d,%d,%d,%d},\
							{%.3f,%.3f,%.3f,%.1f,%d,%d}",
			tmp,DeviceErrNum,
			socd_pct_ahSoc,socd_pct_battSoc,socd_pct_bcuSoc,socd_pct_ekfSoc,
			BBox_TotalCharEngy,BBox_TotalDischarEngy,BBox_TotalBackCharEngy,BBox_TotalCharCapy,BBox_TotalDischarCapy,BBox_TotalBackCharCapy,
			ihd_V_cellUMax,ihd_V_cellUMin,ihd_V_cellUAvrg,ihd_I_battCurr_T2,BMS_PackSOC,rtev_flg_EESt[3]);

	BufferLen = strlen((const char *)rbuf);
	*SendLen = BufferLen + sizeof(DebugMsgInfo);
	SendBuffer = malloc(*SendLen);
	memcpy(SendBuffer + sizeof(DebugMsgInfo) - 1, rbuf, BufferLen);
	DataLen = sizeof(DebugMsgInfo.DebugInfo) + BufferLen;
	DebugMsgInfo.startSymbol[0] = TCP_START_SYM1;
	DebugMsgInfo.startSymbol[1] = TCP_START_SYM2;
	DebugMsgInfo.cmdSymbol = TCP_CMD_SYM;
	DebugMsgInfo.ansSymbol = TCP_ANS_SYM;
	memcpy(DebugMsgInfo.SN, TcpbattSN, BATT_SN_LEN);
	DebugMsgInfo.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	DebugMsgInfo.dataLength[0] = (DataLen >> 8) & 0xFF;
	DebugMsgInfo.dataLength[1] = DataLen & 0xFF;
	DebugMsgInfo.DebugInfo.sendTimeUTC[0] = UTC8TimeTcp.year & 0xFF;   // year
	DebugMsgInfo.DebugInfo.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;  // month
	DebugMsgInfo.DebugInfo.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	   // day
	DebugMsgInfo.DebugInfo.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;   // hour
	DebugMsgInfo.DebugInfo.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	DebugMsgInfo.DebugInfo.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	DebugMsgInfo.DebugInfo.msgMark = DebugMsg;
	DebugMsgInfo.DebugInfo.DebugLen[0] = BufferLen >> 8;
	DebugMsgInfo.DebugInfo.DebugLen[1] = BufferLen;
	memcpy(SendBuffer, (UINT8 *)(&DebugMsgInfo), sizeof(DebugMsgInfo) - 1);
	DebugMsgInfo._CRC = bcc_chk(SendBuffer, BufferLen + sizeof(DebugMsgInfo) - 1);
	memcpy(SendBuffer + BufferLen + sizeof(DebugMsgInfo) - 1, &DebugMsgInfo._CRC, 1);
	*PtrSendAddr = (uint32)SendBuffer;
}




static void tcpEncodeVerMsg(uint32* PtrSendAddr,uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	VersionMsgtoTcpType VerMsgToTcpInfo;
	*SendLen = sizeof(VersionMsgtoTcpType);
	SendBuffer = malloc(*SendLen);
	uint16 DataLen = 0;
	DataLen = (uint16)sizeof(VerInfoType);
	VerMsgToTcpInfo.startSymbol[0] = TCP_START_SYM1;
	VerMsgToTcpInfo.startSymbol[1] = TCP_START_SYM2;
	VerMsgToTcpInfo.cmdSymbol = TCP_CMD_SYM;
	VerMsgToTcpInfo.ansSymbol = TCP_ANS_SYM;
	memcpy(VerMsgToTcpInfo.SN, TcpbattSN, BATT_SN_LEN);
	VerMsgToTcpInfo.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	VerMsgToTcpInfo.dataLength[0] = (DataLen >> 8) & 0xFF;
	VerMsgToTcpInfo.dataLength[1] = DataLen & 0xFF;
	VerMsgToTcpInfo.VerInfo.sendTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	VerMsgToTcpInfo.VerInfo.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	// month
	VerMsgToTcpInfo.VerInfo.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	// day
	VerMsgToTcpInfo.VerInfo.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	// hour
	VerMsgToTcpInfo.VerInfo.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	VerMsgToTcpInfo.VerInfo.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	VerMsgToTcpInfo.VerInfo.msgMark = VerMsg;
	VerMsgToTcpInfo.VerInfo.msgCollectionTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	VerMsgToTcpInfo.VerInfo.msgCollectionTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	 // month
	VerMsgToTcpInfo.VerInfo.msgCollectionTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	 // day
	VerMsgToTcpInfo.VerInfo.msgCollectionTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	 // hour
	VerMsgToTcpInfo.VerInfo.msgCollectionTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	VerMsgToTcpInfo.VerInfo.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF;

	VerMsgToTcpInfo.VerInfo.tcpProtocolVer[0] 		=	(TCP_PROTOL_VER >> 8) & 0xFF;
	VerMsgToTcpInfo.VerInfo.tcpProtocolVer[1] 		= 	TCP_PROTOL_VER&0xFF;
	VerMsgToTcpInfo.VerInfo.deviceType				=	DEVICE_TYPE;
	VerMsgToTcpInfo.VerInfo.deviceGenerationInfo 	=	DEVICE_GENERATION;
	memcpy(VerMsgToTcpInfo.VerInfo.ICCID, IccidNum, 20);
	memcpy(VerMsgToTcpInfo.VerInfo.IMEI, ImeiNum, 15);

	VerMsgToTcpInfo.VerInfo.deviceHwVersion[0] 		=	(DEVICE_HW_VERSION >> 8) & 0xFF;
	VerMsgToTcpInfo.VerInfo.deviceHwVersion[1] 		= 	(DEVICE_HW_VERSION)&0xFF;

	VerMsgToTcpInfo.VerInfo.deviceKernelVersion[0] = DEVICE_KERNEL_VER >> 24;
	VerMsgToTcpInfo.VerInfo.deviceKernelVersion[1] = DEVICE_KERNEL_VER >> 16;
	VerMsgToTcpInfo.VerInfo.deviceKernelVersion[2] = DEVICE_KERNEL_VER >> 8;
	VerMsgToTcpInfo.VerInfo.deviceKernelVersion[3] = DEVICE_KERNEL_VER;

	VerMsgToTcpInfo.VerInfo.deviceDriverSWVersion[0] = DEVICE_DRIVER_SW_VER >> 24;
	VerMsgToTcpInfo.VerInfo.deviceDriverSWVersion[1] = DEVICE_DRIVER_SW_VER >> 16;
	VerMsgToTcpInfo.VerInfo.deviceDriverSWVersion[2] = DEVICE_DRIVER_SW_VER >> 8;
	VerMsgToTcpInfo.VerInfo.deviceDriverSWVersion[3] = DEVICE_DRIVER_SW_VER;

	VerMsgToTcpInfo.VerInfo.deviceAppSWVersion[0] = DEVICE_APP_SW_VER >> 24;
	VerMsgToTcpInfo.VerInfo.deviceAppSWVersion[1] = DEVICE_APP_SW_VER >> 16;
	VerMsgToTcpInfo.VerInfo.deviceAppSWVersion[2] = DEVICE_APP_SW_VER >> 8;
	VerMsgToTcpInfo.VerInfo.deviceAppSWVersion[3] = DEVICE_APP_SW_VER;
	memcpy((uint8*)(VerMsgToTcpInfo.VerInfo.BleMacAddr),BLEMAC,sizeof(BLEMAC));
	memcpy((uint8*)(VerMsgToTcpInfo.VerInfo.deviceProduceDate),DEVICE_PRO_DATE,sizeof(DEVICE_PRO_DATE));

	VerMsgToTcpInfo.CRC = bcc_chk((uint8 *)(&VerMsgToTcpInfo), sizeof(VerMsgToTcpInfo) - 1);
	memcpy(SendBuffer, (uint8*)(&VerMsgToTcpInfo), sizeof(VersionMsgtoTcpType));
	*PtrSendAddr = (uint32)SendBuffer;
}



static void tcpEncodeGPSMsg(uint32* PtrSendAddr,uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	GPSInfo GpsRecvData;
	GPSMsgtoTcpType GpsToTcpInfo;
	*SendLen = sizeof(GpsToTcpInfo);
	SendBuffer = malloc(*SendLen);
	uint16 tac = 0;
	uint32 cellId = 0;
	uint8 DataLen = (uint16)sizeof(GPSInfoType);
	GpsToTcpInfo.startSymbol[0] = TCP_START_SYM1;
	GpsToTcpInfo.startSymbol[1] = TCP_START_SYM2;
	GpsToTcpInfo.cmdSymbol = TCP_CMD_SYM;
	GpsToTcpInfo.ansSymbol = TCP_ANS_SYM;
	memcpy(GpsToTcpInfo.SN, TcpbattSN, BATT_SN_LEN);
	GpsToTcpInfo.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	GpsToTcpInfo.dataLength[0] = (DataLen >> 8) & 0xFF;
	GpsToTcpInfo.dataLength[1] = DataLen & 0xFF;
	GpsToTcpInfo.gpsInfo.sendTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	GpsToTcpInfo.gpsInfo.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	 // month
	GpsToTcpInfo.gpsInfo.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	 // day
	GpsToTcpInfo.gpsInfo.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	 // hour
	GpsToTcpInfo.gpsInfo.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	GpsToTcpInfo.gpsInfo.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	GpsToTcpInfo.gpsInfo.msgMark = GPSMsg;
	GpsToTcpInfo.gpsInfo.msgCollectionTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	GpsToTcpInfo.gpsInfo.msgCollectionTimeUTC[1] = UTC8TimeTcp.month & 0xFF;  // month
	GpsToTcpInfo.gpsInfo.msgCollectionTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	  // day
	GpsToTcpInfo.gpsInfo.msgCollectionTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	  // hour
	GpsToTcpInfo.gpsInfo.msgCollectionTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	GpsToTcpInfo.gpsInfo.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF;
	if (xQueueReceive(GpsDataQueueHandle, &GpsRecvData, 0) == pdPASS)
	{
		memcpy((uint8 *)&GpsToTcpInfo.gpsInfo.GpsInfoData, (uint8 *)&GpsRecvData, sizeof(GPSInfo));
	}
	else
	{
		memset((uint8 *)&GpsToTcpInfo.gpsInfo.GpsInfoData, 0x00, sizeof(GPSInfo));
	}
	GpsToTcpInfo.gpsInfo.Tac[0] = tac >> 8;
	GpsToTcpInfo.gpsInfo.Tac[1] = tac & 0xFF;
	GpsToTcpInfo.gpsInfo.CellID[0] = cellId >> 24;
	GpsToTcpInfo.gpsInfo.CellID[1] = cellId >> 16;
	GpsToTcpInfo.gpsInfo.CellID[2] = cellId >> 8;
	GpsToTcpInfo.gpsInfo.CellID[3] = cellId;

	GpsToTcpInfo.CRC = bcc_chk((uint8 *)(&GpsToTcpInfo), sizeof(GPSMsgtoTcpType) - 1);
	memcpy(SendBuffer, (uint8*)(&GpsToTcpInfo), sizeof(GpsToTcpInfo));
	*PtrSendAddr = (uint32)SendBuffer;
}


static void tcpEncodeDeviceStMsg(uint32* PtrSendAddr,uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	DeviceStateMsgtoTcpType deviceStateMsg = {0x00};
	*SendLen = sizeof(DeviceStateMsgtoTcpType);
	SendBuffer = malloc(*SendLen);
	uint16 DataLen = 0;
	DataLen = (uint16)sizeof(DeviceStateInfoType);
	deviceStateMsg.startSymbol[0] = TCP_START_SYM1;
	deviceStateMsg.startSymbol[1] = TCP_START_SYM2;
	deviceStateMsg.cmdSymbol = TCP_CMD_SYM;
	deviceStateMsg.ansSymbol = TCP_ANS_SYM;
	memcpy(deviceStateMsg.SN, TcpbattSN, BATT_SN_LEN);
	deviceStateMsg.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	deviceStateMsg.dataLength[0] = (DataLen >> 8) & 0xFF;
	deviceStateMsg.dataLength[1] = DataLen & 0xFF;
	deviceStateMsg.DeviceState.sendTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	deviceStateMsg.DeviceState.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	// month
	deviceStateMsg.DeviceState.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	// day
	deviceStateMsg.DeviceState.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	// hour
	deviceStateMsg.DeviceState.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	deviceStateMsg.DeviceState.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	deviceStateMsg.DeviceState.msgMark = DeviceStateMsg;
	deviceStateMsg.DeviceState.msgCollectionTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	deviceStateMsg.DeviceState.msgCollectionTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	 // month
	deviceStateMsg.DeviceState.msgCollectionTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	 // day
	deviceStateMsg.DeviceState.msgCollectionTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	 // hour
	deviceStateMsg.DeviceState.msgCollectionTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	deviceStateMsg.DeviceState.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF;

	uint8 CSQValue = 0;
	GetCSQValue(&CSQValue);

	deviceStateMsg.DeviceState.deviceErrorCode 		=	0x12;
	deviceStateMsg.DeviceState.deviceTcpCSQValue 	=	CSQValue;
	deviceStateMsg.DeviceState.deviceLockBattState 	= 	0x34;
	deviceStateMsg.DeviceState.deviceBeepState 		=	1;
	deviceStateMsg.DeviceState.deviceAuthState 		=	1;

	deviceStateMsg.DeviceState.deviceInstallElevation 		=	0x23;
	deviceStateMsg.DeviceState.deviceInstallRollAngle 		= 	0x34;


	uint16 xyzDatacache[3] = {0};
	memcpy(xyzDatacache, xyzData, 3 * sizeof(uint16));
	for (uint8 i = 0; i < 3; i++)
	{
		if (xyzDatacache[i] > 0x8000) // 鏁版嵁涓鸿礋
		{
			xyzDatacache[i] = 20000U + (sint16)xyzDatacache[i];
		}
		else
		{
			xyzDatacache[i] = xyzDatacache[i] + 20000U;
		}
	}
	deviceStateMsg.DeviceState.deviceXAxisAccVal[0] 		=	xyzDatacache[0] >> 8;
	deviceStateMsg.DeviceState.deviceXAxisAccVal[1] 		=	xyzDatacache[0];
	deviceStateMsg.DeviceState.deviceYAxisAccVal[0] 		= 	xyzDatacache[1] >> 8;
	deviceStateMsg.DeviceState.deviceYAxisAccVal[1] 		=	xyzDatacache[1];
	deviceStateMsg.DeviceState.deviceZAxisAccVal[0] 		=	xyzDatacache[2] >> 8;
	deviceStateMsg.DeviceState.deviceZAxisAccVal[1] 		= 	xyzDatacache[2];

	memcpy(deviceStateMsg.DeviceState.deviceFFT_X_FreData, returnFreq[0], 5);
	memcpy(deviceStateMsg.DeviceState.deviceFFT_X_AmpData, returnP[0], 5);
	memcpy(deviceStateMsg.DeviceState.deviceFFT_Y_FreData, returnFreq[1], 5);
	memcpy(deviceStateMsg.DeviceState.deviceFFT_Y_AmpData, returnP[1], 5);
	memcpy(deviceStateMsg.DeviceState.deviceFFT_Z_FreData, returnFreq[2], 5);
	memcpy(deviceStateMsg.DeviceState.deviceFFT_Z_AmpData, returnP[2], 5);

	deviceStateMsg.DeviceState.deviceUpsSOC 		=	100;


	deviceStateMsg.DeviceState.deviceUpsVolt[0] = 0x12;
	deviceStateMsg.DeviceState.deviceUpsVolt[1] = 0x34;

	deviceStateMsg.DeviceState.deviceUpsTemp 		=	0x40;

	deviceStateMsg.DeviceState.deviceTempNum 		=	10;	//闀垮害涓嶇‘瀹�
	memset((uint8*)(deviceStateMsg.DeviceState.deviceTemp),0x65,deviceStateMsg.DeviceState.deviceTempNum);

	deviceStateMsg.CRC = bcc_chk((uint8 *)(&deviceStateMsg), sizeof(DeviceStateMsgtoTcpType) - 1);
	memcpy(SendBuffer, (uint8*)(&deviceStateMsg), sizeof(DeviceStateMsgtoTcpType));
	*PtrSendAddr = (uint32)SendBuffer;
}
static void tcpBattStaticMsg(uint32* PtrSendAddr,uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	BattStaticMsgToTcpType battStaticMsg = {0x00};
	*SendLen = sizeof(BattStaticMsgToTcpType);
	SendBuffer = malloc(*SendLen);
	uint16 DataLen = 0;
	DataLen = (uint16)sizeof(BattStaticMsgType);
	battStaticMsg.startSymbol[0] = TCP_START_SYM1;
	battStaticMsg.startSymbol[1] = TCP_START_SYM2;
	battStaticMsg.cmdSymbol = TCP_CMD_SYM;
	battStaticMsg.ansSymbol = TCP_ANS_SYM;
	memcpy(battStaticMsg.SN, TcpbattSN, BATT_SN_LEN);
	battStaticMsg.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	battStaticMsg.dataLength[0] = (DataLen >> 8) & 0xFF;
	battStaticMsg.dataLength[1] = DataLen & 0xFF;
	battStaticMsg.battStaticInfo.sendTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	battStaticMsg.battStaticInfo.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	// month
	battStaticMsg.battStaticInfo.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	// day
	battStaticMsg.battStaticInfo.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	// hour
	battStaticMsg.battStaticInfo.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	battStaticMsg.battStaticInfo.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	battStaticMsg.battStaticInfo.msgMark = BattStaticMsg;
	battStaticMsg.battStaticInfo.msgCollectionTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	battStaticMsg.battStaticInfo.msgCollectionTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	 // month
	battStaticMsg.battStaticInfo.msgCollectionTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	 // day
	battStaticMsg.battStaticInfo.msgCollectionTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	 // hour
	battStaticMsg.battStaticInfo.msgCollectionTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	battStaticMsg.battStaticInfo.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF;

	battStaticMsg.battStaticInfo.battCustomCode[0] 		=	0x31;
	battStaticMsg.battStaticInfo.battCustomCode[1] 		= 	0x32;
	battStaticMsg.battStaticInfo.battPackManuCode[0] 	=	0x33;
	battStaticMsg.battStaticInfo.battPackManuCode[1] 	= 	0x34;
	battStaticMsg.battStaticInfo.battCellManuCode[0] 	=	0x35;
	battStaticMsg.battStaticInfo.battCellManuCode[1] 	= 	0x36;
	battStaticMsg.battStaticInfo.battCellTypeCode 		=	0;

	battStaticMsg.battStaticInfo.battCellVoltNum[0] 	=	0;
	battStaticMsg.battStaticInfo.battCellVoltNum[1] 	= 	0;
	battStaticMsg.battStaticInfo.battCellTempNum[0] 	=	0;
	battStaticMsg.battStaticInfo.battCellTempNum[1] 	= 	0;
	battStaticMsg.battStaticInfo.battBMSSNLen 			=	BMS_SN_LEN;
	memset(battStaticMsg.battStaticInfo.battBMSSN,0x31,BMS_SN_LEN);

	battStaticMsg.battStaticInfo.battRelatedCapacity[0] =	0x12;
	battStaticMsg.battStaticInfo.battRelatedCapacity[1] = 	0x34;

	battStaticMsg.battStaticInfo.battRelatedEnergy[0] 	=	0x45;
	battStaticMsg.battStaticInfo.battRelatedEnergy[1] 	= 	0x56;

	battStaticMsg.battStaticInfo.battRelatedVolt[0] 	=	0x67;
	battStaticMsg.battStaticInfo.battRelatedVolt[1] 	= 	0x78;

	memcpy(battStaticMsg.battStaticInfo.battProduceDate,BATT_PRO_DATE,3);

	battStaticMsg.battStaticInfo.battRelatedCellVolt[0] 		=	0x11;
	battStaticMsg.battStaticInfo.battRelatedCellVolt[1] 		= 	0x22;
	battStaticMsg.battStaticInfo.battRelatedMaxCellVolt[0] 		=	0x33;
	battStaticMsg.battStaticInfo.battRelatedMaxCellVolt[1] 		= 	0x44;
	battStaticMsg.battStaticInfo.battRelatedMinCellVolt[0] 		=	0x55;
	battStaticMsg.battStaticInfo.battRelatedMinCellVolt[1] 		= 	0x66;
	battStaticMsg.battStaticInfo.battThermalManagType 			= 	2;

	battStaticMsg.battStaticInfo.battConstMaxchrgCurr[0] 		=	0x77;
	battStaticMsg.battStaticInfo.battConstMaxchrgCurr[1] 		= 	0x88;

	battStaticMsg.battStaticInfo.battConstMaxDischrgCurr[0] 	=	0x99;
	battStaticMsg.battStaticInfo.battConstMaxDischrgCurr[1] 	= 	0xaa;

	battStaticMsg.battStaticInfo.bmsHwVersion[0] 		=	1;
	battStaticMsg.battStaticInfo.bmsHwVersion[1] 		= 	2;
	battStaticMsg.battStaticInfo.bmsHwVersion[2] 		=	3;
	battStaticMsg.battStaticInfo.bmsHwVersion[3] 		= 	1;

	battStaticMsg.battStaticInfo.bmsSwVersion[0] 		=	2;
	battStaticMsg.battStaticInfo.bmsSwVersion[1] 		= 	0;
	battStaticMsg.battStaticInfo.bmsSwVersion[2] 		=	0;
	battStaticMsg.battStaticInfo.bmsSwVersion[3] 		= 	3;

	battStaticMsg.CRC = bcc_chk((uint8 *)(&battStaticMsg), sizeof(battStaticMsg) - 1);
	memcpy(SendBuffer, (uint8*)(&battStaticMsg), sizeof(BattStaticMsgToTcpType));
	*PtrSendAddr = (uint32)SendBuffer;
}
static void tcpBattDynamicMsg(uint32* PtrSendAddr,uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	BattDynamicMsgType1 battDynamicMsgType1 = {0x00};
	BattDynamicMsgType2 battDynamicMsgType2 = {0x00};
	BattDynamicMsgToTcpType battDynamicMsgType = {0x00};

	getBattSysErrCodeFromCAN();

	uint16 DataLen = 0;
	DataLen =  sizeof(BattDynamicMsgType1)
				+  (2 + BMS_CellTotal * 2)
				+ (1 + BATT_CHRG_TEMP_NUM)
				+ (1 + BATT_CONN_TEMP_NUM)
				+ (2 + BMS_TempTotal)
				+ (1 + OTHER_TEMP_NUM)
				+ sizeof(BattDynamicMsgType2)
				+ 1 + BATT_SYS_ERROR_NUM_BBox_To_TCP;

	*SendLen = sizeof(BattDynamicMsgToTcpType) + DataLen + 1; //(+1 means crc)
	SendBuffer = malloc(*SendLen);

	battDynamicMsgType.startSymbol[0] = TCP_START_SYM1;
	battDynamicMsgType.startSymbol[1] = TCP_START_SYM2;
	battDynamicMsgType.cmdSymbol = TCP_CMD_SYM;
	battDynamicMsgType.ansSymbol = TCP_ANS_SYM;
	memcpy(battDynamicMsgType.SN, TcpbattSN, BATT_SN_LEN);
	battDynamicMsgType.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	battDynamicMsgType.dataLength[0] = (DataLen >> 8) & 0xFF;
	battDynamicMsgType.dataLength[1] = DataLen & 0xFF;

	memcpy((SendBuffer + 0),&battDynamicMsgType,sizeof(BattDynamicMsgToTcpType));  //without crc

	battDynamicMsgType1.sendTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	battDynamicMsgType1.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	// month
	battDynamicMsgType1.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	// day
	battDynamicMsgType1.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	// hour
	battDynamicMsgType1.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	battDynamicMsgType1.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	battDynamicMsgType1.msgMark = BattDynamicMsg;
	battDynamicMsgType1.msgCollectionTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	battDynamicMsgType1.msgCollectionTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	 // month
	battDynamicMsgType1.msgCollectionTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	 // day
	battDynamicMsgType1.msgCollectionTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	 // hour
	battDynamicMsgType1.msgCollectionTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	battDynamicMsgType1.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec

	battDynamicMsgType1.battBmsErrLv 	  = 	0x01;
	battDynamicMsgType1.battBmsErrCode[0] = 	0x02;
	battDynamicMsgType1.battBmsErrCode[1] = 	0x03;
	battDynamicMsgType1.battPackCurr[0]   = 	0x04;
	battDynamicMsgType1.battPackCurr[1]   = 	0x05;
	battDynamicMsgType1.battLinkVolt[0]   = 	0x06;
	battDynamicMsgType1.battLinkVolt[1]   =		0x07;
	battDynamicMsgType1.battPackVolt[0] = 0x08;
	battDynamicMsgType1.battPackVolt[1] = 0x09;
	battDynamicMsgType1.battWorkState	= 0x0a;
	battDynamicMsgType1.battRelayState[0] = 0x0b;
	battDynamicMsgType1.battRelayState[1] = 0x0c;
	battDynamicMsgType1.battRelayState[2] = 0x0d;
	battDynamicMsgType1.battRelayState[3] = 0x0e;
	battDynamicMsgType1.battHVState = 0x10;
	battDynamicMsgType1.battChrgSt = 0x20;
	battDynamicMsgType1.battChrgGunSt = 0x30;
	battDynamicMsgType1.battChrgMode = 0x40;
	battDynamicMsgType1.battBMSSOC = 0x50;
	battDynamicMsgType1.battBMSSOH = 0x60;
	battDynamicMsgType1.battBalanceSt = 0x70;
	battDynamicMsgType1.battInsR[0] = 0x80;
	battDynamicMsgType1.battInsR[1] = 0x90;
	battDynamicMsgType1.battTMSSt = 0xa0;
	battDynamicMsgType1.battTMSErrCode = 0xb0;
	battDynamicMsgType1.battTMSReqPWR[0] = 0xc0;
	battDynamicMsgType1.battTMSReqPWR[1] = 0xd0;
	battDynamicMsgType1.battTMSOutletTemp = 0xe0;
	battDynamicMsgType1.battTMSInjectTemp = 0xf0;
	memset(battDynamicMsgType1.reverseVar,0x12,BATT_DYNAMIC_MSG_REVERS_BYTE);

	battDynamicMsgType2.battMaxCellVolt[0] = 0x11;
	battDynamicMsgType2.battMaxCellVolt[1] = 0x12;
	battDynamicMsgType2.battMaxCellVolOrderNum[0] = 0x13;
	battDynamicMsgType2.battMaxCellVolOrderNum[1] = 0x14;
	battDynamicMsgType2.battMinCellVolt[0] = 0x15;
	battDynamicMsgType2.battMinCellVolt[1] = 0x16;
	battDynamicMsgType2.battMinCellVoltOrderNum[0] = 0x17;
	battDynamicMsgType2.battMinCellVoltOrderNum[1] = 0x18;
	battDynamicMsgType2.battMaxCellTemp = (BMS_MaxCellTemp)&0xFF;
	battDynamicMsgType2.battMaxCellTempOrderNum[0] = (BMS_MaxCellTempNum>>8)&0xFF;
	battDynamicMsgType2.battMaxCellTempOrderNum[1] = (BMS_MaxCellTempNum)&0xFF;
	battDynamicMsgType2.battMinCellTemp = (BMS_MinCellTemp)&0xFF;
	battDynamicMsgType2.battMinCellTempOrderNum[0] = (BMS_MinCellTempNum>>8)&0xFF;
	battDynamicMsgType2.battMinCellTempOrderNum[1] = (BMS_MinCellTempNum)&0xFF;
	battDynamicMsgType2.battMaxRechrgCurr[0] = 0x12;
	battDynamicMsgType2.battMaxRechrgCurr[1] = 0x13;
	battDynamicMsgType2.battMaxDischrgCurr[0] = 0x14;
	battDynamicMsgType2.battMaxDischrgCurr[1] = 0x15;


	memcpy((SendBuffer 	+ sizeof(BattDynamicMsgToTcpType)),&battDynamicMsgType1,sizeof(BattDynamicMsgType1));

	uint8 battCellVoltNum[2] = {0x00};
	battCellVoltNum[0] = (BMS_CellTotal>>8)&0xFF;
	battCellVoltNum[1] = BMS_CellTotal&0xFF;

	memcpy((SendBuffer 	+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)),	battCellVoltNum,2);
	memcpy((SendBuffer 	+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)
						+ 2),	BMS_CellVolt,BMS_CellTotal*2);  //copy the cell vol info

	uint8 battChrgTemp[BATT_CHRG_TEMP_NUM]  =  {0x30};

	*(SendBuffer 		+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)
						+ (2 + BMS_CellTotal*2)) = BATT_CHRG_TEMP_NUM;
	memcpy((SendBuffer 	+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)
						+ (2 + BMS_CellTotal*2)
						+ 1),	battChrgTemp,BATT_CHRG_TEMP_NUM	);  //copy the cell vol info

	uint8 battConnTemp[BATT_CONN_TEMP_NUM] = {0x31};
	memset(battConnTemp,0x31,BATT_CONN_TEMP_NUM);		//tset data

	*(SendBuffer 		+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)
						+ (2 + BMS_CellTotal*2)
						+ (1 + BATT_CHRG_TEMP_NUM)) = BATT_CONN_TEMP_NUM;
	memcpy((SendBuffer 	+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)
						+ (2 + BMS_CellTotal*2)
						+ (1 + BATT_CHRG_TEMP_NUM)
						+ (1)),	battConnTemp,	BATT_CONN_TEMP_NUM	); //copy the batt connector temp info

	uint8 battCellTempNum[2] = {0x00};
	battCellTempNum[0] = (BMS_TempTotal>>8)&0xFF;
	battCellTempNum[1] = BMS_TempTotal&0xFF;
	memcpy((SendBuffer 	+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)
						+ (2 + BMS_CellTotal*2)
						+ (1 + BATT_CHRG_TEMP_NUM)
						+ (1 + BATT_CONN_TEMP_NUM)),battCellTempNum,2);
	memcpy((SendBuffer 	+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)
						+ (2 + BMS_CellTotal*2)
						+ (1 + BATT_CHRG_TEMP_NUM)
						+ (1 + BATT_CONN_TEMP_NUM)
						+ (2)),	BMS_CellTemp,BMS_TempTotal);	//copy the cell temp info


	uint8 otherTemp[OTHER_TEMP_NUM] = {0x32};
	memset(otherTemp,0x32,OTHER_TEMP_NUM);		//tset data

	*(SendBuffer 		+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)
						+ (2 + BMS_CellTotal*2)
						+ (1+  BATT_CHRG_TEMP_NUM)
						+ (1 + BATT_CONN_TEMP_NUM)
						+ (2 + BMS_TempTotal)) = 	OTHER_TEMP_NUM;
	memcpy((SendBuffer 	+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)
						+ (2 + BMS_CellTotal*2)
						+ (1 + BATT_CHRG_TEMP_NUM)
						+ (1 + BATT_CONN_TEMP_NUM)
						+ (2 + BMS_TempTotal)
						+ (1)),otherTemp,	OTHER_TEMP_NUM);	//copy the other temp info
	memcpy((SendBuffer 	+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)
						+ (2 + BMS_CellTotal*2)
						+ (1 + BATT_CHRG_TEMP_NUM)
						+ (1 + BATT_CONN_TEMP_NUM)
						+ (2 + BMS_TempTotal)
						+ (1 + OTHER_TEMP_NUM)),(uint8*)(&battDynamicMsgType2),sizeof(BattDynamicMsgType2));	//copy the dynamic msg2 info

	*(SendBuffer 	+ sizeof(BattDynamicMsgToTcpType)// copy the system error code info
						+ sizeof(BattDynamicMsgType1)
						+ (2 + BMS_CellTotal*2)
						+ (1 + BATT_CHRG_TEMP_NUM)
						+ (1 + BATT_CONN_TEMP_NUM)
						+ (2 + BMS_TempTotal)
						+ (1 + OTHER_TEMP_NUM)
						+ sizeof(BattDynamicMsgType2)
						+ 1) = BATT_SYS_ERROR_NUM_BBox_To_TCP&0xFF;
	if(BATT_SYS_ERROR_NUM_BBox_To_TCP != 0 && BATT_SYS_ERROR_CODE_ARRAY_BBox_To_TCP != NULL)
	{
		memcpy((SendBuffer 	+ sizeof(BattDynamicMsgToTcpType)
						+ sizeof(BattDynamicMsgType1)
						+ (2 + BMS_CellTotal*2)
						+ (1 + BATT_CHRG_TEMP_NUM)
						+ (1 + BATT_CONN_TEMP_NUM)
						+ (2 + BMS_TempTotal)
						+ (1 + OTHER_TEMP_NUM)
						+ 1),BATT_SYS_ERROR_CODE_ARRAY_BBox_To_TCP, BATT_SYS_ERROR_NUM_BBox_To_TCP);
		vPortFree((BATT_SYS_ERROR_CODE_ARRAY_BBox_To_TCP));
	}


	*(SendBuffer+ (*SendLen - 1)) = bcc_chk(SendBuffer, (*SendLen - 1));
	*PtrSendAddr = (uint32)SendBuffer;
}


static void tcpTruckVehiMsg(uint32* PtrSendAddr,uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	TruckVehiMsgToTcpType truckVehiMsgToTcpMsg = {0x00};
//	TruckVehiMsgType1 truckVehiMsgType1  = {0x00};
	uint16 DataLen = 0;
	DataLen =	sizeof(TruckVehiMsgType1);
//				+ (1 + BATT_CONN_TEMP_NUM)
//				+ (1 + BATT_BSC_LOCK_NUM)
//				+ 1
//				+ 2;

	*SendLen = sizeof(TruckVehiMsgToTcpType);// + DataLen + 1; //(+1 means crc)
	SendBuffer = malloc(*SendLen);


	truckVehiMsgToTcpMsg.startSymbol[0] = TCP_START_SYM1;
	truckVehiMsgToTcpMsg.startSymbol[1] = TCP_START_SYM2;
	truckVehiMsgToTcpMsg.cmdSymbol = TCP_CMD_SYM;
	truckVehiMsgToTcpMsg.ansSymbol = TCP_ANS_SYM;
	memcpy(truckVehiMsgToTcpMsg.SN, TcpbattSN, BATT_SN_LEN);
	truckVehiMsgToTcpMsg.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	truckVehiMsgToTcpMsg.dataLength[0] = (DataLen >> 8) & 0xFF;
	truckVehiMsgToTcpMsg.dataLength[1] = DataLen & 0xFF;

//	memcpy((SendBuffer + 0),&truckVehiMsgToTcpMsg,sizeof(TruckVehiMsgToTcpType));  //without crc

	truckVehiMsgToTcpMsg.truckVehiInfo.sendTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	truckVehiMsgToTcpMsg.truckVehiInfo.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	// month
	truckVehiMsgToTcpMsg.truckVehiInfo.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	// day
	truckVehiMsgToTcpMsg.truckVehiInfo.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	// hour
	truckVehiMsgToTcpMsg.truckVehiInfo.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	truckVehiMsgToTcpMsg.truckVehiInfo.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	truckVehiMsgToTcpMsg.truckVehiInfo.msgMark = TruckVehiMsg;
	truckVehiMsgToTcpMsg.truckVehiInfo.msgCollectionTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	truckVehiMsgToTcpMsg.truckVehiInfo.msgCollectionTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	 // month
	truckVehiMsgToTcpMsg.truckVehiInfo.msgCollectionTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	 // day
	truckVehiMsgToTcpMsg.truckVehiInfo.msgCollectionTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	 // hour
	truckVehiMsgToTcpMsg.truckVehiInfo.msgCollectionTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	truckVehiMsgToTcpMsg.truckVehiInfo.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	memcpy(truckVehiMsgToTcpMsg.truckVehiInfo.VIN,VIN,17);
	truckVehiMsgToTcpMsg.truckVehiInfo.vehiSpeed[0] = 0x12;
	truckVehiMsgToTcpMsg.truckVehiInfo.vehiSpeed[1] = 0x34;
	truckVehiMsgToTcpMsg.truckVehiInfo.vehiErrCode[0] = 0x56;
	truckVehiMsgToTcpMsg.truckVehiInfo.vehiErrCode[1] = 0x78;
	truckVehiMsgToTcpMsg.truckVehiInfo.bscSystemErrCode = 0x9a;
	truckVehiMsgToTcpMsg.truckVehiInfo.vehiSt = 0x01;
	truckVehiMsgToTcpMsg.truckVehiInfo.bmsHvReq = 0x02;
	truckVehiMsgToTcpMsg.truckVehiInfo.vehiCurrGearSt = 0x03;
	truckVehiMsgToTcpMsg.truckVehiInfo.vehiBreakSt = 0x04;
	memset(truckVehiMsgToTcpMsg.truckVehiInfo.vehilRelaySt,0x23,10);	//tset data
	truckVehiMsgToTcpMsg.truckVehiInfo.bscSt = 0x05;

	truckVehiMsgToTcpMsg.truckVehiInfo.battBSCConTempNum = BATT_CONN_TEMP_NUM;
	memset(truckVehiMsgToTcpMsg.truckVehiInfo.battBSCConTemp,0x22,BATT_CONN_TEMP_NUM);
	truckVehiMsgToTcpMsg.truckVehiInfo.battBSCLockNum = BATT_BSC_LOCK_NUM;
	memset(truckVehiMsgToTcpMsg.truckVehiInfo.battBSCLockSt,0x32,BATT_BSC_LOCK_NUM);

	truckVehiMsgToTcpMsg.truckVehiInfo.bscConnType = 0x05;

	truckVehiMsgToTcpMsg.truckVehiInfo.bscConnSt = 0x06;
	truckVehiMsgToTcpMsg.truckVehiInfo.bscChangeCount[0] = 0x07;
	truckVehiMsgToTcpMsg.truckVehiInfo.bscChangeCount[1] = 0x08;

	truckVehiMsgToTcpMsg.CRC = bcc_chk((uint8*)(&truckVehiMsgToTcpMsg), (*SendLen - 1));
	memcpy(SendBuffer,(uint8*)(&truckVehiMsgToTcpMsg),(*SendLen));
	*PtrSendAddr = (uint32)SendBuffer;
}


static void tcpEngyStoreSysMsg(uint32* PtrSendAddr,uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	EngyStoreSysMsgToTcpType engyStoreSysMsgToTcpMsg = {0x00};
	uint16 DataLen = 0;
	*SendLen = sizeof(EngyStoreSysMsgToTcpType); //(+1 means crc)
	SendBuffer = malloc(*SendLen);

	DataLen =  sizeof(EngyStoreSysMsgType);
	engyStoreSysMsgToTcpMsg.startSymbol[0] = TCP_START_SYM1;
	engyStoreSysMsgToTcpMsg.startSymbol[1] = TCP_START_SYM2;
	engyStoreSysMsgToTcpMsg.cmdSymbol = TCP_CMD_SYM;
	engyStoreSysMsgToTcpMsg.ansSymbol = TCP_ANS_SYM;
	memcpy(engyStoreSysMsgToTcpMsg.SN, TcpbattSN, BATT_SN_LEN);
	engyStoreSysMsgToTcpMsg.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	engyStoreSysMsgToTcpMsg.dataLength[0] = (DataLen >> 8) & 0xFF;
	engyStoreSysMsgToTcpMsg.dataLength[1] = DataLen & 0xFF;

	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.sendTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	// month
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	// day
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	// hour
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.msgMark = EngyStoreSysMsg;
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.msgCollectionTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.msgCollectionTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	 // month
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.msgCollectionTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	 // day
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.msgCollectionTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	 // hour
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.msgCollectionTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.inverterSt 			= 0x02;
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.battRelaySt 			= 0x04;
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.battTMSFanSt 		= 0x05;
	engyStoreSysMsgToTcpMsg.energyStoreSysInfo.battTMSHeaterRelaySt = 0x06;
	engyStoreSysMsgToTcpMsg.CRC = bcc_chk((uint8*)(&engyStoreSysMsgToTcpMsg), (*SendLen - 1));
	memcpy(SendBuffer,(uint8*)(&engyStoreSysMsgToTcpMsg),(*SendLen));
	*PtrSendAddr = (uint32)SendBuffer;
}

static void tcpBattAccInfoMsg(uint32* PtrSendAddr,uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	AccInfoToTcpType accInfoToTcpType = {0x00};
	uint16 DataLen = 0;
	*SendLen = sizeof(AccInfoToTcpType); //(+1 means crc)
	SendBuffer = malloc(*SendLen);

	DataLen =  sizeof(AccInfoType);
	accInfoToTcpType.startSymbol[0] = TCP_START_SYM1;
	accInfoToTcpType.startSymbol[1] = TCP_START_SYM2;
	accInfoToTcpType.cmdSymbol = TCP_CMD_SYM;
	accInfoToTcpType.ansSymbol = TCP_ANS_SYM;
	memcpy(accInfoToTcpType.SN, TcpbattSN, BATT_SN_LEN);
	accInfoToTcpType.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	accInfoToTcpType.dataLength[0] = (DataLen >> 8) & 0xFF;
	accInfoToTcpType.dataLength[1] = DataLen & 0xFF;

	accInfoToTcpType.AccInfo.sendTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	accInfoToTcpType.AccInfo.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	// month
	accInfoToTcpType.AccInfo.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	// day
	accInfoToTcpType.AccInfo.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	// hour
	accInfoToTcpType.AccInfo.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	accInfoToTcpType.AccInfo.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	accInfoToTcpType.AccInfo.msgMark = BattAccuMsg;
	accInfoToTcpType.AccInfo.msgCollectionTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	accInfoToTcpType.AccInfo.msgCollectionTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	 // month
	accInfoToTcpType.AccInfo.msgCollectionTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	 // day
	accInfoToTcpType.AccInfo.msgCollectionTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	 // hour
	accInfoToTcpType.AccInfo.msgCollectionTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	accInfoToTcpType.AccInfo.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	accInfoToTcpType.AccInfo.accOnlineDays[0] 			= 0x00;
	accInfoToTcpType.AccInfo.accOnlineDays[1] 			= 0x00;
	accInfoToTcpType.AccInfo.vehiODO[0] 			= 0x27;
	accInfoToTcpType.AccInfo.vehiODO[1] 			= 0x10;
	accInfoToTcpType.AccInfo.vehiODO[2] 			= 0x28;
	accInfoToTcpType.AccInfo.vehiODO[3] 			= 0x11;
	accInfoToTcpType.AccInfo.accBattCycTimes[0] 		= 0x12;
	accInfoToTcpType.AccInfo.accBattCycTimes[1] 		= 0x34;
	accInfoToTcpType.AccInfo.accOverChrgTimes[0] 		= 0x45;
	accInfoToTcpType.AccInfo.accOverChrgTimes[1] 		= 0x56;
	accInfoToTcpType.AccInfo.accOverDischrgTimes[0] 		= 0x13;
	accInfoToTcpType.AccInfo.accOverDischrgTimes[1] 		= 0x35;
	accInfoToTcpType.AccInfo.accChrgTimes[0] 		= 0x01;
	accInfoToTcpType.AccInfo.accChrgTimes[1] 		= 0x02;
	accInfoToTcpType.AccInfo.accDischrgTimes[0] 		= 0x33;
	accInfoToTcpType.AccInfo.accDischrgTimes[1] 		= 0x44;
	accInfoToTcpType.AccInfo.bmsTotalChrgCapy[0] 		= 0x55;
	accInfoToTcpType.AccInfo.bmsTotalChrgCapy[1] 		= 0x66;
	accInfoToTcpType.AccInfo.bmsTotalChrgCapy[2] 		= 0x77;
	accInfoToTcpType.AccInfo.bmsTotalChrgCapy[3] 		= 0x88;
	accInfoToTcpType.AccInfo.bmsTotalChrgEngy[0] 		= 0x99;
	accInfoToTcpType.AccInfo.bmsTotalChrgEngy[1] 		= 0xaa;
	accInfoToTcpType.AccInfo.bmsTotalChrgEngy[2] 		= 0xbb;
	accInfoToTcpType.AccInfo.bmsTotalChrgEngy[3] 		= 0xcc;
	accInfoToTcpType.AccInfo.bmsTotalDischrgCapy[0] 		= 0xdd;
	accInfoToTcpType.AccInfo.bmsTotalDischrgCapy[1] 		= 0xee;
	accInfoToTcpType.AccInfo.bmsTotalDischrgCapy[2] 		= 0xff;
	accInfoToTcpType.AccInfo.bmsTotalDischrgCapy[3] 		= 0x01;
	accInfoToTcpType.AccInfo.bmsTotalDischrgEngy[0] 		= 0x02;
	accInfoToTcpType.AccInfo.bmsTotalDischrgEngy[1] 		= 0x03;
	accInfoToTcpType.AccInfo.bmsTotalDischrgEngy[2] 		= 0x04;
	accInfoToTcpType.AccInfo.bmsTotalDischrgEngy[3] 		= 0x05;
	accInfoToTcpType.AccInfo.bmsTotalStaCharCapy[0] 		= 0x01;
	accInfoToTcpType.AccInfo.bmsTotalStaCharCapy[1] 		= 0x03;
	accInfoToTcpType.AccInfo.bmsTotalStaCharCapy[2] 		= 0x04;
	accInfoToTcpType.AccInfo.bmsTotalStaCharCapy[3] 		= 0x06;
	accInfoToTcpType.AccInfo.bmsTotalStaCharEngy[0] 		= 0x02;
	accInfoToTcpType.AccInfo.bmsTotalStaCharEngy[1] 		= 0x04;
	accInfoToTcpType.AccInfo.bmsTotalStaCharEngy[2] 		= 0x06;
	accInfoToTcpType.AccInfo.bmsTotalStaCharEngy[3] 		= 0x08;
	accInfoToTcpType.AccInfo.bmsTotalBackCharCapy[0] 		= 0x09;
	accInfoToTcpType.AccInfo.bmsTotalBackCharCapy[1] 		= 0x0a;
	accInfoToTcpType.AccInfo.bmsTotalBackCharCapy[2] 		= 0x0b;
	accInfoToTcpType.AccInfo.bmsTotalBackCharCapy[3] 		= 0x0c;
	accInfoToTcpType.AccInfo.bmsTotalBackCharEngy[0] 		= 0x0d;
	accInfoToTcpType.AccInfo.bmsTotalBackCharEngy[1] 		= 0x0e;
	accInfoToTcpType.AccInfo.bmsTotalBackCharEngy[2] 		= 0x0f;
	accInfoToTcpType.AccInfo.bmsTotalBackCharEngy[3] 		= 0x11;
	accInfoToTcpType.AccInfo.bmsTotalGunCharCapy[0] 		= 0x12;
	accInfoToTcpType.AccInfo.bmsTotalGunCharCapy[1] 		= 0x13;
	accInfoToTcpType.AccInfo.bmsTotalGunCharCapy[2] 		= 0x14;
	accInfoToTcpType.AccInfo.bmsTotalGunCharCapy[3] 		= 0x15;
	accInfoToTcpType.AccInfo.bmsTotalGunCharEngy[0] 		= 0x16;
	accInfoToTcpType.AccInfo.bmsTotalGunCharEngy[1] 		= 0x17;
	accInfoToTcpType.AccInfo.bmsTotalGunCharEngy[2] 		= 0x18;
	accInfoToTcpType.AccInfo.bmsTotalGunCharEngy[3] 		= 0x19;
	accInfoToTcpType.CRC = bcc_chk((uint8*)(&accInfoToTcpType), (*SendLen - 1));
	memcpy(SendBuffer,(uint8*)(&accInfoToTcpType),sizeof(AccInfoToTcpType));
	*PtrSendAddr = (uint32)SendBuffer;
}

static void tcpBattSceneInfoMsg(uint32* PtrSendAddr,uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	BattSceneMsgtoTcpType battSceneMsgtoTcpMsg = {0x00};
	uint16 DataLen = 0;
	*SendLen = sizeof(BattSceneMsgtoTcpType);
	SendBuffer = malloc(*SendLen);

	DataLen =  sizeof(BattSceneInfoType);
	battSceneMsgtoTcpMsg.startSymbol[0] = TCP_START_SYM1;
	battSceneMsgtoTcpMsg.startSymbol[1] = TCP_START_SYM2;
	battSceneMsgtoTcpMsg.cmdSymbol = TCP_CMD_SYM;
	battSceneMsgtoTcpMsg.ansSymbol = TCP_ANS_SYM;
	memcpy(battSceneMsgtoTcpMsg.SN, TcpbattSN, BATT_SN_LEN);
	battSceneMsgtoTcpMsg.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	battSceneMsgtoTcpMsg.dataLength[0] = (DataLen >> 8) & 0xFF;
	battSceneMsgtoTcpMsg.dataLength[1] = DataLen & 0xFF;

	battSceneMsgtoTcpMsg.battSceneInfo.sendTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	battSceneMsgtoTcpMsg.battSceneInfo.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	// month
	battSceneMsgtoTcpMsg.battSceneInfo.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	// day
	battSceneMsgtoTcpMsg.battSceneInfo.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	// hour
	battSceneMsgtoTcpMsg.battSceneInfo.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	battSceneMsgtoTcpMsg.battSceneInfo.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	battSceneMsgtoTcpMsg.battSceneInfo.msgMark = BattSceneMsg;
	battSceneMsgtoTcpMsg.battSceneInfo.msgCollectionTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	battSceneMsgtoTcpMsg.battSceneInfo.msgCollectionTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	 // month
	battSceneMsgtoTcpMsg.battSceneInfo.msgCollectionTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	 // day
	battSceneMsgtoTcpMsg.battSceneInfo.msgCollectionTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	 // hour
	battSceneMsgtoTcpMsg.battSceneInfo.msgCollectionTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	battSceneMsgtoTcpMsg.battSceneInfo.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	battSceneMsgtoTcpMsg.battSceneInfo.sceneType 			= 0x01;
	battSceneMsgtoTcpMsg.battSceneInfo.sceneSt 				= 0x02;
	memset(battSceneMsgtoTcpMsg.battSceneInfo.sceneStartDate,0x12,6);		//tset data
	memset(battSceneMsgtoTcpMsg.battSceneInfo.sceneAvalibleTime,0x13,2);	//tset data
	memset(battSceneMsgtoTcpMsg.battSceneInfo.sceneDeadTime,0x14,2);		//tset data
	battSceneMsgtoTcpMsg.CRC = bcc_chk((uint8*)(&battSceneMsgtoTcpMsg), (*SendLen - 1));
	memcpy(SendBuffer,(uint8*)(&battSceneMsgtoTcpMsg),sizeof(BattSceneMsgtoTcpType));
	*PtrSendAddr = (uint32)SendBuffer;
}


static void tcpBattHighFeqInfoMsg(uint32* PtrSendAddr,uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	BattHighFeqMsgtoTcpType battHighFeqMsgtoTcpMsg = {0x00};
	uint16 DataLen = 0;
	*SendLen = sizeof(BattHighFeqMsgtoTcpType);
	SendBuffer = malloc(*SendLen);

	DataLen =  sizeof(BattHighFeqInfoType);
	battHighFeqMsgtoTcpMsg.startSymbol[0] = TCP_START_SYM1;
	battHighFeqMsgtoTcpMsg.startSymbol[1] = TCP_START_SYM2;
	battHighFeqMsgtoTcpMsg.cmdSymbol = TCP_CMD_SYM;
	battHighFeqMsgtoTcpMsg.ansSymbol = TCP_ANS_SYM;
	memcpy(battHighFeqMsgtoTcpMsg.SN, TcpbattSN, BATT_SN_LEN);
	battHighFeqMsgtoTcpMsg.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	battHighFeqMsgtoTcpMsg.dataLength[0] = (DataLen >> 8) & 0xFF;
	battHighFeqMsgtoTcpMsg.dataLength[1] = DataLen & 0xFF;

	battHighFeqMsgtoTcpMsg.battHighFeqInfo.sendTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	// month
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	// day
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	// hour
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.msgMark = BattHighFeqMsg;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.msgCollectionTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.msgCollectionTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	 // month
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.msgCollectionTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	 // day
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.msgCollectionTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	 // hour
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.msgCollectionTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battPackVolt[0] 			= 0x01;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battPackVolt[1] 			= 0x02;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battPackCurr[0] 			= 0x27;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battPackCurr[1] 			= 0x10;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battMaxCellVolt[0] 		= 0x03;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battMaxCellVolt[1] 		= 0x04;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battMinCellVolt[0] 		= 0x05;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battMinCellVolt[1] 		= 0x06;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battMaxCellTemp[0] 		= 0x07;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battMaxCellTemp[1] 		= 0x08;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battMinCellTemp[0] 		= 0x09;
	battHighFeqMsgtoTcpMsg.battHighFeqInfo.battMinCellTemp[1] 		= 0x09;
	battHighFeqMsgtoTcpMsg.CRC = bcc_chk((uint8*)(&battHighFeqMsgtoTcpMsg), (*SendLen - 1));
	memcpy(SendBuffer,(uint8*)(&battHighFeqMsgtoTcpMsg),sizeof(BattHighFeqMsgtoTcpType));
	*PtrSendAddr = (uint32)SendBuffer;
}

static void tcpBattAlgthInfoMsg(uint32* PtrSendAddr,uint16* SendLen)
{
	uint8 *SendBuffer = NULL;
	BattAlgthMsgtoTcpType battAlgthMsgtoTcpMsg = {0x00};
	uint16 DataLen = 0;
	*SendLen = sizeof(BattAlgthMsgtoTcpType);
	SendBuffer = malloc(*SendLen);

	DataLen =  sizeof(BattAlgthInfoType);
	battAlgthMsgtoTcpMsg.startSymbol[0] = TCP_START_SYM1;
	battAlgthMsgtoTcpMsg.startSymbol[1] = TCP_START_SYM2;
	battAlgthMsgtoTcpMsg.cmdSymbol = TCP_CMD_SYM;
	battAlgthMsgtoTcpMsg.ansSymbol = TCP_ANS_SYM;
	memcpy(battAlgthMsgtoTcpMsg.SN, TcpbattSN, BATT_SN_LEN);
	battAlgthMsgtoTcpMsg.encryptMethod = TCP_ENCPT_DISABLE; // not encrypt
	battAlgthMsgtoTcpMsg.dataLength[0] = (DataLen >> 8) & 0xFF;
	battAlgthMsgtoTcpMsg.dataLength[1] = DataLen & 0xFF;

	battAlgthMsgtoTcpMsg.battAlgthInfo.sendTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	battAlgthMsgtoTcpMsg.battAlgthInfo.sendTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	// month
	battAlgthMsgtoTcpMsg.battAlgthInfo.sendTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	// day
	battAlgthMsgtoTcpMsg.battAlgthInfo.sendTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	// hour
	battAlgthMsgtoTcpMsg.battAlgthInfo.sendTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	battAlgthMsgtoTcpMsg.battAlgthInfo.sendTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	battAlgthMsgtoTcpMsg.battAlgthInfo.msgMark = BattAlgthMsg;
	battAlgthMsgtoTcpMsg.battAlgthInfo.msgCollectionTimeUTC[0] = (UTC8TimeTcp.year) & 0xFF; // year
	battAlgthMsgtoTcpMsg.battAlgthInfo.msgCollectionTimeUTC[1] = UTC8TimeTcp.month & 0xFF;	 // month
	battAlgthMsgtoTcpMsg.battAlgthInfo.msgCollectionTimeUTC[2] = UTC8TimeTcp.day & 0xFF;	 // day
	battAlgthMsgtoTcpMsg.battAlgthInfo.msgCollectionTimeUTC[3] = UTC8TimeTcp.hour & 0xFF;	 // hour
	battAlgthMsgtoTcpMsg.battAlgthInfo.msgCollectionTimeUTC[4] = UTC8TimeTcp.minute & 0xFF; // mins
	battAlgthMsgtoTcpMsg.battAlgthInfo.msgCollectionTimeUTC[5] = UTC8TimeTcp.second & 0xFF; // sec
	battAlgthMsgtoTcpMsg.battAlgthInfo.bmsPackSOC 			= 0x10;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bmsPackSOH 			= 0x20;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalSOC 			= 0x27;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalSOH 			= 0x10;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalDischrgCapy[0] 		= 0x30;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalDischrgCapy[1] 		= 0x40;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalDischrgCapy[2] 		= 0x50;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalDischrgCapy[3] 		= 0x60;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalBackchrgCapy[0] 		= 0x70;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalBackchrgCapy[1] 		= 0x80;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalBackchrgCapy[2] 		= 0x90;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalBackchrgCapy[3] 		= 0xa0;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalChrgCapy[0] 		= 0x0b;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalChrgCapy[1] 		= 0x0c;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalChrgCapy[2] 		= 0x0d;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalChrgCapy[3] 		= 0x0e;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalDischrgEngy[0] 		= 0x01;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalDischrgEngy[1] 		= 0x02;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalDischrgEngy[2] 		= 0x03;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalDischrgEngy[3] 		= 0x04;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalBackchrgEngy[0] 		= 0x05;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalBackchrgEngy[1] 		= 0x06;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalBackchrgEngy[2] 		= 0x07;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalBackchrgEngy[3] 		= 0x08;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalChrgEngy[0] 		= 0x09;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalChrgEngy[1] 		= 0x0a;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalChrgEngy[2] 		= 0x0b;
	battAlgthMsgtoTcpMsg.battAlgthInfo.bboxCalTotalChrgEngy[3] 		= 0x0c;
	battAlgthMsgtoTcpMsg.battAlgthInfo.BBox_Dq_Dv_MAX[0] 		= 0x11;
	battAlgthMsgtoTcpMsg.battAlgthInfo.BBox_Dq_Dv_MAX[1] 		= 0x22;
	battAlgthMsgtoTcpMsg.battAlgthInfo.BBox_Dq_Dv_MAX[2] 		= 0x33;
	battAlgthMsgtoTcpMsg.battAlgthInfo.BBox_Dq_Dv_MAX[3] 		= 0x44;
	battAlgthMsgtoTcpMsg.battAlgthInfo.BBox_Dq_Dv_MIN[0] 		= 0x55;
	battAlgthMsgtoTcpMsg.battAlgthInfo.BBox_Dq_Dv_MIN[1] 		= 0x66;
	battAlgthMsgtoTcpMsg.battAlgthInfo.BBox_Dq_Dv_MIN[2] 		= 0x77;
	battAlgthMsgtoTcpMsg.battAlgthInfo.BBox_Dq_Dv_MIN[3] 		= 0x88;
	battAlgthMsgtoTcpMsg.CRC = bcc_chk((uint8*)(&battAlgthMsgtoTcpMsg), (*SendLen - 1));
	memcpy(SendBuffer,(uint8*)(&battAlgthMsgtoTcpMsg),sizeof(BattAlgthMsgtoTcpType));
	*PtrSendAddr = (uint32)SendBuffer;
}
static void tcpUdsCmdNegAnsMsg(uint32* PtrSendAddr,uint16* SendLen)
{

}
static void tcpUdsCmdPosAnsMsg(uint32* PtrSendAddr,uint16* SendLen)
{

}

#endif