01. 电容触摸按键简介
触摸按键相对于传统的机械按键有寿命长、占用空间少、易于操作等诸多优点。大家看看如今的手机，触摸屏、触摸按键大行其道，而传统的机械按键，正在逐步从手机上面消失。接下来给大家介绍一种简单的触摸按键：电容式触摸按键。
9 X# }' `) Z# t/ ?. X. J4 o# B% {# q
利用探索者 STM32F4 开发板上的触摸按键（TPAD）来实现对 DS1 的亮灭控制。这里 TPAD 其实就是探索者 STM32F4 开发板上的一小块覆铜区域，实现原理如图所示：
9 c2 h2 ~: _' S3 W8 s; Y6 ]
* Q2 R/ d7 P0 h  J# f" h5 S5 ^
/ X2 R/ ^0 `5 Y1 j6 x4 F* j! k, |1 X
( ~& z2 s3 @' l; m  W我们使用的是检测电容充放电时间的方法来判断是否有触摸，图中 R 是外接的电容充电电阻，Cs 是没有触摸按下时 TPAD 与 PCB 之间的杂散电容。而 Cx 则是有手指按下的时候，手指与 TPAD 之间形成的电容。图中的开关是电容放电开关（由实际使用时，由 STM32F4 的IO 代替）。

先用开关将 Cs（或 Cs+Cx）上的电放尽，然后断开开关，让 R 给 Cs（或 Cs+Cx）充电，当没有手指触摸的时候，Cs 的充电曲线如图中的 A 曲线。而当有手指触摸的时候，手指和 TPAD之间引入了新的电容 Cx，此时 Cs+Cx 的充电曲线如图中的 B 曲线。从上图可以看出，A、B两种情况下，Vc 达到 Vth 的时间分别为 Tcs 和 Tcs+Tcx。

5 X9 [' p: M( I' T4 p其中，除了 Cs 和 Cx 我们需要计算，其他都是已知的，根据电容充放电公式：

Vc=V0(1-e^(-t/RC))*
9 \% {2 B2 \. {8 V
其中 Vc 为电容电压，V0 为充电电压，R 为充电电阻，C 为电容容值，e 为自然底数，t 为充电时间。根据这个公式，我们就可以计算出 Cs 和 Cx。利用这个公式，我们还可以把探索者开发板作为一个简单的电容计，直接可以测电容容量了。
7 }9 _$ s9 Y1 a7 {3 Z  a
我们只要能够区分 Tcs 和 Tcs+Tcx，就已经可以实现触摸检测了，当充电时间在 Tcs 附近，就可以认为没有触摸，而当充电时间大于 Tcs+Tx 时，就认为有触摸按下（Tx为检测阀值）。
- \0 l! `* h/ M2 v  P+ e: ?) U& U
( R7 [( [! \5 L4 r# ?# U我们使用 PA5(TIM2_CH1)来检测 TPAD 是否有触摸，在每次检测之前，我们先配置PA5 为推挽输出，将电容 Cs（或 Cs+Cx）放电，然后配置 PA5 为浮空输入，利用外部上拉电阻给电容 Cs(Cs+Cx)充电，同时开启 TIM2_CH1 的输入捕获，检测上升沿，当检测到上升沿的时候，就认为电容充电完成了，完成一次捕获检测。

) Z! N* D) V# @6 [: N在 MCU 每次复位重启的时候，我们执行一次捕获检测（可以认为没触摸），记录此时的值，记为 tpad_default_val，作为判断的依据。在后续的捕获检测，我们就通过与 tpad_default_val 的对比，来判断是不是有触摸发生。

02. 硬件设计
用到的硬件资源有：
1） 指示灯 DS0 和 DS1
2） 定时器 TIM2
' ]( H' i% q- U! J: o3） 触摸按键 TPAD
$ l/ T6 i9 M- _6 v
需要通过 TIM2_CH1（PA5）采集 TPAD 的信号，所以需要用跳线帽短接多功能端口（P12）的 TPAD 和 ADC，以实现 TPAD 连接到PA5。如图所示：
/ }- p! z3 y( V$ u
5 E- {- N( b' L# q1 c4 \4 r
2 _. q+ L  O1 p7 j
6 ?" N" s3 J& K$ h: p: i0 V) _03. 功能描述
5 Q, X$ c8 D: S' u- N实现一个简单的电容触摸按键，通过该按键控制 DS1 的亮灭。
" y8 ^1 T  q/ p
04. 程序示例
  @  f8 t  ?. x6 F& R( s3 qtpad.h
% H2 g7 u: v% x3 \4 |) S
( h& c  e) U& R1 A. X

1. #ifndef __TPAD_H
   
2. #define __TPAD_H
   9 r" r6 U. g3 Y1 H6 x
3. #include "sys.h"
   . D$ O- |- i9 u6 k7 L, m6 F
4.            
   
5. //空载的时候(没有手按下),计数器需要的时间
   # _5 h) Y# q+ J# W6 b
6. //这个值应该在每次开机的时候被初始化一次
   ; C5 J: O$ E- L' Q3 U3 p$ X
7. extern vu16 tpad_default_val;
   
8.                                                                        
   
9. void TPAD_Reset(void);
   5 C& m) i4 v! p' X- \/ T8 B% e
10. u16  TPAD_Get_Val(void);
    
11. u16 TPAD_Get_MaxVal(u8 n);
    
12. u8   TPAD_Init(u8 systick);
    ) W2 T0 ?$ x' |8 J; t" [/ r
13. u8   TPAD_Scan(u8 mode);
    
14. void TIM2_CH1_Cap_Init(u32 arr,u16 psc);     
    
15. #endif

复制代码

tpad.c
5 x' ^/ s+ L  T* P) O+ D! E

1. #define TPAD_ARR_MAX_VAL  0XFFFFFFFF        //最大的ARR值(TIM2是32位定时器)         
   
2. vu16 tpad_default_val=0;                                //空载的时候(没有手按下),计数器需要的时间
   4 E6 y8 i' Y% ~2 c# v. d
3. //初始化触摸按键
   + W. X9 F: F* ^; x7 i/ w! |1 k
4. //获得空载的时候触摸按键的取值.
   5 Y, }  f: K; k1 a0 k0 B! f% M
