[add] add new component: rt-link

components/utilities/Kconfig

@@ -205,4 +205,6 @@ config RT_USING_UTEST
             default 20
     endif
 
+source "$RTT_DIR/components/utilities/rt-link/Kconfig"
+
 endmenu

components/utilities/rt-link/Kconfig

@@ -0,0 +1,40 @@
+# Kconfig file for rt_link
+menuconfig RT_USING_RT_LINK
+    bool "RT-Link"
+    default n
+
+if RT_USING_RT_LINK
+    choice
+        prompt"use hw crc device or not"
+        default RT_LINK_USING_SF_CRC
+        
+        config RT_LINK_USING_SF_CRC
+            bool "use software crc table"
+        config RT_LINK_USING_HW_CRC
+            bool "use hardware crc device"
+    endchoice
+
+    menu "rt-link hardware device configuration"
+        config RT_LINK_HW_DEVICE_NAME
+            string "the name of base actual device"
+            default "uart2"
+
+        choice
+            prompt"hardware device is spi, uart or usb"
+            default RT_LINK_USING_UART
+
+            config RT_LINK_USING_UART
+                bool "use UART"
+        endchoice
+
+    endmenu
+
+    menu "rt link debug option"
+        config USING_RT_LINK_DEBUG
+            bool "Enable RT-Link debug"
+            default n
+        config USING_RT_LINK_HW_DEBUG
+            bool "Enable RT-Link hw debug"
+            default n
+    endmenu
+endif

components/utilities/rt-link/SConscript

@@ -0,0 +1,15 @@
+# RT-Thread building script for bridge
+
+import os
+from building import *
+
+cwd = GetCurrentDir()
+objs = []
+list = os.listdir(cwd)
+
+for d in list:
+    path = os.path.join(cwd, d)
+    if os.path.isfile(os.path.join(path, 'SConscript')):
+        objs = objs + SConscript(os.path.join(d, 'SConscript'))
+
+Return('objs')

components/utilities/rt-link/hw_port/SConscript

@@ -0,0 +1,14 @@
+import os
+from building import *
+import rtconfig
+
+cwd  = GetCurrentDir()
+src  = []
+CPPPATH = []
+
+if GetDepend('RT_LINK_USING_UART'):
+    src += ['uart/rtlink_port_uart.c']
+
+group = DefineGroup('rt-link-port', src, depend = ['RT_USING_RT_LINK'], CPPPATH = CPPPATH)
+
+Return('group')

