首先，总结全文，设计步骤主要如下：
1，初始化GPIO
2，初始化USART1
3，初始化NVIC（嵌套向量中断控制器）
4，编写中断服务函数
& t, ~- Y! |/ b0 d0 j8 B! K5，编写主函数

详细步骤如下：

' ~& H5 B3 h. C, e! w1，初始化GPIO
2 P8 B* J# M- I

1. void IO_Init()
   . H/ H! f; N8 d" D* D
2. {
   
3.         GPIO_InitTypeDef Uart_A;
   
4.         GPIO_InitTypeDef led;
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC| RCC_APB2Periph_AFIO,ENABLE);
   
6.        
   % E& H5 A% c7 i* ]  E. }( B% Y
7.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable|GPIO_Remap_SWJ_JTAGDisable,ENABLE);
   
8.        
   
9.         led.GPIO_Pin = GPIO_Pin_13;//博主开发板上的LED灯接的GPIOC的13引脚
   
10.         led.GPIO_Mode = GPIO_Mode_Out_PP;
    
11.         led.GPIO_Speed = GPIO_Speed_50MHz;
    7 Z. z! ]. w0 W0 y# i, }* w2 E
12.         GPIO_Init(GPIOC,&led);
    
13.        
    
14.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    9 V4 Y/ U2 i. s7 M% x# }, ^; Y
15.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    * i: R1 v+ W- h( _
16.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    
17.         GPIO_Init(GPIOA,&Uart_A);
    # A& ?& P% K5 W2 ]
18.        
    
19.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    
20.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    3 n9 V- \8 _$ T# b; l
21.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
22.         GPIO_Init(GPIOA,&Uart_A);
    / g& L. f  r5 `/ ^6 a
23.        
    , N3 y* m, M# b( i& A0 ]8 W9 Z
24. }

复制代码

( h6 h- p3 p$ Z) E以上代码不在详细介绍，前参看STM32基础设计（1）---点亮LED灯、SEM32基础设计（2）---查询串口通信
  m# \# f1 P6 e5 M# a9 ?
9 L# c0 ?3 r  e) A% r% T  {
$ @1 d7 b; N& g5 C! `: `5 e8 q2 ~9 y2，初始化USART1

1. void Usart1_Init()
   0 _; s; D9 O& w2 n8 O, |
2. {
   
3.         USART_InitTypeDef Uart;
   6 G/ S* W* C: E! c" d  V$ L
4.        
   3 H, I. B9 c- p" Q' M) N. b
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
   - s" J) \( Q( _6 ^. J+ L
6.         Uart.USART_BaudRate = 115200;
   9 k/ c8 T" @0 h' S" y
7.         Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
   
8.         Uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
   
9.         Uart.USART_Parity = USART_Parity_No;
   ' X/ i$ ]3 p8 n# b
10.         Uart.USART_StopBits = USART_StopBits_1;
    2 v9 f) w% M) V9 X
11.         Uart.USART_WordLength = USART_WordLength_8b;
    
12.         USART_Init(USART1,&Uart);
    $ V7 G( E7 B0 L. [( j3 _! ], r) R5 U* `- n
13.        
    * b! Z) ~3 o9 y+ _
14.         USART_Cmd(USART1,ENABLE);
    
15.         USART_ClearFlag(USART1,USART_FLAG_TC);
    
16. }

复制代码

