中断的概念： 中断是当单片机的CPU在执行程序时，外部或内部发生了一个随机事件，导致CPU暂时中断正在执行的程序，转去执行一段特殊的服务程序也就是中断服务子程序或中断处理程序。当处理完服务程序后，返回到被中断的程序继续执行，这样的一个过程就被称为中断，引发这个中断的事件被称为中断源。中断在stm32中还被分为相应的优先级，低优先级的中断会被高优先级中断所中断，即为中断的嵌套。在Crotex-M3内核中支持256个中断，其中包含16个内核中断以及240个外部中断。STM32F10X芯片中只用了其中的84个中断通道，包含16个内核中断和68个可屏蔽中断。
中断的优先级： STM32的每个中断通道都有一个中断优先级控制字节（8位二进制数据，可设置为0~255，数值越小，优先级越高。在STM32F103中只用其中高4位数据），其用于表达优先级的高4位又被分为抢占式优先级和响应式优先级。在抢占式优先级相同情况下，高响应优先级的中断优先被响应。优先级相同时，按照中断响应的顺序执行服务程序，越靠前的先执行。中断的相关功能需要通过NVIC（嵌套向量中断器）来配置。
0 e, ^6 _0 i+ {+ V2 A1 S( n8 ~中断的配置： 首先使能某个外设中断；然后设置中断优先级分组，初始化NVIC_InitTypeDef结构体，设置抢占优先级和响应优先级，使能中断请求；最后编写中断服务函数。
1 x1 z  ]' t9 z
: I$ Y# T; g% D1、外部中断编程
. K4 c; d* v# ?9 u1.1 EXTI的结构
在STM32F10X芯片中外部中断/事件控制器（EXTI）有20个用于产生中断/事件请求的边沿检测器，其对应的每一根输入线都可以单独进行配置，选择“中断”或“事件”类型以及触发事件（上升沿触发、边沿触发和下降沿触发），还可以对中断开启屏蔽。外部中断/事件控制器（EXTI）的结构如下图中所示：

+ ~2 q$ L# L4 K4 H
. k0 T: M& ]* U; z7 m# l7 Y5 \
8 o, w6 k# V$ }( c+ m0 M/ a. W$ vEXTI主要有两个功能，一个用来产生中断，另一个被用来产生事件。
  z0 E% T0 D7 |; ^! z! ~6 z（1）产生中断的线路由输入线开始，经边沿检测电路，到一个或门电路再到一个与门电路，最后至NVIC中断控制器结束。输入线可以通过寄存器设置为任何一个GPIO引脚，也可以是外设的时间，在这部分主要是传递一个电平变化的信号；边沿检测电路可以对触发方式进行选择，有上升沿触发、下降沿触发以及边沿触发三种方式；或门电路使得中断不仅可以由外部电路进行触发也可以通过软件来启动中断/事件；与门电路用来决定是否产生中断，只有中断屏蔽寄存器端和或门电路端的有效信号均为1时，中断才会被产生；最后将挂起寄存器内容输入到NVIC中，实现系统中断事件的控制。
