首先，总结全文，设计步骤主要如下：
1 V2 q' b7 m& w' b; g/ O/ W* [1，初始化GPIO
2，初始化USART1
3，初始化NVIC（嵌套向量中断控制器）
4，编写中断服务函数
4 k9 V& e' J: \& V) B- ?( e5，编写主函数
! Q* Y2 G: T% z: V) q
% w+ V& V5 c2 |) T  j详细步骤如下：
. k' }6 Q3 G7 j( [4 V
1，初始化GPIO

1. void IO_Init()
   / m" J; u1 t$ t! M1 F( ~9 _
2. {
   
3.         GPIO_InitTypeDef Uart_A;
   
4.         GPIO_InitTypeDef led;
   ) O- p0 B. H& t* u
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC| RCC_APB2Periph_AFIO,ENABLE);
   5 g( |0 W2 f6 {  \3 G1 Z: Y
6.        
   : ]8 C% y& O" G' ?5 k/ \5 F
7.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable|GPIO_Remap_SWJ_JTAGDisable,ENABLE);
   + I& p7 t. o) ?& }4 X# ~
8.        
   
9.         led.GPIO_Pin = GPIO_Pin_13;//博主开发板上的LED灯接的GPIOC的13引脚
   + i0 b- `- d; ], l
10.         led.GPIO_Mode = GPIO_Mode_Out_PP;
    $ K& `# \- L6 B) G3 o& V
11.         led.GPIO_Speed = GPIO_Speed_50MHz;
    / F7 y' B$ f/ e& D" g9 I3 G  r6 {  D
12.         GPIO_Init(GPIOC,&led);
    
13.        
    7 w( i$ g* A: V6 }7 Q
14.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    4 A/ M7 J0 u& b( R5 g5 T" m
15.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
16.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    
17.         GPIO_Init(GPIOA,&Uart_A);
    . _; L  {  X1 q% ]) X* X$ P) N# U2 ]
