设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机驱动MPU6050+ADXL345带详细注释的源程序
返回列表 发新帖
查看: 3759|回复: 0
收起左侧

51单片机驱动MPU6050+ADXL345带详细注释的源程序

[复制链接]
ID:375307 发表于 2018-7-20 08:50 | 显示全部楼层 |阅读模式
0.png
单片机源码：
  1. #include <STC15.H>   //引用STC15系列头文件，百度上搜索下载
  2. #include <INTRINS.H>
  3. #include <MATH.H>

  5. #define     I2C_SCL     P14      //时钟信号线
  6. #define     I2C_SDA     P15      //数据信号线

  8. #define PWR_MGMT_1      0x6B      //电源管理，典型值：0x00(正常启用)
  9. #define WHO_AM_I        0x75      //IIC地址寄存器(默认数值0x68，只读)
  10. #define SlaveAddress    0xD0      //IIC写入时的地址字节数据，+1为读取

  12. #define NOP1() nop_()
  13. #define NOP2() NOP1(),NOP1()

  15. #define MAIN_Fosc                   24000000L               //主时钟,不同的晶振频率可以直接修改
  16. #define serial_one_read_max         16                      //接收缓存区长度
  17. #define serial_one_baud_rate        115200L                 //波特率，波特率可以直接修改
  18. #define Timer1_Reload_Usart         (65536UL -(MAIN_Fosc / 4 / serial_one_baud_rate))       //Timer1重装值，定时器1产生波特率


  21. //****************************************
  22. // 定义MPU6050内部地址
  23. //****************************************
  24. #define SMPLRT_DIV      0x19    //陀螺仪采样率，典型值：0x07(125Hz)
  25. #define CONFIG          0x1A    //低通滤波频率，典型值：0x06(5Hz)
  26. #define GYRO_CONFIG     0x1B    //陀螺仪自检及测量范围，典型值：0x18(不自检，2000deg/s)
  27. #define ACCEL_CONFIG    0x1C    //加速计自检、测量范围及高通滤波频率，典型值：0x01(不自检，2G，5Hz)
  28. #define ACCEL_XOUT_H    0x3B
  29. #define ACCEL_XOUT_L    0x3C
  30. #define ACCEL_YOUT_H    0x3D
  31. #define ACCEL_YOUT_L    0x3E
  32. #define ACCEL_ZOUT_H    0x3F
  33. #define ACCEL_ZOUT_L    0x40
  34. #define TEMP_OUT_H      0x41
  35. #define TEMP_OUT_L      0x42
  36. #define GYRO_XOUT_H     0x43
  37. #define GYRO_XOUT_L     0x44   
  38. #define GYRO_YOUT_H     0x45
  39. #define GYRO_YOUT_L     0x46
  40. #define GYRO_ZOUT_H     0x47
  41. #define GYRO_ZOUT_L     0x48


  44. void Delay1000ms()      //延时函数1秒
  45. {
  46.     unsigned char i, j, k;

  48.     _nop_();
  49.     _nop_();
  50.     i = 85;
  51.     j = 12;
  52.     k = 155;
  53.     do
  54.     {
  55.         do
  56.         {
  57.             while (--k);
  58.         } while (--j);
  59.     } while (--i);
  60. }


  63. //========================================================================
  64. // 函数: void I2C_Start()
  65. // 描述: I2C起始信号.
  66. // 参数: none.
  67. // 返回: none.
  68. // 版本: V1.0, 2017-06-23
  69. //========================================================================
  70. void I2C_Start()
  71. {
  72.     I2C_SDA = 1;                    //拉高数据线
  73.     I2C_SCL = 1;                    //拉高时钟线
  74.     NOP2();                         //等待机器反应
  75.     I2C_SDA = 0;                    //产生下降沿
  76.     I2C_SCL = 0;                    //拉低时钟线
  77. }

  79. //========================================================================
  80. // 函数: void I2C_Stop()
  81. // 描述: I2C停止信号.
  82. // 参数: none.
  83. // 返回: none.
  84. // 版本: V1.0, 2017-06-23
  85. //========================================================================
  86. void I2C_Stop()
  87. {
  88.     I2C_SDA = 0;                    //拉低数据线
  89.     I2C_SCL = 1;                    //拉高时钟线
  90.     NOP2();                         //等待机器反应
  91.     I2C_SDA = 1;                    //产生上升沿
  92.     NOP1();                         //等待机器反应
  93. }

  95. //========================================================================
  96. // 函数: void I2C_SendACK(bit ack)
  97. // 描述: I2C发送应答信号.
  98. // 参数: ack (0:ACK 1:NAK).
  99. // 返回: none.
  100. // 版本: V1.0, 2017-06-23
  101. //========================================================================
  102. void I2C_SendACK(bit ack)
  103. {
  104.     I2C_SDA = ack;                  //写应答信号
  105.     I2C_SCL = 1;                    //拉高时钟线
  106.     NOP2();                                         //等待机器反应
  107.     I2C_SCL = 0;                    //拉低时钟线
  108.     NOP1();                                         //等待机器反应
  109. }

  111. //========================================================================
  112. // 函数: bit I2C_RecvACK()
  113. // 描述: I2C接收应答信号.
  114. // 参数: none.
  115. // 返回: 1：成功，0：失败.
  116. // 版本: V1.0, 2017-06-23
  117. //========================================================================
  118. bit I2C_RecvACK()
  119. {
  120.     I2C_SCL = 1;            //拉高时钟线
  121.     NOP2();                         //等待机器反应
  122.     CY = I2C_SDA;           //读应答信号
  123.     I2C_SCL = 0;            //拉低时钟线
  124.     return CY;
  125. }

  127. //========================================================================
  128. // 函数: void I2C_SendByte(u8 dat)
  129. // 描述: 向I2C总线发送一个字节数据.
  130. // 参数: dat：要发送的数据.
  131. // 返回: none.
  132. // 版本: V1.0, 2017-06-23
  133. //========================================================================
  134. void I2C_SendByte(unsigned char dat)
  135. {
  136.     unsigned char i;
  137.     for (i=0; i<8; i++)         //8位计数器
  138.     {
  139.         dat <<= 1;              //移出数据的最高位
  140.         I2C_SDA = CY;           //送数据口
  141.         I2C_SCL = 1;                //拉高时钟线
  142.         NOP2();                                 //等待机器反应
  143.         I2C_SCL = 0;                //拉低时钟线
  144.     }
  145.     I2C_RecvACK();
  146. }

  148. //========================================================================
  149. // 函数: unsigned char I2C_RecvByte()
  150. // 描述: 从I2C总线接收一个字节数据.
  151. // 参数: none.
  152. // 返回: 接收到的数据.
  153. // 版本: V1.0, 2017-06-23
  154. //========================================================================
  155. unsigned char I2C_RecvByte()
  156. {
  157.     unsigned char i;
  158.     unsigned char dat = 0;
  159.     I2C_SDA = 1;                    //使能内部上拉,准备读取数据,
  160.     for (i=0; i<8; i++)                       //8位计数器
  161.     {
  162.         dat <<= 1;
  163.         I2C_SCL = 1;                //拉高时钟线
  164.         NOP2();                                 //等待机器反应
  165.         dat |= I2C_SDA;             //读数据               
  166.         I2C_SCL = 0;                //拉低时钟线
  167.     }
  168.     return dat;
  169. }

  171. //========================================================================
  172. // 函数: void Single_WriteI2C(unsigned char REG_Address,unsigned char REG_data)
  173. // 描述: 向I2C设备写入一个字节数据.
  174. // 参数: REG_Address：地址.
  175. //           REG_data：要写入的数据.
  176. // 返回: none.
  177. // 版本: V1.0, 2017-06-23
  178. //========================================================================
  179. void Single_WriteI2C(unsigned char REG_Address,unsigned char REG_data)
  180. {
  181.     I2C_Start();                  //起始信号
  182.     I2C_SendByte(SlaveAddress);   //发送设备地址+写信号
  183.     I2C_SendByte(REG_Address);    //内部寄存器地址，
  184.     I2C_SendByte(REG_data);       //内部寄存器数据，
  185.     I2C_Stop();                   //发送停止信号
  186. }

  188. //========================================================================
  189. // 函数: unsigned char Single_ReadI2C(unsigned char REG_Address)
  190. // 描述: 从I2C设备读取一个字节数据.
  191. // 参数: REG_Address：地址.
  192. // 返回: 读取到的数据.
  193. // 版本: V1.0, 2017-06-23
  194. //========================================================================
  195. unsigned char Single_ReadI2C(unsigned char REG_Address)
  196. {
  197.     unsigned char REG_data;
  198.     I2C_Start();                   //起始信号
  199.     I2C_SendByte(SlaveAddress);    //发送设备地址+写信号
  200.     I2C_SendByte(REG_Address);     //发送存储单元地址，从0开始  
  201.     I2C_Start();                   //起始信号
  202.     I2C_SendByte(SlaveAddress+1);  //发送设备地址+读信号
  203.     REG_data=I2C_RecvByte();       //读出寄存器数据
  204.     I2C_SendACK(1);                //接收应答信号
  205.     I2C_Stop();                    //停止信号
  206.     return REG_data;
  207. }

  209. //========================================================================
  210. // 函数: void MPU6050_init()
  211. // 描述: 初始化MPU6050.
  212. // 参数: none.
  213. // 返回: none.
  214. // 版本: V1.0, 2017-06-23
  215. //========================================================================
  216. void MPU6050_Init()
  217. {
  218.     Single_WriteI2C(PWR_MGMT_1, 0x00);  //解除休眠状态
  219.     Single_WriteI2C(SMPLRT_DIV, 0x07);
  220.     Single_WriteI2C(CONFIG, 0x06);
  221.     Single_WriteI2C(GYRO_CONFIG, 0x18);
  222.     Single_WriteI2C(ACCEL_CONFIG, 0x01);
  223. }

  225. //========================================================================
  226. // 函数: int GetData(u8 REG_Address)
  227. // 描述: 读取数据并合成为int型数据.
  228. // 参数: REG_Address：地址.
  229. // 返回: 读取到的数据.
  230. // 版本: V1.0, 2017-06-23
  231. //========================================================================
  232. int GetData(unsigned char REG_Address)
  233. {
  234.     unsigned char H,L;
  235.     H = Single_ReadI2C(REG_Address);
  236.     L = Single_ReadI2C(REG_Address + 1);
  237.     return (H << 8) + L;   //合成数据
  238. }

  240. ////========================================================================
  241. //// 函数: int get_x_angle()
  242. //// 描述: 获取三轴角速度，三轴加速度
  243. //// 参数: gyro_id：数据ID，1：x角速度，2：y角速度，3：z角速度，4：x加速度，5：y加速度，6：z加速度.
  244. //// 返回: 陀螺仪值.
  245. //// 版本: V2.0, 2017-07-15
  246. ////========================================================================
  247. int Get_Gyro_Data(unsigned char gyro_id)
  248. {
  249.     switch(gyro_id)
  250.     {
  251.         case 1: return GetData(ACCEL_XOUT_H);   break;
  252.         case 2: return GetData(ACCEL_YOUT_H);   break;
  253.         case 3: return GetData(ACCEL_ZOUT_H);   break;
  254.         case 4: return GetData(GYRO_XOUT_H) ;   break;
  255.         case 5: return GetData(GYRO_YOUT_H) ;   break;
  256.         case 6: return GetData(GYRO_ZOUT_H) ;   break;
  257.     }
  258.     return 0;
  259. }

  261. //========================================================================
  262. // 函数: int MPU6050_Get_Angle(float x,float y,float z,u8 dir)
  263. // 描述: 转化成与三个方向的夹角.
  264. // 参数: x：x方向数据.
  265. //       y：y方向数据.
  266. //       z：z方向数据.
  267. //       dir:方向ID.
  268. // 返回: 夹角角度值（放大10倍）.
  269. // 版本: V1.0, 2017-06-23
  270. //========================================================================
  271. int MPU6050_Get_Angle(int x,int y,int z,unsigned char dir)
  272. {
  273.     float xdata temp;
  274.     float xdata res = 0;
  275.     switch(dir)
  276.     {
  277.         case 0://与z轴的夹角
  278.                 temp = sqrt(((float)x*(float)x+(float)y*(float)y))/(float)z;
  279.                 res  = atan(temp);
  280.         break;
  281.         case 1://与x轴的夹角
  282.                 temp = (float)x/sqrt(((float)y*(float)y+(float)z*(float)z));
  283.                 res  = atan(temp);
  284.         break;
  285.         case 2://与y轴的夹角
  286.                 temp = (float)y/sqrt(((float)x*(float)x+(float)z*(float)z));
  287.                 res  = atan(temp);
  288.         break;
  289.     }
  290.     return (int)(res*1800/3.1416);//弧度转换为角度,扩大10倍
  291. }

  293. //========================================================================
  294. // int get_included_angle(unsigned dat)
  295. // 描述: 获取角度或加速度
  296. // 参数: angle_id：方向指示变量（1：X轴角度，2：Y轴角度，3：Z轴角度，4：X轴加速度，5：Y轴加速度，6：Z轴加速度）.
  297. // 返回: 夹角角度值（放大10倍）.
  298. // 版本: V1.0, 2017-06-23
  299. //========================================================================
  300. int MPU6050_Get_Data(unsigned angle_id)
  301. {
  302.     switch(angle_id)
  303.     {
  304.         case 1:return MPU6050_Get_Angle( Get_Gyro_Data(1), Get_Gyro_Data(2), Get_Gyro_Data(3), 1);break;
  305.         case 2:return MPU6050_Get_Angle( Get_Gyro_Data(1), Get_Gyro_Data(2), Get_Gyro_Data(3), 2);break;
  306.         case 3:return MPU6050_Get_Angle( Get_Gyro_Data(1), Get_Gyro_Data(2), Get_Gyro_Data(3), 0);break;
  307.         case 4:return (int)((float)((float)Get_Gyro_Data(4)/16384)*9.8*100);
  308.         case 5:return (int)((float)((float)Get_Gyro_Data(5)/16384)*9.8*100);
  309.         case 6:return (int)((float)((float)Get_Gyro_Data(6)/16384)*9.8*100);
  310.     }
  311.     return 0;
  312. }

  314. //串口初始化
  315. void Uart_Init()
  316. {
  317.     SCON |= 0x40;               //8位数据
  318.     P_SW1 &=  ~0xc0;       //UART1 使用P30 P31口  默认
  319.     TR1 = 0;                        //关闭定时器1
  320.     AUXR &= ~0x01;         //串口1波特率使用定时器1
  321.     TMOD &= ~(1<<6);       //Timer1 set As Timer
  322.     TMOD &= ~0x30;         //16位自动重装
  323.     AUXR |=  (1<<6);        //定时器使用1T模式
  324.     TH1 = (unsigned char)(Timer1_Reload_Usart >> 8);
  325.     TL1 = (unsigned char)Timer1_Reload_Usart;
  326.     TR1 = 1;                        //打开定时器1
  327.     PS  = 1;                        //高优先级中断
  328.     REN = 1;                        //允许接收
  329.     ES  = 1;                        //允许中断
  330.     EA  = 1;                        //允许全局中断
  331. }

  333. //========================================================================
  334. // 函数: serial_one_send_byte(unsigned char dat)
  335. // 描述: 串口1发送一个字节.
  336. // 参数: dat：字符（无符号八位整型数据）.
  337. // 返回: none.
  338. // 版本: V1.0, 2017-06-22
  339. //========================================================================
  340. void serial_one_send_byte(unsigned char dat)
  341. {
  342.     SBUF = dat;
  343.     while(!TI);
  344.     TI = 0;
  345. }

  347. //========================================================================
  348. // 函数: serial_one_send_string(u8 *dat)
  349. // 描述: 串口1发送字符串.
  350. // 参数: dat：字符串.
  351. // 返回: none.
  352. // 版本: V1.0, 2017-06-22
  353. //========================================================================
  354. void serial_one_send_string(unsigned char *dat)
  355. {
  356.     while(*dat)
  357.         serial_one_send_byte(*dat++);
  358. }

  360. //========================================================================
  361. // 函数: void serial_one_send_number(long num)
  362. // 描述: 串口1发送整型数据.
  363. // 参数: num：整型数值.
  364. // 返回: none.
  365. // 版本: V1.0, 2017-06-22
  366. //========================================================================
  367. void serial_one_send_number(long num)
  368. {
  369.     long dat = 0;
  370.     unsigned char  length = 0;
  371.     if(num < 0)                                     //当数值为负数时
  372.     {
  373.         serial_one_send_byte('-');  //输出负号
  374.         num = -num;                                 //将数值取相反数
  375.     }

  377.     if(num == 0)                                    //当数值为0时
  378.         serial_one_send_byte('0');  //输出字符0
  379.     else                                            //当数值不为0时
  380.     {
  381.         while(num)                                  //将数值倒过来
  382.         {
  383.             dat = dat * 10;
  384.             dat = dat + num % 10;
  385.             num = num / 10;
  386.             length++;
  387.         }

  389.         while(length--)                         //从第一位开始输出倒过来的数值
  390.         {
  391.             serial_one_send_byte(dat % 10 + '0');
  392.             dat = dat / 10;
  393.         }
  394.     }
  395. }

  397. void serial_one_send_float(double float_val, char bit_val)
  398. {
  399.     long xdata value_int = 0;
  400.     long xdata value_flt = 0;

  402.     if(float_val < 0)
  403.     {
  404.         serial_one_send_byte('-');
  405.         float_val = -float_val;
  406.     }

  408.     value_int = (long)float_val;

  410.     float_val = float_val - (double)value_int;

  412.     for(;bit_val;bit_val--)
  413.         float_val = float_val * 10;

  415.     serial_one_send_number(value_int);
  416.     serial_one_send_byte('.');
  417.     serial_one_send_number((long)float_val);
  418. }

  420. float value = 0;

  422. //主函数
  423. void main()
  424. {
  425.     Delay1000ms();
  426.     Uart_Init();            //串口初始化
  427.     MPU6050_Init();         //初始化MPU6505
  428.     while(1)
  429.     {
  430.         value = MPU6050_Get_Data(1);                    //获取与x轴的夹角，角度被放大10倍
  431.         serial_one_send_string("模块与x轴的夹角为：");
  432.         serial_one_send_float(value / 10,1);            //角度除以10，并从串口发出,第二个参数为保留一位小数
  433.         serial_one_send_string("\r\n");                 //换行

  435.         value = MPU6050_Get_Data(2);                    //获取与y轴的夹角，角度被放大10倍
  436.         serial_one_send_string("模块与y轴的夹角为：");
  437.         serial_one_send_float(value / 10,1);            //角度除以10，并从串口发出
  438.         serial_one_send_string("\r\n");                 //换行

  440.         value = MPU6050_Get_Data(3);                    //获取与z轴的夹角，角度被放大10倍
  441.         serial_one_send_string("模块与z轴的夹角为：");
  442.         serial_one_send_float(value / 10,1);            //角度除以10，并从串口发出
  443.         serial_one_send_string("\r\n");                 //换行

  445.         value = MPU6050_Get_Data(4);                    //获取与x轴加速度，数值被放大100倍
  446.         serial_one_send_string("x轴加速度为：");
  447.         serial_one_send_float(value/100,1);         //角度除以100，并从串口发出，第二个参数为保留一位小数
  448.         serial_one_send_string(" M/S2\r\n");                    //换行

  450.         value = MPU6050_Get_Data(4);                    //获取与y轴加速度，数值被放大100倍
  451.         serial_one_send_string("y轴加速度为：");
  452.         serial_one_send_float(value / 100,1);           //角度除以100，并从串口发出
  453.         serial_one_send_string(" M/S2\r\n");                    //换行

  455.         value = MPU6050_Get_Data(4);                    //获取与z轴加速度，数值被放大100倍
  456.         serial_one_send_string("z轴加速度为：");
  457.         serial_one_send_float(value / 100,1);           //角度除以100，并从串口发出
  458.         serial_one_send_string(" M/S2\r\n\r\n");                    //换行

  460.         Delay1000ms();
  461.         Delay1000ms();
  462.     }
  463. }

  465. //串口中断
  466. void Uart1_Int (void) interrupt 4
  467. {
  468.     if(RI)
  469.         RI = 0;
  470. }