: M. E% s2 Y$ q1 X+ y（2）产生事件的前三步与（1）相同，后经过一个与门电路，再经过一个脉冲发生器电路后结束。其中与门电路是用来决定是否产生事件，只有事件屏蔽寄存器端和或门电路端的有效信号均为1时，事件才会被产生；脉冲发生器电路只有在与门电路为有效信号1时才会输出一个脉冲信号；脉冲信号可被用于其他外设电路的使用，如定时器、ADC等等。
3 x+ t2 q8 `$ S$ D' B: @从EXTI框图中可以看出，中断的输出是NVIC控制器，从而会导致系统运行中断服务函数，处于软件层面；时间的输出是脉冲信号流向其他外设电路，处于硬件层面。
' E/ m. R/ ?6 G# R% Q8 l# n/ X
" r2 }9 x+ H" R, N% i5 q1.2 外部中断/事件线 映射
STM32F10X的EXTI对用连接的外设如下表中所示：
- G4 N4 @$ a% c1 ]' l3 L


4 ^8 z* K3 y6 |  k# u" J从表中可以看出EXTI可供外部IO使用的中断线有16根，但STM32F103芯片的IO口数量却有很多，每个GPIO端口均有16个管脚对应了16根中断线。中断线每次只能连接在一个IO口上，因此就需要用到外部中断的映射功能，通过AFIO（复用IO）的外部中断配置寄存器1的EXTIx[3:0]位来决定对应的中断线映射到哪个GPIO端口上。对于中断映射到GPIO端口的配置函数在stm32f10x_gpio.c和stm32f10x_gpio.h中，所以在使用标准库进行开发时需要将这两个文件添加到工程中。
# c/ e8 P! c: ~) r* F: F
1.3 外部中断/事件线 映射
EXTI相关的库函数在stm32f10x_exti.c和stm32f10x_exti.h文件中，使用库函数对外部中断进行配置的步骤如下：

3 R5 C9 S' @% L+ @  ]1.使能IO口时钟，配置IO模式为输入；
1 m) z) }- u% X* ?2.开启AFIO时钟，设置IO口与中断线的映射关系；
首先需要使能AFIO时钟，其是挂载在APB2总线上的；
! Y/ ^/ I" r) ~. @, ?  i8 w, t

1. RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);

复制代码

. R% ^1 |) s2 Q' m+ _然后将GPIO映射到对应的中断线上；
& H4 C3 |* c9 `6 {0 j) h
! I: y# F( b# Y1 |) }

1. GPIO_EXTILineConfig(GPIO_PortSourceGPIOx, GPIO_PinSourceY]);//Y是0~15号中断线

复制代码

- k5 i  J  ]- L5 h' C5 Z  y9 B/ Q配置中断分组（NVIC），使能中断；
# ?4 F/ F/ m4 U# O% r. t

1. NVIC_InitTypeDef NVIC_InitStructure;
   " J! D! ]. V! Z) ?1 H) V* I
2. NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;                        //EXTI0 中断通道
   . I2 v/ K5 b% g: Y" a
3. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;                //抢占优先级
   / G3 {% c! ^" S
4. NVIC_InitStructure.NVIC_IRQChannelSubPriority =3;                         //子优先级
   
5. NVIC_Init(&NVIC_InitStructure);

复制代码

初始化EXTI，选择触发方式；
; s9 d' Z4 y- z配置好NVIC后就需要对中断线上的中断进行初始化，需要调用void EXTI_Init(EXTI_InitTypeDef* EXTI_InitStruct)函数，其中结构体EXTI_InitTypeDef的成员变量有：

1. typedef struct
   4 k  K" ^$ [% f' D4 p/ R
2. {
   $ U. G+ W; P% B  a+ g: x
3.         uint32_t EXTI_Line;                                 //中断/事件线
   . ^! t. X& C, P0 U# m3 l3 u
4.         EXTIMode_TypeDef EXTI_Mode;                 //EXTI模式
   ( p- I. p' M# b5 D$ r! F
5.         EXTITrigger_TypeDef EXTI_Trigger;         //EXTI 触发方式
   8 b' s% P- J2 a' A
6.         FunctionalState EXTI_LineCmd;                 //中断线使能或失能
   
7. }

复制代码

) m9 a! Q4 b, e' U% @0 KEXTI_Line： 可配置参数为EXTI0~EXTI20；
EXTI_Mode： 可配置为EXTI_Mode_Interrupt（中断模式）和EXTI_Mode_Event（事件模式）；
EXTI_Trigger： 可配置为EXTI_Trigger_Rising（上升沿触发）、EXTI_Trigger_Falling（下降沿触发）以及EXTI_Trigger_Rising_Falling（边沿触发）；
EXTI_LineCmd： 配置ENABLE为使能，DISABLE为失能。
5. 编写EXTI中断服务函数
中断服务函数就是当外部中断发生后，需要执行的一段用户程序，可根据需求进行编写。
4 s: O- A6 ?7 _9 V  e8 z
1.4 应用示例
在本小节中使用一个按键来触发外部中断，在服务函数中执行点亮LED的程序，这个功能是很简单的，但也能够解释清楚外部中断的配置过程，详细的代码如下所示（其中LED文件的代码在上一章节中已经给出）：
exit.h

1. #ifndef _exti_H
   
2. #define _exti_H
   
3. 
   6 B' E' R$ C7 K3 f) _& l
