Merge remote-tracking branch 'upstream/master'

# Conflicts:
#	src/thread.c

7 files changed, 1095 insertions, 164 deletions

diff --git a/examples/network/tcpclient.c b/examples/network/tcpclient.c
index 20d14baebb..d4c96f893a 100644
--- a/examples/network/tcpclient.c
+++ b/examples/network/tcpclient.c
@@ -1,27 +1,60 @@
 #include <rtthread.h>
+#include <string.h>
 
+#if !defined(SAL_USING_POSIX)
+#error "Please enable SAL_USING_POSIX!"
+#else
+#include <sys/time.h>
+#include <sys/select.h>
+#endif
 #include <sys/socket.h> /* 使用BSD socket，需要包含socket.h头文件 */
 #include "netdb.h"
 
+#define DEBUG_TCP_CLIENT
+
+#define DBG_ENABLE
+#define DBG_SECTION_NAME               "TCP"
+#ifdef DEBUG_TCP_CLIENT
+#define DBG_LEVEL                      DBG_LOG
+#else
+#define DBG_LEVEL                      DBG_INFO /* DBG_ERROR */
+#endif
+#define DBG_COLOR
+#include <rtdbg.h>
+
 #define BUFSZ   1024
 
+static int started = 0;
+static int is_running = 0;
+static char url[256];
+static int port = 8080;
 static const char send_data[] = "This is TCP Client from RT-Thread."; /* 发送用到的数据 */
