[components]rt-link v0.2.0 新特性：

1. service 通道增加【连接状态】属性
2. service 通道增加发送消息质量配置，ACK、CRC 可配置开关；
3. 发送接口支持阻塞、非阻塞两种发送方式；
4. 已对接到 device 框架，支持 rt_device 接口操作
5. 已对接到 DFS 框架，支持 POSIX 接口操作
6. 移除 hw_port 目录，改为软件包方式添加 hw_port
7. 修复已知 BUG

2 files changed, 467 insertions, 45 deletions

diff --git a/examples/rt-link/rtlink_dev_example.c b/examples/rt-link/rtlink_dev_example.c
new file mode 100644
index 0000000000..0a026bcb3d
--- /dev/null
+++ b/examples/rt-link/rtlink_dev_example.c
@@ -0,0 +1,395 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-06-19     Sherman    the first version
+ */
+
+#include <string.h>
+#include <stdlib.h>
+
+#define DBG_TAG    "example"
+#define DBG_LVL    DBG_LOG
+#include <rtdbg.h>
+#include <rtlink_dev.h>
+
+enum
+{
+    NONE_TEST = 0,
+    SHORT_FRAME_TEST,
+    LONG_FRAME_TEST
+};
+static rt_uint8_t speed_test_type = NONE_TEST;
+
+static struct rt_link_device rtlink_dev = {0};
+#define  RTLINK01       "rtlink01"
+#define TEST_CONTEXT    "This message is sent by RT-Link"
+rt_uint8_t test_buff[1024] = {0};
+
+static rt_err_t rtlink_dev_rx_ind(rt_device_t dev, rt_size_t size)
+{
+    RT_ASSERT(dev != RT_NULL);
+    LOG_I("rx_ind: dev name %s, rx size %d", dev->parent.name, size);
+    return RT_EOK;
+}
+
+static rt_err_t rtlink_dev_tx_done(rt_device_t dev, void *buffer)
+{
+    RT_ASSERT(dev != RT_NULL);
+    struct rt_link_device *rtlink_dev = (struct rt_link_device *)dev;
+    LOG_I("tx_done: dev name %s, buffer 0x%p errno %d", dev->parent.name, buffer, rtlink_dev->service.err);
+    rt_free(buffer);
+    return RT_EOK;
+}
+
+#ifdef RT_USING_POSIX
+#include <dfs_posix.h>
+#include <dfs_poll.h>
+#include <dfs_select.h>
+
+#define RTLINK01_PATH "/dev/rtlink01"
+int fd  = -1;
+
+static void rtlink_fopen(int argc, char *argv[])
+{
+    fd = open(RTLINK01_PATH, O_RDWR | O_NONBLOCK);
+
+    if (fd < 0)
+    {
+        LOG_E("open rt_link failed!");
+    }
+}
+MSH_CMD_EXPORT(rtlink_fopen, rtlink posix interface example);
+
+static void rtlink_fclose(int argc, char *argv[])
+{
+    LOG_D("colse %d", fd);
+    close(fd);
+    fd = -1;
+}
+MSH_CMD_EXPORT(rtlink_fclose, rtlink posix interface example);
+
+static void rtlink_fread(int argc, char *argv[])
+{
+    int read_len;
+    read_len = read(fd, test_buff, sizeof(test_buff));
+    LOG_D("read len %d", read_len);
+    LOG_HEX("read", 8, test_buff, 32);
+}
+MSH_CMD_EXPORT(rtlink_fread, rtlink posix interface example);
+
+static void rtlink_fwrite(int argc, char *argv[])
+{
+    char *data = RT_NULL;
+    rt_size_t length = 0;
+    rt_uint16_t count = 0;
+    rt_size_t ret = 0;
+
+    if (argc == 1)
+    {
+        data = rt_malloc(sizeof(TEST_CONTEXT));
+        if (data)
+        {
+            length = sizeof(TEST_CONTEXT) - 1;
+            rt_memcpy(data, TEST_CONTEXT, sizeof(TEST_CONTEXT) - 1);
+            ret = write(fd, data, length);
+        }
+        LOG_I("write data(0x%p) result: %d.", data, ret);
+    }
+    else if (argc >= 3)
+    {
+        if (strcmp(argv[1], "-l") == 0)
+        {
+            data = rt_malloc(atoi((const char *)argv[2]));
+            if (data)
+            {
+                for (count = 0; count < atoi((const char *)argv[2]); count++)
+                {
+                    data[count] = (count % 93 + 33);
+                }
+                length = atoi((const char *)argv[2]);
+                ret = write(fd, data, length);
+            }
+            LOG_I("write data(0x%p) result: %d.", data, ret);
+        }
+        else
+        {
+            LOG_E("Invalid parameter.");
+        }
+    }
+}
+MSH_CMD_EXPORT(rtlink_fwrite, rtlink posix interface example);
+
+#define RTLINK02         "rtlink02"
+#define RTLINK02_PATH    "/dev/rtlink02"
+static struct rt_link_device rtlink_fd = {0};
+rt_uint8_t fd_buff[1024] = {0};
+
+static void listen_thread(void *param)
+{
+    int fd  = open(RTLINK02_PATH, O_RDWR | O_NONBLOCK);
+    if (fd < 0)
+    {
+        LOG_E("open (%s) failed", RTLINK02);
+        return;
+    }
+    while (1)
+    {
+        rt_uint8_t *write_buf = RT_NULL;
+        int write_len = 0;
+        fd_set readfds, writefds;
+        FD_ZERO(&readfds);
+        FD_ZERO(&writefds);
+        FD_SET(fd, &readfds);
+        FD_SET(fd, &writefds);
+
+        int ret = select(fd + 1, &readfds, &writefds, RT_NULL, RT_NULL);
+        LOG_D("select ret(%d), read (%d), write (%d)", ret, readfds, writefds);
+        if (FD_ISSET(fd, &readfds))
+        {
+            LOG_I("POLLIN");
+            int read_len = read(fd, fd_buff, sizeof(test_buff));
+            LOG_D("read len %d", read_len);
+            LOG_HEX("read", 8, test_buff, 32);
+        }
+
+        if (FD_ISSET(fd, &writefds))
+        {
+            LOG_I("POLLOUT");
+            write_buf = rt_malloc(1024);
+            if (write_buf)
+            {
+                write_len = write(fd, write_buf, 1024);
+                LOG_D("write %d", write_len);
+            }
+        }
+
+        rt_thread_delay(500);
+    }
+    LOG_I("fd (%s) listen thread exit", RTLINK02);
+}
+
+static void rtlink_fselect()
+{
+    /* step1: register rtlink to to the device framework */
+    rt_link_dev_register(&rtlink_fd, RTLINK02,
+                         RT_DEVICE_FLAG_RDWR |
+                         RT_DEVICE_FLAG_REMOVABLE |
+                         RT_DEVICE_FLAG_STANDALONE,
+                         RT_NULL);
+
+    /* step2: Initialize the rlink device as the default configuration,  */
+    rt_device_t device = rt_device_find(RTLINK02);
+    if (device == RT_NULL)
+    {
+        LOG_E("device not find!");
+        return ;
+    }
+    rt_device_init(device);
+
+    /* step3: config rtlink device rx/tx callback, channel, send timeout */
+    rt_device_set_rx_indicate(device, rtlink_dev_rx_ind);
+    rt_device_set_tx_complete(device, rtlink_dev_tx_done);
+    struct rt_link_service service;
+    service.service = RT_LINK_SERVICE_MNGT;
+    service.timeout_tx = RT_WAITING_NO;
+    rt_device_control(device, RT_DEVICE_CTRL_CONFIG, &service);
+
+    rt_thread_t tid = rt_thread_create(RTLINK02, listen_thread, RT_NULL, 1024, 21, 20);
+    if (tid)
+    {
+        rt_thread_startup(tid);
+    }
+}
+MSH_CMD_EXPORT(rtlink_fselect, rtlink posix interface example);
+#endif  /* RT_USING_POSIX */
+
+static void rtlink_dread(void)
+{
+    rt_size_t read_len = 0;
+    rt_device_t dev = rt_device_find(RTLINK01);
+    if (dev == RT_NULL)
+    {
+        LOG_E("dev %s not find ", RTLINK01);
+        return;
+    }
+
+    read_len = rt_device_read(dev, 0, test_buff, sizeof(test_buff));
+
+    LOG_D("read len %d", read_len);
+    LOG_HEX("read", 8, test_buff, 32);
+}
+MSH_CMD_EXPORT(rtlink_dread, rtlink device interface example);
+
+void rt_link_speed_test(void *paremeter)
+{
+    int ret;
+    rt_uint8_t *send_buf, *data;
+    rt_size_t bufflen = 0;
+    rt_size_t sentlen = 0;
+    rt_size_t count = 0;
+    rt_tick_t tick1, tick2;
+    rt_size_t total = 0;
+    rt_uint32_t integer, decimal;
+    rt_device_t dev = rt_device_find(RTLINK01);
+    if (dev == RT_NULL)
+    {
+        LOG_E("dev %s not find!", RTLINK01);
+        return ;
+    }
+
+    if (speed_test_type == SHORT_FRAME_TEST)
+    {
+        bufflen = 988;
+    }
+    else
+    {
+        bufflen = 3036;
+    }
+
+    send_buf = rt_malloc(bufflen);
+    if (send_buf != RT_NULL)
+    {
+        data = send_buf;
+        for (count = 0; count < bufflen; count++)
+        {
+            *data++ = (count % 93 + 33);
+        }
+    }
+    else
+    {
+        rt_kprintf("speed of send buffer malloc failed.");
+        return;
+    }
+
+    tick1 = rt_tick_get();
+    while (speed_test_type)
+    {
+        ret = rt_device_write(dev, 0, send_buf, bufflen);
+
+        if (ret == RT_EOK)
+        {
+            sentlen += bufflen;
+        }
+
+        tick2 = rt_tick_get();
+        if (tick2 - tick1 >= RT_TICK_PER_SECOND)
+        {
+            total = sentlen * RT_TICK_PER_SECOND / 125 / (tick2 - tick1);
+            integer = total / 1000;
+            decimal = total % 1000;
+            LOG_I("%d.%03d0 Mbps!", integer, decimal);
+            sentlen = 0;
+            tick1 = tick2;
+        }
+    }
+    rt_free(send_buf);
+    LOG_W("speed test end, type %d", speed_test_type);
+}
+
+void create_thead_to_test_speed(rt_uint8_t mutil_num)
+{
+    rt_uint8_t i = 0;
+
+    LOG_D("Speed test type [%02d], mutil [%02d]", speed_test_type, mutil_num);
+    for (i = 0; i < mutil_num; i++)
+    {
+        rt_thread_t tid;
+        char tid_name[RT_NAME_MAX + 1] = {0};
+
+        rt_snprintf(tid_name, sizeof(tid_name), "lny_s%03d", i + 1);
+        tid = rt_thread_create(tid_name, rt_link_speed_test, RT_NULL, 1024, 20, 10);
+        rt_thread_startup(tid);
+        LOG_I("Speed test thread[%s] startup", tid_name);
+    }
+}
+
+static void rtlink_dwrite(int argc, char *argv[])
+{
+    char *data = RT_NULL;
+    rt_size_t length = 0;
+    rt_uint16_t count = 0;
+    rt_size_t ret = RT_ERROR;
+
+    rt_device_t dev = rt_device_find(RTLINK01);
+    if (dev == RT_NULL)
+    {
+        LOG_E("device not find!");
+        return ;
+    }
+
+    if (argc == 1)
+    {
+        data = rt_malloc(sizeof(TEST_CONTEXT));
+        length = sizeof(TEST_CONTEXT) - 1;
+        rt_memcpy(data, TEST_CONTEXT, sizeof(TEST_CONTEXT) - 1);
+
+        ret = rt_device_write(dev, 0, data, length);
+        LOG_I("write data(0x%p) result: %d.", data, ret);
+    }
+    else if (argc >= 3)
+    {
+        if (strcmp(argv[1], "-l") == 0)
+        {
+            data = rt_malloc(atoi((const char *)argv[2]));
+            for (count = 0; count < atoi((const char *)argv[2]); count++)
+            {
+                data[count] = (count % 93 + 33);
+            }
+            length = atoi((const char *)argv[2]);
+            ret = rt_device_write(dev, 0, data, length);
+            LOG_I("write data(0x%p) result: %d.", data, ret);
+        }
+        else
+        {
+            LOG_E("Invalid parameter.");
+        }
+    }
+}
+MSH_CMD_EXPORT(rtlink_dwrite, rtlink device interface example);
+
+static void rtlink_dinit(void)
+{
+    /* step1: register rtlink to to the device framework */
+    rt_link_dev_register(&rtlink_dev, RTLINK01,
+                         RT_DEVICE_FLAG_RDWR |
+                         RT_DEVICE_FLAG_REMOVABLE |
+                         RT_DEVICE_FLAG_STANDALONE,
+                         RT_NULL);
+
+    /* step2: Initialize the rlink device as the default configuration,  */
+    rt_device_t device = rt_device_find(RTLINK01);
+    if (device == RT_NULL)
+    {
+        LOG_E("device not find!");
+        return ;
+    }
+    rt_device_init(device);
+
+    /* step3: config rtlink device rx/tx callback, channel, send timeout */
+    rt_device_set_rx_indicate(device, rtlink_dev_rx_ind);
+    rt_device_set_tx_complete(device, rtlink_dev_tx_done);
+    struct rt_link_service service;
+    service.service = RT_LINK_SERVICE_SOCKET;
+    service.timeout_tx = RT_WAITING_FOREVER;
+    service.flag = RT_LINK_FLAG_ACK | RT_LINK_FLAG_CRC;
+    rt_device_control(device, RT_DEVICE_CTRL_CONFIG, &service);
+}
+MSH_CMD_EXPORT(rtlink_dinit, rtlink device interface example);
+
+static void rtlink_dopen()
+{
+    /* step4: open rtlink device, attach the service channel */
+    rt_device_t device = rt_device_find(RTLINK01);
+    if (device == RT_NULL)
+    {
+        LOG_E("device not find!");
+        return ;
+    }
+    rt_err_t ret = rt_device_open(device, RT_DEVICE_OFLAG_RDWR);
+    LOG_I("dev open ret %d", ret);
+}
+MSH_CMD_EXPORT(rtlink_dopen, rtlink device interface example);
diff --git a/examples/rt-link/rtlink_example.c b/examples/rt-link/rtlink_example.c
index 841e56b17e..4c9b9c54fb 100644
--- a/examples/rt-link/rtlink_example.c
+++ b/examples/rt-link/rtlink_example.c
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 2006-2021, RT-Thread Development Team
  *
