M21/user/MainTask.c

/********************************************************************************
 * File Name: 	MainTask.c
 * Function Describe:The main task for the system
 * Relate Module:
 * Explain:	Hardware version is HS121
 * Writer:  ShiLiangWen
 * Date:	2015.7.8
 *******************************************************************************/
#define THIS_FILE_ID 8
//---------------------------------------------------------------------------------
#include "includes.h"
#include "stm32f10x_it.h"
//OS ID

OS_TID idMainTask=0;
U64 stkMainTask[MAIN_TASK_STK_SIZE];
unsigned char modemInitReady=0;//0模块没开始初始化 1模块初始化成功 2 POC已运行
unsigned char modemPwrOffNow=0;


unsigned char g_ucBackLightCnt;
int g_iVbat=0;

unsigned int g_LCDTemp = 0;
unsigned char g_ucGtMode=0;
unsigned char g_usSOSCnt;
unsigned char g_usLightCnt;
unsigned char g_usVoiceCnt;
unsigned char g_usFastInterfaceCnt;
unsigned char g_usGtcnt;
unsigned char g_uslockCnt;
unsigned char g_uslockflag;
unsigned char Ui_LockFlag; //用于 被锁界面可操作PTT
unsigned char g_usFactory;
unsigned char g_uckeybeep;  //按键滴音
unsigned char g_ucPoweroffcnt;
unsigned char g_cMenuBack;

unsigned char Pttfreeflag;
unsigned char Ui_VolLvFlag;
unsigned char Ui_VolLvCnt;

unsigned char ReCharge=0;

char sysStartTTS[START_TTS_LENGTH];
//SUT_MSG_QUEUE ModemMsgQueue;
//char ModemMsgBuffer[512];
void FingerDaemonfinger(void);

unsigned char g_ucEnterGroupFlag=0;
unsigned char pocTimeOutTime=30;//默认30分钟

unsigned int Vbat;


 //======================================
void ReportVbatCsqGps(void);
void EncodeKeyProcess(void);
void iap_jump_app_s(void);
int GetCheckCodeByPsnMEID(char *pCheckCode,unsigned long PSN,char *pMEID);
void ReportCheckCode(void); 

//-----
#ifdef USE_RUNNING_MAKE
	void RunningMake(unsigned short FileID,unsigned long line)
	{
		g_usFileID=FileID;
		g_ulFileLine=line;
	}
#endif
	unsigned short g_usFileID=0;
	unsigned long g_ulFileLine=0;
	
//  unsigned char m_GroupSelect=0;//用于使用左边上下键去选择群组时使用 wjl
	unsigned char m_GroupSwitch=0;//表示是否曾经按过左边上下群组切换按键
	unsigned char m_GroupSwitchCnt=0;//按过的话，5秒内没按OK键则退出切换
	
/***********************************************
强制复位
************************************************/
void SystemReset(void)
{
	//IWDG_Configuration();
	while(1);
}


void PowerCtrlInit(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC, ENABLE);
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Pin = PWR_EN_PIN;
	GPIO_Init(PWR_EN_PORT, &GPIO_InitStructure);
	PWR_EN_LOW; 
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Pin = CHARGE_IC_PIN;
	GPIO_Init(CHARGE_IC_PORT, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Pin = CHARGE_STATUE_PIN;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	CHARGE_IC_LOW;
}
/*************************************************************************
拷贝数据，并判断与原数据是否相同
相同返回0
不同返回1
**************************************************************************/
unsigned char CopyData(unsigned char *pDst,unsigned char *pSrc,unsigned char len)
{
	unsigned char i;
	unsigned char flag=0;
	for(i=0;i<len;i++){
		if(*pDst!=*pSrc){
			flag=1;
			*pDst=*pSrc;
		}
		pDst++;
		pSrc++;
	}
	return flag;
}

/********************************************************************
*开关机键检测
*********************************************************************/
int OnOffCheck(void)
{
	static unsigned char sucCt=0;
	unsigned long k;
	k=ONOFF_CK_PORT->IDR;	
	if((k&ONOFF_CK_PIN)==ONOFF_CK_PIN){
		if(sucCt<5)sucCt++;
		else return 1;
	}else{
		sucCt=0;
	}
	return 0;
}
void GPIO_Config_ALL_AIN(void);


/**********************************************************************
*系统关机
***********************************************************************/
void SysShutDown(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	unsigned long k;	
	int len;
	GPS_PWREN_LOW;
	MODEM_LED1_HIGH;
	MODEM_LED2_HIGH;
	ModemSendAT("AT+ZPWROFF\r\n");
	SlwTrace(INF,"Set modem OnOff down!",1);
	ModemSendAT("AT+ZPWROFF\r\n");
	//os_dly_wait(50);
	SlwTrace(INF,"Set system power off!",1);
	//SlwTraceWaitCompleted();
	MODEM_LED1_LOW;
	MODEM_LED2_LOW;
	//-------
	k=ONOFF_CK_PORT->IDR;	
	if((k&ONOFF_CK_PIN)==0){
		SlwTrace(INF,"Reset system!",1);
		//SlwTraceWaitCompleted();
		SystemReset();
	}else{
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_InitStructure.GPIO_Pin = PWR_EN_PIN;
		GPIO_Init(PWR_EN_PORT, &GPIO_InitStructure);
		while(1);	
	}
}

