首先，总结全文，设计步骤主要如下：
1，初始化GPIO
# d; t. P+ D, Y, c! w2，初始化USART1
3，初始化NVIC（嵌套向量中断控制器）
4，编写中断服务函数
5，编写主函数

: E0 v+ V# Q& p+ i4 J( g详细步骤如下：
, z/ t; E* M. v% s' z' F- W$ H% |
1，初始化GPIO
. x) t8 e! m" e' x

1. void IO_Init()
   . B4 p6 P) @6 J9 j6 U
2. {
   ! y% ]7 i2 n: }1 I: y
3.         GPIO_InitTypeDef Uart_A;
   7 G7 u, n2 L7 j3 k4 ?; p# J, x
4.         GPIO_InitTypeDef led;
   & Q" X" H; P9 t1 z7 U
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC| RCC_APB2Periph_AFIO,ENABLE);
   " }! L9 t: C9 X
6.        
   
7.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable|GPIO_Remap_SWJ_JTAGDisable,ENABLE);
   
8.        
   0 g& ^$ R$ b& S8 i6 R* v9 b
9.         led.GPIO_Pin = GPIO_Pin_13;//博主开发板上的LED灯接的GPIOC的13引脚
   5 a2 a, {9 ~7 [7 t
10.         led.GPIO_Mode = GPIO_Mode_Out_PP;
    
11.         led.GPIO_Speed = GPIO_Speed_50MHz;
    ; q" s- T9 \( E' X) z
12.         GPIO_Init(GPIOC,&led);
    
13.        
    2 y  m# {' u' |2 E) H$ C1 w
14.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    * K2 Q) R2 C: |7 p. k) }; |( H
15.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
16.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    
17.         GPIO_Init(GPIOA,&Uart_A);
      B  E$ i, @( B; n
18.        
    1 N. F, m' }7 p( I# }
19.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    / d, }' v0 e3 N  R1 X
20.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
21.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
22.         GPIO_Init(GPIOA,&Uart_A);
    
23.        
    * ~( x( z. E. S6 P* A% J
24. }

复制代码

6 P% S, v6 L( p2 e9 f) N7 {以上代码不在详细介绍，前参看STM32基础设计（1）---点亮LED灯、SEM32基础设计（2）---查询串口通信


2，初始化USART1

1. void Usart1_Init()
   + e- {: T5 f8 V' R8 p0 y
2. {
   
3.         USART_InitTypeDef Uart;
   . n. M% t( d# T7 Y* R
4.        
   8 B  v1 y; }8 i8 j: Y" u
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
   
6.         Uart.USART_BaudRate = 115200;
   
7.         Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
   
8.         Uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
   
9.         Uart.USART_Parity = USART_Parity_No;
   * l+ `2 N0 ?, }2 H
10.         Uart.USART_StopBits = USART_StopBits_1;
    
11.         Uart.USART_WordLength = USART_WordLength_8b;
    0 \3 u8 W1 S$ c3 M. }
12.         USART_Init(USART1,&Uart);
    4 b9 `# x% W( q, M# z9 b2 n
13.        
    8 N0 l; z3 g% t# j- N0 v
14.         USART_Cmd(USART1,ENABLE);
    
15.         USART_ClearFlag(USART1,USART_FLAG_TC);
    ! P; D# X- w# i- B% j" }* W7 E3 y
16. }

复制代码

以上代码不在详细介绍，具体请参看STM32基础设计（2）---查询串口通信
: w* T3 f" w0 b; I! E

) x9 i6 p, ]) r- i  Z5 m7 s3，初始化NVIC
首先，让我们来了解库函数中的NVIC结构体：
' I7 ?8 z. Y8 }8 `; b* H8 v

1. typedef struct
   7 ~' K7 A) e0 h; F8 T) R* O. C
2. {//指明那个中断通道
   
3.   uint8_t NVIC_IRQChannel;                    /*!< Specifies the IRQ channel to be enabled or disabled.
   
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. //抢占优先级
   ' _% c6 y1 B: p  i
8.   uint8_t NVIC_IRQChannelPreemptionPriority;  /*!< Specifies the pre-emption priority for the IRQ channel
   8 ?3 W$ z4 M4 o. T
9.                                                    specified in NVIC_IRQChannel. This parameter can be a value
   
10.                                                    between 0 and 15 as described in the table @ref NVIC_Priority_Table */
    
11. //子优先级
    
12.   uint8_t NVIC_IRQChannelSubPriority;         /*!< Specifies the subpriority level for the IRQ channel specified
    
13.                                                    in NVIC_IRQChannel. This parameter can be a value
    
14.                                                    between 0 and 15 as described in the table @ref NVIC_Priority_Table */
    $ ?+ z. `6 A" Q8 ]  G" N0 l
15. //中断通道使能
    ( u+ r) l. C$ |- W
16.   FunctionalState NVIC_IRQChannelCmd;         /*!< Specifies whether the IRQ channel defined in NVIC_IRQChannel
    
17.                                                    will be enabled or disabled.
    * e7 J8 u; o, Q( @3 f
18.                                                    This parameter can be set either to ENABLE or DISABLE */   
    " t+ L# A$ Y- T) P& S' K
19. } NVIC_InitTypeDef;

复制代码

了解了这个结构体后，就可以在初始化函数中定义这个变量了

- [* H( d, ~, ~1 O5 H

1. NVIC_InitTypeDef nvic;

复制代码

% K4 E; W% a4 U另外在NVIC初始化中还设置优先级分组（哪怕只有一个中断也要分组，这是规定）。具体使用这个库函数：
2 b" G$ l& f! h% E- C1 b
  ^% v0 V# u& Y

1. void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
   $ p" y% H" M7 D2 E5 L, `9 R
2. {
   2 Q3 I7 D! `( ^
3.   /* Check the parameters */
   9 o# O  b  Q0 Z* N
4.   assert_param(IS_NVIC_PRIORITY_GROUP(NVIC_PriorityGroup));
   * a5 Z$ h6 L: v+ A9 k; g
5.   
   2 u& g; y! ~/ c
6.   /* Set the PRIGROUP[10:8] bits according to NVIC_PriorityGroup value */
   . t% d9 x8 r- i( L5 z$ ?8 J
7.   SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
   
8. }

复制代码

! S5 {( H1 ^" n+ h+ H接下来，设置结构体中变量的值：
1 s( ?  H) S! q  r  u4 l: ?# t+ F

1. nvic.NVIC_IRQChannelPreemptionPriority = 1;//抢占优先级
   
2. nvic.NVIC_IRQChannelSubPriority = 0;//子优先级
   
3. nvic.NVIC_IRQChannel = USART1_IRQn;//中断通道
   
4. nvic.NVIC_IRQChannelCmd = ENABLE;//通道使能
   % s+ ]9 H  E( i: O5 J, `7 D0 V2 g
5. NVIC_Init(&nvic);//NVIC寄存器初始化

复制代码

2 L, ]" K7 O+ x# e4，编写中断服务函数
先贴代码，在解释

1. void USART1_IRQHandler(void)//注意，这个函数名必须这样写，否则进不了USART1中断。详见库函数中的  IRQn_Type 结构体
   
2. {
   
3.         char temp= '0';
   " m5 `2 c( X. ~- H
4.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)//判断是否接收到数据
     ]- g) h- {* G0 }$ S; j  O
