本文介绍基于STM32F407的KS103超声波模块的使用，包含使用注意事项以及代码配置，同时会附上本人在开发时遇到的问题以及解决方法。

1 P' V8 j! X  t( g* Q. h4 F8 G7 }/ W' E
) V, x" ^+ r1 ^4 DKS103模块使用串口/IIC接口与主机通信，自动响应主机的iic/串口控制指令。
& x' F6 f4 |0 i  T0 V包含温度补偿的距离探测，同时可以在1ms内检测光强。

探测范围 1cm～800cm及 1cm～1000cm(10 米)
5s 未收到 I2C 控制指令自动进入 uA 级休眠，并可随时被主机 I2C 控制指令唤醒
% s: `/ o: b6 p* t/ L8 @2 b  DTTL串口模式
& Z) o' r6 w- p. ^2 G在 KS103 上连线引脚上标识有：VCC、SDA/TX、SCL/RX、GND 及 MODE。模块在上电之前，MODE 需要接 0V 地，上电后模块将工作于 TTL 串口模式。如果KS103在上电后再将 MODE 引脚接 0V 地，模块将仍然工作于 I2C 模式。因此，TTL 串口模式时需要 5 根线来控制，其中 VCC 用于连接+5V(3.0～5.5V 范围均可)电源(1)，GND用于连接电源地，SDA/TX 连接 MCU 或 USB 转 TTL 模块的 RXD，SCL/RX 引脚连接 MCU 或USB 转 TTL 模块的 TXD 。

/ E  F0 Q/ t! E4 A- z) f在使用时最好使用5V标准电压，电压低会影响量程。
' v4 n* E2 y. M+ F3 Z新到手的模块默认串口地址是0xE8，可修改。
3 B3 b2 F1 d2 K这里本人被坑了，因为我到手的模块是别人用过的，被修改了地址但是不和我说，就是调试不出来。
当然也是我偷懒了，模块在上电的时候背面的LED会闪烁，告诉用户自身的地址，我没在意。上电后快闪两下是代表二进制的“1”，慢闪一下代表“0”，一共八位，盯着记录就能获得其地址。
串口模式很占用串口资源，我并没有使用该模式进行开发，仅仅使用了官方的上位机进行测试，鉴定模组的好坏。

确认模组没问题，选用IIC接口进行开发，这样一条总线可以挂载多个模块，只需要总线寻址便可。

0 i" o) U; h, ~3 z/ u( QI2C 模式
8 e0 o  V, |4 j在使用iic模式时，硬件需要注意几点：
) G7 I- E( Z6 NSCL 及 SDA 线均需要由主机接一个 4.7K(阻值 1～10K 均可)电阻到 VCC ；
5 t+ w4 _. B. Y+ d, wI2C 通信速率建议不要高于 100kbit/s （因为模块的iic最大速率只有100K）。
% T0 v; I8 f0 E  c2 _  i/ _! b; E直接从代码开始：
6 ~2 M+ t$ o& j$ U因为对速度要求不高，而且为了移植方便，采用软件模拟iic。其实为了偷懒，模拟简单呀。
& S( o+ A/ Q( Q6 F; R老规矩，初始化iic。

1. void IIC_Init(void)
   7 P/ ]/ \! B" ^3 {( |( Z) y. k
2. 
   
3. {                        
   
4. 
   
5.   GPIO_InitTypeDef  GPIO_InitStructure;
   
6. 
   
7. 
   
8. 
   ' j$ I/ u" \4 J2 V
9.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
   
10. 
    . D/ b1 m; e; H3 d0 H, L/ w
11. 
    , p! B6 y2 T: S. U
12. 
    
13.   //GPIOB8,B9初始化设置
    
14. 
    
15.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
    9 B8 f- x3 T: r3 D, s6 z5 b6 G; H
16. 
    
17.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
    
18. 
    , {$ |# W2 D# B
19.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    # ^# ?% c# f+ j( L# O
20. 
    
21.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    
22. 
    * H* {7 Q. Z$ a1 v% S4 g
23.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
24. 
    
25.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    
26. 
    3 J( X6 j& k, S5 H' b% E
27.         IIC_SCL=1;
    
28. 
    2 S& D6 q# G- ]/ z4 }  Q( R
29.         IIC_SDA=1;
    3 |& x) F$ C' Q0 y% @
30. 
    $ q8 ?6 U& |7 ]: n. H7 _
31. }

复制代码

写iic控制函数，老掉牙的东西，全网都有。

1. //产生IIC起始信号
   
2. 
   
3. void IIC_Start(void)
   
4. 
   
5. {
   
6. 
   
7.         SDA_OUT();     //sda线输出
   
8. 
   3 W' q) t3 U  v8 q0 n
9.         IIC_SDA=1;                    
   6 w6 \' @$ h, i% Y) M' J$ ]7 Q1 g
10. 
    
11.         IIC_SCL=1;
    
12. 
    
13.         delay_us(10);
    " H: ^( p* z% {2 B& t# {
14. 
    * q4 Q& y6 Y  }( \. ]# m
15.          IIC_SDA=0;//START:when CLK is high,DATA change form high to low
    # ~& V; E1 ], j- @) [; p# I+ b  \
16. 
    ( ~* D6 ~" G% i  C! F) l
17.         delay_us(10);
    8 g; @) M" r8 p% P
18. 
    ' p! g! s/ {9 l3 u
19.         IIC_SCL=0;//钳住I2C总线，准备发送或接收数据
    7 `* D( m, ]9 O9 |