//从source查找长度为targetLen目标的target，找到后返回目标段后一字节的索引，没找到返回-1，source结束为sourceEndIndicator
//witchOne: 找第几个目标
short FindTargetIndex(char *source, char sourceEndIndicator, char *target, unsigned char targetLen,unsigned char witchOne)
{
	unsigned short targetIndex;
	unsigned char targetNum;
	targetIndex=0;
	targetNum=0;
	while(*source != sourceEndIndicator)
	{
		if(0==memcmp(source, target, targetLen))
		{//找到了
			targetNum++;
			if(targetNum == witchOne)
			  return (targetIndex+targetLen);
		}
		source++;
		targetIndex++;
	}
	return -1;
}
unsigned char AscToHex(unsigned char aHex)
{    
	if((aHex>=0)&&(aHex<=9))        
	aHex += 0x30;    
	else if((aHex>=10)&&(aHex<=15))//A-F        
	//aHex += 0x37;    
	aHex += 0x57;  
	else aHex = 0xff;    
	return aHex;
}
void AscStrToHexStr(char *AscStr, char *HexStr)
{
	char *pAscStr=AscStr;
	unsigned char d,h,l;
	while(0!=(d=(unsigned char)*pAscStr++)){
		l=d&0x0f;
		h=d>>4;
		*HexStr++=AscToHex(h);
		*HexStr++=AscToHex(l);
	}
	*HexStr=0;
}
unsigned char apnUpdateFlag=0;
void PcMsgHandle(char *msg)
{
	
	const char *CmdList[]={
		"TM",	//Trace Modem
		"TG",   //Trace GPS
		"DM",	//Download Modem
		"FOTA",	//Fota Modem
		"STP",  //Set Test Parameter
		"SMP",	//Set Modem Parameter
		"SGP",	//Set GPS Parameter
		"RMP",  //Read Modem Parameter
		"PST",  //PST Mode for modem
		"VER",	//Read Version
		"BAT",  //Battery voltage
		"APN",	//SET APN
		"RAPN", //Read APN
		"BEEP", //Beep test
		"RGP",
		""	//必须以空字串为结束
	};
	int h,m,s;
	unsigned short Port;
	unsigned short Select;
	unsigned long PSN;
	char buf[150];
	char buf1[300];
  	char strIP[40];
	char strAccount[20+20];
	char strPassword[20+20];
	
	unsigned short PID;//省域ID 16byte
	unsigned short CID; //市域ID16byte
	char Mfactur[10]; //制造商
	char TMod[42];    //终端型号 不足补0x00
	char TID[28];			//终端ID 不足补0x00  本来7个字节 为了跟星安一致 取4个字节8
	unsigned char PColor; //车牌颜色 未上牌取值为0
	char Plate[16];					// 车牌8
	char SIM[12];
	
	int i,j,len;
	char flag;
	const char *pCmd;
	char *pMsg;
	int CmdListNum=0;
	RunMake(THIS_FILE_ID);
	while(*CmdList[CmdListNum++]);//计算命令列表个数
	CmdListNum--;
	RunMake(THIS_FILE_ID);
	//查找与命令列表相同的命令位置
	for(i=0;i<CmdListNum;i++){
		pCmd=CmdList[i];
		pMsg=&msg[3];
		flag=0;
		j=0;
		while(*pCmd){
			if(*pCmd!=*pMsg){
				flag=1;
				break;
			}
			pCmd++;
		    pMsg++;
			j++;
		}
		if(!flag){
			break;	
		}	
	}
	RunMake(THIS_FILE_ID);
    if(i==CmdListNum)return;
	//处理命令
	switch(i)
	{
		case 0://"TM"
			//idNetTask

			SetLedStatus(RedBlueSlowFlash);
		//	g_ucNetTaskDisable=0xff;
			SlwTrace(INF,"GT+TM:OK",1);
			//SlwTraceWaitCompleted();
			ComSelect(COM_SEL_MODEM);
			g_ucGtMode=1;

			break;
		case 1://"TG"
			SetLedStatus(RedBlueSlowFlash);
			SlwTrace(INF,"GT+TG:OK",1);
			//SlwTraceWaitCompleted();
			GPSInit();
			sutGpsInfo.Updata=1;
			g_uiGpsStat=1;
			GpsTaskTick(0);
			ComSelect(COM_SEL_GPS);
			break;
		case 2://"DM"
			SetLedStatus(RedBlueSlowFlash);
		
			break;
		case 3://"FOTA" 
			SetLedStatus(RedBlueSlowFlash);
			if(msg[8]=='M' && msg[9]=='C' && msg[10]=='U' ){//GT+FOTA=MCU
				//g_ucNetTaskDisable=0xff;
				SlwTrace(INF,"GT+FOTA:MCU",1);
				//SlwTraceWaitCompleted();
				sutProductPara.IapFlag=0x55;
				SaveProductParaToFlash("COM-FOTA");
				while(1);
			}else if(msg[8]=='M' && msg[9]=='O' && msg[10]=='D' && msg[11]=='E' && msg[12]=='M' ){//GT+FOTA=MODEM 对讲版本
				//g_ucNetTaskDisable=0xff;
				SlwTrace(INF,"GT+FOTA:MODEM",1);
				//SlwTraceWaitCompleted();
				//OSTimeDlyHMSM(0, 0, 0, 100);
				ModemSendAT("at+poc=10000018\r\n");
				while(1){
					IWDG_ReloadCounter();//喂狗
					if(OnOffCheck()){
						PWR_EN_LOW;
					}	
				}
			}
			break;
		case 4://"STP"	GT+STP=IP=地址或域名;Port=端口号; Account=账号;Password=密码;
			//g_ucNetTaskDisable=0xff;
			//OSTimeDlyHMSM(0, 0, 0, 100);
			len=GetParaFromStr(msg,"IP",buf);
			if(len<1 || len>=40){
				SlwTrace(INF,"GT+STP:FAIL[IP Invalid]",1);
				break;	
			}else strcpy(strIP,buf);
			
			len=GetParaFromStr(msg,"Port",buf);
			if(len==0)Port=0;
			else if(len>5){
				SlwTrace(INF,"GT+STP:FAIL[Port Invalid]",1);
				break;	
			}else{
				Port=atoi(buf);
			}

			len=GetParaFromStr(msg,"Account",buf);
			if(len<1 || len>=20){  
				SlwTrace(INF,"GT+STP:FAIL[Account Invalid]",1);
				break;	
			}else strcpy(strAccount,buf);

			len=GetParaFromStr(msg,"Password",buf);
			if(len<1 || len>=20){
				SlwTrace(INF,"GT+STP:FAIL[Password Invalid]",1);
				break;	
			}else strcpy(strPassword,buf);
			//send to modem
			snprintf(buf, sizeof(buf),"id=%s;ip=%s;pwd=%s;",strAccount,strIP,strPassword);
			AscStrToHexStr(buf,buf1);
			ModemSendAT("AT+POC=120000");
			ModemSendAT(buf1);
			ModemSendAT("\r\n");
			//send to pc
			snprintf(buf, sizeof(buf),"GT+STP:IP=%s;Port=%u;Account=%s;Password=%s",strIP,Port,strAccount,strPassword);
			SlwTrace(INF,buf,1);
			break;
			
		case 5://"SMP"	GT+SMP=IP=地址或域名;Port=端口号;PSN=终端序列号
			len=GetParaFromStr(msg,"IP",buf);
			if(len<1 || len>=40){
				SlwTrace(INF,"GT+SMP:FAIL[IP Invalid]",1);
				break;	
			}
			strcpy(strIP,buf);
			
			len=GetParaFromStr(msg,"Port",buf);
			if(len==0)Port=0;
			else if(len>5){
				SlwTrace(INF,"GT+SMP:FAIL[Port Invalid]",1);
				break;	
			}else{
				Port=atoi(buf);
			}

			len=GetParaFromStr(msg,"PSN",buf);
			if(len<1 || len>10){  
				SlwTrace(INF,"GT+SMP:FAIL[PSN Invalid]",1);
				break;	
			}else{
				PSN=atol(buf);
			}
			//PSN 
			sutProductPara.PSN=PSN;
			strcpy(sutProductPara.PIP,strIP);
			sutProductPara.PocPort=Port;
			//send to modem
			if(strlen(sutProductPara.HARDID)<14){
				SlwTrace(INF,"GT+SMP:FAIL[MEID Invalid]",1);
				break;	
			}
			snprintf(buf, sizeof(buf),"id=%lu;ip=%s;pwd=%s;",sutProductPara.PSN,strIP,sutProductPara.HARDID);
			AscStrToHexStr(buf,buf1);
			ModemSendAT("AT+POC=010000");
			ModemSendAT(buf1);
			ModemSendAT("\r\n");
			//save para
			SaveProductParaToFlash("COM-SMP");
			snprintf(buf, sizeof(buf),"GT+SMP:IP=%s;Port=%u;PSN=%lu",sutProductPara.PIP,sutProductPara.PocPort,sutProductPara.PSN);
			SlwTrace(INF,buf,1);
			break;
		case 6://"SGP"	GT+SGP=IP=地址或域名;Port=端口号; 
			len=GetParaFromStr(msg,"IP",buf);
			if(len<1 || len>=40){
				SlwTrace(INF,"GT+SGP:FAIL[IP Invalid]",1);
				break;	
			}else strcpy(strIP,buf);
			
			len=GetParaFromStr(msg,"Port",buf);
			if(len==0)Port=0;
			else if(len>5){
				SlwTrace(INF,"GT+SGP:FAIL[Port Invalid]",1);
				break;	
			}else{
				Port=atoi(buf);
			}
			strcpy(sutProductPara.GIP,strIP);
			sutProductPara.GpsPort=Port;
			//Save para to flash
			SaveProductParaToFlash("COM-SGP");
			//echo
			snprintf(buf, sizeof(buf),"GT+SGP:IP=%s;Port=%u;",sutProductPara.GIP,sutProductPara.GpsPort);
			SlwTrace(INF,buf,1);
			break;
		case 7://"RMP"	GT+RMP<CR><LF> PSN=终端序列号;MEID=模块MEID号;CNUM=电信号;UIMID=电信UIMID;
			snprintf(buf, sizeof(buf),"GT+RMP:PSN=%lu;MEID=%s;CNUM=0000000000;UIMID=0000000000;IP=%s;",sutProductPara.PSN,sutProductPara.HARDID,sutProductPara.PIP);
			SlwTrace(INF,buf,1);
			break;
		case 8://"PST"
			SetLedStatus(RedBlueSlowFlash);
			//g_ucNetTaskDisable=0xff;
			SlwTrace(INF,"GT+PST:OK",1);
			//SlwTraceWaitCompleted();
			os_dly_wait(1);
			ComSelect(COM_SEL_MODEM);
			MODEM_PWRKEY_LOW;
			MODEM_RESET_HIGH;
			os_dly_wait(5);
			MODEM_RESET_LOW;
			while(1){
				IWDG_ReloadCounter();//喂狗
				if(OnOffCheck()){
    				PWR_EN_LOW;
				}	
			}
			break;
		case 9://"VER"
			snprintf(buf, sizeof(buf),"GT+VER:%s_V%d",sutProductPara.ProductName,sutProductPara.ProductVersion);
			SlwTrace(INF,buf,1);
			break;
		case 10://BAT
			snprintf(buf, sizeof(buf),"GT+BAT: %d V",g_iVbat);   
			SlwTrace(INF,buf,1);
//		  SlwTrace(INF, msg,1);
//		  cntMeiTiao=atoi(&msg[7]);
//		SpeakerEnable();
//		  //SetBeepByNoOS(878, 100);
//      SetBeep(878, 3000);
			break;
		case 11://APN
			/*
		设置格式：GT+APN=Account=用户名;Password=密码;<CR><LF>
		成功返回：GT+APN:Account=用户名;Password=密码;<CR><LF>
		失败返回：GT+APN:FAIL[失败原因]<CR><LF>
			*/
			len=GetParaFromStr(msg,"Account",buf);
			if(len<1 || len > 30){
				SlwTrace(INF,"GT+APN:FAIL[Account Invalid]",1);
				return;
			}
			strcpy(strAccount,buf);
			
			len=GetParaFromStr(msg,"Password",buf);
			if(len<1 || len > 30){
				SlwTrace(INF,"GT+APN:FAIL[Password Invalid]",1);
				return;
			}
			if(sutProductPara.APNIndex==3 && validApnNum != 1)
			{
				strcpy(sutProductPara.APNName,strAccount);
				strcpy(sutProductPara.APNPass,buf);
				SaveProductParaToFlash("COM-APN");
			}
			snprintf(buf1, sizeof(buf1),"GT+APN:Account=%s;Password=%s;",strAccount,buf);
			SlwTrace(INF,buf1,1);
			
			if(ApnFileIndex==-1 || HgsApnLen==0) break;
			if(0==strcmp(strAccount, showApnTable[6]) &&
				 0==strcmp(buf, showApnTable[7]))
			break;
			strcpy(showApnTable[6],strAccount);
			strcpy(showApnTable[7],buf);
      apnUpdateFlag=1;
			break;
		case 12://RAPN
			if(validApnNum==1){
				i=0;j=1;
			}
			else{//有多个时，只能读取可配置的那个
				i=6;j=7;
			}
			sprintf(buf1,"GT+RAPN:Account=%s;Password=%s;",showApnTable[i],showApnTable[j]);
			SlwTrace(INF,buf1,1);
			break;
		case 13://BEEP
			len=GetParaFromStr(msg,"F",buf);
			if(len)i=atoi(buf);
			else i=878;
			len=GetParaFromStr(msg,"T",buf);
			if(len)Port=atoi(buf);
			else Port=8;//80
			SpeakerEnable(); 
			SetBeep(i,Port);
			snprintf(buf, sizeof(buf),"BEEP=%dHz,%dms",i,Port*10);   
			SlwTrace(INF,buf,1);
			break;
	  case 14://RGP
			snprintf(buf, sizeof(buf),"GT+RGP:IP=%s;PORT=%d;",sutProductPara.GIP,sutProductPara.GpsPort);
			SlwTrace(INF,buf,1);
			break;
		
	}
	RunMake(THIS_FILE_ID);
}



void SwitchGroupPre(void)
{
	//让菜单变成:确定
	ShowButton(1,107,"确定");
	m_GroupSwitch=1;
	m_GroupSwitchCnt=0;
}
//volatile 
unsigned int pttPressFreeCt;
/***********************************************************************
*按键按下事件
************************************************************************/