18.        
    , b( Z+ R- f! C% l7 j# v
19.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    ( [$ {0 g: p' U! b. l4 y
20.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    # P2 G9 t8 U+ j3 K1 g6 S9 T% n
21.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
22.         GPIO_Init(GPIOA,&Uart_A);
    
23.        
    * O0 q9 p, Q  X) G7 X& x% m
24. }

复制代码

. j  l+ N' {( m以上代码不在详细介绍，前参看STM32基础设计（1）---点亮LED灯、SEM32基础设计（2）---查询串口通信
8 ~/ r" D! ]2 h
, n# |( |1 G0 f/ q
2，初始化USART1
/ P' ]$ o/ R+ V) m0 Z! Y6 k9 I! I

1. void Usart1_Init()
   $ B3 s& p. ^: B1 f# i, ?
2. {
   # l7 v. h! P( X+ W' d3 \  H
3.         USART_InitTypeDef Uart;
   
4.        
   # _3 O5 n5 F- e) w  m
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
   
6.         Uart.USART_BaudRate = 115200;
   ) u3 ?' K+ Z: e
7.         Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
   9 a* F! g# {; l  T: C# c+ t6 m
8.         Uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
   
9.         Uart.USART_Parity = USART_Parity_No;
   2 a( x0 U( w0 G- V( \
10.         Uart.USART_StopBits = USART_StopBits_1;
    6 I, h  n0 f* V3 B1 J8 Y% [
11.         Uart.USART_WordLength = USART_WordLength_8b;
    
12.         USART_Init(USART1,&Uart);
    
13.        
    5 P4 a& N- V7 ?5 C& \: h
14.         USART_Cmd(USART1,ENABLE);
    
15.         USART_ClearFlag(USART1,USART_FLAG_TC);
      g: q) e9 i. ^$ \$ K5 O3 N
16. }

复制代码

; u0 K4 p$ t- n& v( H4 d以上代码不在详细介绍，具体请参看STM32基础设计（2）---查询串口通信
/ Z, A1 C# b: G3 v  l. h0 J

3，初始化NVIC
; I( _& E# E7 v# `0 b! A+ I首先，让我们来了解库函数中的NVIC结构体：

1. typedef struct
   % P. d/ y0 s9 r8 }
2. {//指明那个中断通道
   
3.   uint8_t NVIC_IRQChannel;                    /*!< Specifies the IRQ channel to be enabled or disabled.
   ! u" Y. q, y7 C  I& H
4.                                                    This parameter can be a value of @ref IRQn_Type
   . z( R1 M* q9 ~( Q
5.                                                    (For the complete STM32 Devices IRQ Channels list, please
   8 {6 O- `+ X0 s; m' Z1 l% i5 O
6.                                                     refer to stm32f10x.h file) */
   7 i& i3 J% {% W* z) W7 [. P
7. //抢占优先级
   
8.   uint8_t NVIC_IRQChannelPreemptionPriority;  /*!< Specifies the pre-emption priority for the IRQ channel
   , `/ O1 b; I: M! H9 M( C
9.                                                    specified in NVIC_IRQChannel. This parameter can be a value
   7 M" E& J# W7 K( o& {% C* M
10.                                                    between 0 and 15 as described in the table @ref NVIC_Priority_Table */
    - x" W) D8 y; [, X
11. //子优先级
    3 F% p2 W, Q/ U! P
12.   uint8_t NVIC_IRQChannelSubPriority;         /*!< Specifies the subpriority level for the IRQ channel specified
    ! X2 a% m( l% }- ~* @) U
13.                                                    in NVIC_IRQChannel. This parameter can be a value
    
14.                                                    between 0 and 15 as described in the table @ref NVIC_Priority_Table */
    / \8 Y. n9 G* ?" _* N
15. //中断通道使能
    
16.   FunctionalState NVIC_IRQChannelCmd;         /*!< Specifies whether the IRQ channel defined in NVIC_IRQChannel
    " y  C0 k  U$ ]7 z; B- n
17.                                                    will be enabled or disabled.
    & p# q  x) W  ~  p8 y9 p
18.                                                    This parameter can be set either to ENABLE or DISABLE */   
    
19. } NVIC_InitTypeDef;

复制代码

% e( U! @  y. @/ G) E了解了这个结构体后，就可以在初始化函数中定义这个变量了

; h: C# g' X4 Q2 J* k! Z- m% ?

1. NVIC_InitTypeDef nvic;

复制代码

另外在NVIC初始化中还设置优先级分组（哪怕只有一个中断也要分组，这是规定）。具体使用这个库函数：

3 V  S  H) t2 ~: v# }2 `# g

1. void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
   
2. {
   
3.   /* Check the parameters */
   
4.   assert_param(IS_NVIC_PRIORITY_GROUP(NVIC_PriorityGroup));
   : L* |* m+ d- o6 |1 j" p/ x
5.   
   - e! e# ^' l6 U8 h) q: s
6.   /* Set the PRIGROUP[10:8] bits according to NVIC_PriorityGroup value */
   " V$ c  @3 h+ L3 \
7.   SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
   
8. }

复制代码

, }" b( |8 Q+ M接下来，设置结构体中变量的值：
( u6 d; |, I2 D0 r! Q' H

1. nvic.NVIC_IRQChannelPreemptionPriority = 1;//抢占优先级
   
2. nvic.NVIC_IRQChannelSubPriority = 0;//子优先级
   
3. nvic.NVIC_IRQChannel = USART1_IRQn;//中断通道
   
4. nvic.NVIC_IRQChannelCmd = ENABLE;//通道使能
     Y$ M* P* @5 v
5. NVIC_Init(&nvic);//NVIC寄存器初始化

复制代码

) D& F- ^6 y  n4，编写中断服务函数
先贴代码，在解释
. L" E$ y% r8 L" w& g/ K1 X8 l

1. void USART1_IRQHandler(void)//注意，这个函数名必须这样写，否则进不了USART1中断。详见库函数中的  IRQn_Type 结构体
   
2. {
   ; R0 r: r( T$ g! p- M8 G+ R8 b  U
3.         char temp= '0';
   3 }9 t% f" b5 U0 ?0 t* |* v0 U* w1 f9 I' q
4.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)//判断是否接收到数据
   
5.         {
   
6.                 temp = USART1->DR;//如果接收到数据，就将其读出，这样才可将RXNE寄存器清除
   
7.                 if(temp == 'G')//如果接收到G  则关灯
   % }, E$ Q$ L  i$ s. n* b8 |' U3 F
8.                 {
   
9.                         GPIOC->BRR = GPIO_Pin_13;
     B  }# b$ P( V0 R
10.                 }else if(temp == 'K')//开灯
    , q# |2 P5 \9 s7 S# X3 K
11.                 {
    
12.                         GPIOC->BSRR = GPIO_Pin_13;
    $ n* P! e/ h+ I4 \; v: j: K
13.                 }
    9 b7 j5 H: [) x6 S' Y
14.         }
    " e, K4 E  s+ i# u; ]) F
15.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')//如果发送寄存器为空，即可以发送数据
    ) m2 ?0 k+ G$ {4 L6 [7 L# w; F
16.                 {
    
17.                         USART1->DR = temp;将接收到的数据再发送回去
    ; d2 `0 \8 g3 O0 h  o, H) T( N
18.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));等待数据发送完毕
    
19.                 }
    0 H% x* b. F" n& N2 T: A
20. }

复制代码

3 d5 A; P- Q' ~$ o( W5，编写主函数
7 T- ^; V/ R* L! Q老规矩，先贴代码再解释：

1. int main()
   
2. {
   
3.         IO_Init();
   
4.         Usart1_Init();
   9 Z  e, \, N1 j/ l& t! E
5.         Nvic_Init();
   / l2 D% ]1 M6 l7 `$ \( C) n
6.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);//这里是打开串口的接收中断，以便在USART1收到数据时，进入中断函数。这里特别提一下，现在不用打开发送中断，只有在准备发送数据时才应打开，否则会直接进入中断函数。
   
7.         GPIOC->BSRR = GPIO_Pin_13;
   + R; m* e' g  \6 T" B0 E9 `
8.         while(1){}
   : |1 m. G) I1 j0 a/ Y( l6 F
9. }

复制代码

! U: f2 q) k# L+ ?8 l额。。。突然发现没什么好解释的。

" A$ y$ S) H2 L! i3 f& |中断串口通信介绍到此完毕。

7 u* z) n' d. v/ g+ Z本文完整代码如下：
9 O5 X3 Q6 H" u" H" C% x. g

