波特率，串口通信的速率
空闲，一般为高电平
起始位，标志一个数据帧的开始，固定为低电平。当数据开始发送时，产生一个下降沿。(空闲–>起始位)
数据位，发送数据帧，1为高电平，0为低电平。低位先行。
比如发送数据帧0x0F 在数据帧里就是低位线性即 1111 0000
校验位，用于数据验证，根据数据位的计算得来。有奇校验，偶校验和无校验。
停止位，用于数据的间隔，固定为高电平。数据帧发送完成后，产生一个上升沿。(数据传输–>停止位)

下方就是一个字节数据的传输过程，从图中可以看出，串口发送的数据一般都是以数据帧的形式进行传输，每个数据帧都由起始位，数据位，停止位组成，且停止位可变。

2，串口的发送和接收

USART是STM32内部集成的硬件外设，可以根据数据寄存器的一个字节数据自动生成数据帧时序，从TX引脚发送出去，也可以自动接收RX引脚的数据帧时序，拼接成一个字节数据，存放在数据寄存器里。

当配置好USART的电路之后，直接读取数据寄存器，就可以自动发送数据和接收数据了。在发送和接收的模块有4个重要的寄存器

发送数据寄存器TDR
发送移位寄存器，把一个字节的数据一位一位的移出去
接收数据寄存器RDR
接收移位寄存器，把一个字节的数据

下方为串口的发送和接收图解：

串口发送：

在配置串口的各个参数时，可以选择发送数据帧的数据位的大小，可选8位或9位。

串口发送数据实际上就是对发送数据寄存器TDR进行写操作。

1. 当串口发送数据时，会检测发送移位寄存器是不是有数据正在移位，如果没有移位，那么这个数据就会立刻转移到发送移位寄存器里。准备发送。

2. 当数据移动到移位寄存器时，会产生一个TXE发送寄存器空标志位，该位描述如下。当TXE被置1，那么就可以在TDR写入下一个数据了。即发送下一个数据。

3. 发送移位寄存器在发送器控制的控制下，向右移位，一位一位的把数据传输到TX引脚。

4. 数据移位完成后，新的数据就会再次从TDR转移到发送移位寄存器里来，依次重复1-3的过程。通过读取TXE标志位来判断是否发送下一个数据。

串口接收：

数据从RX引脚通向接收移位寄存器，在接收控制的控制下，一位一位的读取RX的电平，把第一位放在最高位，然后右移，移位八次之后就可以接收一个字节了。
当一个字节数据移位完成之后，这一个字节的数据就会整体的移到接收数据寄存器RDR里来。
在转移时会置RXNE接收标志位，即RDR寄存器非空，下方为该位的描述。当被置1后，就说明数据可以被读出。

下图即为串口接收的工作流程

串口在STM32中的配置：

1. RCC开启USART、串口TX/RX所对应的GPIO口


RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);  //开启USART2的时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);   //开启GPIOA的时钟

2. 初始化GPIO口

这里注意哈，根据自己的需求来配置GPIO口，发送和接收是都需要还是只需要其中一个。然后对应的根据引脚定义表来初始化对应的GPIO口。

USART3对应的引脚

USART2对应的引脚

USART1对应的引脚

这里根据手册来看，RX引脚模式配置成浮空输入或者上拉输入。TX引脚模式配置成复用推挽输出。


    GPIO_InitTypeDef GPIO_InitStructure;
 
    // USART3 TX -> PB10
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);   
 
    // USART3 RX -> PB11
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

3. 串口初始化

注意哈，USART_Init()这个函数，是用来配置串口的相关参数的。

