本文记录了我使用STM32F103结合VL53L0测距模块的一个学习过程。
VL53L0是由ST公司最新推出的一款飞行时间测距+手势检测的微型模块，它应用非常广泛包括：激光测距、避障检测、一维手势识别等；接下来我们重点介绍它的激光测距功能。
2 m6 ^4 {( R4 T: Y
一、模块的硬件连接
( ]1 n3 M( {! Q8 p7 ?1 J
3 f- X' I3 U  x" ~1 D2 r
! F% r3 B2 [/ |1 D" m
9 g! S* y& X" E/ t7 I/ N
; w+ {0 u% }+ f/ S1 {1 z. d% V上图便是我所使用的测距模块GYVL53L0XV2，它预留了六个接口：
/ b! R/ r# q6 _2 M1、VIN：供电电压，可在3V~5V范围内进行供电，但如果自己进行电路搭建的话，则需要一个线性稳压电路，将输入电压稳定在2.8V进行芯片供电和芯片I/O端口的上拉，这个可以自己看它的数据手册；
5 {$ f$ k% ~' G  Y$ h3 `+ ?2 t7 t2、GND：参考地；
3、SCL：I2C通信的时钟线；
" i8 \: Z! o* h% U4、SDA：I2C通信的数据线；
5、XSHUT：芯片的使能管脚，电平1代表有效，电平0代表无效；
6、GPIO1：芯片的中断管脚。
& J4 i! b# K9 g1 g4 L" y
本文与STM32F103的连线如下：
VIN--------------->3.3V
  }0 Y/ M: e- L% s" [8 BGND------------->GND
5 }  b, U& q  f( iSCL-------------->PB6
SDA-------------->PB7

其中XSHUT与GPIO1没有连接，由电路可知，未连接时它们均上拉为高电平，XSHUT一直为高则代表芯片始终有效工作，如果有需要也可以进行连接，用单片机控制。在这里我没有使用到，因此直接不连接就行。
" H) P; i) g6 l5 r. h
6 g! ?. ^7 j' v+ [% t3 U
% c7 l, h$ y+ s: r" Y, K3 e二、程序代码
. e- q1 F8 o# @

1. #ifndef _VL53L0_H
   9 A2 l3 `) G# }1 {0 S2 R$ }
2. #define _VL53L0_H
   
3. 
   0 V3 Y' h" a) ]" W
4. #define VL53L0X_REG_IDENTIFICATION_MODEL_ID         0xc0
   ; d; Q! [: |  u1 Q( D! r1 Z
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
   1 U% Q8 @8 s9 X: q7 E; p
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"
    1 k; A$ Y  p; G' m) `; w% Y
13. #include "bsp_usart1.h"
    ! b9 ~5 V+ X4 p$ B: Z
14. #include "bsp_i2c_gpio.h"
    5 S( q+ e: f+ [
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);
    : `  b( {* f  q; T
19. u8 VL53L0X_Read_Byte(u8 reg);
    / d9 e8 D7 p5 m, C$ |
20. uint16_t bswap(u8 b[]);                                  
    4 w% ?$ F/ v7 L! o; f. s
21. uint16_t VL53L0X_decode_vcsel_period(short vcsel_period_reg);       
    
22. uint16_t makeuint16(int lsb, int msb);                 
    3 _0 {9 g' a. u4 L
23. 
    
24. #endif
    
25. 
    9 A( d5 J/ W, a. V' I- C# n% ~
26. #include "VL53L0.h"
    & C/ U6 v" @" D0 k2 L4 G
27. uint16_t bswap(u8 b[])
    ; _7 _6 J7 ]4 i/ F+ f  B6 z
28. {
    
29.         uint16_t val = ((b[0]<< 8) & b[1]);
    ( e7 }' I6 T6 a/ h$ h
30.         return val;
    
31. }
    8 L( c) Y2 T3 B/ a  t
32. 
    
33. uint16_t VL53L0X_decode_vcsel_period(short vcsel_period_reg)
    1 v' X, o0 D' v0 _
34. {
    : u4 d; o) G! L) r7 o
35.         uint16_t vcsel_period_pclks = (vcsel_period_reg + 1) <<1;
    
36.         return vcsel_period_pclks;
    
37. }
    
38. 
    , G- X( P2 ^9 L/ T5 V
39. uint16_t makeuint16(int lsb, int msb)
    
40. {
    4 u6 o3 C# ^0 P( p4 u" H
41.     return ((msb & 0xFF) << 8) | (lsb & 0xFF);
    
42. }
    
43. 
    9 i! [, \9 f( o2 R0 g$ _
44. u8 VL53L0X_Write_Len(u8 addr,u8 reg,u8 len,u8 *buf)
    
45. {
    
46.         u8 i;
    # c# t6 P4 l& ^! w; p
47.     i2c_Start();
    
48.         i2c_SendByte((addr<<1)|0);
    
49.         if(i2c_WaitAck())
    " C0 W( s$ H7 J# |6 d! u' z
50.         {
    ( ]. ?) a1 r( Q* J# H
51.                 i2c_Stop();                 
    ; ]" f: Z) Y% q1 u
52.                 return 1;               
    + ?; ]0 [% Y/ `; r2 G8 |: @  [. R
53.         }
    
54.     i2c_SendByte(reg);
    
55.     i2c_WaitAck();               
    3 @5 d) ]0 a# ~' r
56.         for(i=0;i<len;i++)
    . k% t* I6 \- V
57.         {
    * i+ N2 p# @$ G4 |
58.                 i2c_SendByte(buf[i]);       
    $ |3 Y; `3 P9 H: }: E' ~' i4 n
59.                 if(i2c_WaitAck())               
    $ _% ~7 ^4 Z# u' y! {
60.                 {
    # P% K: b7 f/ E: y- Q- n6 M  I
61.                         i2c_Stop();         
    
62.                         return 1;                 
    ) ]/ Q. M$ [' u. \8 J& b  \
63.                 }               
    
64.         }   
    
65.     i2c_Stop();         
    
66.         return 0;       
    6 w; S+ c4 O. ^; |! M
67. }
    
68. 
    
69. u8 VL53L0X_Read_Len(u8 addr,u8 reg,u8 len,u8 *buf)
    
70. {
    / \- |& ^% J. l) r
71.         i2c_Start();
    ; G" `" J7 {1 O9 k1 r4 p9 f
72.         i2c_SendByte((addr<<1)|0);
    % q6 q7 g- Q2 F) ~. p/ [4 x& z7 ~- b7 l
73.         if(i2c_WaitAck())       
    
74.                 i2c_Stop();                 
    * r+ u' k3 @) k" D
75.                 return 1;               
    
76.         }
    
77.     i2c_SendByte(reg);       
    
78.     i2c_WaitAck();               
    , V0 B4 ?) S* ], P3 B
79.     i2c_Start();
    * b, ?6 q5 Q9 I4 b1 M
80.         i2c_SendByte((addr<<1)|1);       
    8 U3 G) y1 B' b) d1 [. T
81.     i2c_WaitAck();               
    
82.                
    : g! b$ y. o8 S1 a/ m; y7 o
83. while(len)
    ; L* p, k( k2 w9 i. A' E" D: {+ n
84.         {
    & ]' q  n5 e2 _/ N, p. W# P" Z
85.                 if(len==1)
    
86.                 {
    
87.                         *buf=i2c_ReadByte();
      x7 s5 V. k* e* Z
88.                         i2c_NAck();
    
89.                 }
    / [/ m, l- N/ L
90.                 else
    9 U6 q* U1 h1 y  t
91.                 {
    
92.                         *buf=i2c_ReadByte();       
    0 ]+ v% E+ R) ^7 w
93.                         i2c_Ack();
    4 Q- h4 X5 ?  [; L& Y& [
94.                 }
    9 j" f( l7 B. J: h# e2 l0 \4 k
95.                 len--;
    8 P+ c, y" A7 `* P8 ~6 r
96.                 buf++;
    7 K' J% w. I' f# U
97.         }   
    
98.     i2c_Stop();
    
99.         return 0;       
    
100. }
     
101. 
     , E) M% i% c$ s# H3 h) o  s1 G
102. //IIC写一个字节
     ) w! j7 c' k: H0 W; y
