2-STM32串口通信实验解析

STM32实现串口通信串口通信是一种常见的通信方式，通过将数据一位一位地以比特的形式传输，实现设备之间的数据传输。

通常使用的串口通信接口有RS232、RS485、TTL等，STM32微控制器中一般使用USART模块来实现串口通信。

STM32的USART模块提供了多个串口接口，不同型号的STM32微控制器提供的USART接口数量和功能略有不同。

例如，一些型号的STM32微控制器提供了多个USART接口，可以同时与多个外设进行通信。

USART支持的波特率范围广泛，通常从几十bps到几Mbps，适用于不同速率的通信需求。

要实现串口通信，首先需要通过STM32的寄存器配置USART模块的工作参数。

具体步骤和代码如下：1.打开USART时钟，使能USART外设的时钟。

RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);2.配置串口工作参数，包括波特率、数据位数、停止位、校验位等。

USART_InitTypeDef USART_InitStructure;USART_ART_WordLength = USART_WordLength_8b;USART_ART_StopBits = USART_StopBits_1;USART_ART_Parity = USART_Parity_No ;USART_ART_HardwareFlowControl =USART_HardwareFlowControl_None;USART_ART_Mode = USART_Mode_Rx ，USART_Mode_Tx;USART_Init(USART1, &USART_InitStructure);3.使能USART接收和发送功能。

USART_Cmd(USART1, ENABLE);4.实现数据的接收和发送功能。

可以使用USART的中断或DMA方式进行数据的接收和发送。

stm32实训心得体会篇一：STM32 实验2报告实验2MINI STM32按键控制LED灯实验一、实验目的1、掌握嵌入式程序设计流程。

2、熟悉STM32固件库的基本使用。

二、实验内容1、编程使用I/O口作为输入，控制板载的两个LED 灯。

2、使用固件库编程。

三、实验设备硬件： PC机一台MINI STM32开发板一套软件： RVMDK 一套Windows XP 一套四、实验步骤1、设计工程，使用固件库来编程设置。

、在这里我们建立一个文件夹为: STM32-Projects.点击Keil 的菜单：Project –>New Uvision Project ，然后将目录定位到刚才建立的文件夹STM32-Projecst 之下，在这个目录下面建立子文件夹shiyan1, 然后定位到 shiyan1目录下面，我们的工程文件就都保存到shiyan1 文件夹下面。

工程命名为shiyan1, 点击保存.是这个型号。

