RT-Thread SPARK CAN的通信内核详解
CAN发送
1.rt_device_write
rt_size_t rt_device_write(rt_device_t dev,
rt_off_t pos,
const void buffer,
rt_size_t size)
{
/ parameter check /
RT_ASSERT(dev != RT_NULL);
RT_ASSERT(rt_object_get_type(&dev->parent) == RT_Object_Class_Device);
if (dev->ref_count == 0)
{
rt_set_errno(-RT_ERROR);
return 0;
}
/ call device_write interface /
if (device_write != RT_NULL)
{
// rt_kprintf("device_write:%dn",device_write(dev, pos, buffer, size));
return device_write(dev, pos, buffer, size);
}
/ set error code */
rt_set_errno(-RT_ENOSYS);
return 0;
}
其实挺一目了然的，就是调用device的device_write接口
2.device_write
#define device_write (dev->write)
dev->write = rt_pipe_write;
还挺能藏
3.rt_pipe_write
static rt_size_t rt_pipe_write(rt_device_t device, rt_off_t pos, const void *buffer, rt_size_t count)
{
uint8_t *pbuf;
rt_size_t write_bytes = 0;
rt_pipe_t *pipe = (rt_pipe_t *)device;
if (device == RT_NULL)
{
rt_set_errno(EINVAL);
return 0;
}
if (count == 0) return 0;
pbuf = (uint8_t *)buffer;
rt_mutex_take(&pipe->lock, -1);
while (write_bytes < count)
{
int len = rt_ringbuffer_put(pipe->fifo, &pbuf[write_bytes], count - write_bytes);
if (len <= 0) break;
write_bytes += len;
}
rt_mutex_release(&pipe->lock);
return write_bytes;
}
函数接受四个参数 device、pos、buffer 和 count，分别表示设备指针、写入位置（未使用）、数据缓冲区指针和要写入的数据字节数。
将数据缓冲区指针 buffer 强制转换为 uint8_t 类型的指针，方便按字节操作数据。
使用互斥锁 pipe->lock 来保护管道操作的原子性，通过调用 rt_mutex_take 函数获取互斥锁。
进入循环，不断写入数据到管道，直到写入的字节数达到指定的 count。
调用 rt_ringbuffer_put 函数将数据写入管道的环形缓冲区（pipe->fifo）。该函数返回实际写入的字节数 len。
如果 len 小于等于 0，说明无法继续写入数据到管道，跳出循环。
释放互斥锁，通过调用 rt_mutex_release 函数释放互斥锁。
返回已写入的字节数 write_bytes。
4.rt_ringbuffer_put
rt_ringbuffer是啥？
/* ring buffer */
struct rt_ringbuffer
{
rt_uint8_t buffer_ptr;
/ use the msb of the {read,write}_index as mirror bit. You can see this as
- if the buffer adds a virtual mirror and the pointers point either to the
- normal or to the mirrored buffer. If the write_index has the same value
- with the read_index, but in a different mirror, the buffer is full.
- While if the write_index and the read_index are the same and within the
- same mirror, the buffer is empty. The ASCII art of the ringbuffer is:
mirror = 0 mirror = 1- +---+---+---+---+---+---+---+|+
++++++~~~+ - | 0 | 1 | 2 | 3 | 4 | 5 | 6 ||| 0 | 1 | 2 | 3 | 4 | 5 | 6 | Full
- +---+---+---+---+---+---+---+|+
++++++~~~+ - read_idx-^ write_idx-^
- +---+---+---+---+---+---+---+|+
++++++~~~+ - | 0 | 1 | 2 | 3 | 4 | 5 | 6 ||| 0 | 1 | 2 | 3 | 4 | 5 | 6 | Empty
- +---+---+---+---+---+---+---+|+
++++++~~~+ - read_idx-^ ^-write_idx
- The tradeoff is we could only use 32KiB of buffer for 16 bit of index.
- But it should be enough for most of the cases.
- Ref: http://en.wikipedia.org/wiki/Circular_buffer#Mirroring /
rt_uint16_t read_mirror : 1;
rt_uint16_t read_index : 15;
rt_uint16_t write_mirror : 1;
rt_uint16_t write_index : 15;
/ as we use msb of index as mirror bit, the size should be signed and - could only be positive. */
rt_int16_t buffer_size;
};
enum rt_ringbuffer_state
{
RT_RINGBUFFER_EMPTY, //环形缓冲区空
RT_RINGBUFFER_FULL, //环形缓冲区满
RT_RINGBUFFER_HALFFULL, //环形缓冲区半满
};
定义
环形缓冲区是嵌入式系统中十分重要的一种数据结构，比如在串口处理中，串口中断接收数据直接往环形缓冲区丢数据，而应用可以从环形缓冲区取数据进行处理，这样数据在读取和写入的时候都可以在这个缓冲区里循环进行，程序员可以根据自己需要的数据大小来决定自己使用的缓冲区大小。
特点
使用读取索引和写入索引的高位作为镜像位，通过镜像位的不同来表示缓冲区的状态。
当读取索引和写入索引的值相同时，但镜像位不同时，表示缓冲区已满。read_index==write_index&&
当读取索引和写入索引的值相同时，并且镜像位也相同时，表示缓冲区为空。
使用环形缓冲区的好处是当一个元素被消费时，不需要移动其他元素，因为新的元素可以直接写入到最后一个位置上，实现了一种先进先出（FIFO）的数据结构。这在很多应用中非常有用。
回到实际代码
rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb,
const rt_uint8_t ptr,
rt_uint16_t length)
{
rt_uint16_t size;
RT_ASSERT(rb != RT_NULL);
/ whether has enough space /
size = rt_ringbuffer_space_len(rb);
/ no space /
if (size == 0)
return 0;
/ drop some data /
if (size < length)
length = size;
if (rb->buffer_size - rb->write_index > length)
{
/ read_index - write_index = empty space /
rt_memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
/ this should not cause overflow because there is enough space for
length of data in current mirror /
rb->write_index += length;
return length;
}
rt_memcpy(&rb->buffer_ptr[rb->write_index],
&ptr[0],
rb->buffer_size - rb->write_index);
rt_memcpy(&rb->buffer_ptr[0],
&ptr[rb->buffer_size - rb->write_index],
length - (rb->buffer_size - rb->write_index));
/ we are going into the other side of the mirror */
rb->write_mirror = ~rb->write_mirror;
rb->write_index = length - (rb->buffer_size - rb->write_index);
return length;
}
该函数的目的是向环形缓冲区中写入数据，根据当前写指针的位置和可用空间的大小，判断数据是否可以连续写入当前镜像，如果不能，则跨越镜像边界继续写入。函数返回实际写入的数据长度
5.存放数据的管道结构体
/**
Pipe Device
/
struct rt_pipe_device
{
struct rt_device parent;
rt_bool_t is_named;
/ ring buffer in pipe device */
struct rt_ringbuffer *fifo;
rt_uint16_t bufsz;
rt_uint8_t readers;
rt_uint8_t writers;
rt_wqueue_t reader_queue;
rt_wqueue_t writer_queue;
struct rt_mutex lock;
};
typedef struct rt_pipe_device rt_pipe_t;
rt_pipe_write函数把我们的device指针强转为管道device
在它的fifo数据缓冲区中存储数据
CAN接收
前面和上面差不多，直接跳到pipe层
rt_pipe_read
static rt_size_t rt_pipe_read(rt_device_t device, rt_off_t pos, void *buffer, rt_size_t count)
{
uint8_t *pbuf;
rt_size_t read_bytes = 0;
rt_pipe_t *pipe = (rt_pipe_t *)device;
if (device == RT_NULL)
{
rt_set_errno(EINVAL);
return 0;
}
if (count == 0) return 0;
pbuf = (uint8_t *)buffer;
rt_mutex_take(&(pipe->lock), RT_WAITING_FOREVER);
while (read_bytes < count)
{
int len = rt_ringbuffer_get(pipe->fifo, &pbuf[read_bytes], count - read_bytes);
if (len <= 0) break;
read_bytes += len;
}
rt_mutex_release(&pipe->lock);
return read_bytes;
}
调用 rt_ringbuffer_get 函数从管道的环形缓冲区中读取数据到缓冲区中，返回实际读取的字节数。将读取的数据追加到 pbuf 中，并更新已读取字节数。
rt_ringbuffer_get
/**
@brief Get data from the ring buffer.
@param rb A pointer to the ring buffer.
@param ptr A pointer to the data buffer.
@param length The size of the data we want to read from the ring buffer.
@return Return the data size we read from the ring buffer.
*/
rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb,
rt_uint8_t ptr,
rt_uint16_t length)
{
rt_size_t size;
RT_ASSERT(rb != RT_NULL);
/ whether has enough data /
size = rt_ringbuffer_data_len(rb);
/ no data /
if (size == 0)
return 0;
/ less data /
if (size < length)
length = size;
if (rb->buffer_size - rb->read_index > length)
{
/ copy all of data /
rt_memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
/ this should not cause overflow because there is enough space for
length of data in current mirror /
rb->read_index += length;
return length;
}
rt_memcpy(&ptr[0],
&rb->buffer_ptr[rb->read_index],
rb->buffer_size - rb->read_index);
rt_memcpy(&ptr[rb->buffer_size - rb->read_index],
&rb->buffer_ptr[0],
length - (rb->buffer_size - rb->read_index));
/ we are going into the other side of the mirror */
rb->read_mirror = ~rb->read_mirror;
rb->read_index = length - (rb->buffer_size - rb->read_index);
return length;
}
首先通过调用 rt_ringbuffer_data_len(rb) 函数获取当前环形缓冲区中的数据大小。
如果数据大小为0，则表示缓冲区中没有数据可读，直接返回0。
如果数据大小小于要读取的长度 length，则将要读取的长度修改为数据大小，避免越界访问。
判断从当前读取索引位置开始，到缓冲区末尾的数据是否足够读取 length 大小的数据。如果足够，则直接将数据复制到指定的数据缓冲区 ptr 中，并更新读取索引。
如果从当前读取索引位置开始，到缓冲区末尾的数据不足以满足读取 length 大小的数据，则先将缓冲区末尾的数据复制到 ptr 中，然后将剩余长度的数据从缓冲区开头复制到 ptr 的剩余空间中。
更新读取索引，将其设置为剩余数据的起始位置，并且切换读取索引的镜像位，以便正确读取数据。
综上所述
SPARK的can例程看似并不涉及通俗意义的can协议，只是把一段数据层层调用接口，最终写入一个can设备的pipe强转类型的rt_ringbuffer环形缓冲区种，然后再由要读的设备从那里读出来。比如说can0想要向can1写数据，那么就会直接把数据写在can1的环形缓存区中。
-
CAN通信
+关注
关注
5文章
93浏览量
17829 -
FIFO存储
+关注
关注
0文章
103浏览量
5968 -
串口中断
+关注
关注
0文章
64浏览量
13882 -
RT-Thread
+关注
关注
31文章
1285浏览量
40081 -
环形缓冲
+关注
关注
0文章
3浏览量
1507
发布评论请先 登录
相关推荐
RT-Thread上CAN实践
RT-Thread记录（二、RT-Thread内核启动流程）
RT-Thread 内核学习笔记 - 理解defunct僵尸线程
RT-Thread 内核学习笔记 - 设备模型rt_device的理解
RT-Thread 内核学习笔记 - 内核对象链表结构深入理解
RT-Thread 内核学习笔记 - 内核对象初始化链表组织方式
RT-Thread 内核学习笔记 - 内核对象操作API
大佬带你理解RT-Thread内核并上手实践
基于rt-thread的socket通信设计
工商网监
评论