修改log组件、对可能资源竞争的添加保护(还不完整)

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.associations": {
+        "ryanw5500store.h": "c"
+    }
+}

W5500Client/RyanW5500.c

@@ -1,8 +1,7 @@
-#define DBG_ENABLE
-
-#define DBG_SECTION_NAME ("w5500")
-#define DBG_LEVEL LOG_LVL_INFO
-#define DBG_COLOR
+#define rlogEnable 1               // 是否使能日志
+#define rlogColorEnable 1          // 是否使能日志颜色
+#define rlogLevel (rlogLvlWarning) // 日志打印等级
+#define rlogTag "W5500"            // 日志tag
 
 #include "RyanW5500Store.h"
 
@@ -13,7 +12,6 @@
  */
 void RyanW5500IRQCallback(void *argument)
 {
-    LOG_D("中断");
     rt_event_send(RyanW5500Entry.W5500EventHandle, RyanW5500IRQBit);
 }
 
@@ -74,14 +72,14 @@ int RyanW5500NetWorkInit(struct netdev *netdev)
     {
         if (getDHCPRemainLeaseTime() < 10 * 1000) // 如果租期只剩余10秒，重新获取ip
         {
-            LOG_I("dhcp租期接近超时, 重新获取ip");
+            rlog_i("dhcp租期接近超时, 重新获取ip");
             MaintainFlag = 0;
             goto next;
         }
 
         if (getDHCPRemainLeaseTime() < (getDHCPLeaseTime() / 2)) // 超过一半就开始续租
         {
-            LOG_I("dhcp续租");
+            rlog_i("dhcp续租");
             MaintainFlag = 1;
             goto next;
         }
@@ -94,7 +92,7 @@ int RyanW5500NetWorkInit(struct netdev *netdev)
 
     if (PHY_LINK_ON == linkState) // w5500处于link状态，更新信息后就退出
     {
-        LOG_D("link State: %d\r\n", linkState);
+        rlog_d("link State: %d\r\n", linkState);
         RyanW5500NetDevInfoUpdate(netdev);
         return 0;
     }
@@ -152,6 +150,9 @@ static void wizIntDataTask(void *parameter)
     // 检查w5500连接是否正常
     while (1)
     {
+
+        RyanW5500Reset(); // 重启w5500
+
         // 超时中断触发为retry_cnt * time_100us * 100us
         struct wiz_NetTimeout_t net_timeout = {
             .retry_cnt = 5,      // 重试次数
@@ -164,9 +165,11 @@ static void wizIntDataTask(void *parameter)
         if (5 == net_timeout.retry_cnt && 2000 == net_timeout.time_100us)
             break;
 
-        LOG_E("Wiznet chip not detected");
-        delay(1000);
+        rlog_e("没有监测到w5500");
+
+        delay(2000);
     }
+    netdev_low_level_set_status(netdev, RT_TRUE); // 设置网络接口设备状态
 
     platformTimerCutdown(&netWorkTimer, 0);
 
@@ -177,7 +180,7 @@ static void wizIntDataTask(void *parameter)
         {
             if (-1 == RyanW5500NetWorkInit(netdev))
             {
-                LOG_D("网络没有连接");
+                rlog_d("网络没有连接");
                 delay(1000);
                 continue;
             }
@@ -186,7 +189,7 @@ static void wizIntDataTask(void *parameter)
         }
 
         rt_event_recv(RyanW5500Entry.W5500EventHandle, RyanW5500IRQBit,
-                      RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
+                      RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
                       1000, NULL);
 
         while (1)
@@ -207,7 +210,7 @@ static void wizIntDataTask(void *parameter)
                     continue;
 
                 // setSIR(socket); // 清除当前socket中断  setSn_IR时w5500内部会自动清除
-                // Sn_IR_SENDOK Sn_IR_TIMEOUT wiz官方库有使用，这里不使用
+                // Sn_IR_SENDOK和Sn_IR_TIMEOUT wiz官方库有使用，这里不使用
                 sn_ir = 0;
                 sn_ir = getSn_IR(socket);         // 获取中断类型消息
                 setSn_IR(socket, RyanW5500SnIMR); // 清除中断类型消息
@@ -215,18 +218,18 @@ static void wizIntDataTask(void *parameter)
                 if (sn_ir & Sn_IR_RECV) // 接收到了对方数据
                 {
                     RyanW5500RecvDataCallback(socket);
-                    LOG_D("接收到数据");
+                    rlog_d("接收到数据");
                 }
 
                 if (sn_ir & Sn_IR_DISCON) // 当接收到对方的 FIN or FIN/ACK 包时
                 {
                     RyanW5500CloseCallback(socket);
-                    LOG_D("断开连接");
+                    rlog_d("断开连接");
                 }
 
                 if (sn_ir & Sn_IR_CON) // 成功与对方建立连接
                 {
-                    LOG_D("连接成功");
+                    rlog_d("连接成功");
                     RyanW5500Socket *clientSock = RyanW5500GetSock(socket);
                     if (-1 == clientSock->serviceSocket)
                         continue;
@@ -260,14 +263,12 @@ int RyanW5500Init(wiz_NetInfo *netInfo)
     reg_wizchip_spi_cbfunc(RyanW5500ReadByte, RyanW5500WriteByte);          // 注册读写函数
     reg_wizchip_spiburst_cbfunc(RyanW5500ReadBurst, RyanW5500WriteBurst);   // 注册多个字节读写
 
-    RyanW5500Reset(); // 重启w5500
-
     RyanW5500Entry.socketMutexHandle = rt_mutex_create("RyanW5500SocketMutex", RT_IPC_FLAG_FIFO);
     RyanW5500Entry.W5500EventHandle = rt_event_create("RyanW5500Event", RT_IPC_FLAG_PRIO);
     RyanW5500AttachIRQ(RyanW5500IRQCallback); // 绑定w5500中断回调函数
 
     netdev = RyanW5500NetdevRegister("RyanW5500"); // W5500
-    netdev_low_level_set_status(netdev, RT_TRUE);  // 设置网络接口设备状态
+    netdev_low_level_set_status(netdev, RT_FALSE); // 设置网络接口设备状态
 
     RyanW5500Entry.w5500TaskHandle = rt_thread_create("RyanW5500",    // 线程name
                                                       wizIntDataTask, // 线程入口函数

W5500Client/RyanW5500Ping.c

@@ -1,8 +1,7 @@
-#define DBG_ENABLE
-
-#define DBG_SECTION_NAME ("RyanW5500Ping")
-#define DBG_LEVEL LOG_LVL_INFO
-#define DBG_COLOR
+#define rlogEnable 1               // 是否使能日志
+#define rlogColorEnable 1          // 是否使能日志颜色
+#define rlogLevel (rlogLvlWarning) // 日志打印等级
+#define rlogTag "W5500Ping"        // 日志tag
 
 #include "RyanW5500Store.h"
 
@@ -151,7 +150,7 @@ static int wiz_ping_reply(int socket, struct sockaddr *from)
         break;
 
     default:
-        LOG_W("unknown ping receive message.");
+        rlog_w("unknown ping receive message.");
         return -1;
     }
 
@@ -167,7 +166,7 @@ int RyanW5500Ping(struct netdev *netdev, const char *host, size_t data_len, uint
     hostent = wiz_gethostbyname(host);
     if (NULL == hostent || NULL == hostent->h_addr_list[0])
     {
-        LOG_W("hostent is NULL.");
+        rlog_w("hostent is NULL.");
         return -RT_FALSE;
     }
 
@@ -177,7 +176,7 @@ int RyanW5500Ping(struct netdev *netdev, const char *host, size_t data_len, uint
     socket = wiz_socket(AF_WIZ, SOCK_RAW, 0);
     if (socket < 0)
     {
-        LOG_W("create ping socket(%d) failed.", socket);
+        rlog_w("create ping socket(%d) failed.", socket);
         return -1;
     }
 
@@ -188,11 +187,8 @@ int RyanW5500Ping(struct netdev *netdev, const char *host, size_t data_len, uint
                               .tv_usec = times % 1000 * 1000};
 
     // 设置接收和发送超时选项
-    wiz_setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout,
-                   sizeof(timeout));
-
-    wiz_setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (void *)&timeout,
-                   sizeof(timeout));
+    wiz_setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout, sizeof(timeout));
+    wiz_setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (void *)&timeout, sizeof(timeout));
 
     struct sockaddr_in server_addr = {.sin_family = AF_WIZ,
                                       .sin_port = htons(WIZ_PING_PORT),

W5500Client/RyanW5500Socket.c

@@ -1,8 +1,7 @@
-#define DBG_ENABLE
-
-#define DBG_SECTION_NAME ("RyanW5500Socket")
-#define DBG_LEVEL LOG_LVL_INFO
-#define DBG_COLOR
+#define rlogEnable 1               // 是否使能日志
+#define rlogColorEnable 1          // 是否使能日志颜色
+#define rlogLevel (rlogLvlWarning) // 日志打印等级
+#define rlogTag "W5500Socket"      // 日志tag
 
 #include "RyanW5500Store.h"
 
@@ -30,7 +29,7 @@ int RyanW5500RecvDataCallback(int socket)
     RyanW5500Socket *sock = NULL;
 
     sock = RyanW5500GetSock(socket);
-    RyanW5500CheckCode(NULL != sock, EBADF, { return -1; });
+    RyanW5500CheckCode(NULL != sock, EBADF, rlog_d, { return -1; });
 
     rt_event_send(RyanW5500Entry.W5500EventHandle, 1 << sock->socket);
     return 0;
@@ -47,7 +46,7 @@ int RyanW5500CloseCallback(int socket)
     RyanW5500Socket *sock = NULL;
 
     sock = RyanW5500GetSock(socket);
-    RyanW5500CheckCode(NULL != sock, EBADF, { return -1; });
+    RyanW5500CheckCode(NULL != sock, EBADF, rlog_d, { return -1; });
 
     sock->state = RyanW5500SocketClose;
     rt_event_send(RyanW5500Entry.W5500EventHandle, 1 << sock->socket);
@@ -62,8 +61,8 @@ int RyanW5500CloseCallback(int socket)
  */
 void inAddrToipStrArr(in_addr_t *s_addr, uint8_t *ipStrArr)
 {
-    assert(NULL != s_addr);
-    assert(NULL != ipStrArr);
+    RT_ASSERT(NULL != s_addr);
+    RT_ASSERT(NULL != ipStrArr);
 
     // inet_pton(AF_INET, inet_ntoa(sin->sin_addr), &ipStrArr); // 效率有点低
     uint8_t *p = (uint8_t *)s_addr;
@@ -81,7 +80,7 @@ void inAddrToipStrArr(in_addr_t *s_addr, uint8_t *ipStrArr)
  */
 in_addr_t ipStrArrToinAddr(uint8_t *ipStrArr)
 {
-    assert(NULL != ipStrArr);
+    RT_ASSERT(NULL != ipStrArr);
 
     // 效率有点低
     // char remote_ipaddr[16] = {0};
@@ -106,11 +105,17 @@ in_addr_t ipStrArrToinAddr(uint8_t *ipStrArr)
 RyanW5500Socket *RyanW5500GetSock(int socket)
 {
     if (socket < 0 || socket >= RyanW5500MaxSocketNum)
+    {
+        rlog_w("socket 越界");
         return NULL;
+    }
 
     // 检查套接字结构是否有效
     if (RyanW5500Sockets[socket].magic != WIZ_SOCKET_MAGIC)
+    {
+        rlog_w("套接字结构无效");
         return NULL;
+    }
 
     return &RyanW5500Sockets[socket];
 }
@@ -123,24 +128,24 @@ RyanW5500Socket *RyanW5500GetSock(int socket)
  */
 RyanW5500Socket *RyanW5500CreateListenClient(RyanW5500Socket *serviceSock)
 {
-    assert(NULL != serviceSock);
+    RT_ASSERT(NULL != serviceSock);
 
     RyanW5500Socket *clientSock = NULL;
     RyanW5500ClientInfo *clientInfo = NULL;
     clientSock = RyanW5500SocketCreate(serviceSock->type, serviceSock->port);
-    RyanW5500CheckCode(NULL != clientSock, EMFILE, { goto err; });
+    RyanW5500CheckCode(NULL != clientSock, EMFILE, rlog_d, { goto err; });
 
     clientSock->serviceSocket = serviceSock->socket;
 
     // 创建客户端信息并将客户端添加到服务器clientList
     clientInfo = (RyanW5500ClientInfo *)malloc(sizeof(RyanW5500ClientInfo));
-    RyanW5500CheckCode(NULL != clientInfo, ENOMEM, { goto err; });
+    RyanW5500CheckCode(NULL != clientInfo, ENOMEM, rlog_d, { goto err; });
     memset(clientInfo, 0, sizeof(RyanW5500ClientInfo));
 
     clientInfo->sock = clientSock;
     RyanListAddTail(&clientInfo->list, &serviceSock->serviceInfo->clientList);
 
-    RyanW5500CheckCode(SOCK_OK == wizchip_listen(clientSock->socket), EPROTO, {wiz_closesocket(clientSock->socket); goto err; });
+    RyanW5500CheckCode(SOCK_OK == wizchip_listen(clientSock->socket), EPROTO, rlog_d, {wiz_closesocket(clientSock->socket); goto err; });
     clientSock->state = RyanW5500SocketListen;
 
     return clientSock;
@@ -158,8 +163,9 @@ static void RyanW5500ListenSocketDestory(RyanW5500Socket *sock)
 {
 
     RyanW5500Socket *serviceSock = RyanW5500GetSock(sock->serviceSocket);
-    assert(NULL != serviceSock);
-    assert(NULL != serviceSock->serviceInfo && sock->port == serviceSock->port);
+    RT_ASSERT(NULL != serviceSock);
+    RT_ASSERT(NULL != serviceSock->serviceInfo);
+    RT_ASSERT(sock->port == serviceSock->port);
 
     // 分配并初始化新的客户端套接字
     RyanList_t *curr = NULL,
@@ -170,22 +176,22 @@ static void RyanW5500ListenSocketDestory(RyanW5500Socket *sock)
     {
         // 获取此节点的结构体
         clientInfo = RyanListEntry(curr, RyanW5500ClientInfo, list);
-        assert(NULL != clientInfo);
+        RT_ASSERT(NULL != clientInfo);
         if (clientInfo->sock->socket != sock->socket)
             continue;
 
         RyanListDel(&clientInfo->list);
 
-        // 增加listen客户端数
-        if (0 == serviceSock->serviceInfo->backlog)
-        {
-            RyanW5500Socket *sock = RyanW5500CreateListenClient(serviceSock);
-            if (NULL == sock)
-            {
-                int8_t socket = -1;
-                rt_mq_send(serviceSock->serviceInfo->clientInfoQueueHandle, &socket, sizeof(int8_t));
-            }
-        }
+        // // 增加listen客户端数
+        // if (0 == serviceSock->serviceInfo->backlog)
+        // {
+        //     RyanW5500Socket *sock = RyanW5500CreateListenClient(serviceSock);
+        //     if (NULL == sock)
+        //     {
+        //         int8_t socket = -1;
+        //         rt_mq_send(serviceSock->serviceInfo->clientInfoQueueHandle, &socket, sizeof(int8_t));
+        //     }
+        // }
 
         // 添加服务器套接字监听数
         serviceSock->serviceInfo->backlog++;
@@ -197,9 +203,12 @@ static void RyanW5500ListenSocketDestory(RyanW5500Socket *sock)
 static int RyanW5500SocketDestory(RyanW5500Socket *sock)
 {
 
-    assert(NULL != sock);
+    RT_ASSERT(NULL != sock);
+
+    rt_mutex_take(RyanW5500Entry.socketMutexHandle, RT_WAITING_FOREVER); //
+    if (sock->magic != WIZ_SOCKET_MAGIC)
+        goto next;
 
-    rt_mutex_take(RyanW5500Entry.socketMutexHandle, RT_WAITING_FOREVER); // 获取互斥锁
     if (sock->remoteAddr)
         free(sock->remoteAddr);
 
@@ -237,6 +246,8 @@ static int RyanW5500SocketDestory(RyanW5500Socket *sock)
     setSn_IR(sock->socket, 0xff); // 清空套接字中断
     setSn_IMR(sock->socket, 0);   // 设置套接字ISR状态支持
     memset(sock, 0, sizeof(RyanW5500Socket));
+
+next:
     rt_mutex_release(RyanW5500Entry.socketMutexHandle); // 释放互斥锁
     return 0;
 }
@@ -256,11 +267,13 @@ RyanW5500Socket *RyanW5500SocketCreate(int type, int port)
 
     rt_mutex_take(RyanW5500Entry.socketMutexHandle, RT_WAITING_FOREVER); // 获取互斥锁
     // 找到一个空的 WIZnet 套接字条目
-    for (idx = 0; idx < RyanW5500MaxSocketNum && RyanW5500Sockets[idx].magic; idx++)
+    for (idx = 0; idx < RyanW5500MaxSocketNum && WIZ_SOCKET_MAGIC == RyanW5500Sockets[idx].magic; idx++)
         ;
 
     // 没有空闲socket
-    RyanW5500CheckCode(RyanW5500MaxSocketNum != idx, EMFILE, { goto err; });
+    RyanW5500CheckCode(RyanW5500MaxSocketNum != idx, EMFILE, rlog_d, {
+                        rt_mutex_release(RyanW5500Entry.socketMutexHandle); // 释放互斥锁
+                        goto err; });
 
     sock = &(RyanW5500Sockets[idx]);
     sock->magic = WIZ_SOCKET_MAGIC;
@@ -283,14 +296,13 @@ RyanW5500Socket *RyanW5500SocketCreate(int type, int port)
     int8_t result = wizchip_socket(sock->socket, sock->type, sock->port, 0); // wizchip_socket内部会先close一次
     if (result != sock->socket)
     {
-        LOG_E("RyanW5500 socket(%d) create failed!  result: %d", sock->socket, result);
+        rlog_e("RyanW5500 socket(%d) create failed!  result: %d", sock->socket, result);
         goto err;
     }
 
     return sock;
 
 err:
-    rt_mutex_release(RyanW5500Entry.socketMutexHandle); // 释放互斥锁
     wiz_closesocket(sock->socket);
     return NULL;
 }
@@ -304,9 +316,9 @@ err:
 void RyanListenServiceAddClient(RyanW5500Socket *serviceSock, RyanW5500Socket *clientSock)
 {
 
-    assert(NULL != serviceSock);
-    assert(NULL != clientSock);
-    assert(serviceSock->serviceInfo->backlog > 0);
+    RT_ASSERT(NULL != serviceSock);
+    RT_ASSERT(NULL != clientSock);
+    RT_ASSERT(serviceSock->serviceInfo->backlog > 0);
 
     int8_t socket = -1;
 
@@ -318,6 +330,7 @@ void RyanListenServiceAddClient(RyanW5500Socket *serviceSock, RyanW5500Socket *c
 
     if (serviceSock->serviceInfo->backlog > 0)
     {
+        rlog_w("listen回调连接");
         RyanW5500Socket *sock = RyanW5500CreateListenClient(serviceSock);
         if (NULL == sock)
         {
@@ -342,9 +355,9 @@ int wiz_socket(int domain, int type, int protocol)
     RyanW5500Socket *sock = NULL;
 
     // 该实现不支持指定的协议族类型。
-    RyanW5500CheckCode(AF_INET == domain || AF_WIZ == domain, EAFNOSUPPORT, { return -1; });
+    RyanW5500CheckCode(AF_INET == domain || AF_WIZ == domain, EAFNOSUPPORT, rlog_d, { return -1; });
     // 不支持特定的运输层协议
-    // RyanW5500CheckCode(0 == protocol, EPROTONOSUPPORT, { return -1; });
+    // RyanW5500CheckCode(0 == protocol, EPROTONOSUPPORT, rlog_d,  { return -1; });
 
     switch (type)
     {
@@ -355,12 +368,12 @@ int wiz_socket(int domain, int type, int protocol)
 
     default:
         // 协议不支持套接字类型
-        RyanW5500CheckCode(NULL, EPROTOTYPE, { return -1; });
+        RyanW5500CheckCode(NULL, EPROTOTYPE, rlog_d, { return -1; });
     }
 
     // 分配并初始化一个新的 WIZnet 套接字
     sock = RyanW5500SocketCreate(type, wiz_port);
-    RyanW5500CheckCode(NULL != sock, EMFILE, { return -1; });
+    RyanW5500CheckCode(NULL != sock, EMFILE, rlog_d, { return -1; });
 
     sock->state = RyanW5500SocketInit;
     wiz_port++;
@@ -384,10 +397,10 @@ int wiz_bind(int socket, const struct sockaddr *name, socklen_t namelen)
     RyanW5500Socket *sock = NULL;
     uint16_t port = 0;
 
-    RyanW5500CheckCode(NULL != name && 0 != namelen, EAFNOSUPPORT, { return -1; }); // 非法地址
+    RyanW5500CheckCode(NULL != name && 0 != namelen, EAFNOSUPPORT, rlog_d, { return -1; }); // 非法地址
 
     sock = RyanW5500GetSock(socket);
-    RyanW5500CheckCode(NULL != sock, EBADF, { return -1; });
+    RyanW5500CheckCode(NULL != sock, EBADF, rlog_d, { return -1; });
 
     // PRASE IP 地址和端口
     const struct sockaddr_in *sin = (const struct sockaddr_in *)name;
@@ -399,7 +412,7 @@ int wiz_bind(int socket, const struct sockaddr *name, socklen_t namelen)
     sock->port = port;
     // wizchip_socket内部会先close一次
     int8_t result = wizchip_socket(sock->socket, sock->type, sock->port, 0);
-    RyanW5500CheckCode(result == sock->socket, EMFILE, { return -1; });
+    RyanW5500CheckCode(result == sock->socket, EMFILE, rlog_d, { return -1; });
 
     sock->state = RyanW5500SocketInit;
 
@@ -417,13 +430,13 @@ int wiz_bind(int socket, const struct sockaddr *name, socklen_t namelen)
 int wiz_connect(int socket, const struct sockaddr *name, socklen_t namelen)
 {
     RyanW5500LinkCheck(-1);
-    RyanW5500CheckCode(NULL != name && 0 != namelen, EAFNOSUPPORT, { return -1; }); // 非法地址
+    RyanW5500CheckCode(NULL != name && 0 != namelen, EAFNOSUPPORT, rlog_d, { return -1; }); // 非法地址
 
     RyanW5500Socket *sock = NULL;
 
     sock = RyanW5500GetSock(socket);
-    RyanW5500CheckCode(NULL != sock, EBADF, { return -1; });
-    RyanW5500CheckCode(RyanW5500SocketInit == sock->state, EADDRINUSE, { return -1; }); // 尝试建立 已在使用的 / 未初始化 socket的连接。
+    RyanW5500CheckCode(NULL != sock, EBADF, rlog_d, { return -1; });
+    RyanW5500CheckCode(RyanW5500SocketInit == sock->state, EADDRINUSE, rlog_d, { return -1; }); // 尝试建立 已在使用的 / 未初始化 socket的连接。
 
     switch (getSn_SR(socket))
     {
@@ -432,7 +445,7 @@ int wiz_connect(int socket, const struct sockaddr *name, socklen_t namelen)
         if (NULL == sock->remoteAddr)
         {
             sock->remoteAddr = (struct sockaddr *)malloc(sizeof(struct sockaddr));
-            RyanW5500CheckCode(NULL != sock->remoteAddr, ENOMEM, { return -1; });
+            RyanW5500CheckCode(NULL != sock->remoteAddr, ENOMEM, rlog_d, { return -1; });
             memset(sock->remoteAddr, 0, sizeof(struct sockaddr));
         }
 
@@ -452,8 +465,8 @@ int wiz_connect(int socket, const struct sockaddr *name, socklen_t namelen)
         int result = wizchip_connect(socket, ipStrArr, htons(sin->sin_port));
         if (SOCK_OK != result)
         {
-            RyanW5500CheckCode(SOCKERR_IPINVALID != result, EAFNOSUPPORT, { return -1; }); // 无效的 IP 地址
-            RyanW5500CheckCode(SOCKERR_TIMEOUT != result, ETIMEDOUT, { return -1; });      // 连接超时
+            RyanW5500CheckCode(SOCKERR_IPINVALID != result, EAFNOSUPPORT, rlog_d, { return -1; }); // 无效的 IP 地址
+            RyanW5500CheckCode(SOCKERR_TIMEOUT != result, ETIMEDOUT, rlog_d, { return -1; });      // 连接超时
             return -1;
         }
     }
@@ -481,13 +494,14 @@ int wiz_listen(int socket, int backlog)
 
     RyanW5500Socket *sock = RyanW5500GetSock(socket);
 
-    RyanW5500CheckCode(NULL != sock, EBADF, { return -1; });                               // 套接字参数不是有效的文件描述符。
-    RyanW5500CheckCode(RyanW5500SocketEstablished != sock->state, EINVAL, { return -1; }); // 套接字已连接
-    RyanW5500CheckCode(Sn_MR_IPRAW != sock->type, EOPNOTSUPP, { return -1; });             // 套接字协议不支持 listen()
-    RyanW5500CheckCode(NULL == sock->serviceInfo, EINVAL, { return -1; });                 // 套接字第一次调用listen
+    RyanW5500CheckCode(NULL != sock, EBADF, rlog_d, { return -1; }); // 套接字参数不是有效的文件描述符。
+    RyanW5500CheckCode(WIZ_SOCKET_MAGIC == sock->magic, EIO, rlog_d, { return -1; });
+    RyanW5500CheckCode(RyanW5500SocketEstablished != sock->state, EINVAL, rlog_d, { return -1; }); // 套接字已连接
+    RyanW5500CheckCode(Sn_MR_IPRAW != sock->type, EOPNOTSUPP, rlog_d, { return -1; });             // 套接字协议不支持 listen()
+    RyanW5500CheckCode(NULL == sock->serviceInfo, EINVAL, rlog_d, { return -1; });                 // 套接字第一次调用listen
 
     sock->serviceInfo = (RyanW5500ServiceInfo *)malloc(sizeof(RyanW5500ServiceInfo));
-    RyanW5500CheckCode(NULL != sock->serviceInfo, ENOMEM, { goto err; });
+    RyanW5500CheckCode(NULL != sock->serviceInfo, ENOMEM, rlog_d, { goto err; });
     memset(sock->serviceInfo, 0, sizeof(RyanW5500ServiceInfo));
 
     // 创建listen客户端连接消息队列
@@ -497,11 +511,12 @@ int wiz_listen(int socket, int backlog)
 
     // BSD socket允许listen为0，这里消息队列创建1大小，为了appect可以阻塞
     sock->serviceInfo->clientInfoQueueHandle = rt_mq_create(name, sizeof(int8_t), backlog > 0 ? backlog : 1, RT_IPC_FLAG_FIFO);
-    RyanW5500CheckCode(NULL != sock->serviceInfo->clientInfoQueueHandle, ENOMEM, { goto err; });
+    RyanW5500CheckCode(NULL != sock->serviceInfo->clientInfoQueueHandle, ENOMEM, rlog_d, { goto err; });
 
     RyanListInit(&sock->serviceInfo->clientList);
     sock->state = RyanW5500SocketListen;
 
+    rlog_w("listen连接");
     if (NULL == RyanW5500CreateListenClient(sock))
         goto err;
 
@@ -530,13 +545,14 @@ err:
 int wiz_accept(int socket, struct sockaddr *addr, socklen_t *addrlen)
 {
     RyanW5500LinkCheck(-1);
-    RyanW5500CheckCode(NULL != addr && 0 != addrlen, EAFNOSUPPORT, { return -1; }); // 非法地址
+    RyanW5500CheckCode(NULL != addr && 0 != addrlen, EAFNOSUPPORT, rlog_d, { return -1; }); // 非法地址
 
     RyanW5500Socket *serviceSock = RyanW5500GetSock(socket);
 
-    RyanW5500CheckCode(NULL != serviceSock, EBADF, { return -1; });                          // 套接字参数不是有效的文件描述符。
-    RyanW5500CheckCode(RyanW5500SocketListen == serviceSock->state, EINVAL, { return -1; }); // 套接字不接受连接，没有listen
-    RyanW5500CheckCode(NULL != serviceSock->serviceInfo, ENOBUFS, { return -1; });           // 没有可用的缓冲区空间,理论上不会出现
+    RyanW5500CheckCode(NULL != serviceSock, EBADF, rlog_d, { return -1; }); // 套接字参数不是有效的文件描述符。
+    RyanW5500CheckCode(WIZ_SOCKET_MAGIC == serviceSock->magic, EIO, rlog_d, { return -1; });
+    RyanW5500CheckCode(RyanW5500SocketListen == serviceSock->state, EINVAL, rlog_d, { return -1; }); // 套接字不接受连接，没有listen
+    RyanW5500CheckCode(NULL != serviceSock->serviceInfo, ENOBUFS, rlog_d, { return -1; });           // 没有可用的缓冲区空间,理论上不会出现
 
     while (1)
     {
@@ -545,14 +561,14 @@ int wiz_accept(int socket, struct sockaddr *addr, socklen_t *addrlen)
         if (rt_mq_recv(serviceSock->serviceInfo->clientInfoQueueHandle, (void *)&clientSocket, sizeof(int8_t), RT_WAITING_FOREVER) != RT_EOK)
             continue;
 
-        RyanW5500CheckCode(-1 != clientSocket, EPROTO, { return -1; });
+        RyanW5500CheckCode(-1 != clientSocket, EPROTO, rlog_d, { return -1; });
 
         // 检查连接消息类型
         if (SOCK_ESTABLISHED != getSn_SR(clientSocket))
         {
             // 错误按摩，关闭客户端套接字
             wiz_closesocket(clientSocket);
-            RyanW5500CheckCode(NULL, EPROTO, { return -1; }); // 发生协议错误,客户端套接字不处于连接状态，极端情况才会出现
+            RyanW5500CheckCode(NULL, EPROTO, rlog_d, { return -1; }); // 发生协议错误,客户端套接字不处于连接状态，极端情况才会出现
         }
 
         // 获取新的客户端套接字信息
@@ -566,7 +582,7 @@ int wiz_accept(int socket, struct sockaddr *addr, socklen_t *addrlen)
         sin->sin_addr.s_addr = ipStrArrToinAddr(ipStrArr);
 
         *addrlen = sizeof(struct sockaddr);
-        LOG_D("accept remote ip: %s, remote port: %d", inet_ntoa(sin->sin_addr.s_addr), remotePort);
+        rlog_d("accept remote ip: %s, remote port: %d", inet_ntoa(sin->sin_addr.s_addr), remotePort);
 
         return clientSocket;
     }
@@ -586,7 +602,7 @@ int wiz_accept(int socket, struct sockaddr *addr, socklen_t *addrlen)
 int wiz_sendto(int socket, const void *data, size_t size, int flags, const struct sockaddr *to, socklen_t tolen)
 {
     RyanW5500LinkCheck(-1);
-    RyanW5500CheckCode(NULL != data && 0 != size, EFAULT, { return -1; });
+    RyanW5500CheckCode(NULL != data && 0 != size, EFAULT, rlog_d, { return -1; });
 
     RyanW5500Socket *sock = NULL;
     uint8_t socketState = 0;
@@ -594,13 +610,14 @@ int wiz_sendto(int socket, const void *data, size_t size, int flags, const struc
             timeout = 0;
 
     sock = RyanW5500GetSock(socket);
-    RyanW5500CheckCode(NULL != sock, EBADF, { return -1; });
+    RyanW5500CheckCode(NULL != sock, EBADF, rlog_d, { return -1; });
+    RyanW5500CheckCode(WIZ_SOCKET_MAGIC == sock->magic, EIO, rlog_d, { return -1; });
 
     timeout = sock->sendTimeout;
     if (timeout <= 0)
         timeout = RT_WAITING_FOREVER;
 
-    // 设置接收超时
+    // 设置发送超时
     platformTimer_t recvTimer = {0};
     platformTimerCutdown(&recvTimer, timeout);
 
@@ -608,23 +625,23 @@ int wiz_sendto(int socket, const void *data, size_t size, int flags, const struc
     {
     case Sn_MR_TCP:
         socketState = getSn_SR(socket);
-        RyanW5500CheckCode(SOCK_ESTABLISHED == socketState, EDESTADDRREQ, { return -1; }); // 套接字不是连接模式，没有设置其对等地址，也没有指定目标地址。
+        RyanW5500CheckCode(SOCK_ESTABLISHED == socketState, EDESTADDRREQ, rlog_d, { return -1; }); // 套接字不是连接模式，没有设置其对等地址，也没有指定目标地址。
 
         // 如果发送数据比剩余缓冲区大，则分片发送，否则缓冲区数据会被清空
         sendLen = getSn_TX_FSR(sock->socket);
-        RyanW5500CheckCode(sendLen > 0, EWOULDBLOCK, { return -1; }); // 发送缓冲区已满
+        RyanW5500CheckCode(sendLen > 0, EWOULDBLOCK, rlog_d, { return -1; }); // 发送缓冲区已满
 
         if (sendLen > size)
             sendLen = size;
         sendLen = wizchip_send(socket, (uint8_t *)data, sendLen);
-        RyanW5500CheckCode(sendLen > 0, EINTR, { return -1; }); // 发送失败，一般不会，所以将错误设置为信号中断
+        RyanW5500CheckCode(sendLen > 0, EINTR, rlog_d, { return -1; }); // 发送失败，一般不会，所以将错误设置为信号中断
         return sendLen;
 
     case Sn_MR_UDP:
     case Sn_MR_IPRAW:
     {
         socketState = getSn_SR(socket);
-        RyanW5500CheckCode(SOCK_UDP == socketState || SOCK_IPRAW == socketState, EDESTADDRREQ, { return -1; });
+        RyanW5500CheckCode(SOCK_UDP == socketState || SOCK_IPRAW == socketState, EDESTADDRREQ, rlog_d, { return -1; });
 
         struct sockaddr_in *sin = NULL;
 
@@ -636,7 +653,7 @@ int wiz_sendto(int socket, const void *data, size_t size, int flags, const struc
 
         // 查看是否是广播
         if (sin->sin_addr.s_addr == -1) // inet_addr("255.255.255.255")
-            RyanW5500CheckCode(0 != (sock->soOptionsFlag & SO_BROADCAST), EACCES, { return -1; });
+            RyanW5500CheckCode(0 != (sock->soOptionsFlag & SO_BROADCAST), EACCES, rlog_d, { return -1; });
 
         // 将发送ip转换为W5500识别的
         uint8_t ipStrArr[4] = {0};
@@ -644,15 +661,15 @@ int wiz_sendto(int socket, const void *data, size_t size, int flags, const struc
 
         // 如果发送数据比剩余缓冲区大，则分片发送，否则缓冲区数据会被清空
         sendLen = getSn_TX_FSR(sock->socket);
-        RyanW5500CheckCode(sendLen > 0, EWOULDBLOCK, { return -1; }); // 发送缓冲区已满
+        RyanW5500CheckCode(sendLen > 0, EWOULDBLOCK, rlog_d, { return -1; }); // 发送缓冲区已满
 
         if (sendLen > size)
             sendLen = size;
         sendLen = wizchip_sendto(sock->socket, (uint8_t *)data, sendLen, ipStrArr, htons(sin->sin_port));
         if (sendLen <= 0)
         {
-            RyanW5500CheckCode(SOCKERR_SOCKCLOSED == sendLen, EPIPE, { return -1; }); // 套接字被关闭
-            LOG_E("udp send fail, result: %d", sendLen);
+            RyanW5500CheckCode(SOCKERR_SOCKCLOSED == sendLen, EPIPE, rlog_d, { return -1; }); // 套接字被关闭
+            rlog_e("udp send fail, result: %d", sendLen);
             return -1;
         }
 
@@ -660,7 +677,7 @@ int wiz_sendto(int socket, const void *data, size_t size, int flags, const struc
     }
 
     default:
-        LOG_E("socket (%d) type %d is not support.", socket, sock->type);
+        rlog_e("socket (%d) type %d is not support.", socket, sock->type);
         return -1;
     }
 }
@@ -679,7 +696,7 @@ int wiz_sendto(int socket, const void *data, size_t size, int flags, const struc
 int wiz_recvfrom(int socket, void *mem, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
 {
     RyanW5500LinkCheck(-1);
-    RyanW5500CheckCode(NULL != mem && 0 != len, EFAULT, { return -1; });
+    RyanW5500CheckCode(NULL != mem && 0 != len, EFAULT, rlog_d, { return -1; });
 
     RyanW5500Socket *sock = NULL;
     uint8_t socketState = 0;
@@ -689,7 +706,8 @@ int wiz_recvfrom(int socket, void *mem, size_t len, int flags, struct sockaddr *
     platformTimer_t recvTimer = {0};
 
     sock = RyanW5500GetSock(socket);
-    RyanW5500CheckCode(NULL != sock, EBADF, { return -1; });
+    RyanW5500CheckCode(NULL != sock, EBADF, rlog_d, { return -1; });
+    RyanW5500CheckCode(WIZ_SOCKET_MAGIC == sock->magic, EIO, rlog_d, { return -1; });
 
     // 设置 WIZNnet 套接字接收超时
     timeout = sock->recvTimeout;
@@ -700,20 +718,20 @@ int wiz_recvfrom(int socket, void *mem, size_t len, int flags, struct sockaddr *
 
 again:
     // 判断是否超时
-    RyanW5500CheckCode(0 != platformTimerRemain(&recvTimer), EAGAIN, { return -1; });
+    RyanW5500CheckCode(0 != platformTimerRemain(&recvTimer), EAGAIN, rlog_d, { return -1; });
 
     switch (sock->type)
     {
     case Sn_MR_TCP:
     {
         socketState = getSn_SR(socket);
-        RyanW5500CheckCode(SOCK_ESTABLISHED == socketState, ENOTCONN, { return -1; }); // 在未连接的连接模式套接字上尝试接收。
+        RyanW5500CheckCode(SOCK_ESTABLISHED == socketState, ENOTCONN, rlog_d, { return -1; }); // 在未连接的连接模式套接字上尝试接收。
 
         result = rt_event_recv(RyanW5500Entry.W5500EventHandle, (1 << sock->socket),
                                RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
                                timeout, NULL);
-        RyanW5500CheckCode(RT_EOK == result, EAGAIN, { return -1; });                        // 判断是否超时
-        RyanW5500CheckCode(RyanW5500SocketClose != sock->state, ECONNRESET, { return -1; }); // 连接被对等方关闭。
+        RyanW5500CheckCode(RT_EOK == result, EAGAIN, rlog_d, { return -1; });                        // 判断是否超时
+        RyanW5500CheckCode(RyanW5500SocketClose != sock->state, ECONNRESET, rlog_d, { return -1; }); // 连接被对等方关闭。
 
         // 获取数据寄存器，没有数据就重新接收
         recvLen = getSn_RX_RSR(socket);
@@ -727,7 +745,7 @@ again:
         recvLen = wizchip_recv(socket, mem, recvLen);
         if (recvLen <= 0)
         {
-            LOG_E("recv error, result: %d", recvLen);
+            rlog_e("recv error, result: %d", recvLen);
             return -1;
         }
 
@@ -738,13 +756,13 @@ again:
     case Sn_MR_IPRAW:
     {
         socketState = getSn_SR(socket);
-        RyanW5500CheckCode(SOCK_UDP == socketState || SOCK_IPRAW == socketState, ENOTCONN, { return -1; }); // 在未连接的连接模式套接字上尝试接收。
+        RyanW5500CheckCode(SOCK_UDP == socketState || SOCK_IPRAW == socketState, ENOTCONN, rlog_d, { return -1; }); // 在未连接的连接模式套接字上尝试接收。
 
         result = rt_event_recv(RyanW5500Entry.W5500EventHandle, (1 << sock->socket),
                                RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
                                timeout, NULL);
-        RyanW5500CheckCode(RT_EOK == result, EAGAIN, { return -1; }); // 判断是否超时
-        RyanW5500CheckCode(RyanW5500SocketClose != sock->state, ECONNRESET, { return -1; });
+        RyanW5500CheckCode(RT_EOK == result, EAGAIN, rlog_d, { return -1; }); // 判断是否超时
+        RyanW5500CheckCode(RyanW5500SocketClose != sock->state, ECONNRESET, rlog_d, { return -1; });
 
         // 获取数据寄存器，没有数据就重新接收
         recvLen = getSn_RX_RSR(socket);
@@ -761,7 +779,7 @@ again:
         recvLen = wizchip_recvfrom(socket, mem, recvLen, remoteIp, &remotePort);
         if (recvLen <= 0)
         {
-            LOG_E("recvfrom error, result: %d", recvLen);
+            rlog_e("recvfrom error, result: %d", recvLen);
             return -1;
         }
 
@@ -776,7 +794,7 @@ again:
     }
 
     default:
-        LOG_E("socket (%d) type %d is not support.", socket, sock->type);
+        rlog_e("socket (%d) type %d is not support.", socket, sock->type);
         return -1;
     }
 }
@@ -811,7 +829,7 @@ int wiz_closesocket(int socket)
     RyanW5500Socket *sock = NULL;
 
     sock = RyanW5500GetSock(socket);
-    RyanW5500CheckCode(NULL != sock, EBADF, { return -1; });
+    RyanW5500CheckCode(NULL != sock, EBADF, rlog_d, { return -1; });
 
     if (SOCK_CLOSED == getSn_SR(sock->socket))
     {
@@ -829,7 +847,7 @@ int wiz_closesocket(int socket)
         result = wizchip_close(sock->socket);
         if (SOCK_OK != result)
         {
-            LOG_E("socket(%d) close failed.", sock->socket);
+            rlog_e("socket(%d) close failed.", sock->socket);
             RyanW5500SocketDestory(sock);
             return -1;
         }
@@ -857,11 +875,11 @@ int wiz_shutdown(int socket, int how)
         break;
 
     default:
-        RyanW5500CheckCode(NULL, EINVAL, return -1;)
+        RyanW5500CheckCode(NULL, EINVAL, rlog_d, return -1;)
     }
 
     sock = RyanW5500GetSock(socket);
-    RyanW5500CheckCode(NULL != sock, EBADF, { return -1; });
+    RyanW5500CheckCode(NULL != sock, EBADF, rlog_d, { return -1; });
 
     return wiz_closesocket(sock->socket);
 }
@@ -879,20 +897,20 @@ int wiz_shutdown(int socket, int how)
 int wiz_setsockopt(int socket, int level, int optname, const void *optval, socklen_t optlen)
 {
     RyanW5500LinkCheck(-1);
-    RyanW5500CheckCode(NULL != optval && 0 != optlen, EFAULT, { return -1; });
+    RyanW5500CheckCode(NULL != optval && 0 != optlen, EFAULT, rlog_d, { return -1; });
 
     RyanW5500Socket *sock = NULL;
 
     sock = RyanW5500GetSock(socket);
-    RyanW5500CheckCode(NULL != sock, EBADF, { return -1; }); // 指定的选项在指定的套接字级别无效或套接字已关闭。
+    RyanW5500CheckCode(NULL != sock, EBADF, rlog_d, { return -1; }); // 指定的选项在指定的套接字级别无效或套接字已关闭。
 
     if (SOL_SOCKET == level)
     {
         switch (optname)
         {
-        case SO_BROADCAST:                                                       // 配置用于发送广播数据的套接字。此选项仅适用于支持广播 IP 和 UDP 的协议 布尔类型
-            RyanW5500CheckCode(Sn_MR_TCP != sock->type, EINVAL, { return -1; }); // 指定的选项在指定的套接字级别无效或套接字已关闭。
-            RyanW5500CheckCode(sizeof(int) == optlen, EFAULT, { return -1; });
+        case SO_BROADCAST:                                                               // 配置用于发送广播数据的套接字。此选项仅适用于支持广播 IP 和 UDP 的协议 布尔类型
+            RyanW5500CheckCode(Sn_MR_TCP != sock->type, EINVAL, rlog_d, { return -1; }); // 指定的选项在指定的套接字级别无效或套接字已关闭。
+            RyanW5500CheckCode(sizeof(int) == optlen, EFAULT, rlog_d, { return -1; });
             if (1 == *(int *)optval)
                 sock->soOptionsFlag |= optname;
             else
@@ -905,18 +923,18 @@ int wiz_setsockopt(int socket, int level, int optname, const void *optval, sockl
                 break;
             uint32_t keepalive = 2 * 60 * 60 / 5; // w5500 Sn_KPALVTR单位时间为5
             if (1 == *(int *)optval)
-                RyanW5500CheckCode(SOCK_OK == wizchip_setsockopt(sock->socket, SO_KEEPALIVEAUTO, (void *)&keepalive), EINVAL, { return -1; });
+                RyanW5500CheckCode(SOCK_OK == wizchip_setsockopt(sock->socket, SO_KEEPALIVEAUTO, (void *)&keepalive), EINVAL, rlog_d, { return -1; });
             break;
         }
 
         case SO_RCVTIMEO: // 阻止接收调用的超时（以毫秒为单位）。 此选项的默认值为零，表示接收操作不会超时 类型struct timeval
-            RyanW5500CheckCode(sizeof(struct timeval) == optlen, EFAULT, { return -1; });
+            RyanW5500CheckCode(sizeof(struct timeval) == optlen, EFAULT, rlog_d, { return -1; });
             sock->recvTimeout = ((const struct timeval *)optval)->tv_sec * 1000 +
                                 ((const struct timeval *)optval)->tv_usec / 1000;
             break;
 
         case SO_SNDTIMEO: // 阻止发送调用的超时（以毫秒为单位）。 此选项的默认值为零，表示发送操作不会超时。类型struct timeval
-            RyanW5500CheckCode(sizeof(struct timeval) == optlen, EFAULT, { return -1; });
+            RyanW5500CheckCode(sizeof(struct timeval) == optlen, EFAULT, rlog_d, { return -1; });
             sock->sendTimeout = ((const struct timeval *)optval)->tv_sec * 1000 +
                                 ((const struct timeval *)optval)->tv_usec / 1000;
             break;
@@ -937,7 +955,7 @@ int wiz_setsockopt(int socket, int level, int optname, const void *optval, sockl
             return -1;
 
         default:
-            RyanW5500CheckCode(NULL, ENOPROTOOPT, { return -1; });
+            RyanW5500CheckCode(NULL, ENOPROTOOPT, rlog_d, { return -1; });
         }
     }
     else if (IPPROTO_IP == level)
@@ -945,18 +963,18 @@ int wiz_setsockopt(int socket, int level, int optname, const void *optval, sockl
         switch (optname)
         {
         case IP_TOS: // 本选项是int型的数值选项，允许对TCP、UDP的IP头中的tos字段进行设置
-            RyanW5500CheckCode(SOCK_OK == wizchip_setsockopt(sock->socket, SO_TOS, (void *)optval), EINVAL, { return -1; });
+            RyanW5500CheckCode(SOCK_OK == wizchip_setsockopt(sock->socket, SO_TOS, (void *)optval), EINVAL, rlog_d, { return -1; });
             break;
 
         case IP_TTL: // 本选项是int型的数值选项，允许对单播报文的TTL默认值进行设置。
-            RyanW5500CheckCode(SOCK_OK == wizchip_setsockopt(sock->socket, SO_TTL, (void *)optval), EINVAL, { return -1; });
+            RyanW5500CheckCode(SOCK_OK == wizchip_setsockopt(sock->socket, SO_TTL, (void *)optval), EINVAL, rlog_d, { return -1; });
             break;
 
         // UDP 多播的选项和类型
         case IP_ADD_MEMBERSHIP: // 加入一个组播组 struct ip_mreq
         {
-            RyanW5500CheckCode(Sn_MR_TCP != sock->type, EINVAL, { return -1; }); // 指定的选项在指定的套接字级别无效或套接字已关闭。
-            RyanW5500CheckCode(sizeof(struct ip_mreq) == optlen, EFAULT, { return -1; });
+            RyanW5500CheckCode(Sn_MR_TCP != sock->type, EINVAL, rlog_d, { return -1; }); // 指定的选项在指定的套接字级别无效或套接字已关闭。
+            RyanW5500CheckCode(sizeof(struct ip_mreq) == optlen, EFAULT, rlog_d, { return -1; });
             struct ip_mreq *mreq = (struct ip_mreq *)optval;
 
             // 需要在Sn_CR命令之前，分开配置组播 IP 地址及端口号。
@@ -974,14 +992,14 @@ int wiz_setsockopt(int socket, int level, int optname, const void *optval, sockl
             setSn_DPORT(sock->socket, sock->port);
 
             int8_t result = wizchip_socket(sock->socket, sock->type, sock->port, Sn_MR_MULTI);
-            RyanW5500CheckCode(result == sock->socket, EMFILE, { return -1; });
+            RyanW5500CheckCode(result == sock->socket, EMFILE, rlog_d, { return -1; });
             break;
         }
 
         case IP_DROP_MEMBERSHIP: // 退出组播组 struct ip_mreq
         {
             int8_t result = wizchip_socket(sock->socket, sock->type, sock->port, 0);
-            RyanW5500CheckCode(result == sock->socket, EMFILE, { return -1; });
+            RyanW5500CheckCode(result == sock->socket, EMFILE, rlog_d, { return -1; });
             break;
         }
 
@@ -993,7 +1011,7 @@ int wiz_setsockopt(int socket, int level, int optname, const void *optval, sockl
             // case IP_RECVIF:          // 本选项是标志位，置上之后，允许对UDP socket调用recvfrom的时候，能够以辅助数据的形式获取到客户端报文的目的接口。
 
         default:
-            RyanW5500CheckCode(NULL, ENOPROTOOPT, { return -1; });
+            RyanW5500CheckCode(NULL, ENOPROTOOPT, rlog_d, { return -1; });
         }
     }
     else if (IPPROTO_TCP == level)
@@ -1006,11 +1024,11 @@ int wiz_setsockopt(int socket, int level, int optname, const void *optval, sockl
         case TCP_KEEPCNT:   // 获取或设置将在连接终止之前发送的 TCP 保持活动探测数。 将TCP_KEEPCNT设置为大于 255 的值是非法的。
             return -1;
         default:
-            RyanW5500CheckCode(NULL, ENOPROTOOPT, { return -1; });
+            RyanW5500CheckCode(NULL, ENOPROTOOPT, rlog_d, { return -1; });
         }
     }
     else
-        RyanW5500CheckCode(NULL, EINVAL, { return -1; });
+        RyanW5500CheckCode(NULL, EINVAL, rlog_d, { return -1; });
 
     return 0;
 }
@@ -1031,19 +1049,19 @@ int wiz_getsockopt(int socket, int level, int optname, void *optval, socklen_t *
 {
 
     RyanW5500LinkCheck(-1);
-    RyanW5500CheckCode(NULL != optval && NULL != optlen, EFAULT, { return -1; });
+    RyanW5500CheckCode(NULL != optval && NULL != optlen, EFAULT, rlog_d, { return -1; });
 
     RyanW5500Socket *sock = NULL;
 
     sock = RyanW5500GetSock(socket);
-    RyanW5500CheckCode(NULL != sock, EBADF, { return -1; });
+    RyanW5500CheckCode(NULL != sock, EBADF, rlog_d, { return -1; });
 
     if (SOL_SOCKET == level)
     {
         switch (optname)
         {
         case SO_BROADCAST: // 报告是否支持广播消息的传输 布尔类型
-            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, { return -1; });
+            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, rlog_d, { return -1; });
             *(int *)optval = Sn_MR_TCP != sock->type ? 1 : 0;
             *optlen = sizeof(int);
             break;
@@ -1053,33 +1071,33 @@ int wiz_getsockopt(int socket, int level, int optname, void *optval, socklen_t *
             return -1;
 
         case SO_RCVTIMEO: // 报告阻止接收调用的超时。 类型struct timeval
-            RyanW5500CheckCode(sizeof(struct timeval) <= *optlen, EINVAL, { return -1; });
+            RyanW5500CheckCode(sizeof(struct timeval) <= *optlen, EINVAL, rlog_d, { return -1; });
             ((struct timeval *)(optval))->tv_sec = sock->recvTimeout / 1000U;
             ((struct timeval *)(optval))->tv_usec = (sock->recvTimeout % 1000U) * 1000U;
             *optlen = sizeof(struct timeval);
             break;
 
         case SO_SNDTIMEO: // 报告阻止发送调用的超时。 此选项的默认值为零，表示发送操作不会超时。类型struct timeval
-            RyanW5500CheckCode(sizeof(struct timeval) <= *optlen, EINVAL, { return -1; });
+            RyanW5500CheckCode(sizeof(struct timeval) <= *optlen, EINVAL, rlog_d, { return -1; });
             ((struct timeval *)optval)->tv_sec = sock->sendTimeout / 1000U;
             ((struct timeval *)optval)->tv_usec = (sock->sendTimeout % 1000U) * 1000U;
             *optlen = sizeof(struct timeval);
             break;
 
         case SO_SNDBUF: // 报告发送缓冲区大小。此选项采用 int 值。
-            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, { return -1; });
+            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, rlog_d, { return -1; });
             wizchip_getsockopt(socket, (sockopt_type)SO_SENDBUF, (void *)optval);
             *optlen = sizeof(int);
             break;
 
         case SO_RCVBUF: // 报告接收缓冲区大小。此选项采用 int 值。
-            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, { return -1; });
+            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, rlog_d, { return -1; });
             wizchip_getsockopt(socket, (sockopt_type)SO_RECVBUF, (void *)optval);
             *optlen = sizeof(int);
             break;
 
         case SO_ACCEPTCONN: // 报告是否启用套接字侦听 布尔类型
-            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, { return -1; });
+            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, rlog_d, { return -1; });
             if (RyanW5500SocketListen == sock->state && NULL != sock->serviceInfo)
                 *(int *)optval = 1;
             else
@@ -1088,14 +1106,14 @@ int wiz_getsockopt(int socket, int level, int optname, void *optval, socklen_t *
             break;
 
         case SO_ERROR: // 报告有关错误状态的信息并将其清除。 int
-            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, { return -1; });
+            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, rlog_d, { return -1; });
             *(int *)optval = errno;
             *optlen = sizeof(int);
             errno = 0;
             break;
 
         case SO_TYPE: // 报告套接字类型   int
-            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, { return -1; });
+            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, rlog_d, { return -1; });
             *(int *)optval = sock->type;
             *optlen = sizeof(int);
             break;
@@ -1110,7 +1128,7 @@ int wiz_getsockopt(int socket, int level, int optname, void *optval, socklen_t *
             return -1;
 
         default:
-            RyanW5500CheckCode(NULL, ENOPROTOOPT, { return -1; });
+            RyanW5500CheckCode(NULL, ENOPROTOOPT, rlog_d, { return -1; });
         }
     }
     else if (IPPROTO_IP == level)
@@ -1118,13 +1136,13 @@ int wiz_getsockopt(int socket, int level, int optname, void *optval, socklen_t *
         switch (optname)
         {
         case IP_TOS: // 本选项是int型的数值选项，允许对TCP、UDP的IP头中的tos字段进行获取
-            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, { return -1; });
+            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, rlog_d, { return -1; });
             wizchip_getsockopt(sock->socket, (sockopt_type)SO_TOS, optval);
             *optlen = sizeof(int);
             break;
 
         case IP_TTL: // 本选项是int型的数值选项，允许对单播报文的TTL默认值进行获取
-            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, { return -1; });
+            RyanW5500CheckCode(sizeof(int) <= *optlen, EINVAL, rlog_d, { return -1; });
             wizchip_getsockopt(sock->socket, (sockopt_type)SO_TTL, optval);
             *optlen = sizeof(int);
             break;
@@ -1139,7 +1157,7 @@ int wiz_getsockopt(int socket, int level, int optname, void *optval, socklen_t *
             //     return -1;
 
         default:
-            RyanW5500CheckCode(NULL, ENOPROTOOPT, { return -1; });
+            RyanW5500CheckCode(NULL, ENOPROTOOPT, rlog_d, { return -1; });
         }
     }
     else if (IPPROTO_TCP == level)
@@ -1152,11 +1170,11 @@ int wiz_getsockopt(int socket, int level, int optname, void *optval, socklen_t *
         case TCP_KEEPCNT:   // 获取或设置将在连接终止之前发送的 TCP 保持活动探测数。 将TCP_KEEPCNT设置为大于 255 的值是非法的。
             return -1;
         default:
-            RyanW5500CheckCode(NULL, ENOPROTOOPT, { return -1; });
+            RyanW5500CheckCode(NULL, ENOPROTOOPT, rlog_d, { return -1; });
         }
     }
     else
-        RyanW5500CheckCode(NULL, EINVAL, { return -1; });
+        RyanW5500CheckCode(NULL, EINVAL, rlog_d, { return -1; });
 
     return 0;
 
@@ -1184,20 +1202,20 @@ int RyanW5500_gethostbyname(const char *name, ip_addr_t *addr)
         uint8_t remote_ip[4] = {0};
         uint8_t data_buffer[512];
 
-        ulog_w("TAG", "%s:%d 开始获取dns", __FILE__, __LINE__);
+        rlog_w("开始获取dns");
         // DNS客户端处理
         ret = DNS_run(gWIZNETINFO.dns, (uint8_t *)name, remote_ip, data_buffer);
         if (1 != ret)
         {
             if (-1 == ret)
             {
-                LOG_E("MAX_DOMAIN_NAME is too small, should be redefined it.");
+                rlog_e("MAX_DOMAIN_NAME is too small, should be redefined it.");
                 return -1;
             }
 
             if (-2 == ret)
             {
-                LOG_E("DNS failed, socket number is full.");
+                rlog_e("DNS failed, socket number is full.");
                 return -2;
             }
             return -1;
@@ -1237,7 +1255,7 @@ struct hostent *wiz_gethostbyname(const char *name)
 
     if (NULL == name)
     {
-        LOG_E("gethostbyname input name err!");
+        rlog_e("gethostbyname input name err!");
         return NULL;
     }
 

W5500Client/RyanW5500Store.h

@@ -11,19 +11,26 @@ extern "C"
 #include <stdint.h>
 #include <string.h>
 #include <stdlib.h>
-#include <ctype.h>
 #include <errno.h>
 
-#include <netdb.h>
-#include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
-#include "sal.h"
+
+#include <rtthread.h>
+
+#include <sal_socket.h>
+#include <sal_netdb.h>
+#if (RTTHREAD_VERSION > 40100)
+#include <sal_low_lvl.h>
+#else
+#include <sal.h>
+#endif
+
 #include "netdev_ipaddr.h"
 #include "netdev.h"
 
-#include "ulog.h"
-
+#include "RyanList.h"
+#include "RyanW5500Log.h"
 #include "platformTimer.h"
 #include "platformW5500Hardware.h"
 #include "wizchip_conf.h"
@@ -31,7 +38,6 @@ extern "C"
 #include "wizchip_dhcp.h"
 #include "wizchip_dns.h"
 #include "w5500.h"
-#include "RyanList.h"
 #include "RyanW5500.h"
 #include "RyanW5500Socket.h"
 #include "RyanW5500Ping.h"
@@ -41,26 +47,6 @@ extern "C"
 #define delay(ms) rt_thread_mdelay(ms)
 #endif
 
-#define RyanW5500SetErrno(err) \
-    do                         \
-    {                          \
-        if (err)               \
-            errno = (err);     \
-    } while (0)
-
-#define RyanW5500Check(EX, ErrorCode) RyanW5500CheckCode(EX, ErrorCode, NULL)
-
-#define RyanW5500CheckCode(EX, ErrorCode, code)                    \
-    if (!(EX))                                                     \
-    {                                                              \
-        LOG_D("%s:%d ErrorCode: %d, strError: %s",                 \
-              __FILE__, __LINE__, ErrorCode, strerror(ErrorCode)); \
-        RyanW5500SetErrno(ErrorCode);                              \
-        {                                                          \
-            code                                                   \
-        }                                                          \
-    }
-
 // WIZnet套接字魔术词
 #define WIZ_SOCKET_MAGIC 0x3120
 
@@ -80,6 +66,22 @@ extern "C"
 #define RyanW5500SnIMR (Sn_IR_RECV | Sn_IR_DISCON | Sn_IR_CON)     // Sn_IMR
 #define RyanW5500IMR (IR_CONFLICT | IR_UNREACH | IR_PPPoE | IR_MP) // IMR (中断屏蔽寄存器)
 
+#define RyanW5500CheckCodeNoReturn(EX, ErrorCode, Ryanlevel, code) \
+    if (!(EX))                                                     \
+    {                                                              \
+                                                                   \
+        Ryanlevel("ErrorCode: %d, strError: %s",                   \
+                  ErrorCode, RyanW5500StrError(ErrorCode));        \
+        errno = (ErrorCode);                                       \
+        {code};                                                    \
+    }
+
+#define RyanW5500CheckCode(EX, ErrorCode, level, code) RyanW5500CheckCodeNoReturn(EX, ErrorCode, level, { {code}; return ErrorCode; });
+
+#define RyanW5500CheckNoReturn(EX, ErrorCode, level) RyanW5500CheckCodeNoReturn(EX, ErrorCode, level, {})
+#define RyanW5500Check(EX, ErrorCode, level) RyanW5500CheckCode(EX, ErrorCode, level, {})
+#define RyanW5500CheckAssert(EX, ErrorCode, level) RyanW5500CheckCodeNoReturn(EX, ErrorCode, level, { assert(NULL); })
+
     // 定义枚举类型
 
     // 定义结构体类型

common/RyanW5500Log.h

@@ -0,0 +1,123 @@
+#ifndef __RyanMqttLog__
+#define __RyanMqttLog__
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include "rtthread.h"
+
+#define platformPrint rt_kprintf
+
+// 日志等级
+#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 "W5500"
+#endif
+
+/**
+ * @brief 日志相关
+ *
+ */
+#if rlogEnable > 0
+static void rlog_output(char *lvl, uint8_t color_n, char *const fmt, ...)
+{
+    // RyanLogPrintf("\033[字背景颜色;字体颜色m  用户字符串 \033[0m" );
+    char dbgBuffer[256];
+    uint16_t len;
+
+// 打印颜色
+#if rlogColorEnable > 0
+    len = snprintf(dbgBuffer, sizeof(dbgBuffer), "\033[%dm", color_n);
+    platformPrint(dbgBuffer, len);
+#endif
+
+    // 打印提示符
+    len = snprintf(dbgBuffer, sizeof(dbgBuffer), "[%s/%s]", lvl, rlogTag);
+    platformPrint(dbgBuffer, len);
+
+    // 打印用户输入
+    va_list args;
+    va_start(args, fmt);
+    len = vsnprintf(dbgBuffer, sizeof(dbgBuffer), fmt, args);
+    va_end(args);
+    platformPrint(dbgBuffer, len);
+
+// 打印颜色
+#if rlogColorEnable > 0
+    platformPrint("\033[0m", sizeof("\033[0m"));
+#endif
+
+    platformPrint("\r\n", sizeof("\r\n"));
+}
+
+static void rlog_output_raw(char *const fmt, ...)
+{
+    char dbgBuffer[256];
+    uint16_t len;
+
+    va_list args;
+    va_start(args, fmt);
+    len = vsnprintf(dbgBuffer, sizeof(dbgBuffer), fmt, args);
+    va_end(args);
+
+    platformPrint(dbgBuffer, len);
+}
+
+#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, " %s:%d " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
+#else
+#define rlog_d(...)
+#endif
+
+#if (rlogLevel >= rlogLvlInfo)
+#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, " %s:%d " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
+#else
+#define rlog_w(...)
+#endif
+
+#if (rlogLevel >= rlogLvlError)
+#define rlog_e(fmt, ...) rlog_output("E", 31, " %s:%d " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
+#else
+#define rlog_e(...)
+#endif
+
+#define log_d rlog_d
+
+#define rlog_raw(...) rlog_output_raw(__VA_ARGS__)
+
+#endif

ioLibrary/DHCP/wizchip_dhcp.c

@@ -1,13 +1,10 @@
+#define rlogEnable 1               // 是否使能日志
+#define rlogColorEnable 1          // 是否使能日志颜色
+#define rlogLevel (rlogLvlWarning) // 日志打印等级
+#define rlogTag "W5500Dhcp"        // 日志tag
 
 #include "wizchip_socket.h"
 #include "wizchip_dhcp.h"
-
-#define DBG_ENABLE
-
-#define DBG_SECTION_NAME "dhcp"
-#define DBG_LEVEL DBG_WARNING
-#define DBG_COLOR
-
 #include <stdio.h>
 #include <string.h>
 #include "RyanW5500Store.h"
@@ -154,7 +151,7 @@ uint8_t OLD_allocated_ip[4] = {0}; // 以前的 IP 地址
 wizchipDhcpState_e dhcp_state = STATE_DHCP_INIT; // DHCP 状态
 platformTimer_t dhcp_lease_time = {0};           // dhcp租期定时器
 uint32_t DHCP_XID;                               // 任何数字
-uint8_t *HOST_NAME = (uint8_t*)DCHP_HOST_NAME;             // 主机名
+uint8_t *HOST_NAME = (uint8_t *)DCHP_HOST_NAME;  // 主机名
 RIP_MSG *pDHCPMSG;                               // DHCP 处理的缓冲区指针
 
 char NibbleToHex(uint8_t nibble)
@@ -270,7 +267,7 @@ void send_DHCP_DISCOVER(void)
     for (i = k; i < OPT_SIZE; i++)
         pDHCPMSG->OPT[i] = 0;
 
-    LOG_D("> Send DHCP_DISCOVER");
+    rlog_d("> Send DHCP_DISCOVER");
 
     // 广播发送
     wizchip_sendto(DHCP_SOCKET, (uint8_t *)pDHCPMSG, RIP_MSG_SIZE, ip, DHCP_SERVER_PORT);
@@ -354,7 +351,7 @@ void send_DHCP_REQUEST(void)
     for (i = k; i < OPT_SIZE; i++)
         pDHCPMSG->OPT[i] = 0;
 
-    LOG_D("> Send DHCP_REQUEST");
+    rlog_d("> Send DHCP_REQUEST");
 
     wizchip_sendto(DHCP_SOCKET, (uint8_t *)pDHCPMSG, RIP_MSG_SIZE, ip, DHCP_SERVER_PORT);
 }
@@ -405,7 +402,7 @@ void send_DHCP_DECLINE(void)
     // 发送广播包
     memset(ip, 0xFF, 4);
 
-    LOG_D("> Send DHCP_DECLINE");
+    rlog_d("> Send DHCP_DECLINE");
 
     wizchip_sendto(DHCP_SOCKET, (uint8_t *)pDHCPMSG, RIP_MSG_SIZE, ip, DHCP_SERVER_PORT);
 }
@@ -430,7 +427,7 @@ int8_t parseDHCPMSG(void)
         return 0;
 
     len = wizchip_recvfrom(DHCP_SOCKET, (uint8_t *)pDHCPMSG, len, svr_addr, &svr_port);
-    LOG_D("DHCP message : %d.%d.%d.%d(%d) %d received. ", svr_addr[0], svr_addr[1], svr_addr[2], svr_addr[3], svr_port, len);
+    rlog_d("DHCP message : %d.%d.%d.%d(%d) %d received. ", svr_addr[0], svr_addr[1], svr_addr[2], svr_addr[3], svr_port, len);
 
     if (DHCP_SERVER_PORT != svr_port)
         return 0;
@@ -438,7 +435,7 @@ int8_t parseDHCPMSG(void)
     // 校验mac地址
     if (0 != memcmp(gWIZNETINFO.mac, pDHCPMSG->chaddr, sizeof(gWIZNETINFO.mac)))
     {
-        LOG_D("No My DHCP Message. This message is ignored.");
+        rlog_d("No My DHCP Message. This message is ignored.");
         return 0;
     }
 
@@ -448,7 +445,7 @@ int8_t parseDHCPMSG(void)
         if (0 != memcmp(DHCP_SIP, svr_addr, sizeof(DHCP_SIP)) &&
             0 != memcmp(DHCP_REAL_SIP, svr_addr, sizeof(DHCP_REAL_SIP)))
         {
-            LOG_D("Another DHCP sever send a response message. This is ignored.");
+            rlog_d("Another DHCP sever send a response message. This is ignored.");
             return 0;
         }
     }
@@ -567,7 +564,7 @@ int8_t check_DHCP_leasedIP(void)
     if (ret == SOCKERR_TIMEOUT)
     {
         // UDP 发送超时发生：分配的 IP 地址是唯一的，DHCP 成功
-        LOG_D("> Check leased IP - OK");
+        rlog_d("> Check leased IP - OK");
         return 1;
     }
     else
@@ -598,7 +595,7 @@ uint8_t DHCP_run(uint8_t flag)
     sock = RyanW5500SocketCreate(Sn_MR_UDP, DHCP_CLIENT_PORT);
     if (NULL == sock)
     {
-        LOG_W("dhcp socket失败");
+        rlog_w("dhcp socket失败");
         return -1;
     }
 
@@ -643,7 +640,7 @@ uint8_t DHCP_run(uint8_t flag)
         case STATE_DHCP_DISCOVER:
             if (DHCP_OFFER == type) // 服务器提供地址续约，offer报文
             {
-                LOG_D("> Receive DHCP_OFFER");
+                rlog_d("> Receive DHCP_OFFER");
                 memcpy(gWIZNETINFO.ip, pDHCPMSG->yiaddr, sizeof(gWIZNETINFO.ip));
                 send_DHCP_REQUEST(); // 发送请求地址租用 request报文
                 dhcp_state = STATE_DHCP_REQUEST;
@@ -654,13 +651,13 @@ uint8_t DHCP_run(uint8_t flag)
         case STATE_DHCP_REQUEST:  // 客户端选择并请求地址租用
             if (DHCP_NAK == type) // 服务器取消把地址租用给客户端
             {
-                LOG_D("> Receive DHCP_NACK");
+                rlog_d("> Receive DHCP_NACK");
                 dhcp_state = STATE_DHCP_DISCOVER;
             }
 
             else if (DHCP_ACK == type) // 服务器确认将地址租用给客户端 ack报文
             {
-                LOG_D("> Receive DHCP_ACK");
+                rlog_d("> Receive DHCP_ACK");
                 // 发生 IP 地址冲突
                 dhcp_state = check_DHCP_leasedIP() ? STATE_DHCP_LEASED : STATE_DHCP_INIT;
             }
@@ -670,7 +667,7 @@ uint8_t DHCP_run(uint8_t flag)
         case STATE_DHCP_LEASED: // 当租期超过50%（1/2）时，客户端会以单播形式向DHCP服务器发送DHCP Request报文来续租IP地址。
             if (dhcp_lease_time.timeOut != 0 && platformTimerRemain(&dhcp_lease_time) < (dhcp_lease_time.timeOut / 2))
             {
-                LOG_D("> Maintains the IP address ");
+                rlog_d("> Maintains the IP address ");
                 DHCP_XID++;
                 send_DHCP_REQUEST();
 
@@ -682,12 +679,12 @@ uint8_t DHCP_run(uint8_t flag)
             if (type == DHCP_ACK)
             {
                 // 不需要判断续租分配的新ip还是旧ip，都会写入到w5500寄存器里
-                LOG_D("> Receive DHCP_ACK, Maintains the IP address");
+                rlog_d("> Receive DHCP_ACK, Maintains the IP address");
                 dhcp_state = STATE_DHCP_LEASED;
             }
             else if (type == DHCP_NAK)
             {
-                LOG_D("> Receive DHCP_NACK, Failed to maintain ip");
+                rlog_d("> Receive DHCP_NACK, Failed to maintain ip");
                 dhcp_state = STATE_DHCP_DISCOVER;
             }
 
@@ -706,17 +703,17 @@ uint8_t DHCP_run(uint8_t flag)
             switch (dhcp_state)
             {
             case STATE_DHCP_DISCOVER:
-                LOG_D("<<timeout>> state : STATE_DHCP_DISCOVER");
+                rlog_d("<<timeout>> state : STATE_DHCP_DISCOVER");
                 send_DHCP_DISCOVER();
                 break;
 
             case STATE_DHCP_REQUEST:
-                LOG_D("<<timeout>> state : STATE_DHCP_REQUEST");
+                rlog_d("<<timeout>> state : STATE_DHCP_REQUEST");
                 send_DHCP_REQUEST();
                 break;
 
             case STATE_DHCP_REREQUEST:
-                LOG_D("<<timeout>> state : STATE_DHCP_REREQUEST");
+                rlog_d("<<timeout>> state : STATE_DHCP_REREQUEST");
                 send_DHCP_REQUEST();
                 break;
 

ioLibrary/DNS/wizchip_dns.c

@@ -1,8 +1,7 @@
-#define DBG_ENABLE
-
-#define DBG_SECTION_NAME ("dns")
-#define DBG_LEVEL DBG_WARNING
-#define DBG_COLOR
+#define rlogEnable 1               // 是否使能日志
+#define rlogColorEnable 1          // 是否使能日志颜色
+#define rlogLevel (rlogLvlWarning) // 日志打印等级
+#define rlogTag "W5500Dns"         // 日志tag
 
 #include "RyanW5500Store.h"
 
@@ -456,11 +455,11 @@ int8_t DNS_run(uint8_t *dns_ip, uint8_t *name, uint8_t *ip_from_dns, uint8_t *bu
     sock = RyanW5500SocketCreate(SOCK_DGRAM, IPPORT_DOMAIN);
     if (NULL == sock)
     {
-        LOG_W("dns socket失败");
+        rlog_w("dns socket失败");
         return -2;
     }
 
-    LOG_D("> DNS Query to DNS Server : %d.%d.%d.%d", dns_ip[0], dns_ip[1], dns_ip[2], dns_ip[3]);
+    rlog_d("> DNS Query to DNS Server : %d.%d.%d.%d", dns_ip[0], dns_ip[1], dns_ip[2], dns_ip[3]);
 
     DNS_SOCKET = sock->socket; // SOCK_DNS
     pDNSMSG = buf;             // User's shared buffer
@@ -478,14 +477,14 @@ int8_t DNS_run(uint8_t *dns_ip, uint8_t *name, uint8_t *ip_from_dns, uint8_t *bu
             if (len > MAX_DNS_BUF_SIZE)
                 len = MAX_DNS_BUF_SIZE;
             len = wizchip_recvfrom(DNS_SOCKET, pDNSMSG, len, ip, &port);
-            LOG_D("> Receive DNS message from %d.%d.%d.%d(%d). len = %d", ip[0], ip[1], ip[2], ip[3], port, len);
+            rlog_d("> Receive DNS message from %d.%d.%d.%d(%d). len = %d", ip[0], ip[1], ip[2], ip[3], port, len);
             ret = parseDNSMSG(&dhp, pDNSMSG, ip_from_dns);
             break;
         }
 
         if (0 == platformTimerRemain(&recvTimer))
         {
-            LOG_D("> DNS Timeout\r\n");
+            rlog_d("> DNS Timeout\r\n");
             wizchip_sendto(DNS_SOCKET, pDNSMSG, len, dns_ip, IPPORT_DOMAIN);
             platformTimerCutdown(&recvTimer, DNS_WAIT_TIME);
             retry_count++;
@@ -493,7 +492,7 @@ int8_t DNS_run(uint8_t *dns_ip, uint8_t *name, uint8_t *ip_from_dns, uint8_t *bu
 
         if (retry_count >= MAX_DNS_RETRY)
         {
-            LOG_D("> DNS Server is not responding : %d.%d.%d.%d", dns_ip[0], dns_ip[1], dns_ip[2], dns_ip[3]);
+            rlog_d("> DNS Server is not responding : %d.%d.%d.%d", dns_ip[0], dns_ip[1], dns_ip[2], dns_ip[3]);
             wizchip_close(DNS_SOCKET);
             return 0; // timeout occurred
         }

platform/RT-Thread/platformW5500Hardware.c

@@ -2,11 +2,11 @@
 
 #include <stdio.h>
 #include <stdint.h>
-#include <board.h>
 #include <rtthread.h>
 #include <rtdevice.h>
-#include <rtdbg.h>
+#include <board.h>
 #include "drv_spi.h"
+#include "RyanW5500Log.h"
 
 static struct rt_spi_device *RyanW5500SpiDevice = NULL;
 #define RyanW5500SpiFreqMax (40 * 1000 * 1000)
@@ -20,7 +20,7 @@ int RyanW5500SpiInit()
     RyanW5500SpiDevice = (void *)rt_device_find(RYANW5500_SPI_DEVICE);
     if (RyanW5500SpiDevice == NULL)
     {
-        LOG_E("You should attach [%s] into SPI bus firstly.", RYANW5500_SPI_DEVICE);
+        rlog_e("You should attach [%s] into SPI bus firstly.", RYANW5500_SPI_DEVICE);
         return RT_ERROR;
     }
 
@@ -33,7 +33,7 @@ int RyanW5500SpiInit()
 
     if (rt_device_open((rt_device_t)RyanW5500SpiDevice, RT_DEVICE_OFLAG_RDWR) != RT_EOK)
     {
-        LOG_E("open WIZnet SPI device %s error.", RYANW5500_SPI_DEVICE);
+        rlog_e("open WIZnet SPI device %s error.", RYANW5500_SPI_DEVICE);
         return RT_ERROR;
     }
 
@@ -149,10 +149,10 @@ void RyanW5500Reset(void)
     rt_pin_mode(RYANW5500_RST_PIN, PIN_MODE_OUTPUT); // 设置重启引脚电平
 
     rt_pin_write(RYANW5500_RST_PIN, PIN_LOW);
-    rt_thread_mdelay(2);
+    rt_thread_mdelay(10);
 
     rt_pin_write(RYANW5500_RST_PIN, PIN_HIGH);
-    rt_thread_mdelay(2);
+    rt_thread_mdelay(10);
 }
 
 /**