主要内容：
1） 三种定时器分类及区别；
2） 通用定时器特点；
3） 通用定时器工作过程；
4） 实验一：定时器中断实验补充知识及部代码解读；
6） 实验二：定时器PWM输出实验补充知识及部分代码解读；
+ R, n6 }: u, ~# z/ v/ ~$ E, o7 J7） 实验三：定时器输入捕获实验补充知识及部分代码解读。
相关实验：
实验一定时器中断实验：通过定时器中断配置，使用定时器3，每隔500ms触发一次中断，后中断服务函数中控制LED实现LED1状态取反；
实验二定时器PWM输出实验：使用定时器3的PWM功能，输出占空比可变的PWM波，用来驱动LED灯，从而达到LED0亮度由暗变亮，又从亮变暗。
实验三定时器输入捕获实验：测量一个信号的脉冲宽度，要求如下图，按键按下后为高电平，获取2~3高电平的持续时间。
2 a) d3 ?8 a5 x" T* d# _


7 ]! F$ m$ ?/ @9 X5 G1. STM32定时器
STM32F103RC和STM32F103ZE总共最多有8个定时器。
1 E8 G5 F) N& o& a/ x3 }
1 V$ h: P0 n" [8 P; ~
! }9 L  U# N+ q' O- W% T4 \
2. 三种定时器区别
$ T8 d" T" Y1 ~! _+ n3 P

9 N! z( O0 p  T: U% r
3 b. I& H5 t! Q3 g3. 通用定时器功能特点
" y8 d) M$ ]3 R6 w" s* m* Y5 h针对STM3 的通用 TIMx (TIM2、TIM3、TIM4 和 TIM5)定时器的特点：
  t  V( ~; V9 Z7 l+ g3.1 可来源于位于低速的APB1总线上(APB1)；
3.2 16 位向上、向下、向上/向下(也称中心对齐)计数模式，自动装载计数器（TIMx_CNT）；
6 f0 {) O3 M# {3.3 16 位可编程(可实时修改)预分频器(TIMx_PSC)，计数器时钟频率的分频系数 为 1～65535 之间的任意数值。
3.4 4 个独立捕获/比较通道（TIMx_CH1~4），这些通道可以用来作为：
3.4.1 输入捕获；
2 h' E) |3 V; }; Y! U; m: \- Q3.4.2 输出比较；
/ U2 G; s# \# Z3 T5 d3.4.3 PWM 生成(边缘或中间对齐模式) ；
' k* m$ [4 B# J/ k* I+ {1 Y, h3.4.4 单脉冲模式输出。
3.5 可使用外部信号（TIMx_ETR）控制定时器和定时器互连（可用 1 个定时器控制另一个定时器）的同步电路。
3.6 如下事件发生时产生中断/DMA（6个独立的IRQ/DMA请求生成器）：
. c" k0 {9 r+ U$ C% u) \' ?3.6.1 更新：计数器向上溢出/向下溢出，计数器初始化(通过软件或者内部/外部触发)；
' x! z* j% m  n, l$ B3.6.2 触发事件(计数器启动、停止、初始化或者由内部/外部触发计数) ；
3.6.3 输入捕获；
% d) l) o* t- ^7 E: ]3.6.4 输出比较；
8 Q' x$ @1 v0 Y. T1 L% z# t. K3.6.5 支持针对定位的增量(正交)编码器和霍尔传感器电路；
3.6.6 触发输入作为外部时钟或者按周期的电流管理。
3.7 STM32 通用定时器可被用于，测量输入信号的脉冲长度(输入捕获)或者产生输出波形(输出比较和 PWM)等。
3.8 使用定时器预分频器和 RCC 时钟控制器预分频器，脉冲长度和波形周期可以在几个微秒到几个毫秒间调整。STM32 的每个通用定时器都是完全独立的，没有互相共享的任何资源。

4. 通用定时器的计数模式
通用定时器可以向上计数、向下计数、向上向下双向计数模式：
4.1 向上计数模式：计数器从0计数到自动加载值(TIMx_ARR)，然后重新从0开始计数并且产生一个计数器溢出事件；
4.2 向下计数模式：计数器从自动装入的值(TIMx_ARR)开始向下计数到0，然后从自动装入的值重新开始，并产生一个计数器向下溢出事件；
4.3 中央对齐模式（向上/向下计数）：计数器从0开始计数到自动装入的值-1，产生一个计数器溢出事件，然后向下计数到1并且产生一个计数器溢出事件，然后再从0开始重新计数。



- @5 E; b' D7 ?- {' ]5. 通用定时器的工作过程


4 c2 U" w1 k* m2 @5.1 上图中：
5.1.1 上半部分可称为时钟发生器，主要目的是产生时钟至PSC预分频器；
- c: a$ E) i/ x* N5.1.2 PSC预分频器、自动重装载寄存器和CNT计数器构成时基单元；
5.1.3 左下部分称为输入捕获部分，对输入信号进行相关操作；
5.1.4 右下部分称为输出比较部分；
1 H5 o6 j$ W, h4 Z4 i5 E5.1.5 剩余的捕获比较寄存器作为剩余的部分。
5.2 针对5.1.1细讲：

2 C: ]# B9 H  G8 ^5 e3 L! I( o) b

" ?; N  r% z- e- d+ U3 I5.2.1 计数时钟可来源于RCC的TIMxCLK的内部时钟（主要通过APB1经过倍频获得）；
5.2.2 计数时钟可来源于外部引脚TIMx_ETR（主要针对TIM2、TIM3、TIM4），经极性选择、边沿检测、预分频器和滤波后产生时钟信号；
5.2.3 计数时钟可来源于ITR0~3（内部触发输入，即来自于其他定时器），经过选择器后作为时钟来源；
3 E8 j, ]  v: [- g5.2.4 计数时钟可来源于TI1F_ED，TI1FP1,TI1FP2（最终来源于TIMx_CH1~4，外部通道）。
5.3 针对5.1.2细讲：
; U5 S; A* u3 M7 z时钟信号先经过PSC预分频器（即除法运算）产生CK_CNT时钟（计数器最终时钟），然后根据触发控制器配置的计数模式（向上，向下或中心对齐）进行计数，计数到重装载值后，会产生溢出事件，可产生触发中断或DMA请求；
, K2 w2 A& {. C3 }% g* h' ^' v5.4针对5.1.3细讲：
捕获通道引脚上的电平（比如上升沿捕获，边沿检测，可计算脉冲宽度）；
4 ~6 Q" z: E( z8 C0 S5.5 针对5.1.4细讲：
可调整输出高低电平的占空比。

6. 实验一：定时器中断实验知识补充
6.1 内部时钟选择过程
1 Q- q% r- r0 ^

2 y/ E' U+ H( P. p, c
$ A5 w7 t- F- K) H4 a3 Z, zAHB时钟经APB1预分频后产生的时钟供通用定时器TIM2，3，4，5用，注意：如果APB1预分频=1，则1倍输出，否则2倍输出。
* Y- `: F5 n% s# N

& d9 _" e3 N/ }6 }9 b
. w) i- h/ n8 N4 w, ^举例：
) i8 G2 o( t) t8 a: m# s再次强调：除非APB1的分频系数是1，否则通用定时器的时钟等于APB1时钟的2倍。
4 O8 T3 y& e5 i默认调用SystemInit函数情况下：
SYSCLK=72M；
6 x' A- I- O2 x( x+ s  m. ?AHB时钟=72M；//AHB预分频1//
0 n- q, a, y) J) C/ {# I# wAPB1时钟=36M；//APB1预分频2//
; d, [( ?/ p% H  q4 ?所以，通用定时器时钟CK_INT应为APB1时钟的2倍，即2*36M=72M，
最终计数时钟CK_CNT时钟由CK_PSC分频后获得。

6.2 计数模式
6.2.1 向下计数（时钟分频因子=1）
数器从自动装入的值 (TIMx_ARR计数器的值)开始向下计数到0，然后从自动装入的值重新开始并且产生一个计数器向下溢出的事件。
9 Q9 u+ r( k2 R% V
6 k8 s2 s/ H5 I6 z8 z

2 i- e) s5 f5 m$ y6 K4 g8 H! w6.2.2 向上计数（时钟分频因子=1）
1 `7 I( \3 ~  G. H1 n+ t  K计数器从0计数到自动加载值(TIMx_ARR计数器的值)，然后重新从0开始计数并且产生一个计数器溢出事件。
! Q- J4 ~- u% p. E' k

. h$ Y* t! e% W( t: Y* j& I
3 q2 G7 q7 b- C! t* I2 S6.2.3 中央对齐计数模式（时钟分频因子=1 ARR=6）
9 O9 q# ~# r/ K3 G" S$ [; z计数器从0开始计数到自动加载的值（TIMx_ARR寄存器的值−1），产生一个计数器溢出事件，然后向下计数到1并且产生一个计数器下溢事件，然后再从0开始重新计数。



6.3 定时器中断实验相关寄存器
' b* Z4 F7 ^+ O* b. d3 w6.3.1 计数器当前值寄存器CNT；
2 S0 t. K+ d3 r& A' `+ k9 z, U6.3.2 预分频寄存器TIMx_PSC；
% @& W3 h! h3 X$ u4 j6.3.3 自动重装载寄存器（TIMx_ARR)；
# g6 L$ n" |9 P% `3 c: {6.3.4 控制寄存器1（TIMx_CR1）；
6.3.5 DMA中断使能寄存器（TIMx_DIER）。
2 x, b; K1 \! _" U6 [& d1 {6.4. 定时器中断实验常用库函数
# a% o& r! c) U6.4.1 定时器参数初始化：
8 [. c2 i$ W% r6 M: m* _
  m: |, P1 n- k" V1 g. j- L7 u/ g

1. void TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct);

复制代码

$ _6 f3 a; C! S) i) n举例：

