01. 电容触摸按键简介
触摸按键相对于传统的机械按键有寿命长、占用空间少、易于操作等诸多优点。大家看看如今的手机，触摸屏、触摸按键大行其道，而传统的机械按键，正在逐步从手机上面消失。接下来给大家介绍一种简单的触摸按键：电容式触摸按键。

利用探索者 STM32F4 开发板上的触摸按键（TPAD）来实现对 DS1 的亮灭控制。这里 TPAD 其实就是探索者 STM32F4 开发板上的一小块覆铜区域，实现原理如图所示：

" b  K! E2 S/ Y0 ?
1 t$ d. B: A: n0 s1 @; N5 X3 z
我们使用的是检测电容充放电时间的方法来判断是否有触摸，图中 R 是外接的电容充电电阻，Cs 是没有触摸按下时 TPAD 与 PCB 之间的杂散电容。而 Cx 则是有手指按下的时候，手指与 TPAD 之间形成的电容。图中的开关是电容放电开关（由实际使用时，由 STM32F4 的IO 代替）。

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

其中，除了 Cs 和 Cx 我们需要计算，其他都是已知的，根据电容充放电公式：
2 A+ B* J/ g, J" X. Y8 `
Vc=V0(1-e^(-t/RC))*
+ D" c6 z. B$ ~" [# e
7 v- B. n* t, b- l其中 Vc 为电容电压，V0 为充电电压，R 为充电电阻，C 为电容容值，e 为自然底数，t 为充电时间。根据这个公式，我们就可以计算出 Cs 和 Cx。利用这个公式，我们还可以把探索者开发板作为一个简单的电容计，直接可以测电容容量了。

  D- m; Z' @  F我们只要能够区分 Tcs 和 Tcs+Tcx，就已经可以实现触摸检测了，当充电时间在 Tcs 附近，就可以认为没有触摸，而当充电时间大于 Tcs+Tx 时，就认为有触摸按下（Tx为检测阀值）。

( V# A. x1 Q7 _: ^我们使用 PA5(TIM2_CH1)来检测 TPAD 是否有触摸，在每次检测之前，我们先配置PA5 为推挽输出，将电容 Cs（或 Cs+Cx）放电，然后配置 PA5 为浮空输入，利用外部上拉电阻给电容 Cs(Cs+Cx)充电，同时开启 TIM2_CH1 的输入捕获，检测上升沿，当检测到上升沿的时候，就认为电容充电完成了，完成一次捕获检测。

( ]/ ~7 [$ H4 n& \在 MCU 每次复位重启的时候，我们执行一次捕获检测（可以认为没触摸），记录此时的值，记为 tpad_default_val，作为判断的依据。在后续的捕获检测，我们就通过与 tpad_default_val 的对比，来判断是不是有触摸发生。

02. 硬件设计
用到的硬件资源有：
3 B3 S6 f; r8 N! e6 w( f' t1） 指示灯 DS0 和 DS1
" f9 C% @8 S' ]% d2） 定时器 TIM2
3） 触摸按键 TPAD

& t9 ]# D- F4 d需要通过 TIM2_CH1（PA5）采集 TPAD 的信号，所以需要用跳线帽短接多功能端口（P12）的 TPAD 和 ADC，以实现 TPAD 连接到PA5。如图所示：
* G" B: y& \/ q' O
# H- P% a- P  ]- [$ M

03. 功能描述
3 m* w' ?- L/ w: M! m( c实现一个简单的电容触摸按键，通过该按键控制 DS1 的亮灭。

04. 程序示例
: t, P2 i9 y* F1 }  W5 ftpad.h

1. #ifndef __TPAD_H
   : `# ^1 Y$ P8 R% Z- n# \+ _
2. #define __TPAD_H
   
3. #include "sys.h"
   ) u, s: J9 Q  L8 Q
4.            
   
5. //空载的时候(没有手按下),计数器需要的时间
   % h2 p, [6 i; n( F8 c# R( A! q
6. //这个值应该在每次开机的时候被初始化一次
   
7. extern vu16 tpad_default_val;
   ( n/ Y+ }' P3 j1 A. ]
8.                                                                        
   
9. void TPAD_Reset(void);
   
10. u16  TPAD_Get_Val(void);
    
11. u16 TPAD_Get_MaxVal(u8 n);
    
12. u8   TPAD_Init(u8 systick);
    
13. u8   TPAD_Scan(u8 mode);
    
14. void TIM2_CH1_Cap_Init(u32 arr,u16 psc);     
    
15. #endif

复制代码

tpad.c
+ e3 i3 g+ p- p+ P

1. #define TPAD_ARR_MAX_VAL  0XFFFFFFFF        //最大的ARR值(TIM2是32位定时器)         
   
2. vu16 tpad_default_val=0;                                //空载的时候(没有手按下),计数器需要的时间
   ) b# G# i6 L, a3 i
3. //初始化触摸按键
   * w2 Q: p. X+ w, ^
4. //获得空载的时候触摸按键的取值.
   
5. //psc:分频系数,越小,灵敏度越高.
   9 t. q$ u2 M. y2 [! Y4 C
6. //返回值:0,初始化成功;1,初始化失败
   
7. u8 TPAD_Init(u8 psc)
   
8. {
   & S+ @9 Y9 A: T2 N
9.         u16 buf[10];
   , r: y( W) s5 A* w$ q1 x
10.         u16 temp;
    
11.         u8 j,i;
    
12.         TIM2_CH1_Cap_Init(TPAD_ARR_MAX_VAL,psc-1);//设置分频系数
    ( D. ]: y  M  w" N# ?
13.         for(i=0;i<10;i++)//连续读取10次
    ; ?. y2 z& n0 H( o# ~- ?
14.         {                                 
    
15.                 buf=TPAD_Get_Val();
      ]  p# q' j0 B8 A, L! X+ p% |
16.                 delay_ms(10);            
    
17.         }                                    
    8 W7 ?, W' {2 ]6 x; ]
18.         for(i=0;i<9;i++)//排序
    # n- R! Z+ x. A( H! q' q
19.         {
    
20.                 for(j=i+1;j<10;j++)
    * e+ \/ l- U- W( T2 v
21.                 {
    : w7 A5 F7 `% N
22. if(buf>buf[j])//升序排列
    ) Z5 z) T# f0 N( `* Q# j+ f
