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

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

#include "string.h"
#include "Module.h"
#include "Socket.h"
#include "Module.h"
#include "EC600SCSQ.h"
#include "EC600SDriver.h"
#include "EC600SSocket.h"
#include "EC600SAudio.h"
#include "HIDO_FSM.h"
#include "HIDO_Timer.h"
#include "HIDO_Util.h"
#include "HIDO_Debug.h"
#include "ATConfig.h"
#include "Uart.h"
#include "RTC.h"
#include "Module.h"

#include "TTS.h"
#include "ADC.h"
#include "WS2812.h"

#include "global_param.h"
#include "ADC.h"

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

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

/*******************************************************************************
 *                            Global Variable                                  *
 *******************************************************************************/
HIDO_FSM_DECLARE_IMPLEMENT(EC600S);
HIDO_FSM_DETACHED_STATE(EC600SRunATCmd)
HIDO_FSM_DETACHED_STATE(EC600SCloseWireless)
HIDO_FSM_DETACHED_STATE(EC600SOpenWireless)

/*******************************************************************************
 *                             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 EC600S_Poll(HIDO_ATLiteDeviceStruct *_pstATDevice);
static HIDO_INT32 EC600S_PollOnIPReady(HIDO_ATLiteDeviceStruct *_pstATDevice);

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

/*******************************************************************************
 * State Name        : EC600S
 * Parent State      : None
 * Description       : EC600SÖ÷״̬
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EC600S, HIDO_NULL, HIDO_FSM_STATE(EC600SPowerOn))
{
    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            break;
        }
        case HIDO_AT_EVENT_TIMEOUT:
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SInit), HIDO_NULL);
            break;
        }
        case EC600S_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;
        }
        case EC600S_EVENT_QTTS:
        {
            HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;

            if (strcmp((HIDO_CHAR *) pstData->m_pData, "+QTTS: 0\r\n") != 0)
            {
                break;
            }

            EC600SAudio_TTSOver();

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

            if (strcmp((HIDO_CHAR *) pstData->m_pData, "+QLTONE: 0\r\n") != 0)
            {
                break;
            }

            EC600SAudio_TONEOver();

            break;
        }
#ifdef __EC600S_MQTT__
        case EC600S_EVENT_QMTRECV:
        {
            HIDO_UINT32 u32ClientID = 0;
            HIDO_UINT32 u32MsgID = 0;
            HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;

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

            MQTT_HaveRecvData(u32ClientID);

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

    return HIDO_EVENT_OK;
}

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

            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EC600SPowerOff
 * Parent State      : EC600SInit
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EC600SPowerOff, HIDO_FSM_STATE(EC600S), HIDO_NULL)
{
    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            EC600SDriver_PowerOff();
            Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_OFF);
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            break;
        }
        case EC600S_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(EC600SPowerOn), HIDO_NULL);
            }

            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EC600SPowerOn
 * Parent State      : EC600SInit
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EC600SPowerOn, HIDO_FSM_STATE(EC600SInit), HIDO_NULL)
{
    static enum
    {
        EC600S_SUB_STATE_POWER_OFF,
        EC600S_SUB_STATE_POWER_ON,
        EC600S_SUB_STATE_PWRKEY_RESET,
        EC600S_SUB_STATE_PWRKEY_SET,
    } l_eEC600SSubState;

    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EC600SDriverData *)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_eEC600SSubState = EC600S_SUB_STATE_POWER_OFF;
            EC600SDriver_PowerOff();
            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(3), _pstFSM, EC600S_EVENT_DELAY);
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            /* Í˳ö³õʼ»¯ */
            HIDO_TimerCancel(u32FSMTimerID);

            break;
        }
        case EC600S_EVENT_DELAY:
        {
            switch(l_eEC600SSubState)
            {
                case EC600S_SUB_STATE_POWER_OFF:
                {
                    l_eEC600SSubState = EC600S_SUB_STATE_POWER_ON;
                    EC600SDriver_PowerOn();
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM, EC600S_EVENT_DELAY);
                    break;
                }
                case EC600S_SUB_STATE_POWER_ON:
                {
                    l_eEC600SSubState = EC600S_SUB_STATE_PWRKEY_RESET;
                    EC600SDriver_PWRKEYReset();
                    Uart_ReConfigBaudRate(UART_ID_4G, 921600);
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM, EC600S_EVENT_DELAY);
                    break;
                }
                case EC600S_SUB_STATE_PWRKEY_RESET:
                {
                    l_eEC600SSubState = EC600S_SUB_STATE_PWRKEY_SET;
                    EC600SDriver_PWRKEYSet();
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_MS(800), _pstFSM, EC600S_EVENT_DELAY);
                    break;
                }
                case EC600S_SUB_STATE_PWRKEY_SET:
                {
                    HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SWaitReady), HIDO_NULL);
                    break;
                }
            }

            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EC600SWaitReady
 * Parent State      : EC600SInit
 * Description       : 
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
extern int Last4G;
extern int LowPower;
extern int Power_J;
int temp1;

