写了一个串口接收的 FIFO ，一直都看不出有什么问题！

188089942

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;
}

youkebing

没加锁啊

yyliu

学习学习

188089942

youkebing 发表于 2016-8-15 16:43
没加锁啊

是什么意思呢？

我怎么看 逻辑都没有错的呀！

ycping

路过帮顶。

t3486784401

中断和主程序可以认为是两个线程，访问公用的数据（临界区）时，需要通过加锁来确保原子操作。否则数据可能不正确加载

yyliu

t3486784401 发表于 2016-8-15 17:21
中断和主程序可以认为是两个线程，访问公用的数据（临界区）时，需要通过加锁来确保原子操作。否则数据可能 ...

他们操作的只是同一个数组，但不是同一个数据啊~~

liufabing

同一个数组不就是同一个数据么.
可能会存在读的时间,中断里又修改了(你不确定中断什么时候发生).

t3486784401

yyliu 发表于 2016-8-15 17:23
他们操作的只是同一个数组，但不是同一个数据啊~~

随便看看 US1_RX_FIFO_user 就公用了，类似还会有  siz 那个，一个访问到一半被另一个中断改掉了，就是这么样

pazulin

这个有bug的，明显US1_RX_FIFO_user 这个变量就是冲突所在，根本不需要这个变量。head和tail的差值就cnt，看看linux的kfifo

shangdawei

linux内核数据结构之kfifo

http://www.cnblogs.com/Anker/p/3481373.html



环形缓冲区的详细介绍及实现方法可以参考http://en.wikipedia.org/wiki/Circular_buffer，介绍的非常详细，列举了实现环形队列的几种方法。

环形队列的不便之处在于如何判断队列是空还是满。维基百科上给三种实现方法。

188089942

shangdawei 发表于 2016-8-16 02:04
linux内核数据结构之kfifo

http://www.cnblogs.com/Anker/p/3481373.html

非常感谢

AlertTao

我好像遇到类似问题：先将引脚配置为USART功能，再初始化USART，顺序问题。
楼主试一下。

AlertTao

shangdawei 发表于 2016-8-16 02:04
linux内核数据结构之kfifo

http://www.cnblogs.com/Anker/p/3481373.html

非常感谢提供这个资源，我要好好看一下

unnormal

学习了  谢谢分享

188089942

pazulin 发表于 2016-8-15 22:48
这个有bug的，明显US1_RX_FIFO_user 这个变量就是冲突所在，根本不需要这个变量。head和tail的差值就cnt， ...

我之前也写过，不用user 变量的，就是直接从in out 指针得出，用了一段时间，挺好的没有什么问题。
用串口波特率460800 压力测试也没有问题。
但是总感觉效率不是最高的，每次查询user 的时候都要运行加减操作，这样速度就变低了！
我用 user 变量的目的是“用内存换速度” ！

188089942

t3486784401 发表于 2016-8-15 17:21
中断和主程序可以认为是两个线程，访问公用的数据（临界区）时，需要通过加锁来确保原子操作。否则数据可能 ...

我这个是跑裸机的，没有什么锁的怎么办呢？

188089942

AlertTao 发表于 2016-8-16 08:49
我好像遇到类似问题：先将引脚配置为USART功能，再初始化USART，顺序问题。
楼主试一下。 ...

我感觉不会，我感觉是程序的问题

sblpp

shangdawei 发表于 2016-8-16 02:04
linux内核数据结构之kfifo

http://www.cnblogs.com/Anker/p/3481373.html

牛X，学习了。

迈锐数据

t3486784401 发表于 2016-8-15 17:21
中断和主程序可以认为是两个线程，访问公用的数据（临界区）时，需要通过加锁来确保原子操作。否则数据可能 ...

  中断只写   main只读     需要强行上锁吗？

shangdawei

区分缓冲区满或者空 -- 镜像指示位

