STM32F103 how to write a function can receive no matter what type of data is sent in USART1 and printed out through the serial port assistant
Source code:
#include “usart.h”
/* USER CODE BEGIN 0 */
#include <string.h>
UART_HANDLE hdl_uart1;
UART_HANDLE hdl_uart2;
UART_HANDLE hdl_uart3;
UART_HANDLE hdl_uart4;
/* USER CODE END 0 */
UART_HandleTypeDef huart4;
UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;
UART_HandleTypeDef huart3;
/* USART1 init function */
void MX_USART1_UART_Init(void)
{
huart1.Instance = USART1;
huart1.Init.BaudRate = 9600;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler(“UART_Init(&huart1) error. \n”);
}
/* USER CODE BEGIN 0 */
hdl_uart1.huart = &huart1;
strcpy ( hdl_uart1.ID_str, “UART1”);
hdl_uart1.tx_ready = SET;
hdl_uart1.tx_buf.len = 0;
hdl_uart1.tx_data.len = 0;
hdl_uart1.tx_data.msg[0] = NULL;
hdl_uart1.rx_ready = SET;
hdl_uart1.rx_buf.len = MAX_RECEIVE_LEN;
hdl_uart1.rx_data.len = 0;
if(HAL_UART_Receive_IT(&huart1, hdl_uart1.rx_buf.msg, hdl_uart1.rx_buf.len) == HAL_OK) //Start receiving interrupt
{ hdl_uart1.rx_ready = RESET; }
/* USER CODE END 0 */
}
/* USART2 init function */
void MX_USART2_UART_Init(void)
{
huart2.Instance = USART2;
huart2.Init.BaudRate = 9600;
huart2.Init.WordLength = UART_WORDLENGTH_8B;
huart2.Init.StopBits = UART_STOPBITS_1;
huart2.Init.Parity = UART_PARITY_NONE;
huart2.Init.Mode = UART_MODE_TX_RX;
huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart2.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart2) != HAL_OK)
{
Error_Handler(“UART_Init(&huart2) error. \n”);
}
/* USER CODE BEGIN 0 */
hdl_uart2.huart = &huart2;
strcpy ( hdl_uart2.ID_str, “UART2”);
hdl_uart2.tx_ready = SET;
hdl_uart2.tx_buf.len = 0;
hdl_uart2.tx_data.len = 0;
hdl_uart2.tx_data.msg[0] = NULL;
hdl_uart2.rx_ready = SET;
hdl_uart2.rx_buf.len = MAX_RECEIVE_LEN;
hdl_uart2.rx_data.len = 0;
/*
if(HAL_UART_Receive_IT(&huart2, hdl_uart2.rx_buf.msg, hdl_uart2.rx_buf.len) == HAL_OK) //Start receiving interrupt
{ hdl_uart2.rx_ready = RESET; } */
/* USER CODE END 0 */
}
/* USART3 init function */
void MX_USART3_UART_Init(void)
{
huart3.Instance = USART3;
huart3.Init.BaudRate = 115200;
huart3.Init.WordLength = UART_WORDLENGTH_8B;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = UART_PARITY_NONE;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart3) != HAL_OK)
{
Error_Handler(“UART_Init(&huart3) error. \n”);
}
/* USER CODE BEGIN 0 */
hdl_uart3.huart = &huart3;
strcpy ( hdl_uart3.ID_str, “UART3”);
hdl_uart3.tx_ready = SET;
hdl_uart3.tx_buf.len = 0;
hdl_uart3.tx_data.len = 0;
hdl_uart3.tx_data.msg[0] = NULL;
hdl_uart3.rx_ready = SET;
hdl_uart3.rx_buf.len = MAX_RECEIVE_LEN;
hdl_uart3.rx_data.len = 0;
/*
if(HAL_UART_Receive_IT(&huart3, hdl_uart3.rx_buf.msg, hdl_uart3.rx_buf.len) == HAL_OK) //启动接收中断
{
hdl_uart3.rx_ready = RESET;
}
/
/ USER CODE END 0 */
}
/* UART4 init function */
void MX_UART4_Init(void)
{
huart4.Instance = UART4;
huart4.Init.BaudRate = 9600;
huart4.Init.WordLength = UART_WORDLENGTH_8B;
huart4.Init.StopBits = UART_STOPBITS_1;
huart4.Init.Parity = UART_PARITY_NONE;
huart4.Init.Mode = UART_MODE_TX_RX;
huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart4.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart4) != HAL_OK)
{
Error_Handler(“UART_Init(&huart4) error. \n”);
}
}
void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
if(uartHandle->Instance==UART4)
{
/* USER CODE BEGIN UART4_MspInit 0 */
/* USER CODE END UART4_MspInit 0 /
/ UART4 clock enable */
__HAL_RCC_UART4_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
/**UART4 GPIO Configuration
PC10 ------> UART4_TX
PC11 ------> UART4_RX
*/
GPIO_InitStruct.Pin = GPIO_PIN_10;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/* UART4 interrupt Init */
HAL_NVIC_SetPriority(UART4_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(UART4_IRQn);
/* USER CODE BEGIN UART4_MspInit 1 */
/* USER CODE END UART4_MspInit 1 /
}
else if(uartHandle->Instance==USART1)
{
/ USER CODE BEGIN USART1_MspInit 0 */
/* USER CODE END USART1_MspInit 0 /
/ USART1 clock enable */
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
/**USART1 GPIO Configuration
PA9 ------> USART1_TX
PA10 ------> USART1_RX
*/
GPIO_InitStruct.Pin = UART1_TX_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(UART1_TX_GPIO_Port, &GPIO_InitStruct);
GPIO_InitStruct.Pin = UART1_RX_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(UART1_RX_GPIO_Port, &GPIO_InitStruct);
/* USART1 interrupt Init */
HAL_NVIC_SetPriority(USART1_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(USART1_IRQn);
/* USER CODE BEGIN USART1_MspInit 1 */
/* USER CODE END USART1_MspInit 1 /
}
else if(uartHandle->Instance==USART2)
{
/ USER CODE BEGIN USART2_MspInit 0 */
/* USER CODE END USART2_MspInit 0 /
/ USART2 clock enable */
__HAL_RCC_USART2_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
/**USART2 GPIO Configuration
PA2 ------> USART2_TX
PA3 ------> USART2_RX
*/
GPIO_InitStruct.Pin = UART2_TX_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(UART2_TX_GPIO_Port, &GPIO_InitStruct);
GPIO_InitStruct.Pin = UART2_RX_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(UART2_RX_GPIO_Port, &GPIO_InitStruct);
/* USART2 interrupt Init */
HAL_NVIC_SetPriority(USART2_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(USART2_IRQn);
/* USER CODE BEGIN USART2_MspInit 1 */
/* USER CODE END USART2_MspInit 1 /
}
else if(uartHandle->Instance==USART3)
{
/ USER CODE BEGIN USART3_MspInit 0 */
/* USER CODE END USART3_MspInit 0 /
/ USART3 clock enable */
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
/**USART3 GPIO Configuration
PB10 ------> USART3_TX
PB11 ------> USART3_RX
*/
GPIO_InitStruct.Pin = UART3_TX_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(UART3_TX_GPIO_Port, &GPIO_InitStruct);
GPIO_InitStruct.Pin = UART3_TXB11_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(UART3_TXB11_GPIO_Port, &GPIO_InitStruct);
/* USART3 interrupt Init */
HAL_NVIC_SetPriority(USART3_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(USART3_IRQn);
/* USER CODE BEGIN USART3_MspInit 1 */
/* USER CODE END USART3_MspInit 1 */
}
}
void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
{
if(uartHandle->Instance==UART4)
{
/* USER CODE BEGIN UART4_MspDeInit 0 */
/* USER CODE END UART4_MspDeInit 0 /
/ Peripheral clock disable */
__HAL_RCC_UART4_CLK_DISABLE();
/**UART4 GPIO Configuration
PC10 ------> UART4_TX
PC11 ------> UART4_RX
*/
HAL_GPIO_DeInit(GPIOC, GPIO_PIN_10|GPIO_PIN_11);
/* UART4 interrupt Deinit */
HAL_NVIC_DisableIRQ(UART4_IRQn);
/* USER CODE BEGIN UART4_MspDeInit 1 */
/* USER CODE END UART4_MspDeInit 1 /
}
else if(uartHandle->Instance==USART1)
{
/ USER CODE BEGIN USART1_MspDeInit 0 */
/* USER CODE END USART1_MspDeInit 0 /
/ Peripheral clock disable */
__HAL_RCC_USART1_CLK_DISABLE();
/**USART1 GPIO Configuration
PA9 ------> USART1_TX
PA10 ------> USART1_RX
*/
HAL_GPIO_DeInit(GPIOA, UART1_TX_Pin|UART1_RX_Pin);
/* USART1 interrupt Deinit */
HAL_NVIC_DisableIRQ(USART1_IRQn);
/* USER CODE BEGIN USART1_MspDeInit 1 */
/* USER CODE END USART1_MspDeInit 1 /
}
else if(uartHandle->Instance==USART2)
{
/ USER CODE BEGIN USART2_MspDeInit 0 */
/* USER CODE END USART2_MspDeInit 0 /
/ Peripheral clock disable */
__HAL_RCC_USART2_CLK_DISABLE();
/**USART2 GPIO Configuration
PA2 ------> USART2_TX
PA3 ------> USART2_RX
*/
HAL_GPIO_DeInit(GPIOA, UART2_TX_Pin|UART2_RX_Pin);
/* USART2 interrupt Deinit */
HAL_NVIC_DisableIRQ(USART2_IRQn);
/* USER CODE BEGIN USART2_MspDeInit 1 */
/* USER CODE END USART2_MspDeInit 1 /
}
else if(uartHandle->Instance==USART3)
{
/ USER CODE BEGIN USART3_MspDeInit 0 */
/* USER CODE END USART3_MspDeInit 0 /
/ Peripheral clock disable */
__HAL_RCC_USART3_CLK_DISABLE();
/**USART3 GPIO Configuration
PB10 ------> USART3_TX
PB11 ------> USART3_RX
*/
HAL_GPIO_DeInit(GPIOB, UART3_TX_Pin|UART3_TXB11_Pin);
/* USART3 interrupt Deinit */
HAL_NVIC_DisableIRQ(USART3_IRQn);
/* USER CODE BEGIN USART3_MspDeInit 1 */
/* USER CODE END USART3_MspDeInit 1 */
}
}
/* USER CODE BEGIN 1 */
void UART_tx(UART_HANDLE *hdl)
{ //UART1 send data if( hdl->tx_ready == SET) //When sending is idle, copy the sending data to the sending buffer area { if (hdl->tx_data.len) // Send Data { hdl->tx_buf.len = hdl->tx_data.len; memcpy(hdl->tx_buf.msg, hdl->tx_data.msg, hdl->tx_data.len); hdl->tx_data.len = 0; / /Clear tx_data hdl->tx_data.msg[0] = NULL;
if(HAL_UART_Transmit_IT(hdl->huart, hdl->tx_buf.msg, hdl->tx_buf.len)== HAL_OK)
{
hdl->tx_ready = RESET;
}
}
}
}
void UART_rx( UART_HANDLE *hdl )
{
if (hdl->rx_ready == SET) //receive buffer full
{ print_str (hdl->ID_str ); print_str ("receive buffer full.\n");
if(HAL_UART_Receive_IT( hdl->huart, hdl->rx_buf.msg, hdl->rx_buf.len) == HAL_OK) //重启接收中断
{
hdl->rx_ready = RESET;
}
}
else //Receiving buffer is not full
{ if (hdl->huart->RxXferSize> hdl->huart->RxXferCount) //Received characters: transfer received data { /* During the transfer of received data, the receiving interrupt is prohibited* / __HAL_UART_DISABLE_IT( hdl->huart, UART_IT_RXNE);
for (int i=0; i< (hdl->huart->RxXferSize - hdl->huart->RxXferCount); i++)
{
hdl->rx_data.msg[hdl->rx_data.len++] = hdl->rx_buf.msg[i];
}
//重置接收缓冲区
hdl->huart->pRxBuffPtr = hdl->rx_buf.msg;
hdl->huart->RxXferCount = hdl->rx_buf.len;
/* 重启接收中断 */
__HAL_UART_ENABLE_IT( hdl->huart, UART_IT_RXNE);
//处理接收数据
if ( hdl->rx_data.len > (MAX_RECEIVE_LEN - 128) )
{
hdl->rx_data.len = 0;
print_str ( hdl->ID_str );
print_str(" receive data overflow.\n");
}
//only for test
hdl->rx_data.msg[hdl->rx_data.len] = NULL; //补充字符串结束符
print_str ((char *)hdl->rx_data.msg);
hdl->rx_data.len = 0;
}
}
}
/**
- @brief Tx Transfer completed callback
- @param UartHandle: UART handle.
- @note This example shows a simple way to report end of IT Tx transfer, and
-
you can add your own implementation. - @retval None
*/
void HAL_UART_TxCpltCallback(UART_HandleTypeDef UartHandle)
{
/ Set transmission flag: transfer complete */
if(UartHandle->InstanceUSART1)
hdl_uart1.tx_ready = SET;
else if(UartHandle->InstanceUSART2)
hdl_uart2.tx_ready = SET;
else if(UartHandle->InstanceUSART3)
hdl_uart3.tx_ready = SET;
else if(UartHandle->InstanceUART4)
hdl_uart4.tx_ready = SET;
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef UartHandle)
{
/ Set transmission flag: transfer complete */
if(UartHandle->InstanceUSART1)
hdl_uart1.rx_ready = SET;
else if(UartHandle->InstanceUSART2)
hdl_uart2.rx_ready = SET;
else if(UartHandle->InstanceUSART3)
hdl_uart3.rx_ready = SET;
else if(UartHandle->InstanceUART4)
hdl_uart4.rx_ready = SET;
}
void UART_send(void)
{
UART_tx(&hdl_uart1);
//UART_tx(&hdl_uart3);
}
void UART_receive(void)
{
UART_rx( &hdl_uart1 );
//UART_rx( &hdl_uart3 );
}
#define DEBUG_UART1
#ifdef DEBUG_UART1
void print_str(char *str) //Output string through UART1 port, NULL is the terminator
{ char *p_msg = (char *) hdl_uart1.tx_data.msg;
hdl_uart1.tx_data.msg[hdl_uart1.tx_data.len] =NULL; //Process tx_data as a string
strcat(p_msg, str);
if (strlen(p_msg)> (MAX_PRINT_LEN-128)) //Overflow handling
{ strcpy(p_msg, “UART1 Print buffer overflow.\n”); }
hdl_uart1.tx_data.len = strlen(p_msg);
}
#else
void print_str(char *str) //Output string through UART1 port, NULL is the terminator
{ char *p_msg = (char *) hdl_uart3.tx_data.msg;
hdl_uart3.tx_data.msg[hdl_uart3.tx_data.len] =NULL; //Process tx_data as a string
strcat(p_msg, str);
if (strlen(p_msg)> (MAX_PRINT_LEN-128)) //Overflow handling
{ strcpy(p_msg, “UART3 Print buffer overflow.\n”); }
hdl_uart3.tx_data.len = strlen(p_msg);
}
#endif
How to fix the debug1 serial port 1 function so that I can print the received data through serial port 1 regardless of the type? Now I can only print the string and encounter 0 data, which will cause an error, and now I can call this function to output what I want to output through the serial port 1.