void KeyPress(void)
{
	
	char i=0;
	char buf[30];
	static unsigned char sucReportFlag=0;
	
//	if(g_ucGtMode==0){//在GT模式下不能与串口同时发送AT指令会冲突，导致重启
//		UI_Key();
//	}
	
	if(sutUIstatus.Status==UIS_STANDBY && g_uslockflag==1)
	{
		if((g_ulKeyValue==KEY_FUNC_P2)||(g_ulKeyValue==KEY_PANEL_EXIT)||(g_ulKeyValue==KEY_PANEL_UP)||(g_ulKeyValue==KEY_PANEL_DOWN)||(g_ulKeyValue==KEY_FUNC_P3))
		{
			//Ui_LockFlag=1;
			return;
		}
	}
	
	if(sutUIstatus.Status==UIS_STANDBY&&g_ulKeyValue!=KEY_PPT){
		
		if(LcdSleepFlag==1){
						LcdSleepFlag=0;
						return;
					}
	}
	UI_Key();
	switch(g_ulKeyValue){
		//-------------------------------------------------------------------
		case KEY_PPT://=====================KEY_PPT Press====================
			if(!sutPocStatus.Prepare){
				if(++g_usFactory>2){//1
					g_uGtFactory=1;
					g_usFactory=0;
					UISetNextStatus(UIS_FACTORY_MENU);
				}
			}else{
				g_ucKeyMode=1;//单次模式
			
				if(os_time_get() < pttPressFreeCt) break;
				if((g_ucGtMode==0))
				{
					if(Pttfreeflag) Pttfreeflag=0;
					ModemSendAT(POC_CMD_PPT_START);//
					printf(POC_CMD_PPT_START);
				}		
			 }
				SlwTrace(INF,"[KEY_PPT/KEY_PPT_MIC Press]",1);	
			break;
			 
		//-------------------------------------------------------------------
		case KEY_INFO:
				g_ucKeyMode=0;
				SlwTrace(INF,"[KEY_INFO Press]",1);
//				if(++g_usLightCnt==2){
//					ModemSendAT("AT+POC=520&9\r\n");//播报当前群组
//				}
		
			break;
		case KEY_FUNC_P2:
			//g_ucKeyMode=1;//单次模式
			SlwTrace(INF,"[KEY_FUNC_P2 Press]",1);
//			if(++g_usVoiceCnt==2){
//						if(ChangeIng){
//							CHARGE_IC_HIGH;
//							os_dly_wait(50);
//							snprintf(buf,sizeof(buf),"AT+POC=522&%d&%d\r\n",(GetOneceVbat1()-340)*100/(430-340),g_iCSQ);//435
//							ModemSendAT(buf);
//							SlwTrace(INF,buf,1);
//							os_dly_wait(100);
//							CHARGE_IC_LOW;
//					}
//					ModemSendAT("at+poc=520&10\r\n"); //播报电量
//				}
				
							if(sutProductPara.VolLv<11&&Ui_VolLvFlag){
								sutProductPara.VolLv++;
								snprintf(buf,sizeof(buf),"AT+POC=607&%d\r\n",sutProductPara.VolLv);
								ModemSendAT(buf);
							}
							printf("sutProductPara.VolLv==%d\r\n",sutProductPara.VolLv);
							snprintf(buf,sizeof(buf),"%02d",sutProductPara.VolLv);
								if(sutUIstatus.Status==UIS_STANDBY){
								
									GuiShowBmp(5,80,"volume.bmp");
									GuiShowStr(26,80,buf,0x11);
								}
							
							Ui_VolLvFlag=1;
							Ui_VolLvCnt=0;
							
			
		
			break;
			
			
			case KEY_FUNC_P3:
					
					if(sutProductPara.VolLv>0&&Ui_VolLvFlag){
						sutProductPara.VolLv--;
						snprintf(buf,sizeof(buf),"AT+POC=607&%d\r\n",sutProductPara.VolLv);
						ModemSendAT(buf);		
					}
					printf("sutProductPara.VolLv==%d\r\n",sutProductPara.VolLv);
					snprintf(buf,sizeof(buf),"%02d",sutProductPara.VolLv);
					if(sutUIstatus.Status==UIS_STANDBY){
						GuiShowBmp(5,80,"volume.bmp");
						GuiShowStr(26,80,buf,0x11);
					}
					Ui_VolLvFlag=1;
					Ui_VolLvCnt=0;
				
//				//g_usFastInterfaceCnt;
//				if(++g_usFastInterfaceCnt==2){
//								//待定	
//					}
				SlwTrace(INF, "[KEY_FUNC_P3 Press]",1);
			break;	
			

		case KEY_PANEL_MENU://=====================KEY_PANEL_MENU  Press=================
			if(++g_uslockCnt==2&&!g_uGtFactory&&!BOOTDebug){
								if(g_uslockflag){
									g_uslockflag=0;
								}else g_uslockflag=1;
							
								if(g_uslockflag==1){
										GuiShowBmp(72,110,"lock.bmp");
									}else{
										g_cMenuBack=1;
										GuiFillRect(72,110,72+17,110+17,OrangeColorId);
								}
							}
				SlwTrace(INF,"[KEY_PANEL_MENU Press]",1);
			break;
		case KEY_PANEL_EXIT://=====================KEY_PANEL_EXIT  Press=================
					SlwTrace(INF,"[KEY_PANEL_EXIT Press]",1);
					if(++g_ucPoweroffcnt>2){
								SlwTrace(INF, "PwrOffOk",1);
								ShowMessageBox("正在关机!");
								MODEN_POWER_EN_HIGH;
								IWDG_ReloadCounter();
								os_dly_wait(100);
								MODEN_POWER_EN_LOW;
								PWR_EN_LOW;
								while(1);	
					}

			break;
					
		case KEY_PANEL_UP://=====================KEY_PANEL_UP  Press=================
			

				SlwTrace(INF,"[KEY_PANEL_UP Press]",1);
			break;
			
		case KEY_PANEL_DOWN://=====================KEY_PANEL_DOWN  Press=================
				
				SlwTrace(INF,"[KEY_PANEL_DOWN Press]",1);
			break;
			
		case KEY_EXIT_DOWN_GT://=====================KEY_UP_OK_GT  Press=================
			
				if(++g_usGtcnt==3)EnterGTMode();
				SlwTrace(INF,"[KEY_EXIT_DOWN_GT Press]",1);
		  break;
		
		case KEY_P1_P3_UPDATE:
			SlwTrace(INF, "[KEY_P1_P3_UPDATE Press]",1);
			break;
		
		case KEY_OK_DOWN_GPS:
			SlwTrace(INF, "[KEY_OK_DOWN_GPS Press]",1);
		  break;
	
		case KEY_SOS_OK:	
				SlwTrace(INF, "[KEY_SOS_OK Press]",1);
				g_usSOSCnt++;
//			if(sutUIstatus.Status==UIS_STANDBY)
//			{
				if(g_usSOSCnt==3)
				{
					sutPocStatus.SOS_Flag=1;
					ModemSendAT(POC_SOS);	
					UISetNextStatus(UIS_STANDBY);
//				GuiShowStr(30,60+18+18,"按PTT取消SOS",0x01);	
				}		
//		}	
		break;
				
		case KEY_PTT_EXIT:
			if(!sutPocStatus.Prepare){
				if(++g_usFactory>2){//1
					g_uGtFactory=1;
					g_usFactory=0;
					UISetNextStatus(UIS_FACTORY_MENU);
				}
			}
			break;
	}
	
}

//长按 EXIT和下箭头3秒，只进入一次
void GTMode_Detected(void)
{
	static char GT_Flag=0;
	
	if(GT_Flag == 2) return;
	if(g_ulKeyValue == KEY_EXIT_DOWN_GT)
	{
		if(GT_Flag == 0)
		{
			g_ucUKC=0;
			GT_Flag ++;
		}else
		{
			if(g_ucUKC>3){
			  EnterGTMode();
		    GT_Flag++;
			}
		}
	}else
	{
		if(GT_Flag == 1)
			GT_Flag = 0;
	}
}

void UpdataAppVersion(void)
{
	//正旋1格后松开，升级应用版本
	SpeakerEnable();
	ModemSendAT("AT+ZTTS=1,\"C6510759F466B065945E287548722C67F78B73513A678D51005F3A67\"\r"); //准备更新应用版本,请关机再开机
	SlwTrace(INF,"Update APP Version!",1);
	SetLedStatus(RedFastFlash);
	sutProductPara.IapFlag=0x55;
	SaveProductParaToFlash("MAIN-UP");
	while(1){
		IWDG_ReloadCounter();//喂狗 
		os_dly_wait(1);
		if(OnOffCheck()){
			PWR_EN_LOW;
		}
	}

}
void UpdataPocVersion(void)
{
	SpeakerEnable();
	ModemSendAT("AT+POC=10000018\r\n");
	SlwTrace(INF,"Update POC Version!",1);
}

void EnterGTMode(void)
{
	g_ucModemTaskEn=0;
	SpeakerEnable();	
	SetBeep(1176,10);
	os_dly_wait(20);
	SpeakerEnable();	
	SetBeep(878,10);
	os_dly_wait(20);
	SpeakerEnable();	
	SetBeep(1176,10);
	Uart1RxEnable2(1);
	LedProcess(1);
	SetLedStatus(RedBlueFastFlash);
	SlwTrace(INF,"[EnterTxMode]",1);
}

void openModem()
{
	MODEM_RESET_HIGH;
	os_dly_wait(100);
	MODEM_RESET_LOW;
	MODEM_PWRKEY_HIGH;
	os_dly_wait(100);
	MODEM_PWRKEY_LOW;
}

