STM32F407ZE驱动陀螺仪MPU6050有何应用

　　STM32F407ZE 驱动陀螺仪MPU6050的应用实例，实现如下功能：
　　①使用MPU6050的驱动实现陀螺仪遥控
　　左倾：LED1亮
　　右倾：LED2亮
　　前倾：LED3亮
　　后倾：LED4亮
　　使用的是获取的欧拉角！！
　　②做一个碰撞警告功能
　　如果板子在一定速度的前提下 ，碰上障碍物 ，
　　速度锐减，蜂鸣器响，以示警告（请用PWM让蜂鸣器的响度降低）
　　使用的是陀螺仪的加速度计！
　　具体代码与解析如下：
　　main.c部分
　　#include 《stm32f4xx.h》
　　#include 《math.h》
　　#include “sys.h”
　　#include “led.h”
　　#include “uart.h”
　　#include “systick.h”
　　#include “iic.h”
　　#include “mpu6050.h”
　　#include “inv_mpu.h”
　　#include 《string.h》
　　int main（）
　　{
　　short Templ;
　　short Gx，Gy，Gz;
　　short Ax，Ay，Az;
　　float Pitch，Roll，Yaw; //欧拉角记录变量
　　NVIC_PriorityGroupConfig（NVIC_PriorityGroup_2）; //中断优先级分组 2分组
　　Systick_Init（）; //精准延时初始化
　　USART1_Init（）;
　　LED_Init（）; //LED灯初始化
　　IIC_GPIOInit（）; //IIC相关引脚初始化
　　// if（0 ！= MPU_Init（））//加上Mpu初始化
　　// {
　　// printf（“Init MPU Fail！rn”）;
　　// return 0;
　　// }
　　if（0 ！= mpu_dmp_init（））
　　{
　　printf（“DMP Init MPU Fail！rn”）;
　　return 0;
　　}
　　delay（10）;
　　while（1）
　　{
　　//表示使用DMP成功获取 四元数 并计算得到了欧拉角
　　if（mpu_dmp_get_data（&Pitch，&Roll，&Yaw） == 0）
　　{
　　Templ = MPU_Get_Temperature（）;
　　MPU_Get_Gyroscope（&Gx，&Gy，&Gz）;
　　MPU_Get_Accelerometer（&Ax，&Ay，&Az）;
　　//printf（“Gx：%.3f Gy：%.3f Gz：%.3f Ax：%d Ay：%d Az：%drn”，Gx/16.4，Gy/16.4，Gz/16.4，Ax，Ay，Az）;
　　//printf（“温度：%.3frn”，Templ/100.0）;
　　//printf（“俯仰角：%.2f 横滚角：%.2f 航向角：%.2frn”，Pitch，Roll，Yaw）;
　　//mpu6050_send_data（Ax，Ay，Az，Gx，Gy，Gz）;//用自定义帧发送加速度和陀螺仪原始数据
　　//usart1_report_imu（Ax，Ay，Az，Gx，Gy，Gz，（int）（Roll*100），（int）（Pitch*100），（int）（Yaw*10））;
　　LED_Control（Pitch，Roll）; //判断Pitch，Roll的值，从而判别陀螺仪向偏向哪边
　　FM_Control（Ax，Ay）; //判断Ax，Ay的值，从而判别陀螺仪往哪个方向加速，控制蜂鸣器的响停
　　delay_ms（500）;
　　}
　　}
　　}
　　sys.h部分
　　#ifndef __SYS_H
　　#define __SYS_H
　　#include “stm32f4xx.h”
　　//IO口操作宏定义
　　#define BITBAND（addr， bitnum） （（addr & 0xF0000000）+0x2000000+（（addr & 0xFFFFF）《《5）+（bitnum《《2））
　　#define MEM_ADDR（addr） *（（volatile unsigned long *）（addr））
　　#define BIT_ADDR（addr， bitnum） MEM_ADDR（BITBAND（addr， bitnum））
　　//IO口地址映射
　　#define GPIOA_ODR_Addr （GPIOA_BASE+20） //0x40020014
　　#define GPIOB_ODR_Addr （GPIOB_BASE+20） //0x40020414
　　#define GPIOC_ODR_Addr （GPIOC_BASE+20） //0x40020814
　　#define GPIOD_ODR_Addr （GPIOD_BASE+20） //0x40020C14
　　#define GPIOE_ODR_Addr （GPIOE_BASE+20） //0x40021014
　　#define GPIOF_ODR_Addr （GPIOF_BASE+20） //0x40021414
　　#define GPIOG_ODR_Addr （GPIOG_BASE+20） //0x40021814
　　#define GPIOH_ODR_Addr （GPIOH_BASE+20） //0x40021C14
　　#define GPIOI_ODR_Addr （GPIOI_BASE+20） //0x40022014
　　#define GPIOA_IDR_Addr （GPIOA_BASE+16） //0x40020010
　　#define GPIOB_IDR_Addr （GPIOB_BASE+16） //0x40020410
　　#define GPIOC_IDR_Addr （GPIOC_BASE+16） //0x40020810
　　#define GPIOD_IDR_Addr （GPIOD_BASE+16） //0x40020C10
　　#define GPIOE_IDR_Addr （GPIOE_BASE+16） //0x40021010
　　#define GPIOF_IDR_Addr （GPIOF_BASE+16） //0x40021410
　　#define GPIOG_IDR_Addr （GPIOG_BASE+16） //0x40021810
　　#define GPIOH_IDR_Addr （GPIOH_BASE+16） //0x40021C10
　　#define GPIOI_IDR_Addr （GPIOI_BASE+16） //0x40022010
　　//STM32中 对寄存器的访问 是不能单独访问寄存器的单个bit 只能以32bit地址访问寄存器
　　//这些位为只写形式，只能在字（word）--4byte、半字2byte 或字节模式下访问
　　//IO口操作，只对单一的IO口！
　　//确保n的值小于16！
　　#define PAout（n） BIT_ADDR（GPIOA_ODR_Addr，n） //输出
　　#define PAin（n） BIT_ADDR（GPIOA_IDR_Addr，n） //输入
　　#define PBout（n） BIT_ADDR（GPIOB_ODR_Addr，n） //输出
　　#define PBin（n） BIT_ADDR（GPIOB_IDR_Addr，n） //输入
　　#define PCout（n） BIT_ADDR（GPIOC_ODR_Addr，n） //输出
　　#define PCin（n） BIT_ADDR（GPIOC_IDR_Addr，n） //输入
　　#define PDout（n） BIT_ADDR（GPIOD_ODR_Addr，n） //输出
　　#define PDin（n） BIT_ADDR（GPIOD_IDR_Addr，n） //输入
　　#define PEout（n） BIT_ADDR（GPIOE_ODR_Addr，n） //输出
　　#define PEin（n） BIT_ADDR（GPIOE_IDR_Addr，n） //输入
　　#define PFout（n） BIT_ADDR（GPIOF_ODR_Addr，n） //输出
　　#define PFin（n） BIT_ADDR（GPIOF_IDR_Addr，n） //输入
　　#define PGout（n） BIT_ADDR（GPIOG_ODR_Addr，n） //输出
　　#define PGin（n） BIT_ADDR（GPIOG_IDR_Addr，n） //输入
　　#define PHout（n） BIT_ADDR（GPIOH_ODR_Addr，n） //输出
　　#define PHin（n） BIT_ADDR（GPIOH_IDR_Addr，n） //输入
　　#define PIout（n） BIT_ADDR（GPIOI_ODR_Addr，n） //输出
　　#define PIin（n） BIT_ADDR（GPIOI_IDR_Addr，n） //输入
　　#endif
　　led.h部分
　　#ifndef _LED_H_
　　#define _LED_H_
　　#include 《stm32f4xx.h》
　　#include “sys.h”
　　#include 《math.h》
　　#include 《stdlib.h》
　　#include “uart.h”
　　#include “tim.h”
　　void LED_Init（void）;
　　void LED_Control（float a，float b）; //判断Pitch，Roll的值，从而判别陀螺仪偏向哪边，控制LED灯的亮灭
　　void FM_Control（short x，short y）; //判断Ax，Ay的值，从而判别陀螺仪往哪个方向加速，控制蜂鸣器的响停
　　#endif
　　led.c部分
　　#include “led.h”
　　short flag1，flag2;
　　void LED_Init（void）
　　{
　　GPIO_InitTypeDef aaa;
　　//1、先开启对应用到的模块时钟节拍
　　RCC_AHB1PeriphClockCmd（RCC_AHB1Periph_GPIOF，ENABLE）;
　　RCC_AHB1PeriphClockCmd（RCC_AHB1Periph_GPIOE，ENABLE）;//PE组时钟
　　//2、可以初始化配置GPIO F组的8、9、10号引脚
　　aaa.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_8;
　　aaa.GPIO_Mode = GPIO_Mode_OUT;//输出模式
　　aaa.GPIO_Speed = GPIO_Fast_Speed;//快速 点灯和引脚速度无关
　　aaa.GPIO_OType = GPIO_OType_PP;//推挽输出
　　aaa.GPIO_PuPd = GPIO_PuPd_UP;//内部上拉
　　GPIO_Init（GPIOF，&aaa）;
　　aaa.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14;
　　GPIO_Init（GPIOE，&aaa）;
　　//初始化完成 灭掉4盏灯
　　PFout（9） = 1;
　　PFout（10） = 1;
　　PEout（13） = 1;
　　PEout（14） = 1;
　　}
　　void LED_Control（float a，float b） //判断Pitch，Roll的值，从而判别陀螺仪偏向哪边，控制LED灯的亮灭
　　{
　　if（fabs（a） 》 fabs（b） && fabs（a） 》 2） //Pitch值大于Roll值（控制左右）
　　{
　　if（a 》 0） //Pitch值大于0，偏左
　　{
　　PFout（9） = 0;
　　PFout（10） = 1;
　　PEout（13） = 1;
　　PEout（14） = 1;
　　printf（“左倾！rn”）;
　　}
　　if（a 《 0） //Pitch值小于0，偏右
　　{
　　PFout（10） = 0;
　　PFout（9） = 1;
　　PEout（13） = 1;
　　PEout（14） = 1;
　　printf（“右倾！rn”）;
　　}
　　}
　　else if（fabs（b） 》 fabs（a） && fabs（b） 》 2） //Roll值大于Pitch值（控制前后）
　　{
　　if（b 》 0） //Roll值大于0，低头
　　{
　　PEout（13） = 0;
　　PFout（9） = 1;
　　PFout（10） = 1;
　　PEout（14） = 1;
　　printf（“低头！rn”）;
　　}
　　if（b 《 0） //Roll值小于0，抬头
　　{
　　PEout（14） = 0;
　　PFout（9） = 1;
　　PFout（10） = 1;
　　PEout（13） = 1;
　　printf（“抬头！rn”）;
　　}
　　}
　　else //不属于以上的情况，就是平衡状态
　　{
　　PFout（9） = 1;
　　PFout（10） = 1;
　　PEout（13） = 1;
　　PEout（14） = 1;
　　printf（“平衡状态！rn”）;
　　}
　　}
　　void FM_Control（short x，short y） //判断Ax，Ay的值，从而判别陀螺仪往哪个方向加速，控制蜂鸣器的响停
　　{
　　if（abs（x） 》 2000） //如果某次Ax的值大于2000
　　{
　　flag1 = 0 ; //x轴的标志位置0
　　}
　　if（flag1 == 0） //紧接判断下次读取Ax的值
　　{
　　if（2000 - abs（x） 》 1000 ） //连续两次的Ax值的差大于1000（突然减速）
　　{
　　TIM_Init（85）; //控制蜂鸣器音量（0-99），数值越大音量越低
　　flag1 = 1; //x轴的标志位置1
　　}
　　}
　　if（abs（y） 》 2000） //如果某次Ay的值大于2000
　　{
　　flag2 = 0 ; //y轴的标志位置0
　　}
　　if（flag2 == 0） //紧接判断下次读取Ay的值
　　{
　　if（2000 - abs（y） 》 1000 ） //连续两次的Ay值的差大于1000（突然减速）
　　{
　　TIM_Init（85）; //控制蜂鸣器音量（0-99），数值越大音量越低
　　flag2 = 1; //y轴的标志位置1
　　}
　　}
　　}
　　uart.h部分
　　#ifndef __UART_H_
　　#define __UART_H_
　　#include 《stm32f4xx.h》
　　#include “sys.h”
　　#include 《stdio.h》
　　extern char USART1_ReciveArry［50］;
　　extern char Recive_flag;
　　void USART1_Init（void）;
　　#endif
　　uart.c部分
　　#include “uart.h”
　　//重定向 c 库函数 printf 到串口，重定向后可使用 printf 函数 记得勾选 USE MiroLib
　　int fputc（int ch， FILE *f）
　　{
　　/* 发送一个字节数据到串口 */
　　USART_SendData（USART1， （uint8_t） ch）; //程序开始时，会发送一次数据，ch是系统分配的（可能是0），串口会显示大概两个空格的内容
　　/* 等待发送完毕 */
　　while （USART_GetFlagStatus（USART1， USART_FLAG_TXE） == RESET）;
　　return （ch）;
　　}
　　void USART1_Init（void）
　　{
　　GPIO_InitTypeDef GPIOInit_Struct;
　　USART_InitTypeDef USARTInit_Struct;
　　NVIC_InitTypeDef UARTNVIC_Struct;
　　//1、使能时钟
　　RCC_APB2PeriphClockCmd（RCC_APB2Periph_USART1， ENABLE）;
　　//2、初始化对应的IO引脚复用为USART1功能
　　RCC_AHB1PeriphClockCmd（RCC_AHB1Periph_GPIOA，ENABLE）;
　　GPIOInit_Struct.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10;
　　GPIOInit_Struct.GPIO_Mode = GPIO_Mode_AF;//复用模式 需要全参数设置 输入和模拟模式不需要设置 输出类型和引脚速度
　　GPIOInit_Struct.GPIO_Speed = GPIO_Fast_Speed;//快速
　　GPIOInit_Struct.GPIO_OType = GPIO_OType_PP;//推挽输出
　　GPIOInit_Struct.GPIO_PuPd = GPIO_PuPd_UP;//上拉
　　GPIO_Init（GPIOA，&GPIOInit_Struct）;
　　//将PA9 PA10复用为USART1功能
　　GPIO_PinAFConfig（GPIOA， GPIO_PinSource9， GPIO_AF_USART1）;
　　GPIO_PinAFConfig（GPIOA， GPIO_PinSource10， GPIO_AF_USART1）;
　　//3、USART1初始化
　　USARTInit_Struct.USART_BaudRate = 115200;
　　USARTInit_Struct.USART_WordLength = USART_WordLength_8b;//8bit数据位
　　USARTInit_Struct.USART_Parity = USART_Parity_No;//无校验
　　USARTInit_Struct.USART_StopBits = USART_StopBits_1;//1bit停止位
　　USARTInit_Struct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//收发模式
　　USARTInit_Struct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件控制流
　　USART_Init（USART1，&USARTInit_Struct）;
　　//补充接收中断的开启 让中断帮我们去监测串口1接收标志位
　　USART_ITConfig（USART1，USART_IT_RXNE，ENABLE）;
　　UARTNVIC_Struct.NVIC_IRQChannel = USART1_IRQn ;// 37 stm32f4xx.h
　　UARTNVIC_Struct.NVIC_IRQChannelPreemptionPriority = 0;
　　UARTNVIC_Struct.NVIC_IRQChannelSubPriority = 0;
　　UARTNVIC_Struct.NVIC_IRQChannelCmd = ENABLE;
　　NVIC_Init（&UARTNVIC_Struct）;
　　//4、开启串口
　　USART_Cmd（USART1，ENABLE）;
　　}
　　

