HAL_UART_Receive_IT() is not meant to be called from an interrupt handler that way, but to initiate receiving a fixed number of bytes via interrupt.

A possible workaround is to check your input buffer after HAL_UART_IRQHandler() completes, i.e., in the /* USER CODE BEGIN USART1_IRQn 1 */ section. When a command is processed, you can reset pRxBuffPtr and RxXferCount in the handle structure to their original values to start from the start of the buffer again.

Another horrible possible workaround would be to call HAL_UART_Receive_IT() with a buffer size of 1, and set up a HAL_UART_RxCpltCallback() handler that checks the received byte each time, and calls HAL_UART_Receive_IT() again when necessary.

Of course you could do it without HAL, as PeterJ and others (always) suggest.

• You've already implemented pin and interrupt setup. Leave them unchanged at first.
• Calculate the UART->BRR value according to the reference manual, or copy the relevant code from HAL.
• set UART->CR1 = USART_CR1_RE | USART_CR1_TE | USART_CR1_UE |USART_CR1_RXNEIE; Now, you are getting interrupts.
• In the interrupt function, read UART->SR into a temporary variable, and examine it.
• Read UART->DR when there is a received byte waiting, and do the error handling otherwise (later).
• Get rid of the rest of the HAL calls when the above is working.

Interrupt response and processing time is often critical in embedded applications, and the HAL just wastes a lot of that.

Generally, you only need to handle the interrupt flags which you have specifically enabled with USART_ITConfig().

However, if you enable the RXNE interrupt (USART_ITConfig(USARTx, USART_IT_RXNE)) then this also enables the Overrun interrupt! So you must handle both of those.

The USART flags can be confusing. There are separate status flags and interrupt flags and they share similar names. For example: USART_IT_RXNE and USART_FLAG_RXNE.

In addition, there are various methods to clear these flags. For example, the USART_ClearITPendingBit() function only works for four (of the ten) possible flags.

Here is a summary of the interrupt flags and how to use them. These are specific for the STM32F105, but are representative:

USART_IT_TXE - "Transmit Data register empty"

• It is cleared automatically when calling USART_SendData()

USART_IT_RXNE - "Receive Data register not empty"

• It is cleared automatically when calling USART_ReceiveData(USARTx)

• It can be cleared manually by calling USART_ClearITPendingBit(USARTx, USART_IT_RXNE)

USART_IT_TC - "Transmission complete"

• It is cleared automatically by:

  • USART_GetITStatus(USARTx, USART_IT_TC) followed by
  • USART_SendData()

• It can be also be cleared manually by calling USART_ClearITPendingBit(USARTx, USART_IT_TC)

USART_IT_CTS - "CTS change"

• Cleared by calling USART_ClearITPendingBit(USARTx, USART_IT_CTS)

USART_IT_LBD - "LIN Break detected"

• Cleared by calling USART_ClearITPendingBit(USARTx, USART_IT_LBD)

USART_IT_PE - "Parity error"

• Cleared by:
  • USART_GetITStatus(USARTx, USART_IT_PE) followed by
  • USART_ReceiveData(USARTx)

USART_IT_NE - "Noise error"

• Cleared by:
  • USART_GetITStatus(USARTx, USART_IT_NE) followed by
  • USART_ReceiveData(USARTx)

USART_IT_ORE - "Overrun error"

• Cleared by:
  • USART_GetITStatus(USARTx, USART_IT_ORE) followed by
  • USART_ReceiveData(USARTx)()

USART_IT_IDLE - "Idle line detected"

• Cleared by:
  • USART_GetITStatus(USARTx, USART_IT_IDLE) followed by
  • USART_ReceiveData(USARTx)()

Such a question is difficult to answer without knowing which specific processor you are using, which board you are using, and/or which compiler you are using. But in an attempt to be helpful, here's my code.

Here's my GPIO and NVIC initialization code using Sourcery CodeBench Lite with an STM32F4 processor mounted on a custom board.

GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;

GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;

RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);

GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_USART3);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource11, GPIO_AF_USART3);  
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
GPIO_Init(GPIOB, &GPIO_InitStructure);

// Enable the USART RX Interrupt 
USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);

Of course your settings will vary depending on your processor, board and interrupt priority.

Here's my interrupt handler code. In my development environment, this handler is declared in my startup assembly file as a weak reference to Default_Handler...

Default_Handler:
b .  

/* ... */

.word     USART3_IRQHandler

/* ... */

.weak      USART3_IRQHandler      
.thumb_set USART3_IRQHandler,Default_Handler

... so as long as I provide a new declaration and implementation of this interrupt handler, the weak reference will be replaced. Here's what my code looks like.

//Interrupt handler declaration
void USART3_IRQHandler();

If you are using C++ you will need to declare it as follows:

//Interrupt handler declaration in C/C++
#ifdef __cplusplus
 extern "C" {
#endif
void USART3_IRQHandler();
#ifdef __cplusplus
 }
#endif

And here's the interrupt handler implemenation.

//Interrupt handler implementation
void USART3_IRQHandler()
{
    //handle interrupt
}