本文记录了我使用STM32F103结合VL53L0测距模块的一个学习过程。
VL53L0是由ST公司最新推出的一款飞行时间测距+手势检测的微型模块，它应用非常广泛包括：激光测距、避障检测、一维手势识别等；接下来我们重点介绍它的激光测距功能。

一、模块的硬件连接




上图便是我所使用的测距模块GYVL53L0XV2，它预留了六个接口：
1、VIN：供电电压，可在3V~5V范围内进行供电，但如果自己进行电路搭建的话，则需要一个线性稳压电路，将输入电压稳定在2.8V进行芯片供电和芯片I/O端口的上拉，这个可以自己看它的数据手册；
2、GND：参考地；
3、SCL：I2C通信的时钟线；
4、SDA：I2C通信的数据线；
5、XSHUT：芯片的使能管脚，电平1代表有效，电平0代表无效；
6、GPIO1：芯片的中断管脚。

本文与STM32F103的连线如下：
VIN--------------->3.3V
GND------------->GND
SCL-------------->PB6
SDA-------------->PB7

其中XSHUT与GPIO1没有连接，由电路可知，未连接时它们均上拉为高电平，XSHUT一直为高则代表芯片始终有效工作，如果有需要也可以进行连接，用单片机控制。在这里我没有使用到，因此直接不连接就行。


二、程序代码

1. #ifndef _VL53L0_H
   
2. #define _VL53L0_H
   
3. 
   
4. #define VL53L0X_REG_IDENTIFICATION_MODEL_ID         0xc0
   
5. #define VL53L0X_REG_IDENTIFICATION_REVISION_ID      0xc2
   
6. #define VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD   0x50
   
7. #define VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD 0x70
   
8. #define VL53L0X_REG_SYSRANGE_START                  0x00
   
9. #define VL53L0X_REG_RESULT_INTERRUPT_STATUS         0x13
   
10. #define VL53L0X_REG_RESULT_RANGE_STATUS             0x14
    
11. #define VL53L0X_Add 0x29
    
12. #include "stm32f10x.h"
    
13. #include "bsp_usart1.h"
    
14. #include "bsp_i2c_gpio.h"
    
15. 
    
16. u8 VL53L0X_Write_Len(u8 addr,u8 reg,u8 len,u8 *buf);
    
17. u8 VL53L0X_Read_Len(u8 addr,u8 reg,u8 len,u8 *buf);
    
18. u8 VL53L0X_Write_Byte(u8 reg,u8 data);
    
19. u8 VL53L0X_Read_Byte(u8 reg);
    
20. uint16_t bswap(u8 b[]);                                  
    
21. uint16_t VL53L0X_decode_vcsel_period(short vcsel_period_reg);       
    
22. uint16_t makeuint16(int lsb, int msb);                 
    
23. 
    
24. #endif
    
25. 
    
26. #include "VL53L0.h"
    
27. uint16_t bswap(u8 b[])
    
28. {
    
29.         uint16_t val = ((b[0]<< 8) & b[1]);
    
30.         return val;
    
31. }
    
32. 
    
33. uint16_t VL53L0X_decode_vcsel_period(short vcsel_period_reg)
    
34. {
    
35.         uint16_t vcsel_period_pclks = (vcsel_period_reg + 1) <<1;
    
36.         return vcsel_period_pclks;
    
37. }
    
38. 
    
39. uint16_t makeuint16(int lsb, int msb)
    
40. {
    
41.     return ((msb & 0xFF) << 8) | (lsb & 0xFF);
    
42. }
    
43. 
    
44. u8 VL53L0X_Write_Len(u8 addr,u8 reg,u8 len,u8 *buf)
    
45. {
    
46.         u8 i;
    
47.     i2c_Start();
    
48.         i2c_SendByte((addr<<1)|0);
    
49.         if(i2c_WaitAck())
    
50.         {
    
51.                 i2c_Stop();                 
    
52.                 return 1;               
    
53.         }
    
54.     i2c_SendByte(reg);
    
55.     i2c_WaitAck();               
    
56.         for(i=0;i<len;i++)
    
57.         {
    
58.                 i2c_SendByte(buf[i]);       
    
59.                 if(i2c_WaitAck())               
    
60.                 {
    
61.                         i2c_Stop();         
    
62.                         return 1;                 
    
63.                 }               
    
64.         }   
    
65.     i2c_Stop();         
    
66.         return 0;       
    
67. }
    
68. 
    
69. u8 VL53L0X_Read_Len(u8 addr,u8 reg,u8 len,u8 *buf)
    
70. {
    
71.         i2c_Start();
    
72.         i2c_SendByte((addr<<1)|0);
    
73.         if(i2c_WaitAck())       
    
74.                 i2c_Stop();                 
    
75.                 return 1;               
    
76.         }
    
77.     i2c_SendByte(reg);       
    
78.     i2c_WaitAck();               
    
79.     i2c_Start();
    
