mpu6050六轴传感器msp430驱动程序

1. #include <msp430g2553.h>
   
2. #include"mpu6050.h"
   
3. #include "USCI_A0.h"
   
4. #include "IMU.h "
   
5. /*
   
6. *  ======== BCSplus_graceInit ========
   
7. *  Initialize MSP430 Basic Clock System
   
8. */
   
9. void BCSplus_graceInit(void)
   
10. {
    
11.     /* USER CODE START (section: BCSplus_graceInit_prologue) */
    
12.     /* User initialization code */
    
13.     /* USER CODE END (section: BCSplus_graceInit_prologue) */
    
14. 
    
15.     /*
    
16.      * Basic Clock System Control 2
    
17.      *
    
18.      * SELM_0 -- DCOCLK
    
19.      * DIVM_0 -- Divide by 1
    
20.      * ~SELS -- DCOCLK
    
21.      * DIVS_1 -- Divide by 2
    
22.      * ~DCOR -- DCO uses internal resistor
    
23.      *
    
24.      * Note: ~<BIT> indicates that <BIT> has value zero
    
25.      */
    
26.     BCSCTL2 = SELM_0 | DIVM_0 | DIVS_1;
    
27. 
    
28.     if (CALBC1_16MHZ != 0xFF) {
    
29.         /* Adjust this accordingly to your VCC rise time */
    
30.         __delay_cycles(100000);
    
31. 
    
32.         /* Follow recommended flow. First, clear all DCOx and MODx bits. Then
    
33.          * apply new RSELx values. Finally, apply new DCOx and MODx bit values.
    
34.          */
    
35.         DCOCTL = 0x00;
    
36.         BCSCTL1 = CALBC1_16MHZ;     /* Set DCO to 16MHz */
    
37.         DCOCTL = CALDCO_16MHZ;
    
38.     }
    
39. 
    
40.     /*
    
41.      * Basic Clock System Control 1
    
42.      *
    
43.      * XT2OFF -- Disable XT2CLK
    
44.      * ~XTS -- Low Frequency
    
45.      * DIVA_0 -- Divide by 1
    
46.      *
    
47.      * Note: ~XTS indicates that XTS has value zero
    
48.      */
    
49.     BCSCTL1 |= XT2OFF | DIVA_0;
    
50. 
    
51.     /*
    
52.      * Basic Clock System Control 3
    
53.      *
    
54.      * XT2S_0 -- 0.4 - 1 MHz
    
55.      * LFXT1S_0 -- If XTS = 0, XT1 = 32768kHz Crystal ; If XTS = 1, XT1 = 0.4 - 1-MHz crystal or resonator
    
56.      * XCAP_1 -- ~6 pF
    
57.      */
    
58.     BCSCTL3 = XT2S_0 | LFXT1S_0 | XCAP_1;
    
59. 
    
60.     /* USER CODE START (section: BCSplus_graceInit_epilogue) */
    
61.     /* User code */
    
62.     /* USER CODE END (section: BCSplus_graceInit_epilogue) */
    
63. }/*
    
64. * main.c
    
65. */
    
66. int main(void)
    
67. {
    
68.     WDTCTL = WDTPW | WDTHOLD;        // Stop watchdog timer
    
69.     BCSplus_graceInit();        //MCLK = 16M,SMCLK = 8M,ack =32.768k
    
70.     WDTCTL = WDTPW | WDTTMSEL | WDTIS0;
    
71.     IE1 |= WDTIE;
    
72.     USCI_A0_init();             //uart 38400bps  
    
73.     P1DIR |= BIT0;              //initialize led control PIN
    
74.     _EINT();
    
75.     MPU6050_Init();             //initialize mpu6050
    
76.    
    
77.     while(1)
    
78.     {
    
79.       /*
    
80.       Get_Attitude();
    
81.      //MPU6050_Dataanl();
    
82.      // ReadMPU6050All();
    
83.      //Prepare_Data();             //耗时6.15ms
    
84.      //Uart1_Send_AF();             //耗时8.42ms
    
85.      P1OUT ^= BIT0;
    
86.      Get_Attitude();
    
87.      //ReadMPU6050All();
    
88.      //MPU6050_Dataanl();         //未使用多字节读取，耗时6ms,使用多字节读取，耗时3.6ms
    
89.      //Prepare_Data();
    
90.     // Uart1_Send_AF();
    
91.      P1OUT ^= BIT0;
    
92.      */
    
93.     }
    
94.    
    
95. }
    
96. 
    
97. //watchdog interrupt server program per 1ms
    
98. #pragma vector=WDT_VECTOR
    
99. __interrupt void WDT_ISR_HOOK(void)
    
100. {
     
101.     /* USER CODE START (section: WDT_ISR_HOOK) */
     
102.     /* replace this comment with your code */
     
103.     static unsigned int count=0;
     
104.     static unsigned char ms2 = 0,ms5 = 0,ms10 = 0;
     
105.     count++;
     
106.     ms2++;
     
107.     ms5++;
     
108.     ms10++;
     
109.    
     
110.     if(ms2 == 2)
     
111.     {
     
112.      ms2 = 0;
     
113.      Prepare_Data();
     
114.      //MPU6050_Dataanl();
     
115.     }
     
116.     if(ms5 >= 4)
     
117.     {
     
118.       ms5 = 0;
     
119.       Get_Attitude();
     
120.    
     
121.     }
     
122.     if(ms10 >= 10)
     
123.     {
     
124.       ms10 = 0;
     
125.       Uart1_Send_AF();
     
126.     }
     
127.     if(count== 200)
     
128.     {
     
129.       count=0;
     
130.       P1OUT ^= BIT0;
     
131.     }
     
132. 
     
133.         /* USER CODE END (section: WDT_ISR_HOOK) */
     
134. }
     
135. 
     
136. 
     
137. 
     
138. /*
     
139. * This file contains some mpu6050 operation.
     
140. * By IC爬虫 (1394024051@qq.com)
     
141. * 2014-4-13 v1.0
     
142. */
     
143. #include "mpu6050.h"
     
144. 
     
145. unsigned char   mpu6050_buffer[14];     //I2C读取后存放数据
     
146. 
     
147. int ACC_OFFSET_X,ACC_OFFSET_Y,ACC_OFFSET_Z;
     
148. int GYRO_OFFSET_X,GYRO_OFFSET_Y,GYRO_OFFSET_Z;
     
149. 
     
150. unsigned char        GYRO_OFFSET_OK = 1;
     
151. unsigned char        ACC_OFFSET_OK = 1;
     
152. 
     
153. int MPU6050_ACC_LAST_X,MPU6050_ACC_LAST_Y,MPU6050_ACC_LAST_Z;    //final accelerate speed
     
154. int MPU6050_GYRO_LAST_X,MPU6050_GYRO_LAST_Y,MPU6050_GYRO_LAST_Z; //final  gyro  speed
     
155. 
     
156. /**********************************************************/
     
157. //函数名称：void MPU6050_Dataanl
     
158. //入口参数：无
     
