K60 + L3G4200 LPLD的库(已解决)

孤独stranger

1. #ifndef __DEV_L3G4200_H__
   
2. #define __DEV_L3G4200_H__
   
3. 
   
4. #include "common.h"
   
5. #include "HW_I2C.h"
   
6. 
   
7. /********用户可修改值 开始***********/
   
8. //连接L3G4200用到的I2C通道
   
9. #define L3G4200_I2CX    (I2C1)
   
10. 
    
11. //连接L3G4200用到的SCL引脚
    
12. #define L3G4200_SCLPIN  (PTC10)
    
13. 
    
14. //连接L3G4200用到的SDA引脚
    
15. #define L3G4200_SDAPIN  (PTC11)
    
16. /********用户可修改值 结束***********/
    
17. 
    
18. //定义SCL Bus Speed取值，外设总线为50Mhz时的计算结果
    
19. #define L3G4200_SCL_50KHZ                   (0x33)
    
20. #define L3G4200_SCL_100KHZ                  (0x2B)  
    
21. #define L3G4200_SCL_150KHZ                  (0x28)
    
22. #define L3G4200_SCL_200KHZ                  (0x23)
    
23. #define L3G4200_SCL_250KHZ                  (0x21)
    
24. #define L3G4200_SCL_300KHZ                  (0x20)
    
25. #define L3G4200_SCL_400KHZ                  (0x17)  
    
26. 
    
27. //=========MMA8451 功能参数==================//
    
28. #define L3G4200_DEV_ADDR     0x69         //定义器件地址，可根据硬件修改
    
29. #define L3G4200_DEV_WRITE    0xD2     
    
30. #define L3G4200_DEV_READ     0xD3
    
31. #define L3G4200_DEV_ID       0xD3     //设备ID
    
32. 
    
33. //L3G4200 内部寄存器地址
    
34. #define WHO_AM_I               0x0F
    
35. #define CTRL_REG1              0x20
    
36. #define CTRL_REG2         0x21
    
37. #define CTRL_REG3         0x22
    
38. #define CTRL_REG4         0x23
    
39. #define CTRL_REG5         0x24
    
40. #define REFERENCE         0x25
    
41. #define OUT_TEMP          0x26
    
42. #define STATUS_REG         0x27
    
43. #define OUT_X_L         0x28
    
44. #define OUT_X_H         0x29
    
45. #define OUT_Y_L         0x2A
    
46. #define OUT_Y_H         0x2B
    
47. #define OUT_Z_L         0x2C
    
48. #define OUT_Z_H         0x2D
    
49. 
    
50. 
    
51. //=========L3G4200 STATUS寄存器 寄存器位==================//
    
52. #define L3G4200_STATUS_X_READY   0x01
    
53. #define L3G4200_STATUS_Y_READY   0x02
    
54. #define L3G4200_STATUS_Z_READY   0x04
    
55. #define L3G4200_STATUS_XYZ_READY 0x08
    
56. #define L3G4200_STATUS_X_OW      0x10
    
57. #define ML3G4200_STATUS_Y_OW     0x20
    
58. #define L3G4200_STATUS_Z_OW      0x40
    
59. #define L3G4200_STATUS_XYZ_OW    0x80
    
60. 
    
61. //函数声明
    
62. uint8  L3G4200_Init(void);
    
63. void  L3G4200_WriteReg(uint8, uint8);
    
64. uint8 L3G4200_ReadReg(uint8);
    
65. int16 L3G4200_GetResult(uint8, uint8);
    
66. 
    
67. #endif
    
68. 
    
69. #include "dev_l3g4200.h"
    
70. 
    
71. static void L3G4200_Delay(void);
    
72. 
    
73. uint8 L3G4200_Init(void)
    
