STM32标准库USART串口

简介: STM32标准库USART串口

前言

最近想重温一下32标准库的内容,所以打算写几篇博客梳理一遍之前学过的知识点,图片和代码都是参考江科大的,江科大32教程非常不错,不管是小白还是大佬想学习32标准库都可以看他b站的课程。

一、串口

1.全双工、半双工及单工通讯

2.通信接口

  • 通信的目的:将一个设备的数据传送到另一个设备,扩展硬件系统
  • 通信协议:制定通信的规则,通信双方按照协议规则进行数据收发

3.串口通信

  • 串口是一种应用十分广泛的通讯接口,串口成本低、容易使用、通信线路简单,可实现两个设备的互相通信
  • 单片机的串口可以使单片机与单片机、单片机与电脑、单片机与各式各样的模块互相通信,极大地扩展了单片机的应用范围,增强了单片机系统的硬件实力

4.硬件电路

  • 简单双向串口通信有两根通信线(发送端TX和接收端RX)
  • TX与RX要交叉连接
  • 当只需单向的数据传输时,可以只接一根通信线
  • 当电平标准不一致时,需要加电平转换芯片


5.电平标准

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

  • TTL电平:+3.3V或+5V表示1,0V
  • RS232电平:-3~-15V表示1,+3~+15V表示0
  • RS485电平:两线压差+2~+6V表示1,-2~-6V表示0(差分信号)

6.串口参数及时序


  1. 波特率:每隔1秒发送一位,那么接收方也必须每隔1秒接收一位。如果接收方过早接收,则可能会重复接收某些位;如果接收方过晚接收,则可能会错过某些位。因此,发送方和接收方必须约定好传输速率,这个速率参数,就是波特率。
  2. 起始位:它是标志一个数据帧的开始,固定为低电平。首先,串口的空闲状态是高电平,也就是没有数据传输的时候,然后需要传输的时候,必须要先发送一个起始位,这个起始位必须是低电平,来打破空闲状态的高电平,产生一个下降沿。这个下降沿,就告诉接收设备,这一帧数据要开始了。如果没有起始位,那当我发送8个1的时候,是不是数据线就一直都是高电平,没有任何波动。
  3. 数据位:这里数据位表示数据帧的有效载荷,1为高电平,0为低电平,低位先行。比如我要发送一个字节,是0x0F,那就首先把0F转换为二进制,就是0000 1111,然后低位先行,所以数据要从低位开始发送,也就是1111 0000,像这样,依次放在发送引脚上。所以说如果你想发0x0F这一个字节数据,那就按照波特率要求,定时翻转引脚电平,产生一个这样的波形就行了。
  4. 数据校验:如果数据出错了,可以选择丢弃或者要求重传,校验可以选择3种方式,无校验、奇校验和偶校验。无校验,就是不需要校验位,波形就是左边这个,起始位、数据位、停止位,总共3个部分。奇校验要求有效数据和校验位中“1”的个数为奇数,比如一个8位长的有效数据为:01101001,此时总共有4个“1”, 为达到奇校验效果,校验位为“1”,最后传输的数据将是8位的有效数据加上1位的校验位总共9位。偶校验与奇校验要求刚好相反,要求帧数据和校验位中“1”的个数为偶数, 比如数据帧:11001010,此时数据帧“1”的个数为4个,所以偶校验位为“0”。0校验是不管有效数据中的内容是什么,校验位总为“0”,1校验是校验位总为“1”。

时序图:

二、USART

1.USART介绍


2.USART框图:


  1. TX: 发送数据输出引脚。
  2. RX: 接收数据输入引脚。
  3. SCLK: 发送器时钟输出引脚。这个引脚仅适用于同步模式。
  4. SW_RX: 数据接收引脚,只用于单线和智能卡模式,属于内部引脚,没有具体外部引脚。
  5. nRTS: 请求以发送(Request To Send),n表示低电平有效。如果使能RTS流控制,当USART接收器准备好接收新数据时就会将nRTS变成低电平; 当接收寄存器已满时,nRTS将被设置为高电平。该引脚只适用于硬件流控制。
  6. nCTS: 清除以发送(Clear To Send),n表示低电平有效。如果使能CTS流控制,发送器在发送下一帧数据之前会检测nCTS引脚, 如果为低电平,表示可以发送数据,如果为高电平则在发送完当前数据帧之后停止发送。该引脚只适用于硬件流控制。
  7. 一个是发送数据寄存器TDR(Transmit DR),另一个是接收数据计算器RDR(Receive DR),这两个寄存器占用同一个地址,就跟51单片机串口的SBUF寄存器一样,在程序上只表现为一个寄存器,就是数据寄存器DR(Data Register),但实际硬件中是分成了两个寄存器,一个用于发送TDR,一个用于接收RDR,TDR是只写的,RDR是只读的,当你进行写操作时,数据就写到了TDR,当你进行读操作时,数据就是从RDR读出来的。
  8. 流控有两个引脚,一个是nRTS,一个是nCTS。nRTS(Request To Send)是请求发送,是输出脚,也就是告诉别人,我当前能不能接收;nCTS (Clear To Send)是清除发送,是输入脚,也就是用于接收别人nRTS的信号的。首先,我们需要找到一个支持流控的串口,并将它的TX连接到我们的RX。同时,我们的RTS需要输出一个接收反馈信号,并将其连接到对方的CTS。当我们可以接收数据时,RTS会置为低电平,请求对方发送。对方的CTS接收到信号后,就可以继续发送数据。如果处理不过来,比如接收数据寄存器未及时读取,导致新数据无法接收,此时RTS会置为高电平,对方的CTS接收到信号后,就会暂停发送,直到接收数据寄存器被读走,RTS重新置为低电平,数据才会继续发送。反过来当我们的TX向对方发送数据时,对方的RTS会连接到我们的CTS,用于判断对方是否可以接收数据。TX和CTS是一对对应的信号,RX和RTS也是一对对应的信号。此外,CTS和RTS之间也需要交叉连接,这就是流控的工作模式。然而,我们一般不使用流控,因此只需要了解一下即可。
  9. 中断申请位,就是状态寄存器这里的各种标志位,状态寄存器这里,有两个标志位比较重要,一个是TXE发送寄存器空,另一个是RXNE接收寄存器非空,这两个是判断发送状态和接收状态的必要标志位。(位于图中接收器控制下方)
  10. 波特率发生器其实就是分频器,APB时钟进行分频,得到发送和接收移位的时钟。看一下,这里时钟输入是fPCLKx(x=1或2),(USART1挂载在APB2,所以就是PCLK2的时钟,一般是72M;其他的USART都挂载在APB1,所以是PCLK1的时钟,一般是36M)之后这个时钟进行一个分频,除一个USARTDIV的分频系数,并且分为了整数部分和小数部分,因为有些波特率,用72M除一个整数的话,可能除不尽,会有误差。所以这里分频系数是支持小数点后4位的,分频就更加精准,之后分频完之后,还要再除个16,得到发送器时钟和接收器时钟,通向控制部分。然后右边这里,如果TE (TX Enable)为1,就是发送器使能了,发送部分的波特率就有效;如果RE(RX Enable)为1,就是接收器使能了,接收部分的波特率就有效。(位于图中虚线框部分)