159. //出口参数：无
     
160. //函数功能：MPU6050数据读取并处理
     
161. /**********************************************************/
     
162. void MPU6050_Dataanl(void)
     
163. {
     
164. #ifndef READALL
     
165.   MPU6050_ACC_LAST_X = GetAccelX() - ACC_OFFSET_X;
     
166.   MPU6050_ACC_LAST_Y = GetAccelY() - ACC_OFFSET_Y;
     
167.   MPU6050_ACC_LAST_Z = GetAccelZ() - ACC_OFFSET_Z;
     
168.   
     
169.   MPU6050_GYRO_LAST_X = GetAnguX() - GYRO_OFFSET_X;
     
170.   MPU6050_GYRO_LAST_Y = GetAnguY() - GYRO_OFFSET_Y;
     
171.   MPU6050_GYRO_LAST_Z = GetAnguZ() - GYRO_OFFSET_Z;
     
172.   //------------------------------------------------------------------//
     
173.   //补偿偏移
     
174.   if(!GYRO_OFFSET_OK)
     
175.   {
     
176.     static long int tempgx=0,tempgy=0,tempgz=0;
     
177.     static unsigned char cnt_g=0;
     
178. 
     
179.     if(cnt_g==0)
     
180.     {
     
181.       GYRO_OFFSET_X=0;
     
182.       GYRO_OFFSET_Y=0;
     
183.       GYRO_OFFSET_Z=0;
     
184.       tempgx = 0;
     
185.       tempgy = 0;
     
186.       tempgz = 0;
     
187.       cnt_g = 1;
     
188.     }
     
189.     tempgx+= MPU6050_GYRO_LAST_X;
     
190.     tempgy+= MPU6050_GYRO_LAST_Y;
     
191.     tempgz+= MPU6050_GYRO_LAST_Z;
     
192.     if(cnt_g==200)
     
193.     {
     
194.       GYRO_OFFSET_X=tempgx/cnt_g;
     
195.       GYRO_OFFSET_Y=tempgy/cnt_g;
     
196.       GYRO_OFFSET_Z=tempgz/cnt_g;
     
197.       cnt_g = 0;
     
198.       GYRO_OFFSET_OK = 1;
     
199.       
     
200.     }
     
201.     cnt_g++;
     
202.   }
     
203.   if(!ACC_OFFSET_OK)
     
204.   {
     
205.     static long int tempax=0,tempay=0,tempaz=0;
     
206.     static unsigned char cnt_a=0;
     
207.    
     
208.     if(cnt_a==0)
     
209.     {
     
210.       ACC_OFFSET_X = 0;
     
211.       ACC_OFFSET_Y = 0;
     
212.       ACC_OFFSET_Z = 0;
     
213.       tempax = 0;
     
214.       tempay = 0;
     
215.       tempaz = 0;
     
216.       cnt_a = 1;
     
217.       
     
218.     }
     
219.     tempax += MPU6050_ACC_LAST_X;//累加
     
220.     tempay += MPU6050_ACC_LAST_Y;
     
221.     tempaz += MPU6050_ACC_LAST_Z;
     
222.     if(cnt_a==200)
     
223.     {
     
224.       ACC_OFFSET_X = tempax/cnt_a;
     
225.       ACC_OFFSET_Y = tempay/cnt_a;
     
226.       ACC_OFFSET_Z = tempaz/cnt_a;
     
227.       cnt_a = 0;
     
228.       ACC_OFFSET_OK = 1;
     
229.       
     
230.     }
     
231.     cnt_a++;
     
232.   }
     
233.   //--------------------------------------------//
     
234. #else
     
235. struct MPU6050Struct *MPU6050WORK;
     
236.   MPU6050WORK = ReadMPU6050All();
     
237.   MPU6050_ACC_LAST_X = (MPU6050WORK ->MPU6050_ACC_X) - ACC_OFFSET_X;
     
238.   MPU6050_ACC_LAST_Y = (MPU6050WORK ->MPU6050_ACC_Y) - ACC_OFFSET_Y;
     
239.   MPU6050_ACC_LAST_Z = (MPU6050WORK ->MPU6050_ACC_Z) - ACC_OFFSET_Z;
     
240.   
     
241.   MPU6050_GYRO_LAST_X = (MPU6050WORK ->MPU6050_GYRO_X) - GYRO_OFFSET_X;
     
242.   MPU6050_GYRO_LAST_Y = (MPU6050WORK ->MPU6050_GYRO_Y) - GYRO_OFFSET_Y;
     
243.   MPU6050_GYRO_LAST_Z = (MPU6050WORK ->MPU6050_GYRO_Z) - GYRO_OFFSET_Z;
     
244. 
     
245.   if(!GYRO_OFFSET_OK)
     
246.   {
     
247.     static long int tempgx=0,tempgy=0,tempgz=0;
     
248.     static unsigned char cnt_g=0;
     
249. 
     
250.     if(cnt_g==0)
     
251.     {
     
252.       GYRO_OFFSET_X=0;
     
253.       GYRO_OFFSET_Y=0;
     
254.       GYRO_OFFSET_Z=0;
     
255.       tempgx = 0;
     
256.       tempgy = 0;
     
257.       tempgz = 0;
     
258.       cnt_g = 1;
     
259.     }
     
260.     tempgx+= MPU6050_GYRO_LAST_X;
     
261.     tempgy+= MPU6050_GYRO_LAST_Y;
     
262.     tempgz+= MPU6050_GYRO_LAST_Z;
     
263.     if(cnt_g==200)
     
264.     {
     
265.       GYRO_OFFSET_X=tempgx/cnt_g;
     
266.       GYRO_OFFSET_Y=tempgy/cnt_g;
     
267.       GYRO_OFFSET_Z=tempgz/cnt_g;
     
268.       cnt_g = 0;
     
269.       GYRO_OFFSET_OK = 1;
     
270.       
     
271.     }
     
272.     cnt_g++;
     
273.   }
     
274.   if(!ACC_OFFSET_OK)
     
275.   {
     
276.     static long int tempax=0,tempay=0,tempaz=0;
     
277.     static unsigned char cnt_a=0;
     
278.    
     
279.     if(cnt_a==0)
     
280.     {
     
281.       ACC_OFFSET_X = 0;
     
282.       ACC_OFFSET_Y = 0;
     
283.       ACC_OFFSET_Z = 0;
     
284.       tempax = 0;
     
285.       tempay = 0;
     
286.       tempaz = 0;
     
287.       cnt_a = 1;
     
288.       
     
289.     }
     
290.     tempax += MPU6050_ACC_LAST_X;//累加
     
291.     tempay += MPU6050_ACC_LAST_Y;
     
292.     tempaz += MPU6050_ACC_LAST_Z;
     
293.     if(cnt_a==200)
     
294.     {
     
295.       ACC_OFFSET_X = tempax/cnt_a;
     
296.       ACC_OFFSET_Y = tempay/cnt_a;
     
297.       ACC_OFFSET_Z = tempaz/cnt_a;
     
298.       cnt_a = 0;
     
299.       ACC_OFFSET_OK = 1;
     
300.       
     
301.     }
     
302.     cnt_a++;
     
303.   }
     
304. #endif
     
305.   
     
306. }
     
