測試環境：stm32F401RCT6、RT-Thread版本: v4.1.0、RT-Thread Studio版本: 2.2.6、網絡硬件使用ec800m移植at_socket使用sal框架。

1、移植介紹
RyanMqtt 庫希望應用程序為以下接口提供實現：

system 接口
RyanMqtt 需要 RTOS 支持，必須實現如下接口才可以保證 mqtt 客戶端的正常運行

network 接口
RyanMqtt 依賴于底層傳輸接口 API，必須實現該接口 API 才能在網絡上發送和接收數據包

MQTT 協議要求基礎傳輸層能夠提供有序的、可靠的、雙向傳輸（從客戶端到服務端 和從服務端到客戶端）的字節流

time 接口
RyanMqtt 依靠函數生成毫秒時間戳，用于計算持續時間和超時，內部已經做了數值溢出處理

2、開始移植
得益于RT-Thread驅動應用層分離的思想和SAL框架，platform/rtthread的適配層可以適應任何RT-Thread代碼，所以我們就不拿RT-Thread來移植了。

使用FreeRTOS內核來移植，使用CMSIS-RTOS V2兼容層。

system 接口
系統接口，需要移植RTOS的接口。為方便管理類型使用平臺結構體，修改platformSystem.h里面的結構體
就是線程和互斥鎖

typedef struct
{
    osThreadId_t thread;
} platformThread_t;
typedef struct
{
    osMutexId_t mutex;
} platformMutex_t;

再來實現platformSystem.c里面的函數定義
注意里面的 platformPrint 函數，由于FreeRTOS沒有官方的打印接口。記得修改為你的打印接口

#include "platformSystem.h"
/**

• @brief 申請內存
• @param size
• @return void*
  /
  void platformMemoryMalloc(size_t size)
  {
  return pvPortMalloc(size);
  }
  /
• @brief 釋放內存
• @param ptr
  /
  void platformMemoryFree(void ptr)
  {
  vPortFree(ptr);
  }
  /
• @brief ms延時
• @param ms
  /
  void platformDelay(uint32_t ms)
  {
  osDelay(ms);
  }
  / *
• @brief 打印字符串函數,可通過串口打印出去
• @param str
• @param strLen
  /
  void platformPrint(char str, uint16_t strLen)
  {
  }
  /
• @brief 初始化并運行線程
• @param userData
• @param platformThread
• @param name
• @param entry
• @param param
• @param stackSize
• @param priority
• @return RyanMqttError_e
  */
  RyanMqttError_e platformThreadInit(void *userData,
  platformThread_t *platformThread,
  const char *name,
  void (*entry)(void ),
  void const param,
  uint32_t stackSize,
  uint32_t priority)
  {
  const osThreadAttr_t myTask02_attributes = {
  .name = name,
  .stack_size = stackSize,
  .priority = (osPriority_t)priority,
  };
  platformThread->thread = osThreadNew(entry, param, &myTask02_attributes);
  if (NULL == platformThread->thread)
  return RyanMqttNoRescourceError;
  return RyanMqttSuccessError;
  }
  /
• @brief 銷毀自身線程
• @param userData
• @param platformThread
• @return RyanMqttError_e
  */
  RyanMqttError_e platformThreadDestroy(void userData, platformThread_t platformThread)
  {
  osThreadTerminate(platformThread->thread);
  return RyanMqttSuccessError;
  }
  /
• @brief 開啟線程
• @param userData
• @param platformThread
• @return RyanMqttError_e
  */
  RyanMqttError_e platformThreadStart(void userData, platformThread_t platformThread)
  {
  osThreadResume(platformThread->thread);
  return RyanMqttSuccessError;
  }
  /
• @brief 掛起線程
• @param userData
• @param platformThread
• @return RyanMqttError_e
  */
  RyanMqttError_e platformThreadStop(void userData, platformThread_t platformThread)
  {
  osThreadSuspend(platformThread->thread);
  return RyanMqttSuccessError;
  }
  /
• @brief 互斥鎖初始化
• @param userData
• @param platformMutex
• @return RyanMqttError_e
  */
  RyanMqttError_e platformMutexInit(void userData, platformMutex_t platformMutex)
  {
  const osMutexAttr_t myMutex01_attributes = {
  .name = "mqttMutex"};
  platformMutex->mutex = osMutexNew(&myMutex01_attributes);
  return RyanMqttSuccessError;
  }
  /