3.USART基本结构:

4.数据帧

(1)字长设置

这里有4种选择,9位字长,有校验或无校验;8位字长,有校验或无校验。但我们最好选择9位字长 有校验,或8位字长 无校验,这两种,这样每一帧的有效载荷都是1字节。

(2)停止位配置

5.起始位检测

6.数据采样

7.波特率发生器


8.数据模式

(1)HEX数据包


(2)文本数据包

(3)HEX数据包接收

(4)文本数据包接收


三、串口收发数据代码标准库实现

串口打印汉字时,编码改成GB2312就不会出现乱码

如果编译时是因为汉字报错的话,可以在杂项控制栏加上:--no-multibyte-chars

(1)串口发送

代码示例:

Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>
#include <stdarg.h>
 
/**
  * 函    数:串口初始化
  * 参    数:无
  * 返 回 值:无
  */
void Serial_Init(void)
{
  /*开启时钟*/
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);  //开启USART1的时钟
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //开启GPIOA的时钟
  
  /*GPIO初始化*/
  GPIO_InitTypeDef GPIO_InitStructure;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);          //将PA9引脚初始化为复用推挽输出
  
  /*USART初始化*/
  USART_InitTypeDef USART_InitStructure;          //定义结构体变量
  USART_InitStructure.USART_BaudRate = 9600;        //波特率
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //硬件流控制,不需要
  USART_InitStructure.USART_Mode = USART_Mode_Tx;     //模式,选择为发送模式
  USART_InitStructure.USART_Parity = USART_Parity_No;   //奇偶校验,不需要
  USART_InitStructure.USART_StopBits = USART_StopBits_1;  //停止位,选择1位
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;   //字长,选择8位
  USART_Init(USART1, &USART_InitStructure);       //将结构体变量交给USART_Init,配置USART1
  
  /*USART使能*/
  USART_Cmd(USART1, ENABLE);                //使能USART1,串口开始运行
}
 
/**
  * 函    数:串口发送一个字节
  * 参    数:Byte 要发送的一个字节
  * 返 回 值:无
  */
void Serial_SendByte(uint8_t Byte)
{
  USART_SendData(USART1, Byte);   //将字节数据写入数据寄存器,写入后USART自动生成时序波形
  while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET); //等待发送完成
  /*下次写入数据寄存器会自动清除发送完成标志位,故此循环后,无需清除标志位*/
}
 
/**
  * 函    数:串口发送一个数组
  * 参    数:Array 要发送数组的首地址
  * 参    数:Length 要发送数组的长度
  * 返 回 值:无
  */
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
  uint16_t i;
  for (i = 0; i < Length; i ++)   //遍历数组
  {
    Serial_SendByte(Array[i]);    //依次调用Serial_SendByte发送每个字节数据
  }
}
 
/**
  * 函    数:串口发送一个字符串
  * 参    数:String 要发送字符串的首地址
  * 返 回 值:无
  */
void Serial_SendString(char *String)
{
  uint8_t i;
  for (i = 0; String[i] != '\0'; i ++)//遍历字符数组(字符串),遇到字符串结束标志位后停止
  {
    Serial_SendByte(String[i]);   //依次调用Serial_SendByte发送每个字节数据
  }
}
 
/**
  * 函    数:次方函数(内部使用)
  * 返 回 值:返回值等于X的Y次方
  */
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
  uint32_t Result = 1;  //设置结果初值为1
  while (Y --)      //执行Y次
  {
    Result *= X;    //将X累乘到结果
  }
  return Result;
}
 
/**
  * 函    数:串口发送数字
  * 参    数:Number 要发送的数字,范围:0~4294967295
  * 参    数:Length 要发送数字的长度,范围:0~10
  * 返 回 值:无
  */
void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
  uint8_t i;
  for (i = 0; i < Length; i ++)   //根据数字长度遍历数字的每一位
  {
    Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');  //依次调用Serial_SendByte发送每位数字
  }
}
 