USART_BaudRate 串口通信使用的波特率一般是9600或者是115200，这里我们给9600
USART_HardwareFlowControl 是否选择硬件流触发，一般这个我们也不选，所以选择无硬件流触发。
USART_Mode 这个参数要注意了哈，串口的模式，发送模式还是接收模式，还是两者都有，这里使用收发模式
USART_Parity 校验位，可以选择奇偶校验和不校验。没有需求就直接无校验
USART_StopBits 停止位有1、0.5、2位，我们这里选1位停止位
USART_WordLength 数据位有8位和9位可以选择


 //串口初始化
	USART_InitTypeDef USART_InitStruct;
	USART_StructInit(&USART_InitStruct);  //初始默认值
	USART_InitStruct.USART_BaudRate=9600;
	USART_InitStruct.USART_HardwareFlowControl=USART_HardwareFlowControl_None;   //不使用硬件流触发
	USART_InitStruct.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;	//收发模式（TX 发送模式  RX 接收模式）   			
	USART_InitStruct.USART_Parity=USART_Parity_No;   		//不选择校验
	USART_InitStruct.USART_StopBits=USART_StopBits_1;  		//停止位1位
	USART_InitStruct.USART_WordLength=USART_WordLength_8b;	//数据位8位
	USART_Init(USART3,&USART_InitStruct);

4. 串口使能


//串口使能
   USART_Cmd(USART3,ENABLE);

5. 串口发送数据

注意哈，我们要判断TXE标志位的状态。0，数据还没有被转移到移位寄存器；1,数据已经被转移到移位寄存器。当TXE标志位为1时，就说明可以发送下一个数据了。详细过程可看上面串口发送的解释。


//串口3发送一个字节
void Usart3_SendByte(u8 val)
{
    USART_SendData(USART3, val);
	//0 表示数据还未转移到移位寄存器 循环等待 1 数据已经被转移到了移位寄存器可以发送数据
    while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET);	//等待发送完成,不需要手动清零 再次写入TDR时会自动清零	
}

经过上述五步的配置，单片机就可以通过串口发送数据了。

串口接收的两种实现方式：

串口接收通常可以通过轮询（Polling）和中断（Interrupt）两种方式来实现。

轮询方式就是通过不断的查询RXNE标志位，通过判断RXNE位的状态来确定数据是否接收。
中断方式就是通过配置接收输出控制通道，配置NVIC，在中断服务子函数里进行数据的接收。

1，轮询方式：

在轮询方式中，程序通过不断地查询串口接收缓冲区是否有数据到达。当检测到数据到达时，程序立即读取接收缓冲区中的数据。

优点：

实现简单，易于理解。
可以直接在接收到数据后立即进行处理。
适合于数据传输量不大且CPU负荷较轻的场合。

缺点：

需要不断地轮询串口接收缓冲区，占用 CPU 资源。
无法及时响应其他任务或事件。
效率较低，可能会错过一些数据。

实现步骤：
配置串口：设置串口的波特率、数据位数、停止位等参数。
轮询状态寄存器：不断检查USART的状态寄存器，判断接收缓冲区是否有新数据。
读取数据：一旦发现有新数据，立即从数据寄存器读取数据。

示例代码：


// 定义一个函数，用于轮询方式接收 USART 数据
void USART_Receive_Polling(void) {
    // 进入一个无限循环
    while(1) {
        // 检查接收缓冲区是否有数据
        if(USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == SET) {
            // 如果接收缓冲区有数据
            // 从接收缓冲区读取数据
            uint8_t data = USART_ReceiveData(USART3);
            // 处理接收到的数据
            // 这里可以添加代码来解析和处理接收到的数据
        }
        // 如果接收缓冲区无数据，则继续轮询
        // 可以添加延时以降低 CPU 占用率
        // delay_ms(10);
    }
}

2，中断方式：

在中断方式中，程序允许 MCU 在接收到数据时触发串口接收中断，并在中断服务函数中处理接收到的数据。当接收缓冲区有新数据时，硬件自动产生一个中断，CPU响应这个中断并执行中断服务程序来处理接收到的数据。

优点：

采用了中断机制，不需要不断地轮询串口接收缓冲区，减少了 CPU 的占用率。
效率高，可以及时响应其他任务或事件，提高了系统的实时性。
适合于数据量大或实时性要求高的应用

缺点：

实现相对复杂，需要编写中断服务函数。
在中断服务函数中对数据的处理需要考虑中断嵌套、优先级等问题，需要谨慎设计。

实现步骤：
配置串口：同轮询方式。
使能中断：在串口初始化中，使能USART的接收中断。
编写中断服务程序：实现USART的中断服务函数，该函数会在接收到新数据时被调用。
数据处理：在中断服务程序中读取接收到的数据，并进行相应的处理。

