/*******************************************************************************
 * File Name         : EG800Driver.c
 * Description       :
 * Created on        : 2018Äê5ÔÂ22ÈÕ
 * Author            : ¶Å¼ü
 *******************************************************************************/

/*******************************************************************************
 *                              Include Files                                  *
 *******************************************************************************/
#include "EG800Driver.h"

#include "EG800FSM.h"
#include "string.h"
#include "GPIO.h"
#include "UART.h"
#include "HIDO_Timer.h"
#include "HIDO_Util.h"
#include "HIDO_Debug.h"
#include "HIDO_Log.h"
#include "stdio.h"

/*******************************************************************************
 *                                  Macro                                      *
 *******************************************************************************/
/* ´®¿ÚÏà¹Ø */
#define EG800_UART_TX_BUF_SIZE (2048) /* ´®¿ÚδʹÓÃDMAģʽ£¬²»ÐèÒªbuff */
#define EG800_UART_RX_BUF_SIZE (1024 * 2 + 512)
#define EG800_UART_TX_QUEUE_MEMBER_CNT 16 /* ´®¿ÚδʹÓÃDMAģʽ£¬²»ÐèÒª */

/* ATÏà¹Ø */
#define EG800_AT_SEND_BUF_SIZE (1024 + 512) /* ·¢Ë͵ĵ¥ÌõATÖ¸ÁîµÄ×î´ó³¤¶È */
#define EG800_AT_RECV_BUF_SIZE (1024 + 512) /* µ¥ÌôATÖ¸Áî */

/*******************************************************************************
 *                             Type Definition                                 *
 *******************************************************************************/

/*******************************************************************************
 *                             Local Variable                                  *
 *******************************************************************************/
static HIDO_UINT8 l_au8EG800UartRxBuf[EG800_UART_RX_BUF_SIZE];
static HIDO_UINT8 l_au8EG800UartTxBuf[EG800_UART_TX_BUF_SIZE];

static HIDO_UINT8 l_au8ATSendBuf[EG800_AT_SEND_BUF_SIZE];
static HIDO_UINT8 l_au8ATRecvBuf[EG800_AT_RECV_BUF_SIZE];

static ST_EG800DriverData l_stDriverData;
static HIDO_ATLiteDeviceStruct l_stEG800Device;
static HIDO_UINT32 l_u32ConnectLen = 0;

