【自学嵌入式：stm32单片机】串口发送+接收
串口发送+接收
接线图
代码实现
标准库实现
已开源到：https://gitee.com/qin-ruiqian/jiangkeda-stm32
Serial.h
#ifndef __SERIAL_H
#define __SERIAL_H
#include <stdio.h>
void Serial_Init(void);
void Serial_SendByte(uint8_t Byte);
void Serial_SendArray(uint8_t* Array, uint16_t Length);
void Serial_SendString(char *String);
void Serial_SendNumber(uint32_t Number, uint8_t Length);
void Serial_Printf(char* format, ...);
uint8_t Serial_GetRxFlag(void);
uint8_t Serial_GetRxData(void);
#endif
Serial.c
#include "stm32f10x.h" // Device header
#include "stdio.h" //重写printf
#include "stdarg.h" //封装用
uint8_t Serial_RxData; //串口接收的数据
uint8_t Serial_RxFlag; //串口接收标志位
// 初始化串口通信
void Serial_Init(void)
{
// 开启时钟，USART1是APB2的外设，其他的串口都是APB1的外设
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
// 开启GPIO时钟，后续在PA9 PA10读写数据
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
// 初始化GPIO引脚
// 将PA9配置为复用推挽输出，供USART1的TX使用
// 将PA10配置为上拉输入，供USART1的RX使用
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; // 复用推挽输出
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; // PA9做TX
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; // 上拉输入
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; // PA10做RX
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// 初始化USART
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = 9600; // 波特率
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // 不使用流控
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; // 发送和接收都开启
USART_InitStructure.USART_Parity = USART_Parity_No; // 不需要校验位
USART_InitStructure.USART_StopBits = USART_StopBits_1; // 1位停止位
USART_InitStructure.USART_WordLength = USART_WordLength_8b; // 8位字长，不需要奇偶校验位
USART_Init(USART1, &USART_InitStructure);
// 开启USART
USART_Cmd(USART1, ENABLE);
//对于串口接收来说，可以使用查询和中断两种方法
//如果使用查询，那初始化就结束了
//如果使用中断，那还需要在这里开启中断，配置NVIC
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
//配置NVIC
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //2分组
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
//优先级都随便给个1
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_Init(&NVIC_InitStructure);
}
// 串口发送一个字节的数据
void Serial_SendByte(uint8_t Byte)
{
USART_SendData(USART1, Byte);
// 还需要等待一下，等TDR的数据转移到移位寄存器
// 要不然数据还在TDR进行等待，我们再写入数据，就会产生数据覆盖
while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET); // 等待发送寄存器空标志位置1
// 标志位置SET（高电平）后不需要手动清零
// 下一次再SendData，标志位自动清零
}
// 发送一个数组
// Array是数组首地址
// Length是数组长度
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
uint16_t i = 0; // 循环变量
for (i = 0; i < Length; i++)
{
Serial_SendByte(Array[i]);
}
}
// 发送一个字符串
void Serial_SendString(char *String)
{
uint8_t i = 0; // 循环遍历
for (i = 0; String[i] != '\0'; i++)
{
Serial_SendByte(String[i]);
}
}
//取次方函数
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
uint32_t Result = 1;
while(Y--)
{
Result *= X;
}
return Result;
}
//发送一个数字
void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
uint8_t i = 0; // 循环遍历
for (i = 0; i < Length; i++)
{
//从个位开始发
Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
}
}
//重写fputc函数
//printf函数的底层
int fputc(int ch, FILE* f)
{
Serial_SendByte(ch);
return ch;
}
//对sprintf进行封装
//用可变参数
void Serial_Printf(char* format, ...)
{
char String[100]; //定义缓冲区存储格式化后的字符串
va_list arg; // 声明可变参数列表
va_start(arg, format); //从format位置开始接收参数列表，放在arg里面
// 使用vsprintf将格式化字符串写入缓冲区
// vsprintf与sprintf类似，但接收的是可变参数列表，对封装格式，要用vsprintf
vsprintf(String, format, arg);
va_end(arg); //释放参数列表
Serial_SendString(String);
}
//获取串口接收标志位
uint8_t Serial_GetRxFlag(void)
{
if(Serial_RxFlag == 1)
{
Serial_RxFlag = 0;
return 1;
}
return 0;
}
//获取串口接收的数据
uint8_t Serial_GetRxData(void)
{
return Serial_RxData;
}
//中断处理
void USART1_IRQHandler(void)
{
//先判断标志位
if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == SET)
{
Serial_RxData = USART_ReceiveData(USART1);
Serial_RxFlag = 1; //传输标志位
USART_ClearITPendingBit(USART1, USART_IT_RXNE); //手动清零
}
}
main.c
#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "MYOLED.h"
#include "Serial.h"
uint8_t RxData; //接收的数据
int main(void)
{
MYOLED_Init();
Serial_Init();
MYOLED_ShowString(0,0,"RxData:");
// Serial_SendByte('A');
// uint8_t MyArray[] = {0x42, 0x43, 0x44, 0x45};
// Serial_SendArray(MyArray, 4);
// Serial_SendString("OK\r\n"); //win中\r\n是换行
// Serial_SendNumber(114514, 6);
// printf("Num=%d\r\n", 114514);
// char String[100];
// sprintf(String, "Num=%d\r\n", 114514); //sprintf可以指定打印位置，不涉及重定向的东西，所以每个串口都可以使用sprintf进行格式化打印
// Serial_SendString(String); //可以封装sprintf
// Serial_Printf("牡蛎莫牡蛎%d\r\n", 114514); //我用的是UTF-8编码
while(1)
{
if(Serial_GetRxFlag() == 1)
{
RxData = Serial_GetRxData();
Serial_SendByte(RxData); //把接收到的数据回传电脑
MYOLED_ShowHexNum(7,0,RxData,2);
}
}
}
HAL库实现
已开源到：https://gitee.com/qin-ruiqian/jiangkeda-stm32-hal
在上一篇文章的基础上，把中断使能打开
然后把NVIC分组设置一下
Serial.h
/*
* Serial.h
*
* Created on: Aug 19, 2025
* Author: Administrator
*/
#ifndef HARDWARE_SERIAL_H_
#define HARDWARE_SERIAL_H_
//为了重写printf的全局变量
extern UART_HandleTypeDef* __printf_uhtd;
#include <stdio.h>
typedef struct Serial{
UART_HandleTypeDef* uhtd;
uint8_t Serial_RxData; //串口接收的数据
uint8_t Serial_RxFlag; //串口接收标志位
}Serial;
void Serial_Init(Serial* pSerial, UART_HandleTypeDef* uhtd);
void Serial_SendByte(Serial* pSerial, uint8_t Byte);
void Serial_SendArray(Serial* pSerial, uint8_t *Array, uint16_t Length);
void Serial_SendNumber(Serial* pSerial, uint32_t Number, uint8_t Length);
void Serial_SendString(Serial* pSerial, char *String);
void Serial_Printf(Serial* pSerial, char* format, ...);
uint8_t Serial_GetRxFlag(Serial* pSerial);
uint8_t Serial_GetRxData(Serial* pSerial);
#endif /* HARDWARE_SERIAL_H_ */
Serial.c
/*
* Serial.c
*
* Created on: Aug 19, 2025
* Author: Administrator
*/
#include "stm32f1xx_hal.h"
#include "Serial.h"
#include "stdio.h" //重写printf
#include "stdarg.h" //封装用
#include "string.h" //获取字符串长度
UART_HandleTypeDef* __printf_uhtd;
//初始化
//传指针方便更新状态
//如果初始化函数中对句柄采用值传递（而非指针传递），会导致句柄状态无法被正确更新，进而使中断启动失败。
void Serial_Init(Serial* pSerial, UART_HandleTypeDef* uhtd)
{
pSerial->uhtd = uhtd;
__printf_uhtd = uhtd;
pSerial->Serial_RxData = 0;
pSerial->Serial_RxFlag = 0;
HAL_UART_Receive_IT(pSerial->uhtd, &(pSerial->Serial_RxData), 1);
}
// 串口发送一个字节的数据
void Serial_SendByte(Serial* pSerial, uint8_t Byte)
{
HAL_UART_Transmit(pSerial->uhtd, &Byte, 1, HAL_MAX_DELAY);
}
// 发送一个数组
// Array是数组首地址
// Length是数组长度
void Serial_SendArray(Serial* pSerial, uint8_t *Array, uint16_t Length)
{
HAL_UART_Transmit(pSerial->uhtd, Array, Length, HAL_MAX_DELAY);
}
// 发送一个字符串
void Serial_SendString(Serial* pSerial, char *String)
{
HAL_UART_Transmit(pSerial->uhtd, (uint8_t *)String, strlen(String), HAL_MAX_DELAY);
}
//取次方函数
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
uint32_t Result = 1;
while(Y--)
{
Result *= X;
}
return Result;
}
//发送一个数字
void Serial_SendNumber(Serial* pSerial, uint32_t Number, uint8_t Length)
{
uint8_t i = 0; // 循环遍历
for (i = 0; i < Length; i++)
{
//从个位开始发
Serial_SendByte(pSerial, Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
}
}
//STM32CubeIDE用的是GCC
//Keil是fputc可以，STM32CubeIDE是用GCC，用的是__io_putchar
//此处是条件编译语句，让两类编译器都兼容
#ifdef __GNUC__
int __io_putchar(int ch)
{
uint8_t data = (uint8_t)ch; // 显式转换为uint8_t（1字节），匹配串口传输的字节类型
HAL_UART_Transmit(__printf_uhtd, &data, 1, HAL_MAX_DELAY);
return ch;
}
#else
int fputc(int ch, FILE *stream)
{
uint8_t data = (uint8_t)ch; // 显式转换为uint8_t（1字节），匹配串口传输的字节类型
HAL_UART_Transmit(__printf_uhtd, &data, 1, HAL_MAX_DELAY);
return ch;
}
#endif
//对sprintf进行封装
//用可变参数
void Serial_Printf(Serial* pSerial, char* format, ...)
{
char String[100]; //定义缓冲区存储格式化后的字符串
va_list arg; // 声明可变参数列表
va_start(arg, format); //从format位置开始接收参数列表，放在arg里面
// 使用vsprintf将格式化字符串写入缓冲区
// vsprintf与sprintf类似，但接收的是可变参数列表，对封装格式，要用vsprintf
vsprintf(String, format, arg);
va_end(arg); //释放参数列表
HAL_UART_Transmit(pSerial->uhtd, (uint8_t *)String, strlen(String), HAL_MAX_DELAY);
}
//获取串口接收标志位
uint8_t Serial_GetRxFlag(Serial* pSerial)
{
if(pSerial->Serial_RxFlag == 1)
{
pSerial->Serial_RxFlag = 0;
return 1;
}
return 0;
}
//获取串口接收的数据
uint8_t Serial_GetRxData(Serial* pSerial)
{
return pSerial->Serial_RxData;
}
main.c
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2025 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "Serial.h"
#include "MYOLED.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
Serial serial;
uint8_t RxData; //接收的数据
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
// HAL库中断回调：接收1字节完成后触发
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1)
{
// 重新开启中断，等待下一个字节
HAL_UART_Receive_IT(&huart1, &(serial.Serial_RxData), 1);
serial.Serial_RxFlag = 1; // 设置接收标志
}
}
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_USART1_UART_Init();
/* USER CODE BEGIN 2 */
MYOLED_Init();
Serial_Init(&serial, &huart1);
MYOLED_ShowString(0,0,"RxData:");
//HAL_UART_Receive_IT(&huart1, &(serial.Serial_RxData), 1);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
if(Serial_GetRxFlag(&serial) == 1)
{
RxData = Serial_GetRxData(&serial);
Serial_SendByte(&serial, RxData); //把接收到的数据回传电脑
MYOLED_ShowHexNum(7,0,RxData,2);
}
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
实现效果
浙公网安备 33010602011771号