复制代码

  1. /*
  2. * ADXL345模块
  3. *
  4. * 用途：ADXL345模块IIC测试程序
  5. *
  6. * 作者                                        日期                                备注
  7. *
  8. */
  9. #include "uart3.h"
  10. #include  <stc15.H>        
  11. #include  <math.h>    //Keil library  
  12. #include  <stdio.h>   //Keil library        
  13. #include  <INTRINS.H>
  14. #define   uchar unsigned char
  15. #define   uint unsigned int


  18. sbit          SCL=P0^6;      //IIC时钟引脚定义
  19. sbit           SDA=P0^7;      //IIC数据引脚定义
  20. sbit    P_PWM = P2^5;       //定义PWM输出引脚。
  21. sbit                O_PWM = P2^1;
  22. #define        SlaveAddress   0xa6          //定义器件在IIC总线中的从地址,根据ALT  ADDRESS地址引脚不同修改
  23.                               //ALT  ADDRESS引脚接地时地址为0xA6，接电源时地址为0x3A
  24. #define     PWM_HIGH_MIN    32              //限制PWM输出的最小占空比。用户请勿修改。
  25. #define     PWM_HIGH_MAX    (PWM_DUTY-PWM_HIGH_MIN) //限制PWM输出的最大占空比。用户请勿修改。
  26. long  PWM_DUTY=20200;
  27. unsigned int duty;
  28. unsigned char fu_flag=0;

  30. unsigned int     pwm;                //定义PWM输出高电平的时间的变量。用户操作PWM的变量。
  31. //BYTE BUF[8];                         //接收数据缓存区              
  32. uchar ge,shi,bai,qian,wan;           //显示变量
  33. int  dis_data;                       //变量
  34. int  x_value=0;
  35. void delay(unsigned int k);
  36. void Init_ADXL345(void);             //初始化ADXL345

  38. void conversion(uint temp_data);

  40. void  Single_Write_ADXL345(uchar REG_Address,uchar REG_data);   //单个写入数据
  41. uchar Single_Read_ADXL345(uchar REG_Address);                   //单个读取内部寄存器数据
  42. void  Multiple_Read_ADXL345();                                  //连续的读取内部寄存器数据






  49. //sbit  P_PWM = P1^4;       //定义PWM输出引脚。STC15W204S



  53. unsigned int     PWM_high,PWM_low;   //中间变量，用户请勿修改。
  54. void         change_pwm(int i);
  55. void  LoadPWM(int i);
  56. void        pwm_init();
  57. //------------------------------------
  58. void PID_Operation();  
  59. void PID_Output(void);
  60. void Delay5us();
  61. void Delay5ms();
  62. void ADXL345_Start();
  63. void ADXL345_Stop();
  64. void ADXL345_SendACK(bit ack);
  65. bit  ADXL345_RecvACK();
  66. void ADXL345_SendByte(BYTE dat);
  67. BYTE ADXL345_RecvByte();
  68. void ADXL345_ReadPage();
  69. void ADXL345_WritePage();
  70. //-----------------------------------

  72. //*********************************************************
  73. //void conversion(uint temp_data)  
  74. //{  
  75. //    wan=temp_data/10000+0x30 ;
  76. //    temp_data=temp_data%10000;   //取余运算
  77. //                qian=temp_data/1000+0x30 ;
  78. //    temp_data=temp_data%1000;    //取余运算
  79. //    bai=temp_data/100+0x30   ;
  80. //    temp_data=temp_data%100;     //取余运算
  81. //    shi=temp_data/10+0x30    ;
  82. //    temp_data=temp_data%10;      //取余运算
  83. //    ge=temp_data+0x30;         
  84. //}

  86. /*******************************/
  87. void delay(unsigned int k)        
  88. {                                                
  89. unsigned int i,j;                                
  90.         for(i=0;i<k;i++)
  91.         {                        
  92.         for(j=0;j<121;j++)                        
  93.         {;}}                                                
  94. }
  95. /**************************************
  96. 延时5微秒(STC90C52RC---12MHz---12T)
  97. 不同的工作环境,需要调整此函数，注意时钟过快时需要修改
  98. 当改用1T的MCU时,请调整此延时函数
  99. **************************************/
  100. void Delay5us()
  101. {
  102. unsigned char i;

  104.         _nop_();
  105.         _nop_();
  106.         i = 27;
  107.         while (--i);
  108. }

  110. ///**************************************
  111. //延时5毫秒(STC90C52RC@12M)
  112. //不同的工作环境,需要调整此函数
  113. //当改用1T的MCU时,请调整此延时函数
  114. //**************************************/
  115. //void Delay5ms()
  116. //{
  117. //        unsigned char i, j;

  119. //        i = 117;
  120. //        j = 184;
  121. //        do
  122. //        {
  123. //                while (--j);
  124. //        } while (--i);
  125. //}

  127. /**************************************
  128. 起始信号
  129. **************************************/
  130. void ADXL345_Start()
  131. {
  132.     SDA = 1;                    //拉高数据线
  133.     SCL = 1;                    //拉高时钟线
  134.     Delay5us();                 //延时
  135.     SDA = 0;                    //产生下降沿
  136.     Delay5us();                 //延时
  137.     SCL = 0;                    //拉低时钟线
  138. }

  140. /**************************************
  141. 停止信号
  142. **************************************/
  143. void ADXL345_Stop()
  144. {
  145.     SDA = 0;                    //拉低数据线
  146.     SCL = 1;                    //拉高时钟线
  147.     Delay5us();                 //延时
  148.     SDA = 1;                    //产生上升沿
  149.     Delay5us();                 //延时
  150. }

  152. /**************************************
  153. 发送应答信号
  154. 入口参数:ack (0:ACK 1:NAK)
  155. **************************************/
  156. void ADXL345_SendACK(bit ack)
  157. {
  158.     SDA = ack;                  //写应答信号
  159.     SCL = 1;                    //拉高时钟线
  160.     Delay5us();                 //延时
  161.     SCL = 0;                    //拉低时钟线
  162.     Delay5us();                 //延时
  163. }

  165. /**************************************
  166. 接收应答信号
  167. **************************************/
  168. bit ADXL345_RecvACK()
  169. {
  170.     SCL = 1;                    //拉高时钟线
  171.     Delay5us();                 //延时
  172.     CY = SDA;                   //读应答信号
  173.     SCL = 0;                    //拉低时钟线
  174.     Delay5us();                 //延时

  176.     return CY;
  177. }

  179. /**************************************
  180. 向IIC总线发送一个字节数据
  181. **************************************/
  182. void ADXL345_SendByte(BYTE dat)
  183. {
  184.     BYTE i;

  186.     for (i=0; i<8; i++)         //8位计数器
  187.     {
  188.         dat <<= 1;              //移出数据的最高位
  189.         SDA = CY;               //送数据口
  190.         SCL = 1;                //拉高时钟线
  191.         Delay5us();             //延时
  192.         SCL = 0;                //拉低时钟线
  193.         Delay5us();             //延时
  194.     }
  195.     ADXL345_RecvACK();
  196. }

  198. /**************************************
  199. 从IIC总线接收一个字节数据
  200. **************************************/
  201. BYTE ADXL345_RecvByte()
  202. {
  203.     BYTE i;
  204.     BYTE dat = 0;

  206.     SDA = 1;                    //使能内部上拉,准备读取数据,
  207.     for (i=0; i<8; i++)         //8位计数器
  208.     {
  209.         dat <<= 1;
  210.         SCL = 1;                //拉高时钟线
  211.         Delay5us();             //延时
  212.         dat |= SDA;             //读数据               
  213.         SCL = 0;                //拉低时钟线
  214.         Delay5us();             //延时
  215.     }
  216.     return dat;
  217. }

  219. //******单字节写入*******************************************

  221. void Single_Write_ADXL345(uchar REG_Address,uchar REG_data)
  222. {
  223.     ADXL345_Start();                  //起始信号
  224.     ADXL345_SendByte(SlaveAddress);   //发送设备地址+写信号
  225.     ADXL345_SendByte(REG_Address);    //内部寄存器地址，请参考中文pdf22页
  226.     ADXL345_SendByte(REG_data);       //内部寄存器数据，请参考中文pdf22页
  227.     ADXL345_Stop();                   //发送停止信号
  228. }

  230. //********单字节读取*****************************************
  231. uchar Single_Read_ADXL345(uchar REG_Address)
  232. {  uchar REG_data;
  233.     ADXL345_Start();                          //起始信号
  234.     ADXL345_SendByte(SlaveAddress);           //发送设备地址+写信号
  235.     ADXL345_SendByte(REG_Address);            //发送存储单元地址，从0开始        
  236.     ADXL345_Start();                          //起始信号
  237.     ADXL345_SendByte(SlaveAddress+1);         //发送设备地址+读信号
  238.     REG_data=ADXL345_RecvByte();              //读出寄存器数据
  239.         ADXL345_SendACK(1);   
  240.         ADXL345_Stop();                           //停止信号
  241.     return REG_data;
  242. }
  243. //*********************************************************
  244. //
  245. //连续读出ADXL345内部加速度数据，地址范围0x32~0x37
  246. //
  247. //*********************************************************
  248. void Multiple_read_ADXL345(void)
  249. {   uchar i;
  250.     ADXL345_Start();                          //起始信号
  251.     ADXL345_SendByte(SlaveAddress);           //发送设备地址+写信号
  252.     ADXL345_SendByte(0x32);                   //发送存储单元地址，从0x32开始        
  253.     ADXL345_Start();                          //起始信号
  254.     ADXL345_SendByte(SlaveAddress+1);         //发送设备地址+读信号
  255.          for (i=0; i<6; i++)                      //连续读取6个地址数据，存储中BUF
  256.     {
  257.         BUF[i] = ADXL345_RecvByte();          //BUF[0]存储0x32地址中的数据
  258.         if (i == 5)
  259.         {
  260.            ADXL345_SendACK(1);                //最后一个数据需要回NOACK
  261.         }
  262.         else
  263.         {
  264.           ADXL345_SendACK(0);                //回应ACK
  265.        }
  266.    }
  267.     ADXL345_Stop();                          //停止信号

  269. }
  270. //void send0ff()

  272. //{
  273. //        SendData(0xff);
  274. //        SendData(0xff);
  275. //        SendData(0xff);
  276. //}

  278. //*****************************************************************

  280. //初始化ADXL345，根据需要请参考pdf进行修改************************
  281. void Init_ADXL345()
  282. {
  283.    Single_Write_ADXL345(0x31,0x08);   //测量范围,正负16g，13位模式
  284.    Single_Write_ADXL345(0x2C,0x0a);   //速率设定为12.5 参考pdf13页
  285.    Single_Write_ADXL345(0x2D,0x08);   //选择电源模式   参考pdf24页
  286.    Single_Write_ADXL345(0x2E,0x80);   //使能 DATA_READY 中断
  287.    Single_Write_ADXL345(0x1E,0x00);   //X 偏移量 根据测试传感器的状态写入pdf29页
  288.    Single_Write_ADXL345(0x1F,0x00);   //Y 偏移量 根据测试传感器的状态写入pdf29页
  289.    Single_Write_ADXL345(0x20,0x05);   //Z 偏移量 根据测试传感器的状态写入pdf29页
  290. }
  291. ////***********************************************************************
  292. ////显示x轴
  293. //void display_x()
  294. //{   float temp;
  295. //                unsigned char dis_t[16]="n0.val=0000";
  296. //    dis_data=(BUF[1]<<8)+BUF[0];  //合成数据   
  297. //        if(dis_data<0){
  298. //        dis_data=-dis_data;
  299. //   SendString("t3.txt=\"-\"");
  300. //                send0ff();
  301. //        }
  302. //                else{
  303. //                SendString("t3.txt=\" \"");
  304. //                        send0ff();}

  306. //    temp=(float)dis_data*3.9;  //计算数据和显示,查考ADXL345快速入门第4页
  307. //    conversion(temp);          //转换出显示需要的数据
  308. //                dis_t[7]=qian;
  309. //                dis_t[8]=bai;
  310. //                dis_t[9]=shi;
  311. //                dis_t[10]=ge;
  312. //                dis_t[11]=0xff;
  313. //        dis_t[12]=0xff;
  314. //        dis_t[13]=0xff;
  315. //        SendString(dis_t);
  316. //}

  318. //***********************************************************************
  319. //显示y轴
  320. //void display_y()
  321. //{     float temp;
  322. //        unsigned char dis_t[16]="n1.val=";
  323. //    dis_data=(BUF[3]<<8)+BUF[2];  //合成数据   
  324. //        if(dis_data<0){
  325. //        dis_data=-dis_data;
  326. //   SendString("t4.txt=\"-\"");
  327. //                send0ff();
  328. //        }
  329. //                else{
  330. //                SendString("t4.txt=\" \"");
  331. //                        send0ff();}

  333. //    temp=(float)dis_data*3.9;  //计算数据和显示,查考ADXL345快速入门第4页
  334. //    conversion(temp);          //转换出显示需要的数据
  335. //                dis_t[7]=qian;
  336. //                dis_t[8]=bai;
  337. //                dis_t[9]=shi;
  338. //                dis_t[10]=ge;
  339. //                dis_t[11]=0xff;
  340. //        dis_t[12]=0xff;
  341. //        dis_t[13]=0xff;
  342. //        SendString(dis_t);
  343. //}

  345. //***********************************************************************
  346. //显示z轴
  347. //void display_z()
  348. //{
  349. //    float temp;
  350. //        unsigned char dis_t[16]="n2.val=";
  351. //    dis_data=(BUF[5]<<8)+BUF[4];    //合成数据   
  352. //        if(dis_data<0){
  353. //        dis_data=-dis_data;
  354. //   SendString("t5.txt=\"-\"");
  355. //                send0ff();
  356. //        }
  357. //        else{
  358. //                SendString("t5.txt=\" \"");
  359. //                        send0ff();
  360. //}

  362. //    temp=(float)dis_data*3.9;  //计算数据和显示,查考ADXL345快速入门第4页
  363. //    conversion(temp);          //转换出显示需要的数据
  364. //                dis_t[7]=qian;
  365. //                dis_t[8]=bai;
  366. //                dis_t[9]=shi;
  367. //                dis_t[10]=ge;
  368. //        dis_t[11]=0xff;
  369. //        dis_t[12]=0xff;
  370. //        dis_t[13]=0xff;
  371. //        SendString(dis_t);
  372. //}
  373. void io_init()
  374. {
  375.           P0M0 = 0x00;
  376.     P0M1 = 0x00;
  377.     P1M0 = 0x00;
  378.     P1M1 = 0x00;
  379.     P2M0 = 0x00;
  380.     P2M1 = 0x00;
  381.     P3M0 = 0x00;
  382.     P3M1 = 0x00;
  383.     P4M0 = 0x00;
  384.     P4M1 = 0x00;
  385.     P5M0 = 0x00;
  386.     P5M1 = 0x00;
  387.     P6M0 = 0x00;
  388.     P6M1 = 0x00;
  389.     P7M0 = 0x00;
  390.     P7M1 = 0x00;
  391. }

  393. //*********************************************************
  394. //******主程序********
  395. //*********************************************************
  396. void main()
  397. {
  398.         uchar temp[5];
  399.         uchar devid;
  400.         delay(500);                                   //上电延时               
  401.         io_init();
  402.         pwm_init();
  403.         uart3_init();
  404.         PID.iSetVal=16;        
  405.         PID.uKP_Coe=3;
  406.         PID.uKI_Coe=0.1;
  407.         PID.uKD_Coe=5;
  408.         Init_ADXL345();                         //初始化ADXL345
  409.         devid=Single_Read_ADXL345(0X00);        //读出的数据为0XE5,表示正确
  410.         while(1)                                 //循环
  411.         {
  412.                 Multiple_Read_ADXL345();               //连续读出数据，存储在BUF中         
  413.                 x_value=(BUF[1]<<8)+BUF[0];  //合成数据  
  414.                
  415.                 if(x_value<=0)
  416.                 {
  417.                         fu_flag=1;
  418.                         x_value=-x_value;
  419.                 }
  420.                 else
  421.                         fu_flag=0;
  422.                 temp[0]=x_value/10000+'0';
  423.                 temp[1]=x_value/1000%10+'0';
  424.                 temp[2]=x_value/100%10+'0';
  425.                 temp[3]=x_value/10%10+'0';
  426.                 temp[4]=x_value%10+'0';
  427.                
  428.                
  429.                
  430.                
  431.                 SendString(temp);
  432.                 PID.iCurVal=x_value;
  433.                 PID_Operation();
  434.                 PID_Output();
  435. //                if(x_value>0)
  436. //                {
  437. //                        fu_flag=0;
  438. //                        if(x_value>=300)
  439. //                        {
  440. //                                x_value=300;
  441. //                                
  442. //                        }
  443. //                        change_pwm(x_value);
  444. //                }
  445. //                else if(x_value<0)
  446. //                {
  447. //                        x_value=-x_value;
  448. //                        fu_flag=1;
  449. //                        if(x_value>=300)
  450. //                        {
  451. //                                x_value=300;
  452. //                                
  453. //                        }
  454. //                        change_pwm(x_value);
  455. //                }
  456.                         
  457.         }
  458. }
  459. void pwm_init()
  460. {
  461.                 P_PWM = 0;
  462.     P2M1 &= ~(1 << 5);  //P2.5 设置为推挽输出
  463.     P2M0 |=  (1 << 5);
  464.                 P2M1 &= ~(1 << 1);  //P2.1 设置为推挽输出
  465.     P2M0 |=  (1 << 1);

  467. //  P1M1 &= ~(1 << 4);  //P1.4 设置为推挽输出   STC15W204S
  468. //  P1M0 |=  (1 << 4);

  470.     TR0 = 0;        //停止计数
  471.     ET0 = 1;        //允许中断
  472.     PT0 = 1;        //高优先级中断
  473.     TMOD &= ~0x03;  //工作模式,0: 16位自动重装
  474.     AUXR |=  0x80;  //1T
  475.     TMOD &= ~0x04;  //定时
  476.     INT_CLKO |=  0x01;  //输出时钟

  478.     TH0 = 0;
  479.     TL0 = 0;
  480.     TR0 = 1;    //开始运行

  482.     EA = 1;
  483. }


  486. //========================================================================
  487. // 函数: void  delay_ms(unsigned char ms)
  488. // 描述: 延时函数。
  489. // 参数: ms,要延时的ms数, 这里只支持1~255ms. 自动适应主时钟.
  490. // 返回: none.
  491. // 版本: VER1.0
  492. // 日期: 2013-4-1
  493. // 备注:
  494. //========================================================================
  495. void         change_pwm(int i)
  496. {
  497.         LoadPWM(PWM_DUTY * i / 300);
  498. }

  500. /**************** 计算PWM重装值函数 *******************/
  501. void    LoadPWM(int i)
  502. {
  503.     int j;

  505.     if(i > PWM_HIGH_MAX)        i = PWM_HIGH_MAX;   //如果写入大于最大占空比数据，则强制为最大占空比。
  506.     if(i < PWM_HIGH_MIN)        i = PWM_HIGH_MIN;   //如果写入小于最小占空比数据，则强制为最小占空比。
  507.     j = 65536UL - PWM_DUTY + i; //计算PWM低电平时间
  508.     i = 65536UL - i;            //计算PWM高电平时间
  509.     EA = 0;
  510.     PWM_high = i;   //装载PWM高电平时间
  511.     PWM_low  = j;   //装载PWM低电平时间
  512.     EA = 1;
  513. }

  515. /********************* Timer0中断函数************************/
  516. void timer0_int (void) interrupt 1
  517. {
  518.     if(P_PWM&&fu_flag==0)
  519.     {
  520.         TH0 = (unsigned char)(PWM_low >> 8);   //如果是输出高电平，则装载低电平时间。
  521.         TL0 = (unsigned char)PWM_low;
  522.                                 P_PWM=0;
  523.                                 O_PWM=0;
  524.     }
  525.     else if(!P_PWM&&fu_flag==0)
  526.     {
  527.         TH0 = (unsigned char)(PWM_high >> 8);  //如果是输出低电平，则装载高电平时间。
  528.         TL0 = (unsigned char)PWM_high;
  529.                                 O_PWM=0;
  530.                                 P_PWM=1;
  531.     }
  532.                 if(O_PWM&&fu_flag==1)
  533.                 {
  534.         TH0 = (unsigned char)(PWM_low >> 8);   //如果是输出高电平，则装载低电平时间。
  535.         TL0 = (unsigned char)PWM_low;
  536.                                 O_PWM=0;
  537.                                 P_PWM=0;
  538.     }
  539.     else if(!O_PWM&&fu_flag==1)
  540.     {
  541.         TH0 = (unsigned char)(PWM_high >> 8);  //如果是输出低电平，则装载高电平时间。
  542.         TL0 = (unsigned char)PWM_high;
  543.                                 O_PWM=1;
  544.                                 P_PWM=0;
  545.     }
  546. }
  547. /*
  548. ********************************************************

  550. /*
  551. 函数名称：PID_Operation()  void PID_Output(void)                                

  553. /*
  554. 函数功能：PID运算                    

  556. /*
  557. 入口参数：无（隐形输入，系数、设定值等）                     

  559. /*
  560. 出口参数：无（隐形输出，U(k)）

  562. /*
  563. 函数说明：U(k)=KP*[E(k)-E(k-1)]+KI*E(k)+KD*[E(k)-2E(k-1)+E(k-2)]                                    

  565. ********************************************************
  566. */

  568. void        PID_Operation(void)

  570. {

  572.     uInt32        Temp[3] = {0};   //中间临时变量

  574.     uInt32        PostSum = 0;     //正数和

  576.     uInt32        NegSum = 0;      //负数和

  578.     if(PID.iSetVal > PID.iCurVal)                //设定值大于实际值否？

  580.     {

  582.         if(PID.iSetVal - PID.iCurVal > 300)      //偏差大于10否？

  584.             PID.iPriVal = 300;                  //偏差大于10为上限幅值输出(全速加热)

  586.         else                                   

  588. //否则慢慢来

  590.         {

  592.             Temp[0] = PID.iSetVal - PID.iCurVal;    //偏差<=10,计算E(k)

  594.             PID.uEkFlag[1] = 0;                     //E(k)为正数,因为设定值大于实际值

  596.             /*
  597. 数值进行移位，注意顺序，否则会覆盖掉前面的数值 */

  599.             PID.liEkVal[2] = PID.liEkVal[1];

  601.             PID.liEkVal[1] = PID.liEkVal[0];

  603.             PID.liEkVal[0] = Temp[0];

  605.             /*
  606. =================================================================== */

  608.             if(PID.liEkVal[0] > PID.liEkVal[1])              //E(k)>E(k-1)否？

  610.             {

  612.                 Temp[0] = PID.liEkVal[0] - PID.liEkVal[1];  //E(k)>E(k-1)

  614.                 PID.uEkFlag[0] = 0;                         //E(k)-E(k-1)为正数

  616.             }                                      

  618.             else

  620.             {

  622.                 Temp[0] = PID.liEkVal[1] - PID.liEkVal[0];  //E(k)<E(k-1)

  624.                 PID.uEkFlag[0] = 1;                         //E(k)-E(k-1)为负数

  626.             }                       

  628.             /*
  629. =================================================================== */

  631.             Temp[2] = PID.liEkVal[1] * 2;                   //2E(k-1)

  633.             if((PID.liEkVal[0] + PID.liEkVal[2]) > Temp[2]) //E(k-2)+E(k)>2E(k-1)否？

  635.             {

  637.                 Temp[2] = (PID.liEkVal[0] + PID.liEkVal[2]) - Temp[2];

  639.                 PID.uEkFlag[2]=0;                          //E(k-2)+E(k)-2E(k-1)为正数

  641.             }                                             

  643.             else                                           //E(k-2)+E(k)<2E(k-1)

  645.             {

  647.                 Temp[2] = Temp[2] - (PID.liEkVal[0] + PID.liEkVal[2]);

  649.                 PID.uEkFlag[2] = 1;                         //E(k-2)+E(k)-2E(k-1)为负数

  651.             }                                 

  653.             /*
  654. =================================================================== */

  656.             Temp[0] = (uInt32)PID.uKP_Coe * Temp[0];        //KP*[E(k)-E(k-1)]

  658.             Temp[1] = (uInt32)PID.uKI_Coe * PID.liEkVal[0]; //KI*E(k)

  660.             Temp[2] = (uInt32)PID.uKD_Coe * Temp[2];        //KD*[E(k-2)+E(k)-2E(k-1)]

  662.             /*
  663. 以下部分代码是讲所有的正数项叠加，负数项叠加 */

  665.             /*
  666. ========= 计算KP*[E(k)-E(k-1)]的值 ========= */

  668.             if(PID.uEkFlag[0] == 0)

  670.                 PostSum += Temp[0];                         //正数和

  672.             else                                            

  674.                 NegSum += Temp[0];                          //负数和

  676.             /*
  677. ========= 计算KI*E(k)的值 ========= */

  679.             if(PID.uEkFlag[1] == 0)     

  681.                 PostSum += Temp[1];                         //正数和

  683.             else
  684.                                                         ;  
  685. /*
  686. 空操作。就是因为PID.iSetVal > PID.iCurVal（即E(K)>0）才进入if的，

  688.                     那么就没可能为负，所以打个转回去就是了
  689. */

  691.             /*
  692. ========= 计算KD*[E(k-2)+E(k)-2E(k-1)]的值 ========= */

  694.             if(PID.uEkFlag[2]==0)

  696.                 PostSum += Temp[2];             //正数和

  698.             else

  700.                 NegSum += Temp[2];              //负数和

  702.             /*
  703. ========= 计算U(k) ========= */                        

  705.             PostSum += (uInt32)PID.iPriVal;         

  707.             if(PostSum > NegSum)                 //是否控制量为正数

  709.             {

  711.                 Temp[0] = PostSum - NegSum;

  713.                 if(Temp[0] < 300 )               //小于上限幅值则为计算值输出

  715.                     PID.iPriVal = (uInt16)Temp[0];

  717.                 else
  718.                                                                                 PID.iPriVal = 300;         //否则为上限幅值输出

  720.             }

  722.             else                              

  724. //控制量输出为负数，则输出0(下限幅值输出)

  726.                 PID.iPriVal = 0;

  728.         }

  730.     }

  732.     else

  734. PID.iPriVal = 0;                       

  736. }

  738. /*
  739. ********************************************************

  741. /*
  742. 函数名称：PID_Output()                                    

  744. /*
  745. 函数功能：PID输出控制                  

  747. /*
  748. 入口参数：无（隐形输入，U(k)）                        

  750. /*
  751. 出口参数：无（控制端）                                      

  753. ********************************************************
  754. */

  756. void PID_Output(void)

  758. {

  760.     static uInt16 iTemp;

  762.     iTemp = PID.iPriVal;

  764.                 change_pwm(iTemp);

  766. }
复制代码

所有资料51hei提供下载:
PCA捕获 带串口通信.zip (80.33 KB, 下载次数: 40)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表