STM32学习之MPU6050芯片 及 软件I2C读写MPU6050实验

已于 2025-01-06 22:46:39 修改
阅读量1.3k 收藏 17
点赞数 8
分类专栏： 单片机（32） 文章标签： stm32 学习 单片机 经验分享 笔记
于 2025-01-04 16:21:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44114055/article/details/144890005
版权

在这里插入图片描述

在这里插入图片描述

MPU6050是一个6轴姿态传感器，可测量芯片自身X、Y、Z轴的加速度、角速度参数，可以通过这些数据融合，可进一步得到姿态角（或者叫做欧拉角），常应用于平衡车、飞行器等需要检测自身姿态的场景

一个IMU（惯性测量单元）内会装有三洲的陀螺仪和三个方向的加速度计，一般安装在物体重心位置
在这里插入图片描述

在这里插入图片描述
//
I2C是在进行通信，通信是有从机的，当主机不断驱动SCL时钟时，从机就有义务去改变SDA的电平。所以主机每次循环读取SDA的时候，这个读取到的数据是从机控制的，这个数据也正是从机想要给我们发送的数据；

发送应答：主机在接收完一个字节之后，在下一个时钟发送一位数据，数据0表示应答，数据1表示非应答；

I2C的引脚都是开漏输出+弱上拉的配置。主机输出1并不是强制SDA为高电平，而是释放SDA；I2C通信时，主机释放了SDA，从机在此时把SDA再拉低的。所以这里即使之前主机把SDA置1再读取SDA，读到的值也可能是0，读到0代表从机给了应答，读到1代表从机没给应答；

/
学习参考江协科技以及学习博客
///
//
软件I2C读写MPU6050实验
接线图：
在这里插入图片描述
32为主机，6050为从机，6050模块内部有上拉电阻，所以SCL和SDA不用再接

第一部分，完成软件I2C的时序，第二部分，基于I2C协议，读写寄存器，来操控MPU6050

在这里插入图片描述

/
代码部分以oled为基础 main.c /oled.h .c / mpu6050.c.h / MyO2C.c .h

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);
	}
}

///
OLED.h

#ifndef __OLED_H
#define __OLED_H

void OLED_Init(void);
void OLED_Clear(void);
void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char);
void OLED_ShowString(uint8_t Line, uint8_t Column, char *String);
void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length);
void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);

#endif

//
OLED.c

#include "stm32f10x.h"
#include "OLED_Font.h"

/*引脚配置*/
#define OLED_W_SCL(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_8, (BitAction)(x))
#define OLED_W_SDA(x)		GPIO_WriteBit(GPIOB, GPIO_Pin_9, (BitAction)(x))
//BitAction类型通常用于指定要写入到GPIO引脚的具体电平值

/*引脚初始化*/
void OLED_I2C_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
 	GPIO_Init(GPIOB, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
 	GPIO_Init(GPIOB, &GPIO_InitStructure);
	
	OLED_W_SCL(1);
	OLED_W_SDA(1);
}

/**
  * @brief  I2C开始
  * @param  无
  * @retval 无
  */
void OLED_I2C_Start(void)
{
	OLED_W_SDA(1);
	OLED_W_SCL(1);
	OLED_W_SDA(0);
	OLED_W_SCL(0);
}

/**
  * @brief  I2C停止
  * @param  无
  * @retval 无
  */
void OLED_I2C_Stop(void)
{
	OLED_W_SDA(0);
	OLED_W_SCL(1);
	OLED_W_SDA(1);
}

/**
  * @brief  I2C发送一个字节
  * @param  Byte 要发送的一个字节
  * @retval 无
  */
void OLED_I2C_SendByte(uint8_t Byte)
{
	uint8_t i;
	for (i = 0; i < 8; i++)
	{
		OLED_W_SDA(Byte & (0x80 >> i));
		OLED_W_SCL(1);
		OLED_W_SCL(0);
	}
	OLED_W_SCL(1);	//额外的一个时钟，不处理应答信号
	OLED_W_SCL(0);
}

/**
  * @brief  OLED写命令
  * @param  Command 要写入的命令
  * @retval 无
  */
void OLED_WriteCommand(uint8_t Command)
{
	OLED_I2C_Start();
	OLED_I2C_SendByte(0x78);		//从机地址
	OLED_I2C_SendByte(0x00);		//写命令
	OLED_I2C_SendByte(Command); 
	OLED_I2C_Stop();
}

