4G接电信平台

4G接电信平台，实现tcp透传功能：

系统ucosiii，其中网络处理代码如下：

/*****************************************************************************
 * FILE NAME   gsm.c
 * DESCRIPTION:    
 * Copyright   : PGST Technologies Ltd.
 * All Rights  Reserved
 * Author: Milo lu
 * Copyright (c) 2021, PGST Technologies Ltd.
 *
 * All rights reserved.
-* ****************************************************************************/
#include "main.h"
#include "includes.h"
#include <my.h>
#include <my_string.h>
#include <stdlib.h>

#include "para.h"
#include "wavplay.h"

#include "protocol.h"
#include "Encoder.h"
#include "Parser_Bxi.h"
#include "crc16.h"
#include "my_enum.h"
#include "caption.h"
#include "gsm.h"



//=======================================\
Public external variable declaration\
=========================================/
extern flag_e gflag;
extern u32 g_CurrentTransmit_buf[];
extern u16 EnLength;
extern uint16_t g16_package_length;
extern char encodingString[];
extern TyReadTypeDef_t TyReadTypeDef;
extern STRU_LEARN struLearn;
extern u8 show_uplink_downlink_icon;
//================================\
Public variable declaration\
==================================/
SequenceNumber_e sequence_number_req;
SequenceNumber_e sequence_number_res;
u8 tmr_clock_test;

u8 g_M25_M26_specific;
u8 g_Version_M25MAR01A11=0;
u8 ec200n_dk = 0;
//u8 NoAckResponse_Count;

OS_EVENT *msg_gsm_parse;

volatile u16 tmrRecord;
volatile ENUM_AUDIO_MODE audio_mode;

#if WReadCounter_Enable
u8 g_u8_WReadCounter;
#endif
#if PK
u32 TestSignal_24H_Timer_sec = 0;   /* default value is 0, when network registered, it will start counting TestSignal_24H_Timer_sec=1 */
#endif

//=================================\
Private variable declaration\
===================================/
Registered_e Registered_On_Network=UNKNOWN;

const static s8 USA_ICCID[] = "01";
//const static s8 IRELAND_ICCID[]= "35";
const static s8 UK_ICCID[]= "44";
const static s8 CHINA_ICCID[]="86";
const static s8 CANADA_ICCID[]  = "30";
const static s8 NETHERLANDS_ICCID[] = "31";
const static s8 ATT_ICCID[]="89011";

const static s8 AT_ATT_CGDCONT[]="wyless.com.attz";
const static s8 AT_NETHERLANDS[]="gneroaming.net";
const static s8 AT_USA_CGDCONT[]="telargo.t-mobile.com";
const static s8 AT_IRELAND_CGDCONT[]="wyless.net";
const static s8 AT_UK_CGDCONT[]="o2.wyless.net";
const static s8 AT_CHINA_CGDCONT[]= "CMNET";
const static s8 AT_CANADA_CGDCONT[]= "gne.apn";
const static s8 AT_CHINA_UNICOM[]="UNINET";//988601,06,09

static TcpTx_e  My_TcpTx = TCP_IDLE;
static u8 Timer_index=0;
static u16 Remote_index=0;
static u16 Detector_index=0;
//=================================\
Private variable declaration\
===================================/
const STRU_AT struAtNetwork[] =         /* Network signal check, request per 6second */
{
    { "AT\r",RET_OK,1,10},
    { "AT+CSQ\r",RET_OK,2,2},            /* check signal quality */
    { "AT+CGREG?\r",RET_OK,2,2},            /* Check network registration status */
    { "AT+CEREG?\r",RET_OK,2,2},            /* Check network registration status */
    { NULL, NULL, 0, 0},
};

const STRU_AT struAtInit[] = 
{
    { "ATE0\r",RET_OK,1,2},
//    { "AT+CMGF=1\r",RET_OK,1,60},       /* Message format configuration: 1=Text */
    //{ "AT+CLIP=1\r",RET_OK,1,60},       /* Mobile terminating call indication */
//    { "AT+CNMI=2,1\r",RET_OK,2,60},     /* SMS Event reporting configuration */
//    { "AT+CMGL=\"ALL\"\r",RET_OK,5,60}, /* List all message */
    { NULL, NULL, 0, 0},
};
const STRU_AT AT_UC15_INIT_UART[] =     /* not used for ec200s module */
{
    { "AT+QCFG=\"vbatt\",2,4400,0\r",RET_OK,1,2},
    { "AT+QURCCFG=\"urcport\",\"uart1\"\r",RET_OK,1,2},
//    { "AT+QCFG=\"amrcodec\",7\r",RET_OK,1,2},
//    { "AT+QRCH=0\r",RET_OK,1,2},
//    { "AT+QMIC=1,8192,8192\r",RET_OK,2,2},        /* range:0~65535,default value:8192 all */
    { NULL, NULL, 0, 0},
};
const STRU_AT AT_EC200S_EC25_INIT_UART[] = 
{
    { "AT+QURCCFG=\"urcport\",\"uart1\"\r",RET_OK,2,6}, /* urc configuration*/
    { NULL, NULL, 0, 0},
};