HIDO_FSM_STATE_IMPLEMENT(EC600SWaitReady, HIDO_FSM_STATE(EC600SInit), HIDO_NULL)
{
    static HIDO_BOOL bReady = HIDO_FALSE;
    static HIDO_UINT32 u32RetryCnt = 0,Power_r = 0,Power_j = 0,Open_PJ,dev_id,POWER_PJ;
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;
    HIDO_UINT32 u32FSMTimerID = ((ST_EC600SDriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;
    
    HIDO_CHAR TTS_Open[60];
    
    HIDO_FLOAT Power_V = 0;
    HIDO_CHAR LOWpower[60];
    

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10),
                    _pstFSM, EC600S_EVENT_DELAY);
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            HIDO_ATLiteCmdSendOver(pstATDevice);
            HIDO_TimerCancel(u32FSMTimerID);
            break;
        }
        case EC600S_EVENT_RDY:
        {
//            temp1 = Power_GetBatteryVoltage();

//            if(LowPower == 1)      //µÍµçÁ¿×Ô¶¯¹Ø»ú£¬¶Ô±ÈÄÚ²¿²Î¿¼µçѹ
//            {
//                GPIOD->BSRR = 0x0004;      //´ò¿ªTTSµçÔ´
//                HAL_Delay(800);               //±ØÒªÑÓʱ,ÑÓʱÊÇΪÁ˱ÜÃâ˵²»³öÀ´µÚÒ»¸ö×Ö

//                HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QTTS=2,\"%s\"\r\n", "µçÁ¿¹ýµÍ");
//                HAL_Delay(2000);
//                
//                // µ÷Óùػú½Ó¿Ú
//                while(1)
//                {
//                    GPIOA->BSRR = 0X0100 << 16;
//                }
//            }

//            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+QTTS=2,\"¿ª»ú\"\r\n");
            Power_r = Power_GetBatteryPercentage();
           
            dev_id = ((g_com_map[DEV_ID]>>12)&0xf)*1000+((g_com_map[DEV_ID]>>8)&0xf)*100+((g_com_map[DEV_ID]>>4)&0xf)*10+(g_com_map[DEV_ID]&0xf);
            Open_PJ = sprintf(TTS_Open, "É豸±àºÅ%dÊ£ÓàµçÁ¿°Ù·ÖÖ®%d",dev_id, Power_r);       //ÕâÀïµçÁ¿ÊÇƽ»¬Ç°µÄ
            TTS_Play((HIDO_UINT8 *)TTS_Open, strlen(TTS_Open));

            break;
        }
        case HIDO_AT_EVENT_OK:
        case EC600S_EVENT_DELAY:
        case HIDO_AT_EVENT_TIMEOUT:
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SATCmdTest), HIDO_NULL);
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EC600SATCmdTest
 * Parent State      : EC600SInit
 * Description       : ATÃüÁî²âÊÔ״̬
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EC600SATCmdTest, HIDO_FSM_STATE(EC600SInit), 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_EC600SDriverData *)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, EC600S_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, EC600S_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(EC600SWaitSimCardReady), HIDO_NULL);
                }
            }
            else
            {
                HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM,
                        EC600S_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,
                        EC600S_EVENT_DELAY);
            }
            else if (l_u32TimeoutCnt > 10)
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SPowerOn), HIDO_NULL);
            }
            else
            {
                HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM,
                        EC600S_EVENT_DELAY);
            }

            break;
        }
        case EC600S_EVENT_DELAY:
        {
            if (HIDO_TRUE == l_bConfigBaudRate)
            {
                /* Éϵç³É¹¦ */
                Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_ON);
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SWaitSimCardReady), HIDO_NULL);
                break;
            }
            else
            {
                HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "ATE0\r\n");
            }
            break;
        }
        case EC600S_EVENT_POLL:
        {
            if(Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
            {
                HIDO_FSMStateChange(HIDO_FSM(EC600S), HIDO_FSM_STATE(EC600SPowerOff), HIDO_NULL);

                break;
            }

            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EC600SWaitSimCardReady
 * Parent State      : EC600SInit
 * Description       : µÈ´ýSIM¿¨×¼±¸Íê³É
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EC600SWaitSimCardReady, HIDO_FSM_STATE(EC600SInit), 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_EC600SDriverData *)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, EC600S_EVENT_DELAY);
            break;
        }
        case HIDO_AT_EVENT_ERROR:
        {
            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1),
                    _pstFSM, EC600S_EVENT_DELAY);
            break;
        }
        case HIDO_AT_EVENT_TIMEOUT:
        {
            if (HIDO_TRUE == bReady)
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SATCmdInit), HIDO_NULL);
            }
            else
            {
                return HIDO_EVENT_NO_PROC;
            }

            break;
        }
        case EC600S_EVENT_DELAY:
        {
            if (HIDO_TRUE == bReady)
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SATCmdInit), HIDO_NULL);
            }
            else
            {
              //  HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SIdle), HIDO_NULL);
                 if(u32RetryCnt < 10)
                {
                    u32RetryCnt++;
                    HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CPIN?\r\n");
                }
                else
                {
                    HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SIdle), HIDO_NULL);
                }
            }
            break;
        }
        case EC600S_EVENT_CPIN:
        {
            bReady = HIDO_TRUE;
            break;
        }
        case EC600S_EVENT_POLL:
        {
            if(Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
            {
                HIDO_FSMStateChange(HIDO_FSM(EC600S), HIDO_FSM_STATE(EC600SPowerOff), HIDO_NULL);

                break;
            }

            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EC600SATCmdInit
 * Parent State      : EC600SInit
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EC600SATCmdInit, HIDO_FSM_STATE(EC600SInit), 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_EC600SDriverData *) 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(EC600SReady), 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(EC600SReady), 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(EC600SPowerOn), HIDO_NULL);
                }
                else
                {
                    /* ²»ÊÇÆÚ´ýµÄ½á¹û£¬10ºóÔٴγ¢ÊÔ */
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10), _pstFSM,
                            EC600S_EVENT_DELAY);
                }
            }

            break;
        }
        case EC600S_EVENT_DELAY:
        {
            HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
            break;
        }
        case EC600S_EVENT_NUM_0:
        case EC600S_EVENT_NUM_1:
        case EC600S_EVENT_NUM_2:
        case EC600S_EVENT_NUM_3:
        case EC600S_EVENT_NUM_4:
        case EC600S_EVENT_NUM_5:
        case EC600S_EVENT_NUM_6:
        case EC600S_EVENT_NUM_7:
        case EC600S_EVENT_NUM_8:
        case EC600S_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 EC600S_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 EC600S_EVENT_POLL:
        {
            if(Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
            {
                HIDO_FSMStateChange(HIDO_FSM(EC600S), HIDO_FSM_STATE(EC600SPowerOff), HIDO_NULL);

                break;
            }

            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

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

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            break;
        }
        case EC600S_EVENT_POLL:
        {
            EC600S_Poll(pstATDevice);

            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

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

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EC600SSearchingNetwork
 * Parent State      : EC600S
 * Description       : ²éÕÒÍøÂç
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EC600SSearchingNetwork, HIDO_FSM_STATE(EC600SReady), HIDO_NULL)
{
    static enum
    {
        EC600S_SUB_STATE_CREG,
        EC600S_SUB_STATE_CGREG,
    } l_eEC600SSubState;

    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_EC600SDriverData *) pstATDevice->m_pUserData)->m_u32FSMTimerID;

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

                if (1 == l_u32RespCode || 5 == l_u32RespCode)
                {
                    l_eEC600SSubState = EC600S_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(EC600SInit), HIDO_NULL);
                        break;
                    }
                    else
                    {
                        HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(2), _pstFSM,
                                EC600S_EVENT_DELAY);
                    }
                }
            }
            else if (EC600S_SUB_STATE_CGREG == l_eEC600SSubState)
            {
                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(EC600SIPInit), HIDO_NULL);
                }
                else
                {
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(2), _pstFSM,
                            EC600S_EVENT_DELAY);
                }

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

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

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

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

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

            break;
        }
        case EC600S_EVENT_POLL:
        {
            if (HIDO_FALSE == l_bATBusy)
            {
                EC600S_Poll(pstATDevice);
            }

            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EC600SIPInit
 * Parent State      : EC600S
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EC600SIPInit, HIDO_FSM_STATE(EC600SReady), 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_EC600SDriverData *) 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(EC600SIPReady), 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(EC600SIPReady), 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(EC600S), HIDO_NULL);
                }
                else
                {
                    /* ²»ÊÇÆÚ´ýµÄ½á¹û£¬10ºóÔٴγ¢ÊÔ */
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10), _pstFSM,
                            EC600S_EVENT_DELAY);
                }
            }

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

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EC600SIPReady
 * Parent State      : EC600S
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EC600SIPReady, HIDO_FSM_STATE(EC600SReady), HIDO_FSM_STATE(EC600SIPPoll))
{
    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            Socket_ClosedAll();
#ifdef __EC600S_MQTT__
            MQTT_ClosedAll();
#endif
            break;
        }
        case EC600S_EVENT_POLL:
        {
            break;
        }
        case HIDO_AT_EVENT_TIMEOUT:
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SInit), HIDO_NULL);
            break;
        }
        case EC600S_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 EC600S_EVENT_PDPDEACT:
        {
            l_bDeact = HIDO_TRUE;
            break;
        }