20. 
    ! @& R" \- B) s2 r$ J) L5 R
21. }         
    
22. 
    $ a* h7 [1 o% S
23. //产生IIC停止信号
    2 H7 s2 y* P# s. Y6 [- O9 X
24. 
    $ `4 i9 O: |# T) H0 }$ V5 T
25. void IIC_Stop(void)
    ! ]6 j3 A# c$ J, F( Y9 A6 C. v; P
26. 
    # K- {1 t8 M, x/ T% }
27. {
    
28. 
    9 [* Q% R6 u4 \: B4 N5 u
29.         SDA_OUT();//sda线输出
    * Y! ~. j8 Y- e2 u8 n, E
30. 
    2 e' [# B0 m! t! j4 \
31.         IIC_SCL=0;
    
32. 
    
33.         IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    6 v4 W3 ^; _$ u+ u
34. 
    ; x7 T2 z& i/ v4 N/ U4 o
35.          delay_us(10);
    % q, a) n+ ~; `. w# m% _5 P* Y
36. 
    + d+ }$ {; _- r, T; ?* a
37.         IIC_SCL=1;
    4 W7 Z/ R1 d; W& h# j. Q" O
38. 
    
39.         IIC_SDA=1;//发送I2C总线结束信号
    0 }4 O& u9 C( S  C7 A
40. 
    6 z3 r4 v$ k, i: V3 I) S
41.         delay_us(10);                                                                  
    
42. 
    7 Z9 S7 Z0 _6 k
43. }
    ; _1 y6 V- j( h, x  T  P' u0 h, E
44. 
    7 Q% h$ f" Z4 Q& x; O7 h
45. //等待应答信号到来
    : b0 R3 d) R+ s0 L" y
46. 
    : K& A) q, K3 E( `
47. //返回值：1，接收应答失败
    & J( I- R- ^: i0 _1 Q( v
48. 
    ! I5 X- h$ M( |6 T3 x% t& z8 y
49. //        0，接收应答成功
    
50. 
    2 T7 }1 o6 B" M) O# Y% Y& H. q  m1 v1 o
51. u8 IIC_Wait_Ack(void)
    
52. 
    0 ^" t' H, ?0 e  f0 k5 a
53. {
    , ?; F" R) `/ k% p; K
54. 
    
55.         u8 ucErrTime=0;
    
56. 
    / g/ p* y) V1 K. d. H) R  `8 D
57.         SDA_IN();      //SDA设置为输入  
    4 i* m: l" H! O2 T
58. 
    
59.         IIC_SDA=1;delay_us(6);           
    
60. 
    
61.         IIC_SCL=1;delay_us(6);         
    4 v0 E2 I! q8 c' W5 x+ r9 M
62. 
    
63.         while(READ_SDA)
    4 P; G/ s$ Y; Y3 F) G
64. 
    / u6 i4 O2 |1 i& Q, b
65.         {
    ; }: m+ n  ~/ p# I9 {
66. 
    
67.                 ucErrTime++;
    
68. 
    % N- T3 e# \2 |4 T( l- b: b* Y* n
69.                 if(ucErrTime>250)
    
70. 
    # C4 l( D9 ^9 C
71.                 {
    
72. 
    & d( K; r8 C/ G/ x4 n+ G
73.                         IIC_Stop();
    
74. 
    
75.                         return 1;
    0 q, V1 I9 C& R# [+ W  s8 K
76. 
    
77.                 }
    0 E: b, \1 c. I, n
78. 
    0 a2 x$ y7 q: g$ B' f; Y" S2 N
79.         }
    - M" w# T% [/ |* l" S0 p6 w. G
80. 
    
81.         IIC_SCL=0;//时钟输出0            
    4 h' d6 g: M1 c# t9 E
82. 
    6 ^4 H9 P* n5 P: @* p. s
83.         return 0;  
    / ~2 V$ }' j. n. h' [3 C
84. 
    
85. }
    
86. 
    - Y& C  S7 q, C" I0 S7 M. e, L
87. //产生ACK应答
    0 I1 u$ {; E# T
88. 
    " x  W$ z" {) H0 }* K8 ]' w
89. void IIC_Ack(void)
    
90. 
    $ _; R, e2 P# K9 A. M
91. {
    5 j  d$ @' ^, {9 M  l
92. 
    : t* J" x+ h+ q2 l: A6 `; l
