【STN32】分享是标准库的STM32F103C8T6的串口123(USART1、USART2、USART3)的初始化代码，使用宏定义裁切串口点c文件

已于 2025-03-06 13:06:24 修改
阅读量572 收藏 7
点赞数 5
文章标签： stm32 c语言 嵌入式硬件
于 2025-03-06 13:04:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79711406/article/details/146063646
版权

前言：本代码使用宏定义的方式裁切.c .h文件，不用担心放在工程中编译后产生对应的bin（编译后不会产生usart的内容）

代码框架：

有三个宏定义控制整个.c 和 .h的裁剪（注释宏定义则关闭相关函数）

 代码功能：

① 实现波特率115200，8位数据位，1位停止位，无校验位，tx，rx的初始化（接收数据使用的是串口的rx中断）

② 实现c库中的printf的重定向（在代码中需解开注释才可用，在中断服务函数下面int fputc(int ch, FILE* f) ）

③ 实现不定长度的数据包收发（只有串口1书写了，可根据自己的需求完善其他串口）

代码讲解：

1. 数据包发送函数：在初始化串口后，只需调用一次即可发送data数据内len长度的数据包。

2.数据包接收：Rxdata1为每一个数据，RxPack1为接收的数据包数据不含包头包尾（后面的数字为对应的串口）变量已经在头文件extern出去了，在别的文件直接调用即可。其中数据包每完成一次接收会有一个标志位pack1_f，使用函数USART1_GetPackFlag即可获得。

完整代码： （直接可用）

头文件内容：

#ifndef __USART_H_
#define __USART_H_

/**** 头文件 ****/
#include "stm32f10x.h"
#include <stdio.h>

/**** 宏定义 ****/
#define EN_USART1   //使用串口1
#define EN_USART2   //使用串口2
#define EN_USART3   //使用串口3

/**** 函数 ****/
#ifdef EN_USART1
void USART1_Init(void);
void USART1_SendByte(u8 byte);
void USART1_SendString(char* str);
void USART1_IRQHandler(void);

void USART1_SendPack(uint8_t* dat, u8 len, u8 top, u8 tail);
s8 USART1_GetPackFlag(void);

extern u8 Rxdata1;   // 数据
extern u8 RxPack1[4];// 数据包
#endif //EN_USART1

#ifdef EN_USART2
void USART2_Init(void);
void USART2_SendByte(u8 byte);
void USART2_SendString(char* str);
void USART2_IRQHandler(void);

extern u8 Rxdata2;
#endif //EN_USART2

#ifdef EN_USART3
void USART3_Init(void);
void USART3_SendByte(u8 byte);
void USART3_SendString(char* str);
void USART3_IRQHandler(void);

extern u8 Rxdata3;
#endif //EN_USART3

#endif // __USART_H_

.c内容 

#include "usart.h"

#ifdef EN_USART1
/***********************************************************
*@fuction	: USART1_Init
*@brief		: USART1 初始化
*@param		: None
*@return	: None
*@author	: HongScholar
*@date		: 2025.01.12
***********************************************************/
void USART1_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

	//USART1_TX   PA9
    GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIOA->LCKR = 0x00010000 | GPIO_Pin_9;
    GPIOA->LCKR = GPIO_Pin_9;
    GPIOA->LCKR = 0x00010000 | GPIO_Pin_9;
    GPIOA->LCKR;
    GPIOA->LCKR;

	//USART1_RX	  PA10
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIOA->LCKR = 0x00010000 | GPIO_Pin_10;
    GPIOA->LCKR = GPIO_Pin_10;
    GPIOA->LCKR = 0x00010000 | GPIO_Pin_10;
    GPIOA->LCKR;
    GPIOA->LCKR;
    
    USART_InitTypeDef USART_InitStructure;
	USART_DeInit(USART1);
	USART_InitStructure.USART_BaudRate = 115200;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_Init(USART1, &USART_InitStructure);
    
	USART_Cmd(USART1, ENABLE);

	// 开启接收中断
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);

	// 设置中断优先级
    NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;// 抢占优先级
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;     // 响应优先级
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
}