74. {
    
75.   I2C_InitTypeDef i2c_init_param;
    
76.   uint8 device_id=0;  
    
77.   
    
78.   //初始化L3G4200_I2CX
    
79.   i2c_init_param.I2C_I2Cx = L3G4200_I2CX ;       //在DEV_L3G4200.h中修改该值
    
80.   i2c_init_param.I2C_IntEnable = FALSE;
    
81.   i2c_init_param.I2C_ICR = L3G4200_SCL_200KHZ;  //可根据实际电路更改SCL频率
    
82.   i2c_init_param.I2C_SclPin = L3G4200_SCLPIN;   //在DEV_MMA8451.h中修改该值
    
83.   i2c_init_param.I2C_SdaPin = L3G4200_SDAPIN;   //在DEV_MMA8451.h中修改该值
    
84.   i2c_init_param.I2C_Isr = NULL;
    
85.   
    
86.   LPLD_I2C_Init(i2c_init_param);
    
87.   
    
88.     //读取设备ID
    
89.   device_id = L3G4200_ReadReg(WHO_AM_I);
    
90.   
    
91.   //进行寄存器配置
    
92.   L3G4200_WriteReg(CTRL_REG1, 0x0f);   //100hz    0xff(800hz)
    
93.   L3G4200_WriteReg(CTRL_REG2, 0x00);   
    
94.   L3G4200_WriteReg(CTRL_REG3, 0x08);
    
95.   L3G4200_WriteReg(CTRL_REG4, 0x30);  //+-2000dps , Data LSB @ lower address
    
96.   L3G4200_WriteReg(CTRL_REG5, 0x00);  
    
97.   
    
98.   return device_id ;
    
99. }
    
100. 
     
101. /*
     
102. *   L3G4200_WriteReg
     
103. *   该函数用于配置L3G4200的寄存器
     
104. *
     
105. *   参数：
     
106. *   RegisterAddress
     
107. *    |__ L3G4200寄存器地址
     
108. *   Data
     
109. *    |__ 具体写入的字节型数据
     
110. */
     
111. void  L3G4200_WriteReg(uint8 RegisterAddress, uint8 Data)
     
112. {
     
113.    //发送从机地址
     
114.   LPLD_I2C_StartTrans(L3G4200_I2CX,L3G4200_DEV_ADDR, I2C_MWSR);
     
115.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
116.   
     
117.   //写L3G4200寄存器地址
     
118.   LPLD_I2C_WriteByte(L3G4200_I2CX, RegisterAddress);
     
119.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
120.   
     
121.   //向寄存器中写具体数据
     
122.   LPLD_I2C_WriteByte(L3G4200_I2CX, Data);
     
123.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
124. 
     
125.   LPLD_I2C_Stop(L3G4200_I2CX);
     
126.    
     
127.   L3G4200_Delay();
     
128. }
     
129. 
     
130. /*
     
131. *   L3G4200_ReadReg
     
132. *   该函数用于读取L3G4200的数据
     
133. *
     
134. *   参数：
     
135. *     RegisterAddress
     
136. *        |__ MMA8451寄存器地址
     
137. *   返回值
     
138. *      加速传感器的测量值
     
139. */
     
140. uint8 L3G4200_ReadReg(uint8 RegisterAddress)
     
141. {
     
142.   uint8 result=0;
     
143. 
     
144.   //发送从机地址
     
145.   LPLD_I2C_StartTrans(L3G4200_I2CX,L3G4200_DEV_ADDR, I2C_MWSR);
     
146.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
147. 
     
148.   //写L3G4200_I2CX寄存器地址
     
149.   LPLD_I2C_WriteByte(L3G4200_I2CX, RegisterAddress);
     
150.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
151. 
     
152.   //再次产生开始信号
     
153.   LPLD_I2C_ReStart(L3G4200_I2CX);
     
154. 
     
155.   //发送从机地址和读取位
     
156.   LPLD_I2C_WriteByte(L3G4200_I2CX , L3G4200_DEV_READ);
     
157.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
158. 
     
159.   //转换主机模式为读
     
160.   LPLD_I2C_SetMasterWR(L3G4200_I2CX, I2C_MRSW);
     
161. 
     
162.   //关闭应答ACK
     
163.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_OFF);//关闭ACK
     
164. 
     
165.   // Dummy read 虚假读取
     
166.   result =LPLD_I2C_ReadByte(L3G4200_I2CX);  
     
167.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
168. 
     
169.   //发送停止信号
     
170.   LPLD_I2C_Stop(L3G4200_I2CX);
     
171. 
     
172.   //读IIC数据
     
173.   result = LPLD_I2C_ReadByte(L3G4200_I2CX);
     
174.   
     
175.   L3G4200_Delay();
     
176. 
     
177.   return result;
     
