格式化部分代码

yincheng.zhong

2 天以前 2ebb8217f43b69f491620423ea4d5d5944d1f91d

 keil/include/components/internet/src/AIR780EFSM.c

@@ -76,64 +76,64 @@
{
    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
    case HIDO_EVENT_ENTRY:
    {
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        break;
    }
    case HIDO_AT_EVENT_TIMEOUT:
    {
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EInit), HIDO_NULL);
        break;
    }
    case AIR780E_EVENT_RECEIVE:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;
        HIDO_UINT32 u32ID = 0;
        HIDO_UINT8 *pu8Data = HIDO_NULL;
        HIDO_UINT32 u32Len = 0;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "+RECEIVE,%d,%d:\r\n%e", &u32ID, &u32Len, &pu8Data)
                != 3)
        {
            break;
        }
        case HIDO_EVENT_EXIT:

        Socket_RecvData(u32ID, pu8Data, u32Len);
        Socket_OnRecv(u32ID);
        break;
    }
    case AIR780E_EVENT_NUM_0:
    case AIR780E_EVENT_NUM_1:
    case AIR780E_EVENT_NUM_2:
    case AIR780E_EVENT_NUM_3:
    case AIR780E_EVENT_NUM_4:
    case AIR780E_EVENT_NUM_5:
    {
        HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;
        HIDO_UINT32 u32ConnectID = 0;
        HIDO_DataStruct stEvent;

        if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "%d, %p\r\n",
                                 &u32ConnectID, &stEvent) != 2)
        {
            break;
        }
        case HIDO_AT_EVENT_TIMEOUT:

        if (strncmp(stEvent.m_pData, "CLOSED", stEvent.m_u32Len) == 0)
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EInit), HIDO_NULL);
            break;
            Socket_OnClosed(u32ConnectID);
        }
        case AIR780E_EVENT_RECEIVE:
        {
            HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;
            HIDO_UINT32 u32ID = 0;
         HIDO_UINT8 *pu8Data = HIDO_NULL;
         HIDO_UINT32 u32Len = 0;

            if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "+RECEIVE,%d,%d:\r\n%e", &u32ID, &u32Len, &pu8Data)
                    != 3)
            {
                break;
            }

            Socket_RecvData(u32ID, pu8Data, u32Len);
         Socket_OnRecv(u32ID);
            break;
        }
        case AIR780E_EVENT_NUM_0:
        case AIR780E_EVENT_NUM_1:
        case AIR780E_EVENT_NUM_2:
        case AIR780E_EVENT_NUM_3:
        case AIR780E_EVENT_NUM_4:
        case AIR780E_EVENT_NUM_5:
        {
            HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;
            HIDO_UINT32 u32ConnectID = 0;
         HIDO_DataStruct stEvent;

            if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "%d, %p\r\n",
                    &u32ConnectID, &stEvent) != 2)
            {
                break;
            }

            if (strncmp(stEvent.m_pData, "CLOSED", stEvent.m_u32Len) == 0)
            {
                Socket_OnClosed(u32ConnectID);
            }

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

    return HIDO_EVENT_OK;
@@ -150,25 +150,25 @@
{
    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            break;
        }
        case HIDO_AT_EVENT_TIMEOUT:
        {
            /* AT命令相应超时,重新初始化 */
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EInit), HIDO_NULL);
    case HIDO_EVENT_ENTRY:
    {
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        break;
    }
    case HIDO_AT_EVENT_TIMEOUT:
    {
        /* AT命令相应超时,重新初始化 */
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EInit), HIDO_NULL);

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

    return HIDO_EVENT_OK;