/**
  * 函    数:使用printf需要重定向的底层函数
  * 参    数:保持原始格式即可,无需变动
  * 返 回 值:保持原始格式即可,无需变动
  */
int fputc(int ch, FILE *f)
{
  Serial_SendByte(ch);      //将printf的底层重定向到自己的发送字节函数
  return ch;
}
 
/**
  * 函    数:自己封装的prinf函数
  * 参    数:format 格式化字符串
  * 参    数:... 可变的参数列表
  * 返 回 值:无
  */
void Serial_Printf(char *format, ...)
{
  char String[100];       //定义字符数组
  va_list arg;          //定义可变参数列表数据类型的变量arg
  va_start(arg, format);      //从format开始,接收参数列表到arg变量
  vsprintf(String, format, arg);  //使用vsprintf打印格式化字符串和参数列表到字符数组中
  va_end(arg);          //结束变量arg
  Serial_SendString(String);    //串口发送字符数组(字符串)
}


Serial.h

#ifndef __SERIAL_H
#define __SERIAL_H
 
#include <stdio.h>
 
void Serial_Init(void);
void Serial_SendByte(uint8_t Byte);
void Serial_SendArray(uint8_t *Array, uint16_t Length);
void Serial_SendString(char *String);
void Serial_SendNumber(uint32_t Number, uint8_t Length);
void Serial_Printf(char *format, ...);
 
#endif


main.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
 
int main(void)
{
  /*模块初始化*/
  OLED_Init();            //OLED初始化
  
  Serial_Init();            //串口初始化
  
  /*串口基本函数*/
  Serial_SendByte(0x41);        //串口发送一个字节数据0x41
  
  uint8_t MyArray[] = {0x42, 0x43, 0x44, 0x45}; //定义数组
  Serial_SendArray(MyArray, 4);   //串口发送一个数组
  
  Serial_SendString("\r\nNum1=");   //串口发送字符串
  
  Serial_SendNumber(111, 3);      //串口发送数字
  
  /*下述3种方法可实现printf的效果*/
  
  /*方法1:直接重定向printf,但printf函数只有一个,此方法不能在多处使用*/
  printf("\r\nNum2=%d", 222);     //串口发送printf打印的格式化字符串
                    //需要重定向fputc函数,并在工程选项里勾选Use MicroLIB
  
  /*方法2:使用sprintf打印到字符数组,再用串口发送字符数组,此方法打印到字符数组,之后想怎么处理都可以,可在多处使用*/
  char String[100];         //定义字符数组
  sprintf(String, "\r\nNum3=%d", 333);//使用sprintf,把格式化字符串打印到字符数组
  Serial_SendString(String);      //串口发送字符数组(字符串)
  
  /*方法3:将sprintf函数封装起来,实现专用的printf,此方法就是把方法2封装起来,更加简洁实用,可在多处使用*/
  Serial_Printf("\r\nNum4=%d", 444);  //串口打印字符串,使用自己封装的函数实现printf的效果
  Serial_Printf("\r\n");
  
  while (1)
  {
    
  }
}


(2)串口发送+接收

代码示例:

Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>
#include <stdarg.h>
 
uint8_t Serial_RxData;    //定义串口接收的数据变量
uint8_t Serial_RxFlag;    //定义串口接收的标志位变量
 
/**
  * 函    数:串口初始化
  * 参    数:无
  * 返 回 值:无
  */
void Serial_Init(void)
{
  /*开启时钟*/
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);  //开启USART1的时钟
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //开启GPIOA的时钟
  
  /*GPIO初始化*/
  GPIO_InitTypeDef GPIO_InitStructure;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);          //将PA9引脚初始化为复用推挽输出
  
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);          //将PA10引脚初始化为上拉输入
  
  /*USART初始化*/
  USART_InitTypeDef USART_InitStructure;          //定义结构体变量
  USART_InitStructure.USART_BaudRate = 9600;        //波特率
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //硬件流控制,不需要
  USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; //模式,发送模式和接收模式均选择
  USART_InitStructure.USART_Parity = USART_Parity_No;   //奇偶校验,不需要
  USART_InitStructure.USART_StopBits = USART_StopBits_1;  //停止位,选择1位
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;   //字长,选择8位
  USART_Init(USART1, &USART_InitStructure);       //将结构体变量交给USART_Init,配置USART1
  
  /*中断输出配置*/
  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);      //开启串口接收数据的中断
  
  /*NVIC中断分组*/
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);     //配置NVIC为分组2
  
  /*NVIC配置*/
  NVIC_InitTypeDef NVIC_InitStructure;          //定义结构体变量
  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;   //选择配置NVIC的USART1线
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;     //指定NVIC线路使能
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;   //指定NVIC线路的抢占优先级为1
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;    //指定NVIC线路的响应优先级为1
  NVIC_Init(&NVIC_InitStructure);             //将结构体变量交给NVIC_Init,配置NVIC外设
  
  /*USART使能*/
  USART_Cmd(USART1, ENABLE);                //使能USART1,串口开始运行
}
 
/**
  * 函    数:串口发送一个字节
  * 参    数:Byte 要发送的一个字节
  * 返 回 值:无
  */
void Serial_SendByte(uint8_t Byte)
{
  USART_SendData(USART1, Byte);   //将字节数据写入数据寄存器,写入后USART自动生成时序波形
  while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET); //等待发送完成
  /*下次写入数据寄存器会自动清除发送完成标志位,故此循环后,无需清除标志位*/
}
 
/**
  * 函    数:串口发送一个数组
  * 参    数:Array 要发送数组的首地址
  * 参    数:Length 要发送数组的长度
  * 返 回 值:无
  */
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
  uint16_t i;
  for (i = 0; i < Length; i ++)   //遍历数组
  {
    Serial_SendByte(Array[i]);    //依次调用Serial_SendByte发送每个字节数据
  }
}
 