178. }
     
179. 
     
180. /*
     
181. * 函数功能：读L3G4200加速度输出
     
182. * 参数
     
183. *       Status - 数据寄存器状态
     
184. *       Regs_Addr - 数据寄存器地址
     
185. * 函数返回值：加速度值（int16）
     
186. */   
     
187. int16 L3G4200_GetResult(uint8 Status, uint8 Regs_Addr)
     
188. {
     
189.   uint8 ret=0;
     
190.   uint16 cnt=0;
     
191.   int16 result,temp;
     
192.    
     
193.   // 等待转换完成并取出值
     
194. 
     
195.   while(!(ret&Status))
     
196.   {
     
197.     ret = L3G4200_ReadReg( STATUS_REG);
     
198.     if(++cnt>500)
     
199.     //  break;
     
200.       ;
     
201.   }
     
202. 
     
203.   
     
204.   temp= L3G4200_ReadReg( Regs_Addr);        //低字节数据
     
205.   result  = L3G4200_ReadReg( Regs_Addr+1);  //高字节
     
206.   result=result<<8;
     
207.   result=result|temp;
     
208.   
     
209.   return result;
     
210. }
     
211. 
     
212. 
     
213. /*
     
214. * 延时函数
     
215. */
     
216. static void L3G4200_Delay(void){
     
217.   int n;
     
218.   for(n=1;n<200;n++) {
     
219.     asm("nop");
     
220.   }
     
221. }

复制代码

求救啊，为嘛我读出来的数据，全是0xFF ,
器件地址应该是对啊，LPLD 底层库有进行移位操作啊，器件也是好的
CS 和SA 都接的高
为嘛我读MMA8451可以读出来，读L3G4200 就读不出来

FSL_TICS_ZJJ

你可以参考一下L3G4200 的相关应用，检查一下不代码和这款芯片对应应用的区别。

FSL_TICS_ZJJ

看到其他地方一个建议操作，不过那边后来也没有回应，你可以试试看其他网友的建议操作。
“请将SDA管脚配置为open drain输出试试看看。
PortxPCR寄存器中ODE位。”

孤独stranger

FSL_TICS_ZJJ 发表于 2014-1-10 14:39
看到其他地方一个建议操作，不过那边后来也没有回应，你可以试试看其他网友的建议操作。
“请将SDA管脚配置 ...

刚看了下，那个引脚的开漏输出已经使能了啊在底层库里面
boolean ode = i2c_init_structure.I2C_OpenDrainEnable;

FSL_TICS_ZJJ

孤独stranger 发表于 2014-1-10 15:13
刚看了下，那个引脚的开漏输出已经使能了啊在底层库里面
boolean ode = i2c_init_structure.I2C_OpenDrai ...

只是其他网友的建议，
我没有用过LPLD库，既然飞思的加速度传感器可以使用，
建议你还是去看看这个L3G4200的一些典型应用，是不是外围，或者控制时序方面有差异。

孤独stranger

FSL_TICS_ZJJ 发表于 2014-1-10 15:29
只是其他网友的建议，
我没有用过LPLD库，既然飞思的加速度传感器可以使用，
建议你还是去看看这个L3G420 ...

之前拿M3的板子，用IO口模拟IIC，都可以读出来，现在不管是用M3的硬件IIC，还是K60的硬件IIC，配置的都可以读出其它IIC器件，就是读不出来L3G4200

孤独stranger

，求解决方案啊

湛泸骏驰

孤独stranger 发表于 2014-1-11 13:12
，求解决方案啊

楼主现在怎么样； ，期待你能够采集出信号，分享经验。。我的也是不行啊，NEC-03 温漂的厉害啊。。

湛泸骏驰

传几个资料，希望打什么可以帮忙解决一下，在此表示十分的感谢

FSL_TICS_ZJJ

孤独stranger 发表于 2014-1-10 17:23
之前拿M3的板子，用IO口模拟IIC，都可以读出来，现在不管是用M3的硬件IIC，还是K60的硬件IIC，配置的都可 ...

建议你可以把你的通信波形抓出来，然后资讯一下L3G4200公司的技术支持！

孤独stranger

湛泸骏驰 发表于 2014-1-11 22:17
楼主现在怎么样； ，期待你能够采集出信号，分享经验。。我的也是不行啊，NEC-03 温漂的厉害啊。。 ...