、这里我们定位到STMicroelectronics 下面的STM32F103RB( 针对我们的mini 板子、弹出对话框“Copy STM32 Startup Code to project ?.”，询问是否添加启动代码到我们的工程中，这里我们选择“否”，因为我们使用的ST固件库文件已经包含了启动文件。

、接下来，我们在 Template 工程目录下面，新建3 个文件夹 CORE, USER,STM32F10x_FWLib 。

USER 用来放我们主函数文件 , 以及其他包括system_ 等等，CORE 用来存放启动文件等，STM32F10x_FWLib 文件夹顾名思义用来存放ST官方提供的库函数源码文件.、.打开官方固件库包，定位到我们之前准备好的固件库包的目录。

STM32F10x_StdPeriph_Lib_\Libraries\STM32F10x_StdPer iph_Driver 下面，将目录下面的src,inc 文件夹 copy 到我们刚才建立的STM32F10x_FWLib 文件夹下面。

stm32串口通信实验原理STM32是一款由STMicroelectronics公司推出的基于ARM Cortex-M 内核的32位微控制器。

在STM32系列中，串口通信是一种常见的外设模块，可以实现与其他设备之间的数据传输。

本文将介绍STM32串口通信的原理及实验方法。

一、串口通信的原理串口通信是一种通过串行方式传输数据的通信方式。

在串口通信中，数据是一位一位地依次发送或接收的。

与并行通信相比，串口通信只需要两根信号线即可实现数据的传输，因此在资源有限的嵌入式系统中被广泛应用。

STM32的串口通信模块包括多个寄存器，其中包括控制寄存器、状态寄存器、数据寄存器等。

通过配置这些寄存器，可以实现串口通信的参数设置和数据的发送接收。

二、STM32串口通信的实验步骤以下是一种基本的STM32串口通信实验步骤：1. 硬件连接：将STM32开发板的串口引脚与其他设备的串口引脚通过串口线连接起来。

一般来说，串口通信需要连接的引脚包括TX （发送引脚）、RX（接收引脚）、GND（地线）。

2. 引脚配置：通过STM32的引脚复用功能，将相应的GPIO引脚配置为串口功能。

具体的引脚配置方法可以参考STM32的开发板手册或者相关的资料。

3. 时钟配置：配置STM32的时钟源，使得串口通信模块能够正常工作。

一般来说，串口通信模块使用的时钟源可以选择系统时钟或者外部时钟。

4. 串口配置：配置串口通信模块的参数，包括波特率、数据位、停止位、校验位等。

这些参数的配置需要根据实际的通信需求来确定。

5. 数据发送：通过向数据寄存器写入数据，向其他设备发送数据。

在发送数据之前，需要通过状态寄存器的标志位判断串口是否空闲，以确保数据能够正常发送。

6. 数据接收：通过读取数据寄存器的数据，从其他设备接收数据。

在接收数据之前，需要通过状态寄存器的标志位判断是否有数据到达，以确保数据能够正确接收。

7. 中断处理：在串口通信过程中，可以使用中断来实现数据的异步传输。

stm32-串⼝实验遇到的问题
1.Printf函数不能在调试助⼿⾥正常打印？
前提是已经重定向了printf到串⼝，⽽且已经在option⾥勾上了use microlib,⼀切配置都毫⽆问题，在main.c⾥简单printf(“balabala”);却不能在调试助⼿⾥打印出来，点发送也只能发送在调试界⾯输⼊的内容；
2.解决⽅案
（1）将连接电脑的串⼝线，拔⼀下，再插⼀下，点击发送，打印就OK了；
（2）上⾯这种⽅法⽐较笨重，还有⼀种简单的⽅法：直接reset，就会直接答印了；
3.分析
实质上两种⽅法有根本的区别，读者⾃⾏实验判断；由于我是⽤串⼝烧写程序的，在烧写时会关闭调试助⼿的串⼝，等烧写完再打开调试助⼿的串⼝，在这段时间内，⼀条printf打印信息已经被发送完了，但根本没被调试助⼿接收到，所以只要reset⼀下，就会马上打印你想输出的信息了；
4.总结
⼀开始以为是调试助⼿的问题，到处下载其他的调试助⼿，实则结果都⼀样；然后再排查程序的问题（重定向），也没问题；再着查看配置的问题，⽐如引脚的配置，波特率的配置，也都没问题；最后偶然插拔了⼀下usb线就可以了解决问题了；再最后发现reset更为有效。

所以通过以上步骤可以发现，遇到问题，只要⼀⼀排查所有的可能性，最终是会发现答案的。

实验要求∙使用开发板上的串口向PC发送信息∙PC通过串口向开发板发送数据，CPU在接收到后，确认信息，并通过串口返回数据例如：开发板先发送一个字符‘c’，然后PC发送一个字符‘a’，开发板接收到后，再发送一个字符‘b’[编辑] 实验目的∙学习和掌握STM32的USART模块的工作原理和使用方法∙学习和掌握USART固件库的使用∙掌握串口中断的使用方法[编辑] 实验分析硬件分析：USART的工作原理软件分析：USART固件库USART实例[编辑] 开发板原理图设计MAX3232与主芯片的连接[编辑] 硬件知识点详见STM32F10XXX英文版参考手册RM0008-Reference Manual[编辑] USART通用同步异步收发器(USART)提供了一种灵活的方法与使用工业标准NRZ异步串行数据格式的外部设备之间进行全双工数据交换。

USART利用小数波特率发生器提供宽范围的波特率选择。

它支持同步单向通信和半双工单线通信，也支持LIN(局部互连网)，智能卡协议和IrDA(红外数据组织)SIR ENDEC规范，以及调制解调器(CTS/RTS)操作。

它还允许多处理器通信。

使用多缓冲器配置的DMA方式，可以实现高速数据通信。

(表) USART模式支持[编辑] USART内部结构[编辑] 引脚定义任何USART双向通信至少需要两个引脚：接收数据输入(RX)和发送数据输出(TX)。

∙RX：接收数据输入。

通过过采样技术来区别数据和噪音，从而恢复数据。

∙TX：发送数据输出。

当发送器被禁止时，输出引脚恢复到它的I/O端口配置。

当发送器被激活，并且不发送数据时，TX引脚处于高电平。

在单线和智能卡模式里，此I/O口被同时用于数据的发送和接收。

在同步模式中需要下列引脚：∙CK：发送器时钟输出。

此引脚输出用于同步传输的时钟， (在起始位和停止位上没有时钟脉冲，软件可选地，可以在最后一个数据位送出一个时钟脉冲)。

数据可以在RX上同步被接收。

python3下对stm32串⼝数据做解析1、最近有个想做⼀个传感器数据实时显⽰的上位机，常规的数据打印太频繁了，⽆法直观的看出数据的变化。

python下的上位机实现起来简单⼀点，⽹上找了⼀些python界⾯Tkinter相关资料和python串⼝的demo.测试实现了简单的数据显⽰。

Mark ⼀下问题点：最⼤的问题点在于对bytes型数据的拼接：之前的串⼝解析的代码是在python 2.7平台上实现的，切换到python3.0之后，测试失踪⽆法通过。

幸⽽找到了⼤神相助。

python 2.7code:1import os2import time3import sys, traceback4from serial.serialutil import SerialException5from serial import Serial67import struct8import binascii91011class Arduino:12def__init__(self, port="/dev/ttyUSB0", baudrate=115200, timeout=0.5):1314 self.port = port15 self.baudrate = baudrate16 self.timeout = timeout17 self.encoder_count = 018 self.writeTimeout = timeout19 self.interCharTimeout = timeout / 30.2021 self.WAITING_FF = 022 self.WAITING_AA = 123 self.RECEIVE_LEN = 224 self.RECEIVE_PACKAGE = 325 self.RECEIVE_CHECK = 426 self.HEADER0 = 0xff27 self.HEADER1 = 0xaa28 self.REC_CMD = 529 self.count = 030 self.data1 = 031 self.data2 = 032 self.error_flag = 033 self.SUCCESS = 034 self.FAIL = -13536 self.receive_state_ = self.WAITING_FF37 self.receive_check_sum_ = 038 self.payload_command = ''39 self.payload_ack = ''40 self.payload_args = ''41 self.payload_len = 042 self.byte_count_ = 043 self.receive_message_length_ = 04445 self.mutex = threading.Thread.allocate_lock()4647# An array to cache analog sensor readings48 self.analog_sensor_cache = [None] * self.N_ANALOG_PORTS4950# An array to cache digital sensor readings51 self.digital_sensor_cache = [None] * self.N_DIGITAL_PORTS5253def connect(self):54try:55print"Connecting to Arduino on port", self.port, "..."56 self.port = Serial(port=self.port, baudrate=self.baudrate, timeout=self.timeout, writeTimeout=self.writeTimeout)57# The next line is necessary to give the firmware time to wake up.58 time.sleep(1)59 state_, val = self.get_baud()60if val != self.baudrate:61 time.sleep(1)62 state_, val = self.get_baud()63if val != self.baudrate:64raise SerialException65print"Connected at", self.baudrate66print"Arduino is ready."6768except SerialException:69print"Serial Exception:"70print sys.exc_info()71print"Traceback follows:"72 traceback.print_exc(file=sys.stdout)73print"Cannot connect to Arduino!"74 os._exit(1)7576def open(self):77 self.port.open()7879def close(self):80 self.port.close()8182def send(self, cmd):83 self.port.write(cmd)8485def receiveFiniteStates(self, rx_data):86if self.receive_state_ == self.WAITING_FF:87#print str(binascii.b2a_hex(rx_data))88if rx_data == '\xff':89 self.receive_state_ = self.WAITING_AA90 self.receive_check_sum_ =091 self.receive_message_length_ = 092 self.byte_count_=093 self.payload_ack = ''94 self.payload_args = ''95 self.payload_len = 096 self.count = 09798elif self.receive_state_ == self.WAITING_AA :99if rx_data == '\xaa':100 self.receive_state_ = self.REC_CMD101else:102 self.receive_state_ = self.WAITING_FF103elif self.receive_state_ == self.REC_CMD:104 self.count+=1105if self.count == 1:106 self.data1,=struct.unpack("B",rx_data)107elif self.count == 2:108 self.data2,=struct.unpack("B",rx_data)109 self.receive_state_ = self.RECEIVE_LEN110if self.error_flag == 0 and self.data1 != 0:111 self.error_flag = 1112if self.data2 != 0 and self.error_flag == 0:113 self.error_flag = 1114elif self.receive_state_ == self.RECEIVE_LEN:115 self.receive_message_length_, = struct.unpack("B",rx_data)116 self.receive_state_ = self.RECEIVE_PACKAGE117elif self.receive_state_ == self.RECEIVE_PACKAGE:118if self.byte_count_==0:119 self.payload_ack = rx_data120else:121 self.payload_args += rx_data122 self.byte_count_ +=1123#print "byte:"+str(byte_count_) +","+ "rece_len:"+str(receive_message_length_) 124if self.byte_count_ >= self.receive_message_length_:125 self.receive_state_ = self.RECEIVE_CHECK126127elif self.receive_state_ == self.RECEIVE_CHECK:128#if(rx_data == (unsigned char)receive_check_sum_)129if 1:130 self.receive_state_ = self.WAITING_FF131#print str(binascii.b2a_hex(value))132#left, right, = struct.unpack('hh', value)133#print "left:"+str(left)+", right:"+str(right)134return 1135else:136 self.receive_state_ = self.WAITING_FF137else:138 self.receive_state_ = self.WAITING_FF;139return 0140141def recv(self, timeout=0.5):142 timeout = min(timeout, self.timeout)143''' This command should not be used on its own: it is called by the execute commands 144 below in a thread safe manner. Note: we use read() instead of readline() since145 readline() tends to return garbage characters from the Arduino146'''147 c = ''148 value = ''149 attempts = 0150 c = self.port.read(1)151#print str(binascii.b2a_hex(c))152while self.receiveFiniteStates(c) != 1:153 c = self.port.read(1)154#print str(binascii.b2a_hex(c))155 attempts += 1156if attempts * self.interCharTimeout > timeout:157return 0158return 1159160def recv_ack(self):161 ack = self.recv(self.timeout)162return ack == 'OK'163164def execute(self, cmd):165 self.mutex.acquire()166167try:168 self.port.flushInput()169except:170pass171172 ntries = 1173 attempts = 0174175try:176 self.port.write(cmd)177 res = self.recv(self.timeout)178while attempts < ntries and res !=1 :179try:180 self.port.flushInput()181 self.port.write(cmd)182 res = self.recv(self.timeout)183except:184print"Exception executing command: " + str(binascii.b2a_hex(cmd))185 attempts += 1186except:187 self.mutex.release()188print"Exception executing command: " + str(binascii.b2a_hex(cmd))189return 0190191 self.mutex.release()192return 1193194def get_baud(self):195''' Get the current baud rate on the serial port.196'''197 cmd_str=struct.pack("4B", self.HEADER0, self.HEADER1, 0x01, 0x00) + struct.pack("B", 0x01) 198if (self.execute(cmd_str))==1 and self.payload_ack == '\x00':199 val, = struct.unpack('I', self.payload_args)200return self.SUCCESS, val201else:202return self.FAIL, 0203204def get_check_sum(self,list):205 list_len = len(list)206 cs = 0207for i in range(list_len):208#print i, list[i]209 cs += list[i]210 cs=cs%255211return cs212213def stop(self):214''' Stop both motors.215'''216 self.drive(0, 0)View Code在python 3.6 version 中就该修改部分代码：问题在于bytes类型的拼接：以下的拼接是正确的：bytes('','ascii')+bytes([1,2,3,4,5,6,7,8,9])bytes('','ascii')+bytes([1,2,3,4,5,6,7,8,9])+bytes([1,2,3,4,5,6,7,8,9])也即是：bytes类型的拼接的初始变量要声明为：bytes('','ascii')如果声明为其它类型：⽐如字符串，执⾏时会直接报错。

stm32 串口通信数据发送和波特率生成原理【实用版】目录一、STM32 串口通信概述二、数据发送原理1.数据传输过程2.串口发送函数三、波特率生成原理1.波特率的概念2.波特率发生器3.STM32 串口最高波特率四、STM32 串口通信应用实例正文一、STM32 串口通信概述STM32 是一类芯片的统称，常用于嵌入式系统开发。

串口通信是STM32 芯片的一个重要功能，可以实现与其他设备的数据交互。

在 STM32 中，有多个串口（如 USART1、USART2 等），每个串口都可以独立配置并进行通信。

二、数据发送原理1.数据传输过程在 STM32 中，数据发送过程主要涉及到以下几个步骤：（1）将待发送数据放入发送缓存（Tx Buffer）。

（2）串口时钟使能，开始进行数据传输。

（3）数据从发送缓存中取出，并通过串口发送给接收设备。

（4）发送完成后，将发送缓存清空，准备发送下一数据。

2.串口发送函数在 STM32 中，发送数据主要通过调用库函数（如HAL_UART_Transmit()）实现。

该函数接收一个字符串（或字节数组）作为参数，并将其发送给指定的串口。

三、波特率生成原理1.波特率的概念波特率是指每秒钟传输的比特数，通常用来描述串口通信的传输速率。

在 STM32 中，波特率是一个重要的配置参数，影响着串口通信的速率。

2.波特率发生器STM32 中的波特率发生器负责生成串口通信所需的时钟信号。

波特率发生器可以根据不同的波特率设置，生成相应的时钟信号，以保证数据传输的稳定性。

3.STM32 串口最高波特率STM32 串口的最高速度为 4.5Mbps。

具体的 USART 的特征参数如下：全双工的，异步通信，NRZ 标准格式，分数波特率发生器系统。

四、STM32 串口通信应用实例以下是一个简单的 STM32 串口通信应用实例：（1）配置串口时钟和 IO 口状态。

（2）调用库函数中发送函数发送数据。

（3）在中断中接收数据。

STM32的串⼝通信UARTTTL常⽤的串⼝pinSTM32的串⼝是基础通信⽅式, 每个型号都带多组串⼝, ⼀般都使⽤默认的组, 可以参考芯⽚的datasheet, 去看pinout and pin definitions, 对于stm32f103c8t6, 这是48pin的芯⽚, 提供3组串⼝, 如果使⽤3组, 各组串⼝的pin脚为USART2 - A2, A3PA0: USART2_CTSPA1: USART2_RTSPA2: USART2_TXPA3: USART2_RXPA4: USART2_CKUSART1 - A9, A10PA8: USART1_CKPA9: USART1_TXPA10: USART1_RXPA11: USART1_CTSPA12: USART1_RTSUSART3 - B10, B11PB10: USART3_TXPB11: USART3_RXPB12: USART3_CKPB13: USART1_CTSPB14: USART1_RTS串⼝通信编程⼀般通过以下的步骤实现串⼝通信1. 申请内存作为buffer, 声明标记位和buffer指针简单的例⼦u8 usart_buf[100] = {0};u16 index1 = 0, flag1 = 0;复杂的例⼦#define TTL_BufferLength ((uint16_t)0x0040)#define TTL_WriteOk ((uint16_t)0x0000)#define TTL_BufferOverrun ((uint16_t)0x0001) // full flag#define TTL_BufferUnderrun ((uint16_t)0x0002) // empty flag/* Private types -------------------------------------------------------------*/typedef struct{uint16_t size; /* The size of the buffer */uint16_t start; /* The index of the next character to send */uint16_t end; /* The index at which to write the next character */char* elems; /* The location in memory of the buffer */} TTL_BufferTypeDef;/* Private variables ----------------------------------------------------------*/TTL_BufferTypeDef cb;/* Private Methods -----------------------------------------------------------*/void TTL_Buffer_Init(){cb.size = TTL_BufferLength;cb.start = 0;cb.end = 0;cb.elems = calloc(cb.size, sizeof(char));}void TTL_Buffer_Free(){free(cb.elems);}uint16_t TTL_Buffer_IsFull(){return (cb.end + 1) % cb.size == cb.start;}uint16_t TTL_Buffer_IsEmpty(){return cb.end == cb.start;}uint16_t TTL_Buffer_Write(char c){// check for a buffer overrunif (TTL_Buffer_IsFull()) {return TTL_BufferOverrun;} else {cb.elems[cb.end] = c;cb.end = (cb.end + 1) % cb.size;}return TTL_WriteOk;}uint16_t TTL_Buffer_Read(char* c){// check for a buffer underrunif (TTL_Buffer_IsEmpty()) {return TTL_BufferUnderrun;} else {*c = cb.elems[cb.start];cb.start = (cb.start + 1) % cb.size;}}2. 初始化UART端⼝: 使能GPIO, UART, NVIC /* Public Methods -----------------------------------------------------------*/void TTL_Init(){// Structures to hold the initialisation dataGPIO_InitTypeDef GPIO_InitStruct;USART_InitTypeDef USART_InitStruct;NVIC_InitTypeDef NVIC_InitStruct;// enable the peripherals we're going to useRCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);// Usart1 Tx is on GPIOB pin 6 as an alternative functionGPIO_InitStruct.GPIO_Pin = GPIO_Pin_6;GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;GPIO_Init(GPIOB, &GPIO_InitStruct);// Connect pin 6 to the USARTGPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_USART1);// fill in the interrupt configurationNVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;NVIC_Init(&amp;NVIC_InitStruct);// init the USART to 8:N:1 at 9600 baud as specified in the// TTL data sheetUSART_ART_BaudRate = 9600;USART_ART_WordLength = USART_WordLength_8b;USART_ART_StopBits = USART_StopBits_1;USART_ART_Parity = USART_Parity_No;USART_ART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_ART_Mode = USART_Mode_Tx;USART_Init(USART1, &USART_InitStruct);// Enable USART1 peripheralUSART_Cmd(USART1, ENABLE);// ensure USART1 interrupts are off until we have dataUSART_ITConfig(USART1, USART_IT_TXE, DISABLE);// prepare the bufferTTL_Buffer_Init();}3. 实现中断处理⽅法读消息/* Public Methods -----------------------------------------------------------*//** Handles all interrupts for USART1.*/void USART1_IRQHandler(void){// is this interrupt telling us that we can send a new character?if (USART_GetITStatus(USART1, USART_IT_TXE) != RESET) {// is there something for us to read?if (TTL_Buffer_IsEmpty()) {// no, disable the interruptUSART_ITConfig(USART1, USART_IT_TXE, DISABLE);} else {// yes, get the next character from the bufferchar c = 0x00;TTL_Buffer_Read(&c);// send it to the deviceUSART_SendData(USART1, c);}}}4. ⼯具⽅法: 写消息, 反初始化(⾮必须)注意在每次调⽤USART_SendData这个⽅法之后, 都需要阻塞判断 USART_FLAG_TC 是否为SET才能继续往下执⾏. ...USART_SendData(USART1, *str++);while( USART_GetFlagStatus(USART1, USART_FLAG_TC) != SET);...例如/* Public Methods -----------------------------------------------------------*/void TTL_DeInit(){// disable the interruptsUSART_ITConfig(USART1, USART_IT_TXE, DISABLE);// free the bufferTTL_Buffer_Free();}uint16_t TTL_IsBufferFull(){return TTL_Buffer_IsFull();}uint16_t TTL_WriteMessage(char* text, uint16_t length){// index into the character arrayuint16_t i = 0;// return valueuint16_t rv = TTL_WriteOk;while(length--) {USART_SendData(USART1, *text++);// USART_SendData(USART1,(uint16_t) *text++);// Loop until the end of transmissionwhile(USART_GetFlagStatus(USART1, USART_FLAG_TC) != SET);}// enable the interrupt to send the messageUSART_ITConfig(USART1, USART_IT_TXE, ENABLE);return rv;}代码例⼦这是⼀个完整的代码例⼦, 适⽤于STM32F103#include "sys.h"#include "usart.h"#include "delay.h"u8 usart1_buf[100] = {0}, usart2_buf[100] = {0}, usart3_buf[100] = {0};u16 index1 = 0, index2 = 0, index3 = 0, flag1 = 0, flag2 = 0, flag3 = 0;void uart_init(u32 bound){GPIO_InitTypeDef GPIO_InitStructure;USART_InitTypeDef USART_InitStructure;NVIC_InitTypeDef NVIC_InitStructure;RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2 | RCC_APB1Periph_USART3, ENABLE);//使能USART1，GPIOA时钟RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE);/*************UART1********************/GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复⽤推挽输出GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化GPIOA.9//USART1_RX GPIOA.10初始化GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //PA10GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输⼊GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化GPIOA.10NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;//抢占优先级3NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //⼦优先级3NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器USART_ART_BaudRate = bound;//串⼝波特率USART_ART_WordLength = USART_WordLength_8b; //字长为8位数据格式USART_ART_StopBits = USART_StopBits_1; //⼀个停⽌位USART_ART_Parity = USART_Parity_No; //⽆奇偶校验位USART_ART_HardwareFlowControl = USART_HardwareFlowControl_None; //⽆硬件数据流控制 USART_ART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式USART_Init(USART1, &USART_InitStructure); //初始化串⼝1USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串⼝接受中断USART_Cmd(USART1, ENABLE); //使能串⼝1/***************UART2******************/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); //初始化GPIOA.2GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输⼊GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化GPIOA.3NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;//抢占优先级3NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; //⼦优先级3NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器USART_ART_BaudRate = bound;//串⼝波特率USART_ART_WordLength = USART_WordLength_8b; //字长为8位数据格式USART_ART_StopBits = USART_StopBits_1; //⼀个停⽌位USART_ART_Parity = USART_Parity_No; //⽆奇偶校验位USART_ART_HardwareFlowControl = USART_HardwareFlowControl_None; //⽆硬件数据流控制 USART_ART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式USART_Init(USART2, &USART_InitStructure); //初始化串⼝2USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启串⼝接受中断USART_Cmd(USART2, ENABLE); //使能串⼝2/****************UART3***********************///USART3_TX GPIOB.10GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //PB.10GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复⽤推挽输出GPIO_Init(GPIOB, &GPIO_InitStructure); //初始化GPIOB.10//USART3_RX GPIOB.11GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11; //PB11GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输⼊GPIO_Init(GPIOB, &GPIO_InitStructure); //初始化GPIOB.11//Usart3 NVIC 配置NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1; //抢占优先级4NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //⼦优先级3NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器USART_ART_BaudRate = 115200; //串⼝波特率USART_ART_WordLength = USART_WordLength_8b; //字长为8位数据格式USART_ART_StopBits = USART_StopBits_1; //⼀个停⽌位USART_ART_Parity = USART_Parity_No; //⽆奇偶校验位USART_ART_HardwareFlowControl = USART_HardwareFlowControl_None; //⽆硬件数据流控制 USART_ART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式USART_Init(USART3, &USART_InitStructure); //初始化串⼝3USART_ITConfig(USART3, USART_IT_RXNE, ENABLE); //开启串⼝接受中断USART_Cmd(USART3, ENABLE);}/**每个字节⼀个中断, 这⾥⽤0x0a作为⼀条消息读取结束*/void USART1_IRQHandler(void){u16 code;if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) {USART_ClearITPendingBit(USART1, USART_IT_RXNE);//Removal of receiving interrupt flagcode = USART_ReceiveData(USART1);usart1_buf[index1] = code;index1++;if(code == 0x0a) {index1 = 0;flag1 = 1;}}}void USART2_IRQHandler(void){u16 code;if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) {USART_ClearITPendingBit(USART2, USART_IT_RXNE);code=USART_ReceiveData(USART2);usart2_buf[index2] = code;index2++;if(code == 0x0a) {index2 = 0;flag2 = 1;}}}void USART3_IRQHandler(void){u16 code;if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET) {USART_ClearITPendingBit(USART3, USART_IT_RXNE);code = USART_ReceiveData(USART3);usart3_buf[index3] = code;index3++;if(code == 0x0a) {index3 = 0;flag3 = 1;}}}void USART1_Send(u8 *str){while(*str != 0x0a) {USART_GetFlagStatus(USART1, USART_FLAG_TC);USART_SendData(USART1, *str++);while( USART_GetFlagStatus(USART1,USART_FLAG_TC) != SET);}USART_SendData(USART1, 0x0a);}void USART2_Send(u8 *str){while(*str != 0x0a) {USART_GetFlagStatus(USART2, USART_FLAG_TC);USART_SendData(USART2, *str++);while( USART_GetFlagStatus(USART2,USART_FLAG_TC) != SET);}USART_SendData(USART2, 0x0a);}void USART3_Send(u8 *str){while(*str != 0x0a) {USART_GetFlagStatus(USART3, USART_FLAG_TC);USART_SendData(USART3, *str++);while( USART_GetFlagStatus(USART3,USART_FLAG_TC) != SET); }USART_SendData(USART3, 0x0a);}/*******************main***********************/#include "led.h"#include "delay.h"#include "key.h"#include "sys.h"#include "usart.h"#include "buzzer.h"#include "string.h"int main(void){u8 Zigb_Head[]="ZigB:";u8 buf[100];delay_init();NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);uart_init(115200);Buzzer_Init();LED_Init();while(1) {if(flag2 == 1) {LED0=0;flag2=0;USART3_Send(usart2_buf);memset(usart2_buf,0,sizeof(usart2_buf));} else if(flag3==1) {LED1=0;flag3=0;memcpy(buf,Zigb_Head,sizeof(Zigb_Head));strcat(buf,usart3_buf);USART2_Send(buf);memset(buf,0,sizeof(buf));}delay_ms(500);LED1=1;LED0=1;delay_ms(500);}}参考。

STM32--—SPI（DMA)通信的总结(库函数操作)本文主要由7项内容介绍SPI并会在最后附上测试源码供参考：1.SPI的通信协议2.SPI通信初始化（以STM32为从机,LPC1114为主机介绍）3.SPI的读写函数4.SPI的中断配置5.SPI的SMA操作6.测试源码7.易出现的问题及原因和解决方法一、SPI的通信协议SPI（Serial Peripheral Interface)是一种串行同步通讯协议,由一个主设备和一个或多个从设备组成，主设备启动一个与从设备的同步通讯，从而完成数据的交换。

