dtu/Core/Src/tt808.c

#include "tt808.h"
#include "usart.h"
#include "key.h"
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include "rtc.h"
#include "database.h"
//*整型
int rlt;
uint16_t uploadtime=0;	//上传时间
uint16_t hccd = 0;//ascii个数(*2)
uint8_t header[12];		//处理头部
uint8_t index_2c = 0;
uint8_t MIPurc[100];	//接收平台数据
uint8_t MIPurc1[100];	//接收平台数据
uint8_t MIPurcXXTCSJ[100];//平台下行透传数据
uint8_t speedBegin=0;
uint8_t speedEnd=0;
uint8_t speed[10];		//处理头部
uint8_t DTUurc[100];	//接收平台数据
uint8_t DTUurc1[15];	//接收平台数据


int pushpullcount = 0;
double dSpeed=0;
double dlatitude=0;
double dlongitude=0;
char cSpeed[10];
char clatitude[15];
char clongitude[15];
char csatellitesNum[5];
char MGNSSLOC[100];	//接收定位数据
char CSQ[12];	//接收定位数据

char MGNSSLOC_time[6];	//接收定位数据
uint32_t Stamp =0;
uint8_t GNSSdata[40]={0};
//*结构体
TT808 tt808;
extern TipsFlag tipsflag;	
extern Menu_table menu;	
extern bool refresh;
extern LockInfo lockinfo;
//*布尔
bool authFlag = false;
bool GnssFlag = false;
bool Offline = false;
bool Retrans = false;
bool Online = false;
bool reIME = false;
/**
				时间     纬度(北纬)   经度(东经)  水平精度因子  海拔高度    定位类型(1无,2 2d,3 3d) 运动角度    水平运动速度(KM/h)    水平运动速度(Knots)	日月年	卫星数量	差分定位标识(1单点,2差分)
eg.+MGNSSLOC: 015032.301,3014.8605N,12001.9250E,1.8,			17.6,		3,                      0.00,		3.6,			      1.9,					080424,	12,			1	 
*/

void reconn(void)
{
	char TCPconnvalue[120];
	TcpConn(TCPconnvalue, 1, JLPTIP, JLPTPORT,0);		//cid=1		tcpConnmode=0 普通模式
	if(sendCmd_4G(TCPconnvalue, "+MIPOPEN: 1,0", 1, 1))	//TCP连接 0普通模式  2缓存模式  1透传模式
	{
		printf("重连成功\r\n");
	}
}
uint8_t Messagetemp_length=0;
uint8_t MessageHandleData[100];	//放入封装后数据
uint8_t tcppacket[100]; //消息数据
void MessageHandle(uint16_t MessageID)
{

	Flash_ReadBytes((uint16_t*)&(tt808.LSH),tt808serialNum,1);//读取loc头部是否发生写入
	if(tt808.LSH==0xFFFF)
	{
		tt808.LSH=0;//初始未写入
	}
	uint16_t MessageAttributeData = Messagetemp_length;

	MessageAttributeData |= ( Messagetemp_length | (TCPJMFSNULL<<10)); // 将长度左移3位后和加密方式进行按位或操作(001 RSA ,000 无加密)
	
	header[0] 	= ((MessageID>>8)&0xff);
	header[1] 	= (MessageID&0xff);				//消息ID
	header[2] 	= ((MessageAttributeData>>8)&0xff);
	header[3] 	= (MessageAttributeData&0xff);			//消息属性
	//*test	phoneNumxy
	//*work	phoneNum
	if(phonenull)
	{
		header[4] 	= 0x00;
		header[5] 	= 0x00;
		header[6] 	= 0x16;
		header[7] 	= 0x00;
		header[8] 	= 0x00;
		header[9] 	= 0x08;						//“手机号”
	}
	else
	{
		header[4] 	= (phonenum[0]>>8)&0xff;
		header[5] 	= (phonenum[0])&0xff;
		header[6] 	= (phonenum[1]>>8)&0xff;
		header[7] 	= (phonenum[1])&0xff;
		header[8] 	= (phonenum[2]>>8)&0xff;
		header[9] 	= (phonenum[2])&0xff;					//“手机号”
	}

	header[10] 	=  ((tt808.LSH>>8)&0xff);
	header[11] 	=  (tt808.LSH&0xff);
	
	int index = 0;
	tcppacket[index++] = TT808FLAG;  // Set the headflag 0x7E
		
	for (int i = 0; i < 12; i++) {
		tcppacket[index++] = header[i];
	}
	// Copy message body to packet
	for (size_t i = 0; i < Messagetemp_length; i++) {
		tcppacket[index++] = MessageHandleData[i];
	}
	tcppacket[index++] = xorBytes(&tcppacket[1],12+Messagetemp_length);;  // Set the checksum
	tcppacket[index++] = TT808FLAG;      // Set the flag at the end
	
	for (int i = 0; i < index; i++) {
		printf("%02X ", tcppacket[i]);  // 以十六进制格式打印每个元素
	}
	printf("\r\n");
	
	
//#if open4G ==1
	char TCPvalue[120];
	char *ptr = TCPvalue;
	ptr += sprintf(ptr, "AT+MIPSEND=1,%d,\"",index);
	for (int i = 0; i < index; i++) {
		ptr += sprintf(ptr, "%02X", tcppacket[i]);
	}
	sprintf(ptr, "\"\r\n");//TCPvalue
	if(sendCmd_4G(TCPvalue, "+MIPSEND:", 1, 1))//发送
	{
		printf("#等待回应\r\n");
	}
//#endif
	
	
	tt808.LSH+=1;//需做写入处理
	Flash_WriteBytes((uint16_t*)&(tt808.LSH),tt808serialNum,1);
}
uint16_t swapBytes16(uint16_t value) {
    return (value >> 8) | (value << 8);
}
uint32_t swapBytes32(uint32_t value) {
    return ((value & 0xFF) << 24) | ((value & 0xFF00) << 8) |
           ((value >> 8) & 0xFF00) | ((value >> 24) & 0xFF);
}
/**
  * @breaf 消息体封装
  * Message[] 消息数据;	length 消息数据长度;	outMessage[] 封装后消息数据; MessageID 消息ID
  */