4. #include "system.h"
   # [. }8 S) B& y0 y' [3 D
5. void MY_EXTI_Init(void);
   " ~5 l, o8 R) d$ B+ J4 a" M
6. 
   
7. #endif

复制代码

exit.c
, P% Q: L8 r# N
( w* ]( t) z% b2 D1 O

1. #include "exti.h"
   
2. #include "SysTick.h"
   
3. #include "key.h"
   5 l6 D: H& P, o0 T6 A2 H( l
4. #include "led.h"
   - n  K) B- w$ w6 S1 N( o
5. void MY_EXTI_Init()
   
6. {
   
7.         NVIC_InitTypeDef NVIC_InitStructure;
   
8.         EXTI_InitTypeDef EXTI_InitStructure;
   
9.         
   + q, }9 U* M' h; j6 p
10.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
    . z- f" q9 L1 ^  B$ B. i0 O' w
11.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource0);
    ! @4 c$ s& l3 O4 t* _
12.         
    , }! A0 O% }  ]8 s
13.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOE,GPIO_PinSource2);
    
14.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOE,GPIO_PinSource3);
    
15.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOE,GPIO_PinSource4);
    5 a& P& U: H0 ~8 l
16.         
    
17.         NVIC_InitStructure.NVIC_IRQChannel=EXTI0_IRQn;
    & W9 C, v- ]3 @! J7 ?. i( |
18.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;
    
19.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=3;
      X$ C8 d) [4 B" Z
20.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
21.         NVIC_Init(&NVIC_InitStructure);
    
22.         
    % F; y& b& v" A) Y3 w3 |- H8 E
23.         NVIC_InitStructure.NVIC_IRQChannel=EXTI2_IRQn;
    + |8 d* P- I! m8 v  m/ \) ?
24.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;
    * j" q- m% [/ L8 o" _/ z
25.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=2;
    4 G8 C$ {3 d: T% D2 S8 J1 i+ T. c2 h
26.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    % X3 L# C- D+ J$ @& c! J0 y7 Q9 i
27.         NVIC_Init(&NVIC_InitStructure);
    ( D1 _8 `% m" f4 N/ L9 T
28.         
    ) f/ z) V- |2 S# s' O
29.         NVIC_InitStructure.NVIC_IRQChannel=EXTI3_IRQn;
    ; ]3 S1 f0 y  T5 N& V, n. W
30.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;
    & v; {4 x: Y# I' p% [9 A
31.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
    
32.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
33.         NVIC_Init(&NVIC_InitStructure);
    & \. t8 C( x8 i# v3 e
34.         
    
35.         NVIC_InitStructure.NVIC_IRQChannel=EXTI4_IRQn;
    # J  P2 ?8 r' F# s  g! `% g
36.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;
    
37.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0;
    6 ?2 G) O* W# \
38.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
39.         NVIC_Init(&NVIC_InitStructure);
    , N, W; v5 b- F; N9 Q  @1 ]
40.         
    9 m0 ~7 c; _7 W, ~; j; R
41.         EXTI_InitStructure.EXTI_Line=EXTI_Line0;
    $ o% G  e! Z9 k( Q. x: i9 H: \/ Y
42.         EXTI_InitStructure.EXTI_LineCmd=ENABLE;
    7 S# |, }' R  ~' r4 Q, ^2 Y' i
43.         EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
    # \, @+ y6 _% K
44.         EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Rising;
    $ Z& ?! \3 h/ }& d: e1 K0 e, B: H3 t