. M0 `( L: n$ o( g7 T- u6 V以上代码不在详细介绍，具体请参看STM32基础设计（2）---查询串口通信
5 ]% N2 O, |0 F1 {. l

: n. w8 \3 N, F1 F8 W2 Q/ a3，初始化NVIC
9 p; s* o$ p* D+ z2 l* o首先，让我们来了解库函数中的NVIC结构体：
( V, H: _/ B2 ^& E" k  r

1. typedef struct
   
2. {//指明那个中断通道
   
3.   uint8_t NVIC_IRQChannel;                    /*!< Specifies the IRQ channel to be enabled or disabled.
   8 U' W8 L! R8 y2 I, g9 M
4.                                                    This parameter can be a value of @ref IRQn_Type
   
5.                                                    (For the complete STM32 Devices IRQ Channels list, please
   ( A  G0 e, D5 L
6.                                                     refer to stm32f10x.h file) */
   + s1 h' O1 e& u4 H
7. //抢占优先级
   " [  r2 d/ \! A! ]7 ^
8.   uint8_t NVIC_IRQChannelPreemptionPriority;  /*!< Specifies the pre-emption priority for the IRQ channel
   0 ?9 K+ b6 E8 Y' k2 ]: Q* }
9.                                                    specified in NVIC_IRQChannel. This parameter can be a value
   & b0 y0 s/ w2 M7 S- a& r* e# b% l/ Y& l
10.                                                    between 0 and 15 as described in the table @ref NVIC_Priority_Table */
    / T; Q% F, N3 g3 F, G3 b
11. //子优先级
    
12.   uint8_t NVIC_IRQChannelSubPriority;         /*!< Specifies the subpriority level for the IRQ channel specified
    / t) F6 X4 U9 e
13.                                                    in NVIC_IRQChannel. This parameter can be a value
    
14.                                                    between 0 and 15 as described in the table @ref NVIC_Priority_Table */
    . w" g- [: q8 N+ e# n- a
15. //中断通道使能
      j6 R3 [8 x& J- Q$ e5 |6 @& n) T
16.   FunctionalState NVIC_IRQChannelCmd;         /*!< Specifies whether the IRQ channel defined in NVIC_IRQChannel
    1 o/ X" d. J% G2 J; a
17.                                                    will be enabled or disabled.
    
18.                                                    This parameter can be set either to ENABLE or DISABLE */   
    7 A: W5 w6 |7 f$ y( R+ _0 |! b
19. } NVIC_InitTypeDef;

复制代码

( L% ?3 k, d, u1 R了解了这个结构体后，就可以在初始化函数中定义这个变量了

1. NVIC_InitTypeDef nvic;

复制代码

9 Z$ o$ g6 G6 E4 w# k另外在NVIC初始化中还设置优先级分组（哪怕只有一个中断也要分组，这是规定）。具体使用这个库函数：
& \' r  Q3 v3 O  j! K

1. void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
   
2. {
   & R0 g# |  I" t8 L2 c+ y
3.   /* Check the parameters */
   " w; Q; Z( m' V& j4 Z. J* ^6 c
4.   assert_param(IS_NVIC_PRIORITY_GROUP(NVIC_PriorityGroup));
   & Z- d/ o4 D/ F3 D1 d! N. h% R
5.   
     d' h7 O' g, g( [/ c6 |
6.   /* Set the PRIGROUP[10:8] bits according to NVIC_PriorityGroup value */
   & {% V- Y8 B) {+ o9 e. J; C5 {) ~/ v* h
7.   SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
   5 u( Y  b5 y. F$ h) v" S  b
8. }

复制代码

' f8 E7 E. A) w/ f) F2 h8 ]& k接下来，设置结构体中变量的值：
/ s/ z2 K1 Q2 S# d* l

1. nvic.NVIC_IRQChannelPreemptionPriority = 1;//抢占优先级
   
2. nvic.NVIC_IRQChannelSubPriority = 0;//子优先级
   2 s1 u) J6 B' W  ?
3. nvic.NVIC_IRQChannel = USART1_IRQn;//中断通道
   3 r( q. I, f1 Y9 y+ N0 L
4. nvic.NVIC_IRQChannelCmd = ENABLE;//通道使能
   
5. NVIC_Init(&nvic);//NVIC寄存器初始化

复制代码

4，编写中断服务函数
; F# t7 p8 k* x# L1 T先贴代码，在解释
, L4 e' ?* g+ v- }0 C* s' e/ r% _

1. void USART1_IRQHandler(void)//注意，这个函数名必须这样写，否则进不了USART1中断。详见库函数中的  IRQn_Type 结构体
   ( F; \# l4 [% J$ n
2. {
   
3.         char temp= '0';
   ( E- ]  a9 P- ~: v7 e
4.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)//判断是否接收到数据
   
5.         {
   
6.                 temp = USART1->DR;//如果接收到数据，就将其读出，这样才可将RXNE寄存器清除
   
7.                 if(temp == 'G')//如果接收到G  则关灯
   
8.                 {
   : A) P5 X! i* H/ b/ [7 }
9.                         GPIOC->BRR = GPIO_Pin_13;
   
10.                 }else if(temp == 'K')//开灯
    ; Q6 b$ }' j- Y- q2 {& d' F$ L, a
11.                 {
    ! @6 j' B! O4 V1 N2 K' k
12.                         GPIOC->BSRR = GPIO_Pin_13;
    ) Z' f4 n, i" R6 z1 J
13.                 }
    ' T+ A5 n5 ^( h' E2 r
14.         }
    6 X5 y+ d' A5 ^' H" t1 q
15.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')//如果发送寄存器为空，即可以发送数据
    
16.                 {
    
17.                         USART1->DR = temp;将接收到的数据再发送回去
    : W3 p8 }, @3 f% P2 b7 I
18.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));等待数据发送完毕
    4 d2 P; z4 `, J# R3 R