/***********************************************************
*@fuction	: USART1_SendByte
*@brief		: USART1 发发送一个字节
*@param		: 数据
*@return	: None
*@author	: HongScholar
*@date		: 2025.01.12
***********************************************************/
void USART1_SendByte(u8 byte)
{
    USART_SendData(USART1, byte);
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}


void USART1_SendString(char* str)
{
    while(*str != '\0')
        USART1_SendByte(*str++);
}

/***********************************************************
*@fuction	: USART1_SendPack
*@brief		: USART1 发送数据包 帧头01 帧尾68
*@param		: 数据, 长度, 包头, 包尾
*@return	: None
*@author	: HongScholar
*@date		: 2025.01.12
***********************************************************/
void USART1_SendPack(uint8_t* dat, u8 len, u8 top, u8 tail)
{
    USART1_SendByte(top);
    for(uint8_t i=0; i<len; i++)
        USART1_SendByte(dat[i]);
    USART1_SendByte(tail);
}

s8 pack1_f; // 数据包接收完成标志位
u8 RxPack1[4];// 数据包

/***********************************************************
*@fuction	: USART1_GetPackFlag
*@brief		: USART1 获取接收数据包完成标志位
*@param		: None
*@return	: 1: finish 
             -1: err 接收错误
              0: empty
*@author	: HongScholar
*@date		: 2025.01.12
***********************************************************/
s8 USART1_GetPackFlag(void)
{
    if(pack1_f == 1)
    {
        pack1_f = 0;
        return 1;
    }
    else if(pack1_f == -1)
    {
        pack1_f = 0;
        return -1;
    }
    else
        return 0;
}

/***********************************************************
*@fuction	: USART1_GetPack
*@brief		: USART1 接收数据包 帧头01 帧尾68
*@param		: USRT1->DR, 无帧头帧尾的数据包, 包长, 帧头, 帧尾
*@return	: None
*@author	: HongScholar
*@date		: 2025.01.12
***********************************************************/
void USART1_GetPack(uint8_t* DR, u8* dat, u8 len, u8 top, u8 tail)
{
    static u8 rx1_s;   // 接收进程
    static u8 p_rx1;   // 数据帧
    
    
    /* 接收帧头*/
    if(rx1_s == 0)
    {
        if(*DR == top)// 帧头
        {
            rx1_s = 1;
            p_rx1 = 0;
        }
    }/* 接收数据*/
    else if(rx1_s == 1)
    {
        dat[p_rx1] = *DR;
        p_rx1++;
        if(p_rx1 == len)
        {
            rx1_s = 2;
            p_rx1 = 0;
        }
    }/* 接收帧尾*/
    else if(rx1_s == 2)
    {
        if(*DR == tail)// 帧尾
        {
            rx1_s = 0;
            pack1_f = 1;
        }
        else/* 接收错误, 清空之前接收*/
        {
            pack1_f = -1;
            for(uint8_t i=0; i<len; i++)
                dat[i] = 0x00;
        }
    }
}

u8 Rxdata1;
void USART1_IRQHandler(void) 
{
	if(USART_GetITStatus(USART1, USART_IT_RXNE) == SET)
	{
		Rxdata1 = USART_ReceiveData(USART1);	//读取接收到的数据
        USART1_GetPack(&Rxdata1, RxPack1, 4, 0x01, 0x68);
        
        USART_ClearITPendingBit(USART1, USART_IT_RXNE);
    }	  
}

/* 重印相printf*/
//int fputc(int ch, FILE* f)
//{
//    USART1_SendByte(ch);
//    return ch;
//}
#endif //EN_USART1