#ifdef __EC600S_MQTT__
        case EC600S_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 EC600S_EVENT_QMTPUBEX:
        {
            EC600SMQTT_SendAck((HIDO_DataStruct *) _pArg);

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

    return HIDO_EVENT_OK;
}

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

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            break;
        }
        case EC600S_EVENT_POLL:
        {
            if (HIDO_TRUE == l_bDeact)
            {
                l_bDeact = HIDO_FALSE;
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SReady), HIDO_NULL);
                break;
            }

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

            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : EC600SIPCheck
 * Parent State      : EC600SIPReady
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(EC600SIPCheck, HIDO_FSM_STATE(EC600SIPReady), 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(EC600SIPPoll), HIDO_NULL);
            }
            else
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(EC600SReady), HIDO_NULL);
            }

            break;
        }
        case EC600S_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        : EC600SRunATCmd
 * Parent State      : EC600SReady
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_DETACHED_STATE_IMPLEMENT(EC600SRunATCmd, 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        : EC600SRunATCmd
 * Parent State      : EC600SReady
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_DETACHED_STATE_IMPLEMENT(EC600SCloseWireless, 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(EC600SIdle), HIDO_NULL);
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * State Name        : OpenWireless
 * Parent State      : EC600SReady
 * Description       :
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018-05-01
 *******************************************************************************/
HIDO_FSM_DETACHED_STATE_IMPLEMENT(EC600SOpenWireless, 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(EC600SReady), HIDO_NULL);
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    }

    return HIDO_EVENT_OK;
}