5.         {
   
6.                 temp = USART1->DR;//如果接收到数据，就将其读出，这样才可将RXNE寄存器清除
   + r8 U' {! g. l) ~& }$ T& B
7.                 if(temp == 'G')//如果接收到G  则关灯
   
8.                 {
   
9.                         GPIOC->BRR = GPIO_Pin_13;
   
10.                 }else if(temp == 'K')//开灯
    
11.                 {
    
12.                         GPIOC->BSRR = GPIO_Pin_13;
    6 ?$ l2 `& D- Z+ y/ s, c
13.                 }
    
14.         }
    
15.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')//如果发送寄存器为空，即可以发送数据
    
16.                 {
    % @5 |) P% X+ h
17.                         USART1->DR = temp;将接收到的数据再发送回去
    $ q: V1 m$ s! A; J
18.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));等待数据发送完毕
    ; |6 g5 [% s, u9 t  R
19.                 }
    $ d! ^# b+ _2 r8 A
20. }

复制代码

5，编写主函数
! y' j5 x: L9 t$ T8 I# A( D2 C老规矩，先贴代码再解释：
/ @1 Z# j9 Y5 r% t7 a

1. int main()
   % ^% U, A3 d% W3 _
2. {
   
3.         IO_Init();
   
4.         Usart1_Init();
   ( d4 v/ q2 m# U6 N( k
5.         Nvic_Init();
   3 ?7 F( c" X! ]& A
6.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);//这里是打开串口的接收中断，以便在USART1收到数据时，进入中断函数。这里特别提一下，现在不用打开发送中断，只有在准备发送数据时才应打开，否则会直接进入中断函数。
   $ J0 T( e* A8 q% y6 R
7.         GPIOC->BSRR = GPIO_Pin_13;
   # a- T3 D* t0 T1 m7 g) Z6 M
8.         while(1){}
   + J- L, N' f) u# {
9. }

复制代码

; g. E" x* [/ ^. h/ j额。。。突然发现没什么好解释的。
" A& [5 T/ M) H
中断串口通信介绍到此完毕。
  Q4 W: M! k# `; R4 n- Y
本文完整代码如下：
/ h( [% \% C1 w% h9 j5 P4 _( v. W3 V9 x

1. #include<stm32f10x.h>
   3 v' m/ H# L/ C, @
2. #define uint unsigned int
   
3. #define uchar unsigned char
   5 n' p* K8 o  _: v! R, D
4. void delay(uint n)
   7 s8 E  c2 P, i" T6 ?2 z
5. {
   & x- k( |/ T7 ]! D
6.         int i,j;
   0 b$ z- D, n* O+ `) a& r
7.         for(i=0;i<n;i++)
   
8.         for(j=0;j<8500;j++);
   
9. }
   4 K8 g, k3 U; p% h
10. 
    # N8 L; Y. i" ]$ f( B$ g
11. void IO_Init()
    : Y- O% C" O/ _* s
12. {
    
13.         GPIO_InitTypeDef Uart_A;
    
14.         GPIO_InitTypeDef led;
    % X; d* d- k" W& ?6 a- Z
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.        
    . x; z3 L+ e$ ]) @8 i+ i! j" p
19.         led.GPIO_Pin = GPIO_Pin_13;
    
20.         led.GPIO_Mode = GPIO_Mode_Out_PP;
    
21.         led.GPIO_Speed = GPIO_Speed_50MHz;
    
22.         GPIO_Init(GPIOC,&led);
    
23.        
    
24.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    : q" U4 s6 l  U' x/ @( x
25.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    5 z) F$ W  l. r4 g& g
26.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    
27.         GPIO_Init(GPIOA,&Uart_A);
    
28.        
    2 }  d! |: F6 `4 p2 K: c
29.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    
30.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    5 \5 w5 ?! q1 r& L
31.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING; //page 110
    
32.         GPIO_Init(GPIOA,&Uart_A);
    
33.        
    - P# o8 w* |6 g8 h0 m/ o6 p
34. }
    
35. void Usart1_Init()
    
36. {
    $ `0 h( p: G' e4 `) N5 [  ?
37.         USART_InitTypeDef Uart;
    8 n; ?: A2 h0 B) k
38.        
    
39.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
      i, W. E' X3 g% c4 [- L0 ~
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;
    
44.         Uart.USART_StopBits = USART_StopBits_1;
    
45.         Uart.USART_WordLength = USART_WordLength_8b;
    ; F$ `: H8 J. [5 A  M
46.         USART_Init(USART1,&Uart);
    
47.        
    
48.         USART_Cmd(USART1,ENABLE);
    
49.         USART_ClearFlag(USART1,USART_FLAG_TC); //page 540
    
50. }
    
51. void Nvic_Init()
    
52. {
    
53.         NVIC_InitTypeDef nvic;
    8 [/ I: \) W" `. @9 ^0 e! G
54.        
    3 I, F; c& |  n. k! J6 I# i4 e
55.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    * Y. Z+ h4 p& R7 n$ \- {5 {8 O, H
56.        
    
57.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    ' K$ I% N& i; [" j- X
58.         nvic.NVIC_IRQChannelSubPriority = 0;
    
59.         nvic.NVIC_IRQChannel = USART1_IRQn;
    $ _% S8 Q9 [  B: U' B
60.         nvic.NVIC_IRQChannelCmd = ENABLE;
    
61.         NVIC_Init(&nvic);
    
62. }
    ; R+ d7 _1 C# h5 ]1 i% h3 Z, i: o- b
63. 
      l6 G0 g! q2 J8 b( k8 M
64. int main()
    2 N( h0 S# D/ Q; p& \& q
65. {
    
66.         IO_Init();
    
67.         Usart1_Init();
    
68.         Nvic_Init();
    
69.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
    4 z* V* y+ o6 ^  F* @
70.         GPIOC->BSRR = GPIO_Pin_13;
    
71.         while(1){}
    
72. }
    9 _' S2 M+ F; z& V
73. 
    
74. void USART1_IRQHandler(void)
    
75. {
    
76.         char temp= '0';
    " B, L$ u' s( B( V1 s
77.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)
    
78.         {
    
79.                 temp = USART1->DR;
    . M) i4 q" l0 z$ g$ h% C
80.                 if(temp == 'G')
    
81.                 {
    
82.                         GPIOC->BRR = GPIO_Pin_13;
    % i0 L7 V9 W) ~- U3 k
83.                 }else if(temp == 'K')
    ; U, ~: Y6 \7 }1 T5 q! A  Z
84.                 {
    0 i' o7 _0 B0 X+ x8 o7 k
85.                         GPIOC->BSRR = GPIO_Pin_13;
    
86.                 }
    
87.         }
    
88.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')
    8 W5 I/ E# Y) d
89.                 {
    
90.                         USART1->DR = temp;
    
91.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));
    7 M/ g- X# v( Q4 x7 I
92.                 }
    6 f3 H% E2 H9 B2 ~3 j* g3 t) c; r
93. }

复制代码

( ^( E5 b# y6 F0 A) P4 Z  y
————————————————
- S8 q8 c; ^  `0 z! W. i版权声明：家安