现在搞定了，当时有人提出是SDA管脚要开漏，
我没仔细看，就以为它默认的是开漏
过了两天，我再仔细看，发现默认的是FALSE
改成TRUE就行了

FSL_TICS_ZJJ

孤独stranger 发表于 2014-1-13 10:58
现在搞定了，当时有人提出是SDA管脚要开漏，
我没仔细看，就以为它默认的是开漏
过了两天，我再仔细看， ...

恭喜楼主解决问题，同时也感谢你分享经验！
另外楼主如果问题解决了，请将标题加上“已解决”

湛泸骏驰

孤独stranger 发表于 2014-1-13 10:58
现在搞定了，当时有人提出是SDA管脚要开漏，
我没仔细看，就以为它默认的是开漏
过了两天，我再仔细看， ...

一个不小心给烧了，哎。。你的程序仅仅只是加了一句   i2c_init_param.I2C_OpenDrainEnable=TRUE;  对吧。。谢谢了。

孤独stranger

湛泸骏驰 发表于 2014-1-13 13:56
一个不小心给烧了，哎。。你的程序仅仅只是加了一句   i2c_init_param.I2C_OpenDrainEnable=TRUE;  对吧 ...

额，有钱人啊，烧一个一百多啊！！
是的，就加那一句话就可以了

湛泸骏驰

孤独stranger 发表于 2014-1-13 14:03
额，有钱人啊，烧一个一百多啊！！
是的，就加那一句话就可以了

我的这个没有那多，也心疼啊

湛泸骏驰

之前我测VCC和GND他们是导通的 ，现在又，没有问题了，可以我的CS 一接3.3V 就冒烟，你遇到这样的问题了吗？

孤独stranger

湛泸骏驰 发表于 2014-1-13 18:35
之前我测VCC和GND他们是导通的 ，现在又，没有问题了，可以我的CS 一接3.3V 就冒烟，你遇到这样的问题了吗 ...

木有发现这个问题额，我还以为你是主控板烧了呢，传感器烧了是小事

湛泸骏驰

1. int16 resultx,resulty,resultz;
   
2. uint8 device_id  ;
   
3.   void delay(void)  ;
   
4. 
   
5. 
   
6. void main (void)
   
7. {
   
8. 
   
9.    //初始化L3G4200D底层驱动及寄存器
   
10. device_id=L3G4200_Init();
    
11. 
    
12.   if(device_id==L3G4200_DEV_ID)
    
13.   {
    
14.     printf("L3G4200D init succeed!\r\n");
    
15.     printf("Device ID :0x%X\r\n,device_id") ;
    
16.   }
    
17.   else
    
18.   {
    
19.     printf("L3G4200D Init failed !\r\n");
    
20.     printf("Device ID :0x%x\r\n,device_id");
    
21.     while(1);
    
22.    
    
23.   }
    
24.   
    
25.   while(1)
    
26.   {
    
27.     resultx=L3G4200_GetResult(L3G4200_STATUS_X_READY,OUT_X_L);
    
28.     resulty=L3G4200_GetResult(L3G4200_STATUS_Y_READY,OUT_Y_L) ;
    
29.     resultz=L3G4200_GetResult(L3G4200_STATUS_Z_READY,OUT_Z_L);
    
30.     printf("XYZ:\t%d\t%d\t%d\r\n", resultx, resulty, resultz);
    
31.   }
    
32. }
    
33. 
    
34. 
    
35. void delay(void)
    
36. {
    
37.    int16 i,n;
    
38.    for (i=0;i<30000;i++)
    
39.    {
    
40.       for (n=0;n<200;n++)
    
41.       {
    
42.         asm("nop");
    
43.       }
    
44.    }
    
45. }
    
46.    

复制代码

孤独stranger 发表于 2014-1-13 20:41
木有发现这个问题额，我还以为你是主控板烧了呢，传感器烧了是小事

在CS 端接10K电阻后接3.3V没有冒烟，不接就会冒烟的，现在还是不能正确的读取ID
给看看是不是这里有问题呢，

我刚刚测了一下CS端的电压，电压比较低。但是如果我不在电路中串入电阻的话，传感器就会冒烟的，我是使用的lm117-3.3 V的稳压芯片。