SPI 接口一般由4根线组成，CS片选信号（有的单片机上也称为NSS），SCLK时钟信号线，MISO数据线(主机输入从机输出），MOSI数据线（主机输出从机输入），CS 决定了唯一的与主设备通信的从设备,如没有CS 信号,则只能存在一个从设备，主设备通过产生移位时钟信号来发起通讯。

通讯时主机的数据由MISO输入,由MOSI 输出，输入的数据在时钟的上升或下降沿被采样，输出数据在紧接着的下降或上升沿被发出（具体由SPI的时钟相位和极性的设置而决定）.二、以STM32为例介绍SPI通信1.STM32f103 带有3个SPI模块其特性如下：2SPI 初始化初始化SPI 主要是对SPI要使用到的引脚以及SPI通信协议中时钟相位和极性进行设置，其实STM32的工程师已经帮我们做好了这些工作，调用库函数,根据自己的需要来修改其中的参量来完成自己的配置即可,主要的配置是如下几项：引脚的配置SPI1的SCLK，MISO ,MOSI分别是PA5，PA6，PA7引脚，这几个引脚的模式都配置成GPIO_Mode_AF_PP 复用推挽输出（关于GPIO的8种工作模式如不清楚请自己百度，在此不解释）,如果是单主单从，CS引脚可以不配置，都设置成软件模式即可.通信参数的设置1.SPI_Direction_2Lines_FullDuplex把SPI设置成全双工通信；2.在SPI_Mode 里设置你的模式(主机或者从机），3.SPI_DataSize是来设置数据传输的帧格式的SPI_DataSize_8b是指8位数据帧格式，也可以设置为SPI_DataSize_16b，即16位帧格式4.SPI_CPOL和SPI_CPHA是两个很重要的参数，是设置SPI通信时钟的极性和相位的，一共有四种模式在库函数中CPOL有两个值SPI_CPOL_High（=1）和SPI_CPOL_Low （=0)。

基于stm32的串口通信设计报告基于STM32的串口通信设计报告一、引言STM32微控制器因其高性能、低功耗和丰富的外设接口而广泛应用于各种嵌入式系统。

其中，串口通信（UART）是STM32中非常常用的一种通信方式，它允许微控制器与其他设备或计算机进行数据交换。

本报告将详细介绍基于STM32的串口通信设计。

二、STM32串口通信概述STM32的UART通信主要通过其通用同步/异步接收器发送器（USART）实现。

USART是一个全双工的串行通信接口，支持同步和异步两种模式。

它提供了一种可靠的通信方式，适用于低速和高速数据传输。

三、串口通信硬件设计1. 引脚配置：根据具体的STM32型号，选择适当的TXD（发送数据）、RXD（接收数据）、RTS（请求发送）和CTS（清除发送）等引脚。

2. 电源与地：为UART模块提供稳定的电源和地线。

3. 电平转换：如果微控制器与外部设备之间的电平不匹配，需要进行电平转换。

四、串口通信软件设计1. 初始化UART：在开始通信之前，需要配置UART的各种参数，如波特率、数据位、停止位和奇偶校验等。

这通常在STM32的初始化代码中完成。

2. 数据发送：通过使用HAL库或标准外设库函数，可以方便地发送数据。

一般来说，发送函数会将数据放入一个缓冲区，然后启动发送过程。

3. 数据接收：与发送类似，接收数据时，数据首先被读取到一个缓冲区中，然后可以通过中断或轮询方式进行处理。

4. 中断处理：为了提高效率，可以启用UART的中断功能。

当中断被触发时，相应的中断处理程序会被执行，用于处理接收或发送的数据。

五、示例代码与测试以下是一个简单的示例代码，展示了如何在STM32上使用HAL库进行UART通信：include "stm32f4xx_"UART_HandleTypeDef huart1;void SystemClock_Config(void);static void MX_GPIO_Init(void);static void MX_USART1_UART_Init(void);int main(void){HAL_Init();SystemClock_Config();MX_GPIO_Init();MX_USART1_UART_Init();uint8_t txBuffer[] = "Hello, UART!";HAL_UART_Transmit(&huart1, txBuffer, sizeof(txBuffer), HAL_MAX_DELAY);while (1)// 循环等待，直到收到中断或手动终止程序}}```六、结论通过本报告，我们详细介绍了基于STM32的串口通信设计。

基于stm32的串口通信的自我总结1. 背景介绍近年来，随着物联网和嵌入式系统的快速发展，嵌入式开发领域的需求也越来越大。

而基于stm32的串口通信技术在嵌入式开发中扮演着重要的角色。

串口通信是嵌入式系统中常用的通信方式，它可以实现单片机与外部设备之间的数据传输，应用广泛。

本文将对基于stm32的串口通信进行总结和归纳，旨在共享相关经验和教训，方便读者更好地应用该技术。

2. stm32串口通信的原理基于stm32的串口通信涉及到串口的相关知识和stm32单片机的硬件支持。

在串口通信中，常用的有UART、USART、RS232等协议。

而stm32单片机作为一款常用的嵌入式处理器，在硬件上支持多个串口通信接口，如USART1、USART2、UART4等。

在实际应用中，需要根据具体的需求选择合适的串口通信接口，并在软件上进行相应的配置和驱动。

在stm32的串口通信中，需要了解串口通信的相关寄存器、时钟配置等，以实现数据的可靠传输。

3. 基于stm32的串口通信应用基于stm32的串口通信可以应用在很多场景下，比如与PC机的数据通信、与外部传感器的数据采集等。

在实际的应用中，需要根据具体的需求和外部设备的通信协议选择合适的串口通信接口，并在程序中进行相应的配置和驱动。

另外，在实际的应用过程中，需要考虑串口通信的稳定性和可靠性，并进行相应的错误处理和数据校验，以确保数据的正确传输。

4. 基于stm32的串口通信的优化在实际的应用中，基于stm32的串口通信可能会遇到一些性能上的瓶颈和稳定性的问题。

针对这些问题，可以采取一些优化的措施，比如合理设计串口通信的协议、优化中断服务程序、增加数据校验和重发机制等，以实现串口通信的稳定和高效。

5. 结语基于stm32的串口通信技术在嵌入式系统中应用广泛，本文总结了关于该技术的相关知识和经验。

通过对串口通信的原理、应用和优化进行总结，可以帮助读者更好地理解和应用该技术，提高嵌入式系统的开发效率和质量。

stm32 串口通信数据发送和波特率生成原理串口通信是通过串口发送和接收数据的方式进行通信的一种方式。

在STM32微控制器中，可以使用USART模块来实现串口通信。

USART模块提供了寄存器来配置串口的波特率及其他参数，并且提供了发送和接收数据的功能。

首先，我们需要了解一下串口通信中的波特率。

波特率是指每秒钟传送的位数。

在串口通信中，波特率用来表示每秒传输的比特数。

常见的波特率有9600bps、115200bps等。

STM32系列微控制器提供了一个时钟源，该时钟源可以用来生成波特率。

一般情况下，波特率的生成与STM32微控制器的主时钟CLK相关，主时钟经过分频和倍频等操作可以生成不同的波特率。

具体来说，可以通过配置USART的寄存器来设置波特率发生器的参数。

对于STM32微控制器中的USART模块，一般包含以下与波特率相关的寄存器：1. BRR (波特率发生器寄存器)：用于设置USART的波特率。

该寄存器包含了DIV_Mantissa和DIV_Fraction两个字段，分别用于设置整数和小数部分的分频系数。

2. BRR寄存器的设置：- 对于USART模块，BRR寄存器的值可以通过公式 BRR = USARTDIV = (fck + (Baudrate/2)) / Baudrate 来计算得到。

其中，fck表示USART的输入时钟频率，Baudrate表示所需的波特率。

根据这个公式，可以计算出合适的分频系数并设置到BRR寄存器中。

- 在STM32微控制器中，每个USART模块都有自己的BRR寄存器，可以通过设置这个寄存器来实现不同的波特率。

3. CR1寄存器：该寄存器中的配置位与波特率设置相关。

例如，使用OVER8位来选择是否使用8个采样位。

有了波特率的设置，就可以通过USART模块发送和接收数据。

STM32提供了发送与接收数据的寄存器，例如：1. USART_TXDR寄存器：用于写入要发送的数据。

STM32串口通信学习总结STM32是STMicroelectronics推出的一款32位单片机系列，具有高性能、低功耗、丰富的外设等特点，广泛应用于工业控制、消费电子、汽车电子等领域。

其中，串口通信是单片机中常用的通信方式之一，本文将对STM32串口通信学习进行总结。

1.串口通信原理及基础知识在STM32中，USART（通用同步/异步收发器）是负责串口通信的外设。

USART提供了多种模式的串口通信，包括异步模式（Asynchronous）、同步模式（Synchronous）以及单线模式（Single-wire）等。

2.STM32串口通信配置步骤（1）GPIO配置：首先需要配置串口通信所涉及的GPIO引脚，通常需要配置为复用功能，使其具备USART功能。

（2）USART配置：根据需要选择USART1、USART2、USART3等串口进行配置，设置通信模式、波特率等参数。

在配置时需要注意与外部设备的通信标准和参数保持一致。

（3）中断配置（可选）：可以选择中断方式来实现串口数据的收发。

通过配置中断，当接收到数据时会触发中断，从而实现接收数据的功能。

（4）发送数据：通过USART的发送寄存器将数据发送出去，可以通过查询方式或者中断方式进行发送。

（5）接收数据：通过读取USART的接收寄存器，获取接收到的数据。

同样可以通过查询方式或者中断方式进行接收。

3.常见问题及解决方法（1）波特率设置错误：在进行串口通信时，波特率设置错误可能会导致通信失败。

需要根据外设的要求，选择适当的波特率设置，并在STM32中进行配置。

（2）数据丢失：在高速通信或大量数据传输时，由于接收速度跟不上发送速度，可能会导致数据丢失。

可以通过增加接收缓冲区大小、优化接收中断处理等方式来解决该问题。

（3）数据帧错误：在数据传输过程中，可能发生数据位错误、校验错误等问题。

可以通过对USART的配置进行检查，包括校验位、停止位、数据位等的设置是否正确。

STM32串口设计实验小结概述本文记录了基于S TM32的串口设计实验的相关内容，通过该实验，我们探索了ST M32串口通信的基本原理和应用。

引言串口通信是一种常见的通信方式，通过串口可以实现与外部设备的数据交互。

在嵌入式系统中，使用串口进行与P C或其他设备的通信非常常见。

本实验旨在通过使用ST M32单片机与上位机之间进行串口通信，深入理解串口通信的原理和实现方法。

实验目的本实验旨在：1.理解ST M32的串口通信工作原理；2.学习串口通信协议及其相关参数设置；3.掌握ST M32H AL库的使用方法；4.设计一个简单的串口通信系统。

实验器材和预备知识实验器材-S TM32F系列开发板（如S TM32F103C8T6）-U SB转串口模块-电脑预备知识-C语言编程基础-S TM32及H AL库的基本使用方法实验过程步骤一：环境搭建在开始实验之前，我们需要完成以下准备工作：1.安装Ke il MD K软件并注册；2.利用ST M32C ub eMX生成S TM32的工程，并配置串口相关参数；3.链接ST M32开发板与电脑，并确保能够正常通信。

步骤二：代码编写编写代码是实验中的核心步骤，我们需要实现以下功能：1.初始化串口配置；2.接收上位机发来的数据，并进行处理；3.返回处理结果给上位机。

下面是一个示例代码，用于接收上位机发送的字符串，并将其原样返回给上位机：#i nc lu de"s tm32f1x x_h al.h"#i nc lu de<s td io.h>U A RT_H an dl eT yp eDe f hu ar t1;v o id Sy st em Cl oc k_C o nf ig(v oi d);s t at ic vo id MX_G PIO_In it(v oi d);s t at ic vo id MX_U SAR T1_UA RT_I ni t(voi d);i n tm ai n(vo id){H A L_In it();S y st em Cl oc k_Co nfi g();M X_G PI O_In it();M X_U SA RT1_UA RT_In i t();w h il e(1){u i nt8_tr ec ei vB uff e r[64];i f(H AL_U AR T_Re cei v e(&h ua rt1,re cei v Bu ff er,64,1000)==H AL_ O K){H A L_UA RT_T ra ns mit(&h ua rt1,re ce ivB u ff er,s tr le n((ch a r*)r e c e iv Bu ff er),1000);}}}v o id Sy st em Cl oc k_C o nf ig(v oi d){//系统时钟配置...}s t at ic vo id MX_G PIO_In it(v oi d){//GP IO初始化配置...}s t at ic vo id MX_U SAR T1_UA RT_I ni t(voi d){h u ar t1.I ns ta nc e=U S AR T1;h u ar t1.I ni t.Ba udR a te=115200;h u ar t1.I ni t.Wo rdL e ng th=U AR T_WO RDL E NG TH_8B;h u ar t1.I ni t.St opB i ts=U AR T_ST OP BIT S_1;h u ar t1.I ni t.Pa rit y=U AR T_PA RI TY_NO N E;h u ar t1.I ni t.Mo de=U AR T_MO DE_T X_RX;h u ar t1.I ni t.Hw Flo w Ct l=UA RT_H WC ONT R OL_N ON E;h u ar t1.I ni t.Ov erS a mp li ng=U AR T_OV E R SA MP LI NG_16;H A L_UA RT_I ni t(&hu a rt1);}步骤三：测试与验证将编写好的固件文件烧录进S TM32开发板，在电脑中打开串口调试助手，选择对应串口号和波特率进行连接。

stm32串口通信工作原理一、引言串口通信是一种常见的数据交换方式，在嵌入式系统中扮演着重要的角色。

本文将介绍s t m32单片机上串口通信的基本原理以及其工作流程。

二、串口通信概述串口通信是指通过串行通信接口，按照一定的协议和规则，将数据传输到另一个设备。

常用的串口通信接口有R S-232、R S-485和UA RT等。

三、s t m32串口通信的基本原理s t m32单片机具有多个串口外设，每个串口包含了发送和接收数据的功能。

串口的工作原理可以简述为以下几个步骤：1.配置串口参数在使用s tm32串口通信之前，需要先对串口进行配置。

包括波特率、数据位、停止位、校验位等参数的设定。

这些参数会影响数据的传输速率和可靠性。

2.发送数据当需要发送数据时，首先将待发送的数据写入发送缓冲区。

数据会按照之前设定的参数进行编码并传输出去。

发送完成后，会产生发送完成中断。

3.接收数据接收数据时，st m32单片机会将接收到的数据存储到接收缓冲区。

当接收缓冲区有数据时，会触发接收完成中断，应用程序可以读取缓冲区中的数据。

4.中断处理s t m32单片机支持中断功能，通过设置相应的中断使能标志位，可以实现在数据发送和接收过程中对中断的响应。

中断处理函数负责对中断进行处理，以确保数据的正确传输。

四、s t m32串口通信的工作流程下面将详细介绍s tm32串口通信的工作流程：1.配置串口参数：使用st m32提供的库函数，根据需求设置波特率、数据位、停止位和校验位等参数。

2.初始化串口：调用库函数进行串口初始化，包括G PI O引脚设置、时钟使能等。

3.发送数据：将待发送的数据写入发送缓冲区。

4.等待发送完成中断：等待发送完成中断的触发，表示数据发送完成。

5.接收数据：接收到数据后，存储到接收缓冲区。

6.判断是否有数据可读：检测接收缓冲区是否有数据可读。

7.读取数据：读取接收缓冲区中的数据。

8.中断处理：根据需要进行中断处理，如错误处理、数据处理等。