@@ -7,6 +6,7 @@
  * Change Logs:
  * Date           Author       Notes
  * 2021-05-15     Sherman      the first version
+ * 2021-08-04     Sherman      Adapted to new version of rt-link API
  */
 
 #include <stdlib.h>
@@ -30,33 +30,25 @@ enum
 
 void rt_link_speed_test(void *paremeter);
 static rt_uint8_t speed_test_type = NONE_TEST;
+static struct rt_link_service serv_socket;
+static struct rt_link_service serv_wifi;
 
-rt_err_t rt_link_receive_example_callback(void *data, rt_size_t length)
+static void send_cb(struct rt_link_service *service, void *buffer)
 {
-    LOG_I("recv data %d",length);
-    LOG_HEX("example",8,data,length);
-    rt_free(data);
-    return RT_EOK;
+    LOG_I("send_cb: service (%d) buffer (0x%p) err(%d)", service->service, buffer, service->err);
 }
 
-void create_thead_to_test_speed(rt_uint8_t mutil_num)
+static void recv_cb(struct rt_link_service *service, void *data, rt_size_t size)
 {
-    rt_uint8_t i = 0;
+    LOG_I("service (%d) size (%d) data(0x%p)", service->service, size, data);
 
-    LOG_D("Speed test type [%02d], mutil [%02d]", speed_test_type, mutil_num);
-    for(i = 0; i< mutil_num; i++)
+    if (size)
     {
-        rt_thread_t tid;
-        char tid_name[RT_NAME_MAX + 1] = {0};
-
-        rt_snprintf(tid_name, sizeof(tid_name), "lny_s%03d", i + 1);
-        tid = rt_thread_create(tid_name, rt_link_speed_test, RT_NULL, 1024, 20, 10);
-        rt_thread_startup(tid);
-        LOG_I("Speed test thread[%s] startup", tid_name);
+        rt_free(data);
     }
 }
 