uint8_t Message_bodydata(uint8_t *Message, uint8_t length, uint8_t outMessage[],uint16_t MessageID)
{
	int index = 0;
	uint8_t temp_length = 0;//加首尾 25/23/crc
	
	if(MessageID==MessageID_authentication  || MessageID==MessageID_heartbeat)//不加头尾（鉴权、心跳）
	{
		temp_length = length;//不加首尾
		uint8_t temp_Message[temp_length];
		
		for (int i = 0; i < length; i++) {
			temp_Message[index++] = Message[i];  // 将消息头拷贝到报文中
		}
		
		temp_length = index;
		
		for(int i =0;i<temp_length;i++)
		{
			outMessage[i]=temp_Message[i];
		}
	}
	else if(MessageID==MessageID_location)//终端地址0200  补传0704
	{
		
		temp_length = length;//不加首尾
		//状态标志/纬度/经度/速度

		uint8_t temp_Message[temp_length];
		for (int i = 0; i < length; i++) {
			temp_Message[index++] = Message[i];  // 将消息头拷贝到报文中
		}
		
		
		for(int i =0;i<temp_length;i++)
		{
			outMessage[i]=temp_Message[i];
		}
	}
	else if(MessageID==MessageID_Retrans)// 补传0704+5
	{
		temp_length = length;//不加首尾
		uint8_t temp_Message[temp_length];
		
		temp_Message[index++] = 0x00;
		temp_Message[index++] = 0x01;
		temp_Message[index++] = 0x00;
		temp_Message[index++] = 0x00;
		temp_Message[index++] = 0x22;
		
		
		for (int i = 0; i < length; i++) {
			temp_Message[index++] = Message[i];  // 将消息头拷贝到报文中
		}
		
		
		for(int i =0;i<temp_length;i++)
		{
			outMessage[i]=temp_Message[i];
		}
	}
	else//加首尾
	{
		temp_length = length+3;//加首尾 25/23/crc
		uint8_t temp_Message[temp_length];
		
		temp_Message[index++]=temp_length;
		temp_Message[index++]=0x2A;
		for (int i = 0; i < length; i++) {
			temp_Message[index++] = Message[i];  // 将消息头拷贝到报文中
		}
		temp_Message[index++]=0x23;
		temp_Message[index++]=xorBytes(&temp_Message[1],temp_length-1);
		temp_length = index;
		
		for(int i =0;i<temp_length;i++)
		{
			outMessage[i]=temp_Message[i];
		}
	}
	return  temp_length;
}