/**
  * @brief  OLED写数据
  * @param  Data 要写入的数据
  * @retval 无
  */
void OLED_WriteData(uint8_t Data)
{
	OLED_I2C_Start();
	OLED_I2C_SendByte(0x78);		//从机地址
	OLED_I2C_SendByte(0x40);		//写数据
	OLED_I2C_SendByte(Data);
	OLED_I2C_Stop();
}

/**
  * @brief  OLED设置光标位置
  * @param  Y 以左上角为原点，向下方向的坐标，范围：0~7
  * @param  X 以左上角为原点，向右方向的坐标，范围：0~127
  * @retval 无
  */
void OLED_SetCursor(uint8_t Y, uint8_t X)
{
	OLED_WriteCommand(0xB0 | Y);					//设置Y位置
	OLED_WriteCommand(0x10 | ((X & 0xF0) >> 4));	//设置X位置高4位
	OLED_WriteCommand(0x00 | (X & 0x0F));			//设置X位置低4位
}

/**
  * @brief  OLED清屏
  * @param  无
  * @retval 无
  */
void OLED_Clear(void)
{  
	uint8_t i, j;
	for (j = 0; j < 8; j++)
	{
		OLED_SetCursor(j, 0);
		for(i = 0; i < 128; i++)
		{
			OLED_WriteData(0x00);
		}
	}
}

/**
  * @brief  OLED显示一个字符
  * @param  Line 行位置，范围：1~4
  * @param  Column 列位置，范围：1~16
  * @param  Char 要显示的一个字符，范围：ASCII可见字符
  * @retval 无
  */
void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char)
{      	
	uint8_t i;
	OLED_SetCursor((Line - 1) * 2, (Column - 1) * 8);		//设置光标位置在上半部分
	for (i = 0; i < 8; i++)
	{
		OLED_WriteData(OLED_F8x16[Char - ' '][i]);			//显示上半部分内容
	}
	OLED_SetCursor((Line - 1) * 2 + 1, (Column - 1) * 8);	//设置光标位置在下半部分
	for (i = 0; i < 8; i++)
	{
		OLED_WriteData(OLED_F8x16[Char - ' '][i + 8]);		//显示下半部分内容
	}
}

/**
  * @brief  OLED显示字符串
  * @param  Line 起始行位置，范围：1~4
  * @param  Column 起始列位置，范围：1~16
  * @param  String 要显示的字符串，范围：ASCII可见字符
  * @retval 无
  */
void OLED_ShowString(uint8_t Line, uint8_t Column, char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i++)
	{
		OLED_ShowChar(Line, Column + i, String[i]);
	}
}

/**
  * @brief  OLED次方函数
  * @retval 返回值等于X的Y次方
  */
uint32_t OLED_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y--)
	{
		Result *= X;
	}
	return Result;
}

/**
  * @brief  OLED显示数字（十进制，正数）
  * @param  Line 起始行位置，范围：1~4
  * @param  Column 起始列位置，范围：1~16
  * @param  Number 要显示的数字，范围：0~4294967295
  * @param  Length 要显示数字的长度，范围：1~10
  * @retval 无
  */
void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i++)							
	{
		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(10, Length - i - 1) % 10 + '0');
	}
}

/**
  * @brief  OLED显示数字（十进制，带符号数）
  * @param  Line 起始行位置，范围：1~4
  * @param  Column 起始列位置，范围：1~16
  * @param  Number 要显示的数字，范围：-2147483648~2147483647
  * @param  Length 要显示数字的长度，范围：1~10
  * @retval 无
  */
void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length)
{
	uint8_t i;
	uint32_t Number1;
	if (Number >= 0)
	{
		OLED_ShowChar(Line, Column, '+');
		Number1 = Number;
	}
	else
	{
		OLED_ShowChar(Line, Column, '-');
		Number1 = -Number;
	}
	for (i = 0; i < Length; i++)							
	{
		OLED_ShowChar(Line, Column + i + 1, Number1 / OLED_Pow(10, Length - i - 1) % 10 + '0');
	}
}