#ifdef EN_USART2
void USART2_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

	//USART2_TX   PA2
    GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_PinLockConfig(GPIOA, GPIO_Pin_2);

	//USART2_RX	  PA3
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_PinLockConfig(GPIOA, GPIO_Pin_3);
    
    USART_InitTypeDef USART_InitStructure;
	USART_DeInit(USART2);
	USART_InitStructure.USART_BaudRate = 9600;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_Init(USART2, &USART_InitStructure);
    
	USART_Cmd(USART2, ENABLE);

	// 开启接收中断
	USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);

	// 设置中断优先级
    NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;// 抢占优先级
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;     // 响应优先级
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
}

void USART2_SendByte(uint8_t byte)
{
    USART_SendData(USART2, byte);
    while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);
}

void USART2_SendString(char* str)
{
    while(*str != '\0')
    {
        USART2_SendByte(*str++);
    }
}

u8 Rxdata2;
void USART2_IRQHandler(void) 
{
	if(USART_GetITStatus(USART2, USART_IT_RXNE) == SET)
	{
		Rxdata2 = USART_ReceiveData(USART2);	//读取接收到的数据
        USART_ClearITPendingBit(USART2, USART_IT_RXNE);
    }	  
}

/* 重印相printf*/
//int fputc(int ch, FILE* f)
//{
//    USART2_SendByte(ch);
//    return ch;
//}
#endif //EN_USART2

#ifdef EN_USART3
void USART3_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);

	//USART3_TX   PB10
    GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
    GPIO_PinLockConfig(GPIOB, GPIO_Pin_10);

	//USART3_RX	  PB11
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
    GPIO_PinLockConfig(GPIOB, GPIO_Pin_11);
    
    USART_InitTypeDef USART_InitStructure;
	USART_DeInit(USART3);
	USART_InitStructure.USART_BaudRate = 9600;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_Init(USART3, &USART_InitStructure);
    
	USART_Cmd(USART3, ENABLE);

	// 开启接收中断
	USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);

	// 设置中断优先级
    NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;// 抢占优先级
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;     // 响应优先级
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
}

void USART3_SendByte(uint8_t byte)
{
    USART_SendData(USART3, byte);
    while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);
}

void USART3_SendString(char* str)
{
    while(*str != '\0')
    {
        USART3_SendByte(*str++);
    }
}

u8 Rxdata3;
void USART3_IRQHandler(void) 
{ 
	if(USART_GetITStatus(USART3, USART_IT_RXNE) == SET)
	{
		Rxdata3 = USART_ReceiveData(USART3);	//读取接收到的数据
        USART_ClearITPendingBit(USART3, USART_IT_RXNE);
    }	  
}

/* 重印相printf*/
//int fputc(int ch, FILE* f)
//{
//    USART3_SendByte(ch);
//    return ch;
//}
#endif //EN_USART3

作者希望所有读者一路顺风，发现乐趣！敬请期待...

