12345qiupeng
/
Motion_EC_HC32_archived
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Motion_EC_HC32_archived/rt-thread/components/utilities/rt-link/src/rtlink.c

1321 lines
44 KiB
C
Raw Normal View History

initial
2022-01-10 16:20:39 +08:00
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2021-02-02 xiangxistu the first version
* 2021-03-19 Sherman Optimize the transfer process
* 2021-04-20 Sherman Optimize memory footprint
* 2021-05-10 Sherman Add rtlink_status MSH command;
* Optimize transmission timer Settings;
* Fix known bugs
* 2021-08-06 Sherman Add NACK, NCRC, non-blocking transmit mode;
* Add service connection status;
*/
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>
#include <rthw.h>
#include <rtlink.h>
#include <rtlink_hw.h>
#include <rtlink_utils.h>
#define DBG_ENABLE
#ifdef USING_RT_LINK_DEBUG
#define DBG_LVL DBG_LOG
#else
#define DBG_LVL DBG_INFO
#endif
#define DBG_TAG "rtlink"
#define DBG_COLOR
#include <rtdbg.h>
#ifdef RT_LINK_USING_SPI
#define RT_LINK_LONG_FRAME_TIMEOUT 50
#define RT_LINK_SENT_FRAME_TIMEOUT 100
#else
#define RT_LINK_LONG_FRAME_TIMEOUT 100
#define RT_LINK_SENT_FRAME_TIMEOUT 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 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 = 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) */
static struct rt_link_session *rt_link_scb = RT_NULL;
struct rt_link_session *rt_link_get_scb(void)
{
return rt_link_scb;
}
static rt_int16_t rt_link_check_seq(rt_uint8_t new, rt_uint8_t used)
{
rt_int16_t compare_seq = 0;
compare_seq = new - used;
if (compare_seq < 0)
{
compare_seq = compare_seq + 256;
}
return compare_seq;
}
static int rt_link_frame_init(struct rt_link_frame *frame, rt_uint8_t config)
{
if (frame == RT_NULL)
{
return -RT_ERROR;
}
/* set frame control information */
rt_memset(&frame->head, 0, sizeof(struct rt_link_frame_head));
if (config & RT_LINK_FLAG_CRC)
{
frame->head.crc = 1;
}
if (config & RT_LINK_FLAG_ACK)
{
frame->head.ack = 1;
}
frame->head.magicid = RT_LINK_FRAME_HEAD;
/* frame data information */
rt_memset(&frame->extend, 0, sizeof(struct rt_link_extend));
frame->crc = 0;
frame->real_data = RT_NULL;
frame->data_len = 0;
frame->index = 0;
frame->total = 0;
frame->attribute = RT_LINK_RESERVE_FRAME;
frame->issent = RT_LINK_FRAME_NOSEND;
rt_slist_init(&frame->slist);
return RT_EOK;
}
/* remove the sending list node*/
static void rt_link_frame_remove(struct rt_link_service *service)
{
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)
{
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;
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)
{
length += RT_LINK_CRC_LENGTH;
}
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 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)
{
slist = rt_slist_next(&rt_link_scb->tx_data_slist);
}
if (slist == RT_NULL)
{
LOG_W("send data list NULL");
return -RT_ERROR;
}
do
{
/* get frame for send */
frame = rt_container_of(slist, struct rt_link_frame, slist);
slist = rt_slist_next(slist);
if (frame_send(frame) == 0)
{
rt_link_scb->service[frame->head.service]->err = RT_LINK_EIO;
goto __err;
}
frame->issent = RT_LINK_FRAME_SENT;
if ((slist == RT_NULL) || (frame->index + 1 >= frame->total))
{
send_max = 0;
is_finish = RT_TRUE;
}
else
{
send_max >>= 1;
}
}while (send_max);
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)
{
LOG_D("Continue sending");
rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
}
}
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)
{
rt_timer_stop(&rt_link_scb->longframetimer);
if (rt_link_scb->rx_record.dataspace != RT_NULL)
{
rt_free(rt_link_scb->rx_record.dataspace);
rt_link_scb->rx_record.dataspace = RT_NULL;
}
rt_link_scb->rx_record.long_count = 0;
rt_link_scb->rx_record.total = 0;
}
static rt_err_t rt_link_frame_stop_receive(struct rt_link_frame *frame)
{
rt_memset(frame, 0, sizeof(struct rt_link_frame));
if (rt_link_scb->rx_record.dataspace)
{
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;
rt_timer_stop(&rt_link_scb->recvtimer);
rt_link_scb->recvtimer.parameter = 0;
return RT_EOK;
}
static rt_err_t rt_link_resend_handle(struct rt_link_frame *receive_frame)
{
struct rt_link_frame *find_frame = RT_NULL;
rt_slist_t *tem_list = RT_NULL;
tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
while (tem_list != RT_NULL)
{
find_frame = rt_container_of(tem_list, struct rt_link_frame, slist);
if (find_frame->head.sequence == receive_frame->head.sequence)
{
LOG_D("resend frame(%d)", find_frame->head.sequence);
frame_send(find_frame);
break;
}
tem_list = tem_list->next;
}
if (tem_list == RT_NULL)
{
LOG_D("frame resent failed, can't find(%d).", receive_frame->head.sequence);
rt_link_command_frame_send(receive_frame->head.service,
receive_frame->head.sequence,
RT_LINK_SESSION_END, RT_NULL);
}
return RT_EOK;
}
static rt_err_t rt_link_confirm_handle(struct rt_link_frame *receive_frame)
{
static struct rt_link_frame *send_frame = RT_NULL;
rt_slist_t *tem_list = RT_NULL;
rt_uint16_t seq_offset = 0;
LOG_D("confirm seq(%d) frame", receive_frame->head.sequence);
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 */
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);
}
return RT_EOK;
}
/* Check to see if the frame is send for confirm */
tem_list = rt_slist_first(&rt_link_scb->tx_data_slist);
if (tem_list == RT_NULL)
{
return -RT_ERROR;
}
send_frame = rt_container_of(tem_list, struct rt_link_frame, slist);
seq_offset = rt_link_check_seq(receive_frame->head.sequence, send_frame->head.sequence);
if (seq_offset <= send_frame->total)
{
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)
{
LOG_D("Continue sending");
rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
}
}
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)
{
if (receive_frame->head.ack)
{
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;
}
else
{
LOG_W("short data %dB alloc failed", receive_frame->data_len);
}
receive_frame->real_data = RT_NULL;
return 0;
}
static void _long_handle_first(struct rt_link_frame *receive_frame)
{
if (receive_frame->extend.parameter % RT_LINK_MAX_DATA_LENGTH == 0)
{
receive_frame->total = receive_frame->extend.parameter / RT_LINK_MAX_DATA_LENGTH;
}
else
{
receive_frame->total = receive_frame->extend.parameter / RT_LINK_MAX_DATA_LENGTH + 1;
}
rt_link_scb->rx_record.total = receive_frame->total;
rt_link_scb->rx_record.dataspace = rt_malloc(receive_frame->extend.parameter);
if (rt_link_scb->rx_record.dataspace == RT_NULL)
{
LOG_W("long data (%dB) alloc failed.", receive_frame->extend.parameter);
}
}
static void _long_handle_second(struct rt_link_frame *receive_frame)
{
static rt_uint8_t ack_mask = RT_LINK_ACK_MAX;
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("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)))
{
LOG_D("ERR:index %d, rx_seq %d", receive_frame->index, rt_link_scb->rx_record.rx_seq);
}
else if (rt_link_scb->rx_record.dataspace != RT_NULL)
{
rt_link_scb->rx_record.long_count |= (0x01 << receive_frame->index);
offset = RT_LINK_MAX_DATA_LENGTH * receive_frame->index;
rt_link_hw_copy(rt_link_scb->rx_record.dataspace + offset, receive_frame->real_data, receive_frame->data_len);
if (receive_frame->head.ack)
{
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();
/* 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_exit_critical();
}
else if (rt_link_hw_recv_len(rt_link_scb->rx_buffer) < (receive_frame->data_len % RT_LINK_MAX_DATA_LENGTH))
{
rt_int32_t timeout = RT_LINK_LONG_FRAME_TIMEOUT;
rt_timer_control(&rt_link_scb->longframetimer, RT_TIMER_CTRL_SET_TIME, &timeout);
rt_timer_start(&rt_link_scb->longframetimer);
}
}
}
static rt_err_t rt_link_long_handle(struct rt_link_frame *receive_frame)
{
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);
}
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);
}
receive_frame->real_data = RT_NULL;
return RT_EOK;
}
static rt_err_t rt_link_handshake_handle(struct rt_link_frame *receive_frame)
{
LOG_D("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;
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;
}
/* Discriminate frame type */
static rt_err_t rt_link_parse_frame(struct rt_link_frame *receive_frame)
{
switch (receive_frame->attribute)
{
case RT_LINK_RESEND_FRAME:
rt_link_resend_handle(receive_frame);
break;
case RT_LINK_CONFIRM_FRAME:
rt_link_confirm_handle(receive_frame);
break;
case RT_LINK_HANDSHAKE_FRAME:
rt_link_handshake_handle(receive_frame);
break;
case RT_LINK_SESSION_END:
rt_link_session_end_handle(receive_frame);
break;
case RT_LINK_DETACH_FRAME:
rt_link_detach_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;
default:
return -RT_ERROR;
}
return RT_EOK;
}
/* RT_LINK_READ_CHECK_EVENT handle */
static void rt_link_frame_check(void)
{
static struct rt_link_frame receive_frame = {0};
static rt_link_frame_parse_t analysis_status = FIND_FRAME_HEAD;
static rt_uint8_t *data = RT_NULL;
static rt_uint16_t buff_len = RT_LINK_HEAD_LENGTH;
struct rt_link_frame *send_frame = RT_NULL;
rt_tick_t timeout = 0;
rt_uint32_t temporary_crc = 0;
rt_uint8_t offset = 0;
rt_size_t recv_len = rt_link_hw_recv_len(rt_link_scb->rx_buffer);
while (recv_len > 0)
{
switch (analysis_status)
{
case FIND_FRAME_HEAD:
{
/* if we can't find frame head, throw that data */
if ((*rt_link_scb->rx_buffer->read_point & RT_LINK_FRAME_HEAD_MASK) == RT_LINK_FRAME_HEAD)
{
analysis_status = PARSE_FRAME_HEAD;
break;
}
rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
break;
}
case PARSE_FRAME_HEAD:
{
if (recv_len < buff_len)
{
LOG_D("HEAD: actual: %d, need: %d.", recv_len, buff_len);
return ;
}
/* Data is an offset address */
data = rt_link_scb->rx_buffer->read_point;
rt_link_frame_init(&receive_frame, RT_NULL);
rt_link_hw_copy((rt_uint8_t *)&receive_frame.head, data, sizeof(struct rt_link_frame_head));
rt_link_hw_buffer_point_shift(&data, sizeof(struct rt_link_frame_head));
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;
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_EXTEND_LENGTH;
analysis_status = PARSE_FRAME_EXTEND;
}
else
{
receive_frame.attribute = RT_LINK_SHORT_DATA_FRAME;
analysis_status = PARSE_FRAME_SEQ;
}
}
case PARSE_FRAME_EXTEND:
{
if (receive_frame.head.extend)
{
if (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));
if (receive_frame.extend.attribute < RT_LINK_RESERVE_FRAME)
{
receive_frame.attribute = receive_frame.extend.attribute;
}
else
{
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;
}
}
analysis_status = PARSE_FRAME_SEQ;
}
case PARSE_FRAME_SEQ:
{
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)
{
send_frame = rt_container_of(rt_link_scb->tx_data_slist.next, struct rt_link_frame, slist);
if (offset > send_frame->total)
{
/* exceptional frame, ignore it */
LOG_D("seq (%d) failed, tx_seq (%d).offset=(%d) total= (%d)", receive_frame.head.sequence, rt_link_scb->tx_seq, offset, send_frame->total);
rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
goto __find_head;
}
}
break;
}
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)
{
/* 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->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)
{
buff_len += RT_LINK_CRC_LENGTH;
analysis_status = CHECK_FRAME_CRC;
}
else
{
analysis_status = HEADLE_FRAME_DATA;
}
/* fill real data point */
receive_frame.real_data = data;
}
case CHECK_FRAME_CRC:
{
if (receive_frame.head.crc)
{
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);
rt_timer_start(&rt_link_scb->recvtimer);
return;
}
rt_timer_stop(&rt_link_scb->recvtimer);
rt_link_hw_buffer_point_shift(&data, receive_frame.data_len);
rt_link_hw_copy((rt_uint8_t *)&receive_frame.crc, data, RT_LINK_CRC_LENGTH);
temporary_crc = rt_link_scb->calculate_crc(RT_TRUE, rt_link_scb->rx_buffer->read_point, buff_len - RT_LINK_CRC_LENGTH);
if (receive_frame.crc != temporary_crc)
{
/* check failed. ready resent */
LOG_D("CRC: calc:(0x%08x) ,recv:(0x%08x).", temporary_crc, receive_frame.crc);
rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, 1);
goto __find_head;
}
}
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;
buff_len = RT_LINK_HEAD_LENGTH;
analysis_status = FIND_FRAME_HEAD;
break;
}
default:
__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)
{
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->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
{
/* Avoid sending the first data frame multiple times */
if ((frame != RT_NULL) && (frame->issent == RT_LINK_FRAME_NOSEND))
{
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);
}
}
}
}
static void rt_link_frame_recv_timeout(void)
{
/* The receiving frame timeout and a new receive begins */
rt_link_hw_buffer_point_shift(&rt_link_scb->rx_buffer->read_point, rt_link_hw_recv_len(rt_link_scb->rx_buffer));
}
static void rt_link_send_timeout(void)
{
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!");
rt_link_scb->sendtimer.parameter = 0x00;
rt_link_service_send_finish(RT_LINK_ETIMEOUT);
}
else
{
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 void rt_link_long_recv_timeout(void)
{
if ((rt_uint32_t)rt_link_scb->longframetimer.parameter >= 5)
{
LOG_W("long package receive timeout");
rt_link_scb->longframetimer.parameter = 0x00;
_stop_recv_long();
rt_timer_stop(&rt_link_scb->longframetimer);
}
else
{
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_SERVICE_RTLINK,
(rt_link_scb->rx_record.rx_seq + total),
RT_LINK_RESEND_FRAME, RT_NULL);
}
}
}
}
void rt_link_thread(void *parameter)
{
rt_uint32_t recved = 0;
while (1)
{
rt_event_recv(&rt_link_scb->event,
RT_LINK_READ_CHECK_EVENT |
RT_LINK_SEND_READY_EVENT |
RT_LINK_SEND_TIMEOUT_EVENT |
RT_LINK_RECV_TIMEOUT_FRAME_EVENT |
RT_LINK_RECV_TIMEOUT_LONG_EVENT,
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
RT_WAITING_FOREVER,
&recved);
if (recved & RT_LINK_READ_CHECK_EVENT)
{
rt_link_frame_check();
}
if (recved & RT_LINK_SEND_READY_EVENT)
{
rt_link_send_ready();
}
if (recved & RT_LINK_SEND_TIMEOUT_EVENT)
{
rt_link_send_timeout();
}
if (recved & RT_LINK_RECV_TIMEOUT_FRAME_EVENT)
{
rt_link_frame_recv_timeout();
}
if (recved & RT_LINK_RECV_TIMEOUT_LONG_EVENT)
{
rt_link_long_recv_timeout();
}
}
}
static void rt_link_sendtimer_callback(void *parameter)
{
rt_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);
}
static void rt_link_recvtimer_callback(void *parameter)
{
rt_event_send(&rt_link_scb->event, RT_LINK_RECV_TIMEOUT_FRAME_EVENT);
}
static void rt_link_receive_long_frame_callback(void *parameter)
{
rt_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, 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(struct rt_link_service *service, const void *data, rt_size_t size)
{
RT_ASSERT(service != RT_NULL);
rt_uint32_t recved = 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_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;
}
else
{
total = size / RT_LINK_MAX_DATA_LENGTH + 1;
}
if (total > RT_LINK_FRAMES_MAX)
{
service->err = RT_LINK_ENOMEM;
goto __exit;
}
else if (total > 1)
{
attribute = RT_LINK_LONG_DATA_FRAME;
}
do
{
send_frame = rt_malloc(sizeof(struct rt_link_frame));
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;
if (attribute == RT_LINK_LONG_DATA_FRAME)
{
send_frame->attribute = RT_LINK_LONG_DATA_FRAME;
if (offset + RT_LINK_MAX_DATA_LENGTH > size)
{
send_frame->data_len = size - offset;
}
else
{
send_frame->data_len = RT_LINK_MAX_DATA_LENGTH;
offset += RT_LINK_MAX_DATA_LENGTH;
}
rt_link_frame_extend_config(send_frame, RT_LINK_LONG_DATA_FRAME, size);
}
else
{
send_frame->attribute = RT_LINK_SHORT_DATA_FRAME;
send_frame->data_len = size;
}
/* append the frame on the tail of list */
LOG_D("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);
/* Notify the core thread to send packet */
rt_event_send(&rt_link_scb->event, RT_LINK_SEND_READY_EVENT);
if (service->timeout_tx != RT_WAITING_NO)
{
/* 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:
return send_len;
}
void rtlink_status(void)
{
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->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);
rt_kprintf("\trecv len=%d\n", rt_link_hw_recv_len(rt_link_scb->rx_buffer));
rt_tick_t state = 0;
rt_timer_control(&rt_link_scb->longframetimer, RT_TIMER_CTRL_GET_STATE, &state);
rt_kprintf("\tlong timer state=%d\n", state);
rt_timer_control(&rt_link_scb->sendtimer, RT_TIMER_CTRL_GET_STATE, &state);
rt_kprintf("\tsend timer state=%d\n", state);
rt_kprintf("\tevent set=0x%08x\n", rt_link_scb->event.set);
if (rt_link_scb->tx_data_slist.next)
{
rt_slist_t *data = RT_NULL;
rt_slist_for_each(data, &rt_link_scb->tx_data_slist)
{
rt_kprintf("\tsend data list: serv %u\t", ((struct rt_link_frame_head *)data)->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);
}
}
else
{
rt_kprintf("\tsend data list: NULL\n");
}
rt_uint8_t serv = RT_LINK_SERVICE_MAX - 1;
while (serv--)
{
rt_kprintf("\tservices [%d](0x%p)\n", serv, rt_link_scb->service[serv]);
}
}
else
{
rt_kprintf("status NULL, please check the initialization status!\n");
}
}
MSH_CMD_EXPORT(rtlink_status, Display RTLINK status);
/**
* rtlink deinit the interface
* */
rt_err_t rt_link_deinit(void)
{
rt_enter_critical();
rt_link_hw_deinit();
if (rt_link_scb)
{
rt_timer_detach(&rt_link_scb->longframetimer);
rt_timer_detach(&rt_link_scb->sendtimer);
rt_timer_detach(&rt_link_scb->recvtimer);
rt_event_detach(&rt_link_scb->event);
rt_free(rt_link_scb);
rt_link_scb = RT_NULL;
}
rt_thread_t thread = rt_thread_find(RT_LINK_THREAD_NAME);
if (thread)
{
rt_thread_delete(thread);
}
rt_exit_critical();
return RT_EOK;
}
MSH_CMD_EXPORT(rt_link_deinit, rt link deinit);
/**
* rtlink initializes the interface, usually automatically.
* @return int Function Execution Result
* */
int rt_link_init(void)
{
rt_err_t result = RT_EOK;
rt_thread_t thread = RT_NULL;
if (rt_link_scb != RT_NULL)
{
goto __exit;
}
rt_link_scb = rt_malloc(sizeof(struct rt_link_session));
if (rt_link_scb == RT_NULL)
{
result = -RT_ENOMEM;
goto __exit;
}
rt_memset(rt_link_scb, 0, sizeof(struct rt_link_session));
rt_event_init(&rt_link_scb->event, "rtlink", RT_IPC_FLAG_FIFO);
rt_event_control(&rt_link_scb->event, RT_IPC_CMD_RESET, RT_NULL);
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,
RT_NULL, 0, RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT);
rt_timer_init(&rt_link_scb->longframetimer, "rxl_time", rt_link_receive_long_frame_callback,
RT_NULL, 0, RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_PERIODIC);
rt_link_scb->rx_record.rx_seq = 255;
rt_slist_init(&rt_link_scb->tx_data_slist);
rt_link_scb->tx_seq = RT_LINK_INIT_FRAME_SEQENCE;
/* create rtlink core work thread */
thread = rt_thread_create(RT_LINK_THREAD_NAME,
rt_link_thread,
RT_NULL,
RT_LINK_THREAD_STACK_SIZE,
RT_LINK_THREAD_PRIORITY,
RT_LINK_THREAD_TICK);
if (thread == RT_NULL)
{
result = -RT_ENOMEM;
goto __exit;
}
rt_thread_startup(thread);
rt_link_scb->state = RT_LINK_INIT;
__exit:
if (result != RT_EOK)
{
LOG_E("rtlink init failed.");
rt_link_deinit();
}
else
{
LOG_I("rtlink init success(VER:%s).", RT_LINK_VER);
}
return result;
}
#ifdef RT_LINK_AUTO_INIT
INIT_ENV_EXPORT(rt_link_init);
#endif
MSH_CMD_EXPORT(rt_link_init, rt link init);
/**
* rtlink service attach
* @param service Registered service channel, struct rt_link_service
* @return Function Execution Result
* */
rt_err_t rt_link_service_attach(struct rt_link_service *serv)
{
RT_ASSERT(serv != RT_NULL);
if (serv->service >= RT_LINK_SERVICE_MAX)
{
LOG_W("Invalid parameter.");
return -RT_EINVAL;
}
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, struct rt_link_service
* @return rt_err_t Function Execution Result
* */
rt_err_t rt_link_service_detach(struct rt_link_service *serv)
{
RT_ASSERT(serv != RT_NULL);
if (serv->service >= RT_LINK_SERVICE_MAX)
{
LOG_W("Invalid parameter.");
return -RT_EINVAL;
}
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;
}