void closeModem()
{
	MODEM_RESET_HIGH;
	MODEM_PWRKEY_HIGH;
}
/***********************************************************************
*按键释放事件
************************************************************************/
void KeyFree(void)
{
	int i;
	char CheckCode[10];
	char buf[30];
	int flag;
	SUT_MODEM_AT_MSG *pMsg;
  //unsigned int temp;
	char pressFlag;

	static char lightflag=0;
	
	if(sutUIstatus.Status==UIS_FACTORY_KEY){
					GuiClearArea(64,56+18,80,18);
					GuiShowStr(64,56+18,"无",1); 
	}
	
	if(sutUIstatus.Status==UIS_STANDBY && g_uslockflag==1)
	{
		//||(g_ulKeyValue==KEY_PANEL_MENU)
		if((g_ulKeyValue==KEY_FUNC_P2)||(g_ulKeyValue==KEY_PANEL_EXIT)||(g_ulKeyValue==KEY_PANEL_UP)||(g_ulKeyValue==KEY_PANEL_DOWN)||(g_ulKeyValue==KEY_FUNC_P3))
		{
			Ui_LockFlag=1;
			return;
		}
	}

	//-------------------------------------------------------------------
	if(KEY_PPT==g_ulKeyValue  )
	{//===============KEY_PPT Free=============
		SlwTrace(INF,"[KEY_PPT/KEY_PPT_MIC Free]",1);
		//MODEM_LED1_LOW;  //为了增强体验，要不然熄灯太慢。
if(!sutPocStatus.Prepare){
			g_usFactory=0;
		}else {
			g_ucKeyPPTPress=0;
			sutPocStatus.PPTpress=0;
			pttPressFreeCt=os_time_get()+20; 
			if((g_ucGtMode==0))
			{
				Pttfreeflag=1;
				ModemSendAT(POC_CMD_PPT_STOP);//结束讲话 放开PPT键
				SlwTrace(INF,POC_CMD_PPT_STOP,1);
				g_ucKeyMode=0;
			}
		}			
	}else if(KEY_INFO==g_ulKeyValue)
	{
		SlwTrace(INF,"[KEY_INFO Free]",1);
		g_ucKeyMode=0;
		if(g_usLightCnt<2){
			
		lightflag=!lightflag;
			if(lightflag==1)KEY_LED(1);
			else KEY_LED(0);		
				
		}
		g_usLightCnt=0;
		
	}else if(KEY_FUNC_P2==g_ulKeyValue)
	{
	  g_ucKeyMode=0;
//		if(g_usVoiceCnt<2){
//				ModemSendAT("AT+POC=520&6\r\n");//播报语音记录
//		}
//		g_usVoiceCnt=0;
//		
		SlwTrace(INF,"[KEY_FUNC_P2 Free]",1);
	}
	else if(KEY_SOS_OK==g_ulKeyValue)
	{//=========KEY_SOS_OK Free==============
		SlwTrace(INF,"[KEY_SOS_OK Free]",1);
		g_usSOSCnt=0;
		return;
	}
	else if(KEY_PANEL_MENU==g_ulKeyValue)
	{//=========KEY_PANEL_MENU Free==============
		g_uslockCnt=0;
		if(g_uslockCnt<2&&g_uslockflag==0&&sutUIstatus.Status==UIS_STANDBY){
			if(g_cMenuBack!=1)UISetNextStatus(UIS_MENU_MAIN);
			g_cMenuBack=0;
		}
		//g_uslockCnt=0;
		SlwTrace(INF,"[KEY_PANEL_MENU Free]",1);
		return;
	}		
	else if(KEY_PANEL_EXIT==g_ulKeyValue)
	{
		
		//=========KEY_PANEL_EXIT Free==============
		g_ucPoweroffcnt=0;
	
//		if(sutUIstatus.Status==UIS_STANDBY)		 
//		{
//			switch(g_ulKeyValue){		

//				case KEY_PANEL_EXIT:
//					if(g_uslockflag==1)return;	
//					if(sutPocStatus.danHunStatus==2){
//						snprintf(buf,sizeof(buf),"AT+POC=540&2&%d\r\n",sutPocStatus.CallID);
//						ModemSendAT(buf);
//					}else {
//							if(LastLcdSleepFlag==0){
//								LCDTimeOut(1);
//								sutLcdParam.OnTimeCt=g_ausTimeOut[sutProductPara.LCDSetIndex];
//							}	
//							else {
//								LCDTimeOut(0);
//								sutLcdParam.OnTimeCt=0;
//							}		
//					}
//		
//			}
//		
//		}
//		

		SlwTrace(INF,"[KEY_PANEL_EXIT Free]",1);
		return;
	}				
	else if(KEY_PANEL_UP==g_ulKeyValue)
	{//=========KEY_PANEL_UP Free============
		
		SlwTrace(INF,"[KEY_PANEL_UP Free]",1);
	}
	else if(KEY_PANEL_DOWN==g_ulKeyValue)
	{//=========KEY_PANEL_DOWN Free============
		
		SlwTrace(INF,"[KEY_PANEL_DOWN Free]",1);
		
	}	
	else if(KEY_EXIT_DOWN_GT==g_ulKeyValue)
	{//=====================KEY_EXIT_DOWN_GT  Press=================
		g_ulKeyValue=0;
		g_usGtcnt=0;
		SlwTrace(INF,"[KEY_EXIT_DOWN_GT Free]",1);
	}else if(KEY_FUNC_P3 == g_ulKeyValue)
	{
		//g_usFastInterfaceCnt
		SlwTrace(INF,"[KEY_FUNC_P3 Free]",1);	
//		if(g_usFastInterfaceCnt<2&&g_uGtFactory!=1){
//			
//			sutUIstatus.ShortCut=1;
//			
//			if(sutProductPara.FastInterface==0){
//					sutPocStatus.recordflag=0;
//				UISetNextStatus(UIS_MENU_GROUP_SEL);
//				
//			}
//			else if(sutProductPara.FastInterface==1){
//					sutPocStatus.recordflag=0;
//					UISetNextStatus(UIS_MENU_USER_SEL);	
//			}
//			else{
//					sutPocStatus.recordflag=1;
//				UISetNextStatus(UIS_MENU_GROUP_SEL);
//			} 
//			
//		}
//			g_usFastInterfaceCnt=0;
	}
}


void apnUpdateFun(void)
{
	int len;
	char buf1[400];
	char *pMsg;
	if(apnUpdateFlag!=1) return;
	apnUpdateFlag=0;
	len=HgsApnLen;
	if(HgsApnLen > sizeof(buf1)) len=sizeof(buf1);

	len=ReadFileData(ApnFileIndex,0,len,(u8*)buf1);
	if(len==0) return;
	pMsg=strstr(buf1,"APN4=");
	if(0==pMsg) return;
	sprintf(pMsg+5, "%s,%s;\r\n",showApnTable[6],showApnTable[7]);
	ModifyFileData(ApnFileIndex, 0, strlen(buf1), (unsigned char *)buf1);
}

void cmdShutDown(char type)
{
	static short cntDown;
	static char ttype;
	char power_down=0;
	static char Powercnt=150;
	char xoffset=0;
	char buf[30];
	ttype=type;
	SlwTrace(INF, "Try to PwrOff",1);
	
	if(modemInitReady==0){
		if(0==strcmp(sutProductPara.Language,"cn"))ShowMessageBox("正在关机,请稍候");
			else ShowMessageBox("please wait");
	}
	PWR_EN_HIGH;
	while(1){
			IWDG_ReloadCounter();
				os_dly_wait(10);
			if(--Powercnt==0)return;
			if(modemInitReady>0){
					break;
			}
		}
	
	for(cntDown=3;cntDown>=0;cntDown--)
	{
		if(cntDown==3)
		{
			switch(ttype)
			{
				case 0:
					if(0==strcmp(sutProductPara.Language,"cn")) snprintf(buf, sizeof(buf), "正在关机");
						else {
							snprintf(buf, sizeof(buf),"PowerOff");
							xoffset=8;
				
						}
						break;
				case 1:
					if(0==strcmp(sutProductPara.Language,"cn"))snprintf(buf, sizeof(buf), "低压关机");
					else {
						snprintf(buf, sizeof(buf), "LowVoltage");
						xoffset=16;		
					}
						break;
				default:
					return;
			}
			
			ShowMessageBox(buf);
			SlwTrace(INF, buf, 1);
		
		}	
		GuiClearArea(xoffset+104,LCD_HEIGHT/2-8,25,16);
		memset(buf,0,sizeof(buf));
		if(cntDown%3==0){
			snprintf(buf,sizeof(buf),".");
			GuiShowStr(xoffset+104,LCD_HEIGHT/2-8,buf,0x01);
		}
		if(cntDown%3==1){
			snprintf(buf,sizeof(buf),"...");
			GuiShowStr(xoffset+104,LCD_HEIGHT/2-8,buf,0x01);
		}
		if(cntDown%3==2){
			snprintf(buf,sizeof(buf),"..");
			GuiShowStr(xoffset+104,LCD_HEIGHT/2-8,buf,0x01);
		}
		
		IWDG_ReloadCounter();
		os_dly_wait(100);
	}
}

void PowerOffProtetion(char type)
{
	if(modemPwrOffNow==0) return;
	printf("POWEROFF NOW\r\n");
	LCDTimeOut(0);
	GPS_PWREN_LOW;
	if(type==0)cmdShutDown(0);
	PWR_EN_LOW;
	while(1);
}