/*******************************************************************************
 * Function Name     : EC600S_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 EC600S_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(EC600S), HIDO_FSM_STATE(EC600SPowerOff), HIDO_NULL);
        return HIDO_OK;
    }

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EC600S_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 EC600S_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(EC600SRunATCmd, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
	    HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(EC600SRunATCmd), HIDO_NULL);

	    return HIDO_OK;
	}

	return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EC600S_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 EC600S_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(EC600SCloseWireless, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
	    HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(EC600SCloseWireless), HIDO_NULL);

	    return HIDO_OK;
	}

	return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EC600S_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 EC600S_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(EC600SOpenWireless, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
	    HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(EC600SOpenWireless), HIDO_NULL);

	    return HIDO_OK;
	}

	return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EC600S_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 EC600S_Poll(HIDO_ATLiteDeviceStruct *_pstATDevice)
{
    /* Power */
    if(EC600S_PowerPoll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

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

    /* Audio */
    if (EC600SAudio_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

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

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

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

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

#ifdef __EC600S_FILE__
    if (EC600SFile_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }
#endif

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : EC600S_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 EC600S_PollOnIPReady(HIDO_ATLiteDeviceStruct *_pstATDevice)
{
    HIDO_UINT32 u32CurTick = HIDO_TimerGetTick();

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

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

    /* Audio */
    if (EC600SAudio_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }
    
    /* Socket */
    if (EC600SSocket_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

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

#ifdef __EC600S_HTTP__
    /* HTTP */
    if (EC600SHTTP_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }
#endif
    /* CSQ */
    if (EC600SCSQ_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }

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

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

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

    if (EC600S_OpenWirelessPoll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }
    
#ifdef __EC600S_FILE__
    if (EC600SFile_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
    }
#endif

    return HIDO_ERR;
}

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

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

        pstTmpState = pstTmpState->m_pstParent;
    }

    return HIDO_FALSE;
}

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

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

    return HIDO_FALSE;
}