//======================================================================
//文件名称：main.c（应用工程主函数）
//框架提供：SD-Arm（sumcu.suda.edu.cn）
//版本更新：20191108-20200419
//功能描述：见本工程的..\01_Doc\Readme.txt
//移植规则：【固定】
//======================================================================
#define GLOBLE_VAR
#include "includes.h"      //包含总头文件

//----------------------------------------------------------------------
//声明使用到的内部函数
//main.c使用的内部函数声明处
//main.c使用的内部函数声明处
void userData_init(UserData *data);   //初始化用户帧结构体data
void userData_get(UserData *data);    //给用户帧结构体data赋值
void LCD_Showfirst();                 //初始化LCD的显示，主要是标签
void ArrayCpy(uint8_t * dest,uint8_t*source,uint16_t len);
void main_Dly_ms(uint32_t ms);
void main_TimeStamp();
void comm_init();
void consrv_init();

//----------------------------------------------------------------------
//主函数，一般情况下可以认为程序从此开始运行（实际上有启动过程，参见书稿）
int main(void)
{
    //（1）启动部分（开头）======
    //（1.1）声明main函数使用的局部变量
    uint16_t mi,mj;                        //主程序使用到的16位循环变量

    int mTsi;                      //记录当前触摸按键次数
    uint8_t  mSendFlag;                 //发送数据标志位;1:发送;0:不发送
    uint8_t  mRetdata[100];              //存放uecom初始化返回的结果
    uint16_t mUserLen;                  //需要发送的字节长度
    uint16_t mFlashLen;                 //需要存储flash的字节长度
    uint64_t mRecvCount;                //收到的次数
    uint8_t mString[30];                //数字转文本使用的临时数组
    uint8_t mCmd[2];                    //存储命令
    uint8_t mflag;               //主循环使用的标志判断变量
    uint8_t mWriteFlashFlag;          //表明是否需要将数据写入flash
    int mLCD_RefreshFlag;   //LCD显示刷新标志
    uint8_t  mSendData[1000];     //待发送数据缓冲区
    uint16_t mSendLen;           //待发送数据的长度
    uint8_t  mLBS[30];           //存储LBS定位信息
    uint16_t  mSendFreq;
    uint16_t  mSendFreqOld;

    //（1.2）


    //（1.3）【不变】关总中断
    DISABLE_INTERRUPTS;
     //（1.4）给全局变量赋初值
    mTsi=0;                            //清空触摸按键次数
    mSendFlag = 1;                     //默认终端发送数据
    mWriteFlashFlag = 0;                    //默认不写入flash
    mUserLen = sizeof(UserData);      //获得需要发送的字节长度
    mFlashLen = sizeof(FlashData);    //获得存入flash的字节长度
    mRecvCount = 0;                    //清空接收次数

    mLCD_RefreshFlag=0;   //LCD显示刷新标志
    mSendLen=0;

    mSendFreq=0;
    mSendFreqOld=0;

    //（1.5）给全局变量赋初值
    ArrayCpy(gTimeString,(uint8_t *)"0000-00-00 00:00:00\0",20);
    gCount=0;
    gUserData.touchNum=0;
    //（1.6）用户外设模块初始化
    gpio_init(LIGHT_RED,GPIO_OUTPUT,LIGHT_ON);    //初始化红灯
    gpio_init(LIGHT_BLUE,GPIO_OUTPUT,LIGHT_OFF);    //初始化红灯
    gpio_init(GPIO_TSI,GPIO_INPUT,1);             //GPIO模拟触摸
    uart_init(UART_UE,115200);                    //用户串口初始化
    uart_init(UART_Debug,115200);
    timer_init(TIMER_USER,20);                    //LPTMR计时器初始化为500毫秒
    flash_init();                                 //初始化flash
    LCD_Init();                                   //初始化LCD
    adc_init(AD_LIGHT,0);                 		   //初始化AD光照模块
    adc_init(AD_MCU_TEMP,0);					   //初始化AD芯片温度模块

    printf("AHL-IoT-GEC start...  \n");
    //【画瓢处1】-初始化

	//（1.7）使能模块中断
	timer_enable_int(TIMER_USER);                //使能LPTMR中断
	uart_enable_re_int(UART_Debug);

	//（1.8）【不变】开总中断
	ENABLE_INTERRUPTS;

	//（1.9）【根据实际需要增删】 主循环前的初始化操作
	//向Flash最后一个扇区写用户参数
	LCD_ShowString(6,300,BLUE,GRAY,    "flash_erase and write... ");
	printf("flash_erase and write...        \r\n");
	flash_erase(MCU_SECTOR_NUM-1);    //擦除最后一个扇区
	flash_write((MCU_SECTOR_NUM-1),28,sizeof(FlashData),(uint8_t *)flashInit);  //向最后一个扇区写数据
	LCD_ShowString(6,300,BLUE,GRAY,    "flash_erase and write...OK ");
	printf("flash_erase and write...OK        \r\n");

	//（1.9.1）读取flash中的配置信息至gFlashData；初始化用户帧数据gUserData
	//读取Flash中126扇区的参数信息到gFlashData中
	flash_read_logic((uint8_t*)(&gFlashData),(MCU_SECTOR_NUM-1),28,sizeof(FlashData));
	userData_init(&gUserData);         //初始化用户帧结构体gUserData
	LCD_Showfirst();                   //LCD显示初始内容
	//（1.9.2）判断复位状态，并将复位状态数据存储到flash中（注意不影响原有数据）
	if (IS_POWERON_RESET)             //冷复位，置零
		gFlashData.resetCount = 0;
	else                              //热复位，则加1
	{
		gFlashData.resetCount++;
		flash_read_logic((uint8_t*)gcRecvBuf,(MCU_SECTOR_NUM-1),0,MCU_SECTORSIZE);
		flash_erase(MCU_SECTOR_NUM-1);
		ArrayCpy(((uint8_t*)gcRecvBuf+166),(uint8_t*)(gFlashData.resetCount),4);
		flash_write((MCU_SECTOR_NUM-1),0,MCU_SECTORSIZE,(uint8_t*)gcRecvBuf);
	}

	//（1.9.3）初始化通信模组，并在LCD上显示初始化过程
	comm_init();
	consrv_init();
	LCD_ShowString(6,300,BLUE,GRAY,    "AHL Init                    ");
	printf("\r\nAHL Init                    \r\n");
	for(;;)
	{
		if (gcRecvLen<=0)   goto Send_Procedure_Branch;
		else goto PostBack_Procedure_Branch;



		Send_Procedure_Branch:
			for(int i = 0; i < 4133394; i++) continue;
			mSendFreq++;
			LCD_ShowString(49,209,BLUE,GRAY,(char *)gTimeString);
			gpio_reverse(LIGHT_RED);
			if (mSendFreq-mSendFreqOld>=30)
			{
				mSendFreqOld=mSendFreq;
				mSendFlag = 1;                         //发送标志置1；
				printf("\r\n%d 秒时间到，发送一帧数据！\r\n",30);
			}
			mj=0;
			for (mi=0;mi<3000;mi++)
			mj=mj+gpio_get(GPIO_TSI);
			if (mj<2000)
			{
				mTsi++;
				printf("\r\n触摸次数 = %d\r\n", mTsi);
				LCD_ShowString(40,189,BLUE,GRAY,(char *)IntConvertToStr(mTsi,mString));
				if ((mTsi-gUserData.touchNum)>=3)
				{
					mSendFlag = 1;
					printf("\r\n触摸三次，发送一帧数据！\r\n");
					gUserData.touchNum=mTsi;
					printf("\r\n触摸次数 ============= %d\n", mTsi);
				}
			}
			if(mSendFlag == 1)
			{
				userData_get(&gUserData);
				//（2.3.2）根据命令，获得需要发送的数据
				if(gFlashData.frameCmd[0]=='U'&&gFlashData.frameCmd[1]=='0')
				{
					mSendLen = mUserLen;
					ArrayCpy(gUserData.cmd,gFlashData.frameCmd,2);
					ArrayCpy(mSendData,(uint8_t *)&gUserData,mSendLen);
				}
				else if(gFlashData.frameCmd[0]=='U'&&gFlashData.frameCmd[1]=='1')
				{
					ArrayCpy(mSendData,gFlashData.frameCmd,2);
					ArrayCpy(mSendData+2,gUserData.IMSI,15);
					//【20200816】
					main_TimeStamp();   //给gUserData.currentTime赋值

					ArrayCpy(mSendData+17,(uint8_t *)&gUserData.currentTime,8);

					ArrayCpy(mSendData+25,(uint8_t *)&gUserData.mcuTemp,4);
					ArrayCpy(mSendData+29,(uint8_t *)&gUserData.signalPower,1);
					ArrayCpy(mSendData+30,(uint8_t *)&gUserData.bright,2);
					ArrayCpy(mSendData+32,(uint8_t *)&gUserData.touchNum,2);
					ArrayCpy(mSendData+34,gUserData.lbs_location,25);
				}
				mflag = wifi_sendN(mSendData,mSendLen,gUserData.IMSI);
				if(!mflag)
				{
					LCD_ShowString(6,300,BLUE,GRAY,(char *)"WiFi Send Successfully       ");
					printf("\r\nWiFi Send Successfully\r\n");
				}
			}
			goto Send_ClearMark_Procedure_Branch;
		PostBack_Procedure_Branch:
			mRecvCount++;
			mflag = 0xff;
			mSendLen = 0;
			mWriteFlashFlag = 0;
			mLCD_RefreshFlag=1;
			LCD_ShowString(6,300,BLUE,GRAY,"AHL Recv one frame          ");
			printf("\r\n收到一帧\n");
			ArrayCpy(mCmd,gcRecvBuf,2);
			ArrayCpy(mSendData,gcRecvBuf,2);
			if(mCmd[0]=='A')        	//读取flash中的信息
			{
				if(mCmd[1]=='0')		//读取flash中的所有信息
				{
					mSendLen = mFlashLen+2;
					ArrayCpy(mSendData+2,(uint8_t*)(&gFlashData),mFlashLen);
				}
				else if(mCmd[1]=='1')	//读取flash中的产品信息
				{
					mSendLen = 145;
					ArrayCpy(mSendData+2,gFlashData.equipName,mSendLen-2);
				}
				else if(mCmd[1]=='2')	//读取flash中的服务器信息
				{
					mSendLen = 22;
					ArrayCpy(mSendData+2,gFlashData.serverIP,mSendLen-2);
				}
				else if(mCmd[1]=='3')	//读取用户存入flash的信息
				{
					mSendLen = 10;
					ArrayCpy(mSendData+2,(uint8_t*)(&gFlashData.sendFrequencySec),mSendLen-2);
				}
			}
			else if(mCmd[0]=='B')   	//更改flash中的信息
			{
				if(mCmd[1]=='0')		//更改flash中的所有信息
				{
					ArrayCpy((uint8_t *)(gFlashData.equipName),(uint8_t*)&(gcRecvBuf[2]),mFlashLen);
					mWriteFlashFlag = 1;
					mSendLen = 9;
					ArrayCpy((uint8_t *)mSendData+2,(uint8_t *)"success",mSendLen-2);
				}
				else if(mCmd[1]=='1')	//更改flash中的产品信息
				{
					ArrayCpy((uint8_t *)(gFlashData.equipName),(uint8_t*)&(gcRecvBuf[2]),124);
					mWriteFlashFlag = 1;
					mSendLen = 9;
					ArrayCpy((uint8_t *)mSendData+2,(uint8_t *)"success",mSendLen-2);
				}
				else if(mCmd[1]=='2')	//更改flash中的服务器信息
				{
					ArrayCpy((uint8_t *)(gFlashData.serverIP),(uint8_t*)&(gcRecvBuf[2]),30);
					mWriteFlashFlag = 1;
					mSendLen = 9;
					ArrayCpy((uint8_t *)mSendData+2,(uint8_t *)"success",mSendLen-2);
				}
				else if(mCmd[1]=='3')	//更改用户存入flash的信息
				{
					ArrayCpy((uint8_t *)(&gFlashData.sendFrequencySec),(uint8_t*)&(gcRecvBuf[2]),8);
					mWriteFlashFlag = 1;
					mSendLen = 9;
					ArrayCpy((uint8_t *)mSendData+2,(uint8_t *)"success",mSendLen-2);
				}
			}
			else if(mCmd[0]=='U')
			{
				if(mCmd[1]=='0')		//获取“U0”命令要发送的数据
				{
					ArrayCpy(gFlashData.frameCmd,mCmd,2);
					if(gcRecvLen == mUserLen)       //若为整帧数据
					{
						mSendLen = gcRecvLen;
						mWriteFlashFlag  =1;
						ArrayCpy((uint8_t*)(&gUserData),gcRecvBuf,mUserLen);
						ArrayCpy(gFlashData.equipName,gUserData.equipName,30);
						ArrayCpy(gFlashData.equipID,gUserData.equipID,20);
						ArrayCpy(gFlashData.equipType,gUserData.equipType,20);
						ArrayCpy(gFlashData.vendor,gUserData.vendor,30);
						ArrayCpy(gFlashData.userName,gUserData.userName,20);
						ArrayCpy(gFlashData.phone,gUserData.phone,11);
						ArrayCpy(gFlashData.serverIP,gUserData.serverIP,15);
						ArrayCpy(gFlashData.serverPort,gUserData.serverPort,5);
						gFlashData.sendFrequencySec = gUserData.sendFrequencySec;
						gFlashData.resetCount = gUserData.resetCount;
						ArrayCpy(gFlashData.frameCmd,gUserData.cmd,2);
						//【画瓢处2】-执行操作
						if(strcmp((char*)gUserData.surplusInfo,(char*)"LIGHT_ON") == 0)
						{
							gpio_set(LIGHT_BLUE,LIGHT_ON);
							printf("LIGHT_ON");
						}
						else if(strcmp((char*)gUserData.surplusInfo,(char*)"LIGHT_OFF") == 0)
						{
							gpio_set(LIGHT_BLUE,LIGHT_OFF);
							printf("LIGHT_OFF");
						}
						else
						{

						}

					}
				}
				if(mCmd[1]=='1')		//获取“U1”命令要发送的数据
				{
					if(gcRecvLen == 59)
					{
						ArrayCpy(gUserData.cmd,gcRecvBuf,2);
						ArrayCpy(gUserData.IMSI,gcRecvBuf+2,15);
						ArrayCpy((uint8_t *)&gUserData.currentTime,gcRecvBuf+17,8);
						ArrayCpy((uint8_t *)&gUserData.mcuTemp,gcRecvBuf+25,4);
						ArrayCpy((uint8_t *)&gUserData.signalPower,gcRecvBuf+29,1);
						ArrayCpy((uint8_t *)&gUserData.bright,gcRecvBuf+30,2);
						ArrayCpy((uint8_t *)&gUserData.touchNum,gcRecvBuf+32,2);
						ArrayCpy(gUserData.lbs_location,gcRecvBuf+34,25);
					}
				}
			}

			if (mSendLen>0)                      //若有需要发送的数据
			{
				mflag = wifi_sendN(mSendData,mSendLen,gUserData.IMSI);
			}
			gcRecvLen = 0;                    //接收数据长度清零，表明已经读取
			if(mflag==0)
				LCD_ShowString(6,300,BLUE,GRAY,"AHL Reply Successfully      ");
			else if(mflag == 0xff)
				LCD_ShowString(6,300,BLUE,GRAY,"AHL Recv Successfully       ");
			else
				LCD_ShowString(6,300,BLUE,GRAY,"Send Error:Send Data Not OK ");
			 //判断是否需要写flash
			 if(mWriteFlashFlag == 1)
			 {
				   flash_read_logic((uint8_t*)gcRecvBuf,(MCU_SECTOR_NUM-1),0,MCU_SECTORSIZE);
				   flash_erase(MCU_SECTOR_NUM-1);
				   ArrayCpy(((uint8_t*)gcRecvBuf+28),(uint8_t*)(&gFlashData),mFlashLen);
				   flash_write((MCU_SECTOR_NUM-1),0,MCU_SECTORSIZE,(uint8_t*)gcRecvBuf);

				mWriteFlashFlag = 0;
			 }
			//
			if (mLCD_RefreshFlag==1)
			{
				LCD_Showfirst();                //更新LCD上的显示
				mLCD_RefreshFlag=0;
				//补充显示显示设备的IMSI号、基站位置信息、接收次数
				LCD_ShowString(60,85,BLUE,GRAY,(char *)mRetdata+20);
				LCD_ShowString(60,131,BLUE,GRAY,(char *)mLBS);  //基站位置
				LCD_ShowString(90,251,BLUE,GRAY,(char *)IntConvertToStr(mRecvCount,mString));
			}
		Send_ClearMark_Procedure_Branch:
			mSendFlag = 0;                       //修改发送标记
			mSendLen=0;
	}        //图形化编程之主循环流程扫描分支添加处【Graphic12】*/
}   //main函数（结尾）