/**
  * 函    数:串口发送一个字符串
  * 参    数:String 要发送字符串的首地址
  * 返 回 值:无
  */
void Serial_SendString(char *String)
{
  uint8_t i;
  for (i = 0; String[i] != '\0'; i ++)//遍历字符数组(字符串),遇到字符串结束标志位后停止
  {
    Serial_SendByte(String[i]);   //依次调用Serial_SendByte发送每个字节数据
  }
}
 
/**
  * 函    数:次方函数(内部使用)
  * 返 回 值:返回值等于X的Y次方
  */
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
  uint32_t Result = 1;  //设置结果初值为1
  while (Y --)      //执行Y次
  {
    Result *= X;    //将X累乘到结果
  }
  return Result;
}
 
/**
  * 函    数:串口发送数字
  * 参    数:Number 要发送的数字,范围:0~4294967295
  * 参    数:Length 要发送数字的长度,范围:0~10
  * 返 回 值:无
  */
void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
  uint8_t i;
  for (i = 0; i < Length; i ++)   //根据数字长度遍历数字的每一位
  {
    Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');  //依次调用Serial_SendByte发送每位数字
  }
}
 
/**
  * 函    数:使用printf需要重定向的底层函数
  * 参    数:保持原始格式即可,无需变动
  * 返 回 值:保持原始格式即可,无需变动
  */
int fputc(int ch, FILE *f)
{
  Serial_SendByte(ch);      //将printf的底层重定向到自己的发送字节函数
  return ch;
}
 
/**
  * 函    数:自己封装的prinf函数
  * 参    数:format 格式化字符串
  * 参    数:... 可变的参数列表
  * 返 回 值:无
  */
void Serial_Printf(char *format, ...)
{
  char String[100];       //定义字符数组
  va_list arg;          //定义可变参数列表数据类型的变量arg
  va_start(arg, format);      //从format开始,接收参数列表到arg变量
  vsprintf(String, format, arg);  //使用vsprintf打印格式化字符串和参数列表到字符数组中
  va_end(arg);          //结束变量arg
  Serial_SendString(String);    //串口发送字符数组(字符串)
}
 
/**
  * 函    数:获取串口接收标志位
  * 参    数:无
  * 返 回 值:串口接收标志位,范围:0~1,接收到数据后,标志位置1,读取后标志位自动清零
  */
uint8_t Serial_GetRxFlag(void)
{
  if (Serial_RxFlag == 1)     //如果标志位为1
  {
    Serial_RxFlag = 0;
    return 1;         //则返回1,并自动清零标志位
  }
  return 0;           //如果标志位为0,则返回0
}
 
/**
  * 函    数:获取串口接收的数据
  * 参    数:无
  * 返 回 值:接收的数据,范围:0~255
  */
uint8_t Serial_GetRxData(void)
{
  return Serial_RxData;     //返回接收的数据变量
}
 
/**
  * 函    数:USART1中断函数
  * 参    数:无
  * 返 回 值:无
  * 注意事项:此函数为中断函数,无需调用,中断触发后自动执行
  *           函数名为预留的指定名称,可以从启动文件复制
  *           请确保函数名正确,不能有任何差异,否则中断函数将不能进入
  */
void USART1_IRQHandler(void)
{
  if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)    //判断是否是USART1的接收事件触发的中断
  {
    Serial_RxData = USART_ReceiveData(USART1);        //读取数据寄存器,存放在接收的数据变量
    Serial_RxFlag = 1;                    //置接收标志位变量为1
    USART_ClearITPendingBit(USART1, USART_IT_RXNE);     //清除USART1的RXNE标志位
                                //读取数据寄存器会自动清除此标志位
                                //如果已经读取了数据寄存器,也可以不执行此代码
  }
}


Serial.h

#ifndef __SERIAL_H
#define __SERIAL_H
 
#include <stdio.h>
 
void Serial_Init(void);
void Serial_SendByte(uint8_t Byte);
void Serial_SendArray(uint8_t *Array, uint16_t Length);
void Serial_SendString(char *String);
void Serial_SendNumber(uint32_t Number, uint8_t Length);
void Serial_Printf(char *format, ...);
 
uint8_t Serial_GetRxFlag(void);
uint8_t Serial_GetRxData(void);
 
#endif


main.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
 
uint8_t RxData;     //定义用于接收串口数据的变量
 
int main(void)
{
  /*模块初始化*/
  OLED_Init();    //OLED初始化
  
  /*显示静态字符串*/
  OLED_ShowString(1, 1, "RxData:");
  
  /*串口初始化*/
  Serial_Init();    //串口初始化
  
  while (1)
  {
    if (Serial_GetRxFlag() == 1)      //检查串口接收数据的标志位
    {
      RxData = Serial_GetRxData();    //获取串口接收的数据
      Serial_SendByte(RxData);      //串口将收到的数据回传回去,用于测试
      OLED_ShowHexNum(1, 8, RxData, 2); //显示串口接收的数据
    }
  }
}


(3)串口收发HEX数据包

代码示例:

Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>
#include <stdarg.h>
 
uint8_t Serial_TxPacket[4];       //定义发送数据包数组,数据包格式:FF 01 02 03 04 FE
uint8_t Serial_RxPacket[4];       //定义接收数据包数组
uint8_t Serial_RxFlag;          //定义接收数据包标志位
 
/**
  * 函    数:串口初始化
  * 参    数:无
  * 返 回 值:无
  */