缓冲区的长度如果是n，逻辑地址空间则为0至n-1；那么，规定n至2n-1为镜像逻辑地址空间。

本策略规定读写指针的地址空间为0至2n-1，其中低半部分对应于常规的逻辑地址空间，高半部分对应于镜像逻辑地址空间。

当指针值大于等于2n时，使其折返（wrapped）到ptr-2n。

使用一位表示写指针或读指针是否进入了虚拟的镜像存储区：置位表示进入，不置位表示没进入还在基本存储区。


在读写指针的值相同情况下，如果二者的指示位相同，说明缓冲区为空；

如果二者的指示位不同，说明缓冲区为满。

这种方法优点是测试缓冲区满/空很简单；

不需要做取余数操作；读写线程可以分别设计专用算法策略，能实现精致的并发控制。
缺点是读写指针各需要额外的一位作为指示位。


如果缓冲区长度是2的幂，则本方法可以省略镜像指示位。
如果读写指针的值相等，则缓冲区为空；如果读写指针相差n，则缓冲区为满，这可以用条件表达式（写指针 == (读指针 异或 缓冲区长度)）来判断。

1. /* This approach adds one bit to end and start pointers */
   
2. 
   
3. /* Circular buffer object */
   
4. typedef struct {
   
5.     int         size;   /* maximum number of elements           */
   
6.     int         start;  /* index of oldest element              */
   
7.     int         end;    /* index at which to write new element  */
   
8.     ElemType   *elems;  /* vector of elements                   */
   
9. } CircularBuffer;
   
10. 
    
11. void cbInit(CircularBuffer *cb, int size) {
    
12.     cb->size  = size;
    
13.     cb->start = 0;
    
14.     cb->end   = 0;
    
15.     cb->elems = (ElemType *)calloc(cb->size, sizeof(ElemType));
    
16. }
    
17. 
    
18. void cbPrint(CircularBuffer *cb) {
    
19.     printf("size=0x%x, start=%d, end=%d\n", cb->size, cb->start, cb->end);
    
20. }
    
21. 
    
22. int cbIsFull(CircularBuffer *cb) {
    
23.     return cb->end == (cb->start ^ cb->size); /* This inverts the most significant bit of start before comparison */ }
    
24. 
    
25. int cbIsEmpty(CircularBuffer *cb) {
    
26.     return cb->end == cb->start; }
    
27. 
    
28. int cbIncr(CircularBuffer *cb, int p) {
    
29.     return (p + 1)&(2*cb->size-1); /* start and end pointers incrementation is done modulo 2*size */
    
30. }
    
31. 
    
32. void cbWrite(CircularBuffer *cb, ElemType *elem) {
    
33.     cb->elems[cb->end&(cb->size-1)] = *elem;
    
34.     if (cbIsFull(cb)) /* full, overwrite moves start pointer */
    
35.         cb->start = cbIncr(cb, cb->start);
    
36.     cb->end = cbIncr(cb, cb->end);
    
37. }
    
38. 
    
39. void cbRead(CircularBuffer *cb, ElemType *elem) {
    
40.     *elem = cb->elems[cb->start&(cb->size-1)];
    
41.     cb->start = cbIncr(cb, cb->start);
    
42. }

复制代码

shangdawei

环形缓冲器

https://zh.wikipedia.org/wiki/%E ... 9%E8%A1%9D%E5%8D%80



Linux内核的kfifo

在Linux内核文件kfifo.h和kfifo.c中，定义了一个先进先出圆形缓冲区实现。

如果只有一个读线程、一个写线程，二者没有共享的被修改的控制变量，那么可以证明这种情况下不需要并发控制。

kfifo就满足上述条件。

kfifo要求缓冲区长度必须为2的幂。

读、写指针分别是无符号整型变量。把读写指针变换为缓冲区内的索引值，仅需要“按位与”操作：
（指针值 按位与 （缓冲区长度-1））。这避免了计算代价高昂的“求余”操作。且下述关系总是成立：

