/*
*********************************************************************************************************
*                                       IAR Development Kits
*                                              on the
*
*                                    M451
*
* Filename      : uart_dtu.c
* Version       : V1.00
* Programmer(s) : Qian Xianghong
*********************************************************************************************************
*/

#include  "includes.h"

#include "drv_dtu.h"
#include "drv_gps.h"

// ³õʼ»½ÐÑ´ÎÊý(¿ìËÙ·¢ËÍ£©
#define INITIAL_TRAN_COUNT 6

// ¾ø¶ÔÖµ
#define abs(x) ((x) < 0 ? -(x) : (x))

// GPSÉϱ¨Êý¾ÝµÄʱ¼ä´Á£¬Äê»ùÊýΪ2010
#define GPS_BASE_YEAR	2010

// Boot-loaderµØÖ·£¨ÔÚÏßÉý¼¶ÒÔºóÖØÆôÔËÐУ©
#define LDROM_BASE			0x100000ul	// 1M

// GPRS´®¿Ú½ÓÊÕµÄÑ­»·»º³å
#define DTU_TASKM_DATA_COUNT 200
loopbuff_t DTU_TaskM;
uint8_t DTU_TaskM_Data[sizeof(uint8_t) * (DTU_TASKM_DATA_COUNT + 1)] = {0};

// ά»¤Æ½Ì¨Á¬½Ó¼Æʱ
volatile uint32_t DTU_ldmsTime = 0;
// ×î½üÒ»ÌõÉÏ´«Êý¾ÝµÄ²É¼¯Ê±¼ä
volatile uint32_t DTU_dataTime = 0;
// ·¢Ëͳɹ¦Ê±¼ä
volatile uint32_t DTU_succTime = 0;

// Õâ¸ö»º³åÇø±È½Ï´ó£¬²»·ÅÔÚstackÀïÃæ
char DTU_gpsData[2][DTU_GPSDATA_SIZE] = {0}; // À©Õ¹ÄÚ´æ
char DTU_recvBuff[DTU_RECVBUFF_SIZE] = {0}; // À©Õ¹ÄÚ´æ

// Ò»´ÎÇëÇóÉý¼¶°üÊý¾Ý´óС
#define UPGRADE_DATA_LEN 1024

// DTU_TaskÈÎÎñºÍ·þÎñÆ÷Ö®¼äµÄÊÕ·¢»º³å
#define TASK_SENDBUFF_SIZE	400
uint8_t Task_sendBuff[TASK_SENDBUFF_SIZE] = {0}; // À©Õ¹ÄÚ´æ

#define TASK_RECVBUFF_SIZE	(UPGRADE_DATA_LEN + 32)
uint8_t Task_recvBuff[TASK_RECVBUFF_SIZE] = {0}; // À©Õ¹ÄÚ´æ

// ÐźÅÁ¿£¬ÓÃÓÚִ֪ͨÐÐÈÎÎñ
volatile uint8_t DTU_semGPS = 0;
volatile uint8_t DTU_semGPRS = 0;
volatile uint8_t DTU_semSync = 0;

// ÓÃÓÚ·¢Ë͵½·þÎñÆ÷µÄÊý¾Ý½á¹¹
// ºÍÀ¶ÑÀµÄÏàÓ¦ÃüÁîÒ»ÖÂ
#pragma pack(push, 1)

typedef struct
{
    uint16_t	mark;
    unsigned	ver : 7;
    unsigned	trans : 1;
    unsigned	reserved: 8;
    uint16_t	len;
    union
    {
        uint16_t	cmd;
        struct
        {
            uint8_t		err;
            uint8_t		cmd_L;
        };
    };
} bluetooth_recv_t;

typedef bluetooth_recv_t bluetooth_send_t;

typedef struct
{
    unsigned staEPress3 :	2;
    unsigned staETempr1 :	2;
    unsigned staETempr2 :	2;
    unsigned staETempr3 :	2;

    unsigned staDiff :		2;
    unsigned staPress :		2;
    unsigned staEPress1 :	2;
    unsigned staEPress2 :	2;

} bluetooth_sensor_t;