TIM.h部分
　　#ifndef __TIM_H_
　　#define __TIM_H_
　　#include 《stm32f4xx.h》
　　#include “sys.h”
　　#include “systick.h”
　　void TIM_Init（int FM）;
　　#endif
　　TIM.c部分
　　#include “tim.h”
　　int sum = 0;
　　void TIM_Init（int FM）
　　{
　　TIM_TimeBaseInitTypeDef TIMInit_struct;
　　NVIC_InitTypeDef TIMNVIC_Struct;
　　//0、使能TIM2时钟
　　RCC_APB1PeriphClockCmd（RCC_APB1Periph_TIM4，ENABLE）;
　　RCC_APB1PeriphClockCmd（RCC_APB1Periph_TIM5，ENABLE）;
　　//1、初始化定时器2模块
　　TIMInit_struct.TIM_Prescaler = 840-1; //84Mhz/840 = 100000Hz 0.01ms/脉冲
　　TIMInit_struct.TIM_Period = FM; //定时1s
　　TIMInit_struct.TIM_CounterMode = TIM_CounterMode_Up; //递增模式
　　TIMInit_struct.TIM_ClockDivision = TIM_CKD_DIV1; //不分频
　　TIM_TimeBaseInit（TIM4，&TIMInit_struct）;
　　TIMInit_struct.TIM_Period = 100-FM; //定时1s
　　TIM_TimeBaseInit（TIM5，&TIMInit_struct）;
　　//2、开启定时器2的更新中断---确保定时一到能够通过中断机制报告给CPU
　　//让CPU快速执行对应的功能
　　TIM_ITConfig（TIM4，TIM_IT_Update，ENABLE）;
　　TIM_ITConfig（TIM5，TIM_IT_Update，ENABLE）;
　　//3、NVIC中断管理
　　TIMNVIC_Struct.NVIC_IRQChannel = TIM4_IRQn;//stm32f4xx.h
　　TIMNVIC_Struct.NVIC_IRQChannelPreemptionPriority = 1;
　　TIMNVIC_Struct.NVIC_IRQChannelSubPriority = 0;
　　TIMNVIC_Struct.NVIC_IRQChannelCmd = ENABLE;
　　NVIC_Init（&TIMNVIC_Struct）;
　　TIMNVIC_Struct.NVIC_IRQChannel = TIM5_IRQn;//stm32f4xx.h
　　NVIC_Init（&TIMNVIC_Struct）;
　　//4、开启对应定时器的计数器----启动定时器
　　TIM_Cmd（TIM4，ENABLE）;
　　TIM_Cmd（TIM5，ENABLE）;
　　delay_ms（100）;
　　TIM_Cmd（TIM4，DISABLE）;
　　TIM_Cmd（TIM5，DISABLE）;
　　}
　　void TIM4_IRQHandler（void）
　　{
　　//再次对相应的标志位进行判断
　　if（TIM_GetITStatus（TIM4，TIM_IT_Update） == 1）
　　{
　　PFout（8） = 1;
　　//清除指定的中断标志位 Update
　　TIM_ClearITPendingBit（TIM4，TIM_IT_Update）;
　　}
　　}
　　void TIM5_IRQHandler（void）
　　{
　　//再次对相应的标志位进行判断
　　if（TIM_GetITStatus（TIM5，TIM_IT_Update） == 1）
　　{
　　PFout（8） = 0;
　　//清除指定的中断标志位 Update
　　TIM_ClearITPendingBit（TIM5，TIM_IT_Update）;
　　}
　　}
　　systick.h部分（精准延时）
　　#ifndef __SYSTICK_H_
　　#define __SYSTICK_H_
　　//头文件
　　#include “stm32f4xx.h”
　　//函数声明
　　void Systick_Init（void）;
　　void delay_us（u32 nus）;
　　void delay_ms（u32 nms）;
　　void delay_s（u32 ns）;
　　#endif
　　systick.c部分（精准延时）
　　#include “systick.h”
　　u8 my_us = 0;
　　u16 my_ms = 0;
　　//初始化滴答定时器
　　void Systick_Init（void）
　　{
　　//得到的Systick时钟 21MHZ
　　SysTick_CLKSourceConfig（SysTick_CLKSource_HCLK_Div8）;
　　my_us = 21; //21
　　my_ms = 21000;
　　}
　　//微秒延时，nms最大值：798.915
　　void delay_us（u32 nus）
　　{
　　u32 temp = 0;
　　//往自动重装载除值寄存器写入延时nus SysTick-》LOAD最大值0xFFFFFF
　　SysTick-》LOAD = nus*my_us;
　　SysTick-》VAL = 0x00;
　　SysTick-》CTRL |= SysTick_CTRL_ENABLE_Msk; //开启计数
　　do
　　{
　　//读控制寄存器
　　temp = SysTick-》CTRL;
　　}while（！（temp & （1《《16）））;
　　SysTick-》CTRL &= ~SysTick_CTRL_ENABLE_Msk; //关闭计数
　　SysTick-》VAL = 0x00;
　　}
　　//毫秒延时，nus最大值，nus最大值798915
　　void delay_ms（u32 nms）
　　{
　　u32 temp = 0;
　　//往自动重装载除值寄存器写入延时nus SysTick-》LOAD最大值0xFFFFFF
　　SysTick-》LOAD = nms*my_ms;
　　SysTick-》VAL = 0x00;
　　SysTick-》CTRL |= SysTick_CTRL_ENABLE_Msk; //开启计数
　　do
　　{
　　//读控制寄存器
　　temp = SysTick-》CTRL;
　　}while（！（temp & （1《《16）））;
　　SysTick-》CTRL &= ~SysTick_CTRL_ENABLE_Msk; //关闭计数
　　SysTick-》VAL = 0x00;
　　}
　　//秒延时
　　void delay_s（u32 ns）
　　{
　　for（; ns》0; ns--）
　　{
　　delay_ms（500）;
　　delay_ms（500）;
　　}
　　}
　　IIC.h部分
　　#ifndef __IIC_H_
　　#define __IIC_H_
　　#include 《stm32f4xx.h》
　　#include “sys.h”
　　#include “systick.h”
　　#define SDA_W PBout（9）
　　#define SDA_R PBin（9）
　　#define SCL PBout（8） //SCL固定由32控制 SCL一直为输出模式
　　void IIC_GPIOInit（void）;
　　void IIC_SDAModeCH（GPIOMode_TypeDef SelectMode）;
　　void IIC_Start（void）;
　　void IIC_WriteByte（unsigned char Data）;
　　unsigned char IIC_ReadByte（void）;
　　void IIC_Stop（void）;
　　char IIC_ReadAck（void）;
　　void IIC_WriteAck（char Ack）;
　　#endif
　　IIC.c部分
　　#include “iic.h”
　　//IIC用到引脚的初始化 这个初始化必须在主函数调用一次即可
　　void IIC_GPIOInit（void）
　　{
　　//对PB8、PB9一起先初始化一次
　　GPIO_InitTypeDef IIC;
　　//1、先开启对应用到的模块时钟节拍
　　RCC_AHB1PeriphClockCmd（RCC_AHB1Periph_GPIOB，ENABLE）;
　　//2、可以初始化配置GPIO F组的8、9号引脚
　　IIC.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_8;
　　IIC.GPIO_Mode = GPIO_Mode_OUT; //输出模式
　　IIC.GPIO_Speed = GPIO_Fast_Speed; //快速点灯和引脚速度无关
　　IIC.GPIO_OType = GPIO_OType_PP; //推挽输出
　　IIC.GPIO_PuPd = GPIO_PuPd_UP; //内部上拉
　　GPIO_Init（GPIOB，&IIC）;
　　SCL = 1;
　　SDA_W = 1;
　　}
　　//随时改变SDA ---PB9的模式
　　void IIC_SDAModeCH（GPIOMode_TypeDef SelectMode）
　　{
　　GPIO_InitTypeDef IIC;
　　//2、可以初始化配置GPIO F组的9号引脚
　　IIC.GPIO_Pin = GPIO_Pin_9;
　　IIC.GPIO_Mode = SelectMode; //输出模式
　　IIC.GPIO_Speed = GPIO_Fast_Speed; //快速点灯和引脚速度无关
　　IIC.GPIO_OType = GPIO_OType_PP; //推挽输出
　　IIC.GPIO_PuPd = GPIO_PuPd_UP; //内部上拉
　　GPIO_Init（GPIOB，&IIC）;
　　}
　　/*
　　起始信号函数
　　*/
　　void IIC_Start（void）
　　{
　　//先将SDA改为输出
　　IIC_SDAModeCH（GPIO_Mode_OUT）;
　　SDA_W = 1;
　　SCL = 1; //保证开始前IIC处于空闲状态
　　delay_us（30）;
　　SDA_W = 0; //SDA先拉低
　　delay_us（5）;
　　SCL = 0; //SCL再拉低
　　}
　　//主机给从机写一个字节数据函数
　　void IIC_WriteByte（unsigned char Data）
　　{
　　int i;
　　IIC_SDAModeCH（GPIO_Mode_OUT）; //先将SDA改为输出
　　SCL = 0;
　　for（i=0;i《8;i++）
　　{
　　delay_us（2）;
　　SDA_W = （Data》》（7-i））&0x01; //高位先发
　　delay_us（3）;
　　SCL = 1;
　　delay_us（5）; //给接收方接收的时间
　　SCL = 0;
　　}
　　}
　　//主机从从机内读取一个字节数据函数 返回值为读取的8bit数据结果
　　unsigned char IIC_ReadByte（void）
　　{
　　int i;
　　unsigned char Data=0; //存方从从机读取的数据的容器
　　IIC_SDAModeCH（GPIO_Mode_IN）; //先将SDA改为输入
　　SCL = 0;
　　for（i=0;i《8;i++）
　　{
　　delay_us（5）; //主机正在等从机改变SDA
　　SCL = 1;
　　delay_us（2）; //主机作为接收方在SCL高电平期间收
　　if（SDA_R）
　　Data |= （0x01《《（7-i））; //高位先收
　　delay_us（3）;
　　SCL = 0;
　　}
　　return Data;
　　}
　　//主机发送的停止信号
　　void IIC_Stop（void）
　　{
　　IIC_SDAModeCH（GPIO_Mode_OUT）; //先将SDA改为输出
　　SCL = 0;
　　SDA_W = 0;
　　delay_us（5）;
　　SCL = 1;
　　delay_us（5）;
　　SDA_W = 1; //SDA拉高
　　}
　　//主机读取从机发送的应答信号
　　char IIC_ReadAck（void）
　　{
　　IIC_SDAModeCH（GPIO_Mode_IN）; //先将SDA改为输入
　　char ACK = 1;
　　SCL = 0;
　　delay_us（5）; //主机正在等从机改变SDA
　　SCL = 1;
　　delay_us（2）; //主机作为接收方在SCL高电平期间收
　　if（SDA_R）
　　ACK = 1;
　　else
　　ACK = 0;
　　delay_us（3）;
　　SCL = 0;
　　return ACK;
　　}
　　//主机作为接收方 读取完从机的数据后 要发送应答信号给从机 你可以选择发送有应答还是无应答
　　void IIC_WriteAck（char Ack）
　　{
　　IIC_SDAModeCH（GPIO_Mode_OUT）; //先将SDA改为输出
　　SCL = 0;
　　delay_us（2）;
　　SDA_W = Ack;
　　delay_us（3）;
　　SCL = 1;
　　delay_us（5）;
　　SCL = 0; //SCL再拉高
　　}
　　

