首先，总结全文，设计步骤主要如下：
1，初始化GPIO
2，初始化USART1
% i. X. `% c' y% M6 r! L3，初始化NVIC（嵌套向量中断控制器）
2 M7 ~8 W2 C+ C6 \" d2 z. a4，编写中断服务函数
  R6 W, W+ t; G# {" F) ^* P: R5，编写主函数
5 C5 _* d# i7 O! R: u
详细步骤如下：

1，初始化GPIO

1. void IO_Init()
   
2. {
   
3.         GPIO_InitTypeDef Uart_A;
   
4.         GPIO_InitTypeDef led;
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC| RCC_APB2Periph_AFIO,ENABLE);
   2 H6 ]. l9 s2 O* e
6.        
   
7.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable|GPIO_Remap_SWJ_JTAGDisable,ENABLE);
   5 p: }( x( M# ?5 p1 H4 k& ?' V
8.        
   2 b/ H# m6 E' i. J5 E6 Q7 f
9.         led.GPIO_Pin = GPIO_Pin_13;//博主开发板上的LED灯接的GPIOC的13引脚
   . p+ }+ P& P) c/ U4 |
10.         led.GPIO_Mode = GPIO_Mode_Out_PP;
    
11.         led.GPIO_Speed = GPIO_Speed_50MHz;
    ; @9 H, x3 T" y! f
12.         GPIO_Init(GPIOC,&led);
    ( S) V5 U- u3 |
13.        
      N0 ~: M  ~9 ]7 ~9 \, d
14.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    
15.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
16.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    
17.         GPIO_Init(GPIOA,&Uart_A);
    ' j2 z5 O. s1 ~! |1 o
18.        
    
19.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    % F' x* D$ J; a7 T0 L2 m' T
20.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
      Z8 t% ?4 U0 t- ?! j8 G5 e
21.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
22.         GPIO_Init(GPIOA,&Uart_A);
    
23.        
    ! j4 }6 Y  l9 Z% s- j! s9 Q
24. }

复制代码

% L% |- E- x( r8 J' g以上代码不在详细介绍，前参看STM32基础设计（1）---点亮LED灯、SEM32基础设计（2）---查询串口通信

: a6 g) ]# Y- ^* W( {% t! \
% z# U; l% ~& v; l, ?* p2，初始化USART1

1. void Usart1_Init()
   
2. {
   & X4 J$ n! k3 x" C& N! y1 j6 Z
3.         USART_InitTypeDef Uart;
   6 Q: t/ g2 D$ z3 N+ v) e) _% u
4.        
   / e* ^2 ?5 E2 \: n
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
   4 M  E; |6 Y. V9 O5 L
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;
   $ g( \1 z0 j: j& c# b1 M0 J
10.         Uart.USART_StopBits = USART_StopBits_1;
    
11.         Uart.USART_WordLength = USART_WordLength_8b;
    ' i9 u4 J" P$ X. |+ B; R+ s) F. S+ [
12.         USART_Init(USART1,&Uart);
    ! X+ t1 }6 I* c4 Q9 C
13.        
    ; F/ g; `) ^& k) v
14.         USART_Cmd(USART1,ENABLE);
    
15.         USART_ClearFlag(USART1,USART_FLAG_TC);
    % Z; g5 O5 T/ S1 X/ r
16. }

复制代码

. I: A+ h- Y3 Q
以上代码不在详细介绍，具体请参看STM32基础设计（2）---查询串口通信


( A; c) ?6 @  v, }1 x  V3，初始化NVIC
首先，让我们来了解库函数中的NVIC结构体：

1. typedef struct
   . m& `( k- R; a$ g- z
2. {//指明那个中断通道
   
3.   uint8_t NVIC_IRQChannel;                    /*!< Specifies the IRQ channel to be enabled or disabled.
   + W+ ^! s; L9 j1 d+ B8 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) */
   2 S5 _/ E! h/ G, W0 M
7. //抢占优先级
   * {: {; @; f8 {1 k3 v5 h
8.   uint8_t NVIC_IRQChannelPreemptionPriority;  /*!< Specifies the pre-emption priority for the IRQ channel
   
9.                                                    specified in NVIC_IRQChannel. This parameter can be a value
   3 C+ T5 @; ~9 W: k  v% ~% [! D9 G
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
    $ B) m" Z" i3 K1 c. R+ Q+ V  a
13.                                                    in NVIC_IRQChannel. This parameter can be a value
    - K6 N0 |+ {9 D4 c
14.                                                    between 0 and 15 as described in the table @ref NVIC_Priority_Table */
    8 C* D- j2 L1 E+ x% Q( L4 {" G: @& s
15. //中断通道使能
    , ]9 L5 X% E# m0 o, o
16.   FunctionalState NVIC_IRQChannelCmd;         /*!< Specifies whether the IRQ channel defined in NVIC_IRQChannel
    * s# J% ^; }0 e9 R
17.                                                    will be enabled or disabled.
    6 d3 @4 @, p& r, O/ F! Z9 U
18.                                                    This parameter can be set either to ENABLE or DISABLE */   
    / r7 A# F6 M" d  a& Q! G
19. } NVIC_InitTypeDef;

复制代码

了解了这个结构体后，就可以在初始化函数中定义这个变量了
: G7 R& [) i8 g9 g2 `0 G2 Q
, m: R7 g7 D/ s

