diff --git a/components/utilities/rt-link/Kconfig b/components/utilities/rt-link/Kconfig index 10ed129e69eb441df97187020ff99c268b31272c..d20c2f01d470e1727b27f53eaece651aa2259bad 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 e34243ebdaf9515ba586b4c7e997aeffcce4c7a9..0000000000000000000000000000000000000000 --- 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 48fbb91bc3d74047cf398ff672bfca90633aba99..0000000000000000000000000000000000000000 --- 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 -#include - -#include - -#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 - -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 dd98b57c30a07a5e4b864593c0a021b75b13cce5..941c35a3591dfdcbb0d5a40bd410678ea719d0a3 100644 --- a/components/utilities/rt-link/inc/rtlink.h +++ b/components/utilities/rt-link/inc/rtlink.h @@ -14,81 +14,102 @@ #include +#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_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_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_LONG_DATA_FRAME = 5, + RT_LINK_SHORT_DATA_FRAME = 6, - RT_LINK_HANDSHAKE_FRAME -} rt_link_frame_attribute_t; + 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 0000000000000000000000000000000000000000..01fd04373c4abc425e81127671203509b3a7334f --- /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 +#include + +#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 c75609a23a62ac5cfaf0ae168b2ba0cf8327b8e0..d0a56fe98c6e73c8e73468cfb9a6722bec4804dd 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 54a064d117a000cbc8ec025817a0d4ff599a9ace..b22f19072ad6a617bf5131f59037d17028b62456 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 /* 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 37a99538b6654caf399a3826e80eaa1ec070e40d..010083aaa58d5829fb50c22dd3c655b91209a8a1 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 @@ -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 0000000000000000000000000000000000000000..5eff1f9782fbfdb0077b5af163bd5d0afa845679 --- /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 + +#include +#include +#include +#include + +#define RTLINK_SERV(dev) (((struct rt_link_device*)dev)->service) + +#ifdef RT_USING_POSIX +#include +#include + +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 9c4567ab63296f9815e59599ee82f9409d0de56e..696ab5b78a07b1960a0e1cf0a179d10aef8680ae 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 0000000000000000000000000000000000000000..0a026bcb3dbb6357ad1e532e534e35e07c7ce37d --- /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 +#include + +#define DBG_TAG "example" +#define DBG_LVL DBG_LOG +#include +#include + +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 +#include +#include + +#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 841e56b17e4664e9f70b0e077be1a9e32a8f8799..4c9b9c54fb4aeae6addae9902992bdadf65a1ddd 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 @@ -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) { - - rt_link_service_attach(RT_LINK_SERVICE_RTLINK, rt_link_receive_example_callback); + 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); + + 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);