@@ -185,34 +185,34 @@
{
    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
    case HIDO_EVENT_ENTRY:
    {
        AIR780EDriver_PowerOff();
        Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_OFF);
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        break;
    }
    case AIR780E_EVENT_POLL:
    {
        if(Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
        {
            AIR780EDriver_PowerOff();
            Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_OFF);
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            break;
        }
        case AIR780E_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(AIR780EPowerOn), HIDO_NULL);
            }

            break;
        }
        default:
        if(Module_NeedPowerOn(MODULE_MAIN) == HIDO_TRUE)
        {
            return HIDO_EVENT_NO_PROC;
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EPowerOn), HIDO_NULL);
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -238,66 +238,66 @@

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

            l_eAIR780ESubState = AIR780E_SUB_STATE_POWER_OFF;
            AIR780EDriver_PowerOff();
            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM, AIR780E_EVENT_DELAY);
        l_eAIR780ESubState = AIR780E_SUB_STATE_POWER_OFF;
        AIR780EDriver_PowerOff();
        HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM, AIR780E_EVENT_DELAY);
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        /* 退出初始化 */
        HIDO_TimerCancel(u32FSMTimerID);

        break;
    }
    case AIR780E_EVENT_DELAY:
    {
        switch(l_eAIR780ESubState)
        {
        case AIR780E_SUB_STATE_POWER_OFF:
        {
            l_eAIR780ESubState = AIR780E_SUB_STATE_POWER_ON;
            AIR780EDriver_PowerOn();
            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(5), _pstFSM, AIR780E_EVENT_DELAY);
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            /* 退出初始化 */
            HIDO_TimerCancel(u32FSMTimerID);

            break;
        }
        case AIR780E_EVENT_DELAY:
        {
            switch(l_eAIR780ESubState)
            {
                case AIR780E_SUB_STATE_POWER_OFF:
                {
                    l_eAIR780ESubState = AIR780E_SUB_STATE_POWER_ON;
                    AIR780EDriver_PowerOn();
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(5), _pstFSM, AIR780E_EVENT_DELAY);
                    break;
                }
                case AIR780E_SUB_STATE_POWER_ON:
                {
                    HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EATCmdTest), HIDO_NULL);
                    //Uart_ReConfigBaudRate(UART_ID_4G, 115200);
                    //HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+IPR=9600;&W\r\n");
                    //Uart_ReConfigBaudRate(UART_ID_4G, 9600);
                    break;
                }
            }

            break;
        }
        case AIR780E_EVENT_RDY:
        case AIR780E_SUB_STATE_POWER_ON:
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EATCmdTest), HIDO_NULL);
            //Uart_ReConfigBaudRate(UART_ID_4G, 115200);
            //HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+IPR=9600;&W\r\n");
            //Uart_ReConfigBaudRate(UART_ID_4G, 9600);
            break;
        }
        case HIDO_AT_EVENT_OK:
        case HIDO_AT_EVENT_ERROR:
        case HIDO_AT_EVENT_TIMEOUT:
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EATCmdTest), HIDO_NULL);
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }

        break;
    }
    case AIR780E_EVENT_RDY:
    {
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EATCmdTest), HIDO_NULL);
        break;
    }
    case HIDO_AT_EVENT_OK:
    case HIDO_AT_EVENT_ERROR:
    case HIDO_AT_EVENT_TIMEOUT:
    {
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EATCmdTest), HIDO_NULL);
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -312,48 +312,48 @@
 *******************************************************************************/
