前言
5 j% ?# \6 ^/ d

9 u& u6 K8 S1 S: b" u3 H    测试代码的运行时间的两种方法：
5 [/ x! b! o: U0 x( D( Q4 g& F使用单片机内部定时器，在待测程序段的开始启动定时器，在待测程序段的结尾关闭定时器。为了测量的准确性，要进行多次测量，并进行平均取值。
( k+ E8 \) j+ d% |借助示波器的方法是：在待测程序段的开始阶段使单片机的一个GPIO输出高电平，在待测程序段的结尾阶段再令这个GPIO输出低电平。用示波器通过检查高电平的时间长度，就知道了这段代码的运行时间。显然，借助于示波器的方法更为简便。
8 Z% D; B' i) g# Z借助示波器方法的实例

& m$ Q+ V" O. I% a# a9 z
Delay_us函数使用STM32系统滴答定时器实现：
7 [: w* d/ k* k. Y2 g' |; g

1. 
   0 E9 V7 C: R" w1 H% l$ T
2. #include "systick.h"
   
3. 
   
4. /* SystemFrequency / 1000    1ms中断一次
   . q: x4 u3 z/ U1 B) z9 [- z5 V7 x
5. * SystemFrequency / 100000     10us中断一次
   
6. * SystemFrequency / 1000000 1us中断一次
   
7. */
   
8. 
   
9. #define SYSTICKPERIOD                    0.000001
   
10. #define SYSTICKFREQUENCY            (1/SYSTICKPERIOD)
    . u8 @, G" Q' f) ^/ ~5 s
11. 
    
12. /**
    
13.   * @brief  读取SysTick的状态位COUNTFLAG
    
14.   * @param  无
    . g% {' K) G- g' H
15.   * @retval The new state of USART_FLAG (SET or RESET).
    
16.   */
    5 L2 n2 {: E) c# Y4 A/ t
17. static FlagStatus SysTick_GetFlagStatus(void)
    ) v0 Q& L! h: x7 k- w' _0 K" W
18. {
    
19.     if(SysTick->CTRL&SysTick_CTRL_COUNTFLAG_Msk)
    
20.     {
    ; t/ M8 F8 ^! n
21.         return SET;
    8 S9 X" S8 A$ f* C2 o
22.     }
    5 y% D" n4 S6 j& A, G+ J
23.     else
    
24.     {
    6 m6 t. G! V9 q6 H5 k
25.         return RESET;
    
26.     }
    % {7 l' C8 k7 }# K0 U+ ~
27. }
    - ]3 Y7 m) Z9 @1 Z& B, |
28. 
    " d  v" M# u5 r( K
29. /**
    
30.   * @brief  配置系统滴答定时器 SysTick
    
31.   * @param  无
    
32.   * @retval 1 = failed, 0 = successful
    
33.   */
    ! C+ [8 f$ d" P' m" L7 ]$ v
34. uint32_t SysTick_Init(void)
    
35. {
    
36.        /* 设置定时周期为1us  */
    ! u) k# {! Z% m& G5 E& ?7 B
37.     if (SysTick_Config(SystemCoreClock / SYSTICKFREQUENCY))
    " w+ C" K. \2 U/ ^" ~4 w
38.     {
    
39.         /* Capture error */
    5 V9 U+ |- D1 z+ f# V* g; o
40.         return (1);
    " f2 F5 F& g* x: `. d. p
41.     }
    - ]& i- t! W" f& Z$ Q% f1 u
42. 
    * u3 ^* [- z) A& @
43.     /* 关闭滴答定时器且禁止中断  */
      [/ O3 u" Q  }  I
44.     SysTick->CTRL &= ~ (SysTick_CTRL_ENABLE_Msk | SysTick_CTRL_TICKINT_Msk);                                                  
    ' k$ r8 d" v. E8 w! i* _
45.     return (0);
    
46. }
    : M( O' l; v5 W4 m: Z
47. 
    
48. /**
    * T, h7 M% k; v) L% P
49.   * @brief   us延时程序,10us为一个单位
    
50.   * @param  
    4 b# N$ c1 p0 K$ {4 K" H
51.   *        @arg nTime: Delay_us( 10 ) 则实现的延时为 10 * 1us = 10us
    1 p# b% g4 m8 T: r" @, r) |/ h1 A
52.   * @retval  无
    
53.   */
    
54. void Delay_us(__IO uint32_t nTime)
    - ?1 _5 L9 ^1 p7 B, @
55. {     
    
56.     /* 清零计数器并使能滴答定时器 */  
    " w4 G- `, a8 y
57.     SysTick->VAL   = 0;  
    
58.     SysTick->CTRL |=  SysTick_CTRL_ENABLE_Msk;     
    
59. 
    
60.     for( ; nTime > 0 ; nTime--)
    5 R) o) M. f% S" P4 Q6 Z, |
61.     {
    
62.      /* 等待一个延时单位的结束 */
      b7 M+ t; b- i+ m9 u  e! d3 n
63.      while(SysTick_GetFlagStatus() != SET);
    8 b9 }7 x' A5 c, t% \
64.     }
    0 x" P* u+ T$ E* B8 O: @
65. 
    ) W0 `+ J$ o% {5 K9 Z
66.     /* 关闭滴答定时器 */
    ( \+ p5 o: u0 C5 z2 f9 _% [' L
67.     SysTick->CTRL &= ~ SysTick_CTRL_ENABLE_Msk;
    ! z# x% x" p( C/ ?. X0 ^
68. }

复制代码

检验Delay_us执行时间中用到的GPIO(gpio.h、gpio.c)的配置：

1. 
   
2. #ifndef __GPIO_H
   
3. #define    __GPIO_H
   
4. 
   
5. #include "stm32f10x.h"
   
6. 
   $ e( S; `- S0 A. O