/*需要传入消息体长度sizeof(Message)/sizeof(Message[0]);*/
void tt808FsFunc(uint8_t* Message, uint8_t length, uint16_t MessageID)
{
	HAL_Delay(200);
	Messagetemp_length = Message_bodydata(Message, length, MessageHandleData, MessageID);
	MessageHandle(MessageID);
	
}


void printBytes(uint8_t *data, size_t length) {
    for (size_t i = 0; i < length; i++) {
        printf("%02x ", data[i]);
    }
    printf("\n");
}
// 函数用于提取第7到第8个逗号之间的字符串
void extractString(char* receiveStr, char* result, uint8_t start, uint16_t end)
{
  int comma_count = 0;
  int start_index = -1;
  int end_index = -1;
  int length = strlen(receiveStr);
  // 遍历字符串，统计逗号数量和记录起始和结束索引
  for (int i = 0; i < length; i++)
  {
    if (receiveStr[i] == ',')
    {
      comma_count++;
      if (comma_count == start)
      {
        start_index = i + 1; // 第start个逗号之后的字符
      }
      else if (comma_count == end)
      {
		if(start==1 && end==2)//*纬度去尾符号 
		{
			end_index = i-1; // 第end个逗号之前的字符
		}
		else if(start==2 && end==3)//*经度去尾符号 
		{
			end_index = i-1; // 第end个逗号之前的字符
		}
		else
		{
			end_index = i; // 第end个逗号之前的字符
		}
        
        break;
      }
    }
  }
  
  // 提取字符串并存储在result数组中
  if (start_index != -1 && end_index != -1 && start_index < end_index)
  {
    strncpy(result, receiveStr + start_index, end_index - start_index);
    result[end_index - start_index] = '\0'; // 添加字符串结束符
  }
}

void extractStringPoint(char* receiveStr, char* result, uint8_t start, uint16_t end)
{
  int comma_count = 0;
  int start_index = -1;
  int end_index = -1;
  int length = strlen(receiveStr);
  // 遍历字符串，统计逗号数量和记录起始和结束索引
	
  for (int i = 0; i < length; i++)
  {
	  if(start==0 && end==1)// = -> .
	  {
		start_index = start; // 第start个逗号之后的字符

		if (receiveStr[i] == '.')
		{
			comma_count++;	
		}
		else if (comma_count == end)
		{
			end_index = i-1; // 第end个逗号之前的字符
			break;
		}
	  }
	  else if(start==3 && end==4)
	  {
		  if (receiveStr[i] == '.')
		  {
			  comma_count++;
			  if (comma_count == start)
			  {
				  start_index = i + 1; // 第start个逗号之后的字符
			  }
		  }
		  else if(receiveStr[i] == ':')
		  {
			  end_index = i;
		  }
	  }
	  else if(start==4 && end==5)
	  {
		  if (receiveStr[i] == ':')
		  {
			comma_count=4;
			if (comma_count == start)
			{
				start_index = i+1; // 第start个逗号之后的字符
			}
			end_index = start_index+4;
			break;
		}
	  }
	  
	  else
	  {
			if (receiveStr[i] == '.')
			{
			  comma_count++;
			  if (comma_count == start)
			  {
				start_index = i + 1; // 第start个逗号之后的字符
			  }
			  else if (comma_count == end)
			  {
				end_index = i; // 第end个逗号之前的字符
				break;
			  }
			}  
	  }
  }

  
  // 提取字符串并存储在result数组中
  if (start_index != -1 && end_index != -1 && start_index < end_index)
  {
    strncpy(result, receiveStr + start_index, end_index - start_index);
    result[end_index - start_index] = '\0'; // 添加字符串结束符
  }
}



double convertToDouble(char* str) {
	if(str == csatellitesNum)
	{
	  uint8_t result;
	  sscanf(str, "%hhu", &result);
	  return result;
	}
	else
	{
	  double result;
	  sscanf(str, "%lf", &result);
	  return result;
	}
}