/**
  * @brief  OLED显示数字（十六进制，正数）
  * @param  Line 起始行位置，范围：1~4
  * @param  Column 起始列位置，范围：1~16
  * @param  Number 要显示的数字，范围：0~0xFFFFFFFF
  * @param  Length 要显示数字的长度，范围：1~8
  * @retval 无
  */
void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
	uint8_t i, SingleNumber;
	for (i = 0; i < Length; i++)							
	{
		SingleNumber = Number / OLED_Pow(16, Length - i - 1) % 16;
		if (SingleNumber < 10)
		{
			OLED_ShowChar(Line, Column + i, SingleNumber + '0');
		}
		else
		{
			OLED_ShowChar(Line, Column + i, SingleNumber - 10 + 'A');
		}
	}
}

/**
  * @brief  OLED显示数字（二进制，正数）
  * @param  Line 起始行位置，范围：1~4
  * @param  Column 起始列位置，范围：1~16
  * @param  Number 要显示的数字，范围：0~1111 1111 1111 1111
  * @param  Length 要显示数字的长度，范围：1~16
  * @retval 无
  */
void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i++)							
	{
		OLED_ShowChar(Line, Column + i, Number / OLED_Pow(2, Length - i - 1) % 2 + '0');
	}
}

/**
  * @brief  OLED初始化
  * @param  无
  * @retval 无
  */
void OLED_Init(void)
{
	uint32_t i, j;
	
	for (i = 0; i < 1000; i++)			//上电延时
	{
		for (j = 0; j < 1000; j++);
	}
	
	OLED_I2C_Init();			//端口初始化
	
	OLED_WriteCommand(0xAE);	//关闭显示
	
	OLED_WriteCommand(0xD5);	//设置显示时钟分频比/振荡器频率
	OLED_WriteCommand(0x80);
	
	OLED_WriteCommand(0xA8);	//设置多路复用率
	OLED_WriteCommand(0x3F);
	
	OLED_WriteCommand(0xD3);	//设置显示偏移
	OLED_WriteCommand(0x00);
	
	OLED_WriteCommand(0x40);	//设置显示开始行
	
	OLED_WriteCommand(0xA1);	//设置左右方向，0xA1正常 0xA0左右反置
	
	OLED_WriteCommand(0xC8);	//设置上下方向，0xC8正常 0xC0上下反置

	OLED_WriteCommand(0xDA);	//设置COM引脚硬件配置
	OLED_WriteCommand(0x12);
	
	OLED_WriteCommand(0x81);	//设置对比度控制
	OLED_WriteCommand(0xCF);

	OLED_WriteCommand(0xD9);	//设置预充电周期
	OLED_WriteCommand(0xF1);

	OLED_WriteCommand(0xDB);	//设置VCOMH取消选择级别
	OLED_WriteCommand(0x30);

	OLED_WriteCommand(0xA4);	//设置整个显示打开/关闭

	OLED_WriteCommand(0xA6);	//设置正常/倒转显示

	OLED_WriteCommand(0x8D);	//设置充电泵
	OLED_WriteCommand(0x14);

	OLED_WriteCommand(0xAF);	//开启显示
		
	OLED_Clear();				//OLED清屏
}

//
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

//
//
/
这是重点，6个模块，I2C的起始、终止、发送字节、接受字节、发送接收应答的代码化

I2C时序
下图是指定地址写
对于指定设备(Slave Address)在指定地址(Reg Address)下，写入指定数据(Data)
在这里插入图片描述

下图是当前地址读
对于指定设备在当前地址指针指示的地址下，读取从机数据(Data)(Slave Address)
在这里插入图片描述

下图是指定地址读
对于指定设备在指定地址(Reg Address)下，读取从机数据(Data)(Slave Address)
在这里插入图片描述
在 I2C 时序图中，“Sr” 表示 “重复起始条件”（Repeated Start condition）
起始条件（Start condition，S）：在 I2C 通信开始时，由主机将 SDA 线从高电平拉低，同时 SCL 线为高电平，这个操作标志着一次 I2C 通信的开始；
重复起始条件（Repeated Start condition，Sr）：在一次 I2C 通信过程中，主机可以在不释放总线的情况下，再次发送一个起始条件，这个操作称为重复起始条件。它用于在一次通信中切换数据传输方向或访问不同的从机设备。