19.                 }
    
20. }

复制代码

% y& i/ @0 ^# g6 H, [0 S/ w/ s5，编写主函数
老规矩，先贴代码再解释：

1. int main()
   
2. {
   
3.         IO_Init();
   - u" x9 d5 T, P8 T0 W+ G
4.         Usart1_Init();
   4 G6 n6 T5 l" M9 b9 P
5.         Nvic_Init();
   8 x7 @+ _" O% E$ ~6 ~8 \
6.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);//这里是打开串口的接收中断，以便在USART1收到数据时，进入中断函数。这里特别提一下，现在不用打开发送中断，只有在准备发送数据时才应打开，否则会直接进入中断函数。
   
7.         GPIOC->BSRR = GPIO_Pin_13;
   
8.         while(1){}
   , b& X( X9 O- Z; n( H
9. }

复制代码

额。。。突然发现没什么好解释的。

! Z: ^& X1 c5 |1 @- N中断串口通信介绍到此完毕。
' \; z4 r& i* {$ J  _7 `9 t* W
' a; F' ~  [1 J本文完整代码如下：

1. #include<stm32f10x.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4. void delay(uint n)
   
5. {
   4 m8 ?& _. d' @6 ^8 ~
6.         int i,j;
   
7.         for(i=0;i<n;i++)
   4 \$ j2 Z- h* q% l, v
8.         for(j=0;j<8500;j++);
   
9. }
   " M4 ?2 `" m3 L! p4 O' {- n, J
10. 
    3 y# o, }4 s# D
11. void IO_Init()
    $ C( v. W1 x+ c% T' n& X
12. {
    + N3 ?5 R8 f6 s9 }: W
13.         GPIO_InitTypeDef Uart_A;
    
14.         GPIO_InitTypeDef led;
    
15.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC| RCC_APB2Periph_AFIO,ENABLE);
    
16.        
    
17.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable|GPIO_Remap_SWJ_JTAGDisable,ENABLE);
    
18.        
    
19.         led.GPIO_Pin = GPIO_Pin_13;
    0 Z6 l# [8 w+ v0 m4 W! |
20.         led.GPIO_Mode = GPIO_Mode_Out_PP;
    
21.         led.GPIO_Speed = GPIO_Speed_50MHz;
    / F: L3 k9 ^' H
22.         GPIO_Init(GPIOC,&led);
    
23.        
    
24.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    
25.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
26.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    
27.         GPIO_Init(GPIOA,&Uart_A);
    
28.        
    # b' e0 H8 m+ }# D: J, v
29.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    
30.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
31.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING; //page 110
    
32.         GPIO_Init(GPIOA,&Uart_A);
    
33.        
    
34. }
    2 b; S, x( D  D: q: U/ p/ j# ?
35. void Usart1_Init()
    
36. {
    4 w6 _, x$ k. _7 e' z8 `
37.         USART_InitTypeDef Uart;
    
38.        
    3 t& W8 j# F4 }1 W7 Y
39.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    & |7 @6 S7 `4 H9 U
40.         Uart.USART_BaudRate = 115200;
    & @* W! h1 l; {' q0 s" K
41.         Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
42.         Uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
43.         Uart.USART_Parity = USART_Parity_No;
    ! J) X" {2 r6 M1 V0 l
44.         Uart.USART_StopBits = USART_StopBits_1;
    - l. v2 L- }% n+ C
45.         Uart.USART_WordLength = USART_WordLength_8b;
    
46.         USART_Init(USART1,&Uart);
    6 f1 m5 `- |: g2 x  e
47.        
    
48.         USART_Cmd(USART1,ENABLE);
    
49.         USART_ClearFlag(USART1,USART_FLAG_TC); //page 540
    
50. }
    - l) h1 l' _* O4 s
51. void Nvic_Init()
    
52. {
    7 C: A! I; W7 Z
53.         NVIC_InitTypeDef nvic;
    
54.        
    ) T1 u) O  o. c" c3 @4 d