1. typedef struct
   . N! y0 K: I" L0 \6 `$ o3 f
2. {
   ( i7 T/ q- Z0 T6 W. g) @
3. uint16_t TIM_Prescaler;        
   ) y1 \. f9 @, R6 Y: T# z# ]' J
4. uint16_t TIM_CounterMode;     
   
5. uint16_t TIM_Period;        
   3 ]; t+ P2 I" [; g
6. uint16_t TIM_ClockDivision;  
   & }4 F5 H& G6 B! p6 k
7. uint8_t  TIM_RepetitionCounter;
   
8. } TIM_TimeBaseInitTypeDef;
   6 ~* G& s2 I5 p. w4 O* i: d
9. 
   
10. TIM_TimeBaseStructure.TIM_Period = 4999;
    . ]- K) o. t; [$ s6 x
11. TIM_TimeBaseStructure.TIM_Prescaler =7199;
    
12. TIM_TimeBaseStructure.TIM_ClockDivision =   TIM_CKD_DIV1;
    
13. TIM_TimeBaseStructure.TIM_CounterMode =   TIM_CounterMode_Up;
    
14. TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
    

复制代码

6.4.2 定时器使能函数：
, w- ^" K& h. i/ l

1. void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState);

复制代码

6.4.3 定时器中断使能函数：

1. void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState);

复制代码

6.4.4 状态标志位获取和清除：
  [0 O9 p& b( U0 X4 k
, K; F! d* L/ M  m5 V3 Y

1. FlagStatus TIM_GetFlagStatus(TIM_TypeDef* TIMx, uint16_t TIM_FLAG);
   
2. void TIM_ClearFlag(TIM_TypeDef* TIMx, uint16_t TIM_FLAG);
   
3. ITStatus TIM_GetITStatus(TIM_TypeDef* TIMx, uint16_t TIM_IT);
   
4. void TIM_ClearITPendingBit(TIM_TypeDef* TIMx, uint16_t TIM_IT);

复制代码

6.5 定时器中断实现步骤
$ k) n* V$ S; r. r# L  a/ _6.5.1 使能定时器时钟：

1. RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState);

复制代码

& k* c8 H4 a1 H$ X; ~" x+ G6.5.2 初始化定时器，配置ARR,PSC：

1. TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct);

复制代码

9 H/ w9 `: {& z+ N, E6.5.3 开启定时器中断，配置NVIC：

1. void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState);
   ; O# f( }" f+ T; M% |
2. NVIC_Init(NVIC_InitTypeDef* NVIC_InitStruct);

复制代码

6.5.4 使能定时器：

4 Y2 J$ e) u8 _8 g* x/ V

1. TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState);

复制代码

6.5.5 编写中断服务函数：
! q7 E& w, j* z  R, Y- X

1. void TIMx_IRQHandler(void);

复制代码

5 Y& h0 e! x$ `% y* X( `6.6 溢出时间计算公式（有计数时钟、重载值和PSC分频系数共同决定）：
Tout（溢出时间）=（ARR+1)(PSC+1)/Tclk
6.7 定时器中断实验部分代码解读
6.7.1 timer.h头文件

1. #ifndef __TIMER_H
   
2. #define __TIMER_H
   8 g2 b3 G. `* j0 [# U, t
3. #include "sys.h"
   
4. //申明一个定时器3中断初始化函数，入口参数包括16位的arr和psc//
     Z$ s7 \  Z6 y
5. void TIMER3_Interrput_Init(u16 arr, u16 psc);
   
6. #endif

复制代码

) q5 w' R' d2 u& h# y6 O; F  L6.7.2 timer.c文件

) f5 ?7 }; V6 l0 f$ X: q, R9 ^

1. #include "timer.h"
   
2. #include "led.h"
   1 T& q: M+ q3 s
3. //编写定时器3中断初始化函数，入口参数包括16位的arr和psc//
   
4. void TIMER3_Interrput_Init(u16 arr, u16 psc)
     d/ \; S# ~9 i% U: x
5. {
   + P7 o2 r# s8 [$ h' z! D) A( B
6.       //定义两个结构体//
   
7.       TIM_TimeBaseInitTypeDef TIM_TimeBaseInitTypeStruct;
   
8.       NVIC_InitTypeDef        NVIC_InitTypeDef_TIM3Struct;
   + d0 ^! a! v! m; ^6 m
9.       //使能TIM3时钟//
   3 _( x$ F9 K; Q
10.       RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);
    
11.       //定时器参数初始化，第一个结构体参数初始化//
    
12.       TIM_TimeBaseInitTypeStruct.TIM_Period=arr;
    
13.       TIM_TimeBaseInitTypeStruct.TIM_Prescaler=psc;
    
14.       TIM_TimeBaseInitTypeStruct.TIM_CounterMode=TIM_CounterMode_Up;
    * [' X9 X& M' C5 p9 o- H
15.       TIM_TimeBaseInitTypeStruct.TIM_ClockDivision=TIM_CKD_DIV1;
    
16.       //*下面这行代码可以不写，值取0x00~0xFF之间，仅对TIM1和TIM8有效*//
    $ @( _4 @0 ]- C% |5 V- A
17.       TIM_TimeBaseInitTypeStruct.TIM_RepetitionCounter=0x55;
    : v1 Z' k2 g$ @2 p& U2 _+ Z( ]3 n# d2 q# C2 d
18.       TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitTypeStruct);
    
19.       //*定时器3的中断使能//
    
20.       TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE);
    