7. #define     LOW          0
   $ V- A8 V8 N, J5 S1 Z
8. #define     HIGH         1
   ) d& R% j9 O5 i$ G; Z
9. 
   
10. /* 带参宏，可以像内联函数一样使用 */
    
11. #define TX(a)                if (a)    \
    
12.                                             GPIO_SetBits(GPIOB,GPIO_Pin_0);\
    
13.                                         else        \
    
14.                                             GPIO_ResetBits(GPIOB,GPIO_Pin_0)
      P% ?9 Q; u6 K1 X, [; d% C* U
15. void GPIO_Config(void);
    
16. 
    
17. #endif
    ( P' F+ X) K6 C( R! ~
18. 
    ; v, D: _' e* h! V2 @6 n
19. #include "gpio.h"   
      h7 g3 Q/ [1 [; e9 H7 H
20. 
    4 L3 K' V( R! H' p+ I
21. /**
    
22.   * @brief  初始化GPIO
    ; G. |. s& k* d  P; M
23.   * @param  无
    8 o) U& ^7 s) x% b
24.   * @retval 无
    
25.   */
    
26. void GPIO_Config(void)
    
27. {        
    ( `. ~2 W; G: }8 v' l- j2 N
28.         /*定义一个GPIO_InitTypeDef类型的结构体*/
    
29.         GPIO_InitTypeDef GPIO_InitStructure;
    ' ]! X9 n5 Z& R3 o
30. 
    
31.         /*开启LED的外设时钟*/
    2 K: k0 t% c5 Q' `
32.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE);
    
33.                                                            
    
34.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;   
    6 v7 L( ?( s- U* {) o; {
35.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;     
    . N2 k; ~9 @% f/ T9 f
36.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
37.         GPIO_Init(GPIOB, &GPIO_InitStructure);   
    
38. }
    + f& Z2 P' b9 j8 F

复制代码

在main函数中检验Delay_us的执行时间：

1. 
   
2. #include "systick.h"
   / b! Q- ?$ X9 j9 A2 I
3. #include "gpio.h"
   8 P& ?, M8 q: v+ c' V
4. 
   ! ~" D( v* a, f/ E5 ?
5. /**
   
6.   * @brief  主函数
   
7.   * @param  无  
   5 `% {: N+ I! a: H" c( j9 _8 V
8.   * @retval 无
   
9.   */
   0 j* C* m; `% c) C$ T* f9 w* K
10. int main(void)
    
11. {   
    
12.     GPIO_Config();
    
13. 
    7 b/ w1 J7 F  j; O' c- Z% @/ N& ?
14.     /* 配置SysTick定时周期为1us */
    
15.     SysTick_Init();
    8 U6 h7 R1 `$ D9 f9 Z
16. 
    . E. E7 P. u  d. s+ b# N: `
17.     for(;;)
    3 l/ y. G+ [5 y0 b
18.     {
    
19.         TX(HIGH);
    + t" B" j1 k5 q" k  |- s, B/ Q$ @
20.         Delay_us(1);
    
21.         TX(LOW);
    9 H8 G1 h2 G# t- j
22.         Delay_us(100);
    
23.     }     
    0 T2 t$ @$ v9 m1 |8 \
24. }
    

复制代码

示波器的观察结果：

可见Delay_us(100)，执行了大概102us，而Delay_us(1)执行了2.2us。


& s, p8 m7 r  N更改一下main函数的延时参数：

1. 
   
2. int main(void)
   
3. {   
   
4.     /* LED 端口初始化 */
   , l/ B+ i% s8 j# w
5.     GPIO_Config();
   
6. 
   
7.     /* 配置SysTick定时周期为1us */
   ) {, E1 F2 u/ N& U& a: X# O
8.     SysTick_Init();
   / u6 D" K2 @+ [
9. 
   
10.     for(;;)
    
11.     {
    2 G% K/ M9 n" p9 T3 s; M
12.         TX(HIGH);
    
13.         Delay_us(10);
    ! ]; J) V% e0 [, ?0 \
14.         TX(LOW);
    , i1 B2 {7 e1 i5 ^
15.         Delay_us(100);
    
16.     }     
    
17. }

复制代码

示波器的观察结果：

5 [% J) N) b# y. O  ^$ ~" m# R
6 \  H2 N' k$ y) q7 T可见Delay_us(100)，执行了大概101us，而Delay_us(10)执行了11.4us。


结论：此延时函数基本上还是可靠的。
4 ?/ ]) m, h; R2 K, \9 l4 f

使用定时器方法的实例
0 H* a8 D9 \) R
Delay_us函数使用STM32定时器2实现：
0 V+ T* ~; T# G
8 ?  X1 t8 P; v- ~" C

1. 
   8 @6 c. `# V2 d" m
2. #include "timer.h"
   
3. 
   
4. /* SystemFrequency / 1000            1ms中断一次
   
5. * SystemFrequency / 100000     10us中断一次
   
6. * SystemFrequency / 1000000         1us中断一次
   
7. */
   / |2 j" P1 ~: h: i$ L' G+ k
8. 
     w$ N) J* k( s
9. #define SYSTICKPERIOD                    0.000001
   
10. #define SYSTICKFREQUENCY            (1/SYSTICKPERIOD)
    6 }4 ]# u% u* e) O! c
11. 
    
12. /**
    " {; _& \6 V9 W! m+ S; J, v4 b
13.   * @brief  定时器2的初始化,，定时周期1uS
    
14.   * @param  无
    
15.   * @retval 无
    " Y0 _/ i0 |0 f$ L* i3 i" |
16.   */
    
17. void TIM2_Init(void)
    
18. {
    0 h0 \  I+ P( J' h
19.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    * ~8 U( P% y6 k% _8 m# q& E3 U
20. 
    " V1 X& p* E+ C- A
21.     /*AHB = 72MHz,RCC_CFGR的PPRE1 = 2，所以APB1 = 36MHz,TIM2CLK = APB1*2 = 72MHz */
    
22.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    3 {3 f' j: m0 \( ~4 C
23.    
    
24.     /* Time base configuration */         
    : B2 H% y2 x( K- ?
25.     TIM_TimeBaseStructure.TIM_Period = SystemCoreClock/SYSTICKFREQUENCY -1;
    " Z/ ~  K; n6 M1 C1 m7 D
26.     TIM_TimeBaseStructure.TIM_Prescaler = 0;
    
27.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    
28.     TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
    ; {! b% w8 }9 C& K! |: ^1 ^
29.    
    / R$ F) F7 p: B) K+ P7 @& C6 ~3 T
30.     TIM_ARRPreloadConfig(TIM2, ENABLE);
    % x1 w4 v: N& u9 w  C5 n
31.    
    " K! K9 Z2 a1 ]% A
32.     /* 设置更新请求源只在计数器上溢或下溢时产生中断 */
    3 H: ^- p  _" x" R5 n
33.     TIM_UpdateRequestConfig(TIM2,TIM_UpdateSource_Global);
    
34.     TIM_ClearFlag(TIM2, TIM_FLAG_Update);
    ) V7 ]# T4 A; w7 [
35. }
    % w% z- d6 K( j5 |- {3 u
36. 
    
37. /**
    7 l- A2 Q% s& U
38.   * @brief   us延时程序,10us为一个单位
    1 K% p; g& }+ \9 `8 i
39.   * @param  
    " s' L8 c9 P$ b% ?. c3 }
40.   *        @arg nTime: Delay_us( 10 ) 则实现的延时为 10 * 1us = 10us
    
41.   * @retval  无
    
42.   */
    2 n$ c8 L7 H3 F- m2 U: l7 Y
43. void Delay_us(__IO uint32_t nTime)
    
44. {     
    7 x; n, r1 i" ^
45.     /* 清零计数器并使能滴答定时器 */  
    
46.     TIM2->CNT   = 0;  
    $ U$ x- @6 r4 |% Z. v8 v
47.     TIM_Cmd(TIM2, ENABLE);     
    
48. 
    ( m4 p% p# y$ D2 [
49.     for( ; nTime > 0 ; nTime--)
    
50.     {
    , R& i( w! Z1 P0 N1 p, X
51.      /* 等待一个延时单位的结束 */
    
52.      while(TIM_GetFlagStatus(TIM2, TIM_FLAG_Update) != SET);
    & X( T9 J- v# q" r) A$ u
53.      TIM_ClearFlag(TIM2, TIM_FLAG_Update);
    
54.     }
    4 Y2 @  T% I2 @$ G8 Q  H
55. 
    ( X$ l* F6 ^, J. v5 p- _% k: c
56.     TIM_Cmd(TIM2, DISABLE);
    
57. }

复制代码

在main函数中检验Delay_us的执行时间：

1. 
   
2. #include "stm32f10x.h"
   
3. #include "Timer_Drive.h"
   ! a* Y; b* }( V9 A) M
4. #include "gpio.h"
   " w2 |- |2 E9 P9 o0 V4 U
5. #include "systick.h"
   
6. 
   
7. TimingVarTypeDef Time;
   ! Q# p$ ?/ Q$ K7 Y1 [" S" G* S9 d
8. 
   % ~6 Z9 l: y9 m- K
9. int main(void)
   : r) [. a6 z& v) a. R! q) j) x, O
10. {   
    " h) p; Q4 W. O- u
11.     TIM2_Init();   
    $ {5 H( j( k9 G/ d7 Y
12.     SysTick_Init();
    / r% B8 g9 e! _, z  V7 {
13.     SysTick_Time_Init(&Time);
    3 U' M9 E  I6 c2 d" d
14.    
    
15.     for(;;)
      I. V. U( u8 r' g, B7 n, C4 V/ e
16.     {
    4 z; w5 z2 ]8 ^6 C$ P
17.         SysTick_Time_Start();
    / ?8 D8 }; G: `& A+ j( Z0 H
18.         Delay_us(1000);
    % k  K: a$ f" F3 e) B5 Q2 _1 a
19.         SysTick_Time_Stop();
    
20.     }     
    
21. }

复制代码

怎么去看检测结果呢？用调试的办法，打开调试界面后，将Time变量添加到Watch一栏中。然后全速运行程序，既可以看到Time中保存变量的变化情况，其中TimeWidthAvrage就是最终的结果。

& T$ b2 R/ M/ e0 [% B# Q可以看到TimeWidthAvrage的值等于0x119B8,十进制数对应72120，滴答定时器的一个滴答为1/72M（s），所以Delay_us(1000)的执行时间就是72120*1/72M (s) = 0.001001s，也就是1ms。验证成功。


: b1 w- H6 t! `+ W% r备注：定时器方法输出检测结果有待改善，你可以把得到的TimeWidthAvrage转换成时间（以us、ms、s）为单位，然后通过串口打印出来，不过这部分工作对于经常使用调试的人员来说也可有可无。


; }! E2 @3 M6 i" G. ]& P- ~3 l两种方法对比

- _* z4 _! J1 K9 `* i
软件测试方法
3 P4 o5 M. W' Z  M, E9 \) v
' |; p  q: v9 |2 D: U1 m
操作起来复杂，由于在原代码基础上增加了测试代码，可能会影响到原代码的工作，测试可靠性相对较低。由于使用32位的变量保存systick的计数次数，计时的最大长度可以达到2^32/72M = 59.65 s。

& N" z# z4 H. V3 p/ O* s4 V4 g% T
示波器方法
2 i# @$ c9 |0 [1 U

操作简单，在原代码基础上几乎没有增加代码，测试可靠性很高。由于示波器的显示能力有限，超过1s以上的程序段，计时效果不是很理想。但是，通常的单片机程序实时性要求很高，一般不会出现程序段时间超过秒级的情况。
* l4 b6 v  y# |
6 S2 Q" _) t9 I3 z: G9 [


% c6 ]( `, e, d. r9 A8 ?
$ u. k" E( ]* q* s% O
; l; N, L2 ~6 z% w' I9 c6 l$ a* x

8 G# \" b' j0 h7 z; S
* I: z6 C" u% G0 J1 V; q1 {