char hex2asc(const char *hex)
{
	char asc = 0;
	char a = (hex[0]>='A' && hex[0]<='F')?(hex[0]^32):hex[0];
	char b = (hex[1]>='A' && hex[1]<='F')?(hex[1]^32):hex[1];
	if ((a>='0' && a<='9' || a>='a' && a<='f') && (b>='0' && b<='9' || b>='a' && b<='f')){
		asc = ((('a'<=a && a<='f')?(a-'a')+10:a-'0')<<4)|(('a'<=b && b<='f')?(b-'a')+10:b-'0');
	}
	return asc;
}
uint8_t testHex2Asc(const char *hex) {
    char asc = hex2asc(hex);
    printf("Hex: %s\tASC: %d\n", hex, asc);
	return asc;
}

char *bin2hex(char *hex, const unsigned char *bin, int size)
{
	size_t i;
	for(i=0; i<size; i++)
	{
		sprintf(hex+i*2, "%02x", bin[i]);
	}
	hex[i+i] = 0;
	return hex;
}

int hex2bin(unsigned char *bin, const char *hex)
{
	const char *h = hex;
	unsigned char *b = bin;
	int rlt = 0;
	while(*h){
		*b++ = hex2asc(h);
		h = h + 2;
		rlt++;
	}
	return rlt;//长度
}

// 将单个十六进制数转换为 BCD 码
uint8_t hexToBcd(uint8_t hex) {
    return ((hex / 10) << 4) | (hex % 10);
}
// 将整数数组中的所有十六进制数转换为 BCD 码
void hexArrayToBcd(uint8_t* array, size_t length, uint8_t* out) {//时间用
	array[3]+=8;
    for (size_t i = 0; i < length; i++) {
        out[i] = hexToBcd(array[i]);
    }
}
void hexToBcd_arr(uint8_t* array, size_t length, uint8_t* out) {//通用

    for (size_t i = 0; i < length; i++) {
        out[i] = hexToBcd(array[i]);
    }
}
char input_strings[20]={0};
char reIp0[10];
char reIp1[10];
char reIp2[10];
char reIp3[10];
char reIpP[10];
Ipaddr ipaddr;
MacSet macset;
MacSet *macsetptr = &macset;
char Newip[30];
extern bool wdiFlag;