typedef struct
{
    unsigned maskStamp :	1;
    unsigned maskEPress1 :	1;
    unsigned maskEPress2 :	1;
    unsigned maskEPress3 :	1;
    unsigned  : 1;
    unsigned maskLowPower : 1;
    unsigned maskAbnormal :	1;
    unsigned maskCharging :	1;

    unsigned maskRssi :		1;
    unsigned maskGPS :		1;
    unsigned maskETempr1 :	1;
    unsigned maskETempr2 :	1;
    unsigned maskETempr3 :	1;
    unsigned maskBattery :	1;
    unsigned maskFlow :		1;
    unsigned maskLeak :		1;
} bluetooth_mask_t;

typedef union
{
    struct
    {
        unsigned sec : 6;
        unsigned min : 6;
        unsigned hour_L : 4;
        unsigned hour_H : 1;
        unsigned day : 5;
        unsigned mon : 4;
        unsigned year : 6;
    };
    uint32_t tm;
} bluetooth_timestamp_t;

typedef	union
{
    unsigned long long ll;
    struct
    {
        unsigned long l;
        unsigned long h;
    };
} longlong_mask_t;

typedef struct
{
    union
    {
        struct
        {
            unsigned sateCount : 5;		// gps¿É¼ûÎÀÐÇÊýÁ¿
            unsigned posState : 1;		// gps¶¨Î»×´Ì¬		£¨0-GPSδ¶¨Î»£¬1-GPSÒѶ¨Î»£©
            unsigned carState : 1;		// ³µÁ¾ÊÇ·ñÆô¶¯		£¨0-³µÁ¾Î´Æô¶¯£¬1-³µÁ¾ÒÑÆô¶¯£©
            unsigned carEvent : 1;		// ³µÁ¾Æô¶¯»òֹͣʼþ£¨0-Æô¶¯×´Ì¬Î´¸Ä±ä£¬1-Æô¶¯×´Ì¬ÒѸı䣩
        };
        uint8_t state;
    };
    bluetooth_timestamp_t 	time;	// ʱ¼ä´Á
    int32_t					latitude;
    int32_t					longitude;
    uint16_t 				speed;
} gps_data_t;

typedef struct	// size = 158
{
    uint32_t	sample_time;	// ²É¼¯Ê±¼ä£º×ÔÆô¶¯ÒÔÀ´¾­¹ýµÄÃëÊý
    data_dtu_t			dtuData;	// size = 36
    data_sample_t		sampleData; // size = 118
} gprs_data_t;