1. #include<stm32f10x.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4. void delay(uint n)
   8 W3 n2 Y! C9 M7 U( E% n# N
5. {
   ; O$ i# I" W* |2 W) N* y& k0 P
6.         int i,j;
   8 q6 K( m( v8 w- q2 p. h) j
7.         for(i=0;i<n;i++)
   
8.         for(j=0;j<8500;j++);
   
9. }
   
10. 
    ; O$ d% s5 I, v( @3 `5 C3 ^& X
11. void IO_Init()
    
12. {
    
13.         GPIO_InitTypeDef Uart_A;
      R$ ^: c$ J6 t
14.         GPIO_InitTypeDef led;
    ; ^7 e7 l/ H. W0 f1 Z' Y# e
15.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC| RCC_APB2Periph_AFIO,ENABLE);
    * {0 e' a$ B- N+ q$ i; Z
16.        
    0 O" q- G% Z: Y1 d
17.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable|GPIO_Remap_SWJ_JTAGDisable,ENABLE);
    
18.        
    
19.         led.GPIO_Pin = GPIO_Pin_13;
    / u! P0 E; F6 d4 n( `
20.         led.GPIO_Mode = GPIO_Mode_Out_PP;
    
21.         led.GPIO_Speed = GPIO_Speed_50MHz;
    / y! _1 E  R3 M/ l1 R
22.         GPIO_Init(GPIOC,&led);
    
23.        
    , a% m* c6 U7 [$ D
24.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    . _3 x8 E* x  j$ `$ a
25.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
26.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    - o! A. P  h1 n4 L7 m0 N8 y
27.         GPIO_Init(GPIOA,&Uart_A);
    
28.        
      r5 Z" b0 Q7 I: K! k$ y
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);
    ( Z& _8 G: `9 M/ |
33.        
    
34. }
    
35. void Usart1_Init()
    
36. {
    ) C3 u3 Z1 r* a2 n
37.         USART_InitTypeDef Uart;
    , h2 I% A5 E, w& t0 E. D3 v
38.        
    
39.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    % N1 p+ t2 E1 Z* O6 S" Q7 [
40.         Uart.USART_BaudRate = 115200;
      j$ ~8 h& D4 X6 {: h
41.         Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
42.         Uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
43.         Uart.USART_Parity = USART_Parity_No;
    - U; v7 [$ v/ u
44.         Uart.USART_StopBits = USART_StopBits_1;
    + X% R! C+ O- R! \7 N6 D
45.         Uart.USART_WordLength = USART_WordLength_8b;
    ) [0 I. b& i3 {9 c
46.         USART_Init(USART1,&Uart);
    
47.        
    % l% z7 F2 j8 F' K" _8 o0 _- u) I
48.         USART_Cmd(USART1,ENABLE);
    
49.         USART_ClearFlag(USART1,USART_FLAG_TC); //page 540
    , V: }8 D% R( W% @: n0 ~
50. }
    
51. void Nvic_Init()
    ; y& i: }) O' l5 p" a% M- X
52. {
    7 F/ Q% {* f% ^
53.         NVIC_InitTypeDef nvic;
    
54.        
    
55.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    8 k+ A0 g8 H* H3 M
56.        
    / Q" P* r3 A) g9 y+ x
57.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    9 A! u- B+ h& j4 w6 b
58.         nvic.NVIC_IRQChannelSubPriority = 0;
    
59.         nvic.NVIC_IRQChannel = USART1_IRQn;
    7 j: x: y* Y1 g) k' O3 e
60.         nvic.NVIC_IRQChannelCmd = ENABLE;
    
61.         NVIC_Init(&nvic);
    3 S3 E8 M+ u6 ]7 X$ E; }
62. }
    0 E% [5 E; E, ]
63. 
    
64. int main()
    : C* P+ ]. x+ J9 Z0 J6 G+ E
