【自学嵌入式：stm32单片机】串口发送

目录

串口发送

接线图

image

引脚定义

image
USART1的TX是PA9，RX是PA10，我们要用USART进行通信，所以就选这两个脚

数据模式

  • HEX模式/十六进制模式/二进制模式：以原始数据的形式显示
  • 文本模式/字符模式：以原始数据编码后的形式显示

image

image

代码实现

标准库实现

已开源到：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, ...);

#endif

Serial.c

#include "stm32f10x.h" // Device header
#include "stdio.h" //重写printf
#include "stdarg.h" //封装用

// 初始化串口通信
void Serial_Init(void)
{
    // 开启时钟，USART1是APB2的外设，其他的串口都是APB1的外设
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
    // 开启GPIO时钟，后续在PA9 PA10读写数据
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    // 初始化GPIO引脚
    // 目前只需要数据发送，所以只初始化TX即可
    // 将PA9配置为复用推挽输出，供USART1的TX使用
    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);
    // 初始化USART
    USART_InitTypeDef USART_InitStructure;
    USART_InitStructure.USART_BaudRate            = 9600;                           // 波特率
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // 不使用流控
    USART_InitStructure.USART_Mode                = USART_Mode_Tx;                  // 只发送，TX
    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);
}

// 串口发送一个字节的数据
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);
}

main.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "MYOLED.h"
#include "Serial.h"

int main(void)
{
	MYOLED_Init();
	Serial_Init();
	Serial_SendByte('A');
	uint8_t MyArray[] = {0x42, 0x43, 0x44, 0x45};
	Serial_SendArray(MyArray, 4);
	Serial_SendString("Testing\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)
	{
		
	}
}

HAL库实现

已开源到：https://gitee.com/qin-ruiqian/jiangkeda-stm32-hal
关于USART1在IDE中的配置：
image

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;
}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, ...);

#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;
}

// 串口发送一个字节的数据
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);
}

//初始串口

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"
#include "Serial.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* 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 */

/* 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 */

/* 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 */
  Serial serial;
  Serial_Init(&serial, huart1);
  Serial_SendByte(&serial, 'A');
  uint8_t MyArray[] = {0x42, 0x43, 0x44, 0x45};
  Serial_SendArray(&serial, MyArray, 4);
  Serial_SendString(&serial, "Testing\r\n"); //win中\r\n是换行
  Serial_SendNumber(&serial, 114514, 6);
  printf("Num=%d\r\n", 114514);
  char String[100];
  sprintf(String, "Num1=%d\r\n", 114514); //sprintf可以指定打印位置，不涉及重定向的东西，所以每个串口都可以使用sprintf进行格式化打印
  Serial_SendString(&serial, String); //可以封装sprintf
  Serial_Printf(&serial, "牡蛎莫牡蛎%d\r\n", 114514); //我用的是UTF-8编码
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* 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_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  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_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != 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 */

实现效果

image

posted @ 2025-08-19 20:38  秦瑞迁  阅读(45)  评论(0)    收藏  举报