• @brief 銷毀互斥鎖
• @param userData
• @param platformMutex
• @return RyanMqttError_e
  */
  RyanMqttError_e platformMutexDestroy(void userData, platformMutex_t platformMutex)
  {
  osMutexDelete(platformMutex->mutex);
  return RyanMqttSuccessError;
  }
  /
• @brief 阻塞獲取互斥鎖
• @param userData
• @param platformMutex
• @return RyanMqttError_e
  */
  RyanMqttError_e platformMutexLock(void userData, platformMutex_t platformMutex)
  {
  osMutexAcquire(platformMutex->mutex, osWaitForever);
  return RyanMqttSuccessError;
  }
  /
• @brief 釋放互斥鎖
• @param userData
• @param platformMutex
• @return RyanMqttError_e
  */
  RyanMqttError_e platformMutexUnLock(void userData, platformMutex_t platformMutex)
  {
  osMutexRelease(platformMutex->mutex);
  return RyanMqttSuccessError;
  }
  /
• @brief 進入臨界區 / 關中斷

/
void platformCriticalEnter(void)
{
osKernelLock();
}
/ *

• @brief 退出臨界區 / 開中斷

*/
void platformCriticalExit(void)
{
osKernelUnlock();
}
time 接口
time接口，只需要提供一個ms時間戳就行，直接修改函數，這里使用FreeRTOS的心跳。

uint32_t platformUptimeMs(void)
{
if (1000 == osKernelGetTickFreq())
return (uint32_t)osKernelGetTickCount();
else
{
uint32_t tick = 0;
tick = osKernelGetTickCount() * 1000;
return (uint32_t)((tick + osKernelGetTickCount() - 1) / osKernelGetTickCount());
}
}
network 接口
MQTT 協議要求基礎傳輸層能夠提供有序的、可靠的、雙向傳輸（從客戶端到服務端 和從服務端到客戶端）的字節流
由于FreeRTOS沒有規定標準的網絡層，你可以選擇 FreeRTOS-Plus-TCP / FreeRTOS-Cellular-Interface/ lwip / W5500等網絡方法，幾乎RT-Thread支持的你也可以在FreeRTOS倉庫找到。

這里以lwip為例，使用socket接口來實現，網絡阻塞發送和接收使用 SO_SNDTIMEO 和 SO_RCVTIMEO 來實現，你也可以選擇select / poll / epoll等方式。

修改 platformNetwork_t 結構體以支持 socket

typedef struct
{
    int socket;
} platformNetwork_t;

接著實現platformNetwork.c里面的函數

#define rlogEnable 1 // 是否使能日志
#define rlogColorEnable 1 // 是否使能日志顏色
#define rlogLevel (rlogLvlWarning) // 日志打印等級
#define rlogTag "RyanMqttNet" // 日志tag
#include "platformNetwork.h"
#include "RyanMqttLog.h"
/**

• @brief 連接mqtt服務器
• @param userData
• @param platformNetwork
• @param host
• @param port
• @return RyanMqttError_e
• 成功返回RyanMqttSuccessError， 失敗返回錯誤信息
  */
  RyanMqttError_e platformNetworkConnect(void *userData, platformNetwork_t *platformNetwork, const char *host, const char port)
  {
  RyanMqttError_e result = RyanMqttSuccessError;
  struct addrinfo addrList = NULL;
  struct addrinfo hints = {
  .ai_family = AF_UNSPEC,
  .ai_socktype = SOCK_STREAM,
  .ai_protocol = IPPROTO_TCP};
  if (getaddrinfo(host, port, &hints, &addrList) != 0)
  {
  result = RyanSocketFailedError;
  goto exit;
  }
  platformNetwork->socket = socket(addrList->ai_family, addrList->ai_socktype, addrList->ai_protocol);
  if (platformNetwork->socket < 0)
  {
  result = RyanSocketFailedError;
  goto exit;
  }
  if (connect(platformNetwork->socket, addrList->ai_addr, addrList->ai_addrlen) != 0)
  {
  platformNetworkClose(userData, platformNetwork);
  result = RyanMqttSocketConnectFailError;
  goto exit;
  }
  exit:
  if (NULL != addrList)
  freeaddrinfo(addrList);
  return result;
  }
  /
