【Artix-7 50T FPGA试用体验】(六)+ “microblaze” 之 IIC驱动BMP180

好久没有发新的帖子了，最近一直都在调试IIC的驱动部分，终于让我调试通过了，下面就来记录一下！！！这次调试花了比较久的时间，中间也遇到了各种坑，最后发现其实大部分都是因为自己对器件的不熟悉导致的。。。话不多说，先上代码!!!

1. /*
   
2. * main.c
   
3. *
   
4. *  Created on: 2016年11月22日
   
5. *      Author: SEELE
   
6. */
   
7. 
   
8. #include
   
9. #include
   
10. #include "xil_printf.h"
    
11. #include "xparameters.h"
    
12. #include "xiic.h"
    
13. #include "xintc.h"
    
14. #include "xil_exception.h"
    
15. #include "xenv.h"
    
16. 
    
17. #define BMP180_ADDRESS                        0x77 /*actual address is 0xEE*/
    
18. 
    
19. #define LED_DELAY          500000
    
20. 
    
21. const unsigned char OSS = 0;  // Oversampling Setting
    
22. 
    
23. #define IIC_DEVICE_ID                    XPAR_IIC_0_DEVICE_ID
    
24. #define INTC_DEVICE_ID                        XPAR_INTC_0_DEVICE_ID
    
25. #define INTC_IIC_INTERRUPT_ID        XPAR_INTC_0_IIC_0_VEC_ID
    
26. 
    
27. XIic Iic;
    
28. 
    
29. XIntc InterruptController;
    
30. u8 BMPIicAddr;
    
31. 
    
32. static int SetupInterruptSystem(XIic *IicPtr);
    
33. 
    
34. static void RecvHandler(XIic *InstancePtr);
    
35. 
    
36. static void SendHandler(XIic *InstancePtr);
    
37. 
    
38. static void StatusHandler(void *CallbackRef, int Status);
    
39. 
    
40. volatile int Delay;
    
41. 
    
42. s16 ac1;
    
43. s16 ac2;
    
44. s16 ac3;
    
45. u16 ac4;
    
46. u16 ac5;
    
47. u16 ac6;
    
48. s16 b1;
    
49. s16 b2;
    
50. s16 mb;
    
51. s16 mc;
    
52. s16 md;
    
53. 
    
54. u8 WriteBuffer[10];
    
55. 
    
56. u8 Readbuffer[10];
    
57. 
    
58. volatile u8 TransmitComplete;
    
59. volatile u8 ReceiveComplete;
    
60. 
    
61. // b5 is calculated in bmp085GetTemperature(...), this variable is also used in bmp085GetPressure(...)
    
62. // so ...Temperature(...) must be called before ...Pressure(...).
    
63. long b5;
    
64. 
    
65. int IicBMP180_Int()
    
66. {
    
67.         int Status;
    
68.         XIic_Config *ConfigPtr;
    
69.         BMPIicAddr = BMP180_ADDRESS;
    
70. 
    
71.         ConfigPtr = XIic_LookupConfig(IIC_DEVICE_ID);
    
72.         if (ConfigPtr == NULL) {
    
73.                 return XST_FAILURE;
    
74.         }
    
75. 
    
76.         Status = XIic_CfgInitialize(&Iic, ConfigPtr,
    
77.                         ConfigPtr->BaseAddress);
    
78.         if (Status != XST_SUCCESS) {
    
79.                 return XST_FAILURE;
    
80.         }
    
81. 
    
82.         XIic_SetRecvHandler(&Iic,&Iic,
    
83.                                 (XIic_Handler) RecvHandler);
    
84.         XIic_SetStatusHandler(&Iic,&Iic,
    
85.                                 (XIic_StatusHandler) StatusHandler);
    
86.         XIic_SetSendHandler(&Iic,&Iic,
    
87.                         (XIic_Handler) SendHandler);
    
88. 
    
89.         Status = SetupInterruptSystem(&Iic);
    
90.         if (Status != XST_SUCCESS){
    
91.                 return XST_FAILURE;
    
92.         }
    
93. 
    
94.         Status = XIic_SetAddress(&Iic, XII_ADDR_TO_SEND_TYPE, BMPIicAddr);
    
95.         if (Status != XST_SUCCESS)
    
96.         {
    
97.                 return XST_FAILURE;
    
98.         }
    
99.         return XST_SUCCESS;
    
100. }
     
101. 
     
102. static int SetupInterruptSystem(XIic *IicPtr)
     