孤独stranger

湛泸骏驰 发表于 2014-1-13 20:58
在CS 端接10K电阻后接3.3V没有冒烟，不接就会冒烟的，现在还是不能正确的读取ID  
给看看 ...

悬空试试？ 理论上直接接3.3V 是没有问题的，或者是你那块板子有问题

湛泸骏驰

孤独stranger 发表于 2014-1-14 12:53
悬空试试？ 理论上直接接3.3V 是没有问题的，或者是你那块板子有问题

等我的传感器到了，如果不行的话。在请教一下你哈。。

湛泸骏驰

1. /**
   
2. * @file DEV_L3G4200D.h
   
3. * @version 0.1[LUDSMARTCAR]
   
4. * @date 2013-11-9
   
5. * @brief L3G4200三轴陀螺仪设备驱动程序
   
6. */
   
7. 
   
8. #ifndef __DEV_L3G4200D_H__
   
9. 
   
10. #define __DEV_L3G4200D_H__
    
11. 
    
12. 
    
13. #include "common.h"
    
14. 
    
15. #include "HW_I2C.h"
    
16. 
    
17. 
    
18. /********用户可修改值 开始***********/
    
19. 
    
20. //连接L3G4200用到的I2C通道
    
21. 
    
22. #define L3G4200_I2CX    (I2C1)
    
23. 
    
24. 
    
25. //连接L3G4200用到的SCL引脚
    
26. 
    
27. #define L3G4200_SCLPIN  (PTC10)
    
28. 
    
29. 
    
30. //连接L3G4200用到的SDA引脚
    
31. 
    
32. #define L3G4200_SDAPIN  (PTC11)
    
33. 
    
34. /********用户可修改值 结束***********/
    
35. 
    
36. 
    
37. //定义SCL Bus Speed取值，外设总线为50Mhz时的计算结果
    
38. 
    
39. #define L3G4200_SCL_50KHZ                   (0x33)
    
40. #define L3G4200_SCL_100KHZ                  (0x2B)  
    
41. 
    
42. #define L3G4200_SCL_150KHZ                  (0x28)
    
43. 
    
44. #define L3G4200_SCL_200KHZ                  (0x23)
    
45. 
    
46. #define L3G4200_SCL_250KHZ                  (0x21)
    
47. 
    
48. #define L3G4200_SCL_300KHZ                  (0x20)
    
49. 
    
50. #define L3G4200_SCL_400KHZ                  (0x17)  
    
51. 
    
52. 
    
53. //=========MMA8451 功能参数==================//
    
54. 
    
55. #define L3G4200_DEV_ADDR     0x69//0X68//0x69         //定义器件地址，可根据硬件修改
    
56. 
    
57. #define L3G4200_DEV_WRITE    0xD2//0XD0//0xD2     
    
58. 
    
59. #define L3G4200_DEV_READ     0XD3//0XD1//0xD3
    
60. 
    
61. #define L3G4200_DEV_ID       0xD3    //设备ID
    
62. 
    
63. 
    
64. //L3G4200 内部寄存器地址
    
65. 
    
66. #define WHO_AM_I               0x0F
    
67. 
    
68. #define CTRL_REG1              0x20
    
69. 
    
70. #define CTRL_REG2         0x21
    
71. 
    
72. #define CTRL_REG3         0x22
    
73. 
    
74. #define CTRL_REG4         0x23
    
75. 
    
76. #define CTRL_REG5         0x24
    
77. 
    
78. #define REFERENCE         0x25
    
79. 
    
80. #define OUT_TEMP          0x26
    
81. 
    
82. #define STATUS_REG         0x27
    
83. 
    
84. #define OUT_X_L         0x28
    
85. 
    
86. #define OUT_X_H         0x29
    
87. 
    
88. #define OUT_Y_L         0x2A
    
89. 
    
90. #define OUT_Y_H         0x2B
    
91. 
    
92. #define OUT_Z_L         0x2C
    
93. 
    
94. #define OUT_Z_H         0x2D
    
95. 
    
96. 
    
97. 
    
98. //=========L3G4200 STATUS寄存器 寄存器位==================//
    
99. 
    
100. #define L3G4200_STATUS_X_READY   0x01
     
