首先，总结全文，设计步骤主要如下：
/ [+ X% V! h# f1，初始化GPIO
2，初始化USART1
. @& l3 g  M& P4 D/ b, @" j4 h3，初始化NVIC（嵌套向量中断控制器）
6 k7 b5 u; _! P- V, e4，编写中断服务函数
+ f: p; l! V" s+ [- f5，编写主函数

详细步骤如下：

- I& f2 G7 k. J; O9 ^1，初始化GPIO

1. void IO_Init()
   $ n" g" }+ b, i8 c$ \! z
2. {
   
3.         GPIO_InitTypeDef Uart_A;
   ' i: M- q( {8 H3 [2 L& ?
4.         GPIO_InitTypeDef led;
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC| RCC_APB2Periph_AFIO,ENABLE);
   2 K8 g- z& p) k0 S3 b5 O( |  K) G0 E
6.        
   % V5 v1 s# O- u& G6 S3 b. `
7.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable|GPIO_Remap_SWJ_JTAGDisable,ENABLE);
   
8.        
   % {' H! w" Q. @  F
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;
    
12.         GPIO_Init(GPIOC,&led);
    
13.        
    
14.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    % g% K- s7 R  q) k; ^8 C, M
15.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
16.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    
17.         GPIO_Init(GPIOA,&Uart_A);
    
18.        
    3 X: J/ d, _& E# `8 l1 t& G
19.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    - I; i0 a# \/ `( V2 m& g
20.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
21.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
22.         GPIO_Init(GPIOA,&Uart_A);
    
23.        
    
24. }

复制代码

- `5 Y1 s- i7 G: p' b以上代码不在详细介绍，前参看STM32基础设计（1）---点亮LED灯、SEM32基础设计（2）---查询串口通信
+ p3 l% h8 {& j: }  q

2，初始化USART1

1. void Usart1_Init()
     Q2 q5 V' P0 ^* {- q  c
2. {
   
3.         USART_InitTypeDef Uart;
   - P/ S6 s5 S' f9 W
4.        
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
   ; T& k' u$ M5 }/ 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;
   
10.         Uart.USART_StopBits = USART_StopBits_1;
    
11.         Uart.USART_WordLength = USART_WordLength_8b;
    
12.         USART_Init(USART1,&Uart);
    , {; Z5 V9 V4 h0 E1 `
13.        
    
14.         USART_Cmd(USART1,ENABLE);
    6 Q  z# A5 X% r) Z+ o; n- ^
15.         USART_ClearFlag(USART1,USART_FLAG_TC);
    
16. }

复制代码

, ]" M  @' a' ]) X8 V以上代码不在详细介绍，具体请参看STM32基础设计（2）---查询串口通信


3 _" l- @% @* }6 L7 z  K% k- F+ m3，初始化NVIC
首先，让我们来了解库函数中的NVIC结构体：

1. typedef struct
   2 r2 g( q! k6 s
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. //抢占优先级
   
8.   uint8_t NVIC_IRQChannelPreemptionPriority;  /*!< Specifies the pre-emption priority for the IRQ channel
   ' k6 P! f, c  G2 C
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 */
    # {: M3 Q/ R5 K( g# L+ p( V
11. //子优先级
    - i9 i; x. B* x$ V. y! B  A
12.   uint8_t NVIC_IRQChannelSubPriority;         /*!< Specifies the subpriority level for the IRQ channel specified
    1 D# e* K5 H3 d# t
13.                                                    in NVIC_IRQChannel. This parameter can be a value
    
14.                                                    between 0 and 15 as described in the table @ref NVIC_Priority_Table */
    
15. //中断通道使能
    # |4 M* T( s$ c( ?6 w, a
16.   FunctionalState NVIC_IRQChannelCmd;         /*!< Specifies whether the IRQ channel defined in NVIC_IRQChannel
    
17.                                                    will be enabled or disabled.
    . Y$ K; `8 t% E5 `0 k( f* F
18.                                                    This parameter can be set either to ENABLE or DISABLE */   
    
19. } NVIC_InitTypeDef;

复制代码

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

1. NVIC_InitTypeDef nvic;

复制代码

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

1. void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
   5 F6 S* v2 w$ w/ y
2. {
   
3.   /* Check the parameters */
   $ u' o* X; q0 |. p
4.   assert_param(IS_NVIC_PRIORITY_GROUP(NVIC_PriorityGroup));
   # ^* m1 B! h, @2 q
5.   
   
6.   /* Set the PRIGROUP[10:8] bits according to NVIC_PriorityGroup value */
   ; A% S% J. k5 l/ C, }  j