示例代码：


// USART3中断处理函数
void USART3_IRQHandler(void) {
    // 检查 USART3 接收中断标志位是否被设置
    if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET) {
        // 如果接收缓冲区非空
        // 从接收缓冲区读取数据
        uint8_t data = USART_ReceiveData(USART3);
        // 处理接收到的数据
        // 在这里可以添加代码来处理接收到的数据
    }
}
 
// 使 USART3 接收中断
void USART_Receive_Interrupt(void) {
    // 使能串口接收中断
    USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
    
    // 配置 USART3 中断优先级
    NVIC_InitTypeDef NVIC_InitStructure;
    // 设置中断通道为 USART3
    NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    // 设置中断抢占优先级为0
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    // 设置中断响应优先级为0
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    // 使能中断通道
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    // 初始化 NVIC
    NVIC_Init(&NVIC_InitStructure);
    
    // 进入一个无限循环，等待中断服务函数处理接收到的数据
    while(1) {
        // 在中断服务函数中处理接收到的数据
    }
}

查询RXNE标志位

这里我们还是来看一看RXNE标志位的描述

上图描述，为0时数据没有收到，为1时收到了数据，数据可以从RDR里读出

所以在主程序里不断读取RXNE标志位，如果为1，表示数据可以读出


uint8_t RX_Data; // 定义一个全局变量 RX_Data，用于存储接收到的数据
 
int main() // 主函数入口
{ 
    Serial_Init(); // 初始化串口
 
    Serial_SendByte(0x16); // 向串口发送一个字节数据 0x16
 
    while(1) // 进入一个无限循环
    {
        if(USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == SET) // 检查 USART2 接收缓冲区是否有数据，0=RESET 循环等待 ，1=SET 可以接收数据
        {
            RX_Data = USART_ReceiveData(USART2); // 如果接收缓冲区有数据，则从中读取数据并存储到 RX_Data 中
            Serial_SendByte(RX_Data); // 将接收到的数据发送回串口
        }
    }
}

if(USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == SET)

// 检查 USART2 接收缓冲区是否有数据，0=RESET 循环等待，1=SET 可以接收数据

下图为程序现象：pc向单片机发送数据0x15，单片机接收数据0x15，并且把接收到的数据作为数据发送到pc，在pc上显示0x15。

使用中断

通过配置串口的接收作为中断源，开启中断输出控制，配置NVIC。开启中断通道。


// 开启 USART2 接收中断
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
 
// 配置 NVIC（Nested Vectored Interrupt Controller，嵌套向量中断控制器）
 
// 设置 NVIC 分组优先级，选择分组 2
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
 
// 定义一个 NVIC_InitTypeDef 结构体变量，用于配置中断控制器
NVIC_InitTypeDef NVIC_InitStruct;
 
// 设置中断通道为 USART2，即选择 USART2 的中断通道
NVIC_InitStruct.NVIC_IRQChannel = USART2_IRQn;
 
// 使能中断通道
NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
 
// 设置抢占优先级为 1
NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
 
// 设置子优先级为 1
NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
 
// 将配置好的 NVIC_InitStruct 结构体变量传入 NVIC_Init 函数中，对 NVIC 进行配置
NVIC_Init(&NVIC_InitStruct);

中断服务子函数
中断服务子函数写好后，就可以在中断里读取接收到的数据了。
当接收到数据后，触发接收中断，主程序暂停执行。接收完数据后主程序回复执行。当接收到数据时，就触发中断。


void USART2_IRQHandler(void)
{
    // 检查 USART2 接收缓冲区是否有数据
    if(USART_GetITStatus(USART2, USART_IT_RXNE) == SET)   // RXNE 标志位为1 表示可以接收数据
    {
        // 从接收缓冲区读取数据并存储到 RX_Data 中
        RX_Data = USART_ReceiveData(USART2);
 
        // 设置标志位 Flag 为 1，表示已接收到数据
        Flag = 1;
 
        // 清除 USART2 接收中断标志位 RXNE
        USART_ClearITPendingBit(USART2, USART_IT_RXNE);  // 清除 RXNE 标志位
    }
}