103. {
     
104.         int Status;
     
105. 
     
106.         Status = XIntc_Initialize(&InterruptController,INTC_DEVICE_ID);
     
107.         if (Status != XST_SUCCESS){
     
108.                 return XST_FAILURE;
     
109.         }
     
110. 
     
111.         Status = XIntc_Connect(&InterruptController, INTC_IIC_INTERRUPT_ID,
     
112.                         (XInterruptHandler)XIic_InterruptHandler, IicPtr);
     
113.         if (Status != XST_SUCCESS){
     
114.                 return XST_FAILURE;
     
115.         }
     
116. 
     
117.         Status = XIntc_Start(&InterruptController, XIN_REAL_MODE);
     
118.         if (Status != XST_SUCCESS){
     
119.                 return XST_FAILURE;
     
120.         }
     
121. 
     
122.         XIntc_Enable(&InterruptController, INTC_IIC_INTERRUPT_ID);
     
123.         if (Status != XST_SUCCESS){
     
124.                         return XST_FAILURE;
     
125.         }
     
126. 
     
127.         Xil_ExceptionInit();
     
128. 
     
129.         Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
     
130.                         (Xil_ExceptionHandler)XIntc_InterruptHandler,
     
131.                         &InterruptController);
     
132. 
     
133.         Xil_ExceptionEnable();
     
134. 
     
135.         return XST_SUCCESS;
     
136. }
     
137. 
     
138. int Bmp180WriteData(u16 ByteCount)
     
139. {
     
140.         int Status;
     
141. 
     
142. 
     
143.         TransmitComplete = 1;
     
144.         Iic.Stats.TxErrors = 0;
     
145. 
     
146.         Status = XIic_Start(&Iic);
     
147.         if (Status != XST_SUCCESS)
     
148.         {
     
149.                 return XST_FAILURE;
     
150.         }
     
151. 
     
152.         Status = XIic_MasterSend(&Iic,WriteBuffer, ByteCount);
     
153.         if (Status != XST_SUCCESS)
     
154.         {
     
155.                 return XST_FAILURE;
     
156.         }
     
157. 
     
158.         while ((TransmitComplete) || (XIic_IsIicBusy(&Iic) == TRUE)) {
     
159. 
     
160.                 if (Iic.Stats.TxErrors != 0) {
     
161. 
     
162. 
     
163.                         Status = XIic_Start(&Iic);
     
164.                         if (Status != XST_SUCCESS){
     
165.                                 return XST_FAILURE;
     
166.                         }
     
167. 
     
168.                         if (!XIic_IsIicBusy(&Iic)){
     
169.                                 Status = XIic_MasterSend(&Iic,
     
170.                                                 WriteBuffer,
     
171.                                                 ByteCount);
     
172. 
     
173.                                 if (Status == XST_SUCCESS){
     
174.                                         Iic.Stats.TxErrors = 0;
     
175.                                 }
     
176.                                 else {
     
177. 
     
178.                                 }
     
179.                         }
     
180.                 }
     
181.         }
     
182. 
     
183.         Status = XIic_Stop(&Iic);
     
184.         if (Status != XST_SUCCESS){
     
185.                 return XST_FAILURE;
     
186.         }
     
187. 
     
188.         return XST_SUCCESS;
     
189. }
     
190. 
     
191. int Bmp180ReadData(u8 add,u8 *BufferPtr, u16 ByteCount)
     
192. {
     
193.         int Status;
     
194. 
     
195.         ReceiveComplete = 1;
     
196. 
     
197.         WriteBuffer[0] = add;
     
198. 
     
199.         Status = Bmp180WriteData(0x01);
     
200.         if (Status != XST_SUCCESS)
     
201.         {
     
202.                 return XST_FAILURE;
     
203.         }
     
204. 
     
205.         Status = XIic_Start(&Iic);
     
206.         if (Status != XST_SUCCESS){
     
207.                 return XST_FAILURE;
     
208.         }
     
209. 
     
210.         Status = XIic_MasterRecv(&Iic, BufferPtr, ByteCount);
     
211.         if (Status != XST_SUCCESS)
     
212.         {
     
213.                 return XST_FAILURE;
     
214.         }
     
215. 
     
216.         while ((ReceiveComplete) || (XIic_IsIicBusy(&Iic) == TRUE)) {
     
217. 
     
218.         }
     
219. 
     
220.         Status = XIic_Stop(&Iic);
     
221.         if (Status != XST_SUCCESS){
     
222.                 return XST_FAILURE;
     
223.         }
     
224. 
     
225.         return XST_SUCCESS;
     
226. }
     
227. 
     
228. s16 bmp180ReadInt(u8 Address)
     