HIDO_FSM_STATE_IMPLEMENT(AIR780EATCmdTest, HIDO_FSM_STATE(AIR780EInit), HIDO_NULL)
{
   static HIDO_UINT32 l_u32TimeoutCnt = 0;
    static HIDO_UINT32 l_u32TimeoutCnt = 0;
    HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "ATE0\r\n");
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            HIDO_ATLiteCmdSendOver(pstATDevice);
            break;
        }
        case HIDO_AT_EVENT_OK:
        {
            /* 上电成功 */
            Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_ON);
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EWaitSimCardReady), HIDO_NULL);
    case HIDO_EVENT_ENTRY:
    {
        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "ATE0\r\n");
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        break;
    }
    case HIDO_AT_EVENT_OK:
    {
        /* 上电成功 */
        Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_ON);
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EWaitSimCardReady), HIDO_NULL);

            break;
        }
        case HIDO_AT_EVENT_ERROR:
        break;
    }
    case HIDO_AT_EVENT_ERROR:
    {
        break;
    }
    case HIDO_AT_EVENT_TIMEOUT:
    {
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EPowerOn), HIDO_NULL);
        l_u32TimeoutCnt++;
        if (3 == l_u32TimeoutCnt)
        {
            break;
            AIR780E_Reset_usart();
        }
        case HIDO_AT_EVENT_TIMEOUT:
        { 
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EPowerOn), HIDO_NULL);
                  l_u32TimeoutCnt++;
                if (3 == l_u32TimeoutCnt)
            {
                     AIR780E_Reset_usart();
                  }
					
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -374,61 +374,61 @@

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
    case HIDO_EVENT_ENTRY:
    {
        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_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EATCmdInit), HIDO_NULL);
        break;
    }
    case HIDO_AT_EVENT_ERROR:
    {
        HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1),
                           _pstFSM, AIR780E_EVENT_DELAY);
        break;
    }
    case HIDO_AT_EVENT_TIMEOUT:
    {
        break;
    }
    case AIR780E_EVENT_DELAY:
    {
        if(u32RetryCnt < 10)
        {
            u32RetryCnt = 0;
            u32RetryCnt++;
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CPIN?\r\n");
            break;
        }
        case HIDO_EVENT_EXIT:
        else
        {
            HIDO_ATLiteCmdSendOver(pstATDevice);
            HIDO_TimerCancel(u32FSMTimerID);
            break;
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EIdle), HIDO_NULL);
        }
        case HIDO_AT_EVENT_OK:
        break;
    }
    case AIR780E_EVENT_POLL:
    {
        if(Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EATCmdInit), HIDO_NULL);
            break;
        }
        case HIDO_AT_EVENT_ERROR:
        {
            HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1),
                    _pstFSM, AIR780E_EVENT_DELAY);
            break;
        }
        case HIDO_AT_EVENT_TIMEOUT:
        {
            break;
        }
        case AIR780E_EVENT_DELAY:
        {
            if(u32RetryCnt < 10)
            {
                u32RetryCnt++;
                HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CPIN?\r\n");
            }
            else
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EIdle), HIDO_NULL);
            }
            break;
        }
        case AIR780E_EVENT_POLL:
        {
            if(Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
            {
                HIDO_FSMStateChange(HIDO_FSM(AIR780E), HIDO_FSM_STATE(AIR780EPowerOff), HIDO_NULL);

                break;
            }
            HIDO_FSMStateChange(HIDO_FSM(AIR780E), HIDO_FSM_STATE(AIR780EPowerOff), HIDO_NULL);

            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -452,7 +452,7 @@
        { "AT+CIMI\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
        { "AT+CCID\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
        { "ATI\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
            { "AT+CFGRI=1\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
        { "AT+CFGRI=1\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
//        { "AT+CTTSPARAM=100,0,50,50,0,2,25,1500,150,1,0,1\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
    };

@@ -461,50 +461,28 @@

    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++;
    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:
        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)
        {
            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(AIR780EReady), 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))
            if(astInitCmdList[l_u32CmdIndex].m_u32Result & AT_CMD_RESULT_TIMEOUT)
            {
                l_u32RetryCnt = 0;
                l_u32CmdIndex++;
@@ -516,83 +494,105 @@
                {
                    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(AIR780EPowerOn), HIDO_NULL);
                }
                else
                {
                    /* 不是期待的结果，10后再次尝试 */
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10), _pstFSM,
                            AIR780E_EVENT_DELAY);
                }
            }

            break;
        }
        case AIR780E_EVENT_DELAY:
        {
            HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
            break;
        }
        case AIR780E_EVENT_NUM_0:
        case AIR780E_EVENT_NUM_1:
        case AIR780E_EVENT_NUM_2:
        case AIR780E_EVENT_NUM_3:
        case AIR780E_EVENT_NUM_4:
        case AIR780E_EVENT_NUM_5:
        case AIR780E_EVENT_NUM_6:
        case AIR780E_EVENT_NUM_7:
        case AIR780E_EVENT_NUM_8:
        case AIR780E_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;
                }
            case 2:
                {
                    Module_SetCCID((HIDO_CHAR *)pstData->m_pData, pstData->m_u32Len);
                    break;
                }
                default:
                {
                    break;
                }
            }

            break;
        }
        case AIR780E_EVENT_POLL:
        {
            if(Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
            {
                HIDO_FSMStateChange(HIDO_FSM(AIR780E), HIDO_FSM_STATE(AIR780EPowerOff), HIDO_NULL);

                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(AIR780EReady), 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(AIR780EPowerOn), HIDO_NULL);
            }
            else
            {
                /* 不是期待的结果，10后再次尝试 */
                HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10), _pstFSM,
                                   AIR780E_EVENT_DELAY);
            }
        }

        break;
    }
    case AIR780E_EVENT_DELAY:
    {
        HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
        break;
    }
    case AIR780E_EVENT_NUM_0:
    case AIR780E_EVENT_NUM_1:
    case AIR780E_EVENT_NUM_2:
    case AIR780E_EVENT_NUM_3:
    case AIR780E_EVENT_NUM_4:
    case AIR780E_EVENT_NUM_5:
    case AIR780E_EVENT_NUM_6:
    case AIR780E_EVENT_NUM_7:
    case AIR780E_EVENT_NUM_8:
    case AIR780E_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;
        }
        case 2:
        {
            Module_SetCCID((HIDO_CHAR *)pstData->m_pData, pstData->m_u32Len);
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
            break;
        }
        }

        break;
    }
    case AIR780E_EVENT_POLL:
    {
        if(Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
        {
            HIDO_FSMStateChange(HIDO_FSM(AIR780E), HIDO_FSM_STATE(AIR780EPowerOff), HIDO_NULL);

            break;
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -611,24 +611,24 @@

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            break;
        }
        case AIR780E_EVENT_POLL:
        {
            AIR780E_Poll(pstATDevice);
    case HIDO_EVENT_ENTRY:
    {
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        break;
    }
    case AIR780E_EVENT_POLL:
    {
        AIR780E_Poll(pstATDevice);

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

    return HIDO_EVENT_OK;
@@ -645,18 +645,18 @@
{
    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    case HIDO_EVENT_ENTRY:
    {
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -687,143 +687,143 @@

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
    case HIDO_EVENT_ENTRY:
    {
        l_eAIR780ESubState = AIR780E_SUB_STATE_CGREG;
        l_u32Cnt = 0;
        l_u32RespCode = 0;
        l_bATBusy = HIDO_TRUE;

        HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CGREG?\r\n");
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        HIDO_ATLiteCmdSendOver(pstATDevice);
        HIDO_TimerCancel(u32FSMTimerID);
        break;
    }
    case HIDO_AT_EVENT_OK:
    {
        if (AIR780E_SUB_STATE_CREG == l_eAIR780ESubState)
        {
            l_eAIR780ESubState = AIR780E_SUB_STATE_CGREG;
            l_u32Cnt = 0;
            l_u32RespCode = 0;
            l_bATBusy = HIDO_TRUE;
            
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CGREG?\r\n");
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            HIDO_ATLiteCmdSendOver(pstATDevice);
            HIDO_TimerCancel(u32FSMTimerID);
            break;
        }
        case HIDO_AT_EVENT_OK:
        {
            if (AIR780E_SUB_STATE_CREG == l_eAIR780ESubState)
            l_bATBusy = HIDO_FALSE;

            if (1 == l_u32RespCode || 5 == l_u32RespCode)
            {
                l_bATBusy = HIDO_FALSE;

                if (1 == l_u32RespCode || 5 == l_u32RespCode)
                {
                    l_eAIR780ESubState = AIR780E_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(AIR780EInit), HIDO_NULL);
                        break;
                    }
                    else
                    {
                        HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(2), _pstFSM,
                                AIR780E_EVENT_DELAY);
                    }
                }
            }
            else if (AIR780E_SUB_STATE_CGREG == l_eAIR780ESubState)
            {
                l_bATBusy = HIDO_FALSE;

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

                if (l_u32ReadyCnt >= 1)
                {
                    HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EIPInit), HIDO_NULL);
                }
                else
                {
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(2), _pstFSM,
                            AIR780E_EVENT_DELAY);
                }

                if (l_u32Cnt > 100)
                {
                    /* TODO网络出错 */
                }
            }

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

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

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

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

            break;
        }
        case AIR780E_EVENT_POLL:
        {
            if (HIDO_FALSE == l_bATBusy)
            else
            {
                AIR780E_Poll(pstATDevice);
                l_u32Cnt++;

                if (l_u32Cnt > 100)
                {
                    HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EInit), HIDO_NULL);
                    break;
                }
                else
                {
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(2), _pstFSM,
                                       AIR780E_EVENT_DELAY);
                }
            }
        }
        else if (AIR780E_SUB_STATE_CGREG == l_eAIR780ESubState)
        {
            l_bATBusy = HIDO_FALSE;

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

            break;
            if (l_u32ReadyCnt >= 1)
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EIPInit), HIDO_NULL);
            }
            else
            {
                HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(2), _pstFSM,
                                   AIR780E_EVENT_DELAY);
            }

            if (l_u32Cnt > 100)
            {
                /* TODO网络出错 */
            }
        }
        default:

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

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

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

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

        break;
    }
    case AIR780E_EVENT_POLL:
    {
        if (HIDO_FALSE == l_bATBusy)
        {
            AIR780E_Poll(pstATDevice);
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -848,18 +848,18 @@

    const ST_ATCmd astInitCmdList[] =
    {
            { "AT+CIPRXF=1\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
            { "AT+CIPMUX=1\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
            { "AT*I\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
        { "AT+CIPRXF=1\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
        { "AT+CIPMUX=1\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
        { "AT*I\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
//            { "AT+CSTT=\"%s\",\"\",\"\"\r\n", 60000, AT_CMD_RESULT_OK | AT_CMD_RESULT_ERROR },
//            { "AT+CIICR\r\n", 60000, AT_CMD_RESULT_OK | AT_CMD_RESULT_ERROR },
//            { "AT+CIFSR\r\n", 1000, AT_CMD_RESULT_OK | AT_CMD_RESULT_TIMEOUT },
#ifdef _4G_115200

#else            
            { "AT+POWERMODE=\"PRO\"\r\n", 5000, AT_CMD_RESULT_OK | AT_CMD_RESULT_TIMEOUT },
         { "AT+POWERMODE?\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
#endif                        
#else
        { "AT+POWERMODE=\"PRO\"\r\n", 5000, AT_CMD_RESULT_OK | AT_CMD_RESULT_TIMEOUT },
        { "AT+POWERMODE?\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
#endif
    };

    pcIMSI = Module_GetIMSI();
@@ -882,50 +882,28 @@

    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++;
    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:
        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)
        {
            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(AIR780EIPReady), HIDO_NULL);
                    }
                    else
                    {
                        HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd, acAPN);
                    }

                    break;
                }
                else
                {
                    return HIDO_EVENT_NO_PROC;
                }
            }
ok:
            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)))
            if(astInitCmdList[l_u32CmdIndex].m_u32Result & AT_CMD_RESULT_TIMEOUT)
            {
                l_u32RetryCnt = 0;
                l_u32CmdIndex++;
@@ -937,56 +915,78 @@
                {
                    HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd, acAPN);
                }

                break;
            }
            else
            {
                l_u32RetryCnt++;
                if (l_u32RetryCnt >= 3)
                {
                    /* 重试超限 */
                    HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780E), HIDO_NULL);
                }
                else
                {
                    /* 不是期待的结果，10后再次尝试 */
                    HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10), _pstFSM,
                            AIR780E_EVENT_DELAY);
                }
                return HIDO_EVENT_NO_PROC;
            }

            break;
        }
        case AIR780E_EVENT_DELAY:
