/\*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 要发送的数字，范围：04294967295
* 参 数：Length 要发送数字的长度，范围：010
* 返 回 值：无
*/
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标志位 //读取数据寄存器会自动清除此标志位 //如果已经读取了数据寄存器，也可以不执行此代码 } }
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); //显示串口接收的数据
}
}
}
### USART串口数据包
先来看两张图，是关于我规定的**数据包格式**，一种是HEX数据包，一种是文本数据包，之后两个图，展示的就是接收数据包的思路。
接着我们来研究几个问题：
* 第一个问题：包头包尾和数据载荷重复的问题，这里定义FF为包头，FE为包尾，如果我传输的数据本身就是FF和FE怎么办呢？那这个问题确实存在，如果数据和包头包尾重复，可能会引起误判。对应这个问题我们有如下几种解决方法：**第一种，限制载荷数据的范围**。如果可以的话，我们可以在发送的时候，对数据进行限幅，比如XYZ，3个数据，变化范围都可以是0~100 那就好办了，我们可以在载荷中只发送0-100的数据，这样就不会和包头包尾重复了；**第二种，如果无法避免载荷数据和包头包尾重复，那我们就尽量使用固定长度的数据包**。这样由于载荷数据是固定的，只要我们通过包头包尾对齐了数据，我们就可以严格知道，哪个数据应该是包头包尾，哪个数据应该是载荷数据。在接收载荷数据的时候，我们并不会判断它是否是包头包尾，而在接收包头包尾的时候，我们会判断它是不是确实是包头包尾，用于数据对齐。这样，在经过几个数据包的对齐之后，剩下的数据包应该就不会出现问题了；**第三种，增加包头包尾的数量，并且尽量让它呈现出载荷数据出现不了的状态**。比如我们使用FF、FE作为包头，FD、FC作为包尾，这样也可以避免载荷数据和包头包尾重复的情况发生
* 第二个问题：这个包头包尾并不是全部都需要的，比如我们可以只要一个包头，把包尾删掉，这样数据包的格式就是，一个包头FF，加4个数据，这样也是可以的。当检测到FF，开始接收，收够4个字节后，置标志位，一个数据包接收完成，这样也可以。不过这样的话，载荷和包头重复的问题会更严重一些，比如最严重的情况下，我载荷全是FF，包头也是FF，那你肯定不知道哪个是包头了，而加上了FE作为包尾，无论数据怎么变化，都是可以分辨出包头包尾的。
* 第三个问题：固定包长和可变包长的选择问题，对应HEX数据包来说,如果你的载荷会出现和包头包尾重复的情况,那就最好选择固定包长,这样可以避免接收错误,如果你又会重复，又选择可变包长那数据很容易就乱套了；如果载荷不会和包头包尾重复，那可以选择可变包长，数据长度，像这样，4位、3位、等等，1位、10位，来回任意变，肯定都没问题。因为包头包尾是唯一的，只要出现包头，就开始数据包，只要出现包尾，就结束数据包，这样就非常灵活了，这就是固定包长和可变包长选择的问题。
* 最后一个问题：各种数据转换为字节流的问题。这里数据包都是一个字节一个字节组成的，如果你想发送16位的整型数据、32位的整型数据，float、double，甚至是结构体，其实都没问题，因为它们内部其实都是由一个字节一个字节组成的，只需要用一个uint8\_t的指针指向它，把它们当做一个字节数组发送就行了。
好，有关HEX数据包定义的内容，就讲这么多，接下来看一下文本数据包。
文本数据包和HEX数据包分别对应了文本模式和HEX模式。**在HEX数据包中，数据以原始字节形式呈现。而在文本数据包中，每个字节经过了一层编码和译码，最终以文本格式呈现**。实际上，每个文本字符背后都有一个字节的HEX数据。
综上所述，我们需要根据实际场景来选择和设计数据包格式。在需要直接传输和简单解析原始数据的情况下，HEX数据包是更好的选择。而在需要输入指令进行人机交互的场合，文本数据包则更为适用。
好，数据包格式的定义讲完了，接下来我们就来学一下**数据包的收发流程**。
首先，发送数据包的过程相对简单。在发送HEX数据包时，可以通过定义一个数组，填充数据，然后使用之前我们写过的SendArray函数发送即可。在发送文本数据包时，可以通过写一个字符串，然后调用SendString函数发送。因此，发送数据包的过程是可控的，我们可以根据需要发送任何类型的数据包。相比之下，接收数据包的过程较为复杂。
那接下来，接收一个数据包，这就比较复杂了，我们来学习一下，我这里演示了固定包长HEX数据包的接收方法，和可变包长文本数据包的接收方法，其他的数据包也都可以套用这个形式，等会儿我们写程序就会根据这里面的流程来。
我们先看一下如**何来接收这个固定包长的HEX数据包**。要接收固定包长的HEX数据包，我们需要设计一个状态机来处理。根据之前的代码，我们知道每当收到一个字节，程序会进入中断。在中断函数里，我们可以获取这个字节，但获取后需要退出中断。因此，每个收到的数据都是独立的过程，而数据包则具有前后关联性，包括包头、数据和包尾。为了处理这三种状态，我们需要设计一个能够记住不同状态的机制，并在不同状态下执行不同的操作，同时进行状态合理转移。这种程序设计思维就是“状态机”。
这就是使用状态机接收数据包的思路。这个状态机其实是一种很广泛的编程思路，在很多地方都可以用到，使用的基本步骤是，先根据项目要求定义状态，画几个圈，然后考虑好各个状态在什么情况下会进行转移，如何转移，画好线和转移条件，最后根据这个图来进行编程，这样思维就会非常清晰了。
那接下来继续，我们来看一下这个**可变包长、文本数据包的接收流程**。
好，到这里，我们这个数据包的，定义、分类、优缺点和注意事项，就讲完了，接下来，我们就来写程序，验证一下刚才所学的内容吧。
#### 代码实战：串口收发HEX数据包&&串口收发文本数据包
9-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 要发送的数字，范围：04294967295
* 参 数：Length 要发送数字的长度，范围：010
* 返 回 值：无
*/
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); //清除标志位
}
}
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);
}
}
}
9-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 要发送的数字，范围：04294967295
* 参 数：Length 要发送数字的长度，范围：010
* 返 回 值：无
*/
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); //清除标志位
}
}
mian.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; //处理完成后，需要将接收数据包标志位清零，否则将无法接收后续数据包
}
}
}
## I2C通信协议（正在改动）
注：[通信协议的设计背景 3:00~10:13](https://gitee.com/vip204888)
I2C 通讯协议(Inter－Integrated Circuit)是由Phiilps公司开发的，由于它引脚少，硬件实现简单，可扩展性强， 不需要USART、CAN等通讯协议的外部收发设备，现在被广泛地使用在系统内多个集成电路(IC)间的通讯。
I2C总线是一种用于芯片之间进行通信的串行总线。它由两条线组成：串行时钟线（SCL）和串行数据线（SDA）。这种总线允许多个设备在同一条总线上进行通信。
### 物理层
I2C通讯设备之间的常用连接方式见图
I2C通信协议是一种通用的总线协议。I2C通信协议有以下特征：
* (1) 它是一个支持设备的总线。“总线”指多个设备共用的信号线。在一个I2C通讯总线中， 可连接多个I2C通讯设备，支持多个通讯主机及多个通讯从机。
* (2) 一个I2C总线只使用两条总线线路，一条双向串行数据线(SDA) ， 一条串行时钟线 (SCL)。数据线即用来表示数据，时钟线用于数据收发同步。
* (3) 每个连接到总线的设备都有一个独立的地址， 主机可以利用这个地址进行不同设备之间的访问。
* (4) 总线通过上拉电阻接到电源。当I2C设备空闲时，会输出高阻态， 而当所有设备都空闲，都输出高阻态时，由上拉电阻把总线拉成高电平。
* (5) 多个主机同时使用总线时，为了防止数据冲突， 会利用仲裁方式决定由哪个设备占用总线。
* (6) 具有三种传输模式：标准模式传输速率为100kbit/s ，快速模式为400kbit/s ， 高速模式下可达 3.4Mbit/s，但目前大多I2C设备尚不支持高速模式。
* (7) 连接到相同总线的 IC 数量受到总线的最大电容 400pF 限制
* SDA数据线在每个SCL的时钟周期传输一位数据，SCL为高电平的时候SDA表示的数据有效。
* 应答信号和非应答信号I2C的数据和地址传输都带响应。
**一主多从**是指单片机作为主机，主导I2C总线的运行。挂在I2C总线上的所有外部模块都是从机，只有被主机点名后才能控制I2C总线，不能在未经允许的情况下访问I2C总线，以防止冲突。这就像在课堂上，老师是主机，学生是从机。未经点名允许，学生不能发言，但可以被动地听老师讲课。
另外，I2C还支持**多主多从**模型，即多个主机。在多主多从模型中，总线上任何一个模块都可以主动跳出来说，接下来我就是主机，你们都得听我的。这就像在教室里，老师正在讲课，突然一个学生站起来说，打断一下，接下来让我来说，所有同学听我指挥。但是，同一个时间只能有一个人说话，这时就相当于发生了总线冲突。在总线冲突时，I2C协议会进行仲裁，仲裁胜利的一方取得总线控制权，失败的一方自动变回从机。由于时钟线也由主机控制，所以**在多主机的模型下还要进行时钟同步**。多主机的情况下，协议是比较复杂的。本课程仅使用一主多从模型。
以上是有关I2C的设计背景和基本功能。接下来我们将详细分析I2C如何实现这些功能。 作为一个通信协议，I2C必须在硬件和软件上作出规定。**硬件上的规定包括电路的连接方式、端口的输入输出模式等；软件上的规定包括时序的定义、字节的传输方式、高位先行还是低位先行等**。这些硬件和软件的规定结合起来构成了一个完整的通信协议。
### 协议层
I2C的协议定义了通讯的起始和停止信号、数据有效性、响应、仲裁、时钟同步和地址广播等环节。
#### 1.I2C基本读写过程
先看看I2C通讯过程的基本结构，它的通讯过程见图
接下来我们先看一下12C的硬件规定，也就是I2C的硬件电路
#### I2C的硬件电路
这个图就是I2C的典型电路模型，这个模型采用了一主多从的结构。在左侧，我们可以看到CPU作为主设备，控制着总线并拥有很大的权利。其中，主机对SCL线拥有完全的控制权，无论何时何地，主机都负责掌控SCL线。在空闲状态下，主机还可以主动发起对SDA的控制。但是，从机发送数据或应答时，主机需要将SDA的控制权转交给从机。
接下来，我们看到了一系列被控IC，它们是挂载在12C总线上的从机设备，如姿态传感器、OLED、存储器、时钟模块等。这些从机的权利相对较小。**对于SCL时钟线，它们在任何时刻都只能被动的读取，不允许控制SCL线**；**对于SDA数据线，从机也不允许主动发起控制，只有在主机发送读取从机的命令后，或从机应答时，从机才能短暂地取得SDA的控制权**。这就是一主多从模型中协议的规定。
然后我们来看接线部分。所有I2C设备的SCL和SDA都连接在一起。主机的SCL线拉出来，所有从机的SCL都接在这上面。主机的SDA线也是一样，拉出来，所有从机的SDA接在这上面。这就是SCL和SDA的接线方式。
那到现在，我们先不继续往后看了，先忽略这两个电阻，那到现在，假设我们就这样连接，那如何规定每个设备SCL和SDA的输入输出模式呢？
由于现在是一主多从结构，主机拥有SCL的绝对控制权，因此主机的SCL可以配置成推挽输出，所有从机的SCL都配置成浮空输入或上拉输入。数据流向为主机发送、所有从机接收。但是到SDA线这里就比较复杂了，因为这是半双工协议，所以主机的SDA在发送时是输出，在接收时是输入。同样地，从机的SDA也会在输入和输出之间反复切换。如果能够协调好输入输出的切换时机就没有问题。但是这样做的话，如果总线时序没有协调好，就极有可能发生两个引脚同时处于输出的状态。如果此时一个引脚输出高电平，一个引脚输出低电平，就会造成电源短路的情况，这是要极力避免的。
为了避免这种情况的发生，I2C的设计规定所有设备不输出强上拉的高电平，而是采用外置弱上拉电阻加开漏输出的电路结构。这两点规定对应于前面提到的“设备的SCL和SDA均要配置成开漏输出模式”以及“SCL和SDA各添加一个上拉电阻，阻值一般为4.7KΩ左右”。对应上面这个图。
所有的设备，包括CPU和被控IC，它们的引脚内部结构都如上图所示。图左侧展示的是SCL的结构，其中SClk代表SCL；右侧则是SDA的结构，其中DATA代表SDA。引脚的信号输入都可以通过一个数据缓冲器或施密特触发器进行，因为输入对电路无影响，所以任何设备在任何时刻都可以输入。然而，在输出部分，采用的是开漏输出的配置。
正常的推挽输出方式如下：上面一个开关管连接正极，下面一个开关管连接负极。当上面导通时，输出高电平；下面导通时，输出低电平。因为这是通过开关管直接连接到正负极的，所以这是强上拉和强下拉的模式。
而开漏输出呢，就是去掉这个强上拉的开关管，输出低电平时，下管导通，是强下拉，输出高电平时，下管断开，但是没有上管了，此时引脚处于浮空的状态，这就是开漏输出。
和这里图示是一样的，输出低电平，这个开关管导通，引脚直接接地，是强下拉，输出高电平，这个开关管断开，引脚什么都不接，处于浮空状态，这样的话，所有的设备都只能输出低电平而不能输出高电平，为了避免高电平造成的引脚浮空，这时就需要在总线外面，SCL和SDA各外置一个上拉电阻，这是通过一个电阻拉到高电平的，所以这是一个弱上拉。
[UP主用弹簧和杆子的模型解释这一段硬件电路设计](https://gitee.com/vip204888)
这样做的好处是：
* 第一，完全杜绝了电源短路现象，保证电路的安全。你看所有人无论怎么拉杆子或者放手，杆子都不会处于一个被同时强拉和强推的状态，即使有多个人同时往下拉杆子，也没问题
* 第二，避免了引脚模式的频繁切换。开漏加弱上拉的模式，同时兼具了输入和输出的功能，你要是想输出，就去拉杆子或放手，操作杆子变化就行了，你要是想输入，就直接放手，然后观察杆子高低就行了，**因为开漏模式下，输出高电平就相当于断开引脚，所以在输入之前，可以直接输出高电平，不需要再切换成输入模式了**。
* 第三，就是这个模式会有一个“线与”的现象。就是只要有任意一个或多个设备输出了低电平，总线就处于低电平，只有所有设备都输出高电平，总线才处于高电平。I2C可以利用这个电路特性执行多主机模式下的时钟同步和总线仲裁，所以这里SCL虽然在一主多从模式下可以用推挽输出，但是它仍然**采用了开漏加上拉输出的模式**，因为在多主机模式下会利用到这个特征。
好，以上就是I2C的硬件电路设计，那接下来，我们就要来学习软件，也就是时序的设计了。
#### I2C时序设计
首先我们来学习一下I2C规定的一些时序基本单元。
##### 起始和终止条件
**起始条件是指SCL高电平期间，SDA从高电平切换到低电平**。在I2C总线处于空闲状态时，SCL和SDA都处于高电平状态，由外挂的上拉电阻保持。当主机需要数据收发时，会首先产生一个起始条件。这个起始条件是，SCL保持高电平，然后把SDA拉低，产生一个下降沿。当从机捕获到这个SCL高电平，SDA下降沿信号时，就会进行自身的复位，等待主机的召唤。之后，主机需要将SCL拉低。这样做一方面是占用这个总线，另一方面也是为了方便这些基本单元的拼接。这样，除了起始和终止条件，每个时序单元的SCL都是以低电平开始，低电平结束。
**终止条件是，SCL高电平期间，SDA从低电平切换到高电平**。SCL先放开并回弹到高电平，SDA再放开并回弹高电平，产生一个上升沿。这个上升沿触发终止条件，同时终止条件之后，SCL和SDA都是高电平，回归到最初的平静状态。这个起始条件和终止条件就类似串口时序里的起始位和停止位。一个完整的数据帧总是以起始条件开始、终止条件结束。另外，起始和终止都是由主机产生的。因此，从机必须始终保持双手放开，不允许主动跳出来去碰总线。如果允许从机这样做，那么就会变成多主机模型，不在本节的讨论范围之内。这就是起始条件和终止条件的含义。
##### 发送一个字节
接着继续看，在起始条件之后，这时就可以紧跟着一个发送一个字节的时序单元，**如何发送一个字节呢**？
就这样的流程，主机拉低SCL，把数据放在SDA上，主机松开SCL，从机读取SDA的数据，在SCL的同步下，依次进行主机发送和从机接收，循环8次，就发送了8位数据，也就是一个字节，另外注意，这里是高位先行，所以第一位是一个字节的最高位B7，然后依次是次高位B6…
##### 接收一个字节
那我们再继续看最后两个基本单元，就是应答机制的设计。
##### 发送应答和接收应答
**发一字节收一位，收一字节发一位**
#### 应用：
##### I2C从机地址
12C的完整时序，主要有指定地址写,当前地址读和指定地址读这3种。
首先注意的是，我们这个12C是一主多从的模型，主机可以访问总线上的任何一个设备，那如何发出指令，来确定要访问的是哪个设备呢？
为了解决这个问题，我们需要为每个从设备分配一个唯一的设备地址。这些地址就像是每个设备的名字，主机通过发送这些地址来确定要与哪个设备通信。
当主机发送一个地址时，所有的从设备都会收到这个地址。但是，只有与发送的地址匹配的设备会响应主机的读写操作。
在I2C总线中，每个挂载的设备的地址必须是唯一的，否则当主机发送一个地址时，多个设备响应，就会导致混乱。
在12C协议标准中，从机设备地址分为7位和10位两种。我们今天主要讨论7位地址，因为它们相对简单且应用广泛。
**每个I2C设备在出厂时都会被分配一个7位的地址**。例如，MPU6050的7位地址是1101 000，而AT24C02的7位地址是1010 000。不同型号的芯片地址是不同的，但相同型号的芯片地址是相同的。
**如果多个相同型号的芯片挂载在同一条总线上，我们可以通过调整地址的最后几位来解决这个问题**。例如，MPU6050的地址可以通过ADO引脚来改变，而AT24C02的地址可以通过A0、A1、A2引脚来改变。这样，即使相同型号的芯片，挂载在同一个总线上，也可以通过切换地址低位的方式，保证每个设备的地址都是唯一的。这就是12C设备的从机地址。
[下面时序讲解详情](https://gitee.com/vip204888)
注意：时序里面的RA是接收从机的应答位(Receive Ack, RA)
##### 指定地址写
(Sláve Address + R/W) 中最后一位 0=W（写），根据协议规定，紧跟着的单元，就得是接收从机的应答位（Receive Ack， RA），在这个时刻，主机要释放SDA，
所以如果单看主机的波形，应该是这样，
释放SDA之后，引脚电平回弹到高电平，但是根据协议规定，从机要在这个位拉低SDA，所以单看从机的波形，应该是这样（绿色线）
该应答的时候，从机立刻拽住SDA，然后应答结束之后，从机再放开SDA，那现在综合两者的波形，结合线与的特性，在主机释放SDA之后，由于SDA也被从机拽住了，所以主机松手后，SDA并没有回弹高电平，这个过程，就代表从机产生了应答。最终高电平期间，主机读取SDA，发现是0，就说明，我进行寻址，有人给我应答了。如果主机读取SDA，发现是1，就说明，我进行寻址，应答位期间，我松手了，但是没人拽住它，没人给我应答，那就直接产生停止条件吧，并提示一些信息，这就是应答位。
然后这个上升沿，就是应答位结束后，从机释放SDA产生的，从机交出了SDA的控制权，因为从机要在低电平尽快变换数据，所以这个上升沿和SCL的下降沿，几乎是同时发生的。
##### 当前地址读
##### 指定地址读
指定地址读=指定地址写+当前地址读
Sr (Start Repeat)的意思就是重复起始条件，因为指定读写标志位只能是跟着起始条件的第一个字节，所以如果想切换读写方向，只能再来个起始条件。然后起始条件后，重新寻址并且指定读写标志位
#### 代码实战：10-1 软件I2C读写MPU6050
由于我们这个代码使用的是软件I2C，就是用普通的GPIO口，手动翻转电平实现的协议，它并不需要STM32内部的外设资源支持，所以这里的端口（SDA，SCL），其实可以任意指定，不局限于这两个端口，你也可以SCL接PAO，SDA接PB12，或者SCL接PA8,SDA接PA9看，等等等等，接在任意的两个普通的GPIO口就可以。
软件I2C，只需要用gpio的读写函数就行了，就不用I2C的库函数了。
程序的整体框架：
MyI2C.h
#ifndef __MYI2C_H #define __MYI2C_H
void MyI2C_Init(void); void MyI2C_Start(void); void MyI2C_Stop(void); void MyI2C_SendByte(uint8_t Byte); uint8_t MyI2C_ReceiveByte(void); void MyI2C_SendAck(uint8_t AckBit); uint8_t MyI2C_ReceiveAck(void);
#endif
MyI2C.C
#include "stm32f10x.h" // Device header #include "Delay.h"
/引脚配置层/
/**
- 函 数：I2C写SCL引脚电平
- 参 数：BitValue 协议层传入的当前需要写入SCL的电平，范围0~1
- 返 回 值：无
- 注意事项：此函数需要用户实现内容，当BitValue为0时，需要置SCL为低电平，当BitValue为1时，需要置SCL为高电平 */ void MyI2C_W_SCL(uint8_t BitValue) { GPIO_WriteBit(GPIOB, GPIO_Pin_10, (BitAction)BitValue); //根据BitValue，设置SCL引脚的电平 Delay_us(10); //延时10us，防止时序频率超过要求 }
/**
- 函 数：I2C写SDA引脚电平
- 参 数：BitValue 协议层传入的当前需要写入SDA的电平，范围0~0xFF
- 返 回 值：无
- 注意事项：此函数需要用户实现内容，当BitValue为0时，需要置SDA为低电平，当BitValue非0时，需要置SDA为高电平 */ void MyI2C_W_SDA(uint8_t BitValue) { GPIO_WriteBit(GPIOB, GPIO_Pin_11, (BitAction)BitValue); //根据BitValue，设置SDA引脚的电平，BitValue要实现非0即1的特性 Delay_us(10); //延时10us，防止时序频率超过要求 }
/**
- 函 数：I2C读SDA引脚电平
- 参 数：无
- 返 回 值：协议层需要得到的当前SDA的电平，范围0~1
- 注意事项：此函数需要用户实现内容，当前SDA为低电平时，返回0，当前SDA为高电平时，返回1 */ uint8_t MyI2C_R_SDA(void) { uint8_t BitValue; BitValue = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11); //读取SDA电平 Delay_us(10); //延时10us，防止时序频率超过要求 return BitValue; //返回SDA电平 }
/**
-
函 数：I2C初始化
-
参 数：无
-
返 回 值：无
-
注意事项：此函数需要用户实现内容，实现SCL和SDA引脚的初始化 */ void MyI2C_Init(void) { /开启时钟/ RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); //开启GPIOB的时钟
/GPIO初始化/ GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOB, &GPIO_InitStructure); //将PB10和PB11引脚初始化为开漏输出
/设置默认电平/ GPIO_SetBits(GPIOB, GPIO_Pin_10 | GPIO_Pin_11); //设置PB10和PB11引脚初始化后默认为高电平（释放总线状态） }
/协议层/
/**
- 函 数：I2C起始
- 参 数：无
- 返 回 值：无 */ void MyI2C_Start(void) { MyI2C_W_SDA(1); //释放SDA，确保SDA为高电平 MyI2C_W_SCL(1); //释放SCL，确保SCL为高电平 MyI2C_W_SDA(0); //在SCL高电平期间，拉低SDA，产生起始信号 MyI2C_W_SCL(0); //起始后把SCL也拉低，即为了占用总线，也为了方便总线时序的拼接 }
/**
- 函 数：I2C终止
- 参 数：无
- 返 回 值：无 */ void MyI2C_Stop(void) { MyI2C_W_SDA(0); //拉低SDA，确保SDA为低电平 MyI2C_W_SCL(1); //释放SCL，使SCL呈现高电平 MyI2C_W_SDA(1); //在SCL高电平期间，释放SDA，产生终止信号 }
/**
- 函 数：I2C发送一个字节
- 参 数：Byte 要发送的一个字节数据，范围：0x00~0xFF
- 返 回 值：无 */ void MyI2C_SendByte(uint8_t Byte) { uint8_t i; for (i = 0; i < 8; i ++) //循环8次，主机依次发送数据的每一位 { MyI2C_W_SDA(Byte & (0x80 >> i)); //使用掩码的方式取出Byte的指定一位数据并写入到SDA线 MyI2C_W_SCL(1); //释放SCL，从机在SCL高电平期间读取SDA MyI2C_W_SCL(0); //拉低SCL，主机开始发送下一位数据 } }
/**
- 函 数：I2C接收一个字节
- 参 数：无
- 返 回 值：接收到的一个字节数据，范围：0x00~0xFF */ uint8_t MyI2C_ReceiveByte(void) { uint8_t i, Byte = 0x00; //定义接收的数据，并赋初值0x00，此处必须赋初值0x00，后面会用到 MyI2C_W_SDA(1); //接收前，主机先确保释放SDA，避免干扰从机的数据发送 for (i = 0; i < 8; i ++) //循环8次，主机依次接收数据的每一位 { MyI2C_W_SCL(1); //释放SCL，主机机在SCL高电平期间读取SDA if (MyI2C_R_SDA() == 1){Byte |= (0x80 >> i);} //读取SDA数据，并存储到Byte变量 //当SDA为1时，置变量指定位为1，当SDA为0时，不做处理，指定位为默认的初值0 MyI2C_W_SCL(0); //拉低SCL，从机在SCL低电平期间写入SDA } return Byte; //返回接收到的一个字节数据 }
/**
- 函 数：I2C发送应答位
- 参 数：Byte 要发送的应答位，范围：0~1，0表示应答，1表示非应答
- 返 回 值：无 */ void MyI2C_SendAck(uint8_t AckBit) { MyI2C_W_SDA(AckBit); //主机把应答位数据放到SDA线 MyI2C_W_SCL(1); //释放SCL，从机在SCL高电平期间，读取应答位 MyI2C_W_SCL(0); //拉低SCL，开始下一个时序模块 }
/**
- 函 数：I2C接收应答位
- 参 数：无
- 返 回 值：接收到的应答位，范围：0~1，0表示应答，1表示非应答 */ uint8_t MyI2C_ReceiveAck(void) { uint8_t AckBit; //定义应答位变量 MyI2C_W_SDA(1); //接收前，主机先确保释放SDA，避免干扰从机的数据发送 MyI2C_W_SCL(1); //释放SCL，主机机在SCL高电平期间读取SDA AckBit = MyI2C_R_SDA(); //将应答位存储到变量里 MyI2C_W_SCL(0); //拉低SCL，开始下一个时序模块 return AckBit; //返回定义应答位变量 }
函数逻辑：
* void MyI2C\_Start(void)
如果起始条件之前SCL和SDA已经是高电平了，那先释放哪一个是一样的效果，但是在指定地址读中，为了改变读写标志位，我们这个Start还要兼容这里的重复起始条件Sr。
Sr最开始，SCL是低电平，SDA电平不敢确定，所以保险起见，我们趁SCL是低电平，先确保释放SDA，再释放SCL，这时SDA和SCL都是高电平，然后再拉低SDA、拉低SCL，这样这个Start就可以兼容起始条件和重复起始条件了。
【如果先释放SCL，在SCL高电平期间再释放SDA会被误以为是终止条件；这里Sr是需要重新生成一个开始条件即SCL高电平期间，SDA从高变低。如果不先拉低SDA，就容易造成。SCL高电平期间，SDA从低变高。变成结束信号了。】
* void MyI2C\_Stop(void)
在这里，如果Stop开始时，那就先释放SCL，再释放SDA就行了，但是在这个时序单元开始时，SDA并不一定是低电平，所以为了确保之后释放SDA能产生上升沿，我们要在时序单元开始时，先拉低SDA，然后再释放SCL、释放SDA。
* void MyI2C\_SendByte(uint8\_t Byte)
发送一个字节时序开始时，SCL是低电平,实际上，除了终止条件，SCL以高电平结束,所有的单元我们都会保证SCL以低电平结束，这样方便各个单元的拼接。
补充：
`Byte & 0x80` 就是用按位与的方式，取出数据的某一位或某几位，感觉这里准确的讲是检查位是否为1，而不是取出最高位
* …
MPU6050\_Reg.h
#ifndef __MPU6050_REG_H #define __MPU6050_REG_H
#define MPU6050_SMPLRT_DIV 0x19 #define MPU6050_CONFIG 0x1A #define MPU6050_GYRO_CONFIG 0x1B #define MPU6050_ACCEL_CONFIG 0x1C
#define MPU6050_ACCEL_XOUT_H 0x3B #define MPU6050_ACCEL_XOUT_L 0x3C #define MPU6050_ACCEL_YOUT_H 0x3D #define MPU6050_ACCEL_YOUT_L 0x3E #define MPU6050_ACCEL_ZOUT_H 0x3F #define MPU6050_ACCEL_ZOUT_L 0x40 #define MPU6050_TEMP_OUT_H 0x41 #define MPU6050_TEMP_OUT_L 0x42 #define MPU6050_GYRO_XOUT_H 0x43 #define MPU6050_GYRO_XOUT_L 0x44 #define MPU6050_GYRO_YOUT_H 0x45 #define MPU6050_GYRO_YOUT_L 0x46 #define MPU6050_GYRO_ZOUT_H 0x47 #define MPU6050_GYRO_ZOUT_L 0x48
#define MPU6050_PWR_MGMT_1 0x6B #define MPU6050_PWR_MGMT_2 0x6C #define MPU6050_WHO_AM_I 0x75
#endif
MPU6050.h
#ifndef __MPU6050_H #define __MPU6050_H
void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data); uint8_t MPU6050_ReadReg(uint8_t RegAddress);
void MPU6050_Init(void); uint8_t MPU6050_GetID(void); void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ);
#endif
MPU6050.c
#include "stm32f10x.h" // Device header #include "MyI2C.h" #include "MPU6050_Reg.h"
#define MPU6050_ADDRESS 0xD0 //MPU6050的I2C从机地址
/**
- 函 数：MPU6050写寄存器
- 参 数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
- 参 数：Data 要写入寄存器的数据，范围：0x00~0xFF
- 返 回 值：无 */ void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data) { MyI2C_Start(); //I2C起始 MyI2C_SendByte(MPU6050_ADDRESS); //发送从机地址，读写位为0，表示即将写入 MyI2C_ReceiveAck(); //接收应答 MyI2C_SendByte(RegAddress); //发送寄存器地址 MyI2C_ReceiveAck(); //接收应答 MyI2C_SendByte(Data); //发送要写入寄存器的数据 MyI2C_ReceiveAck(); //接收应答 MyI2C_Stop(); //I2C终止 }
/**
-
函 数：MPU6050读寄存器
-
参 数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
-
返 回 值：读取寄存器的数据，范围：0x00~0xFF */ uint8_t MPU6050_ReadReg(uint8_t RegAddress) { uint8_t Data;
MyI2C_Start(); //I2C起始 MyI2C_SendByte(MPU6050_ADDRESS); //发送从机地址，读写位为0，表示即将写入 MyI2C_ReceiveAck(); //接收应答 MyI2C_SendByte(RegAddress); //发送寄存器地址 MyI2C_ReceiveAck(); //接收应答
MyI2C_Start(); //I2C重复起始 MyI2C_SendByte(MPU6050_ADDRESS | 0x01); //发送从机地址，读写位为1，表示即将读取 MyI2C_ReceiveAck(); //接收应答 Data = MyI2C_ReceiveByte(); //接收指定寄存器的数据 MyI2C_SendAck(1); //发送应答，给从机非应答，终止从机的数据输出 MyI2C_Stop(); //I2C终止
return Data; }
/**
-
函 数：MPU6050初始化
-
参 数：无
-
返 回 值：无 */ void MPU6050_Init(void) { MyI2C_Init(); //先初始化底层的I2C
/MPU6050寄存器初始化，需要对照MPU6050手册的寄存器描述配置，此处仅配置了部分重要的寄存器/ MPU6050_WriteReg(MPU6050_PWR_MGMT_1, 0x01); //电源管理寄存器1，取消睡眠模式，选择时钟源为X轴陀螺仪 MPU6050_WriteReg(MPU6050_PWR_MGMT_2, 0x00); //电源管理寄存器2，保持默认值0，所有轴均不待机 MPU6050_WriteReg(MPU6050_SMPLRT_DIV, 0x09); //采样率分频寄存器，配置采样率 MPU6050_WriteReg(MPU6050_CONFIG, 0x06); //配置寄存器，配置DLPF MPU6050_WriteReg(MPU6050_GYRO_CONFIG, 0x18); //陀螺仪配置寄存器，选择满量程为±2000°/s MPU6050_WriteReg(MPU6050_ACCEL_CONFIG, 0x18); //加速度计配置寄存器，选择满量程为±16g }
/**
- 函 数：MPU6050获取ID号
- 参 数：无
- 返 回 值：MPU6050的ID号 */ uint8_t MPU6050_GetID(void) { return MPU6050_ReadReg(MPU6050_WHO_AM_I); //返回WHO_AM_I寄存器的值 }
/**
-
函 数：MPU6050获取数据
-
参 数：AccX AccY AccZ 加速度计X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
-
参 数：GyroX GyroY GyroZ 陀螺仪X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
-
返 回 值：无 */ void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ) { uint8_t DataH, DataL; //定义数据高8位和低8位的变量
DataH = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_H); //读取加速度计X轴的高8位数据 DataL = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_L); //读取加速度计X轴的低8位数据 *AccX = (DataH << 8) | DataL; //数据拼接，通过输出参数返回
DataH = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_H); //读取加速度计Y轴的高8位数据 DataL = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_L); //读取加速度计Y轴的低8位数据 *AccY = (DataH << 8) | DataL; //数据拼接，通过输出参数返回
DataH = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_H); //读取加速度计Z轴的高8位数据 DataL = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_L); //读取加速度计Z轴的低8位数据 *AccZ = (DataH << 8) | DataL; //数据拼接，通过输出参数返回
DataH = MPU6050_ReadReg(MPU6050_GYRO_XOUT_H); //读取陀螺仪X轴的高8位数据 DataL = MPU6050_ReadReg(MPU6050_GYRO_XOUT_L); //读取陀螺仪X轴的低8位数据 *GyroX = (DataH << 8) | DataL; //数据拼接，通过输出参数返回
DataH = MPU6050_ReadReg(MPU6050_GYRO_YOUT_H); //读取陀螺仪Y轴的高8位数据 DataL = MPU6050_ReadReg(MPU6050_GYRO_YOUT_L); //读取陀螺仪Y轴的低8位数据 *GyroY = (DataH << 8) | DataL; //数据拼接，通过输出参数返回
DataH = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_H); //读取陀螺仪Z轴的高8位数据 DataL = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_L); //读取陀螺仪Z轴的低8位数据 *GyroZ = (DataH << 8) | DataL; //数据拼接，通过输出参数返回 }
main.c
#include "stm32f10x.h" // Device header #include "Delay.h" #include "OLED.h" #include "MPU6050.h"
uint8_t ID; //定义用于存放ID号的变量 int16_t AX, AY, AZ, GX, GY, GZ; //定义用于存放各个数据的变量
int main(void) { /模块初始化/ OLED_Init(); //OLED初始化 MPU6050_Init(); //MPU6050初始化
/*显示ID号*/
OLED_ShowString(1, 1, "ID:"); //显示静态字符串
ID = MPU6050_GetID(); //获取MPU6050的ID号
OLED_ShowHexNum(1, 4, ID, 2); //OLED显示ID号
while (1)
{
MPU6050_GetData(&AX, &AY, &AZ, &GX, &GY, &GZ); //获取MPU6050的数据
OLED_ShowSignedNum(2, 1, AX, 5); //OLED显示数据
OLED_ShowSignedNum(3, 1, AY, 5);
OLED_ShowSignedNum(4, 1, AZ, 5);
OLED_ShowSignedNum(2, 8, GX, 5);
OLED_ShowSignedNum(3, 8, GY, 5);
OLED_ShowSignedNum(4, 8, GZ, 5);
}
}
那之前的课程我们用的是软件I2C，手动拉低或释放时钟线，然后再手动对每个数据位进行判断，拉低或释放数据线，这样来产生这个的波形，这是软件I2C。由于12C是同步时序，这每一位的持续时间要求不严格，或许中途暂停一下时序，影响都不大，所以2C是比较容易用软件模拟的。
在实际项目中，软件模拟的I2C也是非常常见的，但是作为一个协议标准，I2C通信，也是可以有硬件收发电路的。就像之前的串口通信一样，我们先讲了串口的时序波形，但是在程序中，我们并没有用软件去手动翻转电平来实现这个波形，这是因为串口是异步时序，每一位的时间要求很严格，不能过长也不能过短，所以串口时序虽然可以用软件模拟，但是操作起来比较困难。另外，由于串口的硬件收发器在单片机中的普及程度非常高，基本上每个单片机都有串口的硬件资源，而且硬件实现的串口使用起来还非常简单，所以，串口通信，我们基本都是借助硬件收发器来实现的。
### I2C通信外设
**硬件实现串口（USART）的使用流程：首先配置USART外设，然后写入数据寄存器DR，然后硬件收发器就会自动生成波形发送出去，最后我们等待发送完成的标志位即可。**
回到I2C这里，I2C也可以有软件模拟和硬件收发器自动操作这两种异步时序，对于串口这样的异步时序，软件实现麻烦，硬件实现简单，所以串口的实现基本是全部倒向硬件。而对**于I2C这样的同步时序来说，软件实现简单灵活，硬件实现麻烦**，但可以节省软件资源、可以实现完整的多主机通信模型等，各有优缺点。
#### I2C框图
#### I2C基本结构
#### 代码实战：10-2硬件I2C读写MPU6050
MPU6050.h
#ifndef __MPU6050_H #define __MPU6050_H
void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data); uint8_t MPU6050_ReadReg(uint8_t RegAddress);
void MPU6050_Init(void); uint8_t MPU6050_GetID(void); void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ);
#endif
MPU6050\_REG.h
#ifndef __MPU6050_REG_H #define __MPU6050_REG_H
#define MPU6050_SMPLRT_DIV 0x19 #define MPU6050_CONFIG 0x1A #define MPU6050_GYRO_CONFIG 0x1B #define MPU6050_ACCEL_CONFIG 0x1C
#define MPU6050_ACCEL_XOUT_H 0x3B #define MPU6050_ACCEL_XOUT_L 0x3C #define MPU6050_ACCEL_YOUT_H 0x3D #define MPU6050_ACCEL_YOUT_L 0x3E #define MPU6050_ACCEL_ZOUT_H 0x3F #define MPU6050_ACCEL_ZOUT_L 0x40 #define MPU6050_TEMP_OUT_H 0x41 #define MPU6050_TEMP_OUT_L 0x42 #define MPU6050_GYRO_XOUT_H 0x43 #define MPU6050_GYRO_XOUT_L 0x44 #define MPU6050_GYRO_YOUT_H 0x45 #define MPU6050_GYRO_YOUT_L 0x46 #define MPU6050_GYRO_ZOUT_H 0x47 #define MPU6050_GYRO_ZOUT_L 0x48
#define MPU6050_PWR_MGMT_1 0x6B #define MPU6050_PWR_MGMT_2 0x6C #define MPU6050_WHO_AM_I 0x75
#endif
MPU6050.c
#include "stm32f10x.h" // Device header #include "MPU6050_Reg.h"
#define MPU6050_ADDRESS 0xD0 //MPU6050的I2C从机地址
/**
- 函 数：MPU6050等待事件
- 参 数：同I2C_CheckEvent
- 返 回 值：无 / void MPU6050_WaitEvent(I2C_TypeDef I2Cx, uint32_t I2C_EVENT) { uint32_t Timeout; Timeout = 10000; //给定超时计数时间 while (I2C_CheckEvent(I2Cx, I2C_EVENT) != SUCCESS) //循环等待指定事件 { Timeout --; //等待时，计数值自减 if (Timeout == 0) //自减到0后，等待超时 { /超时的错误处理代码，可以添加到此处/ break; //跳出等待，不等了 } } }
/**
-
函 数：MPU6050写寄存器
-
参 数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
-
参 数：Data 要写入寄存器的数据，范围：0x00~0xFF
-
返 回 值：无 */ void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data) { I2C_GenerateSTART(I2C2, ENABLE); //硬件I2C生成起始条件 MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT); //等待EV5
I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter); //硬件I2C发送从机地址，方向为发送 MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED); //等待EV6
I2C_SendData(I2C2, RegAddress); //硬件I2C发送寄存器地址 MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTING); //等待EV8
I2C_SendData(I2C2, Data); //硬件I2C发送数据 MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED); //等待EV8_2
I2C_GenerateSTOP(I2C2, ENABLE); //硬件I2C生成终止条件 }
/**
-
函 数：MPU6050读寄存器
-
参 数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
-
返 回 值：读取寄存器的数据，范围：0x00~0xFF */ uint8_t MPU6050_ReadReg(uint8_t RegAddress) { uint8_t Data;
I2C_GenerateSTART(I2C2, ENABLE); //硬件I2C生成起始条件 MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT); //等待EV5
I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter); //硬件I2C发送从机地址，方向为发送 MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED); //等待EV6
I2C_SendData(I2C2, RegAddress); //硬件I2C发送寄存器地址 MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED); //等待EV8_2
I2C_GenerateSTART(I2C2, ENABLE); //硬件I2C生成重复起始条件 MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT); //等待EV5
I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Receiver); //硬件I2C发送从机地址，方向为接收 MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED); //等待EV6
I2C_AcknowledgeConfig(I2C2, DISABLE); //在接收最后一个字节之前提前将应答失能 I2C_GenerateSTOP(I2C2, ENABLE); //在接收最后一个字节之前提前申请停止条件
MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_RECEIVED); //等待EV7 Data = I2C_ReceiveData(I2C2); //接收数据寄存器
I2C_AcknowledgeConfig(I2C2, ENABLE); //将应答恢复为使能，为了不影响后续可能产生的读取多字节操作
return Data; }
/**
-
函 数：MPU6050初始化
-
参 数：无
-
返 回 值：无 */ void MPU6050_Init(void) { /开启时钟/ RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE); //开启I2C2的时钟 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); //开启GPIOB的时钟
/GPIO初始化/ GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOB, &GPIO_InitStructure); //将PB10和PB11引脚初始化为复用开漏输出
/I2C初始化/ I2C_InitTypeDef I2C_InitStructure; //定义结构体变量 I2C_InitStructure.I2C_Mode = I2C_Mode_I2C; //模式，选择为I2C模式 I2C_InitStructure.I2C_ClockSpeed = 50000; //时钟速度，选择为50KHz I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2; //时钟占空比，选择Tlow/Thigh = 2 I2C_InitStructure.I2C_Ack = I2C_Ack_Enable; //应答，选择使能 I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; //应答地址，选择7位，从机模式下才有效 I2C_InitStructure.I2C_OwnAddress1 = 0x00; //自身地址，从机模式下才有效 I2C_Init(I2C2, &I2C_InitStructure); //将结构体变量交给I2C_Init，配置I2C2
/I2C使能/ I2C_Cmd(I2C2, ENABLE); //使能I2C2，开始运行
/MPU6050寄存器初始化，需要对照MPU6050手册的寄存器描述配置，此处仅配置了部分重要的寄存器/ MPU6050_WriteReg(MPU6050_PWR_MGMT_1, 0x01); //电源管理寄存器1，取消睡眠模式，选择时钟源为X轴陀螺仪 MPU6050_WriteReg(MPU6050_PWR_MGMT_2, 0x00); //电源管理寄存器2，保持默认值0，所有轴均不待机 MPU6050_WriteReg(MPU6050_SMPLRT_DIV, 0x09); //采样率分频寄存器，配置采样率 MPU6050_WriteReg(MPU6050_CONFIG, 0x06); //配置寄存器，配置DLPF MPU6050_WriteReg(MPU6050_GYRO_CONFIG, 0x18); //陀螺仪配置寄存器，选择满量程为±2000°/s MPU6050_WriteReg(MPU6050_ACCEL_CONFIG, 0x18); //加速度计配置寄存器，选择满量程为±16g }
/**
- 函 数：MPU6050获取ID号
- 参 数：无
- 返 回 值：MPU6050的ID号 */ uint8_t MPU6050_GetID(void) { return MPU6050_ReadReg(MPU6050_WHO_AM_I); //返回WHO_AM_I寄存器的值 }
/**
-
函 数：MPU6050获取数据
-
参 数：AccX AccY AccZ 加速度计X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
-
参 数：GyroX GyroY GyroZ 陀螺仪X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
-
返 回 值：无 */ void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ) { uint8_t DataH, DataL; //定义数据高8位和低8位的变量
DataH = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_H); //读取加速度计X轴的高8位数据 DataL = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_L); //读取加速度计X轴的低8位数据 *AccX = (DataH << 8) | DataL; //数据拼接，通过输出参数返回
DataH = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_H); //读取加速度计Y轴的高8位数据 DataL = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_L); //读取加速度计Y轴的低8位数据 *AccY = (DataH << 8) | DataL; //数据拼接，通过输出参数返回
DataH = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_H); //读取加速度计Z轴的高8位数据 DataL = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_L); //读取加速度计Z轴的低8位数据 *AccZ = (DataH << 8) | DataL; //数据拼接，通过输出参数返回
DataH = MPU6050_ReadReg(MPU6050_GYRO_XOUT_H); //读取陀螺仪X轴的高8位数据
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新