unsigned int bootMapCnt=0;
unsigned char bootFlag=0;
MUC_TYPE Mcu_Type;
/*******************************************************************
*MainTask
*主任务
********************************************************************/
__task void MainTask(void)
{ 
	int KeyFlag=0; 
	int FileIndex;
	static unsigned int sucCt=0;
	Mcu_Type=MCU_UNKNOWN;
	Uart1RxEnable(1);
	KeyInit();
	MCU_FACTORY_RECOGNIZE();
	ReadProductParaFromFlash();
	IWDG_Configuration(500);//500
	SpeakerInit(); 
	IWDG_ReloadCounter();//
	W25Q64_Init();
	FileSysInit();
	SysIniRead();
	LcdInit(); //放此地调整用户体验
	printf("LcdInit... OK!\r\n"); 
	GuiInit();
	IWDG_ReloadCounter();//
	printf("GuiInit... OK!\r\n"); 
	ADCInit();//ADC Init
	//g_iVbat=GetOneceVbat1();
	//电量检测，低电关机
	//PVD_Config();
	BeepInit();
	//OnOff_Init();
	MY_NVIC_Init();
	LedInit();
	Uart3Init();
	GPSInit();
	////显示开机动画
	ShowBootAnimation();
	SysTick_Config(SystemCoreClock / 100);
	//Obtain own system task identification number. */
	idMainTask = os_tsk_self();
	memset((unsigned char *)&sutPocStatus,0,sizeof(SUT_POC_STATUS));
	
	//开机提示音
	SpeakerEnable();
	os_dly_wait(10);
	SetBeepByNoOS(888,100);
	SetLedIndicator(InStart);
	SpeakerDisable();
	
	SlwTrace(INF,"Main Task Start!",1);
	bootMapCnt=os_time_get()+800;//开机界面持续
	//create PocTask	
	idModemUartTask=os_tsk_create_user(ModemUartTask,3,&stkModemUartTask,sizeof(stkModemUartTask));//1024	
	idModemTask=os_tsk_create_user(ModemTask,3,&stkModemTask,sizeof(stkModemTask));//1024
	RunMake(THIS_FILE_ID);
	UI_Init();
	
	while(1)
	{
		if(g_uGtTaskEn==1||g_uGtFactory==1)
		{
			UI_Loop();
		}else 
		{			
			if(bootFlag==0)
				{
					if((os_time_get() > bootMapCnt) || sutPocStatus.FirstLogined==1)
						bootFlag=1;
		  	}
				if(bootFlag==1) UI_Loop();
		}
		os_dly_wait(1);
		//处理PC发送过来的消息

		if(g_usUart1RecvLen){	
			if(RxBuffer1[0]=='>'){
				PcMsgHandle2((char *)RxBuffer1);
			}else PcMsgHandle((char *)RxBuffer1);
			RxBuffer1[0]=0;
			rx1_ct=0;
			g_usUart1RecvLen=0;
		}
		
		RunMake(THIS_FILE_ID);
		if(sutUIstatus.Status!=UIS_STANDBY &&(sutPocStatus.PPTpress!=0 || sutPocStatus.PocingCnt==1))  //|| sutPocStatus.Speaker!=0
			{
				if(sutUIstatus.Status!=UIS_UPDATA_SHOW) UISetNextStatus(UIS_STANDBY);;
				sutPocStatus.PocingCnt=0;
				sutPocStatus.recordflag=0;
			}
			
		//键盘处理
		if(0!=(KeyFlag=GetKey())){
					//按键处理
			if(1==KeyFlag){	//按键按下
				
						LCDTimeOut(0);
						sutLcdParam.OnTimeCt=0;
						KeyPress();				
						if(0==strcmp(sutProductPara.Keysound,"open")){	
								if((sutUIstatus.Status==UIS_MENU_USER_SEL||
										sutUIstatus.Status==UIS_MENU_GROUP_SEL||
										sutUIstatus.Status==UIS_Voice_Record )&&
									(g_ulKeyValue ==KEY_PANEL_MENU||g_ulKeyValue ==KEY_SOS_OK))  // GPS
								{
								
								}
								else if(g_ulKeyValue != KEY_PPT )
								{
									//if(g_usSOSCnt<=1&& g_usVoiceCnt<=1&&g_usLightCnt<=1&&g_usFastInterfaceCnt<=1){
										if(g_usSOSCnt<=1){
										SpeakerEnable();
										//os_dly_wait(10);//等待硬件功放初始化完成
										if(g_uckeybeep==0)SetBeep(500,12);//700
										g_uckeybeep=1;
									}
								}			
							}
						//if(g_ulKeyValue != KEY_PANEL_EXIT){
						
					//	}
		
							sutPocStatus.keypressCnt=0;
			
		}else{ //按键释放	
			
				KeyFree();
				g_uckeybeep=0;
			
		}			
	}	
//	//LED处理
		LedProcess(0);
		Ear_check(0);
		GTMode_Detected(); 
		//---以下控制每秒执行一次---
		if(os_time_get() < sucCt) continue;	
		sucCt = os_time_get()+100;
		if(Ui_VolLvCnt<3&&Ui_VolLvFlag)Ui_VolLvCnt++;
		RTC_Update();
		//SoftPwrOffCheck();
		if(Pttfreeflag==1&&! g_uGtTaskEn && !g_uGtFactory){
			Pttfreeflag=0;
			ModemSendAT(POC_CMD_PPT_STOP);//规避 未POC收到放麦问题，实属无奈
			SlwTrace(INF,POC_CMD_PPT_STOP,1);
		}
		KeyCount();//键盘按下、释放计数控制
		//测量电池电压
		if(sutPocStatus.Speaker==0 && sutPocStatus.PPTpress==0) Vbat=GetVbat()+sutProductPara.VbatCalibration;   //非对讲状态才去测试电压
			//printf("VBAT========%d\r\n",Vbat);	
		
		if(GPIO_ReadInputDataBit(CHARGE_STATUE_PORT,CHARGE_STATUE_PIN)==RESET)
		{
//			printf("IC 已经判饱-----------\r\n");
		}
			if(Vbat>0)g_iVbat=Vbat;
		//判断电池电压是否过低关机
		CheckVbat(g_iVbat);
		//MODEM防护
		FingerDaemonfinger();  
		
		Vbatsend();  //定时发送  电量	
		/***LED灭屏及返回主界面***/
		if(++sutPocStatus.keypressCnt>60 && g_uGtTaskEn!=1&& g_uGtFactory!=1&&BOOTDebug!=1) //60秒不操作返回主界面
		{
			if(sutUIstatus.Status!=UIS_STANDBY) UISetNextStatus(UIS_STANDBY);
			sutPocStatus.keypressCnt=0;
		}
		
		if(g_ausTimeOut[sutProductPara.LCDSetIndex]>0){
			if(++sutLcdParam.OnTimeCt>=g_ausTimeOut[sutProductPara.LCDSetIndex]){
				sutLcdParam.OnTimeCt=0;
				if(sutPocStatus.FirstLogined==1)//没登陆过(刚开机)，LCD一直亮着
				  LCDTimeOut(1);
			}
		}	
		
		if(Ui_VolLvFlag&&Ui_VolLvCnt==3){
				if(sutUIstatus.Status==UIS_STANDBY)GuiClearRect(0,80,159,80+16);	
				SaveProductParaToFlash("vol");
				Ui_VolLvFlag=0;
				Ui_VolLvCnt=0;
		}	
	}
}

void ADCInit(void)
{
	ADC_InitTypeDef  ADC_InitStructure; 
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,ENABLE); 
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
	
	GPIO_InitStructure.GPIO_Pin  =GPIO_Pin_0; 	
	GPIO_InitStructure.GPIO_Mode =GPIO_Mode_IPU;//先内部上拉模式给IO充能 
	GPIO_Init(GPIOA,&GPIO_InitStructure); 
	DelayMs(100);
	GPIO_InitStructure.GPIO_Mode =GPIO_Mode_AIN; 
	GPIO_Init(GPIOA,&GPIO_InitStructure); //默认速度为两兆
	DelayMs(200);//让电平恢复正常
	
	//配置ADC的运行：
	ADC_InitStructure.ADC_Mode              = ADC_Mode_Independent;  //独立模式 
	ADC_InitStructure.ADC_ScanConvMode      =DISABLE;      //连续多通道模式 
	ADC_InitStructure.ADC_ContinuousConvMode =DISABLE;//ENABLE;      //连续转换 
	ADC_InitStructure.ADC_ExternalTrigConv  = ADC_ExternalTrigConv_None; //转换不受外界决定 
	ADC_InitStructure.ADC_DataAlign         =ADC_DataAlign_Right;   //右对齐 
	ADC_InitStructure.ADC_NbrOfChannel      =1;       //扫描通道数 
	ADC_Init(ADC1,&ADC_InitStructure); 
	ADC_RegularChannelConfig(ADC1,ADC_Channel_0, 1,ADC_SampleTime_1Cycles5); //通道X,采样时间为1.5周期,1代表规则通道第1个这个1是啥意思我不太清楚只有是1的时候我的ADC才正常。 
	ADC_Cmd  (ADC1,ENABLE);             //使能或者失能指定的ADC 
	ADC_SoftwareStartConvCmd(ADC1,ENABLE);//使能或者失能指定的ADC的软件转换启动功能
}


void GPIO_Config_ALL_AIN(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;

  /* Enable GPIOD and GPIOE clock */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB 
                         | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD 
                         | RCC_APB2Periph_AFIO, ENABLE);
  
  
  /* Disable the Serial Wire Jtag Debug Port SWJ-DP */
  GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable, ENABLE); 
  
    /* PA  */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
      /* PB  */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; 
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
      /* PC  */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
  GPIO_Init(GPIOC, &GPIO_InitStructure);
        /* PD  */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA  
                         | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD  
                         , DISABLE);

}
/***********************************************************************
*获取电池电压
返回值： -1为无效 ； 正数表示电池电压放大100倍，如 382表示3.82V
***********************************************************************/
int GetVbat(void)
{
	char buf[30];
	static int Ct=0;
	static int siVbat[10]={0,0,0,0,0,0,0,0,0,0};
	int iVbat[10];
	int max[5];
	int sum;
	int i,j,k;
	int adc;
	int Vbat;
	short Vref=330;
	
#if 1
	//ADC_StartCalibration(ADC1);
  ADC_SoftwareStartConvCmd(ADC1,ENABLE);
	while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
	adc=ADC_GetConversionValue(ADC1);
	
	if(adc<100 && adc>4095)
	{
		printf("VDAC OVER");
		return -1;
	}
#else
	//采集ADC
	if(ADC_GetFlagStatus(ADC1,ADC_FLAG_EOC)!=RESET){//检查制定ADC标志位置1与否 ADC_FLAG_EOC 转换结束标志位 	if(ADC_GetFlagStatus(ADC1,ADC_FLAG_EOC)!=RESET){
	
		ADC_SoftwareStartConvCmd(ADC1,ENABLE);
		adc=ADC_GetConversionValue(ADC1);

		if(adc<100 && adc>4095)
		{
			//printf("ERR1");
			return -1;
		}
	}else
		{
			printf("ERR2");
			return -1;
		}
		#endif
	//循环存储
	siVbat[Ct]=adc;
	if(++Ct>9)Ct=0;
	//printf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\r\n",siVbat[0],siVbat[1],siVbat[2],siVbat[3],siVbat[4],siVbat[5],siVbat[6],siVbat[7],siVbat[8],siVbat[9]);
	//滤波处理，排列取3个最大值，3个最大中去掉第一大，其余求平均
	//拷贝
	for(i=0;i<10;i++){
		iVbat[i]=siVbat[i];
	}
	for(i=0;i<4;i++){
		max[i]=0;
		for(j=0;j<10;j++){
			if(iVbat[j]>max[i]){
				max[i]=iVbat[j];	
				k=j;	
			}
		}
		iVbat[k]=0;
	}

//	printf("%d,%d,%d\r\n",max[0],max[1],max[2]);
	sum=max[1]+max[2];
	if(max[2]<200)
	{
		//printf("ERR3");
			return -1;
	}
	
	if(Mcu_Type==MCU_HK)Vref=332;
	else if(Mcu_Type==MCU_ST)Vref=339;
	else Vref=330;
	
	Vbat=sum*Vref/4096;   //325
	return Vbat;
}





