/*******************************************************************************
|
* File Name : MT571XFSM.c
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
|
/*******************************************************************************
|
* Include Files *
|
*******************************************************************************/
|
#include "MT571XFSM.h"
|
|
#include "string.h"
|
#include "Module.h"
|
#include "Socket.h"
|
#include "Module.h"
|
#include "MT571XCSQ.h"
|
#include "MT571XTEMP.h"
|
#include "MT571XDriver.h"
|
#include "MT571XSocket.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 "ADC.h"
|
#include "WS2812.h"
|
|
#include "global_param.h"
|
#include "ADC.h"
|
|
/*******************************************************************************
|
* Macro *
|
*******************************************************************************/
|
#define TTS_SPEED "-10000"
|
#define TTS_VOLUME "32767"
|
|
/*******************************************************************************
|
* Type Definition *
|
*******************************************************************************/
|
|
/*******************************************************************************
|
* Global Variable *
|
*******************************************************************************/
|
HIDO_FSM_DECLARE_IMPLEMENT(MT571X);
|
HIDO_FSM_DETACHED_STATE(MT571XRunATCmd)
|
HIDO_FSM_DETACHED_STATE(MT571XCloseWireless)
|
HIDO_FSM_DETACHED_STATE(MT571XOpenWireless)
|
|
/*******************************************************************************
|
* 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 MT571X_Poll(HIDO_ATLiteDeviceStruct *_pstATDevice);
|
static HIDO_INT32 MT571X_PollOnIPReady(HIDO_ATLiteDeviceStruct *_pstATDevice);
|
|
/*******************************************************************************
|
* Global Function *
|
*******************************************************************************/
|
|
/*******************************************************************************
|
* State Name : MT571X
|
* Parent State : None
|
* Description : MT571XÖ÷״̬
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571X, HIDO_NULL, HIDO_FSM_STATE(MT571XPowerOn))
|
{
|
switch (_u32Event)
|
{
|
case HIDO_EVENT_ENTRY:
|
{
|
break;
|
}
|
case HIDO_EVENT_EXIT:
|
{
|
break;
|
}
|
case HIDO_AT_EVENT_TIMEOUT:
|
{
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XInit), HIDO_NULL);
|
break;
|
}
|
case MT571X_EVENT_NEW_IP_DATA:
|
{
|
HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;
|
HIDO_UINT32 u32ID = 0;
|
HIDO_UINT32 u32Len = 0;
|
HIDO_UINT8 *pu8Data = HIDO_NULL;
|
|
if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "^IPDATA:%d,%d,%e", &u32ID, &u32Len, &pu8Data)
|
!= 3)
|
{
|
break;
|
}
|
|
Socket_RecvData(u32ID, pu8Data, u32Len);
|
|
//HIDO_Debug("Socket[%u] Recv %u {", l_i32SocketID, u32ReadLen);
|
//HIDO_DebugHex(pu8IPData, u32ReadLen);
|
//HIDO_Debug("}\r\n");
|
|
Socket_OnRecv(u32ID);
|
break;
|
}
|
case MT571X_EVENT_QTTS:
|
{
|
// MT571XAudio_TTSOver();
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XInit
|
* Parent State : MT571X
|
* Description : ³õʼ»¯Ö÷״̬
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XInit, HIDO_FSM_STATE(MT571X), HIDO_FSM_STATE(MT571XPowerOn))
|
{
|
switch (_u32Event)
|
{
|
case HIDO_EVENT_ENTRY:
|
{
|
break;
|
}
|
case HIDO_EVENT_EXIT:
|
{
|
break;
|
}
|
case HIDO_AT_EVENT_TIMEOUT:
|
{
|
/* ATÃüÁîÏàÓ¦³¬Ê±,ÖØгõʼ»¯ */
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XInit), HIDO_NULL);
|
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XPowerOff
|
* Parent State : MT571XInit
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XPowerOff, HIDO_FSM_STATE(MT571X), HIDO_NULL)
|
{
|
switch (_u32Event)
|
{
|
case HIDO_EVENT_ENTRY:
|
{
|
MT571XDriver_PowerOff();
|
Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_OFF);
|
break;
|
}
|
case HIDO_EVENT_EXIT:
|
{
|
break;
|
}
|
case MT571X_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(MT571XPowerOn), HIDO_NULL);
|
}
|
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XPowerOn
|
* Parent State : MT571XInit
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XPowerOn, HIDO_FSM_STATE(MT571XInit), HIDO_NULL)
|
{
|
static enum
|
{
|
MT571X_SUB_STATE_POWER_OFF,
|
MT571X_SUB_STATE_POWER_ON,
|
MT571X_SUB_STATE_PWRKEY_RESET,
|
MT571X_SUB_STATE_PWRKEY_SET,
|
} l_eMT571XSubState;
|
|
HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;
|
HIDO_UINT32 u32FSMTimerID = ((ST_MT571XDriverData *)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_eMT571XSubState = MT571X_SUB_STATE_POWER_OFF;
|
MT571XDriver_PowerOff();
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(3), _pstFSM, MT571X_EVENT_DELAY);
|
break;
|
}
|
case HIDO_EVENT_EXIT:
|
{
|
/* Í˳ö³õʼ»¯ */
|
HIDO_TimerCancel(u32FSMTimerID);
|
|
break;
|
}
|
case MT571X_EVENT_DELAY:
|
{
|
switch(l_eMT571XSubState)
|
{
|
case MT571X_SUB_STATE_POWER_OFF:
|
{
|
l_eMT571XSubState = MT571X_SUB_STATE_POWER_ON;
|
MT571XDriver_PowerOn();
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM, MT571X_EVENT_DELAY);
|
break;
|
}
|
case MT571X_SUB_STATE_POWER_ON:
|
{
|
l_eMT571XSubState = MT571X_SUB_STATE_PWRKEY_RESET;
|
MT571XDriver_PWRKEYReset();
|
Uart_ReConfigBaudRate(UART_ID_4G, 115200);
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM, MT571X_EVENT_DELAY);
|
break;
|
}
|
case MT571X_SUB_STATE_PWRKEY_RESET:
|
{
|
l_eMT571XSubState = MT571X_SUB_STATE_PWRKEY_SET;
|
MT571XDriver_PWRKEYSet();
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_MS(800), _pstFSM, MT571X_EVENT_DELAY);
|
break;
|
}
|
case MT571X_SUB_STATE_PWRKEY_SET:
|
{
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XWaitReady), HIDO_NULL);
|
break;
|
}
|
}
|
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XWaitReady
|
* Parent State : MT571XInit
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XWaitReady, HIDO_FSM_STATE(MT571XInit), 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_MT571XDriverData *)pstATDevice->m_pUserData)->m_u32FSMTimerID;
|
|
switch (_u32Event)
|
{
|
case HIDO_EVENT_ENTRY:
|
{
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(60),
|
_pstFSM, MT571X_EVENT_DELAY);
|
break;
|
}
|
case HIDO_EVENT_EXIT:
|
{
|
HIDO_ATLiteCmdSendOver(pstATDevice);
|
HIDO_TimerCancel(u32FSMTimerID);
|
break;
|
}
|
case MT571X_EVENT_RDY:
|
{
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(5),
|
_pstFSM, MT571X_EVENT_DELAY);
|
break;
|
}
|
case HIDO_AT_EVENT_OK:
|
case MT571X_EVENT_DELAY:
|
case HIDO_AT_EVENT_TIMEOUT:
|
{
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XATCmdTest), HIDO_NULL);
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XATCmdTest
|
* Parent State : MT571XInit
|
* Description : ATÃüÁî²âÊÔ״̬
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XATCmdTest, HIDO_FSM_STATE(MT571XInit), 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_MT571XDriverData *)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, MT571X_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, MT571X_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(MT571XWaitSimCardReady), HIDO_NULL);
|
}
|
}
|
else
|
{
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM,
|
MT571X_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,
|
MT571X_EVENT_DELAY);
|
}
|
else if (l_u32TimeoutCnt > 10)
|
{
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XPowerOn), HIDO_NULL);
|
}
|
else
|
{
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM,
|
MT571X_EVENT_DELAY);
|
}
|
|
break;
|
}
|
case MT571X_EVENT_DELAY:
|
{
|
if (HIDO_TRUE == l_bConfigBaudRate)
|
{
|
/* Éϵç³É¹¦ */
|
Module_PowerEvent(MODULE_MAIN, MODULE_STATE_POWER_ON);
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XWaitSimCardReady), HIDO_NULL);
|
break;
|
}
|
else
|
{
|
HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "ATE0\r\n");
|
}
|
break;
|
}
|
case MT571X_EVENT_POLL:
|
{
|
if(Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
|
{
|
HIDO_FSMStateChange(HIDO_FSM(MT571X), HIDO_FSM_STATE(MT571XPowerOff), HIDO_NULL);
|
|
break;
|
}
|
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XWaitSimCardReady
|
* Parent State : MT571XInit
|
* Description : µÈ´ýSIM¿¨×¼±¸Íê³É
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XWaitSimCardReady, HIDO_FSM_STATE(MT571XInit), 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_MT571XDriverData *)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, MT571X_EVENT_DELAY);
|
break;
|
}
|
case HIDO_AT_EVENT_ERROR:
|
{
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1),
|
_pstFSM, MT571X_EVENT_DELAY);
|
break;
|
}
|
case HIDO_AT_EVENT_TIMEOUT:
|
{
|
if (HIDO_TRUE == bReady)
|
{
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XATCmdInit), HIDO_NULL);
|
}
|
else
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
|
break;
|
}
|
case MT571X_EVENT_DELAY:
|
{
|
if (HIDO_TRUE == bReady)
|
{
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XATCmdInit), HIDO_NULL);
|
}
|
else
|
{
|
// HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XIdle), HIDO_NULL);
|
if(u32RetryCnt < 10)
|
{
|
u32RetryCnt++;
|
HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+CPIN?\r\n");
|
}
|
else
|
{
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XIdle), HIDO_NULL);
|
}
|
}
|
break;
|
}
|
case MT571X_EVENT_CPIN:
|
{
|
bReady = HIDO_TRUE;
|
break;
|
}
|
case MT571X_EVENT_POLL:
|
{
|
if(Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
|
{
|
HIDO_FSMStateChange(HIDO_FSM(MT571X), HIDO_FSM_STATE(MT571XPowerOff), HIDO_NULL);
|
|
break;
|
}
|
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XATCmdInit
|
* Parent State : MT571XInit
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
#define _5G_SUOPIN
|
//#define _LOG_CAIJI
|
//#define _5G_USE_APN
|
HIDO_FSM_STATE_IMPLEMENT(MT571XATCmdInit, HIDO_FSM_STATE(MT571XInit), HIDO_NULL)
|
{
|
static HIDO_UINT32 l_u32CmdIndex = 0;
|
static HIDO_UINT32 l_u32RetryCnt = 0;
|
|
const ST_ATCmd astInitCmdList[] =
|
{
|
{ "AT^ICCID?\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
|
{ "ATI\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
|
{ "AT^TTSCFG=\"appid\",\"1ae37467\"\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
|
{ "AT^TTSCFG=\"enable\",1\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
|
{ "AT^TTSCFG=\"volume\",9\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
|
{ "AT^TTSCFG=\"rate\",1\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK },
|
};
|
//#define APN_ARGS &g_com_map[APN_START], &g_com_map[APN_USER_START], &g_com_map[APN_PWD_START]
|
|
HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;
|
HIDO_UINT32 u32FSMTimerID = ((ST_MT571XDriverData *) 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, APN_ARGS);
|
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(MT571XReady), HIDO_NULL);
|
}
|
else
|
{
|
// HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd, APN_ARGS);
|
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(MT571XReady), HIDO_NULL);
|
}
|
else
|
{
|
//HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd, APN_ARGS);
|
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(MT571XPowerOn), HIDO_NULL);
|
}
|
else
|
{
|
/* ²»ÊÇÆÚ´ýµÄ½á¹û£¬10ºóÔٴγ¢ÊÔ */
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10), _pstFSM,
|
MT571X_EVENT_DELAY);
|
}
|
}
|
|
break;
|
}
|
case MT571X_EVENT_DELAY:
|
{
|
// HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd, APN_ARGS);
|
HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
|
break;
|
}
|
case MT571X_EVENT_NUM_0:
|
case MT571X_EVENT_NUM_1:
|
case MT571X_EVENT_NUM_2:
|
case MT571X_EVENT_NUM_3:
|
case MT571X_EVENT_NUM_4:
|
case MT571X_EVENT_NUM_5:
|
case MT571X_EVENT_NUM_6:
|
case MT571X_EVENT_NUM_7:
|
case MT571X_EVENT_NUM_8:
|
case MT571X_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 MT571X_EVENT_CCID:
|
{
|
HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;
|
HIDO_DataStruct stCCID;
|
|
if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "^ICCID: %p\r\n",
|
&stCCID) != 1)
|
{
|
break;
|
}
|
|
Module_SetCCID((HIDO_CHAR *)stCCID.m_pData, stCCID.m_u32Len);
|
break;
|
}
|
case MT571X_EVENT_POLL:
|
{
|
if(Module_NeedPowerOff(MODULE_MAIN) == HIDO_TRUE)
|
{
|
HIDO_FSMStateChange(HIDO_FSM(MT571X), HIDO_FSM_STATE(MT571XPowerOff), HIDO_NULL);
|
|
break;
|
}
|
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XIdle
|
* Parent State : MT571X
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XIdle, HIDO_FSM_STATE(MT571X), HIDO_NULL)
|
{
|
HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;
|
|
switch (_u32Event)
|
{
|
case HIDO_EVENT_ENTRY:
|
{
|
break;
|
}
|
case HIDO_EVENT_EXIT:
|
{
|
break;
|
}
|
case MT571X_EVENT_POLL:
|
{
|
MT571X_Poll(pstATDevice);
|
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XReady
|
* Parent State : MT571X
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XReady, HIDO_FSM_STATE(MT571X), HIDO_FSM_STATE(MT571XSearchingNetwork))
|
{
|
switch (_u32Event)
|
{
|
case HIDO_EVENT_ENTRY:
|
{
|
break;
|
}
|
case HIDO_EVENT_EXIT:
|
{
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XSearchingNetwork
|
* Parent State : MT571X
|
* Description : ²éÕÒÍøÂç
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XSearchingNetwork, HIDO_FSM_STATE(MT571XReady), HIDO_NULL)
|
{
|
static HIDO_BOOL l_bIsReady = HIDO_FALSE;
|
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_MT571XDriverData *) pstATDevice->m_pUserData)->m_u32FSMTimerID;
|
|
switch (_u32Event)
|
{
|
case HIDO_EVENT_ENTRY:
|
{
|
l_u32Cnt = 0;
|
l_bIsReady = HIDO_FALSE;
|
l_bATBusy = HIDO_TRUE;
|
HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+C5GREG?\r\n");
|
break;
|
}
|
case HIDO_EVENT_EXIT:
|
{
|
HIDO_ATLiteCmdSendOver(pstATDevice);
|
HIDO_TimerCancel(u32FSMTimerID);
|
break;
|
}
|
case HIDO_AT_EVENT_OK:
|
{
|
l_bATBusy = HIDO_FALSE;
|
|
if(HIDO_TRUE == l_bIsReady)
|
{
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XIPInit), HIDO_NULL);
|
}
|
else
|
{
|
l_u32Cnt++;
|
if(l_u32Cnt < 100)
|
{
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(1), _pstFSM, MT571X_EVENT_DELAY);
|
}
|
else
|
{
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571X), HIDO_NULL);
|
}
|
}
|
|
break;
|
}
|
case MT571X_EVENT_DELAY:
|
l_bIsReady = HIDO_FALSE;
|
l_bATBusy = HIDO_TRUE;
|
HIDO_ATLiteCmdSend(pstATDevice, AT_GENERAL_TIMEOUT_TIME, "AT+C5GREG?\r\n");
|
break;
|
case MT571X_EVENT_C5GREG:
|
{
|
HIDO_DataStruct *pstData = (HIDO_DataStruct *) _pArg;
|
HIDO_INT32 i32State;
|
|
if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "+C5GREG: %*,%d,%*\r\n",
|
&i32State) == 3)
|
{
|
|
}else if (HIDO_UtilParseFormat((HIDO_UINT8 *) pstData->m_pData, pstData->m_u32Len, "+C5GREG: %*,%d\r\n",
|
&i32State) == 2)
|
{
|
}else{
|
break;
|
}
|
switch (i32State)
|
{
|
case 1:
|
case 5:
|
l_bIsReady = HIDO_TRUE;
|
break;
|
|
default:
|
break;
|
}
|
|
break;
|
}
|
case MT571X_EVENT_POLL:
|
{
|
if (HIDO_FALSE == l_bATBusy)
|
{
|
MT571X_Poll(pstATDevice);
|
}
|
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XIPInit
|
* Parent State : MT571X
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XIPInit, HIDO_FSM_STATE(MT571XReady), HIDO_NULL)
|
{
|
static HIDO_UINT32 l_u32CmdIndex = 0;
|
static HIDO_UINT32 l_u32RetryCnt = 0;
|
|
HIDO_CHAR *pcIMSI = HIDO_NULL;
|
HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;
|
HIDO_UINT32 u32FSMTimerID = ((ST_MT571XDriverData *) pstATDevice->m_pUserData)->m_u32FSMTimerID;
|
|
const ST_ATCmd astInitCmdList[] =
|
{
|
//{ "AT^NDISDUP=7,0\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK | AT_CMD_RESULT_ERROR | AT_CMD_RESULT_TIMEOUT },
|
{ "AT^NDISDUP=7,1\r\n", AT_GENERAL_TIMEOUT_TIME, AT_CMD_RESULT_OK | AT_CMD_RESULT_ERROR | AT_CMD_RESULT_TIMEOUT },
|
};
|
|
switch (_u32Event)
|
{
|
case HIDO_EVENT_ENTRY:
|
{
|
l_u32CmdIndex = 0;
|
l_u32RetryCnt = 0;
|
if(0 == l_u32CmdIndex)
|
{
|
// HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd,
|
// &g_com_map[APN_START], &g_com_map[APN_USER_START], &g_com_map[APN_PWD_START]);
|
HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
|
}
|
else
|
{
|
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(MT571XIPReady), HIDO_NULL);
|
}
|
else
|
{
|
if(0 == l_u32CmdIndex)
|
{
|
// HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd,
|
// &g_com_map[APN_START], &g_com_map[APN_USER_START], &g_com_map[APN_PWD_START]);
|
HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
|
}
|
else
|
{
|
HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
|
}
|
}
|
|
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(MT571XIPReady), HIDO_NULL);
|
}
|
else
|
{
|
if(0 == l_u32CmdIndex)
|
{
|
// HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd,
|
// &g_com_map[APN_START], &g_com_map[APN_USER_START], &g_com_map[APN_PWD_START]);
|
HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
|
}
|
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(MT571X), HIDO_NULL);
|
}
|
else
|
{
|
/* ²»ÊÇÆÚ´ýµÄ½á¹û£¬10ºóÔٴγ¢ÊÔ */
|
HIDO_FSMStartTimer(u32FSMTimerID, HIDO_TIMER_TYPE_ONCE, HIDO_TIMER_TICK_S(10), _pstFSM,
|
MT571X_EVENT_DELAY);
|
}
|
}
|
|
break;
|
}
|
case MT571X_EVENT_DELAY:
|
{
|
if(0 == l_u32CmdIndex)
|
{
|
// HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd,
|
// &g_com_map[APN_START], &g_com_map[APN_USER_START], &g_com_map[APN_PWD_START]);
|
HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
|
}
|
else
|
{
|
HIDO_ATLiteCmdSend(pstATDevice, astInitCmdList[l_u32CmdIndex].m_u32TimeOut, astInitCmdList[l_u32CmdIndex].m_pcATCmd);
|
}
|
break;
|
}
|
case MT571X_EVENT_POLL:
|
{
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XIPReady
|
* Parent State : MT571X
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XIPReady, HIDO_FSM_STATE(MT571XReady), HIDO_FSM_STATE(MT571XIPPoll))
|
{
|
switch (_u32Event)
|
{
|
case HIDO_EVENT_ENTRY:
|
{
|
break;
|
}
|
case HIDO_EVENT_EXIT:
|
{
|
Socket_ClosedAll();
|
break;
|
}
|
case MT571X_EVENT_POLL:
|
{
|
break;
|
}
|
case HIDO_AT_EVENT_TIMEOUT:
|
{
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XInit), HIDO_NULL);
|
break;
|
}
|
case MT571X_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 MT571X_EVENT_PDPDEACT:
|
{
|
l_bDeact = HIDO_TRUE;
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XIPPoll
|
* Parent State : MT571XIPReady
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XIPPoll, HIDO_FSM_STATE(MT571XIPReady), HIDO_NULL)
|
{
|
HIDO_ATLiteDeviceStruct *pstATDevice = (HIDO_ATLiteDeviceStruct *) _pstFSM->m_pPrivateData;
|
|
switch (_u32Event)
|
{
|
case HIDO_EVENT_ENTRY:
|
{
|
break;
|
}
|
case HIDO_EVENT_EXIT:
|
{
|
break;
|
}
|
case MT571X_EVENT_POLL:
|
{
|
if (HIDO_TRUE == l_bDeact)
|
{
|
l_bDeact = HIDO_FALSE;
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XReady), HIDO_NULL);
|
break;
|
}
|
|
if(MT571X_PollOnIPReady(pstATDevice) == HIDO_OK)
|
{
|
break;
|
}
|
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : MT571XIPCheck
|
* Parent State : MT571XIPReady
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_STATE_IMPLEMENT(MT571XIPCheck, HIDO_FSM_STATE(MT571XIPReady), 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(MT571XIPPoll), HIDO_NULL);
|
}
|
else
|
{
|
HIDO_FSMStateChange(_pstFSM, HIDO_FSM_STATE(MT571XReady), HIDO_NULL);
|
}
|
|
break;
|
}
|
case MT571X_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 : MT571XRunATCmd
|
* Parent State : MT571XReady
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_DETACHED_STATE_IMPLEMENT(MT571XRunATCmd, 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 : MT571XRunATCmd
|
* Parent State : MT571XReady
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_DETACHED_STATE_IMPLEMENT(MT571XCloseWireless, 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(MT571XIdle), HIDO_NULL);
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* State Name : OpenWireless
|
* Parent State : MT571XReady
|
* Description :
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_FSM_DETACHED_STATE_IMPLEMENT(MT571XOpenWireless, 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(MT571XReady), HIDO_NULL);
|
break;
|
}
|
default:
|
{
|
return HIDO_EVENT_NO_PROC;
|
}
|
}
|
|
return HIDO_EVENT_OK;
|
}
|
|
/*******************************************************************************
|
* Function Name : MT571X_PowerPoll
|
* Description : µçÔ´´¦ÀíʼþµÄÂÖѯ
|
* Input : _pstATDevice ATÉ豸ÃèÊö
|
* Output : None
|
* Return : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
|
* Author : hido.ltd
|
*******************************************************************************/
|
static HIDO_INT32 MT571X_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(MT571X), HIDO_FSM_STATE(MT571XPowerOff), HIDO_NULL);
|
return HIDO_OK;
|
}
|
|
return HIDO_ERR;
|
}
|
|
/*******************************************************************************
|
* Function Name : MT571X_RunATCmdPoll
|
* Description : ÔËÐÐÓû§ATÃüÁî´¦ÀíÂÖѯ
|
* Input : _pstATDevice ATÉ豸ÃèÊö
|
* Output : None
|
* Return : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
|
* Author : hido.ltd
|
*******************************************************************************/
|
static HIDO_INT32 MT571X_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(MT571XRunATCmd, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
|
HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(MT571XRunATCmd), HIDO_NULL);
|
|
return HIDO_OK;
|
}
|
|
return HIDO_ERR;
|
}
|
|
/*******************************************************************************
|
* Function Name : MT571X_CloseWirelessPoll
|
* Description : ¹Ø±ÕÎÞÏßÊý¾ÝÂÖѯ
|
* Input : _pstATDevice ATÉ豸ÃèÊö
|
* Output : None
|
* Return : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
|
* Author : hido.ltd
|
*******************************************************************************/
|
static HIDO_INT32 MT571X_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(MT571XCloseWireless, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
|
HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(MT571XCloseWireless), HIDO_NULL);
|
|
return HIDO_OK;
|
}
|
|
return HIDO_ERR;
|
}
|
|
/*******************************************************************************
|
* Function Name : MT571X_OpenWirelessPoll
|
* Description : ´ò¿ªÎÞÏßÊý¾ÝÂÖѯ
|
* Input : _pstATDevice ATÉ豸ÃèÊö
|
* Output : None
|
* Return : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
|
* Author : hido.ltd
|
*******************************************************************************/
|
static HIDO_INT32 MT571X_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(MT571XOpenWireless, _pstATDevice->m_pstFSM->m_pstCurrentState->m_pstParent, HIDO_NULL);
|
HIDO_FSMStateChange(_pstATDevice->m_pstFSM, HIDO_FSM_STATE(MT571XOpenWireless), HIDO_NULL);
|
|
return HIDO_OK;
|
}
|
|
return HIDO_ERR;
|
}
|
|
/*******************************************************************************
|
* Function Name : MT571X_Poll
|
* Description : ÔÚ·ÇIPReady״̬ʱµÄÂÖѯ´¦Àí
|
* Input : _pstATDevice ATÉ豸ÃèÊö
|
* Output : None
|
* Return : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
|
* Author : hido.ltd
|
*******************************************************************************/
|
static HIDO_INT32 MT571X_Poll(HIDO_ATLiteDeviceStruct *_pstATDevice)
|
{
|
/* Power */
|
if(MT571X_PowerPoll(_pstATDevice) == HIDO_OK)
|
{
|
return HIDO_OK;
|
}
|
|
/* CSQ */
|
if (MT571XCSQ_Poll(_pstATDevice) == HIDO_OK)
|
{
|
return HIDO_OK;
|
}
|
|
/* TEMP */
|
// if (MT571XTEMP_Poll(_pstATDevice) == HIDO_OK)
|
// {
|
// return HIDO_OK;
|
// }
|
|
/* Audio */
|
// if (MT571XAudio_Poll(_pstATDevice) == HIDO_OK)
|
// {
|
// return HIDO_OK;
|
// }
|
|
/* RunATCmd */
|
if (MT571X_RunATCmdPoll(_pstATDevice) == HIDO_OK)
|
{
|
return HIDO_OK;
|
}
|
|
/* GSM */
|
if (MT571X_CloseWirelessPoll(_pstATDevice) == HIDO_OK)
|
{
|
return HIDO_OK;
|
}
|
|
if (MT571X_OpenWirelessPoll(_pstATDevice) == HIDO_OK)
|
{
|
return HIDO_OK;
|
}
|
|
return HIDO_ERR;
|
}
|
|
/*******************************************************************************
|
* Function Name : MT571X_PollOnIPReady
|
* Description : ÔÚIPReady״̬ʱµÄÂÖѯ´¦Àí
|
* Input : _pstATDevice ATÉ豸ÃèÊö
|
* Output : None
|
* Return : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
|
* Author : hido.ltd
|
*******************************************************************************/
|
static HIDO_INT32 MT571X_PollOnIPReady(HIDO_ATLiteDeviceStruct *_pstATDevice)
|
{
|
HIDO_UINT32 u32CurTick = HIDO_TimerGetTick();
|
|
/* Power */
|
if (MT571X_PowerPoll(_pstATDevice) == HIDO_OK)
|
{
|
return HIDO_OK;
|
}
|
|
/* Audio */
|
// if (MT571XAudio_Poll(_pstATDevice) == HIDO_OK)
|
// {
|
// return HIDO_OK;
|
// }
|
|
/* Socket */
|
if (MT571XSocket_Poll(_pstATDevice) == HIDO_OK)
|
{
|
return HIDO_OK;
|
}
|
|
// /* CSQ */
|
// if (MT571XCSQ_Poll(_pstATDevice) == HIDO_OK)
|
// {
|
// return HIDO_OK;
|
// }
|
|
/* TEMP */
|
// if (MT571XTEMP_Poll(_pstATDevice) == HIDO_OK)
|
// {
|
// return HIDO_OK;
|
// }
|
|
// if ((u32CurTick - l_u32IPCheckTick) > HIDO_TIMER_TICK_S(10))
|
// {
|
// l_u32IPCheckTick = u32CurTick;
|
// HIDO_FSMStateChange(HIDO_FSM(MT571X), HIDO_FSM_STATE(MT571XIPCheck), HIDO_NULL);
|
// return HIDO_OK;
|
// }
|
|
/* RunATCmd */
|
if (MT571X_RunATCmdPoll(_pstATDevice) == HIDO_OK)
|
{
|
return HIDO_OK;
|
}
|
|
// /* GSM */
|
// if (MT571X_CloseWirelessPoll(_pstATDevice) == HIDO_OK)
|
// {
|
// return HIDO_OK;
|
// }
|
|
// if (MT571X_OpenWirelessPoll(_pstATDevice) == HIDO_OK)
|
// {
|
// return HIDO_OK;
|
// }
|
|
return HIDO_ERR;
|
}
|
|
/*******************************************************************************
|
* Function Name : MT571X_IsIPReady
|
* Description : ÅжÏ״̬»úÊÇ·ñ´¦ÔÚMT571XIPReady״̬
|
* Input : None
|
* Output : None
|
* Return : HIDO_TRUE ÊÇ, HIDO_FALSE ·ñ
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_BOOL MT571X_IsIPReady(void)
|
{
|
const HIDO_StateStruct *pstTmpState = HIDO_FSM(MT571X)->m_pstCurrentState;
|
|
while(pstTmpState != HIDO_NULL)
|
{
|
if(pstTmpState == HIDO_FSM_STATE(MT571XIPReady))
|
{
|
return HIDO_TRUE;
|
}
|
|
pstTmpState = pstTmpState->m_pstParent;
|
}
|
|
return HIDO_FALSE;
|
}
|
|
/*******************************************************************************
|
* Function Name : MT571X_IsIPIdle
|
* Description : ÅжÏ״̬»úÊÇ·ñ´¦ÔÚMT571XIPPoll״̬
|
* Input : None
|
* Output : None
|
* Return : HIDO_TRUE ÊÇ, HIDO_FALSE ·ñ
|
* Author : hido.ltd
|
*******************************************************************************/
|
HIDO_BOOL MT571X_IsIPIdle(void)
|
{
|
const HIDO_StateStruct *pstTmpState = HIDO_FSM(MT571X)->m_pstCurrentState;
|
|
if(pstTmpState == HIDO_FSM_STATE(MT571XIPPoll))
|
{
|
return HIDO_TRUE;
|
}
|
|
return HIDO_FALSE;
|
}
|