inv_mpu.h部分
　　/*
　　$License：
　　Copyright （C） 2011-2012 InvenSense Corporation， All Rights Reserved.
　　See included License.txt for License information.
　　$
　　*/
　　/**
　　* @addtogroup DRIVERS Sensor Driver Layer
　　* @brief Hardware drivers to communicate with sensors via I2C.
　　*
　　* @{
　　* @file inv_mpu.h
　　* @brief An I2C-based driver for Invensense gyroscopes.
　　* @details This driver currently works for the following devices：
　　* MPU6050
　　* MPU6500
　　* MPU9150 （or MPU6050 w/ AK8975 on the auxiliary bus）
　　* MPU9250 （or MPU6500 w/ AK8963 on the auxiliary bus）
　　*/
　　#ifndef _INV_MPU_H_
　　#define _INV_MPU_H_
　　#include “stm32f4xx.h”
　　//定义输出速度
　　#define DEFAULT_MPU_HZ （100） //100Hz
　　#define INV_X_GYRO （0x40）
　　#define INV_Y_GYRO （0x20）
　　#define INV_Z_GYRO （0x10）
　　#define INV_XYZ_GYRO （INV_X_GYRO | INV_Y_GYRO | INV_Z_GYRO）
　　#define INV_XYZ_ACCEL （0x08）
　　#define INV_XYZ_COMPASS （0x01）
　　//移植官方MSP430 DMP驱动过来
　　struct int_param_s {
　　//#if defined EMPL_TARGET_MSP430 || defined MOTION_DRIVER_TARGET_MSP430
　　void （*cb）（void）;
　　unsigned short pin;
　　unsigned char lp_exit;
　　unsigned char active_low;
　　//#elif defined EMPL_TARGET_UC3L0
　　// unsigned long pin;
　　// void （*cb）（volatile void*）;
　　// void *arg;
　　//#endif
　　};
　　#define MPU_INT_STATUS_DATA_READY （0x0001）
　　#define MPU_INT_STATUS_DMP （0x0002）
　　#define MPU_INT_STATUS_PLL_READY （0x0004）
　　#define MPU_INT_STATUS_I2C_MST （0x0008）
　　#define MPU_INT_STATUS_FIFO_OVERFLOW （0x0010）
　　#define MPU_INT_STATUS_ZMOT （0x0020）
　　#define MPU_INT_STATUS_MOT （0x0040）
　　#define MPU_INT_STATUS_FREE_FALL （0x0080）
　　#define MPU_INT_STATUS_DMP_0 （0x0100）
　　#define MPU_INT_STATUS_DMP_1 （0x0200）
　　#define MPU_INT_STATUS_DMP_2 （0x0400）
　　#define MPU_INT_STATUS_DMP_3 （0x0800）
　　#define MPU_INT_STATUS_DMP_4 （0x1000）
　　#define MPU_INT_STATUS_DMP_5 （0x2000）
　　/* Set up APIs */
　　int mpu_init（void）;
　　int mpu_init_slave（void）;
　　int mpu_set_bypass（unsigned char bypass_on）;
　　/* Configuration APIs */
　　int mpu_lp_accel_mode（unsigned char rate）;
　　int mpu_lp_motion_interrupt（unsigned short thresh， unsigned char time，
　　unsigned char lpa_freq）;
　　int mpu_set_int_level（unsigned char active_low）;
　　int mpu_set_int_latched（unsigned char enable）;
　　int mpu_set_dmp_state（unsigned char enable）;
　　int mpu_get_dmp_state（unsigned char *enabled）;
　　int mpu_get_lpf（unsigned short *lpf）;
　　int mpu_set_lpf（unsigned short lpf）;
　　int mpu_get_gyro_fsr（unsigned short *fsr）;
　　int mpu_set_gyro_fsr（unsigned short fsr）;
　　int mpu_get_accel_fsr（unsigned char *fsr）;
　　int mpu_set_accel_fsr（unsigned char fsr）;
　　int mpu_get_compass_fsr（unsigned short *fsr）;
　　int mpu_get_gyro_sens（float *sens）;
　　int mpu_get_accel_sens（unsigned short *sens）;
　　int mpu_get_sample_rate（unsigned short *rate）;
　　int mpu_set_sample_rate（unsigned short rate）;
　　int mpu_get_compass_sample_rate（unsigned short *rate）;
　　int mpu_set_compass_sample_rate（unsigned short rate）;
　　int mpu_get_fifo_config（unsigned char *sensors）;
　　int mpu_configure_fifo（unsigned char sensors）;
　　int mpu_get_power_state（unsigned char *power_on）;
　　int mpu_set_sensors（unsigned char sensors）;
　　int mpu_set_accel_bias（const long *accel_bias）;
　　/* Data getter/setter APIs */
　　int mpu_get_gyro_reg（short *data， unsigned long *timestamp）;
　　int mpu_get_accel_reg（short *data， unsigned long *timestamp）;
　　int mpu_get_compass_reg（short *data， unsigned long *timestamp）;
　　int mpu_get_temperature（long *data， unsigned long *timestamp）;
　　int mpu_get_int_status（short *status）;
　　int mpu_read_fifo（short *gyro， short *accel， unsigned long *timestamp，
　　unsigned char *sensors， unsigned char *more）;
　　int mpu_read_fifo_stream（unsigned short length， unsigned char *data，
　　unsigned char *more）;
　　int mpu_reset_fifo（void）;
　　int mpu_write_mem（unsigned short mem_addr， unsigned short length，
　　unsigned char *data）;
　　int mpu_read_mem（unsigned short mem_addr， unsigned short length，
　　unsigned char *data）;
　　int mpu_load_firmware（unsigned short length， const unsigned char *firmware，
　　unsigned short start_addr， unsigned short sample_rate）;
　　int mpu_reg_dump（void）;
　　int mpu_read_reg（unsigned char reg， unsigned char *data）;
　　int mpu_run_self_test（long *gyro， long *accel）;
　　int mpu_register_tap_cb（void （*func）（unsigned char， unsigned char））;
　　//自行添加的一些函数
　　void mget_ms（unsigned long *time）;
　　unsigned short inv_row_2_scale（const signed char *row）;
　　unsigned short inv_orientation_matrix_to_scalar（const signed char *mtx）;
　　u8 run_self_test（void）;
　　u8 mpu_dmp_init（void）;
　　u8 mpu_dmp_get_data（float *pitch，float *roll，float *yaw）;
　　#endif /* #ifndef _INV_MPU_H_ */
　　mpu6050.h部分
　　#ifndef __MPU6050_H_
　　#define __MPU6050_H_
　　#include 《stm32f4xx.h》
　　#include “iic.h”
　　//#define MPU_ACCEL_OFFS_REG 0X06 //accel_offs寄存器，可读取版本号，寄存器手册未提到
　　//#define MPU_PROD_ID_REG 0X0C //prod id寄存器，在寄存器手册未提到
　　#define MPU_SELF_TESTX_REG 0X0D //自检寄存器X
　　#define MPU_SELF_TESTY_REG 0X0E //自检寄存器Y
　　#define MPU_SELF_TESTZ_REG 0X0F //自检寄存器Z
　　#define MPU_SELF_TESTA_REG 0X10 //自检寄存器A
　　#define MPU_SAMPLE_RATE_REG 0X19 //采样频率分频器
　　#define MPU_CFG_REG 0X1A //配置寄存器
　　#define MPU_GYRO_CFG_REG 0X1B //陀螺仪配置寄存器
　　#define MPU_ACCEL_CFG_REG 0X1C //加速度计配置寄存器
　　#define MPU_MOTION_DET_REG 0X1F //运动检测阀值设置寄存器
　　#define MPU_FIFO_EN_REG 0X23 //FIFO使能寄存器
　　#define MPU_I2CMST_CTRL_REG 0X24 //IIC主机控制寄存器
　　#define MPU_I2CSLV0_ADDR_REG 0X25 //IIC从机0器件地址寄存器
　　#define MPU_I2CSLV0_REG 0X26 //IIC从机0数据地址寄存器
　　#define MPU_I2CSLV0_CTRL_REG 0X27 //IIC从机0控制寄存器
　　#define MPU_I2CSLV1_ADDR_REG 0X28 //IIC从机1器件地址寄存器
　　#define MPU_I2CSLV1_REG 0X29 //IIC从机1数据地址寄存器
　　#define MPU_I2CSLV1_CTRL_REG 0X2A //IIC从机1控制寄存器
　　#define MPU_I2CSLV2_ADDR_REG 0X2B //IIC从机2器件地址寄存器
　　#define MPU_I2CSLV2_REG 0X2C //IIC从机2数据地址寄存器
　　#define MPU_I2CSLV2_CTRL_REG 0X2D //IIC从机2控制寄存器
　　#define MPU_I2CSLV3_ADDR_REG 0X2E //IIC从机3器件地址寄存器
　　#define MPU_I2CSLV3_REG 0X2F //IIC从机3数据地址寄存器
　　#define MPU_I2CSLV3_CTRL_REG 0X30 //IIC从机3控制寄存器
　　#define MPU_I2CSLV4_ADDR_REG 0X31 //IIC从机4器件地址寄存器
　　#define MPU_I2CSLV4_REG 0X32 //IIC从机4数据地址寄存器
　　#define MPU_I2CSLV4_DO_REG 0X33 //IIC从机4写数据寄存器
　　#define MPU_I2CSLV4_CTRL_REG 0X34 //IIC从机4控制寄存器
　　#define MPU_I2CSLV4_DI_REG 0X35 //IIC从机4读数据寄存器
　　#define MPU_I2CMST_STA_REG 0X36 //IIC主机状态寄存器
　　#define MPU_INTBP_CFG_REG 0X37 //中断/旁路设置寄存器
　　#define MPU_INT_EN_REG 0X38 //中断使能寄存器
　　#define MPU_INT_STA_REG 0X3A //中断状态寄存器
　　#define MPU_ACCEL_XOUTH_REG 0X3B //加速度值，X轴高8位寄存器
　　#define MPU_ACCEL_XOUTL_REG 0X3C //加速度值，X轴低8位寄存器
　　#define MPU_ACCEL_YOUTH_REG 0X3D //加速度值，Y轴高8位寄存器
　　#define MPU_ACCEL_YOUTL_REG 0X3E //加速度值，Y轴低8位寄存器
　　#define MPU_ACCEL_ZOUTH_REG 0X3F //加速度值，Z轴高8位寄存器
　　#define MPU_ACCEL_ZOUTL_REG 0X40 //加速度值，Z轴低8位寄存器
　　#define MPU_TEMP_OUTH_REG 0X41 //温度值高八位寄存器
　　#define MPU_TEMP_OUTL_REG 0X42 //温度值低8位寄存器
　　#define MPU_GYRO_XOUTH_REG 0X43 //陀螺仪值，X轴高8位寄存器
　　#define MPU_GYRO_XOUTL_REG 0X44 //陀螺仪值，X轴低8位寄存器
　　#define MPU_GYRO_YOUTH_REG 0X45 //陀螺仪值，Y轴高8位寄存器
　　#define MPU_GYRO_YOUTL_REG 0X46 //陀螺仪值，Y轴低8位寄存器
　　#define MPU_GYRO_ZOUTH_REG 0X47 //陀螺仪值，Z轴高8位寄存器
　　#define MPU_GYRO_ZOUTL_REG 0X48 //陀螺仪值，Z轴低8位寄存器
　　#define MPU_I2CSLV0_DO_REG 0X63 //IIC从机0数据寄存器
　　#define MPU_I2CSLV1_DO_REG 0X64 //IIC从机1数据寄存器
　　#define MPU_I2CSLV2_DO_REG 0X65 //IIC从机2数据寄存器
　　#define MPU_I2CSLV3_DO_REG 0X66 //IIC从机3数据寄存器
　　#define MPU_I2CMST_DELAY_REG 0X67 //IIC主机延时管理寄存器
　　#define MPU_SIGPATH_RST_REG 0X68 //信号通道复位寄存器
　　#define MPU_MDETECT_CTRL_REG 0X69 //运动检测控制寄存器
　　#define MPU_USER_CTRL_REG 0X6A //用户控制寄存器
　　#define MPU_PWR_MGMT1_REG 0X6B //电源管理寄存器1
　　#define MPU_PWR_MGMT2_REG 0X6C //电源管理寄存器2
　　#define MPU_FIFO_CNTH_REG 0X72 //FIFO计数寄存器高八位
　　#define MPU_FIFO_CNTL_REG 0X73 //FIFO计数寄存器低八位
　　#define MPU_FIFO_RW_REG 0X74 //FIFO读写寄存器
　　#define MPU_DEVICE_ID_REG 0X75 //器件ID寄存器
　　//函数声明
　　u8 MPU_Init（void）;
　　short MPU_Get_Temperature（void）;
　　u8 MPU_Get_Gyroscope（short *gx，short *gy，short *gz）;
　　u8 MPU_Get_Accelerometer（short *ax，short *ay，short *az）;
　　u8 MPU6050_Write_Len（u8 addr，u8 reg，u8 len，u8 *buf）;
　　u8 MPU6050_Read_Len（u8 addr，u8 reg，u8 len，u8 *buf）;
　　//使用串口1 根据匿名四轴上位机软件的通信协议 发送对应MPU6050的数据上去显示
　　void mpu6050_send_data（short aacx，short aacy，short aacz，short gyrox，short gyroy，short gyroz）;
　　void usart1_report_imu（short aacx，short aacy，short aacz，short gyrox，short gyroy，short gyroz，short roll，short pitch，short yaw）;
　　#endif
　　