229. {
     
230.         u8 data[2] = {0,0};
     
231. 
     
232.         Bmp180ReadData(Address,data,2);
     
233. 
     
234.     return (s16) data[0]<<8 | data[1];
     
235. }
     
236. 
     
237. void bmp180Calibration()
     
238. {
     
239.         ac1 = bmp180ReadInt(0xAA);
     
240.         ac2 = bmp180ReadInt(0xAC);
     
241.         ac3 = bmp180ReadInt(0xAE);
     
242.         ac4 = bmp180ReadInt(0xB0);
     
243.         ac5 = bmp180ReadInt(0xB2);
     
244.         ac6 = bmp180ReadInt(0xB4);
     
245.         b1 = bmp180ReadInt(0xB6);
     
246.         b2 = bmp180ReadInt(0xB8);
     
247.         mb = bmp180ReadInt(0xBA);
     
248.         mc = bmp180ReadInt(0xBC);
     
249.         md = bmp180ReadInt(0xBE);
     
250. }
     
251. 
     
252. u16 bmp180ReadUT()
     
253. {
     
254.         u16 ut;
     
255. 
     
256.         //write 0x2e into register 0xf4
     
257. 
     
258.         WriteBuffer[0] = 0xF4;
     
259.         WriteBuffer[1] = 0x2E;
     
260.         Bmp180WriteData(2);
     
261. 
     
262.         for (Delay = 0; Delay < LED_DELAY; Delay++);
     
263. 
     
264.         ut = bmp180ReadInt(0xF6);
     
265.         return ut;
     
266. }
     
267. 
     
268. float bmp180GetTemperature(u16 ut)
     
269. {
     
270.         long x1, x2;
     
271.         x1 = (((long)ut - (long)ac6)*(long)ac5)>>15;
     
272.         x2 = ((long)mc << 11)/(x1 + md);
     
273.         b5 = x1 + x2;
     
274.         float temp = ((b5 + 8)>>4);
     
275.         temp = temp / 10;
     
276. 
     
277.         return temp;
     
278. }
     
279. 
     
280. u32 bmp180ReadUP()
     
