首先，总结全文，设计步骤主要如下：
' I+ X! s; P6 T' ~; r! \+ n7 n1，初始化GPIO
2，初始化USART1
* _1 t, C( S2 a3，初始化NVIC（嵌套向量中断控制器）
1 W( ]! x! _# z( l5 V# [- h' z4，编写中断服务函数
5，编写主函数
4 q1 v2 t5 w" t
详细步骤如下：
/ O4 F; Y4 b, O" Z0 [
1 m4 ?" g# B0 l8 T* d" x% i8 x* _1，初始化GPIO

1. void IO_Init()
   ' C' ~% K0 b# m# S
2. {
   
3.         GPIO_InitTypeDef Uart_A;
   ' C& K' f* A: c4 R
4.         GPIO_InitTypeDef led;
   4 T9 c$ s+ a, A) L8 [
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC| RCC_APB2Periph_AFIO,ENABLE);
   / C/ g2 c% g/ E4 _3 t
6.        
   
7.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable|GPIO_Remap_SWJ_JTAGDisable,ENABLE);
     Q( g  r8 {/ u4 l! F+ g
8.        
   
9.         led.GPIO_Pin = GPIO_Pin_13;//博主开发板上的LED灯接的GPIOC的13引脚
   ' ^# l' j: P. Y9 N* H2 ?2 ^
10.         led.GPIO_Mode = GPIO_Mode_Out_PP;
    
11.         led.GPIO_Speed = GPIO_Speed_50MHz;
    
12.         GPIO_Init(GPIOC,&led);
    & @  Y: l3 v0 L
13.        
    8 u  f& s. @3 Y; `: p+ r1 h
14.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    : w! i6 D1 q& A! z: H+ J: C  |
15.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
16.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    ' B+ m8 ^  \, o# `1 S# ?6 Q
17.         GPIO_Init(GPIOA,&Uart_A);
    
18.        
    
19.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    ! n; S! g7 r& v' C2 x
20.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    6 n+ k$ O$ p8 L5 s2 i
21.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    0 r! j& i5 M4 f, E
22.         GPIO_Init(GPIOA,&Uart_A);
    
23.        
    8 Y' D: |3 \% J* L9 }5 q
24. }

复制代码

) k8 M& m& n3 E+ {* m+ C以上代码不在详细介绍，前参看STM32基础设计（1）---点亮LED灯、SEM32基础设计（2）---查询串口通信

3 }( _6 @" g  N+ O4 j3 E  u
4 n" C" G- l$ d) H" w8 m* r/ n$ T$ d5 w2，初始化USART1

1. void Usart1_Init()
   9 f3 B' _4 J) }* q3 [
2. {
   8 h: e, t+ K& B% i' p
3.         USART_InitTypeDef Uart;
   
4.        
   ! w" d: p3 k. Z9 A) u# \/ Q
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
   & B) @# l  u8 M6 f
