重构log组件、添加quecOpen平台实现、packetType错误修复

.gitignore

@@ -4,3 +4,5 @@
 # 平台移植层
 platform/linux/*
 platform/FreeRTOS/*
+
+null

.vscode/settings.json

@@ -1,6 +0,0 @@
-{
-    "files.associations": {
-        "ryanmqttpublic.h": "c",
-        "mqttpacket.h": "c"
-    }
-}

README.md

@@ -9,13 +9,13 @@ RyanMqtt 实现了 MQTT3.1.1 协议的客户端。此库针对资源受限的嵌
 初衷：在使用[RT-Thread](https://github.com/RT-Thread/rt-thread)时，没有非常合适的 mqtt 客户端。项目中 mqtt 又是非常核心的功能。随即参考 MQTT3.1.1 标准和项目需求设计的 mqtt 客户端，它拥有以下特点。
 
 - 严格遵循 MQTT3.1.1 协议标准
-- 稳定的全 QOS 等级实现消息实现，用户可控的消息丢弃，避免 QOS2 / QOS1 消息无限堆积重发消耗的内存空间
+- 稳定的全 QOS 等级实现消息实现，用户可控的消息丢弃，避免 RyanMqttQos2 / RyanMqttQos1 消息无限堆积重发消耗的内存空间
 - 支持多客户端
 - 客户端多功能参数配置，丰富的用户可选的事件回调，满足实际项目的绝大部分需求
 - 完整的 MQTT 主题通配符支持，“/”、“#”、“+”、“$”
 - 可选择的 keepalive、reconnet、lwt、session 等
 - 资源占用少，依赖少
-- 优化过的并发能力，无等待的连续 200 条 QOS2 消息稳定发送和接收(取决于硬件内存大小、也取决于硬件收发能力)
+- 优化过的并发能力，无等待的连续 200 条 RyanMqttQos2 消息稳定发送和接收(取决于硬件内存大小、也取决于硬件收发能力)
 - 跨平台，只需实现少量的平台接口即可
 - 没有内置 TLS 支持，用户可以在接口层自己实现 TLS（作者对 TLS 并不熟悉、项目中也暂未使用到、使用 TLS 的项目也不会只有 mqtt 使用，用户自己实现也可以防止 TLS 模块间冲突）
 - 不支持裸机平台，裸机想要稳定的 MQTT3.1.1 实现可以参考[coreMQTT](https://github.com/FreeRTOS/coreMQTT)
@@ -90,10 +90,8 @@ RT-Thread 平台
 
 ### 5、依赖
 
-RT-Thread 内置 ulog 组件，方便的使用 ulog api 来管理 RyanMqtt 打印信息
-
-如果没有使能 ulog 或者非 RT-Thread 平台，用户需要手动修改 RyanMqttLog.h 文件调整打印等级。
+请根据自己平台实现RyanLogPrintf, 在common/RyanMqttLog.h
 
 ### 6、声明
 
-- 请勿将此库 QOS 消息等级用于**支付等可能造成重大损失**的场景，如需使用请自行**深度评估后使用**，作者不对使用此库造成的任何损失负责。一般也不会选择只是用 qos2 来保证安全。（尽管此库 QOS2 消息等级经过很多测试，但是异步组件由于诸多因素例如波动非常大的网络甚至无法建立稳定连接、mqtt 服务端的策略配置等，无法做到绝对的实时性，需要用户自己做到数据的最终一致性。）
+- 请勿将此库 QOS 消息等级用于**支付等可能造成重大损失**的场景，如需使用请自行**深度评估后使用**，作者不对使用此库造成的任何损失负责。一般也不会选择只是用 qos2 来保证安全。（尽管此库 RyanMqttQos2 消息等级经过很多测试，但是异步组件由于诸多因素例如波动非常大的网络甚至无法建立稳定连接、mqtt 服务端的策略配置等，无法做到绝对的实时性，需要用户自己做到数据的最终一致性。）

common/RyanList.c

@@ -2,9 +2,6 @@
 
 #include "RyanList.h"
 
-// 此库为公共库，别的包也有使用
-#define __weak __attribute__((weak)) // 防止函数重定义, gcc / ARM编译器有效  IAR可以注释此行
-
 /**
  * @brief 在prev和next之前插入节点
  *
@@ -47,7 +44,7 @@ static void _RyanListDel_entry(RyanList_t *entry)
  *
  * @param list
  */