307. 
     
308. /**********************************************************/
     
309. //函数名称：void MPU6050Init
     
310. //入口参数：无
     
311. //出口参数：无
     
312. //函数功能：MPU6050初始化
     
313. /**********************************************************/
     
314. void MPU6050_Init()
     
315. {
     
316. #ifdef IMITATEIIC
     
317.   InitImitateIICPort();
     
318. #else
     
319.   I2C_Init(SlaveAddr);
     
320. #endif
     
321.   I2C_Write(PWR_MGMT_1,0x00); //resume from sleep.
     
322.   I2C_Write(SMPLRT_DIV, 0x07);
     
323.   I2C_Write(CONFIG, 0x06);
     
324.   I2C_Write(GYRO_CONFIG, 0x18);
     
325.   I2C_Write(ACCEL_CONFIG, 0x01);
     
326. }
     
327. /**********************************************************/
     
328. //函数名称：int Get16Bit
     
329. //入口参数：address:读取数据的地址
     
330. //出口参数：无
     
331. //函数功能：获取MPU6050相应地址上的数据
     
332. /**********************************************************/
     
333. int Get16Bit (unsigned char  address)
     
334. {
     
335. #ifndef MULTIREAD
     
336.   unsigned char  ho,lo;
     
337.   int temp ;
     
338.   ho = I2C_Read(address);
     
339.   lo = I2C_Read(address+1);
     
340.   temp=ho;
     
341.   temp<<=8;
     
342.   temp+=lo;
     
343.   return temp ;
     
344. #else
     
345.   return( Double_Read_ADXL345(address));
     
346. #endif
     
347. }
     
348. /**********************************************************/
     
349. //函数名称：
     
350. //入口参数：无
     
351. //出口参数：无
     
352. //函数功能：获取MPU6050相应轴上的加速度数据
     
353. /**********************************************************/
     
354. // X/Y/Z-Axis Acceleration
     
355. int GetAccelX ()
     
356. {
     
357.   return Get16Bit(ACCEL_XOUT_H);
     
358. }
     
359. 
     
360. int GetAccelY ()
     
361. {
     
362.   return Get16Bit(ACCEL_YOUT_H);
     
363. }
     
364. 
     
365. int GetAccelZ ()
     
366. {
     
367.   return Get16Bit(ACCEL_ZOUT_H);
     
368. }
     
369. /**********************************************************/
     
370. //函数名称：
     
371. //入口参数：无
     
372. //出口参数：无
     
373. //函数功能：获取MPU6050相应轴上的角速度数据
     
374. /**********************************************************/
     
375. // X/Y/Z-Axis Angular velocity
     
376. int GetAnguX ()
     
377. {
     
378.   return Get16Bit(GYRO_XOUT_H);
     
379. }
     
380. 
     
381. int GetAnguY ()
     
382. {
     
383.   return Get16Bit(GYRO_YOUT_H);
     
384. }
     
385. 
     
386. int GetAnguZ ()
     
387. {
     
388.   return Get16Bit(GYRO_ZOUT_H);
     
389. }
     
390. 
     
391. 
     
392. 
     
393. #include"msp430iic.h"  
     
394. 
     
395. struct MPU6050Struct    MPU6050Data;
     
396. void InitImitateIICPort(void)
     
397. {
     
398.   SET_SDA_OUT;          //set  SDA PIN is out mode
     
399.   SDA_HIGH;             // set SDA PIN out is high
     
400.   SCL_HIGH;             //set SCL PIN is input mode ,pull up register to SCL PIN high
     
401. }
     
402. 
     
403. /**************************************
     
404. 起始信号
     
405. **************************************/
     
406. void ADXL345_Start(void)
     
407. {
     
408.     SET_SDA_OUT;
     
409.     SDA_HIGH;                    //拉高数据线
     
410.     SCL_HIGH;                    //拉高时钟线
     
411.     Delay5us();                 //延时
     
412.     SDA_LOW;                    //产生下降沿
     
413.     Delay5us();                 //延时
     
414.     SCL_LOW;                    //拉低时钟线
     
415. }
     
416. 
     
417. /**************************************
     
418. 停止信号
     
419. **************************************/
     
420. void ADXL345_Stop(void)
     
421. {
     
422.     SET_SDA_OUT;
     
423.     SDA_LOW;                    //拉低数据线
     
424.     SCL_HIGH;                    //拉高时钟线
     
425.     Delay5us();                 //延时
     
426.     SDA_HIGH;                    //产生上升沿
     
427.     Delay5us();                 //延时
     
428. }
     
429. 
     
430. /**************************************
     
431. 发送应答信号
     
432. 入口参数:ack (0:ACK 1:NAK)
     
433. **************************************/
     
434. void ADXL345_SendACK(unsigned char ack)
     
435. {
     
436.     SET_SDA_OUT;
     
437.     if(ack)
     
438.       SDA_HIGH;                //写NACK应答信号
     
439.     else
     
440.       SDA_LOW;                 //写ACK应答信号
     
441.     SCL_HIGH;                    //拉高时钟线
     
442.     Delay5us();                 //延时
     
443.     SCL_LOW;                    //拉低时钟线
     
444.     Delay5us();                 //延时
     
445. }
     
446. 
     
447. /**************************************
     
448. 接收应答信号
     
449. **************************************/
     
450. unsigned char ADXL345_RecvACK(void)
     
451. {
     
452.     unsigned char ack;
     
453.     //------------------//
     
454.     //一下两句切不可调换顺序，否则会导致时序错误
     
455.     SET_SDA_IN;
     
456.     SCL_HIGH;                    //拉高时钟线  
     
457.     //-----------------//
     
458.     Delay5us();                 //延时
     
459.     ack = SDA_IN;                   //读应答信号
     
460.     SCL_LOW;                    //拉低时钟线
     
461.     Delay5us();                 //延时
     
462.     return ack;
     
463. }
     
464. 
     
465. /**************************************
     
466. 向IIC总线发送一个字节数据
     
467. **************************************/
     
468. void ADXL345_Senduchar(unsigned char dat)
     
469. {
     
470.     unsigned char i,m;
     
471.     SET_SDA_OUT;
     
472.     for (i=8; i!=0; i--)         //8位计数器
     
473.     {
     
474.         m=dat & 0x80;           //移出数据的最高位
     
475.         if(m == 0x80)
     
476.             SDA_HIGH;
     
477.         else
     
478.             SDA_LOW;
     
479.         SCL_HIGH;                //拉高时钟线
     
480.         Delay5us();             //延时
     
481.         SCL_LOW;                //拉低时钟线
     
482.         dat=dat<<1;
     
483.         Delay5us();             //延时
     
484.     }
     
485.     ADXL345_RecvACK();
     
486. }
     
487. 
     