mpu6050.c部分
　　#include “mpu6050.h”
　　#define MPU_AddrW 0xD0 //0x68 01101 000（w/r）
　　#define MPU_AddrR 0xD1 //
　　//以下部分代参考了正点原子
　　int MPU6050_WriteByte（u8 Addr ，u8 Data）
　　{
　　IIC_Start（）;
　　IIC_WriteByte（MPU_AddrW）;//写入期间地址 确定操作哪个IIC从设备
　　if（1 == IIC_ReadAck（））
　　{
　　IIC_Stop（）;
　　return -1;
　　}
　　IIC_WriteByte（Addr）;//写入你要存在AT24C02哪个字节空间
　　if（1 == IIC_ReadAck（））
　　{
　　IIC_Stop（）;
　　return -2;
　　}
　　IIC_WriteByte（Data）;
　　if（1 == IIC_ReadAck（））
　　{
　　IIC_Stop（）;
　　return -3;
　　}
　　IIC_Stop（）;
　　return 0;
　　}
　　u8 MPU6050_ReadByte（u8 Addr）
　　{
　　u8 Data=0;
　　IIC_Start（）;
　　IIC_WriteByte（MPU_AddrW）;
　　if（1 == IIC_ReadAck（））
　　{
　　IIC_Stop（）;
　　return -1;
　　}
　　IIC_WriteByte（Addr）;
　　if（1 == IIC_ReadAck（））
　　{
　　IIC_Stop（）;
　　return -2;
　　}
　　//重新开始
　　IIC_Start（）;
　　IIC_WriteByte（MPU_AddrR）;//切换为发送读模式器件地址
　　if（1 == IIC_ReadAck（））
　　{
　　IIC_Stop（）;
　　return -3;
　　}
　　Data = IIC_ReadByte（）;
　　IIC_WriteAck（1）;//主机发送无应答信号给从机 读取完一个即可
　　IIC_Stop（）;
　　return Data;
　　}
　　//IIC连续读
　　//addr：器件地址
　　//reg：要读取的寄存器地址
　　//len：要读取的长度
　　//buf：读取到的数据存储区
　　//返回值：0，正常
　　// 其他，错误代码
　　u8 MPU6050_Read_Len（u8 addr，u8 reg，u8 len，u8 *buf）
　　{
　　IIC_Start（）;
　　IIC_WriteByte（（addr《《1）|0x00）;//发送器件地址+写命令
　　if（IIC_ReadAck（）） //等待应答
　　{
　　IIC_Stop（）;
　　return 1;
　　}
　　IIC_WriteByte（reg）; //写寄存器地址
　　IIC_ReadAck（）; //等待应答
　　IIC_Start（）;
　　IIC_WriteByte（（addr《《1）|0x01）;//发送器件地址+读命令
　　IIC_ReadAck（）; //等待应答
　　while（len）
　　{
　　*buf=IIC_ReadByte（）;
　　if（len==1）
　　{
　　IIC_WriteAck（1）;//读最后一个字节数据，发送nACK
　　break;
　　}
　　IIC_WriteAck（0）;//Ack
　　len--;
　　buf++;
　　}
　　IIC_Stop（）; //产生一个停止条件
　　return 0;
　　}
　　//IIC连续写
　　//addr：器件地址
　　//reg：寄存器地址
　　//len：写入长度
　　//buf：数据区
　　//返回值：0，正常
　　// 其他，错误代码
　　u8 MPU6050_Write_Len（u8 addr，u8 reg，u8 len，u8 *buf）
　　{
　　u8 i;
　　IIC_Start（）;
　　IIC_WriteByte（（addr《《1）|0）;//发送器件地址+写命令
　　if（IIC_ReadAck（）） //等待应答
　　{
　　IIC_Stop（）;
　　return 1;
　　}
　　IIC_WriteByte（reg）; //写寄存器地址
　　IIC_ReadAck（）; //等待应答
　　for（i=0;i《len;i++）
　　{
　　IIC_WriteByte（buf［i］）; //发送数据
　　if（IIC_ReadAck（）） //等待ACK
　　{
　　IIC_Stop（）;
　　return 1;
　　}
　　}
　　IIC_Stop（）;
　　return 0;
　　}
　　//设置MPU6050陀螺仪传感器满量程范围
　　//fsr:0，±250dps;1，±500dps;2，±1000dps;3，±2000dps
　　//返回值：0，设置成功
　　// 其他，设置失败
　　u8 MPU_Set_Gyro_Fsr（u8 fsr）
　　{
　　return MPU6050_WriteByte（MPU_GYRO_CFG_REG，fsr《《3）;//设置陀螺仪满量程范围
　　}
　　//设置MPU6050加速度传感器满量程范围
　　//fsr:0，±2g;1，±4g;2，±8g;3，±16g
　　//返回值：0，设置成功
　　// 其他，设置失败
　　u8 MPU_Set_Accel_Fsr（u8 fsr）
　　{
　　return MPU6050_WriteByte（MPU_ACCEL_CFG_REG，fsr《《3）;//设置加速度传感器满量程范围
　　}
　　//设置MPU6050的数字低通滤波器
　　//lpf：数字低通滤波频率（Hz）
　　//返回值：0，设置成功
　　// 其他，设置失败
　　u8 MPU_Set_LPF（u16 lpf）
　　{
　　u8 data=0;
　　if（lpf》=188）data=1;
　　else if（lpf》=98）data=2;
　　else if（lpf》=42）data=3;
　　else if（lpf》=20）data=4;
　　else if（lpf》=10）data=5;
　　else data=6;
　　return MPU6050_WriteByte（MPU_CFG_REG，data）;//设置数字低通滤波器
　　}
　　//设置MPU6050的采样率（假定Fs=1KHz）
　　//rate:4~1000（Hz）
　　//返回值：0，设置成功
　　// 其他，设置失败
　　u8 MPU_Set_Rate（u16 rate）
　　{
　　u8 data;
　　if（rate》1000）rate=1000;
　　if（rate《4）rate=4;
　　data=1000/rate-1;
　　data=MPU6050_WriteByte（MPU_SAMPLE_RATE_REG，data）; //设置数字低通滤波器
　　return MPU_Set_LPF（rate/2）; //自动设置LPF为采样率的一半
　　}
　　//初始化MPU6050
　　//返回值：0，成功
　　// 其他，错误代码
　　u8 MPU_Init（void）
　　{
　　u8 res;
　　//IIC_Init（）;//初始化IIC总线
　　MPU6050_WriteByte（MPU_PWR_MGMT1_REG，0X80）; //复位MPU6050
　　delay_ms（100）;
　　MPU6050_WriteByte（MPU_PWR_MGMT1_REG，0X00）; //唤醒MPU6050
　　MPU_Set_Gyro_Fsr（3）; //陀螺仪传感器，±2000dps
　　MPU_Set_Accel_Fsr（0）; //加速度传感器，±2g
　　MPU_Set_Rate（50）; //设置采样率50Hz
　　MPU6050_WriteByte（MPU_INT_EN_REG，0X00）; //关闭所有中断
　　MPU6050_WriteByte（MPU_USER_CTRL_REG，0X00）; //I2C主模式关闭
　　MPU6050_WriteByte（MPU_FIFO_EN_REG，0X00）; //关闭FIFO
　　MPU6050_WriteByte（MPU_INTBP_CFG_REG，0X80）; //INT引脚低电平有效
　　res=MPU6050_ReadByte（MPU_DEVICE_ID_REG）;
　　if（res== 0x68）//器件ID正确 0x68 《《1 | w/r 011010 00 （w/r）
　　{
　　MPU6050_WriteByte（MPU_PWR_MGMT1_REG，0X01）; //设置CLKSEL，PLL X轴为参考
　　MPU6050_WriteByte（MPU_PWR_MGMT2_REG，0X00）; //加速度与陀螺仪都工作
　　MPU_Set_Rate（50）; //设置采样率为50Hz
　　}else return 1;
　　return 0;
　　}
　　//得到温度值
　　//返回值：温度值（扩大了100倍）
　　short MPU_Get_Temperature（void）
　　{
　　u8 buf［2］;
　　short raw;
　　float temp;
　　MPU6050_Read_Len（0x68，MPU_TEMP_OUTH_REG，2，buf）;
　　raw=（（u16）buf［0］《《8）|buf［1］;
　　temp=36.53+（（double）raw）/340;
　　return temp*100;
　　}
　　//得到陀螺仪值（原始值）
　　//gx，gy，gz：陀螺仪x，y，z轴的原始读数（带符号）
　　//返回值：0，成功
　　// 其他，错误代码
　　u8 MPU_Get_Gyroscope（short *gx，short *gy，short *gz）
　　{
　　u8 buf［6］，res;
　　res=MPU6050_Read_Len（0x68，MPU_GYRO_XOUTH_REG，6，buf）;
　　if（res==0）
　　{
　　*gx=（（u16）buf［0］《《8）|buf［1］;
　　*gy=（（u16）buf［2］《《8）|buf［3］;
　　*gz=（（u16）buf［4］《《8）|buf［5］;
　　}
　　return res;;
　　}
　　//得到加速度值（原始值）
　　//gx，gy，gz：陀螺仪x，y，z轴的原始读数（带符号）
　　//返回值：0，成功
　　// 其他，错误代码
　　u8 MPU_Get_Accelerometer（short *ax，short *ay，short *az）
　　{
　　u8 buf［6］，res;
　　res=MPU6050_Read_Len（0x68，MPU_ACCEL_XOUTH_REG，6，buf）;
　　if（res==0）
　　{
　　*ax=（（u16）buf［0］《《8）|buf［1］;
　　*ay=（（u16）buf［2］《《8）|buf［3］;
　　*az=（（u16）buf［4］《《8）|buf［5］;
　　}
　　return res;;
　　}
　　//串口1发送1个字符
　　//c：要发送的字符
　　void usart1_send_char（u8 c）
　　{
　　while（USART_GetFlagStatus（USART1，USART_FLAG_TC）==RESET）
　　{}
　　USART_SendData（USART1，c）;
　　}
　　//传送数据给匿名四轴上位机软件（V2.6版本）
　　//fun：功能字。 0XA0~0XAF
　　//data：数据缓存区，最多28字节！！
　　//len:data区有效数据个数
　　void usart1_niming_report（u8 fun，u8*data，u8 len）
　　{
　　u8 send_buf［32］;
　　u8 i;
　　if（len》28）return; //最多28字节数据
　　send_buf［len+3］=0; //校验数置零
　　send_buf［0］=0X88; //帧头
　　send_buf［1］=fun; //功能字
　　send_buf［2］=len; //数据长度
　　for（i=0;i《len;i++）send_buf［3+i］=data［i］; //复制数据
　　for（i=0;i《len+3;i++）send_buf［len+3］+=send_buf［i］; //计算校验和
　　for（i=0;i《len+4;i++）usart1_send_char（send_buf［i］）; //发送数据到串口1
　　}
　　//发送加速度传感器数据和陀螺仪数据
　　//aacx，aacy，aacz:x，y，z三个方向上面的加速度值
　　//gyrox，gyroy，gyroz:x，y，z三个方向上面的陀螺仪值
　　void mpu6050_send_data（short aacx，short aacy，short aacz，short gyrox，short gyroy，short gyroz）
　　{
　　u8 tbuf［12］;
　　tbuf［0］=（aacx》》8）&0XFF;
　　tbuf［1］=aacx&0XFF;
　　tbuf［2］=（aacy》》8）&0XFF;
　　tbuf［3］=aacy&0XFF;
　　tbuf［4］=（aacz》》8）&0XFF;
　　tbuf［5］=aacz&0XFF;
　　tbuf［6］=（gyrox》》8）&0XFF;
　　tbuf［7］=gyrox&0XFF;
　　tbuf［8］=（gyroy》》8）&0XFF;
　　tbuf［9］=gyroy&0XFF;
　　tbuf［10］=（gyroz》》8）&0XFF;
　　tbuf［11］=gyroz&0XFF;
　　usart1_niming_report（0XA1，tbuf，12）;//自定义帧，0XA1
　　}
　　//通过串口1上报结算后的姿态数据给电脑
　　//aacx，aacy，aacz:x，y，z三个方向上面的加速度值
　　//gyrox，gyroy，gyroz:x，y，z三个方向上面的陀螺仪值
　　//roll：横滚角。单位0.01度。 -18000 -》 18000 对应 -180.00 -》 180.00度
　　//pitch：俯仰角。单位 0.01度。-9000 - 9000 对应 -90.00 -》 90.00 度
　　//yaw：航向角。单位为0.1度 0 -》 3600 对应 0 -》 360.0度
　　void usart1_report_imu（short aacx，short aacy，short aacz，short gyrox，short gyroy，short gyroz，short roll，short pitch，short yaw）
　　{
　　u8 tbuf［28］;
　　u8 i;
　　for（i=0;i《28;i++）tbuf［i］=0;//清0
　　tbuf［0］=（aacx》》8）&0XFF;
　　tbuf［1］=aacx&0XFF;
　　tbuf［2］=（aacy》》8）&0XFF;
　　tbuf［3］=aacy&0XFF;
　　tbuf［4］=（aacz》》8）&0XFF;
　　tbuf［5］=aacz&0XFF;
　　tbuf［6］=（gyrox》》8）&0XFF;
　　tbuf［7］=gyrox&0XFF;
　　tbuf［8］=（gyroy》》8）&0XFF;
　　tbuf［9］=gyroy&0XFF;
　　tbuf［10］=（gyroz》》8）&0XFF;
　　tbuf［11］=gyroz&0XFF;
　　tbuf［18］=（roll》》8）&0XFF;
　　tbuf［19］=roll&0XFF;
　　tbuf［20］=（pitch》》8）&0XFF;
　　tbuf［21］=pitch&0XFF;
　　tbuf［22］=（yaw》》8）&0XFF;
　　tbuf［23］=yaw&0XFF;
　　usart1_niming_report（0XAF，tbuf，28）;//飞控显示帧，0XAF
　　}