主程序测试


uint8_t RX_Data; // 定义一个全局变量 RX_Data，用于存储接收到的数据
uint8_t Flag;    // 定义一个全局变量 Flag，用于表示是否接收到数据的标志位
 
int main() // 主函数入口
{
    Serial_Init(); // 初始化串口
    Serial_SendByte(0x16); // 向串口发送一个字节数据 0x16
 
    while(1) // 进入一个无限循环
    {
        if(Flag == 1) // 如果接收到数据的标志位为 1
        {
            Serial_SendByte(RX_Data); // 向串口发送接收到的数据，这里可以改为自己需要的逻辑
        }
    }
}
 
void USART2_IRQHandler(void) // USART2 中断服务函数
{
    if(USART_GetITStatus(USART2, USART_IT_RXNE) == SET) // 如果 USART2 接收到数据
    {
        RX_Data = USART_ReceiveData(USART2); // 从接收缓冲区读取数据并存储到 RX_Data 中
        Flag = 1; // 设置接收到数据的标志位 Flag 为 1
        USART_ClearITPendingBit(USART2, USART_IT_RXNE); // 清除 USART2 的接收中断标志位 RXNE，准备接收下一次数据
    }
}

下图为程序现象：可以看到，串口确实收到了数据，只是我把接收到的数据0xFE放在了while循环里，这说明数据接收是成功的，使用中断是可行的。

实战演练：

要求：使用stm32f103C8T6，使用标准库，硬件方面使用到了一个LED灯，要求在PC端串口助手发送"led on"，单片机的usart3接收到PC端发送的led on时，打开LED灯，同时向PC端发送“已打开”

为了实现提出的要求，你需要按照以下步骤进行编程和硬件配置：

硬件连接：

LED 灯连接到单片机的一个 GPIO 端口（比如 PA0）。
USART3 需要连接到 PC 通过串口或者通过串口转USB模块。

软件实现（使用STM32标准库）：

以下提供一个粗略的实现示例：

首先，确保你已经在项目中正确配置了 STM32F103 的标准库，以及正确设置系统时钟。

1. 初始化LED灯相应的GPIO口


void LED_Init(void) {
    GPIO_InitTypeDef GPIO_InitStructure; // 定义一个 GPIO_InitTypeDef 结构体变量，用于配置 GPIO
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); // 开启 GPIOA 时钟
    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; // 设置要初始化的引脚为 PA0
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // 设置引脚工作模式为推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // 设置引脚的输出速度为 50MHz
    
    GPIO_Init(GPIOA, &GPIO_InitStructure); // 初始化 GPIOA 的 PA0 引脚
    GPIO_SetBits(GPIOA, GPIO_Pin_0); // 将 PA0 引脚输出高电平，默认关闭 LED
}

2. 初始化USART3


void USART3_Init(void) {
    GPIO_InitTypeDef GPIO_InitStructure; // 定义一个 GPIO_InitTypeDef 结构体变量，用于配置 GPIO
    USART_InitTypeDef USART_InitStructure; // 定义一个 USART_InitTypeDef 结构体变量，用于配置 USART
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); // 打开 GPIOB 的时钟
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); // 打开 USART3 的时钟
    
    // 配置 USART3 的 TX 引脚为复用推挽输出模式
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; // 设置要初始化的引脚为 PB10
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; // 设置引脚工作模式为复用推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // 设置引脚的输出速度为 50MHz
    GPIO_Init(GPIOB, &GPIO_InitStructure); // 初始化 GPIOB 的 PB10 引脚
    
    // 配置 USART3 的 RX 引脚为浮空输入模式
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11; // 设置要初始化的引脚为 PB11
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; // 设置引脚工作模式为浮空输入
    GPIO_Init(GPIOB, &GPIO_InitStructure); // 初始化 GPIOB 的 PB11 引脚
    
    // 配置 USART3 的通信参数
    USART_InitStructure.USART_BaudRate = 9600; // 设置波特率为 9600
    USART_InitStructure.USART_WordLength = USART_WordLength_8b; // 设置数据位长度为 8 位
    USART_InitStructure.USART_StopBits = USART_StopBits_1; // 设置停止位为 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 的工作模式为接收和发送都使能
    USART_Init(USART3, &USART_InitStructure); // 初始化 USART3
    
    USART_Cmd(USART3, ENABLE); // 使能 USART3
}