101. 
     
102. #define L3G4200_STATUS_Y_READY   0x02
     
103. 
     
104. #define L3G4200_STATUS_Z_READY   0x04
     
105. 
     
106. #define L3G4200_STATUS_XYZ_READY 0x08
     
107. 
     
108. #define L3G4200_STATUS_X_OW      0x10
     
109. 
     
110. #define ML3G4200_STATUS_Y_OW     0x20
     
111. 
     
112. #define L3G4200_STATUS_Z_OW      0x40
     
113. 
     
114. #define L3G4200_STATUS_XYZ_OW    0x80
     
115. 
     
116. 
     
117. //函数声明
     
118. 
     
119. uint8  L3G4200_Init(void);
     
120. 
     
121. void  L3G4200_WriteReg(uint8, uint8);
     
122. 
     
123. uint8 L3G4200_ReadReg(uint8);
     
124. 
     
125. int16 L3G4200_GetResult(uint8, uint8);
     
126. 
     
127. 
     
128. #endif
     
129. 
     
130. 
     
131. 
     
132. /**
     
133. * @file DEV_L3G4200D.h
     
134. * @version 0.1[LUDSMARTCAR]
     
135. * @date 2013-11-9
     
136. * @brief L3G4200三轴陀螺仪设备驱动程序
     
137. */
     
138. 
     
139. #include "DEV_L3G4200D.h"
     
140. 
     
141. static void L3G4200_Delay(void);
     
142. 
     
143. 
     
144. uint8 L3G4200_Init(void)
     
145. 
     
146. {
     
147. 
     
148.   I2C_InitTypeDef i2c_init_param;
     
149. 
     
150.   uint8 device_id=0;  
     
151. 
     
152.   
     
153. 
     
154.   //初始化L3G4200_I2CX
     
155. 
     
156.   i2c_init_param.I2C_I2Cx = L3G4200_I2CX ;       //在DEV_L3G4200.h中修改该值
     
157. 
     
158.   i2c_init_param.I2C_IntEnable = FALSE;
     
159. 
     
160.   i2c_init_param.I2C_ICR = L3G4200_SCL_200KHZ;  //可根据实际电路更改SCL频率
     
161. 
     
162.   i2c_init_param.I2C_SclPin = L3G4200_SCLPIN;   //在DEV_MMA8451.h中修改该值
     
163. 
     
164.   i2c_init_param.I2C_SdaPin = L3G4200_SDAPIN;   //在DEV_MMA8451.h中修改该值
     
165.   
     
166.   i2c_init_param.I2C_OpenDrainEnable=TRUE;
     
167. 
     
168.   i2c_init_param.I2C_Isr = NULL;
     
169. 
     
170.   
     
171. 
     
172.   LPLD_I2C_Init(i2c_init_param);
     
173. 
     
174.   
     
175. 
     
176.     //读取设备ID
     
177. 
     
178.   device_id = L3G4200_ReadReg(WHO_AM_I);
     
179. 
     
180.   
     
181. 
     
182.   //进行寄存器配置
     
183. 
     
184.   L3G4200_WriteReg(CTRL_REG1, 0x0f);   //100hz    0xff(800hz)
     
185. 
     
186.   L3G4200_WriteReg(CTRL_REG2, 0x00);   
     
187.   L3G4200_WriteReg(CTRL_REG3, 0x08);
     
188.   L3G4200_WriteReg(CTRL_REG4, 0x30);  //+-2000dps , Data LSB @ lower address
     
189. 
     
190.   L3G4200_WriteReg(CTRL_REG5, 0x00);  
     
191. 
     
192.   
     
193. 
     
194.   return device_id ;
     
195. 
     
196. }
     
197. 
     
198. 
     
199. /*
     
200. 
     
201. *   L3G4200_WriteReg
     
202. 
     
203. *   该函数用于配置L3G4200的寄存器
     
204. 
     
205. *
     
206. 
     
207. *   参数：
     
208. 
     
209. *   RegisterAddress
     
210. *    |__ L3G4200寄存器地址
     
211. 
     
212. *   Data
     
213. 
     
214. *    |__ 具体写入的字节型数据
     
215. */
     
216. 
     
217. void  L3G4200_WriteReg(uint8 RegisterAddress, uint8 Data)
     