21.       //*定时器3中断使能函数初始化*//
    / x4 W- V, w7 s, ^" C
22.       NVIC_InitTypeDef_TIM3Struct.NVIC_IRQChannel=TIM3_IRQn;
    
23.       NVIC_InitTypeDef_TIM3Struct.NVIC_IRQChannelCmd=ENABLE;
    * H5 U- S4 ~3 A' x
24.       NVIC_InitTypeDef_TIM3Struct.NVIC_IRQChannelPreemptionPriority=0;
    - [5 d+ p6 G" Q. g2 j3 a7 t
25.       NVIC_InitTypeDef_TIM3Struct.NVIC_IRQChannelSubPriority=3;
    ! U% _2 o7 V( V/ k$ D5 Q
26.       NVIC_Init(&NVIC_InitTypeDef_TIM3Struct);
    
27.       //使能定时器3//
    
28.       TIM_Cmd(TIM3,ENABLE);
    
29. }
    : E* V$ u  h) X9 U" r# [4 \
30.      //编写定时器3中断服务函数//
    
31. void TIM3_IRQHandler(void)
    6 h2 ?; g& t3 X( z, i& S( R/ w
32. {   
    
33. //获取定时器3状态//
    5 L4 w6 S7 x7 d- C1 [
34. if(TIM_GetITStatus(TIM3,TIM_IT_Update)==SET)//判断定时器3状态是否为上升模式//
    " ^3 `8 Y( Z% P/ J
35. {
    $ @& C9 G) u8 c
36.   LED1=!LED1;                               //是的话就翻转LED1//
    
37.   TIM_ClearITPendingBit(TIM3,TIM_IT_Update);//清除标识//
    
38. }
    ) x, z  {) ~# N5 y2 v
39. }

复制代码

6.7.3 main.c文件
  L) M/ ~$ a9 l: T

1. #include "sys.h"
   
2. #include "delay.h"
   & I5 l% U0 n- u: o
3. #include "led.h"
   