23.                         {
    
24.                                 temp=buf;
    3 p' a% b5 U' i8 J0 z+ Y
25.                                 buf=buf[j];
    
26.                                 buf[j]=temp;
    ! L: |1 F% l5 T
27.                         }
    
28.                 }
    4 E& I) J- e% j4 i
29.         }
    
30.         temp=0;
    
31.         for(i=2;i<8;i++)temp+=buf;//取中间的8个数据进行平均
    
32.         tpad_default_val=temp/6;
    / C; {0 e- }# n: X5 O
33.         printf("tpad_default_val:%d\r\n",tpad_default_val);        
    : O) U* _" I: X- c7 n
34.         if(tpad_default_val>TPAD_ARR_MAX_VAL/2)return 1;//初始化遇到超过TPAD_ARR_MAX_VAL/2的数值,不正常!
    8 r: V5 C% G- w; `: J8 g
35.         return 0;                                                                           
    
36. }
    $ R1 Y1 F0 O% M6 |
37. //复位一次
    
38. //释放电容电量，并清除定时器的计数值
    
39. void TPAD_Reset(void)
    ' A& |2 x5 `% w6 p! D! f6 X
40. {               
    
41.         GPIO_InitTypeDef GPIO_InitStructure;
    ; |( N) s, |! R/ M" n2 H
42.         
    
43.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;  //PA5
    
44.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出
    
45.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;        //速度100MHz
    
46.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽
    
47.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; //下拉
    . n+ `* X5 s" w- N* a, |4 f
48.         GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA5
    
49.          
    ) w& C1 r! G3 g' a7 Y( V
50.         GPIO_ResetBits(GPIOA,GPIO_Pin_5);//输出0,放电
    
51. 
    & l  w7 o- R* c3 _4 @$ ]# d  U0 q
52.         delay_ms(5);
    
53.         TIM_ClearITPendingBit(TIM2, TIM_IT_CC1|TIM_IT_Update); //清除中断标志
    
54.         TIM_SetCounter(TIM2,0);                //归0
    
55.         
    & ]$ q5 m3 ]4 c
56. 
    
57.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5; //PA5
    2 O8 a! j# O/ W7 \* H$ \
58.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用输出
    
59.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//速度100MHz
    & z; B. E) k& G( Q6 V5 j9 }0 m
60.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽
    / a) K' Q, z! I* ^
61.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//不带上下拉
    3 M8 R) g' _4 a+ Z2 F- E- S; n/ ]6 M
62.         GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA5
    
63.         
    # X7 v8 i8 W$ Z& F6 `
64. }
    
65. //得到定时器捕获值
      I; Q7 E" x4 B4 [) L- y3 Y8 o- z
66. //如果超时,则直接返回定时器的计数值.
    * c6 c% c) y! a
67. //返回值：捕获值/计数值（超时的情况下返回）
    & i! E% u% ^# o$ x9 ]. J; r, N: m