218. 
     
219. {
     
220. 
     
221.    //发送从机地址
     
222. 
     
223.   LPLD_I2C_StartTrans(L3G4200_I2CX,L3G4200_DEV_ADDR, I2C_MWSR);
     
224. 
     
225.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
226. 
     
227.   
     
228. 
     
229.   //写L3G4200寄存器地址
     
230. 
     
231.   LPLD_I2C_WriteByte(L3G4200_I2CX, RegisterAddress);
     
232. 
     
233.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
234. 
     
235.   
     
236. 
     
237.   //向寄存器中写具体数据
     
238. 
     
239.   LPLD_I2C_WriteByte(L3G4200_I2CX, Data);
     
240. 
     
241.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
242. 
     
243. 
     
244.   LPLD_I2C_Stop(L3G4200_I2CX);
     
245.    
     
246.    L3G4200_Delay();
     
247. 
     
248. }
     
249. 
     
250. 
     
251. /*
     
252. 
     
253. *   L3G4200_ReadReg
     
254. 
     
255. *   该函数用于读取L3G4200的数据
     
256. 
     
257. *
     
258. 
     
259. *   参数：
     
260. 
     
261. *     RegisterAddress
     
262. *        |__ MMA8451寄存器地址
     
263. 
     
264. *   返回值
     
265. 
     
266. *      加速传感器的测量值
     
267. 
     
268. */
     
269. 
     
270. uint8 L3G4200_ReadReg(uint8 RegisterAddress)
     
271. 
     
272. {
     
273. 
     
274.   uint8 result=0;
     
275. 
     
276. 
     
277.   //发送从机地址
     
278. 
     
279.   LPLD_I2C_StartTrans(L3G4200_I2CX,L3G4200_DEV_ADDR, I2C_MWSR);
     
280. 
     
281.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
282. 
     
283. 
     
284.   //写L3G4200_I2CX寄存器地址
     
285. 
     
286.   LPLD_I2C_WriteByte(L3G4200_I2CX, RegisterAddress);
     
287. 
     
288.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
289. 
     
290. 
     
291.   //再次产生开始信号
     
292. 
     
293.   LPLD_I2C_ReStart(L3G4200_I2CX);
     
294. 
     
295. 
     
296.   //发送从机地址和读取位
     
297. 
     
298.   LPLD_I2C_WriteByte(L3G4200_I2CX , L3G4200_DEV_READ);
     
299. 
     
300.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
301. 
     
302. 
     
303.   //转换主机模式为读
     
304. 
     
305.   LPLD_I2C_SetMasterWR(L3G4200_I2CX, I2C_MRSW);
     
306. 
     
307. 
     
308.   //关闭应答ACK
     
309. 
     
310.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_OFF);//关闭ACK
     
311. 
     
312. 
     
313.   // Dummy read 虚假读取
     
314. 
     
315.   result =LPLD_I2C_ReadByte(L3G4200_I2CX);  
     
316. 
     
317.   LPLD_I2C_WaitAck(L3G4200_I2CX, I2C_ACK_ON);
     
318. 
     
319. 
     
320.   //发送停止信号
     
321. 
     
322.   LPLD_I2C_Stop(L3G4200_I2CX);
     
323. 
     
324. 
     
325.   //读IIC数据
     
326. 
     
327.   result = LPLD_I2C_ReadByte(L3G4200_I2CX);
     
328. 
     
329.   
     
330. 
     
331.   L3G4200_Delay();
     
332.   L3G4200_Delay();
     
333.   L3G4200_Delay();
     
334. 
     
335.   return result;
     
336. 
     
337. }
     
338. 
     
339. 
     
340. /*
     
341. 
     
342. * 函数功能：读L3G4200加速度输出
     
343. 
     
344. * 参数
     
345. 
     
346. *       Status - 数据寄存器状态
     
347. 
     
348. *       Regs_Addr - 数据寄存器地址
     
349. 
     
350. * 函数返回值：加速度值（int16）
     
351. 
     
352. */   
     
353. 
     
354. int16 L3G4200_GetResult(uint8 Status, uint8 Regs_Addr)
     
355. 
     
