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

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

denis krasutski denis krasutski · Accepted Answer · 2017-11-22T09:37:10

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.

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

1 Answers