Restart HAL_UART_Receive_IT

Hi

yuri.cherniakov

Please have a look to this example it may help you :

STM32Cube_FW_L4_V1.0\Projects\STM32L476G-EVAL\Examples\I2C\I2C_TwoBoards_RestartComIT:

This example describes how to perform a single I2C data buffer transmission/reception

-Nesrine-

Hi Nesrine,

Thanks for responding. unfortunetly this doesnt help since i'm using UART communication.

Reflect on the library code provided, and write something better. There is no value to building a fine house on a poor foundation. I prefer a clean/elegant approach over an abstracted/obtuse one.

With the HAL you'd likely need to transition the object's buffer state in the IRQ Handler prior to calling into the HAL layer, or lock down the interrupt/structure to reconfigure it.

this seems to be the problem:

'There comes a moment during the run of the program when the pointer to buffer given to the function expires'

this is an architectural issue. imho

This is likely because the HAL function checks 'busy' flag set by it's previous call.

If the flag is set it immediately fails.

https://github.com/pavel-a/stm32f4_libs/blob/db5c1ad80b84837d8c52efabd071e1e65811a340/STM32Cube_FW_F4/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_usart.c#L707

So you need to let the HAL function complete, or call

https://github.com/pavel-a/stm32f4_libs/blob/db5c1ad80b84837d8c52efabd071e1e65811a340/STM32Cube_FW_F4/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_usart.c#L1193

-- pa

You should either use a statically or dynamically allocated buffer for the UART or use an automatic (stack allocation) buffer that is declared at a scope that does not 'expire'.  Static allocation of buffers is easier to debug, though other schemes are possible.  Stack allocation is particularly hard to debug because the interrupt callback functions don't have the stack variables from the non-interrupt thread in their scope.  The buffer is still there, but there's no really good way to get the address of it using the array name for the buffer.

In any case, I recommend not calling the 'HAL_UART_Receive_IT()' function in your initialization routine.  You can set up the interface there without calling the receive function.  Instead, make the receive call at the top of a main loop where the buffer does not go out of scope until the program exits.  You can cancel any pending IO on the way out.  Having the input pending before you are prepared to process the data then switching to a new buffer will cause any data received up to that point to be lost anyway, so it's best to wait to make the receieve call until you're ready to process the data.

Thaks everyone for your responses,

I understand that the 'expiration' of the pointer to the buffer is an architechtural issue that has to be dealt with.

unfortunetly, i have inhereted some code that can not be changed at this part of the project.

I am particularly intrested in the HAL_UART_Abort function, this would help me solve the probem, i was unable to find it in the HAL functions.

i am working on the STM32F7 , is the set of the abort commands is not yet implemented for the F7?

OK. I have been doing this all the time and it id based on the assumption that if I do not receive a byte within 5ms of the last, then I have received the whole message. No fuss with circular buffers and get tangled with in-and-out pointers etc.

Obviously there are some assumed code. If you want those as well, email me at willem(at)stima.co.za.

Firstly the IRQ handler has to be modified:

In STM32xxx_it.c:

void USART2_IRQHandler(void)

           /* just my Status Engine that informs the application that reception is in progress. Struct is below */

          Usart_Message.Status.Receiving = true;

          if(Tick_IsStarted(&MessageRXTicker))

                   /* refreshing the timeout a tick driven timer. Can put your own solution here */

                   /* setting a tick timer for 30ms after first character received with a callback function

                              UART_RXVD_Complete() that would be called at timeout. Can put own solution here */

   }

  /* USER CODE END USART2_IRQn 1 */

in usart.c user section:

void UART_RXVD_Complete(void)

   /* This is how you stop further reception and solve you HA_BUSY problem  */

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)

/* for all Usarts */

    memset((void *)&RX_TEMPBUFFER, 0, sizeof(RX_TEMPBUFFER));

  return HAL_OK;

In your main.c:

typedef struct MESSAGE_OBJECT

volatile MessageObject Usart_Message;

//mainloop:

}