488. /**************************************
     
489. 从IIC总线接收一个字节数据
     
490. **************************************/
     
491. unsigned char  ADXL345_Recvuchar(void)
     
492. {
     
493.     unsigned char  i;
     
494.     unsigned char dat = 0;
     
495.     unsigned char m;
     
496.     SDA_HIGH;                    //使能内部上拉,准备读取数据,
     
497.     SET_SDA_IN;
     
498.     for (i=8; i!=0; i--)         //8位计数器
     
499.     {
     
500.         dat <<= 1;
     
501.         SCL_HIGH;                //拉高时钟线
     
502.         SET_SDA_IN;
     
503.         m = SDA_IN;
     
504.         if(m == I2C_SDA)
     
505.             dat = dat|0x01;
     
506.         Delay5us();             //延时
     
507.         SCL_LOW;                //拉低时钟线
     
508.         Delay5us();             //延时
     
509.     }
     
510.     return dat;
     
511. }
     
512. 
     
513. //******单字节写入*******************************************
     
514. 
     
515. void Single_Write_ADXL345(unsigned char REG_Address,unsigned char REG_data)
     
516. {
     
517.     ADXL345_Start();                  //起始信号
     
518.     ADXL345_Senduchar(SlaveAddress);   //发送设备地址+写信号
     
519.     ADXL345_Senduchar(REG_Address);    //内部寄存器地址，请参考中文pdf22页
     
520.     ADXL345_Senduchar(REG_data);       //内部寄存器数据，请参考中文pdf22页
     
521.     ADXL345_Stop();                   //发送停止信号
     
522. }
     
523. 
     
524. //********单字节读取*****************************************
     
525. unsigned char  Single_Read_ADXL345(unsigned char  REG_Address)
     
526. {  unsigned char REG_data=0;
     
527.     ADXL345_Start();                          //起始信号
     
528.     ADXL345_Senduchar(SlaveAddress);           //发送设备地址+写信号
     
529.     ADXL345_Senduchar(REG_Address);                   //发送存储单元地址，从0开始
     
530.     ADXL345_Start();                          //起始信号
     
531.     ADXL345_Senduchar(SlaveAddress+1);         //发送设备地址+读信号
     
532.     REG_data=ADXL345_Recvuchar();              //读出寄存器数据
     
533.     ADXL345_SendACK(1);                     //NACK
     
534.     ADXL345_Stop();                           //停止信号
     
535.     return REG_data;
     
536. }
     
537. //********多字节读取*****************************************
     
538. int  Double_Read_ADXL345(unsigned char  REG_Address)
     
539. {
     
540.     unsigned char ValueL=0;
     
541.     int Value=0;
     
542.     ADXL345_Start();                            //起始信号
     
543.     ADXL345_Senduchar(SlaveAddress);            //发送设备地址+写信号
     
544.     ADXL345_Senduchar(REG_Address);             //发送存储单元地址，从0开始
     
545.     ADXL345_Start();                            //起始信号
     
546.     ADXL345_Senduchar(SlaveAddress+1);          //发送设备地址+读信号
     
547.    
     
548.     Value=ADXL345_Recvuchar();                  //读出寄存器数据
     
549.     ADXL345_SendACK(0);                         //ACK
     
550.    
     
551.     ValueL=ADXL345_Recvuchar();                 //读出寄存器数据
     
552.     ADXL345_SendACK(1);                         //NACK
     
553.    
     
554.     ADXL345_Stop();                             //停止信号
     
555.     Value=(Value<<8)+ValueL;
     
556.     return Value;
     
557. }
     
558. 
     
559. struct MPU6050Struct *ReadMPU6050All()
     
560. {
     
561.   unsigned char TempAcc1=0,TempAcc2=0,TempAcc3=0,TempAcc4=0,TempAcc5=0,TempAcc6=0;
     
562.   unsigned char TempGyro1=0,TempGyro2=0,TempGyro3=0,TempGyro4=0,TempGyro5=0,TempGyro6=0;
     
563. 
     
564.     ADXL345_Start();                            //起始信号
     
565.     ADXL345_Senduchar(SlaveAddress);            //发送设备地址+写信号
     
566.     ADXL345_Senduchar(0x3B);                    //发送存储单元地址，从0x3b开始
     
567.     ADXL345_Start();                            //起始信号
     
568.     ADXL345_Senduchar(SlaveAddress+1);          //发送设备地址+读信号
     
569.    
     
570.     TempAcc2=ADXL345_Recvuchar();                  //读出寄存器数据
     
571.     ADXL345_SendACK(0);                         //ACK
     
572.    
     
573.     TempAcc1=ADXL345_Recvuchar();                 //读出寄存器数据
     
574.     ADXL345_SendACK(0);                         //ACK
     
575.    
     
576.     TempAcc4=ADXL345_Recvuchar();                  //读出寄存器数据
     
577.     ADXL345_SendACK(0);                         //ACK
     
578.    
     
579.     TempAcc3=ADXL345_Recvuchar();                 //读出寄存器数据
     
580.     ADXL345_SendACK(0);                         //ACK
     
581.    
     
582.     TempAcc6=ADXL345_Recvuchar();                  //读出寄存器数据
     
583.     ADXL345_SendACK(0);                         //ACK
     
584.    
     
585.     TempAcc5=ADXL345_Recvuchar();                 //读出寄存器数据
     
586.     ADXL345_SendACK(0);                         //ACK
     
587.    
     
588.     ADXL345_Recvuchar();                         //丢弃不连续地址的数据
     
589.     ADXL345_SendACK(0);                         //ACK
     
590.    
     
591.     ADXL345_Recvuchar();                         //丢弃不连续地址的数据
     
592.     ADXL345_SendACK(0);
     
593.    
     
594.     TempGyro2=ADXL345_Recvuchar();                  //读出寄存器数据
     
595.     ADXL345_SendACK(0);                         //ACK
     
596.    
     
597.     TempGyro1=ADXL345_Recvuchar();                 //读出寄存器数据
     
598.     ADXL345_SendACK(0);
     
599.    
     
600.     TempGyro4=ADXL345_Recvuchar();                  //读出寄存器数据
     
601.     ADXL345_SendACK(0);                         //ACK
     
602.    
     
603.     TempGyro3=ADXL345_Recvuchar();                 //读出寄存器数据
     
604.     ADXL345_SendACK(0);
     
605.    
     
606.     TempGyro6=ADXL345_Recvuchar();                  //读出寄存器数据
     
607.     ADXL345_SendACK(0);                         //ACK
     
608.    
     
609.     TempGyro5=ADXL345_Recvuchar();                 //读出寄存器数据
     
610.     ADXL345_SendACK(1);                         //NACK
     
611.    
     
612.     ADXL345_Stop();
     
613. 
     
614.     MPU6050Data.MPU6050_ACC_X=(TempAcc2<<8) + TempAcc1;
     
615.     MPU6050Data.MPU6050_ACC_Y=(TempAcc4<<8) + TempAcc3;
     
616.     MPU6050Data.MPU6050_ACC_Z=(TempAcc6<<8) + TempAcc5;
     
617.    
     
618.     MPU6050Data.MPU6050_GYRO_X=(TempGyro2<<8) + TempGyro1;
     
619.     MPU6050Data.MPU6050_GYRO_Y=(TempGyro4<<8) + TempGyro3;
     
620.     MPU6050Data.MPU6050_GYRO_Z=(TempGyro6<<8) + TempGyro5;
     
621.     return (&MPU6050Data);
     
622. }
     
