STM32

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

2019-12-23 18:38发布

站内问答 / STM32/STM8
16253 31 31
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;
}
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
31条回答
shangdawei
2019-12-26 05:28

POSIX优化实现


  1. #include <sys/mman.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>

  5. #define report_exceptional_condition() abort ()

  7. struct ring_buffer
  8. {
  9.   void * address;

  11.   unsigned long count_bytes;
  12.   unsigned long write_offset_bytes;
  13.   unsigned long read_offset_bytes;
  14. };

  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;

  24.   file_descriptor = mkstemp( path );
  25.   if ( file_descriptor < 0 )
  26.     report_exceptional_condition();

  28.   status = unlink( path );
  29.   if ( status )
  30.     report_exceptional_condition();

  32.   buffer->count_bytes = 1UL << order;
  33.   buffer->write_offset_bytes = 0;
  34.   buffer->read_offset_bytes = 0;

  36.   status = ftruncate( file_descriptor, buffer->count_bytes );
  37.   if ( status )
  38.     report_exceptional_condition();

  40.   buffer->address = mmap( NULL, buffer->count_bytes << 1, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE,  - 1, 0 );

  42.   if ( buffer->address == MAP_FAILED )
  43.     report_exceptional_condition();

  45.   address = mmap( buffer->address, buffer->count_bytes, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, file_descriptor,
  46.     0 );

  48.   if ( address != buffer->address )
  49.     report_exceptional_condition();

  51.   address = mmap( buffer->address + buffer->count_bytes, buffer->count_bytes, PROT_READ | PROT_WRITE, MAP_FIXED |
  52.     MAP_SHARED, file_descriptor, 0 );

  54.   if ( address != buffer->address + buffer->count_bytes )
  55.     report_exceptional_condition();

  57.   status = close( file_descriptor );
  58.   if ( status )
  59.     report_exceptional_condition();
  60. }

  62. void ring_buffer_free( struct ring_buffer * buffer )
  63. {
  64.   int status;

  66.   status = munmap( buffer->address, buffer->count_bytes << 1 );
  67.   if ( status )
  68.     report_exceptional_condition();
  69. }

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

  77. void ring_buffer_write_advance( struct ring_buffer * buffer, unsigned long count_bytes )
  78. {
  79.   buffer->write_offset_bytes += count_bytes;
  80. }

  82. void * ring_buffer_read_address( struct ring_buffer * buffer )
  83. {
  84.   return buffer->address + buffer->read_offset_bytes;
  85. }

  87. void ring_buffer_read_advance( struct ring_buffer * buffer, unsigned long count_bytes )
  88. {
  89.   buffer->read_offset_bytes += count_bytes;

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

  99. unsigned long ring_buffer_count_bytes( struct ring_buffer * buffer )
  100. {
  101.   return buffer->write_offset_bytes - buffer->read_offset_bytes;
  102. }

  104. unsigned long ring_buffer_count_free_bytes( struct ring_buffer * buffer )
  105. {
  106.   return buffer->count_bytes - ring_buffer_count_bytes( buffer );
  107. }

  109. void ring_buffer_clear( struct ring_buffer * buffer )
  110. {
  111.   buffer->write_offset_bytes = 0;
  112.   buffer->read_offset_bytes = 0;
  113. }

  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. */
复制代码

一周热门 更多>