65. {
    , P/ g1 N9 ]( M) M+ k% o; A
66.         IO_Init();
    
67.         Usart1_Init();
    
68.         Nvic_Init();
    3 {' P" V5 d- @  \# l; \5 w5 m( m
69.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
    $ t# k: H7 i: F1 Z5 d; l# \
70.         GPIOC->BSRR = GPIO_Pin_13;
    
71.         while(1){}
    8 v2 r5 U. A7 A7 E/ p1 Y
72. }
    
73. 
    
74. void USART1_IRQHandler(void)
    
75. {
    
76.         char temp= '0';
    2 o4 G' s; k* }& O8 `4 U, o
77.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)
    
78.         {
      O9 u0 D$ {0 e! i5 P+ @" ^, ]
79.                 temp = USART1->DR;
    , ~3 C3 K/ j. g& ]
80.                 if(temp == 'G')
    
81.                 {
    
82.                         GPIOC->BRR = GPIO_Pin_13;
    $ O! R+ Z8 t5 X, a$ y: E
83.                 }else if(temp == 'K')
    
84.                 {
    
85.                         GPIOC->BSRR = GPIO_Pin_13;
    
86.                 }
    , ?: [# Y  l* K3 W" J0 H
87.         }
    
88.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')
    
89.                 {
    
90.                         USART1->DR = temp;
    
91.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));
    0 I6 J6 b: N  z& B* l5 N$ L
92.                 }
    : h# G/ v& f# q* L) K0 w; C
93. }

复制代码

0 Q* D1 H! T7 D0 ?1 e3 t
( A9 U8 A7 l1 w3 Y. d+ l( _————————————————
% t+ f- x# b; a( B/ d: [版权声明：家安
7 Q( c8 F1 i  j  b