68. u16 TPAD_Get_Val(void)
    
69. {                                   
    " X; q8 W: s8 Y3 C0 \
70.         TPAD_Reset();
    * Y- i, n& p" o' T& H2 x& L
71.         while(TIM_GetFlagStatus(TIM2, TIM_IT_CC1) == RESET)//等待捕获上升沿
    
72.         {
    : b& [7 k  r# R% }. X3 v! D
73.                 if(TIM_GetCounter(TIM2)>TPAD_ARR_MAX_VAL-500)return TIM_GetCounter(TIM2);//超时了,直接返回CNT的值
    ! C" M% R$ e( y  g, _
74.         };        
    
75.         return TIM_GetCapture1(TIM2);         
    * g% H  T, E- q9 F! U- n# \  V
76. }           
    
77. //读取n次,取最大值
    
78. //n：连续获取的次数
    
79. //返回值：n次读数里面读到的最大读数值
    
80. u16 TPAD_Get_MaxVal(u8 n)
    & e) e, O1 i+ `5 m. o- g. w. ?5 ?
81. {
      P% `' h. t) v/ C3 |- l
82.         u16 temp=0;
    
83.         u16 res=0;
    
84.         while(n--)
    " b1 a% z6 M3 W9 R
85.         {
    
86.                 temp=TPAD_Get_Val();//得到一次值
    , O! Q& ?- H. b- X, r
87.                 if(temp>res)res=temp;
    3 u! f  g; Z; r  ^. D* W0 Q* k
88.         };
    ) j# m* ?* }& j
89.         return res;
    
90. }  
    ) o" o3 q. t$ S0 U- s
91. //扫描触摸按键
    7 i2 l. e0 L3 A- I  B
92. //mode:0,不支持连续触发(按下一次必须松开才能按下一次);1,支持连续触发(可以一直按下)
    8 K# O' E5 Q' a- x2 g2 n5 _4 M" v5 D5 n3 w
93. //返回值:0,没有按下;1,有按下;                                                                                 
    
94. #define TPAD_GATE_VAL         100        //触摸的门限值,也就是必须大于tpad_default_val+TPAD_GATE_VAL,才认为是有效触摸.
    7 W" Y# i- L1 F/ c9 o
95. u8 TPAD_Scan(u8 mode)
      P( L! m4 x0 J
96. {
    ) Z! ^$ p4 \$ A  }0 ^) `- C" O
97.         static u8 keyen=0;        //0,可以开始检测;>0,还不能开始检测         
    
98.         u8 res=0;
    
99.         u8 sample=3;                //默认采样次数为3次         
    8 u3 P/ b1 t* p  ~2 A
100.         u16 rval;
     : s7 p; j" S5 k" P
101.         if(mode)
     
102.         {
     5 ~1 H) g/ I0 `. Y
103.                 sample=6;        //支持连按的时候，设置采样次数为6次
     * g1 m6 y+ ?/ g( }" g+ S7 T* P5 @
104.                 keyen=0;        //支持连按         
     
105.         }
     
106.         rval=TPAD_Get_MaxVal(sample);
     ) f+ F  H, z* D. [% g3 V
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.         {                                                         
     . S8 w' j' y  Q9 W& M5 M% h
109.                 if((keyen==0)&&(rval>(tpad_default_val+TPAD_GATE_VAL)))        //大于tpad_default_val+TPAD_GATE_VAL,有效
     * [" A/ [' G7 d( a
110.                 {
     ' H7 d4 @, L, r' W/ k
111.                         res=1;
     
112.                 }           
     
113.                 //printf("r:%d\r\n",rval);                                                                           
     6 f) Z  ?7 G8 ^7 R1 N
114.                 keyen=3;                                //至少要再过3次之后才能按键有效   
     
115.         }
     
116.         if(keyen)keyen--;                                                                                                                                                         
     
117.         return res;
     
118. }         
     + F) t( j! }1 s3 Z
119. //定时器2通道2输入捕获配置         
       w: X$ {6 w+ p; C
120. //arr：自动重装值
     
121. //psc：时钟预分频数
     9 A" P5 F: f! t4 k; E% }
122. void TIM2_CH1_Cap_Init(u32 arr,u16 psc)
     0 C$ W  h, D& n! j7 b
123. {
     % j& x' c" R  S2 Y0 m4 V
124.         GPIO_InitTypeDef  GPIO_InitStructure;
     * M0 o) A! b6 r
125.   TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
     ! P) B3 M1 s3 a6 N2 K$ Y* _
126.         TIM_ICInitTypeDef  TIM2_ICInitStructure;
     : }9 P. ?" c- z5 |' f5 ~: |