93.         IIC_SCL=0;
    - d/ W+ _4 b) _- F
94. 
    / s: c$ y2 g! ^/ d6 P
95.         SDA_OUT();
    8 ~) E  ]/ a4 Y  t" |7 g
96. 
    
97.         IIC_SDA=0;
    
98. 
    " N6 d; t0 W/ a9 w7 k5 X' j3 Y. Y
99.         delay_us(10);
    
100. 
     
101.         IIC_SCL=1;
     7 P4 C6 F8 x; h0 i2 n/ J
102. 
     
103.         delay_us(10);
     & g9 t2 C  Z% e6 v
104. 
     5 x5 c+ ]9 g! R: v4 {$ x
105.         IIC_SCL=0;
     & G# ]7 c. j: J/ e/ t4 l
106. 
     
107. }
     + |, t1 P! {8 P/ l/ W& a& Y' d0 o
108. 
     # a  g0 h; f5 D& m/ H' j: L
109. //不产生ACK应答                    
     
110. 
     
111. void IIC_NAck(void)
     + W2 G" _) p; {8 }4 u
112. 
     , g1 l4 K. G! H% k) @
113. {
     
114. 
     ( v: O; R: A; T; e4 K4 J5 V; r9 [
115.         IIC_SCL=0;
     + T( s- J7 ?6 L' Z
116. 
     4 S, X. x! Y! h) Z  a5 L/ ?
117.         SDA_OUT();
     
118. 
     
119.         IIC_SDA=1;
     & d; p6 o: |& i+ f4 D
120. 
       ]' j3 C, ^4 V, ]0 i& D- g/ I2 b
121.         delay_us(10);
     
122. 
     
123.         IIC_SCL=1;
     ! z$ b2 y+ U1 e5 a5 p, i: M$ G) Y% v
124. 
     
125.         delay_us(10);
     ' j- ~3 q+ p! }% u) X' l; \/ p
126. 
     % ?  \) J' \* x
127.         IIC_SCL=0;
     
128. 
     
129. }                                                                              
     & W; T0 \1 Q0 |* M+ p
130. 
     
131. //IIC发送一个字节
     
132. 
     
133. //返回从机有无应答
     
134. 
     
135. //1，有应答
     ( {, p7 J! N$ p% F! b" d/ {1 P
136. 
     
137. //0，无应答                          
     
138. 
     
139. void IIC_Send_Byte(u8 txd)
     
140. 
     
141. {                        
     9 i5 O0 }: T' E( t( C4 n
142. 
     
143.     u8 t;   
     & _0 M7 }' [! \/ C& |
144. 
     . ?  F3 }/ O' y/ p4 S$ M
145.         SDA_OUT();            
     ) f# h! w  \7 F' s* O; \
146. 
     3 H# t! a; w# N% b( G) Z8 x
147.     IIC_SCL=0;//拉低时钟开始数据传输
     
148. 
     