//*485测试命令
void Test485Re(void)
{
	//*test485 模拟
	 if(strncmp((char*)U1_485recvBuff, "+MIPURC: \"disconn\",1,1",  strlen("+MIPURC: \"disconn\",1,1"))==0)//"disconn" 平台断连
	 {
		 Offline=true;
		 uploaweork=false;
		 printf("@U1与平台断开连接\r\n");
		 memset(U1_485recvBuff,0,BUFFER_SIZE);
	 }	
	 else if(strncmp((char*)U1_485recvBuff, "+MIPOPEN: 1,0",  strlen("+MIPOPEN: 1,0"))==0)//连接平台
	 {
		 Offline=false;
		 Online = true;
		 uploaweork=true;
		 printf("@U1设备已上线!!\r\n");
		 refresh=true;
		 memset(U1_485recvBuff,0,BUFFER_SIZE);
	 }	

	 else if(strncmp((char*)&U1_485recvBuff, "DTU+FLASH=deleteloc",  strlen("DTU+FLASH=deleteloc"))==0)//连接平台
	 {
			dblocptr->headinfo.loc_pushIndex=0;
			dblocptr->headinfo.loc_pullIndex=0;
			Flash_WriteBytes((uint16_t*)&(dblocptr->headinfo),LocDbHeadStart,4);//更新刻度
			memset(U1_485recvBuff,0,BUFFER_SIZE);
			printf("更新刻度成功\r\n");
	 }	
	 else if(strncmp((char*)U1_485recvBuff, "DTU+JT808_IMEI=",  strlen("DTU+JT808_IMEI="))==0)//修改IME号
	 {
		memcpy(DTUurc1,U1_485recvBuff+15,12);
		
		const char *hex = (const char *)DTUurc1;  // 将 uint8_t * 转换为 const char *
		int size = strlen(hex) / 2;  // 计算二进制数据的长度
		unsigned char *bin = (unsigned char *)malloc(size);  // 分配足够的内存用于存储二进制数据
		rlt = hex2bin(bin, hex);  // 调用hex2bin函数进行转换
		memcpy(DTUurc, bin, rlt);  // 将 bin 中的 rlt 个字节复制到 MIPurc1 中						接收到的数据放入MIPurc1中
		free(bin);  // 释放内存  
		 
		//memset(DTUurc1,0,100);
		memset(U1_485recvBuff,0,BUFFER_SIZE);
		reIME = true;
		HAL_Delay(500);
	 }
	 else if(strncmp((char*)U1_485recvBuff, "DTU+JT808_SERVER=",  strlen("DTU+JT808_SERVER="))==0)
	 {
		memcpy(input_strings,U1_485recvBuff+17,20);

		extractStringPoint(input_strings,reIp0,0,1);
		extractStringPoint(input_strings,reIp1,1,2);
		extractStringPoint(input_strings,reIp2,2,3);
		extractStringPoint(input_strings,reIp3,3,4);
		extractStringPoint(input_strings,reIpP,4,5);

		ipaddr.IP0 = atoi(reIp0);
		ipaddr.IP1 = atoi(reIp1);
		ipaddr.IP2 = atoi(reIp2);
		ipaddr.IP3 = atoi(reIp3);
		ipaddr.IPp = atoi(reIpP);
		//printf("%d.%d.%d.%d:%d",ipaddr.IP0,ipaddr.IP1,ipaddr.IP2,ipaddr.IP3,ipaddr.IPp);
		HAL_StatusTypeDef writeSta = Flash_WriteBytes((uint16_t*)&(ipaddr.IP0),ReIPAddr,5);
		 if(writeSta == HAL_OK)
		 {
			char *ptr = Newip;
			ptr += sprintf(ptr, "%d.", ipaddr.IP0);
			ptr += sprintf(ptr, "%d.", ipaddr.IP1);
			ptr += sprintf(ptr, "%d.", ipaddr.IP2);
			ptr += sprintf(ptr, "%d", ipaddr.IP3);
			printf("更换IP成功\r\n");
		 }
		//ptr += sprintf(ptr, ":%d", ipaddr.IPp);
		//printf("%s\r\n",Newip);
		memset(U1_485recvBuff,0,BUFFER_SIZE);
		HAL_Delay(500);
		printf("即将重启\r\n");
		wdiFlag = true;
	 }
	 else if(strncmp((char*)U1_485recvBuff, "DTU+VER=?",  strlen("DTU+VER=?"))==0)
	 {
		printf("%s\r\n",version);
		memset(U1_485recvBuff,0,BUFFER_SIZE);
	 }


	 REPdaMode();//PDA 485 MQTT
}
				
void AtPRocess(char *value, char *conn,char *connected,char *disconn) {
    sprintf(conn, "AT+CONN=%s\r\n", value);
    sprintf(connected, "+CONNECTED:0,%s", value);
    sprintf(disconn, "+DISCONN:0,%s", value);
	
	printf("%s\r\n",conn);
	printf("%s\r\n",connected);
	printf("%s\r\n",disconn);
}

