/*******************************************************************************
 * File Name         : EG800FSM.c
 * Description       :
 * Created on        : 2018Äê5ÔÂ22ÈÕ
 * Author            : www.hido-studio.com
 *******************************************************************************/

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

#include "string.h"
#include "Module.h"
#include "Socket.h"
#include "Module.h"
#include "EG800CSQ.h"
#include "EG800Driver.h"
#include "EG800Socket.h"
#include "EG800Audio.h"
#include "HIDO_FSM.h"
#include "HIDO_Timer.h"
#include "HIDO_Util.h"
#include "HIDO_Debug.h"
#include "ATConfig.h"
#include "Uart.h"
#include "Module.h"

/*******************************************************************************
 *                                  Macro                                      *
 *******************************************************************************/
#define TTS_SPEED "-10000"
#define TTS_VOLUME "-20000"

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

/*******************************************************************************
 *                            Global Variable                                  *
 *******************************************************************************/
HIDO_FSM_DECLARE_IMPLEMENT(EG800);
HIDO_FSM_DETACHED_STATE(EG800RunATCmd)
HIDO_FSM_DETACHED_STATE(EG800CloseWireless)
HIDO_FSM_DETACHED_STATE(EG800OpenWireless)

/*******************************************************************************
 *                             Local Variable                                  *
 *******************************************************************************/
static HIDO_BOOL l_bDeact = HIDO_FALSE;
static HIDO_UINT32 l_u32IPCheckTick = 0;
// static HIDO_UINT32 l_u32CSQGetTick = 0;
static HIDO_StateArgStruct l_stStateArg;

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

/*******************************************************************************
 *                             Local Function                                  *
 *******************************************************************************/
static HIDO_INT32 EG800_Poll(HIDO_ATLiteDeviceStruct *_pstATDevice);
static HIDO_INT32 EG800_PollOnIPReady(HIDO_ATLiteDeviceStruct *_pstATDevice);

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

/*******************************************************************************
 * State Name        : EG800
 * Parent State      : None
 * Description       : EG800Ö÷״̬
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800, HIDO_NULL, HIDO_FSM_STATE(EG800PowerOn))
{
    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        break;
    }
    case HIDO_AT_EVENT_TIMEOUT:
    {
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Init), HIDO_NULL);
        break;
    }
    case EG800_EVENT_NEW_IP_DATA:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;
        HIDO_UINT32 u32ID = 0;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+QIURC: \"recv\",%d", &u32ID) != 1)
        {
            break;
        }

        Socket_HaveRecvData(u32ID);
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800Init
 * Parent State      : EG800
 * Description       : ³õʼ»¯Ö÷״̬
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800Init, HIDO_FSM_STATE(EG800), HIDO_FSM_STATE(EG800PowerOn))
{
    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        break;
    }
    case HIDO_AT_EVENT_TIMEOUT:
    {
        /* ATÃüÁîÏàÓ¦³¬Ê±,ÖØгõʼ»¯ */
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Init), HIDO_NULL);

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800PowerOff
 * Parent State      : EG800Init
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800PowerOff, HIDO_FSM_STATE(EG800), HIDO_NULL)
{
    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        EG800Driver_PowerOff();
        Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_OFF);
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        break;
    }
    case EG800_EVENT_POLL:
    {
        if (Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
        {
            Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_OFF);
        }

        if (Module_NeedPowerOn(MODULE_MAIN) == HIDO_TRUE)
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800PowerOn), HIDO_NULL);
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800PowerOn
 * Parent State      : EG800Init
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800PowerOn, HIDO_FSM_STATE(EG800Init), HIDO_NULL)
{
    static enum {
        EG800_SUB_STATE_POWER_OFF,
        EG800_SUB_STATE_POWER_ON,
        EG800_SUB_STATE_PWRKEY_RESET,
        EG800_SUB_STATE_PWRKEY_SET,
    } l_eEG800SubState;

    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        pstATDevice->m_u32LineLen = 0;
        while (pstATDevice->m_fnReadLine(pstATDevice) == HIDO_OK)
        {
            ;
        }
        pstATDevice->m_u32LineLen = 0;

        l_eEG800SubState = EG800_SUB_STATE_POWER_OFF;
        EG800Driver_PowerOff();
        HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(3), _pstFSM, EG800_EVENT_DELAY);
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        /* Í˳ö³õʼ»¯ */
        HIDO_TimerCancel(u32FSMTimerID);

        break;
    }
    case EG800_EVENT_DELAY:
    {
        switch (l_eEG800SubState)
        {
        case EG800_SUB_STATE_POWER_OFF:
        {
            l_eEG800SubState = EG800_SUB_STATE_POWER_ON;
            EG800Driver_PowerOn();
            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM, EG800_EVENT_DELAY);
            break;
        }
        case EG800_SUB_STATE_POWER_ON:
        {
            l_eEG800SubState = EG800_SUB_STATE_PWRKEY_RESET;
            EG800Driver_PWRKEYReset();
            Uart_ReConfigBaudRate(UART_ID_4G, 921600);
            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM, EG800_EVENT_DELAY);
            break;
        }
        case EG800_SUB_STATE_PWRKEY_RESET:
        {
            l_eEG800SubState = EG800_SUB_STATE_PWRKEY_SET;
            EG800Driver_PWRKEYSet();
            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_MS(800), _pstFSM, EG800_EVENT_DELAY);
            break;
        }
        case EG800_SUB_STATE_PWRKEY_SET:
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800WaitReady), HIDO_NULL);
            break;
        }
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800WaitReady
 * Parent State      : EG800Init
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
extern int Last4G;