3. 实现发送功能


void USART3_SendChar(char ch) {
    // 发送字符数据 ch 到 USART3
    USART_SendData(USART3, (uint8_t) ch);
 
    // 等待发送完成
    while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET);
}

4. 实现接收字符串功能

此部分可以通过中断或者轮询的方式实现。

1，通过轮询的方式检查是否接收到了特定的字符串：


void checkReceive(void) {
    uint8_t data; // 定义一个无符号 8 位整数型变量 data，用于存储接收到的数据
    char buffer[8]; // 定义一个长度为 8 的字符数组 buffer，用于存储接收到的数据
    int i = 0; // 定义一个整型变量 i，用于索引 buffer 数组
    
    // 进入一个循环，循环条件是 i 小于 7
    while (i < 7) {
        // 检查 USART3 接收缓冲区是否非空，即是否有数据可读
        if (USART_GetFlagStatus(USART3, USART_FLAG_RXNE) != RESET) {
            // 如果接收缓冲区非空，则读取接收到的数据并存储到 data 变量中
            data = (uint8_t)USART_ReceiveData(USART3);
            // 将读取到的数据存储到 buffer 数组中，并将索引 i 自增
            buffer[i++] = data;
        }
    }
    
    // 在 buffer 数组末尾添加字符串结束标志 '\0'
    buffer[i] = '\0';
    
    // 比较 buffer 数组中的内容是否为 "led on"
    if (strcmp(buffer, "led on") == 0) {
        // 如果接收到的数据是 "led on"，则执行以下操作
        
        // 打开 LED 灯，即将 GPIOA 的 PA0 引脚输出低电平
        GPIO_ResetBits(GPIOA, GPIO_Pin_0);
        
        // 定义一个指向字符串常量 "已打开" 的指针 msg
        char *msg = "已打开";
        
        // 进入一个循环，循环条件是指针 msg 指向的字符不为空字符 '\0'
        while (*msg) {
            // 发送指针 msg 指向的字符到 USART3，然后指针 msg 自增
            USART3_SendChar(*msg++);
        }
    }
}

注意：这里并没有添加中断服务程序，也没有实现字符缓存区的溢出处理，此外，发送和接收字符的精确处理逻辑可能需要根据实际需求调整。实际项目中还可能需要考虑debounce（消抖）和更加复杂的串口命令解析。

务必确保单片机的时钟配置正确，并且USART3的引脚与你连接的外设相匹配。在进行硬件连线时也要确保正确连接。

2，通过中断的方式实现USART3接收特定的字符串：

要通过中断方式实现USART3接收字符串，我们需要做几件事情：

配置NVIC以使能USART3中断。
在USART3初始化函数中开启接收中断。
编写USART3的中断服务函数来处理接收到的字节。

这种实现方式相比轮询，可以有效减少CPU的负担，特别是在数据不频繁接收时。

1. 配置NVIC以使能USART3中断

在USART3_Init函数中，初始化USART3后，你应该使能中断：


NVIC_InitTypeDef NVIC_InitStructure; // 定义一个 NVIC_InitTypeDef 结构体变量，用于配置 NVIC 中断控制器
 
// 设置 NVIC 优先级分组为 2
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
 
// 设置中断源为 USART3
NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
// 设置抢占优先级为 1
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
// 设置子优先级为 1
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
// 使能中断通道
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
// 初始化 NVIC
NVIC_Init(&NVIC_InitStructure);
 
// 使能 USART3 接收中断
USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);

2. 在USART3初始化函数中开启接收中断

已经在上面的步骤中通过调用USART_ITConfig来实现了。

3. 编写USART3的中断服务函数来处理接收到的字节

你要定义一个缓冲区来存储接收到的字符，并在接收到整个字符串后进行处理：