void REPdaMode(void)
{
	//*PDA需求	485写入MAC号
	 if(strncmp((char*)U1_485recvBuff, "DTU+ADDMAC",  strlen("DTU+ADDMAC"))==0)
	 {
		memcpy(macset.MACtemp,U1_485recvBuff+11,12);
		const char *hex = (const char *)macset.MACtemp;  // 将 uint8_t * 转换为 const char *
		int size = strlen(hex) / 2;  // 计算二进制数据的长度
		unsigned char *bin = (unsigned char *)malloc(size);  // 分配足够的内存用于存储二进制数据
		rlt = hex2bin(bin, hex);  // 调用hex2bin函数进行转换
		memcpy(macset.mactemp, bin, rlt);  // 将 bin 中的 rlt 个字节复制到 MIPurc1 中						接收到的数据放入MIPurc1中
		free(bin);  // 释放内存  
		 
		macset.mac[0] = macset.mactemp[0]<<8|macset.mactemp[1];
		macset.mac[1] = macset.mactemp[2]<<8|macset.mactemp[3];
		macset.mac[2] = macset.mactemp[4]<<8|macset.mactemp[5];
		HAL_StatusTypeDef WriteSta;
		 
		WriteSta= Flash_WriteBytes(macsetptr->mac,MacDbBodyAddr + (macset.macCount*6),3);
		macset.macCount += 1;
		if(WriteSta == HAL_OK)
		{
			printf("更新MAC存储完成\r\n");
		}
		WriteSta = Flash_WriteBytes(&macsetptr->macCount,MacDbHeadAddr,1);
		if(WriteSta == HAL_OK)
		{
			printf("更新存储刻度完成\r\n");
		}	
		memset(U1_485recvBuff,0,BUFFER_SIZE);
	 }
}
void ReBTcall(void)
{
	 if(strncmp((char*)autoRe, "+CONNECTED:0,",  strlen("+CONNECTED:0,"))==0)
	 {
		 TIPS_MACRO(ConnOK);//连接成功
		 printf("设备已连接\r\n");
		 memset(autoRe,0,BUFFER_SIZE);
	 }

}
//*工作命令
void ReMIPURC(void)//DTU
{
//*设备上线，发送成功
	 if(strncmp((char*)U4_4GrecvBuff, "+MIPOPEN: 1,0",  strlen("+MIPOPEN: 1,0"))==0)//连接平台
	 {

		 memset(U4_4GrecvBuff,0,BUFFER_SIZE);
	 }	 
///*定位信息（MGNSS）
	 else if(strncmp((char*)U4_4GrecvBuff, "+MGNSSURC: \"state\",1",  strlen("+MGNSSURC: \"state\",1"))==0)
	 {
		 printf("@MGNSS设置成功\r\n");
		
		 memset(U4_4GrecvBuff,0,strlen("+MGNSSURC: \"state\",1"));
	 }
	 else if(strncmp((char*)U4_4GrecvBuff, "+MGNSSURC: \"state\",0",  strlen("+MGNSSURC: \"state\",0"))==0)//断开平台
	 {
		 printf("@主动取消GNSS\r\n");
		 memset(U4_4GrecvBuff,0,strlen("+MGNSSURC: \"state\",0"));
	 }	 

///*定位信息（基站）
	 else if(((strncmp((char*)U4_4GrecvBuff, "+MGNSSLOC", strlen("+MGNSSLOC"))==0) || (strncmp((char*)U4_4GrecvBuff, "OK", strlen("OK"))==0)) && MgnssFlag)	//监测平台回复+MGNSSLOC OK4f4b
	 {

		memcpy(MGNSSLOC,&U4_4GrecvBuff[11],75);
		GnssFlag=true;
		memset(U4_4GrecvBuff,0,BUFFER_SIZE);
	 }
///*掉线
#if open4G ==1
	 else if(strncmp((char*)U4_4GrecvBuff, "+MIPURC: \"disconn\",1,1",  strlen("+MIPURC: \"disconn\",1,1"))==0)//"disconn" 平台断连
	 {
		 Offline=true;
		 printf("@未发送成功,平台断开连接\r\n");
		 memset(U4_4GrecvBuff,0,BUFFER_SIZE);
		 uploaweork = false;
		 reconn();//重连
	 }
	 else if((strncmp((char*)U4_4GrecvBuff, "+CPIN: SIM REMOVED", strlen("+CPIN: SIM REMOVED"))==0) || (strncmp((char*)U4_4GrecvBuff, "+CME ERROR: 10", strlen("+CME ERROR: 10"))==0) )//无SIM
	 {
		//TODO
		printf("@SIM卡缺失\r\n");
		Offline=true;
		signal = false;
		menu.current = 0xBB;
		tipsflag = NoSIM;
		refresh=true;
		memset(U4_4GrecvBuff,0,BUFFER_SIZE);
		uploaweork = false;
		reconn();//重连
	 }
	 
	 else if((strncmp((char*)U4_4GrecvBuff, "+MIPCALL: 1,0", strlen("+MIPCALL: 1,0"))==0))//意外断开平台连接！！！！//TCP未知错误
	 {
		//TODO
		Offline=true;
		signal = false;
		printf("@与平台断开连接\r\n");
		memset(U4_4GrecvBuff,0,BUFFER_SIZE);
		uploaweork = false;
		reconn();//重连
		 
	 }
	 else if( (strncmp((char*)U4_4GrecvBuff, "+CME ERROR: 550", strlen("+CME ERROR: 550"))==0))
	 {
		Offline=true;
		signal = false;
		printf("@未发送成功->TCP/IP未知错误\r\n");
		memset(U4_4GrecvBuff,0,BUFFER_SIZE);
		uploaweork = false;
		reconn();//重连
		 
	 }
	 else if((strncmp((char*)U4_4GrecvBuff, "+MIPOPEN: 1,571", strlen("+MIPOPEN: 1,571"))==0))//PDP激活失败
	 {
		//TODO
		Offline=true;
		printf("@未发送成功，PDP激活失败\r\n");
		memset(U4_4GrecvBuff,0,BUFFER_SIZE);
		uploaweork = false;
		reconn();//重连
	 }
#endif
	 else if(U4_4GrecvBuff[1]== 0x43 && U4_4GrecvBuff[2]== 0x53 && U4_4GrecvBuff[3]== 0x51)//CSQ 信号
	 {
		memcpy(CSQ,U4_4GrecvBuff,U4_4GrecvLength);
		dblocptr->location.CSQ = (uint8_t)(CSQ[6]&0xf*10)+(CSQ[7]&0xf);
		memset(CSQ,0,12);
		memset(U4_4GrecvBuff,0,BUFFER_SIZE);
	 }
	 else if(strncmp((char*)U4_4GrecvBuff, "+MIPURC", strlen("+MIPURC"))==0)	//监测平台回复+MIPURC: 
	 { 
		uint8_t high_byte = (U4_4GrecvBuff[18]&0x0f) *10; 
		uint8_t low_byte = U4_4GrecvBuff[19]&0x0f; 
		hccd = high_byte + low_byte;
		memcpy(MIPurc1,&U4_4GrecvBuff[21],hccd*2);
		const char *hex = (const char *)MIPurc1;  // 将 uint8_t * 转换为 const char *
		int size = strlen(hex) / 2;  // 计算二进制数据的长度
		unsigned char *bin = (unsigned char *)malloc(size);  // 分配足够的内存用于存储二进制数据
		rlt = hex2bin(bin, hex);  // 调用hex2bin函数进行转换
		memcpy(MIPurc, bin, rlt);  // 将 bin 中的 rlt 个字节复制到 MIPurc1 中						接收到的数据放入MIPurc1中
		free(bin);  // 释放内存  
		 
		memset(U4_4GrecvBuff,0,BUFFER_SIZE);
		memset(MIPurc1,0,100);
		 
	 }
 }