1. NVIC_InitTypeDef nvic;

复制代码

; L, v: A7 e" t) Y另外在NVIC初始化中还设置优先级分组（哪怕只有一个中断也要分组，这是规定）。具体使用这个库函数：
7 O" M2 N  K1 a3 |7 _  s: u9 h

1. void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
   
2. {
   2 M9 [2 P% [4 W! p3 \# r  [
3.   /* Check the parameters */
   5 s% f& n* b' f# Z) ]" Y
4.   assert_param(IS_NVIC_PRIORITY_GROUP(NVIC_PriorityGroup));
   5 C; y9 \3 j+ G0 t' ]: [2 \6 Q
5.   
   ' B) m' ?% V" z% ?
6.   /* Set the PRIGROUP[10:8] bits according to NVIC_PriorityGroup value */
   
7.   SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
   8 I9 T; f2 g- y- g* q
8. }

复制代码

接下来，设置结构体中变量的值：
$ N0 u; _2 A7 [, O. {' k1 b+ y; d! j

1. nvic.NVIC_IRQChannelPreemptionPriority = 1;//抢占优先级
   
2. nvic.NVIC_IRQChannelSubPriority = 0;//子优先级
   9 R" l+ h( r1 ]0 H8 ?/ j, ~
3. nvic.NVIC_IRQChannel = USART1_IRQn;//中断通道
   
4. nvic.NVIC_IRQChannelCmd = ENABLE;//通道使能
   
5. NVIC_Init(&nvic);//NVIC寄存器初始化

复制代码

4，编写中断服务函数
) V* e6 x6 S9 S% r先贴代码，在解释
8 Z; |; A7 U8 U4 X& @8 t8 q

1. void USART1_IRQHandler(void)//注意，这个函数名必须这样写，否则进不了USART1中断。详见库函数中的  IRQn_Type 结构体
   ; C6 {7 u0 \* B; u; }  N, I' o
2. {
   
3.         char temp= '0';
   " s, F; f) B& O8 _, h' D
4.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)//判断是否接收到数据
   
5.         {
   
6.                 temp = USART1->DR;//如果接收到数据，就将其读出，这样才可将RXNE寄存器清除
   
7.                 if(temp == 'G')//如果接收到G  则关灯
   
8.                 {
   5 ?8 i6 P$ h" A! E( w" @- ]% J# W
9.                         GPIOC->BRR = GPIO_Pin_13;
   
10.                 }else if(temp == 'K')//开灯
    
11.                 {
    3 G% y) ^& a. J2 d8 I8 l, i
12.                         GPIOC->BSRR = GPIO_Pin_13;
    0 G- u. q$ L% t  k, \3 S4 }2 q
13.                 }
    
14.         }
    
15.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')//如果发送寄存器为空，即可以发送数据
    5 \# L+ u" K# a
16.                 {
      d% {6 [" n# S9 W' F) d" Y
17.                         USART1->DR = temp;将接收到的数据再发送回去
    ' x3 c% V$ T9 W
18.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));等待数据发送完毕
    9 r# ?& P, B2 W/ P  `8 N# H
19.                 }
    
20. }

复制代码

1 P9 Q9 T2 ^2 b5，编写主函数
' B$ j. ]$ p1 G& x老规矩，先贴代码再解释：
  H9 A$ H3 g8 l* X; i. D

1. int main()
   3 ]3 M, K8 x% b% k  Q% b- [! F
2. {
   . W; |) U" n9 ?/ Y6 y% e
3.         IO_Init();
   
4.         Usart1_Init();
   + w% M& A( h" A- t- k( j
5.         Nvic_Init();
   
6.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);//这里是打开串口的接收中断，以便在USART1收到数据时，进入中断函数。这里特别提一下，现在不用打开发送中断，只有在准备发送数据时才应打开，否则会直接进入中断函数。
   
7.         GPIOC->BSRR = GPIO_Pin_13;
   
8.         while(1){}
   ; M) m" v0 Z2 L" Q$ ]' H4 @
9. }

复制代码

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

中断串口通信介绍到此完毕。

7 s! |, h4 v* j1 V$ ^本文完整代码如下：
4 A" h) M5 A# T! |# ^