components/utilities/rt-link/hw_port/uart/rtlink_port_uart.c

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2020-12-09     xiangxistu   the first version
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#include <rtlink_port.h>
+
+#ifndef RT_LINK_HW_DEVICE_NAME
+    #define RT_LINK_HW_DEVICE_NAME "uart2"
+#endif
+
+#define DBG_TAG              "rtlink_port"
+#define DBG_LVL              DBG_INFO
+#include <rtdbg.h>
+
+static struct rt_device *hw_device = RT_NULL;
+rt_err_t rt_link_port_rx_ind(rt_device_t device, rt_size_t size)
+{
+    RT_ASSERT(device != RT_NULL);
+
+    rt_uint8_t buffer[RT_SERIAL_RB_BUFSZ] = {0};
+    rt_size_t length = 0;
+    length = rt_device_read(device, 0, buffer, sizeof(buffer));
+    rt_link_hw_write_cb(&buffer, length);
+    return RT_EOK;
+}
+
+rt_size_t rt_link_port_send(void *data, rt_size_t length)
+{
+    rt_size_t size = 0;
+    size = rt_device_write(hw_device, 0, data, length);
+    return size;
+}
+
+int rt_link_port_init(void)
+{
+    hw_device = rt_device_find(RT_LINK_HW_DEVICE_NAME);
+    if (hw_device)
+    {
+        rt_device_open(hw_device, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
+        rt_device_set_rx_indicate(hw_device, rt_link_port_rx_ind);
+    }
+    else
+    {
+        LOG_E("Not find device %s", RT_LINK_HW_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+    return RT_EOK;
+}
+
+int rt_link_port_deinit(void)
+{
+    hw_device = rt_device_find(RT_LINK_HW_DEVICE_NAME);
+    if (hw_device)
+    {
+        rt_device_close(hw_device);
+        rt_device_set_rx_indicate(hw_device, RT_NULL);
+    }
+    else
+    {
+        LOG_E("Not find device %s", RT_LINK_HW_DEVICE_NAME);
+        return -RT_ERROR;
+    }
+    return RT_EOK;
+}

components/utilities/rt-link/inc/rtlink.h

@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-02-02     xiangxistu   the first version
+ * 2021-03-19     Sherman      Streamline the struct rt_link_session
+ */
+
+#ifndef __RT_LINK_H__
+#define __RT_LINK_H__
+
+#include <rtdef.h>
+
+#define RT_LINK_AUTO_INIT
+
+#define RT_LINK_FRAME_HEAD                 0x15
+#define RT_LINK_FRAME_HEAD_MASK            0x1F
+#define RT_LINK_MAX_DATA_LENGTH            2044 /*can exact divide by 4 bytes*/
+#define RT_LINK_FRAMES_MAX   0x03   /* The maximum number of split frames for a long package*/
+
+#define RT_LINK_ACK_MAX   0x07
+#define RT_LINK_CRC_LENGTH          4
+#define RT_LINK_HEAD_LENGTH         4
+#define RT_LINK_MAX_EXTEND_LENGTH       4
+#define RT_LINK_MAX_FRAME_LENGTH        (RT_LINK_HEAD_LENGTH + RT_LINK_MAX_EXTEND_LENGTH + RT_LINK_MAX_DATA_LENGTH + RT_LINK_CRC_LENGTH)
+#define RT_LINK_RECEIVE_BUFFER_LENGTH       (RT_LINK_MAX_FRAME_LENGTH * RT_LINK_FRAMES_MAX + RT_LINK_HEAD_LENGTH + RT_LINK_MAX_EXTEND_LENGTH)
+
+typedef enum
+{
+    RT_LINK_SERVICE_RTLINK = 0,
+    RT_LINK_SERVICE_LINK_SOCKET = 1,
+    RT_LINK_SERVICE_LINK_WIFI = 2,
+    RT_LINK_SERVICE_LINK_MNGT = 3,
+    RT_LINK_SERVICE_LINK_MSHTOOLS = 4,
+    RT_LINK_SERVICE_MAX
+} rt_link_service_t;
+
+enum
+{
+    FRAME_EXTEND = 1 << 0,
+    FRAME_CRC    = 1 << 1,
+    FRAME_ACK    = 1 << 2
+};
+
+typedef enum
+{
+    RT_LINK_RESERVE_FRAME = 0,
+
+    RT_LINK_RESEND_FRAME,
+    RT_LINK_CONFIRM_FRAME,
+    RT_LINK_SHORT_DATA_FRAME,
+    RT_LINK_LONG_DATA_FRAME,
+    RT_LINK_SESSION_END,  /* The retring failed to end the session */
+
+    RT_LINK_HANDSHAKE_FRAME
+} rt_link_frame_attribute_t;
+
+typedef enum
+{
+    /* receive event */
+    RT_LINK_READ_CHECK_EVENT            = 1 << 0,
+    RT_LINK_RECV_TIMEOUT_FRAME_EVENT    = 1 << 1,
+    RT_LINK_RECV_TIMEOUT_LONG_EVENT     = 1 << 2,
+
+    /* send event */
+    RT_LINK_SEND_READY_EVENT    = 1 << 4,
+    RT_LINK_SEND_OK_EVENT       = 1 << 5,
+    RT_LINK_SEND_FAILED_EVENT   = 1 << 6,
+    RT_LINK_SEND_TIMEOUT_EVENT  = 1 << 7
+} rt_link_notice_t;
+
+typedef enum
+{
+    RT_LINK_ESTABLISHING = 0,
+    RT_LINK_NO_RESPONSE,
+    RT_LINK_CONNECT_DONE,
+} rt_link_linkstatus_t;
+
+typedef enum
+{
+    RECVTIMER_NONE = 0,
+    RECVTIMER_FRAME,
+    RECVTIMER_LONGFRAME
+} rt_link_recvtimer_status_t;
+
+struct rt_link_receive_buffer
+{
+    rt_uint8_t data[RT_LINK_RECEIVE_BUFFER_LENGTH]; /* rt-link receive data buffer */
+    rt_uint8_t *read_point;
+    rt_uint8_t *write_point;
+    rt_uint8_t *end_point;
+};
+
+struct rt_link_frame_head
+{
+    rt_uint8_t magicid : 5;
+    rt_uint8_t extend  : 1;
+    rt_uint8_t crc     : 1;
+    rt_uint8_t ack     : 1;
+    rt_uint8_t sequence;
+    rt_uint16_t channel: 5;
+    rt_uint16_t length : 11;
+};
+
+/* record frame information that opposite */
+struct rt_link_record
+{
+    rt_uint8_t rx_seq; /* record the opposite sequence */
+    rt_uint8_t total;       /* the number of long frame number */
+    rt_uint8_t long_count;  /* long packet recv counter */
+    rt_uint8_t *dataspace;  /* the space of long frame */
+};
+
+struct rt_link_extend
+{
+    rt_uint16_t attribute;           /* rt_link_frame_attribute_t */
+    rt_uint16_t parameter;
+};
+
+struct rt_link_frame
+{
+    struct rt_link_frame_head head;         /* frame head */
+    struct rt_link_extend extend;           /* frame extend data */
+    rt_uint8_t *real_data;                  /* the origin data */
+    rt_uint32_t crc;                        /* CRC result */
+
+    rt_uint16_t data_len;         /* the length of frame length */
+    rt_uint16_t attribute;        /* this will show frame attribute , rt_link_frame_attribute_t */
+
+    rt_uint8_t index;              /* the index frame for long frame */
+    rt_uint8_t total;               /* the total frame for long frame */
+
+    rt_slist_t slist;            /* the frame will hang on the send list on session */
+};
+
+struct rt_link_service
+{
+    rt_err_t (*upload_callback)(void *data, rt_size_t size);
+};
+
+struct rt_link_session
+{
+    rt_link_linkstatus_t link_status;   /* Link connection status*/
+    struct rt_event event;      /* the event that core logic */
+    struct rt_link_service channel[RT_LINK_SERVICE_MAX]; /* thansfer to app layer */
+
+    rt_slist_t tx_data_slist;
+    rt_uint8_t tx_seq;     /* sequence for frame */
+    struct rt_mutex tx_lock;    /* protect send data interface, only one thread can hold it */
+    struct rt_timer sendtimer;  /* send function timer for rt link */
+
+    struct rt_link_record rx_record;    /* the memory of receive status */
+    struct rt_timer recvtimer;          /* receive a frame timer for rt link */
+    struct rt_timer longframetimer;     /* receive long frame timer for rt link */
+
+    struct rt_link_receive_buffer *rx_buffer; /* the buffer will store data */
+    rt_uint32_t (*calculate_crc)(rt_uint8_t using_buffer_ring, rt_uint8_t *data, rt_size_t size); /* this function will calculate crc */
+};
+
+/* rtlink init and deinit */
+int rt_link_init(void);
+rt_err_t rt_link_deinit(void);
+/* rtlink send data interface */
+rt_size_t rt_link_send(rt_link_service_t service, void *data, rt_size_t size);
+/* rtlink service attach and detach */
+rt_err_t rt_link_service_attach(rt_link_service_t service, rt_err_t (*function)(void *data, rt_size_t size));
+rt_err_t rt_link_service_detach(rt_link_service_t service);
+
+/* Private operator function */
+struct rt_link_session *rt_link_get_scb(void);
+
+#endif /* __RT_LINK_H__ */

components/utilities/rt-link/inc/rtlink_hw.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-02-02     xiangxistu   the first version
+ *
+ */
+#ifndef __RT_LINK_HW_H__
+#define __RT_LINK_HW_H__
+
+#include <rtdef.h>
+
+rt_size_t rt_link_hw_recv_len(struct rt_link_receive_buffer *buffer);
+void rt_link_hw_copy(rt_uint8_t *dst, rt_uint8_t *src, rt_size_t count);
+void rt_link_hw_buffer_point_shift(rt_uint8_t **pointer_address, rt_size_t length);
+
+rt_err_t rt_link_hw_init(void);
+rt_err_t rt_link_hw_deinit(void);
+rt_err_t rt_link_hw_send(void *data, rt_size_t length);
+
+#endif /* _RT_LINK_PORT_INTERNAL_H_ */

components/utilities/rt-link/inc/rtlink_port.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-02-02     xiangxistu   the first version
+ * 2021-05-15     Sherman      function rename
+ */
+#ifndef __RT_LINK_PORT_H__
+#define __RT_LINK_PORT_H__
+
+#include <rtdef.h>
+
+/* Functions that need to be implemented at the hardware */
+int rt_link_port_init(void);
+int rt_link_port_deinit(void);
+rt_size_t rt_link_port_send(void *data, rt_size_t length);
+
+#ifdef RT_LINK_USING_HW_CRC
+    rt_err_t rt_link_hw_crc32_init(void);
+    rt_err_t rt_link_hw_crc32_deinit(void);
+    rt_err_t rt_link_hw_crc32_reset(void);
+    rt_uint32_t rt_link_hw_crc32(rt_uint8_t *data, rt_size_t u32_size)
+#endif
+
+/* Called when the hardware receives data and the data is transferred to RTLink */
+rt_size_t rt_link_hw_write_cb(void *data, rt_size_t length);
+
+#endif /* __RT_LINK_PORT_H__ */

components/utilities/rt-link/inc/rtlink_utils.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-05-15     Sherman      the first version
+ */
+#ifndef __RT_LINK_UTILITIES_H__
+#define __RT_LINK_UTILITIES_H__
+
+#include <rtthread.h>
+
+/* Calculate the number of '1' */
+int rt_link_utils_num1(rt_uint32_t n);
+
+rt_err_t rt_link_sf_crc32_reset(void);
+rt_uint32_t rt_link_sf_crc32(rt_uint8_t *data, rt_size_t len);
+
+#endif /* __RT_LINK_UTILITIES_H__ */

components/utilities/rt-link/src/SConscript

@@ -0,0 +1,13 @@
+Import('rtconfig')
+from building import *
+
+cwd = GetCurrentDir()
+src = Glob('*.c')
+CPPPATH = [cwd + '/../inc']
+
+group = DefineGroup('rt-link', src, depend = ['RT_USING_RT_LINK'], CPPPATH = CPPPATH)
+
+if os.path.isfile(os.path.join(cwd, 'hw', 'SConscript')):
+    group = group + SConscript(os.path.join('hw', 'SConscript'))
+
+Return('group')

components/utilities/rt-link/src/rtlink.c

@@ -0,0 +1,1192 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-02-02     xiangxistu   the first version
+ * 2021-03-19     Sherman      Optimize the transfer process
+ * 2021-04-20     Sherman      Optimize memory footprint
+ * 2021-05-10     Sherman      Add rtlink_status  MSH command; Optimize transmission timer Settings; Fix known bugs
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <board.h>
+#include <rthw.h>
+
+#include <rtlink.h>
+#include <rtlink_hw.h>
+#include <rtlink_utils.h>
+
+#define DBG_ENABLE
+#ifdef USING_RT_LINK_DEBUG
+    #define DBG_LVL DBG_LOG
+#else
+    #define DBG_LVL DBG_INFO
+#endif
+#define DBG_TAG "rtlink"
+#define DBG_COLOR
+#include <rtdbg.h>
+
+#ifdef RT_LINK_USING_SPI
+    #define RT_LINK_LONG_FRAME_TIMEOUT      50
+    #define RT_LINK_SENT_FRAME_TIMEOUT      100
+#else
+    #define RT_LINK_LONG_FRAME_TIMEOUT      100
+    #define RT_LINK_SENT_FRAME_TIMEOUT      200
+#endif /* RT_LINK_USING_SPI */
+
+#define RT_LINK_RECV_DATA_SEQUENCE      0
+#define RT_LINK_INIT_FRAME_SEQENCE      129
+
+#define RT_LINK_THREAD_NAME "rtlink"
+#define RT_LINK_THREAD_TICK    20
+#define RT_LINK_THREAD_PRIORITY    15
+#define RT_LINK_THREAD_STACK_SIZE      832 /* 32 bytes aligned */
+
+typedef enum
+{
+    FIND_FRAME_HEAD = 0,
+    PARSE_FRAME_HEAD,
+    PARSE_FRAME_EXTEND,
+    PARSE_FRAME_SEQ,
+    CHECK_FRAME_CRC,
+    HEADLE_FRAME_DATA,
+} rt_link_frame_parse_t;
+
+/* rtlink SCB(Session control block) */
+static struct rt_link_session *rt_link_scb = RT_NULL;
+struct rt_link_session *rt_link_get_scb(void)
+{
+    return rt_link_scb;
+}
+
+static rt_int16_t rt_link_check_seq(rt_uint8_t new, rt_uint8_t used)
+{
+    rt_int16_t compare_seq = 0;
+    compare_seq = new - used;
+    if (compare_seq < 0)
+    {
+        compare_seq = compare_seq + 256;
+    }
+    return compare_seq;
+}
+
+static int rt_link_frame_init(struct rt_link_frame *frame, rt_uint8_t config)
+{
+    if (frame == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+
+    /* set frame control information */
+    rt_memset(&frame->head, 0, sizeof(struct rt_link_frame_head));
+    if (config & FRAME_CRC)
+    {
+        frame->head.crc = 1;
+    }
+    if (config & FRAME_ACK)
+    {
+        frame->head.ack = 1;
+    }
+
+    frame->head.magicid = RT_LINK_FRAME_HEAD;
+    /* frame data information */
+    rt_memset(&frame->extend, 0, sizeof(struct rt_link_extend));
+    frame->crc = 0;
+    frame->real_data = RT_NULL;
+    frame->data_len = 0;
+    frame->index = 0;
+    frame->total = 0;
+    frame->attribute = RT_LINK_RESERVE_FRAME;
+
+    rt_slist_init(&frame->slist);
+
+    return RT_EOK;
+}
+
+static rt_err_t rt_link_frame_free(struct rt_link_frame *frame)
+{
+    if (frame == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+
+    if (frame->real_data != RT_NULL)
+    {
+        rt_free(frame->real_data);
+        frame->real_data = RT_NULL;
+    }
+    rt_memset(frame, 0, sizeof(struct rt_link_frame));
+    rt_free(frame);
+    return RT_EOK;
+}
+
+/* performs data transmission */
+static rt_err_t rt_link_frame_send(rt_slist_t *slist)
+{
+    struct rt_link_frame *frame = RT_NULL;
+    rt_uint8_t *origin_data = RT_NULL;
+    rt_uint8_t *data = RT_NULL;
+    rt_size_t length = 0;
+    rt_uint8_t send_max = RT_LINK_ACK_MAX;  /* The number of '1' in the binary number */
+
+    /* if slist is tx_data_slist, we should send all data on the slist*/
+    if (slist == &rt_link_scb->tx_data_slist)
+    {
+        slist = rt_slist_next(&rt_link_scb->tx_data_slist);
+    }
+    if (slist == RT_NULL)
+    {
+        LOG_W("tx_data_slist NULL");
+        return -RT_ERROR;
+    }
+    data = rt_malloc(RT_LINK_MAX_FRAME_LENGTH);
+    if (data == RT_NULL)
+    {
+        LOG_E("rt link alloc memory(%d B) failed, send frame failed.", RT_LINK_MAX_FRAME_LENGTH);
+        return -RT_ENOMEM;
+    }
+    origin_data = data;
+
+    do
+    {
+        /* get frame for send */
+        frame = rt_container_of(slist, struct rt_link_frame, slist);
+        slist = rt_slist_next(slist);
+
+        length = RT_LINK_HEAD_LENGTH;
+        if (frame->head.crc)
+        {
+            length += RT_LINK_CRC_LENGTH;
+        }
+        if (frame->head.extend)
+        {
+            length += RT_LINK_MAX_EXTEND_LENGTH;
+        }
+
+        length += frame->data_len;
+        frame->head.length = frame->data_len;
+        rt_memcpy(data, &frame->head, RT_LINK_HEAD_LENGTH);
+        data = data + RT_LINK_HEAD_LENGTH;
+        if (frame->head.extend)
+        {
+            rt_memcpy(data, &frame->extend, RT_LINK_MAX_EXTEND_LENGTH);
+            data = data + RT_LINK_MAX_EXTEND_LENGTH;
+        }
+        if (frame->attribute == RT_LINK_SHORT_DATA_FRAME || frame->attribute == RT_LINK_LONG_DATA_FRAME)
+        {
+            rt_memcpy(data, frame->real_data, frame->data_len);
+            data = data + frame->data_len;
+        }
+        if (frame->head.crc)
+        {
+            frame->crc = rt_link_scb->calculate_crc(RT_FALSE, origin_data, length - RT_LINK_CRC_LENGTH);
+            rt_memcpy(data, &frame->crc, RT_LINK_CRC_LENGTH);
+        }
+
+        LOG_D("frame send(%d) len(%d) attr:(%d), crc:(0x%08x).", frame->head.sequence, length, frame->attribute, frame->crc);
+        rt_link_hw_send(origin_data, length);
+
+        data = origin_data;
+        if (slist == RT_NULL)
+        {
+            send_max = 0;
+        }
+        send_max >>= 1;
+    }while (send_max);
+    rt_free(origin_data);
+    return RT_EOK;
+}
+
+static void _stop_recv_long(void)
+{
+    rt_timer_stop(&rt_link_scb->longframetimer);
+    if (rt_link_scb->rx_record.dataspace != RT_NULL)
+    {
+        rt_free(rt_link_scb->rx_record.dataspace);
+        rt_link_scb->rx_record.dataspace = RT_NULL;
+    }
+    rt_link_scb->rx_record.long_count = 0;
+    rt_link_scb->rx_record.total = 0;
+}
+
+static rt_err_t rt_link_frame_stop_receive(struct rt_link_frame *frame)
+{
+    rt_memset(frame, 0, sizeof(struct rt_link_frame));
+    rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, rt_link_hw_recv_len(rt_link_scb->rx_buffer));
+    return RT_EOK;
+}
+
+/* Configure the extended field of the frame */
+static rt_err_t rt_link_frame_extend_config(struct rt_link_frame *frame, rt_link_frame_attribute_t attribute, rt_uint16_t parameter)
+{
+    frame->head.extend = 1;
+    frame->extend.attribute = attribute;
+    frame->extend.parameter = parameter;
+    return RT_EOK;
+}
+
+static int rt_link_command_frame_send(rt_uint8_t sequence, rt_link_frame_attribute_t attribute, rt_uint16_t parameter)
+{
+    struct rt_link_frame command_frame = {0};
+    rt_uint8_t extend_flag = RT_FALSE;
+
+    /* command frame don't need crc and ack ability */
+    rt_link_frame_init(&command_frame, RT_NULL);
+    command_frame.head.sequence = sequence;
+    command_frame.head.length = RT_LINK_MAX_EXTEND_LENGTH;
+    command_frame.attribute = attribute;
+    switch (attribute)
+    {
+    case RT_LINK_RESEND_FRAME:
+        extend_flag = RT_TRUE;
+        LOG_D("send RESEND_FRAME(%d).", command_frame.head.sequence);
+        break;
+
+    case RT_LINK_HANDSHAKE_FRAME:
+        extend_flag = RT_TRUE;
+        LOG_D("send HANDSHAKE_FRAME(%d).", command_frame.head.sequence);
+        break;
+
+    case RT_LINK_CONFIRM_FRAME:
+        LOG_D("send CONFIRM_FRAME(%d).", command_frame.head.sequence);
+        break;
+
+    default:
+        break;
+    }
+
+    if (extend_flag)
+    {
+        rt_link_frame_extend_config(&command_frame, attribute, parameter);
+    }
+    rt_link_frame_send(&command_frame.slist);
+    return RT_EOK;
+}
+
+static rt_err_t rt_link_resend_handle(struct rt_link_frame *receive_frame)
+{
+    struct rt_link_frame *find_frame = RT_NULL;
+    rt_slist_t *tem_list = RT_NULL;
+
+    tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+    while (tem_list != RT_NULL)
+    {
+        find_frame = rt_container_of(tem_list, struct rt_link_frame, slist);
+        if (find_frame->head.sequence == receive_frame->head.sequence)
+        {
+            LOG_D("resend frame(%d)", find_frame->head.sequence);
+            rt_link_frame_send(&find_frame->slist);
+            break;
+        }
+        tem_list = tem_list->next;
+    }
+
+    if (tem_list == RT_NULL)
+    {
+        LOG_D("frame resent failed, can't find(%d).", receive_frame->head.sequence);
+        rt_link_command_frame_send(receive_frame->head.sequence, RT_LINK_SESSION_END, RT_NULL);
+    }
+    return RT_EOK;
+}
+
+static rt_err_t rt_link_confirm_handle(struct rt_link_frame *receive_frame)
+{
+    static struct rt_link_frame *send_frame = RT_NULL;
+    struct rt_link_frame *find_frame = RT_NULL;
+    rt_slist_t *tem_list = RT_NULL;
+    rt_uint16_t seq_offset = 0;
+
+    LOG_D("confirm seq(%d) frame", receive_frame->head.sequence);
+    if (rt_link_scb->link_status == RT_LINK_NO_RESPONSE)
+    {
+        /* The handshake success and resends the data frame */
+        LOG_D("link_status RT_LINK_CONNECT_DONE, resend data");
+        rt_link_scb->link_status = RT_LINK_CONNECT_DONE;
+        if (rt_slist_first(&rt_link_scb->tx_data_slist))
+        {
+            rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
+        }
+        return RT_EOK;
+    }
+
+    /* Check to see if the frame is send for confirm */
+    tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+    if (tem_list == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+
+    send_frame = rt_container_of(tem_list, struct rt_link_frame, slist);
+    seq_offset = rt_link_check_seq(receive_frame->head.sequence,
+                                   rt_link_scb->tx_seq);
+    if (seq_offset <= send_frame->total)
+    {
+        LOG_D("confirm frame (%d)", receive_frame->head.sequence);
+        for (int i = 0; i < seq_offset; i++)
+        {
+            find_frame = rt_container_of(tem_list, struct rt_link_frame, slist);
+            LOG_D("confirm(%d), remove(%d)", receive_frame->head.sequence, find_frame->head.sequence);
+
+            rt_enter_critical();
+            rt_slist_remove(&rt_link_scb->tx_data_slist, &find_frame->slist);
+            rt_exit_critical();
+            find_frame->real_data = RT_NULL;
+            rt_link_frame_free(find_frame);
+
+            tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+            if (tem_list == RT_NULL)
+            {
+                break;
+            }
+        }
+        rt_link_scb->tx_seq = receive_frame->head.sequence;
+        rt_link_scb->link_status = RT_LINK_CONNECT_DONE;
+        if (tem_list == RT_NULL)
+        {
+            LOG_D("SEND_OK");
+            rt_event_send(&rt_link_scb->event, RT_LINK_SEND_OK_EVENT);
+        }
+        else
+        {
+            LOG_D("Continue sending");
+            rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
+        }
+    }
+    return RT_EOK;
+}
+
+static rt_err_t rt_link_short_handle(struct rt_link_frame *receive_frame)
+{
+    LOG_D("Seq(%d) short data", receive_frame->head.sequence);
+    rt_link_scb->rx_record.dataspace = rt_malloc(receive_frame->data_len);
+    if (rt_link_scb->rx_record.dataspace != RT_NULL)
+    {
+        rt_link_command_frame_send(receive_frame->head.sequence, RT_LINK_CONFIRM_FRAME, RT_NULL);
+        rt_link_scb->rx_record.rx_seq = receive_frame->head.sequence;
+
+        if (rt_link_scb->channel[receive_frame->head.channel].upload_callback == RT_NULL)
+        {
+            rt_free(rt_link_scb->rx_record.dataspace);
+            LOG_E("Channel %d has not been registered", receive_frame->head.channel);
+        }
+        else
+        {
+            rt_enter_critical();
+            rt_link_hw_copy(rt_link_scb->rx_record.dataspace, receive_frame->real_data, receive_frame->data_len);
+            rt_exit_critical();
+            rt_link_scb->channel[receive_frame->head.channel].upload_callback(rt_link_scb->rx_record.dataspace, receive_frame->data_len);
+        }
+        rt_link_scb->rx_record.dataspace = RT_NULL;
+        rt_link_frame_stop_receive(receive_frame);
+    }
+    else
+    {
+        LOG_W("short data %dB alloc failed", receive_frame->data_len);
+    }
+    receive_frame->real_data = RT_NULL;
+    return 0;
+}
+
+static void _long_handle_first(struct rt_link_frame *receive_frame, rt_uint8_t *count_mask)
+{
+    if (receive_frame->extend.parameter % RT_LINK_MAX_DATA_LENGTH == 0)
+    {
+        receive_frame->total = receive_frame->extend.parameter / RT_LINK_MAX_DATA_LENGTH;
+    }
+    else
+    {
+        receive_frame->total = receive_frame->extend.parameter / RT_LINK_MAX_DATA_LENGTH + 1;
+    }
+
+    rt_link_scb->rx_record.total = receive_frame->total;
+    rt_link_scb->rx_record.dataspace = rt_malloc(receive_frame->extend.parameter);
+    if (rt_link_scb->rx_record.dataspace == RT_NULL)
+    {
+        LOG_W("long data %dB alloc failed.", receive_frame->extend.parameter);
+    }
+
+}
+
+static void _long_handle_second(struct rt_link_frame *receive_frame, rt_uint8_t count_mask)
+{
+    static rt_uint8_t ack_mask = RT_LINK_ACK_MAX;
+
+    void *data = RT_NULL;
+    rt_size_t size = 0;
+    rt_uint16_t serve = 0;
+    rt_size_t offset = 0; /* offset, count from 0 */
+
+    receive_frame->index = rt_link_check_seq(receive_frame->head.sequence, rt_link_scb->rx_record.rx_seq) - 1;
+    LOG_D("index= %d, count= 0x%x, seq(%d), rxseq(%d)", receive_frame->index, rt_link_scb->rx_record.long_count, receive_frame->head.sequence, rt_link_scb->rx_record.rx_seq);
+
+    if ((receive_frame->index > RT_LINK_FRAMES_MAX) || (rt_link_scb->rx_record.long_count & (0x01 << receive_frame->index)))
+    {
+        LOG_D("ERR:index %d, rx_seq %d", receive_frame->index, rt_link_scb->rx_record.rx_seq);
+    }
+    else if (rt_link_scb->rx_record.dataspace != RT_NULL)
+    {
+        LOG_D("long_count (0x%02x)index(%d)total(%d) seq(%d)", rt_link_scb->rx_record.long_count, receive_frame->index, receive_frame->total, receive_frame->head.sequence);
+        rt_link_scb->rx_record.long_count |= (0x01 << receive_frame->index);
+        offset = RT_LINK_MAX_DATA_LENGTH * receive_frame->index;
+
+        rt_enter_critical();
+        rt_link_hw_copy(rt_link_scb->rx_record.dataspace + offset, receive_frame->real_data, receive_frame->data_len);
+        rt_exit_critical();
+
+        if (rt_link_utils_num1(rt_link_scb->rx_record.long_count) == rt_link_scb->rx_record.total)
+        {
+            rt_link_command_frame_send((rt_link_scb->rx_record.rx_seq + rt_link_scb->rx_record.total), RT_LINK_CONFIRM_FRAME, RT_NULL);
+        }
+        else if ((rt_link_scb->rx_record.long_count & ack_mask) == ack_mask)
+        {
+            rt_link_command_frame_send((rt_link_scb->rx_record.rx_seq + rt_link_utils_num1(ack_mask)), RT_LINK_CONFIRM_FRAME, RT_NULL);
+            ack_mask |= ack_mask << rt_link_utils_num1(RT_LINK_ACK_MAX);
+        }
+
+        /* receive a complete package */
+        if (rt_link_utils_num1(rt_link_scb->rx_record.long_count) == rt_link_scb->rx_record.total)
+        {
+            rt_timer_stop(&rt_link_scb->longframetimer);
+
+            rt_enter_critical();
+            data = rt_link_scb->rx_record.dataspace;
+            size = receive_frame->extend.parameter;
+            serve = receive_frame->head.channel;
+            /* empty  rx_record */
+            rt_link_scb->rx_record.rx_seq += rt_link_scb->rx_record.total;
+            rt_link_scb->rx_record.dataspace = RT_NULL;
+            rt_link_scb->rx_record.long_count = 0;
+            rt_link_scb->rx_record.total = 0;
+            ack_mask = RT_LINK_ACK_MAX;
+            rt_link_frame_stop_receive(receive_frame);
+            rt_exit_critical();
+
+            if (rt_link_scb->channel[serve].upload_callback == RT_NULL)
+            {
+                rt_free(data);
+                LOG_E("channel %d haven't been registered.", serve);
+            }
+            else
+            {
+                rt_link_scb->channel[serve].upload_callback(data, size);
+            }
+        }
+        else if (rt_link_hw_recv_len(rt_link_scb->rx_buffer) < (receive_frame->data_len % RT_LINK_MAX_DATA_LENGTH))
+        {
+            rt_int32_t timeout = RT_LINK_LONG_FRAME_TIMEOUT;
+            rt_timer_control(&rt_link_scb->longframetimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+            rt_timer_start(&rt_link_scb->longframetimer);
+        }
+    }
+}
+
+static rt_err_t rt_link_long_handle(struct rt_link_frame *receive_frame)
+{
+    static rt_uint8_t count_mask = 0;
+    if (rt_link_scb->rx_record.long_count == 0)
+    {
+        /* Receive this long package for the first time:
+         * calculates the total number of frames,
+         * requests space, and turns on the receive timer */
+        _long_handle_first(receive_frame, &count_mask);
+    }
+    if (rt_link_scb->rx_record.total > 0)
+    {
+        /* Intermediate frame processing:
+         * serial number repeated check,
+         * receive completion check, reply to ACK */
+        _long_handle_second(receive_frame, count_mask);
+    }
+    receive_frame->real_data = RT_NULL;
+    return RT_EOK;
+}
+
+static rt_err_t rt_link_handshake_handle(struct rt_link_frame *receive_frame)
+{
+    LOG_D("Sequence(%d) is a connect handshake frame.", receive_frame->head.sequence);
+    rt_link_scb->link_status = RT_LINK_CONNECT_DONE;
+    /* sync requester tx seq, responder rx seq = requester tx seq */
+    rt_link_scb->rx_record.rx_seq = receive_frame->head.sequence;
+    /* sync requester rx seq, responder tx seq = requester rx seq */
+    rt_link_scb->tx_seq = receive_frame->extend.parameter;
+    rt_link_command_frame_send(receive_frame->head.sequence, RT_LINK_CONFIRM_FRAME, RT_NULL);
+    return RT_EOK;
+}
+
+/* Discriminate frame type */
+static rt_err_t rt_link_parse_frame(struct rt_link_frame *receive_frame)
+{
+    switch (receive_frame->attribute)
+    {
+    case RT_LINK_RESEND_FRAME:
+        rt_link_resend_handle(receive_frame);
+        break;
+    case RT_LINK_CONFIRM_FRAME:
+        rt_link_confirm_handle(receive_frame);
+        break;
+    case RT_LINK_SHORT_DATA_FRAME:
+        rt_link_short_handle(receive_frame);
+        break;
+    case RT_LINK_LONG_DATA_FRAME:
+        rt_link_long_handle(receive_frame);
+        break;
+    case RT_LINK_HANDSHAKE_FRAME:
+        rt_link_handshake_handle(receive_frame);
+        break;
+    case RT_LINK_SESSION_END:
+        rt_link_frame_stop_receive(receive_frame);
+        break;
+    default:
+        break;
+    }
+    return RT_EOK;
+}
+
+/* Empty the sending list */
+static void rt_link_datalist_empty(void)
+{
+    struct rt_link_frame *find_frame = RT_NULL;
+    rt_slist_t *tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+    while (tem_list != RT_NULL)
+    {
+        find_frame = rt_container_of(tem_list, struct rt_link_frame, slist);
+        tem_list = rt_slist_next(tem_list);
+        rt_enter_critical();
+        rt_slist_remove(&rt_link_scb->tx_data_slist, &find_frame->slist);
+        rt_exit_critical();
+
+        find_frame->real_data = RT_NULL;
+        rt_link_frame_free(find_frame);
+    }
+}
+
+/* RT_LINK_READ_CHECK_EVENT handle */
+static void rt_link_frame_check(void)
+{
+    static struct rt_link_frame receive_frame = {0};
+    static rt_link_frame_parse_t analysis_status = FIND_FRAME_HEAD;
+    static rt_uint8_t *data = RT_NULL;
+    static rt_uint16_t buff_len = RT_LINK_HEAD_LENGTH;
+
+    struct rt_link_frame *send_frame = RT_NULL;
+    rt_tick_t timeout = 0;
+    rt_uint8_t *real_data = RT_NULL;
+    rt_uint32_t temporary_crc = 0;
+
+    rt_uint8_t offset = 0;
+    rt_size_t recv_len = rt_link_hw_recv_len(rt_link_scb->rx_buffer);
+    while (recv_len > 0)
+    {
+        switch (analysis_status)
+        {
+        case FIND_FRAME_HEAD:
+        {
+            /* if we can't find frame head, throw that data */
+            if ((*rt_link_scb->rx_buffer->read_point & RT_LINK_FRAME_HEAD_MASK) == RT_LINK_FRAME_HEAD)
+            {
+                analysis_status = PARSE_FRAME_HEAD;
+                break;
+            }
+            rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+            break;
+        }
+
+        case PARSE_FRAME_HEAD:
+        {
+            if (recv_len < buff_len)
+            {
+                LOG_D("The length is not enough,recv=%d buff=%d", recv_len, buff_len);
+                return ;
+            }
+            /* Data is an offset address */
+            data = rt_link_scb->rx_buffer->read_point;
+            rt_link_frame_init(&receive_frame, RT_NULL);
+            rt_link_hw_copy((rt_uint8_t *)&receive_frame.head, data, sizeof(struct rt_link_frame_head));
+            rt_link_hw_buffer_point_shift(&data, sizeof(struct rt_link_frame_head));
+            receive_frame.data_len = receive_frame.head.length;
+            LOG_D("check seq(%d) data len(%d).", receive_frame.head.sequence, receive_frame.data_len);
+
+            if (receive_frame.head.extend)
+            {
+                buff_len += RT_LINK_MAX_EXTEND_LENGTH;
+                analysis_status = PARSE_FRAME_EXTEND;
+            }
+            else
+            {
+                analysis_status = PARSE_FRAME_SEQ;
+            }
+        }
+
+        case PARSE_FRAME_EXTEND:
+        {
+            if (receive_frame.head.extend)
+            {
+                if (recv_len < buff_len)
+                {
+                    LOG_D("PARSE_FRAME_EXTEND: actual: %d, need: %d.", recv_len, buff_len);
+
+                    /* should set timer, control receive frame timeout, one shot */
+                    timeout = 50;
+                    rt_timer_control(&rt_link_scb->recvtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+                    rt_timer_start(&rt_link_scb->recvtimer);
+                    return;
+                }
+                rt_link_hw_copy((rt_uint8_t *)&receive_frame.extend, data, sizeof(struct rt_link_extend));
+                rt_link_hw_buffer_point_shift(&data, sizeof(struct rt_link_extend));
+                switch (receive_frame.extend.attribute)
+                {
+                case RT_LINK_RESEND_FRAME:
+                case RT_LINK_LONG_DATA_FRAME:
+                case RT_LINK_HANDSHAKE_FRAME:
+                    receive_frame.attribute = receive_frame.extend.attribute;
+                    break;
+                default:
+                    receive_frame.attribute = RT_LINK_RESERVE_FRAME;
+                    break;
+                }
+            }
+            else
+            {
+                if (receive_frame.head.crc)
+                {
+                    receive_frame.attribute = RT_LINK_SHORT_DATA_FRAME;
+                }
+                else
+                {
+                    receive_frame.attribute = RT_LINK_CONFIRM_FRAME;
+                }
+            }
+            if (receive_frame.attribute == RT_LINK_RESERVE_FRAME)
+            {
+                LOG_D("quick filter error frame.");
+                rt_link_frame_stop_receive(&receive_frame);
+                buff_len = RT_LINK_HEAD_LENGTH;
+                analysis_status = FIND_FRAME_HEAD;
+                break;
+            }
+            analysis_status = PARSE_FRAME_SEQ;
+        }
+
+        case PARSE_FRAME_SEQ:
+        {
+            if ((receive_frame.attribute == RT_LINK_CONFIRM_FRAME) || (receive_frame.attribute == RT_LINK_RESEND_FRAME))
+            {
+                offset = rt_link_check_seq(receive_frame.head.sequence, rt_link_scb->tx_seq);
+                if (rt_slist_first(&rt_link_scb->tx_data_slist) != RT_NULL)
+                {
+                    send_frame = rt_container_of(rt_link_scb->tx_data_slist.next, struct rt_link_frame, slist);
+                    if (offset > send_frame->total)
+                    {
+                        /* exceptional frame, ignore it */
+                        LOG_D("seq (%d) failed, tx_seq (%d).offset=(%d) total= (%d)", receive_frame.head.sequence, rt_link_scb->tx_seq, offset, send_frame->total);
+                        rt_link_frame_stop_receive(&receive_frame);
+                        buff_len = RT_LINK_HEAD_LENGTH;
+                        analysis_status = FIND_FRAME_HEAD;
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                offset = rt_link_check_seq(receive_frame.head.sequence, rt_link_scb->rx_record.rx_seq) - 1;
+                if ((offset > RT_LINK_FRAMES_MAX) && (receive_frame.attribute != RT_LINK_HANDSHAKE_FRAME))
+                {
+                    /* exceptional frame, ignore it */
+                    LOG_D("seq (%d) failed, rx_seq (%d) offset=(%d) attr= (%d) status (%d)", receive_frame.head.sequence, rt_link_scb->rx_record.rx_seq, offset, receive_frame.attribute, rt_link_scb->link_status);
+                    rt_link_frame_stop_receive(&receive_frame);
+                    buff_len = RT_LINK_HEAD_LENGTH;
+                    analysis_status = FIND_FRAME_HEAD;
+                    break;
+                }
+            }
+
+            buff_len += receive_frame.data_len;
+            if (receive_frame.head.crc)
+            {
+                buff_len += RT_LINK_CRC_LENGTH;
+                analysis_status = CHECK_FRAME_CRC;
+            }
+            else
+            {
+                analysis_status = HEADLE_FRAME_DATA;
+            }
+        }
+
+        case CHECK_FRAME_CRC:
+        {
+            if (receive_frame.head.crc)
+            {
+                if (recv_len < buff_len)
+                {
+                    /* should set timer, control receive frame timeout, one shot */
+                    timeout = 50;
+                    rt_timer_control(&rt_link_scb->recvtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+                    rt_timer_start(&rt_link_scb->recvtimer);
+                    return;
+                }
+
+                real_data = data;
+                rt_timer_stop(&rt_link_scb->recvtimer);
+                rt_link_hw_buffer_point_shift(&data, receive_frame.data_len);
+                rt_link_hw_copy((rt_uint8_t *)&receive_frame.crc, data, RT_LINK_CRC_LENGTH);
+                temporary_crc = rt_link_scb->calculate_crc(RT_TRUE, rt_link_scb->rx_buffer->read_point, buff_len - RT_LINK_CRC_LENGTH);
+                if (receive_frame.crc != temporary_crc)
+                {
+                    /* check failed. ready resent */
+                    LOG_D("CRC: calc:(0x%08x) ,recv:(0x%08x).", temporary_crc, receive_frame.crc);
+                    /* quick resent, when sequence is right, we can ask for reset this frame */
+                    rt_link_command_frame_send(receive_frame.head.sequence, RT_LINK_RESEND_FRAME, RT_NULL);
+
+                    /* throw the error frame */
+                    buff_len = RT_LINK_HEAD_LENGTH;
+                    rt_link_frame_stop_receive(&receive_frame);
+
+                    /* clear the frame information */
+                    analysis_status = FIND_FRAME_HEAD;
+                    break;
+                }
+                /* fill real data point */
+                receive_frame.real_data = real_data;
+            }
+            analysis_status = HEADLE_FRAME_DATA;
+        }
+
+        case HEADLE_FRAME_DATA:
+        {
+            rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, buff_len);
+            rt_link_parse_frame(&receive_frame);
+            data = RT_NULL;
+            buff_len = RT_LINK_HEAD_LENGTH;
+            analysis_status = FIND_FRAME_HEAD;
+            break;
+        }
+
+        default:
+            LOG_E("analysis_status is error.");
+            break;
+        }
+        recv_len = rt_link_hw_recv_len(rt_link_scb->rx_buffer);
+    }
+}
+
+static void rt_link_send_ready(void)
+{
+    if (rt_link_scb->link_status != RT_LINK_CONNECT_DONE)
+    {
+        rt_link_scb->link_status = RT_LINK_NO_RESPONSE;
+        rt_link_command_frame_send(rt_link_scb->tx_seq, RT_LINK_HANDSHAKE_FRAME, rt_link_scb->rx_record.rx_seq);
+    }
+    else
+    {
+        if (RT_EOK != rt_link_frame_send(&rt_link_scb->tx_data_slist))
+        {
+            rt_event_send(&rt_link_scb->event, RT_LINK_SEND_FAILED_EVENT);
+        }
+    }
+}
+
+static void rt_link_frame_recv_timeout(void)
+{
+    /* The receiving frame timeout and a new receive begins */
+    rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, rt_link_hw_recv_len(rt_link_scb->rx_buffer));
+}
+
+static void rt_link_send_timeout(void)
+{
+    static rt_uint8_t count = 0;
+    if (count++ > 5)
+    {
+        LOG_W("Send timeout, please check the link status!");
+        count = 0;
+        rt_event_send(&rt_link_scb->event, RT_LINK_SEND_FAILED_EVENT);
+    }
+    else
+    {
+        rt_timer_start(&rt_link_scb->sendtimer);
+        rt_link_command_frame_send(rt_link_scb->tx_seq, RT_LINK_HANDSHAKE_FRAME, rt_link_scb->rx_record.rx_seq);
+    }
+}
+
+static int rt_link_long_recv_timeout(void)
+{
+    static rt_uint8_t count = 0;
+    if (count++ > 5)
+    {
+        LOG_W("long package receive timeout");
+        count = 0;
+        _stop_recv_long();
+    }
+    else
+    {
+        for (rt_uint8_t total = rt_link_scb->rx_record.total; total > 0; total--)
+        {
+            if (((rt_link_scb->rx_record.long_count >> (total - 1)) & 0x01) == 0x00)
+            {
+                /* resend command */
+                rt_link_command_frame_send((rt_link_scb->rx_record.rx_seq + total), RT_LINK_RESEND_FRAME, RT_NULL);
+            }
+        }
+    }
+    return RT_EOK;
+}
+
+void rt_link_thread(void *parameter)
+{
+    rt_uint32_t recved = 0;
+    while (1)
+    {
+        rt_event_recv(&rt_link_scb->event, RT_LINK_READ_CHECK_EVENT |
+                      RT_LINK_SEND_READY_EVENT  |
+                      RT_LINK_SEND_TIMEOUT_EVENT |
+                      RT_LINK_RECV_TIMEOUT_FRAME_EVENT |
+                      RT_LINK_RECV_TIMEOUT_LONG_EVENT,
+                      RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
+                      RT_WAITING_FOREVER,
+                      &recved);
+
+        if (recved & RT_LINK_READ_CHECK_EVENT)
+        {
+            rt_link_frame_check();
+        }
+
+        if (recved & RT_LINK_SEND_READY_EVENT)
+        {
+            rt_link_send_ready();
+        }
+
+        if (recved & RT_LINK_SEND_TIMEOUT_EVENT)
+        {
+            rt_link_send_timeout();
+        }
+
+        if (recved & RT_LINK_RECV_TIMEOUT_FRAME_EVENT)
+        {
+            rt_link_frame_recv_timeout();
+        }
+
+        if (recved & RT_LINK_RECV_TIMEOUT_LONG_EVENT)
+        {
+            rt_link_long_recv_timeout();
+        }
+    }
+}
+
+static void rt_link_sendtimer_callback(void *parameter)
+{
+    rt_event_send(&rt_link_scb->event, RT_LINK_SEND_TIMEOUT_EVENT);
+}
+
+static void rt_link_recvtimer_callback(void *parameter)
+{
+    rt_event_send(&rt_link_scb->event, RT_LINK_RECV_TIMEOUT_FRAME_EVENT);
+}
+
+static void rt_link_receive_long_frame_callback(void *parameter)
+{
+    rt_event_send(&rt_link_scb->event, RT_LINK_RECV_TIMEOUT_LONG_EVENT);
+}
+
+/**
+ * rtlink send data interface
+ * @param service   Registered service channel, choose enum rt_link_service_t
+ * @param data      send data
+ * @param size      send data size
+ * @return The actual size of the data sent
+ * */
+rt_size_t rt_link_send(rt_link_service_t service, void *data, rt_size_t size)
+{
+    if ((size == 0) || (data == RT_NULL) || (service >= RT_LINK_SERVICE_MAX))
+    {
+        return 0;
+    }
+    rt_mutex_take(&rt_link_scb->tx_lock, RT_WAITING_FOREVER);
+
+    rt_uint32_t recved = 0;
+    rt_err_t result = RT_EOK;
+    rt_uint32_t timeout = 0;
+
+    rt_uint8_t total = 0; /* The total number of frames to send */
+    rt_uint8_t index = 0; /* The index of the split packet */
+    rt_size_t offset = 0; /* The offset of the send data */
+
+    struct rt_link_frame *send_frame = RT_NULL;
+    rt_link_frame_attribute_t attribute;
+    if (size % RT_LINK_MAX_DATA_LENGTH == 0)
+    {
+        total = size / RT_LINK_MAX_DATA_LENGTH;
+    }
+    else
+    {
+        total = size / RT_LINK_MAX_DATA_LENGTH + 1;
+    }
+
+    if (total > RT_LINK_FRAMES_MAX)
+    {
+        result = -RT_ENOMEM;
+        goto __exit;
+    }
+    else if (total > 1)
+    {
+        attribute =  RT_LINK_LONG_DATA_FRAME;
+    }
+    else
+    {
+        attribute = RT_LINK_SHORT_DATA_FRAME;
+    }
+
+    do
+    {
+        send_frame = rt_malloc(sizeof(struct rt_link_frame));
+        rt_link_frame_init(send_frame, FRAME_CRC | FRAME_ACK);
+        send_frame->head.sequence = rt_link_scb->tx_seq + 1 + index;
+        send_frame->head.channel = service;
+        send_frame->real_data = (rt_uint8_t *)data + offset;
+        send_frame->index = index;
+        send_frame->total = total;
+
+        if (attribute == RT_LINK_LONG_DATA_FRAME)
+        {
+            send_frame->attribute = RT_LINK_LONG_DATA_FRAME;
+            if (offset + RT_LINK_MAX_DATA_LENGTH > size)
+            {
+                send_frame->data_len = size - offset;
+            }
+            else
+            {
+                send_frame->data_len = RT_LINK_MAX_DATA_LENGTH;
+                offset += RT_LINK_MAX_DATA_LENGTH;
+            }
+
+            rt_link_frame_extend_config(send_frame, RT_LINK_LONG_DATA_FRAME, size);
+        }
+        else
+        {
+            send_frame->attribute = RT_LINK_SHORT_DATA_FRAME;
+            send_frame->data_len = size;
+        }
+
+        /* append the frame on the tail of list */
+        LOG_D("new data append on the send slist, seq(%d), len(%d).", send_frame->head.sequence, send_frame->data_len);
+        rt_slist_append(&rt_link_scb->tx_data_slist, &send_frame->slist);
+
+        index++;
+    }while(total > index);
+
+    timeout = RT_LINK_SENT_FRAME_TIMEOUT * total;
+    rt_timer_control(&rt_link_scb->sendtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+    rt_timer_start(&rt_link_scb->sendtimer);
+    /* Notify the core thread to send packet */
+    rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
+
+    /* Wait for the packet to be sent successfully */
+    rt_event_recv(&rt_link_scb->event, RT_LINK_SEND_OK_EVENT | RT_LINK_SEND_FAILED_EVENT, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved);
+
+    if (recved & RT_LINK_SEND_OK_EVENT)
+    {
+        result = RT_EOK;
+    }
+    else if (recved & RT_LINK_SEND_FAILED_EVENT)
+    {
+        LOG_E("the data (%dB) send failed", size);
+        result = -RT_ERROR;
+    }
+    else
+    {
+        LOG_E("unexpected event.");
+        result = -RT_ERROR;
+    }
+__exit:
+    rt_timer_stop(&rt_link_scb->sendtimer);
+    /* Empty the sending list */
+    rt_link_datalist_empty();
+    rt_mutex_release(&rt_link_scb->tx_lock);
+    if (result == RT_EOK)
+    {
+        return size;
+    }
+    return result;
+}
+
+void rtlink_status(void)
+{
+    rt_kprintf("rtlink status:\n");
+    if (rt_link_scb != RT_NULL)
+    {
+        rt_kprintf("\tlink status=%d\n", rt_link_scb->link_status);
+
+        rt_kprintf("\trx seq=%d\n", rt_link_scb->rx_record.rx_seq);
+        rt_kprintf("\ttx seq=%d\n", rt_link_scb->tx_seq);
+        rt_kprintf("\trecv len=%d\n", rt_link_hw_recv_len(rt_link_scb->rx_buffer));
+
+        rt_tick_t state = 0;
+        rt_timer_control(&rt_link_scb->longframetimer, RT_TIMER_CTRL_GET_STATE, &state);
+        rt_kprintf("\tlong timer state=%d\n", state);
+        rt_timer_control(&rt_link_scb->sendtimer, RT_TIMER_CTRL_GET_STATE, &state);
+        rt_kprintf("\tsend timer state=%d\n", state);
+
+        rt_kprintf("\tevent set=0x%08x\n", rt_link_scb->event.set);
+        if (rt_link_scb->tx_data_slist.next)
+        {
+            rt_slist_t *data = RT_NULL;
+            rt_slist_for_each(data, &rt_link_scb->tx_data_slist)
+            {
+                rt_kprintf("\tsend data list: serv %u\t", ((struct rt_link_frame_head *)data)->channel);
+                rt_kprintf(" seq %u\t", ((struct rt_link_frame_head *)data)->sequence);
+                rt_kprintf(" len %u\n", ((struct rt_link_frame_head *)data)->length);
+            }
+        }
+        else
+        {
+            rt_kprintf("\tsend data list: NULL\n");
+        }
+
+        rt_uint8_t serv = sizeof(rt_link_scb->channel) / sizeof(struct rt_link_service);
+        while (serv--)
+        {
+            rt_kprintf("\tservices [%d](0x%p)\n", serv, rt_link_scb->channel[serv]);
+        }
+    }
+    else
+    {
+        rt_kprintf("status NULL, please check the initialization status!\n");
+    }
+}
+MSH_CMD_EXPORT(rtlink_status, Display RTLINK status);
+
+/**
+ * rtlink deinit the interface
+ * */
+rt_err_t rt_link_deinit(void)
+{
+    rt_enter_critical();
+    rt_link_hw_deinit();
+    if (rt_link_scb)
+    {
+        rt_timer_detach(&rt_link_scb->longframetimer);
+        rt_timer_detach(&rt_link_scb->sendtimer);
+        rt_timer_detach(&rt_link_scb->recvtimer);
+        rt_mutex_detach(&rt_link_scb->tx_lock);
+        rt_event_detach(&rt_link_scb->event);
+        rt_free(rt_link_scb);
+        rt_link_scb = RT_NULL;
+    }
+    rt_thread_t thread = rt_thread_find(RT_LINK_THREAD_NAME);
+    if (thread)
+    {
+        rt_thread_delete(thread);
+    }
+    rt_exit_critical();
+    return RT_EOK;
+}
+MSH_CMD_EXPORT(rt_link_deinit, rt link deinit);
+
+/**
+ * rtlink initializes the interface, usually automatically.
+ * @return int Function Execution Result
+ * */
+int rt_link_init(void)
+{
+    rt_err_t result = RT_EOK;
+    rt_thread_t thread = RT_NULL;
+
+    if (rt_link_scb != RT_NULL)
+    {
+        goto __exit;
+    }
+
+    rt_link_scb = rt_malloc(sizeof(struct rt_link_session));
+    if (rt_link_scb == RT_NULL)
+    {
+        result = -RT_ENOMEM;
+        goto __exit;
+    }
+
+    rt_memset(rt_link_scb, 0, sizeof(struct rt_link_session));
+    rt_event_init(&rt_link_scb->event, "lny_event", RT_IPC_FLAG_FIFO);
+    rt_event_control(&rt_link_scb->event, RT_IPC_CMD_RESET, RT_NULL);
+
+    rt_mutex_init(&rt_link_scb->tx_lock, "tx_lock", RT_IPC_FLAG_FIFO);
+    rt_timer_init(&rt_link_scb->sendtimer, "tx_time", rt_link_sendtimer_callback,
+                  RT_NULL, 0, RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_PERIODIC);
+    rt_timer_init(&rt_link_scb->recvtimer, "rx_time", rt_link_recvtimer_callback,
+                  RT_NULL, 0, RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT);
+    rt_timer_init(&rt_link_scb->longframetimer, "rxl_time", rt_link_receive_long_frame_callback,
+                  RT_NULL, 0, RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_PERIODIC);
+
+    rt_link_scb->link_status = RT_LINK_ESTABLISHING;
+
+    rt_link_scb->rx_record.rx_seq = 255;
+
+    rt_slist_init(&rt_link_scb->tx_data_slist);
+    rt_link_scb->tx_seq = RT_LINK_INIT_FRAME_SEQENCE;
+
+    /* create rtlink core work thread */
+    thread = rt_thread_create(RT_LINK_THREAD_NAME,
+                              rt_link_thread,
+                              RT_NULL,
+                              RT_LINK_THREAD_STACK_SIZE,
+                              RT_LINK_THREAD_PRIORITY,
+                              RT_LINK_THREAD_TICK);
+    if (thread == RT_NULL)
+    {
+        result = -RT_ENOMEM;
+        goto __exit;
+    }
+    rt_thread_startup(thread);
+    result = rt_link_hw_init();
+
+__exit:
+    if (result != RT_EOK)
+    {
+        LOG_E("rtlink init failed.");
+        rt_link_deinit();
+    }
+    else
+    {
+        LOG_I("rtlink init success.");
+    }
+    return result;
+}
+#ifdef RT_LINK_AUTO_INIT
+    INIT_ENV_EXPORT(rt_link_init);
+#endif
+MSH_CMD_EXPORT(rt_link_init, rt link init);
+
+/**
+ * rtlink service attach
+ * @param service   Registered service channel, choose enum rt_link_service_t
+ * @param function  receive callback function
+ * @return Function Execution Result
+ * */
+rt_err_t rt_link_service_attach(rt_link_service_t service, rt_err_t (*function)(void *data, rt_size_t size))
+{
+    if (service >= RT_LINK_SERVICE_MAX)
+    {
+        LOG_W("Invalid parameter.");
+        return -RT_ERROR;
+    }
+    rt_link_scb->channel[service].upload_callback = function;
+    LOG_I("rt link attach service[%02d].", service);
+    return RT_EOK;
+}
+
+/**
+ * rtlink service detach
+ * @param service   Registered service channel, choose enum rt_link_service_t
+ * @return rt_err_t Function Execution Result
+ * */
+rt_err_t rt_link_service_detach(rt_link_service_t service)
+{
+    if (service >= RT_LINK_SERVICE_MAX)
+    {
+        LOG_W("Invalid parameter.");
+        return -RT_ERROR;
+    }
+    rt_link_scb->channel[service].upload_callback = RT_NULL;
+    LOG_I("rt link detach service[%02d].", service);
+    return RT_EOK;
+}

components/utilities/rt-link/src/rtlink_hw.c

@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-02-02     xiangxistu   the first version
+ * 2021-05-08     Sherman      Optimize the operation function on the rt_link_receive_buffer
+ */
+
+#include <rtthread.h>
+
+#include <rtlink.h>
+#include <rtlink_hw.h>
+#include <rtlink_port.h>
+#include <rtlink_utils.h>
+
+#define DBG_TAG "rtlink_hw"
+#ifdef USING_RT_LINK_HW_DEBUG
+    #define DBG_LVL DBG_LOG
+#else
+    #define DBG_LVL DBG_INFO
+#endif
+#define DBG_COLOR
+#include <rtdbg.h>
+
+static struct rt_link_receive_buffer *rx_buffer = RT_NULL;
+
+struct rt_link_receive_buffer *rt_link_hw_buffer_init(void *parameter)
+{
+    rx_buffer = rt_malloc(sizeof(struct rt_link_receive_buffer));
+    if (rx_buffer != RT_NULL)
+    {
+        rt_memset(rx_buffer, 0, sizeof(struct rt_link_receive_buffer));
+        rx_buffer->read_point = rx_buffer->data;
+        rx_buffer->write_point = rx_buffer->data;
+        rx_buffer->end_point = rx_buffer->data + RT_LINK_RECEIVE_BUFFER_LENGTH; /* Point to memory that has no access rights */
+    }
+    else
+    {
+        LOG_E("receive buffer alloc failed, init failed.");
+    }
+
+    return rx_buffer;
+}
+
+static rt_size_t rt_link_hw_buffer_write(void *data, rt_size_t count)
+{
+    int surplus = 0;
+    if (rx_buffer == RT_NULL)
+    {
+        return 0;
+    }
+    /* (data)----(r)----(w)----(end) */
+    if (rx_buffer->write_point >= rx_buffer->read_point)
+    {
+        rt_size_t w2end = rx_buffer->end_point - rx_buffer->write_point;
+        surplus = RT_LINK_RECEIVE_BUFFER_LENGTH - (rx_buffer->write_point - rx_buffer->read_point);
+        count = count > surplus ? surplus : count;
+        if (count >= w2end)
+        {
+            rt_memcpy(rx_buffer->write_point, data, w2end);
+            rx_buffer->write_point = rx_buffer->data;
+
+            rt_memcpy(rx_buffer->write_point, (rt_uint8_t *)data + w2end, (count - w2end));
+            rx_buffer->write_point += (count - w2end);
+        }
+        else
+        {
+            rt_memcpy(rx_buffer->write_point, data, count);
+            rx_buffer->write_point += count;
+        }
+    }
+    else    /* (data)----(w)----(r)----(end) */
+    {
+        surplus = rx_buffer->read_point - rx_buffer->write_point;
+        count = count > surplus ? surplus : count;
+        rt_memcpy(rx_buffer->write_point, data, count);
+        rx_buffer->write_point += count;
+    }
+    return count;
+}
+
+/* increases buffer pointer by one and circle around if necessary */
+void rt_link_hw_buffer_point_shift(rt_uint8_t **pointer_address, rt_size_t length)
+{
+    rt_uint8_t *pointer = RT_NULL;
+
+    pointer = *pointer_address + length;
+    if (pointer >= rx_buffer->end_point)
+    {
+        rt_size_t offset = 0;
+        offset = pointer - rx_buffer->end_point;
+        *pointer_address = rx_buffer->data + offset;
+    }
+    else
+    {
+        *pointer_address = *pointer_address + length;
+    }
+}
+
+/* copy data from receive buffer */
+void rt_link_hw_copy(rt_uint8_t *dst, rt_uint8_t *src, rt_size_t count)
+{
+    rt_uint8_t *pointer = RT_NULL;
+
+    pointer = src + count;
+    if (pointer >= rx_buffer->end_point)
+    {
+        rt_size_t offset = 0;
+        offset = rx_buffer->end_point - src;
+        rt_memcpy(dst, src, offset);
+        rt_memcpy(dst + offset,  rx_buffer->data, pointer - rx_buffer->end_point);
+    }
+    else
+    {
+        rt_memcpy(dst, src, count);
+    }
+}
+
+/* Tells, how many chars are saved into the buffer */
+rt_size_t rt_link_hw_recv_len(struct rt_link_receive_buffer *buffer)
+{
+    if (buffer->write_point >= buffer->read_point)
+    {
+        return (buffer->write_point - buffer->read_point);
+    }
+    else
+    {
+        return (RT_LINK_RECEIVE_BUFFER_LENGTH - (buffer->read_point - buffer->write_point));
+    }
+}
+
+rt_err_t rt_link_reset_crc32(void)
+{
+#ifdef RT_LINK_USING_HW_CRC
+    return rt_link_hw_crc32_reset();
+#else
+    return rt_link_sf_crc32_reset();
+#endif
+}
+
+rt_uint32_t rt_link_crc32(rt_uint8_t *data, rt_size_t u32_size)
+{
+#ifdef RT_LINK_USING_HW_CRC
+    return rt_link_hw_crc32(data, u32_size);
+#else
+    return rt_link_sf_crc32(data, u32_size);
+#endif
+}
+
+rt_uint32_t rt_link_get_crc(rt_uint8_t using_buffer_ring, rt_uint8_t *data, rt_size_t size)
+{
+    rt_uint32_t crc32 = 0x0;
+    rt_size_t surplus = 0;
+
+    if (data == RT_NULL)
+    {
+        LOG_D("warning, the parameter error: %d, data: 0x%08d.", size, data);
+        return 0;
+    }
+
+    rt_link_reset_crc32();
+    if (using_buffer_ring == 1)
+    {
+        /* modify the missing character */
+        surplus = rx_buffer->end_point - data;
+        if (surplus >= size)
+        {
+            crc32 = rt_link_crc32(data, size);
+        }
+        else
+        {
+            rt_link_crc32(data, surplus);
+            crc32 = rt_link_crc32(rx_buffer->data, size - surplus);
+        }
+    }
+    else
+    {
+        crc32 = rt_link_crc32(data, size);
+    }
+    return crc32;
+}
+
+rt_err_t rt_link_hw_send(void *data, rt_size_t length)
+{
+    rt_size_t send_len = 0;
+    send_len = rt_link_port_send(data, length);
+    LOG_D("hw_send len= %d", send_len);
+    return send_len;
+}
+
+/* provide this function to hardware spi/uart/usb to store data */
+rt_size_t rt_link_hw_write_cb(void *data, rt_size_t length)
+{
+    /* write real data into rtlink receive buffer */
+    rt_size_t len = rt_link_hw_buffer_write(data, length);
+    struct rt_link_session *scb = rt_link_get_scb();
+    if (scb)
+    {
+        rt_event_send(&scb->event, RT_LINK_READ_CHECK_EVENT);
+    }
+    return len;
+}
+
+rt_err_t rt_link_hw_init(void)
+{
+    struct rt_link_session *scb = rt_link_get_scb();
+    if ((rx_buffer != RT_NULL) || (scb == RT_NULL))
+    {
+        return -RT_ERROR;
+    }
+
+    /* alloc receive buffer to store data */
+    if (rt_link_hw_buffer_init(RT_NULL) == RT_NULL)
+    {
+        return -RT_ENOMEM;
+    }
+    scb->rx_buffer = rx_buffer;
+    scb->calculate_crc = rt_link_get_crc;
+
+    rt_link_port_init();
+
+#ifdef LINK_LAYER_USING_HW_CRC
+    /* crc hardware device for mcu and node */
+    rt_link_hw_crc32_init();
+#endif
+
+    LOG_I("link layer hardware environment init successful.");
+    return RT_EOK;
+}
+
+rt_err_t rt_link_hw_deinit(void)
+{
+    if (rx_buffer)
+    {
+        rt_free(rx_buffer);
+        rx_buffer = RT_NULL;
+    }
+    struct rt_link_session *scb = rt_link_get_scb();
+    if (scb)
+    {
+        scb->rx_buffer = rx_buffer;
+        scb->calculate_crc = RT_NULL;
+    }
+    rt_link_port_deinit();
+
+#ifdef LINK_LAYER_USING_HW_CRC
+    /* crc hardware device for mcu and node */
+    rt_link_hw_crc32_deinit();
+#endif
+
+    LOG_I("rtlink hardware deinit successful.");
+    return RT_EOK;
+}

components/utilities/rt-link/src/rtlink_utils.c

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-05-15     Sherman      the first version
+ */
+
+#include <rtlink_utils.h>
+
+/* Calculate the number of '1' */
+int rt_link_utils_num1(rt_uint32_t n)
+{
+    int ret = 0;
+    while (n)
+    {
+        n &= n - 1;
+        ret++;
+    }
+    return ret;
+}
+
+#ifdef RT_LINK_USING_SF_CRC
+
+static rt_uint32_t crc = 0xffffffff;
+const rt_uint32_t crc_table[256] =
+{
+    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419,
+    0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148,
+    0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0,
+    0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8,
+    0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+    0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF,
+    0xABD13D59, 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
+    0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87,
+    0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
+    0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E,
+    0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162,
+    0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6,
+    0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D,
+    0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
+    0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525,
+    0x206F85B3, 0xB966D409, 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
+    0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C,
+    0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
+    0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344,
+    0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+    0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43,
+    0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767,
+    0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3,
+    0xA867DF55, 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92,
+    0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226,
+    0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82,
+    0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+    0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1,
+    0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
+    0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661,
+    0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
+    0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330,
+    0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8,
+    0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+};
+
+rt_err_t rt_link_sf_crc32_reset(void)
+{
+    crc = 0xffffffff;
+    return RT_EOK;
+}
+
+rt_uint32_t rt_link_sf_crc32(rt_uint8_t *data, rt_size_t len)
+{
+    rt_uint32_t x, y;
+    x = 0;
+    y = 0;
+    rt_size_t i;
+
+    for (i = 0; i < len; i++)
+    {
+        y = (crc ^ data[i]) & 0xff;
+        x = crc_table[y];
+        crc = (crc >> 8) ^ x;
+    }
+    return (crc ^ 0xffffffff);
+}
+#endif /* RT_LINK_USING_SF_CRC */

examples/rt-link/rtlink_example.c

@@ -0,0 +1,189 @@
+
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2021-05-15     Sherman      the first version
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <rtthread.h>
+#include <rtlink.h>
+
+#define DBG_ENABLE
+#define DBG_TAG "rtlink_exam"
+#define DBG_LVL DBG_INFO
+#include <rtdbg.h>
+
+#define TEST_CONTEXT    "This message is sent by RT-Link"
+
+enum
+{
+    NONE_TEST = 0,
+    SHORT_FRAME_TEST,
+    LONG_FRAME_TEST
+};
+
+void rt_link_speed_test(void *paremeter);
+static rt_uint8_t speed_test_type = NONE_TEST;
+
+rt_err_t rt_link_receive_example_callback(void *data, rt_size_t length)
+{
+    LOG_I("recv data %d",length);
+    LOG_HEX("example",8,data,length);
+    rt_free(data);	
+    return RT_EOK;
+}
+
+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);
+    }
+}
+
+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;
+
+    if(speed_test_type == SHORT_FRAME_TEST)
+    {
+        bufflen = 2044;
+    }
+    else
+    {
+        bufflen = 6132;
+    }
+
+    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_link_send(RT_LINK_SERVICE_RTLINK, send_buf, bufflen);
+        if(ret > 0)
+        {
+            sentlen += ret;
+        }
+
+        tick2 = rt_tick_get();
+        if (tick2 - tick1 >= RT_TICK_PER_SECOND)//* 10
+        {
+            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);
+}
+
+
+int rt_link_example_send(int argc, char **argv)
+{
+    char *receive = RT_NULL;
+    rt_size_t length = 0;
+    rt_uint16_t count = 0;
+
+    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);
+        LOG_I("send data length: %d.", length);
+        rt_free(receive);
+    }
+        else if(argc >= 3)
+    {
+        if(strcmp(argv[1], "-l") == 0)
+        {
+            receive = rt_malloc(atoi((const char *)argv[2]));
+            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]));
+            rt_free(receive - atoi((const char *)argv[2]));
+
+            LOG_I("send data length: %d.", length);
+        }
+        else if(strcmp(argv[1], "-s") == 0)
+        {
+            if(speed_test_type == NONE_TEST)
+            {
+                rt_uint8_t mutil_num = 1;
+                if(argc > 3)
+                {
+                    mutil_num = atoi((const char *)argv[3]);
+                }
+
+                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)
+                {
+                    speed_test_type = LONG_FRAME_TEST;
+                }
+                create_thead_to_test_speed(mutil_num);
+            }
+            else
+            {
+                speed_test_type = NONE_TEST;
+                LOG_I("set NONE_TEST");
+            }
+        }
+        else
+        {
+            LOG_E("Invalid parameter.");
+        }
+    }
+    
+    return 0;
+}
+MSH_CMD_EXPORT(rt_link_example_send, rt link layer send test);
+
+int rt_link_example_init(void)
+{
+
+    rt_link_service_attach(RT_LINK_SERVICE_RTLINK, rt_link_receive_example_callback);
+    return RT_EOK;
+}
+MSH_CMD_EXPORT(rt_link_example_init, rt link layer example init);