主要内容
1） 电容触摸按键原理；
2）部分实验代码解读。
7 K6 i3 ^; M; l& Y% L0 G实验内容
6 t! h5 }1 X: R1 I9 }手触摸按键后，LED1灯翻转。

硬件原理图
) @8 q* P1 u' P$ d

上图，TPAD与STM_ADC用跳线帽相连，即TPAD与PA1引脚相连，而PA1引脚也可复用为TIM5_CH2（定时器5的通道2），因此可以用TIM5_CH2进行输入捕获来识别电容触摸。

1. 电容触摸按键原理
1.1 RC充放电电路原理
- d4 m- D) G$ [9 ^- e1 c


1.2 RC电路充放电公式
" v6 w, M. N5 W
Vt = V0+（V1-V0）* [1-e(-t/RC)]

上式中：V0 为电容上的初始电压值； V1 为电容最终可充到或放到的电压值； Vt 为t时刻电容上的电压值。 如果V0为0，也就是从0V开始充电。那么公式简化为：
Vt= V1* [1-e(-t/RC)]

3 ^# W) U9 b" l4 Y! L6 f结论：同样的条件下，电容值C跟时间值t成正比关系，电容越大，充电到达某个临界值的时间越长。
+ u) w) u0 @- M( v# D/ V* S1.3 电容充电时间与电容大小关系
* `; h: H2 k7 \7 M9 K

7 `' ~# e* L: \2 d  W
2. 电容触摸按键
2.1 电容触摸按键原理

! o6 t. M! A% D1 y3 Z: r( ~/ F& {; k

R:外接电容充放电电阻；
Cs:TPAD和PCB间的杂散电容；
' F) T, [' Q' {; I0 H. OCx:手指按下时，手指和TPAD之间的电容；
4 Q" C( Y* Z1 [1 Q  s$ |8 Z开关：电容放电开关，由STM32 IO口代替。
2.2 检测电容触摸按键过程
2.2.1 TPAD引脚设置为推挽输出，输出0，实现电容放电到0；
2.2.2 TPAD引脚设置为浮空输入（IO复位后的状态）,电容开始充电；
2.2.3 同时开启TPAD引脚的输入捕获开始捕获；
& D& x' `: j6 @6 M/ R2.2.4 等待充电完成（充电到底Vx,检测到上升沿）；
2.2.5 计算充电时间。
$ S& ^5 Z# \/ a* i( ~没有按下的时候，充电时间为T1（default)。按下TPAD，电容变大，所以充电时间为T2。我们可以通过检测充放电时间，来判断是否按下。如果T2-T1大于某个值，就可以判断有按键按下。
3 y* O( m) z' Y, h. [8 ]/ e
3. 相关库函数
0 V4 d: W0 ?8 h. m. {3.1 void TPAD_Reset(void)函数，
作用：复位TPAD
4 c6 r$ v1 a& y: r4 [设置IO口为推挽输出输出0，电容放电。等待放电完成之后，设置为浮空输入，从而开始充电。同时把计数器的CNT设置为0。
3.2 TPAD_Get_Val()函数，
. V: O6 w  x0 [作用：获取一次捕获值（得到充电时间）
. D: h3 ], }0 Y, P! W复位TPAD,等待捕获上升沿，捕获之后，得到定时器的值，计算充电时间。
3.3 TPAD_Get_MaxVal()函数，
多次调用TPAD_Get_Val函数获取充电时间，获取最大的值。
/ c6 a) ?0 X2 ~' E3 T! d+ _3.4 TPAD_Init()函数，
1 T3 y  T0 p& g- L% K5 M6 o作用：初始化TPAD
在系统启动后，初始化输入捕获。先10次调用TPAD_Get_Val()函数获取10次充电时间，然后获取中间N(N=8或者6）次的平均值，作为在没有电容触摸按键按下的时候的充电时间缺省值tpad_default_val。
9 X4 \( S9 T2 l& z% P' y5 c) n" g3.5 TPAD_Scan()函数，
' w' a" p5 u4 L! ]& S$ ?作用：扫描TPAD
调用TPAD_Get_MaxVal函数获取多次充电中最大的充电时间，跟tpad_default_val比较，如果大于某个阈值tpad_default_val+TPAD_GATE_VAL，则认为有触摸动作。
3.6 void TIM5_CH2_Cap_Init(u16 arr,u16 psc)函数，
作用：输入捕获通道初始化
可以使用任何一个定时器。M3使用定时器5，M4使用的定时器2。

4. 程序思路

5 R: m) W- E& ~! `! j

5. 实验部分代码解读
5.1 tpad.h头文件

1. #ifndef __TPAD_H
   
2. #define __TPAD_H
   0 w6 \# j- l0 {+ N* Q5 g8 L
3. #include "sys.h"  
   
4. //引用在别的文件中申明的变量tpad_default_cal//
   + f. F6 G7 m' W; A$ O# h/ q  E
5. extern vu16 tpad_default_val;
   
6. //*****函数一*****//
   
7. //申明void TPAD_Reset(void)函数，无返回值，无入口参数//               
   
8. void TPAD_Reset(void);
   
9. //*****函数二*****//
     ~' g6 y; u( p# X
10. //申明u16 TPAD_Get_Val(void)函数，返回u16数据格式的值，无入口参数//
    
11. u16  TPAD_Get_Val(void);
    ) V/ ]8 G! c/ r8 W: f  O
12. //*****函数三*****//
    
13. //申明u16 TPAD_Get_MaxVal(u8 n))函数，返回u16数据格式的值，入口参数为8位的变量n//
    % e: h" s/ W9 u0 r/ Z$ g
14. u16 TPAD_Get_MaxVal(u8 n);
    
15. //*****函数四->初始化触摸按键*****//
    1 b' F/ j, @$ [5 Q. \* m# l3 C* C
16. //申明u8 TPAD_Init(u8 psc)函数，返回u8数据格式的值，入口参数为8位的变量psc//
    
17. u8   TPAD_Init(u8 psc);
    
18. //*****函数五*****//
    
19. //申明u8 TPAD_Scan(u8 mode)函数，返回u8数据格式的值，入口参数为8位的变量mode//
    
20. u8   TPAD_Scan(u8 mode);
    ) L- p, J1 x; ]
21. //*****函数六*****//
    * o9 C/ Y( f3 X  X" u  R: Q) E6 r
22. //申明void TIM5_CH2_Cap_Init(u16 arr,u16 psc)函数，无返回值，入口参数为16位的两个变量arr和psc//
    " T3 _9 L; Q( _) ?% O
23. void TIM5_CH2_Cap_Init(u16 arr,u16 psc);   
    + g  {) B  e& g# x7 h
24. #endif
    

复制代码

5.2 tpad.c文件

1. #include "tpad.h"
   : a' @9 Q* O& I( d$ O$ u
2. #include "delay.h"      
   " A0 J8 t0 {. r1 h! I
3. #include "usart.h"
   . i+ w) a' `  m" k
4. //定义TPAD_ARR_MAX_VAL为一常量，即0xFFFF//
   
5. #define TPAD_ARR_MAX_VAL  0XFFFF
   5 U9 I+ L5 z. g$ W' c- b
6. //定义变量tpad_default_val=0，即空载时候(手没按下),计数器需要的时间//
   
7. vu16 tpad_default_val=0;
   
8. //*****函数一—>TPAD复位-void TPAD_Reset(void)*****//
     k5 ]1 l4 f" u) g/ z/ X
9. void TPAD_Reset(void)
   5 f6 ?7 G9 G2 b8 U1 N9 S
10. {
    ' [  ]6 {$ u4 C- H$ D/ [
11.   GPIO_InitTypeDef  GPIO_InitStructure;                  //定义GPIO初始化结构体//
    - g, P) c; p" ]
12.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);  //使能PA端口时钟//
    
13.   //设置GPIOA.1为推挽输出//
    
14.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;              //PA1 端口配置
    
15.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;       //推挽输出
    
16.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;      //50MHz//
    
17.   GPIO_Init(GPIOA, &GPIO_InitStructure);           
    ( ?6 h9 [2 z6 z: D
18.   GPIO_ResetBits(GPIOA,GPIO_Pin_1);                      //PA.1输出0,放电//
    + c2 j5 z9 \4 z- j8 y0 L/ n
19.   //等待5ms//
    
20.   delay_ms(5);
    
21.   TIM_SetCounter(TIM5,0);                                //将TIM5_CNT计数器寄存器的值设0//
    
22.   TIM_ClearITPendingBit(TIM5, TIM_IT_CC2|TIM_IT_Update); //清除定时器5的捕获2标志和更新标志//
    
23.   //设置GPIOA.1为浮空输入//
    3 ^) w9 X% z1 C6 o$ i# i/ o9 z
24.   GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;    //浮空输入//
    # l+ N1 t; o0 o3 A
25.   GPIO_Init(GPIOA, &GPIO_InitStructure);                 //再次初始化GPIOA0后，开始充电//               
    ( |: q* g. @2 ]7 z
26. }
    / M' P% _- h8 i: e1 W
27. //*****函数二->获得TPAD捕获值-u16 TPAD_Get_Val(void)*****//
    ) u! K& q. ^6 [+ E! w' G/ T
28. //返回值：如果超时,则直接返回定时器5的计数值；如果没超时，则返回定时器5的CCR2寄存器的值//
    ) |8 v( ]) M( t# `( e: ]
29. u16 TPAD_Get_Val(void)
    % H- w$ X1 K& q2 Z# i6 o
30. {      
    
31. TPAD_Reset();
    / ]7 t) h, |- ^7 Q