4. #include "timer.h"
   ; r7 W, m8 V) ~3 w9 [/ E0 q
5. int main(void)
   , g/ r! C# z% ]! f4 a
6. {
   
7.    //进行中断优先级分组//
   4 `& u, l% s4 i
8.    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);  
   
9.    //初始化相关函数//  
   7 h% b: I; R) s- Z& ]# i
10.    delay_init();
    
11.    LED_Init();
    ( t4 @' }* r0 W( f! [
12.    TIMER3_Interrput_Init(4999,7199);//500ms触发一次中断//
    ! @- H' Y" k2 ]
13.   while(1)
    
14.   {
    
15.   }
    
16. }

复制代码

$ Q: _: \+ p( L9 n7. 实验二：定时器PWM输出实验知识补充
7.1 PWM模式概念

" s6 W- y* _7 [3 K
. I- m: X6 w* e
& j8 \# H9 \( Q$ h/ k7.2 PWM工作原理
* e" B2 `' a" e1 b脉冲宽度调制（PWM——Pulse Width Modulation）简称脉宽调制，是利用微处理器的数字输出来对模拟电路进行控制的一种技术。简单一点，就是对脉冲宽度的控制。
PWM工作逻辑可参考下图理解：


; b  F9 j$ p: V3 N
上图中，
ARR为自动重装载寄存器（TIMx_ARR）的位[0:15]设定值，
CCRx为某个捕获比较寄存器（TIMx_CRRx）的位[0:15]设定值，
# ^* ^; a2 k7 O黑线为计数器寄存器（TIMx_CNT）的位[0:15]实时值，记CNT。
当CNT小于CCRx时，可设输出低电平，反之输出高电平。因此可以认为：脉宽调制（PWM）信号的周期由ARR决定，占空比由CCRx决定。


+ |( b: u2 \1 H  V" h2 c
以通道1为例，寄存器主要包括：
' P4 T6 b0 P; Z) @: P: K' `1） 捕获比较(值)寄存器（TIMx_CCRx（x=1,2,3,4)），用来设置比较值；
2） 捕获/比较模式寄存器 1（TIMx_CCMR1），位[4:6]，输出比较1模式（OC1M）：
在PWM方式下，设置PWM模式1（110），在向上计数时，一旦TIMx_CNT<TIMx_CCR1时通道1为有效电平，否则为无效电平；在向下计数时，一旦TIMx_CNT>TIMx_CCR1时通道1为无效电平(OC1REF=0)，否则为有效电平(OC1REF=1)；
, K+ }: l5 h! i, l* b8 v+ B或在PWM方式下，设PWM模式2（111），在向上计数时，一旦TIMx_CNT<TIMx_CCR1时通道1为无效电平，否则为有效电平；在向下计数时，一旦TIMx_CNT>TIMx_CCR1时通道1为有效电平(OC1REF=1)，否则为无效电平(OC1REF=0)。
3） 捕获/比较使能寄存器(TIMx_CCER)，位1，输入/捕获1输出极性CC1P：
当CC1通道配置为输出时，0：高电平有效，1：低电平有效；
4） 捕获/比较使能寄存器(TIMx_CCER)，位0，输入/捕获1输出使能CC1E:
当CC1通道配置为输出时，0：关闭，1：打开。
7.3 PWM模式1 & PWM模式2区别（参考7.2）
& C' X4 ?7 O4 o$ C, u3 O  K针对上述寄存器TIMx_CCMR1的OC1M[2:0]位来分析：
PWM模式1：只要CNT小于CCRx，则为有效电平，反之为无效电平；
PWM模式2：只要CNT小于CCRx，则为无效电平，反之为有效电平。
5 L2 r; m1 T( {1 v7 x举例如下图：
, |4 u' q' x. p5 e$ {* B; D8 `

2 b4 a2 V+ s. `- V: E3 U" m4 D% q
9 F9 L/ j4 o: i/ G: N7.4 对自动重载的预装载寄存器的理解
5 x' b& K& y+ o自动装载寄存器是预先装载的，写或读自动重装载寄存器将访问预装载寄存器。根据在TIMx_CR1寄存器中的自动装载预装载使能位(ARPE)的设置，预装载寄存器的内容被立即或在每次的更新事件UEV时传送到影子寄存器。
  a9 f" n, [5 E% {0 \/ b2 i2 q$ K影子寄存器保存的是定时器当前的计数值（或者溢出值），这个值是立即生效的值，这个计数值是从预装载寄存器（ARR）传过来的，但ARR什么时候把计数值传给影子寄存器呢？这儿就有个预装载使能位（ARPE）：当ARPE=0的时候，你写入ARR的值马上就传到影子寄存器，也就立即生效当ARPE=1的时候，ARR的值就是直接传过去了，而是等到定时器更新事件发生，才把这个值传到影子寄存器，也就起到一个缓冲作用。
举例说明：
9 a/ Q$ L  \8 q" j6 f( m) ?/ `

& R; N/ O7 P2 X  x
上图（左）所示，当ARPE=1时，自动加载寄存器值从F5改为36时，计数器寄存器值从F0增加至F5时产生更新事件，说明自动加载寄存器值从F5改为36时就已生效；
上图（右）所示，当ARPE=0时，自动加载寄存器值从FF改为36时，计数器寄存器值从31增加至36时产生更新事件，说明自动加载寄存器值从F5改为36时未即使生效，要等下个比较周期生效。
简单的说：
! O1 f! j# K6 I# ^4 aRPE=1,ARR立即生效；
APRE=0,ARR下个比较周期生效。
相关函数：
! x$ T: o* \* f+ s2 B: v

1. void TIM_ARRPreloadConfig(TIM_TypeDef* TIMx, FunctionalState NewState);

复制代码

7.5 STM32 定时器3输出通道引脚（可参考数据手册）
& V3 u. l0 {4 F8 h
! D4 G- e, x6 N9 N1 {

STM32 定时器输出通道引脚整理


6 H% G) ?8 Z  z  R7 {2 Q
8 u8 a: n0 V4 s% p7.6 相关库函数
1 Z$ ]% O/ D0 q& t7.6.1 PWM输出库函数
7 p# s, l! D' q; [

1. void TIM_OCxInit(TIM_TypeDef*
   
2. TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct);
   
3. typedef struct
   ' x( u; d! r- ~* L* M% J
4. {
   
5. //*主要用到注释的四个参数*//
   & y# q- t4 R; R* Y( E: m, d" \
6. uint16_t TIM_OCMode;          //PWM模式1或者模式2//
   ! S1 \* u0 c1 L; _3 F- f
7. uint16_t TIM_OutputState;     //输出使能 OR失能//
   
8. uint16_t TIM_OutputNState;
   
9. uint16_t TIM_Pulse;           //比较值，写CCRx
   
10. uint16_t TIM_OCPolarity;      //比较输出极性//
    3 b& k7 \. u% m* g, R1 r
11. uint16_t TIM_OCNPolarity;
    9 M; j$ d3 |' F7 J
12. uint16_t TIM_OCIdleState;  
    
13. uint16_t TIM_OCNIdleState;
    
14. } TIM_OCInitTypeDef;

复制代码

; x* |+ c% \; u$ z& p举例：
" ~# @8 C1 j& J2 X4 ]
$ O, ^, i) E! U- w' p- Q8 k

1. TIM_OCInitStructure.TIM_OCMode= TIM_OCMode_PWM2;              //PWM模式2//
   3 t2 `5 Z, x, u  r# }0 r
2. TIM_OCInitStructure.TIM_OutputState= TIM_OutputState_Enable;  //比较输出使能//
   ! e0 B8 s0 [# r6 o% n& @& ]
3. TIM_OCInitStructure. TIM_Pulse=100;
   
4. TIM_OCInitStructure.TIM_OCPolarity= TIM_OCPolarity_High;      //输出极性:TIM输出比较极性高//
   % Q6 z8 w8 V8 {
5. TIM_OC2Init(TIM3,&TIM_OCInitStructure);                       //根据T指定的参数初始化外设TIM3 OC2//

复制代码

7.6.2 设置比较值函数：
, f8 k9 W( n- A; V- A5 |- \4 K, u
: o; q- ]3 J! p0 D- R

1. void TIM_SetCompareX(TIM_TypeDef* TIMx, uint16_t Compare2);

复制代码

& ^4 t9 `. p" Y  m2 U7.6.3 使能输出比较预装载：

1. void TIM_OC2PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload);

复制代码

7.6.4 使能自动重装载的预装载寄存器允许位：

1. void TIM_ARRPreloadConfig(TIM_TypeDef* TIMx, FunctionalState NewState);

复制代码

2 q- V" X/ {- R3 ~  k6 |7.7 PWM输出配置步骤（以TIM3_CH2为例）：
7.7.1
4 w' F- v+ }: u$ }; l使能定时器3和相关IO口时钟：
使能定时器3时钟：

1. void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState);

复制代码

使能GPIOB时钟：
: F8 m0 |( i& g- |

1. void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState);

复制代码

7.7.2 初始化IO口为复用功能输出。函数：GPIO_Init();
9 e+ {( P2 c; e
6 {: V  ?) S0 E$ N# G8 C

1. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;   

复制代码

9 X) @1 |" A2 u! t6 J7.7.3 开启AFIO时钟（因为要把PB5（对应LED0）作定时器的PWM输出引脚，所以要重映射配置），同时设置重映射。

; d* p- B6 e; F- I

1. RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
   
2. GPIO_PinRemapConfig(GPIO_PartialRemap_TIM3, ENABLE); //部分重映射，即TIM3_CH2对应PB5引脚//

复制代码

7.7.4 初始化定时器，ARR,PSC等：

8 @" M  A9 v; Y+ o, u) Q

1. void TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitTypeStruct);
     G$ n; U7 Z: b& ~7 E1 W
2. //TIM_TimeBaseInitTypeStruct结构体包括5个参数：//
   
3. //uint16_t TIM_Prescaler;            针对预分频器寄存器(TIMx_PSC)，值范围在0x0000到0xFFFF之间//
   ; x; R" F4 o# X, F/ j5 _/ Q1 z9 \
4. //uint16_t TIM_CounterMode;          计数模式，前面已讲//
   
5. //uint16_t TIM_Period;               针对自动重装载寄存器(TIMx_ARR)，确定脉宽调制信号的周期，前面已讲//
   
6. //uint16_t TIM_ClockDivision;        针对控制寄存器1(TIMx_CR1)的位[8:9]，设定时钟分频因子CKD，输入捕获用//
   7 V9 L, O3 F& s& M. u- A; U
7. //uint8_t TIM_RepetitionCounter。    重复计数寄存器(TIMx_RCR)，只有高级定时器才有//

复制代码

7.7.5 初始化输出比较参数：
. Y7 v* v; R! J" S7 a5 A/ W8 d
1 r# w  S5 u7 b2 _; i- n. v$ Q# [

1. void TIM_OC2Init(TIM3,&TIM_OCInitTypeStruct);

复制代码

1 a. O2 s6 [6 ?) A# e0 R7.7.6 使能预装载寄存器：
' v! c8 N  k6 c+ L6 p& C5 T$ J3 \
  u+ `  f/ ~+ }6 B  J' }7 X3 [

1. TIM_OC2PreloadConfig(TIM3,TIM_OCPreload_Enable);  
   , c# i$ r9 T- E" j
2. //针对捕获/比较模式寄存器1（TIM3_CCMR1），位[11]，设置OC2PE值//

复制代码

设计preload register和shadow register的好处是，所有真正需要起作用的寄存器(shadow register)可以在同一个时间(发生更新事件时)被更新为所对应的preload register的内容，这样可以保证多个通道的操作能够准确地同步。如果没有shadow register，或者preload register和shadow register是直通的，即软件更新preload register时，同时更新了shadow register，因为软件不可能在一个相同的时刻同时更新多个寄存器，结果造成多个通道的时序不能同步，如果再加上其它因素(例如中断)，多个通道的时序关系有可能是不可预知的。
8 Y, \) E0 k0 V  r  P7 ^- e
6 \* x! A3 A. k3 z  r7.7.7 使能定时器：

1. void TIM_Cmd(TIM3, Enable);

复制代码

7.7.8 不断改变比较值CCRx，达到不同的占空比效果：

# C0 M9 l0 m& i& B

1. void TIM_SetCompare2(TIM3, uint16_t Compare2); //针对捕获/比较寄存器2(TIM3_CCR2)，位[0:15]，设置捕获/比较2（CCR2）的值//

复制代码

* T" O8 R$ F' i- {/ P7.8 定时器PWM输出实验部分代码解读
7.8.1 timer.h头文件代码解读

3 ~: M4 F% C+ z( W

1. #ifndef __TIMER_H
   ! y' r  g) Q: u; P6 _- K
2. #define __TIMER_H
   + K" B, K& r' x6 l" U2 r; L% k, z
3. #include "sys.h"
   
4. //申明一个定时器3 PWM初始化函数，入口参数包括16位的arr和psc//
   / W! ^6 r# y* {6 G. L  W. Q) ^+ P1 s
5. void TIMER3_PWM_Init(u16 arr, u16 psc);
   ) @$ S) W7 J# ?! }4 b( Q
6. #endif

复制代码

7.8.2 timer.c文件代码解读