const STRU_AT struAtSetAscii[] = 
{
    { "AT+CSCS=\"GSM\"\r",RET_OK,1,2},    /* TE character set: GSM alphabet */
    { "AT+CSMP=,,,0\r",RET_OK,1,2},        /* Set SMS Text Mode Parameters */
    { NULL, NULL, 0, 0},
};
const STRU_AT struM25_AtSetAscii[] = 
{
    { "AT+CSCS=\"GSM\"\r",RET_OK,1,2},    /* TE character set: GSM alphabet */
    //{ "AT+CSMP=,,,0\r",RET_OK,1,2},        /* Set SMS Text Mode Parameters */
    { "AT+CSMP=17,71,0,0\r",RET_OK,1,2},        /* Set SMS Text Mode Parameters */
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtSetHz[] =
{
    { "AT+CSCS=\"UCS2\"\r",RET_OK,1,2},
    { "AT+CSMP=,,,8\r",RET_OK,1,2},
    
    { NULL, NULL, 0, 0},
};
const STRU_AT struM25_AtSetHz[] =
{
    { "AT+CSCS=\"UCS2\"\r",RET_OK,1,2},
    { "AT+CSMP=49,167,0,25\r",RET_OK,1,2},
    
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtCallOut[]=
{
    { "ATH\r",RET_OK,5,10},                 /* Hang up */
    { "AT+QSIDET=0\r",RET_OK,2,6},          /* Set the Side Tone Gain in Current Mode */
    //{ "AT+QTONEDET=0\r",RET_OK,2,6},
    //{"AT+QAUDSW=1\r",RET_OK,2,6},
    { "AT+QTONEDET=1\r",RET_OK,2,6},        /* Enable DTMF */
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtCallOut_SIMCom[]=
{
    { "AT+CLVL=15\r",RET_OK,2,6},   /* 0-15 */
    { "AT+DDET=1\r",RET_OK,2,6},    /* Enable DTMF */
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtCallOut_SIMCom7[]=
{
    { "AT+CMICGAIN=7\r",RET_OK,2,6},   /* mic = 0-7 */
    { "AT+COUTGAIN=7\r",RET_OK,2,6},   /* spk = 0-7 */
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtCallOut_M26[]=  /* not used for ec200s module */
{
    { "AT+QAUDCH=0\r",RET_OK,2,6},  /* change the voice channel:1=main,1=earphone,2=hands-free channel*/
    { "AT+QMIC=0,5\r",RET_OK,2,6},
    { "AT+CLVL=50\r",RET_OK,2,6},   /* 0-100 */
    { "AT+QAPS=1,4,0,\"248.253.2218.31.57351.31.400.0.80.4325.99.0.8223.0.0.8192\"\r",RET_OK,2,6 },
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtCallOut_M25[]=            /* not used for ec200s module */
{
    { "AT+QAUDCH=0\r",RET_OK,2,6},
    { "AT+QMIC=0,3\r",RET_OK,2,6},        /* 0-15*/
    { "AT+CLVL=60\r",RET_OK,2,6},        /* 0-100 */
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtCallOut_UC15[]=         /*not used for ec200s module */
{
    { "AT+QAUDPATH=0\r",RET_OK,2,6},        /* change the voice channel:1=main,1=earphone,2=hands-free channel*/
    { "AT+QMIC=1,8192,8192\r",RET_OK,2,6},  /* range:0~65535,default value:8192 all (1024) */
    { "AT+CLVL=3\r",RET_OK,2,6},            /* range:0~7,default value:3 */
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtCallOut_EC25[]=
{
    { "AT+QDAI=3\r",RET_OK,2,6},
    { "AT+CLVL=3\r",RET_OK,2,6},
    { "AT+QAUDMOD=2\r",RET_OK,2,6},
    { "AT+QMIC=8192,8192\r",RET_OK,2,6},
    { "AT+QRXGAIN=60000\r",RET_OK,2,6},
    { "AT+QEEC=0,2048\r",RET_OK,2,6},
    { "AT+QEEC=5,14\r",RET_OK,2,6},
    { "AT+QEEC=10,160\r",RET_OK,2,6},
    { "AT+QEEC=21,25000\r",RET_OK,2,6},
    { "AT+QEEC=22,6000\r",RET_OK,2,6},
    { "AT+QEEC=33,768\r",RET_OK,2,6},
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtCallOut_EC200S[]=
{   
    #if HW_25==1
    #else
    //{ "AT+QDAI=3\r",RET_OK,2,6},            /* Digital Audio Interface Configuration:Analog output (for our default audio codec ALC5616) */
    #endif
    { "AT+CLVL=4\r",RET_OK,2,6},            /* Loudspeaker volume level selection: 0-3-5 */
    { "AT+QAUDMOD=0\r",RET_OK,2,6},         /* Set Audio Mode:2=Echo canceller, noise suppressor, digital gain and calibration parameter for Speaker */
    //{ "AT+QMIC=8192\r",RET_OK,2,6},       /* Set Uplink Gains of MIC */
    { NULL, NULL, 0, 0},
};

const STRU_AT AT_RECORD_MIC_UC15 = { "AT+QMIC=1,1024,1024\r",RET_OK,2,6};   /* not used for ec200s module!-- range:0~65535,default value:8192 all */
const STRU_AT AT_RECORD_MIC_EC25 = { "AT+QMIC=60000,60000\r",RET_OK,2,2};
const STRU_AT AT_RECORD_MIC_EC200S = { "AT+QMIC=60000\r",RET_OK,2,2};       /* Set Uplink Gains of MIC: 8192 */

const STRU_AT struAtSendDtmf[] =
{
    { "AT+VTD=1,500\r",RET_OK,2,2},                /* Sets the duration of DTMF tones */
    { "AT+VTS=#\r",RET_OK,2,2},                    /* Used to send ASCII characters which cause MSC to transmit DTMF tones to a remote subscriber */
    { NULL, NULL, 0, 0},
};

const STRU_AT AT_GET_FIRMWARE_CGMR = {"AT+CGMR\r",VERSION_OK,2,2};
const STRU_AT AT_GET_FIRMWARE = {"AT+GMR\r",VERSION_OK,2,2};    /* firmware version */
const STRU_AT AT_GET_CGSN = {"AT+CGSN=1\r",RET_OK,2,2};         /* IMEI number */
const STRU_AT AT_GET_IMEI = {"AT+GSN\r",RET_OK,2,2};            /* IMEI number */

const STRU_AT AT_GET_IMSI = {"AT+CIMI\r\n",RET_OK,1,5};            /* Return IMSI number */
const STRU_AT AT_GET_NCCID = {"AT+NCCID\r\n",RET_OK,1,5};        /* Return ICCID number means SIM card inser,or no sim car */
const STRU_AT AT_GET_ICCID = {"AT+CCID\r\n",RET_OK,1,5};        /* Return ICCID number means SIM card inser,or no sim car */
const STRU_AT AT_GET_CICCID = {"AT+CICCID\r\n",RET_OK,1,5};        /* Return ICCID number means SIM card inser,or no sim car */

#ifdef    M26
/***for M26*******************************************************************/
const STRU_AT AT_UC15_CONTEXT = {"AT+QIACT=1\r",RET_OK,30,60};          /* active a PDP context */
const STRU_AT AT_UC15_CHECK_CONTEXT = {"AT+QIACT?\r",RET_CONNECT,1,1};  /* check PDP context */

const STRU_AT struAtSendPlay_M26[] =         /* not used for ec200s module */
{
    {"AT+QFLST=\"RAM:play.amr\"\r",RET_QFLST,2,2},
    {"AT+QPSND=1,\"RAM:play.amr\",1,7,0\r",RET_OK,1,1},
    { NULL, NULL, 0, 0},
};
const STRU_AT PLAY_SIMCom7ToRemote[] =         /* not used for ec200s module */
{
    {"AT+FSLS\r",RET_QFLST,2,2},
    {"AT+CCMXPLAY=\"C:/re.wav\",1,0\r",RET_OK,1,1},/*play record to remote */
    { NULL, NULL, 0, 0},
};

//para:1=mode,2=name,3=channel,4=volume
const STRU_AT AT_PLAY_SIMCom={"AT+CMEDPLAY=1,\"record.amr\",0,100\r",RET_OK,1,1};   /*play record */
//AT+CCMXPLAY="C:/recording.wav",0,0-----//play the recorded file“C:/recording.wav”
const STRU_AT AT_PLAY_SIMCom7={"AT+CCMXPLAY=\"C:/re.wav\",0,0\r",RET_OK,1,1};   /*play record to local */
//AT+CCMXPLAY="C:/3034.amr",1,0----//play “C:/3034.amr” to the remote

const STRU_AT struAtSendPlay_UC15[] =        /* not used for ec200s module */
{
    {"AT+QFLST=\"UFS:play.wav\"\r",RET_QFLST,2,2},
    {"AT+QPSND=1,\"UFS:play.wav\",0,1\r",RET_OK,2,2},
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtSendPlay0_EC200S_EC25[] =
{
    {"AT+QFLST=\"record0.wav\"\r",RET_QFLST,2,2},        /* list the file "record0.wav" */
    {"AT+QPSND=1,\"record0.wav\",0,1,0\r",RET_OK,2,2},    /* Play back the audio files during voice call. */
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtSendPlay1_EC200S_EC25[] =
{
    {"AT+QFLST=\"record1.wav\"\r",RET_QFLST,2,2},        /* list the file "record1.wav" */
    {"AT+QPSND=1,\"record1.wav\",0,1,0\r",RET_OK,2,2},    /* Play back the audio files during voice call. */
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtSendPlay0_EC200n[] =
{
    {"AT+QFLST=\"record0.amr\"\r",RET_QFLST,2,2},        /* list the file "record0.wav" */
    {"AT+QPSND=1,\"record0.amr\",0,1,0\r",RET_OK,2,2},    /* Play back the audio files during voice call. */
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtSendPlay1_EC200n[] =
{
    {"AT+QFLST=\"record1.amr\"\r",RET_QFLST,2,2},        /* list the file "record1.wav" */
    {"AT+QPSND=1,\"record1.amr\",0,1,0\r",RET_OK,2,2},    /* Play back the audio files during voice call. */
    { NULL, NULL, 0, 0},
};

const STRU_AT struAtTcpConfig_M26[] =    /* not used for ec200s module */
{
    { "AT+QIDEACT\r",RET_OK,45,45},        /* Deactivate a PDP context */    
    { "AT+QIFGCNT=0\r",RET_OK,2,2},
    { "AT+QIMUX=0\r",RET_OK,2,2},        /* AT+QIMUX 0 do not support mux sockets */
    { "AT+QIMODE=0\r",RET_OK,2,2},
    { "AT+QIDNSIP=0\r",RET_OK,2,2},
    { "AT+QIHEAD=1\r",RET_OK,2,2},
    { NULL, NULL, 0, 0},
};
const STRU_AT AT_Deactivate_a_PDP_context[] =    /*  (default) */
{
    { "AT+QIDEACT=1\r",RET_OK,45,45},    /* Deactivate a PDP context:AT+QIDEACT=<contextID> */
    { NULL, NULL, 0, 0},
};
const STRU_AT Deactivate_a_PDP_context_SIMCom[] =
{
    { "AT+CIPSHUT\r",SHUT_OK,45,45},    /* Deactivate a PDP context:AT+QIDEACT=<contextID> */
    //{ "AT+CIPHEAD=1\r",RET_OK,2,2},
    { "AT+QIHEAD=1\r",RET_OK,2,2},
    { NULL, NULL, 0, 0},
};
const STRU_AT Deactivate_a_PDP_context_SIMCom4[] =
{
    { "AT+CGACT?\r",RET_OK,5,5},                /* read PDP context; response= +CGACT: [<cid>,<state> */
    { "AT+CGACT=1,1\r",RET_OK,2,2},             /* PDP context active; response= OK */
    { "AT+NSOCR=DGRAM,6,0,1\r",RET_OK,2,2},     /* Set up TCP Client Connection; response= OK */
    { NULL, NULL, 0, 0},
};
const STRU_AT Deactivate_a_PDP_context_SIMCom7[] =
{
    { "AT+CGACT?\r",RET_OK,5,5},        /* read PDP context; response= +CGACT: [<cid>,<state> */
    { "AT+CGACT=1,1\r",RET_OK,2,2},     /* PDP context active; response= OK */
    { "AT+NETOPEN\r",RET_OK,2,2},       /* Set up TCP Client Connection; response= OK */
    { "at+ipaddr\r",RET_OK,2,2},        /* read ip address; response= OK */
    { NULL, NULL, 0, 0},
};
/*******************************************
**        Close a socket service 
********************************************/
const STRU_AT struAtCloseConnect_M26[] =    /* not used for ec200s module */
{
    { "AT+QICLOSE\r",RET_OK,1,10},        /* M26:When AT+QIMUX=0, after establishing TCP or UDP connection, close connection as below */
    { "AT+QICLOSE=1\r",RET_OK,1,10},
    { "AT+QICLOSE=2\r",RET_OK,1,10},
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtCloseConnect_SIMCom[] =    /* not used for ec200s module */
{
    { "AT+CIPSHUT\r",SHUT_OK,1,10},
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtCloseConnect_SIMCom7[] =    /* not used for ec200s module */
{
    { "AT+CIPCLOSE=0\r",SHUT_OK,1,10},          /* response = +CIPCLOSE: <link_num>,<err> */
    { NULL, NULL, 0, 0},
};
const STRU_AT AT_Close_Socket_PDP_Context[] =    /* default */
{
    { "AT+QICLOSE=0\r",RET_OK,1,10},        /*close socketID 0*/
    { "AT+QIDEACT=1\r",RET_OK,40,40},        /* Deactivate PDP ContextID 1 */
    { "AT+QICLOSE=2\r",RET_OK,1,10},
    { NULL, NULL, 0, 0},
};

const STRU_AT struAtTcpAck_M26[] =        /* not used for ec200s module */
{
    { "AT+QISACK\r",RET_TCP_ACK,1,30},
    { "AT+QISACK=1\r",RET_TCP_ACK,1,30},
    { "AT+QISACK=2\r",RET_TCP_ACK,1,30},
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtTcpAck_UC15[] =            /* default */
{
    { "AT+QISEND=0,0\r",RET_TCP_ACK,1,30},    /* TCPIP: send data,socket_id=0,data length=0 */
    { "AT+QISACK=1\r",RET_TCP_ACK,1,30},    /* check data sent, socket_id=1 */
    { "AT+QISACK=2\r",RET_TCP_ACK,1,30},    /* check data sent, socket_id=2 */
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtTcpAck_SIMCom[]=        //AT+CIPACK
{
    { "AT+CIPACK\r",RET_TCP_ACK,1,30},
    { "AT+CIPACK=1\r",RET_TCP_ACK,1,30},
    { "AT+CIPACK=2\r",RET_TCP_ACK,1,30},
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtTcpAck_SIMCom7[]=        //AT+CIPACK
{
    { "AT+CIPACK=0\r",RET_TCP_ACK,1,30},
    { "AT+CIPACK=1\r",RET_TCP_ACK,1,30},
    { "AT+CIPACK=2\r",RET_TCP_ACK,1,30},
    { NULL, NULL, 0, 0},
};
const STRU_AT struAtNetworkTime_M26[] =        /* not used for ec200s module */
{
    { "AT+CTZU=2\r",RET_OK,1,2},
    { "AT+QNITZ=1\r",RET_OK,1,2},
    { "AT+QLTS\r",RET_QLTS,2,10},
    { NULL, NULL, 0, 0},
};
/*const STRU_AT struAtNetworkTime_UC15[] =    // * not used for ec200s module (default) *
{
    { "AT+CTZU=1\r",RET_OK,1,2},
    { "AT+QLTS\r",RET_QLTS,2,10},
    { NULL, NULL, 0, 0},
};*/
const STRU_AT struAtNetworkTime_Default[] =    /* for ec200s module */
{
    { "AT+CTZU=1\r",RET_OK,1,2},    /* Automatic Time Zone Update */
    { "AT+QLTS\r",RET_QLTS,2,10},   /* Obtain the Latest Time Synchronized Through Network */
    { NULL, NULL, 0, 0},
};


//const STRU_AT AT_QFLST_EC200S_EC25 = {"AT+QFDEL=?\r",RET_OK,2,2};



#else
/***for huawei*******************************************************************/
const STRU_AT struAtTcpConfig_MG323[]=
{
    { "AT+CGATT?\r",RET_CGATT,2,60},
    { "AT%ETCPIP\r",RET_OK,60,120},
    { "AT%IOMODE=1,2\r",RET_OK,1,2},
    { NULL, NULL, 0, 0},
};

const STRU_AT struAtCloseConnect_MG323[] =
{
    { "AT%IPCLOSE=1\r",RET_OK,5,5},
    { "AT%IPCLOSE=2\r",RET_OK,5,5},
    { "AT%IPCLOSE=3\r",RET_OK,5,5},
    { NULL, NULL, 0, 0},
};
#endif

/*********************************************************************************************************
    variable declaration
*********************************************************************************************************/
STRU_GSM struGsm;
static u32 at_return_result = 0;
volatile u8 pgsGsm;
/*********************************************************************************************************
    function declaration
*********************************************************************************************************/
SYS_ERR at_cmd_return( const STRU_AT *at );


/*********************************************************************************************************
** Function name:    gsm_usart2_init
** Descriptions:    serial port initialization: baud rate = 115200 bit/s, PB10=TX,PB11=RX
** input parameters:    none
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
void gsm_usart2_init()
{
    GPIO_InitType  GPIO_InitStructure;
    usart_init( USART_ID2,115200 );
    RCC_EnableAPB2PeriphClk(RCC_APB2_PERIPH_GPIOA, ENABLE); /* Enable the GPIOA Clock */
    
    GPIO_InitStructure.Pin = GPIO_PIN_1|GPIO_PIN_11;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitPeripheral(GPIOA, &GPIO_InitStructure);
}
/*********************************************************************************************************
** Function name:    gsm_power_down
** Descriptions:    GSM Main power cut off for 1500 ticks
** input parameters:    none
** Output parameters:    NONE
** Returned value:    none
*********************************************************************************************************/
void gsm_power_cycle()
{
//    OS_ERR err;
    
    GSM_MAIN_PWR(0);
    OSTimeDly( 1500);//,OS_OPT_TIME_PERIODIC,&err );
    GSM_MAIN_PWR(1);
    OSTimeDly( 1000);//,OS_OPT_TIME_PERIODIC,&err );
}
/*********************************************************************************************************
** Function name:    gsm_power_on
** Descriptions:    GSM Power ON(for MG323：TERM_ON_PIN Pull down for 750ms
** if failed to power on, power cycle.
** input parameters:    none
** Output parameters:    NONE
** Returned value:    SYS_ERR_OK or SYS_ERR_AT_FAIL.
*********************************************************************************************************/
SYS_ERR gsm_power_on()
{
    SYS_ERR err;
    u8 ctr;
    const STRU_AT strAt = {"AT\r",RET_OK,1,5};                    /* echo off */
    const STRU_AT struAt = {"ATE0\r",RET_OK,1,15};                    /* echo off */
    //const STRU_AT AT_GET_SIM_STAT = {"AT+QSIMSTAT?\r",RET_OK,1,3};    /* SIM card insertion status */
    //const STRU_AT AT_GET_ICCID = {"AT+CCID\r\n",RET_OK,1,5};        /* Return ICCID number means SIM card inser,or no sim car */
    //const STRU_AT AT_GET_CICCID = {"AT+CICCID\r\n",RET_OK,1,8};        /* Return ICCID number means SIM card inser,or no sim car */
    const STRU_AT AT_Ver = {"AT+CGMR\r",VERSION_OK,1,5};            /* version */
    const STRU_AT AT_ProductInfo = {"ATI\r",RET_OK,1,1};            /* version */
    
    ctr = 3;
    GSM_MAIN_PWR(1);        //power on
    OSTimeDly(1000);       //delay for power stable
    GSM_PWR_KEY(1);            /* power key on */
    OSTimeDly(2000);//OSTimeDly( 750);//,OS_OPT_TIME_PERIODIC,&err );
    GSM_PWR_KEY(0);            /* power key down */
    OSTimeDly(1000);//OSTimeDly( 5000);//,OS_OPT_TIME_PERIODIC,&err );
    while(ctr--)
    {
        err = at_cmd_return(&strAt);
        if( err == SYS_ERR_AT_FAIL )
        {
            continue;
        }
        err = at_cmd_return(&struAt);
        at_cmd_return(&AT_Ver);         //read module version,this command for SIMCom module, does not need to check the result.
        
        OSTimeDly(10);
        at_cmd_return(&AT_ProductInfo); /* The command delivers a product information text */
        
        OSTimeDly(10);//OSTimeDly( 500);//,OS_OPT_TIME_PERIODIC,&err );
        err = at_cmd_return(&struAt);
        if(err == SYS_ERR_OK )
        {
            struGsm.status |= GSM_STAT_NO_SIM;
            return SYS_ERR_OK;
        }
    }
    return SYS_ERR_AT_FAIL;
}
/*********************************************************************************************************
** Function name:    gsm_power_down
** Descriptions:    GSM power down(for MG323：TERM_ON_PIN pull down.)
** if failed to power on, power cycle.
** input parameters:    none
** Output parameters:    NONE
** Returned value:    SYS_ERR_OK or SYS_ERR_AT_FAIL.
*********************************************************************************************************/
SYS_ERR gsm_power_down()
{
    //OS_ERR err;
    const STRU_AT struAt = {"AT\r",RET_OK,1,5};        /* at test */
    u8 ctr;
    
    GSM_PWR_KEY(1);                                    /* power key on */
    OSTimeDly( 2000);//,OS_OPT_TIME_PERIODIC,&err );
    GSM_PWR_KEY(0);                                    /* power key down */
    OSTimeDly( 2000);//,OS_OPT_TIME_PERIODIC,&err );
    ctr = 30;
    while(ctr--)
    {
        if( at_cmd_return(&struAt) == SYS_ERR_AT_FAIL )
        {
            GSM_MAIN_PWR(0);                      // main power off
            OSTimeDly( 20000);//,OS_OPT_TIME_PERIODIC,&err );
            return SYS_ERR_OK;
        }
        OSTimeDly( 1000);//,OS_OPT_TIME_PERIODIC,&err );
    }
    return SYS_ERR_AT_FAIL;
}
/*********************************************************************************************************
** Function name:    at_cmd_return
** Descriptions:    send a at cmd and wait for correct response
** input parameters:    STRU_AT
** Output parameters:    NONE
** Returned value:    SYS_ERR_OK, cmd transmit ok, or return SYS_ERR_AT_FAIL
*********************************************************************************************************/
SYS_ERR at_cmd_return( const STRU_AT *at )
{
    //OS_MSG_SIZE size;
    INT8U  err;
    u32 *msg;
    u8 ctr;
    u32 time_start;
    
    ctr = at->time_total;///at->timeout;
    while(ctr--)
    {
        usart_send_str( USART3,at->command );
        #if gsm_debug
        printf("\r\n%s",at->command);
        #endif
        time_start = OSTimeGet();//&err);
        while(OSTimeGet()-time_start < at->timeout*1000)
        {
            msg = OSQPend( msg_gsm_parse,1000,&err );    /* task pend: wait for response */
            if( err == OS_ERR_NONE && (*msg&at->result) != 0 ) return SYS_ERR_OK;    /* get response */
            OSTimeDly( 10);                                    /* error */
        }
    }
    return SYS_ERR_AT_FAIL;
}
/*********************************************************************************************************
** Function name:    at_cmd_list_return
** Descriptions:    send a list of at cmds,
** input parameters:    lists_at_cmds
** Output parameters:    NONE
** Returned value:    SYS_ERR_OK all of at cmds are ok, or return SYS_ERR_AT_FAIL.
*********************************************************************************************************/
SYS_ERR at_cmd_list_return( const STRU_AT *at )
{
    while( at->command != NULL )
    {
        if( at_cmd_return(at) != SYS_ERR_OK ) 
        {
            return SYS_ERR_AT_FAIL;
        }
        at++;    /* next at cmd */
    }
    return SYS_ERR_OK;
}
/*********************************************************************************************************
** Function name:    check_network_stat
** Descriptions:    read csq & creg status
** input parameters:    
** Output parameters:    NONE
** Returned value:    
*********************************************************************************************************/
SYS_ERR check_network_stat()
{
    const STRU_AT *at;
    static u8 cntCregFail = 0,k;
    
    if( ( struGsm.task&(GSM_TASK_PLAY|GSM_TASK_RECORD|GSM_TASK_SAVE_RECORD) ) != 0 ) return SYS_ERR_OK;
    
    at = &struAtNetwork[0];
    if(at_cmd_return(at) != SYS_ERR_OK)
    {
        cntCregFail = 0;
        return SYS_ERR_AT_FAIL;                /* reset now */
    }
    #if 0
    const STRU_AT struAtNetwork[] =         /* Network signal check, request per 6second */
    {
        { "AT\r",RET_OK,1,10},
        { "AT+CSQ\r",RET_OK,2,2},            /* check signal quality */
        { "AT+CGREG?\r",RET_OK,2,2},        /* Check network registration status */
        { "AT+CEREG?\r",RET_OK,2,2},        /* Check network registration status */
        { NULL, NULL, 0, 0},
    };
    #endif
    k=1;
    at = &struAtNetwork[1];
    while(k)
    {
        if(at_cmd_return(at) != SYS_ERR_OK)        /* check CSQ*/
        {
            if(++cntCregFail >= 90)                /* normal 6s once time, 90*6/60=9 mins no sign,network failed. */
            {
                cntCregFail = 0;
                return SYS_ERR_AT_FAIL;
            }
        }
        else
        {
            if(k!=2)
            {
                if(g_M25_M26_specific==4)
                {
                    at = &struAtNetwork[3];
                }
                else
                {
                    at = &struAtNetwork[2];
                }
                k=2;
            }
            else 
            {
                k=0;
            }
            cntCregFail = 0;
        }
    }
    return SYS_ERR_OK;
}
/*********************************************************************************************************
** Function name:    gsm_at_init
** Descriptions:    
** input parameters:    
** Output parameters:    NONE
** Returned value: 
*********************************************************************************************************/
SYS_ERR gsm_at_init( ENUM_MODULE module )
{
    /*
    { "ATE0\r",RET_OK,1,2},
    { "AT+CMGF=1\r",RET_OK,1,60},        Message format configuration: 1=Text /
    { "AT+CLIP=1\r",RET_OK,1,60},        Mobile terminating call indication /
    { "AT+CNMI=2,1\r",RET_OK,2,60},      SMS Event reporting configuration /
    { "AT+CMGL=\"ALL\"\r",RET_OK,5,60},  List all message /
    { NULL, NULL, 0, 0},
    */
    const STRU_AT *at = &struAtInit[0];
    if( at_cmd_list_return(at) != SYS_ERR_OK ) return SYS_ERR_AT_FAIL;
    
    if( module == MODULE_UC15 )
    {
        return at_cmd_list_return( &AT_UC15_INIT_UART[0] );
    }else if(( module == MODULE_EC200S )||(module == MODULE_EC25))
    {
    /*
    { "AT+QURCCFG=\"urcport\",\"uart1\"\r",RET_OK,2,6},  urc configuration
    { NULL, NULL, 0, 0},
    */
        return at_cmd_list_return( &AT_EC200S_EC25_INIT_UART[0] );
    }
    return SYS_ERR_OK;
}
/*********************************************************************************************************
** Function name:    gsm_save_record
** Descriptions:    
** input parameters:    
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_save_record( ENUM_MODULE module )
{
    OS_CPU_SR cpu_sr=0;
    const STRU_AT AT_QFLST[] =
    {
        {"AT+QFLST=\"RAM:record.amr\"\r",RET_QFLST,1,1},    /* m26 module:list the record.arm file in RAM */
        {"AT+QFLST=\"UFS:record.wav\"\r",RET_QFLST,2,2},    /* uc15 module:list the record.wav file in UFS */
        {"AT+QFLST=\"*\"\r",RET_QFLST,2,2},                    /* ec200s module:list all of files  in UFS */
        {"AT+QFLST=\"*\"\r",RET_QFLST,2,2},
    };

    const STRU_AT AT_UC15_SAVE_RECORD = {"AT+QFMOV=\"UFS:record.wav\",\"UFS:play.wav\",1,1\r",RET_OK,3,3};    /* not used for ec200s module */
    #if WReadCounter_Enable
    const STRU_AT AT_QFOPEN_M26 = {"AT+QFOPEN=\"RAM:record.amr\",2,3128\r",RET_QFOPEN,1,1};                
    #else
    const STRU_AT AT_QFOPEN_M26 = {"AT+QFOPEN=\"RAM:record.amr\",2,16384\r",RET_QFOPEN,1,1};                
    #endif
    
    /* if .amr file exist? and get the file lenth if exist */
    if(g_M25_M26_specific==2)
    {
        ;;
    }
    else if(g_M25_M26_specific==3)
    {
        ;;
    }
    else if( at_cmd_return( &AT_QFLST[module] ) != SYS_ERR_OK ) 
    {
        return SYS_ERR_AT_FAIL;
    }
    
    if( module == MODULE_UC15 )
    {
        if( at_cmd_return( &AT_UC15_SAVE_RECORD ) != SYS_ERR_OK ) return SYS_ERR_AT_FAIL;
    }
    else if ((module == MODULE_EC200S)||(module == MODULE_EC25))
    {
        if (struParaSet.dat.record_audio[0].IsRecord == RECORD_RECORDING)
        {
            struParaSet.dat.record_audio[0].IsRecord = RECORD_RECORDED;
            struParaSet.dat.record_audio[1].IsRecord = RECORD_NULL;
        }
        else if (struParaSet.dat.record_audio[1].IsRecord == RECORD_RECORDING)
        {
            struParaSet.dat.record_audio[1].IsRecord = RECORD_RECORDED;
            struParaSet.dat.record_audio[0].IsRecord = RECORD_NULL;
        }
    }
    else if(g_M25_M26_specific==2)
    {
        struGsm.amr.total = 1000;
    }
    else if(g_M25_M26_specific==3)
    {
        struGsm.amr.total = 1000;
    }
    else
    {
//        OS_ERR err;
        char *p;
        u8 i;
        STRU_AT struAt = {NULL,RET_QFREAD,3,3};
        //if(g_M25_M26_specific==0)
            if( at_cmd_return( &AT_QFOPEN_M26 ) != SYS_ERR_OK ) return SYS_ERR_AT_FAIL;        /* get filehandle */
        //else
            //if( at_cmd_return( &AT_QFOPEN_M25 ) != SYS_ERR_OK ) return SYS_ERR_AT_FAIL;        /* get filehandle */

        task_global |= TASK_GLOBAL_ERASE_ENCODE;
        while( task_global&TASK_GLOBAL_ERASE_ENCODE ) OSTimeDly( 100);//,OS_OPT_TIME_DLY,&err );
        p = mymalloc(64);
        #if WReadCounter_Enable
        g_u8_WReadCounter = 0;
        #endif
        for( i=0;i<struGsm.amr.total/PAGE_SIZE+((struGsm.amr.total%PAGE_SIZE)?1:0);i++ )
        {
            /* read one block */
            //CPU_SR_ALLOC();
            OS_ENTER_CRITICAL();
            pStruUsartGsm->timeout = 20;
            OS_EXIT_CRITICAL();
            sprintf( p,"AT+QFREAD=%d,%d\r",struGsm.amr.filehandle,PAGE_SIZE );
            struAt.command = p;
            if( at_cmd_return( &struAt ) != SYS_ERR_OK )
            {
                break;
            }
            OS_ENTER_CRITICAL();
            pStruUsartGsm->timeout = 5;    // 5
            OS_EXIT_CRITICAL();
            
            struGsm.amr.page = i;
            #if WReadCounter_Enable
            g_u8_WReadCounter++;
            #endif
            task_global |= TASK_GLOBAL_WRITE_AUDIO;
            while( task_global&TASK_GLOBAL_WRITE_AUDIO ) OSTimeDly( 100);//,OS_OPT_TIME_DLY,&err );
        }
        /* !!!close file */
        sprintf( p,"AT+QFCLOSE=%d\r",struGsm.amr.filehandle );
        struAt.command = p;
        struAt.result = RET_OK;
        at_cmd_return( &struAt );
        myfree(p);
    }
    
    /* save the lenth of record file */
    struParaSet.dat.audio_file_len = struGsm.amr.total;
    task_global |= TASK_GLOBAL_WR_PARA_SET;
    
    return SYS_ERR_OK;
}
/*********************************************************************************************************
** Function name:    gsm_audio_record
** Descriptions:    
** input parameters:    
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_audio_record( ENUM_MODULE module )
{
    /*
    for amr format: 40.8KB ver 1m
    record.amr
    */
//    OS_ERR err;
    
    /* 
    { "AT+QFLDS=\"UFS\"\r",RET_OK,2,6},
    return:+QFLDS: <free_size>,<total_size>
    EC200S:+QFLDS: 6582272,6938624 (Byte) 
    */
    
    const STRU_AT AT_QFDEL_EC200S_EC25 = {"AT+QFDEL=\"*\"\r",RET_OK,2,2};  /* delete all files in UFS,Not include catalogue */    
    const STRU_AT AT_QFDEL0_EC25 = {"AT+QFDEL=\"record0.wav\"\r",RET_OK,2,2};
    const STRU_AT AT_QFDEL1_EC25 = {"AT+QFDEL=\"record1.wav\"\r",RET_OK,2,2};
    const STRU_AT AT_QFDEL0_EC200S = {"AT+QFDEL=\"UFS:record0.wav\"\r",RET_OK,2,2};/* delete a file in UFS */
    const STRU_AT AT_QFDEL1_EC200S = {"AT+QFDEL=\"UFS:record1.wav\"\r",RET_OK,2,2};/* Delete a file in UFS */
    const STRU_AT AT_QFDEL0_EC200n = {"AT+QFDEL=\"UFS:record0.amr\"\r",RET_OK,2,2};/* delete a file in UFS */
    const STRU_AT AT_QFDEL1_EC200n = {"AT+QFDEL=\"UFS:record1.amr\"\r",RET_OK,2,2};/* Delete a file in UFS */
    const STRU_AT AT_QFLST_EC200S_EC25 = {"AT+QFLST=\"*\"\r",RET_OK,2,2};          /* list All files in UFS */
    
    const STRU_AT AT_START_RECORD0_EC200S = {"AT+QAUDRD=1,\"record0.wav\",13,1\r",RET_OK,2,2};/* Record a Media file in wav format,store it in UFS,Name as record0 */
    const STRU_AT AT_START_RECORD1_EC200S = {"AT+QAUDRD=1,\"record1.wav\",13,1\r",RET_OK,2,2};/* Record a Media file in wav format,store it in UFS,Name as record1 */
    const STRU_AT AT_AUDIO_PLAYBACK0_EC200S = {"AT+QAUDPLAY=\"record0.wav\",0\r",RET_OK,2,2};/* Play the medio file,not repeat,volume is 7 */
    const STRU_AT AT_AUDIO_PLAYBACK1_EC200S = {"AT+QAUDPLAY=\"record1.wav\",0\r",RET_OK,2,2};/* Play the medio file,not repeat,volume is 7 */
    
    const STRU_AT AT_START_RECORD0_EC200n = {"AT+QAUDRD=1,\"record0.amr\",13\r",RET_OK,2,2};/* Record a Media file in wav format,store it in UFS,Name as record0 */
    const STRU_AT AT_START_RECORD1_EC200n = {"AT+QAUDRD=1,\"record1.amr\",13\r",RET_OK,2,2};/* Record a Media file in wav format,store it in UFS,Name as record1 */
    const STRU_AT AT_AUDIO_PLAYBACK0_EC200n = {"AT+QAUDPLAY=\"record0.amr\",0\r",RET_OK,2,2};/* Play the medio file,not repeat,volume is 7 */
    const STRU_AT AT_AUDIO_PLAYBACK1_EC200n = {"AT+QAUDPLAY=\"record1.amr\",0\r",RET_OK,2,2};/* Play the medio file,not repeat,volume is 7 */
    
    const STRU_AT AT_START_RECORD0_EC25 = {"AT+QAUDRD=1,\"record0.wav\",13,0\r",RET_OK,2,2};
    const STRU_AT AT_START_RECORD1_EC25 = {"AT+QAUDRD=1,\"record1.wav\",13,0\r",RET_OK,2,2};
    const STRU_AT AT_AUDIO_PLAYBACK0_EC25 = {"AT+QPSND=1,\"record0.wav\",0,0,1\r",RET_OK,2,2};
    const STRU_AT AT_AUDIO_PLAYBACK1_EC25 = {"AT+QPSND=1,\"record1.wav\",0,0,1\r",RET_OK,2,2};
    
    const STRU_AT AT_QFDEL_UC15 = {"AT+QFDEL=\"UFS:record.wav\"\r",RET_OK,2,2};
    const STRU_AT AT_START_RECORD_UC15 = {"AT+QAUDRD=1,\"UFS:record.wav\",13,0\r",RET_OK,2,2};
    const STRU_AT AT_QFLST_UC15 = {"AT+QFLST=\"UFS:*\"\r",RET_OK,2,2};                /* list files */
    const STRU_AT AT_AUDIO_PLAYBACK_UC15 = {"AT+QPSND=1,\"UFS:record.wav\",0\r",RET_OK,2,2};

    const STRU_AT AT_QFDEL_M26 = {"AT+QFDEL=\"RAM:record.amr\"\r",RET_OK,1,1};
    const STRU_AT AT_START_RECORD_M26 = {"AT+QAUDRD=1,\"RAM:record.amr\"\r",RET_OK,1,1};
    //------------------ M25 -----------------------------
    const STRU_AT AT_START_RECORD_M25 = {"AT+QAUDRD=1,\"RAM:record.amr\",3,1\r",RET_OK,1,1};
    
    const STRU_AT AT_QFLST_M26 = {"AT+QFLST=\"RAM:*\"\r",RET_OK,1,1};                /* list files */
    
    
    //------------------- SIMCom -------------------------
    const STRU_AT AT_QFDEL_SIMCom = {NULL,NULL,0,0};//{"AT+CFSDFILE=0,\"record.amr\"",RET_OK,2,2};    /* delete */
    const STRU_AT AT_START_RECORD_SIMCom = {"AT+SRD=2\r",RET_OK,1,1};   /* record */
    const STRU_AT AT_STOP_RECORD_SIMCom = {"AT+SRD=3\r",RET_OK,2,2};    /* record stop */
    const STRU_AT AT_QFLST_SIMCom = {"AT+CFSLFILE\r",RET_OK,1,1};       /* list files */
    
    
    const STRU_AT AT_QFDEL_SIMCom7 = {NULL,NULL,0,0};//{"AT+FSDEL=\"re.wav\"\r",RET_OK,1,1};    /* delete; AT+FSDEL=<filename> */
    const STRU_AT AT_START_RECORD_SIMCom7 = {" AT+CREC=1,\"C:/re.wav\"\r",RET_OK,1,1};   /* record */
    const STRU_AT AT_STOP_RECORD_SIMCom7 = {"AT+CREC=0\r",RET_OK,2,2};      /* record stop */
    const STRU_AT AT_QFLST_SIMCom7 = {"AT+FSLS\r",RET_OK,2,2};              /* list files */
    
    
    
    const STRU_AT AT_AUDIO_PLAYBACK_M26 = {"AT+QAUDPLAY=\"RAM:record.amr\",0,60,0\r",RET_OK,1,1};

    const STRU_AT AT_STOP_RECORD = {"AT+QAUDRD=0\r",RET_OK,2,2};

    //const STRU_AT AT_QSIDET = { "AT+QSIDET=8192\r",RET_OK,2,2};
    
    SYS_ERR result;
    const STRU_AT *del,*record,*lst,*playback,*stop;
    
    /********** load at commands *******************/
    if(g_M25_M26_specific==2)
    {
        del = &AT_QFDEL_SIMCom;
        record = &AT_START_RECORD_SIMCom;
        lst = &AT_QFLST_SIMCom;
        playback = &AT_PLAY_SIMCom;
        stop = &AT_STOP_RECORD_SIMCom;
    }
    else if(g_M25_M26_specific==3)
    {
        del = &AT_QFDEL_SIMCom7;
        record = &AT_START_RECORD_SIMCom7;
        lst = &AT_QFLST_SIMCom7;
        playback = &AT_PLAY_SIMCom7;
        stop = &AT_STOP_RECORD_SIMCom7;
    }
    else if( module == MODULE_M26 )
    {
        del = &AT_QFDEL_M26;
        if((g_M25_M26_specific==0) || (g_Version_M25MAR01A11==0)) // 1=for version=higher than 07
        //if(1)                       //for version=07
        {
            record = &AT_START_RECORD_M26;
        }
        else  
        {
            record = &AT_START_RECORD_M25;
        }
        lst = &AT_QFLST_M26;
        playback = &AT_AUDIO_PLAYBACK_M26;
        stop = &AT_STOP_RECORD;
    }
    else if (module == MODULE_EC200S)
    {
        at_cmd_return( &AT_RECORD_MIC_EC200S);  /* mic configuration: cmd="AT+QMIC=8192\r"  Set Uplink Gains of MIC: 8192  */
        //del = &AT_QFDEL0_EC200S;                /* delete cmd:"AT+QFDEL=\"UFS:record0.wav\"\r" */
        //record = &AT_START_RECORD0_EC200S;      /* record cmd:"AT+QAUDRD=1,\"UFS: record0.wav\",13,1\r" */
        //lst = &AT_QFLST_EC200S_EC25;                 /* listed cmd:"AT+QFLST=\"*\"\r" */
        //playback = &AT_AUDIO_PLAYBACK0_EC200S;  /* played cmd:"AT+QAUDPLAY=\"record0.wav\",0,7\r" */
        stop = &AT_STOP_RECORD;
    }
    else if (module == MODULE_EC25)
    {
        at_cmd_return( &AT_RECORD_MIC_EC25);
        //del = &AT_QFDEL0_EC25;
        //record = &AT_START_RECORD0_EC25;
        //lst = &AT_QFLST_EC200S_EC25;
        //playback = &AT_AUDIO_PLAYBACK0_EC25;
        stop = &AT_STOP_RECORD;
    }
    else
    {
        at_cmd_return( &AT_RECORD_MIC_UC15 );
        
        del = &AT_QFDEL_UC15;
        record = &AT_START_RECORD_UC15;
        lst = &AT_QFLST_UC15;
        playback = &AT_AUDIO_PLAYBACK_UC15;
        stop = &AT_STOP_RECORD;
    }
    
    if ((module == MODULE_EC200S)||(module == MODULE_EC25))
    {
        lst = &AT_QFLST_EC200S_EC25;
        if (struParaSet.dat.record_audio[0].IsRecord == RECORD_NULL && struParaSet.dat.record_audio[1].IsRecord == RECORD_NULL)
        {
            del = &AT_QFDEL_EC200S_EC25;                /* "AT+QFDEL=\"*\"\r",files both did not record, record file0 */
            if(module == MODULE_EC25)
            {
                record = &AT_START_RECORD0_EC25;
                playback = &AT_AUDIO_PLAYBACK0_EC25;
            }
            else
            {
                if(ec200n_dk==1)
                {
                    record = &AT_START_RECORD0_EC200n;
                    playback = &AT_AUDIO_PLAYBACK0_EC200n;
                }
                else
                {
                    record = &AT_START_RECORD0_EC200S;
                    playback = &AT_AUDIO_PLAYBACK0_EC200S;
                }
            }
            struParaSet.dat.record_audio[0].IsRecord = RECORD_RECORDING;
        }
        else if (struParaSet.dat.record_audio[0].IsRecord == RECORD_NULL && struParaSet.dat.record_audio[1].IsRecord == RECORD_RECORDED)
        {
            if(module == MODULE_EC25)
            {
                del = &AT_QFDEL0_EC25;
                record = &AT_START_RECORD0_EC25;
                playback = &AT_AUDIO_PLAYBACK0_EC25;
            }
            else if(ec200n_dk==1)
            {
                del = &AT_QFDEL0_EC200n;            /* file1 recorded, record file0 */
                record = &AT_START_RECORD0_EC200n;
                playback = &AT_AUDIO_PLAYBACK0_EC200n;
            }
            else
            {
                del = &AT_QFDEL0_EC200S;            /* file1 recorded, record file0 */
                record = &AT_START_RECORD0_EC200S;
                playback = &AT_AUDIO_PLAYBACK0_EC200S;
            }
            struParaSet.dat.record_audio[0].IsRecord = RECORD_RECORDING;
        }
        else if (struParaSet.dat.record_audio[0].IsRecord == RECORD_RECORDING)
        {
            if(module == MODULE_EC25)
            {
                del = &AT_QFDEL0_EC25;
                record = &AT_START_RECORD0_EC25;
                playback = &AT_AUDIO_PLAYBACK0_EC25;
            }
            else if(ec200n_dk==1)
            {
                del = &AT_QFDEL0_EC200n;            /* file0 is recording, record file0 */
                record = &AT_START_RECORD0_EC200n;
                playback = &AT_AUDIO_PLAYBACK0_EC200n;
            }
            else
            {
                del = &AT_QFDEL0_EC200S;            /* file0 is recording, record file0 */
                record = &AT_START_RECORD0_EC200S;
                playback = &AT_AUDIO_PLAYBACK0_EC200S;
            }
            struParaSet.dat.record_audio[0].IsRecord = RECORD_RECORDING;
        }
        else if (struParaSet.dat.record_audio[0].IsRecord == RECORD_RECORDED)
        {
            if(module == MODULE_EC25)
            {
                del = &AT_QFDEL1_EC25;
                record = &AT_START_RECORD1_EC25;
                playback = &AT_AUDIO_PLAYBACK1_EC25;
            }
            else if(ec200n_dk==1)
            {
                del = &AT_QFDEL1_EC200n;            /* file0 is recorded, record flie1 */
                record = &AT_START_RECORD1_EC200n;
                playback = &AT_AUDIO_PLAYBACK1_EC200n;
            }
            else
            {
                del = &AT_QFDEL1_EC200S;            /* file0 is recorded, record flie1 */
                record = &AT_START_RECORD1_EC200S;
                playback = &AT_AUDIO_PLAYBACK1_EC200S;
            }
            struParaSet.dat.record_audio[1].IsRecord = RECORD_RECORDING;
        }
        else
        {
            del = &AT_QFDEL_EC200S_EC25;                /* else delete all files, record file0 */
            if(module == MODULE_EC25)
            {
                record = &AT_START_RECORD0_EC25;
                playback = &AT_AUDIO_PLAYBACK0_EC25;
            }
            else if(ec200n_dk==1)
            {
                record = &AT_START_RECORD0_EC200n;
                playback = &AT_AUDIO_PLAYBACK0_EC200n;
            }
            else
            {
                record = &AT_START_RECORD0_EC200S;
                playback = &AT_AUDIO_PLAYBACK0_EC200S;
            }
            struParaSet.dat.record_audio[0].IsRecord = RECORD_RECORDING;
        }
        task_global |= TASK_GLOBAL_WR_PARA_SET;
    }
    
    at_cmd_return( del );
    at_cmd_return( lst );

    set_audio_mode( AUDIO_MODE_RECORD );        /* hardware circuit configuration */
    
    pgsGsm = PGS_GSM_RECORD;
    tmrRecord = struParaSet.dat.record_duration*1000/10;
    at_cmd_return( record );                    /* start record audio file */
    while( tmrRecord )                            /* decrease per 10ms */
    {
        if((struGsm.task&GSM_TASK_RECORD) == 0)
        {
            at_cmd_return( stop );            /* stop record:"AT+QAUDRD=0\r" */
            OSTimeDly( 100);//,OS_OPT_TIME_PERIODIC,&err );
            return result;
        }
        OSTimeDly( 10);//,OS_OPT_TIME_PERIODIC,&err );
    }
    at_cmd_return( stop );            /* stop "AT+QAUDRD=0\r" */
    OSTimeDly( 2000);//,OS_OPT_TIME_PERIODIC,&err );
    
    /* playback */
    at_cmd_return( lst );
    tmrRecord = struParaSet.dat.record_duration*1000/10;
    pgsGsm = PGS_GSM_PLAY;
    at_cmd_return( playback );
    set_audio_mode( AUDIO_MODE_PLAYBACK_ONSITE );
    while( tmrRecord ) OSTimeDly( 10);//,OS_OPT_TIME_PERIODIC,&err );
    
    return result;
}
/*********************************************************************************************************
** Function name:    gsm_file_to_voice_call
** Descriptions:    audio file to voice call
** input parameters:    
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_file_to_voice_call( ENUM_MODULE module )
{
//    OS_ERR err;
    SYS_ERR result;
    
    const STRU_AT AT_AUDIO_PLAY[] = 
    {
        {"AT+QAUDPLAY=\"RAM:play.amr\",0,60,0\r",RET_OK,1,1},    /* not used for ec200s module. not repeat,volume=100,channel=0 */
        {"AT+QPSND=1,\"UFS:play.wav\",0\r",RET_OK,2,2},            /* Play Audio File and Send it to the Remote in Call */
        {NULL,0,0,0},
        {NULL,0,0,0},
    };
    
    const STRU_AT AT_AUDIO_PLAY0_EC200S_EC25 = {"AT+QPSND=1,\"record0.wav\",0,0,1\r",RET_OK,2,2};
    const STRU_AT AT_AUDIO_PLAY1_EC200S_EC25 = {"AT+QPSND=1,\"record1.wav\",0,0,1\r",RET_OK,2,2};
    const STRU_AT AT_AUDIO_PLAY0_EC200n = {"AT+QPSND=1,\"record0.amr\",0,0,1\r",RET_OK,2,2};
    const STRU_AT AT_AUDIO_PLAY1_EC200n = {"AT+QPSND=1,\"record1.amr\",0,0,1\r",RET_OK,2,2};
    //const STRU_AT AT_AUDIO_PLAY0_EC200n = {"AT+QAUDPLAY=\"record0.amr\",0\r",RET_OK,2,2};/* Play the medio file,not repeat,volume is 7 */
    //const STRU_AT AT_AUDIO_PLAY1_EC200n = {"AT+QAUDPLAY=\"record1.amr\",0\r",RET_OK,2,2};/* Play the medio file,not repeat,volume is 7 */
    
    if ((module == MODULE_EC200S)||(module == MODULE_EC25))
    {
        if (struParaSet.dat.record_audio[0].IsRecord == RECORD_RECORDED)
        {
            if(ec200n_dk==1)
            {
                result = at_cmd_return( &AT_AUDIO_PLAY0_EC200n );
            }
            else
            {
                result = at_cmd_return( &AT_AUDIO_PLAY0_EC200S_EC25 );
            }
        }
        else if (struParaSet.dat.record_audio[1].IsRecord == RECORD_RECORDED)
        {
            if(ec200n_dk==1)
            {
                result = at_cmd_return( &AT_AUDIO_PLAY1_EC200n );
            }
            else
            {
                result = at_cmd_return( &AT_AUDIO_PLAY1_EC200S_EC25 );
            }
        }
        else 
        {
            if(ec200n_dk==1)
            {
                result = at_cmd_return( &AT_AUDIO_PLAY0_EC200n );
            }
            else
            {
                result = at_cmd_return( &AT_AUDIO_PLAY0_EC200S_EC25 );
            }
        }
            
    }
    else if(g_M25_M26_specific==2)
    {
        result = at_cmd_return( &AT_PLAY_SIMCom );
    }
    else if(g_M25_M26_specific==3)
    {
        result = at_cmd_return( &AT_PLAY_SIMCom7);
    }
    else
    {
        result = at_cmd_return( &AT_AUDIO_PLAY[module] );
    }
    tmrRecord = struParaSet.dat.record_duration*1000/10;
    pgsGsm = PGS_GSM_PLAY;
    while( tmrRecord )
    {
        set_audio_mode( AUDIO_MODE_PLAYBACK_ONSITE );
        OSTimeDly( 10);//,OS_OPT_TIME_PERIODIC,&err );
    }
    return result;
}
/*********************************************************************************************************
** Function name:    gsm_audio_read
** Descriptions:    list audio file from gsm flash memory
** input parameters:    
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_audio_read( ENUM_MODULE module )
{
    SYS_ERR Result;
    u8 index;
    const STRU_AT AT_QFLST_READ[] =
    {
        {"AT+QFLST=\"record0.wav\"\r",RET_QFLST,4,8},
        {"AT+QFLST=\"record1.wav\"\r",RET_QFLST,4,8},
        {"AT+QFLST\r",RET_QFLST,4,8},
    };
    #if WReadCounter_Enable
    if(g_u8_WReadCounter==0)
    #else
    if(struParaSet.dat.audio_file_len == 0 ) 
    #endif
    {
        printf("struParaSet.dat.audio_file_len=0 return gsm_audio_read.\r");
        return SYS_ERR_AT_FAIL;
    }
    
    if( module == MODULE_UC15 )
    {
        /* UC15 :MCU flash move to module is unnecessary */
        if( at_cmd_return( &struAtSendPlay_UC15[0] ) != SYS_ERR_OK )
        {
            struParaSet.dat.audio_file_len = 0;
            task_global |= TASK_GLOBAL_WR_PARA_SET;
            return SYS_ERR_AT_FAIL;
        }
    }
    else if(( module == MODULE_EC200S )||(module == MODULE_EC25))
    {
        if (struParaSet.dat.record_audio[0].IsRecord == RECORD_RECORDED) 
        {
            index = 0;         /* if file0 is recorded, list file0 */
        }
        else if (struParaSet.dat.record_audio[1].IsRecord == RECORD_RECORDED) 
        {
            index = 1;
        }    /* if file0 did not record,and file1 is recorded,list file1 */
        else                                                                            /* if both files did not record, return failed */
        {
            index = 0;
            struParaSet.dat.audio_file_len = 0;
            task_global |= TASK_GLOBAL_WR_PARA_SET;
            return SYS_ERR_AT_FAIL;
        }
        if(ec200n_dk==1)
        {
            index = 2;
        }
        Result = at_cmd_return( &AT_QFLST_READ[index]);
        if( Result != SYS_ERR_OK )                      /* list file which is recorded. */
        {     
            struParaSet.dat.audio_file_len = 0;
            task_global |= TASK_GLOBAL_WR_PARA_SET;
            return SYS_ERR_AT_FAIL;
        }
    }
    else if(g_M25_M26_specific==2)
    {
        ;;
    }
    else if(g_M25_M26_specific==3)
    {
        ;;
    }
    else    /* for ec200s is not used */
    {
//        OS_ERR err;
        char *p;
        u16 i;
        u16 remain;
        STRU_AT struAt = {NULL,RET_CONNECT,3,3};
        const STRU_AT AT_QFDEL_PLAY = {"AT+QFDEL=\"RAM:play.amr\"\r",RET_OK,2,2};
        #if WReadCounter_Enable
        const STRU_AT AT_QFOPEN_PLAY = {"AT+QFOPEN=\"RAM:play.amr\",0,3128\r",RET_QFOPEN,1,1};/* Open the file named <filename> in RAM. If the file does not exist, then create it, and set the max length of the file with value 1024. If the file exists in RAM, just open it, and ignore the length 1024. */ 
        #else
        const STRU_AT AT_QFOPEN_PLAY = {"AT+QFOPEN=\"RAM:play.amr\",0,16384\r",RET_QFOPEN,1,1};/* Open the file named <filename> in RAM. If the file does not exist, then create it, and set the max length of the file with value 1024. If the file exists in RAM, just open it, and ignore the length 1024. */ 
        #endif
        at_cmd_return( &AT_QFDEL_PLAY );
        /* get filehandle */
        //if(g_M25_M26_specific==0)
            if( at_cmd_return( &AT_QFOPEN_PLAY ) != SYS_ERR_OK ) return SYS_ERR_AT_FAIL;
        //else
            //if( at_cmd_return( &AT_QFOPEN_PLAY_M25 ) != SYS_ERR_OK ) return SYS_ERR_AT_FAIL;
            
        struGsm.amr.total = struParaSet.dat.audio_file_len;
        if( struGsm.amr.total > PAGE_SIZE*(9) )
        {
            struGsm.amr.total = PAGE_SIZE*(9);
        }
        
        p = mymalloc(64);
        struAt.command = p;
        remain = struGsm.amr.total;
        #if WReadCounter_Enable
//        printf("g_u8_WReadCounter=%d\n",g_u8_WReadCounter);
//        for(i=0;i<g_u8_WReadCounter;i++)
        #else
        for( i=0;i<struGsm.amr.total/PAGE_SIZE+((struGsm.amr.total%PAGE_SIZE)?1:0);i++ )
        #endif
        {
            /* read one block */
            struGsm.amr.page = i;
            task_global |= TASK_GLOBAL_READ_AUDIO;
            while( task_global&TASK_GLOBAL_READ_AUDIO ) OSTimeDly( 10);//,OS_OPT_TIME_PERIODIC,&err );
            
            struAt.result = RET_CONNECT;
            sprintf( p,"AT+QFWRITE=%d,%d\r",struGsm.amr.filehandle,(remain>=PAGE_SIZE)?(PAGE_SIZE):(remain) );
            at_cmd_return( &struAt );                /* wait connenct ack */
            
            struAt.result = RET_OK;
            *p = 0;
            usart_send_bytes( USART3,(u8*)struGsm.amr.buf,(remain>=PAGE_SIZE)?(PAGE_SIZE):(remain) );
            at_cmd_return( &struAt );
            remain -= PAGE_SIZE;
        }
        struAt.result = RET_OK;
        sprintf( p,"AT+QFSEEK=%d,0,0\r",struGsm.amr.filehandle );
        at_cmd_return( &struAt );
        sprintf( p,"AT+QFREAD=%d\r",struGsm.amr.filehandle );
        at_cmd_return( &struAt );
        sprintf( p,"AT+QFCLOSE=%d\r",struGsm.amr.filehandle );
        at_cmd_return( &struAt );
        myfree(p);
    }
    
    return SYS_ERR_OK;
}
/*********************************************************************************************************
** Function name:    gsm_set_clock
** Descriptions:    get time from network
{ "AT+CTZU=1\r",RET_OK,1,2},    / Automatic Time Zone Update /
{ "AT+QLTS\r",RET_QLTS,2,10},   / Obtain the Latest Time Synchronized Through Network /
{ NULL, NULL, 0, 0},
** input parameters:    
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_set_clock( char *domain,ENUM_MODULE module )
{
    SYS_ERR result;
    char *p;
    STRU_AT struAt = {NULL,RET_OK,1,2};
    
    const STRU_AT *at1;
    const STRU_AT at_cclk = {"AT+CCLK?\r",RET_OK,1,2};/* Query the local time */
    
    const STRU_AT CNTP[] =        /* not used for ec200s module */
    {
        {"at+cgreg?\r",RET_OK,1,5},
        { "AT+SAPBR=3,1,\"Contype\",\"GPRS\"\r",RET_OK,1,2},
        { "AT+SAPBR=1,1\r",RET_OK,2,2},                     //PPP
        { "AT+CNTPCID=1\r",RET_OK,2,2},                     //CID
        { NULL, NULL, 0, 0},
    };
    
    /*STRU_AT CNTP_en[] =
    {
        { "AT+CNTP=\"ntp1.aliyun.com\",00\r",RET_OK,2,2},
        { "AT+CNTP\r",RET_NTP,2,2},
        { NULL, NULL, 0, 0},
    };
    const STRU_AT CNTP_ch[] =
    {
        { "AT+CNTP=\"ntp1.aliyun.com\",32\r",RET_OK,2,2},
        { "AT+CNTP\r",RET_NTP,2,2},
        { NULL, NULL, 0, 0},
    };*/
    STRU_AT CNTP_at[] =
    {
        { "AT+CNTP\r",RET_NTP,2,2},
        { NULL, NULL, 0, 0},
    };
    /*
    等cgreg返回0，1后，AT+CNTP="ntp1.aliyun.com",32 设置东8区， 
    然后发AT+CNTP返回+CNTP: 0 代表同步成功
    */
    /* Query the local time 
    const STRU_AT CNTP_ENG = {"AT+CNTP=\"ntp1.aliyun.com\",00\r",RET_OK,1,2};
    const STRU_AT CNTP_CHN = {"AT+CNTP=\"ntp1.aliyun.com\",32\r",RET_OK,1,2};*/
    const STRU_AT struAtNetworkTime_SIMCom7670[] =    /* for ec200s module */
    {
        { "AT+CNTP\r",RET_NTP,5,5},     /* +CNTP: 0 */
        { "AT+CTZU=1\r",RET_OK,5,5},    /* Automatic Time Zone Update */
        { "AT+CTZR=1\r",RET_OK,5,5},    /* Automatic Time Zone Update */
        { NULL, NULL, 0, 0},
    };
    
    p = mymalloc(64);
    struAt.command = p;
    sprintf( p,"AT+CNTP=\"ntp1.aliyun.com\",%d\r",(struParaSet.dat.time_zone<<2)/10);
    
    /*** Get time from network ***/
    if(g_M25_M26_specific==2)
    {
        at1 = &CNTP[0];
    }
    else if(g_M25_M26_specific==3)
    {
        result = at_cmd_return( &struAt );
        if(result !=SYS_ERR_OK)
        {
            myfree(p);
            return SYS_ERR_AT_FAIL;
        }
        at1 = &struAtNetworkTime_SIMCom7670[0];
    }
    else if( module == MODULE_M26 )
    {
        at1 = &struAtNetworkTime_M26[0];
    }
    else
    {
        at1 = &struAtNetworkTime_Default[0];
    }
    if( at_cmd_list_return(at1) != SYS_ERR_OK )
    {
        myfree(p);
        return SYS_ERR_AT_FAIL;
    }
    if(g_M25_M26_specific==2)
    {
        result = at_cmd_return( &struAt );
        if( result != SYS_ERR_OK )
        {
            myfree(p);
            return SYS_ERR_AT_FAIL;
        }
        if( at_cmd_list_return(CNTP_at) != SYS_ERR_OK )
        {
            myfree(p);
            return SYS_ERR_AT_FAIL;
        }
    }
    result = at_cmd_return( &at_cclk );        /* get network clock now */
    myfree(p);
    return result;
}
/*********************************************************************************************************
** Function name:    gsm_set_tcp_config
** Descriptions:    TCP/IP context Configuration
** input parameters:    
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_set_tcp_config(ENUM_MODULE module )
{
    const STRU_AT *at;
    
    STRU_AT struAt = {NULL,RET_OK,2,2};
    
    char *p;
    s8 *apn;
    SYS_ERR result;
    
    //========================== APN =============================
    p = mymalloc(32);
    if(!strncmp((const char*)struGsm.iccid,(const char*)ATT_ICCID,5))//the first five digital
    {
        //89011
        apn = (s8*)AT_ATT_CGDCONT;
    }
    else if(!strncmp((const char*)&struGsm.iccid[2],(const char*)CHINA_ICCID,2))
    {
        //china 898601,898606,898609
        if((struGsm.iccid[4]=='0')&&(struGsm.iccid[5]=='1'||struGsm.iccid[5]=='6'||struGsm.iccid[5]=='9'))//for China Unicom-apn=scuiot
        {
            apn = (s8*)AT_CHINA_UNICOM;
        }
        else
        {
            apn= (s8*)AT_CHINA_CGDCONT;
        }
    }
    else if(!strncmp((const char*)&struGsm.iccid[2],(const char*)USA_ICCID,2))
    {
        //USA 01
        apn= (s8*)AT_USA_CGDCONT;
    }
    else if(!strncmp((const char*)&struGsm.iccid[2],(const char*)UK_ICCID,2))
    {
        //Europe 44
        apn= (s8*)AT_UK_CGDCONT;
    }
    else if(!strncmp((const char*)&struGsm.iccid[2],(const char*)CANADA_ICCID,2))
    {
        //canada 30
        apn= (s8*)AT_CANADA_CGDCONT;
    }
    else if(!strncmp((const char*)&struGsm.iccid[2],(const char*)NETHERLANDS_ICCID,2))
    {
        //Netherlands 31
        apn= (s8*)AT_NETHERLANDS;
    }
    else 
    {
        //35 
        apn= (s8*)AT_IRELAND_CGDCONT;
    }
    
    if( module == MODULE_UC15 || module == MODULE_EC200S || module == MODULE_EC25)
    {
        sprintf( p,"AT+QICSGP=1,1,\"%s\",\"\",\"\",1\r",apn );/* Configure parameters of a TCP/IP context */
    }
    else if(g_M25_M26_specific==3 || g_M25_M26_specific==4)
    {
        sprintf( p,"AT+CGDCONT=1,\"IP\",\"%s\"\r",apn );
    }
    else
    {
        sprintf( p,"AT+QICSGP=1,\"%s\"\r",apn );
    }
    
    
    struAt.command = p;
    result = at_cmd_return(&struAt);
    
    //===================== close all of socket =========================
    if (g_M25_M26_specific==2)
    {
        at = Deactivate_a_PDP_context_SIMCom;
    }
    else if(g_M25_M26_specific == 3)
    {
        at = Deactivate_a_PDP_context_SIMCom7;
    }
    else if(g_M25_M26_specific==4)
    {
        at = Deactivate_a_PDP_context_SIMCom4;
    }
    else if( module == MODULE_M26 )
    {
        at = &struAtTcpConfig_M26[0];
    }
    else
    {
        at = &AT_Deactivate_a_PDP_context[0];
    }
    result = at_cmd_list_return(at);
    myfree(p);
    return result;
}
/*********************************************************************************************************
** Function name:    gsm_set_tcp_connect
** Descriptions:    Activate a PDP context, then login the server via IP address and port.
** contextID=1,socketID=0,
** input parameters:    
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_set_tcp_connect( u8 index,u8 mode,STRU_IP *ip,ENUM_MODULE module )
{
    const char *CHANNEL_MODE[] = {"TCP","UDP"};
    STRU_AT struAt = {NULL,RET_CONNECT,45,45};
    char *p;
    SYS_ERR result;
    
    if( module == MODULE_UC15 || module == MODULE_EC200S || module == MODULE_EC25 )
    {
        if( at_cmd_return(&AT_UC15_CHECK_CONTEXT) != SYS_ERR_OK )    /* check PDP context */
        {
            /* Query the state of context and activate PDP context if deactivated */
            result = at_cmd_return(&AT_UC15_CONTEXT);                /* active a PDP context, context_id=1:"AT+QIACT=1\r" */
            if( result != SYS_ERR_OK ) return result;
        }
    }
    
    p = mymalloc(64);
    #ifdef    M26
    if( module == MODULE_UC15 || module == MODULE_EC200S || module == MODULE_EC25)
    {
        /* Set up TCP Client Connection and Enter into Direct Push Mode,connectID=1 
        AT+QIOPEN=<contextID>,<connectID>,<service_type>,"<IP_address>/<domain_name>",<remote_port>[,<local_port>[,<access_mode>]]*/
        sprintf( p,"AT+QIOPEN=1,0,\"%s\",\"%s\",%u,0,1\r",CHANNEL_MODE[mode],ip->address,ip->port );
        //test *6666*90116,62,42,223,2001*
        //p="AT+QIOPEN=1,0,\"TCP\",\"116.62.42.223\",2001,0,1\r";
    }
    else if(g_M25_M26_specific==3)
    {
        sprintf( p,"AT+CIPOPEN=0,\"%s\",\"%s\",%u\r",CHANNEL_MODE[mode],ip->address,ip->port );
    }
    else
    {
        sprintf( p,"AT+QIOPEN=\"%s\",\"%s\",%u\r",CHANNEL_MODE[mode],ip->address,ip->port );
    }
    #else
    sprintf( p,"AT%%IPOPENX=%u,\"%s\",\"%s\",%s\r",channnel,CHANNEL_MODE[mode],ip,port );
    #endif
    
    struAt.command = p;
    result = at_cmd_return(&struAt);
    myfree(p);
    return result;
}
/*********************************************************************************************************
** Function name:    gsm_close_connect
** Descriptions:    close socket,deactive PDP contect
**    { "AT+QICLOSE=0\r",RET_OK,1,10},    AT+QICLOSE=<connectID>[,<timeout>]
**    { "AT+QIDEACT=1\r",RET_OK,40,40},   AT+QIDEACT=<contextID>
**    { "AT+QICLOSE=2\r",RET_OK,1,10},    AT+QICLOSE=<connectID>[,<timeout>]
**    { NULL, NULL, 0, 0},
** input parameters:    close connect all if <index> is 0xff
** Output parameters:    NONE
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_close_connect( u8 index,ENUM_MODULE module )
{
    const STRU_AT *at;
    
    if( index == 0xff )
    {
        #ifdef M26
        if(g_M25_M26_specific==2)
        {
            at = &struAtCloseConnect_SIMCom[0];
        }
        else if(g_M25_M26_specific==3)
        {
            at = &struAtCloseConnect_SIMCom7[0];
        }
        else if( module == MODULE_M26 )
        {
            at = &struAtCloseConnect_M26[0];
        }
        else 
        {
            at = &AT_Close_Socket_PDP_Context[0];
        }
        #else
        at = &struAtCloseConnect_MG323[0];
        #endif
        return at_cmd_list_return( at );
    }
    else
    {
        #ifdef M26
        if(g_M25_M26_specific==2)
        {
            at = &struAtCloseConnect_SIMCom[0];
        }
        else if(g_M25_M26_specific==3)
        {
            at = &struAtCloseConnect_SIMCom7[0];
        }
        else if( module == MODULE_M26 )
        {
            at = &struAtCloseConnect_M26[index];
        }
        else
        {
            at_cmd_return( &AT_Close_Socket_PDP_Context[1] );    //  AT+QIDEACT=1
            at = &AT_Close_Socket_PDP_Context[index];
        }
        #else
        at = &struAtCloseConnect_MG323[index];
        #endif
        return at_cmd_return(at);
    }
}
/*********************************************************************************************************
** Function name:    gsm_check_tcp_ack
** Descriptions:    AT+QISEND=<connectID>,<send_length>: Send data to index channel
**     { "AT+QISEND=0,0\r",RET_TCP_ACK,1,30},     TCPIP: send data,socket_id=0,data length=0 
**    { "AT+QISACK=1\r",RET_TCP_ACK,1,30},     check data sent, socket_id=1 
**    { "AT+QISACK=2\r",RET_TCP_ACK,1,30},     check data sent, socket_id=2 
**    { NULL, NULL, 0, 0},
** input parameters:    
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_check_tcp_ack( u8 index,ENUM_MODULE module )
{
    const STRU_AT *at;
    #ifdef M26
    if(g_M25_M26_specific==2)
    {
        at = &struAtTcpAck_SIMCom[index];
    }
    else if(g_M25_M26_specific==3)
    {
        at = &struAtTcpAck_SIMCom7[index];               // +CIPACK: 10,10,5
    }
    else if( module == MODULE_M26 )
    {
        at = &struAtTcpAck_M26[index];
    }
    else 
    {
        at = &struAtTcpAck_UC15[index];
    }
    return at_cmd_return(at);
    #else
    const char TCP_ACK[] = {"AT%TXSTATE?\r"};
    #endif
}
#if 0
/*********************************************************************************************************
** Function name:    gsm_tcp_send
** Descriptions:    AT+QISEND=<connectID>,<send_length>: Send the length of data to index channel
** input parameters:    index=connectID,len=length of data send
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_tcp_send( u8 index,u8 *buf,u16 len,ENUM_MODULE module )
{
    STRU_AT struAt = {NULL,RET_LARGE,5,5};
    char *p;
    SYS_ERR result;
    #if gsm_debug
    u16 i;
    #endif
    p = mymalloc(32);
    if( module == MODULE_UC15 || module == MODULE_EC200S || module == MODULE_EC25)
    {
        sprintf( p,"AT+QISEND=%u,%u\r",index,len );
    }
    else if(g_M25_M26_specific==3)
    {
        sprintf( p,"AT+CIPSEND=%u,%u\r",index,len );
    }
    else
    {
        sprintf( p,"AT+QISEND=%u\r",len );
    }
    
    struAt.command = p;
    result = at_cmd_return( &struAt );
    myfree( p );
    if( result != SYS_ERR_OK ) 
    {
        return result;        /* response '>',then start send data bytes */
    }
    usart_send_bytes( USART3,(u8*)buf,len );
    #if gsm_debug
    for( i = 0; i < len; i++ )
    {
        printf("%02X", buf[i]);
    }
    printf("\n");
    #endif
    
    return SYS_ERR_OK;
}
#endif
SYS_ERR gsm_send_topic( u8 index,u16 len,ENUM_MODULE module ){
    STRU_AT struAt = {NULL,RET_LARGE,5,5};
    char *p;
    SYS_ERR result;
    p = mymalloc(32);
    if( module == MODULE_UC15 || module == MODULE_EC200S || module == MODULE_EC25)
    {
        sprintf( p,"AT+QISEND=%u,%u\r",index,len );
    }
    else if(g_M25_M26_specific==3)
    {
        sprintf( p,"AT+CIPSEND=%u,%u\r",index,len );
    }
    else
    {
        sprintf( p,"AT+QISEND=%u\r",len );
    }
    
    struAt.command = p;
    result = at_cmd_return( &struAt );/* response '>',then start send data bytes */
    myfree( p );
    return result;
}
void Modem_Put_Hex(u8 *s, u16 Length)
{
    u8 *p=s;
    u16 i=0;
    i=Length;
    while(i--)
    {
        USART_SendData(USART3, *s++);
        while(USART_GetFlagStatus(USART3,USART_FLAG_TXC)==RESET);
    }
    #if gsm_debug
    printf("MCU: ");
    for(i=0;i<Length;i++)
    {
        printf("%02x",p[i]);
    }
    printf("\n");
    #endif
}
/**
 02
000b
1010062f0066f4b4c0b447
*/
void Modem_put_data(u8*s,u16 Length)
{
    #if gsm_debug
    u8 *p;
    u8 *p2;
    #endif
    
    u8 topic[3];
    u16 i;
    //FOR AEPCloud: 0x02+2bytes length
    topic[0]=0x02;
    topic[1]=Length>>8;
    topic[2]=Length;
    
    #if gsm_debug
    p=s;
    p2 = topic;
    #endif
    
    for(i=0;i<Length+3;i++)
    {
        if(i < 3)
        {
            USART_SendData(USART3, topic[i]);
        }
        else
        {
            USART_SendData(USART3, *s++);
        }
        while(USART_GetFlagStatus(USART3,USART_FLAG_TXC)==RESET);
    }
    #if gsm_debug
    printf("MCU: ");
    for(i=0;i<Length+3;i++)
    {
        if(i < 3)
        {
            printf("%02x",*p2++);
        }
        else
        {
            printf("%02x",*p++);
        }
    }
    printf("\n");
    #endif
}

/*********************************************************************************************************
** Function name:    gsm_enet_d2s_pulse
** Descriptions:    send data via connectID_0
** input parameters:    
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_enet_tcp_send( u8 *buf,u16 len,u32 ack,ENUM_MODULE module,bool pura_data )
{
    INT32U time_start;
    INT8U err;
    u32 *msg; 
    u8 temp;
    u16 k;
    
    temp = 3;
    while( temp-- ) // repeat 3 times
    {
        if(pura_data){
            k=len;
        }
        else{
            k = len+3;
        }
        if(gsm_send_topic(TCP_INDEX_ENET,k,struGsm.module)!=SYS_ERR_OK)
        {
            return SYS_ERR_TCP_ACK_FAIL;
        }
        if( ack == 0 )
        {
            return SYS_ERR_OK;
        }
        if(pura_data){
            Modem_Put_Hex(buf,len);
        }
        else{
            Modem_put_data(buf,len);
        }
        time_start = OSTimeGet();
        while( OSTimeGet()-time_start < 10*1000 )
        {
            msg = OSQPend( msg_gsm_parse,1000,&err );  /* task pending, wait for response */
            if( err == OS_ERR_NONE )
            {
                if( ( *msg&ack ) != 0 )
                {
                    return SYS_ERR_OK;
                }
            }
            OSTimeDly( 1000);
            
            if( ( struGsm.status&GSM_STAT_TCP_CONNECT ) == 0 ) 
            {
                return SYS_ERR_AT_FAIL;
            }
        }
    }
    return SYS_ERR_AT_FAIL;
}