// Ë«ÏòͨѶµÄÊý¾Ý½á¹¹
typedef struct	// size = 120
{
    uint16_t	serverVer;	// ·þÎñÆ÷²ÎÊý°æ±¾ºÅ
    uint8_t		type;		// ´¢¹ÞÀàÐÍ
    uint32_t	diameter;	// ÄÚ¾¶
    uint32_t	len;		// Ô²ÖùÌ峤¶È
    uint32_t	lenExtra;	// Ö±±ß·âÍ·³¤¶È
    uint32_t	reserved_1[3];
    uint8_t		source;				// ÒºÔ´
    uint32_t	density;			// ¸÷ÒºÔ´µÄ±ÈÖØ£¨kg/m3)
    uint16_t	fullPct;			// ÂúҺλ°Ù·Ö±È
    uint16_t	priPct;				// ¹Ø¼üҺλ°Ù·Ö±È
    uint16_t	orderPct;			// ¶©»õҺλ°Ù·Ö±È
    uint16_t	emptyPct;			// ¿ÕҺλ°Ù·Ö±È
    uint32_t	planMount;			// ÿÈռƻ®ÓÃÁ¿
    uint32_t	predictMount;		// ÿÈÕÔ¤²âÓÃÁ¿
    uint16_t	warnVolt;			// µçѹ±¨¾¯µÍµã: 10mV
    uint16_t	warnVoltH;			// µçѹ±¨¾¯¸ßµã: 10mV
    uint16_t	warnPress;			// ѹÁ¦±¨¾¯µÍµã: KPa
    uint16_t	warnPressH;			// ѹÁ¦±¨¾¯¸ßµã: KPa
    uint32_t	intervalTrans;		// Êý¾ÝÉϱ¨ÖÜÆÚ
    uint32_t	intervalSample;		// Êý¾Ý²É¼¯ÖÜÆÚ
    uint32_t	intervalGPSTrans;	// λÖÃÉϱ¨ÖÜÆÚ
    uint32_t	intervalGPS;		// λÖòɼ¯ÖÜÆÚ
    union
    {
        struct
        {
            char		gpsServer[20];		// Ô¶´«·þÎñÆ÷	(Ö»ÉÏ´«£¬²»ÐÞ¸Ä)
            int16_t		gpsPort;			// Ô¶´«¶Ë¿Ú		(Ö»ÉÏ´«£¬²»ÐÞ¸Ä)
            char		pwd1[6];			// ´¢¹Þ²ÎÊýÐÞ¸ÄÃÜÂë
        };
        struct
        {
            char		gprsServer[26];		// praxair£ºÐÞ¸ÄÊý¾Ý·þÎñÆ÷µØÖ·
            int16_t		gprsPort;			// praxair: ÐÞ¸ÄÊý¾Ý·þÎñÆ÷¶Ë¿Ú
        };
    };
    uint32_t	options;			// ²ÎÊý¿ª¹Ø
    union
    {
        uint8_t		reserved_2[12];
        struct
        {
            uint16_t floorLevel;								// praxair: ÒºÁ¿±¨¾¯ÏÂÏÞ
            uint16_t span;											// praxair: ÒºÁ¿±ä»¯±¨¾¯ÃÅÏÞ
            uint16_t spanPeriod;								// praxair: ÒºÁ¿±ä»¯±¨¾¯Ê±¼ä
            unsigned floorLevelAssigned : 1;		// praxair: ²ÎÊýÖÐfloorLevelÊÇ·ñÓÐЧ
            unsigned spanAssigned : 1;					// praxair: ²ÎÊýÖÐspanÊÇ·ñÓÐЧ
            unsigned spanPeriodAssigned : 1;		// praxair: ²ÎÊýÖÐspanPeriodÊÇ·ñÓÐЧ
            unsigned intervalTransAssigned : 1;	// praxair: ²ÎÊýÖÐintervalTransÊÇ·ñÓÐЧ
            unsigned gprsServerAssigned : 1;		// praxair: ²ÎÊýÖÐÊý¾Ý·þÎñÆ÷µØÖ·ÊÇ·ñÓÐЧ
            unsigned gprsPortAssigned : 1;			// praxair: ²ÎÊýÖÐÊý¾Ý·þÎñÆ÷¶Ë¿ÚÊÇ·ñÓÐЧ
            unsigned : 2;
        };
    };
    uint32_t	ts;					// ²ÎÊýʱ¼ä´Á
} param_data_t;

// Éý¼¶½ø¶ÈÐÅÏ¢£¨´æ·ÅÔÚFRAMÖУ¬¿É¶ÏµãÐø´«£©
typedef struct
{
    uint16_t	check;		// ±êÖ¾£¬¹Ì¶¨Îª0x55AA
    uint32_t	ver;		// ¹Ì¼þ°æ±¾
    int32_t		fileSize;	// ¹Ì¼þ×Ü×Ö½ÚÊý
    uint16_t	fileCrc;	// ¹Ì¼þ×ܵÄcrc
    int32_t		offset;		// ±¾´Î¹Ì¼þÆ«ÒÆÁ¿
    int32_t 	len;		// ±¾´ÎÊý¾Ý³¤¶È
    uint16_t	crc;		// ±¾¼Ç¼µÄcrc
} upgrade_info_t;

// Éý¼¶°ü½ÓÊռǼ
typedef struct
{
    uint32_t	ver;		// ¹Ì¼þ°æ±¾
    int32_t		fileSize;	// ¹Ì¼þ×Ü×Ö½ÚÊý
    uint16_t	fileCrc;	// ¹Ì¼þ×ܵÄcrc
    int32_t		offset;		// ±¾´Î¹Ì¼þÆ«ÒÆÁ¿
    int32_t 	len;		// ±¾´ÎÊý¾Ý³¤¶È
    uint8_t		data[UPGRADE_DATA_LEN];		// ±¾´ÎÊý¾Ý
    uint16_t	crc;		// ±¾´ÎÊý¾ÝµÄcrc
} upgrade_frame_t;