623. 
     
624. 
     
625. /*
     
626. * This file contains some uSCI_A0 operation.
     
627. * By IC爬虫 (1394024051@qq.com)
     
628. * 2014-4-28 v1.0
     
629. */
     
630. //#include "msp430g2553.h"
     
631. #include "USCI_A0.h"
     
632. //#include "stdio.h"
     
633. #include "mpu6050.h"
     
634. #include "IMU.h"
     
635. 
     
636. #define uchar unsigned char
     
637. #define uint unsigned int
     
638. 
     
639. //将“int”类型的数据分成两个单字节的数据
     
640. #define BYTE0(dwTemp)       (*(char *)(&dwTemp))
     
641. #define BYTE1(dwTemp)       (*((char *)(&dwTemp) + 1))
     
642. #define BYTE2(dwTemp)       (*((char *)(&dwTemp) + 2))
     
643. #define BYTE3(dwTemp)       (*((char *)(&dwTemp) + 3))
     
644. 
     
645. /*********************************************************
     
646. *名称：USCI_A0_init
     
647. *功能：串口初始化
     
648. *入口参数：无
     
649. *出口参数：无
     
650. *说明：设置为P1.1和P1.2为串口通信端口
     
651. **********************************************************/
     
652. void USCI_A0_init(void)
     
653. {
     
654.   P1SEL = BIT1 + BIT2 ;   // P1.1 = RXD, P1.2=TXD
     
655.   P1SEL2 = BIT1 + BIT2;                     
     
656.   UCA0CTL1 |= UCSSEL_2;   // SMCLK
     
657.   /*
     
658.   UCA0BR0 = 0x45;         // 8MHz 115200
     
659.   UCA0BR1 = 0;            // 8MHz 115200
     
660.   UCA0MCTL = 0x4a;        // 8MHz 115200  */   
     
661.   /*
     
662.   UCA0BR0 = 0x68;
     
663.   UCA0BR1 = 0;
     
664.   UCA0MCTL = 0x40;
     
665.   */
     
666.   UCA0MCTL = UCBRF_0 | UCBRS_4;
     
667.    
     
668.     /* Baud rate control register 0 */
     
669.     UCA0BR0 = 69;
     
670.   UCA0CTL1 &= ~UCSWRST;          // **Initialize USCI state machine**
     
671.   
     
672.   //IE2 |= UCA0RXIE + UCA0TXIE;  // Enable USCI_A0 TX/RX interrupt
     
673.   //IE2 |= UCA0RXIE;             // Enable USCI_A0 RX interrupt
     
674.   //__bis_SR_register(GIE);      // Enter LPM3 w/ interrupts enabled
     
675. }
     
676. 
     
677. 
     
678. /*********************************************************
     
679. *名称：UartTX_Send_String
     
680. *功能：串口发送字符串函数
     
681. *入口参数：*data:数据指针        len :数据长度
     
682. *出口参数：无
     
683. *说明：
     
684. **********************************************************/
     
685. void UartTX_Send_String(unsigned char *Data,int len)
     
686. {
     
687.   int j;
     
688.   for(j=0;j<len;j++)
     
689.   {
     
690.     UartTX_Send_char(*Data++);
     
691.   }
     
692. }
     
693. 
     
694. /*********************************************************
     
695. *名称：UartTX_Send_char
     
696. *功能：串口发送字符函数
     
697. *入口参数：c
     
698. *出口参数：无
     
699. *说明：
     
700. **********************************************************/
     
701. unsigned char UartTX_Send_char(unsigned char c)
     
702. {
     
703.     UCA0TXBUF=c;   
     
704.     while(!(IFG2&UCA0TXIFG));
     
705.     IFG2&=~UCA0TXIFG;
     
706.     return c;
     
707. }
     
708. /*********************************************************
     
709. *名称：int putchar
     
710. *功能：串口发送字符函数
     
711. *入口参数：ch
     
712. *出口参数：无
     
713. *说明：
     
714. **********************************************************/
     
715. int putchar(int ch)
     
716. {
     
717.   UCA0TXBUF=ch;
     
718.   while(!(IFG2&UCA0TXIFG));
     
719.    //UCA0TXBUF=ch;
     
720.   IFG2&=~UCA0TXIFG;
     
721.    return ch;
     
722. }
     
723. 
     
724. 
     
725. void sendChar(unsigned char c)
     
726. {
     
727.    while(!(IFG2&UCA0TXIFG));
     
728.    UCA0TXBUF=c;
     
729. }
     
730. 
     
731. void sendStr(unsigned char *s)
     
732. {
     
733.   while(*s!='\0')
     
734.   {
     
735.     sendChar(*s);
     
736.     s++;
     
737.   }
     
738. }
     
739. 
     
740. /*********************************************************
     
741. *名称：void Uart1_Send_AF
     
742. *功能：串口发送姿态数据
     
743. *入口参数：无
     
744. *出口参数：无
     
745. *说明：每一次执行这个函数就算是一帧数据，帧头为0X88，功能字
     
746. *      为0XAF
     
747. **********************************************************/
     
748. void Uart1_Send_AF(void)
     