static const HIDO_ATLiteCmdSetStruct l_astATCmdSetList[] =
    {
        {"OK", HIDO_AT_EVENT_OK},
        {"SHUT OK", HIDO_AT_EVENT_OK},
        {"+CME ERROR:", HIDO_AT_EVENT_ERROR},
        {"ERROR", HIDO_AT_EVENT_ERROR},
        {"+CREG:", EG800_EVENT_CREG},
        {"+CGREG:", EG800_EVENT_CGREG},
        {"+CGATT:", EG800_EVENT_CGATT},
        {"+CSQ:", EG800_EVENT_CSQ},
        {"+QLBS:", EG800_EVENT_LBS_LOCATION},
        {"+CPIN:", EG800_EVENT_CPIN},
        {">", EG800_EVENT_ACK},
        {"+CMTI:", EG800_EVENT_NEW_SMS},
        {"+CMGR:", EG800_EVENT_READ_SMS},
        {"SEND OK", EG800_EVENT_SEND_OK},
        {"SEND FAIL", EG800_EVENT_SEND_FAIL},

        {"+QIOPEN:", EG800_EVENT_OPEN},
        {"+QIURC: \"recv\",", EG800_EVENT_NEW_IP_DATA},
        {"+QIURC: \"closed\",", EG800_EVENT_CLOSE},
        {"+QISEND:", EG800_EVENT_SEND},
        {"+QIRD:", EG800_EVENT_READ},
        {"CONNECT", EG800_EVENT_CONNECT},
        {"+QFLST:", EG800_EVENT_QFLST},
        {"+QFOPEN:", EG800_EVENT_QFOPEN},
        {"+QHTTPGET:", EG800_EVENT_QHTTPGET},
        {"+QHTTPPOST:", EG800_EVENT_QHTTPPOST},
        {"+QHTTPREAD:", EG800_EVENT_QHTTPREAD},
        {"+QHTTPREADFILE:", EG800_EVENT_QHTTPREADFILE},
        {"+QHTTPPOSTFILE:", EG800_EVENT_QHTTPPOSTFILE},
        {"+QGPSLOC:", EG800_EVENT_QGPSLOC},
        {"+CCLK:", EG800_EVENT_CCLK},
        {"+QGPSXTRADATA:", EG800_EVENT_QGPSXTRADATA},
        {"+QIURC: \"pdpdeact\"", EG800_EVENT_PDPDEACT},
        {"+QMTOPEN:", EG800_EVENT_QMTOPEN},
        {"+QMTCLOSE:", EG800_EVENT_QMTCLOSE},
        {"+QMTCONN:", EG800_EVENT_QMTCONN},
        {"+QMTDISC:", EG800_EVENT_QMTDISC},
        {"+QMTSUB:", EG800_EVENT_QMTSUB},
        {"+QMTUNS:", EG800_EVENT_QMTUNS},
        {"+QMTPUBEX:", EG800_EVENT_QMTPUBEX},
        {"+QMTRECV:", EG800_EVENT_QMTRECV},
        {"+QMTPING:", EG800_EVENT_QMTPING},
        {"+QMTSTAT:", EG800_EVENT_QMTSTAT},
        {"+CCID:", EG800_EVENT_CCID},
        {"RDY", EG800_EVENT_RDY},
        {"+QTTS:", EG800_EVENT_QTTS},
        {"+QLTONE:", EG800_EVENT_QLTONE},

        {"0\r", EG800_EVENT_NUM_0},
        {"1\r", EG800_EVENT_NUM_1},
        {"2\r", EG800_EVENT_NUM_2},
        {"3\r", EG800_EVENT_NUM_3},
        {"4\r", EG800_EVENT_NUM_4},
        {"5\r", EG800_EVENT_NUM_5},
        {"6\r", EG800_EVENT_NUM_6},
        {"7\r", EG800_EVENT_NUM_7},
        {"8\r", EG800_EVENT_NUM_8},
        {"9\r", EG800_EVENT_NUM_9},
};

static const HIDO_CHAR *const l_apcEventName[EG800_EVENT_LAST] = {
    HIDO_EVENT_ENTRY_NAME,
    HIDO_EVENT_EXIT_NAME,
    "HIDO_AT_EVENT_OK",
    "HIDO_AT_EVENT_ERROR",
    "HIDO_AT_EVENT_TIMEOUT",
    "HIDO_AT_EVENT_SEND_ERROR",
    "EG800_EVENT_OK",
    "EG800_EVENT_CREG",
    "EG800_EVENT_CGREG",
    "EG800_EVENT_CGATT",
    "EG800_EVENT_CSQ",
    "EG800_EVENT_LBS_LOCATION",
    "EG800_EVENT_CPIN",
    "EG800_EVENT_INIT_TIMEOUT",

    "EG800_EVENT_DELAY",
    "-EG800_EVENT_POLL",
    "EG800_EVENT_ACK",
    "EG800_EVENT_NEW_SMS",
    "EG800_EVENT_READ_SMS",
    "EG800_EVENT_SMS_DATA",
    "EG800_EVENT_NEW_IP_DATA",

    "EG800_EVENT_CCID",
    "EG800_EVENT_OPEN",
    "EG800_EVENT_SEND",
    "EG800_EVENT_SEND_OK",
    "EG800_EVENT_SEND_FAIL",
    "EG800_EVENT_CLOSE",
    "EG800_EVENT_READ",
    "EG800_EVENT_CONNECT",
    "EG800_EVENT_QFLST",
    "EG800_EVENT_QFOPEN",
    "EG800_EVENT_QHTTPGET",
    "EG800_EVENT_QHTTPPOST",
    "EG800_EVENT_QHTTPREAD",
    "EG800_EVENT_QHTTPREADFILE",
    "EG800_EVENT_QHTTPPOSTFILE",
    "EG800_EVENT_QGPSLOC",
    "EG800_EVENT_CCLK",
    "EG800_EVENT_QGPSXTRADATA",
    "EG800_EVENT_PDPDEACT",
    "EG800_EVENT_QMTOPEN",
    "EG800_EVENT_QMTCLOSE",
    "EG800_EVENT_QMTCONN",
    "EG800_EVENT_QMTDISC",
    "EG800_EVENT_QMTSUB",
    "EG800_EVENT_QMTUNS",
    "EG800_EVENT_QMTPUBEX",
    "EG800_EVENT_QMTRECV",
    "EG800_EVENT_QMTPING",
    "EG800_EVENT_QMTSTAT",

    "EG800_EVENT_RDY",
    "EG800_EVENT_QTTS",
    "EG800_EVENT_QLTONE",

    "EG800_EVENT_NUM_0",
    "EG800_EVENT_NUM_1",
    "EG800_EVENT_NUM_2",
    "EG800_EVENT_NUM_3",
    "EG800_EVENT_NUM_4",
    "EG800_EVENT_NUM_5",
    "EG800_EVENT_NUM_6",
    "EG800_EVENT_NUM_7",
    "EG800_EVENT_NUM_8",
    "EG800_EVENT_NUM_9",
};