80.         i2c_SendByte((addr<<1)|1);       
    
81.     i2c_WaitAck();               
    
82.                
    
83. while(len)
    
84.         {
    
85.                 if(len==1)
    
86.                 {
    
87.                         *buf=i2c_ReadByte();
    
88.                         i2c_NAck();
    
89.                 }
    
90.                 else
    
91.                 {
    
92.                         *buf=i2c_ReadByte();       
    
93.                         i2c_Ack();
    
94.                 }
    
95.                 len--;
    
96.                 buf++;
    
97.         }   
    
98.     i2c_Stop();
    
99.         return 0;       
    
100. }
     
101. 
     
102. //IIC写一个字节
     
103. //reg：寄存器地址
     
104. //data：数据
     
105. //·返回值：0，代表正常
     
106. //     其他，错误代码
     
107. u8 VL53L0X_Write_Byte(u8 reg,u8 data)                                  
     
108. {
     
109.     i2c_Start();
     
110.         i2c_SendByte((VL53L0X_Add<<1)|0);//发送器件地址+写命令
     
111.         if(i2c_WaitAck())        //等待应答
     
112.         {
     
113.                 i2c_Stop();                 
     
114.                 return 1;               
     
115.         }
     
116.     i2c_SendByte(reg);        //写寄存器地址
     
117.     i2c_WaitAck();                //等待应答
     
118.         i2c_SendByte(data);//发送数据
     
119.         if(i2c_WaitAck())        //等待应答
     
120.         {
     
121.                 i2c_Stop();         
     
122.                 return 1;                 
     
123.         }                 
     
124.     i2c_Stop();         
     
125.         return 0;
     
126. }
     
127. //IIC读一个字节
     
128. //reg：寄存器地址
     
129. //返回值：读到的数据
     
130. u8 VL53L0X_Read_Byte(u8 reg)
     
131. {
     
132.         u8 res;
     
133.     i2c_Start();
     
134.         i2c_SendByte(0x52);//发送器件地址+写命令       
     
135.         i2c_WaitAck();                //等待应答
     
136.     i2c_SendByte(reg);        //写寄存器地址
     
137.     i2c_WaitAck();                //等待应答
     
138.     i2c_Start();
     
139.         i2c_SendByte(0x53 );//发送器件地址+读命令
     
140.     i2c_WaitAck();
     
141. i2c_SendByte(reg);    //写寄存器地址
     
142.         res=i2c_ReadByte();   //读取数据，发送nACK
     
143.     i2c_Stop();                        //产生一个停止条件
     
144.         return res;               
     
145. }
     
146. 
     
147. main.c：
     
148. #include "stm32f10x.h"
     
149. #include "bsp_usart1.h"
     
150. #include "bsp_i2c_gpio.h"
     
151. #include "VL53L0.h"
     
152. 
     
153. uint8_t Rxflag=0;
     
154. uint8_t ucTemp;
     
155. 
     
156. int main(void)
     
157. {       
     
158.        
     
159.         u8 val = 0;
     
160.   u8 gbuf[16];
     
161.         u8 DeviceRangeStatusInternal;
     
162.         u8 tp=0;
     
163.        
     
164.         uint32_t cnt = 0;
     
165.         uint16_t count[3];
     
166.        
     
167.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
     
168.         USARTx_Config();
     
169.         NVIC_Configuration();
     
170.         InitSysTick();
     
171.          bsp_InitI2C();
     
172.         while(1)
     
173.         {
     
174.        
     
175.           VL53L0X_Write_Byte(VL53L0X_REG_SYSRANGE_START, 0x01);
     
176.           
     
177.                  while(cnt < 100)
     
178.                  {
     
179.                                 delay_ms(10);
     
180.                                 val = VL53L0X_Read_Byte(VL53L0X_REG_RESULT_RANGE_STATUS);
     
181.                                 if( val & 0x01) break;
     
182.                                 cnt++;
     
183.                  }
     
184. 
     
185.                  if( val & 0x01)
     
186.                                 printf("\r\n readey \r\n");
     
187.                  else
     
188.                                 printf("\r\n not readey \r\n");
     
189.      VL53L0X_Read_Len(VL53L0X_Add, 0x14 , 12, gbuf);
     
190.                        
     
191.                  count[0] = makeuint16(gbuf[7], gbuf[6]);
     
192.                  count[1] = makeuint16(gbuf[9], gbuf[8]);
     
193.                  count[2] = makeuint16(gbuf[11], gbuf[10]);
     
194.                  DeviceRangeStatusInternal = ((gbuf[0] & 0x78) >> 3);
     
195. 
     
196.                  printf("\r\n ambient count = %4d signal count = %4d distance = %4d status = %d ",count[0],count[1],count[2],DeviceRangeStatusInternal);
     
197. 
     
198.                 delay_ms(1000);
     
199.                  
     
200.        
     
201.         }
     
202. }
     
203. 
     

复制代码

————————————————
版权声明：TangPeng_HanMO