void Serial_Init(void)
{
  /*开启时钟*/
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);  //开启USART1的时钟
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //开启GPIOA的时钟
  
  /*GPIO初始化*/
  GPIO_InitTypeDef GPIO_InitStructure;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);          //将PA9引脚初始化为复用推挽输出
  
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);          //将PA10引脚初始化为上拉输入
  
  /*USART初始化*/
  USART_InitTypeDef USART_InitStructure;          //定义结构体变量
  USART_InitStructure.USART_BaudRate = 9600;        //波特率
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //硬件流控制,不需要
  USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; //模式,发送模式和接收模式均选择
  USART_InitStructure.USART_Parity = USART_Parity_No;   //奇偶校验,不需要
  USART_InitStructure.USART_StopBits = USART_StopBits_1;  //停止位,选择1位
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;   //字长,选择8位
  USART_Init(USART1, &USART_InitStructure);       //将结构体变量交给USART_Init,配置USART1
  
  /*中断输出配置*/
  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);      //开启串口接收数据的中断
  
  /*NVIC中断分组*/
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);     //配置NVIC为分组2
  
  /*NVIC配置*/
  NVIC_InitTypeDef NVIC_InitStructure;          //定义结构体变量
  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;   //选择配置NVIC的USART1线
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;     //指定NVIC线路使能
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;   //指定NVIC线路的抢占优先级为1
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;    //指定NVIC线路的响应优先级为1
  NVIC_Init(&NVIC_InitStructure);             //将结构体变量交给NVIC_Init,配置NVIC外设
  
  /*USART使能*/
  USART_Cmd(USART1, ENABLE);                //使能USART1,串口开始运行
}
 
/**
  * 函    数:串口发送一个字节
  * 参    数:Byte 要发送的一个字节
  * 返 回 值:无
  */
void Serial_SendByte(uint8_t Byte)
{
  USART_SendData(USART1, Byte);   //将字节数据写入数据寄存器,写入后USART自动生成时序波形
  while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET); //等待发送完成
  /*下次写入数据寄存器会自动清除发送完成标志位,故此循环后,无需清除标志位*/
}
 
/**
  * 函    数:串口发送一个数组
  * 参    数:Array 要发送数组的首地址
  * 参    数:Length 要发送数组的长度
  * 返 回 值:无
  */
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
  uint16_t i;
  for (i = 0; i < Length; i ++)   //遍历数组
  {
    Serial_SendByte(Array[i]);    //依次调用Serial_SendByte发送每个字节数据
  }
}
 
/**
  * 函    数:串口发送一个字符串
  * 参    数:String 要发送字符串的首地址
  * 返 回 值:无
  */
void Serial_SendString(char *String)
{
  uint8_t i;
  for (i = 0; String[i] != '\0'; i ++)//遍历字符数组(字符串),遇到字符串结束标志位后停止
  {
    Serial_SendByte(String[i]);   //依次调用Serial_SendByte发送每个字节数据
  }
}
 
/**
  * 函    数:次方函数(内部使用)
  * 返 回 值:返回值等于X的Y次方
  */
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
  uint32_t Result = 1;  //设置结果初值为1
  while (Y --)      //执行Y次
  {
    Result *= X;    //将X累乘到结果
  }
  return Result;
}
 
/**
  * 函    数:串口发送数字
  * 参    数:Number 要发送的数字,范围:0~4294967295
  * 参    数:Length 要发送数字的长度,范围:0~10
  * 返 回 值:无
  */
void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
  uint8_t i;
  for (i = 0; i < Length; i ++)   //根据数字长度遍历数字的每一位
  {
    Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');  //依次调用Serial_SendByte发送每位数字
  }
}
 
/**
  * 函    数:使用printf需要重定向的底层函数
  * 参    数:保持原始格式即可,无需变动
  * 返 回 值:保持原始格式即可,无需变动
  */
int fputc(int ch, FILE *f)
{
  Serial_SendByte(ch);      //将printf的底层重定向到自己的发送字节函数
  return ch;
}
 
/**
  * 函    数:自己封装的prinf函数
  * 参    数:format 格式化字符串
  * 参    数:... 可变的参数列表
  * 返 回 值:无
  */
void Serial_Printf(char *format, ...)
{
  char String[100];       //定义字符数组
  va_list arg;          //定义可变参数列表数据类型的变量arg
  va_start(arg, format);      //从format开始,接收参数列表到arg变量
  vsprintf(String, format, arg);  //使用vsprintf打印格式化字符串和参数列表到字符数组中
  va_end(arg);          //结束变量arg
  Serial_SendString(String);    //串口发送字符数组(字符串)
}
 
/**
  * 函    数:串口发送数据包
  * 参    数:无
  * 返 回 值:无
  * 说    明:调用此函数后,Serial_TxPacket数组的内容将加上包头(FF)包尾(FE)后,作为数据包发送出去
  */
void Serial_SendPacket(void)
{
  Serial_SendByte(0xFF);
  Serial_SendArray(Serial_TxPacket, 4);
  Serial_SendByte(0xFE);
}
 
/**
  * 函    数:获取串口接收数据包标志位
  * 参    数:无
  * 返 回 值:串口接收数据包标志位,范围:0~1,接收到数据包后,标志位置1,读取后标志位自动清零
  */
uint8_t Serial_GetRxFlag(void)
{
  if (Serial_RxFlag == 1)     //如果标志位为1
  {
    Serial_RxFlag = 0;
    return 1;         //则返回1,并自动清零标志位
  }
  return 0;           //如果标志位为0,则返回0
}
 
