1 ACCEPTED SOLUTION
Accepted Solutions
@Krautermann
The problem with HAL_UART_Receive_IT is that you need to know ahead of time exactly how many characters to receive before it interrupts. Strings can vary in length.
To get around this you can interrupt on each character and save it to a buffer. Then this involves a ring buffer. But you're going to need a delimiter like a LF to know that the string is complete before you can parse the string.
But if you were to use HAL_UARTEx_ReceiveToIdle_DMA then you don't need a delimiter.
The code below is using a Nucleo-G431KB dev board. UART1 is the loopback. UART2 is using the Virtual COM Port. I am using Docklight to send messages to UART2 where it gets parsed and looks for a command to turn On/Off the green led. Else it'll copy what it received and transmit it to UART1. Since UART1 it in loopback, it'll receive that string and interrupt even if there is no delimiter because the Idle bit is enabled. Then the UART1 Rx buffer is parsed and transmitted back to UART2. I am utilizing a ring buffer (size 4) so multiple commands/strings can be sent and not be missed.
Below is some text that I am sending to UART2. That gets sent to UART1 and loops back and gets sent back to UART2.
The "grn_led:n" command is turning the LED On and Off.
/*
* PollingRoutine.c
*
* Created on: Mar 29, 2023
* Author: karl.yamashita
*/
#include "main.h"
extern UART_HandleTypeDef huart1; // loopback
extern UART_HandleTypeDef huart2; // Virtual COM Port
UartDataStruct uart1Rx = {0};
UartDataStruct uart1Tx = {0};
UartDataStruct uart2Rx = {0};
UartDataStruct uart2Tx = {0};
// Is called before main while loop
void PollingInit(void)
{
UART_EnableRx(&huart1, &uart1Rx); // init Rx reception
UART_EnableRx(&huart2, &uart2Rx); // init Rx reception
}
// Is called from inside main while loop
void PollingRoutine(void)
{
UART1_Parse();
UART2_Parse();
UART_Send(&huart1, &uart1Tx);
UART_Send(&huart2, &uart2Tx);
UART_RxStatus(&huart1, &uart1Tx);
UART_RxStatus(&huart2, &uart2Tx);
}
// Enable UART reception. Set flag if failed to enable
void UART_EnableRx(UART_HandleTypeDef *huart, UartDataStruct *msg)
{
if(HAL_UARTEx_ReceiveToIdle_DMA(huart, msg->Queue[msg->ptr.iIndexIN].data, RX_BUFFER_SIZE) != HAL_OK)
{
msg->uartRxIsEnabled = false;
}
else
{
msg->uartRxIsEnabled = true;
}
}
// HAL callback
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
if(huart->Instance == huart1.Instance)
{
uart1Rx.Queue[uart1Rx.ptr.iIndexIN].size = Size; // save data length
DRV_RingBuffPtr__Input(&uart1Rx.ptr, UART_QUEUE_SIZE); // increment pointer
UART_EnableRx(&huart1, &uart1Rx); // re-enable UART reception
}
else if(huart->Instance == huart2.Instance)
{
uart2Rx.Queue[uart2Rx.ptr.iIndexIN].size = Size; // save data length
DRV_RingBuffPtr__Input(&uart2Rx.ptr, UART_QUEUE_SIZE); // increment pointer
UART_EnableRx(&huart2, &uart2Rx); // re-enable UART reception
}
}
// TX and RX is in loopback
void UART1_Parse(void)
{
if(uart1Rx.ptr.iCnt_Handle)
{
memcpy(&uart2Tx.Queue[uart2Tx.ptr.iIndexIN].data, uart1Rx.Queue[uart1Rx.ptr.iIndexOUT].data, uart1Rx.Queue[uart1Rx.ptr.iIndexOUT].size); // copy data
uart2Tx.Queue[uart2Tx.ptr.iIndexIN].size = uart1Rx.Queue[uart1Rx.ptr.iIndexOUT].size; // copy data length
DRV_RingBuffPtr__Input(&uart2Tx.ptr, UART_QUEUE_SIZE); // increment tx in pointer
DRV_RingBuffPtr__Output(&uart1Rx.ptr, UART_QUEUE_SIZE); // increment rx out pointer
}
}
// From VCP. Using Docklight to send string messages to this UART.
void UART2_Parse(void)
{
char *token;
char *token2;
char *rest;
if(uart2Rx.ptr.iCnt_Handle)
{
rest = (char*)uart2Rx.Queue[uart2Rx.ptr.iIndexOUT].data;
token = strtok_r(rest, ":", &rest); // command
token2 = strtok_r(rest, "\0", &rest); // argument
if(strncmp(token, "grn_led", strlen("grn_led")) == 0) // original string "grn_led:n" where n = 0 or 1
{
if(atoi(token2) == 0)
{
HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);
}
else if(atoi(token2) == 1)
{
HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_SET);
}
}
else
{
memcpy(&uart1Tx.Queue[uart1Tx.ptr.iIndexIN].data, uart2Rx.Queue[uart2Rx.ptr.iIndexOUT].data, uart2Rx.Queue[uart2Rx.ptr.iIndexOUT].size); // copy data
uart1Tx.Queue[uart1Tx.ptr.iIndexIN].size = uart2Rx.Queue[uart2Rx.ptr.iIndexOUT].size; // copy data length
DRV_RingBuffPtr__Input(&uart1Tx.ptr, UART_QUEUE_SIZE); // increment tx in pointer
}
DRV_RingBuffPtr__Output(&uart2Rx.ptr, UART_QUEUE_SIZE); // increment rx out pointer
}
}
// Send any available messages in buffer
void UART_Send(UART_HandleTypeDef *huart, UartDataStruct *msg)
{
if(msg->ptr.iCnt_Handle)
{
if(HAL_UART_Transmit_IT(huart, msg->Queue[msg->ptr.iIndexOUT].data, msg->Queue[msg->ptr.iIndexOUT].size) == HAL_OK)
{
DRV_RingBuffPtr__Output(&msg->ptr, UART_QUEUE_SIZE); // Successful so we can increment pointer
}
}
}
// Poll this to Enable UART RX if not currently enabled
void UART_RxStatus(UART_HandleTypeDef *huart, UartDataStruct *msg)
{
if(!msg->uartRxIsEnabled)
{
UART_EnableRx(huart, msg);
}
}
/*
* PollingRoutine.h
*
* Created on: Mar 29, 2023
* Author: karl.yamashita
*/
#ifndef INC_POLLINGROUTINE_H_
#define INC_POLLINGROUTINE_H_
#define RX_BUFFER_SIZE 64
#define UART_QUEUE_SIZE 4
typedef struct
{
struct
{
uint8_t data[RX_BUFFER_SIZE];
uint32_t size;
}Queue[UART_QUEUE_SIZE];
RING_BUFF_INFO ptr;
bool uartRxIsEnabled; // only needed for Rx
}UartDataStruct;
void PollingInit(void);
void PollingRoutine(void);
void UART_EnableRx(UART_HandleTypeDef *huart, UartDataStruct *msg);
void UART1_Parse(void);
void UART2_Parse(void);
void UART_Send(UART_HandleTypeDef *huart, UartDataStruct *msg);
void UART_RxStatus(UART_HandleTypeDef *huart, UartDataStruct *msg);
#endif /* INC_POLLINGROUTINE_H_ *//*
* RingBuff.c
*
* Created on: Sep 18, 2019
* Author: Karl
*
*
*/
#include "main.h"
#include "ringBuff.h"
/*
typedef struct {
uint16_t iIndexIN; // change all these if need more than 16bits.
uint16_t iIndexOUT;
uint16_t iCnt_Handle;
uint16_t iCnt_OverFlow;
}RING_BUFF_INFO;
*/
//==========================================================
// Layer : DRIVER
//==========================================================
void DRV_RingBuffPtr__Clean(RING_BUFF_INFO *ptr) {
ptr->iIndexIN = 0;
ptr->iIndexOUT = 0;
ptr->iCnt_Handle = 0;
ptr->iCnt_OverFlow = 0;
}
void DRV_RingBuffPtr__Input(RING_BUFF_INFO *ptr, unsigned int iBufferSize) {
ptr->iIndexIN++;
if (ptr->iIndexIN >= iBufferSize)
ptr->iIndexIN = 0;
ptr->iCnt_Handle++;
if (ptr->iIndexIN == ptr->iIndexOUT) {
ptr->iCnt_OverFlow++;
if (ptr->iCnt_OverFlow > 50000)
ptr->iCnt_OverFlow = 0;
if (ptr->iIndexIN == 0) {
ptr->iIndexOUT = iBufferSize - 1;
} else {
ptr->iIndexOUT = ptr->iIndexIN - 1;
}
ptr->iCnt_Handle = 1;
}
}
void DRV_RingBuffPtr__Output(RING_BUFF_INFO *ptr, unsigned int iBufferSize) {
if (ptr->iCnt_Handle) {
ptr->iIndexOUT++;
if (ptr->iIndexOUT >= iBufferSize)
ptr->iIndexOUT = 0;
ptr->iCnt_Handle--;
}
}
#ifndef RINGBUFF_H
#define RINGBUFF_H
#include "main.h"
#include <stdint.h>
typedef struct {
uint16_t iIndexIN; // change all these if need more than 16bits.
uint16_t iIndexOUT;
uint16_t iCnt_Handle;
uint16_t iCnt_OverFlow;
}RING_BUFF_INFO;
//================================================
// FUNCTION
//================================================
void DRV_RingBuffPtr__Clean(RING_BUFF_INFO *ptr);
void DRV_RingBuffPtr__Input(RING_BUFF_INFO *ptr, unsigned int iBufferSize);
void DRV_RingBuffPtr__Output(RING_BUFF_INFO *ptr, unsigned int iBufferSize);
#endif // RINGBUFF_H