// Éý¼¶ÎļþÍ·
typedef struct // size=12
{
    unsigned short check;			// Êý¾ÝÓÐЧ±êÖ¾, 0x55AA±íʾÓÐЧ
    unsigned upgrade_request : 1;	// Éý¼¶ÇëÇó±êÖ¾£¬0-ÎÞÉý¼¶£¬1-ÓÐÉý¼¶
    unsigned upgrade_result : 3;	// Éý¼¶Ê§°Ü±êÖ¾£¬0-³É¹¦£¬1-ʧ°Ü£¬ÆäÓà±£Áô
    unsigned encrypt_flag : 2;		// ¼ÓÃܱêÖ¾£¬ 0-ÎÞ¼ÓÃÜ£¬ÆäÓà±£Áô
    unsigned compress_flag : 2;		// ѹËõ±êÖ¾£¬ 0-ÎÞѹËõ£¬1-ÓÐѹËõ£¬ÆäÓà±£Áô
    unsigned rerseved1 : 8;			// ±£Áô£¬±ØÐëΪ0xFF

    unsigned long upgrade_length; 	// Éý¼¶Îļþ³¤¶È

    unsigned rerseved2 : 8;			// ±£Áô£¬±ØÐëΪ0xFF
    unsigned rerseved3 : 8;			// ±£Áô£¬±ØÐëΪ0xFF
    unsigned short crc;				// ¶ÔÇ°ÃæÄÚÈݵÄcrcУÑé
} TUpgradeHeader;

// °¢ÀïÔÆÃÜÔ¿¼Ç¼
typedef struct // size=76
{
    unsigned short check;			// Êý¾ÝÓÐЧ±êÖ¾, 0x55AA±íʾÓÐЧ
    uint8_t PSN[6];					// »ñÈ¡ÃÜÔ¿ËùÓõÄPSN£¨Èç¹ûPSN¸Ä±äÐèÖØлñÈ¡£©
    char product[12];				// ²úÆ·´úÂë
    char device[21];				// ĬÈÏΪcPSN
    char secret[33];				// É豸ÃÜÔ¿
    unsigned short crc;				// ¶ÔÇ°ÃæÄÚÈݵÄcrcУÑé
} TAliyunSecret;

#define ALIYUN_SECRET_SIZE (66)

#pragma pack(pop)

// °¢ÀïÔÆÃÜÔ¿
TAliyunSecret aliyunSecret = {0};

// Éý¼¶°ü¼Ç¼
upgrade_info_t upInfo = {0};

// GPSÑ­»·»º³å¼Ç¼
loopbuff_t gpsBuff = {0};

// ´æ·ÅGPRS¼Ç¼µÄÑ­»·»º³å
loopbuff_t gprsBuff = {0};
loopbuff_t bd_gprsBuff = {0};
// GPRS¼Ç¼¶Áд»º³å
gprs_data_t gprsRWBuf;


/**
 * @brief ?????,?????????
 */
struct reportInf_t {
    uint32_t lastTime;	//!< ?????????
    uint32_t nextTime;	//!< ??????????
    uint32_t redoTime;	//!< ????????????
    uint8_t redoNum;	//!< ????????????
    uint8_t fiRedo;		//!< ????,??????????????,(??)????????
};

/**
 * @brief reportInf:????,????????
 */


// ÊÇ·ñGPS¶¨Î»
volatile uint8_t GPS_Locate = 1;
volatile uint8_t GPS_Located = 0;
volatile uint32_t GPS_waitTick = 0;
volatile uint8_t GPS_Waiting = 0;
// GPS¶¨Î»³¬Ê±
const uint8_t DTU_tmrLocate = 90;

// GPS·¢ËÍÊý¾Ý
volatile uint32_t GPS_tranTick = 0;

// ±£´æÉÏ´ÎÊý¾ÝµÄʱ¼ä
bluetooth_timestamp_t GPS_LastTime = {0};

// ÊÇ·ñ·¢ËÍGPRSÊý¾Ý
uint8_t GPRS_Send_Task = 0;
uint32_t GPRS_Send_Time = 0;
// ÊÇ·ñ±£´æGPRSÊý¾Ý
uint8_t GPRS_Save_Task = 0;
uint32_t GPRS_Save_Time = 0;