HIDO_FSM_STATE_IMPLEMENT(EG800WaitReady, HIDO_FSM_STATE(EG800Init), HIDO_NULL)
{
    static HIDO_BOOL bReady = HIDO_FALSE;
    static HIDO_UINT32 u32RetryCnt = 0, Power_r = 0, Open_PJ, dev_id;
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    HIDO_CHAR TTS_Open[60];

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10),
                           _pstFSM, EG800_EVENT_DELAY);
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        HIDO_TimerCancel(u32FSMTimerID);
        break;
    }
    case EG800_EVENT_RDY:
    {
        break;
    }
    case HIDO_AT_EVENT_OK:
    case EG800_EVENT_DELAY:
    case HIDO_AT_EVENT_TIMEOUT:
    {
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800ATCmdTest), HIDO_NULL);
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800ATCmdTest
 * Parent State      : EG800Init
 * Description       : ATÃüÁî²âÊÔ״̬
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800ATCmdTest, HIDO_FSM_STATE(EG800Init), HIDO_NULL)
{
// #define USE_115200
#define USE_921600
    static HIDO_UINT32 l_u32ReadyCnt = 0;
    static HIDO_UINT32 l_u32TimeoutCnt = 0;
    static HIDO_UINT32 l_u32BaudRate = 0;
    static HIDO_BOOL l_bConfigBaudRate = HIDO_FALSE;
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
#ifdef USE_115200
        l_u32BaudRate = 115200;
#else
        l_u32BaudRate = 921600;
#endif

        Uart_ReConfigBaudRate(UART_ID_4G, l_u32BaudRate);

        l_bConfigBaudRate = HIDO_FALSE;
        l_u32ReadyCnt = 0;
        l_u32TimeoutCnt = 0;
        HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM, EG800_EVENT_DELAY);
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        HIDO_TimerCancel(u32FSMTimerID);
        break;
    }
    case HIDO_AT_EVENT_OK:
    {
        if (HIDO_TRUE == l_bConfigBaudRate)
        {
#ifdef USE_115200
            l_u32BaudRate = 115200;
#else
            l_u32BaudRate = 921600;
#endif
            Uart_ReConfigBaudRate(UART_ID_4G, l_u32BaudRate);

            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM, EG800_EVENT_DELAY);
            break;
        }

        l_u32TimeoutCnt = 0;
        l_u32ReadyCnt++;
        if (l_u32ReadyCnt >= 3)
        {
#ifdef USE_115200
            if (921600 == l_u32BaudRate)
#else
            if (115200 == l_u32BaudRate)
#endif
            {
                l_bConfigBaudRate = HIDO_TRUE;
#ifdef USE_115200
                HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+IPR=115200;&W\r\n");
#else
                HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+IPR=921600;&W\r\n");
#endif
            }
            else
            {
                /* Éϵç³É¹¦ */
                Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_ON);
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800WaitSimCardReady), HIDO_NULL);
            }
        }
        else
        {
            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM,
                               EG800_EVENT_DELAY);
        }

        break;
    }
    case HIDO_AT_EVENT_ERROR:
    {
        break;
    }
    case HIDO_AT_EVENT_TIMEOUT:
    {
        l_u32TimeoutCnt++;
        l_u32ReadyCnt = 0;

        if (5 == l_u32TimeoutCnt)
        {
#ifdef USE_115200
            l_u32BaudRate = 921600;
#else
            l_u32BaudRate = 115200;
#endif
            Uart_ReConfigBaudRate(UART_ID_4G, l_u32BaudRate);

            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM,
                               EG800_EVENT_DELAY);
        }
        else if (l_u32TimeoutCnt > 10)
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800PowerOn), HIDO_NULL);
        }
        else
        {
            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM,
                               EG800_EVENT_DELAY);
        }

        break;
    }
    case EG800_EVENT_DELAY:
    {
        if (HIDO_TRUE == l_bConfigBaudRate)
        {
            /* Éϵç³É¹¦ */
            Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_ON);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800WaitSimCardReady), HIDO_NULL);
            break;
        }
        else
        {
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "ATE0\r\n");
        }
        break;
    }
    case EG800_EVENT_POLL:
    {
        if (Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
        {
            HIDO_FSMStateChange(HIDO_FSM(EG800), HIDO_FSM_STATE(EG800PowerOff), HIDO_NULL);

            break;
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800WaitSimCardReady
 * Parent State      : EG800Init
 * Description       : µÈ´ýSIM¿¨×¼±¸Íê³É
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800WaitSimCardReady, HIDO_FSM_STATE(EG800Init), HIDO_NULL)
{
    static HIDO_BOOL bReady = HIDO_FALSE;
    static HIDO_UINT32 u32RetryCnt = 0;
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        bReady = HIDO_FALSE;
        u32RetryCnt = 0;
        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CPIN?\r\n");
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        HIDO_TimerCancel(u32FSMTimerID);
        break;
    }
    case HIDO_AT_EVENT_OK:
    {
        HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(3),
                           _pstFSM, EG800_EVENT_DELAY);
        break;
    }
    case HIDO_AT_EVENT_ERROR:
    {
        HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1),
                           _pstFSM, EG800_EVENT_DELAY);
        break;
    }
    case HIDO_AT_EVENT_TIMEOUT:
    {
        if (HIDO_TRUE == bReady)
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800ATCmdInit), HIDO_NULL);
        }
        else
        {
            return HIDO_EVENT_NO_PROC;
        }

        break;
    }
    case EG800_EVENT_DELAY:
    {
        if (HIDO_TRUE == bReady)
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800ATCmdInit), HIDO_NULL);
        }
        else
        {
            //  HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Idle), HIDO_NULL);
            if (u32RetryCnt < 10)
            {
                u32RetryCnt++;
                HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CPIN?\r\n");
            }
            else
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Idle), HIDO_NULL);
            }
        }
        break;
    }
    case EG800_EVENT_CPIN:
    {
        bReady = HIDO_TRUE;
        break;
    }
    case EG800_EVENT_POLL:
    {
        if (Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
        {
            HIDO_FSMStateChange(HIDO_FSM(EG800), HIDO_FSM_STATE(EG800PowerOff), HIDO_NULL);

            break;
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800ATCmdInit
 * Parent State      : EG800Init
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800ATCmdInit, HIDO_FSM_STATE(EG800Init), HIDO_NULL)
{
    static HIDO_UINT32 l_u32CmdIndex = 0;
    static HIDO_UINT32 l_u32RetryCnt = 0;

    const ST_ATCmd astInitCmdList[] =
        {
            {"AT+GSN\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK},
            {"AT+CIMI\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK},
            {"AT+CCID\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK},
//            {"AT+QTTSETUP=1,1," TTS_SPEED "\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK},
//            {"AT+QTTSETUP=1,2," TTS_VOLUME "\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK},
        };

    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        l_u32CmdIndex = 0;
        l_u32RetryCnt = 0;
        HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
        l_u32RetryCnt++;

        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        HIDO_TimerCancel(u32FSMTimerID);
        break;
    }
    case HIDO_AT_EVENT_OK:
    case HIDO_AT_EVENT_ERROR:
    case HIDO_AT_EVENT_TIMEOUT:
    {
        if (HIDO_AT_EVENT_TIMEOUT == _u32Event)
        {
            if (astInitCmdList[l_u32CmdIndex].m_u32Result & AT_CMD_RESULT_TIMEOUT)
            {
                l_u32RetryCnt = 0;
                l_u32CmdIndex++;
                if (l_u32CmdIndex >= HIDO_ARRARY_COUNT(astInitCmdList))
                {
                    HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Ready), HIDO_NULL);
                }
                else
                {
                    HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
                }

                break;
            }
            else
            {
                return HIDO_EVENT_NO_PROC;
            }
        }

        if (astInitCmdList[l_u32CmdIndex].m_u32Result & (HIDO_AT_EVENT_OK == _u32Event ? AT_CMD_RESULT_OK : AT_CMD_RESULT_ERROR))
        {
            l_u32RetryCnt = 0;
            l_u32CmdIndex++;
            if (l_u32CmdIndex >= HIDO_ARRARY_COUNT(astInitCmdList))
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Ready), HIDO_NULL);
            }
            else
            {
                HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
            }
        }
        else
        {
            l_u32RetryCnt++;
            if (l_u32RetryCnt >= 3)
            {
                /* ÖØÊÔ³¬ÏÞ */
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800PowerOn), HIDO_NULL);
            }
            else
            {
                /* ²»ÊÇÆÚ´ýµÄ½á¹û£¬10ºóÔٴγ¢ÊÔ */
                HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10), _pstFSM,
                                   EG800_EVENT_DELAY);
            }
        }

        break;
    }
    case EG800_EVENT_DELAY:
    {
        HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
        break;
    }
    case EG800_EVENT_NUM_0:
    case EG800_EVENT_NUM_1:
    case EG800_EVENT_NUM_2:
    case EG800_EVENT_NUM_3:
    case EG800_EVENT_NUM_4:
    case EG800_EVENT_NUM_5:
    case EG800_EVENT_NUM_6:
    case EG800_EVENT_NUM_7:
    case EG800_EVENT_NUM_8:
    case EG800_EVENT_NUM_9:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;

        switch (l_u32CmdIndex)
        {
        case 0:
        {
            Module_SetIMEI((HIDO_CHAR *)pstData->m_pData, pstData->m_u32Len);
            break;
        }
        case 1:
        {
            Module_SetIMSI((HIDO_CHAR *)pstData->m_pData, pstData->m_u32Len);
            break;
        }
        default:
        {
            break;
        }
        }

        break;
    }
    case EG800_EVENT_CCID:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;
        HIDO_DataStruct stCCID;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+CCID: %p\r\n",
                                 &stCCID) != 1)
        {
            break;
        }

        Module_SetCCID((HIDO_CHAR *)stCCID.m_pData, stCCID.m_u32Len);
        break;
    }
    case EG800_EVENT_POLL:
    {
        if (Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
        {
            HIDO_FSMStateChange(HIDO_FSM(EG800), HIDO_FSM_STATE(EG800PowerOff), HIDO_NULL);

            break;
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800Idle
 * Parent State      : EG800
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800Idle, HIDO_FSM_STATE(EG800), HIDO_NULL)
{
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        break;
    }
    case EG800_EVENT_POLL:
    {
        EG800_Poll(pstATDevice);

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800Ready
 * Parent State      : EG800
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800Ready, HIDO_FSM_STATE(EG800), HIDO_FSM_STATE(EG800SearchingNetwork))
{
    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800SearchingNetwork
 * Parent State      : EG800
 * Description       : ²éÕÒÍøÂç
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800SearchingNetwork, HIDO_FSM_STATE(EG800Ready), HIDO_NULL)
{
    static enum {
        EG800_SUB_STATE_CREG,
        EG800_SUB_STATE_CGREG,
    } l_eEG800SubState;

    static HIDO_UINT32 l_u32RespCode = 0;
    static HIDO_UINT32 l_u32Cnt = 0;
    static HIDO_UINT32 l_u32ReadyCnt = 0;
    static HIDO_BOOL l_bATBusy = HIDO_FALSE;

    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        l_eEG800SubState = EG800_SUB_STATE_CREG;
        l_u32Cnt = 0;
        l_u32RespCode = 0;
        l_bATBusy = HIDO_TRUE;
        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CREG?\r\n");
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        HIDO_TimerCancel(u32FSMTimerID);
        break;
    }
    case HIDO_AT_EVENT_OK:
    {
        if (EG800_SUB_STATE_CREG == l_eEG800SubState)
        {
            l_bATBusy = HIDO_FALSE;

            if (1 == l_u32RespCode || 5 == l_u32RespCode)
            {
                l_eEG800SubState = EG800_SUB_STATE_CGREG;
                l_u32Cnt = 0;
                l_u32RespCode = 0;
                l_bATBusy = HIDO_TRUE;
                HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CGREG?\r\n");
            }
            else
            {
                l_u32Cnt++;

                if (l_u32Cnt > 100)
                {
                    HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Init), HIDO_NULL);
                    break;
                }
                else
                {
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(2), _pstFSM,
                                       EG800_EVENT_DELAY);
                }
            }
        }
        else if (EG800_SUB_STATE_CGREG == l_eEG800SubState)
        {
            l_bATBusy = HIDO_FALSE;

            if (1 == l_u32RespCode || 5 == l_u32RespCode)
            {
                l_u32ReadyCnt++;
            }
            else
            {
                l_u32ReadyCnt = 0;
                l_u32Cnt++;
            }

            if (l_u32ReadyCnt >= 3)
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPInit), HIDO_NULL);
            }
            else
            {
                HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(2), _pstFSM,
                                   EG800_EVENT_DELAY);
            }

            if (l_u32Cnt > 100)
            {
                /* TODOÍøÂç³ö´í */
            }
        }

        break;
    }
    case EG800_EVENT_CREG:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;

        if (EG800_SUB_STATE_CREG == l_eEG800SubState)
        {
            if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+CREG: %*,%d",
                                     &l_u32RespCode) != 2)
            {
                break;
            }
        }

        break;
    }
    case EG800_EVENT_CGREG:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;

        if (EG800_SUB_STATE_CGREG == l_eEG800SubState)
        {
            if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+CGREG: %*,%d",
                                     &l_u32RespCode) != 2)
            {
                break;
            }
        }
        break;
    }
    case EG800_EVENT_DELAY:
    {
        if (EG800_SUB_STATE_CREG == l_eEG800SubState)
        {
            l_u32RespCode = 0;
            l_bATBusy = HIDO_TRUE;
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CREG?\r\n");
        }
        else if (EG800_SUB_STATE_CGREG == l_eEG800SubState)
        {
            l_u32RespCode = 0;
            l_bATBusy = HIDO_TRUE;
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CGREG?\r\n");
        }

        break;
    }
    case EG800_EVENT_POLL:
    {
        if (HIDO_FALSE == l_bATBusy)
        {
            EG800_Poll(pstATDevice);
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800IPInit
 * Parent State      : EG800
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800IPInit, HIDO_FSM_STATE(EG800Ready), HIDO_NULL)
{
    static HIDO_UINT32 l_u32CmdIndex = 0;
    static HIDO_UINT32 l_u32RetryCnt = 0;

    HIDO_CHAR *pcIMSI = HIDO_NULL;
    HIDO_CHAR acAPN[32] = {0};
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    const ST_ATCmd astInitCmdList[] =
        {
            {"AT+QICSGP=1,1,\"%s\",\"\",\"\",1\r\n", 60000, AT_CMD_RESULT_OK | AT_CMD_RESULT_ERROR},
            {"AT+QIACT=1\r\n", 60000, AT_CMD_RESULT_OK | AT_CMD_RESULT_ERROR},
            {"AT+QIACT?\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK | AT_CMD_RESULT_TIMEOUT},
        };

    pcIMSI = Module_GetIMSI();
    if (strncmp(pcIMSI, "46000", 5) == 0 || strncmp(pcIMSI, "46002", 5) == 0)
    {
        HIDO_UtilSnprintf(acAPN, sizeof(acAPN), "CMNET");
    }
    else if (strncmp(pcIMSI, "46001", 5) == 0)
    {
        HIDO_UtilSnprintf(acAPN, sizeof(acAPN), "UNINET");
    }
    else if (strncmp(pcIMSI, "46006", 5) == 0)
    {
        HIDO_UtilSnprintf(acAPN, sizeof(acAPN), "CMNET");
    }
    else if (strncmp(pcIMSI, "46003", 5) == 0)
    {
        HIDO_UtilSnprintf(acAPN, sizeof(acAPN), "CTNET");
    }

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        l_u32CmdIndex = 0;
        l_u32RetryCnt = 0;
        HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
        l_u32RetryCnt++;

        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        HIDO_TimerCancel(u32FSMTimerID);
        break;
    }
    case HIDO_AT_EVENT_OK:
    case HIDO_AT_EVENT_ERROR:
    case HIDO_AT_EVENT_TIMEOUT:
    {
        if (HIDO_AT_EVENT_TIMEOUT == _u32Event)
        {
            if (astInitCmdList[l_u32CmdIndex].m_u32Result & AT_CMD_RESULT_TIMEOUT)
            {
                l_u32RetryCnt = 0;
                l_u32CmdIndex++;
                if (l_u32CmdIndex >= HIDO_ARRARY_COUNT(astInitCmdList))
                {
                    HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL);
                }
                else
                {
                    HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd, acAPN);
                }

                break;
            }
            else
            {
                return HIDO_EVENT_NO_PROC;
            }
        }

        if ((HIDO_AT_EVENT_OK == _u32Event && (astInitCmdList[l_u32CmdIndex].m_u32Result & AT_CMD_RESULT_OK)) || (HIDO_AT_EVENT_ERROR == _u32Event && (astInitCmdList[l_u32CmdIndex].m_u32Result & AT_CMD_RESULT_ERROR)))
        {
            l_u32RetryCnt = 0;
            l_u32CmdIndex++;
            if (l_u32CmdIndex >= HIDO_ARRARY_COUNT(astInitCmdList))
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL);
            }
            else
            {
                HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd, acAPN);
            }
        }
        else
        {
            l_u32RetryCnt++;
            if (l_u32RetryCnt >= 3)
            {
                /* ÖØÊÔ³¬ÏÞ */
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800), HIDO_NULL);
            }
            else
            {
                /* ²»ÊÇÆÚ´ýµÄ½á¹û£¬10ºóÔٴγ¢ÊÔ */
                HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10), _pstFSM,
                                   EG800_EVENT_DELAY);
            }
        }

        break;
    }
    case EG800_EVENT_DELAY:
    {
        HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd, acAPN);
        break;
    }
    case EG800_EVENT_POLL:
    {
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800IPReady
 * Parent State      : EG800
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800IPReady, HIDO_FSM_STATE(EG800Ready), HIDO_FSM_STATE(EG800IPPoll))
{
    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        Socket_ClosedAll();
#ifdef __EG800_MQTT__
        MQTT_ClosedAll();
#endif
        break;
    }
    case EG800_EVENT_POLL:
    {
        break;
    }
    case HIDO_AT_EVENT_TIMEOUT:
    {
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Init), HIDO_NULL);
        break;
    }
    case EG800_EVENT_CLOSE:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;
        HIDO_UINT32 u32ID = 0;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+QIURC: \"closed\",%d\r\n", &u32ID) != 1)
        {
            break;
        }

        Socket_OnClosed(u32ID);

        break;
    }
    case EG800_EVENT_PDPDEACT:
    {
        l_bDeact = HIDO_TRUE;
        break;
    }