/**
  * 函    数:USART1中断函数
  * 参    数:无
  * 返 回 值:无
  * 注意事项:此函数为中断函数,无需调用,中断触发后自动执行
  *           函数名为预留的指定名称,可以从启动文件复制
  *           请确保函数名正确,不能有任何差异,否则中断函数将不能进入
  */
void USART1_IRQHandler(void)
{
  static uint8_t RxState = 0;   //定义表示当前状态机状态的静态变量
  static uint8_t pRxPacket = 0; //定义表示当前接收数据位置的静态变量
  if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)    //判断是否是USART1的接收事件触发的中断
  {
    uint8_t RxData = USART_ReceiveData(USART1);       //读取数据寄存器,存放在接收的数据变量
    
    /*使用状态机的思路,依次处理数据包的不同部分*/
    
    /*当前状态为0,接收数据包包头*/
    if (RxState == 0)
    {
      if (RxData == 0xFF)     //如果数据确实是包头
      {
        RxState = 1;      //置下一个状态
        pRxPacket = 0;      //数据包的位置归零
      }
    }
    /*当前状态为1,接收数据包数据*/
    else if (RxState == 1)
    {
      Serial_RxPacket[pRxPacket] = RxData;  //将数据存入数据包数组的指定位置
      pRxPacket ++;       //数据包的位置自增
      if (pRxPacket >= 4)     //如果收够4个数据
      {
        RxState = 2;      //置下一个状态
      }
    }
    /*当前状态为2,接收数据包包尾*/
    else if (RxState == 2)
    {
      if (RxData == 0xFE)     //如果数据确实是包尾部
      {
        RxState = 0;      //状态归0
        Serial_RxFlag = 1;    //接收数据包标志位置1,成功接收一个数据包
      }
    }
    
    USART_ClearITPendingBit(USART1, USART_IT_RXNE);   //清除标志位
  }
}


Serial.h

#ifndef __SERIAL_H
#define __SERIAL_H
 
#include <stdio.h>
 
extern uint8_t Serial_TxPacket[];
extern uint8_t Serial_RxPacket[];
 
void Serial_Init(void);
void Serial_SendByte(uint8_t Byte);
void Serial_SendArray(uint8_t *Array, uint16_t Length);
void Serial_SendString(char *String);
void Serial_SendNumber(uint32_t Number, uint8_t Length);
void Serial_Printf(char *format, ...);
 
void Serial_SendPacket(void);
uint8_t Serial_GetRxFlag(void);
 
#endif


main.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "Key.h"
 
uint8_t KeyNum;     //定义用于接收按键键码的变量
 
int main(void)
{
  /*模块初始化*/
  OLED_Init();    //OLED初始化
  Key_Init();     //按键初始化
  Serial_Init();    //串口初始化
  
  /*显示静态字符串*/
  OLED_ShowString(1, 1, "TxPacket");
  OLED_ShowString(3, 1, "RxPacket");
  
  /*设置发送数据包数组的初始值,用于测试*/
  Serial_TxPacket[0] = 0x01;
  Serial_TxPacket[1] = 0x02;
  Serial_TxPacket[2] = 0x03;
  Serial_TxPacket[3] = 0x04;
  
  while (1)
  {
    KeyNum = Key_GetNum();      //获取按键键码
    if (KeyNum == 1)        //按键1按下
    {
      Serial_TxPacket[0] ++;    //测试数据自增
      Serial_TxPacket[1] ++;
      Serial_TxPacket[2] ++;
      Serial_TxPacket[3] ++;
      
      Serial_SendPacket();    //串口发送数据包Serial_TxPacket
      
      OLED_ShowHexNum(2, 1, Serial_TxPacket[0], 2); //显示发送的数据包
      OLED_ShowHexNum(2, 4, Serial_TxPacket[1], 2);
      OLED_ShowHexNum(2, 7, Serial_TxPacket[2], 2);
      OLED_ShowHexNum(2, 10, Serial_TxPacket[3], 2);
    }
    
    if (Serial_GetRxFlag() == 1)  //如果接收到数据包
    {
      OLED_ShowHexNum(4, 1, Serial_RxPacket[0], 2); //显示接收的数据包
      OLED_ShowHexNum(4, 4, Serial_RxPacket[1], 2);
      OLED_ShowHexNum(4, 7, Serial_RxPacket[2], 2);
      OLED_ShowHexNum(4, 10, Serial_RxPacket[3], 2);
    }
  }
}

(4)串口收发文本数据包

代码示例:

Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>
#include <stdarg.h>
 
char Serial_RxPacket[100];        //定义接收数据包数组,数据包格式"@MSG\r\n"
uint8_t Serial_RxFlag;          //定义接收数据包标志位
 
/**
  * 函    数:串口初始化
  * 参    数:无
  * 返 回 值:无
  */
void Serial_Init(void)
{
  /*开启时钟*/
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);  //开启USART1的时钟
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //开启GPIOA的时钟
  
  /*GPIO初始化*/
  GPIO_InitTypeDef GPIO_InitStructure;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);          //将PA9引脚初始化为复用推挽输出
  
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);          //将PA10引脚初始化为上拉输入
  
  /*USART初始化*/
  USART_InitTypeDef USART_InitStructure;          //定义结构体变量
  USART_InitStructure.USART_BaudRate = 9600;        //波特率
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //硬件流控制,不需要
  USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; //模式,发送模式和接收模式均选择
  USART_InitStructure.USART_Parity = USART_Parity_No;   //奇偶校验,不需要
  USART_InitStructure.USART_StopBits = USART_StopBits_1;  //停止位,选择1位
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;   //字长,选择8位
  USART_Init(USART1, &USART_InitStructure);       //将结构体变量交给USART_Init,配置USART1
  
  /*中断输出配置*/
  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);      //开启串口接收数据的中断
  
  /*NVIC中断分组*/
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);     //配置NVIC为分组2
  
  /*NVIC配置*/
  NVIC_InitTypeDef NVIC_InitStructure;          //定义结构体变量
  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;   //选择配置NVIC的USART1线
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;     //指定NVIC线路使能
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;   //指定NVIC线路的抢占优先级为1
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;    //指定NVIC线路的响应优先级为1
  NVIC_Init(&NVIC_InitStructure);             //将结构体变量交给NVIC_Init,配置NVIC外设
  
  /*USART使能*/
  USART_Cmd(USART1, ENABLE);                //使能USART1,串口开始运行
}
 