149.     for(t=0;t<8;t++)
     ( q/ r7 s5 _5 m/ ?2 s
150. 
     
151.     {              
     
152. 
     . f1 ^+ h# M8 @$ S8 R
153.         IIC_SDA=(txd&0x80)>>7;
     
154. 
     
155.         txd<<=1;           
     
156. 
     3 o2 M0 K6 M; n. B9 ?/ S. ]$ O
157.                 delay_us(10);   //对TEA5767这三个延时都是必须的
     . r" S( o7 R0 ]" U
158. 
     5 y( X# O9 t9 z* b2 W4 s7 W
159.                 IIC_SCL=1;
     
160. 
     
161.                 delay_us(10);
     ( q( a3 @* _$ ]) l% ?
162. 
     
163.                 IIC_SCL=0;        
     # L7 v, A/ ^  C2 {. B, p" [
164. 
     1 t. r5 {+ B# `# [. m+ W- l/ c+ Q" X
165.                 delay_us(10);
     
166. 
     
167.     }         
     ) ]" I) P5 ?) F$ {' ]- R
168. 
     
169. }            
     + r8 w7 w* D1 D
170. 
     
171. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
     + f4 h4 ^; [6 \0 t
172. 
     * ~5 i7 r4 W0 c  I8 d$ h
173. u8 IIC_Read_Byte(unsigned char ack)
     : |( E' e$ [6 b. P" r4 I7 [
174. 
     
175. {
     
176. 
     
177.         unsigned char i,receive=0;
     
178. 
     
179.         SDA_IN();//SDA设置为输入
     
180. 
       O. I8 v: @$ ?$ {4 H6 D
181.     for(i=0;i<8;i++ )
     9 g5 J/ E% b0 Q. P% t1 f
182. 
     
183.         {
     : [  l  n4 n+ A" r$ [! ~: N
184. 
     
185.         IIC_SCL=0;
     
186. 
     
187.         delay_us(10);
     2 f- M. K% S: P% B0 W6 o$ V
188. 
     " ~6 N4 s3 I! `0 H) F8 B7 \, L/ A
189.                 IIC_SCL=1;
     % ~  y. l: c* Q2 q8 T! i) T9 \
190. 
     
191.         receive<<=1;
     : m' \; V& J1 p: p8 ~3 n, j
192. 
     
193.         if(READ_SDA)receive++;   
     1 |, _  t# A9 k, s9 g+ A8 D/ G" f+ Q
194. 
     5 {2 i. Q. f  @8 W  j
195.                 delay_us(5);
     # y% M4 q( M9 k8 Z1 b6 J8 e7 `
196. 
     
197.     }                                         
     
198. 
     7 e. [7 C) Q; y; H
199.     if (!ack)
     4 M0 i( X: v. t! }: P3 @) m
200. 
     0 d6 E0 U. x8 y: ~  k5 Z6 ?+ M
201.         IIC_NAck();//发送nACK
     , ?) D1 g  j' j
202. 
     ! _2 A) Y8 Y  w6 ^
203.     else
     ! z: J0 c/ T8 y  s$ ?* o
204. 
     
205.         IIC_Ack(); //发送ACK   
     , ^. t# q) i0 g# L
206. 
     
207.     return receive;
     + Y2 b2 V' Y, g9 `2 T
208. 
     
209. }

复制代码

- t( W) M, a/ E* }( M+ w8 M

写KS103的控制函数

1. u8 KS103_ReadOneByte(u8 address, u8 reg)
   & v% M, {* F* [& G, S  ]
2. 
   ) U: q( ?7 Q8 L; h
3. {
   
4. 
   
5. u8 temp=0;                                                                                                                                                               
   7 n% Z- ?: i" [+ y- g& s
6. 
   5 D2 f# x3 e1 _3 z+ r2 @- Q3 N
7.     IIC_Start();  
   # M% V+ x2 D/ Z5 g2 @1 u& v5 ^, `
8. 
   
9.     IIC_Send_Byte(address);   //发送低地址
   
10. 
    ' Y! S; I8 X3 r9 f6 W$ d7 i1 ^
11.         IIC_Wait_Ack();         
    " E3 m0 t4 J8 h+ l& L/ d
12. 
    
13.         IIC_Send_Byte(reg);   //发送低地址
    
14. 
    1 U! R3 W/ r# M$ j
15.         IIC_Wait_Ack();           
    3 E+ Z+ [! x2 Z4 y! Y5 g
16. 
    3 e" b0 I; N, e( s  W
17.         IIC_Start();                     
    4 B: o% Q) _5 D% H* L2 o( G
18. 
    
19.         IIC_Send_Byte(address + 1);           //进入接收模式                           
    
20. 
    4 X; h7 c+ n1 ?+ ^. F  A; ?
21.         IIC_Wait_Ack();         
    & ~( h1 R+ W9 X: c. F& \3 E9 a$ C
22. 
    
23. 
    
24. 
    
25.         delay_us(50);           //增加此代码通信成功！！！
    * k% ?  X% S  w
26. 
    
27.     temp=IIC_Read_Byte(0);          //读寄存器3           
    
28. 
    
29.     IIC_Stop();//产生一个停止条件            
    
30. 
    
31.         return temp;
    
32. 
    
33. }
    
34. 
      Q# r" }; O& H  w- m) s, W4 t
35. 
    
36. 
    9 ^3 T; h& z9 W$ d& C. A
37. 
    7 n! U  d& s# U# I" m; R4 f; }
38. 
    9 [  Z  x5 [8 u' Z! g
39. void KS103_WriteOneByte(u8 address,u8 reg,u8 command)
    
40. 
    3 }( `' ^6 ^% M& R
41. {
    / R. Y2 j) P5 V! ~* O2 r
42. 
    : r4 }0 H; @4 k4 l4 f
43. IIC_Start();   
    7 T# C+ g6 E& a
44. 
    - ]1 W# {8 P% a. D7 Q2 {
45.         IIC_Send_Byte(address);            //发送写命令
    
46. 
    
47.         IIC_Wait_Ack();
    + U/ ?4 x6 h. @! u/ e) o" f9 c7 `
48. 
    
49.         IIC_Send_Byte(reg);//发送高地址         
    
50. 
    
51.         IIC_Wait_Ack();           
    
52. 
    $ T! ~* O6 S4 O( i+ ]
53.     IIC_Send_Byte(command);   //发送低地址
    
54. 
    + Q7 `) S  P( B+ r+ p  Z7 A
55.         IIC_Wait_Ack();                                                                                                               
      h# @6 N" L8 Y7 P. W4 d
56. 
      O, S7 k) d$ v
57.     IIC_Stop();//产生一个停止条件
      A& J$ K( X) L& e
58. 
    2 _# g. e" Q3 v
59. }

复制代码

( [; a. i2 I$ W; C8 m2 L1 a

这里依照了模块的指令发送流程：

探测指令从 0x01 到 0x2f，数值越大，信号增益越大。
1 f% z7 u- }2 ^; H0 U. y获取距离数据

1.    KS103_WriteOneByte(0XD2,0X02,0XB0);
   - N1 b6 y/ T: j' V- T6 P1 W
2. 
   
3.                                    delay_ms(100);
   
4. 
   
5.                                    range1 = KS103_ReadOneByte(0xD2, 0x02);
   
6. 
   
7.                                    range2 = KS103_ReadOneByte(0xD2, 0x03);

复制代码

每一帧的探测指令格式为：

/ X* \3 [$ {, M
( u1 \! q( a! A  |0 j3 V% }

KS103_WriteOneByte(0XD2,0X02,0XB0); 中，0xd2为模块的地址，02为寄存器地址，0xB0为控制命令。

, ]: l* o) p" h" }- B& T- d/ B
6 A3 r, e8 d" I4 P3 v" L
2 H, P5 n$ ]0 Q( T

在发送探测指令后需要等待一段时间才可通过iic总线获取数据，过早的查询总线会获得0XFF。在读取总线数据时除了需要发送模块iic的地址，还需要将模块iic的地址加1，而且在之后必须要等待，才能获取完整的数据。因为返回的是16位数据，所以这里我采用执行两次KS103_ReadOneByte（）函数。
在这些都处理完之后我将采集到的数据输出到串口，发现并不能成功，range1和range2的值并不变。最后发现我是用的是0xBC探测指令，最大耗时87MS，而我只延时50ms。通过修改探测指令和延时时间均可解决问题。
6 F7 m- d) r$ T( m  j% \; ~后面附上产品手册，必须附录，没这个真不行。到处是坑。说到底也怪我粗心。下次一定，下次一定。

---------------------
  a/ T, r7 Q, x作者：呐咯密密