2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
एषा सामग्री आधारिता अस्तिJiangxie प्रौद्योगिकी STM32विडियो अध्ययनस्य अनन्तरं संकलितम्।
निम्नस्तरीयः होस्ट् दत्तांशं स्थापयति, उच्चस्तरीयः दासः च दत्तांशं पठति ।
आरम्भस्थितेः अनन्तरं प्रथमः बाइट् अपि होस्ट् द्वारा प्रेषितः भवितुमर्हति । यदा SCL न्यूनः भवति, यदि होस्ट् 0 प्रेषयितुम् इच्छति तर्हि SDA न्यूनं आकर्षयति यदि 1 प्रेषयितुम् इच्छति तर्हि सः त्यजति, SDA च उच्चस्तरं प्रति पुनः प्रत्यावर्तयति; SCL इत्यस्य निम्नस्तरस्य समये SDA इत्यस्य स्तरं परिवर्तयितुं अनुमतिः भवति । उच्चस्तरस्य समये सः समयः यदा दासः SDA पठति, अतः उच्चस्तरस्य समये SDA परिवर्तनस्य अनुमतिः नास्ति । SCL उच्चस्तरस्य अनन्तरं, दासस्य SDA यथाशीघ्रं पठितुं आवश्यकं भवति सामान्यतया, दासः SCL इत्यस्य उदयमानस्य धारायाम् पठनं सम्पन्नवान् अस्ति । यतः घण्टा स्वामिना नियन्त्रिता भवति, तस्मात् दासः न जानाति यत् पतन् धारः कदा भवति, अतः दासः SCL इत्यस्य उदयमानस्य धारायां दत्तांशं पठिष्यति । होस्ट् इत्यनेन SCL इत्येतत् किञ्चित्कालं यावत् मुक्तं कृत्वा, सः SCL इत्यस्य निम्नतां आकर्षयितुं अग्रिमबिट् प्रसारयितुं च शक्नोति । होस्ट् इत्यनेन SCL इत्यस्य पतन् धारस्य अनन्तरं यथाशीघ्रं SDA इत्यत्र आँकडानां स्थापनम् अपि आवश्यकम् अस्ति । परन्तु होस्ट् इत्यस्य घण्टायाः नियन्त्रणं भवति, अतः केवलं तस्मिन् समये SDA इत्यत्र दत्तांशं स्थापयितुं आवश्यकं यदा न्यूनस्तरः न्यूनः भवति । दत्तांशस्य मुक्तेः अनन्तरं होस्ट् पुनः SCL मुक्तं करोति, SCL उच्चः भवति, दासः च एतत् बिट् पठति । एतां प्रक्रियां लूप् कुर्वन्तु: होस्ट् SCL न्यूनं आकर्षयति, SDA इत्यत्र आँकडान् स्थापयति, होस्ट् SCL मुक्तं करोति, दासः च SDA दत्तांशं पठति । SCL इत्यस्य समन्वयनस्य अन्तर्गतं मास्टरः प्रसारयति, दासः च क्रमेण प्राप्नोति ।
यतः प्रथमं उच्चक्रमस्य बिट् भवति, प्रथमः बिट् बाइट् इत्यस्य उच्चतमः बिट् B7 भवति, न्यूनतमः बिट् B0 च अन्तिमे प्रेषितः भवति ।
निम्नस्तरीयः दासः आँकडान् स्थापयति, उच्चस्तरीयः मेजबानः आँकडान् पठति
SDA रेखा: स्वामिनः SDA प्राप्तुं पूर्वं मुक्तं कर्तुं प्रवृत्तः भवति यदि दासः 0 प्रेषयितुं आवश्यकः अस्ति तर्हि SDA निम्नम् आकर्षयति यदि दासः 1 प्रेषयितुं आवश्यकः अस्ति उच्चस्तरं प्रति रिबाउण्ड् करोति। निम्नस्तरः दत्तांशं परिवर्तयति, उच्चस्तरः दत्तांशं पठति । ठोसरेखा स्वामिना नियन्त्रितस्तरं प्रतिनिधियति, बिन्दुरेखा च दासनियन्त्रितस्तरं प्रतिनिधियति । SCL सम्पूर्णप्रक्रियायां होस्ट् द्वारा नियन्त्रितं भवति, तथा च SDA होस्ट् प्राप्तुं पूर्वं मुक्तः भवितुमर्हति, नियन्त्रणार्थं च दासाय समर्पितः भवति । यतो हि SCL घड़ी होस्ट् द्वारा नियन्त्रिता भवति, अतः दासस्य दत्तांशरूपान्तरणं मूलतः SCL इत्यस्य पतने धारे भवति, तथा च होस्ट् यदा SCL उच्चः भवति तदा कदापि पठितुं शक्नोति
अर्थात् बाइट् प्रेषणस्य समयं आह्वयित्वा तस्य अनन्तरं receive response इत्यस्य आह्वानस्य समयः अवश्यं भवति, यस्य उपयोगः दासः केवलं तस्मै दत्तं दत्तांशं प्राप्तवान् वा इति निर्धारयितुं भवति यदि दासः तत् प्राप्नोति, तर्हि प्रतिक्रियाबिट् मध्ये, यदा मास्टरः SDA मुक्तं करोति, तदा दासः तत्क्षणमेव SDA अधः आकर्षयेत्, ततः SCL इत्यस्य उच्चस्तरस्य समये होस्ट् प्रतिक्रियाबिट् पठति यदि प्रतिक्रियाबिट् 0 अस्ति तर्हि दासः खलु प्राप्तवान् इति अर्थः ।
बाइट् प्राप्य भवद्भिः प्रेषणप्रतिसादं आह्वयितुं आवश्यकम् । प्रतिक्रियाप्रेषणस्य उद्देश्यं दासं वक्तुं भवति यत् भवान् प्रेषणं निरन्तरं कर्तुम् इच्छति वा इति । यदि दासयन्त्रं दत्तांशखण्डं प्रेषयित्वा स्वामिना प्रतिक्रियां प्राप्नोति तर्हि दासयन्त्रं गुरुयन्त्रात् उत्तरं न प्राप्नोति तर्हि दासयन्त्रं खण्डं प्रेषितवान् इति चिन्तयिष्यति of data, but the master machine ignores me Maybe होस्ट् न इच्छति अस्मिन् समये, दासः आज्ञाकारीरूपेण SDA मुक्तं करिष्यति तथा च होस्टस्य अनन्तरं कार्येषु हस्तक्षेपं निवारयिष्यति।
प्रक्रिया:
(1) आरम्भशर्ताः
(2) बाइट् प्रेषणस्य समयः—0xD0 (दास पता (7bit) + लेखनम् (1bit)-0) (1101 0000)
(3) प्रतिक्रिया प्राप्नुवन्तु : RA = 0 (दासात् प्रतिक्रियां प्राप्नुवन्तु)
(4) निर्दिष्टः पताः 0x19 (0001 1001)
(5) प्रतिक्रिया प्राप्नुवन्तु : RA = 0 (दासात् प्रतिक्रियां प्राप्नुवन्तु)
(6) निर्दिष्टदत्तांशं लिखत: 0xAA (1010 1010)
(7) प्रतिक्रिया प्राप्त करें : RA = 0
(8) स्टॉप बिट् P (समाप्तिस्थितिः) .
अस्य दत्तांशचक्रस्य उद्देश्यं अस्ति यत्: दासपतेः 1101000 निर्दिशति यस्य उपकरणस्य कृते, तस्य आन्तरिकपञ्जिकायां 0x19 पते दत्तांशं 0xAA लिखन्तु ।
0 इत्यस्य अर्थः अस्ति यत्: होस्ट् अनन्तरसमये लेखनक्रियाम् करिष्यति;
१ इत्यस्य अर्थः अस्ति यत्: मेजबानः अनन्तरं समयक्रमे पठनक्रियाम् करिष्यति;
प्रक्रिया:
(1) आरम्भशर्ताः
(2) बाइट् प्रेषणस्य समयः—0xD1 (दास पता (7bit) + पठितुं (1bit)-1) (1101 0001)
(3) प्रतिक्रिया प्राप्नुवन्तु : RA = 0 (दासात् प्रतिक्रियां प्राप्नुवन्तु)
(4) दासदत्तांशं पठन्तु: 0x0F (0000 1111)
(7) प्रतिक्रिया प्रेषयतु : SA = 0
(8) स्टॉप बिट् P (समाप्तिस्थितिः) .
प्रथमं आरभत, ततः पुनः आरम्भं कुर्वन्तु, ततः स्थगयन्तु
प्रक्रिया:
(1) आरम्भशर्ताः
(2) बाइट् प्रेषणस्य समयः—0xD0 (दास पता (7bit) + लेखनम् (1bit)-0) (1101 0000)
(3) प्रतिक्रिया प्राप्नुवन्तु : RA = 0 (दासात् प्रतिक्रियां प्राप्नुवन्तु)
(4) निर्दिष्टः पताः 0x19 (0001 1001)
(5) प्रतिक्रिया प्राप्नुवन्तु : RA = 0 (दासात् प्रतिक्रियां प्राप्नुवन्तु)
(6) आरम्भशर्तं पुनः कुर्वन्तु
(7) एकं बाइटं प्रेषयितुं समयः—0xD1 (दास पता (7bit) + पठितुं (1bit)-1) (1101 0001)
(8) प्रतिक्रिया प्राप्त करें : RA = 0
(9) दासदत्तांशं पठन्तु: 0xAA (1010 1010)
(10) प्रतिक्रिया प्रेषयतु : SA = 0
(11) स्टॉप बिट् P (समाप्तिस्थितिः) .
| आतप | नियोग |
|---|---|
| VCC、GND | विद्युत् आपूर्ति |
| एससीएल、एसडीए | I2C संचार पिन |
| XCL、XDA | होस्ट I2C संचार पिन |
| ई०० | दास-सङ्केतस्य निम्नतमः बिट् |
| INT | संकेतनिर्गमं व्यत्यययतु |
सॉफ्टवेयर I2C संचारस्य माध्यमेन MPU6050 चिप् इत्यस्य अन्तः रजिस्टर्स् पठन्तु लिखन्तु च, भवान् प्लग-इन मॉड्यूल् विन्यस्तं कर्तुं शक्नोति पठितदत्तांशः प्रदर्शितः भविष्यति ।OLED इत्यत्र शीर्षदत्तांशः उपकरणस्य ID सङ्ख्या अस्ति । अधः वामे त्रयः त्वरणसंवेदकस्य निर्गमदत्तांशः सन्ति, ये क्रमशः X-अक्षस्य, Y-अक्षस्य, Z-अक्षस्य च त्वरणं भवन्ति, दक्षिणभागे त्रयः गीरोस्कोपसंवेदकस्य निर्गमदत्तांशः अस्ति ये X-अक्षस्य, Y-अक्षस्य, Z-अक्षस्य च कोणीयवेगाः सन्ति ।
SCL STM32 इत्यस्य PB10 पिन इत्यनेन सह सम्बद्धं भवति, SDA च PB11 पिन इत्यनेन सह सम्बद्धम् अस्ति । यतः अत्र सॉफ्टवेयर-स्तरस्य फ्लिपिंग् कार्यान्वितं भवति, तस्मात् द्वौ GPIO पोर्ट् इच्छया संयोजितुं शक्यते ।
STM32 होस्ट् अस्ति तथा MPU6050 स्लेव् अस्ति, यः मास्टर-स्लेव् मोड् अस्ति ।
#include "stm32f10x.h" // Device header
#include "Delay.h"
void MyI2C_W_SCL(uint8_t BitValue)
{
GPIO_WriteBit(GPIOB, GPIO_Pin_10,(BitAction)BitValue);
Delay_us(10);
}
void MyI2C_W_SDA(uint8_t BitValue)
{
GPIO_WriteBit(GPIOB, GPIO_Pin_11,(BitAction)BitValue);
Delay_us(10);
}
uint8_t MyI2C_R_SDA(void)
{
uint8_t BitValue;
BitValue = GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_11);
Delay_us(10);
return BitValue;
}
void MyI2C_Init(void)
{
/*
软件I2C初始化：
1. 把SCL和SDA都初始化为开漏输出模式；
2. 把SCL和SDA置高电平；
输入时，先输出1，再直接读取输入数据寄存器就行了；
初始化结束后，调用SetBits，把GPIOB的Pin_10和Pin_11都置高电平，
此时I2C总线处于空闲状态
*/
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
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);
GPIO_SetBits(GPIOB, GPIO_Pin_10 | GPIO_Pin_11);
}
/*
起始条件：SCL高电平期间，SDA从高电平切换到低电平。
如果起始条件之前，SDA和SCL都已经是高电平了，那先释放哪一个是一样的效果。
但是这个Start还要兼容重复起始条件Sr，Sr最开始，SCL是低电平，SDA电平不敢确定，
所以为保险起见，在SCL低电平时，先确保释放SDA，再释放SCL。
这时SDA和SCL都是高电平，然后再拉低SDA、拉低SCL。
这样这个Start就可以兼容起始条件和重复起始条件了。
*/
void MyI2C_Start(void)
{
MyI2C_W_SDA(1);
MyI2C_W_SCL(1);
MyI2C_W_SDA(0);
MyI2C_W_SCL(0);
}
/*
终止条件：SCL高电平期间，SDA从低电平切换到高电平
如果Stop开始时，SCL和SDA都已经是低电平了，那就先释放SCL，再释放SDA。
但在这个时序单元开始时，SDA并不一定是低电平，所以为了确保之后释放
SDA能产生上升沿，要在时序单元开始时，先拉低SDA，然后再释放SCL、释放SDA。
*/
void MyI2C_Stop(void)// 终止条件
{
MyI2C_W_SDA(0);
MyI2C_W_SCL(1);
MyI2C_W_SDA(1);
}
/*
发送一个字节：发送一个字节时序开始时，SCL是低电平。
除了终止条件SCL以高电平结束，所有的单元都会保证SCL以低电平结束。
SCL低电平变换数据；高电平保持数据稳定。由于是高位先行，所以变换数据的时候，
按照先放最高位，再放次高位，...，最后最低位的顺序，依次把每一个字节的每一位放在SDA线上，
每放完一位后，执行释放SCL，拉低SCL的操作，驱动时钟运转。
程序：趁SCL低电平，先把Byte的最高位放在SDA线上，
*/
void MyI2C_SendByte(uint8_t Byte) // 发送一个字节
{
uint8_t i;
for (i = 0; i < 8; i ++)
{
MyI2C_W_SDA(Byte & (0x80 >> i));// 右移i位
MyI2C_W_SCL(1);
MyI2C_W_SCL(0);
}
}
/*
接收一个字节：时序开始时，SCL低电平，此时从机需要把数据放到SDA上，
为了防止主机干扰从机写入数据，主机需要先释放SDA，释放SDA相当于切换为输入模式，
那在SCL低电平时，从机会把数据放到SDA上，如果从机想发1，就释放SDA，想发0，就拉低SDA，
主机释放SCL，在SCL高电平期间，读取SDA，再拉低SCL，低电平期间，从机就会把下一位数据放到SDA上，重复8次，
主机就能读到一个字节了。
SCL低电平变换数据，高电平读取数据，实际上是一种读写分离的操作，低电平时间定义为写的时间，高电平时间定义为读的时间，
*/
uint8_t MyI2C_ReceiveByte(void) // 接收一个字节
{
uint8_t i, Byte = 0x00;
MyI2C_W_SDA(1);
for (i = 0; i < 8; i ++)
{
MyI2C_W_SCL(1); // 主机读取数据
if (MyI2C_R_SDA() == 1) // 如果if成立，接收的这一位为1,
{
Byte |= (0x80 >> i); // 最高位置1
}
MyI2C_W_SCL(0);
}
return Byte;
}
/*
问题：反复读取SDA，for循环中又没写过SDA，那SDA读出来应该始终是一个值啊？
回答：I2C是在进行通信，通信是有从机的，当主机不断驱动SCL时钟时，
从机就有义务去改变SDA的电平，所以主机每次循环读取SDA的时候，
这个读取到的数据是从机控制的，这个数据也正是从机想要给我们发送的数据，
所以这个时序叫做接收一个字节。
*/
void MyI2C_SendAck(uint8_t AckBit) // 发送应答
{
// 函数进来，SCL低电平，主机把AckBit放到SDA上，
MyI2C_W_SDA(AckBit);
MyI2C_W_SCL(1); // 从机读取应答
MyI2C_W_SCL(0); // 进入下一个时序单元
}
uint8_t MyI2C_ReceiveAck(void) // 接收应答
{
// 函数进来，SCL低电平，主机释放SDA，防止从机干扰
uint8_t AckBit;
MyI2C_W_SDA(1); // 主机释放SDA
MyI2C_W_SCL(1); // SCL高电平，主机读取应答位
AckBit = MyI2C_R_SDA();
MyI2C_W_SCL(0); // SCL低电平，进入下一个时序单元
return AckBit;
}
/*问题：在程序里，主机先把SDA置1了，然后再读取SDA，
这应答位肯定是1啊，
回答：第一，I2C的引脚是开漏输出+弱上拉的配置，主机输出1，
并不是强制SDA为高电平，而是释放SDA，
第二，I2C是在通信，主机释放了SDA，从机是有义务在此时把SDA再拉低的，
所以，即使主机把SDA置1了，之后再读取SDA，读到的值也可能是0，
读到0，代表从机给了应答，读到1，代表从机没给应答，这就是接收应答的流程。
*/
#ifndef __MPU6050_REG_H
#define __MPU6050_REG_H
// 宏定义: 寄存器的名称 对应的地址
#define MPU6050_SMPLRT_DIV 0x19 // 采样率分频
#define MPU6050_CONFIG 0x1A // 配置外部帧同步(FSYNC)引脚采样和数字低通滤波器(DLPF)设置
#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 // 电源管理寄存器1
#define MPU6050_PWR_MGMT_2 0x6C // 电源管理寄存器2
#define MPU6050_WHO_AM_I 0x75 // 用于验证设备身份
#endif
#include "stm32f10x.h" // Device header
#include "MyI2C.h"
#include "MPU6050_Reg.h"
// 宏定义：从机地址
#define MPU6050_ADDRESS 0xD0
// 指定地址写
void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data)
{
MyI2C_Start();
MyI2C_SendByte(MPU6050_ADDRESS);// 发送从机地址后，接收应答
MyI2C_ReceiveAck();// 寻址找到从机之后，继续发送下一个字节
MyI2C_SendByte(RegAddress); // 指定寄存器地址，存在MPU6050的当前地址指针里，用于指定具体读写哪个寄存器
MyI2C_ReceiveAck();
MyI2C_SendByte(Data);// 指定写入指定寄存器地址下的数据
MyI2C_ReceiveAck();
MyI2C_Stop();
}
// 指定地址读
uint8_t MPU6050_ReadReg(uint8_t RegAddress)
{
uint8_t Data;
MyI2C_Start();
MyI2C_SendByte(MPU6050_ADDRESS);
MyI2C_ReceiveAck();
MyI2C_SendByte(RegAddress); // 指定地址：就是设置了MPU6050的当前地址指针
MyI2C_ReceiveAck();
// 转入读的时序，重新指定读写位，就必须重新起始
MyI2C_Start();// 重复起始条件
MyI2C_SendByte(MPU6050_ADDRESS | 0x01);// 指定从机地址和读写位，0xD0是写地址，或上0x01变为0xD1，读写位为1，接下来要读从机的数据
MyI2C_ReceiveAck(); // 接收应答后，总线控制权就正式交给从机了，从机开始发送一个字节
Data = MyI2C_ReceiveByte();// 主机接收一个字节，该函数返回值就是接收到的数据
// 主机接收一个字节后，要给从机发送一个应答
MyI2C_SendAck(1);// 参数为0，就是给从机应答，参数给1，就是不给从机应答
// 如果想继续读多个字节，就要给应答，从机收到应答之后，就会继续发送数据，如果不想继续读了，就不能给从机应答了。
// 主机收回总线的控制权，防止之后进入从机以为你还想要，但你实际不想要的冲突状态，
// 这里，只需要读取1个字节，所以就给1，不给从机应答，
MyI2C_Stop();
return Data;
}
void MPU6050_Init(void)
{
MyI2C_Init();
// 写入一些寄存器对MPU6050硬件电路进行初始化配置
// 电源管理寄存器1：设备复位：0，不复位；睡眠模式：0，解除睡眠：循环模式：0，不循环；无关位i:0;温度传感器失能：0，不失能；最后三位选择时钟：000，选择内部时钟，001，选择x轴的陀螺仪时钟，
MPU6050_WriteReg(MPU6050_PWR_MGMT_1,0x01);// 解除睡眠，选择陀螺仪时钟
// 电源管理寄存器2：前两位，循环模式唤醒频率：00，不需要；后6位，每一个轴的待机位：全为0，不需要待机；
MPU6050_WriteReg(MPU6050_PWR_MGMT_2,0x00); // 均不待机
// 采样率分频：该8位决定了数据输出的快慢，值越小越快
MPU6050_WriteReg(MPU6050_SMPLRT_DIV,0x09);// 采样分频：10分频
// 配置寄存器：外部同步：全为0，不需要；数字低通滤波器：110，最平滑的滤波
MPU6050_WriteReg(MPU6050_CONFIG,0x06);// 滤波参数给最大
// 陀螺仪配置寄存器：前三位，自测使能：全为0，不自测；满量程选择：11，最大量程；后三位无关位：为0
MPU6050_WriteReg(MPU6050_GYRO_CONFIG,0x18);// 陀螺仪和加速度计都选最大量程
// 加速度计配置寄存器：前三位，自测使能：全为0，不自测；满量程选择：11，最大量程；后三位高通滤波器：用不到，为000
MPU6050_WriteReg(MPU6050_ACCEL_CONFIG,0x18);
}
// 获取芯片的ID号
uint8_t MPU6050_GetID(void)
{
return MPU6050_ReadReg(MPU6050_WHO_AM_I);
}
// 获取寄存器数据的函数，返回6个int16_t的数据，分别表示XYZ的加速度值和陀螺仪值
// 指针地址传递的方法，返回多值
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;
// 加速度计X
DataH = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_H);
DataL = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_L);
*AccX = (DataH << 8) | DataL; // 高8位左移8位，再或上低8位，得到加速度计X轴的16位数据
// 加速度计Y
DataH = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_H);
DataL = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_L);
*AccY = (DataH << 8) | DataL;
// 加速度计Z
DataH = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_H);
DataL = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_L);
*AccZ = (DataH << 8) | DataL;
// 陀螺仪X
DataH = MPU6050_ReadReg(MPU6050_GYRO_XOUT_H);
DataL = MPU6050_ReadReg(MPU6050_GYRO_XOUT_L);
*GyroX = (DataH << 8) | DataL;
// 陀螺仪Y
DataH = MPU6050_ReadReg(MPU6050_GYRO_YOUT_H);
DataL = MPU6050_ReadReg(MPU6050_GYRO_YOUT_L);
*GyroY = (DataH << 8) | DataL;
// 陀螺仪Z
DataH = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_H);
DataL = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_L);
*GyroZ = (DataH << 8) | DataL;
}
#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "OLED.h"
#include "MyI2C.h"
#include "MPU6050.h"
uint8_t ID;
int16_t AX, AY, AZ, GX, GY, GZ;// 接收XYZ轴的加速度值和陀螺仪值
int main(void)
{
OLED_Init();
// MyI2C_Init();
MPU6050_Init();
//
OLED_ShowString(1,1,"ID:");
ID = MPU6050_GetID();
OLED_ShowHexNum(1, 4, ID, 2);
// // 指定地址写
// MyI2C_Start(); // 产生起始条件，开始一次传输
// // 主机首先发送一个字节，内容是从机地址+读写位，进行寻址
// MyI2C_SendByte(0xD0); // 1101 000 0,0代表即将进行写入操作
// // 发送一个字节后，要接收一下应答位，看看从机有没有收到刚才的数据
// uint8_t Ack = MyI2C_ReceiveAck();
// // 接收应答之后，要继续发送一个字节，写入寄存器地址
// MyI2C_Stop();
//
// OLED_ShowNum(1, 1, Ack, 3);
// // 指定地址读
// uint8_t ID = MPU6050_ReadReg(0X75);// 返回值是0x68
// OLED_ShowHexNum(1, 1, ID, 2);
// // 指定地址写，需要先解除睡眠模式，否则写入无效
// // 睡眠模式是电源管理寄存器1的这一位SLEEP控制的，把该寄存器写入0x00，解除睡眠模式
// // 该寄存器地址是0x6B
// MPU6050_WriteReg(0x6B, 0x00);
// // 采样率分频寄存器，地址是0x19，值的内容是采样分频
// MPU6050_WriteReg(0x19, 0xAA);
//
// uint8_t ID = MPU6050_ReadReg(0X19);
// OLED_ShowHexNum(1, 1, ID, 2);//显示0x19地址下的内容，应该是0xAA
while(1)
{
MPU6050_GetData(&AX, &AY, &AZ, &GX, &GY, &GZ);
OLED_ShowSignedNum(2, 1, AX, 5);
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);
}
}
यदा STM32 निर्दिष्टपते लिखितुम् इच्छति तदा तस्य संप्रेषकसंचरणक्रमचित्रस्य अनुसरणं करणीयम् ।
7-बिट् मास्टर रिसेप्शन: आरम्भः, दासपतेः + पठन्तु, प्रतिक्रियां प्राप्नुवन्तु, आँकडान् प्राप्नुवन्तु, प्रतिक्रियां प्रेषयन्तु... आँकडान् प्राप्नुवन्तु, अप्रतिसादं कुर्वन्तु, समाप्तं कुर्वन्तु
void I2C_DeInit(I2C_TypeDef* I2Cx);
void I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct);
void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct);
void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
// 生成起始条件、终止条件
void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState);
// 配置CR1的ACK这一位，0：无应答，1：应答
void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState);
// 发送数据，把Data数据直接写入到DR寄存器
void I2C_SendData(I2C_TypeDef* I2Cx, uint8_t Data);
// 读取DR，接收数据
uint8_t I2C_ReceiveData(I2C_TypeDef* I2Cx);
// Address参数也是通过DR发送的，但在发送之前，设置了Address最低位的读写位，
// I2C_Direction不是发送，是把Address的最低位置1（读），否则最低位清0（写）
void I2C_Send7bitAddress(I2C_TypeDef* I2Cx, uint8_t Address, uint8_t I2C_Direction);
SCL STM32 इत्यस्य PB10 पिन इत्यनेन सह सम्बद्धं भवति, SDA च PB11 पिन इत्यनेन सह सम्बद्धम् अस्ति । यतः अत्र सॉफ्टवेयर-स्तरस्य फ्लिपिंग् कार्यान्वितं भवति, तस्मात् द्वौ GPIO पोर्ट् इच्छया संयोजितुं शक्यते ।
OLED इत्यस्य शीर्षदत्तांशः उपकरणस्य ID सङ्ख्या अस्ति अस्य MPU6050 इत्यस्य ID सङ्ख्या 0x68 इति नियतम् अस्ति । अधः वामे त्रयः त्वरणसंवेदकस्य निर्गमदत्तांशः सन्ति, ये क्रमशः X-अक्षस्य, Y-अक्षस्य, Z-अक्षस्य च त्वरणं भवन्ति, दक्षिणभागे त्रयः गीरोस्कोपसंवेदकस्य निर्गमदत्तांशः अस्ति ये X-अक्षस्य, Y-अक्षस्य, Z-अक्षस्य च कोणीयवेगाः सन्ति ।
#include "stm32f10x.h" // Device header
#include "MPU6050_Reg.h"
/*
1. 配置I2C外设，对I2C外设进行初始化，替换MyI2C_Init
（1）开启I2C外设和对应GPIO口的时钟，
（2）把I2C外设对应的GPIO口初始化为复用开漏模式
（3）使用结构体，对整个I2C进行配置
（4）I2C_Cmd，使能I2C
2. 控制外设电路，实现指定地址写的时序，替换WriteReg
3. 控制外设电路，实现指定地址读的时序，替换ReadReg
*/
// 宏定义：从机地址
#define MPU6050_ADDRESS 0xD0
// 超时退出
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)
{
break;// 跳出循环，直接执行后面的程序
}
}
}
// 指定地址写：发送器传送时序
void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data)
{
// MyI2C_Start();
// MyI2C_SendByte(MPU6050_ADDRESS);// 发送从机地址后，接收应答
// MyI2C_ReceiveAck();// 寻址找到从机之后，继续发送下一个字节
// MyI2C_SendByte(RegAddress); // 指定寄存器地址，存在MPU6050的当前地址指针里，用于指定具体读写哪个寄存器
// MyI2C_ReceiveAck();
// MyI2C_SendByte(Data);// 指定写入指定寄存器地址下的数据
// MyI2C_ReceiveAck();
// MyI2C_Stop();
I2C_GenerateSTART(I2C2, ENABLE); // 起始条件
MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT); //EV5事件
// 发送从机地址，接收应答。该函数自带了接收应答，如果应答错误，硬件会通过标志位和中断来提示我们
I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);
MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED); //EV6事件
// 直接写入DR，发送数据
I2C_SendData(I2C2, RegAddress);
// 写入了DR，DR立刻转移到移位寄存器进行发送，EV8事件出现的非常快，基本不用等。因为有两级缓存，
// 第一个数据写进DR了，会立刻跑到移位寄存器，这时不用等第一个数据发完，第二个数据就可以写进去等着了。
MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTING); //EV8事件
I2C_SendData(I2C2, Data);
MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED); //EV8_2事件
I2C_GenerateSTOP(I2C2, ENABLE);
}
// 指定地址读：接收器传送序列
uint8_t MPU6050_ReadReg(uint8_t RegAddress)
{
uint8_t Data;
// MyI2C_Start();
// MyI2C_SendByte(MPU6050_ADDRESS);
// MyI2C_ReceiveAck();
// MyI2C_SendByte(RegAddress); // 指定地址：就是设置了MPU6050的当前地址指针
// MyI2C_ReceiveAck();
// // 转入读的时序，重新指定读写位，就必须重新起始
// MyI2C_Start();// 重复起始条件
// MyI2C_SendByte(MPU6050_ADDRESS | 0x01);// 指定从机地址和读写位，0xD0是写地址，或上0x01变为0xD1，读写位为1，接下来要读从机的数据
// MyI2C_ReceiveAck(); // 接收应答后，总线控制权就正式交给从机了，从机开始发送一个字节
// Data = MyI2C_ReceiveByte();// 主机接收一个字节，该函数返回值就是接收到的数据
// // 主机接收一个字节后，要给发送从机一个应答
// MyI2C_SendAck(1);// 参数为0，就是给从机应答，参数给1，就是不给从机应答
// MyI2C_Stop();
I2C_GenerateSTART(I2C2, ENABLE); // 起始条件
MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT); //EV5事件
// 发送从机地址，接收应答。该函数自带了接收应答，如果应答错误，硬件会通过标志位和中断来提示我们
I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);
MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED); //EV6事件
// 直接写入DR，发送数据
I2C_SendData(I2C2, RegAddress);
// 写入了DR，DR立刻转移到移位寄存器进行发送，EV8事件出现的非常快，基本不用等。因为有两级缓存，
// 第一个数据写进DR了，会立刻跑到移位寄存器，这时不用等第一个数据发完，第二个数据就可以写进去等着了。
MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED); //EV8_2事件
I2C_GenerateSTART(I2C2, ENABLE);// 重复起始条件
// 主机接收
MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT); //EV5事件
// 接收地址
I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Receiver); // 函数内部就自动将该地址MPU6050_ADDRESS的最低位置1
MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED); //EV6事件
// 在最后一个数据之前就要把应答位ACK置0，同时把停止条件生成位STOP置1
I2C_AcknowledgeConfig(I2C2, DISABLE);
I2C_GenerateSTOP(I2C2, ENABLE);
MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_RECEIVED); //EV7事件
// 等EV7事件产生后，一个字节的数据就已经在DR里面了。
// 读取DR就可拿出该字节
Data = I2C_ReceiveData(I2C2); // 返回值就是DR的数据
// 在接收函数的最后，要恢复默认的ACK = 1。
// 默认状态下ACK就是1，给从机应答，在收最后一个字节之前，临时把ACK置0，给非应答，
// 所以在接收函数的最后，要恢复默认的ACK = 1，这个流程是为了方便指定地址收多个字节。
I2C_AcknowledgeConfig(I2C2, ENABLE);
return Data;
}
void MPU6050_Init(void)
{
// MyI2C_Init();
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
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);
I2C_InitTypeDef I2C_InitStructure;
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C; // 模式
I2C_InitStructure.I2C_ClockSpeed = 50000; // 时钟速度,最大400kHz的时钟频率
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2; // 时钟占空比，只有在时钟频率大于100kHz，也就是进入到快速状态时才有用，小于100kHz，占空比是固定的1:1，
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable; //
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; // STM32作为从机，可以响应几位的地址
I2C_InitStructure.I2C_OwnAddress1 = 0x00; // 自身地址1，也是作为从机使用，
I2C_Init(I2C2, &I2C_InitStructure);
I2C_Cmd(I2C2,ENABLE);
// 写入一些寄存器对MPU6050硬件电路进行初始化配置
// 电源管理寄存器1：设备复位：0，不复位；睡眠模式：0，解除睡眠：循环模式：0，不循环；无关位i:0;温度传感器失能：0，不失能；最后三位选择时钟：000，选择内部时钟，001，选择x轴的陀螺仪时钟，
MPU6050_WriteReg(MPU6050_PWR_MGMT_1,0x01);// 解除睡眠，选择陀螺仪时钟
// 电源管理寄存器2：前两位，循环模式唤醒频率：00，不需要；后6位，每一个轴的待机位：全为0，不需要待机；
MPU6050_WriteReg(MPU6050_PWR_MGMT_2,0x00); // 均不待机
// 采样率分频：该8位决定了数据输出的快慢，值越小越快
MPU6050_WriteReg(MPU6050_SMPLRT_DIV,0x09);// 采样分频：10分频
// 配置寄存器：外部同步：全为0，不需要；数字低通滤波器：110，最平滑的滤波
MPU6050_WriteReg(MPU6050_CONFIG,0x06);// 滤波参数给最大
// 陀螺仪配置寄存器：前三位，自测使能：全为0，不自测；满量程选择：11，最大量程；后三位无关位：为0
MPU6050_WriteReg(MPU6050_GYRO_CONFIG,0x18);// 陀螺仪和加速度计都选最大量程
// 加速度计配置寄存器：前三位，自测使能：全为0，不自测；满量程选择：11，最大量程；后三位高通滤波器：用不到，为000
MPU6050_WriteReg(MPU6050_ACCEL_CONFIG,0x18);
}
// 获取芯片的ID号
uint8_t MPU6050_GetID(void)
{
return MPU6050_ReadReg(MPU6050_WHO_AM_I);
}
// 获取寄存器数据的函数，返回6个int16_t的数据，分别表示XYZ的加速度值和陀螺仪值
// 指针地址传递的方法，返回多值
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;
// 加速度计X
DataH = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_H);
DataL = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_L);
*AccX = (DataH << 8) | DataL; // 高8位左移8位，再或上低8位，得到加速度计X轴的16位数据
// 加速度计Y
DataH = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_H);
DataL = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_L);
*AccY = (DataH << 8) | DataL;
// 加速度计Z
DataH = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_H);
DataL = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_L);
*AccZ = (DataH << 8) | DataL;
// 陀螺仪X
DataH = MPU6050_ReadReg(MPU6050_GYRO_XOUT_H);
DataL = MPU6050_ReadReg(MPU6050_GYRO_XOUT_L);
*GyroX = (DataH << 8) | DataL;
// 陀螺仪Y
DataH = MPU6050_ReadReg(MPU6050_GYRO_YOUT_H);
DataL = MPU6050_ReadReg(MPU6050_GYRO_YOUT_L);
*GyroY = (DataH << 8) | DataL;
// 陀螺仪Z
DataH = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_H);
DataL = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_L);
*GyroZ = (DataH << 8) | DataL;
}
#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "OLED.h"
#include "MPU6050.h"
uint8_t ID;
int16_t AX, AY, AZ, GX, GY, GZ;// 接收XYZ轴的加速度值和陀螺仪值
int main(void)
{
OLED_Init();
MPU6050_Init();
OLED_ShowString(1,1,"ID:");
ID = MPU6050_GetID();
OLED_ShowHexNum(1, 4, ID, 2);
// // 指定地址写
// MyI2C_Start(); // 产生起始条件，开始一次传输
// // 主机首先发送一个字节，内容时从机地址+读写位，进行寻址
// MyI2C_SendByte(0xD0); // 1101 000 0,0代表即将进行写入操作
// // 发送一个字节后，要接收一下应答位，看看从机有没有收到刚才的数据
// uint8_t Ack = MyI2C_ReceiveAck();
// // 接收应答之后，要继续发送一个字节，写入寄存器地址
// MyI2C_Stop();
//
// OLED_ShowNum(1, 1, Ack, 3);
// // 指定地址读
// uint8_t ID = MPU6050_ReadReg(0X75);// 返回值是0x68
// OLED_ShowHexNum(1, 1, ID, 2);
// // 指定地址写，需要先解除睡眠模式，否则写入无效
// // 睡眠模式是电源管理寄存器1的这一位SLEEP控制的，把该寄存器写入0x00，解除睡眠模式
// // 该寄存器地址是0x6B
// MPU6050_WriteReg(0x6B, 0x00);
// // 采样率分频寄存器，地址是0x19，值的内容是采样分频
// MPU6050_WriteReg(0x19, 0xAA);
//
// uint8_t ID = MPU6050_ReadReg(0X19);
// OLED_ShowHexNum(1, 1, ID, 2);//显示0x19地址下的内容，应该是0xAA
while(1)
{
MPU6050_GetData(&AX, &AY, &AZ, &GX, &GY, &GZ);
OLED_ShowSignedNum(2, 1, AX, 5);
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);
}
}
सः ३० वर्षाणाम् अधिकं कालात् प्रौद्योगिक्याः शोधकार्यं कर्तुं समर्पितः अस्ति, तथा च जावा, लिनक्स, जावास्क्रिप्ट्, php, css इत्यादिषु विविधभाषासु प्रवीणः अस्ति, मुक्तस्रोतक्षेत्रे सः बहु योगदानं कृतवान् अस्ति developer documentation station भविष्ये सन्दर्भार्थं प्रौद्योगिकीविकासे केचन विषयाः साझां कर्तुं सर्वे तत् पश्यन्तु