/**
  * 函    数:串口发送一个字节
  * 参    数:Byte 要发送的一个字节
  * 返 回 值:无
  */
void Serial_SendByte(uint8_t Byte)
{
  USART_SendData(USART1, Byte);   //将字节数据写入数据寄存器,写入后USART自动生成时序波形
  while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET); //等待发送完成
  /*下次写入数据寄存器会自动清除发送完成标志位,故此循环后,无需清除标志位*/
}
 
/**
  * 函    数:串口发送一个数组
  * 参    数:Array 要发送数组的首地址
  * 参    数:Length 要发送数组的长度
  * 返 回 值:无
  */
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
  uint16_t i;
  for (i = 0; i < Length; i ++)   //遍历数组
  {
    Serial_SendByte(Array[i]);    //依次调用Serial_SendByte发送每个字节数据
  }
}
 
/**
  * 函    数:串口发送一个字符串
  * 参    数:String 要发送字符串的首地址
  * 返 回 值:无
  */
void Serial_SendString(char *String)
{
  uint8_t i;
  for (i = 0; String[i] != '\0'; i ++)//遍历字符数组(字符串),遇到字符串结束标志位后停止
  {
    Serial_SendByte(String[i]);   //依次调用Serial_SendByte发送每个字节数据
  }
}
 
/**
  * 函    数:次方函数(内部使用)
  * 返 回 值:返回值等于X的Y次方
  */
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
  uint32_t Result = 1;  //设置结果初值为1
  while (Y --)      //执行Y次
  {
    Result *= X;    //将X累乘到结果
  }
  return Result;
}
 
/**
  * 函    数:串口发送数字
  * 参    数:Number 要发送的数字,范围:0~4294967295
  * 参    数:Length 要发送数字的长度,范围:0~10
  * 返 回 值:无
  */
void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
  uint8_t i;
  for (i = 0; i < Length; i ++)   //根据数字长度遍历数字的每一位
  {
    Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');  //依次调用Serial_SendByte发送每位数字
  }
}
 
/**
  * 函    数:使用printf需要重定向的底层函数
  * 参    数:保持原始格式即可,无需变动
  * 返 回 值:保持原始格式即可,无需变动
  */
int fputc(int ch, FILE *f)
{
  Serial_SendByte(ch);      //将printf的底层重定向到自己的发送字节函数
  return ch;
}
 
/**
  * 函    数:自己封装的prinf函数
  * 参    数:format 格式化字符串
  * 参    数:... 可变的参数列表
  * 返 回 值:无
  */
void Serial_Printf(char *format, ...)
{
  char String[100];       //定义字符数组
  va_list arg;          //定义可变参数列表数据类型的变量arg
  va_start(arg, format);      //从format开始,接收参数列表到arg变量
  vsprintf(String, format, arg);  //使用vsprintf打印格式化字符串和参数列表到字符数组中
  va_end(arg);          //结束变量arg
  Serial_SendString(String);    //串口发送字符数组(字符串)
}
 
/**
  * 函    数:USART1中断函数
  * 参    数:无
  * 返 回 值:无
  * 注意事项:此函数为中断函数,无需调用,中断触发后自动执行
  *           函数名为预留的指定名称,可以从启动文件复制
  *           请确保函数名正确,不能有任何差异,否则中断函数将不能进入
  */
void USART1_IRQHandler(void)
{
  static uint8_t RxState = 0;   //定义表示当前状态机状态的静态变量
  static uint8_t pRxPacket = 0; //定义表示当前接收数据位置的静态变量
  if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)  //判断是否是USART1的接收事件触发的中断
  {
    uint8_t RxData = USART_ReceiveData(USART1);     //读取数据寄存器,存放在接收的数据变量
    
    /*使用状态机的思路,依次处理数据包的不同部分*/
    
    /*当前状态为0,接收数据包包头*/
    if (RxState == 0)
    {
      if (RxData == '@' && Serial_RxFlag == 0)    //如果数据确实是包头,并且上一个数据包已处理完毕
      {
        RxState = 1;      //置下一个状态
        pRxPacket = 0;      //数据包的位置归零
      }
    }
    /*当前状态为1,接收数据包数据,同时判断是否接收到了第一个包尾*/
    else if (RxState == 1)
    {
      if (RxData == '\r')     //如果收到第一个包尾
      {
        RxState = 2;      //置下一个状态
      }
      else            //接收到了正常的数据
      {
        Serial_RxPacket[pRxPacket] = RxData;    //将数据存入数据包数组的指定位置
        pRxPacket ++;     //数据包的位置自增
      }
    }
    /*当前状态为2,接收数据包第二个包尾*/
    else if (RxState == 2)
    {
      if (RxData == '\n')     //如果收到第二个包尾
      {
        RxState = 0;      //状态归0
        Serial_RxPacket[pRxPacket] = '\0';      //将收到的字符数据包添加一个字符串结束标志
        Serial_RxFlag = 1;    //接收数据包标志位置1,成功接收一个数据包
      }
    }
    
    USART_ClearITPendingBit(USART1, USART_IT_RXNE);   //清除标志位
  }
}