55.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    / P: x- U6 K) K8 R! f3 W% e1 r) `
56.        
    
57.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    ! X, I* G8 X) r
58.         nvic.NVIC_IRQChannelSubPriority = 0;
    
59.         nvic.NVIC_IRQChannel = USART1_IRQn;
    7 `' P  M/ S2 n
60.         nvic.NVIC_IRQChannelCmd = ENABLE;
    * X/ X( X3 x! a6 E: u+ _
61.         NVIC_Init(&nvic);
    $ N7 B' t/ W) h
62. }
    % C" ~3 b& p; Y$ \: W) E' P3 Q
63. 
    0 ?/ `# m1 A2 ]+ J! _
64. int main()
    
65. {
    
66.         IO_Init();
    
67.         Usart1_Init();
    
68.         Nvic_Init();
    7 F& Q$ l* U4 K6 [
69.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
    7 b* A  E$ g; y; v, N8 S
70.         GPIOC->BSRR = GPIO_Pin_13;
    
71.         while(1){}
    
72. }
    7 g: I, ]1 Y4 b2 y: ~+ r: d
73. 
    
74. void USART1_IRQHandler(void)
    . {7 m, u& m5 k. _8 l# q
75. {
    5 [. K8 z5 H4 S
76.         char temp= '0';
    
77.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)
    ' p3 h2 B$ \' \2 P3 i$ T' d
78.         {
    & F" N9 ?* X' P* t
79.                 temp = USART1->DR;
    
80.                 if(temp == 'G')
    8 d% s2 S2 U6 i) S3 [0 c
81.                 {
    
82.                         GPIOC->BRR = GPIO_Pin_13;
    ' l" f' J/ {6 T$ x2 n9 g0 Q
83.                 }else if(temp == 'K')
    
84.                 {
    
85.                         GPIOC->BSRR = GPIO_Pin_13;
    " @) _" }' @# ]" _9 q/ G1 ?+ X
86.                 }
    
87.         }
    
88.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')
    % W: B+ U: a0 I- P( v
89.                 {
    " ]% S& X8 G$ x' G* P: ~+ D1 D" K
90.                         USART1->DR = temp;
    ( Y7 G5 b8 @$ k. p9 N: a$ F
91.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));
    1 b- k2 e% s  B: |7 H8 H1 C# J/ n
92.                 }
    : n' ~' N2 S! ]* U( \2 n
93. }

复制代码

————————————————
9 m) `+ m! T" V4 X# h  y版权声明：家安
% q1 e# ]' f- x+ V8 {8 V
6 `2 W4 G9 `& T' D
- g0 m. K4 f2 b1 z6 {. \