103. //reg：寄存器地址
     
104. //data：数据
     
105. //·返回值：0，代表正常
     7 K. G1 y& {" w5 S, I
106. //     其他，错误代码
     
107. u8 VL53L0X_Write_Byte(u8 reg,u8 data)                                  
     
108. {
     
109.     i2c_Start();
     
110.         i2c_SendByte((VL53L0X_Add<<1)|0);//发送器件地址+写命令
     % ^( o+ h% I8 }% r1 k9 o6 i9 L- o
111.         if(i2c_WaitAck())        //等待应答
     
112.         {
     
113.                 i2c_Stop();                 
     6 ^% H' u7 c" W" f$ M0 K& e" @
114.                 return 1;               
     
115.         }
     0 q; c3 P! G, h) p* M' R1 a( F
116.     i2c_SendByte(reg);        //写寄存器地址
     
117.     i2c_WaitAck();                //等待应答
     9 M. w4 W- |9 V
118.         i2c_SendByte(data);//发送数据
     9 _4 y8 t+ g* u. C! a' d, B7 n
119.         if(i2c_WaitAck())        //等待应答
     
120.         {
     
121.                 i2c_Stop();         
     
122.                 return 1;                 
     6 A7 f/ P& g+ X) E( h7 Q
123.         }                 
     
124.     i2c_Stop();         
     $ U' ~. d% M9 P. b" \4 U
125.         return 0;
     
126. }
     7 t6 X8 c* Z, ?, F5 T! e