749. {
     
750.   unsigned char sum = 0;//累加串口发送的数据的值，做校验用
     
751.   unsigned int _temp;   
     
752.   sum += UartTX_Send_char(0x88);  //帧头
     
753.   sum += UartTX_Send_char(0xAF);  //功能字
     
754.   
     
755.   sum += UartTX_Send_char(0x1c);
     
756.   sum += UartTX_Send_char( BYTE1(MPU6050_ACC_LAST_X) ); //发送加速度X轴数据的高8位
     
757.   sum += UartTX_Send_char( BYTE0(MPU6050_ACC_LAST_X) ); //发送加速度X轴数据的低8位
     
758.   
     
759.   sum += UartTX_Send_char( BYTE1(MPU6050_ACC_LAST_Y) ); //发送加速度Y轴数据的高8位
     
760.   sum += UartTX_Send_char( BYTE0(MPU6050_ACC_LAST_Y) ); //发送加速度Y轴数据的低8位
     
761.   
     
762.   sum += UartTX_Send_char( BYTE1(MPU6050_ACC_LAST_Z) ); //发送加速度Z轴数据的高8位
     
763.   sum += UartTX_Send_char( BYTE0(MPU6050_ACC_LAST_Z) ); //发送加速度Z轴数据的低8位
     
764.   
     
765.   sum += UartTX_Send_char( BYTE1(MPU6050_GYRO_LAST_X) ); //发送陀螺仪X轴数据的高8位
     
766.   sum += UartTX_Send_char( BYTE0(MPU6050_GYRO_LAST_X) ); //发送陀螺仪X轴数据的低8位
     
767.   
     
768.   sum += UartTX_Send_char( BYTE1(MPU6050_GYRO_LAST_Y) ); //发送陀螺仪Y轴数据的高8位
     
769.   sum += UartTX_Send_char( BYTE0(MPU6050_GYRO_LAST_Y) ); //发送陀螺仪Y轴数据的低8位
     
770.   
     
771.   sum += UartTX_Send_char( BYTE1(MPU6050_GYRO_LAST_Z) ); //发送陀螺仪Z轴数据的高8位
     
772.   sum += UartTX_Send_char( BYTE0(MPU6050_GYRO_LAST_Z) ); //发送陀螺仪Z轴数据的低8位
     
773.   sum += UartTX_Send_char(0);
     
774.   sum += UartTX_Send_char(0);
     
775.   sum += UartTX_Send_char(0);
     
776.   sum += UartTX_Send_char(0);
     
777.   sum += UartTX_Send_char(0);
     
778.   sum += UartTX_Send_char(0);
     
779.         
     
780.   _temp = (long int)(Q_ANGLE_X*100);
     
781.   sum += UartTX_Send_char( BYTE1(_temp) );
     
782.   sum += UartTX_Send_char( BYTE0(_temp) );
     
783.   _temp = (long int)(Q_ANGLE_Y*100);
     
784.   sum += UartTX_Send_char( BYTE1(_temp) );
     
785.   sum += UartTX_Send_char( BYTE0(_temp) );
     
786.         
     
787.   sum += UartTX_Send_char(0);
     
788.   sum += UartTX_Send_char(0);
     
789.   sum += UartTX_Send_char(0);
     
790.   sum += UartTX_Send_char(0);
     
791.   sum += UartTX_Send_char(0);
     
792.   sum += UartTX_Send_char(0);
     
793.   
     
794.   UartTX_Send_char(sum); //串口发送累加值用于校验
     
795. }
     
796. 
     
797. 
     
798. /*
     
799. * This file contains some IMU operation.
     
800. * By IC爬虫 (1394024051@qq.com)
     
801. * 2014-4-29 v1.0
     
802. */
     
803. #include "IMU.h"
     
804. 
     
805. #define RtA           57.324841  //弧度到角度
     
806. #define AtR              0.0174533  //度到角度
     
807. #define Acc_G           0.0011963  //加速度变成G
     
808. #define Gyro_G           0.0152672  //角速度变成度
     
809. #define Gyro_Gr          0.0002663                                
     
810. #define FILTER_NUM 20
     
811. 
     
812. int   ACC_AVG_X,ACC_AVG_Y,ACC_AVG_Z;      //平均值滤波后的ACC
     
813. float GYRO_I_X,GYRO_I_Y,GYRO_I_Z;         //陀螺仪积分
     
814. float EXP_ANGLE_X,EXP_ANGLE_Y,EXP_ANGLE_Z;//期望角度
     
815. float DIF_ANGLE_X,DIF_ANGLE_Y,DIF_ANGLE_Z;//期望角度和实际角度的差
     
816. float Q_ANGLE_X,Q_ANGLE_Y,Q_ANGLE_Z;      //四元数计算出的角度
     
817. 
     
818. int ACC_X_BUF[FILTER_NUM],ACC_Y_BUF[FILTER_NUM],ACC_Z_BUF[FILTER_NUM];        //加速度滑动窗口滤波数组
     
819. 
     
820. /**********************************************************/
     
821. //函数名称：Prepare_Data
     
822. //入口参数：无
     
823. //出口参数：无
     
824. //函数功能：读取MPU6050数据进行平滑滤波，为后续计算准备数据
     
825. /**********************************************************/
     
826. void Prepare_Data(void)
     
827. {
     
828.   static unsigned char filter_cnt=0;
     
829.   long int temp1=0,temp2=0,temp3=0;
     
830.   unsigned char i;
     
831.         
     
832.   MPU6050_Dataanl();//完成传感器数据的读取和计算，并且对数据简单处理
     
833.         
     
834.   ACC_X_BUF[filter_cnt] = MPU6050_ACC_LAST_X;//更新滑动窗口数组
     
835.   ACC_Y_BUF[filter_cnt] = MPU6050_ACC_LAST_Y;
     
836.   ACC_Z_BUF[filter_cnt] = MPU6050_ACC_LAST_Z;
     
837.   
     
838.   for(i=0;i<FILTER_NUM;i++)
     
839.   {
     
840.     temp1 += ACC_X_BUF[i];
     
841.     temp2 += ACC_Y_BUF[i];
     
842.     temp3 += ACC_Z_BUF[i];
     
843.   }
     
844.   
     
845.   ACC_AVG_X = temp1 / FILTER_NUM;
     
846.   ACC_AVG_Y = temp2 / FILTER_NUM;
     
847.   ACC_AVG_Z = temp3 / FILTER_NUM;
     
848.   
     
849.   filter_cnt++;
     
850.   
     
851.   if(filter_cnt==FILTER_NUM)  filter_cnt=0;
     
852.         
     
853.   GYRO_I_X += MPU6050_GYRO_LAST_X*Gyro_G*0.02;//0.0001是时间间隔，两次prepare函数的执行周期
     
854.   GYRO_I_Y += MPU6050_GYRO_LAST_Y*Gyro_G*0.02;//示波器测量的得到的时间是20ms.
     
855.   GYRO_I_Z += MPU6050_GYRO_LAST_Z*Gyro_G*0.02;
     
856. }
     
857. 
     
858. void Get_Attitude(void)
     
859. {
     
860.   IMUupdate( MPU6050_GYRO_LAST_X*Gyro_Gr,
     
861.             MPU6050_GYRO_LAST_Y*Gyro_Gr,
     
862.             MPU6050_GYRO_LAST_Z*Gyro_Gr,
     
863.             ACC_AVG_X,ACC_AVG_Y,ACC_AVG_Z);        //*0.0174转成弧度
     
864. }
     
865. ////////////////////////////////////////////////////////////////////////////////
     
866. #define Kp 10.0f        // proportional gain governs rate of convergence to accelerometer/magnetometer
     
867. #define Ki 0.008f       // integral gain governs rate of convergence of gyroscope biases
     
868. #define halfT 0.004f    // half the sample period采样周期的一半
     
869. 
     
870. float q0 = 1, q1 = 0, q2 = 0, q3 = 0;    // quaternion elements representing the estimated orientation
     
871. float exInt = 0, eyInt = 0, ezInt = 0;    // scaled integral error
     
872. /**********************************************************/
     
873. //函数名称：IMUupdate
     
874. //入口参数：gx：浮点型的陀螺仪x轴数据
     
875. //          gy：浮点型的陀螺仪y轴数据
     
876. //          gz：浮点型的陀螺仪z轴数据
     
877. //          ax：浮点型的加速度x轴数据
     