读指针 + 缓冲区存储的数据长度 == 写指针

即使在写指针达到了无符号整型的上界，上溢出后写指针的值小于读指针的值，上述关系仍然保持成立（这是因为无符号整型加法的性质）。
kfifo的写操作，首先计算缓冲区中当前可写入存储空间的数据长度：

len = min{待写入数据长度, 缓冲区长度 - （写指针 - 读指针）}

然后，分两段写入数据。

第一段是从写指针开始向缓冲区末尾方向；
第二段是从缓冲区起始处写入余下的可写入数据，这部分可能数据长度为0即并无实际数据写入。

shangdawei

POSIX优化实现

1. #include <sys/mman.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. 
   
5. #define report_exceptional_condition() abort ()
   
6. 
   
7. struct ring_buffer
   
8. {
   
9.   void * address;
   
10. 
    
11.   unsigned long count_bytes;
    
12.   unsigned long write_offset_bytes;
    
13.   unsigned long read_offset_bytes;
    
14. };
    
15. 
    
16. //Warning order should be at least 12 for Linux
    
17. void ring_buffer_create( struct ring_buffer * buffer, unsigned long order )
    
18. {
    
19.   char path[ ] = "/dev/shm/ring-buffer-XXXXXX";
    
20.   int file_descriptor;
    
21.   void * address;
    
22.   int status;
    
23. 
    
24.   file_descriptor = mkstemp( path );
    
25.   if ( file_descriptor < 0 )
    
26.     report_exceptional_condition();
    
27. 
    
28.   status = unlink( path );
    
29.   if ( status )
    
30.     report_exceptional_condition();
    
31. 
    
32.   buffer->count_bytes = 1UL << order;
    
33.   buffer->write_offset_bytes = 0;
    
34.   buffer->read_offset_bytes = 0;
    
35. 
    
36.   status = ftruncate( file_descriptor, buffer->count_bytes );
    
37.   if ( status )
    
38.     report_exceptional_condition();
    
39. 
    
40.   buffer->address = mmap( NULL, buffer->count_bytes << 1, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE,  - 1, 0 );
    
41. 
    
42.   if ( buffer->address == MAP_FAILED )
    
43.     report_exceptional_condition();
    
44. 
    
45.   address = mmap( buffer->address, buffer->count_bytes, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, file_descriptor,
    
46.     0 );
    
47. 
    
48.   if ( address != buffer->address )
    
49.     report_exceptional_condition();
    
50. 
    
51.   address = mmap( buffer->address + buffer->count_bytes, buffer->count_bytes, PROT_READ | PROT_WRITE, MAP_FIXED |
    
52.     MAP_SHARED, file_descriptor, 0 );
    
53. 
    
54.   if ( address != buffer->address + buffer->count_bytes )
    
55.     report_exceptional_condition();
    
56. 
    
57.   status = close( file_descriptor );
    
58.   if ( status )
    
59.     report_exceptional_condition();
    
60. }
    
61. 
    
62. void ring_buffer_free( struct ring_buffer * buffer )
    
63. {
    
64.   int status;
    
65. 
    
66.   status = munmap( buffer->address, buffer->count_bytes << 1 );
    
67.   if ( status )
    
68.     report_exceptional_condition();
    
69. }
    
70. 
    
71. void * ring_buffer_write_address( struct ring_buffer * buffer )
    
72. {
    
73.   /*** void pointer arithmetic is a constraint violation. ***/
    
74.   return buffer->address + buffer->write_offset_bytes;
    
75. }
    
76. 
    
77. void ring_buffer_write_advance( struct ring_buffer * buffer, unsigned long count_bytes )
    
78. {
    
79.   buffer->write_offset_bytes += count_bytes;
    
80. }
    
81. 
    
82. void * ring_buffer_read_address( struct ring_buffer * buffer )
    
83. {
    
84.   return buffer->address + buffer->read_offset_bytes;
    
85. }
    
86. 
    