ok:
        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)))
        {
            HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd, acAPN);
            break;
        }
        case AIR780E_EVENT_POLL:
        {
            break;
        }
        case AIR780E_EVENT_NUM_0:
        case AIR780E_EVENT_NUM_1:
        case AIR780E_EVENT_NUM_2:
        case AIR780E_EVENT_NUM_3:
        case AIR780E_EVENT_NUM_4:
        case AIR780E_EVENT_NUM_5:
        case AIR780E_EVENT_NUM_6:
        case AIR780E_EVENT_NUM_7:
        case AIR780E_EVENT_NUM_8:
        case AIR780E_EVENT_NUM_9:
        {
            if(l_u32CmdIndex == 4)
            l_u32RetryCnt = 0;
            l_u32CmdIndex++;
            if (l_u32CmdIndex >= HIDO_ARRARY_COUNT(astInitCmdList))
            {
                _u32Event = HIDO_AT_EVENT_OK;
                goto ok;
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EIPReady), HIDO_NULL);
            }
            break;
            else
            {
                HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd, acAPN);
            }
        }
        default:
        else
        {
            return HIDO_EVENT_NO_PROC;
            l_u32RetryCnt++;
            if (l_u32RetryCnt >= 3)
            {
                /* 重试超限 */
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780E), HIDO_NULL);
            }
            else
            {
                /* 不是期待的结果，10后再次尝试 */
                HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10), _pstFSM,
                                   AIR780E_EVENT_DELAY);
            }
        }

        break;
    }
    case AIR780E_EVENT_DELAY:
    {
        HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd, acAPN);
        break;
    }
    case AIR780E_EVENT_POLL:
    {
        break;
    }
    case AIR780E_EVENT_NUM_0:
    case AIR780E_EVENT_NUM_1:
    case AIR780E_EVENT_NUM_2:
    case AIR780E_EVENT_NUM_3:
    case AIR780E_EVENT_NUM_4:
    case AIR780E_EVENT_NUM_5:
    case AIR780E_EVENT_NUM_6:
    case AIR780E_EVENT_NUM_7:
    case AIR780E_EVENT_NUM_8:
    case AIR780E_EVENT_NUM_9:
    {
        if(l_u32CmdIndex == 4)
        {
            _u32Event = HIDO_AT_EVENT_OK;
            goto ok;
        }
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -1003,79 +1003,79 @@
{
    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
        {
            break;
        }
        case HIDO_EVENT_EXIT:
        {
            Socket_ClosedAll();
    case HIDO_EVENT_ENTRY:
    {
        break;
    }
    case HIDO_EVENT_EXIT:
    {
        Socket_ClosedAll();
#ifdef __AIR780E_MQTT__
            MQTT_ClosedAll();
        MQTT_ClosedAll();
#endif
            break;
        }
        case AIR780E_EVENT_POLL:
        {
            break;
        }
        case HIDO_AT_EVENT_TIMEOUT:
        {
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EInit), HIDO_NULL);
            break;
        }
        case AIR780E_EVENT_CLOSE:
        {
            HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;
            HIDO_UINT32 u32ID = 0;
        break;
    }
    case AIR780E_EVENT_POLL:
    {
        break;
    }
    case HIDO_AT_EVENT_TIMEOUT:
    {
        HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EInit), HIDO_NULL);
        break;
    }
    case AIR780E_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 AIR780E_EVENT_PDPDEACT:
        if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "+QIURC: \"closed\",%d\r\n", &u32ID) != 1)
        {
            l_bDeact = HIDO_TRUE;
            break;
        }

        Socket_OnClosed(u32ID);

        break;
    }
    case AIR780E_EVENT_PDPDEACT:
    {
        l_bDeact = HIDO_TRUE;
        break;
    }
