bsp_US1_RX_int (u8 Data) 这一条是串口接收中断的时候调用,并把出带入。
bsp_US1_RX (u8 * Data) 这一条是取出缓冲区的数据
现在问题是这样的,是不是的数据会丢一两个位,并且丢了之后,以后收到的数据都会出现错位!
正确的应该是 0123456789 ,但错位后收到的数据 5012345678。
u16 bsp_US1_RX (u8 * Data)
{
short temp=0;
while(US1_RX_FIFO_user)
{
*Data++ = US1_RX_FIFO[US1_RX_FIFO_tail++];
if(US1_RX_FIFO_tail == US1_RX_FIFO_Siz)
US1_RX_FIFO_tail = 0;
US1_RX_FIFO_user--;
temp++;
}
return temp;
}
inline s8 bsp_US1_RX_int (u8 Data)
{
if(US1_RX_FIFO_Siz - US1_RX_FIFO_user -1 )
{
US1_RX_FIFO[US1_RX_FIFO_head++] = Data;
if(US1_RX_FIFO_head == US1_RX_FIFO_Siz)
US1_RX_FIFO_head = 0;
US1_RX_FIFO_user++;
}
else
{
return RXbuff_overflow;
}
return 0;
}
友情提示: 此问题已得到解决,问题已经关闭,关闭后问题禁止继续编辑,回答。
中断只写 main只读 需要强行上锁吗?
https://zh.wikipedia.org/wiki/%E ... 9%E8%A1%9D%E5%8D%80
Capture_0048.jpg (52.41 KB, 下载次数: 0)
下载附件
2016-8-16 18:55 上传
Linux内核的kfifo
在Linux内核文件kfifo.h和kfifo.c中,定义了一个先进先出圆形缓冲区实现。
如果只有一个读线程、一个写线程,二者没有共享的被修改的控制变量,那么可以证明这种情况下不需要并发控制。
kfifo就满足上述条件。
kfifo要求缓冲区长度必须为2的幂。
读、写指针分别是无符号整型变量。把读写指针变换为缓冲区内的索引值,仅需要“按位与”操作:
(指针值 按位与 (缓冲区长度-1))。这避免了计算代价高昂的“求余”操作。且下述关系总是成立:
读指针 + 缓冲区存储的数据长度 == 写指针
即使在写指针达到了无符号整型的上界,上溢出后写指针的值小于读指针的值,上述关系仍然保持成立(这是因为无符号整型加法的性质)。
kfifo的写操作,首先计算缓冲区中当前可写入存储空间的数据长度:
len = min{待写入数据长度, 缓冲区长度 - (写指针 - 读指针)}
然后,分两段写入数据。
第一段是从写指针开始向缓冲区末尾方向;
第二段是从缓冲区起始处写入余下的可写入数据,这部分可能数据长度为0即并无实际数据写入。
POSIX优化实现
- #include <sys/mman.h>
- #include <stdlib.h>
- #include <unistd.h>
- #define report_exceptional_condition() abort ()
- struct ring_buffer
- {
- void * address;
- unsigned long count_bytes;
- unsigned long write_offset_bytes;
- unsigned long read_offset_bytes;
- };
- //Warning order should be at least 12 for Linux
- void ring_buffer_create( struct ring_buffer * buffer, unsigned long order )
- {
- char path[ ] = "/dev/shm/ring-buffer-XXXXXX";
- int file_descriptor;
- void * address;
- int status;
- file_descriptor = mkstemp( path );
- if ( file_descriptor < 0 )
- report_exceptional_condition();
- status = unlink( path );
- if ( status )
- report_exceptional_condition();
- buffer->count_bytes = 1UL << order;
- buffer->write_offset_bytes = 0;
- buffer->read_offset_bytes = 0;
- status = ftruncate( file_descriptor, buffer->count_bytes );
- if ( status )
- report_exceptional_condition();
- buffer->address = mmap( NULL, buffer->count_bytes << 1, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, - 1, 0 );
- if ( buffer->address == MAP_FAILED )
- report_exceptional_condition();
- address = mmap( buffer->address, buffer->count_bytes, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, file_descriptor,
- 0 );
- if ( address != buffer->address )
- report_exceptional_condition();
- address = mmap( buffer->address + buffer->count_bytes, buffer->count_bytes, PROT_READ | PROT_WRITE, MAP_FIXED |
- MAP_SHARED, file_descriptor, 0 );
- if ( address != buffer->address + buffer->count_bytes )
- report_exceptional_condition();
- status = close( file_descriptor );
- if ( status )
- report_exceptional_condition();
- }
- void ring_buffer_free( struct ring_buffer * buffer )
- {
- int status;
- status = munmap( buffer->address, buffer->count_bytes << 1 );
- if ( status )
- report_exceptional_condition();
- }
- void * ring_buffer_write_address( struct ring_buffer * buffer )
- {
- /*** void pointer arithmetic is a constraint violation. ***/
- return buffer->address + buffer->write_offset_bytes;
- }
- void ring_buffer_write_advance( struct ring_buffer * buffer, unsigned long count_bytes )
- {
- buffer->write_offset_bytes += count_bytes;
- }
- void * ring_buffer_read_address( struct ring_buffer * buffer )
- {
- return buffer->address + buffer->read_offset_bytes;
- }
- void ring_buffer_read_advance( struct ring_buffer * buffer, unsigned long count_bytes )
- {
- buffer->read_offset_bytes += count_bytes;
- if ( buffer->read_offset_bytes >= buffer->count_bytes )
- {
- /*如果读指针大于等于缓冲区长度,那些读写指针同时折返回[0, buffer_size]范围内 */
- buffer->read_offset_bytes -= buffer->count_bytes;
- buffer->write_offset_bytes -= buffer->count_bytes;
- }
- }
- unsigned long ring_buffer_count_bytes( struct ring_buffer * buffer )
- {
- return buffer->write_offset_bytes - buffer->read_offset_bytes;
- }
- unsigned long ring_buffer_count_free_bytes( struct ring_buffer * buffer )
- {
- return buffer->count_bytes - ring_buffer_count_bytes( buffer );
- }
- void ring_buffer_clear( struct ring_buffer * buffer )
- {
- buffer->write_offset_bytes = 0;
- buffer->read_offset_bytes = 0;
- }
- /*
- * Note, that initial anonymous mmap() can be avoided - after initial mmap() for descriptor fd,
- * you can try mmap() with hinted address as (buffer->address + buffer->count_bytes)
- * and if it fails - another one with hinted address as (buffer->address - buffer->count_bytes).
- *
- * Make sure MAP_FIXED is not used in such case, as under certain situations it could end with segfault.
- * The advantage of such approach is, that it avoids requirement to map twice the amount
- * you need initially (especially useful e.g. if you want to use hugetlbfs and the allowed amount is limited)
- * and in context of gcc/glibc - you can avoid certain feature macros
- * (MAP_ANONYMOUS usually requires one of: _BSD_SOURCE, _SVID_SOURCE or _GNU_SOURCE).
- */
复制代码一周热门 更多>