5. //psc:分频系数,越小,灵敏度越高.
     z2 ?8 I( I; V+ a. _7 _
6. //返回值:0,初始化成功;1,初始化失败
   ! a; h3 `3 y# H4 I! M+ t% n
7. u8 TPAD_Init(u8 psc)
   2 g" j! F/ N6 B2 g- F0 j6 J
8. {
   9 @7 [; D  y; R- K+ f; m
9.         u16 buf[10];
   
10.         u16 temp;
    % ~# ^3 f2 z' S; Z) E
11.         u8 j,i;
    % i- m8 C- a4 W5 ~
12.         TIM2_CH1_Cap_Init(TPAD_ARR_MAX_VAL,psc-1);//设置分频系数
    ! M! X% a5 l* \% Q! x  Y5 n
13.         for(i=0;i<10;i++)//连续读取10次
    
14.         {                                 
    ( v/ i& b1 D  ?* h% D
15.                 buf<i>=TPAD_Get_Val();
    ; c+ ~% W9 G  N
16.                 delay_ms(10);            
    
17.         }                                    
    
18.         for(i=0;i<9;i++)//排序
    
19.         {
    8 P4 ^! p  d5 C$ i2 l
20.                 for(j=i+1;j<10;j++)
    
21.                 {
    
22.                         if(buf<i>>buf[j])//升序排列
    
23.                         {
    / a+ `& b. D. f6 h; {6 K
24.                                 temp=buf<i>;
    
25.                                 buf<i>=buf[j];
    
26.                                 buf[j]=temp;
    ) r9 h$ t$ `% O9 y9 t6 X; o! R
27.                         }
    ) @4 W$ f) G, e& R* _, i. _1 }
28.                 }
    / y) `7 q- v! M, Y; n
29.         }
    