" b+ i( b( l" K1 I6 E6 [# Y

1. #include "timer.h"
   
2. #include "led.h"
   7 t' m& Q' g6 ]
3. //编写定时器3 PWM初始化函数，入口参数包括16位的arr和psc//
   
4. void TIMER3_PWM_Init(u16 arr, u16 psc)
   
5. {
   . l7 g* {2 }" E& Y9 O$ L
6.       //定义三个结构体//
   $ T- Y# O( {2 I3 G4 O; c$ s' B& V
7.       GPIO_InitTypeDef GPIO_InitTypeStruct;
   8 B  E$ e# u- p& h
8.       TIM_TimeBaseInitTypeDef TIM_TimeBaseInitTypeStruct;
   ( [3 o: B# w+ w; y
9.       TIM_OCInitTypeDef TIM_OCInitTypeStruct;
   
10.       //使能TIM3时钟,使能GPIOB时钟，使能AFIO时钟//
    , p3 Q# \/ j+ d& j$ i" A
11.       RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);
    
12.       RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO,ENABLE);     
    ( ]' E, C0 \* v2 t) l
13.       //初始化GPIOB5为复用推挽输出，50MHz//
    
14.       GPIO_InitTypeStruct.GPIO_Pin=GPIO_Pin_5;
    - B% N; C$ w  O: l3 M" O
15.       GPIO_InitTypeStruct.GPIO_Mode=GPIO_Mode_AF_PP;
    
16.       GPIO_InitTypeStruct.GPIO_Speed=GPIO_Speed_50MHz;
    - [& F, z( ^8 k5 C; E
17.       GPIO_Init(GPIOB,&GPIO_InitTypeStruct);
    
18.       //*使能TIM3部分重映射*//
    
19.       GPIO_PinRemapConfig(GPIO_PartialRemap_TIM3, ENABLE);
    , ?/ \9 }) S# R
20.       //定时器3参数初始化//
    ; |2 H9 W7 y+ `. w- b
21.       TIM_TimeBaseInitTypeStruct.TIM_Period=arr;
    
22.       TIM_TimeBaseInitTypeStruct.TIM_Prescaler=psc;
    
23.       TIM_TimeBaseInitTypeStruct.TIM_CounterMode=TIM_CounterMode_Up;
    5 U- B8 t$ S' h6 O0 G  e
24.       TIM_TimeBaseInitTypeStruct.TIM_ClockDivision=TIM_CKD_DIV1;
    3 y1 {& s. W) g2 d3 x- P
25.       //*下面这行代码可以不写，值取0x00~0xFF之间，仅对TIM1和TIM8有效*//
    . C* |& B, |9 z) J+ h. u* @: k
26.       TIM_TimeBaseInitTypeStruct.TIM_RepetitionCounter=0x55;
    . h5 y. E+ o, R% @+ `+ X) X
27.       TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitTypeStruct);
    
28.       //初始化输出比较参数//
    
29.       TIM_OCInitTypeStruct.TIM_OCMode=TIM_OCMode_PWM2;
    
30.       TIM_OCInitTypeStruct.TIM_OutputState=TIM_OutputState_Enable;
    
31.       TIM_OCInitTypeStruct.TIM_Pulse=100;
    & R; [" }2 j9 z' o" g
32.       TIM_OCInitTypeStruct.TIM_OCPolarity=TIM_OCPolarity_High;
    
33.       TIM_OC2Init(TIM3,&TIM_OCInitTypeStruct);
    
34.       //使能预装载寄存器//
    
35.       TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);
    " c7 r, ^* A9 f
36.       //使能定时器3//
    2 l, ]$ O7 u. o# O) i& R
37.       TIM_Cmd(TIM3,ENABLE);
    
38. }

复制代码

: C/ y) b3 I. d6 I# D" B# b. e
  z3 {/ F( Y! _2 @7.8.3 main.c文件代码解读
& Q/ J- I. T; j% F4 h& C& ^
5 q" B3 J& Q: P9 o- a( G

1. #include "sys.h"
   
2. #include "delay.h"
   0 }. t0 _( h, h; f/ @" [, @
3. #include "led.h"
   3 a1 b, \  K: H) ?' O& l' w
4. #include "timer.h"
   
5. int main(void)
   
6. {  
   
7.   u16 led0pwmval=0;
   
8.   u8 dir=1;
   
9.   delay_init();              //延时函数初始化//   
   " k2 j/ W1 h# U+ Z
10.   LED_Init();                //LED端口初始化//
    3 Z. Z5 N) M: |3 m2 I+ |
11.   TIMER3_PWM_Init(899,0);    //不分频，PWM频率=72000000/900=80Khz//
    
12.   while(1)
    # g  X8 i3 B, L& Y9 x: I; ]
13. {
    
14.    delay_ms(10);             //延迟10ms//
    
15.    if(dir)led0pwmval++;      //若dir为1，则led0pwmval加1//
    # y! [; A/ i5 A. e! H1 J5 {
16.    else led0pwmval--;        //若dir不为1，则led0pwmval减1//
    : O3 _' A5 C; {$ \
17.    if(led0pwmval>300)dir=0;  //若led0pwmval大于300，则dir为0//
    
18.    if(led0pwmval==0)dir=1;   //若led0pwmval等于0，则dir为1//        
    
19.    TIM_SetCompare2(TIM3,led0pwmval);   //设置定时器3比较值，该比较值先由0升至300，再降至0，不断重复//
    ; V# {# s' v7 h5 g9 e+ }0 k
20. }  
    # T; Z2 @  I1 d8 l; [! o+ S
21. }

复制代码

1 F' U6 a# n2 j% Y8. 实验三：定时器输入捕获实验知识补充
8.1 如下图，对应是左下部分内容。
5 A* z2 H! ], r8 q; |2 r# q7 a
& S# b" G0 m0 B/ h  D( b3 f& e# _

& a: F6 t/ z. S" T上图红框部分细节展开：
* F$ B# ~0 d! s6 ]/ N% Z8 e
$ f( M# e5 u6 a3 [/ w2 d- L7 R: X

: d9 t6 ^+ q6 s, p% ~1 P  v以通道1为例：
0 L- Q% ^3 \: P2 G  `一句话总结工作过程：通过检测TIMx_CHx上的边沿信号，在边沿信号发生跳变（比如上升沿/下降沿）的时候，将当前定时器的值(TIMx_CNT)存放到对应的捕获/比较寄存器（TIMx_CCRx)里面，完成一次捕获。
& F, p! ?* M# Q5 U0 q5 F( {  y具体步骤为：
3 R3 A( r* K$ X! [8.1.1 设置输入捕获滤波器；
2 J8 l+ v% J. ]: D  T+ I
2 J$ D- u) S2 _, G' G  g3 t

4 Y. |7 g& T- A4 r3 E涉及相关寄存器：
TIMx_CR1控制寄存器1，[9:8]位CKD时钟分频因子确定fDTS频率；
TIMx_CCMR1捕获/比较寄存器1，输入捕获模式下，[7:4]位的IC1F输入捕获1滤波器，确定采样频率及数字滤波器长度。
8.1.2 设置输入捕获极性；
7 i( p/ `3 |8 S' I$ w3 g- j
+ A5 m- m& k( C1 m  Q0 b, @2 W
3 V" G0 b: g* Q8 E) q1 {7 B
* ^- T  \  e  W; d  C) K涉及相关寄存器：
& t+ N, j2 W* |" gTIMx_CCER捕获/比较使能寄存器，输入捕获模式下，[1]位CC1P输入/捕获1输出极性，确定选择是IC1还是IC1的反相信号作为触发或捕获信号。
6 v6 V  h* ]5 u' u" V8.1.3 设置输入捕获映射通道；