878. //          ay：浮点型的加速度y轴数据
     
879. //          az：浮点型的加速度z轴数据
     
880. //出口参数：无
     
881. //函数功能：通过陀螺仪和加速度传感器的数据用四元数计算姿态
     
882. /**********************************************************/
     
883. void IMUupdate(float gx, float gy, float gz, float ax, float ay, float az)
     
884. {
     
885.   float norm;
     
886. //  float hx, hy, hz, bx, bz;
     
887.   float vx, vy, vz;// wx, wy, wz;
     
888.   float ex, ey, ez;
     
889. 
     
890.   //先把这些需要用到的值弄好
     
891.   float q0q0 = q0*q0;
     
892.   float q0q1 = q0*q1;
     
893.   float q0q2 = q0*q2;
     
894. //  float q0q3 = q0*q3;
     
895.   float q1q1 = q1*q1;
     
896. //  float q1q2 = q1*q2;
     
897.   float q1q3 = q1*q3;
     
898.   float q2q2 = q2*q2;
     
899.   float q2q3 = q2*q3;
     
900.   float q3q3 = q3*q3;
     
901.         
     
902.   if(ax*ay*az==0) return;
     
903.                
     
904.   norm = sqrt(ax*ax + ay*ay + az*az);//acc数据归一化
     
905.   ax = ax /norm;
     
906.   ay = ay / norm;
     
907.   az = az / norm;
     
908. 
     
909.   // estimated direction of gravity and flux (v and w)   估计重力方向和流量/变迁
     
910.   vx = 2*(q1q3 - q0q2);        //四元数中xyz的表示
     
911.   vy = 2*(q0q1 + q2q3);
     
912.   vz = q0q0 - q1q1 - q2q2 + q3q3 ;
     
913. 
     
914.   // error is sum of cross product between reference direction of fields and direction measured by sensors
     
915.   ex = (ay*vz - az*vy) ;   //向量外积在相减得到差分就是误差
     
916.   ey = (az*vx - ax*vz) ;
     
917.   ez = (ax*vy - ay*vx) ;
     
918. 
     
919.   exInt = exInt + ex * Ki; //对误差进行积分
     
920.   eyInt = eyInt + ey * Ki;
     
921.   ezInt = ezInt + ez * Ki;
     
922. 
     
923.   // adjusted gyroscope measurements
     
924.   gx = gx + Kp*ex + exInt; //将误差PI后补偿到陀螺仪，即补偿零点漂移
     
925.   gy = gy + Kp*ey + eyInt;
     
926.   gz = gz + Kp*ez + ezInt; //这里的gz由于没有观测者进行矫正会产生漂移，变现出来的就是积分自增或者自减
     
927. 
     
928.   // integrate quaternion rate and normalise //四元数的微分方程
     
929.   q0 = q0 + (-q1*gx - q2*gy - q3*gz)*halfT;
     
930.   q1 = q1 + (q0*gx + q2*gz - q3*gy)*halfT;
     
931.   q2 = q2 + (q0*gy - q1*gz + q3*gx)*halfT;
     
932.   q3 = q3 + (q0*gz + q1*gy - q2*gx)*halfT;
     
933. 
     
934.   // normalise quaternion
     
935.   norm = sqrt(q0*q0 + q1*q1 + q2*q2 + q3*q3);
     
936.   q0 = q0 / norm;
     
937.   q1 = q1 / norm;
     
938.   q2 = q2 / norm;
     
939.   q3 = q3 / norm;
     
940. 
     
941.   //Q_ANGLE.Yaw = atan2(2 * q1 * q2 + 2 * q0 * q3, -2 * q2*q2 - 2 * q3* q3 + 1)* 57.3; // yaw
     
942.   Q_ANGLE_Y  = asin(-2 * q1 * q3 + 2 * q0* q2)* 57.3; // pitch
     
943.   Q_ANGLE_X = atan2(2 * q2 * q3 + 2 * q0 * q1, -2 * q1 * q1 - 2 * q2* q2 + 1)* 57.3; // roll
     
944. }
     
945. 
     
946. 
     
947. 
     
948. 
     
949. /*
     
950. * This file contains some I2C operation.
     
951. * By IC爬虫 (1394024051@qq.com)
     
952. * 2014-4-13 v1.0
     
953. */
     
954. #include "HardWareIIC.h"
     
955. 
     
956. uchar I2CSendBuffer[2],I2CRecvBuffer; //I2C发送缓存和接收缓存
     
957. 
     
958. int I2CSendPtr=0;
     
959. 
     
960. /**********************************************************/
     
961. //函数名称：void I2C_Init
     
962. //入口参数：SlaveAddr:从机的设备地址
     
963. //出口参数：无
     
964. //函数功能：I2C初始化，P1.6->SCL ,P1.7->SDA
     
965. /**********************************************************/
     
966. void I2C_Init (unsigned char SlaveAddr)
     
967. {
     
968.   P1SEL |= BIT6+BIT7;               // Assign I2C pins to USCI_B0
     
969.   P1SEL2|= BIT6+BIT7;               // Assign I2C pins to USCI_B0
     
970.   UCB0CTL1 |= UCSWRST;              // Enable SW reset
     
971.   
     
972.   UCB0CTL0 = UCMST+UCMODE_3+UCSYNC; // I2C Master, synchronous mode
     
973.   UCB0CTL0 &= ~(UCSLA10+UCA10);                        //7 bit add of slave and master
     
974.   
     
975.   UCB0CTL1 = UCSSEL_2+UCSWRST;      // Use SMCLK, keep SW reset
     
976.   
     
977.   UCB0BR0 = 80;                     // fSCL = SMCLK/12 = ~100kHz
     
978.   UCB0BR1 = 0;
     
979.   
     
980.   UCB0I2COA = 0x01A5;                                                                //set own address
     
981.   UCB0I2CSA = SlaveAddr;            // Set slave address
     
982.   
     
983.   IE2 &= ~(UCB0RXIE+UCB0TXIE);         // disenable  TX&RX interrupt
     
984.   UCB0CTL1 &= ~UCSWRST;             // Clear SW reset, resume operation
     
985.   
     
986. }
     
987. /**********************************************************/
     
988. //函数名称：void I2C_WriteInit
     
989. //入口参数：无
     
990. //出口参数：无
     
991. //函数功能：I2C写数据初始化，发送模式，接收中断关闭，发送中断关闭
     
992. /**********************************************************/
     
993. void I2C_WriteInit()
     
994. {
     
995.   UCB0CTL1 |= UCTR;            // UCTR=1 => Transmit Mode (R/W bit = 0)
     
996.   IFG2 &= ~UCB0TXIFG;                //clean TX interrupt sign
     
997.   IE2 &= ~UCB0RXIE;           // disable Receive ready interrupt
     
998.   IE2 &= ~UCB0TXIE;     // disable Transmit ready interrupt
     
999. }
     
1000. /**********************************************************/
      
1001. //函数名称：void I2C_ReadInit
      
1002. //入口参数：无
      