/*********************************************************************************************************
** Function name:    gsm_delete_sms
** Descriptions:    AT+CMGD=<index>[,<delflag>]
** <index> Integer type value in the range of location numbers supported by the associated memory.
** <delflag> 0 Delete the message specified in <index>
** 1 Delete all read messages from <mem1> storage
** 2 Delete all read messages from <mem1> storage and sent mobile originated messages
** 3 Delete all read messages, sent and unsent mobile originated messages from 
** <mem1> storage
** 4 Delete all messages from <mem1> storage
**
** input parameters:    index
** Output parameters:    NONE
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_delete_sms( u8 index )
{
//    const STRU_AT *at = &struAtInit[4];        /* list all sms undeleted */
    STRU_AT struAt = {NULL,RET_OK,5,5};
    char *p;
    SYS_ERR result;
    
    p = mymalloc(32);
    struAt.command = p;
    sprintf( p,"AT+CMGD=%u\r",index );        /* delete the message from index */
    result= at_cmd_return(&struAt);
//    result= at_cmd_return(at);                /* CMGL list all of the message */
    myfree(p);
    return result;
}
/*********************************************************************************************************
** Function name:    gsm_hangup
** Descriptions:    
** input parameters:    
** Output parameters:    
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_hangup()
{
    const STRU_AT *at = &struAtCallOut[0];    /* ATH hangup call */
    STRU_AT struAt = {"AT+CHUP\r",RET_OK,1,1};
    if(g_M25_M26_specific==3)
    {
        at_cmd_return(&struAt);
    }
    return at_cmd_return(at);               /* "ATH\r" */
}
/*********************************************************************************************************
** Function name:    gsm_read_sms
** Descriptions:    AT+CMGR=<index>
** input parameters:    index
** Output parameters:    NONE
** Returned value:    
*********************************************************************************************************/
SYS_ERR gsm_read_sms( u8 index )
{
    const STRU_AT *at;
    STRU_AT struAt = {NULL,RET_OK,5,10};
    char *p;
    SYS_ERR result;
    
    #if 0
    const STRU_AT *at = &struAtSetAscii[0];
    #else
    /* unicode mode read: source number and content of sms are unicode all */
    if(g_M25_M26_specific==0)
        at = &struAtSetHz[0];
    else
        at = &struM25_AtSetHz[0];
    #endif
    at_cmd_list_return(at);
    
    p = mymalloc(32);
    struAt.command = p;
    sprintf( p,"AT+CMGR=%u\r",index );
    result = at_cmd_return(&struAt);
    result = gsm_delete_sms( index );
    myfree(p);
    return result;
}
/*********************************************************************************************************
** Function name:    gsm_send_sms
** Descriptions:    if content is Chinese, need to change to unicode format
** input parameters:    cn=1=Chinese,target=phone number,content=message content
** Output parameters:    
** Returned value:
*********************************************************************************************************/
SYS_ERR gsm_send_sms( u8 cn,char *target,char *content )
{
    const STRU_AT *at;
    STRU_AT struAt = {NULL,RET_LARGE,5,5};
    char *p;
    char *ptr;
    SYS_ERR result;
    
    /*
    at+cscs="gsm"
    OK
    AT+CSMP=,,,0
    OK
    at+cmgs="13602692091"
    > test^Z

    +CMGS: 210

    OK
    
    at+cscs="ucs2"
    OK
    AT+CSMP=,,,8
    OK
    at+cmgs="00310033003600300032003600390032003000390031"
    > 6D4B8BD5^Z

    +CMGS: 211

    OK
    */
    
    if( cn ) 
    {
        if(g_M25_M26_specific==0)
            at = &struAtSetHz[0];
        else
            at = &struM25_AtSetHz[0];
    }
    else 
    {
        if(g_M25_M26_specific==0)
            at = &struAtSetAscii[0];
        else 
            at = &struM25_AtSetAscii[0];
    }
    if( at_cmd_list_return(at) != SYS_ERR_OK ) return SYS_ERR_AT_FAIL;
    
    p = mymalloc( 128 );
    if( cn ) { ascii_2_unicode( p+32,target );ptr=p+32; }        /* if it's Chinese,need to change to unicode */
    else ptr = target;
    sprintf( p,"AT+CMGS=\"%s\"\r",ptr );
    struAt.command = p;
    at_cmd_return( &struAt );               /* it will response '<',then you can send message */
    
    usart_send_str( USART3,content );
    #if gsm_debug
    printf( "%s\r\n",content );
    #endif
    strcpy( p,"\x1a" );                        /* send by ctl+z */
    struAt.result = RET_CMGS;
    struAt.timeout = 15;
    struAt.time_total = 15;
    result = at_cmd_return( &struAt );
    myfree(p);
    
    return result;
}
/*********************************************************************************************************
** Function name:    gsm_call_handle
** Descriptions:    
** input parameters:    call in @<mode> set and call out @<mode> reset
** Output parameters:    
** Returned value:
*********************************************************************************************************/
SYS_ERR gsm_call_handle( char *target,u8 mode,ENUM_MODULE module )
{
    const STRU_AT AT_QPSND_STOP = {"AT+QPSND=0\r",RET_OK,1,1};
    
    char *p;
    INT32U time_start;
    //OS_MSG_SIZE size;
    INT8U err;
    u32 *result;
    SYS_ERR at_result;
    u8 connect;
    const char AT_ATA[] = {"ATA\r"};        /* Answer an Incoming Call */
    const char AT_CLCC[] = {"AT+CLCC\r"};   /* List current calls of ME */
    const STRU_AT *at;
    u8 ctr_clcc;
    STRU_AT struAt = {NULL,RET_OK,5,10};
    u8 temp;
    
    if( ( mode&CALL_MODE_OUT ) != 0 )
    {
        /* hang up if call out */
        if( gsm_hangup() != SYS_ERR_OK ) return SYS_ERR_AT_FAIL;
    }
    
    //DTMF configuration
    if(g_M25_M26_specific==2)
    {
        ;;  //default enable
    }
    else if(g_M25_M26_specific==3)
    {
        ;;  //default enable
    }
    else
    {
        at = &struAtCallOut[1];
        if( at_cmd_list_return( at ) != SYS_ERR_OK ) 
        {
            return SYS_ERR_AT_FAIL;
        }
    }
    
    /** set Loudspeaker volume level,mic,etc.. option ***/
    switch(module)
    {
        case MODULE_M26:
        {
            if(g_M25_M26_specific==0)
            {
                at = &struAtCallOut_M26[0];
            }
            else if(g_M25_M26_specific==2)
            {
                at = &struAtCallOut_SIMCom[0];
            }
            else if(g_M25_M26_specific==3)
            {
                at = &struAtCallOut_SIMCom7[0];
            }
            else at = &struAtCallOut_M25[0];
            break;
        }
        case MODULE_UC15:
        {
            at = &struAtCallOut_UC15[0];
            break;
        }
        case MODULE_EC200S:
        {
            at = &struAtCallOut_EC200S[0];
            break;
        }
        case MODULE_EC25:
        {
            at = &struAtCallOut_EC25[0];
            break;
        }
        default:
        {
            at = &struAtCallOut_UC15[0];
            break;
        }
    }
    
    if( at_cmd_list_return( at ) != SYS_ERR_OK ) 
    {
        return SYS_ERR_AT_FAIL;
    }
    
    if( ( mode&CALL_MODE_OUT ) == 0 )
    {
        /* call in and answer */
        struAt.command = (char *)AT_ATA;
        if( at_cmd_return(&struAt) != SYS_ERR_OK ) return SYS_ERR_AT_FAIL;
    }
    
    connect = 0;
    p = mymalloc(64);
    
    if( ( mode&CALL_MODE_OUT ) != 0 )
    {
        sprintf( p,"ATD%s;\r",target ); /* dialing */
        struAt.command = p;
        at_cmd_return( &struAt );
    }

    ctr_clcc = 0;
    struGsm.dtmf = 0;
    time_start = OSTimeGet();
    while( OSTimeGet()-time_start < 30*60*1000 )
    {
        if( ( struGsm.status&GSM_STAT_DISARM ) != 0 ) break;        /* disarmed when calling */
        struAt.command = (char *)AT_CLCC;
        usart_send_str( USART3,struAt.command );            /* "AT+CLCC\r", CLCC check,list current calls */
        result = OSQPend( msg_gsm_parse,1000,&err );  /* task pend,wait for response */
        if( err == OS_ERR_NONE )
        {
            if( ( *result&RET_NO_CARRIER ) != 0 ) break;        /* NO CARRIER/BUSY/NO DIALTONE */
            
            
            if( ( *result&RET_OK ) != 0 )
            {
                if( ( *result&RET_CLCC ) == 0 )
                {    
                    if( ++ctr_clcc >= 4 ) break;
                }
                else ctr_clcc = 0;
            }
            if( ( *result&RET_CALL_CONNECT ) != 0 ) struGsm.status |= GSM_STAT_CALL_CONNECT;
            
            if( ( *result&RET_VOICE_CONNECT ) != 0 && connect == 0 )
            {   
                connect = 1;
                struGsm.status |= GSM_STAT_VOICE_CONNECT;
                
                if( ( mode&CALL_MODE_PLAY_PRESS ) != 0 )
                {
                    struGsm.status |= GSM_STAT_DTMF_CTRL;
                    OSTimeDly( 1000);//,OS_OPT_TIME_PERIODIC,&err );
                    
                    set_audio_mode( AUDIO_MODE_WAVPLAY_INCALL );
                    set_music_play_task( "alarm" );
                    struPlayWav.channel = DAC_CHANNEL_TO_MIC;
                    delay_wait_wav_play_over();
                    
                    if( ( mode&CALL_MODE_OUT ) != 0 )
                    {
                        /* play alarming segment only in call-out alarming mode */
                        /* play audio file and send it to remote in call */
                        //at = (module==MODULE_M26)?(&struAtSendPlay_M26[0]):((module==MODULE_EC200S)?(&struAtSendPlay0_EC200S_EC25[0]):(&struAtSendPlay_UC15[0]));
                        switch(module)
                        {
                            case MODULE_M26:
                            {
                                if(g_M25_M26_specific == 3)
                                {
                                    at = &PLAY_SIMCom7ToRemote[0];
                                }
                                else
                                {
                                    at = &struAtSendPlay_M26[0];
                                }
                                break;
                            }
                            case MODULE_UC15:
                            {
                                at = &struAtSendPlay_UC15[0];
                                break;
                            }
                            case MODULE_EC200S:
                            case MODULE_EC25:
                            {
                                if(struParaSet.dat.record_audio[1].IsRecord == RECORD_RECORDED)
                                {
                                    if(ec200n_dk==1)
                                    {
                                        at = &struAtSendPlay1_EC200n[0];
                                    }
                                    else
                                    {
                                        at = &struAtSendPlay1_EC200S_EC25[0];
                                    }
                                }
                                else
                                {
                                    if(ec200n_dk==1)
                                    {
                                        at = &struAtSendPlay0_EC200n[0];
                                    }
                                    else
                                    {
                                        at = &struAtSendPlay0_EC200S_EC25[0];
                                    }
                                }
                                break;
                            }
                            default:
                            {
                                at = &struAtSendPlay_UC15[0];
                                break;
                            }
                        }
                        /*if (module==MODULE_EC200S && struParaSet.dat.record_audio[1].IsRecord == RECORD_RECORDED)
                        {    
                            at = &struAtSendPlay1_EC200S_EC25[0];
                        }*/
                        if( struParaSet.dat.audio_file_len != 0 && at_cmd_list_return(at) == SYS_ERR_OK )
                        {
                            /* must cut off the alarming beep channel to mic */
                            set_audio_mode( AUDIO_MODE_PLAYBACK_INCALL );
                            OSTimeDly( struParaSet.dat.record_duration*1000);//,OS_OPT_TIME_PERIODIC,&err );
                             at_cmd_return(&AT_QPSND_STOP);
                        //    printf("\r\nT5");
                        }
                        
                        /* play alarm wav to monitor */
                        set_audio_mode( AUDIO_MODE_WAVPLAY_INCALL );
                        set_speak_play_task( (ENUM_WAV_SEG)struGsm.alarm_target.content );
                        struPlayWav.channel = DAC_CHANNEL_TO_MIC;        /* wav to mic */
                        delay_wait_wav_play_over();
                    }
                    
                    OSTimeDly( 1000);//,OS_OPT_TIME_PERIODIC,&err ); /* delay is necessary!!! */
                    set_speak_play_task( WAV_PRESS );
                    struPlayWav.channel = DAC_CHANNEL_TO_MIC;        /* wav to mic */
                }
            }
        }
        /* restore talking mode */
        if( struPlayWav.status_play_wav == STAT_PLAY_FREE )
        {
            if( connect != 0 || ( pgsGsm == PGS_GSM_USER_CALL && (struGsm.status&GSM_STAT_CALL_CONNECT) != 0 ) )
                set_audio_mode( AUDIO_MODE_INCALL );
        }
        
        temp = 100;
        while(temp--)
        {
            if( struGsm.dtmf != 0 )
            {
                /*The command is used to send ASCII characters which cause MSC to transmit DTMF tones to a remote 
                  subscriber. It can only be operated in voice call.*/
                sprintf( p,"AT+VTS=%c\r",struGsm.dtmf );/*AT+VTS=<dtmfstring>[,<duration>] */
                struAt.command = p;
                at_cmd_return( &struAt );
                struGsm.dtmf = 0;
            }
            OSTimeDly( 10);//,OS_OPT_TIME_PERIODIC,&err );
        }
    }
    at_result = gsm_hangup();                    /* ATH again */
    struGsm.status &= ~(GSM_STAT_CALL_CONNECT|GSM_STAT_VOICE_CONNECT|GSM_STAT_USER_MONITOR|GSM_STAT_DTMF_CTRL);
    myfree(p);
    if( connect != 0 ) return SYS_ERR_CONNECTED;
    return at_result;
}