//======以下为主函数调用的子函数===========================================
//=====================================================================
//函数名称：userData_init
//函数返回：无
//参数说明：data：需要初始化的结构体数据
//功能概要：初始化用户帧结构体data
//=====================================================================
void userData_init(UserData *data)            //初始化用户帧结构体
{
    uint8_t mString[10];
    ArrayCpy(data->cmd,(uint8_t *)"U0",2);
    ArrayCpy(gFlashData.frameCmd,data->cmd,2);
    ArrayCpy(data->IMSI,(uint8_t*)"000001234567890",15);
    data->sn = 0;
    ArrayCpy(data->serverIP,gFlashData.serverIP,15);
    ArrayCpy(data->serverPort,gFlashData.serverPort,5);
    data->currentTime = gFlashData.productTime;
    data->resetCount = gFlashData.resetCount;
    data->sendFrequencySec = gFlashData.sendFrequencySec;
    ArrayCpy(data->userName,gFlashData.userName,20);
    //[2018.8.18] 发送的软件版本取BIOS
    uecom_version(mString);//??????????????????????
    ArrayCpy(data->softVer,mString,4);
    ArrayCpy(data->equipName,gFlashData.equipName,30);
    ArrayCpy(data->equipID,gFlashData.equipID,20);
    ArrayCpy(data->equipType,gFlashData.equipType,20);
    ArrayCpy(data->vendor,gFlashData.vendor,30);
    ArrayCpy(data->phone,gFlashData.phone,11);
    data->touchNum = 0;
    ArrayCpy(data->cmd,gFlashData.frameCmd,2);
    //【画瓢处2】-初始化数据

}

