1.1.1 使用Keil MDK运行第一个STM32F10X程序在上一小节中已经详细介绍了使用Keil MDK和标准外设库创建一个工程的过程，下面将介绍基于这个工程来编写一个小程序，通过这个程序我们可以初步了解：
1.STM32标准外设库的简单使用过程
2.STM32外设的使用方法和大致流程
( T# B& M- H5 b* w# I5 n  g3.程序的编译、链接、下载步骤
4.利用Keil MDK的在线仿真功能进行软件仿真的简要步骤
" x& ^' H* b$ r$ j; m* a5 m- q0 }% d
7 q0 n. y2 x' T, E
1. 程序的编写
) K1 X- _7 w1 I（1）程序实现的功能
3 o  X4 E$ _- _# E为了方便各位读者的入门和理解，这个小程序的功能非常简单，作为本书功能实践的第一个程序，其功能当然也是最为经典的“Hello World！”了，只不过不是简单的屏幕输出，而是利用硬件的串口进行输出，同时作为单片机类的第一个程序自然少不了LED闪烁的功能，这就是这个小程序的两个主要的功能：
0 q+ Z  p; F  @- i0 `  {) Xl 利用串口1输出“Hello World！”字符。
, E5 E! L( x$ s5 T' pl 控制两个LED闪烁。
( a% g6 W, C& x6 B5 n* i) }7 m（2）程序的实现
: S" ]1 k- s9 k5 ~5 G# `在基于标准外设库进行程序开发时一定要充分利用标准外设库下面的帮助文件stm32f10x_stdperiph_lib_um.chm以及库中自带的工程实例，同时结合STM32F10x系列的芯片手册来完成程序的开发，stm32f10x_stdperiph_lib_um.chm帮助文件如图 5‑25所示。此文件中已经包含了标准外设库的全部内容，并根据根据内容结构进行了重新的编排和整理，更加方便程序的阅读和理解。
- X5 M1 v: }3 j+ k  c9 l% E, GSTM32F10x_StdPeriph_Lib_V3.5.0\Project\STM32F10x_StdPeriph_Examples文件夹下包括了众多外设的使用例程，这里的例程多是针对官方的开发板而编写，然而这些例程却非常全面的展示了相关外设的各种使用方法，对我们做基于标准外设库的开发有着非常重要的意义。

, K- x! G/ k" v

" g4 _* b6 l* [& P/ D" N

图 5‑25 标准外设库的帮助文档

& B- C5 |2 i7 L. M7 i

+ c/ I" n7 {8 ^* w$ {% M我们的第一个程序就通过这些参考来完成，首先来看串口部分。串口部分的详细信息可以参考本书第8章，这儿只进行简单的说明和介绍简便的开发方法，首先先找一个与我们使用的功能最近的一个例程，STM32F10x_StdPeriph_Lib_V3.5.0\Project\STM32F10x_StdPeriph_Examples\USART文件夹下给出了多达12中的USART例程，这里选择较为相近的Interrupt文件夹下得例程，打开文件夹下面的mian.c文件，通过简单的浏览可以找到如下一段程序：
, X1 [, P$ C7 V* X/ X9 e2 C

1. /* USARTy and USARTz configuration ------------------------------------------------------*/
   : D) k" b" C  S3 d2 k
2. 
   
3. /* USARTy and USARTz configured as follow:
   
4. 
   
5. - BaudRate = 9600 baud
   
6. 
   
7. - Word Length = 8 Bits
   ' Z; a7 Z5 d/ q. J# }
8. 
   7 y% @; C' c' A: S4 S( h
9. - One Stop Bit
   - {+ p# `, }8 N9 s* L6 y
10. 
    " o8 K* S6 v: Z1 h7 b0 Y: i
11. - No parity
    . I% l; M5 z7 X7 @4 [
12. 
    
13. - Hardware flow control disabled (RTS and CTS signals)
    
14. 
    6 p5 l$ _& a6 c! G
15. - Receive and transmit enabled
    9 U% {+ \8 A" j" y! c2 G! d' }
16. 
    
17. */
    1 C/ B2 b8 |, H2 e