• @brief 非阻塞接收數據
• @param userData
• @param platformNetwork
• @param recvBuf
• @param recvLen
• @param timeout
• @return RyanMqttError_e
• socket錯誤返回 RyanSocketFailedError
• 接收超時或者接收數據長度不等于期待數據接受長度 RyanMqttRecvPacketTimeOutError
• 接收成功 RyanMqttSuccessError
  */
  RyanMqttError_e platformNetworkRecvAsync(void *userData, platformNetwork_t *platformNetwork, char recvBuf, int recvLen, int timeout)
  {
  int32_t recvResult = 0;
  int32_t offset = 0;
  int32_t timeOut2 = timeout;
  struct timeval tv = {0};
  platformTimer_t timer = {0};
  if (-1 == platformNetwork->socket)
  return RyanSocketFailedError;
  platformTimerCutdown(&timer, timeout);
  while ((offset < recvLen) && (0 != timeOut2))
  {
  tv.tv_sec = timeOut2 / 1000;
  tv.tv_usec = timeOut2 % 1000 * 1000;
  if (tv.tv_sec <= 0 && tv.tv_usec <= 100)
  {
  tv.tv_sec = 0;
  tv.tv_usec = 100;
  }
  setsockopt(platformNetwork->socket, SOL_SOCKET, SO_RCVTIMEO, (char )&tv, sizeof(struct timeval)); // 設置錯做模式為非阻塞
  recvResult = recv(platformNetwork->socket, recvBuf + offset, recvLen - offset, 0);
  if (recvResult <= 0) // 小于零，表示錯誤，個別錯誤不代表socket錯誤
  {
  // 下列3種表示沒問題,但需要推出發送
  if ((errno == EAGAIN || // 套接字已標記為非阻塞，而接收操作被阻塞或者接收超時
  errno == EWOULDBLOCK || // 發送時套接字發送緩沖區已滿，或接收時套接字接收緩沖區為空
  errno == EINTR)) // 操作被信號中斷
  break;
  return RyanSocketFailedError;
  }
  offset += recvResult;
  timeOut2 = platformTimerRemain(&timer);
  }
  if (offset != recvLen)
  return RyanMqttRecvPacketTimeOutError;
  return RyanMqttSuccessError;
  }
  /
• @brief 非阻塞發送數據
• @param userData
• @param platformNetwork
• @param sendBuf
• @param sendLen
• @param timeout
• @return RyanMqttError_e
• socket錯誤返回 RyanSocketFailedError
• 接收超時或者接收數據長度不等于期待數據接受長度 RyanMqttRecvPacketTimeOutError
• 接收成功 RyanMqttSuccessError
  */
  RyanMqttError_e platformNetworkSendAsync(void *userData, platformNetwork_t *platformNetwork, char sendBuf, int sendLen, int timeout)
  {
  int32_t sendResult = 0;
  int32_t offset = 0;
  int32_t timeOut2 = timeout;
  struct timeval tv = {0};
  platformTimer_t timer = {0};
  if (-1 == platformNetwork->socket)
  return RyanSocketFailedError;
  platformTimerCutdown(&timer, timeout);
  while ((offset < sendLen) && (0 != timeOut2))
  {
  tv.tv_sec = timeOut2 / 1000;
  tv.tv_usec = timeOut2 % 1000 * 1000;
  if (tv.tv_sec <= 0 && tv.tv_usec <= 100)
  {
  tv.tv_sec = 0;
  tv.tv_usec = 100;
  }
  setsockopt(platformNetwork->socket, SOL_SOCKET, SO_SNDTIMEO, (char )&tv, sizeof(struct timeval)); // 設置錯做模式為非阻塞
  sendResult = send(platformNetwork->socket, sendBuf + offset, sendLen - offset, 0);
  if (sendResult <= 0) // 小于零，表示錯誤，個別錯誤不代表socket錯誤
  {
  // 下列3種表示沒問題,但需要推出發送
  if ((errno == EAGAIN || // 套接字已標記為非阻塞，而接收操作被阻塞或者接收超時
  errno == EWOULDBLOCK || // 發送時套接字發送緩沖區已滿，或接收時套接字接收緩沖區為空
  errno == EINTR)) // 操作被信號中斷
  break;
  return RyanSocketFailedError;
  }
  offset += sendResult;
  timeOut2 = platformTimerRemain(&timer);
  }
  if (offset != sendLen)
  return RyanMqttSendPacketTimeOutError;
  return RyanMqttSuccessError;
  }
  /
  @brief 斷開mqtt服務器連接

@param userData
@param platformNetwork
@return RyanMqttError_e
*/
RyanMqttError_e platformNetworkClose(void *userData, platformNetwork_t *platformNetwork)
{
if (platformNetwork->socket >= 0)
{
closesocket(platformNetwork->socket);
platformNetwork->socket = -1;
}
return RyanMqttSuccessError;
}

3、總結
可以看到，RyanMqtt移植非常簡單，有專門的platform層用來移植。