45.         EXTI_Init(&EXTI_InitStructure);
    - _( \* L) {7 @% _
46.         
    
47.         
    
48.         EXTI_InitStructure.EXTI_Line=EXTI_Line2|EXTI_Line3|EXTI_Line4;
    , N3 p* f: e( R1 Q! W$ Q" O
49.         EXTI_InitStructure.EXTI_LineCmd=ENABLE;
    : L& O& d- |' c9 N$ {2 N
50.         EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
    
51.         EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Falling;
    - n  Y5 }' ?" U
52.         EXTI_Init(&EXTI_InitStructure);
    
53.         
    
54. }
    
55. void EXTI0_IRQHandler()
    
56. {
    
57.         if(EXTI_GetFlagStatus(EXTI_Line0)==1)
    
58.         {
    - x1 j  `6 S- E- i8 U9 n% a: O
59.                 delay_ms(10);
    " k; H! v9 D: V; k: k0 K
60.                 if(K_UP==1)
    1 v* u; k: N! X' v+ U
61.                 {
    # B: R* M' J' F" u7 S4 }1 p8 ]
62.                         led2=0;
    
63.                 }        
    9 x0 u  r' W5 ~, ?& f& T
64.         }
    " T1 G; B: E2 C6 `7 b
65.         EXTI_ClearITPendingBit(EXTI_Line0);
    1 y* S; E  f$ {. t
66. }
    2 V! j% b  \' w( ?3 C5 P
67. void EXTI2_IRQHandler()
    
68. {
    ; J& B. `2 P) X7 Y7 C
69.         if(EXTI_GetFlagStatus(EXTI_Line2)==1)
    
70.         {
    
71.                 delay_ms(10);
    
72.                 if(K_LEFT==0)
    % F6 j" E, b9 M
73.                 {
    5 e7 h  f, P. G, Q
74.                         led3=1;
    + q: @; V! J9 n& j
75.                 }        
    
76.         }
    
77.         EXTI_ClearITPendingBit(EXTI_Line2);
    
78. }
    
79. void EXTI3_IRQHandler()
    2 g4 P- s% S- ^( W. Y
80. {
    
81.         if(EXTI_GetFlagStatus(EXTI_Line3)==1)
    
82.         {
    5 \9 v8 ?- l( R. N) z# P
83.                 delay_ms(10);
    
84.                 if(K_DOWN==0)
    
85.                 {
    
86.                         led2=1;
    ) Y1 B6 n0 a7 N& H. i% W7 _
87.                 }        
    
88.         }
    
89.         EXTI_ClearITPendingBit(EXTI_Line3);
    
90. }
    
91. void EXTI4_IRQHandler()
    $ @, E# d  \+ Z1 s% L8 u7 y% Q8 r( S
92. {
    
93.         if(EXTI_GetFlagStatus(EXTI_Line4)==1)
    
94.         {
      i8 O1 i: f0 m, u
95.                 delay_ms(10);
    ( D/ F5 a* j7 s* I
96.                 if(K_RIGHT==0)
    
97.                 {
    ( Z# c4 t. E" @% C- F
98.                         led3=0;
    
99.                 }        
    
100.         }
     1 P& L( y. K9 F' Z' y$ c6 U
101.         EXTI_ClearITPendingBit(EXTI_Line4);
     
102. }

复制代码

3 O% |! U/ i, Pkey.h
6 W9 W) a7 c5 c( U, U/ X
: j+ E. ?9 k2 T

1. #ifndef _key_H
   8 j. {3 i6 ~& G
2. #define _key_H
   
3. 
   
4. #include "system.h"
   
5. 
   
6. #define KEY_UP_Pin                 GPIO_Pin_0
   4 u& _. x9 j* {
7. #define KEY_LEFT_Pin         GPIO_Pin_2
     q' y4 `6 ^& D7 i( N4 S
8. #define KEY_DOWN_Pin         GPIO_Pin_3
   / E4 K2 i2 A% J! R: G& p1 b* f% n
9. #define KEY_RIGHT_Pin         GPIO_Pin_4
   
10. 
    % V3 {2 S0 P6 r7 d' V+ I
11. #define KEY_UP_PORT         GPIOA
    ! q7 v: n3 o8 g" k
12. #define KEY_PORT                 GPIOE
    
13. 
    
14. #define K_UP PAin(0)
    
15. #define K_DOWN PEin(3)
    
16. #define K_LEFT PEin(2)
    
17. #define K_RIGHT PEin(4)
    , q7 \  }2 [1 m% B; |! ]) n
18. 
    - \- {1 N! h& y  i, e9 k
19. #define KEY_UP 1
    
20. #define KEY_LEFT 3
    0 F% r+ f) E  M& t
21. #define KEY_DOWN 2
    
22. #define KEY_RIGHT 4
    + e, j0 {5 c- m
23. 
    : s7 u! z# {: Z9 p# U' ^) K. ~' B
24. void KEY_Init(void);
    
25. u8 KEY_Scan(u8 mode);
    4 S  e+ R0 z8 E6 D
26. 
    + C, y& P8 K! y1 q. F9 e
27. #endif
    . C# R# a( w+ |4 |

复制代码

key.c

1. #include "key.h"
   7 X6 o& p6 M0 M' R
2. #include "SysTick.h"
   ) P& u* T* c. y5 B; _; O- @7 A4 a
3. void KEY_Init()
   # u9 I7 K% C0 A7 C% X
4. {
   ! B/ c9 }4 p! J  t$ U- v9 y
5.         GPIO_InitTypeDef GPIO_InitStructure;
   
6.         
   6 U3 B2 w% D+ q- C: I
7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOE,ENABLE);
   
8.         
   
9.         GPIO_InitStructure.GPIO_Pin=KEY_UP_Pin;
   
10.         
    
11.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPD;
    * _+ C0 B7 b( l
12.         
    ' C5 R( ?+ A; E+ d  D
13.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    7 c2 d4 X) Y4 f
14.         
    
15.         GPIO_Init(KEY_UP_PORT,&GPIO_InitStructure);
    
16.         
      u5 w& o, [# W2 @. b) a
17.         
    
18.         GPIO_InitStructure.GPIO_Pin=KEY_LEFT_Pin|KEY_DOWN_Pin|KEY_RIGHT_Pin;
    
19.         
    9 G) I% @/ h9 c1 w8 W9 M
20.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
    - Y+ c+ e! T' s
21.         
    $ _, _; r) j8 f/ t# _5 n$ A
22.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    
23.         
    
24.         GPIO_Init(KEY_PORT,&GPIO_InitStructure);
    5 W' ?$ h* ~4 \) F
25. }
    