-void tcpclient(const char *url, int port)
+
+static void tcpclient(void *arg)
 {
     int ret;
     char *recv_data;
-    struct hostent *host;
-    int sock, bytes_received;
+    int bytes_received;
+    int sock = -1;
+    struct hostent *host = RT_NULL;
     struct sockaddr_in server_addr;
 
+    struct timeval timeout;
+    fd_set readset;
+
     /* 通过函数入口参数url获得host地址（如果是域名，会做域名解析） */
     host = gethostbyname(url);
+    if (host == RT_NULL)
+    {
+        LOG_E("Get host by name failed!");
+        return;
+    }
 
     /* 分配用于存放接收数据的缓冲 */
     recv_data = rt_malloc(BUFSZ);
     if (recv_data == RT_NULL)
     {
-        rt_kprintf("No memory\n");
+        LOG_E("No memory");
         return;
     }
 
@@ -29,11 +62,8 @@ void tcpclient(const char *url, int port)
     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
     {
         /* 创建socket失败 */
-        rt_kprintf("Socket error\n");
-
-        /* 释放接收缓冲 */
-        rt_free(recv_data);
-        return;
+        LOG_E("Create socket error");
+        goto __exit;
     }
 
     /* 初始化预连接的服务端地址 */
@@ -46,78 +76,159 @@ void tcpclient(const char *url, int port)
     if (connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
     {
         /* 连接失败 */
-        rt_kprintf("Connect fail!\n");
-        closesocket(sock);
-
-        /*释放接收缓冲 */
-        rt_free(recv_data);
-        return;
+        LOG_E("Connect fail!");
+        goto __exit;
     }
 
-    while (1)
+    started = 1;
+    is_running = 1;
+
+    timeout.tv_sec = 3;
+    timeout.tv_usec = 0;
+
+    while (is_running)
     {
+        FD_ZERO(&readset);
+        FD_SET(sock, &readset);
+
+        /* Wait for read */
+        if (select(sock + 1, &readset, RT_NULL, RT_NULL, &timeout) == 0)
+            continue;
+
         /* 从sock连接中接收最大BUFSZ - 1字节数据 */
         bytes_received = recv(sock, recv_data, BUFSZ - 1, 0);
         if (bytes_received < 0)
         {
             /* 接收失败，关闭这个连接 */
-            closesocket(sock);
-            rt_kprintf("\nreceived error,close the socket.\r\n");
-
-            /* 释放接收缓冲 */
-            rt_free(recv_data);
-            break;
+            LOG_E("Received error, close the socket.");
+            goto __exit;
         }
         else if (bytes_received == 0)
         {
             /* 打印recv函数返回值为0的警告信息 */
-            rt_kprintf("\nReceived warning,recv function return 0.\r\n");
-
+            LOG_W("Received warning, recv function return 0.");
             continue;
         }
-
-        /* 有接收到数据，把末端清零 */
-        recv_data[bytes_received] = '\0';
-
-        if (strcmp(recv_data, "q") == 0 || strcmp(recv_data, "Q") == 0)
-        {
-            /* 如果是首字母是q或Q，关闭这个连接 */
-            closesocket(sock);
-            rt_kprintf("\n got a 'q' or 'Q',close the socket.\r\n");
-
-            /* 释放接收缓冲 */
-            rt_free(recv_data);
-            break;
-        }
         else
         {
-            /* 在控制终端显示收到的数据 */
-            rt_kprintf("\nReceived data = %s ", recv_data);
+            /* 有接收到数据，把末端清零 */
+            recv_data[bytes_received] = '\0';
+
+            if (rt_strcmp(recv_data, "q") == 0 || rt_strcmp(recv_data, "Q") == 0)
+            {
+                /* 如果是首字母是q或Q，关闭这个连接 */
+                LOG_I("Got a 'q' or 'Q', close the socket.");
+                goto __exit;
+            }
+            else
+            {
+                /* 在控制终端显示收到的数据 */
+                LOG_D("Received data = %s", recv_data);
+            }
         }
 
         /* 发送数据到sock连接 */
-        ret = send(sock, send_data, strlen(send_data), 0);
+        ret = send(sock, send_data, rt_strlen(send_data), 0);
         if (ret < 0)
         {
             /* 接收失败，关闭这个连接 */
-            closesocket(sock);
-            rt_kprintf("\nsend error,close the socket.\r\n");
-
-            rt_free(recv_data);
-            break;
+            LOG_I("send error, close the socket.");
+            goto __exit;
         }
         else if (ret == 0)
         {
             /* 打印send函数返回值为0的警告信息 */
-            rt_kprintf("\n Send warning,send function return 0.\r\n");
+            LOG_W("Send warning, send function return 0.");
+        }
+    }
+
+__exit:
+    if (recv_data)
+    {
+        rt_free(recv_data);
+        recv_data = RT_NULL;
+    }
+    if (sock >= 0)
+    {
+        closesocket(sock);
+        sock = -1;
+    }
+    started = 0;
+    is_running = 0;
+    return;
+}
+
+static void usage(void)
+{
+    rt_kprintf("Usage: tcpclient -h <host> -p <port>\n");
+    rt_kprintf("       tcpclient --stop\n");
+    rt_kprintf("       tcpclient --help\n");
+    rt_kprintf("\n");
+    rt_kprintf("Miscellaneous:\n");
+    rt_kprintf("  -h           Specify host address\n");
+    rt_kprintf("  -p           Specify the host port number\n");
+    rt_kprintf("  --stop       Stop tcpclient program\n");
+    rt_kprintf("  --help       Print help information\n");
+}
+
+static void tcpclient_test(int argc, char** argv)
+{
+    rt_thread_t tid;
+
+    if (argc == 1 || argc > 5)
+    {
+        LOG_I("Please check the command you entered!\n");
+        goto __usage;
+    }
+    else
+    {
+        if (rt_strcmp(argv[1], "--help") == 0)
+        {
+            goto __usage;
+        }
+        else if (rt_strcmp(argv[1], "--stop") == 0)
+        {
+            is_running = 0;
+            return;
+        }
+        else if (rt_strcmp(argv[1], "-h") == 0 && rt_strcmp(argv[3], "-p") == 0)
+        {
+            if (started)
+            {
+                LOG_I("The tcpclient has started!");
+                LOG_I("Please stop tcpclient firstly, by: tcpclient --stop");
+                return;
+            }
+
+            if (rt_strlen(argv[2]) > sizeof(url))
+            {
+                LOG_E("The input url is too long, max %d bytes!", sizeof(url));
+                return;
+            }
+            rt_memset(url, 0x0, sizeof(url));
+            rt_strncpy(url, argv[2], rt_strlen(argv[2]));
+            port = atoi(argv[4]);
+        }
+        else
+        {
+            goto __usage;
         }
     }
 
+    tid = rt_thread_create("tcp_client",
+        tcpclient, RT_NULL,
+        2048, RT_THREAD_PRIORITY_MAX/3, 20);
+    if (tid != RT_NULL)
+    {
+        rt_thread_startup(tid);
+    }
     return;
+
+__usage:
+    usage();
 }
 
 #ifdef RT_USING_FINSH
-#include <finsh.h>
-/* 输出tcpclient函数到finsh shell中 */
-FINSH_FUNCTION_EXPORT(tcpclient, startup tcp client);
+MSH_CMD_EXPORT_ALIAS(tcpclient_test, tcpclient,
+    Start a tcp client. Help: tcpclient --help);
 #endif
diff --git a/examples/network/tcpserver.c b/examples/network/tcpserver.c
index 97292449a0..264b6f7c83 100644
--- a/examples/network/tcpserver.c
+++ b/examples/network/tcpserver.c
@@ -1,151 +1,263 @@
 #include <rtthread.h>
+#include <string.h>
 
+#if !defined(SAL_USING_POSIX)
+#error "Please enable SAL_USING_POSIX!"
+#else
+#include <sys/time.h>
+#include <sys/select.h>
+#endif
 #include <sys/socket.h> /* 使用BSD socket，需要包含socket.h头文件 */
 #include "netdb.h"
 
+#define DEBUG_TCP_SERVER
+
+#define DBG_ENABLE
+#define DBG_SECTION_NAME               "TCP"
+#ifdef DEBUG_TCP_SERVER
+#define DBG_LEVEL                      DBG_LOG
+#else
+#define DBG_LEVEL                      DBG_INFO /* DBG_ERROR */
+#endif
+#define DBG_COLOR
+#include <rtdbg.h>
+
 #define BUFSZ       (1024)
 
+static int started = 0;
+static int is_running = 0;
+static int port = 5000;
 static const char send_data[] = "This is TCP Server from RT-Thread."; /* 发送用到的数据 */
-static void tcpserv(void *parameter)
+
+static void tcpserv(void *arg)
 {
+    int ret;
     char *recv_data; /* 用于接收的指针，后面会做一次动态分配以请求可用内存 */
-    socklen_t sin_size;
     int sock, connected, bytes_received;
     struct sockaddr_in server_addr, client_addr;
-    rt_bool_t stop = RT_FALSE; /* 停止标志 */
-    int ret;
+
+    struct timeval timeout;
+    fd_set readset, readset_c;
+    socklen_t sin_size = sizeof(struct sockaddr_in);
 
     recv_data = rt_malloc(BUFSZ + 1); /* 分配接收用的数据缓冲 */
     if (recv_data == RT_NULL)
     {
-        rt_kprintf("No memory\n");
+        LOG_E("No memory");
         return;
     }
 
     /* 一个socket在使用前，需要预先创建出来，指定SOCK_STREAM为TCP的socket */
-    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1)
     {
-        /* 创建失败的错误处理 */
-        rt_kprintf("Socket error\n");
-
-        /* 释放已分配的接收缓冲 */
-        rt_free(recv_data);
-        return;
+        LOG_E("Create socket error");
+        goto __exit;
     }
 
     /* 初始化服务端地址 */
     server_addr.sin_family = AF_INET;
-    server_addr.sin_port = htons(5000); /* 服务端工作的端口 */
+    server_addr.sin_port = htons(port); /* 服务端工作的端口 */
     server_addr.sin_addr.s_addr = INADDR_ANY;
-    rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
+    rt_memset(&(server_addr.sin_zero), 0x0, sizeof(server_addr.sin_zero));
 
     /* 绑定socket到服务端地址 */
     if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
     {
-        /* 绑定失败 */
-        rt_kprintf("Unable to bind\n");
-
-        /* 释放已分配的接收缓冲 */
-        rt_free(recv_data);
-        return;
+        LOG_E("Unable to bind");
+        goto __exit;
     }
 
     /* 在socket上进行监听 */
-    if (listen(sock, 5) == -1)
+    if (listen(sock, 10) == -1)
     {
-        rt_kprintf("Listen error\n");
-
-        /* release recv buffer */
-        rt_free(recv_data);
-        return;
+        LOG_E("Listen error");
+        goto __exit;
     }
 
-    rt_kprintf("\nTCPServer Waiting for client on port 5000...\n");
-    while (stop != RT_TRUE)
+    LOG_I("\nTCPServer Waiting for client on port %d...\n", port);
+
+    started = 1;
+    is_running = 1;
+
+    timeout.tv_sec = 3;
+    timeout.tv_usec = 0;
+
+    while (is_running)
     {
-        sin_size = sizeof(struct sockaddr_in);
+        FD_ZERO(&readset);
+        FD_SET(sock, &readset);
+
+        LOG_I("Waiting for a new connection...");
+
+        /* Wait for read or write */
+        if (select(sock + 1, &readset, RT_NULL, RT_NULL, &timeout) == 0)
+            continue;
 
         /* 接受一个客户端连接socket的请求，这个函数调用是阻塞式的 */
         connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size);
         /* 返回的是连接成功的socket */
         if (connected < 0)
         {
-            rt_kprintf("accept connection failed! errno = %d\n", errno);
+            LOG_E("accept connection failed! errno = %d", errno);
             continue;
         }
 
         /* 接受返回的client_addr指向了客户端的地址信息 */
-        rt_kprintf("I got a connection from (%s , %d)\n",
+        LOG_I("I got a connection from (%s , %d)\n",
                    inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
 
         /* 客户端连接的处理 */
-        while (1)
+        while (is_running)
         {
-            /* 发送数据到connected socket */
-            ret = send(connected, send_data, strlen(send_data), 0);
-            if (ret < 0)
-            {
-                /* 发送失败，关闭这个连接 */
-                closesocket(connected);
-                rt_kprintf("\nsend error,close the socket.\r\n");
-                break;
-            }
-            else if (ret == 0)
-            {
-                /* 打印send函数返回值为0的警告信息 */
-                rt_kprintf("\n Send warning,send function return 0.\r\n");
-            }
+            FD_ZERO(&readset_c);
+            FD_SET(connected, &readset_c);
+
+            /* Wait for read or write */
+            if (select(connected + 1, &readset_c, RT_NULL, RT_NULL, &timeout) == 0)
+                continue;
 
             /* 从connected socket中接收数据，接收buffer是1024大小，但并不一定能够收到1024大小的数据 */
             bytes_received = recv(connected, recv_data, BUFSZ, 0);
             if (bytes_received < 0)
             {
-                /* 接收失败，关闭这个connected socket */
+                LOG_E("Received error, close the connect.");
                 closesocket(connected);
+                connected = -1;
                 break;
             }
             else if (bytes_received == 0)
             {
                 /* 打印recv函数返回值为0的警告信息 */
-                rt_kprintf("\nReceived warning,recv function return 0.\r\n");
-                closesocket(connected);
-                break;
+                LOG_W("Received warning, recv function return 0.");
+                continue;
             }
-
-            /* 有接收到数据，把末端清零 */
-            recv_data[bytes_received] = '\0';
-            if (strcmp(recv_data, "q") == 0 || strcmp(recv_data, "Q") == 0)
+            else
             {
-                /* 如果是首字母是q或Q，关闭这个连接 */
-                closesocket(connected);
-                break;
+                /* 有接收到数据，把末端清零 */
+                recv_data[bytes_received] = '\0';
+                if (strcmp(recv_data, "q") == 0 || strcmp(recv_data, "Q") == 0)
+                {
+                    /* 如果是首字母是q或Q，关闭这个连接 */
+                    LOG_I("Got a 'q' or 'Q', close the connect.");
+                    closesocket(connected);
+                    connected = -1;
+                    break;
+                }
+                else if (strcmp(recv_data, "exit") == 0)
+                {
+                    /* 如果接收的是exit，则关闭整个服务端 */
+                    closesocket(connected);
+                    connected = -1;
+                    goto __exit;
+                }
+                else
+                {
+                    /* 在控制终端显示收到的数据 */
+                    LOG_D("Received data = %s", recv_data);
+                }
             }
-            else if (strcmp(recv_data, "exit") == 0)
+
+            /* 发送数据到connected socket */
+            ret = send(connected, send_data, rt_strlen(send_data), 0);
+            if (ret < 0)
             {
-                /* 如果接收的是exit，则关闭整个服务端 */
+                LOG_E("send error, close the connect.");
                 closesocket(connected);
-                stop = RT_TRUE;
+                connected = -1;
                 break;
             }
-            else
+            else if (ret == 0)
             {
-                /* 在控制终端显示收到的数据 */
-                rt_kprintf("RECEIVED DATA = %s \n", recv_data);
+                /* 打印send函数返回值为0的警告信息 */
+                LOG_W("Send warning, send function return 0.");
             }
         }
     }
 
-    /* 退出服务 */
-    closesocket(sock);
+__exit:
+    if (recv_data)
+    {
+        rt_free(recv_data);
+        recv_data = RT_NULL;
+    }
+    if (connected >= 0)
+    {
+        closesocket(connected);
+        connected = -1;
+    }
+    if (sock >= 0)
+    {
+        closesocket(sock);
+        sock = -1;
+    }
+    started = 0;
+    is_running = 0;
+    return;
+}
+
+static void usage(void)
+{
+    rt_kprintf("Usage: tcpserver -p <port>\n");
+    rt_kprintf("       tcpserver --stop\n");
+    rt_kprintf("       tcpserver --help\n");
+    rt_kprintf("\n");
+    rt_kprintf("Miscellaneous:\n");
+    rt_kprintf("  -p           Specify the host port number\n");
+    rt_kprintf("  --stop       Stop tcpserver program\n");
+    rt_kprintf("  --help       Print help information\n");
+}
+
+static void tcpserver_test(int argc, char** argv)
+{
+    rt_thread_t tid;
+
+    if (argc == 1 || argc > 3)
+    {
+        LOG_I("Please check the command you entered!\n");
+        goto __usage;
+    }
+    else
+    {
+        if (rt_strcmp(argv[1], "--help") == 0)
+        {
+            goto __usage;
+        }
+        else if (rt_strcmp(argv[1], "--stop") == 0)
+        {
+            is_running = 0;
+            return;
+        }
+        else if (rt_strcmp(argv[1], "-p") == 0)
+        {
+            if (started)
+            {
+                LOG_I("The tcpclient has started!");
+                LOG_I("Please stop tcpclient firstly, by: tcpclient --stop");
+                return;
+            }
+
+            port = atoi(argv[2]);
+        }
+        else
+        {
+            goto __usage;
+        }
+    }
 
-    /* 释放接收缓冲 */
-    rt_free(recv_data);
+    tid = rt_thread_create("tcp_serv",
+        tcpserv, RT_NULL,
+        2048, RT_THREAD_PRIORITY_MAX/3, 20);
+    if (tid != RT_NULL)
+    {
+        rt_thread_startup(tid);
+    }
+    return;
 
-    return ;
+__usage:
+    usage();
 }
 
 #ifdef RT_USING_FINSH
-#include <finsh.h>
-/* 输出tcpserv函数到finsh shell中 */
-FINSH_FUNCTION_EXPORT(tcpserv, startup tcp server);
+MSH_CMD_EXPORT_ALIAS(tcpserver_test, tcpserver,
+    Start a tcp server. Help: tcpserver --help);
 #endif
diff --git a/examples/network/udpclient.c b/examples/network/udpclient.c
index 5060c9a087..40542b9fa1 100644
--- a/examples/network/udpclient.c
+++ b/examples/network/udpclient.c
@@ -1,11 +1,28 @@
 #include <rtthread.h>
-//#include <lwip/netdb.h> /* 为了解析主机名，需要包含netdb.h头文件 */
-//#include <lwip/sockets.h> /* 使用BSD socket，需要包含sockets.h头文件 */
+
 #include <sys/socket.h> /* 使用BSD socket，需要包含sockets.h头文件 */
 #include "netdb.h"
 
+#define DEBUG_UDP_CLIENT
+
+#define DBG_ENABLE
+#define DBG_SECTION_NAME               "UDP"
+#ifdef DEBUG_UDP_CLIENT
+#define DBG_LEVEL                      DBG_LOG
+#else
+#define DBG_LEVEL                      DBG_INFO /* DBG_ERROR */
+#endif
+#define DBG_COLOR
+#include <rtdbg.h>
+
+static int started = 0;
+static int is_running = 0;
+static char url[256];
+static int port = 8080;
+static int count = 10;
 const char send_data[] = "This is UDP Client from RT-Thread.\n"; /* 发送用到的数据 */
-void udpclient(const char *url, int port, int count)
+
+static void udpclient(void *arg)
 {
     int sock;
     struct hostent *host;
@@ -13,11 +30,16 @@ void udpclient(const char *url, int port, int count)
 
     /* 通过函数入口参数url获得host地址（如果是域名，会做域名解析） */
     host = (struct hostent *) gethostbyname(url);
+    if (host == RT_NULL)
+    {
+        LOG_E("Get host by name failed!");
+        return;
+    }
 
     /* 创建一个socket，类型是SOCK_DGRAM，UDP类型 */
-    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
+    if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
     {
-        rt_kprintf("Socket error\n");
+        LOG_E("Create socket error");
         return;
     }
 
@@ -27,26 +49,115 @@ void udpclient(const char *url, int port, int count)
     server_addr.sin_addr = *((struct in_addr *)host->h_addr);
     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
 
+    started = 1;
+    is_running = 1;
+
     /* 总计发送count次数据 */
-    while (count)
+    while (count && is_running)
     {
         /* 发送数据到服务远端 */
-        sendto(sock, send_data, strlen(send_data), 0,
+        sendto(sock, send_data, rt_strlen(send_data), 0,
                (struct sockaddr *)&server_addr, sizeof(struct sockaddr));
 
         /* 线程休眠一段时间 */
-        rt_thread_delay(50);
+        rt_thread_mdelay(1000);
 
         /* 计数值减一 */
         count --;
     }
 
+    if (count == 0)
+    {
+        LOG_I("UDP client send data finished!");
+    }
+
     /* 关闭这个socket */
-    closesocket(sock);
+    if (sock >= 0)
+    {
+        closesocket(sock);
+        sock = -1;
+    }
+    started = 0;
+    is_running = 0;
+}
+
+static void usage(void)
+{
+    rt_kprintf("Usage: udpclient -h <host> -p <port> [--cnt] [count]\n");
+    rt_kprintf("       udpclient --stop\n");
+    rt_kprintf("       udpclient --help\n");
+    rt_kprintf("\n");
+    rt_kprintf("Miscellaneous:\n");
+    rt_kprintf("  -h           Specify host address\n");
+    rt_kprintf("  -p           Specify the host port number\n");
+    rt_kprintf("  --cnt        Specify the send data count\n");
+    rt_kprintf("  --stop       Stop tcpclient program\n");
+    rt_kprintf("  --help       Print help information\n");
+}
+
+static void udpclient_test(int argc, char** argv)
+{
+    rt_thread_t tid;
+
+    if (argc == 1 || argc > 7)
+    {
+        LOG_I("Please check the command you entered!\n");
+        goto __usage;
+    }
+    else
+    {
+        if (rt_strcmp(argv[1], "--help") == 0)
+        {
+            goto __usage;
+        }
+        else if (rt_strcmp(argv[1], "--stop") == 0)
+        {
+            is_running = 0;
+            return;
+        }
+        else if (rt_strcmp(argv[1], "-h") == 0 && rt_strcmp(argv[3], "-p") == 0)
+        {
+            if (started)
+            {
+                LOG_I("The tcpclient has started!");
+                LOG_I("Please stop tcpclient firstly, by: tcpclient --stop");
+                return;
+            }
+
+            if (argc == 7 && rt_strcmp(argv[6], "--cnt") == 0)
+            {
+                count = atoi(argv[7]);
+            }
+
+            if (rt_strlen(argv[2]) > sizeof(url))
+            {
+                LOG_E("The input url is too long, max %d bytes!", sizeof(url));
+                return;
+            }
+            rt_memset(url, 0x0, sizeof(url));
+            rt_strncpy(url, argv[2], rt_strlen(argv[2]));
+            port = atoi(argv[4]);
+        }
+        else
+        {
+            goto __usage;
+        }
+    }
+
+    tid = rt_thread_create("udp_client",
+        udpclient, RT_NULL,
+        2048, RT_THREAD_PRIORITY_MAX/3, 20);
+    if (tid != RT_NULL)
+    {
+        rt_thread_startup(tid);
+    }
+    return;
+
+__usage:
+    usage();
 }
 
 #ifdef RT_USING_FINSH
-#include <finsh.h>
-/* 输出udpclient函数到finsh shell中 */
-FINSH_FUNCTION_EXPORT(udpclient, startup udp client);
+MSH_CMD_EXPORT_ALIAS(udpclient_test, udpclient,
+    Start a udp client. Help: udpclient --help);
 #endif
diff --git a/examples/network/udpserver.c b/examples/network/udpserver.c
index a684e9cd0c..c40a1972b4 100644
--- a/examples/network/udpserver.c
+++ b/examples/network/udpserver.c
@@ -1,10 +1,33 @@
 #include <rtthread.h>
+#include <string.h>
 
+#if !defined(SAL_USING_POSIX)
+#error "Please enable SAL_USING_POSIX!"
+#else
+#include <sys/time.h>
+#include <sys/select.h>
+#endif
 #include <sys/socket.h> /* 使用BSD socket，需要包含socket.h头文件 */
 #include "netdb.h"
 
+#define DEBUG_UDP_SERVER
+
+#define DBG_ENABLE
+#define DBG_SECTION_NAME               "UDP"
+#ifdef DEBUG_UDP_SERVER
+#define DBG_LEVEL                      DBG_LOG
+#else
+#define DBG_LEVEL                      DBG_INFO /* DBG_ERROR */
+#endif
+#define DBG_COLOR
+#include <rtdbg.h>
+
 #define BUFSZ   1024
 
+static int started = 0;
+static int is_running = 0;
+static int port = 5000;
+
 static void udpserv(void *paramemter)
 {
     int sock;
@@ -13,28 +36,27 @@ static void udpserv(void *paramemter)
     socklen_t addr_len;
     struct sockaddr_in server_addr, client_addr;
 
+    struct timeval timeout;
+    fd_set readset;
+
     /* 分配接收用的数据缓冲 */
     recv_data = rt_malloc(BUFSZ);
     if (recv_data == RT_NULL)
     {
-        /* 分配内存失败，返回 */
-        rt_kprintf("No memory\n");
+        LOG_E("No memory");
         return;
     }
 
     /* 创建一个socket，类型是SOCK_DGRAM，UDP类型 */
     if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
     {
-        rt_kprintf("Socket error\n");
-
-        /* 释放接收用的数据缓冲 */
-        rt_free(recv_data);
-        return;
+        LOG_E("Create socket error");
+        goto __exit;
     }
 
     /* 初始化服务端地址 */
     server_addr.sin_family = AF_INET;
-    server_addr.sin_port = htons(5000);
+    server_addr.sin_port = htons(port);
     server_addr.sin_addr.s_addr = INADDR_ANY;
     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
 
@@ -42,47 +64,134 @@ static void udpserv(void *paramemter)
     if (bind(sock, (struct sockaddr *)&server_addr,
              sizeof(struct sockaddr)) == -1)
     {
-        /* 绑定地址失败 */
-        rt_kprintf("Bind error\n");
-
-        /* 释放接收用的数据缓冲 */
-        rt_free(recv_data);
-        return;
+        LOG_E("Unable to bind");
+        goto __exit;
     }
 
     addr_len = sizeof(struct sockaddr);
-    rt_kprintf("UDPServer Waiting for client on port 5000...\n");
+    LOG_I("UDPServer Waiting for client on port %d...", port);
 
-    while (1)
+    started = 1;
+    is_running = 1;
+
+    timeout.tv_sec = 3;
+    timeout.tv_usec = 0;
+
+    while (is_running)
     {
+        FD_ZERO(&readset);
+        FD_SET(sock, &readset);
+
+        /* Wait for read or write */
+        if (select(sock + 1, &readset, RT_NULL, RT_NULL, &timeout) == 0)
+            continue;
+
         /* 从sock中收取最大BUFSZ - 1字节数据 */
         bytes_read = recvfrom(sock, recv_data, BUFSZ - 1, 0,
                               (struct sockaddr *)&client_addr, &addr_len);
-        /* UDP不同于TCP，它基本不会出现收取的数据失败的情况，除非设置了超时等待 */
+        if (bytes_read < 0)
+        {
+            LOG_E("Received error, close the connect.");
+            goto __exit;
+        }
+        else if (bytes_read == 0)
+        {
+            LOG_W("Received warning, recv function return 0.");
+            continue;
+        }
+        else
+        {
+            recv_data[bytes_read] = '\0'; /* 把末端清零 */
 
-        recv_data[bytes_read] = '\0'; /* 把末端清零 */
+            /* 输出接收的数据 */
+            LOG_D("Received data = %s", recv_data);
 
-        /* 输出接收的数据 */
-        rt_kprintf("\n(%s , %d) said : ", inet_ntoa(client_addr.sin_addr),
-                   ntohs(client_addr.sin_port));
-        rt_kprintf("%s", recv_data);
+            /* 如果接收数据是exit，退出 */
+            if (strcmp(recv_data, "exit") == 0)
+            {
+                goto __exit;
+            }
+        }
+    }
 
-        /* 如果接收数据是exit，退出 */
-        if (strcmp(recv_data, "exit") == 0)
+__exit:
+    if (recv_data)
+    {
+        rt_free(recv_data);
+        recv_data = RT_NULL;
+    }
+    if (sock >= 0)
+    {
+        closesocket(sock);
+        sock = -1;
+    }
+    started = 0;
+    is_running = 0;
+}
+
+static void usage(void)
+{
+    rt_kprintf("Usage: udpserver -p <port>\n");
+    rt_kprintf("       udpserver --stop\n");
+    rt_kprintf("       udpserver --help\n");
+    rt_kprintf("\n");
+    rt_kprintf("Miscellaneous:\n");
+    rt_kprintf("  -p           Specify the host port number\n");
+    rt_kprintf("  --stop       Stop udpserver program\n");
+    rt_kprintf("  --help       Print help information\n");
+}
+
+static void udpserver_test(int argc, char** argv)
+{
+    rt_thread_t tid;
+
+    if (argc == 1 || argc > 3)
+    {
+        LOG_I("Please check the command you entered!\n");
+        goto __usage;
+    }
+    else
+    {
+        if (rt_strcmp(argv[1], "--help") == 0)
+        {
+            goto __usage;
+        }
+        else if (rt_strcmp(argv[1], "--stop") == 0)
+        {
+            is_running = 0;
+            return;
+        }
+        else if (rt_strcmp(argv[1], "-p") == 0)
         {
-            closesocket(sock);
+            if (started)
+            {
+                LOG_I("The tcpclient has started!");
+                LOG_I("Please stop tcpclient firstly, by: tcpclient --stop");
+                return;
+            }
 
-            /* 释放接收用的数据缓冲 */
-            rt_free(recv_data);
-            break;
+            port = atoi(argv[2]);
+        }
+        else
+        {
+            goto __usage;
         }
     }
 
+    tid = rt_thread_create("udp_serv",
+        udpserv, RT_NULL,
+        2048, RT_THREAD_PRIORITY_MAX/3, 20);
+    if (tid != RT_NULL)
+    {
+        rt_thread_startup(tid);
+    }
     return;
+
+__usage:
+    usage();
 }
 
 #ifdef RT_USING_FINSH
-#include <finsh.h>
-/* 输出udpserv函数到finsh shell中 */
-FINSH_FUNCTION_EXPORT(udpserv, startup udp server);
+MSH_CMD_EXPORT_ALIAS(udpserver_test, udpserver,
+    Start a udp server. Help: udpserver --help);
 #endif
diff --git a/examples/pm/timer_app.c b/examples/pm/timer_app.c
new file mode 100644
index 0000000000..73faf52d0a
--- /dev/null
+++ b/examples/pm/timer_app.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-08-07     Tanek        first implementation
+ */
+
+#include <board.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#ifndef RT_USING_TIMER_SOFT
+    #error "Please enable soft timer feature!"
+#endif
+
+#define TIMER_APP_DEFAULT_TICK  (RT_TICK_PER_SECOND * 2)
+
+#ifdef RT_USING_PM
+
+static rt_timer_t timer1;
+
+static void _timeout_entry(void *parameter)
+{
+    rt_kprintf("current tick: %ld\n", rt_tick_get());
+}
+
+static int timer_app_init(void)
+{
+    timer1 = rt_timer_create("timer_app",
+                             _timeout_entry,
+                             RT_NULL,
+                             TIMER_APP_DEFAULT_TICK,
+                             RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_SOFT_TIMER);
+    if (timer1 != RT_NULL)
+    {
+        rt_timer_start(timer1);
+
+        /* keep in timer mode */
+        rt_pm_request(PM_SLEEP_MODE_TIMER);
+
+        return 0;
+    }
+    else
+    {
+        return -1;
+    }
+}
+INIT_EXPORT_APP(timer_app_init);
+
+#endif /* RT_USING_PM */
+
diff --git a/examples/test/rbb_test.c b/examples/test/rbb_test.c
new file mode 100644
index 0000000000..f276c993da
--- /dev/null
+++ b/examples/test/rbb_test.c
@@ -0,0 +1,341 @@
+/*
+ * File      : rbb_test.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-08-31     armink       the first version
+ */
+
+#include <string.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <stdlib.h>
+
+static rt_bool_t put_finish = RT_FALSE;
+
+static void put_thread(void *param)
+{
+    rt_rbb_t rbb = (rt_rbb_t)param;
+    rt_rbb_blk_t block;
+    rt_uint8_t put_count = 0;
+
+    put_finish = RT_FALSE;
+
+    while (put_count < 255)
+    {
+        if (put_count == 10)
+        {
+            put_count = 10;
+        }
+        block = rt_rbb_blk_alloc(rbb, rand() % 10 + 1);
+        if (block)
+        {
+            block->buf[0] = put_count++;
+            rt_rbb_blk_put(block);
+        }
+        rt_thread_mdelay(rand() % 10);
+    }
+    rt_kprintf("Put block data finish.\n");
+
+    put_finish = RT_TRUE;
+}
+
+static void get_thread(void *param)
+{
+    rt_rbb_t rbb = (rt_rbb_t)param;
+    rt_rbb_blk_t block;
+    rt_uint8_t get_count = 0;
+
+    while (get_count < 255)
+    {
+        if (get_count == 10)
+        {
+            get_count = 10;
+        }
+        block = rt_rbb_blk_get(rbb);
+        if (block)
+        {
+            if (block->buf[0] != get_count++)
+            {
+                rt_kprintf("Error: get data (times %d) has an error!\n", get_count);
+            }
+            rt_rbb_blk_free(rbb, block);
+        }
+        else if (put_finish)
+        {
+            break;
+        }
+        rt_thread_mdelay(rand() % 10);
+    }
+    rt_kprintf("Get block data finish.\n");
+    rt_kprintf("\n====================== rbb dynamic test finish =====================\n");
+}
+
+void rbb_test(void)
+{
+    rt_rbb_t rbb;
+    rt_rbb_blk_t blk1, blk2, blk3, blk4, blk5, blk6, _blk1, _blk2;
+    rt_size_t i, j, k, req_size, size;
+    struct rt_rbb_blk_queue blk_queue1;
+    rt_thread_t thread;
+
+    /* create ring block buffer */
+    rt_kprintf("\n====================== rbb create test =====================\n");
+    rbb = rt_rbb_create(52, 6);
+    if (rbb)
+    {
+        rt_kprintf("6 blocks in 52 bytes ring block buffer object create success.\n");
+    }
+    else
+    {
+        rt_kprintf("Test error: 6 blocks in 52 bytes ring block buffer object create failed.\n");
+    }
+    /* allocate block */
+    rt_kprintf("\n====================== rbb alloc test =====================\n");
+    blk1 = rt_rbb_blk_alloc(rbb, 2);
+    if (blk1 && blk1->size == 2)
+    {
+        memset(blk1->buf, 1, blk1->size);
+        rt_kprintf("Block1 (2 bytes) allocate success.\n");
+    }
+    else
+    {
+        rt_kprintf("Test error: block1 (2 bytes) allocate failed.\n");
+        goto __exit;
+    }
+    blk2 = rt_rbb_blk_alloc(rbb, 4);
+    if (blk2 && blk2->size == 4)
+    {
+        memset(blk2->buf, 2, blk2->size);
+        rt_kprintf("Block2 (4 bytes) allocate success.\n");
+    }
+    else
+    {
+        rt_kprintf("Test error: block2 (4 bytes) allocate failed.\n");
+        goto __exit;
+    }
+    blk3 = rt_rbb_blk_alloc(rbb, 8);
+    if (blk3 && blk3->size == 8)
+    {
+        memset(blk3->buf, 3, blk3->size);
+        rt_kprintf("Block3 (8 bytes) allocate success.\n");
+    }
+    else
+    {
+        rt_kprintf("Test error: block3 (8 bytes) allocate failed.\n");
+        goto __exit;
+    }
+    blk4 = rt_rbb_blk_alloc(rbb, 16);
+    if (blk4 && blk4->size == 16)
+    {
+        memset(blk4->buf, 4, blk4->size);
+        rt_kprintf("Block4 (16 bytes) allocate success.\n");
+    }
+    else
+    {
+        rt_kprintf("Test error: block4 (16 bytes) allocate failed.\n");
+        goto __exit;
+    }
+    blk5 = rt_rbb_blk_alloc(rbb, 32);
+    if (blk5 && blk5->size == 32)
+    {
+        memset(blk5->buf, 5, blk5->size);
+        rt_kprintf("Block5 (32 bytes) allocate success.\n");
+    }
+    else
+    {
+        rt_kprintf("Block5 (32 bytes) allocate failed.\n");
+    }
+    blk5 = rt_rbb_blk_alloc(rbb, 18);
+    if (blk5 && blk5->size == 18)
+    {
+        memset(blk5->buf, 5, blk5->size);
+        rt_kprintf("Block5 (18 bytes) allocate success.\n");
+    }
+    else
+    {
+        rt_kprintf("Test error: block5 (18 bytes) allocate failed.\n");
+        goto __exit;
+    }
+    rt_kprintf("Ring block buffer current status:\n");
+    rt_kprintf("next block queue length: %d\n", rt_rbb_next_blk_queue_len(rbb));
+    rt_kprintf("block list length: %d\n", rt_slist_len(&rbb->blk_list));
+    rt_kprintf("|<- 2 -->|<-- 4 -->|<---- 8 ----->|<------- 16 -------->|<------ 18 ------>|<---- 4 ---->|\n");
+    rt_kprintf("+--------+---------+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("| blcok1 | block2  |    block3    |       block4        |       block5     |    empty    |\n");
+    rt_kprintf("+--------+---------+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("| inited | inited  |    inited    |       inited        |       inited     |             |\n");
+
+    /* put block */
+    rt_kprintf("\n====================== rbb put test =====================\n");
+    rt_rbb_blk_put(blk1);
+    rt_rbb_blk_put(blk2);
+    rt_rbb_blk_put(blk3);
+    rt_rbb_blk_put(blk4);
+    rt_rbb_blk_put(blk5);
+    rt_kprintf("Block1 to block5 put success.\n");
+    rt_kprintf("Ring block buffer current status:\n");
+    rt_kprintf("next block queue length: %d\n", rt_rbb_next_blk_queue_len(rbb));
+    rt_kprintf("block list length: %d\n", rt_slist_len(&rbb->blk_list));
+    rt_kprintf("|<- 2 -->|<-- 4 -->|<---- 8 ----->|<------- 16 -------->|<------ 18 ------>|<---- 4 ---->|\n");
+    rt_kprintf("+--------+---------+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("| blcok1 | block2  |    block3    |       block4        |       block5     |    empty    |\n");
+    rt_kprintf("+--------+---------+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("|  put   |  put    |     put      |        put          |        put       |             |\n");
+
+    /* get block */
+    rt_kprintf("\n====================== rbb get test =====================\n");
+    _blk1 = rt_rbb_blk_get(rbb);
+    _blk2 = rt_rbb_blk_get(rbb);
+    for (i = 0; i < _blk1->size; i++)
+    {
+        if (_blk1->buf[i] != 1) break;
+    }
+    for (j = 0; j < _blk2->size; j++)
+    {
+        if (_blk2->buf[j] != 2) break;
+    }
+    if (blk1 == _blk1 && blk2 == _blk2 && i == _blk1->size && j == _blk2->size)
+    {
+        rt_kprintf("Block1 and block2 get success.\n");
+    }
+    else
+    {
+        rt_kprintf("Test error: block1 and block2 get failed.\n");
+        goto __exit;
+    }
+    rt_kprintf("Ring block buffer current status:\n");
+    rt_kprintf("next block queue length: %d\n", rt_rbb_next_blk_queue_len(rbb));
+    rt_kprintf("block list length: %d\n", rt_slist_len(&rbb->blk_list));
+    rt_kprintf("|<- 2 -->|<-- 4 -->|<---- 8 ----->|<------- 16 -------->|<------ 18 ------>|<---- 4 ---->|\n");
+    rt_kprintf("+--------+---------+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("| blcok1 | block2  |    block3    |       block4        |       block5     |    empty    |\n");
+    rt_kprintf("+--------+---------+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("|  get   |   get   |     put      |        put          |        put       |             |\n");
+
+    /* free block */
+    rt_kprintf("\n====================== rbb free test =====================\n");
+    rt_rbb_blk_free(rbb, blk2);
+    rt_kprintf("Block2 free success.\n");
+    rt_rbb_blk_free(rbb, blk1);
+    rt_kprintf("Block1 free success.\n");
+    rt_kprintf("Ring block buffer current status:\n");
+    rt_kprintf("next block queue length: %d\n", rt_rbb_next_blk_queue_len(rbb));
+    rt_kprintf("block list length: %d\n", rt_slist_len(&rbb->blk_list));
+    rt_kprintf("|<------- 6 ------>|<---- 8 ----->|<------- 16 -------->|<------ 18 ------>|<---- 4 ---->|\n");
+    rt_kprintf("+------------------+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("|      empty2      |    block3    |       block4        |       block5     |    empty1   |\n");
+    rt_kprintf("+------------------+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("|                  |     put      |        put          |        put       |             |\n");
+
+    blk6 = rt_rbb_blk_alloc(rbb, 5);
+    if (blk6)
+    {
+        rt_kprintf("Block6 (5 bytes) allocate success.\n");
+    }
+    else
+    {
+        rt_kprintf("Test error: block6 (5 bytes) allocate failed.\n");
+        goto __exit;
+    }
+
+    rt_rbb_blk_put(blk6);
+    rt_kprintf("Block6 put success.\n");
+    rt_kprintf("Ring block buffer current status:\n");
+    rt_kprintf("next block queue length: %d\n", rt_rbb_next_blk_queue_len(rbb));
+    rt_kprintf("block list length: %d\n", rt_slist_len(&rbb->blk_list));
+    rt_kprintf("|<--- 5 ---->|< 1 >|<---- 8 ----->|<------- 16 -------->|<------ 18 ------>|<---- 4 ---->|\n");
+    rt_kprintf("+------------+-----+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("|   block6   |empty|    block3    |       block4        |       block5     |   fragment  |\n");
+    rt_kprintf("+------------+-----+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("|     put    |     |     put      |        put          |        put       |             |\n");
+
+    /* get block queue */
+    rt_kprintf("\n====================== rbb block queue get test =====================\n");
+    req_size = rt_rbb_next_blk_queue_len(rbb) + 5;
+    size = rt_rbb_blk_queue_get(rbb, req_size, &blk_queue1);
+    i = j = k = 0;
+    for (; i < blk3->size; i++)
+    {
+        if (rt_rbb_blk_queue_buf(&blk_queue1)[i] != 3) break;
+    }
+    for (; j < blk4->size; j++)
+    {
+        if (rt_rbb_blk_queue_buf(&blk_queue1)[i + j] != 4) break;
+    }
+    for (; k < blk5->size; k++)
+    {
+        if (rt_rbb_blk_queue_buf(&blk_queue1)[i + j + k] != 5) break;
+    }
+    if (size && size == 42 && rt_rbb_blk_queue_len(&blk_queue1) == 42 && k == blk5->size)
+    {
+        rt_kprintf("Block queue (request %d bytes, actual %d) get success.\n", req_size, size);
+    }
+    else
+    {
+        rt_kprintf("Test error: Block queue (request %d bytes, actual %d) get failed.\n", req_size, size);
+        goto __exit;
+    }
+    rt_kprintf("Ring block buffer current status:\n");
+    rt_kprintf("next block queue length: %d\n", rt_rbb_next_blk_queue_len(rbb));
+    rt_kprintf("block list length: %d\n", rt_slist_len(&rbb->blk_list));
+    rt_kprintf("|            |     |<----- block queue1 (42 bytes continuous buffer) ----->|             |\n");
+    rt_kprintf("|<--- 5 ---->|< 1 >|<---- 8 ----->|<------- 16 -------->|<------ 18 ------>|<---- 4 ---->|\n");
+    rt_kprintf("+------------+-----+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("|   block6   |empty|    block3    |       block4        |       block5     |   fragment  |\n");
+    rt_kprintf("+------------+-----+--------------+---------------------+------------------+-------------+\n");
+    rt_kprintf("|     put    |     |     get      |        get          |        get       |             |\n");
+
+    /* free block queue */
+    rt_kprintf("\n====================== rbb block queue free test =====================\n");
+    rt_rbb_blk_queue_free(rbb, &blk_queue1);
+    rt_kprintf("Block queue1 free success.\n");
+    rt_kprintf("Ring block buffer current status:\n");
+    rt_kprintf("next block queue length: %d\n", rt_rbb_next_blk_queue_len(rbb));
+    rt_kprintf("block list length: %d\n", rt_slist_len(&rbb->blk_list));
+    rt_kprintf("|<--- 5 ---->|<--------------------------------- 47 ------------------------------------>|\n");
+    rt_kprintf("+------------+---------------------------------------------------------------------------+\n");
+    rt_kprintf("|   block6   |                                 empty                                     |\n");
+    rt_kprintf("+------------+---------------------------------------------------------------------------+\n");
+    rt_kprintf("|     put    |                                                                           |\n");
+    rt_rbb_blk_free(rbb, blk6);
+
+    rt_kprintf("\n====================== rbb static test SUCCESS =====================\n");
+
+    rt_kprintf("\n====================== rbb dynamic test =====================\n");
+
+    thread = rt_thread_create("rbb_put", put_thread, rbb, 1024, 10, 25);
+    if (thread)
+    {
+        rt_thread_startup(thread);
+    }
+
+    thread = rt_thread_create("rbb_get", get_thread, rbb, 1024, 10, 25);
+    if (thread)
+    {
+        rt_thread_startup(thread);
+    }
+
+__exit :
+
+    rt_rbb_destroy(rbb);
+}
+
+MSH_CMD_EXPORT(rbb_test, run ring block buffer testcase)
+
diff --git a/examples/ulog/ulog_example.c b/examples/ulog/ulog_example.c
new file mode 100644
index 0000000000..88572f5152
--- /dev/null
+++ b/examples/ulog/ulog_example.c
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-08-02     armink       the first version
+ */
+
+#include <stdlib.h>
+#include <rtthread.h>
+
+#ifndef ULOG_USING_SYSLOG
+#define LOG_TAG              "example"
+#define LOG_LVL              LOG_LVL_DBG
+#include <ulog.h>
+#else
+#include <syslog.h>
+#endif /* ULOG_USING_SYSLOG */
+
+void ulog_example(void)
+{
+    int count = 0;
+
+#ifdef ULOG_USING_SYSLOG
+    openlog("example1", 0, 0);
+#endif
+
+    while (count++ < 50)
+    {
+#ifndef ULOG_USING_SYSLOG
+        /* output different level log by LOG_X API */
+        LOG_D("LOG_D(%d): RT-Thread is an open source IoT operating system from China.", count);
+        LOG_I("LOG_I(%d): RT-Thread is an open source IoT operating system from China.", count);
+        LOG_W("LOG_W(%d): RT-Thread is an open source IoT operating system from China.", count);
+        LOG_E("LOG_E(%d): RT-Thread is an open source IoT operating system from China.", count);
+        ulog_d("test", "ulog_d(%d): RT-Thread is an open source IoT operating system from China.", count);
+        ulog_i("test", "ulog_i(%d): RT-Thread is an open source IoT operating system from China.", count);
+        ulog_w("test", "ulog_w(%d): RT-Thread is an open source IoT operating system from China.", count);
+        ulog_e("test", "ulog_e(%d): RT-Thread is an open source IoT operating system from China.", count);
+
+#ifdef ULOG_USING_FILTER
+        if (count == 20)
+        {
+            /* Set the global filer level is INFO. All of DEBUG log will stop output */
+            ulog_global_filter_lvl_set(LOG_LVL_INFO);
+            /* Set the test tag's level filter's level is ERROR. The DEBUG, INFO, WARNING log will stop output. */
+            ulog_tag_lvl_filter_set("test", LOG_LVL_ERROR);
+        }
+        else if (count == 30)
+        {
+            /* Set the example tag's level filter's level is LOG_FILTER_LVL_SILENT, the log enter silent mode. */
+            ulog_tag_lvl_filter_set("example", LOG_FILTER_LVL_SILENT);
+            /* Set the test tag's level filter's level is WARNING. The DEBUG, INFO log will stop output. */
+            ulog_tag_lvl_filter_set("test", LOG_LVL_WARNING);
+        }
+        else if (count == 40)
+        {
+            /* Set the test tag's level filter's level is LOG_FILTER_LVL_ALL. All level log will resume output. */
+            ulog_tag_lvl_filter_set("test", LOG_FILTER_LVL_ALL);
+            /* Set the global filer level is LOG_FILTER_LVL_ALL. All level log will resume output */
+            ulog_global_filter_lvl_set(LOG_FILTER_LVL_ALL);
+        }
+#endif /* ULOG_USING_FILTER */
+
+#else
+        /* output different priority log by syslog API */
+        syslog(LOG_INFO, "syslog(%d) LOG_INFO: RT-Thread is an open source IoT operating system from China.", count);
+        syslog(LOG_DEBUG, "syslog(%d) LOG_DEBUG: RT-Thread is an open source IoT operating system from China.", count);
+        syslog(LOG_WARNING, "syslog(%d) LOG_WARNING: RT-Thread is an open source IoT operating system from China.", count);
+        syslog(LOG_ERR, "syslog(%d) LOG_ERR: RT-Thread is an open source IoT operating system from China.", count);
+        syslog(LOG_INFO | LOG_MAIL, "syslog(%d) LOG_INFO | LOG_MAIL: RT-Thread is an open source IoT operating system from China.", count);
+        syslog(LOG_DEBUG | LOG_DAEMON, "syslog(%d) LOG_DEBUG | LOG_DAEMON: RT-Thread is an open source IoT operating system from China.", count);
+        syslog(LOG_WARNING | LOG_AUTH, "syslog(%d) LOG_WARNING | LOG_AUTH: RT-Thread is an open source IoT operating system from China.", count);
+        syslog(LOG_ERR | LOG_SYSLOG, "syslog(%d) LOG_ERR | LOG_SYSLOG: RT-Thread is an open source IoT operating system from China.", count);
+
+        if (count == 20)
+        {
+            /* Set log priority mask. Only output ERR and WARNING log. */
+            setlogmask(LOG_MASK(LOG_ERR) | LOG_MASK(LOG_WARNING));
+        }
+        else if (count == 40)
+        {
+            /* Set log priority mask. The log which level is less than ERROR will stop output. */
+            setlogmask(LOG_UPTO(LOG_ERR));
+        }
+#endif /* ULOG_USING_SYSLOG */
+
+        rt_thread_delay(rt_tick_from_millisecond(rand() % 1000));
+    }
+}
+MSH_CMD_EXPORT(ulog_example, run ulog example)