• 09:STM32-------USART串口通信+串口数据包

    目录

    一:串口协议

    1:通信接口

    2:串口通信

    3:硬件电路

    4:电平标准

    5:串口参数及其时序

    二:USART介绍

    1:简历

    2:USART框图

    3:USART的基本结构

    4:数据帧

    5: 波特率发生器

    6:数据模式

    三:案例

    A:串口发送--单发送

    1:连接图

    2:函数介绍

    3:代码 

    B:串口发送+接收 

    1:函数介绍

     2:串口发送+接收 -----查询代码

    3:函数介绍

    4:串口发送+接收 -----中断代码

    四:USART串口数据包

    1:简历

    2:HEX数据包

    3: 文本数据包

    4:HEX数据包接收

    5:文本数据包接收

    6: 案例

    1:连接图

    A:发送HEX数据包---固定数据长度

    2:连接图

    B:发送文本数据包---数据长度 

    一:串口协议

    1:通信接口

    通信的目的：将一个设备的数据传送到另一个设备，扩展硬件系统

    通信协议：制定通信的规则，通信双方按照协议规则进行数据收发

    USART通信:

            TX:  发送数据的引脚

            RX : 接收数据的引脚

    I2C通信:

            SCL: 时钟     SDA:数据

    SPI通信:

            SCLK:时钟   MOSl:主机输出数据脚    MISO :  主机输入数据脚    CS : 片选，用于指定通信的对象

    CAN通信:

            是差分数据脚，用两个引脚表示一个差分数据

    USB通信:

            也是 是差分数据脚

     双工

    全双工:就是指通信双方能够同时进行双向通信,  两个数据线分别负责发送和接收数据

    半双工 : 一根数据线负责发送和接收数据,   eg:I2C通信的SDA线

    时钟

    同步: 接收方可以在时钟信号的指引下进行采样

    异步 : 没有时钟线,  所以需要双方约定一个采样频率,   还需要加一些帧头帧尾等，进行采样位置的对齐

    电平

    单端: 它们引脚的高低电平都是对GND的电压差,   所以单端信号通信的双方必须要共地，就是把GND接在一起

    差分 : 差分信号,   它是靠两个差分引脚的电压差来传输信号的,   在通信的时候，可以不需要GND,   使用差分信号可以极大地提高抗干扰特性

    设备

    点对点 : 直接传输数据就可以了

    多设备 : 一对多,  需要有一个导址的过程，以确定通信的对象

    2:串口通信

            串口是一种应用十分广泛的通讯接口，串口成本低、容易使用、通信线路简单，可实现两个设备的互相通信

            单片机的串口可以使单片机与单片机、单片机与电脑、单片机与各式各样的模块互相通信，极大地扩展了单片机的应用范围，增强了单片机系统的硬件实力

    3:硬件电路

            简单双向串口通信有两根通信线（发送端TX和接收端RX）

            TX与RX要交叉连接

            当只需单向的数据传输时，可以只接一根通信线

            当电平标准不一致时，需要加电平转换芯片-----------相同的电平标准才可以通信

     VCC的连接

            上面的VCG，如果两个设备都有独立供电,  VCC可以不接

            如果一个设备没有独立供电,  需要VCC把他们连接起来

    4:电平标准

            电平标准是数据1和数据0的表达方式，是传输线缆中人为规定的电压与数据的对应关系，串口常用的电平标准有如下三种：

            TTL电平：+3.3V或+5V表示1，0V表示0

            RS232电平：-3~-15V表示1，+3~+15V表示0

            RS485电平：两线压差+2~+6V表示1，-2~-6V表示0（差分信号）

    5:串口参数及其时序

            波特率：串口通信的速率--------波特率表示单位时间内传送的码元符号的个数.      规定串口通信的速率,   串口一般是使用异步通信,  发送和接收，必须要约定好速率,  速率参数，就是波特率.   双方规定波特率为1000bps,   那就表示，1s要发1000位，每一位的时间就是1ms

            起始位：标志一个数据帧的开始，固定为低电平------串口的空闲状态是高电平,起始位产生一个下降沿, 告诉接收设备要开始传输数据了

            停止位：用于数据帧间隔，固定为高电平-------停止位固定为1，把引脚恢复成高电平,方便下次的数据传输,   可以选择1位、1.5位、2位等

            数据位：数据帧的有效载荷，1为高电平，0为低电平，低位先行

            校验位：用于数据验证，根据数据位计算得来------校验可以选择3种方式，无校验、奇校验和偶校验

            串口中，每一个字节都装载在一个数据帧里面,   每个数据帧都由起始位、数据位和停止位组成

            左边: 这里数据位有8个，代表一个字节的8位         (一个字节为8位)

            右边 : 数据帧里面，还可以在数据位的最后,加一个奇偶校验位 ,这样数据位就9位

    奇偶校验位----实际是对高电频1的校验

            奇校验 : 发送数据0000 1111 采用右边的数据位为9位, 给第9位补1, 这时候1就为5个为奇数,      接收方一验证，发现1的个数不是奇数，那就认为传输出错,  就可以选择丢弃，或者要求重传

            偶校验: 发送数据0000 1111 采用右边的数据位为9位, 给第9位补0, 这时候1就为4个为偶数, 接收方一验证，发现1的个数不是偶数，那就认为传输出错,  就可以选择丢弃，或者要求重传

            奇偶校验只能保证一定程度上的数据校验

    数据位的2中表示方法

            一种是把校验位作为数据位的一部分,  分为8位数据和9位数据,   其中9位数据，就是8位有效载荷和1位校验位,   另一种就是把数据位和校验位独立开,  数据位就是有效载荷，校验位就是独立的1位

    二:USART介绍

    1:简历

            USART（Universal Synchronous/Asynchronous Receiver/Transmitter）通用同步/异步收发器

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

            自带波特率发生器，最高达4.5Mbits/s 可配置数据位长度（8/9）、停止位长（0.5/1/1.5/2）

            可选校验位（无校验/奇校验/偶校验）

            支持同步模式、硬件流控制、DMA、智能卡、IrDA、LIN

    STM32F103C8T6 USART资源： USART1、 USART2、 USART3

            硬件流控制，-----------比如A设备有个TX向B设备的RX发送数据,   A设备一直在发，发的太快了,  如果没有硬件流控制,   那B就只能抛弃新数据或者覆盖原数据了.     如果有硬件流控制，在硬件电路上，会多出一根线,   如果B没准备好接收，就置高电平，如果准备好了，就置低电平;    A接收到了B反馈的准备信号，就只会在B准备好的时候，才发数据

            硬件流控制，可以防止因为B处理慢而导致数据丢失的问题

    2:USART框图

    寄存器

            DR寄存器 : TDR和RDR数据寄存器占用同一个地址,在程序上他们表现为一个寄存器DR寄存器,   TDR是只写的RDR是只读的,  当你进行写操作时 数据就写入到TDR寄存器.   当你进行读操作时，数据就是从RDR读出来的

            发送(接收)移位寄存器:  发送移位寄存器的作用就是，把个字节的数据一位一位地移出去

    标志位-----移位完成产生标志位

            TXE : 在存器里就是二进制存储，0101 0101,   硬件检测到你写入数据了,  就会检查，当前移位寄存器是不是有数据正在移位;   如果没有，这个0101 0101就会立刻全部移动到发送移位寄存器,  准备发送.  当数据从TDR移动到移位寄存器时会置一个标志位(TXE置1)，叫TXE,  发送寄存器空,  就可以在TDR写入下一个数据了

            当TXE标志位置1时,  数据其实还没有发送出去,    只要数据从TDR转移到发送移位寄存器了   ,   TXE就会置1，我们就可以写入新的数据了

            

    while (USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);

            检查标志位USART1的TEX标志为是否等于0-----TDR寄存器的数据有没有移动到发送移位寄存器里面去

            RXNE: 和TXE相同的道理:   当数据从接收移位寄存器,    移动到移位RDR寄存器时会置一个标志位(RXNE置1),  这个也不用手动清除标志位, 和TXE原理相同

    3:USART的基本结构

    4:数据帧

    5: 波特率发生器

            发送器和接收器的波特率由波特率寄存器BRR里的DIV确定

            计算公式：波特率 = fPCLK2/1 / (16 * DIV)

            配置USART1为9600的波特率

    6:数据模式

            HEX模式/十六进制模式/二进制模式：以原始数据的形式显示

            文本模式/字符模式：以原始数据编码后的形式显示

    三:案例

    A:串口发送--单发送

    1:连接图

    2:函数介绍

    在stm32f10x usart.h文件中-----配置USART

    void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct)

    在stm32f10x usart.h文件中-----发送数据

    void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);

     在stm32f10x usart.h文件中-----检查某个寄存器的中断标志位

    FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG);

    USART_GetFlagStatus :      获取标志位状态的函数

    3:代码 

    1. #include "stm32f10x.h"                  // Device header
    2. #include "Delay.h"
    3. #include "OLED.h"
    4. #include "Serial.h"
    5. #include 
    6. void serial_init(void){
    7. 	//开启RCC时钟
    8. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    9. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    10. 	//配置TI的GPIO
    11. 	GPIO_InitTypeDef GPIO_structinit;
    12. 	GPIO_structinit.GPIO_Mode=GPIO_Mode_AF_PP;//复用推挽输出:把控制权交给片上外设
    13. 	GPIO_structinit.GPIO_Pin=GPIO_Pin_9;
    14. 	GPIO_structinit.GPIO_Speed=GPIO_Speed_50MHz;
    15. 	GPIO_Init(GPIOA,&GPIO_structinit);
    16. 	//USART的配置
    17. 	USART_InitTypeDef USART_structinit;
    18. 	USART_structinit.USART_BaudRate=9600;//通信的波特率
    19. 	USART_structinit.USART_HardwareFlowControl=USART_HardwareFlowControl_None;//硬件流控制--不使用
    20. 	USART_structinit.USART_Mode=USART_Mode_Tx;//配置GPIO为TX发送数据模式
    21. 	USART_structinit.USART_Parity=USART_Parity_No;  //选择校验方式---无校验
    22. 	USART_structinit.USART_StopBits=USART_StopBits_1;//停止的位数
    23. 	USART_structinit.USART_WordLength=USART_WordLength_8b;//发送或接收的数据位---我们使用8为
    24. 	USART_Init(USART1,&USART_structinit);
    25. 	//启动USART
    26. 	USART_Cmd(USART1,ENABLE);
    27. }
    28.  
    29. //发送数据
    30. void Serial_SendByte(uint8_t Byte)
    31. {	
    32. 	//发送数据的函数
    33. 	USART_SendData(USART1,Byte);
    34. 	//检查某个寄存器的中断标志位
    35. 	while (USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
    36. 	/*
    37. 	在完成数据发送的时候,TXE置1;
    38. 	下次发送数据自动置0,所以不用手动清除中断标志位.
    39. 	
    40. 	TXE:发送数据寄存器:
    41. 	当TDR寄存器中的数据被硬件转移到移位寄存器的时候，该位被硬件置位。
    42. 	如果USART_CR1寄存器中的TXEIE为1，则产生中断。对USART DR的写操作，将该位清零。
    43. 	0:数据还没有被转移到移位寄存器
    44. 	1:数据已经被转移到移位寄存器。
    45. 	注意:单缓冲器传输中使用该位。
    46. 	*/
    47. }	
    48.  
    49. //发送一个数组;Array:传递的数组,Length数组的长度
    50. void Serial_SendArray(uint8_t *Array, uint16_t Length){
    51. 	 
    52. 	for(uint16_t i=0;i
    53. 	{
    54. 		Serial_SendByte(Array[i]);
    55. 	}
    56.  
    57. }
    58.  
    59. //发送一个字符串
    60. //发送字符串时自带结束标志位
    61. void Serial_Sendstr(char *str)
    62. {
    63. 	for (uint8_t i=0 ; str[i]!=0;i++){//也可写为str[i]!='\0'
    64. 		Serial_SendByte(str[i]);
    65.  
    66. 	}
    67. }
    68.  
    69. //取数字的某一位:数字/10^x/%10 ----/10^x就是把这一位的右边去掉，%10就是把左边去掉
    70. //12345取3 12345/100(10^2)%10=3   x:从左往右数,不包含要取的数字
    71. uint32_t Serial_Pow(uint32_t X, uint32_t Y) //X^Y
    72. {
    73. 	uint32_t Result = 1;
    74. 	while (Y --)
    75. 	{
    76. 		Result *= X;
    77. 	}
    78. 	return Result;
    79. }
    80. //传输数字,把数字中的每一位取出,然后发送出去
    81. //Number:传输的数字;   Length:传输数字的长度
    82. void Serial_SendNumber(uint32_t Number, uint8_t Length)
    83. {
    84. 	uint8_t i;
    85. 	for (i = 0; i < Length; i ++)
    86. 	{
    87. 		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
    88. 	}
    89. }
    90.  
    91. //printf函数的底层
    92. int fputc(int ch, FILE *f)
    93. {
    94. 	Serial_SendByte(ch);
    95. 	return ch;
    96. }
    97.  
    98. //spinrf函数的封装
    99. void Serial_Printf(char *format, ...)
    100. {
    101. 	char String[100];
    102. 	va_list arg;
    103. 	va_start(arg, format);
    104. 	vsprintf(String, format, arg);
    105. 	va_end(arg);
    106. 	Serial_Sendstr(String);
    107. }
    108.  
    109.  
    110.  
    111.  
    112. int main(void)
    113. {
    114. 	OLED_Init();
    115. 	serial_init();
    116. 	
    117. 	Serial_SendByte(0x41);
    118. 	
    119. 	uint8_t Array[]={0x01,0x08,0x43,0x45};
    120. 	Serial_SendArray(Array,4);
    121. 	
    122. 	//换行的话需要加上\r\n
    123. 	Serial_Sendstr("Helloword\r\n");
    124. 	Serial_Sendstr("123\r\n");
    125.  
    126. 	
    127. 	Serial_SendNumber(231,3);
    128. 	
    129. 	//使得printf函数移植方法
    130. 	printf("NUM=%d,",123);
    131. 	
    132. 	char String[100];
    133. 	sprintf(String, "\r\nNum3=%d", 333);
    134. 	Serial_Sendstr(String);
    135. 	
    136. 	
    137. 	Serial_Printf("\r\nNum4=%d", 444);
    138. 	Serial_Printf("\r\n");
    139. 	
    140. 	printf("你好世界");
    141. 	
    142. 	
    143. 	while (1)
    144. 	{
    145. 		
    146. 	}
    147. }

    printf函数三中移植的方法----使得可以通过串口通信打印到其他外设:

    1:通过重写printf函数的底层,使他通过串口

    1. //printf函数的底层
    2. #include 
    3. int fputc(int ch, FILE *f)
    4. {
    5. 	Serial_SendByte(ch);
    6. 	return ch;
    7. }

    2:直接使用sprintf函数

    1.     char String[100];
    2. 	sprintf(String, "\r\nNum3=%d", 333);
    3. 	Serial_Sendstr(String);

    3:对sprintf函数进行封装

    1. //spinrf函数的封装
    2. #include 
    3.  
    4. void Serial_Printf(char *format, ...)
    5. {
    6. 	char String[100];
    7. 	va_list arg;
    8. 	va_start(arg, format);
    9. 	vsprintf(String, format, arg);
    10. 	va_end(arg);
    11. 	Serial_Sendstr(String);  //调用的Serial_Sendstr函数在代码里面可查询
    12. }
    13.  
    14. Serial_Printf("\r\nNum4=%d", 444);

    B:串口发送+接收 

    对于串口接收来说，可以使用查询和中断两种方法

    1:函数介绍

    在stm32f10x usart.h文件中-----返回外设最近接收的数据

    uint16_t USART_ReceiveData(USART_TypeDef* USARTx);

    USART_ReceiveData :  返回USARTx外设最近接收到的数据

     2:串口发送+接收 -----查询代码

    1. #include "stm32f10x.h"                  // Device header
    2. #include "Delay.h"
    3. #include "OLED.h"
    4. #include "Serial.h"
    5. #include 
    6. #include 
    7. void serial_init(void){
    8. 	//开启RCC时钟
    9. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    10. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    11. 	//配置TI的GPIO
    12. 	GPIO_InitTypeDef GPIO_structinit;
    13. 	GPIO_structinit.GPIO_Mode=GPIO_Mode_AF_PP;//复用推挽输出:把控制权交给片上外设
    14. 	GPIO_structinit.GPIO_Pin=GPIO_Pin_9; //PA9在引脚定义中为TX发送
    15. 	GPIO_structinit.GPIO_Speed=GPIO_Speed_50MHz;
    16. 	GPIO_Init(GPIOA,&GPIO_structinit);
    17. 	
    18. 		
    19. 	GPIO_structinit.GPIO_Mode=GPIO_Mode_IPU;//上拉输入
    20. 	GPIO_structinit.GPIO_Pin=GPIO_Pin_10; PA9在引脚定义中为RX接收
    21. 	GPIO_structinit.GPIO_Speed=GPIO_Speed_50MHz;
    22. 	GPIO_Init(GPIOA,&GPIO_structinit);
    23. 	
    24. 	//USART的配置
    25. 	USART_InitTypeDef USART_structinit;
    26. 	USART_structinit.USART_BaudRate=9600;//通信的波特率
    27. 	USART_structinit.USART_HardwareFlowControl=USART_HardwareFlowControl_None;//硬件流控制--不使用
    28. 	USART_structinit.USART_Mode=USART_Mode_Tx |USART_Mode_Rx;//配置GPIO为TX发送数据模式
    29. 	USART_structinit.USART_Parity=USART_Parity_No;  //选择校验方式---无校验
    30. 	USART_structinit.USART_StopBits=USART_StopBits_1;//停止的位数
    31. 	USART_structinit.USART_WordLength=USART_WordLength_8b;//发送或接收的数据位---我们使用8为
    32. 	USART_Init(USART1,&USART_structinit);
    33. 	//启动USART
    34. 	USART_Cmd(USART1,ENABLE);
    35. }
    36.  
    37. //发送数据
    38. void Serial_SendByte(uint8_t Byte)
    39. {	
    40. 	//发送数据的函数
    41. 	USART_SendData(USART1,Byte);
    42. 	//检查某个寄存器的中断标志位
    43. 	while (USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
    44. 	/*
    45. 	在完成数据发送的时候,TXE置1;
    46. 	下次发送数据自动置0,所以不用手动清除中断标志位.
    47. 	
    48. 	TXE:发送数据寄存器:
    49. 	当TDR寄存器中的数据被硬件转移到移位寄存器的时候，该位被硬件置位。
    50. 	如果USART_CR1寄存器中的TXEIE为1，则产生中断。对USART DR的写操作，将该位清零。
    51. 	0:数据还没有被转移到移位寄存器
    52. 	1:数据已经被转移到移位寄存器。
    53. 	注意:单缓冲器传输中使用该位。
    54. 	*/
    55. }	
    56.  
    57. //发送一个数组;Array:传递的数组,Length数组的长度
    58. void Serial_SendArray(uint8_t *Array, uint16_t Length){
    59. 	 
    60. 	for(uint16_t i=0;i
    61. 	{
    62. 		Serial_SendByte(Array[i]);
    63. 	}
    64.  
    65. }
    66.  
    67. //发送一个字符串
    68. //发送字符串时自带结束标志位
    69. void Serial_Sendstr(char *str)
    70. {
    71. 	for (uint8_t i=0 ; str[i]!=0;i++){//也可写为str[i]!='\0'
    72. 		Serial_SendByte(str[i]);
    73.  
    74. 	}
    75. }
    76.  
    77. //取数字的某一位:数字/10^x/%10 ----/10^x就是把这一位的右边去掉，%10就是把左边去掉
    78. //12345取3 12345/100(10^2)%10=3   x:从左往右数,不包含要取的数字
    79. uint32_t Serial_Pow(uint32_t X, uint32_t Y) //X^Y
    80. {
    81. 	uint32_t Result = 1;
    82. 	while (Y --)
    83. 	{
    84. 		Result *= X;
    85. 	}
    86. 	return Result;
    87. }
    88. //传输数字,把数字中的每一位取出,然后发送出去
    89. //Number:传输的数字;   Length:传输数字的长度
    90. void Serial_SendNumber(uint32_t Number, uint8_t Length)
    91. {
    92. 	uint8_t i;
    93. 	for (i = 0; i < Length; i ++)
    94. 	{
    95. 		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
    96. 	}
    97. }
    98.  
    99. //printf函数的底层
    100. int fputc(int ch, FILE *f)
    101. {
    102. 	Serial_SendByte(ch);
    103. 	return ch;
    104. }
    105.  
    106. //spinrf函数的封装
    107. void Serial_Printf(char *format, ...)
    108. {
    109. 	char String[100];
    110. 	va_list arg;
    111. 	va_start(arg, format);
    112. 	vsprintf(String, format, arg);
    113. 	va_end(arg);
    114. 	Serial_Sendstr(String);
    115. }
    116.  
    117.  
    118. uint8_t RXdata;
    119.  
    120. int main(void)
    121. {	
    122. 	
    123. 	OLED_Init();
    124. 	serial_init();
    125. 	
    126.  
    127. 	
    128. 	
    129. 	while (1)
    130. 	{
    131. 		if (USART_GetFlagStatus(USART1,USART_FLAG_RXNE)==SET){
    132. 			RXdata=USART_ReceiveData(USART1);//返回外设最近接收的数据
    133. 			OLED_ShowHexNum(1,1,RXdata,3);
    134. 		
    135. 		
    136. 		
    137. 		}
    138. 	}
    139. }

    PA9口和PA10口的GPIO的模式不同

    引脚的定义

    PA9-----TX发送引脚;          PA10--------Rx接收引脚     

    GPIO工作模式的选择          

            输入工作模式----------将引脚的信号读取到微型控制器---PA10

            输出工作模式---------将微型控制器信号读取到阴极段--PA9

    发送输出;   接收输入

    3:函数介绍

    在stm32f10x usart.h文件中-----使能中断输出信号

    void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState);

    USART_ITConfig : 启用或禁用指定的USART中断

    配置NVIC在misc.h文件中的函数-----配置NVIC

    void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup);
    void NVIC_Init(NVIC_InitTypeDef* NVIC_InitStruct);

    NVIC_PriorityGroupConfig:用来中断分组的，参数是中断分组的方式

    NVIC_Init: 根据结构体里面指定的参数初始化NMIC

     在stm32f10x usart.h文件中-----检查某个寄存器的中断标志位

    FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG);

     在stm32f10x usart.h文件中-----清除中断标志位

    void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT)

     USART_ClearITPendingBit  :        清除USARTx的中断挂起位

    4:串口发送+接收 -----中断代码

            在开启USART之前

    1: 启动USART的RXNE中断,  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);

    2: 配置NVIC

    1. #include "stm32f10x.h"                  // Device header
    2. #include "Delay.h"
    3. #include "OLED.h"
    4. #include "Serial.h"
    5. #include 
    6. #include 
    7. uint8_t Serial_RxData;
    8. uint8_t Serial_RxFlag;
    9. void serial_init(void){
    10. 	//开启RCC时钟
    11. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    12. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    13. 	//配置TI的GPIO
    14. 	GPIO_InitTypeDef GPIO_structinit;
    15. 	GPIO_structinit.GPIO_Mode=GPIO_Mode_AF_PP;//复用推挽输出:把控制权交给片上外设
    16. 	GPIO_structinit.GPIO_Pin=GPIO_Pin_9; //PA9在引脚定义中为TX发送
    17. 	GPIO_structinit.GPIO_Speed=GPIO_Speed_50MHz;
    18. 	GPIO_Init(GPIOA,&GPIO_structinit);
    19. 	
    20. 		
    21. 	GPIO_structinit.GPIO_Mode=GPIO_Mode_IPU;//上拉输入
    22. 	GPIO_structinit.GPIO_Pin=GPIO_Pin_10; PA9在引脚定义中为RX接收
    23. 	GPIO_structinit.GPIO_Speed=GPIO_Speed_50MHz;
    24. 	GPIO_Init(GPIOA,&GPIO_structinit);
    25. 	
    26. 	//USART的配置
    27. 	USART_InitTypeDef USART_structinit;
    28. 	USART_structinit.USART_BaudRate=9600;//通信的波特率
    29. 	USART_structinit.USART_HardwareFlowControl=USART_HardwareFlowControl_None;//硬件流控制--不使用
    30. 	USART_structinit.USART_Mode=USART_Mode_Tx |USART_Mode_Rx;//配置GPIO为TX发送数据模式
    31. 	USART_structinit.USART_Parity=USART_Parity_No;  //选择校验方式---无校验
    32. 	USART_structinit.USART_StopBits=USART_StopBits_1;//停止的位数
    33. 	USART_structinit.USART_WordLength=USART_WordLength_8b;//发送或接收的数据位---我们使用8为
    34. 	USART_Init(USART1,&USART_structinit);
    35. 	
    36. 	//启动USART的RXNE中断
    37. 	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    38. 	//开启NVIC
    39. 	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    40. 	
    41. 	NVIC_InitTypeDef NVIC_initstruct;
    42. 	NVIC_initstruct.NVIC_IRQChannel=USART1_IRQn; //通道
    43. 	NVIC_initstruct.NVIC_IRQChannelCmd=ENABLE;
    44. 	NVIC_initstruct.NVIC_IRQChannelPreemptionPriority=1;
    45. 	NVIC_initstruct.NVIC_IRQChannelSubPriority=1;
    46. 	NVIC_Init(&NVIC_initstruct);
    47. 	
    48.  
    49. 	//启动USART
    50. 	USART_Cmd(USART1,ENABLE);
    51. }
    52.  
    53. //发送数据
    54. void Serial_SendByte(uint8_t Byte)
    55. {	
    56. 	//发送数据的函数
    57. 	USART_SendData(USART1,Byte);
    58. 	//检查某个寄存器的中断标志位
    59. 	while (USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
    60. 	/*
    61. 	在完成数据发送的时候,TXE置1;
    62. 	下次发送数据自动置0,所以不用手动清除中断标志位.
    63. 	
    64. 	TXE:发送数据寄存器:
    65. 	当TDR寄存器中的数据被硬件转移到移位寄存器的时候，该位被硬件置位。
    66. 	如果USART_CR1寄存器中的TXEIE为1，则产生中断。对USART DR的写操作，将该位清零。
    67. 	0:数据还没有被转移到移位寄存器
    68. 	1:数据已经被转移到移位寄存器。
    69. 	注意:单缓冲器传输中使用该位。
    70. 	*/
    71. }	
    72.  
    73. //发送一个数组;Array:传递的数组,Length数组的长度
    74. void Serial_SendArray(uint8_t *Array, uint16_t Length){
    75. 	 
    76. 	for(uint16_t i=0;i
    77. 	{
    78. 		Serial_SendByte(Array[i]);
    79. 	}
    80.  
    81. }
    82.  
    83. //发送一个字符串
    84. //发送字符串时自带结束标志位
    85. void Serial_Sendstr(char *str)
    86. {
    87. 	for (uint8_t i=0 ; str[i]!=0;i++){//也可写为str[i]!='\0'
    88. 		Serial_SendByte(str[i]);
    89.  
    90. 	}
    91. }
    92.  
    93. //取数字的某一位:数字/10^x/%10 ----/10^x就是把这一位的右边去掉，%10就是把左边去掉
    94. //12345取3 12345/100(10^2)%10=3   x:从左往右数,不包含要取的数字
    95. uint32_t Serial_Pow(uint32_t X, uint32_t Y) //X^Y
    96. {
    97. 	uint32_t Result = 1;
    98. 	while (Y --)
    99. 	{
    100. 		Result *= X;
    101. 	}
    102. 	return Result;
    103. }
    104. //传输数字,把数字中的每一位取出,然后发送出去
    105. //Number:传输的数字;   Length:传输数字的长度
    106. void Serial_SendNumber(uint32_t Number, uint8_t Length)
    107. {
    108. 	uint8_t i;
    109. 	for (i = 0; i < Length; i ++)
    110. 	{
    111. 		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
    112. 	}
    113. }
    114.  
    115. //printf函数的底层
    116. int fputc(int ch, FILE *f)
    117. {
    118. 	Serial_SendByte(ch);
    119. 	return ch;
    120. }
    121.  
    122. //spinrf函数的封装
    123. void Serial_Printf(char *format, ...)
    124. {
    125. 	char String[100];
    126. 	va_list arg;
    127. 	va_start(arg, format);
    128. 	vsprintf(String, format, arg);
    129. 	va_end(arg);
    130. 	Serial_Sendstr(String);
    131. }
    132.  
    133.  
    134. uint8_t Serial_GetRxFlag(void)
    135. {
    136. 	if (Serial_RxFlag == 1)
    137. 	{
    138. 		Serial_RxFlag = 0;
    139. 		return 1;
    140. 	}
    141. 	return 0;
    142. }
    143.  
    144. uint8_t Serial_GetRxData(void)
    145. {
    146. 	return Serial_RxData;
    147. }
    148.  
    149.  
    150. //USART的中断函数----在启动文件中找
    151. void USART1_IRQHandler(){
    152. 	//判断RXNE的中断标志位
    153. 	if (USART_GetFlagStatus(USART1,USART_FLAG_RXNE)==SET){
    154. 		Serial_RxData = USART_ReceiveData(USART1);
    155. 		Serial_RxFlag = 1;
    156. 		USART_ClearITPendingBit(USART1,USART_FLAG_RXNE);
    157. 	}
    158. }
    159.  
    160.  
    161.  
    162.  
    163.  
    164. uint8_t RxData;
    165.  
    166. int main(void)
    167. {
    168. 	OLED_Init();
    169. 	OLED_ShowString(1, 1, "RxData:");
    170. 	
    171. 	serial_init();
    172. 	
    173. 	while (1)
    174. 	{
    175. 		if (Serial_GetRxFlag() == 1)
    176. 		{
    177. 			RxData = Serial_GetRxData();
    178. 			Serial_SendByte(RxData);
    179. 			OLED_ShowHexNum(1, 8, RxData, 3);
    180. 		}
    181. 	}
    182. }

    四:USART串口数据包

    1:简历

      数据包作用 : 把一个个单独的数据给打包起来,   方便我们进行多字节的数据通信

    需要把多个字节打包为一个整体进行发送, 极大的方便了我们的使用

    2:HEX数据包

            数据包的包头和包尾是可以自己进行设定的,  它并不是一个固定的

            固定包长, 含包头包尾 : 每个数据包的长度都固定不变 (自己定数据包的长度) ,  数据包前面是包头，后面是包尾

            可变包长，含包头包尾 : 每个数据包的长度可以是不一样的,  数据包前面是包头，后面是包尾

    包头包尾和数据载荷重复的问题 

            当包头包尾的数据和传输的数据重复时-----定义FF为包头，FE为包尾,  如果我传输的数据本身就是FF和FE,  可能会引起误判 

            解决:

            A: 限制载荷数据的范围-------可以在发送的时候，对数据进行限幅.   比如XYZ，3个数据，变化范围都可以是0~100.   我们可以在载荷中只发送0~100的数据

            B:无法避免载荷数据和包头包尾重复-----尽量使用固定长度的数据包,  由于载荷数据是固定的,  只要通过包头和包尾对齐的数据.   就可以哪个数据应该是包头包尾，哪个数据应该是载荷数据.        在接收载荷数据的时候，我们并不会判断它是否是包头包尾,   而在接收包头包尾的时候，我们会判断它是不是确实是包头包尾

            C:增加包头包尾的数量---------尽量呈现出载荷数据出现不了的状态

    固定包长和可变包长的选择问题 

            载荷会出现和包头包尾重复的情况--------最好选择固定包长

            反之选择可变包长

    3: 文本数据包

    在HEX数据包里面，数据都是以原始的字节数据本身呈现的,   而在文本数据包里面，每个字节就经过了一层编码和译码,  最终表现出来的，就是文本格式.   其实都还是一个字节的HEX数据

    4:HEX数据包接收

            每收到一个字节，程序都会进一遍中断 .

    状态机:

            最开始，S=0,  收到一个数据，进中断,   判断数据是不是包头FF,  如果是FF，则代表收到包头,  之后置S=1，退出中断，结束.   下次再进中断，根据S=1，就可以进行接收数据的程序了.   这时再收到数据，我们就直接把它存在数组中,  另外再用一个变量，记录收了多少个数据,  如果没收够规定的数据，就一直是接收状态, 如果收够了，就置S=2.   下次中断时，就可以进入下一个状态了.       最后一个状态就是等待包尾了,判断数据是不是FE,  这样就可以置S=0，回到最初的状态，开始下一个轮回

    5:文本数据包接收

    6: 案例

    1:连接图

    A:发送HEX数据包---固定数据长度

    1.  
    2. #include "stm32f10x.h"                  // Device header
    3. #include "Delay.h"
    4. #include "OLED.h"
    5. #include "Serial.h"
    6. #include "Key.h"
    7. #include 
    8. #include 
    9.  
    10. uint8_t Serial_RxFlag;//一个数据包发送完成的标志位
    11.  
    12. uint8_t Serial_TXPacket[4];//存放发送的数据---STM32向外设发送
    13. uint8_t Serial_RXPacket[4];//存放接收的数据---外设向STM32发送数据
    14.  
    15. void serial_init(void){
    16. 	//开启RCC时钟
    17. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    18. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    19. 	//配置TI的GPIO
    20. 	GPIO_InitTypeDef GPIO_structinit;
    21. 	GPIO_structinit.GPIO_Mode=GPIO_Mode_AF_PP;//复用推挽输出:把控制权交给片上外设
    22. 	GPIO_structinit.GPIO_Pin=GPIO_Pin_9; //PA9在引脚定义中为TX发送
    23. 	GPIO_structinit.GPIO_Speed=GPIO_Speed_50MHz;
    24. 	GPIO_Init(GPIOA,&GPIO_structinit);
    25. 	
    26. 		
    27. 	GPIO_structinit.GPIO_Mode=GPIO_Mode_IPU;//上拉输入
    28. 	GPIO_structinit.GPIO_Pin=GPIO_Pin_10; PA9在引脚定义中为RX接收
    29. 	GPIO_structinit.GPIO_Speed=GPIO_Speed_50MHz;
    30. 	GPIO_Init(GPIOA,&GPIO_structinit);
    31. 	
    32. 	//USART的配置
    33. 	USART_InitTypeDef USART_structinit;
    34. 	USART_structinit.USART_BaudRate=9600;//通信的波特率
    35. 	USART_structinit.USART_HardwareFlowControl=USART_HardwareFlowControl_None;//硬件流控制--不使用
    36. 	USART_structinit.USART_Mode=USART_Mode_Tx |USART_Mode_Rx;//配置GPIO为TX发送数据模式
    37. 	USART_structinit.USART_Parity=USART_Parity_No;  //选择校验方式---无校验
    38. 	USART_structinit.USART_StopBits=USART_StopBits_1;//停止的位数
    39. 	USART_structinit.USART_WordLength=USART_WordLength_8b;//发送或接收的数据位---我们使用8为
    40. 	USART_Init(USART1,&USART_structinit);
    41. 	
    42. 	//启动USART的RXNE中断
    43. 	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    44. 	//开启NVIC
    45. 	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    46. 	
    47. 	NVIC_InitTypeDef NVIC_initstruct;
    48. 	NVIC_initstruct.NVIC_IRQChannel=USART1_IRQn; //通道
    49. 	NVIC_initstruct.NVIC_IRQChannelCmd=ENABLE;
    50. 	NVIC_initstruct.NVIC_IRQChannelPreemptionPriority=1;
    51. 	NVIC_initstruct.NVIC_IRQChannelSubPriority=1;
    52. 	NVIC_Init(&NVIC_initstruct);
    53. 	
    54.  
    55. 	//启动USART
    56. 	USART_Cmd(USART1,ENABLE);
    57. }
    58.  
    59. /**
    60.   * @brief  发送一个字节的数据--8位STM32向外设发送===通过USARTx外设传输单个数据
    61.   * @param  需要发送的数据
    62.   * @retval 无
    63.   */
    64. void Serial_SendByte(uint8_t Byte)
    65. {	
    66. 	//发送数据的函数
    67. 	USART_SendData(USART1,Byte);
    68. 	//检查某个寄存器的中断标志位
    69. 	while (USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
    70. 	/*
    71. 	在完成数据发送的时候,TXE置1;
    72. 	下次发送数据自动置0,所以不用手动清除中断标志位.
    73. 	
    74. 	TXE:发送数据寄存器:
    75. 	当TDR寄存器中的数据被硬件转移到移位寄存器的时候，该位被硬件置位。
    76. 	如果USART_CR1寄存器中的TXEIE为1，则产生中断。对USART DR的写操作，将该位清零。
    77. 	0:数据还没有被转移到移位寄存器
    78. 	1:数据已经被转移到移位寄存器。
    79. 	注意:单缓冲器传输中使用该位。
    80. 	*/
    81. }	
    82.  
    83.  
    84. /**
    85.   * @brief  发送一个数组
    86.   * @param  Array:传递的数组
    87. 	* @param  Length数组的长度
    88.   * @retval 无
    89.   */
    90. void Serial_SendArray(uint8_t *Array, uint16_t Length){
    91. 	 
    92. 	for(uint16_t i=0;i
    93. 	{
    94. 		Serial_SendByte(Array[i]);
    95. 	}
    96.  
    97. }
    98.  
    99.  
    100.  
    101. /**
    102.   * @brief  发送一个字符串
    103.   * @param  需要发送的字符串
    104.   * @retval 无
    105.   */
    106. void Serial_Sendstr(char *str)
    107. {	//发送字符串时自带结束标志位
    108. 	for (uint8_t i=0 ; str[i]!=0;i++){//也可写为str[i]!='\0'
    109. 		Serial_SendByte(str[i]);
    110.  
    111. 	}
    112. }
    113.  
    114.  
    115. /**
    116.   * @brief  取数字的某一位:数字/10^x/%10 ----/10^x就是把这一位的右边去掉，%10就是把左边去掉
    117. 	12345取3 12345/100(10^2)%10=3   x:从左往右数,不包含要取的数字
    118. 	* @param  X:底数
    119. 	* @param  Y:指数
    120.   * @retval 无
    121.   */
    122. uint32_t Serial_Pow(uint32_t X, uint32_t Y) //X^Y
    123. {
    124. 	uint32_t Result = 1;
    125. 	while (Y --)
    126. 	{
    127. 		Result *= X;
    128. 	}
    129. 	return Result;
    130. }
    131.  
    132. /**
    133.   * @brief  输数字,把数字中的每一位取出,然后发送出去
    134.   * @param  传输的数字
    135. 	* @param  传输数字的长度
    136.   * @retval 无
    137.   */
    138. void Serial_SendNumber(uint32_t Number, uint8_t Length)
    139. {
    140. 	uint8_t i;
    141. 	for (i = 0; i < Length; i ++)
    142. 	{
    143. 		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
    144. 	}
    145. }
    146.  
    147.  
    148. //printf函数的底层
    149. int fputc(int ch, FILE *f)
    150. {
    151. 	Serial_SendByte(ch);
    152. 	return ch;
    153. }
    154.  
    155. //spinrf函数的封装
    156. void Serial_Printf(char *format, ...)
    157. {
    158. 	char String[100];
    159. 	va_list arg;
    160. 	va_start(arg, format);
    161. 	vsprintf(String, format, arg);
    162. 	va_end(arg);
    163. 	Serial_Sendstr(String);
    164. }
    165.  
    166.  
    167. /**
    168.   * @brief  知道把中断标志位置位0
    169.   * @retval 无
    170.   */
    171. uint8_t Serial_GetRxFlag(void)
    172. {
    173. 	if (Serial_RxFlag == 1)
    174. 	{
    175. 		Serial_RxFlag = 0;
    176. 		return 1;
    177. 	}
    178. 	return 0;
    179. }
    180.  
    181.  
    182.  
    183. //------------------HEX包----------------------------
    184. /**
    185.   * @brief  发送HEX数据包---STM32发送到其他外设
    186.   * @retval 无
    187.   */
    188. uint16_t Send_HEX()
    189. {
    190. 	Serial_SendByte(0XFF);
    191. 	Serial_SendArray(Serial_TXPacket,4);
    192. 	Serial_SendByte(0XFE);
    193. }
    194.  
    195. /**
    196. * @brief  接收HEX数据包---其他外设发送到STM32上面
    197.   * @retval 无
    198.   */
    199. void USART1_IRQHandler(){
    200. 	//每收到一个字节，程序都会进一遍中断 
    201. 	//static---- 函数进入只会初始化一次,在函数退出后，数据仍然有效
    202. 	static uint8_t RxState = 0;//状态机的标志位
    203. 	static uint8_t pRxPacket = 0;//数据的包长
    204. 	//判断RXNE的中断标志位
    205. 	if (USART_GetFlagStatus(USART1,USART_FLAG_RXNE)==SET){
    206. 		
    207. 		uint8_t data=USART_ReceiveData(USART1);//32接收的数据
    208. 		if (RxState==0)
    209. 		{
    210. 			if (data==0XFF)
    211. 			{
    212. 				RxState=1;
    213. 			}		
    214. 		}
    215. 		else if (RxState==1)
    216. 		{
    217. 			Serial_RXPacket[pRxPacket]=data; //右边的值赋值给等号的左边
    218. 			pRxPacket++;
    219. 			if (pRxPacket>=4)
    220. 			{
    221. 				pRxPacket=0;
    222. 				RxState=2;
    223. 			}	
    224. 		}
    225. 		else if (RxState==2)
    226. 		{
    227. 			if (data==0xFE)
    228. 			{
    229. 				RxState=0;
    230. 				Serial_RxFlag=1;//一个数据包发送完成的标志位
    231. 			}
    232.  
    233. 		}
    234. 		
    235. 		USART_ClearITPendingBit(USART1,USART_FLAG_RXNE);
    236. 	}
    237. }
    238.  
    239.  
    240.  
    241. uint8_t RxData;
    242. uint8_t num;
    243. int main(void)
    244. {
    245. 	Key_Init();
    246. 	OLED_Init();
    247. 	serial_init();
    248. 	OLED_ShowString(1,1,"RX_Data:");
    249. 	OLED_ShowString(3,1,"TX_Data:");
    250. 	
    251. 	Serial_TXPacket[0]=0x01;
    252. 	Serial_TXPacket[1]=0x02;
    253. 	Serial_TXPacket[2]=0x03;
    254. 	Serial_TXPacket[3]=0x04;
    255. 	
    256. 	
    257. 	while (1)
    258. 	{	num=Key_GetNum();
    259. 		if (num==1)
    260. 		{
    261. 			//发送数据
    262. 		Serial_TXPacket[0]++;
    263. 		Serial_TXPacket[1]++;
    264. 		Serial_TXPacket[2]++;
    265. 		Serial_TXPacket[3]++;
    266. 		
    267. 		Send_HEX();
    268. 		
    269. 		OLED_ShowHexNum(2, 1, Serial_TXPacket[0], 2);
    270. 		OLED_ShowHexNum(2, 4, Serial_TXPacket[1], 2);
    271. 		OLED_ShowHexNum(2, 7, Serial_TXPacket[2], 2);
    272. 		OLED_ShowHexNum(2, 10, Serial_TXPacket[3], 2);
    273.  
    274. 		}
    275. 	
    276. 		//接收数据
    277. 		if (Serial_GetRxFlag()==1)
    278. 		{
    279. 			OLED_ShowHexNum(4, 1, Serial_RXPacket[0], 2);
    280. 			OLED_ShowHexNum(4, 4, Serial_RXPacket[1], 2);
    281. 			OLED_ShowHexNum(4, 7, Serial_RXPacket[2], 2);
    282. 			OLED_ShowHexNum(4, 10, Serial_RXPacket[3], 2);
    283. 		
    284. 		
    285. 		}
    286. 		
    287. 	}
    288. }

    2:连接图

    B:发送文本数据包---数据长度 

    1.  
    2. #include "stm32f10x.h"                  // Device header
    3. #include "Delay.h"
    4. #include "OLED.h"
    5. #include "Serial.h"
    6. #include "Key.h"
    7. #include "LED.h"
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. uint8_t Serial_RxFlag;//一个数据包发送完成的标志位
    13.  
    14. uint8_t Serial_TXPacket[4];//存放发送的数据---STM32向外设发送
    15. char Serial_RXPacket[100];//存放接收的数据---外设向STM32发送数据
    16.  
    17. void serial_init(void){
    18. 	//开启RCC时钟
    19. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    20. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    21. 	//配置TI的GPIO
    22. 	GPIO_InitTypeDef GPIO_structinit;
    23. 	GPIO_structinit.GPIO_Mode=GPIO_Mode_AF_PP;//复用推挽输出:把控制权交给片上外设
    24. 	GPIO_structinit.GPIO_Pin=GPIO_Pin_9; //PA9在引脚定义中为TX发送
    25. 	GPIO_structinit.GPIO_Speed=GPIO_Speed_50MHz;
    26. 	GPIO_Init(GPIOA,&GPIO_structinit);
    27. 	
    28. 		
    29. 	GPIO_structinit.GPIO_Mode=GPIO_Mode_IPU;//上拉输入
    30. 	GPIO_structinit.GPIO_Pin=GPIO_Pin_10; PA9在引脚定义中为RX接收
    31. 	GPIO_structinit.GPIO_Speed=GPIO_Speed_50MHz;
    32. 	GPIO_Init(GPIOA,&GPIO_structinit);
    33. 	
    34. 	//USART的配置
    35. 	USART_InitTypeDef USART_structinit;
    36. 	USART_structinit.USART_BaudRate=9600;//通信的波特率
    37. 	USART_structinit.USART_HardwareFlowControl=USART_HardwareFlowControl_None;//硬件流控制--不使用
    38. 	USART_structinit.USART_Mode=USART_Mode_Tx |USART_Mode_Rx;//配置GPIO为TX发送数据模式
    39. 	USART_structinit.USART_Parity=USART_Parity_No;  //选择校验方式---无校验
    40. 	USART_structinit.USART_StopBits=USART_StopBits_1;//停止的位数
    41. 	USART_structinit.USART_WordLength=USART_WordLength_8b;//发送或接收的数据位---我们使用8为
    42. 	USART_Init(USART1,&USART_structinit);
    43. 	
    44. 	//启动USART的RXNE中断
    45. 	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    46. 	//开启NVIC
    47. 	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    48. 	
    49. 	NVIC_InitTypeDef NVIC_initstruct;
    50. 	NVIC_initstruct.NVIC_IRQChannel=USART1_IRQn; //通道
    51. 	NVIC_initstruct.NVIC_IRQChannelCmd=ENABLE;
    52. 	NVIC_initstruct.NVIC_IRQChannelPreemptionPriority=1;
    53. 	NVIC_initstruct.NVIC_IRQChannelSubPriority=1;
    54. 	NVIC_Init(&NVIC_initstruct);
    55. 	
    56.  
    57. 	//启动USART
    58. 	USART_Cmd(USART1,ENABLE);
    59. }
    60.  
    61. /**
    62.   * @brief  发送一个字节的数据--8位STM32向外设发送===通过USARTx外设传输单个数据
    63.   * @param  需要发送的数据
    64.   * @retval 无
    65.   */
    66. void Serial_SendByte(uint8_t Byte)
    67. {	
    68. 	//发送数据的函数
    69. 	USART_SendData(USART1,Byte);
    70. 	//检查某个寄存器的中断标志位
    71. 	while (USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
    72. 	/*
    73. 	在完成数据发送的时候,TXE置1;
    74. 	下次发送数据自动置0,所以不用手动清除中断标志位.
    75. 	
    76. 	TXE:发送数据寄存器:
    77. 	当TDR寄存器中的数据被硬件转移到移位寄存器的时候，该位被硬件置位。
    78. 	如果USART_CR1寄存器中的TXEIE为1，则产生中断。对USART DR的写操作，将该位清零。
    79. 	0:数据还没有被转移到移位寄存器
    80. 	1:数据已经被转移到移位寄存器。
    81. 	注意:单缓冲器传输中使用该位。
    82. 	*/
    83. }	
    84.  
    85.  
    86. /**
    87.   * @brief  发送一个数组
    88.   * @param  Array:传递的数组
    89. 	* @param  Length数组的长度
    90.   * @retval 无
    91.   */
    92. void Serial_SendArray(uint8_t *Array, uint16_t Length){
    93. 	 
    94. 	for(uint16_t i=0;i
    95. 	{
    96. 		Serial_SendByte(Array[i]);
    97. 	}
    98.  
    99. }
    100.  
    101.  
    102.  
    103. /**
    104.   * @brief  发送一个字符串
    105.   * @param  需要发送的字符串
    106.   * @retval 无
    107.   */
    108. void Serial_Sendstr(char *str)
    109. {	//发送字符串时自带结束标志位
    110. 	for (uint8_t i=0 ; str[i]!=0;i++){//也可写为str[i]!='\0'
    111. 		Serial_SendByte(str[i]);
    112.  
    113. 	}
    114. }
    115.  
    116.  
    117. /**
    118.   * @brief  取数字的某一位:数字/10^x/%10 ----/10^x就是把这一位的右边去掉，%10就是把左边去掉
    119. 	12345取3 12345/100(10^2)%10=3   x:从左往右数,不包含要取的数字
    120. 	* @param  X:底数
    121. 	* @param  Y:指数
    122.   * @retval 无
    123.   */
    124. uint32_t Serial_Pow(uint32_t X, uint32_t Y) //X^Y
    125. {
    126. 	uint32_t Result = 1;
    127. 	while (Y --)
    128. 	{
    129. 		Result *= X;
    130. 	}
    131. 	return Result;
    132. }
    133.  
    134. /**
    135.   * @brief  输数字,把数字中的每一位取出,然后发送出去
    136.   * @param  传输的数字
    137. 	* @param  传输数字的长度
    138.   * @retval 无
    139.   */
    140. void Serial_SendNumber(uint32_t Number, uint8_t Length)
    141. {
    142. 	uint8_t i;
    143. 	for (i = 0; i < Length; i ++)
    144. 	{
    145. 		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
    146. 	}
    147. }
    148.  
    149.  
    150. //printf函数的底层
    151. int fputc(int ch, FILE *f)
    152. {
    153. 	Serial_SendByte(ch);
    154. 	return ch;
    155. }
    156.  
    157. //spinrf函数的封装
    158. void Serial_Printf(char *format, ...)
    159. {
    160. 	char String[100];
    161. 	va_list arg;
    162. 	va_start(arg, format);
    163. 	vsprintf(String, format, arg);
    164. 	va_end(arg);
    165. 	Serial_Sendstr(String);
    166. }
    167.  
    168.  
    169. /**
    170.   * @brief  知道把中断标志位置位0
    171.   * @retval 无
    172.   */
    173. uint8_t Serial_GetRxFlag(void)
    174. {
    175. 	if (Serial_RxFlag == 1)
    176. 	{
    177. 		Serial_RxFlag = 0;
    178. 		return 1;
    179. 	}
    180. 	return 0;
    181. }
    182.  
    183.  
    184.  
    185. //------------------HEX包----------------------------
    186. /**
    187.   * @brief  发送HEX数据包---STM32发送到其他外设
    188.   * @retval 无
    189.   */
    190. uint16_t Send_HEX()
    191. {
    192. 	Serial_SendByte(0XFF);
    193. 	Serial_SendArray(Serial_TXPacket,4);
    194. 	Serial_SendByte(0XFE);
    195. }
    196.  
    197. /**
    198. * @brief  接收HEX数据包---其他外设发送到STM32上面
    199.   * @retval 无
    200.   */
    201.  
    202. void USART1_IRQHandler(){
    203. 	//每收到一个字节，程序都会进一遍中断 
    204. 	//static---- 函数进入只会初始化一次,在函数退出后，数据仍然有效
    205. 	static uint8_t RxState = 0;//状态机的标志位
    206. 	static uint8_t pRxPacket = 0;//数据的包长
    207. 	//判断RXNE的中断标志位
    208. 	if (USART_GetFlagStatus(USART1,USART_FLAG_RXNE)==SET){
    209. 		
    210. 		uint8_t data=USART_ReceiveData(USART1);//32接收的数据
    211. 		if (RxState==0)
    212. 		{
    213. 			if (data=='@')
    214. 			{
    215. 				RxState=1;
    216. 				pRxPacket=0;
    217. 			}		
    218. 		}
    219. 		else if (RxState==1)
    220. 		{
    221. 			if (data=='\r') //\r 的意思是： 回车。将当前位置移到本行的开头。
    222.  
    223.  
    224. 			{
    225. 				RxState=2;
    226. 			}
    227. 			else
    228. 			{
    229. 			Serial_RXPacket[pRxPacket]=data; //右边的值赋值给等号的左边
    230. 			pRxPacket++;
    231. 			}
    232. 				
    233. 		}
    234. 		else if (RxState==2)
    235. 		{
    236. 			if (data=='\n')//\n 的意思是：回车换行。将当前位置移到下一行的开头。
    237.  
    238. 			{
    239. 				RxState=0;
    240. 				Serial_RXPacket[pRxPacket]='\0';
    241. 				Serial_RxFlag=1;//一个数据包发送完成的标志位
    242. 			}
    243.  
    244. 		}
    245. 		
    246. 		USART_ClearITPendingBit(USART1,USART_FLAG_RXNE);
    247. 	}
    248. }
    249.  
    250.  
    251.  
    252. uint8_t RxData;
    253. uint8_t num;
    254. int main(void)
    255. {
    256.  
    257. 	OLED_Init();
    258. 	serial_init();
    259. 	LED_Init();
    260. 	OLED_ShowString(1,1,"RX_Data:");
    261. 	OLED_ShowString(3,1,"TX_Data:");
    262. 	
    263.  
    264. 	
    265. 	
    266. 	while (1)
    267. 	{
    268. 		
    269. 		//接收数据
    270. 		if (Serial_RxFlag==1)
    271. 			
    272. 		{	OLED_ShowString(4,1,"                ");			
    273. 			OLED_ShowString(4,1,Serial_RXPacket);
    274. 			
    275. 			if (strcmp(Serial_RXPacket, "LED_ON")==0)
    276. 			{
    277. 				LED1_ON();
    278. 				Serial_Sendstr("LED_ON_OK\r\n");//使用32把数据发送到外设中去
    279. 				OLED_ShowString(2, 1, "                ");
    280. 				OLED_ShowString(2, 1, "LED_ON_OK");
    281. 			}
    282. 			else if(strcmp(Serial_RXPacket, "LED_OFF")==0)
    283. 			{
    284. 				LED1_OFF();
    285. 				Serial_Sendstr("LED_Off_OK\r\n");//使用32把数据发送到外设中去
    286. 				OLED_ShowString(2, 1, "                ");
    287. 				OLED_ShowString(2, 1, "LED_Off_OK");
    288. 			}
    289. 			else
    290.  
    291. 			{	
    292. 				Serial_Sendstr("ERROR_COMMAND\r\n");//使用32把数据发送到外设中去
    293. 				OLED_ShowString(2, 1, "                ");
    294. 				OLED_ShowString(2,1,"ERROR_COMMAND");
    295. 			}
    296. 			
    297. 			Serial_RxFlag = 0;
    298. 		}
    299. 		
    300. 	}
    301. }

  • 相关阅读:
    使用机器学习做医学图像分类的开源项目集锦
    Mycat实现分库分表
    sql server判断两个集合字符串是否存在交集
    【错误记录】Navigation 导航组件报错 ( Activity xxActivity@3f does not have a NavController set on 2131xx )
    Sprite Renderer
    Java泛型漫谈
    计算机系统（23）--- 死锁的处理策略
    WPF元素绑定
    关于rsync用不了之后
    图片加水印怎么弄？小白都会的加水印方法
  • 原文地址：https://blog.csdn.net/m0_74739916/article/details/132677838