Use code formatting as it makes it easier to read code
You say "And have stopped and restarted my HAL_UART_Receive_IT()" but I don't see it in your code you've posted. So if HAL returns HAL_BUSY when you call HAL_UARTEx_ReceiveToIdle_DMA, then the interrupts is not enabled and you'll never get an interrupt on any new data received.
What you should do is set a error flag and check the flag outside of the interrupt. If set, then try to enable the HAL_UARTEx_ReceiveToIdle_DMA again. See code below
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
if (huart->Instance == USART3) {
//memcpy(MainBuf,RxBuf,Size);
oldPos = newPos; // Update the last position before copying new data
/* If the data in large and it is about to exceed the buffer size, we have to route it to the start of the buffer
* This is to maintain the circular buffer
* The old data in the main buffer will be overlapped
*/
if (oldPos + Size > MainBuf_SIZE) // If the current position + new data size is greater than the main buffer
{
uint16_t datatocopy = MainBuf_SIZE - oldPos; // find out how much space is left in the main buffer
memcpy((uint8_t*) MainBuf + oldPos, RxBuf, datatocopy); // copy data in that remaining space
oldPos = 0; // point to the start of the buffer
memcpy((uint8_t*) MainBuf, (uint8_t*) RxBuf + datatocopy,
(Size - datatocopy)); // copy the remaining data
newPos = ((Size) - datatocopy); // update the position
}
/* if the current position + new data size is less than the main buffer
* we will simply copy the data into the buffer and update the position
*/
else {
memcpy(MainBuf + oldPos, RxBuf, Size);
newPos = Size + oldPos;
}
}
print_mem_hex(RxBuf, Size);
UART_EnIdleDMA(huart);
}
int errorFlag;
void UART_EnIdleDMA(ART_HandleTypeDef *huart)
{
if(HAL_UARTEx_ReceiveToIdle_DMA(huart, RxBuf, RxBuf_SIZE) != HAL_OK)
{
// set error flag. Check error flag in main loop and call HAL_UARTEx_ReceiveToIdle_DMA again later.
errorFlag = 1;
}
}
void UART_CheckIdleDMA(void)
{
if(errorFlag)
{
errorFlag = 0;
UART_EnIdleDMA(&huart2);
}
}
int main(void)
{
// other HAL code
while(1)
{
UART_CheckIdleDMA();
}
}
Also should avoid doing memcpy and print routines inside an interrupt as it will prevent other interrupts from firing. You'll want to re-enable UART interrupts and exit right away. That way you don't miss any new packets of data.
See my github code https://github.com/karlyama**bleep**a/Nucleo-L432KC_UART_DMA_HAL_status
It shows how to deal with HAL status. It also uses a ring buffer to save the received data to. Because I use pointers, there is no need to memcpy the data to a buffer. The DMA knows which index of the buffer to save each packet of data to.
UART_Parse function shows how to then get each packet and parse it.
