更新示例、更新readme、优化log组件、去除配置信息里面的静态缓存标志位、细节优化

README.md

@@ -6,18 +6,19 @@
 
 RyanMqtt 实现了 MQTT3.1.1 协议的客户端。此库针对资源受限的嵌入式设备进行了优化。
 
-初衷：在使用[RT-Thread](https://github.com/RT-Thread/rt-thread)时，没有非常合适的 mqtt 客户端。项目中 mqtt 又是非常核心的功能。随即参考 MQTT3.1.1 标准和项目需求设计的 mqtt 客户端，它拥有以下特点。
+初衷：在使用[RT-Thread](https://github.com/RT-Thread/rt-thread)时，没有非常合适的 mqtt 客户端。项目中 mqtt 又是非常核心的功能。参考 MQTT3.1.1 标准和项目需求设计的 mqtt 客户端，它拥有以下特点。
 
-- 严格遵循 MQTT3.1.1 协议标准
-- 稳定的全 QOS 等级实现消息实现，用户可控的消息丢弃，避免 RyanMqttQos2 / RyanMqttQos1 消息无限堆积重发消耗的内存空间
+- **严格遵循 MQTT3.1.1 协议标准实现**
+- **稳定的全 QOS 等级实现消息实现**。**用户可控的消息丢弃机制**，避免 RyanMqttQos2 / RyanMqttQos1 消息无限堆积重发消耗的内存空间
 - 支持多客户端
-- 客户端多功能参数配置，丰富的用户可选的事件回调，满足实际项目的绝大部分需求
-- 完整的 MQTT 主题通配符支持，“/”、“#”、“+”、“$”
+- 弱网环境依然可以稳定运行
+- **完整的 MQTT 主题通配符支持，“/”、“#”、“+”、“$”**
 - 可选择的 keepalive、reconnet、lwt、session 等
+- 客户端多功能参数配置，丰富的用户可选的事件回调，满足实际项目的绝大部分需求
+- 优化过的并发能力，**无等待的连续 20000 条 RyanMqttQos2 消息稳定发送和接收无一丢包**(测试环境为linux，实际情况会收到单片机内存大小和网络硬件的收发能力的影响)
 - 资源占用少，依赖少
-- 优化过的并发能力，无等待的连续 200 条 RyanMqttQos2 消息稳定发送和接收(取决于硬件内存大小、也取决于硬件收发能力)
 - 跨平台，只需实现少量的平台接口即可
-- 没有内置 TLS 支持，用户可以在接口层自己实现 TLS（作者对 TLS 并不熟悉、项目中也暂未使用到、使用 TLS 的项目也不会只有 mqtt 使用，用户自己实现也可以防止 TLS 模块间冲突）
+- 没有内置 TLS 支持，用户可以在platform层实现 TLS（使用 TLS 的项目也不会只有 mqtt 使用，用户自己实现可以防止 TLS 模块间冲突）
 - 不支持裸机平台，裸机想要稳定的 MQTT3.1.1 实现可以参考[coreMQTT](https://github.com/FreeRTOS/coreMQTT)
 
 ### 2、设计
@@ -44,6 +45,7 @@ _RyanMqtt 需要 RTOS 支持，必须实现如下接口才可以保证 mqtt 客
 | --------------------- | ------------------- |
 | platformMemoryMalloc  | 申请内存            |
 | platformMemoryFree    | 释放已申请内存      |
+| platformPrint         | 打印字符串          |
 | platformDelay         | 毫秒延时            |
 | platformThreadInit    | 初始化线程          |
 | platformThreadStart   | 开启线程            |
@@ -82,16 +84,26 @@ _RyanMqtt 依靠函数生成毫秒时间戳，用于计算持续时间和超时
 RT-Thread 平台
 
 - 接口示例请参考 platform/rtthread 文件夹
+
 - RyanMqtt 使用示例请参考 example 文件夹
+
 - 需要使能 SAL 或者 LWIP，示例使用 socket 实现数据收发。
+
 - 需要 MSH 组件，示例默认挂载到 MSH 组件
 
-其余平台暂无示例
+  **详细使用请参考 example，提供了一些测试接口和使用范例**
+
+  ![image-20230927112803101](docs/assert/README.assert/image-20230927112803101.png)
+
+移远QuecOpen平台
+
+- 接口示例请参考 platform/quecopen文件夹，请根据不同平台进行更改
+- RyanMqtt 使用示例请参考 example 文件夹
 
 ### 5、依赖
 
-请根据自己平台实现RyanLogPrintf, 在common/RyanMqttLog.h
+暂无
 
 ### 6、声明
 
-- 请勿将此库 QOS 消息等级用于**支付等可能造成重大损失**的场景，如需使用请自行**深度评估后使用**，作者不对使用此库造成的任何损失负责。一般也不会选择只是用 qos2 来保证安全。（尽管此库 RyanMqttQos2 消息等级经过很多测试，但是异步组件由于诸多因素例如波动非常大的网络甚至无法建立稳定连接、mqtt 服务端的策略配置等，无法做到绝对的实时性，需要用户自己做到数据的最终一致性。）
+- 请勿将此库 QOS 消息等级用于**支付等可能造成重大损失**的场景，如需使用请自行**深度评估后使用！！！作者不对使用此库造成的任何损失负责。不要只依靠 qos2 来保证安全！！！**。（尽管此库 RyanMqttQos2 消息等级经过很多测试，但是异步组件由于诸多因素例如波动非常大的网络甚至无法建立稳定连接、mqtt 服务端的策略配置等，无法做到绝对的准确性。需要用户用应用层做到数据的最终一致性。）

common/RyanMqttLog.h

@@ -39,7 +39,7 @@
 static void rlog_output(char *lvl, uint8_t color_n, char *const fmt, ...)
 {
     // RyanLogPrintf("\033[字背景颜色;字体颜色m  用户字符串 \033[0m" );
-    char dbgBuffer[386];
+    char dbgBuffer[256];
     uint16_t len;
 
 // 打印颜色
@@ -90,25 +90,25 @@ static void rlog_output_raw(char *const fmt, ...)
  *
  */
 #if (rlogLevel >= rlogLvlDebug)
-#define rlog_d(fmt, ...) rlog_output("D", 0, fmt, ##__VA_ARGS__)
+#define rlog_d(fmt, ...) rlog_output("D", 0, " %s:%d " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
 #else
 #define rlog_d(...)
 #endif
 
 #if (rlogLevel >= rlogLvlInfo)
-#define rlog_i(fmt, ...) rlog_output("I", 32, fmt, ##__VA_ARGS__)
+#define rlog_i(fmt, ...) rlog_output("I", 32, " %s:%d " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
 #else
 #define rlog_i(...)
 #endif
 
 #if (rlogLevel >= rlogLvlWarning)
-#define rlog_w(fmt, ...) rlog_output("W", 33, fmt, ##__VA_ARGS__)
+#define rlog_w(fmt, ...) rlog_output("W", 33, " %s:%d " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
 #else
 #define rlog_w(...)
 #endif
 
 #if (rlogLevel >= rlogLvlError)
-#define rlog_e(fmt, ...) rlog_output("E", 31, fmt, ##__VA_ARGS__)
+#define rlog_e(fmt, ...) rlog_output("E", 31, " %s:%d " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
 #else
 #define rlog_e(...)
 #endif

example/RyanMqttTest.c

@@ -1,9 +1,10 @@
 #include "rtconfig.h"
 
-#define RyanMqttHost ("broker.emqx.io") // 填写你的mqtt服务器ip
-#define RyanMqttPort ("1883")           // mqtt服务器端口
-#define RyanMqttUserName ("")           // 为空时填写""
-#define RyanMqttPassword ("")           // 为空时填写""
+#define RyanMqttClientId ("RyanMqttTessdfwrt") // 填写mqtt客户端id，要求唯一
+#define RyanMqttHost ("broker.emqx.io")        // 填写你的mqtt服务器ip
+#define RyanMqttPort ("1883")                  // mqtt服务器端口
+#define RyanMqttUserName ("")                  // 为空时填写""
+#define RyanMqttPassword ("")                  // 为空时填写""
 
 #ifdef PKG_USING_RYANMQTT_EXAMPLE
 #include <stdio.h>
@@ -27,21 +28,21 @@
 
 static RyanMqttClient_t *client = NULL;
 
-static char mqttRecvBuffer[2048];
-static char mqttSendBuffer[2048];
+static char mqttRecvBuffer[1024];
+static char mqttSendBuffer[1024];
 
 // 具体数值计算可以查看事件回调函数
 static uint32_t mqttTest[10] = {0};
-#define dataEventCount (0)      // 接收到几次数据
-#define PublishedEventCount (1) // 发布成功的次数
+#define dataEventCount (0)      // 接收到数据次数统计
+#define PublishedEventCount (1) // qos1和qos2发布成功的次数统计
 
 void printfArrStr(char *buf, uint32_t len, char *userData)
 {
-    rt_kprintf("%s", userData);
+    rlog_raw("%s", userData);
     for (uint32_t i = 0; i < len; i++)
-        rt_kprintf("%x", buf[i]);
+        rlog_raw("%x", buf[i]);
 
-    rt_kprintf("\r\n");
+    rlog_raw("\r\n");
 }
 
 /**
@@ -130,36 +131,6 @@ void mqttEventHandle(void *pclient, RyanMqttEventId_e event, const void const *e
     case RyanMqttEventReconnectBefore:
         // 如果每次connect都需要修改连接信息，这里是最好的选择。 否则需要注意资源互斥
         rlog_i("重连前事件回调");
-
-        RyanMqttClientConfig_t mqttConfig = {
-            .clientId = "RyanMqttTest", // 这里只修改了客户端名字
-            .userName = RyanMqttUserName,
-            .password = RyanMqttPassword,
-            .host = RyanMqttHost,
-            .port = RyanMqttPort,
-            .taskName = "mqttThread",
-            .taskPrio = 16,
-            .taskStack = 3072,
-            .recvBufferSize = sizeof(mqttRecvBuffer),
-            .sendBufferSize = sizeof(mqttSendBuffer),
-            .recvBuffer = mqttRecvBuffer,
-            .sendBuffer = mqttSendBuffer,
-            .recvBufferStaticFlag = RyanMqttTrue,
-            .sendBufferStaticFlag = RyanMqttTrue,
-            .mqttVersion = 4,
-            .ackHandlerRepeatCountWarning = 6,
-            .ackHandlerCountWarning = 20,
-            .autoReconnectFlag = RyanMqttTrue,
-            .cleanSessionFlag = 0,
-            .reconnectTimeout = 3000,
-            .recvTimeout = 11000,
-            .sendTimeout = 2000,
-            .ackTimeout = 10000,
-            .keepaliveTimeoutS = 60,
-            .mqttEventHandle = mqttEventHandle,
-            .userData = NULL};
-
-        RyanMqttSetConfig(client, &mqttConfig);
         break;
 
     case RyanMqttEventAckCountWarning: // qos2 / qos1的ack链表超过警戒值，不进行释放会一直重发，占用额外内存
@@ -198,59 +169,6 @@ void mqttEventHandle(void *pclient, RyanMqttEventId_e event, const void const *e
     }
 }
 
-int mqttConnectFun()
-{
-    RyanMqttError_e result = RyanMqttSuccessError;
-    RyanMqttClientConfig_t mqttConfig = {
-        .clientId = "RyanMqttTessdfwrt",
-        .userName = RyanMqttUserName,
-        .password = RyanMqttPassword,
-        .host = RyanMqttHost,
-        .port = RyanMqttPort,
-        .taskName = "mqttThread",
-        .taskPrio = 16,
-        .taskStack = 3072,
-        .recvBufferSize = sizeof(mqttRecvBuffer),
-        .sendBufferSize = sizeof(mqttSendBuffer),
-        .recvBuffer = mqttRecvBuffer,
-        .sendBuffer = mqttSendBuffer,
-        .recvBufferStaticFlag = RyanMqttTrue,
-        .sendBufferStaticFlag = RyanMqttTrue,
-        .mqttVersion = 4,
-        .ackHandlerRepeatCountWarning = 6,
-        .ackHandlerCountWarning = 20,
-        .autoReconnectFlag = RyanMqttTrue,
-        .cleanSessionFlag = RyanMqttFalse,
-        .reconnectTimeout = 3000,
-        .recvTimeout = 5000,
-        .sendTimeout = 2000,
-        .ackTimeout = 10000,
-        .keepaliveTimeoutS = 120,
-        .mqttEventHandle = mqttEventHandle,
-        .userData = NULL};
-
-    // 初始化mqtt客户端
-    result = RyanMqttInit(&client);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
-
-    // 注册需要的事件回调
-    result = RyanMqttRegisterEventId(client, RyanMqttEventAnyId);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
-
-    // 设置mqtt客户端config
-    result = RyanMqttSetConfig(client, &mqttConfig);
-    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_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, rlog_d);
-    return 0;
-}
-
 /**
  * @brief mqtt msh命令
  *
@@ -320,13 +238,58 @@ static int MqttState(int argc, char *argv[])
  */
 static int MqttConnect(int argc, char *argv[])
 {
-
     if (RyanMqttConnectState == RyanMqttGetState(client))
     {
         rlog_w("mqtt客户端没有连接");
         return 0;
     }
-    mqttConnectFun();
+
+    RyanMqttError_e result = RyanMqttSuccessError;
+    RyanMqttClientConfig_t mqttConfig = {
+        .clientId = RyanMqttClientId,
+        .userName = RyanMqttUserName,
+        .password = RyanMqttPassword,
+        .host = RyanMqttHost,
+        .port = RyanMqttPort,
+        .taskName = "mqttThread",
+        .taskPrio = 16,
+        .taskStack = 2048,
+        .recvBufferSize = sizeof(mqttRecvBuffer),
+        .sendBufferSize = sizeof(mqttSendBuffer),
+        .recvBuffer = mqttRecvBuffer,
+        .sendBuffer = mqttSendBuffer,
+        .mqttVersion = 4,
+        .ackHandlerRepeatCountWarning = 6,
+        .ackHandlerCountWarning = 20,
+        .autoReconnectFlag = RyanMqttTrue,
+        .cleanSessionFlag = RyanMqttFalse,
+        .reconnectTimeout = 3000,
+        .recvTimeout = 5000,
+        .sendTimeout = 2000,
+        .ackTimeout = 10000,
+        .keepaliveTimeoutS = 120,
+        .mqttEventHandle = mqttEventHandle,
+        .userData = NULL};
+
+    // 初始化mqtt客户端
+    result = RyanMqttInit(&client);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
+
+    // 注册需要的事件回调
+    result = RyanMqttRegisterEventId(client, RyanMqttEventAnyId);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_d);
+
+    // 设置mqtt客户端config
+    result = RyanMqttSetConfig(client, &mqttConfig);
+    RyanMqttCheck(RyanMqttSuccessError == result, result, rlog_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, rlog_d);
     return 0;
 }
 
@@ -385,7 +348,7 @@ static int Mqttpublish(int argc, char *argv[])
 {
     if (argc < 7)
     {
-        rlog_i("请输入 topic、 qos、 payload内容、 发送条数、 间隔时间(可以为0) ");
+        rlog_w("参数不完整! 请输入 topic、 qos、 payload内容、 发送条数、 间隔时间(可以为0) ");
         return 0;
     }
 
@@ -412,7 +375,7 @@ static int Mqttpublish(int argc, char *argv[])
     }
 
     delay(3000);
-    LOG_E("pubCount: %d", pubCount);
+    rlog_w("pubCount: %d", pubCount);
     return 0;
 }
 
@@ -427,7 +390,7 @@ static int Mqttsubscribe(int argc, char *argv[])
 {
     if (argc < 4)
     {
-        rlog_i("请输入 topic、 qos ");
+        rlog_w("参数不完整! 请输入 topic、 qos ");
         return 0;
     }
 
@@ -452,7 +415,7 @@ static int MqttUnSubscribe(int argc, char *argv[])
 {
     if (argc < 3)
     {
-        rlog_i("请输入 取消订阅主题");
+        rlog_w("参数不完整! 请输入 取消订阅主题");
         return 0;
     }
 
@@ -481,18 +444,19 @@ static int MqttListSubscribe(int argc, char *argv[])
         return 0;
     }
 
-    RyanMqttMsgHandler_t msgHandles[10] = {0};
+    RyanMqttMsgHandler_t msgHandles[100] = {0};
     int32_t subscribeNum = 0;
     int32_t result = RyanMqttSuccessError;
 
     result = RyanMqttGetSubscribe(client, msgHandles, sizeof(msgHandles) / sizeof(msgHandles[0]), &subscribeNum);
 
     if (result == RyanMqttNoRescourceError)
-        rlog_w("订阅主题数超过10个，已截断");
+        rlog_w("订阅主题数超过缓冲区%d个，已截断，请修改msgHandles缓冲区", sizeof(msgHandles) / sizeof(msgHandles[0]));
+
     rlog_i("mqtt客户端已订阅的主题数: %d", subscribeNum);
 
     for (int32_t i = 0; i < subscribeNum; i++)
-        rlog_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;
 }
@@ -512,7 +476,7 @@ static int MqttListAck(int argc, char *argv[])
 
     if (RyanListIsEmpty(&client->ackHandlerList))
     {
-        rlog_i("ack链表为空");
+        rlog_w("ack链表为空，没有等待ack的消息");
         return 0;
     }
 
@@ -523,9 +487,9 @@ static int MqttListAck(int argc, char *argv[])
         ackHandler = RyanListEntry(curr, RyanMqttAckHandler_t, list);
 
         // 发送qos1 / qos2消息服务器ack响应超时。需要重新发送它们。
-        rlog_w(" type: %d, packetId is %d ", ackHandler->packetType, ackHandler->packetId);
+        rlog_i(" type: %d, packetId is %d ", ackHandler->packetType, ackHandler->packetId);
         if (NULL != ackHandler->msgHandler)
-            rlog_w("topic: %s, qos: %d", ackHandler->msgHandler->topic, ackHandler->msgHandler->qos);
+            rlog_i("topic: %s, qos: %d", ackHandler->msgHandler->topic, ackHandler->msgHandler->qos);
     }
     return 0;
 }