HongScholar
关注
STM32学习笔记（四）串口配置（stm32c8t6）
RobertPeiGen的博客
12-30 1038
串口配置
STM32F103C8-USART1~3串口配置
m0_74282249的博客
04-07 1897
/定义引脚GPIO 9。
STM32单片机初学7-USART串口通信
qq_55203246的博客
08-11 5399
USART是Universal Synchronous/Asynchronous Receiver/Transmitter的英文缩写，意为通用同步/异步串行接收/发送器。它也是单片机中最常用通信方式之一。
STM32F103C8T6多串口同时启用实战教程
weixin_42591908的博客
10-07 2934
本文还有配套的精品资源，点击获取 简介：本文介绍了如何在STM32F103C8T6微控制器上同时激活三个串口（USART1、USART2、USART3）。通过详细介绍串口配置、波特率计算、时钟控制、中断处理等关键步骤，本项目教程旨在为开发者提供一个详细的多串口通信应用指南。使用HAL库或LL库简化操作，并确保数据传输的稳定性和实时性。教程包含代码示例，适合STM32系列微控...
STM32F030C8T6串口例程
11-28
STM32F030C8T6串口例程 非常适合初学者入门学习，mdk5平台
实验三、485通讯
王同学
12-28 525
485通讯
STM32F103C8T6例程.zip_STM32F103C8T6 AD_courtwai_exclaimedty8_stm32
07-15
STM32F103C8T6包含12个定时器：6个基本定时器（TIM6和TIM7）、2个高级定时器（TIM1和TIM8）、2个通用定时器（TIM2、TIM3和TIM4）以及2个PWM接口定时器（TIM5和TIM9到TIM14）。这些定时器可以用于生成脉冲、捕获输入...
【STM32F103C8T6】多路USART串口Printf重定向标准库版
最新发布
12-28
STM32F103C8T6微控制器通过多路USART串口Printf重定向，可以让开发者在使用标准库函数时更加方便地进行串口通信，提高了开发效率和系统的可维护性。这对于那些需要复杂通信协议或者多通道数据处理的嵌入式应用尤为...
STM32F103c8t6-USART收发.7z
03-28
3. **GPIO配置**：STM32F103C8T6的USART通信通常通过特定的GPIO引脚实现，例如PA9（USART1_TX）和PA10（USART1_RX）。需要将这些引脚配置为推挽输出和上拉输入，并设置合适的GPIO模式（如alternate function）。 4....
STM32F103C8T6资料
02-21
3. **外设接口**：STM32F103C8T6提供了丰富的外设接口，包括多个定时器（如TIM）、串行通信接口（如USART和SPI）、I&sup2;C总线、CAN控制器、ADC（模数转换器）、DMA（直接存储器访问）、USB以及GPIO（通用输入输出）等...
STM32F103C8T6的串口1和串口3收发实验
11-30
串口1、3接收有后缀"\r\n"和无后缀"\r\n"的不定长数据（不得超过固定长度） 串口1通过重定义printf打印接收到串口1和串口3的数据，当接收到指定字符串则通过串口3发送指定字符串
STM32c8t6_3个串口.rar
09-10
STM32C8T6 三个串口源码,STM32单片机，三个串口设置配置实验源码实例，STM32 串口 串口 STM32
STM32F030C8T6.串口例程
05-23
STM32F030C8T6 串口例程
STM32F103C8T6串口1空闲中断+DMA接收不定长数据源代码.zip
07-21
在这个项目中，我们将深入探讨如何利用STM32F103C8T6的串口1（USART1）配合DMA（Direct Memory Access）进行数据接收，并处理不定长度的数据。 串口通信是微控制器与外部设备之间进行数据交换的一种常见方式，特别...
GD32F103VE串口中断发送和接收
weixin_42550185的博客
08-09 2920
GD32F103VE串口中断发送和接收，本程序基于RS485完成测试，实现将收到的数据，再发送出去。
GD32f103-USART串口学习
weixin_44501991的博客
11-07 1813
STM32 USART通信协议详细讲解—小白入门_stm32 usart cts rts-CSDN博客从上图红色区域为芯片外部也就是引脚，其他在芯片内部，重要引脚描述如下引脚类型描述RX输入接收数据TX输出I/O(单线模式/智能卡模式)发送数据。当USART使能后，若无数据发送，默认为高电平CK输出用于同步通信的串行时钟信号nCTS输入硬件流控模式发送使能信号nRTS输出硬件流控模式发送请求信号函数名描述功能复位外设输入参数：功能配置USART波特率。
基于STM32F103C8T6的USART1串口的中断接收
weixin_72921448的博客
10-24 4632
中断
STM32F103C8T6学习笔记_串口USART的使用
热门推荐
lab111的博客
11-23 2万+
1、     M  bps                 兆   比特每秒                   Million     bits per second      (形容传输速率)     波特率（Baud）(bound )          单位 Bd    (形容传输速率时  Bd/s） 如果是二进制的话 ， 都表示单位时间内传输的二进制数 2、
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值