26. 
    # [: I; d' F* @5 d  O, w" I
27. 
    
28. u8 KEY_Scan(u8 mode)
    7 N5 V/ l9 G0 J: w8 N
29. {
    
30.         static u8 key=1;
    . `# m1 Z! Z  _
31.         if(key==1&&(K_UP==1||K_DOWN==0||K_LEFT==0||K_RIGHT==0))
    
32.         {
    . N+ V( ^3 g3 h, g- p5 R3 }
33.                 delay_ms(10);
    
34.                 key=0;
    
35.                 if(K_UP==1)
    
36.                 {
    3 [) @/ t( W& _
37.                         return KEY_UP;
    
38.                 }
    
39.                 else if(K_DOWN==0)
    
40.                 {
    
41.                         return KEY_DOWN;
    
42.                 }
    / _: @9 t8 ]8 F7 v0 b3 u6 N6 S: H
43.                 else if(K_LEFT==0)
    ) O: M* q0 P( i9 w* ~. f6 i; V
44.                 {
    
45.                         return KEY_LEFT;
    
46.                 }
    
47.                 else if(K_RIGHT==0)
    
48.                 {
    
49.                         return KEY_RIGHT;
    : o% R- w$ u& q5 f1 T* D
50.                 }
    
51.         }
    
52.         else if(K_UP==0&&K_DOWN==1&&K_LEFT==1&&K_RIGHT==1)
    
53.         {
    * `, v+ u+ J0 D, j& U. C: ?0 w
54.                 key=1;
    
55.         }
    6 y- i/ a) ^$ M