-__weak void RyanListInit(RyanList_t *list)
+void RyanListInit(RyanList_t *list)
 {
     list->next = list;
     list->prev = list;
@@ -59,7 +56,7 @@ __weak void RyanListInit(RyanList_t *list)
  * @param node
  * @param list
  */
-__weak void RyanListAdd(RyanList_t *node, RyanList_t *list)
+void RyanListAdd(RyanList_t *node, RyanList_t *list)
 {
     _RyanListAdd(node, list, list->next);
 }
@@ -70,7 +67,7 @@ __weak void RyanListAdd(RyanList_t *node, RyanList_t *list)
  * @param node
  * @param list
  */
-__weak void RyanListAddTail(RyanList_t *node, RyanList_t *list)
+void RyanListAddTail(RyanList_t *node, RyanList_t *list)
 {
     _RyanListAdd(node, list->prev, list);
 }
@@ -80,7 +77,7 @@ __weak void RyanListAddTail(RyanList_t *node, RyanList_t *list)
  *
  * @param entry
  */
-__weak void RyanListDel(RyanList_t *entry)
+void RyanListDel(RyanList_t *entry)
 {
     _RyanListDel_entry(entry);
 }
@@ -90,7 +87,7 @@ __weak void RyanListDel(RyanList_t *entry)
  *
  * @param entry
  */
-__weak void RyanListDelInit(RyanList_t *entry)
+void RyanListDelInit(RyanList_t *entry)
 {
     _RyanListDel_entry(entry);
     RyanListInit(entry);
@@ -102,7 +99,7 @@ __weak void RyanListDelInit(RyanList_t *entry)
  * @param node
  * @param list
  */
-__weak void RyanListMove(RyanList_t *node, RyanList_t *list)
+void RyanListMove(RyanList_t *node, RyanList_t *list)
 {
     _RyanListDel_entry(node);
     RyanListAdd(node, list);
@@ -114,7 +111,7 @@ __weak void RyanListMove(RyanList_t *node, RyanList_t *list)
  * @param node
  * @param list
  */
-__weak void RyanListMoveTail(RyanList_t *node, RyanList_t *list)
+void RyanListMoveTail(RyanList_t *node, RyanList_t *list)
 {
     _RyanListDel_entry(node);
     RyanListAddTail(node, list);
@@ -126,7 +123,7 @@ __weak void RyanListMoveTail(RyanList_t *node, RyanList_t *list)
  * @param list
  * @return int
  */
-__weak int RyanListIsEmpty(RyanList_t *list)
+int RyanListIsEmpty(RyanList_t *list)
 {
     return list->next == list;
 }

common/RyanList.h

@@ -1,6 +1,6 @@
 
-#ifndef __RyanList__
-#define __RyanList__
+#ifndef __RyanMqttList__
+#define __RyanMqttList__
 
 #ifdef __cplusplus
 extern "C"

common/RyanMqttLog.h

@@ -0,0 +1,110 @@
+#ifndef __RyanMqttLog__
+#define __RyanMqttLog__
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "RyanMqttPublic.h"
+
+#define RyanLogPrintf(fmt, ...) printf
+// #define RyanLogPrintf(fmt, ...)                                                                 \
+//     do                                                                                          \
+//     {                                                                                           \
+//         char str[256];                                                                          \
+//         snprintf(str, sizeof(str), fmt, ##__VA_ARGS__);                                         \
+//         Ql_UART_Write((Enum_SerialPort)(UART_PORT0), (u8 *)(str), strlen((const char *)(str))); \
+//     } while (0)
+
+// 日志等级
+#define rlogLvlError 0
+#define rlogLvlWarning 1
+#define rlogLvlInfo 2
+#define rlogLvlDebug 3
+
+// 是否使能日志
+#ifndef rlogEnable
+#define rlogEnable 1
+#endif
+
+// 是否使能日志颜色
+#ifndef rlogColorEnable
+#define rlogColorEnable 1
+#endif
+
+// 日志打印等级
+#ifndef rlogLevel
+#define rlogLevel (rlogLvlDebug)
+#endif
+
+// 日志tag
+#ifndef rlogTag
+#define rlogTag "LOG"
+#endif
+
+// RyanLogPrintf("\033[字背景颜色;字体颜色m  用户字符串 \033[0m" );
+#if rlogColorEnable > 0
+#define rlogColorStart(color_n) RyanLogPrintf("\033[" #color_n "m")
+#define rlogColorEnd RyanLogPrintf("\033[0m")
+#else
+#define rlogColorStart(color_n)
+#define rlogColorEnd
+#endif
+
+#if rlogEnable > 0
+
+/**
+ * @brief 日志相关
+ *
+ */
+#define rlog_output(lvl, color_n, fmt, ...)   \
+    do                                        \
+    {                                         \
+        rlogColorStart(color_n);              \
+        RyanLogPrintf("[" lvl "/" rlogTag "]" \
+                      " %s:%d ",              \
+                      __FILE__,               \
+                      __LINE__);              \
+        RyanLogPrintf(fmt, ##__VA_ARGS__);    \
+        rlogColorEnd;                         \
+        RyanLogPrintf("\r\n");                \
+    } while (0)
+
+#define rlog_output_raw(...) RyanLogPrintf(__VA_ARGS__);
+
+#else
+#define rlog_output(lvl, color_n, fmt, ...)
+#define rlog_output_raw(...)
+#endif
+
+/**
+ * @brief log等级检索
+ *
+ */
+#if (rlogLevel >= rlogLvlDebug)
+#define rlog_d(fmt, ...) rlog_output("D", 0, fmt, ##__VA_ARGS__)
+#else
+#define rlog_d(...)
+#endif
+
+#if (rlogLevel >= rlogLvlInfo)
+#define rlog_i(fmt, ...) rlog_output("I", 32, fmt, ##__VA_ARGS__)
+#else
+#define rlog_i(...)
+#endif
+
+#if (rlogLevel >= rlogLvlWarning)
+#define rlog_w(fmt, ...) rlog_output("W", 33, fmt, ##__VA_ARGS__)
+#else
+#define rlog_w(...)
+#endif
+
+#if (rlogLevel >= rlogLvlError)
+#define rlog_e(fmt, ...) rlog_output("E", 31, fmt, ##__VA_ARGS__)
+#else
+#define rlog_e(...)
+#endif
+
+#define log_d rlog_d
+
+#define rlog_raw(...) rlog_output_raw(__VA_ARGS__)
+
+#endif

example/RyanMqtt.c → example/RyanMqttTest.c

@@ -1,17 +1,11 @@
 #include "rtconfig.h"
 
-#define RyanMqttHostName ("broker.emqx.io") // 填写你的mqtt服务器ip
-#define RyanMqttPort ("1883")               // mqtt服务器端口
-#define RyanMqttUserName ("")               // 为空时填写""
-#define RyanMqttPassword ("")               // 为空时填写""
-
-#define DBG_ENABLE
-#define DBG_SECTION_NAME "mqttTest"
-#define DBG_LEVEL LOG_LVL_DBG
-#define DBG_COLOR
+#define RyanMqttHost ("broker.emqx.io") // 填写你的mqtt服务器ip
+#define RyanMqttPort ("1883")           // mqtt服务器端口
+#define RyanMqttUserName ("")           // 为空时填写""
+#define RyanMqttPassword ("")           // 为空时填写""
 
 #ifdef PKG_USING_RYANMQTT_EXAMPLE
-
 #include <stdio.h>
 #include <stdint.h>
 #include <string.h>
@@ -22,6 +16,11 @@
 #include <rtdevice.h>
 #include <rtdbg.h>
 
+#define rlogEnable 1             // 是否使能日志
+#define rlogColorEnable 1        // 是否使能日志颜色
+#define rlogLevel (rlogLvlDebug) // 日志打印等级
+#define rlogTag "RyanMqttTest"   // 日志tag
+#include "RyanMqttLog.h"
 #include "RyanMqttClient.h"
 
 #define delay(ms) rt_thread_mdelay(ms)
@@ -63,45 +62,45 @@ void mqttEventHandle(void *pclient, RyanMqttEventId_e event, const void const *e
         break;
 
     case RyanMqttEventConnected: // 不管有没有使能clearSession，都非常推荐在连接成功回调函数中订阅主题
-        LOG_I("mqtt连接成功回调");
+        rlog_i("mqtt连接成功回调");
         break;
 
     case RyanMqttEventDisconnected:
-        LOG_W("mqtt断开连接回调 %d", *(int32_t *)eventData);
+        rlog_w("mqtt断开连接回调 %d", *(RyanMqttConnectAccepted *)eventData);
         break;
 
     case RyanMqttEventSubscribed:
     {
         RyanMqttMsgHandler_t *msgHandler = (RyanMqttMsgHandler_t *)eventData;
-        LOG_W("mqtt订阅成功回调 topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
+        rlog_w("mqtt订阅成功回调 topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
         break;
     }
 
     case RyanMqttEventSubscribedFaile:
     {
         RyanMqttMsgHandler_t *msgHandler = (RyanMqttMsgHandler_t *)eventData;
-        LOG_W("mqtt订阅失败回调 topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
+        rlog_w("mqtt订阅失败回调 topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
         break;
     }
 
     case RyanMqttEventUnSubscribed:
     {
         RyanMqttMsgHandler_t *msgHandler = (RyanMqttMsgHandler_t *)eventData;
-        LOG_W("mqtt取消订阅成功回调 topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
+        rlog_w("mqtt取消订阅成功回调 topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
         break;
     }
 
     case RyanMqttEventUnSubscribedFaile:
     {
         RyanMqttMsgHandler_t *msgHandler = (RyanMqttMsgHandler_t *)eventData;
-        LOG_W("mqtt取消订阅失败回调 topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
+        rlog_w("mqtt取消订阅失败回调 topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
         break;
     }
 
     case RyanMqttEventPublished:
     {
         RyanMqttMsgHandler_t *msgHandler = ((RyanMqttAckHandler_t *)eventData)->msgHandler;
-        LOG_W("qos1 / qos2发送成功事件回调 topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
+        rlog_w("qos1 / qos2发送成功事件回调 topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
         mqttTest[PublishedEventCount]++;
         break;
     }
@@ -109,8 +108,8 @@ void mqttEventHandle(void *pclient, RyanMqttEventId_e event, const void const *e
     case RyanMqttEventData:
     {
         RyanMqttMsgData_t *msgData = (RyanMqttMsgData_t *)eventData;
-        LOG_I(" RyanMqtt topic recv callback! topic: %s, packetId: %d, payload len: %d",
-              msgData->topic, msgData->packetId, msgData->payloadLen);
+        rlog_i(" RyanMqtt topic recv callback! topic: %s, packetId: %d, payload len: %d",
+               msgData->topic, msgData->packetId, msgData->payloadLen);
 
         rt_kprintf("%.*s\r\n", msgData->payloadLen, msgData->payload);
 
@@ -121,38 +120,36 @@ void mqttEventHandle(void *pclient, RyanMqttEventId_e event, const void const *e
     case RyanMqttEventRepeatPublishPacket: // qos2 / qos1重发事件回调
     {
         RyanMqttAckHandler_t *ackHandler = (RyanMqttAckHandler_t *)eventData;
-        LOG_W("%s:%d %s()... packetType: %d, packetId: %d, topic: %s, qos: %d",
-              __FILE__, __LINE__, __FUNCTION__,
-              ackHandler->packetType, ackHandler->packetId, ackHandler->msgHandler->topic, ackHandler->msgHandler->qos);
+        rlog_w("packetType: %d, packetId: %d, topic: %s, qos: %d",
+               ackHandler->packetType, ackHandler->packetId, ackHandler->msgHandler->topic, ackHandler->msgHandler->qos);
 
         printfArrStr(ackHandler->packet, ackHandler->packetLen, "重发数据: ");
-
         break;
     }
 
     case RyanMqttEventReconnectBefore:
         // 如果每次connect都需要修改连接信息，这里是最好的选择。 否则需要注意资源互斥
-        LOG_I("重连前事件回调");
+        rlog_i("重连前事件回调");
 
         RyanMqttClientConfig_t mqttConfig = {
             .clientId = "RyanMqttTest", // 这里只修改了客户端名字
-            .userName = RyanMqttHostName,
+            .userName = RyanMqttUserName,
             .password = RyanMqttPassword,
-            .host = RyanMqttHostName,
+            .host = RyanMqttHost,
             .port = RyanMqttPort,
             .taskName = "mqttThread",
             .taskPrio = 16,
-            .taskStack = 4096,
+            .taskStack = 3072,
             .recvBufferSize = sizeof(mqttRecvBuffer),
             .sendBufferSize = sizeof(mqttSendBuffer),
             .recvBuffer = mqttRecvBuffer,
             .sendBuffer = mqttSendBuffer,
-            .recvBufferStaticFlag = RyanTrue,
-            .sendBufferStaticFlag = RyanTrue,
+            .recvBufferStaticFlag = RyanMqttTrue,
+            .sendBufferStaticFlag = RyanMqttTrue,
             .mqttVersion = 4,
             .ackHandlerRepeatCountWarning = 6,
             .ackHandlerCountWarning = 20,
-            .autoReconnectFlag = RyanTrue,
+            .autoReconnectFlag = RyanMqttTrue,
             .cleanSessionFlag = 0,
             .reconnectTimeout = 3000,
             .recvTimeout = 11000,
@@ -170,7 +167,7 @@ void mqttEventHandle(void *pclient, RyanMqttEventId_e event, const void const *e
         // 根据实际情况清除ack, 这里等待每个ack重发次数到达警戒值后清除。
         // 在资源有限的单片机中也不应频繁发送qos2 / qos1消息
         uint16_t ackHandlerCount = *(uint16_t *)eventData;
-        LOG_I("ack记数值超过警戒值回调: %d", ackHandlerCount);
+        rlog_i("ack记数值超过警戒值回调: %d", ackHandlerCount);
         break;
     }
 
@@ -178,11 +175,7 @@ void mqttEventHandle(void *pclient, RyanMqttEventId_e event, const void const *e
     {
         // 这里选择直接丢弃该消息
         RyanMqttAckHandler_t *ackHandler = (RyanMqttAckHandler_t *)eventData;
-        LOG_I("ack重发次数超过警戒值回调");
-        LOG_W("%s:%d %s()... packetType: %d, packetId: %d, topic: %s, qos: %d",
-              __FILE__, __LINE__, __FUNCTION__,
-              ackHandler->packetType, ackHandler->packetId, ackHandler->msgHandler->topic, ackHandler->msgHandler->qos);
-
+        rlog_w("ack重发次数超过警戒值回调 packetType: %d, packetId: %d, topic: %s, qos: %d" ackHandler->packetType, ackHandler->packetId, ackHandler->msgHandler->topic, ackHandler->msgHandler->qos);
         RyanMqttDiscardAckHandler(client, ackHandler->packetType, ackHandler->packetId);
 
         break;
@@ -191,13 +184,13 @@ void mqttEventHandle(void *pclient, RyanMqttEventId_e event, const void const *e
     case RyanMqttEventAckHandlerdiscard:
     {
         RyanMqttAckHandler_t *ackHandler = (RyanMqttAckHandler_t *)eventData;
-        LOG_I("ack丢弃回调: packetType: %d, packetId: %d, topic: %s, qos: %d",
-              ackHandler->packetType, ackHandler->packetId, ackHandler->msgHandler->topic, ackHandler->msgHandler->qos);
+        rlog_i("ack丢弃回调: packetType: %d, packetId: %d, topic: %s, qos: %d",
+               ackHandler->packetType, ackHandler->packetId, ackHandler->msgHandler->topic, ackHandler->msgHandler->qos);
         break;
     }
 
     case RyanMqttEventDestoryBefore:
-        LOG_I("销毁mqtt客户端前回调");
+        rlog_i("销毁mqtt客户端前回调");
         break;
 
     default:
@@ -210,24 +203,24 @@ int mqttConnectFun()
     RyanMqttError_e result = RyanMqttSuccessError;
     RyanMqttClientConfig_t mqttConfig = {
         .clientId = "RyanMqttTessdfwrt",
-        .userName = RyanMqttHostName,
+        .userName = RyanMqttUserName,
         .password = RyanMqttPassword,
-        .host = RyanMqttHostName,
+        .host = RyanMqttHost,
         .port = RyanMqttPort,
         .taskName = "mqttThread",
         .taskPrio = 16,
-        .taskStack = 4096,
+        .taskStack = 3072,
         .recvBufferSize = sizeof(mqttRecvBuffer),
         .sendBufferSize = sizeof(mqttSendBuffer),
         .recvBuffer = mqttRecvBuffer,
         .sendBuffer = mqttSendBuffer,
-        .recvBufferStaticFlag = RyanTrue,
-        .sendBufferStaticFlag = RyanTrue,
+        .recvBufferStaticFlag = RyanMqttTrue,
+        .sendBufferStaticFlag = RyanMqttTrue,
         .mqttVersion = 4,
         .ackHandlerRepeatCountWarning = 6,
         .ackHandlerCountWarning = 20,
-        .autoReconnectFlag = RyanTrue,
-        .cleanSessionFlag = 0,
+        .autoReconnectFlag = RyanMqttTrue,
+        .cleanSessionFlag = RyanMqttFalse,
         .reconnectTimeout = 3000,
         .recvTimeout = 11000,
         .sendTimeout = 2000,
@@ -238,23 +231,23 @@ int mqttConnectFun()
 
     // 初始化mqtt客户端
     result = RyanMqttInit(&client);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
 
     // 注册需要的事件回调
     result = RyanMqttRegisterEventId(client, RyanMqttEventAnyId);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
 
     // 设置mqtt客户端config
     result = RyanMqttSetConfig(client, &mqttConfig);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
 
     // 设置遗嘱消息
-    result = RyanMqttSetLwt(client, "pub/test", "this is will", strlen("this is will"), QOS0, 0);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+    result = RyanMqttSetLwt(client, "pub/test", "this is will", strlen("this is will"), RyanMqttQos0, 0);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
 
     // 启动mqtt客户端线程
     result = RyanMqttStart(client);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
     return 0;
 }
 
@@ -284,36 +277,36 @@ static int MqttState(int argc, char *argv[])
     RyanMqttState_e clientState = RyanMqttGetState(client);
     switch (clientState)
     {
-    case mqttInvalidState:
+    case RyanMqttInvalidState:
         str = "无效状态";
         break;
 
-    case mqttInitState:
+    case RyanMqttInitState:
         str = "初始化状态";
         break;
 
-    case mqttStartState:
+    case RyanMqttStartState:
         str = "mqtt开始状态";
         break;
 
-    case mqttConnectState:
+    case RyanMqttConnectState:
         str = "连接状态";
         break;
 
-    case mqttDisconnectState:
+    case RyanMqttDisconnectState:
         str = "断开连接状态";
         break;
 
-    case mqttReconnectState:
+    case RyanMqttReconnectState:
         str = "重新连接状态";
         break;
 
     default:
-        RyanMqttCheck(NULL, RyanMqttFailedError, ulog_d);
+        RyanMqttCheck(NULL, RyanMqttFailedError, rlog_d);
         break;
     }
 
-    LOG_I("client state: %s", str);
+    rlog_i("client state: %s", str);
 
     return 0;
 }
@@ -328,9 +321,9 @@ static int MqttState(int argc, char *argv[])
 static int MqttConnect(int argc, char *argv[])
 {
 
-    if (mqttConnectState == RyanMqttGetState(client))
+    if (RyanMqttConnectState == RyanMqttGetState(client))
     {
-        LOG_W("mqtt客户端没有连接");
+        rlog_w("mqtt客户端没有连接");
         return 0;
     }
     mqttConnectFun();
@@ -372,12 +365,12 @@ static int MqttDestroy(int argc, char *argv[])
  */
 static int MqttDisconnect(int argc, char *argv[])
 {
-    if (mqttConnectState != RyanMqttGetState(client))
+    if (RyanMqttConnectState != RyanMqttGetState(client))
     {
-        LOG_W("mqtt客户端没有连接");
+        rlog_w("mqtt客户端没有连接");
         return 0;
     }
-    RyanMqttDisconnect(client, RyanTrue);
+    RyanMqttDisconnect(client, RyanMqttTrue);
     return 0;
 }
 
@@ -392,13 +385,13 @@ static int Mqttpublish(int argc, char *argv[])
 {
     if (argc < 7)
     {
-        LOG_I("请输入 topic、 qos、 payload内容、 发送条数、 间隔时间(可以为0) ");
+        rlog_i("请输入 topic、 qos、 payload内容、 发送条数、 间隔时间(可以为0) ");
         return 0;
     }
 
-    if (mqttConnectState != RyanMqttGetState(client))
+    if (RyanMqttConnectState != RyanMqttGetState(client))
     {
-        LOG_W("mqtt客户端没有连接");
+        rlog_w("mqtt客户端没有连接");
         return 0;
     }
 
@@ -409,7 +402,7 @@ static int Mqttpublish(int argc, char *argv[])
     uint16_t delayTime = atoi(argv[6]);
 
     uint16_t pubCount = 0;
-    LOG_I("qos: %d, count: %d, delayTime: %d, payload: %s", qos, count, delayTime, payload);
+    rlog_i("qos: %d, count: %d, delayTime: %d, payload: %s", qos, count, delayTime, payload);
 
     for (uint16_t i = 0; i < count; i++)
     {
@@ -434,13 +427,13 @@ static int Mqttsubscribe(int argc, char *argv[])
 {
     if (argc < 4)
     {
-        LOG_I("请输入 topic、 qos ");
+        rlog_i("请输入 topic、 qos ");
         return 0;
     }
 
-    if (mqttConnectState != RyanMqttGetState(client))
+    if (RyanMqttConnectState != RyanMqttGetState(client))
     {
-        LOG_W("mqtt客户端没有连接");
+        rlog_w("mqtt客户端没有连接");
         return 0;
     }
 
@@ -459,13 +452,13 @@ static int MqttUnSubscribe(int argc, char *argv[])
 {
     if (argc < 3)
     {
-        LOG_I("请输入 取消订阅主题");
+        rlog_i("请输入 取消订阅主题");
         return 0;
     }
 
-    if (mqttConnectState != RyanMqttGetState(client))
+    if (RyanMqttConnectState != RyanMqttGetState(client))
     {
-        LOG_W("mqtt客户端没有连接");
+        rlog_w("mqtt客户端没有连接");
         return 0;
     }
 
@@ -482,9 +475,9 @@ static int MqttUnSubscribe(int argc, char *argv[])
  */
 static int MqttListSubscribe(int argc, char *argv[])
 {
-    if (mqttConnectState != RyanMqttGetState(client))
+    if (RyanMqttConnectState != RyanMqttGetState(client))
     {
-        LOG_W("mqtt客户端没有连接");
+        rlog_w("mqtt客户端没有连接");
         return 0;
     }
 
@@ -495,11 +488,11 @@ static int MqttListSubscribe(int argc, char *argv[])
     result = RyanMqttGetSubscribe(client, msgHandles, sizeof(msgHandles) / sizeof(msgHandles[0]), &subscribeNum);
 
     if (result == RyanMqttNoRescourceError)
-        LOG_W("订阅主题数超过10个，已截断");
-    LOG_I("mqtt客户端已订阅的主题数: %d", subscribeNum);
+        rlog_w("订阅主题数超过10个，已截断");
+    rlog_i("mqtt客户端已订阅的主题数: %d", subscribeNum);
 
     for (int32_t i = 0; i < subscribeNum; i++)
-        LOG_I("订阅主题: %d, topic: %s, QOS: %d", i, msgHandles[i].topic, msgHandles[i].qos);
+        rlog_i("订阅主题: %d, topic: %s, QOS: %d", i, msgHandles[i].topic, msgHandles[i].qos);
 
     return 0;
 }
@@ -519,7 +512,7 @@ static int MqttListAck(int argc, char *argv[])
 
     if (RyanListIsEmpty(&client->ackHandlerList))
     {
-        LOG_I("ack链表为空");
+        rlog_i("ack链表为空");
         return 0;
     }
 
@@ -530,9 +523,9 @@ static int MqttListAck(int argc, char *argv[])
         ackHandler = RyanListEntry(curr, RyanMqttAckHandler_t, list);
 
         // 发送qos1 / qos2消息服务器ack响应超时。需要重新发送它们。
-        LOG_W(" type: %d, packetId is %d ", ackHandler->packetType, ackHandler->packetId);
+        rlog_w(" type: %d, packetId is %d ", ackHandler->packetType, ackHandler->packetId);
         if (NULL != ackHandler->msgHandler)
-            LOG_W("topic: %s, qos: %d", ackHandler->msgHandler->topic, ackHandler->msgHandler->qos);
+            rlog_w("topic: %s, qos: %d", ackHandler->msgHandler->topic, ackHandler->msgHandler->qos);
     }
     return 0;
 }
@@ -552,14 +545,14 @@ static int MqttListMsg(int argc, char *argv[])
 
     if (RyanListIsEmpty(&client->msgHandlerList))
     {
-        LOG_I("msg链表为空");
+        rlog_i("msg链表为空");
         return 0;
     }
 
     RyanListForEachSafe(curr, next, &client->msgHandlerList)
     {
         msgHandler = RyanListEntry(curr, RyanMqttMsgHandler_t, list);
-        LOG_W("topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
+        rlog_w("topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
     }
     return 0;
 }
@@ -583,8 +576,8 @@ static int Mqttdata(int argc, char *argv[])
             LOG_E("数组越界");
     }
 
-    LOG_I("dataEventCount: %d, publishCount:%u",
-          mqttTest[dataEventCount], mqttTest[PublishedEventCount]);
+    rlog_i("dataEventCount: %d, publishCount:%u",
+           mqttTest[dataEventCount], mqttTest[PublishedEventCount]);
 
     return 0;
 }

mqttclient/RyanMqttClient.c

@@ -1,21 +1,14 @@
-
-
-#include "RyanMqttPublic.h"
+#define rlogEnable 1               // 是否使能日志
+#define rlogColorEnable 1          // 是否使能日志颜色
+#define rlogLevel (rlogLvlWarning) // 日志打印等级
+#define rlogTag "RyanMqttClient"   // 日志tag
+
+#include "RyanMqttLog.h"
+#include "MQTTPacket.h"
+#include "RyanMqttClient.h"
 #include "RyanMqttUtile.h"
 #include "RyanMqttThread.h"
 
-#define DBG_ENABLE
-#define DBG_SECTION_NAME RyanMqttTag
-
-#ifdef RyanDebugEnable
-#define DBG_LEVEL DBG_LOG
-#else
-#define DBG_LEVEL DBG_INFO
-#endif
-
-#define DBG_COLOR
-#include "ulog.h"
-
 /**
  * @brief 获取报文标识符，报文标识符不可为0
  *
@@ -56,28 +49,28 @@ RyanMqttError_e RyanMqttInit(RyanMqttClient_t **pClient)
 {
 
     RyanMqttClient_t *client = NULL;
-    RyanMqttCheck(NULL != pClient, RyanMqttParamInvalidError, ulog_d);
+    RyanMqttCheck(NULL != pClient, RyanMqttParamInvalidError, rlog_d);
 
     client = (RyanMqttClient_t *)platformMemoryMalloc(sizeof(RyanMqttClient_t));
-    RyanMqttCheck(NULL != client, RyanMqttNotEnoughMemError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttNotEnoughMemError, rlog_d);
     memset(client, 0, sizeof(RyanMqttClient_t));
 
     // 网络接口初始化
     client->network = (platformNetwork_t *)platformMemoryMalloc(sizeof(platformNetwork_t));
-    RyanMqttCheckCode(NULL != client->network, RyanMqttNotEnoughMemError, ulog_d, { RyanMqttDestroy(client); });
+    RyanMqttCheckCode(NULL != client->network, RyanMqttNotEnoughMemError, rlog_d, { RyanMqttDestroy(client); });
     memset(client->network, 0, sizeof(platformNetwork_t));
     client->network->socket = -1;
 
     client->config = (RyanMqttClientConfig_t *)platformMemoryMalloc(sizeof(RyanMqttClientConfig_t));
-    RyanMqttCheckCode(NULL != client->config, RyanMqttNotEnoughMemError, ulog_d, { RyanMqttDestroy(client); });
+    RyanMqttCheckCode(NULL != client->config, RyanMqttNotEnoughMemError, rlog_d, { RyanMqttDestroy(client); });
     memset(client->config, 0, sizeof(RyanMqttClientConfig_t));
 
     client->mqttThread = platformMemoryMalloc(sizeof(platformThread_t));
-    RyanMqttCheckCode(NULL != client->mqttThread, RyanMqttNotEnoughMemError, ulog_d, { RyanMqttDestroy(client); });
+    RyanMqttCheckCode(NULL != client->mqttThread, RyanMqttNotEnoughMemError, rlog_d, { RyanMqttDestroy(client); });
     memset(client->mqttThread, 0, sizeof(platformThread_t));
 
     client->sendBufLock = platformMemoryMalloc(sizeof(platformMutex_t));
-    RyanMqttCheckCode(NULL != client->sendBufLock, RyanMqttNotEnoughMemError, ulog_d, { RyanMqttDestroy(client); });
+    RyanMqttCheckCode(NULL != client->sendBufLock, RyanMqttNotEnoughMemError, rlog_d, { RyanMqttDestroy(client); });
     memset(client->sendBufLock, 0, sizeof(platformMutex_t));
 
     client->packetId = 1; // 控制报文必须包含一个非零的 16 位报文标识符
@@ -85,7 +78,7 @@ RyanMqttError_e RyanMqttInit(RyanMqttClient_t **pClient)
     client->eventFlag = 0;
     client->keepaliveTimeoutCount = 0;
     client->ackHandlerCount = 0;
-    client->lwtFlag = RyanFalse;
+    client->lwtFlag = RyanMqttFalse;
     client->lwtOptions = NULL;
 
     platformMutexInit(client->config->userData, client->sendBufLock); // 初始化发送缓冲区互斥锁
@@ -94,7 +87,7 @@ RyanMqttError_e RyanMqttInit(RyanMqttClient_t **pClient)
     RyanListInit(&client->ackHandlerList);
     platformTimerInit(&client->keepaliveTimer);
 
-    RyanMqttSetClientState(client, mqttInitState);
+    RyanMqttSetClientState(client, RyanMqttInitState);
 
     *pClient = client;
     return RyanMqttSuccessError;
@@ -109,7 +102,7 @@ RyanMqttError_e RyanMqttInit(RyanMqttClient_t **pClient)
 RyanMqttError_e RyanMqttDestroy(RyanMqttClient_t *client)
 {
 
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
 
     RyanMqttEventMachine(client, RyanMqttEventDestoryBefore, (void *)NULL);
 
@@ -140,10 +133,10 @@ RyanMqttError_e RyanMqttDestroy(RyanMqttClient_t *client)
     // 清除config信息
     if (NULL != client->config)
     {
-        if (RyanTrue != client->config->recvBufferStaticFlag && NULL != client->config->recvBuffer)
+        if (RyanMqttTrue != client->config->recvBufferStaticFlag && NULL != client->config->recvBuffer)
             platformMemoryFree(client->config->recvBuffer);
 
-        if (RyanTrue != client->config->sendBufferStaticFlag && NULL != client->config->sendBuffer)
+        if (RyanMqttTrue != client->config->sendBufferStaticFlag && NULL != client->config->sendBuffer)
             platformMemoryFree(client->config->sendBuffer);
 
         if (NULL != client->config->clientId)
@@ -169,7 +162,7 @@ RyanMqttError_e RyanMqttDestroy(RyanMqttClient_t *client)
     }
 
     // 清除遗嘱相关配置
-    if (RyanTrue == client->lwtFlag && NULL != client->lwtOptions)
+    if (RyanMqttTrue == client->lwtFlag && NULL != client->lwtOptions)
     {
         if (NULL != client->lwtOptions->topic)
             platformMemoryFree(client->lwtOptions->topic);
@@ -196,9 +189,9 @@ RyanMqttError_e RyanMqttStart(RyanMqttClient_t *client)
 {
 
     RyanMqttError_e result = RyanMqttSuccessError;
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(mqttInitState == client->clientState, RyanMqttFailedError, ulog_d);
-    RyanMqttSetClientState(client, mqttStartState);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttInitState == client->clientState, RyanMqttFailedError, rlog_d);
+    RyanMqttSetClientState(client, RyanMqttStartState);
     // 连接成功，需要初始化 MQTT 线程
     result = platformThreadInit(client->config->userData,
                                 client->mqttThread,
@@ -208,7 +201,7 @@ RyanMqttError_e RyanMqttStart(RyanMqttClient_t *client)
                                 client->config->taskStack,
                                 client->config->taskPrio);
 
-    RyanMqttCheckCode(RyanMqttSuccessError == result, RyanMqttNotEnoughMemError, ulog_d, { RyanMqttSetClientState(client, mqttInitState); });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, RyanMqttNotEnoughMemError, rlog_d, { RyanMqttSetClientState(client, RyanMqttInitState); });
 
     return RyanMqttSuccessError;
 }
@@ -217,19 +210,19 @@ RyanMqttError_e RyanMqttStart(RyanMqttClient_t *client)
  * @brief 断开mqtt服务器连接
  *
  * @param client
- * @param sendDiscFlag RyanTrue表示发送断开连接报文，RyanFalse表示不发送断开连接报文
+ * @param sendDiscFlag RyanMqttTrue表示发送断开连接报文，RyanMqttFalse表示不发送断开连接报文
  * @return RyanMqttError_e
  */
-RyanMqttError_e RyanMqttDisconnect(RyanMqttClient_t *client, RyanBool_e sendDiscFlag)
+RyanMqttError_e RyanMqttDisconnect(RyanMqttClient_t *client, RyanMqttBool_e sendDiscFlag)
 {
 
     int32_t connectState = RyanMqttConnectAccepted;
     int32_t packetLen = 0;
 
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(mqttConnectState == RyanMqttGetClientState(client), RyanMqttNotConnectError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttConnectState == RyanMqttGetClientState(client), RyanMqttNotConnectError, rlog_d);
 
-    if (RyanTrue == sendDiscFlag)
+    if (RyanMqttTrue == sendDiscFlag)
     {
         platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
         // 序列化断开连接数据包并发送
@@ -255,9 +248,9 @@ RyanMqttError_e RyanMqttDisconnect(RyanMqttClient_t *client, RyanBool_e sendDisc
 RyanMqttError_e RyanMqttReconnect(RyanMqttClient_t *client)
 {
 
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != client->mqttThread, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(mqttDisconnectState != RyanMqttGetClientState(client), RyanMqttConnectError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != client->mqttThread, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttDisconnectState != RyanMqttGetClientState(client), RyanMqttConnectError, rlog_d);
 
     RyanMqttEventMachine(client, RyanMqttEventReconnectBefore, NULL);
     platformThreadStart(client->config->userData, client->mqttThread);
@@ -282,22 +275,22 @@ RyanMqttError_e RyanMqttSubscribe(RyanMqttClient_t *client, char *topic, RyanMqt
     MQTTString topicName = MQTTString_initializer;
     topicName.cstring = (char *)topic;
 
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != topic, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(QOS0 <= qos && QOS2 >= qos, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(mqttConnectState == RyanMqttGetClientState(client), RyanMqttNotConnectError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != topic, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttQos0 <= qos && RyanMqttQos2 >= qos, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttConnectState == RyanMqttGetClientState(client), RyanMqttNotConnectError, rlog_d);
 
     platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
     packetId = RyanMqttGetNextPacketId(client);
 
     packetLen = MQTTSerialize_subscribe((uint8_t *)client->config->sendBuffer, client->config->sendBufferSize, 0, packetId, 1, &topicName, (int *)&qos);
-    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, ulog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, rlog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     result = RyanMqttMsgHandlerCreate(topic, strlen(topic), qos, &msgHandler);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     result = RyanMqttAckHandlerCreate(client, SUBACK, packetId, packetLen, msgHandler, &ackHandler);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, {
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, {
         platformMemoryFree(msgHandler);
         platformMutexUnLock(client->config->userData, client->sendBufLock);
     });
@@ -311,7 +304,7 @@ RyanMqttError_e RyanMqttSubscribe(RyanMqttClient_t *client, char *topic, RyanMqt
     result = RyanMqttAckListAdd(client, ackHandler);
 
     result = RyanMqttSendPacket(client, ackHandler->packet, ackHandler->packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { RyanMqttAckHandlerDestroy(client, ackHandler); });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { RyanMqttAckHandlerDestroy(client, ackHandler); });
     return result;
 }
 
@@ -332,23 +325,23 @@ RyanMqttError_e RyanMqttUnSubscribe(RyanMqttClient_t *client, char *topic)
     MQTTString topicName = MQTTString_initializer;
     topicName.cstring = topic;
 
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != topic, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(mqttConnectState == RyanMqttGetClientState(client), RyanMqttNotConnectError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != topic, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttConnectState == RyanMqttGetClientState(client), RyanMqttNotConnectError, rlog_d);
 
     // 查找当前主题是否已经订阅,没有订阅就取消发送
-    result = RyanMqttMsgHandlerFind(client, topicName.cstring, strlen(topicName.cstring), RyanFalse, &msgHandler);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+    result = RyanMqttMsgHandlerFind(client, topicName.cstring, strlen(topicName.cstring), RyanMqttFalse, &msgHandler);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
 
     platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
     packetId = RyanMqttGetNextPacketId(client);
 
     packetLen = MQTTSerialize_unsubscribe((uint8_t *)client->config->sendBuffer, client->config->sendBufferSize, 0, packetId, 1, &topicName);
-    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, ulog_d,
+    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, rlog_d,
                       { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     result = RyanMqttAckHandlerCreate(client, UNSUBACK, packetId, packetLen, msgHandler, &ackHandler);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d,
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d,
                       { platformMutexUnLock(client->config->userData, client->sendBufLock); });
     platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
@@ -360,7 +353,7 @@ RyanMqttError_e RyanMqttUnSubscribe(RyanMqttClient_t *client, char *topic)
     result = RyanMqttAckListAdd(client, ackHandler);
 
     result = RyanMqttSendPacket(client, ackHandler->packet, ackHandler->packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { RyanMqttAckHandlerDestroy(client, ackHandler); });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { RyanMqttAckHandlerDestroy(client, ackHandler); });
 
     return result;
 }
@@ -376,7 +369,7 @@ RyanMqttError_e RyanMqttUnSubscribe(RyanMqttClient_t *client, char *topic)
  * @param retain
  * @return RyanMqttError_e
  */
-RyanMqttError_e RyanMqttPublish(RyanMqttClient_t *client, char *topic, char *payload, uint32_t payloadLen, RyanMqttQos_e qos, RyanBool_e retain)
+RyanMqttError_e RyanMqttPublish(RyanMqttClient_t *client, char *topic, char *payload, uint32_t payloadLen, RyanMqttQos_e qos, RyanMqttBool_e retain)
 {
     RyanMqttError_e result = RyanMqttSuccessError;
     int32_t packetLen = 0;
@@ -386,22 +379,22 @@ RyanMqttError_e RyanMqttPublish(RyanMqttClient_t *client, char *topic, char *pay
     RyanMqttAckHandler_t *ackHandler = NULL;
     topicName.cstring = (char *)topic;
 
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != topic, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(RyanMqttMaxPayloadLen >= payloadLen, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(QOS0 <= qos && QOS2 >= qos, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(RyanTrue == retain || RyanFalse == retain, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(mqttConnectState == RyanMqttGetClientState(client), RyanMqttNotConnectError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != topic, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttMaxPayloadLen >= payloadLen, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttQos0 <= qos && RyanMqttQos2 >= qos, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttTrue == retain || RyanMqttFalse == retain, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttConnectState == RyanMqttGetClientState(client), RyanMqttNotConnectError, rlog_d);
 
     if (payloadLen > 0 && NULL == payload) // 报文支持有效载荷长度为0
         return RyanMqttParamInvalidError;
 
-    if (QOS0 == qos)
+    if (RyanMqttQos0 == qos)
     {
         platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
         packetLen = MQTTSerialize_publish((uint8_t *)client->config->sendBuffer, client->config->sendBufferSize, 0, qos, retain, packetId,
                                           topicName, (uint8_t *)payload, payloadLen);
-        RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, ulog_d,
+        RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, rlog_d,
                           { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
         result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
@@ -415,29 +408,29 @@ RyanMqttError_e RyanMqttPublish(RyanMqttClient_t *client, char *topic, char *pay
 
     packetLen = MQTTSerialize_publish((uint8_t *)client->config->sendBuffer, client->config->sendBufferSize, 0, qos, retain, packetId,
                                       topicName, (uint8_t *)payload, payloadLen);
-    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, ulog_d,
+    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, rlog_d,
                       { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     result = RyanMqttMsgHandlerCreate(topic, strlen(topic), qos, &msgHandler);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d,
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d,
                       { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
-    result = RyanMqttAckHandlerCreate(client, (QOS1 == qos) ? PUBACK : PUBREC, packetId, packetLen, msgHandler, &ackHandler);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, {
+    result = RyanMqttAckHandlerCreate(client, (RyanMqttQos1 == qos) ? PUBACK : PUBREC, packetId, packetLen, msgHandler, &ackHandler);
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, {
         platformMemoryFree(msgHandler);
         platformMutexUnLock(client->config->userData, client->sendBufLock);
     });
     platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
     // 确定节点是否已存在,存在就删除,理论上不会存在
-    result = RyanMqttAckListNodeFind(client, (QOS1 == qos) ? PUBACK : PUBREC, packetId, &ackHandler);
+    result = RyanMqttAckListNodeFind(client, (RyanMqttQos1 == qos) ? PUBACK : PUBREC, packetId, &ackHandler);
     if (RyanMqttSuccessError == result)
         RyanMqttAckHandlerDestroy(client, ackHandler);
 
     result = RyanMqttAckListAdd(client, ackHandler);
 
     result = RyanMqttSendPacket(client, ackHandler->packet, ackHandler->packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { RyanMqttAckHandlerDestroy(client, ackHandler); });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { RyanMqttAckHandlerDestroy(client, ackHandler); });
 
     // 提前设置重发标志位
     RyanMqttSetPublishDup(&ackHandler->packet[0], 1);
@@ -455,7 +448,7 @@ RyanMqttState_e RyanMqttGetState(RyanMqttClient_t *client)
 {
 
     if (NULL == client)
-        return mqttInvalidState;
+        return RyanMqttInvalidState;
 
     return RyanMqttGetClientState(client);
 }
@@ -476,9 +469,9 @@ RyanMqttError_e RyanMqttGetSubscribe(RyanMqttClient_t *client, RyanMqttMsgHandle
                *next = NULL;
     RyanMqttMsgHandler_t *msgHandler = NULL;
 
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != msgHandles, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(0 < msgHandleSize, RyanMqttParamInvalidError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != msgHandles, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(0 < msgHandleSize, RyanMqttParamInvalidError, rlog_d);
 
     *subscribeNum = 0;
 
@@ -514,8 +507,8 @@ RyanMqttError_e RyanMqttGetSubscribe(RyanMqttClient_t *client, RyanMqttMsgHandle
     RyanMqttError_e result = RyanMqttSuccessError;
     RyanMqttClientConfig_t *clientConfig = NULL;
 
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != pclientConfig, RyanMqttParamInvalidError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != pclientConfig, RyanMqttParamInvalidError, rlog_d);
 
     RyanMqttCheck(NULL != client->config, RyanMqttNoRescourceError);
 
@@ -566,35 +559,35 @@ RyanMqttError_e RyanMqttSetConfig(RyanMqttClient_t *client, RyanMqttClientConfig
 
     RyanMqttError_e result = RyanMqttSuccessError;
 
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != clientConfig->clientId, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != clientConfig->host, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != clientConfig->port, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != clientConfig->userName, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != clientConfig->password, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != clientConfig->taskName, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(2 < clientConfig->recvBufferSize && (RyanMqttMaxPayloadLen + 5) >= clientConfig->recvBufferSize, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(2 < clientConfig->sendBufferSize && (RyanMqttMaxPayloadLen + 5) >= clientConfig->sendBufferSize, RyanMqttParamInvalidError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != clientConfig->clientId, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != clientConfig->host, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != clientConfig->port, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != clientConfig->userName, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != clientConfig->password, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != clientConfig->taskName, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(2 < clientConfig->recvBufferSize && (RyanMqttMaxPayloadLen + 5) >= clientConfig->recvBufferSize, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(2 < clientConfig->sendBufferSize && (RyanMqttMaxPayloadLen + 5) >= clientConfig->sendBufferSize, RyanMqttParamInvalidError, rlog_d);
 
-    RyanMqttCheckCode(NULL != client->config, RyanMqttParamInvalidError, ulog_d, { goto exit; });
+    RyanMqttCheckCode(NULL != client->config, RyanMqttParamInvalidError, rlog_d, { goto __exit; });
 
     result = setConfigValue(&client->config->clientId, clientConfig->clientId);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { goto exit; });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { goto __exit; });
 
     result = setConfigValue(&client->config->userName, clientConfig->userName);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { goto exit; });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { goto __exit; });
 
     result = setConfigValue(&client->config->password, clientConfig->password);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { goto exit; });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { goto __exit; });
 
     result = setConfigValue(&client->config->host, clientConfig->host);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { goto exit; });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { goto __exit; });
 
     result = setConfigValue(&client->config->port, clientConfig->port);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { goto exit; });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { goto __exit; });
 
     result = setConfigValue(&client->config->taskName, clientConfig->taskName);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { goto exit; });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { goto __exit; });
 
     client->config->taskPrio = clientConfig->taskPrio;
     client->config->taskStack = clientConfig->taskStack;
@@ -618,20 +611,20 @@ RyanMqttError_e RyanMqttSetConfig(RyanMqttClient_t *client, RyanMqttClientConfig
     client->config->recvBuffer = clientConfig->recvBuffer;
     client->config->sendBuffer = clientConfig->sendBuffer;
 
-    if (RyanTrue != client->config->recvBufferStaticFlag)
+    if (RyanMqttTrue != client->config->recvBufferStaticFlag)
     {
         client->config->recvBuffer = (char *)platformMemoryMalloc(client->config->recvBufferSize);
-        RyanMqttCheckCode(NULL != client->config->recvBuffer, RyanMqttFailedError, ulog_d, { goto exit; });
+        RyanMqttCheckCode(NULL != client->config->recvBuffer, RyanMqttFailedError, rlog_d, { goto __exit; });
     }
 
-    if (RyanTrue != client->config->sendBufferStaticFlag)
+    if (RyanMqttTrue != client->config->sendBufferStaticFlag)
     {
         client->config->sendBuffer = (char *)platformMemoryMalloc(client->config->sendBufferSize);
-        RyanMqttCheckCode(NULL != client->config->sendBuffer, RyanMqttFailedError, ulog_d, { goto exit; });
+        RyanMqttCheckCode(NULL != client->config->sendBuffer, RyanMqttFailedError, rlog_d, { goto __exit; });
     }
     return RyanMqttSuccessError;
 
-exit:
+__exit:
     RyanMqttDestroy(client);
     return RyanMqttFailedError;
 }
@@ -648,24 +641,24 @@ exit:
  * @param payload
  * @return RyanMqttError_e
  */
-RyanMqttError_e RyanMqttSetLwt(RyanMqttClient_t *client, char *topicName, char *payload, uint32_t payloadLen, RyanMqttQos_e qos, RyanBool_e retain)
+RyanMqttError_e RyanMqttSetLwt(RyanMqttClient_t *client, char *topicName, char *payload, uint32_t payloadLen, RyanMqttQos_e qos, RyanMqttBool_e retain)
 {
     RyanMqttError_e result = RyanMqttSuccessError;
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL != topicName, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(RyanMqttMaxPayloadLen >= payloadLen, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(QOS0 <= qos && QOS2 >= qos, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(RyanTrue == retain || RyanFalse == retain, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(NULL == client->lwtOptions, RyanMqttFailedError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL != topicName, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttMaxPayloadLen >= payloadLen, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttQos0 <= qos && RyanMqttQos2 >= qos, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(RyanMqttTrue == retain || RyanMqttFalse == retain, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(NULL == client->lwtOptions, RyanMqttFailedError, rlog_d);
 
     if (payloadLen > 0 && NULL == payload) // 报文支持有效载荷长度为0
         return RyanMqttParamInvalidError;
 
     client->lwtOptions = (lwtOptions_t *)platformMemoryMalloc(sizeof(lwtOptions_t) + payloadLen);
-    RyanMqttCheck(NULL != client->lwtOptions, RyanMqttNotEnoughMemError, ulog_d);
+    RyanMqttCheck(NULL != client->lwtOptions, RyanMqttNotEnoughMemError, rlog_d);
     memset(client->lwtOptions, 0, sizeof(lwtOptions_t) + payloadLen);
 
-    client->lwtFlag = RyanTrue;
+    client->lwtFlag = RyanMqttTrue;
     client->lwtOptions->qos = qos;
     client->lwtOptions->retain = retain;
     client->lwtOptions->payloadLen = payloadLen;
@@ -673,7 +666,7 @@ RyanMqttError_e RyanMqttSetLwt(RyanMqttClient_t *client, char *topicName, char *
     memcpy(client->lwtOptions->payload, payload, payloadLen);
 
     result = RyanMqttStringCopy(&client->lwtOptions->topic, topicName, strlen(topicName));
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { platformMemoryFree(client->lwtOptions); });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { platformMemoryFree(client->lwtOptions); });
 
     return RyanMqttSuccessError;
 }
@@ -689,13 +682,13 @@ RyanMqttError_e RyanMqttDiscardAckHandler(RyanMqttClient_t *client, enum msgType
 {
     RyanMqttError_e result = RyanMqttSuccessError;
     RyanMqttAckHandler_t *ackHandler = NULL;
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(CONNECT <= packetType && DISCONNECT >= packetType, RyanMqttParamInvalidError, ulog_d);
-    RyanMqttCheck(0 < packetId, RyanMqttParamInvalidError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(CONNECT <= packetType && DISCONNECT >= packetType, RyanMqttParamInvalidError, rlog_d);
+    RyanMqttCheck(0 < packetId, RyanMqttParamInvalidError, rlog_d);
 
     // 删除pubrel记录
     result = RyanMqttAckListNodeFind(client, packetType, packetId, &ackHandler);
-    RyanMqttCheck(RyanMqttSuccessError == result, RyanMqttNoRescourceError, ulog_d);
+    RyanMqttCheck(RyanMqttSuccessError == result, RyanMqttNoRescourceError, rlog_d);
 
     RyanMqttEventMachine(client, RyanMqttEventAckHandlerdiscard, (void *)ackHandler); // 回调函数
 
@@ -705,14 +698,14 @@ RyanMqttError_e RyanMqttDiscardAckHandler(RyanMqttClient_t *client, enum msgType
 
 RyanMqttError_e RyanMqttRegisterEventId(RyanMqttClient_t *client, RyanMqttEventId_e eventId)
 {
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
     client->eventFlag |= eventId;
     return RyanMqttSuccessError;
 }
 
 RyanMqttError_e RyanMqttCancelEventId(RyanMqttClient_t *client, RyanMqttEventId_e eventId)
 {
-    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, ulog_d);
+    RyanMqttCheck(NULL != client, RyanMqttParamInvalidError, rlog_d);
     client->eventFlag &= ~eventId;
     return RyanMqttSuccessError;
 }

mqttclient/RyanMqttClient.h

@@ -8,7 +8,12 @@ extern "C"
 {
 #endif
 
+#include "MQTTPacket.h"
+#include "RyanList.h"
 #include "RyanMqttPublic.h"
+#include "platformTimer.h"
+#include "platformSystem.h"
+#include "platformNetwork.h"
 
     // 接收到订阅消息回调函数类型，eventData用户不要进行修改否则mqtt客户端可能崩溃
     typedef void (*RyanMqttEventHandle)(void *client, RyanMqttEventId_e event, const void const *eventData);
@@ -109,16 +114,16 @@ extern "C"
     extern RyanMqttError_e RyanMqttInit(RyanMqttClient_t **pClient);
     extern RyanMqttError_e RyanMqttDestroy(RyanMqttClient_t *client);
     extern RyanMqttError_e RyanMqttStart(RyanMqttClient_t *client);
-    extern RyanMqttError_e RyanMqttDisconnect(RyanMqttClient_t *client, RyanBool_e sendDiscFlag);
+    extern RyanMqttError_e RyanMqttDisconnect(RyanMqttClient_t *client, RyanMqttBool_e sendDiscFlag);
     extern RyanMqttError_e RyanMqttReconnect(RyanMqttClient_t *client);
     extern RyanMqttError_e RyanMqttSubscribe(RyanMqttClient_t *client, char *topic, RyanMqttQos_e qos);
     extern RyanMqttError_e RyanMqttUnSubscribe(RyanMqttClient_t *client, char *topic);
-    extern RyanMqttError_e RyanMqttPublish(RyanMqttClient_t *client, char *topic, char *payload, uint32_t payloadLen, RyanMqttQos_e qos, RyanBool_e retain);
+    extern RyanMqttError_e RyanMqttPublish(RyanMqttClient_t *client, char *topic, char *payload, uint32_t payloadLen, RyanMqttQos_e qos, RyanMqttBool_e retain);
 
     extern RyanMqttState_e RyanMqttGetState(RyanMqttClient_t *client);
     extern RyanMqttError_e RyanMqttGetSubscribe(RyanMqttClient_t *client, RyanMqttMsgHandler_t *msgHandles, int32_t msgHandleSize, int32_t *subscribeNum);
     extern RyanMqttError_e RyanMqttSetConfig(RyanMqttClient_t *client, RyanMqttClientConfig_t *clientConfig);
-    extern RyanMqttError_e RyanMqttSetLwt(RyanMqttClient_t *client, char *topicName, char *payload, uint32_t payloadLen, RyanMqttQos_e qos, RyanBool_e retain);
+    extern RyanMqttError_e RyanMqttSetLwt(RyanMqttClient_t *client, char *topicName, char *payload, uint32_t payloadLen, RyanMqttQos_e qos, RyanMqttBool_e retain);
 
     extern RyanMqttError_e RyanMqttDiscardAckHandler(RyanMqttClient_t *client, enum msgTypes packetType, uint16_t packetId);
     extern RyanMqttError_e RyanMqttRegisterEventId(RyanMqttClient_t *client, RyanMqttEventId_e eventId);

mqttclient/RyanMqttPublic.h

@@ -1,21 +1,17 @@
 
 
-#ifndef __mqttClientStatic__
-#define __mqttClientStatic__
+#ifndef __mqttClientPublic__
+#define __mqttClientPublic__
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
-#include <rtthread.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <string.h>
 #include <errno.h>
 
-// #define RyanDebugEnable
-#define RyanMqttTag ("RyanMqtt")
-
 #define RyanMqttMaxPacketId (0xFFFFU - 1U)  // 你允许的mqtt paketid最大值，协议标准为个非零的 16 位数
 #define RyanMqttMaxPayloadLen (268435455UL) // 你允许的mqtt可变报头和有效载荷最长长度。默认值为协议标准
 #define RyanMqttVersion ("0.0.1")
@@ -23,84 +19,84 @@ extern "C"
     // 定义枚举类型
     typedef enum
     {
-        RyanBit31 = 0x80000000,
-        RyanBit30 = 0x40000000,
-        RyanBit29 = 0x20000000,
-        RyanBit28 = 0x10000000,
-        RyanBit27 = 0x08000000,
-        RyanBit26 = 0x04000000,
-        RyanBit25 = 0x02000000,
-        RyanBit24 = 0x01000000,
-        RyanBit23 = 0x00800000,
-        RyanBit22 = 0x00400000,
-        RyanBit21 = 0x00200000,
-        RyanBit20 = 0x00100000,
-        RyanBit19 = 0x00080000,
-        RyanBit18 = 0x00040000,
-        RyanBit17 = 0x00020000,
-        RyanBit16 = 0x00010000,
-        RyanBit15 = 0x00008000,
-        RyanBit14 = 0x00004000,
-        RyanBit13 = 0x00002000,
-        RyanBit12 = 0x00001000,
-        RyanBit11 = 0x00000800,
-        RyanBit10 = 0x00000400,
-        RyanBit9 = 0x00000200,
-        RyanBit8 = 0x00000100,
-        RyanBit7 = 0x00000080,
-        RyanBit6 = 0x00000040,
-        RyanBit5 = 0x00000020,
-        RyanBit4 = 0x00000010,
-        RyanBit3 = 0x00000008,
-        RyanBit2 = 0x00000004,
-        RyanBit1 = 0x00000002,
-        RyanBit0 = 0x00000001,
-
-    } RyanBit_e;
+        RyanMqttBit31 = 0x80000000,
+        RyanMqttBit30 = 0x40000000,
+        RyanMqttBit29 = 0x20000000,
+        RyanMqttBit28 = 0x10000000,
+        RyanMqttBit27 = 0x08000000,
+        RyanMqttBit26 = 0x04000000,
+        RyanMqttBit25 = 0x02000000,
+        RyanMqttBit24 = 0x01000000,
+        RyanMqttBit23 = 0x00800000,
+        RyanMqttBit22 = 0x00400000,
+        RyanMqttBit21 = 0x00200000,
+        RyanMqttBit20 = 0x00100000,
+        RyanMqttBit19 = 0x00080000,
+        RyanMqttBit18 = 0x00040000,
+        RyanMqttBit17 = 0x00020000,
+        RyanMqttBit16 = 0x00010000,
+        RyanMqttBit15 = 0x00008000,
+        RyanMqttBit14 = 0x00004000,
+        RyanMqttBit13 = 0x00002000,
+        RyanMqttBit12 = 0x00001000,
+        RyanMqttBit11 = 0x00000800,
+        RyanMqttBit10 = 0x00000400,
+        RyanMqttBit9 = 0x00000200,
+        RyanMqttBit8 = 0x00000100,
+        RyanMqttBit7 = 0x00000080,
+        RyanMqttBit6 = 0x00000040,
+        RyanMqttBit5 = 0x00000020,
+        RyanMqttBit4 = 0x00000010,
+        RyanMqttBit3 = 0x00000008,
+        RyanMqttBit2 = 0x00000004,
+        RyanMqttBit1 = 0x00000002,
+        RyanMqttBit0 = 0x00000001,
+
+    } RyanMqttBit_e;
 
     typedef enum
     {
-        RyanFalse = 0,
-        RyanTrue = 1
-    } RyanBool_e;
+        RyanMqttFalse = 0,
+        RyanMqttTrue = 1
+    } RyanMqttBool_e;
 
     typedef enum
     {
-        QOS0 = 0x00,
-        QOS1 = 0x01,
-        QOS2 = 0x02,
-        subFail = 0x80
+        RyanMqttQos0 = 0x00,
+        RyanMqttQos1 = 0x01,
+        RyanMqttQos2 = 0x02,
+        RyanMqttSubFail = 0x80
     } RyanMqttQos_e;
 
     typedef enum
     {
-        mqttInvalidState = -1, // 无效状态
-        mqttInitState = 0,     // 初始化状态
-        mqttStartState,        // 开始状态
-        mqttConnectState,      // 连接状态
-        mqttDisconnectState,   // 断开连接状态
-        mqttReconnectState,    // 重新连接状态
+        RyanMqttInvalidState = -1, // 无效状态
+        RyanMqttInitState = 0,     // 初始化状态
+        RyanMqttStartState,        // 开始状态
+        RyanMqttConnectState,      // 连接状态
+        RyanMqttDisconnectState,   // 断开连接状态
+        RyanMqttReconnectState,    // 重新连接状态
     } RyanMqttState_e;
 
     typedef enum
     {
-        RyanMqttEventError = RyanBit0,                 // 保留事件
-        RyanMqttEventConnected = RyanBit1,             // 连接成功 正数为RyanMqttConnectStatus_e*,负数为RyanMqttError_e*
-        RyanMqttEventDisconnected = RyanBit2,          // 可能由用户触发,断开连接 正数为RyanMqttConnectStatus_e*,负数为RyanMqttError_e*
-        RyanMqttEventSubscribed = RyanBit3,            // 订阅成功事件,服务端可以授予比订阅者要求的低的QoS等级。 RyanMqttMsgHandler_t*
-        RyanMqttEventSubscribedFaile = RyanBit4,       // 订阅失败事件,超时 / 服务器返回订阅失败 RyanMqttMsgHandler_t*
-        RyanMqttEventUnSubscribed = RyanBit5,          // 取消订阅事件 RyanMqttMsgHandler_t*
-        RyanMqttEventUnSubscribedFaile = RyanBit6,     // 取消订阅失败事件，超时 RyanMqttMsgHandler_t*
-        RyanMqttEventPublished = RyanBit7,             // qos1 / qos2发送成功事件。发送没有失败,只会重发或者用户手动丢弃。RyanMqttAckHandler_t*
-        RyanMqttEventRepeatPublishPacket = RyanBit8,   // qos1 / qos2数据(或者ack)重发回调函数 RyanMqttAckHandler_t*
-        RyanMqttEventAckRepeatCountWarning = RyanBit9, // ack重发次数超过警戒值 RyanMqttAckHandler_t*
-        RyanMqttEventAckCountWarning = RyanBit10,      // ack记数值超过警戒值 uint16_t* ackHandlerCount; // 等待ack的记录个数
-        RyanMqttEventAckHandlerdiscard = RyanBit11,    /*!< 用户触发,ack句柄丢弃事件,由用户手动调用RyanMqttDestroyAckHandler函数触发
-                                                        * 可能是发送qos1 / qos2消息丢弃 ack丢弃，也可能是publish报文的ack丢弃 RyanMqttAckHandler_t*
-                                                        */
-        RyanMqttEventReconnectBefore = RyanBit12,      // 重连前事件,用户可以在此时更改connect信息 NULL
-        RyanMqttEventDestoryBefore = RyanBit13,        // 用户触发，销毁客户端前回调 NULL
-        RyanMqttEventData = RyanBit14,                 // 接收到订阅主题数据事件,支持通配符识别，返回的主题信息是报文主题 RyanMqttMsgData_t*
+        RyanMqttEventError = RyanMqttBit0,                 // 保留事件
+        RyanMqttEventConnected = RyanMqttBit1,             // 连接成功 正数为RyanMqttConnectStatus_e*,负数为RyanMqttError_e*
+        RyanMqttEventDisconnected = RyanMqttBit2,          // 可能由用户触发,断开连接 正数为RyanMqttConnectStatus_e*,负数为RyanMqttError_e*
+        RyanMqttEventSubscribed = RyanMqttBit3,            // 订阅成功事件,服务端可以授予比订阅者要求的低的QoS等级。 RyanMqttMsgHandler_t*
+        RyanMqttEventSubscribedFaile = RyanMqttBit4,       // 订阅失败事件,超时 / 服务器返回订阅失败 RyanMqttMsgHandler_t*
+        RyanMqttEventUnSubscribed = RyanMqttBit5,          // 取消订阅事件 RyanMqttMsgHandler_t*
+        RyanMqttEventUnSubscribedFaile = RyanMqttBit6,     // 取消订阅失败事件，超时 RyanMqttMsgHandler_t*
+        RyanMqttEventPublished = RyanMqttBit7,             // qos1 / qos2发送成功事件。发送没有失败,只会重发或者用户手动丢弃。RyanMqttAckHandler_t*
+        RyanMqttEventRepeatPublishPacket = RyanMqttBit8,   // qos1 / qos2数据(或者ack)重发回调函数 RyanMqttAckHandler_t*
+        RyanMqttEventAckRepeatCountWarning = RyanMqttBit9, // ack重发次数超过警戒值 RyanMqttAckHandler_t*
+        RyanMqttEventAckCountWarning = RyanMqttBit10,      // ack记数值超过警戒值 uint16_t* ackHandlerCount; // 等待ack的记录个数
+        RyanMqttEventAckHandlerdiscard = RyanMqttBit11,    /*!< 用户触发,ack句柄丢弃事件,由用户手动调用RyanMqttDestroyAckHandler函数触发
+                                                            * 可能是发送qos1 / qos2消息丢弃 ack丢弃，也可能是publish报文的ack丢弃 RyanMqttAckHandler_t*
+                                                            */
+        RyanMqttEventReconnectBefore = RyanMqttBit12,      // 重连前事件,用户可以在此时更改connect信息 NULL
+        RyanMqttEventDestoryBefore = RyanMqttBit13,        // 用户触发，销毁客户端前回调 NULL
+        RyanMqttEventData = RyanMqttBit14,                 // 接收到订阅主题数据事件,支持通配符识别，返回的主题信息是报文主题 RyanMqttMsgData_t*
         RyanMqttEventAnyId = UINT32_MAX,
     } RyanMqttEventId_e;
 
@@ -149,32 +145,21 @@ extern "C"
 
     /* extern variables-----------------------------------------------------------*/
 
-#include "MQTTPacket.h"
-#include "platformNetwork.h"
-#include "platformTimer.h"
-#include "platformSystem.h"
-#include "RyanList.h"
-
-#define RyanW5500SetErrno(err) \
-    do                         \
-    {                          \
-        if (err)               \
-            errno = (err);     \
-    } while (0)
-
-#define RyanMqttCheck(EX, ErrorCode, level) RyanMqttCheckCode(EX, ErrorCode, level, { NULL; })
-
-    extern const char *RyanStrError(RyanMqttError_e state);
-
-#define RyanMqttCheckCode(EX, ErrorCode, Ryanlevel, code)                  \
-    if (!(EX))                                                             \
-    {                                                                      \
-        {code};                                                            \
-        Ryanlevel(RyanMqttTag, "%s:%d ErrorCode: %d, strError: %s",        \
-                  __FILE__, __LINE__, ErrorCode, RyanStrError(ErrorCode)); \
-        return ErrorCode;                                                  \
+    extern const char *RyanMqttStrError(RyanMqttError_e state);
+#define RyanMqttCheckCodeNoReturn(EX, ErrorCode, Ryanlevel, code) \
+    if (!(EX))                                                    \
+    {                                                             \
+                                                                  \
+        Ryanlevel("ErrorCode: %d, strError: %s",                  \
+                  ErrorCode, RyanMqttStrError(ErrorCode));        \
+        {code};                                                   \
     }
 
+#define RyanMqttCheckCode(EX, ErrorCode, level, code) RyanMqttCheckCodeNoReturn(EX, ErrorCode, level, { {code}; return ErrorCode; });
+
+#define RyanMqttCheckNoReturn(EX, ErrorCode, level) RyanMqttCheckCodeNoReturn(EX, ErrorCode, level, {})
+#define RyanMqttCheck(EX, ErrorCode, level) RyanMqttCheckCode(EX, ErrorCode, level, {})
+#define RyanMqttCheckAssert(EX, ErrorCode, level) RyanMqttCheckCodeNoReturn(EX, ErrorCode, level, { assert(NULL); })
 #ifdef __cplusplus
 }
 #endif

mqttclient/RyanMqttThread.c

@@ -1,20 +1,15 @@
-
-
-#include "RyanMqttPublic.h"
+#define rlogEnable 1               // 是否使能日志
+#define rlogColorEnable 1          // 是否使能日志颜色
+#define rlogLevel (rlogLvlWarning) // 日志打印等级
+#define rlogTag "RyanMqttThread"   // 日志tag
+
+#include "RyanMqttLog.h"
+#include "MQTTPacket.h"
+#include "RyanMqttClient.h"
 #include "RyanMqttUtile.h"
 #include "RyanMqttThread.h"
 
-#define DBG_ENABLE
-#define DBG_SECTION_NAME RyanMqttTag
-
-#ifdef RyanDebugEnable
-#define DBG_LEVEL DBG_LOG
-#else
-#define DBG_LEVEL DBG_INFO
-#endif
-
-#define DBG_COLOR
-#include "ulog.h"
+// void RyanMqttEventMachine(RyanMqttClient_t *client, RyanMqttEventId_e eventId, void *eventData);
 
 /**
  * @brief mqtt心跳保活
@@ -29,7 +24,7 @@ RyanMqttError_e RyanMqttKeepalive(RyanMqttClient_t *client)
     RyanMqttAssert(NULL != client);
 
     // 如果没有连接则不需要心跳保活
-    RyanMqttCheck(mqttConnectState == RyanMqttGetClientState(client), RyanMqttNotConnectError, ulog_d);
+    RyanMqttCheck(RyanMqttConnectState == RyanMqttGetClientState(client), RyanMqttNotConnectError, rlog_d);
 
     // 服务器在心跳时间的1.5倍内没有收到消息则会断开连接
     // 在心跳的一半发送keepalive
@@ -38,7 +33,7 @@ RyanMqttError_e RyanMqttKeepalive(RyanMqttClient_t *client)
 
     // 心跳超时，断开连接
     connectState = RyanMqttKeepaliveTimeout;
-    RyanMqttCheckCode(2 > client->keepaliveTimeoutCount, RyanMqttKeepaliveTimeout, ulog_d,
+    RyanMqttCheckCode(2 > client->keepaliveTimeoutCount, RyanMqttKeepaliveTimeout, rlog_d,
                       { RyanMqttEventMachine(client, RyanMqttEventDisconnected, (void *)&connectState); });
 
     platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
@@ -70,17 +65,17 @@ static RyanMqttError_e RyanMqttGetPayloadLen(RyanMqttClient_t *client, uint32_t
 
     do
     {
-        RyanMqttCheck(++len < 4, RyanMqttFailedError, ulog_d);
+        RyanMqttCheck(++len < 4, RyanMqttFailedError, rlog_d);
 
         result = RyanMqttRecvPacket(client, (char *)&encodedByte, 1);
-        RyanMqttCheck(RyanMqttSuccessError == result, RyanMqttFailedError, ulog_d);
+        RyanMqttCheck(RyanMqttSuccessError == result, RyanMqttFailedError, rlog_d);
 
         *payloadLen += (encodedByte & 127) * multiplier; // 根据 MQTT 协议解码数据长度
         multiplier *= 128;
 
     } while ((encodedByte & 128) != 0);
 
-    RyanMqttCheck(*payloadLen <= RyanMqttMaxPayloadLen, RyanMqttFailedError, ulog_d);
+    RyanMqttCheck(*payloadLen <= RyanMqttMaxPayloadLen, RyanMqttFailedError, rlog_d);
 
     return RyanMqttSuccessError;
 }
@@ -101,11 +96,11 @@ static RyanMqttError_e RyanMqttPubackAndPubcompPacketHandler(RyanMqttClient_t *c
     RyanMqttAssert(NULL != client);
 
     result = MQTTDeserialize_ack(&packetType, &dup, &packetId, (uint8_t *)client->config->recvBuffer, client->config->recvBufferSize);
-    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, ulog_d);
+    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, rlog_d);
 
     // 可能会多次收到puback / pubcomp,仅在首次收到时触发发布成功回调函数
     result = RyanMqttAckListNodeFind(client, packetType, packetId, &ackHandler);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { LOG_I("packetType: %d, packetId: %d", packetType, packetId); });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { rlog_i("packetType: %d, packetId: %d", packetType, packetId); });
 
     RyanMqttEventMachine(client, RyanMqttEventPublished, (void *)ackHandler); // 回调函数
 
@@ -130,16 +125,16 @@ static RyanMqttError_e RyanMqttPubrelPacketHandler(RyanMqttClient_t *client)
     RyanMqttAssert(NULL != client);
 
     result = MQTTDeserialize_ack(&packetType, &dup, &packetId, (uint8_t *)client->config->recvBuffer, client->config->recvBufferSize);
-    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, ulog_d);
+    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, rlog_d);
 
     // 制作确认数据包并发送
     platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
     packetLen = MQTTSerialize_ack((uint8_t *)client->config->sendBuffer, client->config->sendBufferSize, PUBCOMP, 0, packetId);
-    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, ulog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, rlog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 每次收到PUBREL都返回消息
     result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
     platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
     // 删除pubrel记录
@@ -160,7 +155,7 @@ static RyanMqttError_e RyanMqttPubrecPacketHandler(RyanMqttClient_t *client)
 {
     RyanMqttError_e result = RyanMqttFailedError;
     uint8_t dup = 0;
-    RyanBool_e fastFlag = RyanFalse;
+    RyanMqttBool_e fastFlag = RyanMqttFalse;
     uint8_t packetType = 0;
     uint16_t packetId = 0;
     int32_t packetLen = 0;
@@ -170,7 +165,7 @@ static RyanMqttError_e RyanMqttPubrecPacketHandler(RyanMqttClient_t *client)
     RyanMqttAssert(NULL != client);
 
     result = MQTTDeserialize_ack(&packetType, &dup, &packetId, (uint8_t *)client->config->recvBuffer, client->config->recvBufferSize);
-    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, ulog_d);
+    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, rlog_d);
 
     // 只在首次收到pubrec, 并pubcomp不存在于ack链表时，才创建pubcmp到ack链表,再删除pubrec记录
     result = RyanMqttAckListNodeFind(client, PUBREC, packetId, &ackHandlerPubrec);
@@ -179,7 +174,7 @@ static RyanMqttError_e RyanMqttPubrecPacketHandler(RyanMqttClient_t *client)
         // 查找ack链表是否存在pubcomp报文,不存在表示首次接收到
         result = RyanMqttAckListNodeFind(client, PUBCOMP, packetId, &ackHandler);
         if (RyanMqttSuccessError != result)
-            fastFlag = RyanTrue;
+            fastFlag = RyanMqttTrue;
 
         // 出现pubrec和pubcomp同时存在的情况,清除pubrec理论上不会出现
         else
@@ -190,31 +185,31 @@ static RyanMqttError_e RyanMqttPubrecPacketHandler(RyanMqttClient_t *client)
     platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
     // 序列化发布释放报文
     packetLen = MQTTSerialize_ack((uint8_t *)client->config->sendBuffer, client->config->sendBufferSize, PUBREL, 0, packetId);
-    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, ulog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, rlog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 每次收到PUBREC都返回ack
     result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 只在首次收到pubrec, 并pubcomp不存在于ack链表时，才创建pubcmp到ack链表,再删除pubrec记录
-    if (RyanTrue == fastFlag)
+    if (RyanMqttTrue == fastFlag)
     {
         result = RyanMqttMsgHandlerCreate(ackHandlerPubrec->msgHandler->topic,
                                           strlen(ackHandlerPubrec->msgHandler->topic),
                                           ackHandlerPubrec->msgHandler->qos, &msgHandler);
-        RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d,
+        RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d,
                           { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
         // 创建一个 ACK 处理程序节点
         result = RyanMqttAckHandlerCreate(client, PUBCOMP, packetId, packetLen, msgHandler, &ackHandler);
-        RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d,
+        RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d,
                           { platformMemoryFree(msgHandler);
              platformMutexUnLock(client->config->userData, client->sendBufLock); });
     }
     platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
     // 只在首次收到pubrec, 并pubcomp不存在于ack链表时，才创建pubcmp到ack链表,再删除pubrec记录
-    if (RyanTrue == fastFlag)
+    if (RyanMqttTrue == fastFlag)
     {
         result = RyanMqttAckListAdd(client, ackHandler);
         // 保证等待PUBCOMP记录成功后再清除PUBREC记录
@@ -234,7 +229,7 @@ static RyanMqttError_e RyanMqttPublishPacketHandler(RyanMqttClient_t *client)
 {
     RyanMqttError_e result = RyanMqttSuccessError;
     int32_t packetLen = 0;
-    RyanBool_e deliverMsgFlag = RyanFalse;
+    RyanMqttBool_e deliverMsgFlag = RyanMqttFalse;
     MQTTString topicName = MQTTString_initializer;
     RyanMqttMsgData_t msgData = {0};
     RyanMqttMsgHandler_t *msgHandler = NULL;
@@ -243,69 +238,69 @@ static RyanMqttError_e RyanMqttPublishPacketHandler(RyanMqttClient_t *client)
 
     result = MQTTDeserialize_publish(&msgData.dup, (int *)&msgData.qos, &msgData.retained, &msgData.packetId, &topicName,
                                      (uint8_t **)&msgData.payload, (int *)&msgData.payloadLen, (uint8_t *)client->config->recvBuffer, client->config->recvBufferSize);
-    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, ulog_d);
+    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, rlog_d);
 
     // 查看订阅列表是否包含此消息主题,进行通配符匹配。不包含就直接退出在一定程度上可以防止恶意攻击
-    result = RyanMqttMsgHandlerFind(client, topicName.lenstring.data, topicName.lenstring.len, RyanTrue, &msgHandler);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+    result = RyanMqttMsgHandlerFind(client, topicName.lenstring.data, topicName.lenstring.len, RyanMqttTrue, &msgHandler);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
 
     switch (msgData.qos)
     {
-    case QOS0:
-        deliverMsgFlag = RyanTrue;
+    case RyanMqttQos0:
+        deliverMsgFlag = RyanMqttTrue;
         break;
 
-    case QOS1:
+    case RyanMqttQos1:
         platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
         packetLen = MQTTSerialize_ack((uint8_t *)client->config->sendBuffer, client->config->sendBufferSize, PUBACK, 0, msgData.packetId);
-        RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, ulog_d,
+        RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, rlog_d,
                           { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
         result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
-        RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d,
+        RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d,
                           { platformMutexUnLock(client->config->userData, client->sendBufLock); });
         platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
-        deliverMsgFlag = RyanTrue;
+        deliverMsgFlag = RyanMqttTrue;
 
         break;
 
-    case QOS2:
+    case RyanMqttQos2:
     {
-        RyanBool_e fastFlag = RyanFalse;
+        RyanMqttBool_e fastFlag = RyanMqttFalse;
         // 收到publish就期望收到PUBREL，如果PUBREL报文已经存在说明不是首次收到publish不进行qos2消息处理
         result = RyanMqttAckListNodeFind(client, PUBREL, msgData.packetId, &ackHandler);
         if (RyanMqttSuccessError != result)
-            fastFlag = RyanTrue;
+            fastFlag = RyanMqttTrue;
 
         platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
         packetLen = MQTTSerialize_ack((uint8_t *)client->config->sendBuffer, client->config->sendBufferSize, PUBREC, 0, msgData.packetId);
-        RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, ulog_d,
+        RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, rlog_d,
                           { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
         result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
-        RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d,
+        RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d,
                           { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
-        if (RyanTrue == fastFlag)
+        if (RyanMqttTrue == fastFlag)
         {
             result = RyanMqttMsgHandlerCreate(topicName.lenstring.data, topicName.lenstring.len, msgData.qos, &msgHandler);
-            RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, {
+            RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, {
                 platformMutexUnLock(client->config->userData, client->sendBufLock);
             });
 
             result = RyanMqttAckHandlerCreate(client, PUBREL, msgData.packetId, packetLen, msgHandler, &ackHandler);
-            RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, {
+            RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, {
                 platformMemoryFree(msgHandler);
                 platformMutexUnLock(client->config->userData, client->sendBufLock);
             });
         }
         platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
 
-        if (RyanTrue == fastFlag)
+        if (RyanMqttTrue == fastFlag)
         {
             result = RyanMqttAckListAdd(client, ackHandler);
-            deliverMsgFlag = RyanTrue;
+            deliverMsgFlag = RyanMqttTrue;
         }
     }
 
@@ -315,11 +310,11 @@ static RyanMqttError_e RyanMqttPublishPacketHandler(RyanMqttClient_t *client)
         break;
     }
 
-    if (RyanTrue == deliverMsgFlag)
+    if (RyanMqttTrue == deliverMsgFlag)
     {
         // 复制主题名字
         result = RyanMqttStringCopy(&msgData.topic, topicName.lenstring.data, topicName.lenstring.len);
-        RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+        RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
         RyanMqttEventMachine(client, RyanMqttEventData, (void *)&msgData);
         platformMemoryFree(msgData.topic);
     }
@@ -344,14 +339,14 @@ static RyanMqttError_e RyanMqttSubackHandler(RyanMqttClient_t *client)
     RyanMqttAssert(NULL != client);
 
     result = MQTTDeserialize_suback(&packetId, 1, (int *)&count, (int *)&grantedQoS, (uint8_t *)client->config->recvBuffer, client->config->recvBufferSize);
-    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, ulog_d);
+    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, rlog_d);
 
     // ack链表不存在当前订阅确认节点就直接退出
     result = RyanMqttAckListNodeFind(client, SUBACK, packetId, &ackHandler);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
 
     // 订阅失败
-    if (subFail == grantedQoS)
+    if (RyanMqttSubFail == grantedQoS)
     {
         // mqtt事件回调
         RyanMqttEventMachine(client, RyanMqttEventSubscribedFaile, (void *)ackHandler->msgHandler);
@@ -361,7 +356,7 @@ static RyanMqttError_e RyanMqttSubackHandler(RyanMqttClient_t *client)
 
     // 订阅成功
     // 查找是否有同名订阅，如果有就销毁之前的
-    result = RyanMqttMsgHandlerFind(client, ackHandler->msgHandler->topic, strlen(ackHandler->msgHandler->topic), RyanFalse, &msgHandler);
+    result = RyanMqttMsgHandlerFind(client, ackHandler->msgHandler->topic, strlen(ackHandler->msgHandler->topic), RyanMqttFalse, &msgHandler);
     if (RyanMqttSuccessError == result)
         RyanMqttMsgHandlerDestory(msgHandler);
 
@@ -369,7 +364,7 @@ static RyanMqttError_e RyanMqttSubackHandler(RyanMqttClient_t *client)
     result = RyanMqttMsgHandlerCreate(ackHandler->msgHandler->topic,
                                       strlen(ackHandler->msgHandler->topic),
                                       grantedQoS, &msgHandler);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d); // 这里创建失败了不触发回调，等待ack超时触发失败回调函数
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d); // 这里创建失败了不触发回调，等待ack超时触发失败回调函数
 
     RyanMqttMsgHandlerAdd(client, msgHandler);                                 // 将msg信息添加到订阅链表上
     RyanMqttEventMachine(client, RyanMqttEventSubscribed, (void *)msgHandler); // mqtt回调函数
@@ -392,11 +387,11 @@ static RyanMqttError_e RyanMqttUnSubackHandler(RyanMqttClient_t *client)
     RyanMqttAssert(NULL != client);
 
     result = MQTTDeserialize_unsuback(&packetId, (uint8_t *)client->config->recvBuffer, client->config->recvBufferSize);
-    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, ulog_d);
+    RyanMqttCheck(1 == result, RyanMqttDeserializePacketError, rlog_d);
 
     // ack链表不存在当前取消订阅确认节点就直接退出
     result = RyanMqttAckListNodeFind(client, UNSUBACK, packetId, &ackHandler);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
 
     // mqtt事件回调
     RyanMqttEventMachine(client, RyanMqttEventUnSubscribed, (void *)ackHandler->msgHandler);
@@ -426,27 +421,27 @@ RyanMqttError_e RyanMqttReadPacketHandler(RyanMqttClient_t *client, uint8_t *pac
     result = RyanMqttRecvPacket(client, client->config->recvBuffer, fixedHeaderLen);
     if (RyanMqttRecvPacketTimeOutError == result)
         return RyanMqttRecvPacketTimeOutError;
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
 
     // 填充联合体标头信息
     header.byte = client->config->recvBuffer[0];
-    LOG_D("packetType: %d", header.bits.type);
-    RyanMqttCheck(CONNECT <= header.bits.type && DISCONNECT >= header.bits.type, result, ulog_d);
+    rlog_d("packetType: %d", header.bits.type);
+    RyanMqttCheck(CONNECT <= header.bits.type && DISCONNECT >= header.bits.type, result, rlog_d);
 
     // 2.读取mqtt报文剩余长度。 这本身是可变的
     result = RyanMqttGetPayloadLen(client, &payloadLen);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
 
     // 将剩余长度编码成mqtt报文，并放入接收缓冲区,如果消息长度超过缓冲区长度则抛弃此次数据
     fixedHeaderLen += MQTTPacket_encode((uint8_t *)client->config->recvBuffer + fixedHeaderLen, payloadLen);
-    RyanMqttCheckCode((fixedHeaderLen + payloadLen) <= client->config->recvBufferSize, RyanMqttRecvBufToShortError, ulog_d,
+    RyanMqttCheckCode((fixedHeaderLen + payloadLen) <= client->config->recvBufferSize, RyanMqttRecvBufToShortError, rlog_d,
                       { RyanMqttRecvPacket(client, client->config->recvBuffer, payloadLen); });
 
     // 3.读取mqtt载荷数据并放到读取缓冲区
     if (payloadLen > 0)
     {
         result = RyanMqttRecvPacket(client, client->config->recvBuffer + fixedHeaderLen, payloadLen);
-        RyanMqttCheck(RyanMqttSuccessError == result, result, ulog_d);
+        RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
     }
 
     // 控制报文类型
@@ -489,7 +484,8 @@ RyanMqttError_e RyanMqttReadPacketHandler(RyanMqttClient_t *client, uint8_t *pac
         break;
     }
 
-    *packetType = header.bits.type;
+    if (packetType)
+        *packetType = header.bits.type;
 
     return result;
 }
@@ -499,10 +495,10 @@ RyanMqttError_e RyanMqttReadPacketHandler(RyanMqttClient_t *client, uint8_t *pac
  *
  * @param client
  * @param WaitFlag
- *      WaitFlag : RyanFalse 表示不需要等待超时立即处理这些数据包。通常在重新连接后立即进行处理
- *      WaitFlag : RyanTrue 表示需要等待超时再处理这些消息，一般是稳定连接下的超时处理
+ *      WaitFlag : RyanMqttFalse 表示不需要等待超时立即处理这些数据包。通常在重新连接后立即进行处理
+ *      WaitFlag : RyanMqttTrue 表示需要等待超时再处理这些消息，一般是稳定连接下的超时处理
  */
-void RyanMqttAckListScan(RyanMqttClient_t *client, RyanBool_e WaitFlag)
+void RyanMqttAckListScan(RyanMqttClient_t *client, RyanMqttBool_e WaitFlag)
 {
     RyanList_t *curr = NULL,
                *next = NULL;
@@ -510,7 +506,7 @@ void RyanMqttAckListScan(RyanMqttClient_t *client, RyanBool_e WaitFlag)
     RyanMqttAssert(NULL != client);
 
     // 如果链表为空或者mqtt没有连接就退出
-    if ((RyanListIsEmpty(&client->ackHandlerList)) || (mqttConnectState != RyanMqttGetClientState(client)))
+    if ((RyanListIsEmpty(&client->ackHandlerList)) || (RyanMqttConnectState != RyanMqttGetClientState(client)))
         return;
 
     RyanListForEachSafe(curr, next, &client->ackHandlerList)
@@ -519,7 +515,7 @@ void RyanMqttAckListScan(RyanMqttClient_t *client, RyanBool_e WaitFlag)
         ackHandler = RyanListEntry(curr, RyanMqttAckHandler_t, list);
 
         // ack响应没有超时就不进行处理
-        if (0 != platformTimerRemain(&ackHandler->timer) && RyanTrue == WaitFlag)
+        if (0 != platformTimerRemain(&ackHandler->timer) && RyanMqttTrue == WaitFlag)
             continue;
 
         switch (ackHandler->packetType)
@@ -531,7 +527,7 @@ void RyanMqttAckListScan(RyanMqttClient_t *client, RyanBool_e WaitFlag)
         case PUBCOMP:
         {
 
-            if (mqttConnectState != RyanMqttGetClientState(client))
+            if (RyanMqttConnectState != RyanMqttGetClientState(client))
                 continue;
 
             // 重发数据事件回调
@@ -562,8 +558,12 @@ void RyanMqttAckListScan(RyanMqttClient_t *client, RyanBool_e WaitFlag)
         }
 
         default:
+        {
+            rlog_e("不应该出现的值: %d", ackHandler->packetType);
             RyanMqttAssert(NULL); // 不应该为别的值
-            break;
+        }
+
+        break;
         }
     }
 }
@@ -587,7 +587,7 @@ RyanMqttError_e RyanMqttConnect(RyanMqttClient_t *client)
     RyanMqttAssert(NULL != client->network);
     RyanMqttAssert(NULL != client->config);
 
-    RyanMqttCheck(mqttConnectState != RyanMqttGetClientState(client), RyanMqttConnectAccepted, ulog_d);
+    RyanMqttCheck(RyanMqttConnectState != RyanMqttGetClientState(client), RyanMqttConnectAccepted, rlog_d);
 
     // 连接标志位
     connectData.clientID.cstring = client->config->clientId;
@@ -597,7 +597,7 @@ RyanMqttError_e RyanMqttConnect(RyanMqttClient_t *client)
     connectData.cleansession = client->config->cleanSessionFlag;
     connectData.MQTTVersion = client->config->mqttVersion;
 
-    if (RyanTrue == client->lwtFlag)
+    if (RyanMqttTrue == client->lwtFlag)
     {
         connectData.willFlag = 1;
         connectData.will.qos = client->lwtOptions->qos;
@@ -609,29 +609,29 @@ RyanMqttError_e RyanMqttConnect(RyanMqttClient_t *client)
 
     // 调用底层的连接函数连接上服务器
     result = platformNetworkConnect(client->config->userData, client->network, client->config->host, client->config->port);
-    RyanMqttCheck(RyanMqttSuccessError == result, RyanMqttConnectNetWorkFail, ulog_d);
+    RyanMqttCheck(RyanMqttSuccessError == result, RyanMqttConnectNetWorkFail, rlog_d);
 
     platformMutexLock(client->config->userData, client->sendBufLock); // 获取互斥锁
     // 序列化mqtt的CONNECT报文
     packetLen = MQTTSerialize_connect((uint8_t *)client->config->sendBuffer, client->config->sendBufferSize, &connectData);
-    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, ulog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(packetLen > 0, RyanMqttSerializePacketError, rlog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 发送序列化mqtt的CONNECT报文
     result = RyanMqttSendPacket(client, client->config->sendBuffer, packetLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 等待报文
     // mqtt规范 服务端接收到connect报文后，服务端发送给客户端的第一个报文必须是 CONNACK
     result = RyanMqttReadPacketHandler(client, &packetType);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, result, ulog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
-    RyanMqttCheckCode(CONNACK == packetType, RyanMqttConnectDisconnected, ulog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, result, rlog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(CONNACK == packetType, RyanMqttConnectDisconnected, rlog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     // 解析CONNACK报文
     result = MQTTDeserialize_connack(&sessionPresent, (uint8_t *)&connackRc, (uint8_t *)client->config->recvBuffer, client->config->recvBufferSize);
-    RyanMqttCheckCode(1 == result, RyanMqttDeserializePacketError, ulog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
+    RyanMqttCheckCode(1 == result, RyanMqttDeserializePacketError, rlog_d, { platformMutexUnLock(client->config->userData, client->sendBufLock); });
 
     platformMutexUnLock(client->config->userData, client->sendBufLock); // 释放互斥锁
-    LOG_I("result: %d, packetLen: %d, packetType: %d connackRc: %d", result, packetLen, packetType, connackRc);
+    rlog_i("result: %d, packetLen: %d, packetType: %d connackRc: %d", result, packetLen, packetType, connackRc);
 
     return connackRc;
 }
@@ -655,20 +655,20 @@ void RyanMqttEventMachine(RyanMqttClient_t *client, RyanMqttEventId_e eventId, v
     case RyanMqttEventConnected:                                                                       // 连接成功
         client->keepaliveTimeoutCount = 0;                                                             // 重置心跳超时计数器
         platformTimerCutdown(&client->keepaliveTimer, (client->config->keepaliveTimeoutS * 1000 / 2)); // 启动心跳定时器
-        RyanMqttAckListScan(client, RyanFalse);                                                        // 扫描确认列表，销毁已超时的确认处理程序或重新发送它们
-        RyanMqttSetClientState(client, mqttConnectState);
+        RyanMqttAckListScan(client, RyanMqttFalse);                                                        // 扫描确认列表，销毁已超时的确认处理程序或重新发送它们
+        RyanMqttSetClientState(client, RyanMqttConnectState);
         break;
 
     case RyanMqttEventDisconnected: // 断开连接事件
         platformNetworkClose(client->config->userData, client->network);
 
-        if (RyanTrue == client->config->cleanSessionFlag)
+        if (RyanMqttTrue == client->config->cleanSessionFlag)
             RyanMqttCleanSession(client);
-        RyanMqttSetClientState(client, mqttDisconnectState); // 将客户端状态设置为断开连接
+        RyanMqttSetClientState(client, RyanMqttDisconnectState); // 将客户端状态设置为断开连接
         break;
 
     case RyanMqttEventReconnectBefore: // 重连前回调
-        RyanMqttSetClientState(client, mqttReconnectState);
+        RyanMqttSetClientState(client, RyanMqttReconnectState);
         break;
 
     default:
@@ -700,32 +700,32 @@ void RyanMqttThread(void *argument)
         switch (client->clientState)
         {
 
-        case mqttStartState: // 开始状态状态
-            LOG_D("初始化状态，开始连接");
+        case RyanMqttStartState: // 开始状态状态
+            rlog_d("初始化状态，开始连接");
             result = RyanMqttConnect(client);
             RyanMqttEventMachine(client, RyanMqttConnectAccepted == result ? RyanMqttEventConnected : RyanMqttEventDisconnected,
                                  (void *)&result);
             break;
 
-        case mqttConnectState: // 连接状态
-            LOG_D("连接状态");
+        case RyanMqttConnectState: // 连接状态
+            rlog_d("连接状态");
             result = RyanMqttReadPacketHandler(client, NULL);
-            RyanMqttAckListScan(client, 1);
+            RyanMqttAckListScan(client, RyanMqttTrue);
             RyanMqttKeepalive(client);
             break;
 
-        case mqttDisconnectState: // 断开连接状态
-            LOG_D("断开连接状态");
-            if (RyanTrue != client->config->autoReconnectFlag) // 没有使能自动连接就休眠线程
+        case RyanMqttDisconnectState: // 断开连接状态
+            rlog_d("断开连接状态");
+            if (RyanMqttTrue != client->config->autoReconnectFlag) // 没有使能自动连接就休眠线程
                 platformThreadStop(client->config->userData, client->mqttThread);
 
-            LOG_D("触发自动连接，%dms后开始连接\r\n", client->config->reconnectTimeout);
+            rlog_d("触发自动连接，%dms后开始连接\r\n", client->config->reconnectTimeout);
             platformDelay(client->config->reconnectTimeout);
             RyanMqttEventMachine(client, RyanMqttEventReconnectBefore, NULL); // 给上层触发重新连接前事件
 
             break;
 
-        case mqttReconnectState:
+        case RyanMqttReconnectState:
             result = RyanMqttConnect(client);
             RyanMqttEventMachine(client, RyanMqttConnectAccepted == result ? RyanMqttEventConnected : RyanMqttEventDisconnected,
                                  (void *)&result);

mqttclient/RyanMqttThread.h

@@ -2,13 +2,11 @@
 #ifndef __mqttClientTask__
 #define __mqttClientTask__
 
-#include "RyanMqttClient.h"
-
 #ifdef __cplusplus
 extern "C"
 {
 #endif
-
+#include "RyanMqttClient.h"
     // 定义枚举类型
 
     // 定义结构体类型

mqttclient/RyanMqttUtile.c

@@ -1,59 +1,14 @@
-
-
-#include "RyanMqttPublic.h"
+#define rlogEnable 1               // 是否使能日志
+#define rlogColorEnable 1          // 是否使能日志颜色
+#define rlogLevel (rlogLvlWarning) // 日志打印等级
+#define rlogTag "RyanMqttUtile"    // 日志tag
+
+#include "RyanMqttLog.h"
+#include "MQTTPacket.h"
+#include "RyanMqttClient.h"
 #include "RyanMqttUtile.h"
 #include "RyanMqttThread.h"
 
-#define DBG_ENABLE
-#define DBG_SECTION_NAME RyanMqttTag
-
-#ifdef RyanDebugEnable
-#define DBG_LEVEL DBG_LOG
-#else
-#define DBG_LEVEL DBG_INFO
-#endif
-
-#define DBG_COLOR
-#include "ulog.h"
-
-/**
- * @brief 清理session
- *
- * @param client
- */
-void RyanMqttCleanSession(RyanMqttClient_t *client)
-{
-    RyanList_t *curr = NULL,
-               *next = NULL;
-    RyanMqttAckHandler_t *ackHandler = NULL;
-    RyanMqttMsgHandler_t *msgHandler = NULL;
-    RyanMqttAssert(NULL != client);
-
-    // 释放所有ackHandler_list内存
-    if (0 == RyanListIsEmpty(&client->ackHandlerList))
-    {
-        RyanListForEachSafe(curr, next, &client->ackHandlerList)
-        {
-            ackHandler = RyanListEntry(curr, RyanMqttAckHandler_t, list);
-            RyanMqttAckHandlerDestroy(client, ackHandler);
-        }
-        RyanListDelInit(&client->ackHandlerList);
-    }
-
-    // 释放所有msg_handler_list内存
-    if (0 == RyanListIsEmpty(&client->msgHandlerList))
-    {
-        RyanListForEachSafe(curr, next, &client->msgHandlerList)
-        {
-            msgHandler = RyanListEntry(curr, RyanMqttMsgHandler_t, list);
-            RyanMqttMsgHandlerDestory(msgHandler);
-        }
-        RyanListDelInit(&client->msgHandlerList);
-    }
-
-    client->ackHandlerCount = 0;
-}
-
 /**
  * @brief 字符串拷贝，需要手动释放内存
  *
@@ -95,7 +50,7 @@ RyanMqttError_e RyanMqttSetPublishDup(char *headerBuf, uint8_t dup)
     RyanMqttAssert(NULL != headerBuf);
 
     header.byte = *headerBuf;
-    RyanMqttCheck(PUBLISH == header.bits.type, RyanMqttFailedError, ulog_d);
+    RyanMqttCheck(PUBLISH == header.bits.type, RyanMqttFailedError, rlog_d);
 
     header.bits.dup = dup;
     *headerBuf = header.byte;
@@ -121,7 +76,7 @@ RyanMqttError_e RyanMqttRecvPacket(RyanMqttClient_t *client, char *recvBuf, int3
     RyanMqttAssert(NULL != client->config);
     RyanMqttAssert(NULL != recvBuf);
 
-    RyanMqttCheck(0 != recvLen, RyanMqttSuccessError, ulog_d);
+    RyanMqttCheck(0 != recvLen, RyanMqttSuccessError, rlog_d);
 
     result = platformNetworkRecvAsync(client->config->userData, client->network, recvBuf, recvLen, client->config->recvTimeout);
 
@@ -157,7 +112,7 @@ RyanMqttError_e RyanMqttSendPacket(RyanMqttClient_t *client, char *sendBuf, int3
     RyanMqttAssert(NULL != client->config);
     RyanMqttAssert(NULL != sendBuf);
 
-    RyanMqttCheck(0 != sendLen, RyanMqttSuccessError, ulog_d);
+    RyanMqttCheck(0 != sendLen, RyanMqttSuccessError, rlog_d);
 
     result = platformNetworkSendAsync(client->config->userData, client->network, sendBuf, sendLen, client->config->sendTimeout);
     switch (result)
@@ -172,8 +127,6 @@ RyanMqttError_e RyanMqttSendPacket(RyanMqttClient_t *client, char *sendBuf, int3
         RyanMqttEventMachine(client, RyanMqttEventDisconnected, &connectState);
         return RyanSocketFailedError;
     }
-
-    return RyanMqttSuccessError;
 }
 
 /**
@@ -211,17 +164,17 @@ RyanMqttState_e RyanMqttGetClientState(RyanMqttClient_t *client)
  * @param topicLength 主题名称的长度。
  * @param topicFilter 要检查的主题过滤器。
  * @param topicFilterLength 要检查的主题过滤器长度
- * @return RyanBool_e
+ * @return RyanMqttBool_e
  */
-RyanBool_e RyanMqttMatchTopic(const char *topic,
+RyanMqttBool_e RyanMqttMatchTopic(const char *topic,
                               const uint16_t topicLength,
                               const char *topicFilter,
                               const uint16_t topicFilterLength)
 {
 
-    RyanBool_e topicFilterStartsWithWildcard = RyanFalse,
-               matchFound = RyanFalse,
-               shouldStopMatching = RyanFalse;
+    RyanMqttBool_e topicFilterStartsWithWildcard = RyanMqttFalse,
+               matchFound = RyanMqttFalse,
+               shouldStopMatching = RyanMqttFalse;
     uint16_t topicIndex = 0,
              topicFilterIndex = 0;
 
@@ -229,12 +182,11 @@ RyanBool_e RyanMqttMatchTopic(const char *topic,
     RyanMqttAssert((NULL != topicFilter) && (topicFilterLength != 0u));
 
     // 确定主题过滤器是否以通配符开头。
-    topicFilterStartsWithWildcard = (topicFilter[0] == '+') ||
-                                    (topicFilter[0] == '#');
+    topicFilterStartsWithWildcard = (RyanMqttBool_e)((topicFilter[0] == '+') || (topicFilter[0] == '#'));
 
     // 不能将 $ 字符开头的主题名匹配通配符 (#或+) 开头的主题过滤器
-    if ((topic[0] == '$') && (topicFilterStartsWithWildcard == RyanTrue))
-        return RyanFalse;
+    if ((topic[0] == '$') && (topicFilterStartsWithWildcard == RyanMqttTrue))
+        return RyanMqttFalse;
 
     // 匹配主题名称和主题过滤器，允许使用通配符。
     while ((topicIndex < topicLength) && (topicFilterIndex < topicFilterLength))
@@ -255,7 +207,7 @@ RyanBool_e RyanMqttMatchTopic(const char *topic,
                     (topicFilterIndex == (topicFilterLength - 3U)) &&
                     (topicFilter[topicFilterIndex + 1U] == '/') &&
                     (topicFilter[topicFilterIndex + 2U] == '#'))
-                    matchFound = RyanTrue;
+                    matchFound = RyanMqttTrue;
 
                 // 检查下一个字符是否为"#"或"+"，主题过滤器以"/#"或"/+"结尾。
                 // 此检查处理要匹配的情况：
@@ -264,22 +216,21 @@ RyanBool_e RyanMqttMatchTopic(const char *topic,
                 if ((topicFilterIndex == (topicFilterLength - 2U)) &&
                     (topicFilter[topicFilterIndex] == '/'))
                     // 检查最后一个字符是否为通配符
-                    matchFound = (topicFilter[topicFilterIndex + 1U] == '+') || (topicFilter[topicFilterIndex + 1U] == '#');
+                    matchFound = (RyanMqttBool_e)((topicFilter[topicFilterIndex + 1U] == '+') || (topicFilter[topicFilterIndex + 1U] == '#'));
             }
         }
         else
         {
             // 检查是否匹配通配符
-            RyanBool_e locationIsValidForWildcard;
+            RyanMqttBool_e locationIsValidForWildcard;
 
             // 主题过滤器中的通配符仅在起始位置或前面有"/"时有效。
-            locationIsValidForWildcard = ((topicFilterIndex == 0u) ||
-                                          (topicFilter[topicFilterIndex - 1U] == '/'));
+            locationIsValidForWildcard = (RyanMqttBool_e)((topicFilterIndex == 0u) || (topicFilter[topicFilterIndex - 1U] == '/'));
 
-            if ((topicFilter[topicFilterIndex] == '+') && (locationIsValidForWildcard == RyanTrue))
+            if ((topicFilter[topicFilterIndex] == '+') && (locationIsValidForWildcard == RyanMqttTrue))
             {
-                RyanBool_e nextLevelExistsInTopicName = RyanFalse;
-                RyanBool_e nextLevelExistsinTopicFilter = RyanFalse;
+                RyanMqttBool_e nextLevelExistsInTopicName = RyanMqttFalse;
+                RyanMqttBool_e nextLevelExistsinTopicFilter = RyanMqttFalse;
 
                 // 将主题名称索引移动到当前级别的末尾, 当前级别的结束由下一个级别分隔符"/"之前的最后一个字符标识。
                 while (topicIndex < topicLength)
@@ -287,7 +238,7 @@ RyanBool_e RyanMqttMatchTopic(const char *topic,
                     // 如果我们碰到级别分隔符，则退出循环
                     if (topic[topicIndex] == '/')
                     {
-                        nextLevelExistsInTopicName = RyanTrue;
+                        nextLevelExistsInTopicName = RyanMqttTrue;
                         break;
                     }
 
@@ -297,18 +248,18 @@ RyanBool_e RyanMqttMatchTopic(const char *topic,
                 // 确定主题过滤器是否包含在由"+"通配符表示的当前级别之后的子级别。
                 if ((topicFilterIndex < (topicFilterLength - 1U)) &&
                     (topicFilter[topicFilterIndex + 1U] == '/'))
-                    nextLevelExistsinTopicFilter = RyanTrue;
+                    nextLevelExistsinTopicFilter = RyanMqttTrue;
 
                 // 如果主题名称包含子级别但主题过滤器在当前级别结束，则不存在匹配项。
-                if ((nextLevelExistsInTopicName == RyanTrue) &&
-                    (nextLevelExistsinTopicFilter == RyanFalse))
+                if ((nextLevelExistsInTopicName == RyanMqttTrue) &&
+                    (nextLevelExistsinTopicFilter == RyanMqttFalse))
                 {
-                    matchFound = RyanFalse;
-                    shouldStopMatching = RyanTrue;
+                    matchFound = RyanMqttFalse;
+                    shouldStopMatching = RyanMqttTrue;
                 }
                 // 如果主题名称和主题过滤器有子级别，则将过滤器索引推进到主题过滤器中的级别分隔符，以便在下一个级别进行匹配。
                 // 注意：名称索引已经指向主题名称中的级别分隔符。
-                else if (nextLevelExistsInTopicName == RyanTrue)
+                else if (nextLevelExistsInTopicName == RyanMqttTrue)
                     (topicFilterIndex)++;
 
                 // 如果我们已经到达这里，循环以（*pNameIndex < topicLength）条件终止，
@@ -320,21 +271,21 @@ RyanBool_e RyanMqttMatchTopic(const char *topic,
             // "#"匹配主题名称中剩余的所有内容。它必须是主题过滤器中的最后一个字符。
             else if ((topicFilter[topicFilterIndex] == '#') &&
                      (topicFilterIndex == (topicFilterLength - 1U)) &&
-                     (locationIsValidForWildcard == RyanTrue))
+                     (locationIsValidForWildcard == RyanMqttTrue))
             {
                 // 后续字符不需要检查多级通配符。
-                matchFound = RyanTrue;
-                shouldStopMatching = RyanTrue;
+                matchFound = RyanMqttTrue;
+                shouldStopMatching = RyanMqttTrue;
             }
             else
             {
                 // 除"+"或"#"以外的任何字符不匹配均表示主题名称与主题过滤器不匹配。
-                matchFound = RyanFalse;
-                shouldStopMatching = RyanTrue;
+                matchFound = RyanMqttFalse;
+                shouldStopMatching = RyanMqttTrue;
             }
         }
 
-        if ((matchFound == RyanTrue) || (shouldStopMatching == RyanTrue))
+        if ((matchFound == RyanMqttTrue) || (shouldStopMatching == RyanMqttTrue))
             break;
 
         // 增量索引
@@ -344,8 +295,8 @@ RyanBool_e RyanMqttMatchTopic(const char *topic,
 
     // 如果已到达两个字符串的末尾，则它们匹配。这表示当主题过滤器在非起始位置包含 "+" 通配符时的情况。
     // 例如，当将 "sport/+/player" 或 "sport/hockey/+" 主题过滤器与 "sport/hockey/player" 主题名称匹配时。
-    if (matchFound == RyanFalse)
-        matchFound = (topicIndex == topicLength) && (topicFilterIndex == topicFilterLength);
+    if (matchFound == RyanMqttFalse)
+        matchFound = (RyanMqttBool_e)((topicIndex == topicLength) && (topicFilterIndex == topicFilterLength));
 
     return matchFound;
 }
@@ -365,10 +316,10 @@ RyanMqttError_e RyanMqttMsgHandlerCreate(char *topic, uint16_t topicLen, RyanMqt
     RyanMqttMsgHandler_t *msgHandler = NULL;
     RyanMqttAssert(NULL != topic);
     RyanMqttAssert(NULL != pMsgHandler);
-    RyanMqttAssert(QOS0 <= qos && QOS2 >= qos);
+    RyanMqttAssert(RyanMqttQos0 == qos || RyanMqttQos1 == qos || RyanMqttQos2 == qos);
 
     msgHandler = (RyanMqttMsgHandler_t *)platformMemoryMalloc(sizeof(RyanMqttMsgHandler_t));
-    RyanMqttCheck(NULL != msgHandler, RyanMqttNotEnoughMemError, ulog_d);
+    RyanMqttCheck(NULL != msgHandler, RyanMqttNotEnoughMemError, rlog_d);
     memset(msgHandler, 0, sizeof(RyanMqttMsgHandler_t));
 
     // 初始化链表
@@ -376,7 +327,7 @@ RyanMqttError_e RyanMqttMsgHandlerCreate(char *topic, uint16_t topicLen, RyanMqt
 
     msgHandler->qos = qos;
     result = RyanMqttStringCopy(&msgHandler->topic, topic, topicLen);
-    RyanMqttCheckCode(RyanMqttSuccessError == result, RyanMqttNotEnoughMemError, ulog_d, {platformMemoryFree(msgHandler); msgHandler = NULL; });
+    RyanMqttCheckCode(RyanMqttSuccessError == result, RyanMqttNotEnoughMemError, rlog_d, {platformMemoryFree(msgHandler); msgHandler = NULL; });
 
     *pMsgHandler = msgHandler;
     return RyanMqttSuccessError;
@@ -410,7 +361,7 @@ void RyanMqttMsgHandlerDestory(RyanMqttMsgHandler_t *msgHandler)
  * @param pMsgHandler
  * @return RyanMqttError_e
  */
-RyanMqttError_e RyanMqttMsgHandlerFind(RyanMqttClient_t *client, char *topic, uint16_t topicLen, RyanBool_e topicMatchedFlag, RyanMqttMsgHandler_t **pMsgHandler)
+RyanMqttError_e RyanMqttMsgHandlerFind(RyanMqttClient_t *client, char *topic, uint16_t topicLen, RyanMqttBool_e topicMatchedFlag, RyanMqttMsgHandler_t **pMsgHandler)
 {
     RyanList_t *curr = NULL,
                *next = NULL;
@@ -432,15 +383,15 @@ RyanMqttError_e RyanMqttMsgHandlerFind(RyanMqttClient_t *client, char *topic, ui
             continue;
 
         // 不相等跳过
-        if (topicLen != strlen(msgHandler->topic) && RyanTrue != topicMatchedFlag)
+        if (topicLen != strlen(msgHandler->topic) && RyanMqttTrue != topicMatchedFlag)
             continue;
 
         // 主题名称不相等且没有使能通配符匹配
-        if (0 != strncmp(topic, msgHandler->topic, topicLen) && RyanTrue != topicMatchedFlag)
+        if (0 != strncmp(topic, msgHandler->topic, topicLen) && RyanMqttTrue != topicMatchedFlag)
             continue;
 
         // 进行通配符匹配
-        if (RyanTrue != RyanMqttMatchTopic(topic, topicLen, msgHandler->topic, strlen(msgHandler->topic)))
+        if (RyanMqttTrue != RyanMqttMatchTopic(topic, topicLen, msgHandler->topic, strlen(msgHandler->topic)))
             continue;
 
         *pMsgHandler = msgHandler;
@@ -492,7 +443,7 @@ RyanMqttError_e RyanMqttAckHandlerCreate(RyanMqttClient_t *client, enum msgTypes
 
     // 给消息主题添加空格
     ackHandler = (RyanMqttAckHandler_t *)platformMemoryMalloc(sizeof(RyanMqttAckHandler_t) + packetLen);
-    RyanMqttCheck(NULL != ackHandler, RyanMqttNotEnoughMemError, ulog_d);
+    RyanMqttCheck(NULL != ackHandler, RyanMqttNotEnoughMemError, rlog_d);
     memset(ackHandler, 0, sizeof(RyanMqttAckHandler_t) + packetLen);
 
     RyanListInit(&ackHandler->list);
@@ -598,7 +549,45 @@ RyanMqttError_e RyanMqttAckListAdd(RyanMqttClient_t *client, RyanMqttAckHandler_
     return RyanMqttSuccessError;
 }
 
-const char *RyanStrError(RyanMqttError_e state)
+/**
+ * @brief 清理session
+ *
+ * @param client
+ */
+void RyanMqttCleanSession(RyanMqttClient_t *client)
+{
+    RyanList_t *curr = NULL,
+               *next = NULL;
+    RyanMqttAckHandler_t *ackHandler = NULL;
+    RyanMqttMsgHandler_t *msgHandler = NULL;
+    RyanMqttAssert(NULL != client);
+
+    // 释放所有ackHandler_list内存
+    if (0 == RyanListIsEmpty(&client->ackHandlerList))
+    {
+        RyanListForEachSafe(curr, next, &client->ackHandlerList)
+        {
+            ackHandler = RyanListEntry(curr, RyanMqttAckHandler_t, list);
+            RyanMqttAckHandlerDestroy(client, ackHandler);
+        }
+        RyanListDelInit(&client->ackHandlerList);
+    }
+
+    // 释放所有msg_handler_list内存
+    if (0 == RyanListIsEmpty(&client->msgHandlerList))
+    {
+        RyanListForEachSafe(curr, next, &client->msgHandlerList)
+        {
+            msgHandler = RyanListEntry(curr, RyanMqttMsgHandler_t, list);
+            RyanMqttMsgHandlerDestory(msgHandler);
+        }
+        RyanListDelInit(&client->msgHandlerList);
+    }
+
+    client->ackHandlerCount = 0;
+}
+
+const char *RyanMqttStrError(RyanMqttError_e state)
 {
     const char *str = NULL;
 

mqttclient/RyanMqttUtile.h

@@ -6,9 +6,7 @@
 extern "C"
 {
 #endif
-
 #include "RyanMqttClient.h"
-
     // 定义枚举类型
 
     // 定义结构体类型
@@ -29,14 +27,13 @@ extern "C"
 
     extern RyanMqttError_e RyanMqttMsgHandlerCreate(char *topic, uint16_t topicLen, RyanMqttQos_e qos, RyanMqttMsgHandler_t **pMsgHandler);
     extern void RyanMqttMsgHandlerDestory(RyanMqttMsgHandler_t *msgHandler);
-    extern RyanMqttError_e RyanMqttMsgHandlerFind(RyanMqttClient_t *client, char *topic, uint16_t topicLen, RyanBool_e topicMatchedFlag, RyanMqttMsgHandler_t **pMsgHandler);
+    extern RyanMqttError_e RyanMqttMsgHandlerFind(RyanMqttClient_t *client, char *topic, uint16_t topicLen, RyanMqttBool_e topicMatchedFlag, RyanMqttMsgHandler_t **pMsgHandler);
     extern RyanMqttError_e RyanMqttMsgHandlerAdd(RyanMqttClient_t *client, RyanMqttMsgHandler_t *msgHandler);
 
     extern RyanMqttError_e RyanMqttStringCopy(char **dest, char *rest, uint32_t strLen);
     extern RyanMqttError_e RyanMqttSetPublishDup(char *headerBuf, uint8_t dup);
 
     extern void RyanMqttCleanSession(RyanMqttClient_t *client);
-    extern const char *RyanStrError(RyanMqttError_e state);
 
 #ifdef __cplusplus
 }

platform/quecOpen/platformNetwork.c

@@ -0,0 +1,257 @@
+
+
+#define rlogEnable 1               // 是否使能日志
+#define rlogColorEnable 1          // 是否使能日志颜色
+#define rlogLevel (rlogLvlWarning) // 日志打印等级
+#define rlogTag "RyanMqttNet"      // 日志tag
+
+#include "platformNetwork.h"
+#include "RyanMqttLog.h"
+
+#define tcpConnect (RyanBit1)
+#define tcpSend (RyanBit2)
+#define tcpClose (RyanBit3)
+#define tcpRecv (RyanBit4)
+
+static osEventFlagsId_t mqttNetEventHandle;
+static const osEventFlagsAttr_t mqttNetEvent_attributes = {
+    .name = "mqttNetEvent"};
+
+static void callback_socket_connect(s32 socketId, s32 errCode, void *customParam)
+{
+    platformNetwork_t *platformNetwork = (platformNetwork_t *)customParam;
+    if (errCode == SOC_SUCCESS_OK && platformNetwork->socket == socketId)
+    {
+        rlog_i("socket 连接成功: %d", socketId);
+        osEventFlagsSet(mqttNetEventHandle, tcpConnect);
+    }
+}
+
+static void callback_socket_close(s32 socketId, s32 errCode, void *customParam)
+{
+    if (errCode == SOC_SUCCESS_OK)
+    {
+        rlog_w("关闭socket成功: %d", socketId);
+    }
+    else
+    {
+        rlog_e("关闭socket失败 socketId=%d,error_cause=%d", socketId, errCode);
+    }
+}
+
+static void callback_socket_read(s32 socketId, s32 errCode, void *customParam)
+{
+    platformNetwork_t *platformNetwork = (platformNetwork_t *)customParam;
+    if (SOC_SUCCESS_OK == errCode && platformNetwork->socket == socketId)
+    {
+        rlog_w("socket接收到数据: %d", socketId);
+        osEventFlagsSet(mqttNetEventHandle, tcpRecv);
+    }
+}
+
+static void callback_socket_accept(s32 listenSocketId, s32 errCode, void *customParam)
+{
+}
+
+static ST_SOC_Callback callback_soc_func =
+    {
+        callback_socket_connect,
+        callback_socket_close,
+        callback_socket_accept,
+        callback_socket_read,
+};
+
+/**
+ * @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;
+    u8 nw_state = 0;
+    int32_t eventId;
+
+    Ql_SOC_Register(callback_soc_func, platformNetwork); // 注册socket回调函数
+
+    // 如果第一次connect就创建事件标志组，否则情况事件标志组标志位
+    // todo 这里还是推荐在close的时候把时间标志组删除，否则没有别的地方可以调用删除函数。
+    if (NULL == mqttNetEventHandle)
+        mqttNetEventHandle = osEventFlagsNew(&mqttNetEvent_attributes);
+    else
+        osEventFlagsClear(mqttNetEventHandle, INTMAX_MAX);
+
+    // 获取网络连接状态
+    Ql_GetCeregState(&nw_state);
+    if ((1 != nw_state) && (5 != nw_state))
+    {
+        result = RyanMqttSocketConnectFailError;
+        goto __exit;
+    }
+
+    // 创建socket
+    platformNetwork->socket = Ql_SOC_Create(0, SOC_TYPE_TCP);
+    if (platformNetwork->socket < 0)
+    {
+        result = RyanSocketFailedError;
+        goto __exit;
+    }
+
+    // 等待连接成功
+    s32 connectResult = Ql_SOC_Connect(platformNetwork->socket, (u8 *)host, atoi(port));
+    if (SOC_SUCCESS_OK != connectResult && SOC_NONBLOCK != connectResult)
+    {
+        platformNetworkClose(userData, platformNetwork);
+        result = RyanMqttSocketConnectFailError;
+        goto __exit;
+    }
+
+    eventId = osEventFlagsWait(mqttNetEventHandle, tcpConnect, osFlagsWaitAny, 10000);
+    if (tcpConnect != eventId)
+    {
+        platformNetworkClose(userData, platformNetwork);
+        result = RyanMqttSocketConnectFailError;
+        goto __exit;
+    }
+
+__exit:
+    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;
+    int32_t eventId;
+    platformTimer_t timer = {0};
+
+    if (-1 == platformNetwork->socket)
+        return RyanSocketFailedError;
+
+    platformTimerCutdown(&timer, timeout);
+    while ((offset < recvLen) && (0 != timeOut2))
+    {
+
+        recvResult = Ql_SOC_Recv(platformNetwork->socket, (u8 *)(recvBuf + offset), recvLen - offset);
+        if (recvResult > 0)
+        {
+            offset += recvResult;
+        }
+        else
+        {
+            eventId = osEventFlagsWait(mqttNetEventHandle, tcpRecv, osFlagsWaitAny, timeOut2);
+            if (tcpRecv == eventId)
+            {
+                recvResult = Ql_SOC_Recv(platformNetwork->socket, (u8 *)(recvBuf + offset), recvLen - offset);
+                if (recvResult < 0) // 小于零，表示错误，个别错误不代表socket错误
+                {
+                    if (recvResult != SOC_NONBLOCK &&
+                        recvResult != SOC_ERROR_TIMEOUT)
+                    {
+                        rlog_e("recv失败 result: %d, recvLen: %d, eventId: %d", recvResult, recvLen, eventId);
+                        return RyanSocketFailedError;
+                    }
+
+                    break;
+                }
+
+                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;
+    int32_t eventId;
+    platformTimer_t timer = {0};
+
+    if (-1 == platformNetwork->socket)
+        return RyanSocketFailedError;
+
+    platformTimerCutdown(&timer, timeout);
+
+    while ((offset < sendLen) && (0 != timeOut2))
+    {
+
+        sendResult = Ql_SOC_Send(platformNetwork->socket, (u8 *)(sendBuf + offset), sendLen - offset);
+        if (sendResult < 0) // 小于零，表示错误，个别错误不代表socket错误
+        {
+            if (sendResult != SOC_NONBLOCK &&
+                sendResult != SOC_ERROR_TIMEOUT)
+                return RyanSocketFailedError;
+        }
+        offset += sendResult;
+        timeOut2 = platformTimerRemain(&timer);
+    }
+
+    // osDelay(1000);
+
+    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)
+    {
+        Ql_SOC_Close(platformNetwork->socket);
+        platformNetwork->socket = -1;
+    }
+
+    return RyanMqttSuccessError;
+}

platform/quecOpen/platformNetwork.h

@@ -0,0 +1,38 @@
+
+
+#ifndef __platformNetSocket__
+#define __platformNetSocket__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include "RyanMqttPublic.h"
+#include "platformTimer.h"
+
+#include "cmsis_os2.h"
+#include "ril.h"
+#include "ril_util.h "
+#include "ql_ps.h"
+#include "ql_socket.h"
+#include "ql_urc_register.h"
+
+    typedef struct
+    {
+        int socket;
+    } platformNetwork_t;
+
+    extern RyanMqttError_e platformNetworkConnect(void *userData, platformNetwork_t *platformNetwork, const char *host, const char *port);
+    extern RyanMqttError_e platformNetworkRecvAsync(void *userData, platformNetwork_t *platformNetwork, char *recvBuf, int recvLen, int timeout);
+    extern RyanMqttError_e platformNetworkSendAsync(void *userData, platformNetwork_t *platformNetwork, char *sendBuf, int sendLen, int timeout);
+    extern RyanMqttError_e platformNetworkClose(void *userData, platformNetwork_t *platformNetwork);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

platform/quecOpen/platformSystem.c

@@ -0,0 +1,172 @@
+
+#include "platformSystem.h"
+
+void *platformMemoryMalloc(size_t size)
+{
+    return malloc(size);
+}
+
+void platformMemoryFree(void *ptr)
+{
+    free(ptr);
+}
+
+/**
+ * @brief ms延时
+ *
+ * @param ms
+ */
+void platformDelay(uint32_t ms)
+{
+    osDelay(ms);
+}
+
+/**
+ * @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)
+{
+    osThreadExit();
+    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)
+{
+    // rt_enter_critical();
+    osKernelLock();
+}
+
+/**
+ * @brief 退出临界区 / 开中断
+ *
+ */
+void platformCriticalExit(void)
+{
+    // rt_exit_critical();
+    osKernelUnlock();
+}

platform/quecOpen/platformSystem.h

@@ -0,0 +1,56 @@
+
+#ifndef __platformSystem__
+#define __platformSystem__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdio.h>
+#include <stdint.h>
+#include <assert.h>
+#include "cmsis_os2.h"
+#include "RyanMqttPublic.h"
+
+#define RyanMqttAssert(EX) assert(EX)
+
+    typedef struct
+    {
+        osThreadId_t thread;
+    } platformThread_t;
+
+    typedef struct
+    {
+        osMutexId_t mutex;
+    } platformMutex_t;
+
+    extern void *platformMemoryMalloc(size_t size);
+    extern void platformMemoryFree(void *ptr);
+
+    extern void platformDelay(uint32_t ms);
+
+    extern RyanMqttError_e platformThreadInit(void *userData,
+                                              platformThread_t *platformThread,
+                                              const char *name,
+                                              void (*entry)(void *),
+                                              void *const param,
+                                              uint32_t stackSize,
+                                              uint32_t priority);
+    extern RyanMqttError_e platformThreadDestroy(void *userData, platformThread_t *platformThread);
+    extern RyanMqttError_e platformThreadStart(void *userData, platformThread_t *platformThread);
+    extern RyanMqttError_e platformThreadStop(void *userData, platformThread_t *platformThread);
+
+    extern RyanMqttError_e platformMutexInit(void *userData, platformMutex_t *platformMutex);
+    extern RyanMqttError_e platformMutexDestroy(void *userData, platformMutex_t *platformMutex);
+    extern RyanMqttError_e platformMutexLock(void *userData, platformMutex_t *platformMutex);
+    extern RyanMqttError_e platformMutexUnLock(void *userData, platformMutex_t *platformMutex);
+
+    extern void platformCriticalEnter(void);
+    extern void platformCriticalExit(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

platform/quecOpen/platformTimer.c

@@ -0,0 +1,62 @@
+
+
+#include "platformTimer.h"
+
+uint32_t platformUptimeMs(void)
+{
+    return (uint32_t)osKernelGetTickCount();
+}
+
+/**
+ * @brief 初始化定时器,没有使用，
+ * timer结构体比较简单，没有做init和destory。看后面需求
+ *
+ * @param platformTimer
+ */
+void platformTimerInit(platformTimer_t *platformTimer)
+{
+    platformTimer->time = 0;
+    platformTimer->timeOut = 0;
+}
+
+/**
+ * @brief 添加计数时间
+ *
+ * @param platformTimer
+ * @param timeout
+ */
+void platformTimerCutdown(platformTimer_t *platformTimer, uint32_t timeout)
+{
+    platformTimer->timeOut = timeout;
+    platformTimer->time = platformUptimeMs();
+}
+
+/**
+ * @brief 计算time还有多长时间超时,考虑了32位溢出判断
+ *
+ * @param platformTimer
+ * @return uint32_t 返回剩余时间，超时返回0
+ */
+uint32_t platformTimerRemain(platformTimer_t *platformTimer)
+{
+    uint32_t tnow = platformUptimeMs();
+    uint32_t overTime = platformTimer->time + platformTimer->timeOut;
+    // uint32_t 没有溢出
+    if (overTime >= platformTimer->time)
+    {
+        // tnow溢出,不存在时间超时可能性
+        if (tnow < platformTimer->time)
+            return (UINT32_MAX - overTime + tnow + 1);
+
+        // tnow没有溢出
+        return tnow >= overTime ? 0 : (overTime - tnow);
+    }
+
+    // uint32_t 溢出了
+    // tnow 溢出了
+    if (tnow < platformTimer->time)
+        return tnow >= overTime ? 0 : (overTime - tnow + 1);
+
+    // tnow 没有溢出
+    return UINT32_MAX - tnow + overTime + 1;
+}

platform/quecOpen/platformTimer.h

@@ -0,0 +1,26 @@
+
+
+#ifndef __platformTimer__
+#define __platformTimer__
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#include <stdint.h>
+
+    typedef struct
+    {
+        uint32_t time;
+        uint32_t timeOut;
+    } platformTimer_t;
+
+    extern uint32_t platformUptimeMs(void);
+    extern void platformTimerInit(platformTimer_t *platformTimer);
+    extern void platformTimerCutdown(platformTimer_t *platformTimer, uint32_t timeout);
+    extern uint32_t platformTimerRemain(platformTimer_t *platformTimer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

platform/rtthread/platformNetwork.c

@@ -1,6 +1,10 @@
-
+#define rlogEnable 1               // 是否使能日志
+#define rlogColorEnable 1          // 是否使能日志颜色
+#define rlogLevel (rlogLvlWarning) // 日志打印等级
+#define rlogTag "RyanMqttNet"      // 日志tag
 
 #include "platformNetwork.h"
+#include "RyanMqttLog.h"
 
 /**
  * @brief 连接mqtt服务器
@@ -89,7 +93,7 @@ RyanMqttError_e platformNetworkRecvAsync(void *userData, platformNetwork_t *plat
 
         setsockopt(platformNetwork->socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval)); // 设置错做模式为非阻塞
 
-        recvResult = recv(platformNetwork->socket, recvBuf, recvLen - offset, 0);
+        recvResult = recv(platformNetwork->socket, recvBuf + offset, recvLen - offset, 0);
 
         if (recvResult < 0) // 小于零，表示错误，个别错误不代表socket错误
         {
@@ -153,7 +157,7 @@ RyanMqttError_e platformNetworkSendAsync(void *userData, platformNetwork_t *plat
 
         setsockopt(platformNetwork->socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(struct timeval)); // 设置错做模式为非阻塞
 
-        sendResult = send(platformNetwork->socket, sendBuf, sendLen - offset, 0);
+        sendResult = send(platformNetwork->socket, sendBuf + offset, sendLen - offset, 0);
 
         if (sendResult < 0) // 小于零，表示错误，个别错误不代表socket错误
         {

platform/rtthread/platformNetwork.h

@@ -11,10 +11,10 @@ extern "C"
 #include <stdio.h>
 #include <stdint.h>
 #include <string.h>
-#include <rtthread.h>
 #include "RyanMqttPublic.h"
 #include "platformTimer.h"
 
+#include <rtthread.h>
 #ifdef RT_USING_SAL
 #include <sys/socket.h>
 #include <sys/errno.h>

platform/rtthread/platformSystem.c

@@ -2,11 +2,6 @@
 #include "platformSystem.h"
 
 // 存放未初始化
-// #define ccmBss __attribute__((section(".ccmbss")))
-
-// ccmBss static struct rt_thread mqttThreadHandle;
-// ccmBss static char mqttThreadStack[512 * 4];
-
 void *platformMemoryMalloc(size_t size)
 {
     return rt_malloc(size);

platform/rtthread/platformSystem.h

@@ -10,9 +10,9 @@ extern "C"
 #include <stdio.h>
 #include <stdint.h>
 #include <assert.h>
-#include <rtthread.h>
 #include "RyanMqttPublic.h"
 
+#include <rtthread.h>
 #ifdef RT_ASSERT
 #define RyanMqttAssert(EX) RT_ASSERT(EX)
 #else

platform/rtthread/platformTimer.h

@@ -6,8 +6,8 @@
 extern "C"
 {
 #endif
-#include <rtthread.h>
 #include <stdint.h>
+#include <rtthread.h>
 
     typedef struct
     {