87. void ring_buffer_read_advance( struct ring_buffer * buffer, unsigned long count_bytes )
    
88. {
    
89.   buffer->read_offset_bytes += count_bytes;
    
90. 
    
91.   if ( buffer->read_offset_bytes >= buffer->count_bytes )
    
92.   {
    
93.      /*如果读指针大于等于缓冲区长度，那些读写指针同时折返回[0, buffer_size]范围内  */
    
94.     buffer->read_offset_bytes -= buffer->count_bytes;
    
95.     buffer->write_offset_bytes -= buffer->count_bytes;
    
96.   }
    
97. }
    
98. 
    
99. unsigned long ring_buffer_count_bytes( struct ring_buffer * buffer )
    
100. {
     
101.   return buffer->write_offset_bytes - buffer->read_offset_bytes;
     
102. }
     
103. 
     
104. unsigned long ring_buffer_count_free_bytes( struct ring_buffer * buffer )
     
105. {
     
106.   return buffer->count_bytes - ring_buffer_count_bytes( buffer );
     
107. }
     
108. 
     
109. void ring_buffer_clear( struct ring_buffer * buffer )
     
110. {
     
111.   buffer->write_offset_bytes = 0;
     
112.   buffer->read_offset_bytes = 0;
     
113. }
     
114. 
     
115. /*
     
116. * Note, that initial anonymous mmap() can be avoided - after initial mmap() for descriptor fd,
     
117. * you can try mmap() with hinted address as (buffer->address + buffer->count_bytes)
     
118. * and if it fails - another one with hinted address as (buffer->address - buffer->count_bytes).
     
119. *
     
120. * Make sure MAP_FIXED is not used in such case, as under certain situations it could end with segfault.
     
121. * The advantage of such approach is, that it avoids requirement to map twice the amount
     
122. * you need initially (especially useful e.g. if you want to use hugetlbfs and the allowed amount is limited)
     
123. * and in context of gcc/glibc - you can avoid certain feature macros
     
124. * (MAP_ANONYMOUS usually requires one of: _BSD_SOURCE, _SVID_SOURCE or _GNU_SOURCE).
     
125. */
     

复制代码

huangqi412

我是只能写n-1个免得判断相等时候是空还是满 为了一个元素多费功夫

yy8047

感觉那个US1_RX_FIFO_user用得太乱了，我都是一个IP只管往里写，一个IP只管往外读，如果写到IP重合那就溢出丢数据了，只要两个IP不等则有数据缓存

circle_head

shangdawei 发表于 2016-8-16 02:04
linux内核数据结构之kfifo

http://www.cnblogs.com/Anker/p/3481373.html

这个解释真是漂亮啊，很形象啊

holdkcsxym

学了几招，感谢各位分享

dso_2012

US1_RX_FIFO_user   确实不能用，我之前这样用过，程序长时间跑就会丢数据，后面只判断 head tail 就OK了

rube

我的，简单易懂：
#define UART0_FIFO_SIZE        12
typedef struct  
{
        volatile uint8 in;
        volatile uint8 out;
        uint8 fifo[UART0_FIFO_SIZE];
}UART_FIFO;                                       

UART_FIFO uart0;

void uart0_fifopush(int8 dat)
{
          uart0.fifo[uart0.in] = dat;
          if (uart0.in < (UART0_FIFO_SIZE - 1)) uart0.in++;        //判断队列是否已满
          else uart0.in = 0;        //队列满，覆盖头部
}
int8 uart0_fifopop(void)
{
            int8 tmp = uart0.fifo[uart0.out];
        if (uart0.out < (UART0_FIFO_SIZE - 1)) uart0.out++;
        else uart0.out = 0;
        return tmp;
       
}

yanyanyan168

rube 发表于 2016-10-9 09:46
我的，简单易懂：
#define UART0_FIFO_SIZE        12
typedef struct  

好的，谢谢

su33691

学习了，顶一下。