/////////////////////////////////////////
uint32_t Fre[5] = {498000000, 499000000, 509770000, 868000000, 915000000};
uint8_t RXbuffer[60];
#define TASK_SENDBUFF_SIZE	400
//uint8_t Task_sendBuff[TASK_SENDBUFF_SIZE] = {0}; // À©Õ¹ÄÚ´æ

uint8_t TXbuffer[10] = {0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA};

tSX127xError set_lora_freq(int freq)
{
    G_LoRaConfig.LoRa_Freq = Fre[freq];   //????470MHz
    G_LoRaConfig.BandWidth = BW500KHZ;    //BW = 125KHz  BW125KHZ
    G_LoRaConfig.SpreadingFactor = SF12;  //SF = 9
    G_LoRaConfig.CodingRate = CR_4_5;     //CR = 4/6
    G_LoRaConfig.PowerCfig = 15;          //19¡À1dBm
    G_LoRaConfig.MaxPowerOn = true;       //×î´ó¹¦ÂÊ¿ªÆô
    G_LoRaConfig.CRCON = true;            //CRCУÑ鿪Æô£
    G_LoRaConfig.ExplicitHeaderOn = true; //Header¿ªÆô
    G_LoRaConfig.PayloadLength = 42;      //Êý¾Ý°ü³¤¶È
    return SX127X_Lora_init(G_LoRaConfig.LoRa_Freq);
}

////////////////////////////////////////////////////////////////////////////////////////
//-->add
#define LORA_COMMU_IDLE_STATE      0
#define LORA_COMMU_START_STATE     1
#define LORA_COMMU_SEND_STATE      2
#define LORA_COMMU_REC_STATE       3
#define LORA_COMMU_FAIL_STATE      4
#define LORA_COMMU_SUCC_STATE      5
uint16_t g_lora_commu_state=LORA_COMMU_IDLE_STATE;

////////////////////////////////////
uint8_t pack_lora_send_data(gprs_data_t *pGprs, uint32_t totalSeconds)
{
    int i=0;
    uint16_t val = 0;
    Task_sendBuff[i++]=0x01;
    Int2ByteS(Task_sendBuff, i, /*htons*/(dcBuff.sampleData.diff));
	 
    i +=2 ;

    Int2ByteS(Task_sendBuff, i, /*htons*/(dcBuff.dtuData.batVoltage));
    i += 2;
    // °æ±¾ºÅ
	  Task_sendBuff[i++] = dcBuff.powerInfo.hardVer.minor;
    Task_sendBuff[i++] = dcBuff.powerInfo.softVer.minor;
    

    Int2ByteS(Task_sendBuff, i, /*htons*/(dcBuff.configData.intervalSample));
    i += 2;
    Int2ByteL(Task_sendBuff, i, /*htonl*/(dcBuff.configData.intervalTrans));
    i += 4;

    Int2ByteS(Task_sendBuff, i, /*htons*/(dcBuff.configBottle.fullPct)); //¡¢apexÐèÒª¸ÄΪѹǿ
    i += 2;

    Int2ByteS(Task_sendBuff, i, /*htons*/(dcBuff.configBottle.emptyPct));
    i += 2;

//    // ѹÁ¦±¨¾¯ÉÏÏÞ
//    Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnPressH));
//    i += 2;
//    // ѹÁ¦±¨¾¯ÏÂÏÞ
//    Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnPress));
//    i += 2;
//    // ζȱ¨¾¯ÉÏÏÞ
//    Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnTemprH));
//    i += 2;
//    // ζȱ¨¾¯ÏÂÏÞ

//    Int2ByteS(Task_sendBuff, i, htons(dcBuff.configBottle.warnTempr));
//    i += 2;

    return i;
}

