No Data Receiving form UART with Interrupt, STM32F4, HAL drivers - interrupt

Question

When I send a request across the UART port from the PC (serial monitor) to the STM32F4 discovery board the signal will not be received. The board should normally answer with the same request which was received before (UART mirroring). I used an interrupt (without DMA) to send or to receive a message. In the interrupt service routine, interrupt flag has been set. This flag will be read in the main loop. I am not using a callback function.
Without the interrupt service (with only HAL_UART_Transmit(...) and HAL_UART_Receive(...) in the main loop) everything works fine. But I want a communication with interrupt.
In the RUN- Mode I have enable breakpoints in the ISR and the two if statements.
I would like to know, whether there is an issue with the ISR routine. But the ISR Routine works as it should be. By a request from the PC the ISR and the receive if statement is called.
The Problem is, that the receive register stay empty. And if this remains empty the controller will not send the request message.
What is wrong? Where is the problem and can you please help me? Is the configuration of the UART Port right?
Thanks for your help & support!
volatile enum RxStates {
UART_RX, DUMMY_RX, WAIT_RX
} stateRx;
volatile enum TxStates {
UART_TX_READY, DUMMY_TX, WAIT_TX
} stateTx;
static UART_HandleTypeDef s_UARTHandle;
GPIO_InitTypeDef GPIOC2_InitStruct; //GPIO
uint8_t empfang[8]; //buffer
void UART_ini(void)
{
__HAL_RCC_GPIOA_CLK_ENABLE();
__USART2_CLK_ENABLE();
//PIN TX
GPIOC2_InitStruct.Pin = GPIO_PIN_2;
GPIOC2_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIOC2_InitStruct.Alternate = GPIO_AF7_USART2;
GPIOC2_InitStruct.Speed = GPIO_SPEED_FAST;
GPIOC2_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA, &GPIOC2_InitStruct);
//PIN RX
GPIOC2_InitStruct.Pin = GPIO_PIN_3;
GPIOC2_InitStruct.Mode = GPIO_MODE_AF_OD;
HAL_GPIO_Init(GPIOA, &GPIOC2_InitStruct);
//USART2
s_UARTHandle.Instance = USART2;
s_UARTHandle.Init.BaudRate = 9600;
s_UARTHandle.Init.WordLength = UART_WORDLENGTH_8B;
s_UARTHandle.Init.StopBits = UART_STOPBITS_1;
s_UARTHandle.Init.Parity = UART_PARITY_NONE;
s_UARTHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
s_UARTHandle.Init.Mode = UART_MODE_TX_RX;
HAL_UART_Init(&s_UARTHandle);
__HAL_UART_ENABLE_IT(&s_UARTHandle, UART_IT_RXNE | UART_IT_TC);
HAL_NVIC_SetPriority(USART2_IRQn, 15, 15);
HAL_NVIC_EnableIRQ(USART2_IRQn); // Enable Interrupt
}//UART
int main(int argc, char* argv[])
{
//initialization of the interrupt flags
stateRx = WAIT_RX;
stateTx = WAIT_TX;
UART_ini(); //initialization UART
while (1)
{
//receive interrupt flag
if (stateRx == UART_RX)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_13, GPIO_PIN_SET); //set LED
HAL_UART_Receive(&s_UARTHandle, empfang, 2, 10000000); //receive message
stateRx = WAIT_RX; //RESET flag
}
//transmit interrupt flag
if (stateTx == UART_TX_READY)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_13, GPIO_PIN_SET); //set LED
HAL_UART_Transmit(&s_UARTHandle, empfang, 2, 10000); //send message
stateTx = WAIT_TX; //RESET flag
}
//RESET LED
if (stateTx != UART_TX_READY && stateRx != UART_RX)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_13, RESET); //RESET LED
}
}//while
}//main
void USART2_IRQHandler()
{
if (__HAL_UART_GET_FLAG(&s_UARTHandle, UART_FLAG_RXNE) == SET)
{
__HAL_UART_CLEAR_FLAG(&s_UARTHandle, UART_FLAG_RXNE); //clear ISR flag
stateRx = UART_RX; //set RX flag
}
if (__HAL_UART_GET_FLAG(&s_UARTHandle, UART_FLAG_TC) == SET)
{
__HAL_UART_CLEAR_FLAG(&s_UARTHandle, UART_FLAG_TC); //clear ISR flag
stateTx = UART_TX_READY; //set TX flag
}
}//ISR
//EOF

Answer 1

Look into HAL_UART_Receive function, this function waits for UART_FLAG_RXNE flag but you clear this flag in USART2_IRQHandler
Usually, when you use RX interrupt, you have to save received data into user buffer and then parse it.