LWRB and DMA Circular Receive

[Mysteo91]

Hello! Please tell me this implementation of interrupt handling is correctly?
serialReadingDone - function called from usart interrupt (IDLE_IT enabled, TC and HT are disabled)
It is correct to use lwrb_advance without lwrb_get_linear_block_write_address ?

void serialReadingDone(PortSerial serial, int size) {

        uint32_t realSize = 0;
        if (head< size)
        {
            realSize = size - head;
            head+= realSize;
        }
        else
        {
            realSize = HAR_SERIAL_INPUT_TRACER_BUF_LEN - head + size;
            head= HAR_SERIAL_INPUT_TRACER_BUF_LEN - head + size;
        }
        if (lwrb_advance(&tracerLwrb, realSize) != realSize )  /// check if lwrb overflowed 
        {
            serialReadingError(PORT_SERIAL_TRACER);
        }
}

[MaJerle]

I do not have enough information to give you a valuable feedback. The use of lwrb_advance may work if the full setup is correctly set.

[Mysteo91]

So, if DMA is configured correctly, interrupts IT, HT, IDLE are enabled, can we simply write data into the lvrb buffer by DMA and call lwrb_advance in the interrupt without using the lwrb_linear block functions?
I want to implement that DMA writes to the lwrb buffer. And get data using getDataFromLWRB

lwrb_t uartRxLwrb ;
uint8_t uartRxBuffer[UART_RX_BUFFER_SIZE];

void lwrb_rx_overflow() {
  HAL_UART_Abort(&huart1);
  lwrb_reset(&uartRxLwrb);
  HAL_UARTEx_ReceiveToIdle_DMA(&huart1, uartRxBuffer, UART_RX_BUFFER_SIZE);
}


void __attribute__((optimize("O0"))) HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {

  uint8_t* pnt = lwrb_get_linear_block_write_address(&uartRxLwrb);
  uint16_t realSize = 0;
  uint16_t offset = pnt - &uartRxBuffer[0];
  realSize = Size - offset;

  if (lwrb_advance(&uartRxLwrb, realSize) != realSize) {
    lwrb_rx_overflow();
  }

}

void getDataFromLWRB(uint8_t* data, uint32_t size)
{
  uint32_t bytesReady = lwrb_get_full(&uartRxLwrb) ;
  if ( bytesReady  > 0 )
  {
    lwrb_read(&uartRxLwrb, data, size);
  }
}

int main (void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPDMA1_Init();
  MX_USART1_UART_Init();
  lwrb_init(&uartRxLwrb, uartRxBuffer, UART_RX_BUFFER_SIZE);
  HAL_UARTEx_ReceiveToIdle_DMA(&huart1, uartRxBuffer, UART_RX_BUFFER_SIZE);
  while (1) {
      process_1();
      process_2();
      process_3();
  }
}

[MaJerle]

At first glance it looks OK to me (but I didn't go into details on the full config). The only point I see problematic is the function getDataFromLWRB because as a return, you don't kno how much data you will really get out.

And you should not check for the full check before you read. You should perform the read directly and check the return of the function.

void getDataFromLWRB(uint8_t* data, uint32_t size)
{
  uint32_t bytesRead = lwrb_read(&uartRxLwrb, data, size);
  if ( bytesRead > 0 )
  {
    //Function read bytesRead bytes
  }
}

It is the same story as why you should never use the feof function for file operations.
https://stackoverflow.com/questions/5431941/why-is-while-feoffile-always-wrong

[Mysteo91]

And you should not check for the full check before you read. You should perform the read directly and check the return of the function

Thank you for help. That's exactly how it's done in my project.

the code is posted above I wrote from my memory