18. 
    # Q: F* K4 b2 T; K" j
19. USART_InitStructure.USART_BaudRate = 9600;
    
20. 
    & F' X+ m+ c" [2 d' D
21. USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    3 p9 B2 B( J) }' G$ ~
22. 
    / W6 s- F( W9 c/ N
23. USART_InitStructure.USART_StopBits = USART_StopBits_1;
    % g' B# y5 T0 h# [% V% p+ f
24. 
    ( r: r0 {" E4 {; `( y  P+ k
25. USART_InitStructure.USART_Parity = USART_Parity_No;
    " w0 x3 M. F4 O) `* m
26. 
    
27. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    * s' ]3 S) V4 G" O& O+ ~+ L
28. 
    
29. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
30. 
    
31. /* Configure USARTy */
    
32. 
    
33. USART_Init(USARTy, &USART_InitStructure);
    
34. 
    
35. /* Configure USARTz */
    . v8 O( E# a1 @# m2 }) R6 v
36. 
    
37. USART_Init(USARTz, &USART_InitStructure);
    
38. 
    
39. /* Enable USARTy Receive and Transmit interrupts */
    
40. 
    
41. USART_ITConfig(USARTy, USART_IT_RXNE, ENABLE);
    
42. 
    * Q% b, U: a) ~9 b$ t
43. USART_ITConfig(USARTy, USART_IT_TXE, ENABLE);
    
44. 
    # u: c1 }0 n1 X* l: |
45. /* Enable USARTz Receive and Transmit interrupts */
    
46. 
    
47. USART_ITConfig(USARTz, USART_IT_RXNE, ENABLE);
    
48. 
    # V6 F, ?& G& x. _3 i
49. USART_ITConfig(USARTz, USART_IT_TXE, ENABLE);
    
50. 
    4 l- l% v' `7 `) e8 [$ j
51. /* Enable the USARTy */
    
52. 
    * j! }% _5 R9 L  J' V8 i% I
53. USART_Cmd(USARTy, ENABLE);
    $ R5 S9 n1 c8 p
54. 
    
55. /* Enable the USARTz */
    
56. 
    
57. USART_Cmd(USARTz, ENABLE);

复制代码

7 A. X& ^& n. b* r& ~

　上面的这段的程序配合注释可以很容易理解，USART_InitTypeDef定义了一个包括USART主要参数的结构体，因此首先对USART的相关参数进行配置，使用标准外设库进行配置的优势就体现出来了，通过程序可以很容易读出这个串口的配置：
, \) w' z3 @* ]5 ~+ J6 z0 S! o- yl 波特率9600Kbps
l 数据长度8
4 _6 ~9 ]. ?  a% }+ s- b0 B0 [9 xl 停止位1
. X% P7 L1 [9 m; r; F  \) n4 f! al 奇偶校验：无
5 |9 s, B, Z+ E7 H" U( M/ E9 m# Gl 硬件流控制：无
l 工作模式：收、发
  c3 l; X- q- d# T+ u然后利用USART_Init函数进行初始化，这段程序中设置了两个串口，使用同样的配置，然后配置相应的中断。最后通过USART_Cmd函数使能相应的串口，前面有过介绍，这些例程里的程序是针对官方的开发套件的，因此程序中并没有指名具体的端口，而是使用了宏定义USARTy、USARTz。通过这段程序就可以很方便的更改相关的参数得到我们需要的配置程序。
# [0 H" W) W- V" g6 Y1 t这儿只是完成了USART的配置，下面来看一下对应的I/O设置，仍然在这个文件中可以找到GPIO_Configuration(void)这个函数，程序如下：
; N; J  m9 z5 y  Z1 ]) G% B

1. void GPIO_Configuration(void)
   ' H4 p, b' d2 C! o% b$ W6 ?' @0 Q
