基本能搜到的systick 都是作为延时使用的，因为设计需求我更多实用的是系统时间判断。
假如我有个LED，需要每10S闪一下，并且单片机还需要做其他的工作，用延时工作效率太低了，开个定时器又太浪费了。因此系统时钟就体现出了由为重要的应用场合。只需要检测到系统时间为10s 的倍数就可以做动作了，当然前提保证程序的大体循环能在1s 内完成，这个基本没问题如果一个大体循环1s 内完成不了 那这个程序要么就是大到无法形容，要么就是无止境的运行。
  q# d! }# k4 l5 w8 C5 a$ G# T5 J

首先进入while(1) 大循环前初始化systick，进入主体程序就在计数了，计数分毫秒，秒，这样能在特点的时间进入指定的程序中运行。
初始化systick
0 v, ~0 U: h- {6 N  i; F: _

void TimeCount_Init(void)
{
     
    SysTick->LOAD=72000000/1000;//系统频率为72MH
* i7 k+ L' f0 o2 |4 P* Z: t% Y$ T    SysTick->VAL=0x00;
+ F- Z1 t! p2 }- D    SysTick->CTRL=0xFFFFFFFF;
    MilliS=0;
+ f3 @9 L6 s8 F/ S" m# s    Second=0;
    Min=0;
+ Z0 ~6 h& {' h3 G8 x) e1 d) S}
0 B$ G$ ?! e5 o

当然如果用库函数也行的
  F) b7 {6 d3 q4 c. a

void TimeCount_Init(void)
' K0 ^" @( `: _8 C6 k% P1 y{
  o+ `* k/ U6 N0 o; I     
+ O8 R4 s; i3 _6 T  if (SysTick_Config (SystemCoreClock / 1000))
  {  while (1); }

  MilliS=0;
  Second=0;
; G  T8 g, d7 z7 W# b/ H/ C  Min=0;
}

  T& l9 i5 @, a1 K. u

中断函数
" D5 L  |# H! a  {

void SysTick_Handler(void)
{                                                            
  MilliS++;
  if(MilliS>=10000) MilliS=0;//此处10000ms 主要方便延时函数使用
  if(MilliS%1000==0) {Second++;}
1 @. k7 Y% s$ T# [( m  if(Second>=60) {Second=0;min++;}
}

: |, ^0 }% j" T8 M& r+ Q1 `  \) q( h0 D
. G2 L: c" B9 o# F. N1 g' J2 r

如果我们要想5秒去做一次计算某组数据只需要写入秒判断即可
! H# n* H$ |& M' t! t9 [if(Second%5 == 0)
{  需要间隔运行的程序……    }
毫秒也是可以的，换成MilliS 即可，甚至分钟都行。

   好了，那延时怎么办？是的特殊场合我们可能还是可能有需要延时函数的。当然这个也是可以做到的，不过相对运算多一点点。
延时函数如下：

) h, Q4 L" A0 {" V7 Z; q
- U& v$ c0 ^+ D: `3 H2 v* Q0 Iu8 delayms(u16 nCount)
! x: Z; t  Q7 O" D  s' e{
) p% K: _6 k% M7 |, S2 g/ @4 p3 _( O) ~% ~  u16 CurTim=MilliS;
  u16 i=0;
$ g9 O1 Z% Y) K5 t6 K  if(nCount<60000)
* R6 k. T) Q0 Z# U. b     {
5 Y3 ?; `8 Q% J. h. Z        if(CurTim+nCount<10000)  
, B2 {( e, S( |          {
             while(MilliS-CurTim<nCount); return 1;
0 \/ d4 k" }* |! S2 M          }
        i=nCount-(10000-CurTim);
9 H/ f) x5 U. Z; R4 o* C0 v        while(MilliS<9998);
5 R0 U& F# y3 R/ P( [- Q        while(MilliS>=9998||MilliS<i);   
0 i) o$ f" B/ e) i6 W        return 1;
: d. U$ b7 o  q( J8 p$ P! o9 N     }
! h( }. p, d7 {5 h7 i# N  delayS(nCount/1000);
  delayms(nCount%1000);
  //while()
* }) V& d8 g$ s/ v# ~$ a8 T2 {  return 1;
}

u8 delayS(u16 nCount)
{
) }* E% C+ }/ b  u16 CurTim=Second;
  u16 i=0;
  R0 H+ c) `+ W! w$ R  if(nCount<6000)
     {
        if(CurTim+nCount<60)
          {  while(Second-CurTim<nCount);return 1;}
# ^9 U' K' N* h" z2 P        i=nCount-(60-CurTim);
) U$ q; ~! c- V6 N( o        while(Second<59);
        while(Second>=59||Second<i);
        return 1;
     }
, a3 X% w: [! y  return 0;
- N1 i0 S+ U" a! z# v}

4 {; [% {9 t' D+ k- y; N: `1 Z7 s

这里我做的毫秒延时中实际最长的只能计算60000ms 即60s的延时 再长的延时就会先调用秒延时，运行完后再把剩下的毫秒延时运行掉。所以超出部分将计算越出计数器最大计算值多少来计算i=nCount-(10000-CurTim);而中断中定义的技术最大值10000 原因是一般我们使用延时都不会太长，最长一般也就数秒而已，更多的是毫秒级的，所以这里放宽至10S 的长度，直接等待值到了就推出，所以10S内的延时延时还是非常精确的，但如果大于就会有几个微秒的差距了，中间插入了好几条运算和指令，非精确定时就别用这个定时器了。

这样是不是太麻烦了啊，直接让无符号的ms++就行，32位的无符号数溢出之后需要几十天呢