1. #include<stm32f10x.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4. void delay(uint n)
   & _( q% l0 p" I) M
5. {
   ; D' B4 d1 V4 i" c
6.         int i,j;
   + `4 B; {" R2 L7 s
7.         for(i=0;i<n;i++)
   
8.         for(j=0;j<8500;j++);
   5 N: N. D: b/ ~3 P1 H
9. }
   + e3 @7 d9 u' W
10. 
    : N8 ^7 S% g; c. ^# k0 m& B
11. void IO_Init()
    
12. {
    
13.         GPIO_InitTypeDef Uart_A;
    9 x, Q6 Y/ H! A% r- E
14.         GPIO_InitTypeDef led;
    
15.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC| RCC_APB2Periph_AFIO,ENABLE);
    
16.        
    ) q$ C# r$ S( ]% M! I, }: ]9 e
17.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable|GPIO_Remap_SWJ_JTAGDisable,ENABLE);
    4 b% r& J. N, O  U; [
18.        
    7 \: @# S/ }6 B0 F! D/ I
19.         led.GPIO_Pin = GPIO_Pin_13;
    
20.         led.GPIO_Mode = GPIO_Mode_Out_PP;
    ' I% A0 |8 g4 e! Y4 |  J
21.         led.GPIO_Speed = GPIO_Speed_50MHz;
    
22.         GPIO_Init(GPIOC,&led);
    
23.        
    & w8 u( X- Z* @! S' Y. W- r
24.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    ( b1 k: H& k' |- P# ^' v  _7 M6 o3 s
25.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
26.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    
27.         GPIO_Init(GPIOA,&Uart_A);
    
28.        
    
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.        
    9 C; r% y* z% b* R! t8 Y+ Y
34. }
    * U0 o' _( [7 M5 W9 J1 o
35. void Usart1_Init()
    
36. {
    9 _; N: a$ _7 J, z- B% A
37.         USART_InitTypeDef Uart;
    0 {5 R! g( A# f0 l( Z' s
38.        
    
39.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    + {; g9 o$ }' y4 V4 q) m2 D
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;
    % j1 s9 @+ f0 G' c5 B2 _+ ?
46.         USART_Init(USART1,&Uart);
    
47.        
    
48.         USART_Cmd(USART1,ENABLE);
    
49.         USART_ClearFlag(USART1,USART_FLAG_TC); //page 540
    ) Q4 g' O3 @. P
50. }
    4 @$ e" h# \6 r  {, q( Z% m
51. void Nvic_Init()
      l5 P" i$ N0 R. M7 Y2 M
52. {
    
53.         NVIC_InitTypeDef nvic;
    2 J& B+ j. u! v6 n3 }" x" ]$ O! L
54.        
    
55.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    " d' Z/ G* F: E/ ]1 ]8 J3 k/ m
56.        
    : E( i& C  n" }' \5 T) q, R7 E$ `
57.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    7 m8 A2 D$ C8 f  W7 o7 x
58.         nvic.NVIC_IRQChannelSubPriority = 0;
    
59.         nvic.NVIC_IRQChannel = USART1_IRQn;
    - j/ B. g+ g& |
60.         nvic.NVIC_IRQChannelCmd = ENABLE;
    
61.         NVIC_Init(&nvic);
    
62. }
    # ?. f6 |" C) w: ~3 M- \
63. 
    
64. int main()
    8 L6 J% W3 ]0 x) o5 G
65. {
    2 |2 j3 D: t) ~! o5 c
66.         IO_Init();
    . P8 J. g! D) x1 K: l4 g
67.         Usart1_Init();
    
68.         Nvic_Init();
    ' f& |7 `2 \2 I1 r1 }& g
69.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
    0 s: {' D* u3 ?3 j1 o+ l" Q
70.         GPIOC->BSRR = GPIO_Pin_13;
    
71.         while(1){}
      ?' {( Z; i1 b5 ~% t
72. }
    ! ]2 N/ C+ }  x( I5 X% h/ b
73. 
    ( n6 E$ m6 L5 ~4 P3 d7 b
74. void USART1_IRQHandler(void)
    
75. {
    & |$ i. `1 V; T1 m" r7 T; u
76.         char temp= '0';
    
77.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)
    & q/ x; Y8 |6 l3 N5 W
78.         {
    9 D* u0 \% [" c4 _& A7 F: x
79.                 temp = USART1->DR;
    6 @1 g- L* s5 W6 j
80.                 if(temp == 'G')
    # [$ _$ w; ]* }( F1 Z
81.                 {
    
82.                         GPIOC->BRR = GPIO_Pin_13;
    5 A5 g) K* _8 z% D+ x( Q0 N2 j
83.                 }else if(temp == 'K')
    $ ?1 C7 }; I& V: @9 d2 S
84.                 {
    9 O3 @0 Y. Q( {, h" @& X
85.                         GPIOC->BSRR = GPIO_Pin_13;
    
86.                 }
    1 ~$ V  V8 @, }+ P9 }/ ]. P( C0 J
87.         }
    
88.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')
    ; j+ k9 M. d0 o
89.                 {
    . B( w7 K" `$ b  N* F7 o; ?/ u
90.                         USART1->DR = temp;
    
91.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));
    - `- P. ?. z* O- O( N3 b
92.                 }
    
93. }

复制代码

8 |; x' \" l% X! P  r$ ~————————————————
版权声明：家安

4 T7 N: O3 [+ o0 x; G
* x# z( `/ W, {* q+ q