127.         
     - ?8 w0 _$ ~" G* @+ G0 v3 y" e
128.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);            //TIM2时钟使能   
     
129.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);         //使能PORTA时钟        
     
130. 
     & `; x0 b2 K: d9 \
131.         
     
132.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource5,GPIO_AF_TIM2); //GPIOA5复用位定时器2
     7 A: U; S( \) C% N
133. 
     $ p. r# h3 t/ a9 t5 F( L
134.          
     * \- v+ _( v" M. E4 Z& l
135.          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5; //GPIOA5
       z9 a: |) ?8 ~1 E
136.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
     
137.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;        //速度100MHz
     ) s! W# ]8 q! j) T2 }( B
138.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
     5 l7 P  P# O5 ?# ?" u, @
139.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;//不带上下拉
     9 Y6 v6 X0 R, {! v
140.         GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA5
     8 R& k# ]$ H) Q4 m1 Y% @! a6 v7 P
141. 
     + s( k6 X" a' n  y  ~* e! U9 b5 d. g
142.         
     & `- U' V) X! E" Q" K
143.   //初始化TIM2  
     
144.         TIM_TimeBaseStructure.TIM_Period = arr; //设定计数器自动重装值   
     - ^8 J9 ?) L  S3 Y! L" Q7 n
145.         TIM_TimeBaseStructure.TIM_Prescaler =psc;         //预分频器            
     ( q  I( S; _7 J4 y# @
146.         TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
     
147.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
     
148.         TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位
     - p  T  b* U3 D
149.         
     
150.         //初始化通道1
     
151.   TIM2_ICInitStructure.TIM_Channel = TIM_Channel_1; //CC1S=01         选择输入端 IC1映射到TIM2上
     2 p2 l  p9 W! g' W8 C* f) j
152.   TIM2_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;        //上升沿捕获
     & S$ |9 V7 B/ c) B7 t) g
153.   TIM2_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
     ; T! n! E/ U3 ^  O
154.   TIM2_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;         //配置输入分频,不分频
     & }- Y1 J. _( M  s5 H8 {# e( Y
155.   TIM2_ICInitStructure.TIM_ICFilter = 0x00;//IC2F=0000 配置输入滤波器 不滤波
     % V7 r% i: q, @& |% u2 X3 P6 e) E
156.   TIM_ICInit(TIM2, &TIM2_ICInitStructure);//初始化TIM2 IC1
     7 t, D6 w# S) ]& Z4 x
157.                                                                                                                         
     
158.         TIM_Cmd(TIM2,ENABLE );         //使能定时器2
     
159. }

复制代码

+ x% u' I: T! y3 imain.c
) k8 K( L5 m, L8 m0 S$ ~1 D

1. #include "sys.h"
   , c4 |7 j" i3 k1 I. w0 F3 @8 I
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   
5. #include "tpad.h"
   
6. 
   . ^% g/ a7 e; {* U4 A9 L
7. 
   
8. int main(void)
   ! Y* m$ D6 W$ C/ D( k6 n) I
9. {
   / ^! ?7 Z3 ~8 f  f8 z& a2 N3 G
10.         u8 t=0;
    - m# }: @7 R# {, c* C
11.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    
12.         delay_init(168);     //初始化延时函数
    
13.         uart_init(115200);         //初始化串口波特率为115200
    6 @, i) r  B9 B% V/ O* S- c
14.         LED_Init();                                         //初始化LED
    
15.         
    
16.         TPAD_Init(8);                                //初始化触摸按键,以84/4=21Mhz频率计数
    
17.            while(1)
    
18.         {                                                                                                            
    0 {, |; O9 m2 i, J1 Z3 L
19.                  if(TPAD_Scan(0))        //成功捕获到了一次上升沿(此函数执行时间至少15ms)
    0 N* _" h; S* `1 y* x" X" U
20.                 {
    1 t: R# N; \' ~4 n7 w/ L% D9 f6 \
21.                         LED1=!LED1;                //LED1取反
    1 V1 k' x$ w0 {# q: ]
22.                 }
    
23.                 t++;
    
24.                 if(t==15)                 
    ( P: T+ g( \) z3 _
25.                 {
    
26.                         t=0;
    
27.                         LED0=!LED0;                //LED0取反,提示程序正在运行
    - u- s3 a) K0 d) v' l  k7 T: l
28.                 }
    
29.                 delay_ms(10);
    
30.         }
    
31. }
    & N3 O+ T( K5 h1 c. r1 L
32. 
    $ O. b! X8 M6 y0 ~% c
33. 
    

复制代码

可以哦！