Odtnhj

I'm looking at the following code from STMicroelectronics on implementing USART communication with interrupts

#include <stm32f10x_lib.h> // STM32F10x Library Definitions
#include <stdio.h>
#include "STM32_Init.h" // STM32 Initialization


/*----------------------------------------------------------------------------
 Notes:
 The length of the receive and transmit buffers must be a power of 2.
 Each buffer has a next_in and a next_out index.
 If next_in = next_out, the buffer is empty.
 (next_in - next_out) % buffer_size = the number of characters in the buffer.
 *----------------------------------------------------------------------------*/
#define TBUF_SIZE 256 /*** Must be a power of 2 (2,4,8,16,32,64,128,256,512,...) ***/
#define RBUF_SIZE 256 /*** Must be a power of 2 (2,4,8,16,32,64,128,256,512,...) ***/

/*----------------------------------------------------------------------------
 *----------------------------------------------------------------------------*/
#if TBUF_SIZE < 2
#error TBUF_SIZE is too small. It must be larger than 1.
#elif ((TBUF_SIZE & (TBUF_SIZE-1)) != 0)
#error TBUF_SIZE must be a power of 2.
#endif

#if RBUF_SIZE < 2
#error RBUF_SIZE is too small. It must be larger than 1.
#elif ((RBUF_SIZE & (RBUF_SIZE-1)) != 0)
#error RBUF_SIZE must be a power of 2.
#endif

/*----------------------------------------------------------------------------
 *----------------------------------------------------------------------------*/
struct buf_st 
 unsigned int in; // Next In Index
 unsigned int out; // Next Out Index
 char buf [RBUF_SIZE]; // Buffer
;

static struct buf_st rbuf = 0, 0, ;
#define SIO_RBUFLEN ((unsigned short)(rbuf.in - rbuf.out))

static struct buf_st tbuf = 0, 0, ;
#define SIO_TBUFLEN ((unsigned short)(tbuf.in - tbuf.out))

static unsigned int tx_restart = 1; // NZ if TX restart is required

/*----------------------------------------------------------------------------
 USART1_IRQHandler
 Handles USART1 global interrupt request.
 *----------------------------------------------------------------------------*/
void USART1_IRQHandler (void) 
 volatile unsigned int IIR;
 struct buf_st *p;

 IIR = USART1->SR;
 if (IIR & USART_FLAG_RXNE) // read interrupt
 USART1->SR &= ~USART_FLAG_RXNE; // clear interrupt

 p = &rbuf;

 if (((p->in - p->out) & ~(RBUF_SIZE-1)) == 0) 
 p->buf [p->in & (RBUF_SIZE-1)] = (USART1->DR & 0x1FF);
 p->in++;
 
 

 if (IIR & USART_FLAG_TXE) 
 USART1->SR &= ~USART_FLAG_TXE; // clear interrupt

 p = &tbuf;

 if (p->in != p->out) 
 USART1->DR = (p->buf [p->out & (TBUF_SIZE-1)] & 0x1FF);
 p->out++;
 tx_restart = 0;
 
 else 
 tx_restart = 1;
 USART1->CR1 &= ~USART_FLAG_TXE; // disable TX interrupt if nothing to send

 
 


/*------------------------------------------------------------------------------
 buffer_Init
 initialize the buffers
 *------------------------------------------------------------------------------*/
void buffer_Init (void) 

 tbuf.in = 0; // Clear com buffer indexes
 tbuf.out = 0;
 tx_restart = 1;

 rbuf.in = 0;
 rbuf.out = 0;


/*------------------------------------------------------------------------------
 SenChar
 transmit a character
 *------------------------------------------------------------------------------*/
int SendChar (int c) 
 struct buf_st *p = &tbuf;

 // If the buffer is full, return an error value
 if (SIO_TBUFLEN >= TBUF_SIZE)
 return (-1);

 p->buf [p->in & (TBUF_SIZE - 1)] = c; // Add data to the transmit buffer.
 p->in++;

 if (tx_restart) = USART_FLAG_TXE; // enable TX interrupt
 

 return (0);


/*------------------------------------------------------------------------------
 GetKey
 receive a character
 *------------------------------------------------------------------------------*/
int GetKey (void) 
 struct buf_st *p = &rbuf;

 if (SIO_RBUFLEN == 0)
 return (-1);

 return (p->buf [(p->out++) & (RBUF_SIZE - 1)]);



/*----------------------------------------------------------------------------
 MAIN function
 *----------------------------------------------------------------------------*/
int main (void) 

 buffer_Init(); // init RX / TX buffers
 stm32_Init (); // STM32 setup

 printf ("Interrupt driven Serial I/O Examplernrn");

 while (1) // Loop forever
 unsigned char c;

 printf ("Press a key. ");
 c = getchar ();
 printf ("rn");
 printf ("You pressed '%c'.rnrn", c);
 // end while
 // end main

My questions are the following:

1. In the handler function, when does the statement ((p->in - p->out) & ~(RBUF_SIZE-1)) ever evaluate to a value other than zero? If RBUF_SIZE is a power of 2 as indicated, then ~(RBUF_SIZE-1) should always be zero. Is it checking if p->in > p->out? Even if this isn't true, the conditional should evaluate to zero anyway, right?


2. In the line following, the statement p->buf [p->in & (RBUF_SIZE-1)] = (USART1->DR & 0x1FF); is made. Why does the code AND p->in with RBUF_SIZE-1?


3. What kind of buffer are we using in this code? FIFO?

1. Not so. For example, assuming 32-bit arithmetic, if RBUF_SIZE == 0x00000100 then RBUF_SIZE-1 == 0x000000FF and ~(RBUF_SIZE-1) == 0xFFFFFF00 (it's a bitwise NOT, not a logical NOT). The check you refer to is therefore effectively the same as (p->in - p->out) < RBUF_SIZE, and it's not clear why it is superior. ARM GCC 7.2.1 produces identical length code for the two (-O1).




2. p->in & (RBUF_SIZE-1) is the same as p->in % RBUF_SIZE when p->in is unsigned. Again, not sure why the former would be used when the latter is clearer; sure, it effectively forces the compiler to compute the modulo using an AND operation, but given that RBUF_SIZE is known at compile time to be a power of two my guess is that most compilers could figure this out (again, ARM GCC 7.2.1 certainly can, I've just tried it - it produces the same instructions either way).




3. Looks like it. FIFO implemented as a circular buffer.