30.         temp=0;
    . |- c; M# r, @9 G
31.         for(i=2;i<8;i++)temp+=buf<i>;//取中间的8个数据进行平均
    " l! y; r0 M3 z3 m
32.         tpad_default_val=temp/6;
    
33.         printf("tpad_default_val:%d\r\n",tpad_default_val);        
    9 u3 X# Q3 ~# V4 p! d- F/ q
34.         if(tpad_default_val>TPAD_ARR_MAX_VAL/2)return 1;//初始化遇到超过TPAD_ARR_MAX_VAL/2的数值,不正常!
    
35.         return 0;                                                                           
    
36. }
    
37. //复位一次
    6 d" l* p4 Q3 _/ s# |, e
38. //释放电容电量，并清除定时器的计数值
    ( ?1 Q9 A+ m6 Q# ?( a
39. void TPAD_Reset(void)
    1 O2 H4 ^8 o( q1 B& A! U2 `
40. {               
    
41.         GPIO_InitTypeDef GPIO_InitStructure;
    ! J1 |4 u: G9 @  q8 w# f
42.         
    
43.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;  //PA5
    1 ~5 k& i, p! j$ l9 u2 t
44.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出
    % i0 K1 `" X# Z0 D7 U$ k
45.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;        //速度100MHz
    
46.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽
    3 z6 A9 C4 w1 ]# g* E7 {/ {9 S6 ]
47.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; //下拉
    5 ^: a( d- h9 `. t. o' b
48.         GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA5
    - ^4 P" `/ y2 N: [/ l
49.          
    $ F3 Z& ?4 r( z- \# H. ]' N
50.         GPIO_ResetBits(GPIOA,GPIO_Pin_5);//输出0,放电
    
51. 
    : B- F- O! r/ S( e
52.         delay_ms(5);
    % {  m2 b9 ^" }" t" e6 q% [0 ~$ @
53.         TIM_ClearITPendingBit(TIM2, TIM_IT_CC1|TIM_IT_Update); //清除中断标志
    
54.         TIM_SetCounter(TIM2,0);                //归0
    0 G; F! Q2 i* e
55.         
    $ e6 F% q+ u/ \4 k) v: V- E
56. 
    2 l# @1 Z, @' d5 Z
57.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5; //PA5
    
58.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用输出
    . `! u* B+ }9 h6 ~% z
59.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//速度100MHz
    
60.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽
    
61.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//不带上下拉
    
62.         GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA5
    , x3 u' O7 P6 F, p$ d7 K; A
63.         
    
64. }
    
65. //得到定时器捕获值
    % N; _0 y$ y( G5 f5 d; r
66. //如果超时,则直接返回定时器的计数值.
    ( c# e) p; B% c& `. ]
67. //返回值：捕获值/计数值（超时的情况下返回）
    ! D3 {" W+ V3 ?& |6 g/ y
68. u16 TPAD_Get_Val(void)
    9 d2 }* a; q0 o( i# T
69. {                                   
    
70.         TPAD_Reset();
    4 ^) S5 _5 [: {" ]! _! C  U
71.         while(TIM_GetFlagStatus(TIM2, TIM_IT_CC1) == RESET)//等待捕获上升沿
    + \8 Y* l0 j, @  ~+ p
72.         {
    
73.                 if(TIM_GetCounter(TIM2)>TPAD_ARR_MAX_VAL-500)return TIM_GetCounter(TIM2);//超时了,直接返回CNT的值
    1 ]6 u& M  d" x! G% l
74.         };        
    
75.         return TIM_GetCapture1(TIM2);         
    
76. }           
    0 R# S# w) \5 G% N" Z
77. //读取n次,取最大值
    3 b7 _0 N( ?2 J  Z7 S
78. //n：连续获取的次数
    
79. //返回值：n次读数里面读到的最大读数值
    ! i- x$ k) E1 P7 H0 \3 x
80. u16 TPAD_Get_MaxVal(u8 n)
    
81. {
    
82.         u16 temp=0;
    . H* {' b: I3 k" C- x& @: Z
83.         u16 res=0;
    
84.         while(n--)
    
85.         {
    
86.                 temp=TPAD_Get_Val();//得到一次值
    
87.                 if(temp>res)res=temp;
    
88.         };
    8 H# G7 z3 d7 J7 @% F( }% d
89.         return res;
    
90. }  
    , ^( D& N& d- l& X' _% \, }) Z
91. //扫描触摸按键
    
92. //mode:0,不支持连续触发(按下一次必须松开才能按下一次);1,支持连续触发(可以一直按下)
    # }- h! v1 }- r# c( g
93. //返回值:0,没有按下;1,有按下;                                                                                 
    
94. #define TPAD_GATE_VAL         100        //触摸的门限值,也就是必须大于tpad_default_val+TPAD_GATE_VAL,才认为是有效触摸.
    
95. u8 TPAD_Scan(u8 mode)
    0 j. d8 Y  b$ U  a- c
96. {
    - w+ g3 i# X8 r1 M* |& p/ J/ ^
97.         static u8 keyen=0;        //0,可以开始检测;>0,还不能开始检测         
    $ E- w  L& F$ o) f6 Q* a) k
98.         u8 res=0;
    # x0 p! Z( \: E1 [" _
99.         u8 sample=3;                //默认采样次数为3次         
    4 @: ^7 ]# g2 s% X9 Z0 b5 Q$ a
100.         u16 rval;
     
101.         if(mode)
     5 w- d2 z1 w4 B9 y" m) j6 G* u9 a
102.         {
     " j: p2 B$ N/ F& C' V2 E
103.                 sample=6;        //支持连按的时候，设置采样次数为6次
     
104.                 keyen=0;        //支持连按         
     
105.         }
     
106.         rval=TPAD_Get_MaxVal(sample);
     
107.         if(rval>(tpad_default_val+TPAD_GATE_VAL)&&rval<(10*tpad_default_val))//大于tpad_default_val+TPAD_GATE_VAL,且小于10倍tpad_default_val,则有效
     
108.         {                                                         
     + X! j$ L' [, d* z
109.                 if((keyen==0)&&(rval>(tpad_default_val+TPAD_GATE_VAL)))        //大于tpad_default_val+TPAD_GATE_VAL,有效
     
110.                 {
     
111.                         res=1;
     7 d" c+ Y- u1 H! {5 v% z7 Z0 E! K
112.                 }           
     
113.                 //printf("r:%d\r\n",rval);                                                                           
     
114.                 keyen=3;                                //至少要再过3次之后才能按键有效   
     
115.         }
     2 U% k2 |( @* W* @
116.         if(keyen)keyen--;                                                                                                                                                         
     
117.         return res;
     , D, L$ @" s: t! i# d$ @
118. }         
     
119. //定时器2通道2输入捕获配置         
     4 J1 p* ^  a% Q7 Y, K% v
120. //arr：自动重装值
     
121. //psc：时钟预分频数
     1 n" s* x) G' H/ L5 q7 P* L
122. void TIM2_CH1_Cap_Init(u32 arr,u16 psc)
     
123. {
     
124.         GPIO_InitTypeDef  GPIO_InitStructure;
     
125.   TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
     
126.         TIM_ICInitTypeDef  TIM2_ICInitStructure;
     & P6 c5 p% b) s
127.         
     
128.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);            //TIM2时钟使能   
     
129.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);         //使能PORTA时钟        
     
130. 
     
131.         
     
132.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource5,GPIO_AF_TIM2); //GPIOA5复用位定时器2
     
133. 
     & L& l* m( v7 @
134.          
     ) s$ ~2 P4 Y' J8 a9 ?/ ]. u7 U1 a
135.          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5; //GPIOA5
     " [( T- `: L* m( V$ h& i
136.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
       I6 O+ L& L9 r
137.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;        //速度100MHz
     % S4 q, q4 k. _+ B0 V; [
138.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
     
139.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//不带上下拉
     , V, ^4 L0 i+ d$ |  M/ z+ ~3 d
140.         GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA5
     
141. 
     ( y$ D0 K2 f0 E/ B
142.         
     
143.   //初始化TIM2  
     8 |9 n% q: [3 n0 w3 W- g4 t7 ?- @) @
144.         TIM_TimeBaseStructure.TIM_Period = arr; //设定计数器自动重装值   
     ' U2 B+ L+ C1 A- ^: u
145.         TIM_TimeBaseStructure.TIM_Prescaler =psc;         //预分频器            
     0 k( ]5 p) Y! ?% i+ U$ q
146.         TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
     - m- W! i0 l. }) L5 B
147.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
     " Z( p/ c2 M1 A. `7 M8 l
148.         TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位
     
149.         
     
150.         //初始化通道1
     , e. U9 w# ~' k: y4 i& B
151.   TIM2_ICInitStructure.TIM_Channel = TIM_Channel_1; //CC1S=01         选择输入端 IC1映射到TIM2上
     
152.   TIM2_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
     
153.   TIM2_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
     
154.   TIM2_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
     
155.   TIM2_ICInitStructure.TIM_ICFilter = 0x00;//IC2F=0000 配置输入滤波器 不滤波
     : l" d& E/ q0 J0 v, v
156.   TIM_ICInit(TIM2, &TIM2_ICInitStructure);//初始化TIM2 IC1
     
157.                                                                                                                         
     
158.         TIM_Cmd(TIM2,ENABLE );         //使能定时器2
     
159. }</i></i></i></i></i>