- j; a1 H1 _2 U
$ L& b( l) [: A- z; e! D% f
! ^# H! {7 ^+ Z* q涉及相关寄存器：
! i# x! w3 Y. `9 P; m" JTIMx_CCMR1捕获/比较寄存器1，[1:0]位CC1S捕获/比较1选择，定义通道的方向及输入脚的选择。
8.1.4 设置输入捕获分频器；

/ K$ \4 N% R3 Z8 n
1 ^7 c' f) I) h* ?1 K% p
! y5 d9 M9 v, J涉及相关寄存器：
# r! h0 N3 r/ O: }% H2 ~0 }& RTIMx_CCMR1捕获/比较寄存器1，输入捕获模式下，[3:2]位IC1PSC输入/捕获1预分频器，定义CC1输入（IC1）的预分频系数；
TIMx_CCER捕获/比较使能寄存器，输入捕获模式下，[0]位CC1E输入/捕获1输出使能，决定计数器的值是否能捕获TIMx_CCR1寄存器。
9 u. |- @9 S: d' v, p0 `
2 z% Y. n/ q( i; O- r# y! q8.1.5 捕获到有效信号可以开启中断；

* }# B+ e: Q$ w4 U' s
( I8 W' w7 D; ~0 W" k4 W- y
涉及相关寄存器：
, C6 a# {  X6 i+ wTIMx_DIER DMA/中断使能寄存器。

8.1.6 最后，看看定时器通道对应引脚TIM5为例。
# Z7 a& t" b. h4 e4 d% ]! ^

4 B7 c/ A: L( h5 q% E: S* c
8.2 相关库函数
+ s& s2 \+ d0 Q
- F& r$ ?8 ^  @1 h% X! J, w8.2.1 输入捕获通道初始化函数：
9 o1 j. L6 i! D% n0 e

1. void TIM_ICInit(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct);
   
2. typedef struct
   
3. {
   
4. uint16_t TIM_Channel;      //捕获通道1-4//   
   
5. uint16_t TIM_ICPolarity;   //捕获极性//
   
6. uint16_t TIM_ICSelection;  //映射关系//
   ! c7 k  Q' q7 \
7. uint16_t TIM_ICPrescaler;  //分频系数//
   . j# J9 E/ w& a6 ?& y) A  e& \+ T
8. uint16_t TIM_ICFilter;     //滤波器//
   ( n, R) u5 V# A8 S
9. }
   
10. TIM_ICInitTypeDef;   

复制代码

举例：
- s* T7 k! D- b2 K, \) Q

1. TIM5_ICInitStructure.TIM_Channel = TIM_Channel_1;
   
2. TIM5_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
   
3. TIM5_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
     F( o) ^* _9 ?( Q' B
4. TIM5_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
   
5. TIM5_ICInitStructure.TIM_ICFilter = 0x00;
   & s- q; l& K8 u4 c3 `5 P, Z9 ]# P' G
6. TIM_ICInit(TIM5, &TIM5_ICInitStructure);

复制代码

8.2.2 通道极性设置独立函数：

1. void TIM_OCxPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity)；

复制代码

  U  r3 `  d+ G7 _8.2.3 获取通道捕获值

  k/ x8 x  }" y# ^9 m# H4 Z- a& _* Z

1. uint32_t TIM_GetCapture1(TIM_TypeDef* TIMx)；

复制代码

  K. n) W( d4 S8 B( E( |2 l8.3 输入捕获的一般配置步骤
8.3.1 初始化定时器和通道对应IO的时钟；
8.3.2 初始化IO口，模式为输入，
3 f7 J* E4 N- j* s
- t# X8 f2 u3 E' B1 u+ B4 ?

1. void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)；
   - {5 j5 w. d. Z0 `( a* ]
2. GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPD;  //PA0 输入//

复制代码

$ ~' P+ b5 U, e* A( o9 [7 I+ k8.3.3 初始化定时器，主要设置ARR，PSC的值：

1. void TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct)；

复制代码

8 E, S( ^9 x' t8.3.4 初始化输入捕获通道：

1. void TIM_ICInit(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct)；

复制代码

9 s# d1 O5 B( G4 h# C# ~8.3.5 如果要开启捕获中断：
4 w% ~, Q' ^: R2 T  d/ r

1. void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState)
   % J! E, O3 x3 U$ n5 n
2. void NVIC_Init(NVIC_InitTypeDef* NVIC_InitStruct)；

复制代码

" H& i$ D- v# a8.3.6 使能定时器：
* z% X, B# X1 r. n; x( a

1. void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState)；

复制代码

8.3.7 编写中断服务函数：
, t  e, _7 m* [4 s  m, i* n% L7 z
9 f/ g' b& g  `6 g2 v9 o- s7 L

1. void TIMx_IRQHandler(void);

复制代码

8.4 定时器输入捕获实验部分代码解读
8.4.1 timer.h文件代码解读
5 W7 _8 m" z* f8 D1 W  q
- ]5 y  z( Q7 y% T) z! G' s

1. #ifndef __TIMER_H
   $ X2 R% u/ u$ h4 e% i* U
2. #define __TIMER_H
   8 ^' ~2 w* T4 p0 {
3. #include "sys.h"
   
4. //申明一个定时器5 输入捕获初始化函数，入口参数包括16位的arr和psc//
   
5. void TIM5_Cap_Init(u16 arr,u16 psc);
   
6. #endif

复制代码

+ P# J2 v/ G5 i, C0 Q1 t8.4.2 timer.c文件代码解读，本代码将顺便解读库函数相关指令对应的寄存器操作。
$ c' _, u" R( S5 w% v. Y
1 e3 ^+ v2 f$ l) \. I( w$ e

1. #include "timer.h"
   
2. //编写定时器5 输入捕获初始化函数，入口参数包括16位的arr和psc//
   
3. void TIM5_Cap_Init(u16 arr,u16 psc)
   
4. {  
   
5. //申明GPIO，定时器时基，定时器输入捕获和中断参数初始化四个结构体//
   
6. GPIO_InitTypeDef         GPIO_InitStructure;
   0 I  S" s, K% N% y
7. TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
   
8. TIM_ICInitTypeDef        TIM5_ICInitStructure;
   ; {# z& A  O$ h
9. NVIC_InitTypeDef         NVIC_InitStructure;
   
10. //**********************************************************//
    
11. //使能TIM5时钟，使能GPIOA时钟//
    ' m( ]+ O2 k; Q  p% d$ o
12. //针对RCC_APB1ENR寄存器，[3]位，TIM5EN设为1，即定时器5时钟开启//
    
13. RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5,  ENABLE);
    . i1 {" s6 M6 h/ Q
14. //针对RCC_APB2ENR寄存器，[2]位，IOPAEN设为1，即IO端口A时钟开启//
    
15. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
16. //**********************************************************//
    
17. //初始化GPIOA，PA0，下拉输入模式//
    " w: v4 I+ y4 \; c; n5 W
18. GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_0;    //选择引脚0
    & y8 X( `! T) j. K" J
19. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //下拉输入
    5 m. X. Z+ c: n/ V" K5 ^! G0 X: u- ^: D
20. //按照上述参数初始化GPIOA//
    0 q( T' Y$ J3 \% h3 ~/ e: Z
21. GPIO_Init(GPIOA, &GPIO_InitStructure);
    
22. //PA0至0，PA0对应WK_UP按键，按下给1电平，未按给0电平//
    
23. GPIO_ResetBits(GPIOA,GPIO_Pin_0);        
    
24. //**************************************************************//
    
25. //初始化定时器5的间基结构//
    . A, i- H7 j: W8 d5 U
26. //针对TIM5_ARR寄存器，[0:15]位，取arr值，设定自动重装载寄存器的数值//
    - ^1 P, z; c1 g
27. TIM_TimeBaseStructure.TIM_Period = arr;
    5 D* m1 B+ [$ u0 X6 u# \: A( B6 v
28. //针对TIM5_PSC寄存器，[0:15]位，取psc值，设定预分频器的值//
    ! W. ^0 L7 K3 w6 c
29. TIM_TimeBaseStructure.TIM_Prescaler =psc;   
    1 v/ k9 L0 s) R2 T$ `
30. //针对TIM5_CR1寄存器，[8:9]位，CKD设00，TDTS = Tck_tim//
    $ D( a- Z; H0 _* _& f$ D
31. TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;     
    
32. //针对TIM5_CR1寄存器，[4]位，DIR设0，向上技术模式；[5:6]位，CMS设00，数器依据方向位(DIR)向上或向下计数//
    
33. TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    & q: z" Q* X2 J/ v: n  {
34. //按照上述参数初始化定时器5的时基结构//
    : F' ~" f7 `; M. j
35. TIM_TimeBaseInit(TIM5, &TIM_TimeBaseStructure);   
    
36. //**************************************************************************************//
    
37. //初始化TIM5输入捕获参数//
    3 i6 H/ s% G6 h+ ?
38. //选择通道1//
    
39. TIM5_ICInitStructure.TIM_Channel     = TIM_Channel_1;   
    1 l; c; m3 b# K4 Z8 x8 s
40. //针对TIM5_CCMR1寄存器，输入模式下，[0:1]位，CC1S设为01，即CC1通道配置为输入，IC1映射到TI1上//
    . ?" B( H- G. K7 J+ O. m. [8 C# T/ d
41. TIM5_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;  
    
42. //针对TIM5_CCMR1寄存器，输入模式下，[4:7]位，IC1F设为0000，即IC1F设为无滤波器//
    - x8 }& y& W. z2 E5 L
43. TIM5_ICInitStructure.TIM_ICFilter = 0x00;
    
44. //针对TIM5_CCMR1寄存器，输入模式下，[2:3]位，IC1PSC设为00，不分频//
    
45. TIM5_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;            
    
46. //针对TIM5_CCER寄存器，输入模式下，[1]位，CC1E设为0，即上升沿捕获//
    ; j1 @0 C+ t2 e/ N8 {1 d
47. TIM5_ICInitStructure.TIM_ICPolarity  = TIM_ICPolarity_Rising;  
    
48. //按照上述参数初始化TIM5输入捕获//
    
49. TIM_ICInit(TIM5, &TIM5_ICInitStructure);
    ) H! b6 [; ?2 [
50. //*****************************************************************************//
      j/ N8 A- t4 @
51. //TIM5中断参数初始化//
      U9 v$ N+ f  m4 u* ]
52. NVIC_InitStructure.NVIC_IRQChannel = TIM5_IRQn;                  //选择TIM5中断//
    : ^1 o# S' x: j& T0 U
53. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;        //抢占优先级2级//
    * J0 c  A7 A  }/ c5 ?6 q2 m; A/ E
54. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;               //从优先级0级//
    
55. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                  //IRQ通道被使能//
    
56. NVIC_Init(&NVIC_InitStructure);
    
57. //****************************************************************************//
    " k' }# i  v! z8 \1 ^& o5 c
58. //开启捕获中断//
    * V* o  p8 Y& F$ F
59. //针对TIM5_DIER寄存器，[0]位，UIE至1，允许更新中断；[1]位，CC1IE至1，允许捕获/比较1中断//
    - Y4 y9 o& K. i" q
60. TIM_ITConfig(TIM5,TIM_IT_Update|TIM_IT_CC1,ENABLE);   
    1 q  R: d0 d" Y1 F1 L+ u
61. //针对TIM5_CR1寄存器，[0]位，CEN至1,定时器5使能//
    
62. TIM_Cmd(TIM5,ENABLE );                                            
    
63. }
    
64. //****************************************************************************//
    
65. //下面开始编写定时器5中断服务函数//
    9 H$ p/ I. o% {1 ^
66. u8  TIM5CH1_CAPTURE_STA=0; //定义一个8位的输入捕获状态变量，初始化值为0000 0000//         
    9 H* X) q' k1 L8 U
67. u16 TIM5CH1_CAPTURE_VAL;   //定义一个16位输入捕获变量//
    ! }1 P+ l, P; V+ S. D& N
68. void TIM5_IRQHandler(void)
    
69. {
    % l5 E+ l, C+ B% Y8 H& }
70. //判断TIM5CH1_CAPTURE_STA的第7位值是否为0，即第7位为捕获完成标志//
    ( \7 X0 J1 A6 x: h: R( M5 k" {
71. //如果TIM5CH1_CAPTURE_STA的第7位值为0，则捕获未完成，if返回1，执行下述括号内代码，否则跳至最后一行代码//
    
72. if((TIM5CH1_CAPTURE_STA&0X80)==0)      
    % g  |) T  L& F
73. {      
    
74.   //更新中断函数代码，为计数器溢出时服务//
    
75.   //判断定时器5的更新中断是否发生//
    
76.   //针对TIM5_DIER寄存器，[0]位，获取UIE更新中断使能状态值；针对TIM5_SR寄存器，[0]位，获取UIF更新中断标记值//
    
77.   //当UIE为1，UIF为1，说明定时器5产生更新事件，if返回值为1，执行下述括号内代码，否则跳至捕获中断代码//
    $ u- e2 o- |+ `% e: m' B6 s+ ?
78.   if (TIM_GetITStatus(TIM5, TIM_IT_Update) != RESET)   
    
79.   {   
    ( b$ o7 L. X5 u3 u" a8 G' U" B
80.    //判断TIM5CH1_CAPTURE_STA的第6位值是否为1，即发生更新中断之前，是否已捕获到上升沿了//
    * `/ G4 A* T7 [' Z  ]. ]! O
81.    //如果TIM5CH1_CAPTURE_STA的第6位值为1，执行下述括号内代码，否则跳至捕获中断代码//     
    
82.    if(TIM5CH1_CAPTURE_STA&0X40)      
    
83.    {   
    
84.     //判断TIM5CH1_CAPTURE_STA的第0~5位值是否为0x3F，即判断溢出次数是否达到上限//
    
85.     //如果TIM5CH1_CAPTURE_STA的第0~5位值为0x3F，执行下述括号内代码，否则跳至下述else代码//
    
86.     if((TIM5CH1_CAPTURE_STA&0X3F)==0X3F)   
    
87.     {  
    % \; r' D+ w8 a: a
88.      //强制输出捕获的最大时间//
    * c( T2 I! {- ]+ a' N$ Q8 u$ J/ B
89.      //将TIM5CH1_CAPTURE_STA的第7位值至1，将TIM5CH1_CAPTURE_VAL设为0xFFFF//
    1 M% j2 z' P% T1 I5 [5 M* ^" f
90.      TIM5CH1_CAPTURE_STA|=0X80;
    ! P" a  U4 i7 g  @9 t1 F
91.      TIM5CH1_CAPTURE_VAL=0XFFFF;
    
92.     }
    
93.     //如果TIM5CH1_CAPTURE_STA的第0~5位值不为0x3F，则执行下述else代码，TIM5CH1_CAPTURE_STA值加1//
    0 x, u" H5 G5 U2 G, A" ^
94.     else TIM5CH1_CAPTURE_STA++;
    8 w- P) \7 J+ ~+ G5 H8 g
95.    }  
    2 e) \( R0 c% l& A
96.   }
    " x) t# X0 O, a: l7 k
97. //捕获中断函数代码，表示捕获到上升沿或下降沿//
    9 G/ v# @# K) E4 [! h+ A
98. //判断定时器5的捕获1中断是否发生//
    
99. //针对TIM5_DIER寄存器，[1]位，获取CC1IE捕获/比较1使能状态值；针对TIM5_SR寄存器，[1]位，获取CC1IF捕获标记值//
    8 C5 t. x* i; g9 o) U
100. //若捕获1发生捕获事件，即捕获1中断发生，则执行下述括号内代码，否则跳至最后一行代码//
     3 H2 c$ N( n/ n) W. m
101. if (TIM_GetITStatus(TIM5, TIM_IT_CC1) != RESET)
     - q% p9 @. v) }6 f0 B
102.   {
     & T2 u0 n, U$ a) s
103.    //判断TIM5CH1_CAPTURE_STA的第6位值是否为1，即判断再此之前是否已捕获到上升沿了//
     
104.    //若TIM5CH1_CAPTURE_STA的第6位值为1，则之前以捕获到上升沿，本次是下降沿，即完成一次捕获//   
     
105.    if(TIM5CH1_CAPTURE_STA&0X40)      
     
106.    {   
       i! g( Q- @. |4 Q
107.     //将TIM5CH1_CAPTURE_STA的第7位值至1//
     
108.     TIM5CH1_CAPTURE_STA|=0X80;                        
     / E4 @; I% T; E# ~: k6 A
109.     //将TIM_GetCapture1(TIM5)函数的返回值赋给TIM5CH1_CAPTURE_VAL//
     , K7 k' o+ p" s7 Q2 M6 H
110.     //针对TIM5_CCR1,获取[0:15]位的值并传至TIM5CH1_CAPTURE_VAL//
     - M  A+ E: k' n$ L# w( v: a
111.     TIM5CH1_CAPTURE_VAL=TIM_GetCapture1(TIM5);
     + O' o' T- y* |
112.     //重新配置极性，为上升沿捕获//   
     
113.     TIM_OC1PolarityConfig(TIM5,TIM_ICPolarity_Rising);     //CC1P=0 设置为上升沿捕获//
     # t; j, b) }, y+ a2 @( n6 G9 A
114.    }
     ! h& [2 s# F  m
115.    else                                                    //本次捕获的是上升沿//
     
116.    {
     * W, B# _  B, \  U; g7 X
117.     TIM5CH1_CAPTURE_STA=0;                              
     : l4 v. U2 w1 v
118.     TIM5CH1_CAPTURE_VAL=0;
     
119.     //针对TIM5_CNT计数器寄存器，[0:15]位，全设0//
     " P. g. C4 P* j# d
120.     TIM_SetCounter(TIM5,0);
     
121.     TIM5CH1_CAPTURE_STA|=0X40;                             //标记捕获到了上升沿//
     9 O7 ^* m9 U: S9 o) x
122.     TIM_OC1PolarityConfig(TIM5,TIM_ICPolarity_Falling);    //CC1P=1 设置为下降沿捕获//
     6 V/ y$ \4 W+ T6 W+ @; k7 ^2 z
123.    }      
     ; e- l; l$ E" g6 a0 D1 K8 f8 ^; c
124.   }                     
       E! O9 G& |1 |/ V" E# Q
125.   }
     
126.     TIM_ClearITPendingBit(TIM5, TIM_IT_CC1|TIM_IT_Update); //清除中断标志位
     
127. }

复制代码

8.4.3 main.c文件代码解读
# o& [) n) w2 A4 }$ o

1. #include "led.h"
   / ?; w5 P1 h+ W+ n
2. #include "key.h"
   3 y1 Z4 j6 p2 V* {; }; V5 ?
3. #include "timer.h"
   
4. #include "sys.h"
   
5. #include "delay.h"
   
6. #include "usart.h"
   6 ^. m2 K3 B  D0 r
7. //下述两个变量已在timer.c文件中申明过//
   
8. extern u8  TIM5CH1_CAPTURE_STA;                            //输入捕获状态         
   
9. extern u16 TIM5CH1_CAPTURE_VAL;                            //输入捕获值
   ! @" ]' v7 A0 h6 o& k
10. int main(void)
    
11. {  
    
12. u32 temp=0;
    ; r, o: u+ r! N0 P: u2 u9 U# h$ {
13. //设置NVIC中断分组2，即2位抢占优先级，2位响应优先级//
    8 V& F" x' H2 S( _+ ~. x
14. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);            
    7 L# J5 W6 `; h6 c) j5 a" t
15. delay_init();                                             //延时函数初始化   
    : x4 t1 R/ J2 j! a; {* v* _" J$ o
16. uart_init(115200);                                        //串口初始化为115200
    
17. LED_Init();                                               //LED端口初始化
    
18. //初始化TIM5_Cap_Init(u16 arr,u16 psc)函数，arr=0xFFFF，psc=71，即以1Mhz的频率进行计数//
    
19. //1Mhz计算来源：下述函数中，有针对TIM5_CR1寄存器[8:9]位的配置，即CKD设00，即CK_INT频率与CK_PSC频率一样//
    
20. //CK_PSC频率除以psc+1=72，即获得CK_CNT=1Mhz，为什么+1请参考STM32中文参考手册，14.4.11预分频器TIMx_PSC//
    2 X) b- {4 O* b4 n1 E
21. TIM5_Cap_Init(0XFFFF,72-1);  
    
22.   while(1)  
    # f2 E2 p/ ~$ L5 r$ Z( g
23. {
    ( ~5 m' Y+ e7 E7 M, p9 |
24.    delay_ms(10);                                       //延时10ms//  
    5 h: J- h0 i" h4 b: S: m1 E
25.    //判断TIM5CH1_CAPTURE_STA的第7位值是否为0，0x80即0b1000 0000//
      q3 h' ?$ x: X' @
26.    //如果TIM5CH1_CAPTURE_STA的第7位值为0，则if返回1，即成功捕获一次上升沿和一次下降沿，执行下述括号内代码//  
    
27.    if(TIM5CH1_CAPTURE_STA&0X80)                           
    
28.   {
    , ~' C& R& ^' s/ ~8 K8 s
29.    //将TIM5CH1_CAPTURE_STA的第[0:5]位数据传至temp中//
    
30.    temp=TIM5CH1_CAPTURE_STA&0X3F;                     
    3 l2 ^! o- e7 Z
31.    temp*=65536;                                        //temp的最小单位对应65536个计数时间总和//
    
32.    temp+=TIM5CH1_CAPTURE_VAL;                          //TIM5CH1_CAPTURE_VAL的最小单位对应1个计数时间//   
    4 }( [3 _8 a7 y8 ~! w) L
33.    printf("HIGH:%d us\r\n",temp);                      //打印总的高电平时间//
    0 }0 l2 W0 S& p0 q* V9 {
34.    TIM5CH1_CAPTURE_STA=0;                              //开启下一次捕获//
    3 P+ S+ k5 }8 h- u! t0 ^8 u2 ~
35.   }
    & k* I/ ]" u4 g% I% @  v
36. }
    
37. }

复制代码

% w6 `% R' I& P+ C' z% n8.5 定时器输入捕获实验代码缺点，从timer.c文件中也可以发现，每次捕获的上升沿至下降沿的时间间隔不能大于某个最大值（大概4秒多），否则将强制输出最大时间，并开始新一轮上升沿捕获。
4 I! Q0 r0 x* n6 [8 j9 L# k3 _$ z————————————————
- i/ Q2 y  q6 H- c( r* g' q版权声明：天亮继续睡