32. //针对TIM5_SR状态寄存器，输入模式下，当第[2]位值CC2IF为1时，即通道2捕获到上升沿，则运行下述括号内代码，否则跳过//
    & m* c  Q0 ~2 B. n: B" W1 T
33. while(TIM_GetFlagStatus(TIM5, TIM_IT_CC2) == RESET)   
    
34. {
    
35.   //针对TIM5_CNT计数器寄存器，若TIM5_CNT的值大于TPAD_ARR_MAX_VAL-500，返回TIM5_CNT的值，表示超时了//
    5 n0 p! g9 g- e3 j
36.   if(TIM_GetCounter(TIM5)>TPAD_ARR_MAX_VAL-500)return TIM_GetCounter(TIM5);
    
37. };
    
38. //若没超时，返回TIM5_CCR2的值//
    9 ?% @3 F9 ]0 S# Y& n2 k& q2 n/ R
39. return TIM_GetCapture2(TIM5);   
    ; z# ~1 u; x' w+ F
40. }  
    9 j" b$ y% G6 _. [" x" T( Z
41. //*****函数三->读取n次，取最大值-u16 TPAD_Get_MaxVal(u8 n)*****//
    . [6 @- d3 X$ K) }3 f0 z* J. L
42. //返回值：n次读数里面读到的最大读数值res//
    & O5 j* w" }* r% z8 n0 M