356. {
     
357. 
     
358.   uint8 ret=0;
     
359. 
     
360.   uint16 cnt=0;
     
361. 
     
362.   int16 result,temp;
     
363. 
     
364.    
     
365. 
     
366.   // 等待转换完成并取出值
     
367. 
     
368.   while(!(ret&Status))
     
369.   {
     
370. 
     
371.     ret = L3G4200_ReadReg( STATUS_REG);
     
372. 
     
373.     if(++cnt>500)
     
374. 
     
375.     //  break;
     
376. 
     
377.       ;
     
378. 
     
379.   }
     
380. 
     
381. 
     
382.   
     
383. 
     
384.   temp= L3G4200_ReadReg( Regs_Addr);        //低字节数据
     
385. 
     
386.   result  = L3G4200_ReadReg( Regs_Addr+1);  //高字节
     
387.   result=result<<8;
     
388. 
     
389.   result=result|temp;
     
390. 
     
391.   
     
392. 
     
393.   return result;
     
394. 
     
395. }
     
396. 
     
397. 
     
398. 
     
399. /*
     
400. 
     
401. * 延时函数
     
402. 
     
403. */
     
404. 
     
405. static void L3G4200_Delay(void){
     
406. 
     
407.   int n;
     
408. 
     
409.   for(n=1;n<200;n++) {
     
410. 
     
411.     asm("nop");
     
412. 
     
413.   }
     
414. 
     
415. }
     
416. 
     
417. 
     
418. 
     
419. /**
     
420. * --------------基于"拉普兰德K60底层库V3"的工程（L3G4200D）-----------------
     
421. * @file L3G4200D.c
     
422. * @version 0.0
     
423. * @date 2013-9-29
     
424. * @brief 关于该工程的描述
     
425. *
     
426. * 版权所有:北京拉普兰德电子技术有限公司
     
427. * http://www.lpld.cn
     
428. * mail:support@lpld.cn
     
429. * 硬件平台:  LPLD K60 Card / LPLD K60 Nano
     
430. *
     
431. * 本工程基于"拉普兰德K60底层库V3"开发，
     
432. * 所有开源代码均在"lib"文件夹下，用户不必更改该目录下代码，
     
433. * 所有用户工程需保存在"project"文件夹下，以工程名定义文件夹名，
     
434. * 底层库使用方法见相关文档。
     
435. *
     
436. */
     
437. #include "common.h"
     
438. #include "DEV_L3G4200D.h"
     
439. int16 resultx,resulty,resultz;
     
440. uint8 device_id  ;
     
441.   void delay(void)  ;
     
442. 
     
443. 
     
444. void main (void)
     
445. {
     
446. 
     
447.    //初始化L3G4200D底层驱动及寄存器
     
448. device_id=L3G4200_Init();
     
449. 
     
450.   if(device_id==L3G4200_DEV_ID)
     
451.   {
     
452.     printf("L3G4200D init succeed!\r\n");
     
453.     printf("Device ID :0x%X\r\n,device_id") ;
     
454.   }
     
455.   else
     
456.   {
     
457.     printf("L3G4200D Init failed !\r\n");
     
458.     printf("Device ID :0x%x\r\n,device_id");
     
459.     while(1);
     
460.   }
     
461.   
     
462.   while(1)
     
463.   {
     
464.     resultx=L3G4200_GetResult(L3G4200_STATUS_X_READY,OUT_X_L);
     
465.     resulty=L3G4200_GetResult(L3G4200_STATUS_Y_READY,OUT_Y_L) ;
     
466.     resultz=L3G4200_GetResult(L3G4200_STATUS_Z_READY,OUT_Z_L);
     
467.     printf("XYZ:\t%d\t%d\t%d\r\n", resultx, resulty, resultz);
     
468.   }
     
469. }
     
470. 
     
471. 
     
472. void delay(void)
     
473. {
     
474.    int16 i,n;
     
475.    for (i=0;i<30000;i++)
     
476.    {
     
477.       for (n=0;n<200;n++)
     
478.       {
     
479.         asm("nop");
     
480.       }
     
481.    }
     
482. }
     
483.    
     
484. 
     
485. 
     

复制代码

好人楼主，能给测试一下L3G4200D吗？我这里使用你的代码还是读不出ID 啊。新来的传感器。，。帮忙测一下，代码能否读取ID 吧，顺便给来张截图，，