void MIPURCHandle(void)
{
#if open4G == 1
	 if(MIPurc[0]==0x7E)
	 {
		 uint16_t PTXXID = MIPurc[1]<<8 | MIPurc[2];		//消息ID
		 uint16_t xxtcLen = MIPurc[3]<<8 | MIPurc[4];		//数据长度
		 uint16_t xxRE = MIPurc[15]<<8 | MIPurc[16];		//回复ID
		 uint8_t YESorNO = MIPurc[17];						//00 success ; 01 fail
		 
		 if(PTXXID==XXID_pttyyd)			//收到平台通用应答0x8001
		 { 
			if(xxRE == MessageID_authentication)//回复鉴权ID
			{
				if(YESorNO==YES)
				{
					printf("@鉴权应答yes\r\n");
					authFlag = true;
					
					Offline=false;	//待判定假消息
					Online = true;	//待判定假消息
					uploaweork=true;
				}
				else if(YESorNO==NO)
				{
					printf("@鉴权应答no\r\n");
				}
				memset(MIPurc,0,rlt);//rlt下发长度 
			}
			else if(xxRE == MessageID_heartbeat)//回复鉴权ID
			{
				if(YESorNO==YES)
				{
					printf("@心跳应答yes\r\n");
					printf("@TCP连接成功!!\r\n");
				}
				else if(YESorNO==NO)
				{
					printf("@心跳应答no\r\n");
				}
				memset(MIPurc,0,rlt);//rlt下发长度 
				
			}
			else if(xxRE == MessageID_location)//回复鉴权ID
			{
				if(YESorNO==YES)
				{
					printf("@地址应答yes\r\n");
				}
				else if(YESorNO==NO)
				{
					printf("@地址应答no\r\n");
				}
				memset(MIPurc,0,rlt);//rlt下发长度 
			}
		 }
		 else if(PTXXID == XXID_ptxxtc)	//收到平台消息透传 8900
		 {
			authFlag = true;
			Offline=false;	//待判定假消息
			Online = true;	//待判定假消息
			uploaweork=true;
			 
			 uint8_t tcsjLen = MIPurc[13];
			 memcpy(MIPurcXXTCSJ,&MIPurc[13],xxtcLen);
			 printf("@得到透传数据,%d\r\n",tcsjLen);
			 memset(MIPurc,0,rlt);//rlt下发长度 
		 }
	 }
	 else if(authFlag)
	 {
		 authFlag = false;
		 HAL_Delay(500);
	 	 uint8_t test[] = {0x05};			//test心跳
		 tt808FsFunc(test,1,MessageID_heartbeat);		//test心跳
	 }
#endif
	 else if(reIME)
	 {
		reIME=false;		 
		phonenum[0] = DTUurc[0]<<8|DTUurc[1];
		phonenum[1] = DTUurc[2]<<8|DTUurc[3];
		phonenum[2] = DTUurc[4]<<8|DTUurc[5];
		phonenull =false;
		Flash_WriteBytes(phonenum,phoneNumADDR,3);//更新ime
		//memset(DTUurc,0,100);
		printf("IMEI设置完成\r\n");
		printf("即将重启\r\n");
		wdiFlag = true;
	 }
}