7.   SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
   9 }4 [* P7 L* ^3 B
8. }

复制代码

接下来，设置结构体中变量的值：
; n7 L+ P% J9 T2 [3 @: p) I

1. nvic.NVIC_IRQChannelPreemptionPriority = 1;//抢占优先级
   
2. nvic.NVIC_IRQChannelSubPriority = 0;//子优先级
   
3. nvic.NVIC_IRQChannel = USART1_IRQn;//中断通道
   5 @7 X. Q9 g  V' M
4. nvic.NVIC_IRQChannelCmd = ENABLE;//通道使能
   ) [' u) z! r7 C* v5 H9 b
5. NVIC_Init(&nvic);//NVIC寄存器初始化

复制代码

7 h; H8 F* t! k# D4，编写中断服务函数
2 o! h8 `2 ]2 k先贴代码，在解释

1. void USART1_IRQHandler(void)//注意，这个函数名必须这样写，否则进不了USART1中断。详见库函数中的  IRQn_Type 结构体
   ' v; |! _3 h6 h# n* l
2. {
   2 h0 t8 }9 f5 p7 F2 d" p
3.         char temp= '0';
   
4.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)//判断是否接收到数据
   " B1 ^7 u9 P+ P) i) E, [
5.         {
   
6.                 temp = USART1->DR;//如果接收到数据，就将其读出，这样才可将RXNE寄存器清除
   ( }# \$ {; b) {6 i( t
7.                 if(temp == 'G')//如果接收到G  则关灯
   
8.                 {
   
9.                         GPIOC->BRR = GPIO_Pin_13;
   
10.                 }else if(temp == 'K')//开灯
    
11.                 {
    , J. N3 T: s+ Q
12.                         GPIOC->BSRR = GPIO_Pin_13;
    " Q$ X( j- s( ]$ L9 Q, j- j1 ]5 @
13.                 }
    
14.         }
    0 q# r6 p# s4 l6 L. v, O4 f
15.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')//如果发送寄存器为空，即可以发送数据
    
16.                 {
    6 L8 O( j* ~& P- n: o/ q1 C
17.                         USART1->DR = temp;将接收到的数据再发送回去
    & D9 b) y2 l) S/ u+ B. i
18.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));等待数据发送完毕
    
19.                 }
    # u. c# p$ h) y1 g; p' ~. @/ e
20. }

复制代码

5，编写主函数
! d$ y5 Q/ c. F, h% Z* }6 L( }老规矩，先贴代码再解释：
5 U% b) j: K2 f

1. int main()
   : O" `( m8 g  u% q( {" X
2. {
   + F3 p, t& G$ \3 J  p# h# E
3.         IO_Init();
   
4.         Usart1_Init();
   
5.         Nvic_Init();
   8 w3 e; ^3 y3 e2 m. Y: N
6.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);//这里是打开串口的接收中断，以便在USART1收到数据时，进入中断函数。这里特别提一下，现在不用打开发送中断，只有在准备发送数据时才应打开，否则会直接进入中断函数。
   
7.         GPIOC->BSRR = GPIO_Pin_13;
   
8.         while(1){}
   & A4 ~6 n/ ?" W3 O; [
9. }

复制代码

额。。。突然发现没什么好解释的。
8 o0 H5 u) i- d8 z( n8 H7 v
中断串口通信介绍到此完毕。
+ T3 o; d" e2 ^8 c( ~7 g
2 f/ s. e8 l) h; G; P! r本文完整代码如下：

1. #include<stm32f10x.h>
   
2. #define uint unsigned int
   1 D+ E7 e- V: [$ O) ]; F# I9 A2 h
3. #define uchar unsigned char
   & i0 L  t  C( K# g) O; i
4. void delay(uint n)
   
5. {
   
6.         int i,j;
   2 g* h! I: {. ]7 x
7.         for(i=0;i<n;i++)
   , P4 w: r4 x, w9 d8 c6 W
8.         for(j=0;j<8500;j++);
   + I5 }# v' Y& T) O6 |! ]
9. }
   ) ?* R! S1 }" p) L, J3 _* u
10. 
    