/*********************************************************************************************************
** Function name:    OS_gsm_msg_queue_create
** Descriptions:    CREATE A MESSAGE QUEUE
** input parameters:
** Output parameters:    NONE
** Returned value:    
*********************************************************************************************************/
void *MyArrayOfMsg[1];
void gsm_usart_init(void)
{
    msg_gsm_parse = OSQCreate( MyArrayOfMsg, sizeof( MyArrayOfMsg ) );
}
/*********************************************************************************************************
** Function name:    get_gsm_level
** Descriptions:    rssi to 6 copies: 0-5
** input parameters:    NONE
** Output parameters:    NONE
** Returned value:    
*********************************************************************************************************/
u8 get_gsm_level( u8 rssi )
{
    if( rssi <= 2 || rssi == 99 ) return 0;
    else if( rssi >= 14 ) return 5;
    else if( rssi >= 12 ) return 4;
    else if( rssi >= 8 ) return 3;
    else if( rssi >= 5 ) return 2;
    else return 1;
}
/*unsigned char cal_crc(unsigned char *vptr, unsigned char len)
{
  const unsigned char *data = vptr;
  unsigned int crc = 0;
  int i, j;
  for (j = len; j; j--, data++) 
  {
    crc ^= (*data << 8);
    for (i = 8; i; i--) 
    {
      if (crc & 0x8000)
        crc ^= (unsigned int)(0x1070 << 3);
      crc <<= 1;
    }
  }
  return (unsigned char)(crc >> 8);
}
*/
/*********************************************************************************************************
** Function name:    gsm_parse
** Descriptions:    GSM data parase
** input parameters:    *p
** Output parameters:    gsm
** Returned value:    a message to a queue
*********************************************************************************************************/
u32 gsm_parse( const char *p,STRU_GSM *gsm )
{
    u32 l;
    u32 result = 0;
    u8 temp;
    u16 t;
//    s16 tim_zone,min;
//    u8 leap_year;
    /* unique device id */
    union
    {
        u32 udi;
        u8  udi_buf[4];
    }UDI_para;
    
    char *pstr,*pstr2;
    char *p1,*p2;
    ///static u8 ring_counter = 0;
    
    struct tm utc;//,struGMT8;
//    time_t t1,t2;
    
    pstr = mymalloc(32*4);
    pstr2 = mymalloc(32);
    
    if(strstr(p,"NORMAL POWER DOWN\r\n") != NULL)
    {
        
    }
    if( strstr( p,"OK\r\n" ) != NULL )
    {
        result |= RET_OK;        /* received 'OK'*/
    }
    if( strstr( p,"ERROR\r\n" ) != NULL ) 
    {
        result |= RET_ERROR;    /* received 'ERROR'*/
    }
    if(g_M25_M26_specific==3)
    {
        if(strstr(p,"+CNTP: 0") != NULL)
        {
            result |= RET_NTP;
        }
    }
    else
    {
        if(strstr(p,"+CNTP: 1") != NULL)
        {
            result |= RET_NTP;
        }
    }
    
    if(strstr(p,"+CPIN: SIM REMOVED") != NULL)
    {
        struGsm.status |= GSM_STAT_NO_SIM;
    }
    else if(strstr(p,"+CME ERROR: SIM not inserted")!=NULL)
    {
        struGsm.status |= GSM_STAT_NO_SIM;
    }
    
    if(strstr(p,"SHUT OK") != NULL)
    {
        result |= SHUT_OK;
    }
    
    //+CIPCLOSE: <link_num>,<err>; e.g = +CIPCLOSE: 0,0
    if(strstr(p,"+CIPCLOSE: 0,0") != NULL)
    {
        result |= SHUT_OK;
    }
    if(strstr(p,"+NETCLOSE") != NULL)
    {
        result = SHUT_OK;
    }
    
    p1 = strstr( p,"+CREG:" );
    if( p1 != NULL && getsubstr2( p1,',','\r',pstr ) != 0 )
    {
        temp = atoi(pstr);
        if( temp == 1 || temp == 5 )
        {
            gsm->status |= GSM_STAT_CREG;   /* Registered, home network */
#if PK
            if(TestSignal_24H_Timer_sec == 0) //network registered, timer start.
                TestSignal_24H_Timer_sec=1;
#endif
            result |= RET_OK;
        }
        else
        {
            gsm->status &= ~GSM_STAT_CREG;  /* Registered Failed */
            result |= RET_ERROR;
        }
    }
    p1 = strstr( p,"+CGREG:" );
    if( p1 != NULL && getsubstr2( p1,',','\r',pstr ) != 0 )
    {
        temp = atoi(pstr);
        if( temp == 1 || temp == 5 )
        {
            gsm->status |= GSM_STAT_CREG;   /* Registered, home network */
            result |= RET_OK;
        }
        else
        {
            gsm->status &= ~GSM_STAT_CREG;  /* Registered Failed */
            result |= RET_ERROR;
        }
    }
    /* +CEREG: 0,1 */
    p1 = strstr(p,"+CEREG:");
    if(p1!=NULL && getsubstr2( p1,',','\r',pstr ))
    {
        temp = atoi(pstr);
        if( temp == 1 || temp == 5 )
        {
            gsm->status |= GSM_STAT_CREG;   /* Registered, home network */
            result |= RET_OK;
        }
        else
        {
            gsm->status &= ~GSM_STAT_CREG;  /* Registered Failed */
            result |= RET_ERROR;
        }
    }
    
    /*+CSQ: 13,99*/
    p1 = strstr( p,"+CSQ:" );
    if( p1 != NULL && getsubstr2( p1,':',',',pstr ) != 0 )
    {
        temp = atoi(pstr);  /*get rssi*/
        if(struParaSet.dat.KeepaliveIntervalTimeU16==0 || struParaSet.dat.KeepaliveIntervalTimeU16>600){
            if(TyReadTypeDef.NetworkRssiU8Status>temp){
                if(TyReadTypeDef.NetworkRssiU8Status-temp>5){
                    gflag.fReport1Status |= fNetworkRssiU8StatusRes;
                }
            }
            else if(temp-TyReadTypeDef.NetworkRssiU8Status>5){
                gflag.fReport1Status |= fNetworkRssiU8StatusRes;
            }
        }
        TyReadTypeDef.NetworkRssiU8Status = temp;
        gsm->rssi = temp;
        result |= ( temp > 0 && temp < 99 )?RET_OK:RET_ERROR;   /* less 0 or high 99: return ERROR */
    }
    
    /*
    +CCLK: "16/05/03,06:00:16+00"
    +CCLK: "15/01/28,09:15:43"
    +CCLK: "16/05/15,15:37:07"
    */
    p1 = strstr( p,"+CCLK:" );  /* yy/MM/dd,hh:mm:ss:zz  zz=time zone */
    if( p1 != NULL && getsubstr2( p1,'"','"',pstr ) >= 17  )
    {
        sprintf( pstr2,"%.2s%.2s%.2s",pstr+6,pstr+3,pstr );
        l = atof((const char*)pstr2);        /* src:DDMMYY */
        
        utc.tm_mday=l/10000;
        utc.tm_mon=(l/100)%100-1;        /* month is 0-11 in ANSI-C */
        utc.tm_year=l%100+2000;
        
        if( utc.tm_year >= 2017 )
        {
            sprintf( pstr2,"%.2s%.2s%.2s",pstr+9,pstr+12,pstr+15 );
            l = atof((const char*)pstr2);        /* src:hhmmss */
            utc.tm_hour=l/10000;        
            utc.tm_min=(l/100)%100;
            utc.tm_sec=l%100;
            
            OS_CPU_SR cpu_sr=0;// CPU_SR_ALLOC();
            OS_ENTER_CRITICAL();//CPU_CRITICAL_ENTER();
            # if 0
            #if GET_CLOCK_BY_NTP
            get_local_time( &utc,&struGMT8,(struParaSet.dat.time_zone*60/10)*60 );
            #else
            /* test */
            //get_local_time( &utc,&struGMT8,atoi(pstr+17)*15*60 );
            #endif
            //t1 = Time_ConvCalendarToUnix(struGMT8);
            //t2 = Time_ConvCalendarToUnix(calendar);
            //t1 = (t1>=t2)?(t1-t2):(t2-t1);
            //if( t1 >= 5 )
            //{
            
            if((utc.tm_year%4==0&&utc.tm_year%100!=0)||(utc.tm_year%400==0))
            {
                leap_year = 1;
            }
            else
            {
                leap_year = 0;
            }
            
            if((g_M25_M26_specific!=3) && (g_M25_M26_specific!=2))
            {
                tim_zone = atoi(pstr+17);       // time zone
                #if gsm_debug
                printf("utc: %02u-%02u-%02u %02u:%02u:%02u +%02d\r\n",utc.tm_year,utc.tm_mon,utc.tm_mday,utc.tm_hour,utc.tm_min,utc.tm_sec,tim_zone);
                #endif
                
                min = tim_zone*15%60;           // time zone => minute
                utc.tm_min += min;
                tim_zone = tim_zone*15/60;      // time zone => hour
                
                utc.tm_hour += tim_zone;
                if(utc.tm_min >= 60)
                {
                    utc.tm_min = 1;
                    utc.tm_hour++;
                }
            }
            if(utc.tm_hour > 24)
            {
                utc.tm_hour = utc.tm_hour - 24;
                utc.tm_mday++;
                if(utc.tm_mon==2)
                {
                    if(leap_year==1)
                    {
                        if(utc.tm_mday>29)
                        {
                            utc.tm_mday = 1;
                            utc.tm_mon++;
                        }
                    }
                    else
                    {
                        if(utc.tm_mday>28)
                        {
                            utc.tm_mday = 1;
                            utc.tm_mon++;
                        }
                    }
                }
                else if(utc.tm_mon==1 || utc.tm_mon==3 || utc.tm_mon==5 || utc.tm_mon==7 || utc.tm_mon==8 || utc.tm_mon==10 || utc.tm_mon==12)
                {
                    if(utc.tm_mday>31)
                    {
                        utc.tm_mday=1;
                        utc.tm_mon++;
                        if( utc.tm_mon==13)
                        {
                            utc.tm_mon=1;
                            utc.tm_year++;
                        }
                    }
                }
                else if(utc.tm_mon==4 || utc.tm_mon==6 || utc.tm_mon==9 || utc.tm_mon==11)
                {
                    if(utc.tm_mday>30)
                    {
                        utc.tm_mday=1;
                        utc.tm_mon++;
                    }
                }
            }
            else if(utc.tm_hour < 0)
            {
                utc.tm_hour = utc.tm_hour + 24;
                utc.tm_mday--;
                if(utc.tm_mday<0)
                {
                    if(utc.tm_mon==1)
                    {
                        utc.tm_year--;
                        utc.tm_mon=12;
                        utc.tm_mday=31;
                    }
                    else
                    {
                        utc.tm_mon--;
                        if(utc.tm_mon==2)
                        {
                            if(leap_year==1)
                            {
                                utc.tm_mday=29;
                            }
                            else
                            {
                                utc.tm_mday=28;
                            }
                        }
                        else if(utc.tm_mon==3 || utc.tm_mon==5 || utc.tm_mon==7 || utc.tm_mon==8 || utc.tm_mon==10 || utc.tm_mon==12)
                        {
                            utc.tm_mday=31;
                        }
                        else if(utc.tm_mon==4 || utc.tm_mon==6 || utc.tm_mon==9 || utc.tm_mon==11)
                        {
                            utc.tm_mday=30;
                        }
                    }
                }
            }
            #endif
            Time_SetCalendarTime(utc,0);
            OS_EXIT_CRITICAL();//CPU_CRITICAL_EXIT();
        }
    }
    
    /*+CGATT: 1*/
    p1 = strstr( p,"+CGATT:" ); /*+CGATT: <state>*/
    if( p1 != NULL && getsubstr2( p1,':','\r',pstr ) != 0 )
    {
        if( atoi(pstr) == 1 )
        {
            result |= RET_CGATT;
        }
    }
    
    /* +CMTI: "SM",2 */
    p1 =  strstr( p,"+CMTI:" ); /* SMS received */
    if( p1 != NULL && getsubstr2( p1,',',0x0d,pstr ) != 0 )
    {
          gsm->sms_index = atoi(pstr);    /* get index of sms */
        gsm->task |= GSM_TASK_CMGR;
        gsm->task |= GSM_TASK_CMGD;
    }
    
    /*
    Chinese:1234mz领航卫士2楼
    +CMGR: "REC UNREAD","+8613602692091","","2016/03/14 16:36:01+32"
    0031003200330034006D007A9886822A536B58EB0032697C
    
    ascii：
    +CMGR: "REC UNREAD","+8613602692091","","2016/04/08 15:28:47+32"
    *6666*5113602692091,0,1*
    +CMGR: "REC UNREAD","+8613602692091","","2016/05/18 13:43:25+32"
    0031003200330034006D007A9886822A536B58EB0032697C
    OK
    
    +CMGR: "REC UNREAD","002B0038003600310033003600300032003600390032003000390031","","2017/01/13 10:13:08+32"
    003100320033003400400020005B00DF0028003D005300530029002C00C40028003D00410045002900D60028003D004F0045002900DC0028003D004F00550029005D0020
    */
    p1 = strstr( p,"+CMGR:" );  /* SMS Read */
    if( p1 != NULL )
    {
        t = getsubstr( 1,p1,pstr );     /* get the phone number */
        if( t >= 2+3*4 && *pstr == '"' && byte_ascii_2_hex( pstr+1 ) == 0 && byte_ascii_2_hex( pstr+5 ) == 0 )
        {
            /* get the source number of sms and digits >= 3 */
            p2= strrchr( pstr,'"' );
            if( p2 > pstr )
            {
                *p2 = 0;
                pstr[(PHONE_LEN-1)*4+2] = 0;
                if(gsm->module == MODULE_EC200S)
                {
                    if (strncmp(pstr, "\"002B00380036", 13))
                    {
                        unicode_2_ascii( gsm->target.phone,pstr+1,0 );
                    }
                    else
                    {
                        unicode_2_ascii( gsm->target.phone,pstr+13,0 );
                    }
                }
                else
                {
                    unicode_2_ascii( gsm->target.phone,pstr+1,0 );
                }
            }
        }
        else
        {
            // source number is ascii
            pstr[(PHONE_LEN-1)+2] = 0;
            if( getsubstr2( pstr,'"','"',pstr2 ) >= 3 )
            {
                strcpy( gsm->target.phone,pstr2 );
            }
        }
        
        p2 = strchr( p1,'\n' );
        if( p2 != NULL )
        {
            p2++;
            p1 = strchr( p2,'\r' );
            if( p1 > p2 && p1-p2 >= (4+1+1)*4 )
            {
                /* 
                1234#1
                1234@xxxxxxxxxxxxxxxxxxx    
                *6666*AAxxxx*...
                */
                *p1 = 0;
                unicode_2_ascii( pstr,p2,5 );        /* get start character */
                
                temp = SMS_CMD_MODE_NULL;
                /* get the SMS format */
                if( *pstr == '*' ) temp = SMS_CMD_MODE_SETTING;
                else if( pstr[4] == '#' || pstr[4] == '@' ) temp = pstr[4];
                if( temp != SMS_CMD_MODE_NULL )
                {
                    
                    parse_cmd( (ENUM_SMS_CMD_MODE)temp,p2,&struParaSet,gsm );   /* paraser the message */
                }
            }
        }
    }
    
    /*
    +CMGL: 1,"REC READ","10658139122352500148",,"15/12/19,10:50:12+32"
    0068007400740070003A002F002F0079002E00310030003000380036002E0063006E0....
    */
    p1 = strstr( p,"+CMGL:" );  /* SMS list */
    if( p1 != NULL && getsubstr2( p1,':',',',pstr ) != 0 )
    {
        gsm->sms_index = atoi(pstr);    /* get the index SMS in memory */
        gsm->task |= GSM_TASK_CMGD;
    }
    
    if( strstr( p,"\r\n>" ) != NULL ) result |= RET_LARGE;  /* received '<' character */
    if( strstr( p,"+CMGS:" ) != NULL ) result |= RET_CMGS;  /* received the response of send short message */
    
    /*
    +CLCC: 1,0,2,0,0,"13602692091",129,""   //dialing
    OK
    +CLCC: 1,0,3,0,0,"13602692091",129,""   //dialing alerting
    OK
    +CLCC: 1,0,0,0,0,"13602692091",129,""   //dialing active
    OK
    NO CARRIER                              //be hand up
    at+clcc                                 //End, none return
    OK
    */
    p1 = strstr( p,"+CLCC: 1,1,0,1,0,\"\",128" );   /* Mobile terminated (MT) call */
    if( p1 != NULL )
    {
        delete_string( p1 , strlen("+CLCC: 1,1,0,1,0,\"\",128"));
    }
    p1 = strstr( p,"+CLCC:" );
    if(GSM_TASK_INCALL_CHECK & gsm->task)
    {
        if( p1 != NULL && getsubstr2( p1,'"','"',pstr ) >= 3 )
        {
            if( get_phone_if_saved( pstr,&struParaSet ) == 0 )  /* check the phone of incomming if it's the one stored in memory before */
            {
                gsm->task |= GSM_TASK_HANGUP;   /* if it's not the stored in memory, hang up it */
            }
            else 
            {
                gsm->task |= GSM_TASK_CALL_IN;  /* answer it */
            }
        }
        gsm->task &=~ GSM_TASK_INCALL_CHECK;
    }
    else if( p1 != NULL && getsubstr( 2,p1,pstr ) == 1 )
    {
        result |= RET_CLCC;
        if( *pstr == '3' ) 
        {
            result |= RET_CALL_CONNECT;
        }
        else if( *pstr == '0' ) 
        {
            result |= RET_VOICE_CONNECT;
        }
    }
    if( strstr( p,"BUSY" ) != NULL ) result |= RET_NO_CARRIER;          /* dailing is busy */
    if( strstr( p,"NO CARRIER" ) != NULL ) result |= RET_NO_CARRIER;
    if( strstr( p,"NO DIALTONE" ) != NULL ) result |= RET_NO_CARRIER;
    //if( ( result&RET_NO_CARRIER ) != 0 ) ring_counter = 0;
    
    /*
    +QTONEDET: 49   48~57:0~9    42:*    35:#
    +QTONEDET: 51
    
    +CLCC: 1,0,3,0,0,"13602692091",129,""
    OK
    +QTONEDET: 50
    
    +QTONEDET: 69,100
    */
    p1 = strstr( p,"+QTONEDET:" );  /* DTMF code */
    if( p1 != NULL && getsubstr2( p1,':','\r',pstr ) >= 1 && (gsm->status&GSM_STAT_DTMF_CTRL) != 0 )
    {
        t = atoi( pstr );
        if( t >= 48 && t <= 57 ) t -= 48;        /* 0~9 */
        else if( t >= 65 && t <= 68 ) t -= 65+0x0A;    /* A~D */
        else if( t == 42 ) t = 0x0E;            /* * */
        else t = 0x0F;                    /* # */
        dtmf_ctrl_handle( t );
    }
    else
    {
        p1 = strstr( p,"DTMF: " );  /* DTMF code */
        if(p1 != NULL)
        {
            getsubstr2( p1,':','\r',pstr );
            t = atoi( pstr );
            dtmf_ctrl_handle( t );
        }
    }
    
    p1 = strstr(p,"RING");
    if( p1 != NULL )
    {
        #if HA
        gsm->task |= GSM_TASK_HANGUP;
        #else
        gsm->task |= GSM_TASK_DETECTED_INCALL;
        #endif
    }
    
    if( pgsGsm == PGS_GSM_GET_FIRMWARE && (result&RET_OK) != 0 )    /* firmware version response */
    {
        result &= ~RET_OK;
        p1 = strstr( p,M26_MODULE_REVISION );
        p2 = strstr( p,BC26_MODULE_REVISION );
        
        if( p1 != NULL || p2 != NULL)
        {
            gsm->module = MODULE_M26;
            g_M25_M26_specific = 0;
            strcpy( gsm->firmware,GENERATION_2G );
            if( p1 == NULL ) p1 = p2;            // p1 for getting the revision
        }
        else if ((p1 = strstr( p,EC200S_MODULE_REVISION )) != NULL)
        {
            gsm->module = MODULE_EC200S;
            strcpy( gsm->firmware,GENERATION_4G );
        }
        else if ((p1 = strstr( p,EC200N_MODULE_REVISION )) != NULL)
        {
            gsm->module = MODULE_EC200S;
            ec200n_dk = 1;
            strcpy( gsm->firmware,GENERATION_4G );
        }
        else if ((p1 = strstr( p,EC25_MODULE_REVISION )) != NULL)
        {
            gsm->module = MODULE_EC25;
            strcpy( gsm->firmware,GENERATION_4G );
        }
        //M25MAR01A11
        else if((p1 = strstr( p,"M25MAR01A11" )) != NULL)
        {
            gsm->module = MODULE_M26;
            g_M25_M26_specific = 1;
            g_Version_M25MAR01A11 = 1;
            strcpy( gsm->firmware,GENERATION_2G );
        }
        else if((p1 = strstr( p,M25_MODULE_REVISION )) != NULL)
        {
            gsm->module = MODULE_M26;
            g_M25_M26_specific = 1;
            g_Version_M25MAR01A11 = 0;
            
            strcpy( gsm->firmware,GENERATION_2G );
        }
        else if(strstr( p,SIMComR805C_REVISION ) != NULL)
        {
            gsm->module = MODULE_M26;
            g_M25_M26_specific = 2;
            g_Version_M25MAR01A11 = 0;
            p1 = strstr(p,"Revision: ");
            strcpy( gsm->firmware,GENERATION_2G );
        }
        else if(strstr( p,SIMComA7670_REVERSION ) != NULL)
        {
            gsm->module = MODULE_M26;
            g_M25_M26_specific = 3;
            g_Version_M25MAR01A11 = 0;
            p1 = strstr(p," ");
            strcpy( gsm->firmware,GENERATION_4G );
        }
        else if(strstr(p,SIMComA7680_REVERSION) !=NULL)
        {
            gsm->module = MODULE_M26;
            g_M25_M26_specific = 3;
            g_Version_M25MAR01A11 = 0;
            p1 = strstr(p,":");
            p1++;
            strcpy( gsm->firmware,GENERATION_4G );
        }
        else if((p1=strstr(p,SIMComY7025_REVUSUIB)) != NULL)
        {
            gsm->module=MODULE_NB;
            g_M25_M26_specific=4;
            strcpy(gsm->firmware,GENERATION_NB);
        }
        else
        {
            p1 = strstr( p,UC15_MODULE_REVISION );
            if( p1 != NULL )
            {
                gsm->module = MODULE_UC15;
                strcpy( gsm->firmware,GENERATION_3G );
            }
        }
        
        if( p1 != NULL )
        {
            p2 = strchr( p1,'\r' );
            if( p2 != NULL )
            {
                strncpy( pstr,p1,p2-p1 );
                pstr[p2-p1] = 0;
                pstr[32-1] = 0;
                strcat( gsm->firmware,pstr );   /* get the firmware version */
                result |= VERSION_OK;            /* a valid revision received */
            }
        }
    }
    else
    {
        p1 = strstr(p,"Revision: ");
        if( p1 != NULL )
        {
            if((p1 = strstr( p,SIMComR805C_REVISION )) != NULL)
            {
                //gsm->module = MODULE_M26;
                g_M25_M26_specific = 2;
                g_Version_M25MAR01A11 = 0;
                //strcpy( gsm->firmware,GENERATION_2G );
                result |= VERSION_OK;
            }
        }
        //AT+CGMR
        //+CGMR: A011B04A7670M6
        p1 = strstr(p,"+CGMR: ");
        if( p1 != NULL )
        {
            if((p1 = strstr( p,SIMComA7670_REVERSION )) != NULL)
            {
                g_M25_M26_specific = 3;
                g_Version_M25MAR01A11 = 0;
                result |= VERSION_OK;
            }
        }
        else if(strstr(p,"Y7025")!=NULL)
        {
            g_M25_M26_specific=4;
            result |= VERSION_OK;
        }
    }
    
    if( pgsGsm == PGS_GSM_GET_IMEI && (result&RET_OK) != 0 )
    {
        /*
        AT+CGSN=1
        +CGSN:869600051637335
        OK
        */
        if(strstr(p,"+CGSN:")!=NULL)
        {
            if( getsubstr2( (char*)p,':','\r',pstr ) >= 15 )
            {
                pstr[20-1] = 0;
                strcpy( gsm->imei,pstr );
                printf("imei=%s\n",gsm->imei);
                gflag.fReport1Status |= fImeiNumberArrayStatusRes;
                //if((struParaSet.dat.id/100000) != 9)
                {
                    t = calculateChecksum((unsigned char*)gsm->imei,0,15);
                    UDI_para.udi = t;
                    UDI_para.udi*=10;
                    UDI_para.udi += (gsm->imei[14]-'0');
                    UDI_para.udi &= 0x000fffff;
                    if(UDI_para.udi != struParaSet.dat.id)
                    {
                        struParaSet.dat.id = UDI_para.udi;
                        strusParaSet_WriteIntoFlash_08072000();
                    }
                }
            }
        }
        /*
        AT+GSN
        862151030097636
        OK
        */
        else if( getsubstr2( (char*)p,'\n','\r',pstr ) >= 15 )
        {
            pstr[20-1] = 0;
            strcpy( gsm->imei,pstr );       //get IMEI number
            gflag.fReport1Status |= fImeiNumberArrayStatusRes;
            //if((struParaSet.dat.id/100000) != 9)
            {
                t = calculateChecksum((unsigned char*)gsm->imei,0,15);
                UDI_para.udi = t;
                UDI_para.udi*=10;
                UDI_para.udi += (gsm->imei[14]-'0');
                UDI_para.udi &= 0x000fffff;
                if(UDI_para.udi != struParaSet.dat.id)
                {
                    struParaSet.dat.id = UDI_para.udi;
                    strusParaSet_WriteIntoFlash_08072000();
                }
            }
        }
    }
    if( pgsGsm == PGS_GSM_GET_IMSI && (result&RET_OK) != 0 )
    {
        /*
        AT+CIMI
        862151030097636
        OK
        */
        if( getsubstr2( (char*)p,'\n','\r',pstr ) >= 15 )
        {
            pstr[16] = 0;
            strcpy( gsm->imsi,pstr );       //get imsi number
            gsm->status |= GSM_STAT_IMSI;
        }
    }
    if( pgsGsm == PGS_GSM_GET_ICCID && (result&RET_OK) != 0 )
    {
        /*
        AT+CCID //query(U)SIM's CCID number: 898600220909A0206023
        +CCID: "898600220909A0206023"
        OK
        */
        p1 = strstr(p,"+CCID:");
        p2 = strstr(p,"+ICCID: ");
        if(p1!=NULL)
        {
            getsubstr2( (char*)p,'"','"',pstr );
            strcpy( gsm->iccid,pstr );          //get ICCID number
            printf("iccid=%s\n",pstr);
            gflag.fReport1Status |= fSimIccidNumberArrayStatusRes;
            gsm->status &=~GSM_STAT_NO_SIM;
        }
        else if(p2!=NULL)
        {
            if(getsubstr2( (char*)p2,' ','\n',pstr )>19)
            {
                strcpy( gsm->iccid,pstr );          //get ICCID number:+ICCID: 89860478102071528575
                gsm->iccid[strlen(pstr)-1]=0;
                printf("iccid%d=%s\n",strlen(pstr),pstr);
                gflag.fReport1Status |= fSimIccidNumberArrayStatusRes;
                gsm->status &=~GSM_STAT_NO_SIM;
            }
        }
        /*
        AT+NCCID
        +NCCID:898604B61522C0001129
        OK
        */
        else if(strstr(p,"+NCCID:") != NULL)
        {
            if( getsubstr2( (char*)p,':','\r',pstr ) >= 19)
            {
                strcpy( gsm->iccid,pstr );          //get ICCID number:+ICCID: 89860478102071528575
                gsm->iccid[strlen(pstr)-1]=0;
                printf("iccid%d=%s\n",strlen(pstr),pstr);
                gflag.fReport1Status |= fSimIccidNumberArrayStatusRes;
                gsm->status &=~GSM_STAT_NO_SIM;
            }
        }
        else if( getsubstr2( (char*)p,'\n','\r',pstr ) >= 19)
        {
            strcpy( gsm->iccid,pstr );          //get ICCID number
            printf("iccid=%s\n",pstr);
            gflag.fReport1Status |= fSimIccidNumberArrayStatusRes;
            gsm->status &=~GSM_STAT_NO_SIM;
        }
        
    }
    /*
    AT+QSIMSTAT?
    +QSIMSTAT: <enable>,<inserted_status>
    OK
    */
    p1 = strstr( p,"+QSIMSTAT:" );
    if( p1 != NULL && getsubstr( 1,p1,pstr ) == 1 && *pstr != '1' )
    {
        gsm->status |= GSM_STAT_NO_SIM;
    }

    if (pgsGsm == PGS_GSM_RECORD)
    {
        /*p1 = strstr( p,"+QFLST:" );
        if( p1 != NULL && getsubstr2( '\"','\"',pstr )  >= 1 )
        {
            ////gsm->amr.total = atoi(pstr);
            result |= RET_QFLST;
            printf("\r\n%s", pstr);
        }*/
    }
    
    p1 = strstr( p,"+CIPOPEN: " );  //  +CIPOPEN: 0,0
    if( p1 != NULL )
    {
        getsubstr2( p1,',','\r',pstr );
        t = atoi( pstr );
        if(t == 0)
        {
            printf("TCP online\n");
            result&=~RET_ERROR;
            result |= RET_CONNECT;
        }
        else if(t==2 || t==1)   //network failure or network not open
        {
            gsm->status &=~ GSM_STAT_TCP_CONFIG;
        }
    }
    
    if( pgsGsm == PGS_GSM_SAVE_RECORD || pgsGsm == PGS_GSM_READ_RECORD || pgsGsm == PGS_GSM_AUDIO_ALARM )
    {
        /*
        AT+QFLST="RAM:record.amr"
        +QFLST: "RAM:record.amr",3548,512000
        OK
        AT+QFLST="UFS:play.wav"
        +QFLST: "play.wav",155244        //for UC15
        */
        p1 = strstr( p,"+QFLST:" );
        if( p1 != NULL && getsubstr( 1,p1,pstr )  >= 1 )
        {
            gsm->amr.total = atoi(pstr);
            result |= RET_QFLST;
        }
        /*
        AT+FSLS
        +FSLS: FILES:
        re.wav
        OK
        */
        p1 = strstr( p,"+FSLS: " );
        if( p1 != NULL )
        {
            if(strstr( p,"re.wav") != NULL)
            {
                result |= RET_QFLST;
            }
        }
        
        /*
        AT+QFOPEN="RAM:record.amr",2
        +QFOPEN: 265144
        OK
        */
        p1 = strstr( p,"+QFOPEN:" );
        if( p1 != NULL && getsubstr2( p1,':','\r',pstr ) >= 1 )
        {
            gsm->amr.filehandle = atoi(pstr);
            result |= RET_QFOPEN;
        }
        
        p1 = strstr( p,"CONNECT" );
        if( p1 != NULL )
        {
            result |= RET_CONNECT;
            if( getsubstr2( p1,' ','\r',pstr ) >= 1 )
            {
                p2 = strchr( p1,'\n' );
                if( p2 != NULL )
                {
                    p2++;
                    t = atoi( pstr );
                    if( t > AMR_BLOCK_LEN ) t = AMR_BLOCK_LEN;
                    memcpy( gsm->amr.buf,p2,t );
                }
                result |= RET_QFREAD;
            }
        }
    }
    /*
    +QLTS: ""                //none--network failed
    +QLTS: "17/08/10,07:52:21+32,0"
    */
    p1 = strstr( p,"+QLTS:" );
    if( p1 != NULL && getsubstr2( p1,'"','"',pstr ) >= 17 )
    {
        result |= RET_QLTS;
    }
    
    if( strstr( p,"+PDP DEACT\r\n" ) != NULL || strstr( p,"DEACT OK\r\n" ) != NULL ) 
    {
        gsm->status &= ~GSM_STAT_TCP_CONFIG;
    }
    if( strstr( p,"CONNECT OK\r\n" ) != NULL || strstr( p,"ALREAY CONNECT\r\n" ) != NULL )
    {
        result |= RET_CONNECT;
    }
    
    if( gsm->module == MODULE_UC15 || gsm->module == MODULE_EC200S || gsm->module == MODULE_EC25 )
    {
        /*
        AT+QIACT? //Query the state of context.
        +QIACT: 1,1,1,"10.7.157.1"
        OK
        
        +QIOPEN: <connectID>,<err>
        <err> is 0 when service is started successfully, else
        <err> is not 0.
        AT+QIOPEN=1,0,"TCP","116.62.42.223",2001,0,1
        OK
        +QIOPEN: 0,0
        */
        p1 = strstr( p,"+QIACT:" );
        if( p1 != NULL && getsubstr( 1,p1,pstr ) == 1 && atoi(pstr) == 1 )
        {
            result |= RET_CONNECT;
        }
        
        p1 = strstr( p,"+QIOPEN:" );
        if( p1 != NULL && getsubstr( 1,p1,pstr ) >= 1 && atoi(pstr) == 0 )
        {
            result |= RET_CONNECT;
        }
    }
    //+IPCLOSE: 0,1 NETWORK CLOSED UNEXPECTEDLY
    if(strstr(p,"+IPCLOSE: 0") != NULL)
    {
        gsm->status &= ~(GSM_STAT_TCP_CONNECT+GSM_STAT_TCP_CONFIG);
    }
    if( strstr( p,"CLOSED\r\n" ) != NULL ) 
    {
        gsm->status &= ~GSM_STAT_TCP_CONNECT;
    }
    //+IP ERROR: Network is already opened
    if(strstr(p,"+IP ERROR: Network is already opened"))
    {
        result &=~ RET_ERROR;
        result |= RET_OK;
    }
    if( gsm->module == MODULE_UC15 || gsm->module == MODULE_EC200S || gsm->module == MODULE_EC25 )
    {
        p1 = strstr( p,"+QISEND:" );
        if( p1 != NULL && getsubstr2( p1,':',',',pstr ) >= 1 )
        {
            if( atoi(pstr) != 0 && getsubstr( 2,p1,pstr ) >= 1 && atoi( pstr ) == 0 ) result |= RET_TCP_ACK;
        }
    }
    else
    {
        p1 = strstr( p,"+QISACK:" );
        if( p1 != NULL && getsubstr2( p1,':',',',pstr ) >= 1 )
        {
            if( atoi(pstr) != 0 && getsubstr( 2,p1,pstr ) >= 1 && atoi( pstr ) == 0 ) result |= RET_TCP_ACK;
        }
        //+CIPACK: <sent_data_size>,<ack_data_size>,<recv_data_size>; e.g= +CIPACK: 10,10,5 /OK
        p1 = strstr( p,"+CIPACK: " );
        if( p1 != NULL)
        {
            result |= RET_TCP_ACK;
        }
    }
    //+CIPSEND: 0,23,23
    p1 = strstr(p,"+CIPSEND: ");
    if(p1 != NULL)
    {
        if(fDeleteSpecificDetectorsU16CfgRes&g_CurrentTransmit_buf[SENDING_CFG])
        {
            if(struParaSet.dat.delete_all_sub_response&2)
            {
                struParaSet.dat.delete_all_sub_response&=~2;
                task_global |= TASK_GLOBAL_WR_PARA_SET;
            }
        }
        if(fDeleteSpecificRemotesU16CfgRes&g_CurrentTransmit_buf[SENDING_CFG])
        {
            if(struParaSet.dat.delete_all_sub_response&1)
            {
                struParaSet.dat.delete_all_sub_response&=~1;
                task_global |= TASK_GLOBAL_WR_PARA_SET;
            }
        }
        g_CurrentTransmit_buf[SENDING_CFG] &=~ g_CurrentTransmit_buf[RESPONSE_CFG];
        
        g_CurrentTransmit_buf[SENDING_STATUS] &=~ g_CurrentTransmit_buf[RESPONSE_STATUS];
        
        result |= RET_SEND_OK;
    }
    /*
    +RECEIVE: 0, 18    
    
    IPD18:    
    
    UC15:
    +QIURC: “recv”,0,4    //Receive data from remote server.
    test
    +QIURC: "recv",0,18    //<CR><LF>
    */
    if( gsm->module == MODULE_UC15 || gsm->module == MODULE_EC200S || gsm->module == MODULE_EC25 )
    {
        p1 = strstr( p,"+QIURC: \"recv\"" );
        if( p1 != NULL && getsubstr( 2,p1,pstr ) >= 1 )
        {
            p2 = strchr( p1,'\n' );
            if( p2 != NULL )
            {
                p2++;
                t = atoi( pstr );
                Protocol_Analysis((u8*)p2,t);
            }
        }
    }
    else
    {
        p1 = strstr( p,"+IPD" );
        if( p1 != NULL)                     // && getsubstr2( p1,'D',':',pstr ) >= 1 )
        {
            if(g_M25_M26_specific==3)   //+IPD16
            {
                if(getsubstr2( p1,'D','\r',pstr ) >= 1)
                {
                    t = atoi( pstr );       //length of data received
                    
                    p2 = strchr( p1,'\n' );
                    printf("length = %d\n",t);
                    p2++;
                    for(l=0;l<t;l++)
                    {
                        printf("%02x",p2[l]);
                    }
                    printf("\n");   //1010032101005a20
                    Protocol_Analysis((u8*)p2,t);
                }
            }
        }
    }
    /*================================================================================*/
    
    myfree(pstr);
    myfree(pstr2);
    return result;
}
/*********************************************************************************************************
** Function name:    gsm_usart_handle
** Descriptions:    GSM DATA Detector
** input parameters:    NONE
** Output parameters:    NONE
** Returned value:    
*********************************************************************************************************/
void gsm_usart_handle(void)
{
    u8 *p;
    u16 t;
    
//    CPU_SR_ALLOC();
    t = get_usart_buffer( pStruUsartGsm,&p );
    if( t != 0 )
    {
        #if gsm_debug
        printf("\r\n%s",p);
//        printf( "\r\nram used:%u%%\r\n",mem_perused() );
        #endif
        at_return_result = gsm_parse((char *)p,&struGsm);
        
        if( at_return_result != 0 && (at_return_result&RET_ERROR) == 0 )
        {
            OSQFlush( msg_gsm_parse );
            OSQPost( msg_gsm_parse,( void * ) &at_return_result );
        }
        myfree(p);
    }
}
/*********************************************************************************************************
** Function name:    gsm_task_init
** Descriptions:    
** input parameters:    NONE
** Output parameters:    NONE
** Returned value:    
*********************************************************************************************************/
void gsm_task_init(void)
{
    struGsm.reset = 1;
    
    gflag.fReport1Status = fDeviceUidArrayStatusRes+fHardwareVersionU8StatusRes+fSoftwareVersionU8StatusRes;
    gflag.fReportCfg = (fMarsterLanguageU8CfgRes+fArmDisarmSoundSwitchU8CfgRes+fVoiceSoundSwitchU8CfgRes+fAlarmSoundSwitchU8CfgRes+fAlarmPropelSwitchU8CfgRes+fKeypadLockSwitchU8CfgRes+fKeypadToneSwitchU8CfgRes+fKeypadBacklightSwitchU8CfgRes);
}