#define BUFFER_SIZE 100 // 定义缓冲区大小为 100
char buffer[BUFFER_SIZE]; // 声明一个大小为 BUFFER_SIZE 的字符数组作为接收缓冲区
volatile unsigned int buffer_index = 0; // 声明一个无符号整数变量，用于表示当前缓冲区的索引位置，使用 volatile 关键字声明，表示在中断中可能被改变，需要及时更新
 
void USART3_IRQHandler(void) { // 定义 USART3 的中断服务函数
    // 检查是否接收到数据
    if (USART_GetITStatus(USART3, USART_IT_RXNE) != RESET) { // 如果接收到 USART3 的接收中断标志位
        char data = (char)USART_ReceiveData(USART3); // 读取接收到的数据，并转换为字符类型
 
        // 简单的字符串终止判断（例如以换行结束）
        if (data != '\n' && buffer_index < BUFFER_SIZE - 1) { // 如果接收到的字符不是换行且缓冲区索引未超过最大长度减一
            buffer[buffer_index++] = data; // 将接收到的字符存入缓冲区中，并更新索引
        } else { 
            buffer[buffer_index] = '\0'; // 确保字符串结束，即在缓冲区最后添加 '\0' 表示字符串结束
 
            // 检查接收到的命令
            if (strcmp(buffer, "led on") == 0) { // 如果接收到的命令是 "led on"
                GPIO_ResetBits(GPIOA, GPIO_Pin_0); // 点亮 LED
                char *msg = "已打开\n"; // 定义一个指向字符串的指针，表示要发送的消息
                while (*msg) { // 循环发送消息中的每一个字符，直到遇到 '\0' 表示字符串结束
                    USART3_SendChar(*msg++); // 发送字符并将指针移向下一个字符
                }
            }
 
            // 重置索引，准备下一次接收
            buffer_index = 0; // 将缓冲区索引重置为 0，准备接收下一条命令
        }
 
        USART_ClearITPendingBit(USART3, USART_IT_RXNE); // 清除接收中断标志位，准备下一次接收中断
    }
}

这个示例代码会在接收到一串字符后处理这串字符。如果接收到的字符串是"led on"加上换行符'\n'，它将点亮LED并通过USART3发送回"已打开\n"。

注意：实际上你可能需要添加更多的错误处理和缓冲区管理来处理可能出现的错误和异常情况（比如缓冲区溢出）。

此外，为了让上述代码正常工作，请确保你的USART3接收中断已经正确配置，并且你的系统时钟设置支持你的串口通信需求。你可能还需要根据你的具体硬件连接调整GPIO端口初始化和LED操作的代码。

5. 主函数

在主函数里初始化LED和USART3，然后不断检查串口接收：


int main(void) {
    SystemInit();  // 调用 SystemInit() 函数初始化系统时钟，这通常是启动代码中的一部分，用于初始化系统的时钟和基本的硬件设置。
 
    LED_Init();  // 调用 LED_Init() 函数初始化 LED，准备控制 LED 灯的状态。
 
    USART3_Init(); // 调用 USART3_Init() 函数初始化 USART3，配置 USART3 的通信参数和引脚连接等。
 
    while (1) {
        checkReceive(); // 循环调用 checkReceive() 函数，用于检查是否接收到特定命令，并根据接收到的命令执行相应的操作。
    }
}

注：这里的实战演练讲的不是很清晰，建议移步这篇文章：通过串口中断的方式进行ASR-01S模块与STM32通信（问题与解决）

总结：

本文大致总结了串口的发送和接收。

串口的配置，使用查询或者中断来接收数据。

串口的使用会很常用到，所以在这里对串口做一个总结，也算是对之前知识的一个回顾和总结，加强印象。

参考链接：

https://gitcode.csdn.net/65e6e6b81a836825ed787581.html?dp_token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6MjgwNDA1NSwiZXhwIjoxNzEwNjEwNTI5LCJpYXQiOjE3MTAwMDU3MjksInVzZXJuYW1lIjoid2VpeGluXzUxMDI4NTg0In0.1Eac2jHw_Iz7Nc6l36BNEre9cCLz_gXA_Lz_OQnvtLc

更新：

想要获取实际项目代码的同学请移步我这篇文章——通过串口中断的方式进行ASRPRO模块与STM32通信（问题与解决）

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/896004