1003. //出口参数：无
      
1004. //函数功能：I2C读数据初始化，接收模式，接收中断关闭，发送中断关闭
      
1005. /**********************************************************/
      
1006. void I2C_ReadInit()
      
1007. {
      
1008.   UCB0CTL1 &= ~UCTR;   // UCTR=0 => Receive Mode (R/W bit = 1)
      
1009.   IFG2 &= ~UCB0RXIFG;
      
1010.   IE2 &= ~UCB0TXIE;    // disable Transmit ready interrupt
      
1011.   IE2 &= ~UCB0RXIE;     // disable Receive ready interrupt
      
1012. }
      
1013. /**********************************************************/
      
1014. //函数名称：I2C_Write
      
1015. //入口参数：address:需要写入数据的设备的地址
      
1016. //          data：发送的数据
      
1017. //出口参数：无
      
1018. //函数功能：I2C发送数据
      
1019. /**********************************************************/
      
1020. void I2C_Write(uchar address,uchar data)
      
1021. {
      
1022. 
      
1023.   I2C_WriteInit();
      
1024.   UCB0CTL1 |= UCTXSTT;          //generate start condition
      
1025.   //while(UCB0CTL1 & UCTXSTT);        //generate start condition ,and transmit slave address and write bit
      
1026.   while(!(IFG2 & UCB0TXIFG));   //wait start condition and equipment address transmitted
      
1027.   IFG2 &= ~UCB0TXIFG;           //clean UCB0TXIFG
      
1028.   while(UCB0CTL1 & UCTXSTT);    //wait slave acknowledge
      
1029.   
      
1030.   UCB0TXBUF=address;                //send address code
      
1031.   while(!(IFG2 & UCB0TXIFG ));        //wait sending over
      
1032.   IFG2 &= ~UCB0TXIFG;            // Clear USCI_B0 TX int flag
      
1033.    
      
1034.   UCB0TXBUF=data;                //send  data
      
1035.   while(!(IFG2 & UCB0TXIFG ));                //wait sending over
      
1036.   IFG2 &= ~UCB0TXIFG;            // Clear USCI_B0 TX int flag
      
1037.   
      
1038.   UCB0CTL1 |= UCTXSTP;            // I2C stop condition
      
1039.   while (UCB0CTL1 & UCTXSTP);     // Ensure stop condition got sent
      
1040. }
      
1041. /**********************************************************/
      
1042. //函数名称：uchar I2C_Read
      
1043. //入口参数：address:需要读数据的设备的地址
      
1044. //出口参数：无
      
1045. //函数功能：I2C接收数据
      
1046. /**********************************************************/
      
1047. uchar I2C_Read(uchar address)
      
1048. {
      
1049.   unsigned char data;
      
1050.   while (UCB0STAT & UCBUSY); // wait until I2C module has finished all operations
      
1051.   I2C_WriteInit();
      
1052.   UCB0CTL1 |= UCTXSTT;       // start condition generation
      
1053.   while(UCB0CTL1 & UCTXSTT);
      
1054.   
      
1055.   
      
1056.   UCB0TXBUF=address;                                                        //send address code
      
1057.   while(!(IFG2 & UCB0TXIFG ));                //wait sending over
      
1058.   IFG2 &= ~UCB0TXIFG;            // Clear USCI_B0 TX int flag
      
1059.   
      
1060. // __disable_interrupt();
      
1061. I2C_ReadInit();
      
1062.   while(UCB0RXIFG & IFG2);
      
1063.   IFG2 &= ~UCB0RXIFG;
      
1064.   data  = UCB0RXBUF;
      
1065.   
      
1066.   UCB0CTL1 |= UCTXSTP;            // I2C stop condition
      
1067.   while (UCB0CTL1 & UCTXSTP);     // Ensure stop condition got sent
      
1068.   return data;
      
1069. }
      
1070. 
      
1071. /*----------------------------------------------------------------------------*/
      
1072. // Description:
      
1073. //   Acknowledge Polling. The EEPROM will not acknowledge if a write cycle is
      
1074. //   in progress. It can be used to determine when a write cycle is completed.
      
1075. /*----------------------------------------------------------------------------*/
      
1076. void I2C_AckPolling(void)
      
1077. {
      
1078.   while (UCB0STAT & UCBUSY)
      
1079.   {     
      
1080.     ;// wait until I2C module has
      
1081.   }  // finished all operations
      
1082. 
      
1083.   do
      
1084.   {
      
1085.     UCB0STAT = 0x00;              // clear I2C interrupt flags
      
1086.     UCB0CTL1 |= UCTR;             // I2CTRX=1 => Transmit Mode (R/W bit = 0)
      
1087.     UCB0CTL1 &= ~UCTXSTT;
      
1088.     UCB0CTL1 |= UCTXSTT;          // start condition is generated
      
1089.     while (UCB0CTL1 & UCTXSTT)    // wait till I2CSTT bit was cleared
      
1090.     {   
      
1091.       if (!(UCNACKIFG & UCB0STAT))
      
1092.       {  
      
1093.         break;// Break out if ACK received
      
1094.       }
      
1095.     }
      
1096.     UCB0CTL1 |= UCTXSTP;          // stop condition is generated after
      
1097.                                   // slave address was sent => I2C communication is started
      
1098.     while (UCB0CTL1 & UCTXSTP)
      
1099.     {   
      
1100.       ;// wait till stop bit is reset
      
1101.     }
      
1102.     __delay_cycles(500);          // Software delay
      
1103.    
      
1104.   } while (UCNACKIFG & UCB0STAT);
      
1105. }
      
1106. 
      
1107. 
      
1108. // USCI_B0 Data ISR
      
1109. // Notice : UCSIAB0RX_ISR should be handle with UCSIAB0TX_ISR
      
1110. #pragma vector = USCIAB0TX_VECTOR
      
1111. __interrupt void USCIAB0TX_ISR(void)
      
1112. {
      
1113.   if (UCB0TXIFG & IFG2)      // TX
      
1114.   {
      
1115.     UCB0TXBUF = I2CSendBuffer[I2CSendPtr]; // Load TX buffer
      
1116.     I2CSendPtr--;                          // Decrement TX byte counter
      
1117.     if (I2CSendPtr < 0)
      
1118.     {               
      
1119.       while (!(IFG2 & UCB0TXIFG));         // wait for tx complete
      
1120.       IE2 &= ~UCB0TXIE;                    // disable interrupts.
      
1121.       IFG2 &= ~UCB0TXIFG;                  // Clear USCI_B0 TX int flag
      
1122.       __bic_SR_register_on_exit(LPM0_bits);// Exit LPM0
      
1123.     }
      
1124.   }
      
1125.   else if (UCB0RXIFG & IFG2) // RX
      
1126.   {
      
1127.     I2CRecvBuffer = UCB0RXBUF;             // store received data in buffer
      
1128.     __bic_SR_register_on_exit(LPM0_bits);  // Exit LPM0
      
1129.   }
      
1130. }

复制代码