56.         if(mode==1)
    3 a0 l; c+ p6 Z6 D8 y7 p5 p
57.         {
    
58.                 key=1;
    % ^' L* t" t) J( B
59.         }
    ! O5 w& R1 b, K
60.         return 0;
    
61. }

复制代码

main.c
; @, l6 S" E7 x5 g0 c2 S
9 J9 K; \4 Q: \2 \- I, J; F

1. #include "system.h"
   
2. #include "led.h"
   
3. #include "SysTick.h"
   # d. R8 i- i' Z/ y  i: Z
4. #include "exti.h"
   * I1 ?4 x2 }9 Y% a8 s- D! |0 ^- {( j
5. #include "key.h"
   
6. 
   ( W6 c$ G' I6 ]9 r
7. u8 i=0;
   
8. int main()
   
9. {
   % Q! H/ f9 W9 U# m1 x$ K" c7 }
10.         SysTick_Init(72);
    3 d2 V( {2 G( ?1 {- R8 g0 l7 P
11.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    . T$ y2 I" S2 }& Q  a# }' }0 i
12.         MY_EXTI_Init();
    9 _. E# |" S$ l1 G7 u: D7 ]
13.         LED_Init();
    
14.         KEY_Init();
    + q! V- |: O! O: ?. ^1 O
15.         
    
16.         while(1)
    
17.         {
    
18.                 i++;
    3 E! ~& F, f+ X7 D# s" j
19.                 if(i%20==0)
    
20.                 {
    
21.                         led1=!led1;
    + V8 D/ X) e1 u
22.                 }
    ) d/ Q: e* K" o" a* B4 U
23.                 delay_ms(10);
    
24.         }
    
25. }

复制代码

5 \$ f* \% X! V% X+ d7 b8 X2、 定时器中断编程
; B3 K+ q1 [# k  X0 zSTM32F1的定时器系统由2个基本定时器（TIM6、TIM7）、4个通用定时器（TIM2~TIM5）和2个高级定时器（TIM1、TIM8）所组成。基本定时器同51单片机内的定时器类似，功能较为简单；通用定时器在其基础上增加了输入捕获与输出比较功能；高级定时器又在通用定时器基础上增加了可编程死去互补输出、重复计数、带刹车（断路）的功能主要针对于工业电机的控制。
& P) h$ w% p# o
$ R2 X. y, R! P2.1 通用定时器
STM32F1的通用定时器内有一个16位自动重载计数器（CNT）由可编程预分频器（PSC）驱动，其可用于测量输入信号的脉冲宽度（输入捕获）或者生产输出波形（输出比较和PWM）。使用定时器预分频器和RCC时钟控制器预分频器，脉冲长度和波形周期可以在几微秒到几毫秒之间调整，此外每一个定时器都是独立的，之间不互相共享任何资源。通用定时器TIM2~TIM5具备如下功能：

( A& A! p$ m1 _( Q8 d1 b5 i1 b1 a1.16位向上、向下、向上/向下自动装载计数器（TIMx_CNT）;
& o9 \' l3 A8 ~3 J7 J1 B2 K. Y2 n2.16位可编程预分频器，计数器时钟频率的分频系数为1~65535；
/ n0 w) ~+ {% n) c& k  H; m" H6 f- m3.4个独立通道（TIMx_CH1~4）,通道可以被用作输入捕获、输出比较、PWM生成和单脉冲模式输出功能；
4.可以使用外部信号（TIMx_ETR）控制定时器，可实现多个定时器互连的同步电路；
5.发生更新（计数器溢出、初始化）、触发时间（计数器启动、停止、初始化或者由内部/外部触发计数）、输入捕获以及输出比较事件时会产生中断/DMA请求；
4 W; n5 L8 H: `6.支持针对定位的增量（正交）编码器和霍尔传感器电路
7.触发输入作为外部时钟或者按周期的电流管理。
2.2 定时器配置步骤
8 l: @; i+ _( Y$ F定时器相关的库函数在stm32f10x_tim,c和stm32f10x_tim.h文件中，使用库函数对定时器进行配置的详细步骤如下：
2 f9 ?4 U, Y+ X( h
1.使能定时器时钟；
定时器是挂载在APB1总线上的设备，因此使能定时器可以调用函数：
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIMx, ENABLE);

$ [2 X) O0 v! ?2.初始化定时器参数，包含了自动重装值，分频系数，计数方式等；
调用函数：void TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct);
TIM_TimeBaseInitTypeDef为一个结构体类型，包含了定时器初始化的成员变量：
' [1 _/ r$ i- q

1. typedef struct
   
2. {
   
3.         uint16_t TIM_Prescaler;                        //定时器预分频器
   7 w. H# b1 o+ E  O: e0 x
4.         unit16_t TIM_CouterMode;                //计数模式
   
5.         unit16_t TIM_Period;                        //定时器周期
   $ D6 E) Q1 h* v- w! a$ C# ]  X3 u3 ~
6.         unit16_t TIM_ClockDivision;                //时钟分频
   . L$ A* \- z& h: u/ m
7.         unit8_t TIM_RepetitionCounter;        //重复计数器
   
8. }

复制代码

TIM_Prescaler： 时钟源经过该预分频器后输出的是定时器时钟，设置范围为0~65535；
8 u/ `- E6 l: a9 ~/ fTIM_CouterMode： 可设置为TIM_CounterMode_Up（向上）、TIM_CounterMode_Down（向下）以及中心对齐计数模式；
TIM_Period：设置定时器自动重载计数值，范围为0~65536；
TIM_ClockDivision： 时钟分频因子，设置定时器时钟CK_INT频率与数字滤波器采样时钟频率分频比；
TIM_RepetitionCounter： 重复计数器，简单的控制PWM输出个数。
8 a7 N3 }/ P1 ^# H# G
3.设置定时器中断类型，使能定时器；
调用函数：void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState);
% {9 a0 L& W2 p8 \) Y  I* tTIM_IT 用来设置定时器中断类型，包含TIM_IT_Update（更新中断）、TIM_IT_Trigger（触发中断）以及输入捕获中断等等；
: g/ H* G) j' w- ^) l  `  ZFunctionalState 用来使能或使能定时器中断，ENABLE和DISABLE。

4.设置定时器中断优先级，使能定时器中断通道；
+ q+ e% \$ T8 `6 Q1 j' Z8 Y对NVIC初始化，如前一节中所示。
& F2 X0 x- t& S  F% o3 G/ o3 O
5.开启定时器；
9 r4 e* E" w# b% z调用函数：void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState);

6.编写定时器中断服务函数
由于定时器中断类型有很多，因此在中断服务函数中需要通过状态寄存器的值来判断此次中断属于哪一种类型，然后再执行相应的用户程序。

2.3 应用示例
* H+ w9 R. L0 q* f  X  L本次实验通过TIM4定时器的更新中断控制LED灯实现不断闪烁的功能，详细的代码如下所示；
time.h
5 l0 F1 g( A4 c8 W) ^% a- k

1. #ifndef _time_H
   
2. #define _time_H
   
3. 
   $ \! \0 b1 Q( o: C$ m0 O
4. #include "system.h"
   2 L% R* j2 `  t  L
5. 
   
6. void TIM4_Init(u16 pre,u16 psc);
   6 b& I* [$ A7 y! y9 ?4 f
7. 
   
8. #endif

复制代码

) ^9 G4 F- q2 Y9 m- E9 m" U2 D/ \; Q: ftime.c

1. #include "time.h"
   
2. #include "led.h"
   
3. 
   $ }4 ~, I$ N, v# |$ P1 r( K2 X
4. void TIM4_Init(u16 pre,u16 psc)
   6 f. u& j$ N8 W7 L6 q5 y5 V% s
5. {
   
6.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
   ) _: |- q, N4 }  A' K% q
7.         NVIC_InitTypeDef NVIC_InitStructure;
   ; C& g5 [1 g6 ^( K8 A5 H$ _$ ]
8.         
   ' h1 s; ~) z2 z2 }
9.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4,ENABLE);
   3 ~. I1 x2 n% y( H6 C) `
10.         
    8 x( M. J  D7 v' m1 D! ?0 `# `
11.         TIM_TimeBaseInitStructure.TIM_Period=pre;//ÖÜÆÚ
    0 ~' D) p/ ~+ w* j8 b& R
12.         TIM_TimeBaseInitStructure.TIM_Prescaler=psc;
    ! u) o& _5 \- u& [/ @
13.         TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    , U! F  p6 Z- ]: w% S
14.         TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up;
    