uint8_t parse_load(uint8_t *buf)
{
#pragma pack(push, 1)
typedef struct
{
  uint8_t type;
	uint32_t flag;
	uint16_t	intervalSample;		// Êý¾Ý²É¼¯ÖÜÆÚ
	uint32_t	intervalTrans;		// Êý¾ÝÉϱ¨ÖÜÆÚ
  uint16_t	fullPct;
	 uint16_t	emptyPct;
//	uint16_t warnPressH;
//	uint16_t warnPress;
//	int16_t warnTemprH;
//	int16_t warnTempr;
} parse_data_t;
#pragma pack(pop)	
	
	parse_data_t *buf2;
   buf2 = (parse_data_t*) buf;
  if(buf2->flag == 0) return 0;

dcBuff.configData.intervalSample=buf2->intervalSample;
dcBuff.configData.intervalTrans=buf2->intervalTrans;

dcBuff.configBottle.fullPct=buf2->fullPct;
dcBuff.configBottle.emptyPct=buf2->emptyPct;

//dcBuff.configBottle.warnPressH=buf2->warnPressH;
//dcBuff.configBottle.warnPress=buf2->warnPress;

//dcBuff.configBottle.warnTemprH=buf2->warnTemprH;
//dcBuff.configBottle.warnTempr=buf2->warnTempr;
dcBuff.configBottle.updateFlag = 1;	// ²ÎÊý¸üбêÖ¾					
	// ±£´æ
Config_SaveConfig();

//	uint8_t ret = 0;
//    S_RTC_TIME_DATA_T sRTC;
//	
//    if(strncmp(message, "$GPGGA", 6) == 0 || strncmp(message, "$GNGGA", 6) == 0)
//	{
////		printf("\n%s\n", message);
//		*bufIdx = 1 - *bufIdx;
//	}
//    else if(strncmp(message, "$GPRMC", 6) == 0 || strncmp(message, "$GNRMC", 6) == 0)
//	{
//		printf("\n%s\n", message);

//		// »ñÈ¡µ±Ç°Ê±¼ä
//		RTC_GetDateAndTime(&sRTC);
//		// ¼Ç¼GPSÉÏ´ÎÊý¾Ýʱ¼ä
//		DTU_gpsTime = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
//				sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);

//		parse_gga(DTU_gpsData[1 - *bufIdx], sample);
//        ret = parse_rmc(message, sample);
//		if(!ret)
//			sample->posState = 0;
//	}

	return 1;
}