复制代码

6 K0 {$ ]7 [! {5 i2 T' \! Hmain.c
7 }" o8 ?. L' g- {* i6 A

1. #include "sys.h"
   
2. #include "delay.h"
   0 C6 g- _# U9 K) m+ p& s. p9 g/ d
3. #include "usart.h"
   $ V& b- e9 X& h, z! C
4. #include "led.h"
   
5. #include "tpad.h"
   9 i  T' H$ h0 W
6. 
   
7. 
   
8. int main(void)
   0 c% |) }% J1 G8 c) A* s. T% B
9. {
     ?! K' s' h, u2 X5 E+ ]
10.         u8 t=0;
    7 n2 j$ ^' z3 h9 L
11.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    : e* J6 @6 `0 s9 j- u& g
12.         delay_init(168);     //初始化延时函数
    $ i# d2 g- E/ g$ A" |, o+ C
13.         uart_init(115200);         //初始化串口波特率为115200
    
14.         LED_Init();                                         //初始化LED
    3 P. k5 G4 ~' P0 w- w
15.         
    & N+ \* v' R' O2 q5 X" {
16.         TPAD_Init(8);                                //初始化触摸按键,以84/4=21Mhz频率计数
    * Q5 x2 Z: r* J/ t
17.            while(1)
    
18.         {                                                                                                            
    ( ]- x, v3 ~  e4 I& F  \3 I
19.                  if(TPAD_Scan(0))        //成功捕获到了一次上升沿(此函数执行时间至少15ms)
    
20.                 {
    
21.                         LED1=!LED1;                //LED1取反
    9 ?% o" j4 `/ r! z1 w5 A
22.                 }
    - P) Y# v2 |9 ]  n8 P2 g* |& W6 [
23.                 t++;
    + F/ K7 q: H( B: N6 u
24.                 if(t==15)                 
    
25.                 {
    
26.                         t=0;
    % G1 K8 R+ o% a! G' X
27.                         LED0=!LED0;                //LED0取反,提示程序正在运行
    # W9 A% w3 N8 D; \% m# h
28.                 }
    ! m' }+ W4 g" E5 G& p( \
29.                 delay_ms(10);
    
30.         }
    
31. }
    * L, r9 F7 ~. D# K3 b
32. 
    

复制代码