前言


测试代码的运行时间的两种方法：


: [3 Y/ G) V3 I% L1、使用单片机内部定时器，在待测程序段的开始启动定时器，在待测程序段的结尾关闭定时器。为了测量的准确性，要进行多次测量，并进行平均取值。

: u# P0 ^  S% L$ `7 w% O' k0 B
2、简便。

1 X3 x: V% O) r# n; p) D1 @1 r
7 S" |% X" F9 Y1 d5 q借助示波器方法的实例
5 e  o6 p( h) `3 {    Delay_us函数使用STM32系统滴答定时器实现：

1. #include "systick.h"
   
2. 
   ) Q0 q  O0 d. ?. x9 q  `% U
3. /* SystemFrequency / 1000    1ms中断一次
   ' W. K( F. e" Q3 n4 z9 R
4. * SystemFrequency / 100000     10us中断一次
   4 r, X. I  M9 w% ~* j
5. * SystemFrequency / 1000000 1us中断一次
   $ Y0 _( e, \" ~/ \) |9 W
6. */
   : B/ T- ~9 N% l/ K/ C
7. 
   8 f( V. ?3 v# q
8. #define SYSTICKPERIOD                    0.000001
   4 P/ Y3 B  j" P4 X( {0 S. g
9. #define SYSTICKFREQUENCY            (1/SYSTICKPERIOD)
   7 a4 z9 D. a/ j9 M4 C% o
10. 
    
11. /**
    
12.   * @brief  读取SysTick的状态位COUNTFLAG
    / g5 D6 F3 H# N/ l4 ~
13.   * @param  无
    3 v- \. {# H  w9 f: i
14.   * @retval The new state of USART_FLAG (SET or RESET).
    , d8 c- g  i2 x5 C
15.   */
    
16. static FlagStatus SysTick_GetFlagStatus(void)
    
17. {
    3 T( _; j: Z7 d  `& q9 o# @
18.     if(SysTick->CTRL&SysTick_CTRL_COUNTFLAG_Msk)
    
19.     {
    5 ?/ z& ]1 w7 r/ [& H; A% I
20.         return SET;
    
21.     }
    . ~* m- R( ^4 d1 J$ {# {
22.     else
      b( A. c8 f2 l- T0 Z
23.     {
    
24.         return RESET;
    # f7 f# w" w- I* L% B) q& v
25.     }
    2 u/ i5 o) V3 Q4 K
26. }
    
27. 
    2 |; V6 |4 c' P: {
28. /**
    9 M  {, \5 Z1 @5 E) f4 D4 ]
29.   * @brief  配置系统滴答定时器 SysTick
    ' G" R4 o6 T1 t9 ^% p. J
30.   * @param  无
    
31.   * @retval 1 = failed, 0 = successful
    
32.   */
    
33. uint32_t SysTick_Init(void)
    # z+ f( s% M+ O& d
34. {
    
35.        /* 设置定时周期为1us  */
    
36.     if (SysTick_Config(SystemCoreClock / SYSTICKFREQUENCY))
    
37.     {
    & u# E8 @7 Y! R# x% e
38.         /* Capture error */
    
39.         return (1);
    ! c' c  j5 d* t1 r* B/ m0 D9 s
40.     }
    
41. 
    8 A' i7 ~7 G# O
42.     /* 关闭滴答定时器且禁止中断  */
    
43.     SysTick->CTRL &= ~ (SysTick_CTRL_ENABLE_Msk | SysTick_CTRL_TICKINT_Msk);                                                  
    
44.     return (0);
    
45. }
    
46. 
    5 e' w0 {5 U. }+ j6 v7 R
47. /**
    6 R/ O$ V9 T% }# \
48.   * @brief   us延时程序,10us为一个单位
      _+ k5 |, }4 [2 m: j: C6 b
49.   * @param  
    
50.   *        @arg nTime: Delay_us( 10 ) 则实现的延时为 10 * 1us = 10us
    
51.   * @retval  无
    
52.   */
    " i8 w1 d" l; |( l, H  i
53. void Delay_us(__IO uint32_t nTime)
    * E& X& J7 R# N% T
54. {     
      J: h1 ~* k. a% j5 L
55.     /* 清零计数器并使能滴答定时器 */  
    ! ]9 f1 d- v$ d. D
56.     SysTick->VAL   = 0;  
    6 C4 a7 M9 h7 T4 u
57.     SysTick->CTRL |=  SysTick_CTRL_ENABLE_Msk;     
    ) I' j2 u+ Y- L8 ^$ h& b
58. 
    # Z! I" |4 |) L5 q% S) t/ Y
59.     for( ; nTime > 0 ; nTime--)
    
60.     {
    $ I$ N. T& }% q- Q; \
61.      /* 等待一个延时单位的结束 */
    5 S' [4 s0 a7 C5 J9 K$ _& G
62.      while(SysTick_GetFlagStatus() != SET);
    7 u* i. ~$ h- g  r( d' B3 J
63.     }
    
64. 
    ( I! A7 F3 _+ ^, I% k
65.     /* 关闭滴答定时器 */
    
66.     SysTick->CTRL &= ~ SysTick_CTRL_ENABLE_Msk;
    
67. }

复制代码

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

1. #ifndef __GPIO_H
   6 G+ M( _% l! e6 m# \& N$ A  d
2. #define    __GPIO_H
   
3. 
   2 ?" R' L/ V( R5 E) C+ m! G9 u# i
4. #include "stm32f10x.h"
   7 |) g3 R4 p, w) b) C
5. 
   
6. #define     LOW          0
   ! r! E' C2 i9 f8 N# f
7. #define     HIGH         1
   3 Z9 u2 g( x* g0 X! s$ Y, T8 |
8. 
   
9. /* 带参宏，可以像内联函数一样使用 */
   - e5 X3 F3 m& o1 V! L2 _
10. #define TX(a)                if (a)    \
    
11.                                             GPIO_SetBits(GPIOB,GPIO_Pin_0);\
    
12.                                         else        \
    * i3 f( i) X' H) c* m" n
13.                                             GPIO_ResetBits(GPIOB,GPIO_Pin_0)
    : x7 l$ O1 b8 R$ ~1 v- h
14. void GPIO_Config(void);
    
15. 
    / Q4 T  |- P" H9 Q
16. #endif
    % R$ y! `" ~, T  I' n, C9 ^9 r
17. 
    5 A7 `+ g: s7 E: c4 E- I3 T6 K
18. #include "gpio.h"   
    
19. 
    
20. /**
    3 P% e  U6 n3 y. k0 s2 ~5 @
21.   * @brief  初始化GPIO
    + X; p, s+ l) ?1 W3 [
22.   * @param  无
    
23.   * @retval 无
    
24.   */
    # {9 t+ A$ E% {5 O9 P0 [# ^( g
25. void GPIO_Config(void)
    
26. {        
    
27.         /*定义一个GPIO_InitTypeDef类型的结构体*/
    9 A. g7 B2 U. e" e1 x9 J3 z  L
28.         GPIO_InitTypeDef GPIO_InitStructure;
    
29. 
    : D8 N; p9 ]0 v/ e! X5 ^
30.         /*开启LED的外设时钟*/
    ( M5 b% |! B+ h  Z. w% u
31.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE);
    
32.                                                            
    
33.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;   
    
34.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;     
    
35.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
36.         GPIO_Init(GPIOB, &GPIO_InitStructure);   
    - O2 ]2 H) ?/ v3 h; l2 G4 {
37. }

复制代码

  在main函数中检验Delay_us的执行时间：
' M. d$ i6 \; L! C
# f1 W! b+ y3 k

1. 
   & H, a4 R8 @: H1 K  ?$ [3 U
2. #include "systick.h"
   - [+ I( W# G3 E3 d9 _7 ?& d* x
3. #include "gpio.h"
   1 O" g$ g" n0 \) l6 L0 B
4. 
   " g6 y. c% Q) l" b; i$ O: l/ G
5. /**
   
6.   * @brief  主函数
     m3 {+ v  U% q5 F; p& |0 i' H
7.   * @param  无  
   
8.   * @retval 无
   $ k+ f3 e+ w5 y
9.   */
   ' E5 d- }5 [/ ?# p+ h
10. int main(void)
    
11. {   
    & d/ A* g+ u3 q7 E7 u* u3 g+ }. h+ b
12.     GPIO_Config();
    ; L/ {& a; x/ Q2 _+ z5 @
13. 
    
14.     /* 配置SysTick定时周期为1us */
    & s$ Z) J+ ^. t* j3 ]# h" K, Q
15.     SysTick_Init();
    9 r. v- s! `2 N" Y8 g% Y
16. 
    ! @7 T; a2 _" D! h* i  k
17.     for(;;)
    
18.     {
    8 y3 _3 {$ y, g' P7 _
19.         TX(HIGH);
    
20.         Delay_us(1);
    
21.         TX(LOW);
    
22.         Delay_us(100);
    
23.     }     
    
24. }

复制代码

示波器的观察结果：
$ s) q" f$ \* W$ O
可见Delay_us(100)，执行了大概102us，而Delay_us(1)执行了2.2us。
# |+ C$ M9 b% y5 B, g5 Z  S- F
更改一下main函数的延时参数：
& P* C5 _) H: ?. ^7 G+ O

1. 
   
2. int main(void)
   $ M4 Y0 H$ v+ \
3. {   
   
4.     /* LED 端口初始化 */
   7 q2 r) `( v" |9 T4 `, \; ]