int GetOneceVbat1()
{
	int adc;
	int Vbat;
	short Vref=330;
  ADC_SoftwareStartConvCmd(ADC1,ENABLE);
	while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
	adc=ADC_GetConversionValue(ADC1);

	if(adc<100 && adc>4095)
	{
		printf("VDAC OVER");
		return -1;
	}
	
	if(Mcu_Type==MCU_HK)Vref=332;
	else if(Mcu_Type==MCU_ST)Vref=339;
	else Vref=330;
	
	Vbat=adc*Vref/4096; //339
	printf("Vbat===%d\r\n",Vbat*2);
	return Vbat*2;

}

/***************************获取一次电压值****************************************/
int GetOneceVbat()
{
	int adc;
	int Vbat;

  ADC_SoftwareStartConvCmd(ADC1,ENABLE);
	while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
	adc=ADC_GetConversionValue(ADC1);

	if(adc<100 && adc>4095)
	{
		printf("VDAC OVER");
		return -1;
	}
	Vbat=adc*339/4096; //308
	printf("Vbat===%d\r\n",Vbat);
	return Vbat;

}


void Sys_Standby(void)
{  
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);	//使能PWR外设时钟
	PWR_WakeUpPinCmd(ENABLE);  //使能唤醒管脚功能,PA0
	PWR_EnterSTOPMode(PWR_Regulator_LowPower,PWR_STOPEntry_WFI);   		 
}

/*******************************************************
*CheckVbat
*检查电池电压，控制低压报警，
*低压关机已由硬件监测
******************************************************/
void CheckVbat(int Vbat)
{
	static unsigned char sucCt=0;//提示“请充电”计数器
	static unsigned char LowCnt=0;
	static unsigned char Vbatfull=0;

	if(ChangeIngCt>0){
			ChangeIngCt--;//重插
		
		}else{
		if(ChangeIng){  //已经

			if((Vbat>432)||(GPIO_ReadInputDataBit(CHARGE_STATUE_PORT,CHARGE_STATUE_PIN)==RESET)){		
						if(Vbat<418){ //复充			
							CHARGE_IC_HIGH;
							if(++ReCharge>5)
							{
								Vbatfull=1;
								ReCharge=0;
							}
						}else {
							ReCharge=0;
						}
						
					}
			}		
	}
	if(Vbatfull==1){
		Vbatfull=1;
		CHARGE_IC_LOW;
	}
	if(Vbat<MIN_PWR_LEVEL){//	
		if(LowCnt++<30){                  //3次
			return; //判断3次 低压则关机
		}else LowCnt=0;
		SlwTrace(INF,"Vbat low!shutdown now!",1);
		os_dly_wait(1);
		
		//关闭模块
		if(sutPocStatus.ModemPowerOn==1){	
			//发送机指令并等待7秒
			cmdShutDown(1);
		}
		sutPocStatus.ModemPowerOn=0;
		PWR_EN_LOW;
		while(1);
		
	}else if(Vbat<WARN_PWR_LEVEL){//提示请充电 
		if(++sucCt>30){
			sucCt=0;
		}
	}else sucCt=0;
	
}
void GetXinHao(int CSQ,char *XinHao)
{
	
	if(CSQ>31 || CSQ<1){
		strcpy(XinHao,"2C00E065517FDC7EE14FF753");//无网络信号
		
	}else if(CSQ>25){ 			   
		//信号较强 "E14FF753838F3A5F"
		strcpy(XinHao,"E14FF753838F3A5F");
	}else if(CSQ>17){
		//信号适中 "E14FF75302902D4E"
		strcpy(XinHao,"E14FF75302902D4E");
	}else if(CSQ>10){
		//信号偏低 "E14FF7534F504E4F"
		strcpy(XinHao,"E14FF7534F504E4F");
	}else{
		//信号很弱 "E14FF753885F315F"
		strcpy(XinHao,"E14FF753885F315F"); 
	}	
}
void GetVbatPercent(int Vbat,char *Percent)
{
	//10 20 30 40 50 60 70 80 90 100
	const char *ccPercent[]={
	"31003000", 
	"32003000", 
	"33003000", 
	"34003000", 
	"35003000", 
	"36003000", 
	"37003000", 
	"38003000", 
	"39003000", 
	"310030003000"};
	
	//播报电量百分比	       10，20，30, 40, 50, 60, 70, 80, 90,100		
	const int siVbat[]   ={335,343,350,360,370,377,384,392,400,500};
	int i;
	for(i=0;i<10;i++){
		if(Vbat<siVbat[i])break;
	}
	if(i>9)i=9;
	strcpy(Percent,ccPercent[i]);
}
/****************************************************************
*语音播报 电量、信号、GPS
*****************************************************************/
void ReportVbatCsqGps(void)
{
	unsigned char  GpsFlag;
	//电量百分之N，信号强,GPS已登陆已定位
	char buf[30];
	SpeakerEnable();
	ModemSendAT("AT+ZTTS=1,");
	ModemSendAT("\"3575CF917E7606524B4E");//电量百分之
	GetVbatPercent(g_iVbat,buf);
	ModemSendAT(buf); //10~100
	GetXinHao(g_iCSQ,buf); // 信号
	ModemSendAT(buf); 
	

	if(!sutGpsInfo.isGpsWork){
		ModemSendAT("E065470050005300");//,无GPS
		GpsFlag=0x00;
		ModemSendAT("\"\r\n");
	}else{
		if(sutGpsInfo.isServerLogin){ 
			ModemSendAT("470050005300F25D7B764696");	//,GPS已登陆 
			GpsFlag=0x20;
		}else{
			ModemSendAT("4700500053002A677B764696");	//,GPS未登陆 
			GpsFlag=0x10;
		}
		if(sutGpsInfo.isGpsValid){
			ModemSendAT("F25D9A5B4D4F");	//已定位 
			GpsFlag |= 0x01;
		}else{
			ModemSendAT("2A679A5B4D4F"); //未定位
		}
		ModemSendAT("\"\r\n");
	}
	snprintf(buf,30,"Vbat=%d,CSQ=%d,GPS=%02x",g_iVbat,g_iCSQ,GpsFlag);
	SlwTrace(INF,buf,1);
}

/***************************************************************************
将数字转Unicode编码
pUnicode空间最长 5*4+1=21字节
****************************************************************************/
void NumToUnicode(unsigned short Num,char *pUnicode)
{
	char temp[6];
	int i,j,len;
	snprintf(temp, sizeof(temp),"%u",Num);//0~65535
	len=strlen(temp);
	j=0;
	for(i=0;i<len;i++){
		pUnicode[j++]=0x30+temp[i]/16;
		pUnicode[j++]=0x30+temp[i]%16;
		pUnicode[j++]=0x30;
		pUnicode[j++]=0x30;
	}
	pUnicode[j]=0;
}

void ReportVersion(void)
{
	char buf[150];
	char temp[20];
	snprintf(buf, sizeof(buf),"AT+ZTTS=1,\"945E287548722C67");
	NumToUnicode(sutProductPara.ProductVersion,temp);
	strcat(buf,temp);
	strcat(buf,"2C00F95BB28B48722C67");
	NumToUnicode((unsigned short)g_iModemVer,temp);
	strcat(buf,temp);
	strcat(buf,"\"\r\n");
	SpeakerEnable();
	ModemSendAT(buf);//应用版本
	SlwTrace(INF,buf,0);
	/*
	SlwTrace(INF,"[ReportVersion]");
	sprintf(buf,"Mcu=%u,Modem=%u\r\n",sutProductPara.ProductVersion,(unsigned short)g_iModemVer);
	SlwTrace(INF,buf);
	*/
	
}
/*******************************************************************
*GetParaFromStr
*从Str中找到Para=后面至';'或非字符的字串并放入Value
返回Value的长度
举例：Str="GT+SMP=IP=192.168.1.1;Port=12345"    
	如果Para="Port" 则Value将被赋值为"12345",并返回5
	如果Para="IP"	则Value将被赋值为"192.168.1.1",并返回11
	要求Para长度不大于20字节 ,Value长度不大于40字节
********************************************************************/
int GetParaFromStr(char *Str,char *Para,char *Value)
{
	int ValueLen=0,ParaLen=0;
	char ParaTemp[22];
	char *p;
	char d;
	int i=0;

	if(0==*Str || 0==*Para)return 0;

	while(0!=(d=*Para) && ParaLen<20){
		ParaTemp[i++]=d;
		if(d=='=' || d==';')return 0;
		Para++;
		ParaLen++;
	}
	ParaTemp[ParaLen++]='=';
	ParaTemp[ParaLen]=0;
	p=strstr(Str,ParaTemp);
	p+=ParaLen;
	//--
	while(*p>0x20 && ';'!=*p && ValueLen<=80){
		*Value=*p;
		p++;
		Value++;
		ValueLen++;	
	}
	*Value=0;
	return ValueLen;
}

void IWDG_Configuration(unsigned int value)
{
// WWDG 时钟使能
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE);  
	if(RCC_GetFlagStatus(RCC_FLAG_IWDGRST) != RESET)RCC_ClearFlag();  
//写入0x5555,用于允许狗狗寄存器写入功能
	IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
 
//狗狗时钟分频,40K/256=156HZ(6.4ms)
	IWDG_SetPrescaler(IWDG_Prescaler_256);
 
//喂狗时间 
	//IWDG_SetReload(200);1.28s/6.4MS=200 .注意不能大于0xfff
	IWDG_SetReload(value);//3.2s/6.4MS=500 .注意不能大于0xfff
	
//喂狗
	IWDG_ReloadCounter();
 
//使能狗狗
	IWDG_Enable();
}


/*
此处修改：删去ModemSendAT("2C00");另外pocTask.cReplaceStrWithN(&msg[9]、msg[17]);强制将字符串后面的\n\r去掉
*/
void ReportUserGroupName(void)
{
#if POC_USER_NAME_LEN>POC_GROUP_NAME_LEN
	char buf[POC_USER_NAME_LEN*4];
#else
	char buf[POC_GROUP_NAME_LEN*4];
#endif
	
	
	SpeakerEnable();
	ModemSendAT("AT+ZTTS=1,\"");
	AnsiToStrUnicode((uint8_t *)buf,sizeof(buf),sutPocStatus.LocalUser.name); //函数功能未实现，需要修改
	ModemSendAT(buf);
	AnsiToStrUnicode((uint8_t *)buf,sizeof(buf),sutPocStatus.LocalUser.name); 
	ModemSendAT(buf);
	ModemSendAT("\"\r");
	

	
}