//===========================================\
            Get Zone address\
//===========================================/
u16 get_zone_address_from_zoneNo(u16 zoneNo,u8 IsRemoteType)
{
    u16 i;
    u16 addr_index=0;
    
    for(i=0;i<DETECTOR_MAX+EOL_ZONE_NUM;i++)
    {
        if(my_detector.dat.detector[i].null==0xaa && my_detector.dat.detector[i].setting.number==zoneNo)
        {
            if(IsRemoteType==1) 
            {
                if(my_detector.dat.detector[i].setting.classification==EVENT_RMT)
                {
                    addr_index=i+1;
                    break;
                }
            }
            else if(my_detector.dat.detector[i].setting.classification!=EVENT_RMT)
            {
                addr_index=i+1;
                break;
            }
        }
    }
    return addr_index;
}
/****************************************************************
** Function name:    gsm_task
** Descriptions:    
** input parameters:    NONE
** Output parameters:    NONE
** Returned value:    
*****************************************************************/
static u32 keepalive_ticks=0;
void gsm_task(void)
{
    static u32 baudrate_sel=115200;
    static u8 ctr_tcp_connect;
    static bool m_b_variable=false;
    DataUint32TypeDef m32;
    u16 i,j,k;
    char *p;
//    bool TCP_Busy;
#if PK
    static u8 index_phone = 0;
#endif
    //u8 temp;
    SYS_ERR result;
    const STRU_AT *at;
    STRU_GSM *gsm = &struGsm;
    
//    TCP_Busy = (TyReadTypeDef.RegistedU8Status==2 && (g_CurrentTransmit_buf[SENDING_CFG]||g_CurrentTransmit_buf[SENDING_STATUS]||gflag.fReport1Status||gflag.fReportCfg))?true:false;
    
    if( gsm->reset != 0 )
    {
        gsm->status &= (GSM_STAT_AT_OK|GSM_STAT_IP_OK);
        TyReadTypeDef.RegistedU8Status = 0;
        gsm->rssi = 0;
        if( ( gsm->status&GSM_STAT_AT_OK ) != 0 )
        {
            gsm_power_down();
            gsm->status &= ~GSM_STAT_AT_OK;
        }
        printf("usart init:baudrate=%d\n",baudrate_sel);
        USART_DeInit(USART3);
        usart_init(USART_ID2,baudrate_sel);
        if( gsm_power_on() == SYS_ERR_OK )
        {
            if(gsm->module == MODULE_EC200S)
            {
                //Every time reset module, loudspeaker will be set as default,so we need to change it to what we set before.
//                usart_send_str( USART3,"AT+CLVL=3\r" );            /* Loudspeaker volume level selection: 0-3-5 */
            }
            gsm->reset = 0;
            gsm->status |= (GSM_STAT_AT_OK|GSM_BAUDRATE);
        }
        else if(GSM_BAUDRATE&gsm->status)
        {
            ;
        }
        else if(baudrate_sel==115200)
        {
            baudrate_sel=9600;
        }
        else
        {
            baudrate_sel=115200;
        }
        tmr_clock_test = 3;
        
        ctr_tcp_connect = 0;
//        ctr_tcp_send = 0;
    }
    else if( ( gsm->status&GSM_STAT_FIREWARE ) == 0 )
    {   /* get firmware and IMEI numbers */
        pgsGsm = PGS_GSM_GET_FIRMWARE;
        if(g_M25_M26_specific==2 || g_M25_M26_specific==3 || g_M25_M26_specific==4)
        {
            at = &AT_GET_FIRMWARE_CGMR;
        }
        else
        {
            at = &AT_GET_FIRMWARE;
        }
        if( at_cmd_return( at ) != SYS_ERR_OK )
        {
            gsm->reset = 1;
        }
        pgsGsm = PGS_GSM_GET_IMEI;
        if(g_M25_M26_specific==4)
        {
            at = &AT_GET_CGSN;
        }
        else
        {
            at = &AT_GET_IMEI;
        }
        at_cmd_return(at);
//        if(gsm->module == MODULE_EC200S)
//        {
//            usart_send_str( USART3,"AT+CLVL=3\r" );            /* Loudspeaker volume level selection: 0-3-5 */
//        }
        pgsGsm = PGS_GSM_FREE;
        gsm->status |= GSM_STAT_FIREWARE;
    }
    #if GPRS_F==0
    else if( !(gsm->status&GSM_STAT_AMR) && g_M25_M26_specific!=4 )
    {
        pgsGsm = PGS_GSM_READ_RECORD;
        gsm_audio_read( gsm->module );
        pgsGsm = PGS_GSM_FREE;
        gsm->status |= GSM_STAT_AMR;
    }
    else if( (gsm->task&GSM_TASK_SAVE_RECORD)!=0 && g_M25_M26_specific!=4)
    {
        pgsGsm = PGS_GSM_SAVE_RECORD;
        gsm_save_record( gsm->module );
        pgsGsm = PGS_GSM_FREE;
        gsm->task &= ~GSM_TASK_SAVE_RECORD;
    }
    else if( ( gsm->task&GSM_TASK_RECORD )!=0 && g_M25_M26_specific!=4)
    {
        switch(gsm->module)
        {
            case MODULE_M26:
            {
                if(g_M25_M26_specific==0)
                {
                    at = &struAtCallOut_M26[0];
                }
                else if(g_M25_M26_specific==3)
                {
                    at = &struAtCallOut_SIMCom7[0];
                }
                else at = &struAtCallOut_M25[0];
                break;
            }
            case MODULE_UC15:
            {
                at = &struAtCallOut_UC15[0];
                break;
            }
            case MODULE_EC200S:
            {
                at = &struAtCallOut_EC200S[0];
                break;
            }
            case MODULE_EC25:
            {
                at = &struAtCallOut_EC25[0];
                break;
            }
            default:
            {
                at = &struAtCallOut_UC15[0];
                break;
            }
        }
        if(g_M25_M26_specific==2);          /* SIMCom used default setting */
        else if(g_M25_M26_specific==3)     /* default setting for A7670 module */
        {
            at_cmd_list_return( at );      /* configuration mic & loudspeaker option */
        }
        else at_cmd_list_return( at );      /* configuration mic & loudspeaker option */
        gsm_audio_record( gsm->module );    /* audio file record */
        gsm->uc15_played = 1;
        pgsGsm = PGS_GSM_FREE;
        gsm->task &= ~GSM_TASK_RECORD;
    }
    else if( ( gsm->task&GSM_TASK_PLAY )!=0 && g_M25_M26_specific!=4)
    {
        gsm->task &= ~GSM_TASK_PLAY;
        gsm_file_to_voice_call( gsm->module );  /* audio file to voice call */
        gsm->uc15_played = 1;
        pgsGsm = PGS_GSM_FREE;
    }
    #endif
    else if( (gsm->status&GSM_STAT_CREG)==0 || (gsm->task&GSM_TASK_CREG )!=0 )
    {
        gsm->task &= ~GSM_TASK_CREG;
        result = check_network_stat();
        if(result != SYS_ERR_OK ) /* get the csq and creg status */
        {
            gsm->reset = 1;
        }
        else if(gsm->status&GSM_STAT_NO_SIM)
        {
        Registered_On_Network = UNKNOWN;
            pgsGsm = PGS_GSM_GET_ICCID;
            if(g_M25_M26_specific==3)
            {
                at = &AT_GET_CICCID;
            }
            else if(g_M25_M26_specific==4)
            {
                at =&AT_GET_NCCID;
            }
            else
            {
                at =&AT_GET_ICCID;
            }
            at_cmd_return(at);
            pgsGsm = PGS_GSM_FREE;
        }
        else if(!(gsm->status & GSM_STAT_IMSI))
        {
            pgsGsm = PGS_GSM_GET_IMSI;
            at = &AT_GET_IMSI;
            at_cmd_return(at);
            pgsGsm = PGS_GSM_FREE;
        }
    }
    else if( ( gsm->task&GSM_TASK_ENET_ACK ) != 0 )
    {
        gsm->task &= ~GSM_TASK_ENET_ACK;
    }
    else if( (gsm->status&GSM_STAT_INIT )==0 && g_M25_M26_specific!=4)
    {
        if( gsm_at_init( gsm->module ) == SYS_ERR_OK ) 
        {
            gsm->status |= GSM_STAT_INIT;
        }
        else gsm->reset = 1;
        
        if( ( struParaSet.dat.enable&APP_ENABLE_GSM_TIME ) != 0 )
        {
            if( gsm_set_clock( struParaSet.dat.ntp_domain,gsm->module ) == SYS_ERR_OK )
            {
                tmr_clock_test = 3;
            }
        }
    }
    #if GPRS_F==0
    else if( ( gsm->task&GSM_TASK_HANGUP ) != 0 && g_M25_M26_specific!=4)
    {
        gsm->task &= ~GSM_TASK_HANGUP;
        gsm_hangup();
    }
    else if((gsm->task&GSM_TASK_CALL_IN) && !TCP_Busy && g_M25_M26_specific!=4)
    {
        OS_CPU_SR cpu_sr=0;
        OS_ENTER_CRITICAL();
        gsm->task &= ~GSM_TASK_CALL_IN;
        gsm->status &= ~GSM_STAT_DISARM;
        pgsGsm = PGS_GSM_AUDIO_ALARM;
        OS_EXIT_CRITICAL();
        gsm_call_handle( gsm->alarm_target.phone,CALL_MODE_PLAY_PRESS,gsm->module );
        pgsGsm = PGS_GSM_FREE;
    }
    else if( (gsm->task&GSM_TASK_DETECTED_INCALL) != 0 && g_M25_M26_specific!=4)
    {
        gsm->task &=~ GSM_TASK_DETECTED_INCALL;
        usart_send_str( USART3,"AT+CLCC\r" );
        gsm->task |= GSM_TASK_INCALL_CHECK;
    }
    else if( ( gsm->task&GSM_TASK_CMGR ) != 0 && g_M25_M26_specific!=4)
    {
        gsm->task &= ~GSM_TASK_CMGR;
        gsm_read_sms( gsm->sms_index );     /* read SMS */
    }
    else if( ( gsm->task&GSM_TASK_CMGD ) != 0 && g_M25_M26_specific!=4)
    {
        gsm->task &= ~GSM_TASK_CMGD;
        gsm_delete_sms( gsm->sms_index );   /* Delete SMS */
    }
    else if(gsm->task&GSM_TASK_SMS_ALARM && g_M25_M26_specific!=4)
    {
        OS_CPU_SR cpu_sr = 0;
        OS_ENTER_CRITICAL();//CPU_CRITICAL_ENTER();               /* SMS Send */
        gsm->task &= ~GSM_TASK_SMS_ALARM;
        pgsGsm = PGS_GSM_SMS_ALARM;
        OS_EXIT_CRITICAL();//CPU_CRITICAL_EXIT();
        if( get_visible_num( gsm->alarm_target.phone ) >= 3 )
        {
            p = mymalloc( 512 );
            OSTimeDly( 500);//,OS_OPT_TIME_PERIODIC,&err );
            get_hz_alarm_sms( &struParaSet,(char*)gsm->alarm_target.ptr,p );
            if( if_event_with_zone( gsm->alarm_target.event ) != 0 )
            {
                strcat( p,UNICODE_ZONE[language] );
                #if RAMZONE==1
                sprintf( p+500,"%02u",struRunning.alarming_zone_number[gsm->alarm_target.event] );
                #else
                sprintf( p+500,"%02u",struParaRunning.alarming_zone_number[gsm->alarm_target.event] );
                #endif
                ascii_2_unicode( p+strlen(p),p+500 );
            }
//            p[280] = 0;
            gsm_send_sms( 1,gsm->alarm_target.phone,p );
            myfree( p );
        }
        pgsGsm = PGS_GSM_FREE;
    }
#if PK
    else if( (gsm->task & GSM_TASK_TEST_SIGNAL) != 0 )
    {
        if( pgsGsm == PGS_GSM_FREE
        && ( struGsm.task&(GSM_TASK_SMS_ALARM|GSM_TASK_AUDIO_ALARM) ) == 0 
        && ( ( struGsm.status&GSM_STAT_TCP_CONNECT ) == 0 || ( struGsm.task&GSM_TASK_ENET_ALARM ) == 0 ) )
        {
            pgsGsm = PGS_GSM_SMS_ALARM;
            if( ( struParaSet.dat.phone[index_phone].mode&PHONE_SMS_ENABLE ) != 0 && get_visible_num( struParaSet.dat.phone[index_phone].phone ) >= 3 )
            {
                gsm_send_sms( 0,struParaSet.dat.phone[index_phone].phone,"Test Signal." );
            }
        }
        if(index_phone++ >= PHONE_MAX)
        {
            TestSignal_24H_Timer_sec = 1;
            index_phone=0;
            gsm->task &=~ GSM_TASK_TEST_SIGNAL;
        }
        pgsGsm = PGS_GSM_FREE;
    }
#endif
    else if( ( gsm->task&GSM_TASK_SMS_ECHO ) != 0 && g_M25_M26_specific!=4)
    {
        gsm->task &= ~GSM_TASK_SMS_ECHO;    /* SMS ech */
        pgsGsm = PGS_GSM_SMS_ECHO;
        if( get_visible_num( gsm->target.phone ) >= 3 )
        {
            switch( gsm->target.content )
            {
                case ECHO_CONST_HANZI:
                p = mymalloc( 280+1 );
                get_hz_alarm_sms( &struParaSet,(char*)gsm->target.ptr,p );
                gsm_send_sms( 1,gsm->target.phone,p );
                myfree( p );
                break;
                
                case ECHO_PHONE:
                case ECHO_DELAY:
                case ECHO_ENABLE:
                case ECHO_DETECTOR_LEARNED:
                case ECHO_SYSTEM:
                case ECHO_SYSTEM2:
                p = mymalloc( 192 );
                get_para_echo_sms( (ENUM_CMD_ECHO)gsm->target.content,p );
                gsm_send_sms( 0,gsm->target.phone,p );
                myfree( p );
                break;
                
                default:
                break;
            }
        }
        pgsGsm = PGS_GSM_FREE;
    }
    else if(gsm->task&GSM_TASK_AGPS)            /* not used */
    {
        gsm->task &= ~GSM_TASK_AGPS;
    }
    else if((gsm->task&GSM_TASK_USER_CALL) && !TCP_Busy && g_M25_M26_specific!=4)    /* call  handle */
    {
        OS_CPU_SR cpu_sr=0;
        OS_ENTER_CRITICAL();//CPU_CRITICAL_ENTER();
        gsm->task &= ~GSM_TASK_USER_CALL;
        gsm->status &= ~GSM_STAT_DISARM;
        pgsGsm = PGS_GSM_USER_CALL;
        OS_EXIT_CRITICAL();//CPU_CRITICAL_EXIT();
        gsm_call_handle( gsm->user_call_phone,CALL_MODE_OUT,gsm->module );    /* call out @mode=0 */
        pgsGsm = PGS_GSM_FREE;
    }
    else if((gsm->task&GSM_TASK_AUDIO_ALARM) && !TCP_Busy && g_M25_M26_specific!=4)    /* audio alarm */
    {
        OS_CPU_SR cpu_sr=0;
        OS_ENTER_CRITICAL();//CPU_CRITICAL_ENTER();
        gsm->task &= ~GSM_TASK_AUDIO_ALARM;
        gsm->status &= ~GSM_STAT_DISARM;
        pgsGsm = PGS_GSM_AUDIO_ALARM;
        OS_EXIT_CRITICAL();//CPU_CRITICAL_EXIT();
        if( gsm_call_handle( gsm->alarm_target.phone,CALL_MODE_OUT|CALL_MODE_PLAY_PRESS,gsm->module ) == SYS_ERR_CONNECTED )
        {
            OSTimeDly( 5000);//,OS_OPT_TIME_PERIODIC,&err );    /* delay 5s to avoid call in time */
        }
        pgsGsm = PGS_GSM_FREE;
    }
    #endif
    else if( ( gsm->status&GSM_STAT_IP_OK ) != 0 )
    {
        if(( gsm->status&GSM_STAT_TCP_CONFIG ) == 0)              // APN CONFIGURATION
        {
            if( gsm_set_tcp_config(gsm->module ) == SYS_ERR_OK)
            {
                gsm->status |= GSM_STAT_TCP_CONFIG;                 //next step logon the server
                gsm->status &= ~GSM_STAT_TCP_CONNECT;
            }
            else gsm->reset = 1;
        }
        else if(( gsm->status&GSM_STAT_TCP_CONNECT ) == 0)        // LOGON TCP SERVER
        {
            TyReadTypeDef.RegistedU8Status=1;
            if(gsm_set_tcp_connect( TCP_INDEX_ENET,TCP_MODE_TCP,&struParaSet.dat.gprs_ip,gsm->module ) == SYS_ERR_OK)
            {
//                NoAckResponse_Count = 0;
                ctr_tcp_connect = 0;
                My_TcpTx = TCP_IDLE;
                if(Registered_On_Network != LOGIN_OK){
                    gflag.fReport1Status |= (fRegistedU8StatusRes|fProvisioningCmdStatus);
                }
                TyReadTypeDef.RegistedU8Status = 2;
                gsm->task |= GSM_TASK_ENET_PULSE;
                gsm->status |= GSM_STAT_TCP_CONNECT;
            }
            else
            {
                if( ++ctr_tcp_connect >= 20 )
                {
                    gsm->reset = 1;
                }
                else
                {
                    gsm_close_connect( TCP_INDEX_ENET,gsm->module );
                    gsm->status &= ~GSM_STAT_TCP_CONNECT;
                }
            }
            if(m_b_variable){
                m_b_variable = false;
            }
        }
        else                                                    // TCP SERVICE ONLINE
        {
            switch(My_TcpTx)
            {
                case TCP_IDLE:
                {
#if AEP_F_==1
                    if(Registered_On_Network != LOGIN_OK)
                    {
                        EnLength = 0;
                        m_b_variable = true;
                        AEP_ProvisioningReq();
                        printf("provistion request:%d\n",EnLength);
                        My_TcpTx = TCP_UPLINK_PACKAGE;
                        break;
                    }else
#endif
                     if(g_CurrentTransmit_buf[SENDING_CFG]||g_CurrentTransmit_buf[SENDING_STATUS])
                    {
                        g_CurrentTransmit_buf[RESPONSE_STATUS] = 0;
                        g_CurrentTransmit_buf[RESPONSE_CFG]       = 0;
                        My_TcpTx = TCP_MESSAGE_PAYLOAD;
                    }
                    else if(fProvisioningCmdStatus & gflag.fReport1Status)
                    {
                        g_CurrentTransmit_buf[SENDING_STATUS] = fProvisioningCmdStatus;
                        gflag.fReport1Status &=~ fProvisioningCmdStatus;
                    }
                    /*else if(fImeiNumberArrayStatusRes & gflag.fReport1Status)
                    {
                        g_CurrentTransmit_buf[SENDING_STATUS] = fImeiNumberArrayStatusRes;
                        gflag.fReport1Status &=~ fImeiNumberArrayStatusRes;
                    }*/
                    else if(gflag.fReport1Status || gflag.fReportCfg)
                    {
                        g_CurrentTransmit_buf[SENDING_STATUS] = gflag.fReport1Status;
                        g_CurrentTransmit_buf[SENDING_CFG]    = gflag.fReportCfg;
                        gflag.fReport1Status = 0;
                        gflag.fReportCfg = 0;
                    }
                    else if(struParaSet.dat.delete_all_sub_response&3)
                    {
                        if(struParaSet.dat.delete_all_sub_response&1)
                        {
                            TyReadTypeDef.DeleteSpecificRemotesU16 = 0xffff;
                            gflag.fReportCfg |= fDeleteSpecificRemotesU16CfgRes;
                        }
                        if(struParaSet.dat.delete_all_sub_response&2)
                        {
                            TyReadTypeDef.DeleteSpecificDetectorsU16 = 0xffff;
                            gflag.fReportCfg |= fDeleteSpecificDetectorsU16CfgRes;
                        }
                    }
                    #if AEP_F_==1
                    else if(f1HeartBeatSend & gflag.flag1)
                    {
//                        printf("NoAckResponse_Count=%d\n",NoAckResponse_Count);
//                        NoAckResponse_Count++;
                        EnLength = 0;
                        m_b_variable = true;
                        AEP_HeartBeat();
                        My_TcpTx = TCP_UPLINK_PACKAGE;
                        gflag.flag1 &=~ f1HeartBeatSend;
                    }
                    #else
                    else if(keepalive_ticks++ >= struParaSet.dat.KeepaliveIntervalTimeU16*100)
                    {
                        gflag.fReport1Status |= (fAckRequestCmdStatus|fNetworkRssiU8StatusRes);
                        keepalive_ticks = 0;
                    }
                    #endif
                    break;
                }
                case TCP_MESSAGE_PAYLOAD:
                {
                    EnLength = 0;
#if     CMD_F_== 1
                        //========================== commands ======================
                        //------------------- provisioning -------------
                        if(fProvisioningCmdStatus &g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            Provisioning_Request();
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fProvisioningCmdStatus;
                        }
                        //------------------- ack ----------------------
                        if(fAckResponseCmdStatus & g_CurrentTransmit_buf[SENDING_STATUS])        //response
                        {
                            Send_SingleID_Packet(AckResponseID);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fAckResponseCmdStatus;
                        }
                        if(fAckRequestCmdStatus & g_CurrentTransmit_buf[SENDING_STATUS])        //request
                        {
//                            printf("NoAckResponse_Count=%d\n",NoAckResponse_Count);
//                            NoAckResponse_Count++;
                            Send_SingleID_Packet(AckRequestID);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fAckRequestCmdStatus;
                        }
                        //---------------- sequence number -------------
                        if(fAckSeqResponseCmdStatus & g_CurrentTransmit_buf[SENDING_STATUS])    //response
                        {
                            SendSequenceNumberResponse(sequence_number_res.Value);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fAckSeqResponseCmdStatus;
                        }
                        if(fAckSeqRequestCmdStatus & g_CurrentTransmit_buf[SENDING_STATUS])        //request
                        {
                            SendSequenceNumberRequest(sequence_number_req.Value);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fAckSeqRequestCmdStatus;
                        }
#endif
#if     CFG_F_== 1
                        //================== configuration response =====================
                        if(fDeviceServerIpAddressArrayCfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            g16_package_length = strlen((const char*)struParaSet.dat.gprs_ip.address);
                            Read_ConfigCharArrayValue_Responses(DeviceServerIpAddressArrayCfgID, (uint8_t*)struParaSet.dat.gprs_ip.address);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fDeviceServerIpAddressArrayCfgRes;
                        }
                        if(fAlarmPhoneNumbersArrayCfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            p = mymalloc(64);
                            if(TyReadTypeDef.AlarmPhoneNumbersArray!=0)   //report specific phone
                            {
                                if(struParaSet.dat.phone[TyReadTypeDef.AlarmPhoneNumbersArray-1].phone[0]!=0)    //the phone numbers are valid
                                {
                                    k = strlen((const char*)struParaSet.dat.phone[TyReadTypeDef.AlarmPhoneNumbersArray-1].phone);
                                    if(k < PHONE_LEN)
                                    {
                                        p[0]=TyReadTypeDef.AlarmPhoneNumbersArray;                         //number of phone
                                        g16_package_length = k+1;
                                        strcpy((char*)(p+1), struParaSet.dat.phone[TyReadTypeDef.AlarmPhoneNumbersArray-1].phone);    //phone number
                                        Read_ConfigCharArrayValue_Responses(DeviceServerIpAddressArrayCfgID,(uint8_t*)p);
                                    }
                                }
                                TyReadTypeDef.AlarmPhoneNumbersArray = 0;
                            }
                            else                                                    //report all phone
                            {
                                for(j=0;j<PHONE_MAX;j++)
                                {
                                    if(struParaSet.dat.phone[j].phone[0]!=0)
                                    {
                                        k = strlen((const char*)struParaSet.dat.phone[j].phone);
                                        if(k < PHONE_LEN)
                                        {
                                            p[0]=j+1;                                        //number of phone
                                            g16_package_length = k+1;
                                            strcpy((char*)(p+1), struParaSet.dat.phone[j].phone);    //phone number
                                            Read_ConfigCharArrayValue_Responses(DeviceServerIpAddressArrayCfgID,(uint8_t*) p);
                                        }
                                    }
                                }
                            }
                            myfree(p);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fAlarmPhoneNumbersArrayCfgRes;
                        }
                        if(fAlarmMessageArrayCfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fAlarmMessageArrayCfgRes;
                        }
                        if(fLoginResponseU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fLoginResponseU8CfgRes;
                        }
                        if(fMarsterModeU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            if(f1Muffing_APP&gflag.flag1)
                            {
                                k=0;
                                gflag.flag1 &=~ f1Muffing_APP;
                            }
                            else if(struParaRunning.remote1==APP_RMT_ARM)
                            {
                                k=1;
                            }
                            else if(struParaRunning.remote1==APP_RMT_DISARM)
                            {
                                k=0;
                            }
                            else
                            {
                                k=struParaRunning.remote1;
                            }
                            Read_ConfigValueU8_Responses(MarsterModeU8CfgID,k);
                            
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fMarsterModeU8CfgRes;
                        }
                        if(fArmDisarmSoundSwitchU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = (struParaSet.dat.enable&APP_ENABLE_ARM_VOICE)?1:0;
                            Read_ConfigValueU8_Responses(ArmDisarmSoundSwitchU8CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fArmDisarmSoundSwitchU8CfgRes;
                        }
                        if(fVoiceSoundSwitchU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = (struParaSet.dat.enable&APP_ENABLE_HUMAN_VOICE)?1:0;
                            Read_ConfigValueU8_Responses(VoiceSoundSwitchU8CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fVoiceSoundSwitchU8CfgRes;
                        }
                        if(fAlarmSoundSwitchU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = (struParaSet.dat.enable&APP_ENABLE_ALARM_VOICE)?1:0;
                            Read_ConfigValueU8_Responses(AlarmSoundSwitchU8CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fAlarmSoundSwitchU8CfgRes;
                        }
                        if(fAlarmPropelSwitchU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = (struParaSet.dat.enable&APP_ENABLE_ARM_SMS)?1:0;
                            Read_ConfigValueU8_Responses(AlarmPropelSwitchU8CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fAlarmPropelSwitchU8CfgRes;
                        }
                        if(fDeviceStateU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = struParaSet.dat.master_state;
                            Read_ConfigValueU8_Responses(DeviceStateU8CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fDeviceStateU8CfgRes;
                        }
                        if(fAddSubAdminModeU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = 0;
                            j = struLearn.duration;
                            if(j!=0)
                            {
                                if(struLearn.setting.classification == EVENT_RMT)
                                {
                                    k=1;
                                }
                                else if(struLearn.setting.classification == EVENT_RFID)
                                {
                                    k=3;
                                }
                                else
                                {
                                    k=2;
                                }
                            }
                            Read_ConfigValueU8_Responses(AddSubAdminModeU8CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fAddSubAdminModeU8CfgRes;
                        }
                        if(fVoiceVolumeU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            Read_ConfigValueU8_Responses(AlarmSoundSwitchU8CfgID,struParaSet.dat.VoiceVolumeU8);
                            //Read_ConfigValueU8_Responses(AlarmSoundSwitchU8CfgID,15);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fVoiceVolumeU8CfgRes;
                        }
                        if(fDoorbellVolumeU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            Read_ConfigValueU8_Responses(DoorbellVolumeU8CfgID,struParaSet.dat.DoorbellVolumeU8);
                            //Read_ConfigValueU8_Responses(DoorbellVolumeU8CfgID,15);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fDoorbellVolumeU8CfgRes;
                        }
                        if(fAlarmVolumeU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            Read_ConfigValueU8_Responses(AlarmVolumeU8CfgID,struParaSet.dat.AlarmVolumeU8);
                            //Read_ConfigValueU8_Responses(AlarmVolumeU8CfgID,15);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fAlarmVolumeU8CfgRes;
                        }
                        if(fKeypadLockSwitchU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = (struParaSet.dat.enable&APP_ENABLE_KEYPAD_LOCK)?1:0;
                            Read_ConfigValueU8_Responses(KeypadLockSwitchU8CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fKeypadLockSwitchU8CfgRes;
                        }
                        if(fKeypadToneSwitchU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = (struParaSet.dat.enable&APP_ENABLE_KEYPAD_TONE)?1:0;
                            Read_ConfigValueU8_Responses(KeypadToneSwitchU8CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fKeypadToneSwitchU8CfgRes;
                        }
                        if(fWinDoorOpenAlertSwitchU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = (struParaSet.dat.enable&APP_ENABLE_DOOR_OPEN)?1:0;
                            Read_ConfigValueU8_Responses(WinDoorOpenAlertSwitchU8CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fWinDoorOpenAlertSwitchU8CfgRes;
                        }
                        if(fKeypadBacklightSwitchU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = struParaSet.dat.enable&APP_ENABLE_KEYPAD_BL?1:0;
                            Read_ConfigValueU8_Responses(KeypadBacklightSwitchU8CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fKeypadBacklightSwitchU8CfgRes;
                        }
                        if(fMarsterLanguageU8CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = struParaSet.dat.language;
                            Read_ConfigValueU8_Responses(MarsterLanguageU8CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fMarsterLanguageU8CfgRes;
                        }
                        if(fDeviceServerIpPortU16CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = struParaSet.dat.gprs_ip.port;
                            Read_ConfigValueU16_Responses(DeviceServerIpPortU16CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fDeviceServerIpPortU16CfgRes;
                        }
                        if(fArmedDelayTimeU16CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = struParaSet.dat.delay_exit;
                            Read_ConfigValueU16_Responses(ArmedDelayTimeU16CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fArmedDelayTimeU16CfgRes;
                        }
                        if(fAlarmedDelayTimeU16CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = struParaSet.dat.delay_entry;
                            Read_ConfigValueU16_Responses(AlarmedDelayTimeU16CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |=fAlarmedDelayTimeU16CfgRes;
                        }
                        if(fAlarmTimeoutU16CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = struParaSet.dat.delay_horn;
                            Read_ConfigValueU16_Responses(AlarmTimeoutU16CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fAlarmTimeoutU16CfgRes;
                        }
                        if(fKeepaliveIntervalTimeU16CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = struParaSet.dat.KeepaliveIntervalTimeU16;
                            Read_ConfigValueU16_Responses(KeepaliveIntervalTimeU16CfgID,k);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fKeepaliveIntervalTimeU16CfgRes;
                        }
                        if(fDeleteSpecificRemotesU16CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            Read_ConfigValueU16_Responses(DeleteSpecificRemotesU16CfgID,TyReadTypeDef.DeleteSpecificRemotesU16);    //0=none delete,0xffff=delete all of remotes
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fDeleteSpecificRemotesU16CfgRes;
                        }
                        if(fDeleteSpecificDetectorsU16CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            Read_ConfigValueU16_Responses(DeleteSpecificDetectorsU16CfgID,TyReadTypeDef.DeleteSpecificDetectorsU16);//=noe delete,0xffff=delete all of detctors
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fDeleteSpecificDetectorsU16CfgRes;
                        }
                        if(fSystemPasswordsU32CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = struParaSet.dat.engineer_pwd;
                            m32.long_value = 0;
                            //1234%1000=
                            m32.value[3] = struParaSet.dat.engineer_pwd%10000/1000 +'0';     //thousand
                            m32.value[2] = struParaSet.dat.engineer_pwd%1000/100 +'0';     //hundred
                            m32.value[1] = struParaSet.dat.engineer_pwd%100/10 +'0';     //ten
                            m32.value[0] = struParaSet.dat.engineer_pwd%10 +'0';     //one
                            
                            Read_ConfigValueU32_Responses(SystemPasswordsU32CfgID,m32.long_value);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fSystemPasswordsU32CfgRes;
                        }
                        if(fUserPasswordsU32CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = struParaSet.dat.user_pwd;
                            m32.long_value = 0;
                            m32.value[3] = struParaSet.dat.user_pwd%10000/1000 +'0';     //thousand
                            m32.value[2] = struParaSet.dat.user_pwd%1000/100 +'0';     //hundred
                            m32.value[1] = struParaSet.dat.user_pwd%100/10 +'0';     //ten
                            m32.value[0] = struParaSet.dat.user_pwd%10 +'0';    //one
                            
                            Read_ConfigValueU32_Responses(UserPasswordsU32CfgID,m32.long_value);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |=  fUserPasswordsU32CfgRes;
                        }
                        if(fHijackPasswordsU32CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            k = struParaSet.dat.HijackPasswordsU16;
                            m32.long_value = 0;
                            m32.value[3] = struParaSet.dat.HijackPasswordsU16%10000/1000 +'0';     //thousand
                            m32.value[2] = struParaSet.dat.HijackPasswordsU16%1000/100 +'0';     //hundred
                            m32.value[1] = struParaSet.dat.HijackPasswordsU16%100/10 +'0';     //ten
                            m32.value[0] = struParaSet.dat.HijackPasswordsU16%10 +'0';    //one
                            Read_ConfigValueU32_Responses(HijackPasswordsU32CfgID,m32.long_value);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fHijackPasswordsU32CfgRes;
                        }
                        if(fDetectorConfigurationU32CfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            j=TyReadTypeDef.DetectorConfigurationU32>>16;
                            i = 0;
                            Read_ConfigValueU32_Responses(DetectorConfigurationU32CfgID,TyReadTypeDef.DetectorConfigurationU32);
                            
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fDetectorConfigurationU32CfgRes;
                        }
#endif
#if     STS_F_== 1
                        //========================== status =============================
                        if(fDeviceUidArrayStatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            p=mymalloc(8);
                            m32.long_value=struParaSet.dat.id;        //get id
                            for(i=0;i<6;i++)            //id to string
                            {
                                j = m32.long_value&0xf;
                                m32.long_value>>=4;
                                if(j<=9)
                                    p[i] = j+'0';
                                else
                                    p[i]= j+55;
                            }
                            g16_package_length = i;
                            Read_StatusCharArrayValue_Responses(DeviceUidArrayStatusID,(uint8_t*)p);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fDeviceUidArrayStatusRes;
                            myfree(p);
                        }
                        if(fImeiNumberArrayStatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            g16_package_length = strlen((const char *)struGsm.imei);// GsmData.cTelitIMEI);
                            Read_StatusCharArrayValue_Responses(ImeiNumberArrayStatusID,(uint8_t*)struGsm.imei);// GsmData.cTelitIMEI);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fImeiNumberArrayStatusRes;
                        }
                        if(fSimIccidNumberArrayStatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            g16_package_length = strlen((const char *)struGsm.iccid);// GsmData.cSimICCID);
                            Read_StatusCharArrayValue_Responses(SimIccidNumberArrayStatusID,(uint8_t*)struGsm.iccid);// GsmData.cSimICCID);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fSimIccidNumberArrayStatusRes;
                        }
                        if(fZoneAlertContextArrayStatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            k = TyReadTypeDef.ZoneAlertContextArrayStatus.zoneNumber;
                            j = get_zone_address_from_zoneNo(k,0);
                            
                            if(j != 0)          //zone address is valid
                            {
                                p=mymalloc(16);
                                i=0;
                                p[i++]= k>>8;    //zone number high bye
                                p[i++]= k;        //zone number low byte
                                
                                p[i++]= 0;      //zone ID highest byte
                                p[i++]= my_detector.dat.detector[j-1].addr[2];
                                p[i++]= my_detector.dat.detector[j-1].addr[1];
                                p[i++]= my_detector.dat.detector[j-1].addr[0];  //zone ID lowest byte
                                p[i++] = my_detector.dat.detector[j-1].setting.classification;
                                g16_package_length = i;
                                Read_StatusCharArrayValue_Responses(ZoneAlertContextArrayStatusID, (u8*)p);
                            }
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fZoneAlertContextArrayStatusRes;
                        }
                        if(fWinDoorOpenAlertArrayStatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            k = TyReadTypeDef.WinDoorOpenAlertArrayStatus.zoneNumber;
                            j=get_zone_address_from_zoneNo(k,0);
                            
                            if(j != 0)          //zone address is valid
                            {
                                p=mymalloc(16);
                                i=0;
                                p[i++]= k>>8;    //zone number high bye
                                p[i++]= k;        //zone number low byte
                                p[i++]= 0;//my_detector.dat.detector[j-1].setting.classification;
                                p[i++]= my_detector.dat.detector[j-1].addr[2];
                                p[i++]= my_detector.dat.detector[j-1].addr[1];
                                p[i++]= my_detector.dat.detector[j-1].addr[0];  //zone ID lowest byte
                                p[i++]=TyReadTypeDef.WinDoorOpenAlertArrayStatus.status;
                                g16_package_length = i;
                                Read_StatusCharArrayValue_Responses(ZoneAlertContextArrayStatusID, (u8*)p);
                            }
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fWinDoorOpenAlertArrayStatusRes;
                        }
                        if(fRegistedU8StatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            Read_StatusU8Value_Responses(RegistedU8StatusID, TyReadTypeDef.RegistedU8Status);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fRegistedU8StatusRes;
                        }
                        if(fMainPowerSupplyU8StatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            Read_StatusU8Value_Responses(MainPowerSupplyU8StatusID, TyReadTypeDef.MainPowerSupplyU8Status);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fMainPowerSupplyU8StatusRes;
                        }
                        if(fBatterySupplyU8StatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            Read_StatusU8Value_Responses(BatterySupplyU8StatusID, TyReadTypeDef.BatterySupplyU8Status);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fBatterySupplyU8StatusRes;
                        }
                        if(fHardwareVersionU8StatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            Read_StatusU8Value_Responses(HardwareVersionU8StatusID, HARDWARE_VER);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fHardwareVersionU8StatusRes;
                        }
                        if(fSoftwareVersionU8StatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            Read_StatusU8Value_Responses(SoftwareVersionU8StatusID, SOFTWARE_VER);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fSoftwareVersionU8StatusRes;
                        }
                        if(fNetworkRssiU8StatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            Read_StatusU8Value_Responses(NetworkRssiU8StatusID,TyReadTypeDef.NetworkRssiU8Status);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fNetworkRssiU8StatusRes;
                        }
                        /*if(fAlertEventU8StatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            Read_StatusU8Value_Responses(AlertEventU8StatusID, TyReadTypeDef.AlertEventU8Status);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fAlertEventU8StatusRes;
                        }*/
                        if(fBatteryVoltageU16StatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            Read_StatusU16Value_Responses(BatteryVoltageU16StatusID, TyReadTypeDef.BatteryVoltageU16Status);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fBatteryVoltageU16StatusRes;
                        }
                        if(fLocationTimestampU32StatusRes & g_CurrentTransmit_buf[SENDING_STATUS])
                        {
                            extern struct tm calendar;
                            TyReadTypeDef.LocationTimestampU32Status.Bit.year = calendar.tm_year-2000;
                            TyReadTypeDef.LocationTimestampU32Status.Bit.month = calendar.tm_mon+1;
                            TyReadTypeDef.LocationTimestampU32Status.Bit.day = calendar.tm_mday;
                            TyReadTypeDef.LocationTimestampU32Status.Bit.hour = calendar.tm_hour;
                            TyReadTypeDef.LocationTimestampU32Status.Bit.minute = calendar.tm_min;
                            TyReadTypeDef.LocationTimestampU32Status.Bit.second = calendar.tm_sec;
                            printf("time=0x%08x\n",TyReadTypeDef.LocationTimestampU32Status.value);
                            Read_StatusU32Value_Responses(LocationTimestampU32StatusID, TyReadTypeDef.LocationTimestampU32Status.value);
                            g_CurrentTransmit_buf[RESPONSE_STATUS] |= fLocationTimestampU32StatusRes;
                        }
#endif
#if     IDN_F_== 1
                        //================== below must be payload independently ----------------------
                        if(fTimerAttributyArrayCfgRes & g_CurrentTransmit_buf[SENDING_CFG])
                        {
                            if(TyReadTypeDef.TimerReportNumber!=0)  //report specific timer
                            {
                                Timer_index = TyReadTypeDef.TimerReportNumber-1;
                            }
                            if(Timer_index==0)
                            {
                                gflag.flag1 &=~ f1TimerExist;
                            }
                            p = mymalloc(8);
                            for( ;Timer_index < TIMER_NUM;Timer_index++)
                            {
                                k = struParaSet.dat.TIMR[Timer_index].workOption;
                                
                                if((k >=T_DISARM || k <=T_SOS)  && struParaSet.dat.TIMR[Timer_index].hour<24 && struParaSet.dat.TIMR[Timer_index].minute<60)
                                {
                                    if(!(f1TimerExist & gflag.flag1))
                                    {
                                        gflag.flag1 |= f1TimerExist;
                                    }
                                    p[0] = Timer_index+1;                            //timer number 1-254
                                    p[1] = struParaSet.dat.TIMR[Timer_index].wday;  //working day
                                    p[2] = struParaSet.dat.TIMR[Timer_index].hour;
                                    p[3] = struParaSet.dat.TIMR[Timer_index].minute;
                                    p[4] = struParaSet.dat.TIMR[Timer_index].workOption;
                                    g16_package_length = 5;
                                    Read_ConfigCharArrayValue_Responses(TimerAttributyArrayCfgID,(u8*)p);
                                    if(EnLength >= 200)
                                    {
                                        break;
                                    }
                                }
                                if(TyReadTypeDef.TimerReportNumber != 0)
                                {
                                    Timer_index = TIMER_NUM;
                                    break;
                                }
                            }
                            if(Timer_index >= TIMER_NUM)
                            {
                                if(!(f1TimerExist & gflag.flag1))                       //no timer
                                {
                                    p[0] = 0;
                                    g16_package_length = 1;
                                    Read_ConfigCharArrayValue_Responses(TimerAttributyArrayCfgID,(u8*)p);
                                }
                                g_CurrentTransmit_buf[RESPONSE_CFG] |= fTimerAttributyArrayCfgRes;
                                Timer_index = 0;
                            }
                            myfree(p);
                        }
                        if((fZoneRenamArrayCfgRes&g_CurrentTransmit_buf[SENDING_CFG]) && !EnLength)
                        {
                            p= mymalloc(128);
                            i=0;
                            if(TyReadTypeDef.zoneRenameCfg.zone_num!=0)
                            {
                                k=TyReadTypeDef.zoneRenameCfg.zone_num;
                                p[i++]=(k<<8);
                                p[i++]=k;
                                k=TyReadTypeDef.zoneRenameCfg.name_len;
                                if(k>=60)
                                {
                                    k=0;
                                }
                                p[i++]=k;
                                for(j=0;j<k;j++)
                                {
                                    p[i++]=TyReadTypeDef.zoneRenameCfg.zone_name[j];
                                }
                                k=TyReadTypeDef.zoneRenameCfg.stall_len;
                                if(k>=60)
                                {
                                    k=0;
                                }
                                p[i++]=k;
                                for(j=0;j<k;j++)
                                {
                                    p[i++]=TyReadTypeDef.zoneRenameCfg.stall_name[j];
                                }
                            }
                            else
                            {
                                p[i++]=0;
                                p[i++]=0;
                                p[i++]=0;
                                p[i++]=0;
                            }
                            g16_package_length = i;
                            Read_ConfigCharArrayValue_Responses(ZoneInformationRenameID,(u8*)p);
                            g_CurrentTransmit_buf[RESPONSE_CFG] |= fZoneRenamArrayCfgRes;
                        }
                        if((fNewRemoteAddedArrayStatus & g_CurrentTransmit_buf[SENDING_STATUS])&&(EnLength==0))
                        {
                            p= mymalloc(250);
                            if(TyReadTypeDef.NewRemoteNumber != 0)  //report specific remote ?
                            {
                                k = get_zone_address_from_zoneNo(TyReadTypeDef.NewRemoteNumber,1);
                                if(k==0)     //the remote not exist
                                {
                                    p[0] = 0;
                                    p[1] = 0;
                                    g16_package_length = 2;
                                }
                                else
                                {
                                    i=0;
                                    //No.
                                    p[i++]=(u8)TyReadTypeDef.NewRemoteNumber>>8; //remote number
                                    p[i++]=(u8)TyReadTypeDef.NewRemoteNumber;
                                    //ID
                                    p[i++]=0;
                                    p[i++]=my_detector.dat.detector[k-1].addr[2];
                                    p[i++]=my_detector.dat.detector[k-1].addr[1];
                                    p[i++]=my_detector.dat.detector[k-1].addr[0];
                                    g16_package_length = i;
                                }
                                Read_StatusCharArrayValue_Responses(NewRemoteAddedArrayStatusID,(u8*)p);
                                g_CurrentTransmit_buf[RESPONSE_STATUS] |= fNewRemoteAddedArrayStatus;
                            }
                            else                                    //Report all remotes
                            {
                                if(Remote_index==0) //start with no device
                                {
                                    gflag.flag1&=~f1RemoteExist;
                                }
                                i=0;                //number of bytes
                                for(;Remote_index <DETECTOR_MAX;Remote_index++)
                                {
                                    if(my_detector.dat.detector[Remote_index].null==0xaa)
                                    {
                                        if(my_detector.dat.detector[Remote_index].setting.classification==EVENT_RMT)
                                        {
                                            if(i >= 200)        //each time should be less than 200 bytes.
                                            {
                                                Remote_index--; //byters overflow, report it next time.
                                                break;
                                            }
                                            //No.
                                            p[i++]=(u8)my_detector.dat.detector[Remote_index].setting.number>>8;
                                            p[i++]=(u8)my_detector.dat.detector[Remote_index].setting.number;
                                            //ID
                                            p[i++]=0;
                                            p[i++]=my_detector.dat.detector[Remote_index].addr[2];
                                            p[i++]=my_detector.dat.detector[Remote_index].addr[1];
                                            p[i++]=my_detector.dat.detector[Remote_index].addr[0];
                                        }
                                    }
                                }
                                if(i!=0)            //number of bytes
                                {
                                    gflag.flag1|=f1RemoteExist;
                                    g16_package_length = i;
                                    Read_StatusCharArrayValue_Responses(NewRemoteAddedArrayStatusID,(u8*)p);
                                }
                                else if(!(gflag.flag1&f1RemoteExist))
                                {
                                    p[0] = 0;
                                    p[1] = 0;
                                    g16_package_length = 2;
                                    Read_StatusCharArrayValue_Responses(NewRemoteAddedArrayStatusID,(u8*)p);
                                }
                                if(Remote_index>=DETECTOR_MAX)
                                {
                                    g_CurrentTransmit_buf[RESPONSE_STATUS] |= fNewRemoteAddedArrayStatus;
                                    Remote_index = 0;
                                }
                            }
                            myfree(p);
                        }
                        if((fNewDetectorAddedArrayStatus & g_CurrentTransmit_buf[SENDING_STATUS])&&(EnLength==0))
                        {
                            p=mymalloc(250);
                            if(TyReadTypeDef.NewDetectorNumber!=0)  //report specific detector?
                            {
                                k = get_zone_address_from_zoneNo(TyReadTypeDef.NewDetectorNumber,0);
                                if(k==0)        //the detector no exist
                                {
                                    p[0] = 0;
                                    p[1] = 0;
                                    g16_package_length = 2;
                                }
                                else
                                {
                                    i=0;
                                    //No.
                                    p[i++]=(u8)TyReadTypeDef.NewDetectorNumber>>8;
                                    p[i++]=(u8)TyReadTypeDef.NewDetectorNumber;
                                    //ID
                                    p[i++]=0;
                                    p[i++]=my_detector.dat.detector[k-1].addr[2];
                                    p[i++]=my_detector.dat.detector[k-1].addr[1];
                                    p[i++]=my_detector.dat.detector[k-1].addr[0];
                                    //TRIGGER
                                    printf("mode=%d,",my_detector.dat.detector[k-1].setting.mode);
                                    p[i++]=my_detector.dat.detector[k-1].setting.mode;
                                    //TYPE
                                    printf("type=%d\n",my_detector.dat.detector[k-1].setting.classification);
                                    p[i++]=my_detector.dat.detector[k-1].setting.classification;
                                    g16_package_length = i;
                                }
                                Read_StatusCharArrayValue_Responses(NewDetectorAddedArrayStatusID,(u8*)p);
                                g_CurrentTransmit_buf[RESPONSE_STATUS] |= fNewDetectorAddedArrayStatus;
                            }
                            else                                    //report all detectors
                            {
                                if(Detector_index==0)   //start with no device
                                {
                                    gflag.flag1&=~f1DetectorExist;
                                }
                                i=0;    //number of bytes
                                for(;Detector_index<(DETECTOR_MAX+EOL_ZONE_NUM);Detector_index++)
                                {
                                    if(my_detector.dat.detector[Detector_index].null==0xaa)
                                    {
                                        if(my_detector.dat.detector[Detector_index].setting.classification!=EVENT_RMT && my_detector.dat.detector[Detector_index].setting.number<(DETECTOR_MAX+EOL_ZONE_NUM+1))
                                        {
                                            if(i >= 200)        //each time should be less than 200 bytes.
                                            {
                                                Detector_index--; //byters overflow, report it next time.
                                                break;
                                            }
                                            //No.
                                            printf("number=%d,",my_detector.dat.detector[Detector_index].setting.number);
                                            p[i++]=(u8)(my_detector.dat.detector[Detector_index].setting.number>>8);
                                            p[i++]=(u8)my_detector.dat.detector[Detector_index].setting.number;
                                            //ID
                                            printf("ID=00%02x%02x%02x,",my_detector.dat.detector[Detector_index].addr[2],my_detector.dat.detector[Detector_index].addr[1],my_detector.dat.detector[Detector_index].addr[0]);
                                            p[i++]=0;
                                            p[i++]=my_detector.dat.detector[Detector_index].addr[2];
                                            p[i++]=my_detector.dat.detector[Detector_index].addr[1];
                                            p[i++]=my_detector.dat.detector[Detector_index].addr[0];
                                            //TRIGGER
                                            printf("mode=%d,",my_detector.dat.detector[Detector_index].setting.mode);
                                            p[i++]=my_detector.dat.detector[Detector_index].setting.mode;
                                            //TYPE
                                            printf("type=%d\n",my_detector.dat.detector[Detector_index].setting.classification);
                                            p[i++]=my_detector.dat.detector[Detector_index].setting.classification;
                                        }
                                    }
                                }
                                if(i!=0)
                                {
                                    g16_package_length = i;
                                    Read_StatusCharArrayValue_Responses(NewDetectorAddedArrayStatusID,(u8*)p);
                                }
                                else if(!(gflag.flag1&f1DetectorExist))
                                {
                                    p[0] = 0;
                                    p[1] = 0;
                                    g16_package_length = 2;
                                    Read_StatusCharArrayValue_Responses(NewDetectorAddedArrayStatusID,(u8*)p);
                                }
                                if(Detector_index >= (DETECTOR_MAX+EOL_ZONE_NUM))
                                {
                                    g_CurrentTransmit_buf[RESPONSE_STATUS] |= fNewDetectorAddedArrayStatus;
                                    Detector_index = 0;
                                }
                            }
                            myfree(p);
                        }
#endif
                        My_TcpTx = TCP_UPLINK_PACKAGE;
                    break;
                }
                case TCP_UPLINK_PACKAGE:
                {
                    if(EnLength != 0)   // any data to send? yes, send topic first
                    {
                        show_uplink_downlink_icon|=0xf0;
                        result = gsm_enet_tcp_send((u8*)encodingString,EnLength,RET_SEND_OK,gsm->module,m_b_variable);
                        m_b_variable = false;
                        
                        if( result == SYS_ERR_OK )
                        {
                            ctr_tcp_connect = 0;
                            if(Registered_On_Network == LOGIN_OK){
                                OSTimeDly( 100);
                                My_TcpTx = TCP_IDLE;
                            }
                            else{
                                k = 0;
                                do
                                {
                                    OSTimeDly( 100);
                                    
                                    if(Registered_On_Network == LOGIN_OK) 
                                    {
                                        break;
                                    }
                                    else if(k++>=90){   //timeout
                                        My_TcpTx = TCP_ERROR;
                                        break;
                                    }
                                }while(1);
                            }
                        }
                        else
                        {
                            My_TcpTx = TCP_ERROR;
                        }
                    }
                    else
                    {
                        g_CurrentTransmit_buf[0]=0;
                        g_CurrentTransmit_buf[1]=0;
                        g_CurrentTransmit_buf[2]=0;
                        g_CurrentTransmit_buf[3]=0;
                        My_TcpTx = TCP_IDLE;
                    }
                    break;
                }
                case TCP_ERROR:
                {
                    if(ctr_tcp_connect++ >= 5)
                    {
                        gsm->reset = 1;
                    }
                    else
                    {
                        My_TcpTx = TCP_IDLE;
                    }
                    break;
                }
            }
        }
        #if 0
        else if( ( gsm->task&(GSM_TASK_ENET_PULSE|GSM_TASK_ENET_ALARM) ) != 0 )
        {
            p = mymalloc( 64 );
            if( ( gsm->task&GSM_TASK_ENET_ALARM ) != 0 )
            {
                pgsGsm = PGS_GSM_TCP_ALARM;
                temp = enet_d2s_alarm_cmd( (u8*)p,gsm );    /* data encoding */
            }
            else
            {
                /* ENET heart beat */
                pgsGsm = PGS_GSM_TCP_PULSE;
                temp = enet_d2s_pulse_cmd( (u8*)p );        /* heart beat encoding */
                
            }
            result = gsm_enet_tcp_send( (u8*)p,temp,RET_S2D_ACK,gsm->module );    /* send data */
            if( result == SYS_ERR_OK )
            {
                ctr_tcp_send = 0;
                if( pgsGsm == PGS_GSM_TCP_ALARM )
                {
                    gsm->gsm_enet_executed = 1;        
                    gsm->task &= ~GSM_TASK_ENET_ALARM;
                }
                else gsm->task &= ~GSM_TASK_ENET_PULSE;
            }
            else
            {
                if( ++ctr_tcp_send >= 20 ) gsm->reset = 1;
                else
                {
                    gsm_close_connect( TCP_INDEX_ENET,gsm->module );
                    gsm->status &= ~GSM_STAT_TCP_CONNECT;
                }
            }
            myfree( p );
            pgsGsm = PGS_GSM_FREE;
        }
        #endif
    }
}
/*********************************************************************************************************
    gsm timer callback 1 second
*********************************************************************************************************/
void gsm_task_time_callback(void)
{
    STRU_GSM *gsm = &struGsm;
    static u32 tmrCreg = 0;
    
    tmrCreg++;
    if( tmrCreg%35 == 0 ) {
        gsm->task |= GSM_TASK_CREG;
        
        #if AEP_F_
        if(!(f1HeartBeatSend & gflag.flag1)){
            gflag.flag1 |= f1HeartBeatSend;
        }
        #endif
        
    }
    #if AEP_F_
    if(struParaSet.dat.KeepaliveIntervalTimeU16)
    {
        if((fAckRequestCmdStatus & gflag.fReport1Status)==0)
        {
            if(keepalive_ticks < struParaSet.dat.KeepaliveIntervalTimeU16)
            {
                keepalive_ticks++;
            }
            else
            {
                keepalive_ticks = 0;
                gflag.fReport1Status |= (fAckRequestCmdStatus|fNetworkRssiU8StatusRes);
            }
        }
    }
    #endif
    if( tmrCreg >= 24*60*60 )
    {
        tmrCreg = 0;
        gsm->status &= ~GSM_STAT_INIT;
    }
    
}
/*********************************************************************************************************
   END FILE
*********************************************************************************************************/

https://www.ctwing.cn/sbjr/70
l  消息格式
应用层数据报文以1个字节的类型字段作为分割，平台支持登录、心跳、上下行业务数据等消息类型。消息携带的参数必须包含两个字节的参数长度。

透传设备:

消息类型    类型描述            消息格式                                    备注
---------------------------------------------------------------------------------------------------------------------------------------
0x01        登录请求        0x01 +deviceId_length(2字节)              deviceId是由产品ID和设备编号拼接而成的字符串
                            +deviceId   +password_length              password由平台生成，在设备管理业务可以查看; ** version固定1.0**
                            (2字节) +password +version_length
                            (2字节) +version                       
---------------------------------------------------------------------------------------------------------------------------------------
0x02        上行数据报文    0x02 +数据长度(2字节)+业务数据
---------------------------------------------------------------------------------------------------------------------------------------
0x03       下行数据报文     0x03 +数据长度(2字节)+业务数据
---------------------------------------------------------------------------------------------------------------------------------------
0x04        心跳            0x04                                      平台心跳周期为5分钟，设备需在5分钟内发送心跳报文
---------------------------------------------------------------------------------------------------------------------------------------
0x05        登录响应        0x05+结果码(2字节)                       登录结果： 0 成功 1 未知错误 2 设备未注册 
                                                                      3 设备认证失败 4 设备已登录
---------------------------------------------------------------------------------------------------------------------------------------
0x06        心跳响应        0x06                                      平台回复终端心跳的响应