此图最后的终止时，SDA不一定是低电平，所以为了确保之后释放SDA能产生上升沿，就要在时序信号开始时先拉底SDA

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也拉低，即为了占用总线，也为了方便总线时序的拼接
	//因为SCL高的时候时会从SDA读数据的
}

/**
  * 函    数：I2C终止，如果在要终止时，SCL和SDA都是低电平了，那就先释放SCL，再释放SDA就行了，
  * 但此时，SDA不一定是低电平，所以为了确保之后释放SDA能产生上升沿，就要在时序信号开始时先拉底SDA
  * 参    数：无
  * 返 回 值：无
  */
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，主机开始发送下一位数据
		//除了终止条件，其他时候SCL一般都是以低电平结束，方便其他单元的拼接。
		//因为在 SCL 为低电平时，SDA 可以自由地改变状态，这允许其他 I2C 设备
		//在此时准备好下一个要传输的数据位或者准备进行下一次传输操作
	}
}

/**
  * 函    数：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();	
	//将应答位存储到变量里
    //可能会问，上一行SDA就是1，那现在读的肯定是1啊，意义在哪？
    //第一，I2C的引脚都是开漏输出+弱上拉的配置，为1其实是释放
    //第二，I2C是在通信，主机释放了SDA，从机不是在看戏，此时从机有任务的话，是会去拉低SDA的
    //读到0说明从机给了应答


	MyI2C_W_SCL(0);	//拉低SCL，开始下一个时序模块
	return AckBit;	//返回定义应答位变量
}

up主的测试：

在这里插入图片描述
此时是可以检测到的，有应答，当时想的是，MPU模块还没有开始写代码，为啥它会给主机应答信号？

答： MPU6050 内部有一个 I2C 接口控制器，这个控制器是硬件电路的一部分，专门用于处理 I2C 通信。当主机在 I2C总线上发送从机地址时，MPU6050 的 I2C 接口控制器会自动监听总线上的信号。

当主机发送从机地址时，MPU6050 的 I2C 接口控制器会将接收到的地址与自己的预设地址进行比较。MPU6050的默认从机地址是0xD0（当 AD0 引脚接地时）或0xD1（当 AD0 引脚接高电平时）

如果接收到的地址与 MPU6050 的从机地址匹配，在主机发送完从机地址的第 9 个时钟脉冲（SCL 为高电平）期间，MPU6050 会将SDA 线拉低，这就是从机的应答信号（ACK）。这个拉低操作是由 MPU6050 内部的 I2C接口控制器硬件自动完成的，不需要额外的软件干预。

如果接收到的地址与 MPU6050 的从机地址不匹配，MPU6050 会在第 9 个时钟脉冲期间保持 SDA线为高电平，这表示非应答（NACK）。

///
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;						//数据拼接，通过输出参数返回
}


MPU6050Reg.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
I2C通信协议+软件I2C读取MPU6050
2401_87621963的博客
02-24 1154
目的：通过通信线实现单片机读写外挂模块寄存器的功能•I2C（Inter IC Bus）是由Philips公司开发的一种通用数据总线•两根通信线：SCL（Serial Clock）、SDA（Serial Data）•同步，半双工•带数据应答•支持总线挂载多设备（tips：1.异步时序省一根时钟线，对时间要求严格，对硬件电路依赖严重同步时序多一根时钟线，对时间要求不严格，对硬件电路不依赖2.SDA（Serial Data）兼具发送接收。
MPU6050测试程序
11-23
MPU6050测试程序包含51代码。经测试可正常读取加速度，角速度值
STM32学习-MPU6050
kanox的博客
11-11 5503
本文记录学习I2C通信协议的相关笔记。(参考b站江协科技STM32教程)MPU6050是一个6轴姿态传感器，可以测量芯片自身XYZ轴的加速度、角速度参数，通过数据融合，可进一步得到姿态角，常应用于平衡车、飞行器等需要检测自身姿态的场景3轴加速度计（）：测量XYZ轴的加速度3轴陀螺仪传感器（Gyroscope）：测量XYZ轴的角速度以上就是关于MPU6050的相关知识及一些个人认为的重点。并且在最后给出如何使用软件模拟I2C通信来读取MPU6050数据的详细代码。
mpu6050测试程序
09-01
三轴陀螺仪InvenSense公司的三轴陀螺仪MPU6050测试程序。IIC接口，51单片机驱动，LCD1602同步显示。
MPU6050
StudyPower_Max的博客
05-14 9570
姿态传感器—MPU6050简介寄存器数字运动处理器 DMP 简介 MPU6050是一款六轴（三轴加速度+三轴角速度（陀螺仪））传感器 MPU6050含有一个第二IIC接口，可用于连接外部磁力传感器 MPU6050自带数字运动处理器（DMP）通过主IIC接口，可以向CPU提供四元数，CPU可利用四元数得到欧拉角：航向角（yaw） 横滚角（roll） 俯仰角（pitch） 寄存器 1、电源管理寄存器1（0x6B） bit7位用来控制复位，设置为1 硬件自动清零该位。 bit6位用于控制工作模式，1，睡眠模
STM32 HAL库 硬件I2C对MPU6050的使用
11-02
在STM32F407ZG芯片上，我们可以利用其内置的I2C接口来与MPU6050进行通信。 首先，我们需要配置STM32的HAL库以支持I2C通信。这通常涉及以下步骤： 1. 使用STM32CubeMX初始化工具，选择STM32F407ZG芯片并配置I2C接口...
stm32之软件I2C读写MPU6050陀螺仪、加速度传感器
08-30
本案例实现了一个stm32使用软件I2C通信读写MPU6050陀螺仪、加速度传感器的功能，最终我们将MPU6050的实时数据显示在了OLED上。OLED最上面显示的是设备ID号，左下角三个是加速度传感器的输出数据，分别为X轴、Y轴和Z...
stm32之硬件I2C读写MPU6050陀螺仪、加速度传感器
最新发布
09-01
本案例实现了一个stm32使用硬件I2C外设通信读写MPU6050陀螺仪、加速度传感器的功能，最终我们将MPU6050的实时数据显示在了OLED上。OLED最上面显示的是设备ID号，左下角三个是加速度传感器的输出数据，分别为X轴、Y轴...
MPU6050_MPU6050stm32f1_MPU6050_姿态识别_
09-30
STM32F1需要配置I2C外设，设置时钟、中断等参数。然后编写读写函数，用于与传感器交互，获取陀螺仪和加速度计的数据。 3. **数据处理**：MPU6050返回的是原始传感器数据，包括陀螺仪的角速度和加速度计的加速度。...
stm32 MPU-6050三轴加速度 陀螺仪模块程序
03-19
stm32 MPU-6050三轴加速度 陀螺仪模块程序,已经调通可以使用
STM32串口输出MPU-6050陀螺仪
07-15
STM32串口输出MPU-6050陀螺仪，经过测试的程序能在上位机上显示。
mpu6050示例程序stm32版
08-15
U6050M-6D串口陀螺仪应用示范例程，是基于stm32写的，而且里面也跟有U6050M-6D串口陀螺仪加速度模组应用手册，更容易学习。
MPU6050+软件模拟iic程序。
02-19
做直立组智能车期间在在网上收集资料后二次开发，打包分享
MPU6050测试代码.7z
07-23
在 MPU6050 的采样频率设置中，读者可在 imv_mpu.h 文件第 26 行的宏定义进行修改 #define DEFAULT_MPU_HZ (100)，设置成 100HZ，即可保证 6050 的数据是 10ms 更新一次，也就是说 MPU60050 本身的数据输出频率就是 100HZ。（注意：MPU6050 的频率不能超过 200HZ）
STM32单片机读写 MPU6050陀螺仪（软件I2C）软件DEMO例程源码.zip
06-01
在本示例中，我们将探讨如何使用STM32F407型号的单片机通过软件I2C通信协议与MPU6050陀螺仪进行交互。MPU6050是一款集成六轴传感器（三轴陀螺仪和三轴加速度计）的设备，常用于运动检测和姿态估计。 首先，我们需要...
mpu6050上位机测试软件设计方法以及源码下载
viewtoolsz的博客
12-20 1284
  硬件：MPU6050传感器模块+Ginkgo 2 I2C Adapter软件：Qt(MinGW 4.4)+Qwt(6.0.2)效果：  2013-5-21 10:44 上传 下载附件 (82.91 KB)源码下载：  Qt_I2C_MPU6050.rar (212.86 KB, 下载次数: 306) 可执行程序：  MPU6050_EXE.rar (4.5 MB, 下载次数: 446) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

挥剑决浮云 -

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值