//=====================================================================
//函数名称：userData_get
//函数返回：无
//参数说明：data：需要赋值的结构体数据
//功能概要：给用户帧结构体data赋值
//=====================================================================
void userData_get(UserData *data)             //给用户帧结构体data赋值
{
    uint16_t brightAD,mcu_temp_AD;
	char mStr[6];
	float mcu_temp;

    static uint32_t sn = 0;
    data->sn = sn++;
    //获取mcu温度
    mcu_temp_AD = adc_read(AD_MCU_TEMP);       //读取mcu温度通道AD值
    mcu_temp=TempTrans(mcu_temp_AD);           //温度回归
    LCD_ShowString(150,105,BLUE,GRAY,(char *)FloatConvertToStr(mcu_temp,1,mStr));  //LCD上显示芯片温度

    data->mcuTemp =(int32_t) (mcu_temp*10);
    printf("\r\n");
    //获取光照强度
    brightAD = adc_read(AD_LIGHT);
    data->bright = brightAD;
    main_TimeStamp();   //给gUserData.currentTime赋值

    //【画瓢处1】-数据获取


}

//=====================================================================
//函数名称：LCD_Showfirst
//函数返回：无
//参数说明：无
//功能概要：初始化LCD上电显示的内容
//=====================================================================
void LCD_Showfirst()
{
    uint8_t temp[30] = {0};
    //uint8_t tempertature[6];

    //（1）设置全局底色为灰色
    LCD_DrawSurface(0,0,240,320,GRAY);    //240*320像素LCD
    //（2）设置第一区（标题区）
    LCD_aotu(2,2,238,38,1);               //LCD指定区域凸起
    LCD_ShowString(66,15,RED,GRAY,"金葫芦IoT-GEC"); //红字
    //（3）设置第二区（与通信无关区）
    LCD_aotu(2,43,238,123,0);             //LCD指定区域凹下
    //显示型号
    LCD_ShowString(6,45,BLACK,GRAY,"[Type]                     ");
    uecom_typeGet(temp);
    temp[20]=0;
    LCD_ShowString(60,45,BLUE,GRAY,(char *)temp);
    //显示BIOS软件版本
    LCD_ShowString(6,65,BLACK,GRAY,"[BIOS_VER]                  ");
    uecom_version(temp);   //取uecom版本号（作为BIOS版本号）
    LCD_ShowString(88,65,BLUE,GRAY,(char *)temp);   //显示BIOS软件版本
    //显示user软件版本
    LCD_ShowString(120,65,BLACK,GRAY,"[USER_VER]    ");
    ArrayCpy(temp,gFlashData.softVer,4);
    temp[5]=0;
    LCD_ShowString(200,65,BLUE,GRAY,(char *)temp);
    LCD_ShowString(6,85,BLACK,GRAY,"[IMSI]                      ");
    //显示MCU温度
    LCD_ShowString(6,105,BLACK,GRAY,"[MCU_temperature]           ");

    //（4）设置第三区（与通信相关）
    LCD_aotu(2,127,238,228,1);            //LCD指定区域凸起
    LCD_ShowString(6,131,BLACK,GRAY,"[LBS]                      ");
    LCD_ShowString(6,149,BLACK,GRAY,"[Signal strength(%)]       ");
    //显示IP:PT (IP:PORT)
    LCD_ShowString(6,169,BLACK,GRAY,"[IP:PT]                    ");
    ArrayCpy(temp,gFlashData.serverIP,15);   //IP
    temp[15]=0;
    LCD_ShowString(65,169,BLUE,GRAY,(char *)temp);
    LCD_ShowString(185,169,BLUE,GRAY,":");//PORT
    ArrayCpy(temp,gFlashData.serverPort,5);
    temp[5]=0;
    LCD_ShowString(195,169,BLUE,GRAY,(char *)temp);
    //显示发送频率
    LCD_ShowString(6,189,BLACK,GRAY,"TSI:       Freq(s):        ");
    LCD_ShowString(180,189,BLUE,GRAY,"      ");
    LCD_ShowString(180,189,BLUE,GRAY,
    		(char *)IntConvertToStr(gFlashData.sendFrequencySec,temp));
    LCD_ShowString(40,189,BLUE,GRAY,"0"); //显示TSI次数初值0
    LCD_ShowString(6,209,BLACK,GRAY,"Time:                      ");
    LCD_ShowString(49,209,BLUE,GRAY,"0000-00-00 00:00:00" );
    LCD_aotu(2,232,238,271,0);            //LCD指定区域凹下
    LCD_ShowString(6,235,BLACK,GRAY,"Reserved area,you can use it");
    LCD_ShowString(6,253,BLACK,GRAY,"RecvCount:                 ");
    //（5）设置第四区（运行状态显示区）
    LCD_aotu(2,275,238,317,1);            //LCD指定区域凸起
    LCD_ShowString(6,278,BLACK,GRAY,"Run State:                 ");
}
//图形化编程之main文件子函数添加处【Graphic13】