281. {
     
282.         u8 data[3];
     
283.         u32 up = 0;
     
284. 
     
285.         WriteBuffer[0] = 0xF4;
     
286.         WriteBuffer[1] = (0x34 + (OSS<<6));
     
287. 
     
288.         Bmp180WriteData(2);
     
289. 
     
290.         udelay((2 + (3<
291.         for (Delay = 0; Delay < LED_DELAY; Delay++);
     
292. 
     
293.         u8 add = 0xF6;
     
294.         Bmp180ReadData(add,data,3);
     
295. 
     
296.         up = (((unsigned long)data[0]<<16) | ((unsigned long)data[1]<<8) | (unsigned long)data[2]) >> (8-OSS);
     
297. 
     
298.         return up;
     
299. }
     
300. 
     
301. s32 bmp180GetPressure(u32 up)
     
302. {
     
303.         long x1, x2, x3, b3, b6, p;
     
304.         unsigned long b4, b7;
     
305. 
     
306.         b6 = b5 - 4000;
     
307.         // Calculate B3
     
308.         x1 = (b2 * (b6 * b6)>>12)>>11;
     
309.         x2 = (ac2 * b6)>>11;
     
310.         x3 = x1 + x2;
     
311.         b3 = (((((long)ac1)*4 + x3)<>2;
     
312. 
     
313.         // Calculate B4
     
314.         x1 = (ac3 * b6)>>13;
     
315.         x2 = (b1 * ((b6 * b6)>>12))>>16;
     
316.         x3 = ((x1 + x2) + 2)>>2;
     
317.         b4 = (ac4 * (unsigned long)(x3 + 32768))>>15;
     
318. 
     
319.         b7 = ((unsigned long)(up - b3) * (50000>>OSS));
     
320.         if (b7 < 0x80000000)
     
321.         p = (b7<<1)/b4;
     
322.         else
     
323.         p = (b7/b4)<<1;
     
324. 
     
325.         x1 = (p>>8) * (p>>8);
     
326.         x1 = (x1 * 3038)>>16;
     
327.         x2 = (-7357 * p)>>16;
     
328.         p += (x1 + x2 + 3791)>>4;
     
329. 
     
330.         long temp = p;
     
331.         return temp;
     
332. }
     
333. 
     
334. float calcAltitude(float pressure)
     
335. {
     
336.         float A = pressure/101325;
     
337.         float B = 1/5.25588;
     
338.         float C = pow(A,B);
     
339.         C = 1 - C;
     
340.         C = C / 0.0000225577;
     
341. 
     
342.         return C;
     
343. }
     
344. 
     
345. int main()
     
346. {
     
347.         float temperature = 0.0;
     
348.         float pressure = 0.0;
     
349.         u32 up;
     
350.         u16 ut;
     
351.         float atm = 0.0;
     
352.         float altitude = 0.0;
     
353. 
     
354.         xil_printf("hello world!nr");
     
355.         IicBMP180_Int();
     
356.         bmp180Calibration();
     
357. 
     
358.         while (1)
     
359.         {
     
360.                 ut = bmp180ReadUT();
     
361.                 temperature = bmp180GetTemperature(ut);
     
362.                 xil_printf("temp = %drn",(int)temperature);
     
363.                 for (Delay = 0; Delay < LED_DELAY; Delay++);
     
364.                 up = bmp180ReadUP();
     
365.                 pressure = bmp180GetPressure(up);
     
366.                 xil_printf("pressure = %drn",(int)pressure);
     
367.                 for (Delay = 0; Delay < LED_DELAY; Delay++);
     
368.         }
     
369.         return 0;
     
370. };
     
371. 
     
372. /*****************************************************************************/
     
373. /**
     
374. * This receive handler is called asynchronously from an interrupt context and
     
375. * and indicates that data in the specified buffer was received. The byte count
     
376. * should equal the byte count of the buffer if all the buffer was filled.
     
377. *
     
378. * @param        CallBackRef is a pointer to the IIC device driver instance which
     
379. *                the handler is being called for.
     
380. * @param        ByteCount indicates the number of bytes remaining to be received of
     
381. *                the requested byte count. A value of zero indicates all requested
     
382. *                bytes were received.
     
383. *
     
384. * @return        None.
     
385. *
     
386. * @notes        None.
     
387. *
     
388. ****************************************************************************/
     
389. static void RecvHandler(XIic *InstancePtr)
     
390. {
     
391.         ReceiveComplete = 0;
     
392. }
     
393. 
     
394. /*****************************************************************************/
     
395. /**
     
396. * This status handler is called asynchronously from an interrupt context and
     
397. * indicates that the conditions of the IIC bus changed. This  handler should
     
398. * not be called for the application unless an error occurs.
     
399. *
     
400. * @param        CallBackRef is a pointer to the IIC device driver instance which the
     
401. *                handler is being called for.
     
402. * @param        Status contains the status of the IIC bus which changed.
     
403. *
     
404. * @return        None.
     
405. *
     
406. * @notes        None.
     
407. *
     
408. ****************************************************************************/
     
409. static void StatusHandler(void *CallbackRef, int Status)
     
410. {
     
411. 
     
412. }
     
413. 
     
414. static void SendHandler(XIic *InstancePtr)
     
415. {
     
416.         TransmitComplete = 0;
     
417. }
     

复制代码

上面这部分是全部代码，下面是运行结果

其中气压值对应的Pa，温度对应的是摄氏度，我查了一下还是很准的。
这款BMP180温度气压模块是一款高精度，小封装的温度气压传感器，可以用来做一下海拔高度的计算。不过这里我仅仅是读取了温度值和气压值。在模块的内部存储了11个校准系数用来计算温度值和气压值。
而且在使用的过程中需要先计算出温度值，才能计算气压值。

上图就是存储在内部的校准参数。在BMP180的手册中详细描述了BMP180的计算流程，如下图所示。

在驱动的过程中也遇到了很多坑，主要是在延迟上面，由于器件要求每次使能采集温度和气压，需要延迟4.5ms。
而我一开始使用udelay()函数进行延时，发送怎么读取温度和气压都不对，而单独读取温度是对的。搞得我以为是IP核的配置有问题，最后发现是udelay()函数根本就没有定义，所以根本没有延时，最后试用了最简单的for(;;)实现了延时功能，结果终于正确了！！！！
附件中提供了，iic软核的datasheet，在开发之前看一下还是有很大帮助的！！！

66

这是C语言吗？fpga可以用C了？？？

楼主回复一下，确认一下

lee_st 发表于 2017-4-22 16:45
楼主回复一下，确认一下

这是在fpga上面跑了一个软核，所以可以用c开发！

是吗？没玩过，有机会，搞个板子试试

嗯，很棒！也在摸索这个软核功能

BMP180气压传感器   深圳原装现货 QQ：2355959118

多谢分享！！！

我现在再调试microblaze iic,但是IIC上一直都没有信号出来，引脚约束没有问题。不知道您遇到过这种情况么，您写的工程能发给我一份参考么。
stone_zzuli@163.com  谢谢