static uint8_t first_send=1;
// ÈÎÎñÖ÷Ì壺·¢ËÍÔËÐÐÊý¾ÝºÍGPSÊý¾Ý£¬¶ÁÈ¡ÍøÂçÐźÅÇ¿¶ÈµÈ
void DTU_Task(void *p_arg)
{
    bluetooth_send_t *pSend = (bluetooth_send_t *) Task_sendBuff;
    bluetooth_send_t *pRecv = (bluetooth_send_t *) Task_recvBuff;
    uint16_t i, j, k;
    uint8_t gpsCount, gpsDone;
    uint16_t gpsInterval;
    uint32_t totalSeconds;
    uint32_t relativeTime;
    S_RTC_TIME_DATA_T sRTC;
    gprs_data_t *pGprs;
    uint8_t try_count;
    uint16_t recvLen;
    uint8_t upgrade;
    uint8_t ackUpgrade;
    uint8_t downloadParam;
    uint8_t ackParam;
    uint8_t downloadConfig;
    uint8_t ackConfig;
    uint8_t reset = 0;
    param_data_t *pParam;
    TUpgradeHeader upHeader;
    upgrade_frame_t *pFrame;
    gps_data_t gps;
    uint16_t nextPtr;
    uint8_t write_count;
    uint8_t rf_fail_count = 0;
    uint8_t semSync, semGPRS, semGPS;

    uint32_t tick;

    // Çå³ýÊý¾Ý
    memset(&dcBuff.dtuData, 0, sizeof(dcBuff.dtuData));

    // ¶ÁÈ¡ÆäËü°å×ÓµÄÅäÖÃÊý¾Ý

    // Æô¶¯¶¨Ê±Æ÷
    GPS_tranTick = GetDelayTick(dcBuff.configData.intervalGPSTrans * 1000);

    // ÉϵçÔËÐÐÒ»´ÎÈÎÎñ
    DTU_semSync = 1;
    DTU_semGPRS = 1;
    DTU_semGPS = 1;

    while(1)
    {
        // »ñÈ¡µ±Ç°Ê±¼ä
        RTC_GetDateAndTime(&sRTC);
        printf("\n%04d-%02d-%02d %02d:%02d:%02d\n", sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
               sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);
        // ¼ÆËã×ÔÉÏ´Îgps¶¨Î»ÒÔÀ´µÄʱ¼ä
        totalSeconds = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
                                            sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);
        // ¸Õ¿ªÊ¼ÔËÐеÄʱºò£¬»ØÍ˵½¸ÕÆô¶¯µÄʱ¼ä£¨ºöÂÔϵͳ³õʼ»¯Ê±¼ä£©
        if(totalSeconds < 10)
            totalSeconds = 0;

        // ¶ÁÈ¡ÐźÅÁ¿
        semSync = DTU_semSync;
        DTU_semSync = 0;
        semGPRS = DTU_semGPRS;
        DTU_semGPRS = 0;
        semGPS = DTU_semGPS;
        DTU_semGPS = 0;


        printf("\n\n\n------semGPRS=%d-------semSync=%d------\n\n\n",semGPRS,semSync);


        if(semGPRS || semSync)
        {
            GPRS_Send_Task = 0;
            printf("\n*** dcBuff.sampleData.warnning = %d ***\n", dcBuff.sampleData.warnning);
            if(dcBuff.sampleData.warnning||first_send)
            {
                GPRS_Send_Task = 1;
                dcBuff.sampleData.warnning = 0;
							first_send=0;
            }
            // ÅжÏÊÇ·ñ·¢ËÍÖÜÆÚ
            // ·¢Ëͼä¸ô×îСֵ
            if(totalSeconds + 3 >= GPRS_Send_Time + (dcBuff.configData.intervalTrans > 300 ? 300 : dcBuff.configData.intervalTrans))
            {
                GPRS_Send_Task = 1;
            }

            if(((SYS_RSTSTS & 0x13) && !(SYS_RSTSTS & 0x04) && // Éϵç»òÊÖ¶¯¸´Î», ·Ç¿´ÃŹ·¸´Î»
                    totalSeconds < INITIAL_TRAN_COUNT * (dcBuff.configData.intervalSample > 300 ? 300 : dcBuff.configData.intervalSample))
                    || totalSeconds + 3 >= GPRS_Send_Time + dcBuff.configData.intervalTrans )

            {
                // ·¢Ëͼä¸ô×îСֵ
                if(totalSeconds + 3 >= GPRS_Send_Time + (dcBuff.configData.intervalTrans > 300 ? 300 : dcBuff.configData.intervalTrans))
                    GPRS_Send_Task = 1;
            }


            if(Wakeup_GetWorkMode() == WORK_MODE_NORMAL && GPRS_Send_Task)
            {

                if(set_lora_freq(0) != NORMAL)	 //
                {
                    printf("\nlora init err\n");
                }
                // ÏÈÇå³ýÐźÅÁ¿
                GPRS_semSampled = 0;
                // ²É¼¯Êý¾Ý

                Sample_Notify();
                tick = GetDelayTick(3000);
                while(!GPRS_semSampled && !IsTickOut(tick))
                {
                }
                i = pack_lora_send_data(pGprs, totalSeconds);
                try_count = 3;
                while(try_count--)
                {
                    j = rf_app_send_data(i, Task_sendBuff);
                    osDelay(5000);
                    if(g_lora_commu_state==LORA_COMMU_SUCC_STATE)
                    {
                        // ¼Ç¼·¢Ëͳɹ¦µÄʱ¼ä
                        RTC_GetDateAndTime(&sRTC);
                        DTU_succTime = Calc_SecondsFromYear(INITIAL_YEAR, sRTC.u32Year, sRTC.u32Month, sRTC.u32Day,
                                                            sRTC.u32Hour, sRTC.u32Minute, sRTC.u32Second);

                        printf("\ncommu success\n");
                        break;
                    }
                    else
                    {
                        printf("\ncommu fail\n");
                    }
                }
                GPRS_Send_Time = totalSeconds;

                osDelay(1000);

            }

        }

        printf("\nlora to SleepMode\n");
        SX127X_SleepMode();
//			 DIO0_DisableInterrupt();
//			printf("\nlora spi deinit\n");
        Lora_spi_di_deinit();
				osDelay(2000);
        printf("\nlora to powerdown\n");
        Wakeup_Powerdown();
        
        //continue;
    }

}