5.     GPIO_Config();
   $ ?& w4 z/ p/ [4 |
6. 
   4 Q1 ^. b1 B) w: ?
7.     /* 配置SysTick定时周期为1us */
   
8.     SysTick_Init();
   
9. 
   6 q! h# M9 A7 o( F$ P: }8 z
10.     for(;;)
    
11.     {
    ' d9 T$ W- N( h! [
12.         TX(HIGH);
    
13.         Delay_us(10);
    
14.         TX(LOW);
    ! P  {8 \2 p( H4 ?$ w7 K
15.         Delay_us(100);
    ( K2 a1 C; n; U- j! o4 S
16.     }     
    ( m0 X5 h( Z/ ?4 w5 e9 c6 O
17. }

复制代码

示波器的观察结果：

3 b, l& h$ @( @/ ~
    可见Delay_us(100)，执行了大概101us，而Delay_us(10)执行了11.4us。
* X1 e: i* r; y7 R* O: y
    结论：此延时函数基本上还是可靠的。
! H8 e8 A- Z% Q( `* Z& w
使用定时器方法的实例
  l0 X+ ^/ i7 f0 m- `& k& f
    Delay_us函数使用STM32定时器2实现：

5 q- F+ D" S. S% _, @% n* A

1. #include "timer.h"
   9 ?4 Z. `, N6 j! y
2. 
   
3. /* SystemFrequency / 1000            1ms中断一次
   ' h& v) {1 D% h" F
4. * SystemFrequency / 100000     10us中断一次
   
5. * SystemFrequency / 1000000         1us中断一次
   5 S4 b! {( l9 o3 I/ U8 Y$ ]+ ]) K
6. */
   
7. 
   ! D6 B' h" r7 F
8. #define SYSTICKPERIOD                    0.000001
   
9. #define SYSTICKFREQUENCY            (1/SYSTICKPERIOD)
   
10. 
    
11. /**
    & e& ^8 d: M% z. c1 M) u6 R
12.   * @brief  定时器2的初始化,，定时周期1uS
    & H3 r  ]6 V6 t+ d
13.   * @param  无
    
14.   * @retval 无
    
15.   */
    
16. void TIM2_Init(void)
    
17. {
    
18.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    / N( ?& z( [& W# Q  [" n
19. 
    9 i  j5 C( X# J& v
20.     /*AHB = 72MHz,RCC_CFGR的PPRE1 = 2，所以APB1 = 36MHz,TIM2CLK = APB1*2 = 72MHz */
    
21.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    
22.    
    5 j7 Q: c2 W. `8 \. x0 J' |5 @, C
23.     /* Time base configuration */         
    
24.     TIM_TimeBaseStructure.TIM_Period = SystemCoreClock/SYSTICKFREQUENCY -1;
    + N; ~8 f5 h3 {" z
25.     TIM_TimeBaseStructure.TIM_Prescaler = 0;
    * a: l5 n8 G; Y- b* r+ S% m0 S
26.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    
27.     TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
    5 q3 ?7 Q1 b: ?( l$ g
28.    
    
29.     TIM_ARRPreloadConfig(TIM2, ENABLE);
    
30.    
    ( ]3 _, D$ B" |; {- G  ^" c" G
31.     /* 设置更新请求源只在计数器上溢或下溢时产生中断 */
    1 w9 k3 h3 Q" U5 z% h! }
32.     TIM_UpdateRequestConfig(TIM2,TIM_UpdateSource_Global);
    ( u4 R  z( `8 V
33.     TIM_ClearFlag(TIM2, TIM_FLAG_Update);
    
34. }
    
35. 
    6 Z5 f1 G/ \$ d8 h* h; K
36. /**
    * R9 u8 p, P7 R: e6 h5 m  m
37.   * @brief   us延时程序,10us为一个单位
    
38.   * @param  
    , p2 O  }6 o, j, @1 ~0 V% _$ O
39.   *        @arg nTime: Delay_us( 10 ) 则实现的延时为 10 * 1us = 10us
    
40.   * @retval  无
    # x8 `4 Z& M5 I+ A
41.   */
    
42. void Delay_us(__IO uint32_t nTime)
    & J$ x& `0 V9 q% m, x. ?
43. {     
    ! r( p* e6 \/ A1 d3 F
44.     /* 清零计数器并使能滴答定时器 */  
    
45.     TIM2->CNT   = 0;  
    
46.     TIM_Cmd(TIM2, ENABLE);     
    * [! s6 x8 P6 T$ z( `
47. 
    , N/ ^' M+ O, R( }/ Z4 ~1 V
48.     for( ; nTime > 0 ; nTime--)
    8 ~/ K; H1 ?0 g5 l9 t/ p* M
49.     {
    
50.      /* 等待一个延时单位的结束 */
      m! J) n' U, w/ d% o7 A5 `7 ^
51.      while(TIM_GetFlagStatus(TIM2, TIM_FLAG_Update) != SET);
    
52.      TIM_ClearFlag(TIM2, TIM_FLAG_Update);
    ; _' k" \* }4 E) t& [; B( P
53.     }
    
54. 
      K6 n  ]8 v; S2 g
55.     TIM_Cmd(TIM2, DISABLE);
    9 j0 l4 g5 H3 [! l9 E
56. }

复制代码

  在main函数中检验Delay_us的执行时间：
+ V0 e$ @/ n3 u4 Q

1. 
   
2. #include "stm32f10x.h"
   7 L# S/ ?0 c6 X4 b% C# K# D, F
3. #include "Timer_Drive.h"
   ; J$ h/ t- T& c+ `9 W
4. #include "gpio.h"
   8 k, j3 r1 l/ U5 M% ^  \% y
5. #include "systick.h"
   
6. 
   
7. TimingVarTypeDef Time;
   1 ?& N  t4 N: Q. L
8. 
   ; U6 Z% Y- g+ {: i
9. int main(void)
   1 s2 y4 f; n# [5 D8 B
10. {   
    
11.     TIM2_Init();   
    , y! u: U; ?# F! O' l
12.     SysTick_Init();
    
13.     SysTick_Time_Init(&Time);
    
14.    
    
15.     for(;;)
    
16.     {
    6 l* X9 L! ^. D+ g, R- n. u5 v
17.         SysTick_Time_Start();
    
18.         Delay_us(1000);
    $ S/ ], T! [; I8 K
19.         SysTick_Time_Stop();
    
20.     }     
    
21. }

复制代码

怎么去看检测结果呢？用调试的办法，打开调试界面后，将Time变量添加到Watch一栏中。然后全速运行程序，既可以看到Time中保存变量的变化情况，其中TimeWidthAvrage就是最终的结果。
3 E3 t7 O6 W+ ~& `; x" i8 M9 T
    可以看到TimeWidthAvrage的值等于0x119B8,十进制数对应72120，滴答定时器的一个滴答为1/72M（s），所以Delay_us(1000)的执行时间就是72120*1/72M (s) = 0.001001s，也就是1ms。验证成功。
) Z& P% G( s; ~& T9 i0 c$ Q( p
& v7 j+ _6 y, [- C' x! E    备注：定时器方法输出检测结果有待改善，你可以把得到的TimeWidthAvrage转换成时间（以us、ms、s）为单位，然后通过串口打印出来，不过这部分工作对于经常使用调试的人员来说也可有可无。
0 }8 c( h. I" N; ]
两种方法对比
软件测试方法

    操作起来复杂，由于在原代码基础上增加了测试代码，可能会影响到原代码的工作，测试可靠性相对较低。由于使用32位的变量保存systick的计数次数，计时的最大长度可以达到2^32/72M = 59.65 s。
* U0 B; D! \& Q( F" _* t9 O+ |2 k
示波器方法

" y1 J. ]6 b1 e5 G, v2 q8 m    操作简单，在原代码基础上几乎没有增加代码，测试可靠性很高。由于示波器的显示能力有限，超过1s以上的程序段，计时效果不是很理想。但是，通常的单片机程序实时性要求很高，一般不会出现程序段时间超过秒级的情况。


$ d9 W9 _3 k7 e+ }5 |" r! f' W: L

% b) s4 W$ L: O! n; c: T/ n
  o  D9 P$ e! Q






) }, d) s' a" |( w4 C2 J