43. u16 TPAD_Get_MaxVal(u8 n)
    
44. {
    % a" Q6 I) k0 W3 x. F
45. u16 temp=0;
    2 X/ I7 c& j9 _% I  \7 E
46. u16 res=0;
    9 b. C- I) {% Z0 Q7 Z, N
47. while(n--)
    
48. {
    4 Z" H3 ~1 G& F2 _
49.   temp=TPAD_Get_Val();//得到一次值
    & f: q; V2 o( r  E. E' L
50.   if(temp>res)res=temp;
    ) s+ Y8 C) K0 M' q9 \/ N' W- x  G
51. };
    
52. return res;
    
53. }  
    ' }  T- t# b8 D0 `
54. //*****函数四->初始化触摸按键-u8 TPAD_Init(u8 psc)*****//
    5 c" i- |4 B2 z% @1 T1 T9 p# c6 }
55. //作用：获得空载时触摸按键的取值//
    
56. //返回值:0,初始化成功;1,初始化失败//
    
57. u8 TPAD_Init(u8 psc)
    1 }9 Y+ O+ u# o$ Q2 D4 O- y8 b4 U
58. {
    
59. u16 buf[10];                                 //一个16位，组数长度为10的变量组//
    
60. u16 temp;                                    //一个16位变量temp//
      H, A2 L9 |# c, R# U# t0 }
61. u8 j,i;                                      //两个8位变量j和i//
    ) ]8 H. A0 S2 r  f4 K' M2 x- ]
62. TIM5_CH2_Cap_Init(TPAD_ARR_MAX_VAL,psc-1);   //以1Mhz的频率计数
    
63. //10次for循环//
    
64. for(i=0;i<10;i++)
    1 a9 T0 N1 T+ N- \