15.         TIM_TimeBaseInit(TIM4,&TIM_TimeBaseInitStructure);
    
16.         
    + r) G: X( z4 T6 B4 [# A
17.         TIM_ITConfig(TIM4,TIM_IT_Update,ENABLE);
    ( a: B& t+ n7 A: M) [$ J
18.         TIM_ClearITPendingBit(TIM4,TIM_CounterMode_Up);
    
19.         
    
20.         NVIC_InitStructure.NVIC_IRQChannel=TIM4_IRQn;
    
21.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;
    ) u0 d4 w( C' \# m6 g- [
22.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=3;
    
23.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    
24.         NVIC_Init(&NVIC_InitStructure);
    " Y4 E! v1 c) H' h5 N
25.         
    3 H! I+ G- y6 u5 J- f& s9 l
26.         TIM_Cmd(TIM4,ENABLE);
    
27.         
    9 I6 g" S7 x% j8 L/ o4 c
28. }
    + _0 w6 K, [, K
29. void TIM4_IRQHandler(void)
    ; K; J9 A( E7 w+ N
30. {
    ' T! [% [& r" c- H
31.         if(TIM_GetITStatus(TIM4,TIM_IT_Update)==1)
    5 O. P/ b* b& C! o' P
32.         {
    
33.                 led2=!led2;
    
34.         }
    
35.         TIM_ClearITPendingBit(TIM4,TIM_IT_Update);
    
36. }

复制代码

5 C9 ^6 M9 U' j/ ]main.c

( w) |6 m: W" j# F. H, p

1. #include "system.h"
   : q3 M$ ]7 \0 Y" M* g% b9 {
2. #include "led.h"
   
3. #include "SysTick.h"
   
4. #include "time.h"
   
5. 
   
6. u8 i=0;
   
7. 
   ( I+ C! U7 j2 E9 i
8. int main()
   4 \3 X1 H! f! X  B( z* F
9. {
   
10.         SysTick_Init(72);
    
11.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
12.         LED_Init();
    
13.         TIM4_Init(1000,36000-1);//500ms
    / }; p5 y. B3 l' M3 g. s9 U
14.         
    0 G; N' {8 B$ w" F/ e: Y; O
15.         
    
16.         while(1)
    . ]# d: {% B5 j. g
17.         {
    
18.                 i++;
    
19.                 if(i%20==0)
    & l) x% d; T& |# e& n
20.                 {
    5 N0 V. g6 i: B( m$ Y3 }5 f" m
21.                         led1=!led1;
    
22.                 }
    
23.                 delay_ms(10);
    
24.         }
    
25. 
    7 ~* h# G* M& Z* A  ]
26. }

复制代码

" }. l+ G6 W+ n, i
3 p8 _! h0 b# N7 g) h9 H% [6 R