#ifdef __EG800_MQTT__
    case EG800_EVENT_QMTSTAT:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;
        HIDO_UINT32 u32Err = 0;
        HIDO_UINT32 u32ClientID = 0;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+QMTSTAT: %d,%d\r\n",
                                 &u32ClientID, &u32Err) != 2)
        {
            break;
        }

        if (u32Err != 0)
        {
            MQTT_OnClosed(u32ClientID);

            break;
        }

        break;
    }
    case EG800_EVENT_QMTPUBEX:
    {
        EG800MQTT_SendAck((HIDO_DataStruct *)_pArg);

        break;
    }
#endif
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800IPPoll
 * Parent State      : EG800IPReady
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800IPPoll, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL)
{
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EG800DriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_MS(0), _pstFSM, EG800_EVENT_POLL);
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        break;
    }
    case EG800_EVENT_POLL:
    {
        if (HIDO_TRUE == l_bDeact)
        {
            l_bDeact = HIDO_FALSE;
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Ready), HIDO_NULL);
            break;
        }

        if (EG800_PollOnIPReady(pstATDevice) == HIDO_OK)
        {
            break;
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800IPCheck
 * Parent State      : EG800IPReady
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EG800IPCheck, HIDO_FSM_STATE(EG800IPReady), HIDO_NULL)
{
    static HIDO_UINT32 l_u32CGATT = 0;
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        l_u32CGATT = 0;
        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CGATT?\r\n");
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        break;
    }
    case HIDO_AT_EVENT_OK:
    {
        if (1 == l_u32CGATT)
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800IPPoll), HIDO_NULL);
        }
        else
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Ready), HIDO_NULL);
        }

        break;
    }
    case EG800_EVENT_CGATT:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *)_pArg;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *)pstData->m_pData, pstData->m_u32Len, "+CGATT: %d", &l_u32CGATT) == 1)
        {
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800RunATCmd
 * Parent State      : EG800Ready
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_DETACHED_STATE_IMPLEMENT(EG800RunATCmd, HIDO_NULL, HIDO_NULL)
{
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "%s\r\n", Module_GetRunATCmd());
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        break;
    }
    case HIDO_AT_EVENT_OK:
    case HIDO_AT_EVENT_ERROR:
    case HIDO_AT_EVENT_TIMEOUT:
    {
        Module_RunATCmdResult((HIDO_DataStruct *)_pArg);
        HIDO_FSMStateChange(_pstFSM, l_stStateArg.m_pstAfterState, HIDO_NULL);
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EG800RunATCmd
 * Parent State      : EG800Ready
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_DETACHED_STATE_IMPLEMENT(EG800CloseWireless, HIDO_NULL, HIDO_NULL)
{
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CFUN=0\r\n");
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        break;
    }
    case HIDO_AT_EVENT_OK:
    case HIDO_AT_EVENT_ERROR:
    {
        Module_PowerEvent(MODULE_GSM, MODULE_STATE_POWER_OFF);
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Idle), HIDO_NULL);
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : OpenWireless
 * Parent State      : EG800Ready
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_DETACHED_STATE_IMPLEMENT(EG800OpenWireless, HIDO_NULL, HIDO_NULL)
{
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *)_pstFSM->m_pPrivateData;

    switch (_u32Event)
    {
    case HIDO_EVENT_ENTRY:
    {
        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CFUN=1\r\n");
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        break;
    }
    case HIDO_AT_EVENT_OK:
    case HIDO_AT_EVENT_ERROR:
    {
        Module_PowerEvent(MODULE_GSM, MODULE_STATE_POWER_ON);
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EG800Ready), HIDO_NULL);
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * Function Name     : EG800_PowerPoll
 * Description       : µçÔ´´¦ÀíʼþµÄÂÖѯ
 * Input             : _pstATDevice ATÉ豸ÃèÊö
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
static HIDO_INT32 EG800_PowerPoll(HIDO_ATLiteDeviceStruct *_pstATDevice)
{
    if (Module_NeedPowerOn(MODULE_MAIN) == HIDO_TRUE)
    {
        Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_ON);
    }

    if (Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
    {
        HIDO_FSMStateChange(HIDO_FSM(EG800), HIDO_FSM_STATE(EG800PowerOff), HIDO_NULL);
        return HIDO_OK;
    }

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EG800_RunATCmdPoll
 * Description       : ÔËÐÐÓû§ATÃüÁî´¦ÀíÂÖѯ
 * Input             : _pstATDevice ATÉ豸ÃèÊö
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
static HIDO_INT32 EG800_RunATCmdPoll(HIDO_ATLiteDeviceStruct *_pstATDevice)
{
    if (Module_RunATCmdEnable() == HIDO_TRUE)
    {
        l_stStateArg.m_pArg = HIDO_NULL;
        l_stStateArg.m_pstAfterState = _pstATDevice->m_pstFSM->m_pstCurrentState;
        HIDO_FSM_DETACHED_STATE_SETTLE(EG800RunATCmd, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
        HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(EG800RunATCmd), HIDO_NULL);

        return HIDO_OK;
    }

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EG800_CloseWirelessPoll
 * Description       : ¹Ø±ÕÎÞÏßÊý¾ÝÂÖѯ
 * Input             : _pstATDevice ATÉ豸ÃèÊö
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
static HIDO_INT32 EG800_CloseWirelessPoll(HIDO_ATLiteDeviceStruct *_pstATDevice)
{
    if (Module_NeedPowerOff(MODULE_GSM) == HIDO_TRUE)
    {
        l_stStateArg.m_pArg = HIDO_NULL;
        l_stStateArg.m_pstAfterState = _pstATDevice->m_pstFSM->m_pstCurrentState;
        HIDO_FSM_DETACHED_STATE_SETTLE(EG800CloseWireless, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
        HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(EG800CloseWireless), HIDO_NULL);

        return HIDO_OK;
    }

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EG800_OpenWirelessPoll
 * Description       : ´ò¿ªÎÞÏßÊý¾ÝÂÖѯ
 * Input             : _pstATDevice ATÉ豸ÃèÊö
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
static HIDO_INT32 EG800_OpenWirelessPoll(HIDO_ATLiteDeviceStruct *_pstATDevice)
{
    if (Module_NeedPowerOn(MODULE_GSM) == HIDO_TRUE)
    {
        l_stStateArg.m_pArg = HIDO_NULL;
        l_stStateArg.m_pstAfterState = _pstATDevice->m_pstFSM->m_pstCurrentState;
        HIDO_FSM_DETACHED_STATE_SETTLE(EG800OpenWireless, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
        HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(EG800OpenWireless), HIDO_NULL);

        return HIDO_OK;
    }

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EG800_Poll
 * Description       : ÔÚ·ÇIPReady״̬ʱµÄÂÖѯ´¦Àí
 * Input             : _pstATDevice ATÉ豸ÃèÊö
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
static HIDO_INT32 EG800_Poll(HIDO_ATLiteDeviceStruct *_pstATDevice)
{
    /* Power */
    if (EG800_PowerPoll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

#ifdef __EG800_GNSS__
    /* GNSS */
    if (EG800GNSS_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }
#endif

    /* CSQ */
    if (EG800CSQ_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

    /* RunATCmd */
    if (EG800_RunATCmdPoll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

    /* GSM */
    if (EG800_CloseWirelessPoll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

    if (EG800_OpenWirelessPoll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

#ifdef __EG800_FILE__
    if (EG800File_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }
#endif

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EG800_PollOnIPReady
 * Description       : ÔÚIPReady״̬ʱµÄÂÖѯ´¦Àí
 * Input             : _pstATDevice ATÉ豸ÃèÊö
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
static HIDO_INT32 EG800_PollOnIPReady(HIDO_ATLiteDeviceStruct *_pstATDevice)
{
    HIDO_UINT32 u32CurTick = HIDO_TimerGetTick();

    /* Power */
    if (EG800_PowerPoll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

#ifdef __EG800_GNSS__
    /* GNSS */
    if (EG800GNSS_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }
#endif

    /* Socket */
    if (EG800Socket_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

#ifdef __EG800_MQTT__
    /* MQTT */
    if (EG800MQTT_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }
#endif

#ifdef __EG800_HTTP__
    /* HTTP */
    if (EG800HTTP_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }
#endif
    /* CSQ */
    if (EG800CSQ_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

    if ((u32CurTick - l_u32IPCheckTick) > HIDO_TIMER_TICK_S(10))
    {
        l_u32IPCheckTick = u32CurTick;
        HIDO_FSMStateChange(HIDO_FSM(EG800), HIDO_FSM_STATE(EG800IPCheck), HIDO_NULL);
        return HIDO_OK;
    }

    /* RunATCmd */
    if (EG800_RunATCmdPoll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

    /* GSM */
    if (EG800_CloseWirelessPoll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

    if (EG800_OpenWirelessPoll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

#ifdef __EG800_FILE__
    if (EG800File_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }
#endif

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EG800_IsIPReady
 * Description       : ÅжÏ״̬»úÊÇ·ñ´¦ÔÚEG800IPReady״̬
 * Input             : None
 * Output            : None
 * Return            : HIDO_TRUE ÊÇ, HIDO_FALSE ·ñ
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_BOOL EG800_IsIPReady(void)
{
    const HIDO_StateStruct *pstTmpState = HIDO_FSM(EG800)->m_pstCurrentState;

    while (pstTmpState != HIDO_NULL)
    {
        if (pstTmpState == HIDO_FSM_STATE(EG800IPReady))
        {
            return HIDO_TRUE;
        }

        pstTmpState = pstTmpState->m_pstParent;
    }

    return HIDO_FALSE;
}

/*******************************************************************************
 * Function Name     : EG800_IsIPIdle
 * Description       : ÅжÏ״̬»úÊÇ·ñ´¦ÔÚEG800IPPoll״̬
 * Input             : None
 * Output            : None
 * Return            : HIDO_TRUE ÊÇ, HIDO_FALSE ·ñ
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ22ÈÕ
 *******************************************************************************/
HIDO_BOOL EG800_IsIPIdle(void)
{
    const HIDO_StateStruct *pstTmpState = HIDO_FSM(EG800)->m_pstCurrentState;

    if (pstTmpState == HIDO_FSM_STATE(EG800IPPoll))
    {
        return HIDO_TRUE;
    }

    return HIDO_FALSE;
}