65. {     
    
66.   buf<i>=TPAD_Get_Val();                      //将第i次循环获取的TPAD_Get_Val()返回值传至buf<i>中//
    # J% x) @5 {+ f! G  w
67.   delay_ms(10);                               //10ms延迟//     
    
68. }
    3 S7 {4 v0 N; B2 X( S1 @, _7 D
69. //*****将buf里的10个数值由小到大排列*****//
    % n, K) D, N6 U+ |, K
70. for(i=0;i<9;i++)
    
71. {
    
72.   for(j=i+1;j<10;j++)
    
73.   {
    # y: ]4 B( D. A/ {
74.    if(buf<i>>buf[j])
    
75.    {
    
76.     temp=buf<i>;
    ' i( V1 n4 O; B1 m# V+ s' Z
77.     buf<i>=buf[j];
    
78.     buf[j]=temp;
    
79.    }
    / @3 T+ `2 C2 \' N7 }
80.   }
    
81. }
    ! X6 r4 v* m5 Y& n5 K6 C* D! W" |! P
82. //*************************************//
    
83. //******buf[2:7]六个数据加起来平均******//
    
84. temp=0;
    
85. for(i=2;i<8;i++)
    
86. temp+=buf<i>;
    . Y4 |+ i# l: L0 @7 K* o
87. tpad_default_val=temp/6;              //赋值给tpad_default_val//
    
88. printf("tpad_default_val:%d\r\n",tpad_default_val);
    . G  L5 t& i) \; U9 ^/ J7 c
89. //若上述计算的均值大于TPAD_ARR_MAX_VAL的一半，则不正常//
    - C) A  f+ V. T) J/ Z: }8 q
90. if(tpad_default_val>TPAD_ARR_MAX_VAL/2)
    $ a" p# n3 O+ w1 I# p/ ^# H3 I
91.   return 1;
    
92. return 0;                    
    - F% }8 L5 |7 ~0 A4 Z$ A; w
93. }
    
94. //*****函数五->扫描触摸按键-u8 TPAD_Scan(u8 mode)*****//
    ' i$ a" \6 o, n- J
95. //mode:0,不支持连续触发(按下一次必须松开才能按下一次);1,支持连续触发(可以一直按下)//
    - D( e8 L; ]. m" B7 M) c
96. //返回值:0,没有按下;1,有按下; //         
    # U) n( R/ H( `2 y4 r& `
97. #define TPAD_GATE_VAL  100 //触摸的门限值,也就是必须大于tpad_default_val+TPAD_GATE_VAL,才认为是有效触摸.//
    5 w, I8 Z$ b( H: U" ]6 f" g/ X  Q
98. u8 TPAD_Scan(u8 mode)
    6 y+ C$ o- s& w+ j# m" J
99. {
    
100. static u8 keyen=0;              //0,可以开始检测;>0,还不能开始检测//  
     5 Y& X& w" K; B+ \/ O8 z
101. u8 res=0;                       //res=0说明按键无效，res=1说明按键有效//
     % u& i, \1 Q% \+ Q& Z2 _/ w$ t
102. u8 sample=3;                    //默认采样次数为3次  
     
103. u16 rval;                       //
     - C8 H# g, ?" T" |4 r7 v
104. if(mode)                        //mode:0,不支持连续触发//
     0 N0 ?$ S5 V& K3 ~( V
105. {
     
106.   sample=6;                      //支持连按的时候，设置采样次数为6次
     
107.   keyen=0;                       //支持连按   
     " i) p, S! x( E' \% Y
108. }
     : i! R; K0 P/ f# l4 c, i
109. rval=TPAD_Get_MaxVal(sample);   //连续采样三次，取最大值//
     
110. if(rval>(tpad_default_val+TPAD_GATE_VAL))    //如果rval大于tpad_default_val+TPAD_GATE_VAL,则有效触摸//
     
111. {        
     / ]) E/ S, V: g" R1 g
112.   if(keyen==0)                   //0,可以开始检测;>0,还不能开始检测//
     
113.    res=1;                        //当keyen==0,res至1，触摸有效//
     # n! E3 R+ A( k$ z( y& }% E
114.    printf("r:%d\r\n",rval);                    
     5 h; S( v$ t& L5 x9 U. P
115.    keyen=3;                      //至少要再过3次之后才能按键有效//   
     
116. }   
     
117. if(keyen)keyen--;               //keyen不等于0时，keyen减1//                        
     9 ]/ d8 n2 X4 O& N( o* `/ j; \  p+ y! H
118. return res;                     //res=0说明按键无效，res=1说明按键有效//
     
119. }
       k+ L' w+ r  W
120. //*****函数六->定时器2通道2输入捕获配置-void TIM5_CH2_Cap_Init(u16 arr,u16 psc)*****//
     
121. void TIM5_CH2_Cap_Init(u16 arr,u16 psc)
     
122. {
     1 R: s3 n2 w: p7 G3 d' @! S' R
123. //定义GPIO,TIM时基和TIM输入捕获三个初始化结构//
     
124. GPIO_InitTypeDef  GPIO_InitStructure;
     6 z) r1 F& O3 ~4 B3 a2 f  Z! q
125. TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
     
126. TIM_ICInitTypeDef  TIM5_ICInitStructure;
     
127. //使能TIM5时钟，使能GPIOA的端口时钟//
     
128. RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE);  
     + K# d" L% e1 y( t5 t
129. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
     * z$ X  @/ d% y6 u7 E0 b1 g/ h
130. //设置GPIOA.1为浮空输入，
     * n0 V+ a$ J# C* P+ T0 k  g9 t8 ~% P
131. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;     
     5 b5 |& ]$ ^" U
132. GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;
     ; o7 j6 H  B3 F. A! M
133. GPIO_Init(GPIOA, &GPIO_InitStructure);  
     3 R- H2 W! \/ u' k% C# g
134. //初始化TIM5时基//  
     ! f$ _+ e' O2 o
135. TIM_TimeBaseStructure.TIM_Period = arr;                       //设定计数器自动重装值   
     
136. TIM_TimeBaseStructure.TIM_Prescaler =psc;                     //预分频器     
     
137. TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;       //设置时钟分割:TDTS = Tck_tim
     8 n9 r* W- R, _
138. TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;   //TIM向上计数模式
     5 }; y% p" m* b; W3 y2 W) y
139. TIM_TimeBaseInit(TIM5, &TIM_TimeBaseStructure);
     ' N$ z' R5 {! [
140. //初始化TIM5的捕获通道2//
     , g4 y1 _5 {2 O$ H, `* l
141. TIM5_ICInitStructure.TIM_Channel = TIM_Channel_2;             //CC1S=01  选择输入端 IC2映射到TI5上
     
142. TIM5_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;  //上升沿捕获
     . l8 K( `/ p3 \5 a( Z6 L; u' e9 Y
143. TIM5_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
     ( U% I" d3 o) j7 `0 o3 T+ X5 x
144. TIM5_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;        //配置输入分频,不分频
     ; _) l% T+ j0 h( t
145. TIM5_ICInitStructure.TIM_ICFilter = 0x03;                     //IC2F=0011 配置输入滤波器 8个定时器时钟周期滤波
     6 @8 L7 A, U5 q
146. TIM_ICInit(TIM5, &TIM5_ICInitStructure);
     
147. //使能定时器5//
     4 M9 S$ h4 `% T# o# t7 M% g
148. TIM_Cmd(TIM5,ENABLE );  
     ; }1 G( A, G8 {( ?+ g. h
149. }</i></i></i></i></i></i>

复制代码

$ Z. A( u* U" r8 Y0 {5.3 main.c文件
3 p5 O* {! _& p' `# Q
7 ?& L& P9 T* k6 i8 y3 u$ l

1. #include "led.h"
   
2. #include "delay.h"
   # W: e1 G  f) }9 }
3. #include "key.h"
   
4. #include "sys.h"
   
5. #include "usart.h"
   3 \2 z- m3 I5 w/ k) W- @8 s5 t
6. #include "tpad.h"
   7 b4 W! M% i( O& S
7. int main(void)
   9 J9 y( P& @) d& F; E
8. {
   / j& p( g9 I% \' ]/ O
9.   u8 t=0;   
   
10.   delay_init();                                  //延时函数初始化   
    # E& k3 g3 r2 m
11.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置NVIC中断分组2:2位抢占优先级，2位响应优先级
    4 U5 L2 N" R8 ?) _( M8 b
12.   uart_init(115200);                             //串口初始化为115200
    / |, e( B- I$ m
13.   LED_Init();                                    //LED端口初始化
    " z/ D  d! `8 S7 z* Q* j, j. Z% n
14.   TPAD_Init(6);                                  //初始化触摸按键
    ! f1 T( c& R  j! B
15.   while(1)
    
16. {  
      |' _3 a! J, Y* ?+ I* ~" e
17.    //TPAD_Scan(1)支持连续触发，TPAD_Scan(0)不支持连续触发//
    8 R  F/ I, w5 }2 n. y! h
18.    if(TPAD_Scan(1))          //如果成功捕获到了一次上升沿，if返回1
    6 `- |) }- T: Q- S; K$ B
19.   {
    ' |( Y) ~1 z% T0 Q9 |7 @* R0 X% i
20.    LED1=!LED1;               //LED1取反//
    5 j( ^9 e; {# G
21.   }
      d3 v4 [5 Z4 U1 \7 O
22.   t++;
    ' S, d3 F& r! O. ^! n/ ?
23.   if(t==15)   
    
24.   {
    ) |- t& i0 v  I5 c+ m
25.    t=0;
    
26.    LED0=!LED0;               //LED0取反,提示程序正在运行
    
27.   }
    0 o9 t  c0 D9 |* P! i
28.   delay_ms(10);
    $ ?& d! `) T5 B
29. }
    
30. }

复制代码

  A/ z1 W4 n: `9 ?
+ b0 D7 i" V" j3 x% V; _4 n————————————————
版权声明：天亮继续睡