6.         Uart.USART_BaudRate = 115200;
   * j0 ~3 }! f* `- L, |
7.         Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
   / [# ^: n7 u& s$ D; u. \- w
8.         Uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
   
9.         Uart.USART_Parity = USART_Parity_No;
   ) i. [/ X" m* j/ [
10.         Uart.USART_StopBits = USART_StopBits_1;
    / A, u4 i1 q7 r$ w# t( I, x4 w1 H- K
11.         Uart.USART_WordLength = USART_WordLength_8b;
    
12.         USART_Init(USART1,&Uart);
    
13.        
    8 i% f; n/ Y4 X/ o1 f* x
14.         USART_Cmd(USART1,ENABLE);
    " h2 u; X0 `1 `% h
15.         USART_ClearFlag(USART1,USART_FLAG_TC);
    & j  B" t% x( |, {' u
16. }

复制代码

以上代码不在详细介绍，具体请参看STM32基础设计（2）---查询串口通信


) W! j, l6 ?, W) C) ?7 a3，初始化NVIC
首先，让我们来了解库函数中的NVIC结构体：
. m* y9 e+ ?  F. h

1. typedef struct
   
2. {//指明那个中断通道
   9 W. t0 y' U- S; e9 i+ \6 O, N! U
3.   uint8_t NVIC_IRQChannel;                    /*!< Specifies the IRQ channel to be enabled or disabled.
   3 U; q4 S% v6 g- M  n
4.                                                    This parameter can be a value of @ref IRQn_Type
   
5.                                                    (For the complete STM32 Devices IRQ Channels list, please
   
6.                                                     refer to stm32f10x.h file) */
   
7. //抢占优先级
   ) |: c) Q8 Y; ]
8.   uint8_t NVIC_IRQChannelPreemptionPriority;  /*!< Specifies the pre-emption priority for the IRQ channel
     E' y' W( T& D) r2 Y6 r7 e  ?( K
9.                                                    specified in NVIC_IRQChannel. This parameter can be a value
   & i" l0 a0 O/ ?
10.                                                    between 0 and 15 as described in the table @ref NVIC_Priority_Table */
    
11. //子优先级
    8 H9 W% _/ o2 n  R& W
12.   uint8_t NVIC_IRQChannelSubPriority;         /*!< Specifies the subpriority level for the IRQ channel specified
    
13.                                                    in NVIC_IRQChannel. This parameter can be a value
    / e+ Q, G5 P, Z* I& A, N
14.                                                    between 0 and 15 as described in the table @ref NVIC_Priority_Table */
    
15. //中断通道使能
    
16.   FunctionalState NVIC_IRQChannelCmd;         /*!< Specifies whether the IRQ channel defined in NVIC_IRQChannel
    - E- z4 |7 Q  Q9 `
17.                                                    will be enabled or disabled.
    2 }3 s/ f  u  V% D# b/ {/ k
18.                                                    This parameter can be set either to ENABLE or DISABLE */   
    
19. } NVIC_InitTypeDef;

复制代码

了解了这个结构体后，就可以在初始化函数中定义这个变量了
) b* P8 A# O$ j* U. F: ~

1. NVIC_InitTypeDef nvic;

复制代码

另外在NVIC初始化中还设置优先级分组（哪怕只有一个中断也要分组，这是规定）。具体使用这个库函数：
, k% o0 a0 Q9 d1 }, d5 |
2 s# Y! v1 F6 `( p* s

1. void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
   ; q9 b  B% E* f' i, |2 q
2. {
   : z; V& [1 v( Y2 p7 b) a: ~. K8 Q
3.   /* Check the parameters */
   
4.   assert_param(IS_NVIC_PRIORITY_GROUP(NVIC_PriorityGroup));
   
5.   
   
6.   /* Set the PRIGROUP[10:8] bits according to NVIC_PriorityGroup value */
   6 E) o* J0 ~# T2 c8 `3 D2 Y( Y( G
7.   SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
   8 G7 N4 n) [, P, @: Q1 m) N
8. }

复制代码