static ST_GPIO l_stEG800Pin[EG800_PIN_LAST];

/*******************************************************************************
 *                        Local Function Declaration                           *
 *******************************************************************************/

/*******************************************************************************
 *                             Local Function                                  *
 *******************************************************************************/
/*******************************************************************************
 * Function Name     : EG800_GetChar
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
static HIDO_INT32 EG800_GetChar(HIDO_ATLiteDeviceStruct *_pstATDevice, HIDO_CHAR *_pcRecvChar)
{
    return Uart_GetChar(UART_ID_4G, (HIDO_UINT8 *)_pcRecvChar);
}

/*******************************************************************************
 * Function Name     : EG800_ReadLine
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
static HIDO_INT32 EG800_ReadLine(HIDO_ATLiteDeviceStruct *_pstATDevice)
{
    static HIDO_UINT8 l_u8Mode = 0;
    static HIDO_UINT32 l_u32ExpectedLen = 0;
    static HIDO_UINT32 l_u32LastTick = 0;
    HIDO_CHAR cCh = 0;

    if ((HIDO_NULL == _pstATDevice) || (HIDO_NULL == _pstATDevice->m_fnGetc) || (HIDO_NULL == _pstATDevice->m_pcLineBuf) || (0 == _pstATDevice->m_u32LineBufSize))
    {
        return HIDO_ERR;
    }

    while (_pstATDevice->m_u32LineLen < _pstATDevice->m_u32LineBufSize - 1)
    {
        if (_pstATDevice->m_fnGetc(_pstATDevice, &cCh) != HIDO_OK)
        {
            return HIDO_ERR;
        }

        _pstATDevice->m_pcLineBuf[_pstATDevice->m_u32LineLen++] = cCh;
        _pstATDevice->m_pcLineBuf[_pstATDevice->m_u32LineLen] = '\0';

        /* +QIRD: */
        if (7 == _pstATDevice->m_u32LineLen && memcmp("+QIRD: ", _pstATDevice->m_pcLineBuf, 7) == 0)
        {
            l_u8Mode = 1;
            l_u32LastTick = HAL_GetTick();
        }

        /* CONNECT */
        if (7 == _pstATDevice->m_u32LineLen && memcmp("CONNECT", _pstATDevice->m_pcLineBuf, 7) == 0)
        {
            l_u8Mode = 2;
            l_u32LastTick = HAL_GetTick();
        }

        /* +QMTRECV: */
        if (10 == _pstATDevice->m_u32LineLen && memcmp("+QMTRECV: ", _pstATDevice->m_pcLineBuf, 10) == 0)
        {
            l_u8Mode = 3;
            l_u32LastTick = HAL_GetTick();
        }

        /* ³¬Ê±¼ì²é£¬·ÀÖ¹³¤Ê±¼ä´¦ÓÚIPDATAµÄ״̬ */
        if (((l_u8Mode == 1) || (l_u8Mode == 2) || (l_u8Mode == 3)) && (HAL_GetTick() - l_u32LastTick) > 1500)
        {
            break;
        }

        if (1 == l_u8Mode)
        {
            HIDO_CHAR *pcTmp = strstr(_pstATDevice->m_pcLineBuf, "\r\n");

            if (pcTmp != HIDO_NULL)
            {
                HIDO_UINT32 u32ReqLen = 0;

                /* »ñÈ¡ÕæʵÐèÒª½ÓÊյij¤¶È */
                if (HIDO_UtilParseFormat((HIDO_UINT8 *)_pstATDevice->m_pcLineBuf, _pstATDevice->m_u32LineLen, "+QIRD: %d",
                                         &u32ReqLen) != 1)
                {
                    break;
                }

                if (0 == u32ReqLen)
                {
                    break;
                }

                l_u32ExpectedLen = pcTmp - _pstATDevice->m_pcLineBuf + 2 + u32ReqLen;
                l_u8Mode = 10;
            }
        }
        else if (2 == l_u8Mode)
        {
            HIDO_CHAR *pcTmp = strstr(_pstATDevice->m_pcLineBuf, "\r\n");

            if (pcTmp != HIDO_NULL)
            {
                if (CONNECT_LEN_UNKONW == l_u32ConnectLen)
                {
                    HIDO_UINT32 u32ConnectLen = 0;

                    if (HIDO_UtilParseFormat((HIDO_UINT8 *)_pstATDevice->m_pcLineBuf, _pstATDevice->m_u32LineLen, "CONNECT %d",
                                             &u32ConnectLen) != 1)
                    {
                        break;
                    }

                    l_u32ConnectLen = u32ConnectLen;
                }

                if (0 == l_u32ConnectLen)
                {
                    break;
                }

                l_u32ExpectedLen = pcTmp - _pstATDevice->m_pcLineBuf + 2 + l_u32ConnectLen;
                l_u8Mode = 10;
            }
        }
        else if (3 == l_u8Mode)
        {
            HIDO_UINT32 u32ReqLen = 0;
            HIDO_CHAR *pcTmp = strstr(_pstATDevice->m_pcLineBuf, "\r\n");

            if (pcTmp != HIDO_NULL)
            {
                /* »ñÈ¡ÕæʵÐèÒª½ÓÊյij¤¶È */
                if (HIDO_UtilParseFormat((HIDO_UINT8 *)_pstATDevice->m_pcLineBuf, _pstATDevice->m_u32LineLen, "+QMTRECV: %*,%*,%*,%u,%e",
                                         &u32ReqLen, &pcTmp) != 5)
                {
                    break;
                }

                l_u32ExpectedLen = pcTmp - _pstATDevice->m_pcLineBuf + 4 + u32ReqLen;
                l_u8Mode = 10;

                if (_pstATDevice->m_u32LineLen == l_u32ExpectedLen)
                {
                    break;
                }
            }
        }
        else if (10 == l_u8Mode)
        {
            if (_pstATDevice->m_u32LineLen == l_u32ExpectedLen)
            {
                break;
            }
        }
        else
        {
            /* ¼ì²éCR */
            if (AT_READ_CHAR_CR == cCh)
            {
                _pstATDevice->m_eLineReadFlag = AT_RAED_FLAG_GET_CR;
            }
            /* ¼ì²éLF */
            else if (AT_READ_CHAR_LF == cCh)
            {
                if (AT_RAED_FLAG_GET_CR == _pstATDevice->m_eLineReadFlag)
                {
                    _pstATDevice->m_eLineReadFlag = AT_RAED_FLAG_GET_LF;
                }
            }

            if (AT_RAED_FLAG_GET_LF == _pstATDevice->m_eLineReadFlag)
            {
                if (2 == _pstATDevice->m_u32LineLen)
                {
                    _pstATDevice->m_u32LineLen = 0;
                    _pstATDevice->m_eLineReadFlag = AT_RAED_FLAG_NONE;
                }
                else
                {
                    _pstATDevice->m_eLineReadFlag = AT_RAED_FLAG_NONE;

                    if (l_u8Mode == 10)
                    {
                        l_u8Mode = 0;
                        _pstATDevice->m_u32LineLen = 0;
                        _pstATDevice->m_eLineReadFlag = AT_RAED_FLAG_NONE;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            if (1 == _pstATDevice->m_u32LineLen && '>' == _pstATDevice->m_pcLineBuf[0])
            {
                break;
            }
        }
    }

    if (HIDO_UtilIsAsciiString((HIDO_UINT8 *)_pstATDevice->m_pcLineBuf, _pstATDevice->m_u32LineLen) == HIDO_TRUE)
    {
        if ((_pstATDevice->m_u32LineLen > 0) && (_pstATDevice->m_pcLineBuf[_pstATDevice->m_u32LineLen - 1] == '\n'))
        {
            HIDO_DebugEx("[AT Recv] %s", _pstATDevice->m_pcLineBuf);
        }
        else
        {
            HIDO_DebugEx("[AT Recv] %s\r\n", _pstATDevice->m_pcLineBuf);
        }
    }

    l_u8Mode = 0;

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800_Output
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
static HIDO_INT32 EG800_Output(HIDO_ATLiteDeviceStruct *_pstATDevice, HIDO_UINT8 *_pu8Data,
                               HIDO_UINT32 _u32Len)
{
    // if(HIDO_UtilIsAsciiString(_pu8Data, _u32Len) == HIDO_TRUE)
    {
        if (_pu8Data[_u32Len] == '\0')
        {
            if ((_u32Len > 0) && (_pu8Data[_u32Len - 1] == '\n'))
            {
                HIDO_DebugEx("[AT Send] %s", _pu8Data);
            }
            else
            {
                HIDO_DebugEx("[AT Send] %s\r\n", _pu8Data);
            }
        }
    }

    return Uart_Send(UART_ID_4G, _pu8Data, _u32Len);
}

/*******************************************************************************
 *                             Global Function                                 *
 *******************************************************************************/

/*******************************************************************************
 * Function Name     : EG800_PinRegister
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_INT32 EG800Driver_PinRegister(E_EG800Pin _ePin, HIDO_VOID *_pGroup, HIDO_UINT16 _u16Pin)
{
    l_stEG800Pin[_ePin].m_pstGPIOx = (GPIO_TypeDef *)_pGroup;
    l_stEG800Pin[_ePin].m_u16GPIOPin = _u16Pin;

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800_PowerOn
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
extern u8 bat_percent2;
HIDO_INT32 EG800Driver_PowerOn(void)
{
    if (l_stEG800Pin[EG800_PIN_3V8_EN].m_pstGPIOx != HIDO_NULL)
    {
        GPIO_SET(&l_stEG800Pin[EG800_PIN_3V8_EN]);
        // TODO bat_percent2=Get_Battary();
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800_PowerOff
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_INT32 EG800Driver_PowerOff(void)
{
    if (l_stEG800Pin[EG800_PIN_3V8_EN].m_pstGPIOx != HIDO_NULL)
    {
        GPIO_RESET(&l_stEG800Pin[EG800_PIN_3V8_EN]);
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800Driver_PowerEnable
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_INT32 EG800Driver_PWRKEYSet(void)
{
    if (l_stEG800Pin[EG800_PIN_PWRKEY].m_pstGPIOx != HIDO_NULL)
    {
        GPIO_RESET(&l_stEG800Pin[EG800_PIN_PWRKEY]);
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800Driver_PowerEnable
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_INT32 EG800Driver_PWRKEYReset(void)
{
    if (l_stEG800Pin[EG800_PIN_PWRKEY].m_pstGPIOx != HIDO_NULL)
    {
        GPIO_SET(&l_stEG800Pin[EG800_PIN_PWRKEY]);
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800Driver_DebugOn
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_INT32 EG800Driver_DebugOn(void)
{
    HIDO_FSM(EG800)->m_u16DbgFlag = HIDO_FSM_DBG_FLAG_ON;

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800Driver_DebugOff
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_INT32 EG800Driver_DebugOff(void)
{
    HIDO_FSM(EG800)->m_u16DbgFlag = HIDO_FSM_DBG_FLAG_OFF;

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800Driver_SetConnectLen
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_INT32 EG800Driver_SetConnectLen(HIDO_UINT32 _u32ConnectLen)
{
    l_u32ConnectLen = _u32ConnectLen;

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800Driver_FSMDebug
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_INT32 EG800Driver_FSMDebug(HIDO_FSMStruct *_pstStateMachine, HIDO_INT32 _i32Level, HIDO_CHAR *_pcFmt, va_list _ap)
{
    HIDO_CHAR acBuff[384];

    vsnprintf(acBuff, sizeof(acBuff), _pcFmt, _ap);

    //  HIDO_Log(HIDO_LOG_LEVEL_DEBUG, "%s", acBuff);
    HIDO_Debug(acBuff);

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800Driver_Reset
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_INT32 EG800Driver_Reset(void)
{
    HIDO_FSMEventExecute(HIDO_FSM(EG800), HIDO_AT_EVENT_TIMEOUT, HIDO_NULL);

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : EG800Driver_TimerPoll
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
void EG800Driver_TimerPoll(void)
{
    HIDO_TimerPollByID(l_stDriverData.m_u32FSMTimerID);
    HIDO_TimerPollByID(l_stEG800Device.m_u32TimerID);
}

/*******************************************************************************
 * Function Name     : EG800Driver_Init
 * Description       :
 * Input             :
 * Output            :
 * Return            :
 * Author            : ¶Å¼ü
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_INT32 EG800Driver_Init(void)
{
    ST_UartInit stUartInit;

    /* ´®¿Ú³õʼ»¯ */
    stUartInit.m_eRxMode = UART_RX_MODE_DMA;
    stUartInit.m_eTxMode = UART_TX_MODE_DMA;
    stUartInit.m_pu8RxBuf = l_au8EG800UartRxBuf;
    stUartInit.m_u32RxBufSize = EG800_UART_RX_BUF_SIZE;
    stUartInit.m_pu8TxBuf = l_au8EG800UartTxBuf;
    stUartInit.m_u32TxBufSize = EG800_UART_TX_BUF_SIZE;
    stUartInit.m_u32TxQueueMemberCnt = EG800_UART_TX_QUEUE_MEMBER_CNT;
    if (Uart_Init(UART_ID_4G, &stUartInit) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    /* ¶¨Ê±Æ÷³õʼ»¯ */
    if (HIDO_TimerCreate(&l_stDriverData.m_u32FSMTimerID) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    /* ATÇý¶¯³õʼ»¯ */
    HIDO_ATLiteDeviceInitStruct stATInit;

    stATInit.m_pstFSM = HIDO_FSM(EG800);
    stATInit.m_pstAtSets = l_astATCmdSetList;
    stATInit.m_u32AtSetsCount = HIDO_ARRARY_COUNT(l_astATCmdSetList);
    stATInit.m_fnGetc = EG800_GetChar;
    stATInit.m_fnReadLine = EG800_ReadLine;
    stATInit.m_fnOutput = EG800_Output;
    stATInit.m_pcSendBuf = (HIDO_CHAR *)l_au8ATSendBuf;
    stATInit.m_u32SendBufSize = HIDO_ARRARY_COUNT(l_au8ATSendBuf);
    stATInit.m_pcLineBuf = (HIDO_CHAR *)l_au8ATRecvBuf;
    stATInit.m_u32LineBufSize = HIDO_ARRARY_COUNT(l_au8ATRecvBuf);
    stATInit.m_pUserData = &l_stDriverData;

    /* ATÉ豸³õʼ»¯ */
    if (HIDO_ATLiteDeviceInit(&l_stEG800Device, &stATInit) != HIDO_OK)
    {
        return HIDO_ERR;
    }

    /* ״̬»ú³õʼ»¯ */
    HIDO_FSMRegisterDebugFunc(HIDO_FSM(EG800), EG800Driver_FSMDebug);
    HIDO_FSMRegister(HIDO_FSM(EG800), HIDO_FSM_STATE(EG800), "EG800", l_apcEventName, &l_stEG800Device,
                     HIDO_FSM_DBG_FLAG_ON);
    
    return HIDO_OK;
}