#ifdef __AIR780E_MQTT__
        case AIR780E_EVENT_QMTSTAT:
    case AIR780E_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)
        {
            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;
            break;
        }
        case AIR780E_EVENT_QMTPUBEX:

        if(u32Err != 0)
        {
            AIR780EMQTT_SendAck((HIDO_DataStruct *) _pArg);
            MQTT_OnClosed(u32ClientID);

            break;
        }

        break;
    }
    case AIR780E_EVENT_QMTPUBEX:
    {
        AIR780EMQTT_SendAck((HIDO_DataStruct *) _pArg);

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

    return HIDO_EVENT_OK;
@@ -1094,34 +1094,34 @@

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

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

        if(AIR780E_PollOnIPReady(pstATDevice) == HIDO_OK)
        {
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -1141,45 +1141,45 @@

    switch (_u32Event)
    {
        case HIDO_EVENT_ENTRY:
    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)
        {
            l_u32CGATT = 0;
            HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CGATT?\r\n");
            break;
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EIPPoll), HIDO_NULL);
        }
        case HIDO_EVENT_EXIT:
        else
        {
            HIDO_ATLiteCmdSendOver(pstATDevice);
            break;
            HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EReady), HIDO_NULL);
        }
        case HIDO_AT_EVENT_OK:
        {
            if (1 == l_u32CGATT)
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EIPPoll), HIDO_NULL);
            }
            else
            {
                HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(AIR780EReady), HIDO_NULL);
            }

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

        if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "+CGATT: %d", &l_u32CGATT) == 1)
        {
            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;
        }

        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -1198,28 +1198,28 @@

    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;
        }
    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;