void SetPowerEn(unsigned char en)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	if(en!=0){
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC, ENABLE);
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_InitStructure.GPIO_Pin = PWR_EN_PIN;
		GPIO_Init(PWR_EN_PORT, &GPIO_InitStructure);
		PWR_EN_HIGH;
	}else{
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC, ENABLE);
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_InitStructure.GPIO_Pin = PWR_EN_PIN;
		GPIO_Init(PWR_EN_PORT, &GPIO_InitStructure);
		PWR_EN_LOW;
	}
}

/*****************************************************************************************
*函数名：GetCheckCodeByPsnMEID
*功能：根据PSN号和MEID码，生成伪随机码
*入口：PSN--PSN码，无符号长整形，必须是大于150000000的数值，有可能是9位数也可能是10位数
	  pMEID--MEID字串，长度14位或15位，第16字节必须为0。
*出口：pCheckCode:--长度为6的字符串，第7字节为结束符0x00，因此必须留够7字节的空间！
返回：1--成功  0--因参数非法而失败
******************************************************************************************/
const unsigned char sucRandTable[256]={
		0x68,0x59,0x63,0x64,0xc8,0xcc,0xaa,0xa7,0xa2,0xab,0xa5,0x6e,0x6a,0x56,0x8a,0x57,
		0xf4,0xbb,0xfe,0xfa,0x26,0x21,0x2d,0x29,0x0d,0x09,0x3e,0x3a,0x37,0x32,0x0a,0x07,
		0xf7,0xf2,0xfb,0xf5,0xff,0xf6,0x1c,0x18,0x13,0x14,0xf1,0xfd,0xf9,0x0c,0x9f,0x08,
		0x9a,0x97,0x92,0x9b,0x95,0x9f,0x12,0x1b,0x15,0x2c,0x28,0x23,0xf9,0x2a,0x27,0x22,
		0x24,0x2e,0x67,0x25,0x2f,0x98,0xfc,0x75,0xf8,0xf3,0x3c,0x38,0x33,0x34,0x03,0x04,
		0x05,0x0f,0x06,0x01,0x7a,0x77,0x72,0x62,0x6b,0x83,0x84,0x8e,0xc4,0xcb,0x87,0x82,
		0x35,0x3f,0x36,0x4f,0x3d,0x39,0x9c,0x98,0x93,0x94,0x42,0x4f,0x46,0x41,0x81,0x8d,
		0x4d,0x49,0x71,0x7d,0x79,0x96,0x91,0x9d,0x99,0xc3,0xc4,0x1d,0xce,0xca,0x7f,0x76,
		0x7c,0x78,0x73,0x74,0x7e,0x7b,0x75,0x1e,0x1a,0x17,0x1f,0x16,0x11,0x1d,0x47,0x19,
		0x5d,0xc7,0xc2,0xcb,0xc5,0xcf,0xd1,0xdd,0xd9,0x4c,0x48,0xc6,0xc1,0xcd,0x61,0xc9,
		0xd7,0x8c,0xfd,0x88,0xa1,0xad,0xa9,0xb1,0xbd,0xb9,0x8b,0x85,0x8f,0x4b,0x45,0x86,
		0xdc,0xd8,0xd3,0xd4,0xde,0xd2,0xdb,0xd5,0xdf,0xd6,0x43,0x44,0x4e,0x4a,0xe7,0x47,
		0xac,0xa8,0xa3,0xa4,0xae,0xba,0x0d,0xb7,0xb2,0xaf,0xa6,0xe4,0xee,0xea,0xe7,0xe2,
		0xe1,0xed,0x0f,0xe9,0x66,0x61,0x6d,0x69,0xbb,0xb5,0xbf,0xb6,0xec,0xe8,0x0b,0xe3,
		0x52,0x5c,0x65,0x6f,0x58,0x53,0x54,0x0c,0x5e,0x5b,0x55,0x5f,0x31,0x2f,0x9a,0x0b,
		0x0b,0x5a,0x2b,0x9e,0x02,0x89,0x59,0x3b,0x0e,0x51,0x6c,0xeb,0xda,0xe6,0x31,0xf6
	};
int GetCheckCodeByPsnMEID(char *pCheckCode,unsigned long PSN,char *pMEID)
{
	char aucPSN[12];
	char aucMEID[16];
	unsigned char key[10];
	unsigned char temp1,temp2;
	int MeidLen,PsnLen;
	int i,j;
	//PSN合法性检测
	if(PSN<150100000)return 0;
	//MEID合法性检测
	MeidLen=strlen(pMEID);
	//if(MeidLen!=14 && MeidLen!=15)return 0;	//MEID号长度必须为14或15

	if(MeidLen!=14 && MeidLen!=15){

				
	snprintf(aucPSN, sizeof(aucMEID),"%015lu",pMEID); //不够15位前面补零

}
	
	//PSN转字符串，不够10位的前面补'0'
	snprintf(aucPSN, sizeof(aucPSN),"%010lu",PSN);
	PsnLen=strlen(aucPSN);
	//取MEID的最后10个字符
	j=0;
	for(i=(MeidLen-10);i<MeidLen;i++){
		aucMEID[j]=pMEID[i];
		j++;
	}
	//所有字节进行相互异或运算，使每个字节的变化对整体结果都敏感
	temp1=0;
	temp2=0;
	for(i=0;i<10;i++){
		temp1^=(unsigned char)aucPSN[i];
		temp2^=(unsigned char)aucMEID[i];
	}
	temp1^=temp2;
	temp2=sucRandTable[temp1];
	//循环查表异或运算，生成key
	for(i=0;i<10;i++){
		temp1=aucPSN[i]^temp2;
		key[i]=aucMEID[i]^temp1;
		temp2=sucRandTable[temp1];
	}
	//取最后6个key,分别除10取余后再转Ascii，作为结果，结果为6个数字串,如"123456"
	j=0;
	for(i=4;i<10;i++){
		pCheckCode[j]=key[i]%10;
		pCheckCode[j]+=0x30;
		j++;
	}
	pCheckCode[6]=0; //结束符,方便调试打印和语音播报。
	return 1;
}

//使用12位唯一ID生成唯一7位(14位)鉴权码
void makeAuthCode(unsigned char *auth)
{
  unsigned char i,temp1,temp2;
  unsigned char tempAuth[14]="hS";//前面设置成唯一的
	unsigned char srcId[12];
	GetSTM32ID(srcId);
	
  temp1=0;
  for(i=0;i<12;i++)
  {
    temp1 ^= srcId[i];
	  temp1 ^= i;
  }
  
  memcpy(&tempAuth[2], srcId, 12);
  for(i=0;i<14;i++)
  {
    temp2 = tempAuth[i] ^ sucRandTable[temp1];
    tempAuth[i] = temp1 ^ temp2;
  }
	//组合成7个字节内容
	AscStrToHexStr(tempAuth, auth);
}

/***************************************************************************
将数字串转Unicode编码，方便播报
pUnicode长度必须为pNum长度的8倍，否则内存溢出！
****************************************************************************/
void NumStrToUnicode(char *pNum,char *pUnicode)
{
	char temp[10];
	int i,j,len;
	len=strlen(pNum);
	snprintf(temp, sizeof(temp),"len=%d",len);
	SlwTrace(INF,temp,1);
	
	j=0;
	for(i=0;i<len;i++){
		pUnicode[j++]='3';
		pUnicode[j++]=pNum[i];
		pUnicode[j++]='0';
		pUnicode[j++]='0';
		
		if(i==(len-1))break;//最后一个不用加逗号‘,’
		//","
		pUnicode[j++]='2';
		pUnicode[j++]='0';
		pUnicode[j++]='0';
		pUnicode[j++]='0';
	}
	pUnicode[j]=0;
}

/**************************************************************
*ReportCheckCode
***************************************************************/
void ReportCheckCode(void)
{
	char temp[12];
	char buf[80];
	SpeakerEnable();
	//终端编号xxxx
	if(sutProductPara.PSN<150100000 || sutProductPara.PSN==0xffffffff){
		SlwTrace(INF,"PSN Error!",1);
		ModemSendAT("AT+ZTTS=1,\"C87EEF7A167FF7531995EF8B\"\r");//终端编号错误
		return;
	}
	//校验码xxxx
	if(GetCheckCodeByPsnMEID(temp,sutProductPara.PSN,sutProductPara.HARDID)){
		snprintf(buf, sizeof(buf),"CheckCode=%s",temp);
		SlwTrace(INF,buf,1);
		NumStrToUnicode(temp,buf);
		ModemSendAT("AT+ZTTS=1,\"21688C9A01782C00");//校验码,
		ModemSendAT(buf);
		ModemSendAT("\"\r");		
	}else{
		SlwTrace(INF,"CheckCode=NULL",1);
		ModemSendAT("AT+ZTTS=1,\"21688C9A0178B783D6533159258D\"\r");//校验码获取失败
	}
	IWDG_ReloadCounter();//喂狗
	os_dly_wait(100);
	IWDG_ReloadCounter();//喂狗
	os_dly_wait(100);
	IWDG_ReloadCounter();//喂狗
	os_dly_wait(100);
	IWDG_ReloadCounter();//喂狗
	
	//终端编码xxx
	snprintf(temp, sizeof(temp),"%lu",sutProductPara.PSN);
	snprintf(buf, sizeof(buf),"CheckCode=%s",temp);
	SlwTrace(INF,buf,1);
	NumStrToUnicode(temp,buf);
	ModemSendAT("AT+ZTTS=1,\"C87EEF7A167FF7532C00");//终端编码,
	ModemSendAT(buf);
	ModemSendAT("\"\r");	
}
/************************************************************************************
ResetModem
*************************************************************************************/
void ResetModem(void)
{
	//set modem reset
	MODEM_RESET_HIGH;
	os_dly_wait(100);
	MODEM_RESET_LOW;
	MODEM_PWRKEY_HIGH;
	os_dly_wait(100);
	MODEM_PWRKEY_LOW;
	//set uart3 reset
	Uart2Init();
}
/*************************************************************************************
*FingerDaemonfinger
*守护进程
*用于防止通讯模块死机，或者与通讯模块通讯的串口异常而重新启动模块或通讯驱动。
*用于防止GPS模块异常而重启GPS
*此函数需要确保每秒调用一次
入口参数
sutPocStatus.FirstLogined
sutPocStatus.PocLostCt
sutPocStatus.ModemPowerOn
sutPocStatus.ModemInactiveCt
g_iCSQ
**************************************************************************************/
void FingerDaemonfinger(void)
{

	IWDG_ReloadCounter();//喂狗
	if(modemInitReady==0) return;//模块未启动不防护
	if(g_ucModemTaskEn==0)return;
	if(BOOTDebug==1)return;
	if(sutPocStatus.ModemPowerOn==1){		
		if(++sutPocStatus.ModemInactiveCt>50){//等待时间50秒 4G模块重启后至少要15秒才能启动
			sutPocStatus.ModemInactiveCt=1;
			sutPocStatus.modemRstFlag=1;
			//长时间收不到串口消息，重启模块及串口驱动
			SlwTrace(INF,"ModemRecvTimeout!Reset Modem!",1);
		}
	}
	
//	//GPS守护
//	if(sutGpsInfo.isGpsWork>0){
//		if(++sutGpsInfo.GpsInactiveCt>10){
//			sutGpsInfo.GpsInactiveCt=0;
//			//复位GPS
//			GPSInit();
//			Uart3Init();
//			TSGpsDataInit();
//		}
//	}
}