127. //IIC读一个字节
     
128. //reg：寄存器地址
     
129. //返回值：读到的数据
     . F% I5 S) q$ T+ p
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);        //写寄存器地址
     1 J1 f% t8 H" U; E. U+ [% I
137.     i2c_WaitAck();                //等待应答
     9 n. t% k  l6 V# M  ~
138.     i2c_Start();
     % ]( m8 r1 J+ R( i$ w
139.         i2c_SendByte(0x53 );//发送器件地址+读命令
     
140.     i2c_WaitAck();
     - K1 o2 u$ J' t
141. i2c_SendByte(reg);    //写寄存器地址
     4 Q" q% ^! a2 s' Y- Y
142.         res=i2c_ReadByte();   //读取数据，发送nACK
     ( `+ T* A1 r+ c$ P
143.     i2c_Stop();                        //产生一个停止条件
     
144.         return res;               
     , d! s. ^, t( z2 C; n' |5 C
145. }
     $ g$ r+ C+ G& ~' C/ J
146. 
     
147. main.c：
     4 g! f8 }) x) i' b4 y, M
148. #include "stm32f10x.h"
     
149. #include "bsp_usart1.h"
     
150. #include "bsp_i2c_gpio.h"
     : k* a5 f4 _7 R4 J6 P; T2 }
151. #include "VL53L0.h"
     
152. 
     
153. uint8_t Rxflag=0;
     / K# b% p% V: ^: W  u
154. uint8_t ucTemp;
     
155. 
     ; l: \# M0 ?) ^* j, L# l
156. int main(void)
     
157. {       
     , m# e: m; q4 ~/ S, Y
158.        
     , Z1 \. v& Q* j, i7 D5 J
159.         u8 val = 0;
     4 z- G# q9 Q5 p2 K: x& X
160.   u8 gbuf[16];
     " Z8 B4 [! ~+ P- F) L  \
161.         u8 DeviceRangeStatusInternal;
     % s% P+ V! V4 K: Y) h
162.         u8 tp=0;
     ; ?- f7 j4 z- m5 e: F2 f; H! S
163.        
     ( R. B. e+ r4 w. ~+ ^) ^  h# ^
164.         uint32_t cnt = 0;
     
165.         uint16_t count[3];
     
166.        
     
167.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
     : S/ |6 z2 h6 f( h+ v
168.         USARTx_Config();
     
169.         NVIC_Configuration();
     
170.         InitSysTick();
     
171.          bsp_InitI2C();
     ; \5 D5 i, g! c3 p7 b  f; M3 N
172.         while(1)
     
173.         {
     
174.        
     
175.           VL53L0X_Write_Byte(VL53L0X_REG_SYSRANGE_START, 0x01);
     8 {* V& Z  D; n$ c. |& a
176.           
     
177.                  while(cnt < 100)
     
178.                  {
     3 ?+ c! W2 i. B3 \) `9 ]) [$ o
179.                                 delay_ms(10);
     
180.                                 val = VL53L0X_Read_Byte(VL53L0X_REG_RESULT_RANGE_STATUS);
     
181.                                 if( val & 0x01) break;
     7 C- G( p7 m! v/ h
182.                                 cnt++;
     4 O5 C: k7 s/ i4 h
183.                  }
     0 S' y4 G! Y. M5 t* s6 S9 R8 U( d
184. 
     2 k- q8 ]7 o7 ]7 c8 Z" d, ]- x
185.                  if( val & 0x01)
     
186.                                 printf("\r\n readey \r\n");
     # d; X: x9 J/ \' Z
187.                  else
     
188.                                 printf("\r\n not readey \r\n");
     " u. @$ ~" o9 S3 n/ Z
189.      VL53L0X_Read_Len(VL53L0X_Add, 0x14 , 12, gbuf);
     3 r6 G6 x: x3 J1 }2 k7 O* B& ^
190.                        
     
191.                  count[0] = makeuint16(gbuf[7], gbuf[6]);
     & d( [  B5 f9 ~
192.                  count[1] = makeuint16(gbuf[9], gbuf[8]);
     2 X. r+ R5 \. H5 ~5 p' O* }
193.                  count[2] = makeuint16(gbuf[11], gbuf[10]);
     
194.                  DeviceRangeStatusInternal = ((gbuf[0] & 0x78) >> 3);
     : |5 B: u; L4 |/ F3 }8 T
195. 
     - {. m/ ~9 z/ P4 q
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.        
     / l+ g# O# f4 ~) [4 u
201.         }
     
202. }
     ) z& m% {" Y8 t9 x- Q( o
203. 
     

复制代码

; c& R* k  W; X  |1 @$ V4 D- g————————————————
版权声明：TangPeng_HanMO