@@ -1238,27 +1238,27 @@

    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(AIR780EIdle), HIDO_NULL);
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    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(AIR780EIdle), HIDO_NULL);
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -1277,27 +1277,27 @@

    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(AIR780EReady), HIDO_NULL);
            break;
        }
        default:
        {
            return HIDO_EVENT_NO_PROC;
        }
    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(AIR780EReady), HIDO_NULL);
        break;
    }
    default:
    {
        return HIDO_EVENT_NO_PROC;
    }
    }

    return HIDO_EVENT_OK;
@@ -1339,17 +1339,17 @@
 *******************************************************************************/
static HIDO_INT32 AIR780E_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(AIR780ERunATCmd, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
       HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(AIR780ERunATCmd), HIDO_NULL);
    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(AIR780ERunATCmd, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
        HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(AIR780ERunATCmd), HIDO_NULL);

       return HIDO_OK;
   }
        return HIDO_OK;
    }

   return HIDO_ERR;
    return HIDO_ERR;
}

/*******************************************************************************
@@ -1363,17 +1363,17 @@
 *******************************************************************************/
static HIDO_INT32 AIR780E_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(AIR780ECloseWireless, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
       HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(AIR780ECloseWireless), HIDO_NULL);
    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(AIR780ECloseWireless, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
        HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(AIR780ECloseWireless), HIDO_NULL);

       return HIDO_OK;
   }
        return HIDO_OK;
    }

   return HIDO_ERR;
    return HIDO_ERR;
}