@@ -545,14 +509,14 @@ static int MqttListMsg(int argc, char *argv[])
 
     if (RyanListIsEmpty(&client->msgHandlerList))
     {
-        rlog_i("msg链表为空");
+        rlog_w("msg链表为空，没有等待的msg消息");
         return 0;
     }
 
     RyanListForEachSafe(curr, next, &client->msgHandlerList)
     {
         msgHandler = RyanListEntry(curr, RyanMqttMsgHandler_t, list);
-        rlog_w("topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
+        rlog_i("topic: %s, qos: %d", msgHandler->topic, msgHandler->qos);
     }
     return 0;
 }
@@ -573,10 +537,10 @@ static int Mqttdata(int argc, char *argv[])
         if (num < sizeof(mqttTest) / sizeof(mqttTest[0]) - 1)
             mqttTest[num] = 0;
         else
-            LOG_E("数组越界");
+            rlog_e("数组越界");
     }
 
-    rlog_i("dataEventCount: %d, publishCount:%u",
+    rlog_i("接收到数据次数统计: %d, qos1和qos2发布成功的次数统计: %d",
            mqttTest[dataEventCount], mqttTest[PublishedEventCount]);
 
     return 0;
@@ -584,26 +548,40 @@ static int Mqttdata(int argc, char *argv[])
 
 static const struct RyanMqttCmdDes cmdTab[] =
     {
+        // {"help",        "打印帮助信息               params: null", MqttHelp},
+        // {"state",       "打印mqtt客户端状态         params: null", MqttState},
+        // {"connect",     "mqtt客户端连接服务器       params: null", MqttConnect},
+        // {"disc",        "mqtt客户端断开连接         params: null", MqttDisconnect},
+        // {"reconnect",   "mqtt断开连接时重新连接     params: null", MqttReconnect},
+        // {"destory",     "mqtt销毁客户端             params: null", MqttDestroy},
+        // {"pub",         "mqtt发布消息               params: topic、 qos、 payload内容、 发送条数、 间隔时间(可以为0)", Mqttpublish},
+        // {"sub",         "mqtt订阅主题               params: topic、 qos", Mqttsubscribe},
+        // {"unsub",       "mqtt取消订阅主题           params: 取消订阅主题", MqttUnSubscribe},
+        // {"listsub",     "mqtt获取已订阅主题         params: null", MqttListSubscribe},
+        // {"listack",     "打印ack链表                params: null", MqttListAck},
+        // {"listmsg",     "打印msg链表                params: null", MqttListMsg},
+        // {"data",        "打印测试信息用户自定义的    params: null", Mqttdata},
+
         {"help", "打印帮助信息", MqttHelp},
-        {"state", "打印mqtt客户端状态   params: null", MqttState},
-        {"connect", "mqtt客户端连接服务器   params: null", MqttConnect},
-        {"disc", "mqtt客户端断开连接    params: null", MqttDisconnect},
-        {"reconnect", "mqtt断开连接时,重新连接mqtt服务器    params: null", MqttReconnect},
-        {"destory", "mqtt销毁客户端    params: null", MqttDestroy},
-        {"pub", "mqtt发布消息   params: topic、 qos、 payload内容、 发送条数、 间隔时间(可以为0)", Mqttpublish},
-        {"sub", "mqtt订阅主题   params: topic、 qos", Mqttsubscribe},
-        {"unsub", "mqtt取消订阅主题    params: 取消订阅主题", MqttUnSubscribe},
-        {"listsub", "mqtt获取已订阅主题    params: null", MqttListSubscribe},
-        {"listack", "打印ack链表    params: null", MqttListAck},
-        {"listmsg", "打印msg链表    params: null", MqttListMsg},
-        {"data", "打印测试信息，用户自定义的    params: null", Mqttdata},
+        {"state", "打印mqtt客户端状态         params: null", MqttState},
+        {"connect", "mqtt客户端连接服务器       params: null", MqttConnect},
+        {"disc", "mqtt客户端断开连接         params: null", MqttDisconnect},
+        {"reconnect", "mqtt断开连接时重新连接     params: null", MqttReconnect},
+        {"destory", "mqtt销毁客户端             params: null", MqttDestroy},
+        {"pub", "mqtt发布消息               params: topic、 qos、 payload内容、 发送条数、 间隔时间(可以为0)", Mqttpublish},
+        {"sub", "mqtt订阅主题               params: topic、 qos", Mqttsubscribe},
+        {"unsub", "mqtt取消订阅主题           params: 取消订阅主题", MqttUnSubscribe},
+        {"listsub", "mqtt获取已订阅主题         params: null", MqttListSubscribe},
+        {"listack", "打印ack链表                params: null", MqttListAck},
+        {"listmsg", "打印msg链表                params: null", MqttListMsg},
+        {"data", "打印测试信息用户自定义的   params: null", Mqttdata},
 };
 
 static int MqttHelp(int argc, char *argv[])
 {
 
     for (uint8_t i = 0; i < sizeof(cmdTab) / sizeof(cmdTab[0]); i++)
-        rt_kprintf("mqtt %-16s %s\r\n", cmdTab[i].cmd, cmdTab[i].explain);
+        rlog_raw("mqtt %-16s %s\r\n", cmdTab[i].cmd, cmdTab[i].explain);
 
     return 0;
 }

mqttclient/RyanMqttClient.c

@@ -477,6 +477,7 @@ RyanMqttError_e RyanMqttGetSubscribe(RyanMqttClient_t *client, RyanMqttMsgHandle
 
 /**
  * @brief 设置mqtt config 这是很危险的操作，需要考虑mqtt thread线程和用户线程的资源互斥
+ * todo 此函数没有实现完整------
  * 推荐在 RyanMqttStart函数前 / 非用户手动触发的事件回调函数中 / mqtt thread处于挂起状态时调用
  * mqtt thread处于阻塞状态时调用此函数也是很危险的行为，因为无法确定此函数的执行时间，调用此函数的任务运行时间片有多少
  * 总之就是要保证mqtt线程和用户线程的资源互斥
@@ -540,22 +541,9 @@ RyanMqttError_e RyanMqttSetConfig(RyanMqttClient_t *client, RyanMqttClientConfig
 
     client->config->recvBufferSize = clientConfig->recvBufferSize;
     client->config->sendBufferSize = clientConfig->sendBufferSize;
-    client->config->recvBufferStaticFlag = clientConfig->recvBufferStaticFlag;
-    client->config->sendBufferStaticFlag = clientConfig->sendBufferStaticFlag;
     client->config->recvBuffer = clientConfig->recvBuffer;
     client->config->sendBuffer = clientConfig->sendBuffer;
 
-    if (RyanMqttTrue != client->config->recvBufferStaticFlag)
-    {
-        client->config->recvBuffer = (char *)platformMemoryMalloc(client->config->recvBufferSize);
-        RyanMqttCheckCode(NULL != client->config->recvBuffer, RyanMqttFailedError, rlog_d, { goto __exit; });
-    }
-
-    if (RyanMqttTrue != client->config->sendBufferStaticFlag)
-    {
-        client->config->sendBuffer = (char *)platformMemoryMalloc(client->config->sendBufferSize);
-        RyanMqttCheckCode(NULL != client->config->sendBuffer, RyanMqttFailedError, rlog_d, { goto __exit; });
-    }
     return RyanMqttSuccessError;
 
 __exit:

mqttclient/RyanMqttClient.h

@@ -71,8 +71,6 @@ extern "C"
         char *taskName;                        // 线程名字
         char *recvBuffer;                      // mqtt接收缓冲区
         char *sendBuffer;                      // mqtt发送缓冲区
-        uint8_t recvBufferStaticFlag : 1;      // 接收缓冲区是静态空间,不是动态申请
-        uint8_t sendBufferStaticFlag : 1;      // 发送缓冲区是静态空间,不是动态申请
         uint8_t autoReconnectFlag : 1;         // 自动重连标志位
         uint8_t cleanSessionFlag : 1;          // 清除会话标志位
         uint8_t mqttVersion : 4;               // mqtt版本 3.1.1是4, 3.1是3

mqttclient/RyanMqttThread.c

@@ -17,7 +17,7 @@
  * @param client
  * @return int32_t
  */
-RyanMqttError_e RyanMqttKeepalive(RyanMqttClient_t *client)
+static RyanMqttError_e RyanMqttKeepalive(RyanMqttClient_t *client)
 {
     int32_t connectState = RyanMqttConnectAccepted;
     int32_t packetLen = 0;
@@ -408,7 +408,7 @@ static RyanMqttError_e RyanMqttUnSubackHandler(RyanMqttClient_t *client)
  * @param packetType
  * @return RyanMqttError_e
  */
-RyanMqttError_e RyanMqttReadPacketHandler(RyanMqttClient_t *client, uint8_t *packetType)
+static RyanMqttError_e RyanMqttReadPacketHandler(RyanMqttClient_t *client, uint8_t *packetType)
 {
     RyanMqttError_e result = RyanMqttSuccessError;
     int32_t fixedHeaderLen = 1;
@@ -498,7 +498,7 @@ RyanMqttError_e RyanMqttReadPacketHandler(RyanMqttClient_t *client, uint8_t *pac
  *      WaitFlag : RyanMqttFalse 表示不需要等待超时立即处理这些数据包。通常在重新连接后立即进行处理
  *      WaitFlag : RyanMqttTrue 表示需要等待超时再处理这些消息，一般是稳定连接下的超时处理
  */
-void RyanMqttAckListScan(RyanMqttClient_t *client, RyanMqttBool_e WaitFlag)
+static void RyanMqttAckListScan(RyanMqttClient_t *client, RyanMqttBool_e WaitFlag)
 {
     RyanList_t *curr = NULL,
                *next = NULL;
@@ -574,7 +574,7 @@ void RyanMqttAckListScan(RyanMqttClient_t *client, RyanMqttBool_e WaitFlag)
  * @param client
  * @return RyanMqttError_e
  */
-RyanMqttError_e RyanMqttConnect(RyanMqttClient_t *client)
+static RyanMqttError_e RyanMqttConnect(RyanMqttClient_t *client)
 {
 
     RyanMqttError_e result = RyanMqttSuccessError;
@@ -698,6 +698,7 @@ void RyanMqttThread(void *argument)
     while (1)
     {
 
+        // 销毁客户端
         if (RyanMqttTrue == client->destoryFlag)
         {
 
@@ -722,12 +723,6 @@ void RyanMqttThread(void *argument)
             // 清除config信息
             if (NULL != client->config)
             {
-                if (RyanMqttTrue != client->config->recvBufferStaticFlag && NULL != client->config->recvBuffer)
-                    platformMemoryFree(client->config->recvBuffer);
-
-                if (RyanMqttTrue != client->config->sendBufferStaticFlag && NULL != client->config->sendBuffer)
-                    platformMemoryFree(client->config->sendBuffer);
-
                 if (NULL != client->config->clientId)
                     platformMemoryFree(client->config->clientId);
 
@@ -773,6 +768,7 @@ void RyanMqttThread(void *argument)
             platformThreadDestroy(client->config->userData, client->mqttThread);
         }
 
+        // 客户端状态变更状态机
         switch (client->clientState)
         {
 

mqttclient/RyanMqttUtile.c

@@ -167,14 +167,14 @@ RyanMqttState_e RyanMqttGetClientState(RyanMqttClient_t *client)
  * @return RyanMqttBool_e
  */
 RyanMqttBool_e RyanMqttMatchTopic(const char *topic,
-                              const uint16_t topicLength,
-                              const char *topicFilter,
-                              const uint16_t topicFilterLength)
+                                  const uint16_t topicLength,
+                                  const char *topicFilter,
+                                  const uint16_t topicFilterLength)
 {
 
     RyanMqttBool_e topicFilterStartsWithWildcard = RyanMqttFalse,
-               matchFound = RyanMqttFalse,
-               shouldStopMatching = RyanMqttFalse;
+                   matchFound = RyanMqttFalse,
+                   shouldStopMatching = RyanMqttFalse;
     uint16_t topicIndex = 0,
              topicFilterIndex = 0;
 

platform/quecOpen/platformSystem.c

@@ -1,21 +1,27 @@
 
 #include "platformSystem.h"
 
+/**
+ * @brief 申请内存
+ *
+ * @param size
+ * @return void*
+ */
 void *platformMemoryMalloc(size_t size)
 {
     return malloc(size);
 }
 
+/**
+ * @brief 释放内存
+ *
+ * @param ptr
+ */
 void platformMemoryFree(void *ptr)
 {
     free(ptr);
 }
 
-void platformPrint(char *str, uint16_t strLen)
-{
-    printf("%.*s", strLen, str);
-}
-
 /**
  * @brief ms延时
  *
@@ -26,6 +32,17 @@ void platformDelay(uint32_t ms)
     osDelay(ms);
 }
 
+/**
+ * @brief 打印字符串函数,可通过串口打印出去
+ *
+ * @param str
+ * @param strLen
+ */
+void platformPrint(char *str, uint16_t strLen)
+{
+    Ql_UART_Write((Enum_SerialPort)(UART_PORT0), (u8 *)(str), strLen);
+}
+
 /**
  * @brief 初始化并运行线程
  *
@@ -162,7 +179,6 @@ RyanMqttError_e platformMutexUnLock(void *userData, platformMutex_t *platformMut
  */
 void platformCriticalEnter(void)
 {
-    // rt_enter_critical();
     osKernelLock();
 }
 
@@ -172,6 +188,5 @@ void platformCriticalEnter(void)
  */
 void platformCriticalExit(void)
 {
-    // rt_exit_critical();
     osKernelUnlock();
 }

platform/quecOpen/platformSystem.h

@@ -8,17 +8,16 @@ extern "C"
 #endif
 
 #include <stdio.h>
-
 #include <stdint.h>
 #include <assert.h>
 #include "cmsis_os2.h"
+#include "ql_uart.h"
 #include "RyanMqttPublic.h"
 
 #define RyanMqttAssert(EX) assert(EX)
 
     typedef struct
     {
-
         osThreadId_t thread;
     } platformThread_t;
 

platform/rtthread/platformNetwork.c

@@ -1,7 +1,7 @@
-#define rlogEnable 1             // 是否使能日志
-#define rlogColorEnable 1        // 是否使能日志颜色
+#define rlogEnable 1               // 是否使能日志
+#define rlogColorEnable 1          // 是否使能日志颜色
 #define rlogLevel (rlogLvlWarning) // 日志打印等级
-#define rlogTag "RyanMqttNet"    // 日志tag
+#define rlogTag "RyanMqttNet"      // 日志tag
 
 #include "platformNetwork.h"
 #include "RyanMqttLog.h"
@@ -159,7 +159,7 @@ RyanMqttError_e platformNetworkSendAsync(void *userData, platformNetwork_t *plat
 
         sendResult = send(platformNetwork->socket, sendBuf + offset, sendLen - offset, 0);
 
-        if (sendResult < 0) // 小于零，表示错误，个别错误不代表socket错误
+        if (sendResult <= 0) // 小于零，表示错误，个别错误不代表socket错误
         {
             // 下列3种表示没问题,但需要推出发送
             if ((errno == EAGAIN ||      // 套接字已标记为非阻塞，而接收操作被阻塞或者接收超时

platform/rtthread/platformSystem.c

@@ -1,12 +1,22 @@
 
 #include "platformSystem.h"
 
-// 存放未初始化
+/**
+ * @brief 申请内存
+ *
+ * @param size
+ * @return void*
+ */
 void *platformMemoryMalloc(size_t size)
 {
     return rt_malloc(size);
 }
 
+/**
+ * @brief 释放内存
+ *
+ * @param ptr
+ */
 void platformMemoryFree(void *ptr)
 {
     rt_free(ptr);
@@ -22,13 +32,17 @@ void platformDelay(uint32_t ms)
     rt_thread_mdelay(ms);
 }
 
+/**
+ * @brief 打印字符串函数,可通过串口打印出去
+ *
+ * @param str
+ * @param strLen
+ */
 void platformPrint(char *str, uint16_t strLen)
 {
-    printf("%.*s", strLen, str);
+    rt_kprintf("%.*s", strLen, str);
 }
 
-#define RyanLogPrintf(str, strlen) printf("%.*s", strlen, str)
-
 /**
  * @brief 初始化并运行线程
  *
@@ -64,7 +78,7 @@ RyanMqttError_e platformThreadInit(void *userData,
 }
 
 /**
- * @brief 销毁指定线程
+ * @brief 销毁自身线程
  *
  * @param userData
  * @param platformThread