-void rt_link_speed_test(void *paremeter)
+static void rt_link_speed_test(void *paremeter)
 {
     int ret;
     rt_uint8_t *send_buf, *data;
@@ -67,20 +59,20 @@ void rt_link_speed_test(void *paremeter)
     rt_size_t total = 0;
     rt_uint32_t integer, decimal;
 
-    if(speed_test_type == SHORT_FRAME_TEST)
+    if (speed_test_type == SHORT_FRAME_TEST)
     {
-        bufflen = 2044;
+        bufflen = RT_LINK_MAX_DATA_LENGTH;
     }
     else
     {
-        bufflen = 6132;
+        bufflen = RT_LINK_MAX_DATA_LENGTH * RT_LINK_FRAMES_MAX;
     }
 
     send_buf = rt_malloc(bufflen);
-    if(send_buf != RT_NULL)
+    if (send_buf != RT_NULL)
     {
         data = send_buf;
-        for(count = 0;count < bufflen; count++)
+        for (count = 0; count < bufflen; count++)
         {
             *data++ = (count % 93 + 33);
         }
@@ -94,70 +86,94 @@ void rt_link_speed_test(void *paremeter)
     tick1 = rt_tick_get();
     while (speed_test_type)
     {
-        ret = rt_link_send(RT_LINK_SERVICE_RTLINK, send_buf, bufflen);
-        if(ret > 0)
+        ret = rt_link_send(&serv_socket, send_buf, bufflen);
+        if (ret > 0)
         {
             sentlen += ret;
         }
+        else
+        {
+            log_w("send err %d", ret);
+        }
 
         tick2 = rt_tick_get();
-        if (tick2 - tick1 >= RT_TICK_PER_SECOND)//* 10
+        if (tick2 - tick1 >= RT_TICK_PER_SECOND)
         {
             total = sentlen * RT_TICK_PER_SECOND / 125 / (tick2 - tick1);
-            integer = total/1000;
-            decimal = total%1000;
+            integer = total / 1000;
+            decimal = total % 1000;
             LOG_I("%d.%03d0 Mbps!", integer, decimal);
             sentlen = 0;
             tick1 = tick2;
         }
     }
     rt_free(send_buf);
-    LOG_W("speed test end, type %d",speed_test_type);
+    LOG_W("speed test end, type %d", speed_test_type);
+}
+
+static void create_thead_to_test_speed(rt_uint8_t mutil_num)
+{
+    rt_uint8_t i = 0;
+
+    LOG_D("Speed test type [%02d], mutil [%02d]", speed_test_type, mutil_num);
+    for (i = 0; i < mutil_num; i++)
+    {
+        rt_thread_t tid;
+        char tid_name[RT_NAME_MAX + 1] = {0};
+
+        rt_snprintf(tid_name, sizeof(tid_name), "lny_s%03d", i + 1);
+        tid = rt_thread_create(tid_name, rt_link_speed_test, RT_NULL, 1024, 20, 10);
+        if (tid)
+        {
+            rt_thread_startup(tid);
+            LOG_I("Speed test thread[%s] startup", tid_name);
+        }
+    }
 }
 
-int rt_link_example_send(int argc, char **argv)
+static int rtlink_exsend(int argc, char **argv)
 {
     char *receive = RT_NULL;
     rt_size_t length = 0;
     rt_uint16_t count = 0;
 
-    if(argc == 1)
+    if (argc == 1)
     {
         receive = rt_malloc(sizeof(TEST_CONTEXT));
         rt_memcpy(receive, TEST_CONTEXT, sizeof(TEST_CONTEXT) - 1);
-        length = rt_link_send(RT_LINK_SERVICE_RTLINK, receive, sizeof(TEST_CONTEXT) - 1);
+        length = rt_link_send(&serv_socket, receive, sizeof(TEST_CONTEXT) - 1);
         LOG_I("send data length: %d.", length);
         rt_free(receive);
     }
-        else if(argc >= 3)
+    else if (argc >= 3)
     {
-        if(strcmp(argv[1], "-l") == 0)
+        if (strcmp(argv[1], "-l") == 0)
         {
             receive = rt_malloc(atoi((const char *)argv[2]));
-            for(count = 0;count < atoi((const char *)argv[2]); count++)
+            for (count = 0; count < atoi((const char *)argv[2]); count++)
             {
                 *receive++ = (count % 93 + 33);
             }
-            length = rt_link_send(RT_LINK_SERVICE_RTLINK, receive - atoi((const char *)argv[2]), atoi((const char *)argv[2]));
+            length = rt_link_send(&serv_socket, receive - atoi((const char *)argv[2]), atoi((const char *)argv[2]));
             rt_free(receive - atoi((const char *)argv[2]));
 
             LOG_I("send data length: %d.", length);
         }
-        else if(strcmp(argv[1], "-s") == 0)
+        else if (strcmp(argv[1], "-s") == 0)
         {
-            if(speed_test_type == NONE_TEST)
+            if (speed_test_type == NONE_TEST)
             {
                 rt_uint8_t mutil_num = 1;
-                if(argc > 3)
+                if (argc > 3)
                 {
                     mutil_num = atoi((const char *)argv[3]);
                 }
 
-                if(strncmp(argv[2], "-s", rt_strlen(argv[2])) == 0)
+                if (strncmp(argv[2], "-s", rt_strlen(argv[2])) == 0)
                 {
                     speed_test_type = SHORT_FRAME_TEST;
                 }
-                else if(strncmp(argv[2], "-l", rt_strlen(argv[2])) == 0)
+                else if (strncmp(argv[2], "-l", rt_strlen(argv[2])) == 0)
                 {
                     speed_test_type = LONG_FRAME_TEST;
                 }
@@ -176,12 +192,23 @@ int rt_link_example_send(int argc, char **argv)
     }
     return 0;
 }
-MSH_CMD_EXPORT(rt_link_example_send, rt link layer send test);
+MSH_CMD_EXPORT(rtlink_exsend, rt link layer send test);
 
-int rt_link_example_init(void)
+int rtlink_exinit(void)
 {
+    serv_socket.service = RT_LINK_SERVICE_SOCKET;
+    serv_socket.timeout_tx = RT_WAITING_FOREVER;
+    serv_socket.flag = RT_LINK_FLAG_ACK | RT_LINK_FLAG_CRC;
+    serv_socket.recv_cb = recv_cb;
+    serv_socket.send_cb = send_cb;
+    rt_link_service_attach(&serv_socket);
 
-    rt_link_service_attach(RT_LINK_SERVICE_RTLINK, rt_link_receive_example_callback);
+    serv_wifi.service = RT_LINK_SERVICE_WIFI;
+    serv_wifi.timeout_tx = RT_WAITING_FOREVER;
+    serv_wifi.flag = RT_NULL;
+    serv_wifi.recv_cb = recv_cb;
+    serv_wifi.send_cb = send_cb;
+    rt_link_service_attach(&serv_wifi);
     return RT_EOK;
 }
-MSH_CMD_EXPORT(rt_link_example_init, rt link layer example init);
+MSH_CMD_EXPORT(rtlink_exinit, rt link example init);