/*******************************************************************************
@@ -1387,17 +1387,17 @@
 *******************************************************************************/
static HIDO_INT32 AIR780E_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(AIR780EOpenWireless, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
       HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(AIR780EOpenWireless), HIDO_NULL);
    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(AIR780EOpenWireless, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
        HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(AIR780EOpenWireless), HIDO_NULL);

       return HIDO_OK;
   }
        return HIDO_OK;
    }

   return HIDO_ERR;
    return HIDO_ERR;
}

/*******************************************************************************
@@ -1432,7 +1432,7 @@
        return HIDO_OK;
    }
#endif
    

    /* CSQ */
    if (AIR780ECSQ_Poll(_pstATDevice) == HIDO_OK)
    {
@@ -1486,7 +1486,7 @@
    }

#ifdef __AIR780E_GNSS__
      /* GNSS */
    /* GNSS */
    if(AIR780EGNSS_Poll(_pstATDevice) == HIDO_OK)
    {
        return HIDO_OK;
@@ -1500,7 +1500,7 @@
        return HIDO_OK;
    }
#endif
    

    /* Socket */
    if (AIR780ESocket_Poll(_pstATDevice) == HIDO_OK)
    {
@@ -1536,7 +1536,7 @@
        return HIDO_OK;
    }
#endif
    

    /* RunATCmd */
    if (AIR780E_RunATCmdPoll(_pstATDevice) == HIDO_OK)
    {
@@ -1553,7 +1553,7 @@
    {
        return HIDO_OK;
    }
    

#ifdef __AIR780E_FILE__
    if (AIR780EFile_Poll(_pstATDevice) == HIDO_OK)
    {