Don't process any data inside of the interrupt other wise you could miss other interrupts that are happening. Just save the data and set a flag indicating a new byte was received. Enable uart interrupt and exit the callback. Then in a main while loop you can check each character and process it there.
A better approach is not even having to save the data but just use a ring buffer. Below code has a ring buffer though it's over kill for single characters but it can hold up to 2 characters in a queue which you can increase with the #define. Unless you type like Superman then 2 queues is more than efficient. If you type like a turtle then you don't even need a ring buffer. If you're doing a lot of other things like math calculation, then you can increase the queue so you don't get an overflow.
Also notice in HAL_UART_RxCpltCallback I don't have to copy received data to another variable. I just increment a pointer and enable the UART interrupt which points the HAL driver to save to the next queue. Then i check if there is a byte available and parse the character.
#include "main.h"
extern UART_HandleTypeDef hlpuart1;
UART_Data_t uartData = {0};
// before main while loop
void PollingInit(void)
{
UART_EnableInterrupt();
}
// main while loop
void PollingRoutine(void)
{
UART_ParseMessage();
UART_CheckHalStatus();
}
void UART_ParseMessage(void)
{
char *ptr;
if(uartData.ptr.cnt_Handle)
{
// user can parse the pointer data.
ptr = (char*)&uartData.data[uartData.ptr.index_OUT];
switch(*ptr)
{
case 'a':
GreenLED_Toggle();
break;
case 'b':
HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_SET);
break;
case 'c':
HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);
break;
}
RingBuff_Ptr_Output(&uartData.ptr, DATA_SIZE);
}
}
void UART_EnableInterrupt(void)
{
uartData.HAL_Status = HAL_UART_Receive_IT(&hlpuart1, &uartData.data[uartData.ptr.index_IN], 1); // interrupt on 1 byte
}
void UART_CheckHalStatus(void)
{
if(uartData.HAL_Status != HAL_OK)
{
uartData.HAL_Status = HAL_OK;
UART_EnableInterrupt(); // try to enable again
}
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart == &hlpuart1)
{
RingBuff_Ptr_Input(&uartData.ptr, DATA_SIZE);
UART_EnableInterrupt();
}
}
void GreenLED_Toggle(void)
{
HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
}
#ifndef INC_POLLINGROUTINE_H_
#define INC_POLLINGROUTINE_H_
#define DATA_SIZE 8
typedef struct
{
uint8_t data[DATA_SIZE];
RING_BUFF_STRUCT ptr;
HAL_StatusTypeDef HAL_Status;
}UART_Data_t;
void PollingInit(void);
void PollingRoutine(void);
void UART_ParseMessage(void);
void UART_EnableInterrupt(void);
void UART_CheckHalStatus(void);
void GreenLED_Toggle(void);
#endif /* INC_POLLINGROUTINE_H_ */
#include "main.h"
#include "ringBuffer.h"
void RingBuff_Ptr_Reset(RING_BUFF_STRUCT *ptr) {
ptr->index_IN = 0;
ptr->index_OUT = 0;
ptr->cnt_Handle = 0;
ptr->cnt_OverFlow = 0;
}
void RingBuff_Ptr_Input(RING_BUFF_STRUCT *ptr, uint32_t bufferSize) {
ptr->index_IN++;
if (ptr->index_IN >= bufferSize)
ptr->index_IN = 0;
ptr->cnt_Handle++;
if (ptr->index_IN == ptr->index_OUT) {
ptr->cnt_OverFlow++;
if (ptr->cnt_OverFlow > RING_BUFF_OVERFLOW_SIZE)
ptr->cnt_OverFlow = 0;
if (ptr->index_IN == 0) {
ptr->index_OUT = bufferSize - 1;
} else {
ptr->index_OUT = ptr->index_IN - 1;
}
ptr->cnt_Handle = 1;
}
}
void RingBuff_Ptr_Output(RING_BUFF_STRUCT *ptr, uint32_t bufferSize) {
if (ptr->cnt_Handle) {
ptr->index_OUT++;
if (ptr->index_OUT >= bufferSize)
ptr->index_OUT = 0;
ptr->cnt_Handle--;
}
}
#ifndef RING_BUFFER_H
#define RING_BUFFER_H
#include "main.h"
#define RING_BUFF_OVERFLOW_SIZE 100
typedef struct {
uint32_t index_IN; // pointer to where the data will be save to
uint32_t index_OUT; // pointer to next available data in buffer if cnt_handle is not zero
uint32_t cnt_Handle; // if not zero then message available
uint32_t cnt_OverFlow; // has overflow if not zero
}RING_BUFF_STRUCT;
void RingBuff_Ptr_Reset(RING_BUFF_STRUCT *ptr);
void RingBuff_Ptr_Input(RING_BUFF_STRUCT *ptr, uint32_t bufferSize);
void RingBuff_Ptr_Output(RING_BUFF_STRUCT *ptr, uint32_t bufferSize);
#endif // RING_BUFFER_H
int main(void)
{
/* Infinite loop */
/* USER CODE BEGIN WHILE */
PollingInit();
while (1)
{
PollingRoutine();
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
Tips and Tricks with TimerCallback https://www.youtube.com/@eebykarl
If you find my solution useful, please click the Accept as Solution so others see the solution.