Serial.h

#ifndef __SERIAL_H
#define __SERIAL_H
 
#include <stdio.h>
 
extern char Serial_RxPacket[];
extern uint8_t Serial_RxFlag;
 
void Serial_Init(void);
void Serial_SendByte(uint8_t Byte);
void Serial_SendArray(uint8_t *Array, uint16_t Length);
void Serial_SendString(char *String);
void Serial_SendNumber(uint32_t Number, uint8_t Length);
void Serial_Printf(char *format, ...);
 
#endif

main.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "LED.h"
#include "string.h"
 
int main(void)
{
  /*模块初始化*/
  OLED_Init();    //OLED初始化
  LED_Init();     //LED初始化
  Serial_Init();    //串口初始化
  
  /*显示静态字符串*/
  OLED_ShowString(1, 1, "TxPacket");
  OLED_ShowString(3, 1, "RxPacket");
  
  while (1)
  {
    if (Serial_RxFlag == 1)   //如果接收到数据包
    {
      OLED_ShowString(4, 1, "                ");
      OLED_ShowString(4, 1, Serial_RxPacket);       //OLED清除指定位置,并显示接收到的数据包
      
      /*将收到的数据包与预设的指令对比,以此决定将要执行的操作*/
      if (strcmp(Serial_RxPacket, "LED_ON") == 0)     //如果收到LED_ON指令
      {
        LED1_ON();                    //点亮LED
        Serial_SendString("LED_ON_OK\r\n");       //串口回传一个字符串LED_ON_OK
        OLED_ShowString(2, 1, "                ");
        OLED_ShowString(2, 1, "LED_ON_OK");       //OLED清除指定位置,并显示LED_ON_OK
      }
      else if (strcmp(Serial_RxPacket, "LED_OFF") == 0) //如果收到LED_OFF指令
      {
        LED1_OFF();                   //熄灭LED
        Serial_SendString("LED_OFF_OK\r\n");      //串口回传一个字符串LED_OFF_OK
        OLED_ShowString(2, 1, "                ");
        OLED_ShowString(2, 1, "LED_OFF_OK");      //OLED清除指定位置,并显示LED_OFF_OK
      }
      else            //上述所有条件均不满足,即收到了未知指令
      {
        Serial_SendString("ERROR_COMMAND\r\n");     //串口回传一个字符串ERROR_COMMAND
        OLED_ShowString(2, 1, "                ");
        OLED_ShowString(2, 1, "ERROR_COMMAND");     //OLED清除指定位置,并显示ERROR_COMMAND
      }
      
      Serial_RxFlag = 0;      //处理完成后,需要将接收数据包标志位清零,否则将无法接收后续数据包
    }
  }
}
相关文章
|
1天前
|
存储 数据采集 数据安全/隐私保护
使用STM32F103读取TF卡并模拟U盘:使用标准库实现
通过以上步骤,你可以实现用STM32F103将TF卡内容变成U盘进行读取。这种功能在数据采集、便携式存储设备等应用中非常有用。如果你有更多的需求,可以进一步扩展此项目,例如添加文件管理功能、加密存储等。希望这篇博客能帮到你,如果有任何问题,欢迎在评论区留言讨论!
8 1
|
1天前
|
IDE 开发工具
使用STM32F103标准库实现自定义键盘
通过本文,我们学习了如何使用STM32F103标准库实现一个简单的自定义键盘。我们首先初始化了GPIO引脚,然后实现了一个扫描函数来检测按键状态。这个项目不仅能够帮助我们理解STM32的GPIO配置和按键扫描原理,还可以作为进一步学习中断处理和低功耗设计的基础。希望本文对你有所帮助,祝你在嵌入式开发的道路上不断进步!
11 4
|
1天前
使用STM32F103标准库实现定时器控制LED点亮和关闭
通过这篇博客,我们学习了如何使用STM32F103标准库,通过定时器来控制LED的点亮和关闭。我们配置了定时器中断,并在中断处理函数中实现了LED状态的切换。这是一个基础且实用的例子,适合初学者了解STM32定时器和中断的使用。 希望这篇博客对你有所帮助。如果有任何问题或建议,欢迎在评论区留言。
7 2
|
2天前
|
传感器
【经典案例】STM32F407使用HAL库配置I2C详解
STM32F407是一个强大的微控制器,广泛应用于嵌入式系统中。在许多应用中,我们需要使用I2C总线来与传感器、EEPROM、显示屏等外设进行通信。本文将详细介绍如何使用STM32 HAL库来配置和使用I2C接口。
10 2
|
2天前
|
开发者
【经典案例】使用HAL库配置STM32F407的SPI外设
在嵌入式系统开发中,STM32F407是一款广泛应用的微控制器,而SPI(Serial Peripheral Interface)是一种常用的通信接口。本文将详细介绍如何使用STM32的硬件抽象层(HAL)库配置STM32F407的SPI外设,并提供完整的代码示例。
16 1
|
27天前
|
缓存 网络协议 算法
[蓝桥杯嵌入式]hal库 stm32 PWM的使用(随时修改占空比,随时修改频率)
[蓝桥杯嵌入式]hal库 stm32 PWM的使用(随时修改占空比,随时修改频率)
|
29天前
|
传感器 存储 缓存
|
29天前
|
存储 缓存 芯片
|
29天前
【STM32】基于HAL库的360度编码器、摇杆代码编写
【STM32】基于HAL库的360度编码器、摇杆代码编写