2. 
   3 i0 r* j5 [/ @
3. {
   ) g$ i' T( D, z- o
4. 
     e9 k8 m- [+ h
5. GPIO_InitTypeDef GPIO_InitStructure;
   % b" j' ^& [$ T9 O
6. 
   
7. #ifdef USE_STM3210C_EVAL
   
8. 
   
9. /* Enable the USART3 Pins Software Remapping */
   " C/ k# S' D: R2 _& G: \0 N0 @
10. 
    
11. GPIO_PinRemapConfig(GPIO_PartialRemap_USART3, ENABLE);
    
12. 
    
13. /* Enable the USART2 Pins Software Remapping */
    . [% E! T# X# Y9 G/ P- z( i
14. 
    4 }9 h3 A* D& H# e
15. GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);
    
16. 
    1 J& F, P! d( X, c+ e  \# d
17. #elif defined USE_STM3210B_EVAL || defined USE_STM32100B_EVAL
    / J5 _, x/ x; y- ?( K# {9 W
18. 
    # T% b  A' j- k# S! T/ k
19. /* Enable the USART2 Pins Software Remapping */
    
20. 
    7 e+ b3 ?6 T% A. a3 n4 [  \
21. GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);
    5 D1 c4 H% @4 ?4 L
22. 
    # r" W7 R6 B$ l
23. #endif
    , l& M: l5 J; z0 L
24. 
    
25. /* Configure USARTy Rx as input floating */
    
26. 
    0 `5 W% r% y/ G8 L$ T1 X: V
27. GPIO_InitStructure.GPIO_Pin = USARTy_RxPin;
    + t6 G2 S' _+ _) I
28. 
    
29. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
30. 
    ) e, D) A# M/ N% x! r2 {' f
31. GPIO_Init(USARTy_GPIO, &GPIO_InitStructure);
    6 z7 b  r1 u0 v- k0 k/ s
32. 
    ' O& q5 G+ x% R
33. /* Configure USARTz Rx as input floating */
    
34. 
    : Z- d$ W: K" C8 G: z6 U& X3 G
35. GPIO_InitStructure.GPIO_Pin = USARTz_RxPin;
    * M' m# [) b( V
36. 
    5 i  I6 p) s6 {+ f, \1 c
37. GPIO_Init(USARTz_GPIO, &GPIO_InitStructure);
    ! `  Y1 U. R% R$ Y6 [
38. 
    4 j% y% |4 j5 z" Q3 m
39. /* Configure USARTy Tx as alternate function push-pull */
    , T/ O. i5 q8 L9 W( w5 [
40. 
    2 E; ~) \  P2 r7 Z* J
41. GPIO_InitStructure.GPIO_Pin = USARTy_TxPin;
    % U, Y0 X7 A: X# W7 ^
42. 
    & s5 E+ _9 L0 F1 r1 Q) d: E) ^
43. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
44. 
    3 ~& \$ z% p" _$ i1 u& M
45. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    1 _- i. f! l# W
46. 
    
47. GPIO_Init(USARTy_GPIO, &GPIO_InitStructure);
    1 ?( k2 s9 U4 V& Y& ~
48. 
    
49. /* Configure USARTz Tx as alternate function push-pull */
    
50. 
    
51. GPIO_InitStructure.GPIO_Pin = USARTz_TxPin;
    ! Y+ ~2 j* K' R2 t3 |1 O4 L$ \8 {
52. 
    0 s7 n1 H. g! h2 `/ O3 f1 p; }' v
53. GPIO_Init(USARTz_GPIO, &GPIO_InitStructure);
    9 n7 k0 U: K% Y0 Y
54. 
    % A; L# W# ?" f  w5 E9 X$ ]
55. }

复制代码

这段函数完成了相关的I/O配置，首先通过宏定义判断是官方的哪一款开发套件，然后进行相应的端口映射（端口映射请参加官方的数据手册），然后进行相应的端口配置，同串口配置一样，这段程序中德端口用的也是宏定义USARTy_RxPin替代的，改为我们使用的实际I/O，端口时钟设置为50MHz，串口所使用到的端口设置为复用（GPIO_Mode_AF_PP）完成端口初始化。
5 E7 v' o4 d2 \# p4 r$ M5 b% P另外仍然通过观察这个例程可以很容易发现，在使用一个外设时还需要首先打开对应的外设时钟，这部分程序如下：
( v6 I3 B* X- T2 l- Q' b

1. void RCC_Configuration(void)
   1 y4 _% U/ s! w1 `$ v
2. 
   1 Q( \9 p2 S# y2 n
3. {
   
4. 
   1 U* T( i1 r3 B) z5 I1 N: ]6 H  m
5. /* Enable GPIO clock */
   
6. 
   
7. RCC_APB2PeriphClockCmd(USARTy_GPIO_CLK | USARTz_GPIO_CLK | RCC_APB2Periph_AFIO, ENABLE);
   " U: t( c( c; \; d+ b
8. 
   5 ^5 I6 s* _* D1 Y: r
9. #ifndef USE_STM3210C_EVAL
   6 l/ \. ~1 D7 ^
10. 
    
11. /* Enable USARTy Clock */
    ' C0 e% g9 o/ X
12. 
    ' _  R" D5 e6 ?4 {+ Z
13. RCC_APB2PeriphClockCmd(USARTy_CLK, ENABLE);
    
14. 
    
15. #else
    5 n- U( j4 I, U& g4 b  @3 r
16. 
    ( Z) B, R8 Z. C- Q2 b' x8 V
17. /* Enable USARTy Clock */
    $ j1 w7 x- Z( e& F, ~* J! g2 Y
18. 
    # @! u1 B7 i% M1 `' W
19. RCC_APB1PeriphClockCmd(USARTy_CLK, ENABLE);
    
20. 
    
21. #endif
    
22. 
    ; T5 ?5 i8 }  U2 M" ^& T
23. /* Enable USARTz Clock */
    8 f1 [7 R; g0 J# q7 O, t( ~, g9 u
24. 
    
25. RCC_APB1PeriphClockCmd(USARTz_CLK, ENABLE);
    5 k% p) l7 i$ M( O  X
26. 
    1 w& n, i. l) O( P
27. }

复制代码

这段程序中需要注意两点，首先，GPIO、USART等都是连在APB1、APB2两条总线上的，各外设具体的总线连接情况参见图 5‑2，因此首先应该确定外设对应的总线，例如USART1是APB2总线，而USART2是APB1总线。其次使能相应的时钟时不光要使能对应的I/O端口，还要使能总线的复用端口，这点也容易忽略。
% Y) D6 ^" ~" C. b: K最后根据库中的例程，借鉴库中例程的编写风格，就可以得出我们需要的程序，程序在工程的mian.c中编写，函数如下：

1. #include "stm32f10x.h"
   
2. 
   
3. void USART_Configuration(void);
   
4. 
   
5. void GPIO_Configuration(void);
   
6. 
   4 F) R$ s3 d& S  T7 O
7. void Delay(__IO uint32_t nCount);
   8 l( j4 V  ?7 H6 L
8. 
   - n/ d; A! a" b! [* m# c/ c
9. void USART1_Puts(char * str);
   9 ^6 x% d! r" P1 ]7 i
10. 
    
11. int main(void)
    
12. 
      p) \$ n0 [, F8 |
13. {
    
14. 
    
15. USART_Configuration();
    : x6 u# M, O; _0 B( r, r8 w# p8 D# t5 g
16. 
    # X" c+ ~4 c6 |$ \
17. GPIO_Configuration();
    
18. 
    2 R: v% C/ h# O3 g: b3 A  I2 \/ [# s
19. USART1_Puts("Hello Wrold!\n");
    
20. 
    ! E& E6 N+ n' H4 L6 g5 `  h2 G
21. while (1)
    8 M1 _4 [+ [) S: x/ L
22. 
    
23. {
      a- B8 Q! J/ `2 b2 N# q
24. 
    
25. GPIOF->BSRR = 0x000000C0;
    
26. 
    3 }* v% `; V' {4 E* R0 T) V
27. Delay(0xAFFFF);
    0 s6 w. u& V+ X. K7 A) ?! H
28. 
    
29. GPIOF->BRR = 0x000000C0;
    $ I; h% C) ?; r' a1 q2 f2 e
30. 
    7 e# ?0 p6 c+ ~/ d7 J$ X
31. Delay(0xAFFFF);
    
32. 
    
33. USART1_Puts("Hello Wrold!\n");
    
34. 
    9 l( A* Q$ x( {0 H3 s( w+ W4 y. n# _
35. }
    
36. 
    
37. }
    * x& P0 a9 {; R+ _4 s
38. 
    
39. void USART_Configuration(void)
    $ f1 J, M! x; l- I
40. 
    / k8 w- P8 k! Q2 B3 I: a
41. {
    8 s1 ?( F5 f5 w0 W. U" a) n7 Q" {6 E
42. 
    
43. GPIO_InitTypeDef GPIO_InitStructure;
    3 t3 u" W7 V9 b
44. 
    
45. USART_InitTypeDef USART_InitStructure;
    5 J2 E8 U  g* \' o) W) I1 @
46. 
    
47. //使能串口、串口所用的I/O口以及端口复用时钟
    / H! L4 B0 r9 \; T3 f) j; r
48. 
    0 S% c; J6 Q3 q0 \( G, V
49. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1|RCC_APB2Periph_AFIO, ENABLE);
    
50. 
    
51. /* A9 USART1_Tx */
    
52. 
    : A) M. b# q' h3 u/ d. k8 }+ x# Z
53. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
54. 
    8 a! v# L: g& g6 i& q* W
55. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    & Q" S8 {- w8 |3 @- M; P* l
56. 
    $ C6 v! ~( L/ K6 I
57. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //推挽输出-TX
    # |# Y0 T- r2 ?( G
58. 
    + _" z) {4 |* {7 L
59. GPIO_Init(GPIOA,&GPIO_InitStructure);
    - |" b/ [( b/ n0 y' T$ o# ^$ `# ]% w
60. 
    % _6 @# |) s6 Q9 Q+ i
61. /* A10 USART1_Rx */
    ) m0 S1 y0 o+ L- D( X; ^) a
62. 
    8 d: }5 K; z4 i/ S% k; w- g0 X" f2 c4 R
63. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    
64. 
    # m; i3 J0 i; {
65. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入-RX
    , I, v* O6 P9 z: j2 C6 a
66. 
    7 x! M. p4 ?* ^) `
67. GPIO_Init(GPIOA, &GPIO_InitStructure);
    7 X3 P# T3 F' K7 g- i3 v
68. 
    % k) N$ n- Z7 u
69. USART_InitStructure.USART_BaudRate = 9600;
    ( }, B# d/ j# l7 P$ B
70. 
    ' b! a/ K( g) ?" K0 R8 x
71. USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    , S- g: \; ?' [" Q8 O6 U. ?9 I
72. 
    
73. USART_InitStructure.USART_StopBits = USART_StopBits_1;
    1 N! @6 p0 {5 W& J5 U0 x0 E3 E
74. 
    1 A3 V6 T5 J9 t& q
75. USART_InitStructure.USART_Parity = USART_Parity_No;
    
76. 
    
77. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
78. 
    
79. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    ( C( {& y, b, n
80. 
    
81. USART_Init(USART1, &USART_InitStructure);
    % V0 V: o) `( m" e- X
82. 
    8 G4 J$ x2 S7 k( x; T5 }1 e; ?
83. /* Enable the USARTx */
    2 _/ l& ~9 m2 E2 Y, v
84. 
    
85. USART_Cmd(USART1, ENABLE);
    8 S$ f. z$ n1 e: S/ J1 W  L8 s+ ]
86. 
    
87. }
    
88. 
    
89. void GPIO_Configuration(void)
    
90. 
    
91. {
    
92. 
    
93. GPIO_InitTypeDef GPIO_InitStructure;
    % x) \# q5 s/ E0 F
94. 
    
95. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF, ENABLE);
    5 o3 k- g- u/ F& f6 e: q
96. 
    ( `( Z. H0 {6 X) F0 S
97. /* 设置LED对应的引脚 */
    
98. 
    # [4 b9 v. P' N
99. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
    2 [/ l: _+ F+ c9 w9 \0 o; _8 t
100. 
     1 P. b8 r# O6 z9 _3 H4 C' u; ]0 i
101. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
102. 
     ) c/ ]7 i4 H' ?! E5 R+ R/ G* f# R! X
103. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
104. 
     7 j, c& D; H: _, {  h
105. GPIO_Init(GPIOF, &GPIO_InitStructure);
     
106. 
     
107. }
     
108. 
     4 W) V: _! c) Q' P$ u! I3 r
109. void Delay(__IO uint32_t nCount)
     6 ~$ O; @0 F3 m) u+ S; M
110. 
     ( J% I1 n* L" O7 z
111. {
     ; }+ c! D8 g7 D$ G
112. 
     0 a+ w" J" K1 o' K. C$ R! W
113. for(; nCount != 0; nCount--);
     
114. 
     
115. }
     
116. 
     1 A! [. B- F- _# F: e1 p" f
117. void USART1_Puts(char * str)
     ' o1 o6 G5 E4 \3 v' x
118. 
     
119. {
     . {* s1 l4 I& }) f/ O6 E4 x# I0 c+ w
120. 
     # b8 k' T5 x3 I. _+ S& \
121. while(*str)
     , }3 q' }6 Y. o7 q4 c3 M5 o
122. 
     
123. {
     # F) `2 _& x6 O" Q- H+ \
124. 
     
125. USART_SendData(USART1, *str++);
     
126. 
     
127. /* Loop until the end of transmission */
     , j1 ]. \+ B. i+ i  j$ @" l, B
128. 
     . H! T2 ?7 n% Y
129. while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
     
130. 
     4 z5 V' v4 Y& T8 S+ x0 X
131. }
     4 ^, t1 Z9 l9 X
132. 
     
133. }

复制代码

至此完成了主函数的编写。接下来还需要到stm32f10x_conf.h文件中选择相应的头文件，这儿去掉需要使用的头文件之前的注释，去掉注释的头文件如下：
l #include "stm32f10x_gpio.h"
7 z& N8 E: S9 s. ~1 E" ~' Ql #include "stm32f10x_gpio.h"
l #include "stm32f10x_usart.h"
+ [7 @- `/ v. W# W0 |6 ~, O这样，我们的程序编写就完成了，下面可以进行我们的编译与调试了。
9 [' I$ L+ O( A0 ]0 E
2. 程序的编译
" y) X% l" g3 p& c7 q" x+ V在Keil MDK的工具栏上自左至右依次有 三个图标，分别为编译指定文件、生成工程、重新生成所有工程。首先在mian.c下点击编译图标，如果编译没有错误，则输出窗口如图 5‑26所示。如果编译存在错误，点击错误的地方可以直接定位到错误行，根据错误提示进行修改。
) {+ ]0 P! v. T* x8 @

图 5‑26 编译输出窗口

; [3 r' f3 y. q
# Y8 b# r) c+ r( Y0 x
编译不存在错误后点击clip_image008[6]图标生成工程，生成没有错误则输入如图 5‑27所示。如果存在错哦无则可以直接点击对应的错误跳转到对应的文件对应的行，根据错误提示进行再次修改。

图 5‑27 生成工程输出窗口

第一次生成工程成功以后，如果修改了相应的文件再次点击生成工程时只会对有改动的文件进行重新编译、生成，而重新生成全部工程会重新生成工程中的所有文件。

0 I3 C+ D0 x7 K) Q4 y8 w# g3. 程序的调试
3 _" X3 D3 l$ N在实际开发时，可以首先利用软件进行仿真，利用软件进行仿真查看具体的寄存器配置，外设的工作情况等，同时通过断点的配合可以查找出程序中绝大多数的错误。软件仿真完成后可以下载到硬件平台去运行，如果程序仍然没有达到需要的效果，在硬件检查完成后可以使用在线仿真的方式，在硬件平台上直接运行程序，进一步查找问题。
首先，先看一下这个小程序的软件仿真，首先在工程设置Debug选项中选择使用软件模拟，如图 5‑28所示。
/ a0 o4 A, n. V

4 w' R3 o  H" P# P4 k

' V3 e$ g7 L) e; x4 v2 P

图 5‑28 Debug设置选项窗口

4 Z) m1 N) s* [4 U  x" t
* M  H* @- p$ T* z7 f! |, ^% f+ s
& m8 c/ q- t9 u2 o点击 图标，或者从菜单栏-Debug启动调试。启动后界面如图 5‑29所示。调试启动后自动运行到主程序。
3 T5 J1 J5 v  @8 u5 Y) m) S
7 I3 R: `2 j# K) J! j

) t9 F( w. E* K8 ], ?- L

图 5‑29 调试主界面

' O7 h( I+ s  Q% e: M+ ^
( A- z' X/ A& y8 z$ u0 e在工具栏可以找到与调试相关的快捷图标 ，同样在菜单栏Debug菜单下可以找到对应的选项，自左向右分别为复位，运行，点击后直接运行程序；停止，运行时点击停止当前运行；单步，单步执行当前程序；跳过，可以直接跳过子函数的运行；跳出，在某个子函数中运行时可以直接跳出当前函数；运行到光标位置处。
在程序行号的左侧直接双击可以非常方便的添加或者取消断点，如图 5‑30所示。

图 5‑30 断点的添加与取消

/ h( O  ?2 t5 g/ o0 Z

" ^/ k# u% J6 O: ?2 T在菜单Peripherals中可以打开需要查看的外设，这里点击Peripherals-USART1弹出USART1的相关观察窗口，点击运行后，窗口如图 5‑31所示，就会显示运行的程序对USART1所完成的相关配置。从中可以清晰的看出，程序对USART1的相关寄存器配置，从地面Settings一栏中则可以直观的看出USART1当前的工作状态，从这儿就可以检查我们的相关参数设置正确与否，对应时钟有无开启等。需要说明的是这里寄存器在进行仿真的时候是可以进行改写的，也就是说允许我们在程序运行的时候直接进行相关的操作来观察运行结果。但是此时程序本身也是可以对寄存器进行操作的，因此直接更改相应的寄存器观察时还要注意你的操作是否和程序冲突。例如在本程序的运行过程中如果将寄存器中发送使能TE的勾给去掉，则串口就不会在输出数据。

& E8 J1 ~4 t4 y( G+ A3 p6 D& G

. K0 t3 S# ~# _

; }$ |% Z# D6 H& q( `8 l

图 5‑31 USART1寄存器观察窗口

2 r8 U  J6 z, }5 }: g8 z4 V
& U: |0 A( d8 a/ j$ e# u' _
% d" e3 m4 g2 c5 ?; Y接下来继续查看I/O的配置，本程序中使用的是F端口，则点击菜单Peripherals-General-Purpose I/O，选择GPIOF，出现GPIOF的配置窗口，程序运行后可以通过窗口查看GPIOF的相关配置，如图 5‑32所示。在这个窗口中可以查看引脚的配置情况，当程序运行时就能看到对应引脚的勾在闪烁。
: i$ z0 W8 m' t. A+ `# Y4 c3 R+ f
1 b: v* J- \# p( u

. Q6 M6 T. W/ [$ }9 ^) r; _

图 5‑32 GPIOF寄存器观察窗口

, k4 |( Y: w1 f3 J6 Z' \- L
通过这些操作，可以非常方便、直观的查看程序运行后对应的配置是否与我们预想的一致，那么在本程序中通过串口输出了“Hello World！”又该怎样查看运行结果呢？在工具栏 中可以非常方便的打开相应的查看窗口，查看相关寄存器和外设等。由于我们需要使用串口1输出字符，同时LED闪烁显示，因此首先打开串口1的输出，点击 择UART#1即可打开UART的输出窗口，运行程序后会在此窗口中输出串口信息，如图 5‑34所示。

" u6 y$ V' D% L  Q2 b6 ~
1 F* V( Y* \& F

- B1 P2 R3 p" J

图 5‑33 打开UART1输出窗口

  A' _, ]2 A8 x' Z( e3 W" ]8 L

图 5‑34 UART1输出窗口

3 E/ i  u9 b! z; ~8 k, j. A9 p
至此，已经利用Keil MDK的软件仿真功能完成了程序的调试，看到了设计的效果。通过这个例子也能够让我们深刻的体会到Keil MDK在线调试功能的强大之处。接下来我们将编写好的程序下载到开发板中运行，看看运行效果。

3 x3 Y" m! w' B2 {# Y" }; M4. 程序的下载
编写好的程序工程生成完成后下载到硬件平台的方法有很多种，一是直接利用Flash烧写工具烧写相应的hex文件，在工程配置时需要设置才能生成hex文件，具体设置参加图 5‑16，生成hex文件之后就可以利用烧写工具烧写到硬件平台，常用的仿真器都带有相应的软件工具，如笔者使用的JLink-V8，可以使用自带的J-Flash工具，使用J-Flash工具如图 5‑35所示，在工程管理中选择所使用的硬件平台，点击Target-Connect后就可以连接上硬件平台，在图中左侧显示了仿真器以及对应的硬件平台信息。然后选择所生产的hex文件，就可以讲编译的程序下载到硬件平台中。

$ P2 U1 A7 K6 Z# c  f

图 5‑35 J-Flash主界面

这种下载方式非常适合将程序源码不公开的情况下将程序固件提供给第三方使用，然而在使用Keil MDK时还有更为方便的方式，在工程设置中设置好了下载工具后可以点击 图标，直接将程序下载到硬件平台中运行，非常方便。在使用仿真器进行在线仿真时也可以通过设置在在线仿真时将程序下载到flash中。
程序下载到硬件平台后通过实际的串口来查看程序运行情况了，将硬件平台的串口1连接至PC，笔记本等电脑上没有物理串口的可以使用USB转串口设备，注意在设备管理器中查看实际所分配的串口号，本机分配的串口号为COM4，如图 5‑36所示，串口号也可以在高级选项中进行更改。

2 d8 W% v3 `7 h) ]0 {7 U5 E3 k+ F

$ i- T8 P6 y+ [, |

图 5‑36 设备管理器中查看串口号

' u8 z2 U6 R- `% [' d2 s2 @6 ]
: a/ ~8 e: C) p8 O
这里使用本章所介绍的TKStudio中的串口调试助手工具来进行查看，设置串口的相应参数与程序一致，串口设置于运行结果如图 5‑37所示，从图中可以看出串口接数据正确，开发板上的两个LED也在不停闪烁。
/ t4 Z! t- U# q: p. ^

" ~$ g7 K+ @3 w) D# s/ }# c3 P

图 5‑37 串口调试助手运行界面

/ T4 q! s; ?; X: i# J, Z) j
# }8 g7 x8 r+ ^8 S* H( u% m
至此，我们完成了一个简单的程序开发过程。本小节通过实现串口输出与LED闪烁的功能系统的介绍了怎样基于标准外设库进行程序的开发与调试，这儿只是列举了一个非常简单的小例子，更多的联系读者可以参考标准外设库中的例程自行完成。
/ M% E; J5 K/ x- ]* [
: J/ C5 y  r6 X2 D0 k/ f
1 K: I% _8 n/ g/ W, X
转载自：emouse 思·睿