time_t timestamp ;
void time_bj(void) 
{
	struct tm timeinfo;
	timeinfo.tm_year = tt808.Rtime[0]+2000-1900;
	timeinfo.tm_mon = tt808.Rtime[1]-1;
	timeinfo.tm_mday = tt808.Rtime[2];
	timeinfo.tm_hour = tt808.Rtime[3]-8;
	timeinfo.tm_min = tt808.Rtime[4];
	timeinfo.tm_sec = tt808.Rtime[5];
	timestamp = mktime(&timeinfo);
		
	dblocptr->location.timeStamp = timestamp;
}



void ReU4Proces(void)
{
	if(GnssFlag)
	{
		GnssFlag=false;
		RTCtime();//同步时间

		// 调用函数提取字符串
		extractString(MGNSSLOC, cSpeed,7 ,8);//采集
		dSpeed = convertToDouble(cSpeed);	//转换浮点数
		dSpeed*=10;


		// 调用函数提取字符串
		extractString(MGNSSLOC, clatitude,1 ,2);//采集
		dlatitude = convertToDouble(clatitude);	//转换浮点数
		uint32_t latitudetemp=convertGPS(dlatitude);
		dblocptr->location.latitudeH = (latitudetemp>>16)&0xFFFF;
		dblocptr->location.latitudeH = swapBytes16(dblocptr->location.latitudeH);//转换H字节
		dblocptr->location.latitudeL = (latitudetemp)&0xFFFF;
		dblocptr->location.latitudeL = swapBytes16(dblocptr->location.latitudeL);//转换L字节
		
		extractString(MGNSSLOC, clongitude,2 ,3);//采集
		dlongitude = convertToDouble(clongitude);	//转换浮点数
		uint32_t longitudetemp=convertGPS(dlongitude);
		dblocptr->location.longitudeH = (longitudetemp>>16)&0xFFFF;
		dblocptr->location.longitudeH = swapBytes16(dblocptr->location.longitudeH);//转换H字节
		dblocptr->location.longitudeL = (longitudetemp)&0xFFFF;
		dblocptr->location.longitudeL = swapBytes16(dblocptr->location.longitudeL);//转换L字节
		
//		printf("%d\r\n",dblocptr->location.latitude);
//		printf("%d\r\n",dblocptr->location.longitude);
//		printf("%08X\r\n",dblocptr->location.latitude);
//		printf("%08X\r\n",dblocptr->location.longitude);
		
		extractString(MGNSSLOC, csatellitesNum,10 ,11);//采集卫星个数
		dblocptr->location.satellitesNum = convertToDouble(csatellitesNum);	//转换浮点数
		//printf("%d",tt808.satellitesNum);
		
		
		dblocptr->location.speed  = (uint16_t)dSpeed;

		memset(MGNSSLOC,0,100);

	}
}


//*离线蓝牙锁