//=====================================================================
//函数名称：ArrayCpy
//函数返回：无
//参数说明：dest：复制后存放的数组；source：被复制的数组；len:复制的长度
//功能概要：从源数组复制指定长度的内容到目标数组
//=====================================================================
void ArrayCpy(uint8_t * dest,uint8_t*source,uint16_t len)
{
	for(uint16_t r=0;r<len;r++)  dest[r]=source[r];
}

void main_Dly_ms(uint32_t ms)
{
	for(uint32_t i= 0; i < (4800*ms); i++) __asm("nop");
}

void  main_TimeStamp()
{
	//年月日时分秒 十进制
	uint16_t tyear,tmonth,tday,thour,tmin,tsec;
	uint16_t i;
	uint64_t timestamp;	    //时间戳
	uint8_t st[20];
	//每月份之前的天数，闰年另计
	uint16_t MonthDay[12]={31,59,90,120,151,181,212,243,273,304,334,365};
	timestamp=0;
	//将年份化为十进制
	for (i=0;i<=3;i++) st[i]=gTimeString[i]-0x30;
	tyear=st[0]*1000+st[1]*100+st[2]*10+st[3];
	//将月份化为十进制
	for (i=5;i<=6;i++) st[i]=gTimeString[i]-0x30;
	tmonth=st[5]*10+st[6];
	//将天化为十进制
	for (i=8;i<=9;i++) st[i]=gTimeString[i]-0x30;
	tday=st[8]*10+st[9];
	//将时化为十进制
	for (i=11;i<=12;i++) st[i]=gTimeString[i]-0x30;
	thour=st[11]*10+st[12];
	//将分化为十进制
	for (i=14;i<=15;i++) st[i]=gTimeString[i]-0x30;
	tmin=st[14]*10+st[15];
	//将秒化为十进制
	for (i=17;i<=18;i++) st[i]=gTimeString[i]-0x30;
	tsec=st[17]*10+st[18];
	//计算之前年份的秒数
	for(i=1970;i<tyear;i++)
	{
		if(i%4)
			timestamp+=31536000;

		else
			timestamp+=31622400;
	}
	//计算之前月份的秒数
	if(tmonth>12) return;
	if(tmonth>2 && tyear%4)
		timestamp+=MonthDay[tmonth-2]*24*3600;
	else if(tmonth>2 && (tyear%4==0))
		timestamp+=(MonthDay[tmonth-2]+1)*24*3600;
	else if(tmonth==2)
		timestamp+=31*24*3600;
	else
		timestamp+=0;
	//计算当前天的秒数
	if(tday>1) timestamp+=(tday-1)*24*3600;
	timestamp+=(thour*3600)+(tmin*60)+tsec;
    gUserData.currentTime=timestamp;

}