/**************************************
*延时（带喂狗）
t 系统滴答为单位
***************************************/
void OsDelayTime(unsigned short t)
{
	int i;
	for(i=0;i<t;i++){
		os_dly_wait(1);
		IWDG_ReloadCounter();//喂狗
	}
}

//255.255.255.255
//-->0xff 0xff 0xff 0xff
unsigned char GetStringIP2Bytes(unsigned char *IPBytes,char *IPString)
{
	unsigned char len,i,segment,j;
	char *p;
	char temp[3];
	len = strlen(IPString);
	if(len<7 || len >15) return 1;
  segment=0;
	j=0;
	p=IPString;
	for(i=0;i<len;i++)
	{
	  if(IPString[i] == '.')
		{
			if(segment < 4) IPBytes[segment++] = atoi(p);
			else return 2;
			p=&IPString[i+1];
		}else if(IPString[i] < '0' || IPString[i] > '9') return 3;
	}
	if(segment < 5) IPBytes[segment++] = atoi(p);
	return 0;
}

void MakeStrEndByNewLine(char *str)
{//一定要以'\r'结尾
	unsigned short i;
	
	for(i=0;i<strlen(str);i++)
	{
		if(str[i] == '\r')
		{
			str[i]=0;
			return;
		}
	}
}

uint16_t StrUnicodeToAnsi(uint8_t *dest,uint16_t size,const char *src)
{
	//不需要转
}

uint16_t AnsiToStrUnicode(uint8_t *dest,uint16_t size,const char *src)
{
	//不需要转
}

//"3132" --> 0x31,0x32
void StrAsciiToHex(char *src, unsigned char *des)
{
	unsigned char temp[2],i;
	if(strlen(src)%2) return;
	
	while(0!=*src)
	{
		for(i=0;i<2;i++)
		{
			temp[i] = *src++;
			if(temp[i] >= '0' && temp[i] <= '9') temp[i] -= 0x30;
			else if(temp[i] >= 'A' && temp[i] <= 'F') temp[i] -= 0x37;
			else temp[i] -= 0x57;
		}
		temp[0] <<= 4;
		temp[0] &= 0xf0;
		*des++=temp[0]|temp[1];
	}
	*des=0;
}

void PrintBufferData(unsigned char *data, unsigned short length)
{
	unsigned short i;
	
	printf("Data[%d]:\r\n",length);
	
	for(i=0;i<length;i++) printf("%02x",data[i]);
	printf("\r\n");
}



const char *NetList[]={
		"AU",
		"4G",
		"3G",
		"2G",
		""	//必须以空字串为结束
	};
	
void PcMsgHandle2(char *msg)
{
	char buf[40];
	char len;
	char tempbuf[80];//80
	char CmdListNum=0;
	char flag=0;
	char i=0;
	const char *pCmd=NULL;
	char *pMsg=NULL;
	
	switch(atoi(&msg[1]))
	{
		
		case MCU_R_POC_RESTART:
				//ModemSendAT("AT+POC=513\r\n"); //
				os_dly_wait(20);
				PWR_EN_LOW;
		
			break;
		
		case MCU_R_CFG_MODE_STR:  //握手成功
				SlwTrace(INF,PC_Shake_hand_OK,1);//501
				g_uGtTaskEn=1;
			break;
		
		case MCU_R_SET_PARAM_STR: //上位机设置
			//>101&47.106.56.123&ctnet&4G&cn&cn&3225&1&1 
				StringCatByNumb(msg,1,buf);
				len=strlen(buf);
			if(len<1 || len>=40){
				SlwTrace(INF,"FAIL[IP Invalid]",1);
				break;	
			}
			strcpy(sutProductPara.PIP,buf); 
			
			StringCatByNumb(msg,2,buf);
				len=strlen(buf);
			if(len<1 || len>=40){
				SlwTrace(INF,"FAIL[APN Invalid]",1);
				break;	
			}
			strncpy(sutProductPara.APNApn,buf,sizeof(sutProductPara.APNApn));
			
			StringCatByNumb(msg,3,buf);
				len=strlen(buf);
				if(len<2 || len>=40){
				SlwTrace(INF,"FAIL[NET_MODE Invalid]",1);
				break;	
			}
			strncpy(sutProductPara.Net_Mode,buf,sizeof(sutProductPara.Net_Mode));
			
			while(*NetList[CmdListNum++]);
			for(i=0;i<CmdListNum;i++){
				pCmd=NetList[i];
				pMsg=buf;
				flag=0;
				//j=0;
				while(*pCmd){
					if(*pCmd!=*pMsg){
						flag=1;
						break;
					}
					pCmd++;
						pMsg++;
				//	j++;
				}
				if(!flag){
					break;	
				}	
			}
			
			if(sutProductPara.Netmode!=i){
				sutProductPara.Netmode=i;
				snprintf(buf,sizeof(buf),"at+zsnte=%d\r\n",MododrxTable[sutProductPara.Netmode]);
				ModemSendAT(buf);
			}
			StringCatByNumb(msg,4,buf);
				len=strlen(buf);
			if(len<2 || len>=40){
				SlwTrace(INF,"FAIL[LANGUAGE Invalid]",1);
				break;			
			}
			strncpy(sutProductPara.Language,buf,sizeof(sutProductPara.Language));
				StringCatByNumb(msg,5,buf);
				len=strlen(buf);
			if(len<2 || len>=40){
				SlwTrace(INF,"FAIL[Local Invalid]",1);
				break;			
			}
			strncpy(sutProductPara.Local,buf,sizeof(sutProductPara.Local));
			
				StringCatByNumb(msg,6,buf);
				len=strlen(buf);
			if(len<2 || len>=40){
				SlwTrace(INF,"FAIL[Channel Invalid]",1);
				break;			
			}
			strncpy(sutProductPara.Channel,buf,sizeof(sutProductPara.Channel));
			
			StringCatByNumb(msg,7,buf);
			sutProductPara.SendToneEnadble=atoi(buf);

			StringCatByNumb(msg,8,buf);
			sutProductPara.RecvToneEnadble=atoi(buf);
			
			StringCatByNumb(msg,9,buf);
			sutProductPara.PromptToneEnable=atoi(buf);
			
			StringCatByNumb(msg,10,buf);
				len=strlen(buf);
			if(len<2 || len>=40){
				SlwTrace(INF,"FAIL[IMEI Invalid]",1);
				break;			
			}
			strncpy(sutProductPara.IMEI,buf,sizeof(sutProductPara.IMEI));

			SaveProductParaToFlash("COM-APN");
			
			os_dly_wait(10);
			SlwTrace(INF,PC_SETOK,0);//应答
			
			break;
			
		case MCU_R_GET_PARAM_STR: //读取
			//IP&APN&net_mode&language&local&channel&LeadToneEnable&PromptToneEnable&imei

		ReadFlashData(MAIN_CONFIG_ADDR,(unsigned char *)&sutProductPara,sizeof(SUT_PRODUCT_PARA));
		printf("sutProductPara.LCDSetIndex=%s\r\n",sutProductPara.IMEI);
		//2、读取备份参数
		ReadFlashData(BACKUP_CONFIG_ADDR,(unsigned char *)&sutProductPara,sizeof(SUT_PRODUCT_PARA));
		printf("backupPara.LCDSetIndex=%s\r\n",sutProductPara.IMEI);
		
		snprintf(tempbuf,sizeof(tempbuf),"AT+POC=504&%s&%s&%s&%s&%s&%s&%d&%d&%d&%s\r\n",sutProductPara.PIP,sutProductPara.APNApn,NetList[sutProductPara.Netmode] \
		,sutProductPara.Language,sutProductPara.Local,sutProductPara.Channel,sutProductPara.SendToneEnadble,sutProductPara.RecvToneEnadble,sutProductPara.PromptToneEnable,sutProductPara.IMEI);
		SlwTrace(INF,tempbuf,0);
		break;
	}

}


void MCU_FACTORY_RECOGNIZE()//单片机兼容
{
	/*
		0xE00F FFD0    05
		0xE00F FFE0    9b
		0xE00F FFE4    52
		0xE00F FFE8    05 HK     0a ST
	
	*/

	unsigned int temp=0;
	unsigned int RecognizeNumb=0;
//	temp=*(vu32*)0xE00FFFD0;
//	printf("temp1======%08x\r\n",temp);
//	RecognizeNumb=temp<<6;
//	temp=*(vu32*)0xE00FFFE0<<4;
//	printf("temp2======%08x\r\n",temp);
//	RecognizeNumb|=temp;
//	temp=*(vu32*)0xE00FFFE4<<2;
//	printf("temp3======%08x\r\n",temp);
//	RecognizeNumb|=temp;
	RecognizeNumb=*(vu32*)0xE00FFFE8;

	if(RecognizeNumb==0x0a){
		Mcu_Type=MCU_ST;
		printf("Mcu_Type iS ST----\r\n");
	}else if(RecognizeNumb==0x05){
		Mcu_Type=MCU_HK;
		printf("Mcu_Type iS HK----\r\n");
	}else {
		printf("Mcu_Type ---UNKNOWN\r\n");
	}
	
    //return *(vu32*)faddr; 
}