接下来，设置结构体中变量的值：
( Z5 E0 i& o5 Q7 P: C# F5 D( u1 Y

1. nvic.NVIC_IRQChannelPreemptionPriority = 1;//抢占优先级
   
2. nvic.NVIC_IRQChannelSubPriority = 0;//子优先级
   4 _1 v# N8 p' x# Z/ K
3. nvic.NVIC_IRQChannel = USART1_IRQn;//中断通道
   ! o! h8 ?4 H! R6 `5 }. \8 p
4. nvic.NVIC_IRQChannelCmd = ENABLE;//通道使能
   1 b: q" Y% c  A) `
5. NVIC_Init(&nvic);//NVIC寄存器初始化

复制代码

4，编写中断服务函数
( J2 X, f' c( ~7 f# I/ j先贴代码，在解释

1. void USART1_IRQHandler(void)//注意，这个函数名必须这样写，否则进不了USART1中断。详见库函数中的  IRQn_Type 结构体
   9 N  B; G- l3 A$ X0 h# ?1 ^+ S0 b
2. {
   & L( i, R! y/ ~$ f1 ~
3.         char temp= '0';
   4 f* C0 O6 A! h/ t( S
4.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)//判断是否接收到数据
   4 s' V1 [# T2 N( M
5.         {
   * v( ?( [$ Y4 p7 C( T( g
6.                 temp = USART1->DR;//如果接收到数据，就将其读出，这样才可将RXNE寄存器清除
   
7.                 if(temp == 'G')//如果接收到G  则关灯
   
8.                 {
   
9.                         GPIOC->BRR = GPIO_Pin_13;
   
10.                 }else if(temp == 'K')//开灯
    # J) l( {+ h$ L( L
11.                 {
    ' |2 M) Q9 c! p
12.                         GPIOC->BSRR = GPIO_Pin_13;
    5 @9 ?9 M; H" X
13.                 }
    : k9 @, u" P( ~: J( W2 `4 L
14.         }
    - [2 H% `5 l2 @8 X( A) c5 z& r
15.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')//如果发送寄存器为空，即可以发送数据
      P/ K5 b2 B! |% W6 X; I
16.                 {
      p( ~3 P/ R. R4 C) `$ ^
17.                         USART1->DR = temp;将接收到的数据再发送回去
    
18.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));等待数据发送完毕
    - I( V4 g; |% j" w* s) {) v
19.                 }
    
20. }

复制代码

5，编写主函数
老规矩，先贴代码再解释：

1. int main()
   
2. {
   
3.         IO_Init();
   
4.         Usart1_Init();
   
5.         Nvic_Init();
   , o3 E, Q7 i' w) Z) i8 c
6.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);//这里是打开串口的接收中断，以便在USART1收到数据时，进入中断函数。这里特别提一下，现在不用打开发送中断，只有在准备发送数据时才应打开，否则会直接进入中断函数。
   8 y2 y, C1 B/ q: q! c
7.         GPIOC->BSRR = GPIO_Pin_13;
   0 |& F3 l1 l& y" @5 H2 B# z
8.         while(1){}
   
9. }

复制代码

4 `8 Q% Z/ F% A1 R* i+ p$ z8 r+ P6 a额。。。突然发现没什么好解释的。
# A2 q, T* Y5 a& C  s* x% ]
中断串口通信介绍到此完毕。

本文完整代码如下：

1. #include<stm32f10x.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4. void delay(uint n)
   
5. {
   
6.         int i,j;
   
7.         for(i=0;i<n;i++)
   . W0 E" Y' c: p& l
8.         for(j=0;j<8500;j++);
   . p/ R/ `4 y8 M: V% b' g$ u
9. }
   - X/ q; F* Y, z$ ]. d8 {
10. 
    4 O, M7 R; L6 k7 C/ S
11. void IO_Init()
    
12. {
    8 j: Z* Q% z/ `) D
13.         GPIO_InitTypeDef Uart_A;
    , u+ g+ t4 o! R( A
14.         GPIO_InitTypeDef led;
    
15.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC| RCC_APB2Periph_AFIO,ENABLE);
    
16.        
    # e& [% d) k* i4 g2 L
17.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable|GPIO_Remap_SWJ_JTAGDisable,ENABLE);
    * E1 ~1 L6 P6 ?: b3 P* l/ F& k
18.        
    * l* ?0 W8 X1 v: O' P
19.         led.GPIO_Pin = GPIO_Pin_13;
    
20.         led.GPIO_Mode = GPIO_Mode_Out_PP;
    8 Z1 \3 P: K: \- X
21.         led.GPIO_Speed = GPIO_Speed_50MHz;
    , I3 Y+ i! g9 B7 G* H
22.         GPIO_Init(GPIOC,&led);
    
23.        
    4 Q% ~% K1 }7 g6 t$ X3 V: t1 x4 c' X
24.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    " Q. i2 z- h; X3 @6 ?
25.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    : c3 d2 t3 W& J1 E) ]. _1 Z' j
26.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    7 U/ X0 B/ d7 j  z1 z/ u: R
27.         GPIO_Init(GPIOA,&Uart_A);
    % ]8 f  E- O1 w5 x- @% v. s9 l
28.        
    
29.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    4 b0 i$ R9 P9 r" @; a/ I: O
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.        
    ( ?1 l& E9 o, t4 P8 {
34. }
    " ^- T1 K+ v# }9 F
35. void Usart1_Init()
    - }; G0 i: d7 V
36. {
    
37.         USART_InitTypeDef Uart;
    1 l+ a% |5 V! }
38.        
    & O% v# ~% l) E+ P9 m
39.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    
40.         Uart.USART_BaudRate = 115200;
    
41.         Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
42.         Uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
43.         Uart.USART_Parity = USART_Parity_No;
    ; l( F2 A/ o  B3 s5 K
44.         Uart.USART_StopBits = USART_StopBits_1;
    
45.         Uart.USART_WordLength = USART_WordLength_8b;
    ; L# n6 q& a; P& ~9 j
46.         USART_Init(USART1,&Uart);
    2 g1 t; P4 Z2 c$ b& w! W# Y, j: t- N
47.        
    
48.         USART_Cmd(USART1,ENABLE);
    
49.         USART_ClearFlag(USART1,USART_FLAG_TC); //page 540
    
50. }
    ! R' X/ o& e$ G. b
51. void Nvic_Init()
    
52. {
    
53.         NVIC_InitTypeDef nvic;
    8 m! R! U9 d; r: y5 b9 P3 l( |
54.        
    
55.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    / E8 Y4 P( H! W! I5 }' g  m, V
56.        
    0 R, f( R) }, H% g( W& y3 h$ O
57.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    / V& w0 P4 B; b) o$ ]9 J- g
58.         nvic.NVIC_IRQChannelSubPriority = 0;
    
59.         nvic.NVIC_IRQChannel = USART1_IRQn;
    & X5 h2 r7 N  D1 Z& S
60.         nvic.NVIC_IRQChannelCmd = ENABLE;
    4 D- o6 c/ R5 a* g
61.         NVIC_Init(&nvic);
    ) X$ \6 Z1 q% q
62. }
    
63. 
    & r- n. f4 E$ w% D* K0 x6 `1 E8 j% E* J
64. int main()
    9 S4 ^* ^) J6 H; ]/ R7 i
65. {
    & u' X# r# m) l$ B8 Y
66.         IO_Init();
    , ~" W1 ~8 K2 H' B
67.         Usart1_Init();
    ( k1 t: A2 `. f% o( O2 i# {. l( {
68.         Nvic_Init();
    2 M, X+ t; \  U# z9 B6 i
69.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
    
70.         GPIOC->BSRR = GPIO_Pin_13;
    / B6 D3 _$ T6 X) l. z- I5 O5 S3 b
71.         while(1){}
    0 o2 l) P6 N" L
72. }
    - `/ `8 x0 a& r3 d9 Y4 c2 s
73. 
    
74. void USART1_IRQHandler(void)
    " N! I7 V. F4 C8 g$ r# H6 m
75. {
    
76.         char temp= '0';
    6 C( n( x) u" E1 L6 M2 J/ m
77.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)
    ! t! H/ i# P) }6 b- n+ ?8 I
78.         {
    2 G# u0 A% M. X7 i% {
79.                 temp = USART1->DR;
    
80.                 if(temp == 'G')
    $ i( H2 f" ], M$ q
81.                 {
    
82.                         GPIOC->BRR = GPIO_Pin_13;
    
83.                 }else if(temp == 'K')
    
84.                 {
    - _$ O* v3 M" E6 {: j( W4 `# b
85.                         GPIOC->BSRR = GPIO_Pin_13;
    
86.                 }
    
87.         }
    7 V4 s" ^- x3 ]  @0 k4 b
88.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')
    - j5 x+ f# v" c: P" e* R' t( z6 P
89.                 {
    , y/ S+ S& V  @: |
90.                         USART1->DR = temp;
    
91.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));
    % r. A( Z  s4 e
92.                 }
    
93. }

复制代码

————————————————
版权声明：家安
$ b4 K, e$ d: r8 ~6 c* |
% U6 L5 [- q' J9 z* D  y$ {
0 O" [: |% T  ]$ W* s