/*******************************************************************************
|
* File Name : MQTTClient.c
|
* Description :
|
*******************************************************************************/
|
|
/*******************************************************************************
|
* Include Files *
|
*******************************************************************************/
|
#include "MQTTClient.h"
|
#include "string.h"
|
#include "DBG.h"
|
#include "HIDO_Timer.h"
|
#include "HIDO_Debug.h"
|
#include "HIDO_Util.h"
|
#include "HIDO_Json.h"
|
#include "HIDO_VLQueue.h"
|
#include "Socket.h"
|
#include "Module.h"
|
#include "HIDO_Log.h"
|
#include "stdlib.h"
|
//#include "Param.h"
|
#include "MsgPack.h"
|
#include "Internet.h"
|
#include "HIDO_Base64.h"
|
#include "MQTT.h"
|
#include "AppConfig.h"
|
#include "global_param.h"
|
#include "MQTTApp.h"
|
|
/*******************************************************************************
|
* Macro *
|
*******************************************************************************/
|
#define INVALID_SN 0xFFFFFFFF
|
#define MQTT_CLIENT_QUEUE_BUF_SIZE (1024 * 2)
|
#define MQTT_CLIENT_QUEUE_MEMBER_CNT 16
|
|
/*******************************************************************************
|
* Type Definition *
|
*******************************************************************************/
|
|
typedef enum
|
{
|
REPORT_STATE_IDLE,
|
REPORT_STATE_BUSY,
|
}E_ReportState;
|
|
typedef enum
|
{
|
RECV_STATE_LEN,
|
RECV_STATE_BODY,
|
}E_RecvState;
|
|
typedef enum
|
{
|
CONNECT_STATE_IDEL = 0,
|
CONNECT_STATE_CONNECT_WAIT,
|
CONNECT_STATE_CONNECTING,
|
CONNECT_STATE_CLOSED,
|
CONNECT_STATE_CONNECTED,
|
CONNECT_STATE_DISCONNECT_WAIT,
|
CONNECT_STATE_DISCONNECTING,
|
}E_ConnectState;
|
|
typedef struct
|
{
|
HIDO_CHAR m_acHost[64];
|
HIDO_UINT16 m_u16Port;
|
HIDO_UINT32 m_u32KeepAlive;
|
HIDO_CHAR m_acClientID[64];
|
HIDO_CHAR m_acUsername[64];
|
HIDO_CHAR m_acPassword[64];
|
HIDO_CHAR m_acGpsTopic[128];
|
HIDO_CHAR m_acStatusTopic[128];
|
HIDO_CHAR m_acControlTopic[128];
|
HIDO_CHAR m_acPathTopic[128];
|
HIDO_CHAR m_acBaseStationTopic[128];
|
HIDO_CHAR m_acResponseTopic[128];
|
}ST_MQTTClientParam;
|
|
/*******************************************************************************
|
* Local Variable *
|
*******************************************************************************/
|
static ST_MsgPackage l_stSendPackage;
|
static E_ConnectState l_eConectState = CONNECT_STATE_IDEL;
|
static HIDO_INT32 l_i32MQTTClientID = 0;
|
static ST_MQTTConfig l_stMQTTConfig;
|
|
static ST_MQTTClientParam l_stConnectParam;
|
static HIDO_UINT32 l_u32MQTTConnectTick = 0;
|
static HIDO_BOOL l_bMQTTDebugFlag = HIDO_FALSE;
|
|
FN_MQTTClientEventCallback l_fnMQTTClientEventCallback;
|
HIDO_VOID *l_pMQTTClientEventArg = HIDO_NULL;
|
|
static HIDO_UINT8 l_au8SendBuff[512];
|
|
static HIDO_UINT8 l_au8RecvBuf[1500];
|
static HIDO_CHAR l_acRecvTopic[64];
|
static ST_CtrlData l_stCtrlData;
|
|
/* �ڴ���� */
|
static HIDO_VLQStruct l_stMQTTClientQueue;
|
static HIDO_UINT8 l_au8MQTTSendQueueBuf[MQTT_CLIENT_QUEUE_BUF_SIZE];
|
|
/*******************************************************************************
|
* Local Function Declaration *
|
*******************************************************************************/
|
static HIDO_INT32 MQTTClient_EventNotify(E_MQTTClientEvent _eEvent);
|
static HIDO_INT32 MQTTClient_RequestParam(HIDO_VOID);
|
|
/*******************************************************************************
|
* Local Function *
|
*******************************************************************************/
|
/*******************************************************************************
|
* Function Name : MQTTClient_GetConnectStateName
|
* Description :
|
* Input : None
|
* Output : None
|
* Return : HIDO_OK �ɹ�
|
* HIDO_ERR ʧ��
|
*******************************************************************************/
|
HIDO_CHAR *MQTTClient_GetConnectStateName(E_ConnectState _eConectState)
|
{
|
switch (_eConectState)
|
{
|
case CONNECT_STATE_IDEL:
|
{
|
return "IDEL";
|
}
|
case CONNECT_STATE_CONNECT_WAIT:
|
{
|
return "CONNECT_WAIT";
|
}
|
case CONNECT_STATE_CONNECTING:
|
{
|
return "CONNECTING";
|
}
|
case CONNECT_STATE_CLOSED:
|
{
|
return "CLOSED";
|
}
|
case CONNECT_STATE_CONNECTED:
|
{
|
return "CONNECTED";
|
}
|
case CONNECT_STATE_DISCONNECT_WAIT:
|
{
|
return "DISCONNECT_WAIT";
|
}
|
case CONNECT_STATE_DISCONNECTING:
|
{
|
return "DISCONNECTING";
|
}
|
default:
|
{
|
return "ERR";
|
}
|
}
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_SetConnectState
|
* Description : ��������״̬
|
* Input : _eConnectState ����״̬
|
* Output : None
|
* Return : HIDO_OK �ɹ�
|
* HIDO_ERR ʧ��
|
*******************************************************************************/
|
static HIDO_INT32 MQTTClient_SetConnectState(E_ConnectState _eConnectState)
|
{
|
E_ConnectState eOldConnectState = l_eConectState;
|
|
l_eConectState = _eConnectState;
|
HIDO_Log(HIDO_LOG_LEVEL_DEBUG, "l_eConectState = %s -> %s\r\n", MQTTClient_GetConnectStateName(eOldConnectState),
|
MQTTClient_GetConnectStateName(l_eConectState));
|
HIDO_DebugEx("l_eConectState = %s -> %s\r\n", MQTTClient_GetConnectStateName(eOldConnectState),
|
MQTTClient_GetConnectStateName(l_eConectState));
|
|
return HIDO_OK;
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_ReportGps
|
* Description :
|
* Input : _pstPackage ���ݰ�
|
* Output : None
|
* Return : HIDO_OK �ɹ�
|
* HIDO_ERR ʧ��
|
*******************************************************************************/
|
static HIDO_INT32 MQTTClient_ReportGps(ST_MsgPackage *_pstPackage)
|
{
|
if(MQTT_Publish(l_i32MQTTClientID, l_stConnectParam.m_acGpsTopic, _pstPackage->m_au8Data, _pstPackage->m_u32Len, 1) == HIDO_OK)
|
{
|
if (l_bMQTTDebugFlag == HIDO_TRUE)
|
{
|
if(_pstPackage->m_u32Len < sizeof(_pstPackage->m_au8Data))
|
{
|
_pstPackage->m_au8Data[_pstPackage->m_u32Len] = '\0';
|
HIDO_DebugEx("[S] %s\r\n", (HIDO_CHAR *)_pstPackage->m_au8Data);
|
}
|
}
|
|
return HIDO_OK;
|
}
|
else
|
{
|
return HIDO_ERR;
|
}
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_ReportStatus
|
* Description : ���ݰ�����
|
* Input : _pstPackage ���ݰ�
|
* Output : None
|
* Return : HIDO_OK �ɹ�
|
* HIDO_ERR ʧ��
|
*******************************************************************************/
|
static HIDO_INT32 MQTTClient_ReportStatus(ST_MsgPackage *_pstPackage)
|
{
|
if(MQTT_Publish(l_i32MQTTClientID, l_stConnectParam.m_acStatusTopic, _pstPackage->m_au8Data, _pstPackage->m_u32Len, 1) == HIDO_OK)
|
{
|
if (l_bMQTTDebugFlag == HIDO_TRUE)
|
{
|
if(_pstPackage->m_u32Len < sizeof(_pstPackage->m_au8Data))
|
{
|
_pstPackage->m_au8Data[_pstPackage->m_u32Len] = '\0';
|
HIDO_DebugEx("[S] %s\r\n", (HIDO_CHAR *)_pstPackage->m_au8Data);
|
}
|
}
|
|
return HIDO_OK;
|
}
|
else
|
{
|
return HIDO_ERR;
|
}
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_ReportResponse
|
* Description : ���ݰ�����
|
* Input : _pstPackage ���ݰ�
|
* Output : None
|
* Return : HIDO_OK �ɹ�
|
* HIDO_ERR ʧ��
|
*******************************************************************************/
|
static HIDO_INT32 MQTTClient_ReportResponse(ST_MsgPackage *_pstPackage)
|
{
|
if(MQTT_Publish(l_i32MQTTClientID, l_stConnectParam.m_acResponseTopic, _pstPackage->m_au8Data, _pstPackage->m_u32Len, 1) == HIDO_OK)
|
{
|
if (l_bMQTTDebugFlag == HIDO_TRUE)
|
{
|
if(_pstPackage->m_u32Len < sizeof(_pstPackage->m_au8Data))
|
{
|
_pstPackage->m_au8Data[_pstPackage->m_u32Len] = '\0';
|
HIDO_DebugEx("[S] %s\r\n", (HIDO_CHAR *)_pstPackage->m_au8Data);
|
}
|
}
|
|
return HIDO_OK;
|
}
|
else
|
{
|
return HIDO_ERR;
|
}
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_MsgProc
|
* Description :
|
* Input : _pstPackage ���ݰ�
|
* Output : None
|
* Return : HIDO_OK �ɹ�
|
* HIDO_ERR ʧ��
|
*******************************************************************************/
|
static HIDO_INT32 MQTTClient_MsgProc(HIDO_CHAR *_pstTopic, ST_CtrlData *_pstCtrlData)
|
{
|
HIDO_CHAR *pcRequestID = HIDO_NULL;
|
HIDO_BOOL bSaveFence = HIDO_FALSE;
|
|
//TODO MsgPack_Parse
|
|
|
return HIDO_OK;
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_MQTTEventProc
|
* Description : ���ӷ�����
|
* Input : None
|
* Output : None
|
* Return : None
|
*******************************************************************************/
|
static HIDO_VOID MQTTClient_MQTTEventProc(HIDO_INT32 _i32ClientID, E_MQTTEvent _eEvent, HIDO_VOID *_pArg)
|
{
|
HIDO_Log(HIDO_LOG_LEVEL_DEBUG, "_i32ClientID=%d _eEvent=%u @%s\r\n", _i32ClientID, _eEvent, __FUNCTION__);
|
|
switch (_eEvent)
|
{
|
case MQTT_EVENT_CONNECT_FAILED:
|
{
|
HIDO_Log(HIDO_LOG_LEVEL_WARN, "server connect failed\r\n");
|
|
if(CONNECT_STATE_CONNECTING == l_eConectState)
|
{
|
l_u32MQTTConnectTick = HIDO_TimerGetTick();
|
MQTTClient_SetConnectState(CONNECT_STATE_CLOSED);
|
}
|
|
break;
|
}
|
case MQTT_EVENT_CONNECTED:
|
{
|
HIDO_Log(HIDO_LOG_LEVEL_INFO, "server connect success\r\n");
|
|
if (CONNECT_STATE_CONNECTING == l_eConectState)
|
{
|
MQTTClient_SetConnectState(CONNECT_STATE_CONNECTED);
|
MQTTClient_EventNotify(MQTT_CLIENT_EVENT_CONNECT);
|
}
|
break;
|
}
|
case MQTT_EVENT_CLOSED:
|
{
|
if(CONNECT_STATE_DISCONNECTING == l_eConectState)
|
{
|
MQTTClient_SetConnectState(CONNECT_STATE_IDEL);
|
MQTTClient_EventNotify(MQTT_CLIENT_EVENT_DISCONNECT);
|
}
|
else if(l_eConectState != CONNECT_STATE_IDEL)
|
{
|
HIDO_Log(HIDO_LOG_LEVEL_WARN, "socket closed by server\r\n");
|
|
l_u32MQTTConnectTick = HIDO_TimerGetTick();
|
MQTTClient_SetConnectState(CONNECT_STATE_CLOSED);
|
}
|
|
break;
|
}
|
case MQTT_EVENT_DATA_PUBLISHED:
|
{
|
break;
|
}
|
case MQTT_EVENT_RECV_DATA:
|
{
|
HIDO_UINT32 u32RecvLen = 0;
|
|
while (MQTT_Recv(l_i32MQTTClientID, l_acRecvTopic, l_au8RecvBuf, sizeof(l_au8RecvBuf), &u32RecvLen) == HIDO_OK)
|
{
|
// 调用MQTTApp层解析消息
|
MQTTApp_ParseMessage(l_acRecvTopic, l_au8RecvBuf, u32RecvLen);
|
}
|
break;
|
}
|
default:
|
{
|
break;
|
}
|
}
|
}
|
|
/*******************************************************************************
|
* Global Function *
|
*******************************************************************************/
|
/*******************************************************************************
|
* Function Name : MQTTClient_IsNetWorkReady
|
* Description : ��������Ƿ�����
|
* Input : None
|
* Output : None
|
* Return : None
|
*******************************************************************************/
|
HIDO_BOOL MQTTClient_IsNetWorkReady(void)
|
{
|
if (Internet_IsIPReady() == HIDO_TRUE)
|
{
|
return HIDO_TRUE;
|
}
|
|
return HIDO_FALSE;
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_IsConnected
|
* Description : ����Ƿ�Ҳ��������������
|
* Input : None
|
* Output : None
|
* Return : HIDO_TRUE ��
|
* HIDO_FALSE ��
|
*******************************************************************************/
|
HIDO_BOOL MQTTClient_IsConnected(void)
|
{
|
return(HIDO_BOOL)(CONNECT_STATE_CONNECTED == l_eConectState);
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_ConnectPoll
|
* Description : ������ѯ
|
* Input : None
|
* Output : None
|
* Return : None
|
*******************************************************************************/
|
void MQTTClient_ConnectPoll(void)
|
{
|
HIDO_UINT32 u32CurTick = HIDO_TimerGetTick();
|
|
switch(l_eConectState)
|
{
|
/* ��ʼ���� */
|
case CONNECT_STATE_CONNECT_WAIT:
|
{
|
if(MQTTClient_IsNetWorkReady() == HIDO_FALSE)
|
{
|
break;
|
}
|
|
HIDO_DebugEx("Connect Server\r\n");
|
|
MQTT_Connect(l_i32MQTTClientID);
|
MQTTClient_SetConnectState(CONNECT_STATE_CONNECTING);
|
l_u32MQTTConnectTick = u32CurTick;
|
break;
|
}
|
/* δ���ӻ�����ʧ�� */
|
case CONNECT_STATE_CLOSED:
|
{
|
if(MQTTClient_IsNetWorkReady() == HIDO_FALSE)
|
{
|
break;
|
}
|
|
/* �������ʱ�䵽 */
|
if ((u32CurTick - l_u32MQTTConnectTick) >= HIDO_TIMER_TICK_S(5))
|
{
|
HIDO_DebugEx("Reconnect Server\r\n");
|
|
MQTT_Connect(l_i32MQTTClientID);
|
MQTTClient_SetConnectState(CONNECT_STATE_CONNECTING);
|
l_u32MQTTConnectTick = u32CurTick;
|
}
|
|
break;
|
}
|
/* ������ */
|
case CONNECT_STATE_CONNECTED:
|
{
|
ST_MQTTMessage *pstMQTTMessage = HIDO_NULL;
|
HIDO_VLQMemberStruct *pstMember = HIDO_NULL;
|
|
|
/* �����ڴ���� */
|
while((pstMember = HIDO_VLQGetDequeueMember(&l_stMQTTClientQueue)) != HIDO_NULL)
|
{
|
pstMQTTMessage = (ST_MQTTMessage *)pstMember->m_pDataAddr;
|
|
if(MQTT_Publish(l_i32MQTTClientID, pstMQTTMessage->m_acTopic, pstMQTTMessage->m_au8Data, pstMQTTMessage->m_u32DataLen, pstMQTTMessage->m_u32QOS) == HIDO_OK)
|
{
|
if (l_bMQTTDebugFlag == HIDO_TRUE)
|
{
|
HIDO_DebugEx("[S]");
|
HIDO_DebugString((HIDO_CHAR *)pstMQTTMessage->m_au8Data, pstMQTTMessage->m_u32DataLen);
|
HIDO_DebugEx("\r\n");
|
}
|
|
HIDO_VLQDequeue(&l_stMQTTClientQueue, pstMember);
|
}
|
else
|
{
|
break;
|
}
|
}
|
|
break;
|
}
|
/* �ȴ��Ͽ� */
|
case CONNECT_STATE_DISCONNECT_WAIT:
|
{
|
MQTT_Close(l_i32MQTTClientID);
|
MQTTClient_SetConnectState(CONNECT_STATE_DISCONNECTING);
|
break;
|
}
|
default:
|
{
|
break;
|
}
|
}
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_Poll
|
* Description : TCP�ͻ�����ѯ�ӿ�
|
* Input : None
|
* Output : None
|
* Return : None
|
*******************************************************************************/
|
void MQTTClient_Poll(void)
|
{
|
MQTTClient_ConnectPoll();
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_DebugOn
|
* Description :
|
* Input : None
|
* Output : None
|
* Return : HIDO_OK �ɹ�
|
* HIDO_ERR ʧ��
|
*******************************************************************************/
|
void MQTTClient_DebugOn(void)
|
{
|
l_bMQTTDebugFlag = HIDO_TRUE;
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_DebugOff
|
* Description :
|
* Input : None
|
* Output : None
|
* Return : HIDO_OK �ɹ�
|
* HIDO_ERR ʧ��
|
*******************************************************************************/
|
void MQTTClient_DebugOff(void)
|
{
|
l_bMQTTDebugFlag = HIDO_FALSE;
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_GetConnectState
|
* Description :
|
* Input : None
|
* Output : None
|
* Return : HIDO_OK �ɹ�
|
* HIDO_ERR ʧ��
|
*******************************************************************************/
|
HIDO_CHAR *MQTTClient_GetConnectState(void)
|
{
|
return MQTTClient_GetConnectStateName(l_eConectState);
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_EventNotify
|
* Description : ������ѯ
|
* Input : None
|
* Output : None
|
* Return : None
|
*******************************************************************************/
|
static HIDO_INT32 MQTTClient_EventNotify(E_MQTTClientEvent _eEvent)
|
{
|
if (l_fnMQTTClientEventCallback != HIDO_NULL)
|
{
|
l_fnMQTTClientEventCallback(_eEvent, l_pMQTTClientEventArg);
|
}
|
|
return HIDO_OK;
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_SetEventCallback
|
* Description : ������ѯ
|
* Input : None
|
* Output : None
|
* Return : None
|
*******************************************************************************/
|
HIDO_INT32 MQTTClient_SetEventCallback(FN_MQTTClientEventCallback _fnEventCallback, HIDO_VOID *_pArg)
|
{
|
l_fnMQTTClientEventCallback = _fnEventCallback;
|
l_pMQTTClientEventArg = _pArg;
|
|
return HIDO_OK;
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_Connect
|
* Description : ��ʼ����
|
* Input : None
|
* Output : None
|
* Return : None
|
*******************************************************************************/
|
HIDO_INT32 MQTTClient_Connect(void)
|
{
|
switch (l_eConectState)
|
{
|
case CONNECT_STATE_IDEL:
|
case CONNECT_STATE_CLOSED:
|
case CONNECT_STATE_DISCONNECT_WAIT:
|
case CONNECT_STATE_DISCONNECTING:
|
{
|
MQTTClient_SetConnectState(CONNECT_STATE_CONNECT_WAIT);
|
break;
|
}
|
case CONNECT_STATE_CONNECTED:
|
{
|
MQTTClient_EventNotify(MQTT_CLIENT_EVENT_CONNECT);
|
break;
|
}
|
default:
|
{
|
break;
|
}
|
}
|
|
return HIDO_OK;
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_Disconnect
|
* Description : �Ͽ�����
|
* Input : None
|
* Output : None
|
* Return : None
|
*******************************************************************************/
|
HIDO_INT32 MQTTClient_Disconnect(void)
|
{
|
switch (l_eConectState)
|
{
|
case CONNECT_STATE_IDEL:
|
{
|
MQTTClient_EventNotify(MQTT_CLIENT_EVENT_DISCONNECT);
|
break;
|
}
|
case CONNECT_STATE_CONNECT_WAIT:
|
case CONNECT_STATE_CLOSED:
|
{
|
MQTTClient_SetConnectState(CONNECT_STATE_IDEL);
|
MQTTClient_EventNotify(MQTT_CLIENT_EVENT_DISCONNECT);
|
break;
|
}
|
case CONNECT_STATE_CONNECTING:
|
case CONNECT_STATE_CONNECTED:
|
{
|
MQTTClient_SetConnectState(CONNECT_STATE_DISCONNECT_WAIT);
|
break;
|
}
|
default:
|
{
|
break;
|
}
|
}
|
|
return HIDO_OK;
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_IsReportIdle
|
* Description :
|
* Input : None
|
* Output : None
|
* Return : HIDO_OK �ɹ�
|
* HIDO_ERR ʧ��
|
*******************************************************************************/
|
HIDO_BOOL MQTTClient_IsReportIdle(HIDO_VOID)
|
{
|
if(HIDO_VLQGetDequeueMember(&l_stMQTTClientQueue) != HIDO_NULL)
|
{
|
return HIDO_FALSE;
|
}
|
|
HIDO_VLQStruct *pstMQTTQueue = MQTT_GetSendQueue(l_i32MQTTClientID);
|
if(HIDO_VLQGetDequeueMember(pstMQTTQueue) != HIDO_NULL)
|
{
|
return HIDO_FALSE;
|
}
|
|
return HIDO_TRUE;
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_GpsReport
|
* Description :
|
* Input : None
|
* Output : None
|
* Return : None
|
*******************************************************************************/
|
HIDO_INT32 MQTTClient_GpsReport(ST_ReportGps *_pstReporGps)
|
{
|
if(l_eConectState == CONNECT_STATE_CONNECTED)
|
{
|
MsgPack_ReportGps(&l_stSendPackage, _pstReporGps);
|
MQTTClient_ReportGps(&l_stSendPackage);
|
}
|
|
#if 0
|
ST_MQTTMessage *pstMQTTMessage = HIDO_NULL;
|
HIDO_VLQMemberStruct *pstMember = HIDO_NULL;
|
|
pstMember = HIDO_VLQGetEnqueueMember(&l_stMQTTClientQueue, sizeof(ST_MQTTMessage) + l_stSendPackage.m_u32Len);
|
if(HIDO_NULL == pstMember)
|
{
|
return HIDO_ERR;
|
}
|
|
pstMQTTMessage = (ST_MQTTMessage *)pstMember->m_pDataAddr;
|
pstMQTTMessage->m_u32DataLen = l_stSendPackage.m_u32Len;
|
pstMQTTMessage->m_u32QOS = 1;
|
HIDO_UtilSnprintf(pstMQTTMessage->m_acTopic, sizeof(pstMQTTMessage->m_acTopic), l_stConnectParam.m_acGpsTopic);
|
memcpy(pstMQTTMessage->m_au8Data, l_stSendPackage.m_au8Data, l_stSendPackage.m_u32Len);
|
HIDO_VLQEnqueue(&l_stMQTTClientQueue, pstMember);
|
#endif
|
return HIDO_OK;
|
}
|
|
/*******************************************************************************
|
* Function Name : MQTTClient_Init
|
* Description : TCP�ͻ��˳�ʼ��
|
* Input : None
|
* Output : None
|
* Return : HIDO_OK �ɹ�
|
* HIDO_ERR ʧ��
|
*******************************************************************************/
|
HIDO_INT32 MQTTClient_Init(void)
|
{
|
MQTT_Create(&l_i32MQTTClientID, MQTTClient_MQTTEventProc, HIDO_NULL);
|
|
HIDO_UINT32 device_id = g_com_map[DEV_ID];
|
|
/* ��ʼ�����Ӳ��� */
|
HIDO_UtilSnprintf(l_stConnectParam.m_acHost, sizeof(l_stConnectParam.m_acHost), "%u.%u.%u.%u",
|
g_com_map[MQTT_IP_0], g_com_map[MQTT_IP_1], g_com_map[MQTT_IP_2], g_com_map[MQTT_IP_3]);
|
l_stConnectParam.m_u16Port = g_com_map[MQTT_PORT];
|
l_stConnectParam.m_u32KeepAlive = 60;
|
HIDO_UtilSnprintf(l_stConnectParam.m_acClientID, sizeof(l_stConnectParam.m_acClientID), "%u", device_id);
|
HIDO_UtilSnprintf(l_stConnectParam.m_acUsername, sizeof(l_stConnectParam.m_acUsername), "");
|
HIDO_UtilSnprintf(l_stConnectParam.m_acPassword, sizeof(l_stConnectParam.m_acPassword), "");
|
|
// topic
|
HIDO_UtilSnprintf(l_stConnectParam.m_acGpsTopic, sizeof(l_stConnectParam.m_acGpsTopic), "mower/%u/gps", device_id);
|
HIDO_UtilSnprintf(l_stConnectParam.m_acStatusTopic, sizeof(l_stConnectParam.m_acStatusTopic), "mower/%u/status", device_id);
|
HIDO_UtilSnprintf(l_stConnectParam.m_acControlTopic, sizeof(l_stConnectParam.m_acControlTopic), "app/p/mower/%u/control", device_id);
|
HIDO_UtilSnprintf(l_stConnectParam.m_acPathTopic, sizeof(l_stConnectParam.m_acPathTopic), "app/p/mower/%u/path", device_id);
|
HIDO_UtilSnprintf(l_stConnectParam.m_acBaseStationTopic, sizeof(l_stConnectParam.m_acBaseStationTopic), "app/p/mower/%u/basestation", device_id);
|
HIDO_UtilSnprintf(l_stConnectParam.m_acResponseTopic, sizeof(l_stConnectParam.m_acResponseTopic), "mower/%u/response", device_id);
|
|
HIDO_UtilSnprintf(l_stMQTTConfig.m_acClientID, sizeof(l_stMQTTConfig.m_acClientID), l_stConnectParam.m_acClientID);
|
HIDO_UtilSnprintf(l_stMQTTConfig.m_acUsername, sizeof(l_stMQTTConfig.m_acUsername), l_stConnectParam.m_acUsername);
|
HIDO_UtilSnprintf(l_stMQTTConfig.m_acPassword, sizeof(l_stMQTTConfig.m_acPassword), l_stConnectParam.m_acPassword);
|
HIDO_UtilSnprintf(l_stMQTTConfig.m_acRemoteAddr, sizeof(l_stMQTTConfig.m_acRemoteAddr), l_stConnectParam.m_acHost);
|
l_stMQTTConfig.m_u16RemotePort = l_stConnectParam.m_u16Port;
|
l_stMQTTConfig.m_u8Version = 3;
|
l_stMQTTConfig.m_u32KeepAlive = 60;
|
l_stMQTTConfig.m_u32PktTimeout = 15;
|
l_stMQTTConfig.m_u32RetryTimes = 3;
|
l_stMQTTConfig.m_u8CleanSession = 0;
|
l_stMQTTConfig.m_u8PdpCid = 1;
|
|
MQTT_Config(l_i32MQTTClientID, &l_stMQTTConfig);
|
MQTT_Subscribe(l_i32MQTTClientID, l_stConnectParam.m_acControlTopic, 1);
|
MQTT_Subscribe(l_i32MQTTClientID, l_stConnectParam.m_acPathTopic, 1);
|
MQTT_Subscribe(l_i32MQTTClientID, l_stConnectParam.m_acBaseStationTopic, 1);
|
|
/* ��ʼ��״̬ */
|
l_eConectState = CONNECT_STATE_IDEL;
|
|
/* ���г�ʼ�� */
|
HIDO_VLQInit(&l_stMQTTClientQueue, l_au8MQTTSendQueueBuf, MQTT_CLIENT_QUEUE_BUF_SIZE, MQTT_CLIENT_QUEUE_MEMBER_CNT);
|
|
MQTTClient_Connect();
|
|
return HIDO_OK;
|
}
|