void comm_init()
{
    wifi_reset();
	for(;;)
	{
		if(wifi_quitssid() == WIFI_OK)
		{
			break;
		}
		printf("WiFi Quitting...\r\n");
	}
	printf("WiFi Quitted...\r\n");
	main_Dly_ms(4000);
    for(;;)
    {
        if(wifi_linktossid((uint8_t*)"zhouruiqi",(uint8_t*)"zhouruiqi")==WIFI_OK)
        {
        	break;
        }
        printf("WiFi Initing...\r\n");
    }
    printf("WiFi Initted...\r\n");
    main_Dly_ms(4000);
}

void consrv_init()
{
	for(;;)
	{
		if(wifi_disconnect() == WIFI_OK)
		{
			break;
		}
		printf("WiFi Disconnecting...\r\n");
	}
	printf("WiFi Disconnectted...\r\n");
	main_Dly_ms(1000);
	for(;;)
	{
		if(wifi_con_srv((uint8_t*)"192.168.137.1",(uint8_t*)"35000")==WIFI_OK)
		{
			break;
		}
		printf("WiFi Connecting...\r\n");
	}
	printf("WiFi Connectted...\r\n");
	main_Dly_ms(1000);
}

//========================================================================
/*
 知识要素：
 （1）main.c是一个模板，该文件所有代码均不涉及具体的硬件和环境，通过调用构件
      实现对硬件的干预。
 （2）本文件中对宏GLOBLE_VAR进行了定义，所以在包含"includes.h"头文件时，会定
      义全局变量，在其他文件中包含"includes.h"头文件时，
      编译时会自动增加extern
 */