11. void IO_Init()
    . {* l& i! _( g* _. i
12. {
    
13.         GPIO_InitTypeDef Uart_A;
    " [9 j) j* V9 i( o1 G! k5 f1 r- a1 Q
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);
    % X, O% G2 s9 h% N1 a+ l8 l7 s
18.        
    ; c" m. U4 q$ D) O% t
19.         led.GPIO_Pin = GPIO_Pin_13;
    
20.         led.GPIO_Mode = GPIO_Mode_Out_PP;
    ! A. r' i7 e, q% e
21.         led.GPIO_Speed = GPIO_Speed_50MHz;
    
22.         GPIO_Init(GPIOC,&led);
    " r; X! K( j5 ~% [$ p# m. T7 A
23.        
    * M3 L6 H# \! a) `, J2 C6 I
24.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    5 I% h1 [2 ^2 i9 a2 ~
25.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
26.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    5 h5 T& P0 ^" ~+ f: `6 n
27.         GPIO_Init(GPIOA,&Uart_A);
    
28.        
    
29.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    
30.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    + ]: u" L( X, `5 `" c
31.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING; //page 110
    
32.         GPIO_Init(GPIOA,&Uart_A);
    
33.        
    7 f- s! s9 U) }! ~6 @
34. }
    
35. void Usart1_Init()
    
36. {
    ! ^$ H& S- D8 j9 W' |" W4 J9 u
37.         USART_InitTypeDef Uart;
    ; G/ ^9 p0 y$ p; q- x
38.        
    0 X( A- ]" |4 }$ z% @5 Y
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;
    5 Q" b( |( t2 ]! k
44.         Uart.USART_StopBits = USART_StopBits_1;
    " C1 K+ o+ ]8 ]7 D
45.         Uart.USART_WordLength = USART_WordLength_8b;
    ( g$ P3 a; L: O* `
46.         USART_Init(USART1,&Uart);
    # \7 K. S: a* @. x9 `7 E# [3 I4 o
47.        
    
48.         USART_Cmd(USART1,ENABLE);
    " X# r0 o" _& b3 |
49.         USART_ClearFlag(USART1,USART_FLAG_TC); //page 540
    8 i# P" X7 T5 X1 a6 X
50. }
    - b# v' I& S7 d
51. void Nvic_Init()
    + e. T' Z( ~$ E3 M( [! A
52. {
    + `) f/ W; m- q: a
53.         NVIC_InitTypeDef nvic;
    
54.        
    " [1 g, m) B2 Y5 J8 U
55.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    " G- ^' h* Y3 H0 ]8 y# L3 c
56.        
    * I7 n, Z8 ]8 U" f2 j- C
57.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    
58.         nvic.NVIC_IRQChannelSubPriority = 0;
    
59.         nvic.NVIC_IRQChannel = USART1_IRQn;
    
60.         nvic.NVIC_IRQChannelCmd = ENABLE;
    
61.         NVIC_Init(&nvic);
    
62. }
    
63. 
    
64. int main()
    2 ]; [# _0 p0 x$ Y5 D
65. {
    
66.         IO_Init();
    5 ?+ L$ x2 a# D  e
67.         Usart1_Init();
    1 j/ @9 S+ v5 _
68.         Nvic_Init();
    
69.         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
    
70.         GPIOC->BSRR = GPIO_Pin_13;
    
71.         while(1){}
    6 m) K) ^2 ~+ N/ k# y$ m
72. }
    & n0 `" e* ?1 a/ e/ X$ P
73. 
    
74. void USART1_IRQHandler(void)
    
75. {
    , [* G/ i  T0 ]$ V! a
76.         char temp= '0';
    5 u" M+ p2 c  z' K7 k1 b3 R1 M
77.         if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET)
    
78.         {
    / `) p5 ]1 F: K5 }
79.                 temp = USART1->DR;
    . p3 s! [. X( ~$ N7 S4 w
80.                 if(temp == 'G')
    4 a# f( ]. V+ Q; m, k& S/ K
81.                 {
    
82.                         GPIOC->BRR = GPIO_Pin_13;
    
83.                 }else if(temp == 'K')
      q- G+ o5 U6 W' X3 g. {
84.                 {
    ' g/ C" G; e' b* E* B3 p, h+ k
85.                         GPIOC->BSRR = GPIO_Pin_13;
    
86.                 }
    
87.         }
    : w1 [7 x: z) j8 l# K; B
88.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TXE) && temp != '0')
    
89.                 {
    $ p3 X' x5 I% b" K+ R+ t6 C  u: j
90.                         USART1->DR = temp;
    
91.                         while(!USART_GetFlagStatus(USART1,USART_FLAG_TC));
    4 o& x7 K4 F1 |* ^9 P
92.                 }
    " B2 K3 _1 X  X* _/ H& p
93. }

复制代码

1 i2 r0 P/ s* q5 O* u& s# f+ i; h
————————————————
! |- @, o# Y1 D  d- N版权声明：家安