title: No Data Receiving form UART with Interrupt, STM32F4, HAL drivers
body: <p>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.</p>
  
  <p>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.</p>
  
  <p>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. </p>
  
  <p>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 &amp; support!</p>
  
  <pre><code>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, &amp;GPIOC2_InitStruct);
  
  //PIN RX
      GPIOC2_InitStruct.Pin = GPIO_PIN_3;
      GPIOC2_InitStruct.Mode = GPIO_MODE_AF_OD;
      HAL_GPIO_Init(GPIOA, &amp;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(&amp;s_UARTHandle);
  
      __HAL_UART_ENABLE_IT(&amp;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(&amp;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(&amp;s_UARTHandle, empfang, 2, 10000);    //send message
  
              stateTx = WAIT_TX;                                      //RESET flag
          }
  
  //RESET LED
          if (stateTx != UART_TX_READY &amp;&amp; stateRx != UART_RX)         
          {
              HAL_GPIO_WritePin(GPIOD, GPIO_PIN_13, RESET);           //RESET LED
          }
  
      }//while
  }//main
  
  
  void USART2_IRQHandler() 
  {
  
      if (__HAL_UART_GET_FLAG(&amp;s_UARTHandle, UART_FLAG_RXNE) == SET) 
      {
          __HAL_UART_CLEAR_FLAG(&amp;s_UARTHandle, UART_FLAG_RXNE);       //clear ISR flag
          stateRx = UART_RX;                                          //set RX flag
      }
  
      if (__HAL_UART_GET_FLAG(&amp;s_UARTHandle, UART_FLAG_TC) == SET) 
      {
          __HAL_UART_CLEAR_FLAG(&amp;s_UARTHandle, UART_FLAG_TC);         //clear ISR flag
          stateTx = UART_TX_READY;                                    //set TX flag
      }
  }//ISR
  
  //EOF
  </code></pre>