summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorSherman <[email protected]>2021-06-23 18:35:19 +0800
committerSherman <[email protected]>2021-08-12 18:10:49 +0800
commit491524cb9621f85c011215748d30709fc4578adf (patch)
tree668632fe969534166085fd8e5e28040f164295c5
parenta1a656fbe776c40e8ad31298f1bfd2deec11b122 (diff)
[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
Diffstat
-rw-r--r--components/utilities/rt-link/Kconfig15
-rw-r--r--components/utilities/rt-link/hw_port/SConscript14
-rw-r--r--components/utilities/rt-link/hw_port/uart/rtlink_port_uart.c73
-rw-r--r--components/utilities/rt-link/inc/rtlink.h179
-rw-r--r--components/utilities/rt-link/inc/rtlink_dev.h41
-rw-r--r--components/utilities/rt-link/inc/rtlink_hw.h4
-rw-r--r--components/utilities/rt-link/inc/rtlink_port.h6
-rw-r--r--components/utilities/rt-link/src/rtlink.c874
-rw-r--r--components/utilities/rt-link/src/rtlink_dev.c396
-rw-r--r--components/utilities/rt-link/src/rtlink_hw.c70
-rw-r--r--examples/rt-link/rtlink_dev_example.c395
-rw-r--r--examples/rt-link/rtlink_example.c117
12 files changed, 1574 insertions, 610 deletions
diff --git a/components/utilities/rt-link/Kconfig b/components/utilities/rt-link/Kconfig
index 10ed129e69..d20c2f01d4 100644
--- a/components/utilities/rt-link/Kconfig
+++ b/components/utilities/rt-link/Kconfig
@@ -14,21 +14,6 @@ if RT_USING_RT_LINK
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"
diff --git a/components/utilities/rt-link/hw_port/SConscript b/components/utilities/rt-link/hw_port/SConscript
deleted file mode 100644
index e34243ebda..0000000000
--- a/components/utilities/rt-link/hw_port/SConscript
+++ /dev/null
@@ -1,14 +0,0 @@
-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')
diff --git a/components/utilities/rt-link/hw_port/uart/rtlink_port_uart.c b/components/utilities/rt-link/hw_port/uart/rtlink_port_uart.c
deleted file mode 100644
index 48fbb91bc3..0000000000
--- a/components/utilities/rt-link/hw_port/uart/rtlink_port_uart.c
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * 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;
-}
diff --git a/components/utilities/rt-link/inc/rtlink.h b/components/utilities/rt-link/inc/rtlink.h
index dd98b57c30..941c35a359 100644
--- a/components/utilities/rt-link/inc/rtlink.h
+++ b/components/utilities/rt-link/inc/rtlink.h
@@ -14,81 +14,102 @@
#include <rtdef.h>
+#define RT_LINK_VER "0.2.0"
+
#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_FLAG_ACK 0x01
+#define RT_LINK_FLAG_CRC 0x02
+
+#define RT_LINK_FRAME_HEAD 0x15
+#define RT_LINK_FRAME_HEAD_MASK 0x1F
+/* The maximum number of split frames for a long package */
+#define RT_LINK_FRAMES_MAX 0x03
+/* The length in the rt_link_frame_head structure occupies 11 bits,
+so the value range after 4-byte alignment is 0-2044.*/
+#define RT_LINK_MAX_FRAME_LENGTH 1024
-#define RT_LINK_ACK_MAX 0x07
+#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)
+#define RT_LINK_EXTEND_LENGTH 4
+
+#define RT_LINK_MAX_DATA_LENGTH (RT_LINK_MAX_FRAME_LENGTH - \
+ RT_LINK_HEAD_LENGTH - \
+ RT_LINK_EXTEND_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_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;
+ RT_LINK_SERVICE_RTLINK = 0,
+ RT_LINK_SERVICE_SOCKET = 1,
+ RT_LINK_SERVICE_WIFI = 2,
+ RT_LINK_SERVICE_MNGT = 3,
+ RT_LINK_SERVICE_MSHTOOLS = 4,
-enum
-{
- FRAME_EXTEND = 1 << 0,
- FRAME_CRC = 1 << 1,
- FRAME_ACK = 1 << 2
-};
+ /* Expandable to a maximum of 31 */
+ RT_LINK_SERVICE_MAX
+} rt_link_service_e;
typedef enum
{
- RT_LINK_RESERVE_FRAME = 0,
+ RT_LINK_RESEND_FRAME = 0,
+ RT_LINK_CONFIRM_FRAME = 1,
- 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 = 2,
+ RT_LINK_DETACH_FRAME = 3, /* service is not online */
+ RT_LINK_SESSION_END = 4, /* The retring failed to end the session */
- RT_LINK_HANDSHAKE_FRAME
-} rt_link_frame_attribute_t;
+ RT_LINK_LONG_DATA_FRAME = 5,
+ RT_LINK_SHORT_DATA_FRAME = 6,
+
+ RT_LINK_RESERVE_FRAME = 7
+} rt_link_frame_attr_e;
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,
+ 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;
+} rt_link_notice_e;
typedef enum
{
- RT_LINK_ESTABLISHING = 0,
- RT_LINK_NO_RESPONSE,
- RT_LINK_CONNECT_DONE,
-} rt_link_linkstatus_t;
+ RT_LINK_INIT = 0,
+ RT_LINK_DISCONN = 1,
+ RT_LINK_CONNECT = 2,
+} rt_link_linkstate_e;
typedef enum
{
- RECVTIMER_NONE = 0,
- RECVTIMER_FRAME,
- RECVTIMER_LONGFRAME
-} rt_link_recvtimer_status_t;
+ RT_LINK_EOK = 0,
+ RT_LINK_ERR = 1,
+ RT_LINK_ETIMEOUT = 2,
+ RT_LINK_EFULL = 3,
+ RT_LINK_EEMPTY = 4,
+ RT_LINK_ENOMEM = 5,
+ RT_LINK_EIO = 6,
+ RT_LINK_ESESSION = 7,
+ RT_LINK_ESERVICE = 8,
+
+ RT_LINK_EMAX
+} rt_link_err_e;
struct rt_link_receive_buffer
{
- rt_uint8_t data[RT_LINK_RECEIVE_BUFFER_LENGTH]; /* rt-link receive data buffer */
+ /* rt-link receive data buffer */
+ rt_uint8_t data[RT_LINK_RECEIVE_BUFFER_LENGTH];
rt_uint8_t *read_point;
rt_uint8_t *write_point;
rt_uint8_t *end_point;
@@ -100,15 +121,16 @@ struct rt_link_frame_head
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;
+ rt_uint16_t service: 5;
+ rt_uint16_t length : 11; /* range 0~2047 */
};
/* record frame information that opposite */
struct rt_link_record
{
- rt_uint8_t rx_seq; /* record the opposite sequence */
+ 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 */
@@ -116,58 +138,71 @@ struct rt_link_record
struct rt_link_extend
{
- rt_uint16_t attribute; /* rt_link_frame_attribute_t */
+ rt_uint16_t attribute; /* rt_link_frame_attr_e */
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 */
+ 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_uint16_t data_len; /* the length of frame length */
+ rt_uint16_t attribute; /* rt_link_frame_attr_e */
- rt_uint8_t index; /* the index frame for long frame */
- rt_uint8_t total; /* the total frame for long frame */
+ rt_uint8_t issent;
+ 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 */
+ 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);
+ rt_int32_t timeout_tx;
+ void (*send_cb)(struct rt_link_service *service, void *buffer);
+ void (*recv_cb)(struct rt_link_service *service, void *data, rt_size_t size);
+ void *user_data;
+
+ rt_uint8_t flag; /* Whether to use the CRC and ACK */
+ rt_link_service_e service;
+ rt_link_linkstate_e state; /* channel link state */
+ rt_link_err_e err;
};
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 */
+ struct rt_event event;
+ struct rt_link_service *service[RT_LINK_SERVICE_MAX];
+ rt_uint8_t tx_seq; /* Sequence number of the send data frame */
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 */
+ rt_uint8_t sendbuffer[RT_LINK_MAX_FRAME_LENGTH];
+ struct rt_event sendevent;
+ struct rt_timer sendtimer;
- 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_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 */
+ struct rt_link_receive_buffer *rx_buffer;
+ rt_uint32_t (*calculate_crc)(rt_uint8_t using_buffer_ring, rt_uint8_t *data, rt_size_t size);
+ rt_link_linkstate_e state; /* Link status */
};
-/* rtlink init and deinit */
+#define SERV_ERR_GET(service) (service->err)
+
+/* rtlink init and deinit, default is automatic initialization*/
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);
+
+rt_size_t rt_link_send(struct rt_link_service *service, const 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);
+rt_err_t rt_link_service_attach(struct rt_link_service *service);
+rt_err_t rt_link_service_detach(struct rt_link_service *service);
/* Private operator function */
struct rt_link_session *rt_link_get_scb(void);
diff --git a/components/utilities/rt-link/inc/rtlink_dev.h b/components/utilities/rt-link/inc/rtlink_dev.h
new file mode 100644
index 0000000000..01fd04373c
--- /dev/null
+++ b/components/utilities/rt-link/inc/rtlink_dev.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-06-15 Sherman the first version
+ */
+
+#include <rtthread.h>
+#include <rtlink.h>
+
+#define RT_LINK_RX_NONBLOCKING 0x1000
+#define RT_LINK_RX_BLOCKING 0x2000
+#define RT_LINK_TX_NONBLOCKING 0x4000
+#define RT_LINK_TX_BLOCKING 0x8000
+#define RT_LINK_DEVICE_MASK 0xf000
+
+struct rtlink_recv_list
+{
+ void *data;
+ rt_size_t size;
+ rt_size_t index;
+ struct rt_slist_node list;
+};
+
+struct rt_link_device
+{
+ struct rt_device parent;
+ struct rt_link_service service;
+ struct rt_slist_node recv_head; /* recv data list, struct rtlink_recv_list */
+};
+
+/*
+ * rtlink device register
+ */
+rt_err_t rt_link_dev_register(struct rt_link_device *rtlink,
+ const char *name,
+ rt_uint32_t flag,
+ void *data);
diff --git a/components/utilities/rt-link/inc/rtlink_hw.h b/components/utilities/rt-link/inc/rtlink_hw.h
index c75609a23a..d0a56fe98c 100644
--- a/components/utilities/rt-link/inc/rtlink_hw.h
+++ b/components/utilities/rt-link/inc/rtlink_hw.h
@@ -6,6 +6,7 @@
* Change Logs:
* Date Author Notes
* 2021-02-02 xiangxistu the first version
+ * 2021-07-13 Sherman add reconnect API
*
*/
#ifndef __RT_LINK_HW_H__
@@ -19,6 +20,7 @@ void rt_link_hw_buffer_point_shift(rt_uint8_t **pointer_address, rt_size_t lengt
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);
+rt_err_t rt_link_hw_reconnect(void);
+rt_size_t rt_link_hw_send(void *data, rt_size_t length);
#endif /* _RT_LINK_PORT_INTERNAL_H_ */
diff --git a/components/utilities/rt-link/inc/rtlink_port.h b/components/utilities/rt-link/inc/rtlink_port.h
index 54a064d117..b22f19072a 100644
--- a/components/utilities/rt-link/inc/rtlink_port.h
+++ b/components/utilities/rt-link/inc/rtlink_port.h
@@ -7,6 +7,7 @@
* Date Author Notes
* 2021-02-02 xiangxistu the first version
* 2021-05-15 Sherman function rename
+ * 2021-07-13 Sherman add reconnect API
*/
#ifndef __RT_LINK_PORT_H__
#define __RT_LINK_PORT_H__
@@ -14,8 +15,9 @@
#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_err_t rt_link_port_init(void);
+rt_err_t rt_link_port_deinit(void);
+rt_err_t rt_link_port_reconnect(void);
rt_size_t rt_link_port_send(void *data, rt_size_t length);
#ifdef RT_LINK_USING_HW_CRC
diff --git a/components/utilities/rt-link/src/rtlink.c b/components/utilities/rt-link/src/rtlink.c
index 37a99538b6..010083aaa5 100644
--- a/components/utilities/rt-link/src/rtlink.c
+++ b/components/utilities/rt-link/src/rtlink.c
@@ -8,7 +8,11 @@
* 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
+ * 2021-05-10 Sherman Add rtlink_status MSH command;
+ * Optimize transmission timer Settings;
+ * Fix known bugs
+ * 2021-08-06 Sherman Add NACK, NCRC, non-blocking transmit mode;
+ * Add service connection status;
*/
#include <rtthread.h>
@@ -35,25 +39,28 @@
#define RT_LINK_SENT_FRAME_TIMEOUT 100
#else
#define RT_LINK_LONG_FRAME_TIMEOUT 100
- #define RT_LINK_SENT_FRAME_TIMEOUT 200
+ #define RT_LINK_SENT_FRAME_TIMEOUT 100
#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 */
+#define RT_LINK_THREAD_NAME "rtlink"
+#define RT_LINK_THREAD_TICK 20
+#define RT_LINK_THREAD_PRIORITY 25
+#define RT_LINK_THREAD_STACK_SIZE 1024 /* 32 bytes aligned */
+
+#define RT_LINK_FRAME_SENT 1
+#define RT_LINK_FRAME_NOSEND 0
typedef enum
{
- FIND_FRAME_HEAD = 0,
- PARSE_FRAME_HEAD,
- PARSE_FRAME_EXTEND,
- PARSE_FRAME_SEQ,
- CHECK_FRAME_CRC,
- HEADLE_FRAME_DATA,
+ FIND_FRAME_HEAD = 0,
+ PARSE_FRAME_HEAD = 1,
+ PARSE_FRAME_EXTEND = 2,
+ PARSE_FRAME_SEQ = 3,
+ CHECK_FRAME_CRC = 4,
+ HEADLE_FRAME_DATA = 5,
} rt_link_frame_parse_t;
/* rtlink SCB(Session control block) */
@@ -83,11 +90,11 @@ static int rt_link_frame_init(struct rt_link_frame *frame, rt_uint8_t config)
/* set frame control information */
rt_memset(&frame->head, 0, sizeof(struct rt_link_frame_head));
- if (config & FRAME_CRC)
+ if (config & RT_LINK_FLAG_CRC)
{
frame->head.crc = 1;
}
- if (config & FRAME_ACK)
+ if (config & RT_LINK_FLAG_ACK)
{
frame->head.ack = 1;
}
@@ -101,37 +108,153 @@ static int rt_link_frame_init(struct rt_link_frame *frame, rt_uint8_t config)
frame->index = 0;
frame->total = 0;
frame->attribute = RT_LINK_RESERVE_FRAME;
+ frame->issent = RT_LINK_FRAME_NOSEND;
rt_slist_init(&frame->slist);
return RT_EOK;
}
-static rt_err_t rt_link_frame_free(struct rt_link_frame *frame)
+/* remove the sending list node*/
+static void rt_link_frame_remove(struct rt_link_service *service)
{
- if (frame == RT_NULL)
+ RT_ASSERT(service != RT_NULL);
+ struct rt_link_frame *find_frame = RT_NULL;
+ rt_uint8_t total = 0;
+ rt_slist_t *tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+ if (tem_list != RT_NULL)
{
- return -RT_ERROR;
+ do
+ {
+ find_frame = rt_container_of(tem_list, struct rt_link_frame, slist);
+ tem_list = rt_slist_next(tem_list);
+ if (find_frame->head.service == service->service)
+ {
+ if (total == 0)
+ {
+ total = find_frame->total;
+ }
+ /* The data frame order is appended to the list,
+ with total counting starting at 1 and index counting from 0 */
+ LOG_D("remove seq(%d) serv (%d)", find_frame->head.sequence, service->service);
+ rt_enter_critical();
+ rt_slist_remove(&rt_link_scb->tx_data_slist, &find_frame->slist);
+ rt_exit_critical();
+ total--;
+ rt_memset(find_frame, 0, sizeof(struct rt_link_frame));
+ rt_free(find_frame);
+ }
+ } while ((total > 0) && (tem_list != RT_NULL));
+ }
+}
+
+/* Configure the extended field of the frame */
+static rt_err_t rt_link_frame_extend_config(struct rt_link_frame *frame, rt_link_frame_attr_e 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 serv, rt_uint8_t sequence, rt_link_frame_attr_e attribute, rt_uint16_t parameter)
+{
+ struct rt_link_frame command_frame = {0};
+ rt_uint8_t data[sizeof(command_frame.head) + sizeof(command_frame.extend)] = {0};
+ rt_uint8_t data_len = 0;
+
+ /* command frame don't need crc and ack ability */
+ rt_link_frame_init(&command_frame, RT_NULL);
+ data_len += sizeof(command_frame.head);
+
+ rt_link_frame_extend_config(&command_frame, attribute, parameter);
+ rt_memcpy(data + data_len, &command_frame.extend, sizeof(command_frame.extend));
+ data_len += sizeof(command_frame.extend);
+
+ command_frame.head.sequence = sequence;
+ command_frame.head.service = serv;
+ rt_memcpy(data, &command_frame.head, sizeof(command_frame.head));
+
+ rt_link_hw_send(data, data_len);
+ return RT_EOK;
+}
+
+static void rt_link_service_send_finish(rt_link_err_e err)
+{
+ struct rt_link_frame *frame = RT_NULL;
+ rt_uint8_t service = RT_LINK_SERVICE_MAX;
+ void *buffer = RT_NULL;
+ rt_slist_t *tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+ if (tem_list == RT_NULL)
+ {
+ return ;
+ }
+ frame = rt_container_of(tem_list, struct rt_link_frame, slist);
+ if (frame)
+ {
+ service = frame->head.service;
+ buffer = frame->real_data - (frame->index * RT_LINK_MAX_DATA_LENGTH);
+ rt_link_scb->service[service]->err = err;
+ rt_link_scb->sendtimer.parameter = 0;
+ rt_link_frame_remove(rt_link_scb->service[service]);
+ if (rt_link_scb->service[service]->timeout_tx != RT_WAITING_NO)
+ {
+ rt_event_send(&rt_link_scb->sendevent, (0x01 << service));
+ }
+ else
+ {
+ rt_link_scb->service[service]->send_cb(rt_link_scb->service[service], buffer);
+ }
}
+}
+
+static rt_size_t frame_send(struct rt_link_frame *frame)
+{
+ rt_size_t length = 0;
+ rt_uint8_t *data = RT_NULL;
- if (frame->real_data != RT_NULL)
+ rt_memset(rt_link_scb->sendbuffer, 0, sizeof(rt_link_scb->sendbuffer));
+ data = rt_link_scb->sendbuffer;
+ length = RT_LINK_HEAD_LENGTH;
+ if (frame->head.crc)
{
- rt_free(frame->real_data);
- frame->real_data = RT_NULL;
+ length += RT_LINK_CRC_LENGTH;
}
- rt_memset(frame, 0, sizeof(struct rt_link_frame));
- rt_free(frame);
- return RT_EOK;
+ if (frame->head.extend)
+ {
+ length += RT_LINK_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_EXTEND_LENGTH);
+ data = data + RT_LINK_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, rt_link_scb->sendbuffer, length - RT_LINK_CRC_LENGTH);
+ rt_memcpy(data, &frame->crc, RT_LINK_CRC_LENGTH);
+ }
+
+ LOG_D("frame send seq(%d) len(%d) attr:(%d), crc:(0x%08x).", frame->head.sequence, length, frame->attribute, frame->crc);
+ return rt_link_hw_send(rt_link_scb->sendbuffer, length);
}
/* performs data transmission */
static rt_err_t rt_link_frame_send(rt_slist_t *slist)
{
+ rt_uint8_t is_finish = RT_FALSE;
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 */
+ rt_uint8_t send_max = RT_LINK_ACK_MAX;
/* if slist is tx_data_slist, we should send all data on the slist*/
if (slist == &rt_link_scb->tx_data_slist)
@@ -140,16 +263,9 @@ static rt_err_t rt_link_frame_send(rt_slist_t *slist)
}
if (slist == RT_NULL)
{
- LOG_W("tx_data_slist NULL");
+ LOG_W("send data list 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
{
@@ -157,48 +273,42 @@ static rt_err_t rt_link_frame_send(rt_slist_t *slist)
frame = rt_container_of(slist, struct rt_link_frame, slist);
slist = rt_slist_next(slist);
- length = RT_LINK_HEAD_LENGTH;
- if (frame->head.crc)
+ if (frame_send(frame) == 0)
{
- length += RT_LINK_CRC_LENGTH;
+ rt_link_scb->service[frame->head.service]->err = RT_LINK_EIO;
+ goto __err;
}
- if (frame->head.extend)
+ frame->issent = RT_LINK_FRAME_SENT;
+ if ((slist == RT_NULL) || (frame->index + 1 >= frame->total))
{
- 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;
+ send_max = 0;
+ is_finish = RT_TRUE;
}
- if (frame->head.crc)
+ else
{
- 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);
+ send_max >>= 1;
}
+ }while (send_max);
- 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)
+ if ((is_finish) && (frame->head.ack == 0))
+ {
+ /* NACK frame send finish, remove after sending */
+ rt_link_service_send_finish(RT_LINK_EOK);
+ if (slist != RT_NULL)
{
- send_max = 0;
+ LOG_D("Continue sending");
+ rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
}
- send_max >>= 1;
- }while (send_max);
- rt_free(origin_data);
+ }
+ else
+ {
+ rt_int32_t timeout = RT_LINK_SENT_FRAME_TIMEOUT;
+ rt_timer_control(&rt_link_scb->sendtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+ rt_timer_start(&rt_link_scb->sendtimer);
+ }
return RT_EOK;
+__err:
+ return -RT_ERROR;
}
static void _stop_recv_long(void)
@@ -216,54 +326,16 @@ static void _stop_recv_long(void)
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)
+ if (rt_link_scb->rx_record.dataspace)
{
- 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;
+ 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;
- if (extend_flag)
- {
- rt_link_frame_extend_config(&command_frame, attribute, parameter);
- }
- rt_link_frame_send(&command_frame.slist);
+ rt_timer_stop(&rt_link_scb->recvtimer);
+ rt_link_scb->recvtimer.parameter = 0;
return RT_EOK;
}
@@ -279,7 +351,7 @@ static rt_err_t rt_link_resend_handle(struct rt_link_frame *receive_frame)
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);
+ frame_send(find_frame);
break;
}
tem_list = tem_list->next;
@@ -288,7 +360,9 @@ static rt_err_t rt_link_resend_handle(struct rt_link_frame *receive_frame)
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);
+ rt_link_command_frame_send(receive_frame->head.service,
+ receive_frame->head.sequence,
+ RT_LINK_SESSION_END, RT_NULL);
}
return RT_EOK;
}
@@ -296,16 +370,21 @@ static rt_err_t rt_link_resend_handle(struct rt_link_frame *receive_frame)
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)
+
+ rt_timer_stop(&rt_link_scb->sendtimer);
+
+ if (rt_link_scb->service[receive_frame->head.service] != RT_NULL)
+ {
+ rt_link_scb->service[receive_frame->head.service]->state = RT_LINK_CONNECT;
+ }
+
+ if (rt_link_scb->state != RT_LINK_CONNECT)
{
/* 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;
+ rt_link_scb->state = RT_LINK_CONNECT;
if (rt_slist_first(&rt_link_scb->tx_data_slist))
{
rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
@@ -319,38 +398,15 @@ static rt_err_t rt_link_confirm_handle(struct rt_link_frame *receive_frame)
{
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);
+ seq_offset = rt_link_check_seq(receive_frame->head.sequence, send_frame->head.sequence);
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);
+ rt_link_service_send_finish(RT_LINK_EOK);
+ rt_link_scb->state = RT_LINK_CONNECT;
- 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
+ tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
+ if (tem_list != RT_NULL)
{
LOG_D("Continue sending");
rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
@@ -359,29 +415,42 @@ static rt_err_t rt_link_confirm_handle(struct rt_link_frame *receive_frame)
return RT_EOK;
}
+/* serv type rt_link_service_e */
+static void rt_link_recv_finish(rt_uint8_t serv, void *data, rt_size_t size)
+{
+ if (rt_link_scb->service[serv] == RT_NULL)
+ {
+ rt_link_command_frame_send(serv, 0, RT_LINK_DETACH_FRAME, RT_NULL);
+ return;
+ }
+
+ if (rt_link_scb->service[serv]->recv_cb == RT_NULL)
+ {
+ rt_free(data);
+ LOG_W("service %d haven't been registered.", serv);
+ }
+ else
+ {
+ rt_link_scb->service[serv]->recv_cb(rt_link_scb->service[serv], data, size);
+ }
+}
+
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)
+ if (receive_frame->head.ack)
{
- 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_command_frame_send(receive_frame->head.service,
+ receive_frame->head.sequence,
+ RT_LINK_CONFIRM_FRAME, RT_NULL);
}
+ rt_link_scb->rx_record.rx_seq = receive_frame->head.sequence;
+ rt_link_hw_copy(rt_link_scb->rx_record.dataspace, receive_frame->real_data, receive_frame->data_len);
+ rt_link_recv_finish(receive_frame->head.service, 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
{
@@ -391,7 +460,7 @@ static rt_err_t rt_link_short_handle(struct rt_link_frame *receive_frame)
return 0;
}
-static void _long_handle_first(struct rt_link_frame *receive_frame, rt_uint8_t *count_mask)
+static void _long_handle_first(struct rt_link_frame *receive_frame)
{
if (receive_frame->extend.parameter % RT_LINK_MAX_DATA_LENGTH == 0)
{
@@ -406,22 +475,22 @@ static void _long_handle_first(struct rt_link_frame *receive_frame, rt_uint8_t *
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);
+ 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 void _long_handle_second(struct rt_link_frame *receive_frame)
{
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);
+ LOG_D("seq(%d), rxseq(%d), index(%d), total(%d), count(0x%x)"
+ , receive_frame->head.sequence
+ , rt_link_scb->rx_record.rx_seq
+ , receive_frame->index
+ , receive_frame->total
+ , rt_link_scb->rx_record.long_count);
if ((receive_frame->index > RT_LINK_FRAMES_MAX) || (rt_link_scb->rx_record.long_count & (0x01 << receive_frame->index)))
{
@@ -429,51 +498,41 @@ static void _long_handle_second(struct rt_link_frame *receive_frame, rt_uint8_t
}
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)
+ if (receive_frame->head.ack)
{
- 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);
+ if (rt_link_utils_num1(rt_link_scb->rx_record.long_count) == rt_link_scb->rx_record.total)
+ {
+ rt_link_command_frame_send(receive_frame->head.service,
+ (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(receive_frame->head.service,
+ (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_link_recv_finish(receive_frame->head.service, rt_link_scb->rx_record.dataspace, receive_frame->extend.parameter);
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))
{
@@ -486,20 +545,19 @@ static void _long_handle_second(struct rt_link_frame *receive_frame, rt_uint8_t
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);
+ _long_handle_first(receive_frame);
}
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);
+ _long_handle_second(receive_frame);
}
receive_frame->real_data = RT_NULL;
return RT_EOK;
@@ -507,13 +565,41 @@ static rt_err_t rt_link_long_handle(struct rt_link_frame *receive_frame)
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;
+ LOG_D("HANDSHAKE: seq(%d) param(%d)", receive_frame->head.sequence, receive_frame->extend.parameter);
+ rt_link_scb->state = RT_LINK_CONNECT;
/* 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);
+
+ if (rt_link_scb->service[receive_frame->head.service] != RT_NULL)
+ {
+ rt_link_scb->service[receive_frame->head.service]->state = RT_LINK_CONNECT;
+ rt_link_command_frame_send(receive_frame->head.service,
+ receive_frame->head.sequence,
+ RT_LINK_CONFIRM_FRAME, RT_NULL);
+ }
+ else
+ {
+ rt_link_command_frame_send(receive_frame->head.service,
+ receive_frame->head.sequence,
+ RT_LINK_DETACH_FRAME, RT_NULL);
+ }
+ return RT_EOK;
+}
+
+static rt_err_t rt_link_detach_handle(struct rt_link_frame *receive_frame)
+{
+ if (rt_link_scb->service[receive_frame->head.service] != RT_NULL)
+ {
+ rt_link_scb->service[receive_frame->head.service]->state = RT_LINK_DISCONN;
+ }
+ return RT_EOK;
+}
+
+static rt_err_t rt_link_session_end_handle(struct rt_link_frame *receive_frame)
+{
+ rt_link_frame_stop_receive(receive_frame);
return RT_EOK;
}
@@ -528,40 +614,27 @@ static rt_err_t rt_link_parse_frame(struct rt_link_frame *receive_frame)
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);
+ rt_link_session_end_handle(receive_frame);
break;
- default:
+ case RT_LINK_DETACH_FRAME:
+ rt_link_detach_handle(receive_frame);
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();
+ 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;
- find_frame->real_data = RT_NULL;
- rt_link_frame_free(find_frame);
+ default:
+ return -RT_ERROR;
}
+ return RT_EOK;
}
/* RT_LINK_READ_CHECK_EVENT handle */
@@ -574,7 +647,6 @@ static void rt_link_frame_check(void)
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;
@@ -599,7 +671,7 @@ static void rt_link_frame_check(void)
{
if (recv_len < buff_len)
{
- LOG_D("The length is not enough,recv=%d buff=%d", recv_len, buff_len);
+ LOG_D("HEAD: actual: %d, need: %d.", recv_len, buff_len);
return ;
}
/* Data is an offset address */
@@ -607,16 +679,32 @@ static void rt_link_frame_check(void)
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));
+
+ LOG_D("HEAD: seq(%d) serv(%d) ack(%d) crc(%d) ext(%d) len(%d) attr(%d)(0x%x)"
+ , receive_frame.head.sequence
+ , receive_frame.head.service
+ , receive_frame.head.ack
+ , receive_frame.head.crc
+ , receive_frame.head.extend
+ , receive_frame.head.length
+ , receive_frame.extend.attribute
+ , receive_frame.extend.parameter);
+
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.service >= RT_LINK_SERVICE_MAX)
+ {
+ rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+ goto __find_head;
+ }
if (receive_frame.head.extend)
{
- buff_len += RT_LINK_MAX_EXTEND_LENGTH;
+ buff_len += RT_LINK_EXTEND_LENGTH;
analysis_status = PARSE_FRAME_EXTEND;
}
else
{
+ receive_frame.attribute = RT_LINK_SHORT_DATA_FRAME;
analysis_status = PARSE_FRAME_SEQ;
}
}
@@ -627,54 +715,38 @@ static void rt_link_frame_check(void)
{
if (recv_len < buff_len)
{
- LOG_D("PARSE_FRAME_EXTEND: actual: %d, need: %d.", recv_len, buff_len);
-
+ LOG_D("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_timer_stop(&rt_link_scb->recvtimer);
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)
+ if (receive_frame.extend.attribute < RT_LINK_RESERVE_FRAME)
{
- 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;
+ LOG_D("EXTEND: attr(%d) err", receive_frame.extend.attribute);
+ rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+ goto __find_head;
}
}
- 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))
+ switch (receive_frame.attribute)
+ {
+ case RT_LINK_CONFIRM_FRAME:
+ case RT_LINK_RESEND_FRAME:
{
+ /* Check the send sequence */
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)
{
@@ -683,27 +755,36 @@ static void rt_link_frame_check(void)
{
/* 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;
+ rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+ goto __find_head;
}
}
+ break;
}
- else
+ case RT_LINK_LONG_DATA_FRAME:
+ case RT_LINK_SHORT_DATA_FRAME:
+ case RT_LINK_SESSION_END:
{
+ /* Check the receive sequence */
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))
+ if (offset > RT_LINK_FRAMES_MAX)
{
/* 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;
+ 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->state);
+ rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+ goto __find_head;
}
}
+ case RT_LINK_HANDSHAKE_FRAME:
+ case RT_LINK_DETACH_FRAME:
+ analysis_status = HEADLE_FRAME_DATA;
+ break;
+ default:
+ LOG_D("quick filter error frame.");
+ rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+ goto __find_head;
+ }
buff_len += receive_frame.data_len;
if (receive_frame.head.crc)
{
@@ -714,6 +795,8 @@ static void rt_link_frame_check(void)
{
analysis_status = HEADLE_FRAME_DATA;
}
+ /* fill real data point */
+ receive_frame.real_data = data;
}
case CHECK_FRAME_CRC:
@@ -722,6 +805,7 @@ static void rt_link_frame_check(void)
{
if (recv_len < buff_len)
{
+ LOG_D("CRC: 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);
@@ -729,7 +813,6 @@ static void rt_link_frame_check(void)
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);
@@ -738,25 +821,28 @@ static void rt_link_frame_check(void)
{
/* 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;
+ rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
+ goto __find_head;
}
- /* fill real data point */
- receive_frame.real_data = real_data;
}
analysis_status = HEADLE_FRAME_DATA;
}
case HEADLE_FRAME_DATA:
{
+ if (recv_len < buff_len)
+ {
+ LOG_D("PARSE: 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;
+ }
+ LOG_D("PARSE: buff_len (%d) r (0x%p) w (0x%p)"
+ , buff_len, rt_link_scb->rx_buffer->read_point
+ , rt_link_scb->rx_buffer->write_point);
+ rt_timer_stop(&rt_link_scb->recvtimer);
rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, buff_len);
rt_link_parse_frame(&receive_frame);
data = RT_NULL;
@@ -766,25 +852,47 @@ static void rt_link_frame_check(void)
}
default:
- LOG_E("analysis_status is error.");
+__find_head:
+ LOG_D("to find head (%d)", analysis_status);
+ rt_link_frame_stop_receive(&receive_frame);
+ buff_len = RT_LINK_HEAD_LENGTH;
+ analysis_status = FIND_FRAME_HEAD;
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)
+ struct rt_link_frame *frame = RT_NULL;
+ rt_uint8_t seq = rt_link_scb->tx_seq;
+ if (rt_slist_next(&rt_link_scb->tx_data_slist))
+ {
+ frame = rt_container_of(rt_slist_next(&rt_link_scb->tx_data_slist), struct rt_link_frame, slist);
+ }
+
+ if (rt_link_scb->state != RT_LINK_CONNECT)
{
- 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);
+ rt_link_scb->state = RT_LINK_DISCONN;
+ rt_link_command_frame_send(RT_LINK_SERVICE_RTLINK, seq,
+ RT_LINK_HANDSHAKE_FRAME, rt_link_scb->rx_record.rx_seq);
+
+ rt_int32_t timeout = 50;
+ rt_timer_control(&rt_link_scb->sendtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
+ rt_timer_start(&rt_link_scb->sendtimer);
}
else
{
- if (RT_EOK != rt_link_frame_send(&rt_link_scb->tx_data_slist))
+ /* Avoid sending the first data frame multiple times */
+ if ((frame != RT_NULL) && (frame->issent == RT_LINK_FRAME_NOSEND))
{
- rt_event_send(&rt_link_scb->event, RT_LINK_SEND_FAILED_EVENT);
+ if (RT_EOK != rt_link_frame_send(&rt_link_scb->tx_data_slist))
+ {
+ rt_link_scb->state = RT_LINK_DISCONN;
+ rt_link_service_send_finish(RT_LINK_EIO);
+ }
}
}
}
@@ -797,41 +905,51 @@ static void rt_link_frame_recv_timeout(void)
static void rt_link_send_timeout(void)
{
- static rt_uint8_t count = 0;
- if (count++ > 5)
+ LOG_D("send count(%d)", (rt_uint32_t)rt_link_scb->sendtimer.parameter);
+ if ((rt_uint32_t)rt_link_scb->sendtimer.parameter >= 5)
{
+ rt_timer_stop(&rt_link_scb->sendtimer);
LOG_W("Send timeout, please check the link status!");
- count = 0;
- rt_event_send(&rt_link_scb->event, RT_LINK_SEND_FAILED_EVENT);
+ rt_link_scb->sendtimer.parameter = 0x00;
+ rt_link_service_send_finish(RT_LINK_ETIMEOUT);
}
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);
+ if (rt_slist_next(&rt_link_scb->tx_data_slist))
+ {
+ struct rt_link_frame *frame = rt_container_of(rt_slist_next(&rt_link_scb->tx_data_slist), struct rt_link_frame, slist);
+ frame->issent = RT_LINK_FRAME_NOSEND;
+ rt_link_command_frame_send(RT_LINK_SERVICE_RTLINK,
+ frame->head.sequence,
+ RT_LINK_HANDSHAKE_FRAME,
+ rt_link_scb->rx_record.rx_seq);
+ }
}
}
-static int rt_link_long_recv_timeout(void)
+static void rt_link_long_recv_timeout(void)
{
- static rt_uint8_t count = 0;
- if (count++ > 5)
+ if ((rt_uint32_t)rt_link_scb->longframetimer.parameter >= 5)
{
LOG_W("long package receive timeout");
- count = 0;
+ rt_link_scb->longframetimer.parameter = 0x00;
_stop_recv_long();
+ rt_timer_stop(&rt_link_scb->longframetimer);
}
else
{
- for (rt_uint8_t total = rt_link_scb->rx_record.total; total > 0; total--)
+ rt_uint8_t total = rt_link_scb->rx_record.total;
+ for (; 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);
+ rt_link_command_frame_send(RT_LINK_SERVICE_RTLINK,
+ (rt_link_scb->rx_record.rx_seq + total),
+ RT_LINK_RESEND_FRAME, RT_NULL);
}
}
}
- return RT_EOK;
}
void rt_link_thread(void *parameter)
@@ -839,7 +957,8 @@ 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_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 |
@@ -877,6 +996,8 @@ void rt_link_thread(void *parameter)
static void rt_link_sendtimer_callback(void *parameter)
{
+ rt_uint32_t count = (rt_uint32_t)rt_link_scb->sendtimer.parameter + 1;
+ rt_link_scb->sendtimer.parameter = (void *)count;
rt_event_send(&rt_link_scb->event, RT_LINK_SEND_TIMEOUT_EVENT);
}
@@ -887,34 +1008,38 @@ static void rt_link_recvtimer_callback(void *parameter)
static void rt_link_receive_long_frame_callback(void *parameter)
{
+ rt_uint32_t count = (rt_uint32_t)rt_link_scb->longframetimer.parameter + 1;
+ rt_link_scb->longframetimer.parameter = (void *)count;
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 service Registered service channel, struct rt_link_service
* @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)
+rt_size_t rt_link_send(struct rt_link_service *service, const 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_ASSERT(service != RT_NULL);
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 */
+ rt_size_t send_len = 0;
struct rt_link_frame *send_frame = RT_NULL;
- rt_link_frame_attribute_t attribute;
+ rt_link_frame_attr_e attribute = RT_LINK_SHORT_DATA_FRAME;
+
+ if ((size == 0) || (data == RT_NULL))
+ {
+ service->err = RT_LINK_ERR;
+ goto __exit;
+ }
+
+ service->err = RT_LINK_EOK;
if (size % RT_LINK_MAX_DATA_LENGTH == 0)
{
total = size / RT_LINK_MAX_DATA_LENGTH;
@@ -926,24 +1051,25 @@ rt_size_t rt_link_send(rt_link_service_t service, void *data, rt_size_t size)
if (total > RT_LINK_FRAMES_MAX)
{
- result = -RT_ENOMEM;
+ service->err = RT_LINK_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;
+ if (send_frame == RT_NULL)
+ {
+ service->err = RT_LINK_ENOMEM;
+ goto __exit;
+ }
+ rt_link_frame_init(send_frame, service->flag);
+ send_frame->head.sequence = ++rt_link_scb->tx_seq;
+ send_frame->head.service = service->service;
send_frame->real_data = (rt_uint8_t *)data + offset;
send_frame->index = index;
send_frame->total = total;
@@ -970,53 +1096,39 @@ rt_size_t rt_link_send(rt_link_service_t service, void *data, rt_size_t 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);
+ LOG_D("append 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++;
+ send_len += send_frame->data_len;
}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)
+ if (service->timeout_tx != RT_WAITING_NO)
{
- LOG_E("the data (%dB) send failed", size);
- result = -RT_ERROR;
- }
- else
- {
- LOG_E("unexpected event.");
- result = -RT_ERROR;
+ /* Wait for the packet to send the result */
+ rt_err_t ret = rt_event_recv(&rt_link_scb->sendevent, (0x01 << service->service),
+ RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
+ service->timeout_tx, &recved);
+ if (ret == -RT_ETIMEOUT)
+ {
+ service->err = RT_LINK_ETIMEOUT;
+ send_len = 0;
+ }
}
+
__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;
+ return send_len;
}
void rtlink_status(void)
{
- rt_kprintf("rtlink status:\n");
+ rt_kprintf("rtlink(v%s) status:\n", RT_LINK_VER);
if (rt_link_scb != RT_NULL)
{
- rt_kprintf("\tlink status=%d\n", rt_link_scb->link_status);
+ rt_kprintf("\tlink status=%d\n", rt_link_scb->state);
rt_kprintf("\trx seq=%d\n", rt_link_scb->rx_record.rx_seq);
rt_kprintf("\ttx seq=%d\n", rt_link_scb->tx_seq);
@@ -1034,7 +1146,7 @@ void rtlink_status(void)
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("\tsend data list: serv %u\t", ((struct rt_link_frame_head *)data)->service);
rt_kprintf(" seq %u\t", ((struct rt_link_frame_head *)data)->sequence);
rt_kprintf(" len %u\n", ((struct rt_link_frame_head *)data)->length);
}
@@ -1044,10 +1156,10 @@ void rtlink_status(void)
rt_kprintf("\tsend data list: NULL\n");
}
- rt_uint8_t serv = sizeof(rt_link_scb->channel) / sizeof(struct rt_link_service);
+ rt_uint8_t serv = RT_LINK_SERVICE_MAX - 1;
while (serv--)
{
- rt_kprintf("\tservices [%d](0x%p)\n", serv, rt_link_scb->channel[serv]);
+ rt_kprintf("\tservices [%d](0x%p)\n", serv, rt_link_scb->service[serv]);
}
}
else
@@ -1069,7 +1181,6 @@ rt_err_t rt_link_deinit(void)
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;
@@ -1106,10 +1217,12 @@ int rt_link_init(void)
}
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_init(&rt_link_scb->event, "rtlink", 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_event_init(&rt_link_scb->sendevent, "send_rtlink", RT_IPC_FLAG_FIFO);
+ rt_event_control(&rt_link_scb->sendevent, RT_IPC_CMD_RESET, RT_NULL);
+
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,
@@ -1117,8 +1230,6 @@ int rt_link_init(void)
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);
@@ -1137,8 +1248,8 @@ int rt_link_init(void)
goto __exit;
}
rt_thread_startup(thread);
- result = rt_link_hw_init();
+ rt_link_scb->state = RT_LINK_INIT;
__exit:
if (result != RT_EOK)
{
@@ -1147,7 +1258,7 @@ __exit:
}
else
{
- LOG_I("rtlink init success.");
+ LOG_I("rtlink init success(VER:%s).", RT_LINK_VER);
}
return result;
}
@@ -1158,35 +1269,52 @@ 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
+ * @param service Registered service channel, struct rt_link_service
* @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))
+rt_err_t rt_link_service_attach(struct rt_link_service *serv)
{
- if (service >= RT_LINK_SERVICE_MAX)
+ RT_ASSERT(serv != RT_NULL);
+ if (serv->service >= RT_LINK_SERVICE_MAX)
{
LOG_W("Invalid parameter.");
- return -RT_ERROR;
+ return -RT_EINVAL;
}
- rt_link_scb->channel[service].upload_callback = function;
- LOG_I("rt link attach service[%02d].", service);
+ rt_uint8_t seq = rt_link_scb->tx_seq;
+ rt_link_hw_init();
+ rt_link_scb->service[serv->service] = serv;
+ serv->state = RT_LINK_INIT;
+ LOG_I("rt link attach service[%02d].", serv->service);
+
+ if (rt_slist_next(&rt_link_scb->tx_data_slist))
+ {
+ struct rt_link_frame *frame = rt_container_of(rt_slist_next(&rt_link_scb->tx_data_slist), struct rt_link_frame, slist);
+ seq = frame->head.sequence;
+ }
+ rt_link_command_frame_send(serv->service, seq, RT_LINK_HANDSHAKE_FRAME, rt_link_scb->rx_record.rx_seq);
return RT_EOK;
}
/**
* rtlink service detach
- * @param service Registered service channel, choose enum rt_link_service_t
+ * @param service Registered service channel, struct rt_link_service
* @return rt_err_t Function Execution Result
* */
-rt_err_t rt_link_service_detach(rt_link_service_t service)
+rt_err_t rt_link_service_detach(struct rt_link_service *serv)
{
- if (service >= RT_LINK_SERVICE_MAX)
+ RT_ASSERT(serv != RT_NULL);
+ if (serv->service >= RT_LINK_SERVICE_MAX)
{
LOG_W("Invalid parameter.");
- return -RT_ERROR;
+ return -RT_EINVAL;
}
- rt_link_scb->channel[service].upload_callback = RT_NULL;
- LOG_I("rt link detach service[%02d].", service);
+ rt_link_command_frame_send(serv->service,
+ rt_link_scb->tx_seq,
+ RT_LINK_DETACH_FRAME,
+ rt_link_scb->rx_record.rx_seq);
+
+ serv->state = RT_LINK_DISCONN;
+ rt_link_scb->service[serv->service] = RT_NULL;
+ LOG_I("rt link detach service[%02d].", serv->service);
return RT_EOK;
}
diff --git a/components/utilities/rt-link/src/rtlink_dev.c b/components/utilities/rt-link/src/rtlink_dev.c
new file mode 100644
index 0000000000..5eff1f9782
--- /dev/null
+++ b/components/utilities/rt-link/src/rtlink_dev.c
@@ -0,0 +1,396 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-06-15 Sherman the first version
+ */
+
+#define DBG_TAG "RTLINK_DEV"
+#define DBG_LVL DBG_LOG
+#include <rtdbg.h>
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <rtlink_dev.h>
+
+#define RTLINK_SERV(dev) (((struct rt_link_device*)dev)->service)
+
+#ifdef RT_USING_POSIX
+#include <dfs_posix.h>
+#include <dfs_poll.h>
+
+int rtlink_fops_open(struct dfs_fd *fd)
+{
+ rt_uint16_t flags = 0;
+ rt_device_t device;
+
+ switch (fd->flags & O_ACCMODE)
+ {
+ case O_RDONLY:
+ LOG_D("fops open: O_RDONLY!");
+ flags = RT_DEVICE_FLAG_RDONLY;
+ break;
+ case O_WRONLY:
+ LOG_D("fops open: O_WRONLY!");
+ flags = RT_DEVICE_FLAG_WRONLY;
+ break;
+ case O_RDWR:
+ LOG_D("fops open: O_RDWR!");
+ flags = RT_DEVICE_FLAG_RDWR;
+ break;
+ default:
+ LOG_E("fops open: unknown mode - %d!", fd->flags & O_ACCMODE);
+ break;
+ }
+
+ device = (rt_device_t)fd->data;
+ if (fd->flags & O_NONBLOCK)
+ {
+ rt_device_control(device, RT_LINK_TX_NONBLOCKING | RT_LINK_RX_NONBLOCKING, RT_NULL);
+ }
+
+ return rt_device_open(device, flags);
+}
+
+int rtlink_fops_close(struct dfs_fd *fd)
+{
+ rt_device_t device;
+ device = (rt_device_t)fd->data;
+
+ rt_device_set_rx_indicate(device, RT_NULL);
+ return rt_device_close(device);
+}
+
+int rtlink_fops_ioctl(struct dfs_fd *fd, int cmd, void *args)
+{
+ rt_device_t device;
+ device = (rt_device_t)fd->data;
+
+ if (cmd == O_NONBLOCK)
+ {
+ return rt_device_control(device, RT_LINK_TX_NONBLOCKING | RT_LINK_RX_NONBLOCKING, RT_NULL);
+ }
+ else
+ {
+ return rt_device_control(device, cmd, args);
+ }
+}
+
+int rtlink_fops_read(struct dfs_fd *fd, void *buf, size_t count)
+{
+ int size = 0;
+ rt_device_t device;
+ device = (rt_device_t)fd->data;
+
+ size = rt_device_read(device, -1, buf, count);
+ if (size <= 0)
+ {
+ size = -EAGAIN;
+ }
+ return size;
+}
+
+int rtlink_fops_write(struct dfs_fd *fd, const void *buf, size_t count)
+{
+ int size = 0;
+ rt_device_t device;
+ device = (rt_device_t)fd->data;
+
+ size = rt_device_write(device, -1, buf, count);
+ if (size <= 0)
+ {
+ size = -EAGAIN;
+ }
+ return size;
+}
+
+int rtlink_fops_poll(struct dfs_fd *fd, struct rt_pollreq *req)
+{
+ int mask = 0;
+ int flags = 0;
+ rt_device_t device;
+ struct rt_link_device *rtlink_dev;
+
+ device = (rt_device_t)fd->data;
+ RT_ASSERT(device != RT_NULL);
+
+ rtlink_dev = (struct rt_link_device *)device;
+
+ flags = fd->flags & O_ACCMODE;
+ if (flags == O_RDONLY || flags == O_RDWR)
+ {
+ rt_base_t level;
+ rt_poll_add(&(device->wait_queue), req);
+
+ level = rt_hw_interrupt_disable();
+ if (RT_NULL != rt_slist_first(&rtlink_dev->recv_head))
+ mask |= POLLIN;
+ rt_hw_interrupt_enable(level);
+ }
+ mask |= POLLOUT;
+
+ return mask;
+}
+
+const static struct dfs_file_ops _rtlink_fops =
+{
+ rtlink_fops_open,
+ rtlink_fops_close,
+ rtlink_fops_ioctl,
+ rtlink_fops_read,
+ rtlink_fops_write,
+ RT_NULL, /* flush */
+ RT_NULL, /* lseek */
+ RT_NULL, /* getdents */
+ rtlink_fops_poll,
+};
+#endif /* RT_USING_POSIX */
+
+/* The event type for the service channel number,
+ * which is used to wake up the service thread in blocking receive mode */
+struct rt_event recv_event;
+
+static rt_err_t rt_link_event_send(struct rt_link_service *serv)
+{
+ RT_ASSERT(serv != RT_NULL);
+ RT_ASSERT(serv->service < RT_LINK_SERVICE_MAX);
+ rt_uint32_t set = 0x01 << serv->service;
+ return rt_event_send(&recv_event, set);
+}
+
+static rt_err_t rt_link_event_recv(struct rt_link_service *service)
+{
+ RT_ASSERT(service != RT_NULL);
+ RT_ASSERT(service->service < RT_LINK_SERVICE_MAX);
+
+ rt_uint32_t set = 0x01 << service->service;
+ rt_uint32_t recved = 0;
+ rt_err_t ret = rt_event_recv(&recv_event,
+ set,
+ RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
+ RT_WAITING_FOREVER,
+ &recved);
+ if (recved & set)
+ {
+ return ret;
+ }
+ return RT_ERROR;
+}
+
+static void send_cb(struct rt_link_service *service, void *buffer)
+{
+ RT_ASSERT(service != RT_NULL);
+ RT_ASSERT(buffer != RT_NULL);
+ struct rt_link_device *rtlink = (struct rt_link_device *)service->user_data;
+
+ if (rtlink && rtlink->parent.tx_complete)
+ {
+ rtlink->parent.tx_complete(&rtlink->parent, buffer);
+ }
+}
+
+static void recv_cb(struct rt_link_service *service, void *data, rt_size_t size)
+{
+ RT_ASSERT(service != RT_NULL);
+ struct rt_link_device *rtlink = (struct rt_link_device *)service->user_data;
+
+ if (rtlink)
+ {
+ struct rtlink_recv_list *node = rt_malloc(sizeof(struct rtlink_recv_list));
+ node->data = data;
+ node->size = size;
+ node->index = 0;
+ rt_slist_append(&rtlink->recv_head, &node->list);
+ rt_link_event_send(service);
+
+ if (rtlink->parent.rx_indicate)
+ {
+ rtlink->parent.rx_indicate(&rtlink->parent, size);
+ }
+ }
+ else
+ {
+ rt_free(data);
+ }
+}
+
+rt_err_t rt_link_dev_init(rt_device_t dev)
+{
+ RT_ASSERT(dev != RT_NULL);
+
+ dev->rx_indicate = RT_NULL;
+ dev->tx_complete = RT_NULL;
+
+ struct rt_link_device *rtlink = (struct rt_link_device *)dev;
+ rtlink->service.service = RT_LINK_SERVICE_MAX;
+ rtlink->service.recv_cb = RT_NULL;
+ rtlink->service.send_cb = RT_NULL;
+ rtlink->service.timeout_tx = RT_WAITING_NO;
+ rtlink->service.user_data = (void *)dev;
+
+ rt_slist_init(&rtlink->recv_head);
+ return RT_EOK;
+}
+
+rt_err_t rt_link_dev_open(rt_device_t dev, rt_uint16_t oflag)
+{
+ RT_ASSERT(dev != RT_NULL);
+ struct rt_link_device *rtlink = (struct rt_link_device *)dev;
+
+ rtlink->service.recv_cb = recv_cb;
+ rtlink->service.send_cb = send_cb;
+
+ dev->open_flag = oflag & RT_DEVICE_OFLAG_MASK;
+ if (dev->open_flag == RT_DEVICE_OFLAG_RDONLY)
+ {
+ rtlink->service.send_cb = RT_NULL;
+ }
+ else if (dev->open_flag == RT_DEVICE_OFLAG_WRONLY)
+ {
+ rtlink->service.recv_cb = RT_NULL;
+ }
+ return rt_link_service_attach(&rtlink->service);
+}
+
+rt_err_t rt_link_dev_close(rt_device_t dev)
+{
+ RT_ASSERT(dev != RT_NULL);
+ struct rt_link_device *rtlink = (struct rt_link_device *)dev;
+ return rt_link_service_detach(&rtlink->service);
+}
+
+rt_size_t rt_link_dev_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
+{
+ RT_ASSERT(dev != RT_NULL);
+ RT_ASSERT(buffer != RT_NULL);
+ RT_ASSERT(size != 0);
+
+ struct rt_link_device *rtlink = (struct rt_link_device *)dev;
+ struct rtlink_recv_list *node;
+ rt_size_t read_len = 0;
+ rt_size_t unread_len = 0;
+
+ if (dev->rx_indicate == RT_NULL)
+ {
+ /* RT_LINK_RX_BLOCKING, wait service receive data event */
+ rt_link_event_recv(&rtlink->service);
+ }
+
+ if (rt_slist_first(&rtlink->recv_head) != RT_NULL)
+ {
+ node = rt_container_of(rt_slist_next(&rtlink->recv_head), struct rtlink_recv_list, list);
+ unread_len = (node->size) - (node->index);
+ read_len = (size > unread_len) ? unread_len : size;
+ rt_memcpy(buffer, (rt_uint8_t *)node->data + node->index, read_len);
+ node->index += read_len;
+
+ if (node->index >= node->size)
+ {
+ rt_slist_remove(&rtlink->recv_head, &node->list);
+ node->index = 0;
+ rt_free(node->data);
+ rt_free(node);
+ }
+ if (rt_slist_first(&rtlink->recv_head) != RT_NULL)
+ {
+ rt_link_event_send(&rtlink->service);
+ }
+ }
+ return read_len;
+}
+
+rt_size_t rt_link_dev_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
+{
+ RT_ASSERT(dev != RT_NULL);
+ RT_ASSERT(buffer != RT_NULL);
+ RT_ASSERT(size != 0);
+
+ return rt_link_send(&RTLINK_SERV(dev), buffer, size);
+}
+
+rt_err_t rt_link_dev_control(rt_device_t dev, int cmd, void *args)
+{
+ RT_ASSERT(dev != RT_NULL);
+
+ if (cmd & RT_DEVICE_CTRL_CONFIG)
+ {
+ if (args == RT_NULL)
+ return RT_EINVAL;
+ RTLINK_SERV(dev).service = ((struct rt_link_service *)args)->service;
+ RTLINK_SERV(dev).timeout_tx = ((struct rt_link_service *)args)->timeout_tx;
+ RTLINK_SERV(dev).flag = ((struct rt_link_service *)args)->flag;
+ }
+
+ if (cmd & RT_LINK_RX_BLOCKING)
+ {
+ dev->rx_indicate = RT_NULL;
+ }
+ if (cmd & RT_LINK_TX_BLOCKING)
+ {
+ RTLINK_SERV(dev).timeout_tx = RT_WAITING_FOREVER;
+ dev->tx_complete = RT_NULL;
+ }
+ if (cmd & RT_LINK_TX_NONBLOCKING)
+ {
+ RTLINK_SERV(dev).timeout_tx = RT_WAITING_NO;
+ }
+
+ return RT_EOK;
+}
+
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops rtlink_ops =
+{
+ rt_link_dev_init,
+ rt_link_dev_open,
+ rt_link_dev_close,
+ rt_link_dev_read,
+ rt_link_dev_write,
+ rt_link_dev_control
+};
+#endif /* RT_USING_DEVICE_OPS */
+
+/*
+ * rtlink device register
+ */
+rt_err_t rt_link_dev_register(struct rt_link_device *rtlink,
+ const char *name,
+ rt_uint32_t flag,
+ void *data)
+{
+ rt_err_t ret;
+ struct rt_device *device;
+ RT_ASSERT(rtlink != RT_NULL);
+
+ device = (struct rt_device *)rtlink;
+ device->type = RT_Device_Class_Char;
+ device->rx_indicate = RT_NULL;
+ device->tx_complete = RT_NULL;
+
+#ifdef RT_USING_DEVICE_OPS
+ device->ops = &rtlink_ops;
+#else
+ device->init = rt_link_dev_init;
+ device->open = rt_link_dev_open;
+ device->close = rt_link_dev_close;
+ device->read = rt_link_dev_read;
+ device->write = rt_link_dev_write;
+ device->control = rt_link_dev_control;
+#endif
+ device->user_data = data;
+
+ /* register a character device */
+ ret = rt_device_register(device, name, flag);
+
+#if defined(RT_USING_POSIX)
+ /* set fops */
+ device->fops = &_rtlink_fops;
+#endif
+
+ rt_event_init(&recv_event, "rtlink_dev", RT_IPC_FLAG_FIFO);
+ return ret;
+}
diff --git a/components/utilities/rt-link/src/rtlink_hw.c b/components/utilities/rt-link/src/rtlink_hw.c
index 9c4567ab63..696ab5b78a 100644
--- a/components/utilities/rt-link/src/rtlink_hw.c
+++ b/components/utilities/rt-link/src/rtlink_hw.c
@@ -85,18 +85,39 @@ static rt_size_t rt_link_hw_buffer_write(void *data, rt_size_t 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;
+ rt_uint8_t *pointer = *pointer_address + length;
- pointer = *pointer_address + length;
- if (pointer >= rx_buffer->end_point)
+ if (rx_buffer->write_point >= rx_buffer->read_point)
{
- rt_size_t offset = 0;
- offset = pointer - rx_buffer->end_point;
- *pointer_address = rx_buffer->data + offset;
+ if (pointer >= rx_buffer->write_point)
+ {
+ *pointer_address = rx_buffer->write_point;
+ }
+ else
+ {
+ *pointer_address = pointer;
+ }
}
else
{
- *pointer_address = *pointer_address + length;
+ if (pointer >= rx_buffer->end_point)
+ {
+ *pointer_address = rx_buffer->data;
+ pointer = pointer - rx_buffer->end_point + rx_buffer->data;
+
+ if (pointer >= rx_buffer->write_point)
+ {
+ *pointer_address = rx_buffer->write_point;
+ }
+ else
+ {
+ *pointer_address = pointer;
+ }
+ }
+ else
+ {
+ *pointer_address = pointer;
+ }
}
}
@@ -119,9 +140,13 @@ void rt_link_hw_copy(rt_uint8_t *dst, rt_uint8_t *src, rt_size_t count)
}
}
-/* Tells, how many chars are saved into the buffer */
+/* Length of data received */
rt_size_t rt_link_hw_recv_len(struct rt_link_receive_buffer *buffer)
{
+ if (buffer == RT_NULL)
+ {
+ return 0;
+ }
if (buffer->write_point >= buffer->read_point)
{
return (buffer->write_point - buffer->read_point);
@@ -183,15 +208,18 @@ rt_uint32_t rt_link_get_crc(rt_uint8_t using_buffer_ring, rt_uint8_t *data, rt_s
return crc32;
}
-rt_err_t rt_link_hw_send(void *data, rt_size_t length)
+rt_size_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);
+ if (send_len <= 0)
+ {
+ rt_link_port_reconnect();
+ send_len = rt_link_port_send(data, length);
+ }
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 */
@@ -220,11 +248,17 @@ rt_err_t rt_link_hw_init(void)
scb->rx_buffer = rx_buffer;
scb->calculate_crc = rt_link_get_crc;
- rt_link_port_init();
+ if (RT_EOK != rt_link_port_init())
+ {
+ return -RT_ERROR;
+ }
#ifdef LINK_LAYER_USING_HW_CRC
/* crc hardware device for mcu and node */
- rt_link_hw_crc32_init();
+ if (RT_EOK != rt_link_hw_crc32_init())
+ {
+ return -RT_ERROR;
+ }
#endif
LOG_I("link layer hardware environment init successful.");
@@ -244,11 +278,17 @@ rt_err_t rt_link_hw_deinit(void)
scb->rx_buffer = rx_buffer;
scb->calculate_crc = RT_NULL;
}
- rt_link_port_deinit();
+ if (RT_EOK != rt_link_port_deinit())
+ {
+ return -RT_ERROR;
+ }
#ifdef LINK_LAYER_USING_HW_CRC
/* crc hardware device for mcu and node */
- rt_link_hw_crc32_deinit();
+ if (RT_EOK != rt_link_hw_crc32_deinit())
+ {
+ return -RT_ERROR;
+ }
#endif
LOG_I("rtlink hardware deinit successful.");
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);
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-30 12:27:55 +0000