一、关于时间

　　在计算机应用上，2038年问题可能会导致某些软件在2038年无法正常工作。所有使用UNIX时间表示时间的程序都将将受其影响，因为它们以自1970年1月1日经过的秒数（忽略闰秒）来表示时间。这种时间表示法在类Unix（Unix-like）操作系统上是一个标准，并会影响以其C编程语言开发给其他大部份操作系统使用的软件。

　　在大部份的32位操作系统上，此“time_t”数据模式使用一个有正负号的32位元整数（signedint32)存储计算的秒数。也就是说最大可以计数的秒数为 2^31次方 可以算得：

                2^31/3600/24/365 ≈ 68年
/ ~7 n+ [9 H8 K3 k　　所以依照此“time_t”标准，在此格式能被表示的最后时间是2038年1月19日03:14:07，星期二（UTC）。超过此一瞬间，时间将会被掩盖（wrap around）且在内部被表示为一个负数，并造成程序无法工作，因为它们无法将此时间识别为2038年，而可能会依个别实作而跳回1970年或1901年。
+ B+ @4 \9 i. C2 h2 n4 G　　对于PC机来说，时间开始于1980年1月1日，并以无正负符号的32位整数的形式按秒递增，这与UNIX时间非常类似。可以算得：
: I$ X$ G  v% S7 L7 ~/ J                 2^32/3600/24/365 ≈ 136年
! e& e9 V! U% m- r　　到2116年，这个整数将溢出。
: p8 Y7 n+ z; M2 l* @5 U( J, B$ y' |　　　　Windows NT使用64位整数来计时。但是，它使用100纳秒作为增量单位，且时间开始于1601年1月1日，所以NT将遇到2184年问题。
4 Q. T! _) z$ Y  S, T　　苹果公司声明，Mac在29,940年之前不会出现时间问题！
0 T+ E5 n. c4 R* ^) ?8 f. O8 S" w
( t- }( Z/ L& U# r- t  O. h, k3 I二、RTC使用说明

　　"RTC"是Real Time Clock 的简称，意为实时时钟。stm32提供了一个秒中断源和一个闹钟中断源，修改计数器的值可以重新设置系统当前的时间和日期。

　　RTC模块之所以具有实时时钟功能，是因为它内部维持了一个独立的定时器，通过配置，可以让它准确地每秒钟中断一次。但实际上，RTC就只是一个定时器而已，掉电之后所有信息都会丢失，因此我们需要找一个地方来存储这些信息，于是就找到了备份寄存器。其在掉电后仍然可以通过纽扣电池供电，所以能时刻保存这些数据。

　　配置RTC前须知：

　　BKP：

　　RTC模块和时钟配置系统的寄存器是在后备区域的（即BKP），通过BKP后备区域来存储RTC配置的数据可以让其在系统复位或待机模式下唤醒后，RTC里面配置的数据维持不变。

　　PWR：

　　PWR为电源的寄存器，我们需要用到的是电源控制寄存器（PWR_CR），通过使能PWR_CR的DBP位来取消后备区域BKP的写保护。

　　RTC：

　　由一组可编程计数器组成，分成两个模块。第一个模块是RTC的预分频模块，它可编程产生最长为1秒的RTC时间基准TR_CLK。RTC的预分频模块包含了一个20位的可编程分频器（RTC）TR_CLK 周期中RTC产生一个中断（秒中断）。第二个模块是一个32位的可编程计数器，可被初始化为当前的系统时间。系统时间按TR_CLK周期累加并与存储在RTC_ALR寄存器中的可编程时间相比较，如果RTC_CR控制寄存器中设置了相应允许位，比较匹配时，将产生一个闹钟中断。

　　

* \4 x$ n& j' H0 S0 \7 o8 X0 K4 j

　　下面讲解下配置整体过程：

　　　第一步： 通过设置寄存器 RCC_APB1ENR 的 PWREN 和 BKPEN 位来打开电源和后备接口的时钟
　　　调用库函数：

　　　　RCC_APB1PeriphClockCmd (RCC_APB1Periph_PWR | RCC_APB1Periph_BKP,ENABLE );

　　　第二步：电源控制寄存器(PWR_CR) 的 DBP 位来使能对后备寄存器和 RTC 的访问

　　　调用库函数：

　　　　PWR_BackupAccessCmd(ENABLE );

　　　第三步：初始化复位 BKP 寄存器

　　　调用库函数：

　　　BKP_DeInit ();

　　　第四步：设置 RTCCLK，如下图：

　　

　　　我们需要将 RTCCLK 设置为 LSE OSC  这个 32.768KHZ 的晶振。

　　　调用的库函数：　　

　　　RCC_LSEConfig (RCC_LSE_ON);

　　　While(!RCC_GetFlagStatus (RCC_FLAG_HSERDY));//设置后需要等待启动

9 B2 v# \3 ^# Q. s& S- c  V

　　　第五步：将 RTC 输入时钟 选择为 LSE 时钟输入并使能 RTC，等待 RTC 和 APB 时钟同步

　　　调用库函数：

　　　RCC_RTCCLKConfig (RCC_RTCCLKSource_LSE);//选择 LSE 为 RTC 设备的时钟

　　　RCC_RTCCLKCmd (ENABLE );//使能

　　　RTC RTC_WaitForSynchro();//等待同步

　　第六步：配置 RTC 时钟参数。

• 查询 RTOFF 位，直到 RTOFF 的值变为’1’
• 置 CNF 值为 1 ，进入配置模式
• 对一个或多个 RTC 寄存器进行写操作
• 清除 CNF 标志位，退出配置模式
• 查询 RTOFF，直至 RTOFF 位变为’1’ 以确认写操作已经完成。仅当 CNF 标志位被清除时，写操作才能进行，这个过程至少需要 3 个 RTCCLK 周期。
    v1 J9 b# N( ~2 t& i# F# X. W" G5 Z1 `

　　按照上述步骤用库函数来配置：

1. /* 1.    查询 RTOFF 位，直到 RTOFF 的值变为’1’ */
   
2. 
   $ h# s; @9 g% N& h0 x; D  n
3. RTC_WaitForLastTask();//大家可以打开函数库看看这个函数内部的代码，就是查询 RTOFF的值
   
4. 
   
5. /*
   5 R, r# k6 \& J  T; n
6. 
   7 t) p9 p+ \6 Q8 A8 Z, |, x4 {  M
7. 2.置 CNF 值为 1 ，进入配置模式
   
8. 
   
9. 3.对一个或多个 RTC 寄存器进行写操作
   ( e% e# s. s. ]6 m& Y
10. 
    
11. 4.清除 CNF 标志位，退出配置模式
    
12. 
    " K% I& m+ q8 a: k
13. */
    
14. 
    " S/ n* v1 D) C
15. RTC_SetPrescaler(32767); // 这里配置了预分频值，大家可以打开函数库看看这个函数的内部的代码，里面就有包含了 2、3、4 讲述的操作。
    
16. 
    
17. /*
    
18. 每完成一个操作一般都要查询 RTOFF 来判断是否 RTC 正在更新数据,如果是则等待它完成!!!
    : S4 G% @6 x/ \* x, n5 r0 X
19. */
    
20. RTC_WaitForLastTask();//等待更新结束
    
21. 
    
22. RTC_ITConfig(RTC_IT_SEC, ENABLE);//配置秒中断
    / j* V0 B$ W* ~. X' y4 X5 V
23. 
    2 i2 ?% }8 \+ p. {( x* n% S
24. RTC_WaitForLastTask();//等待更新结束

复制代码

8 v4 _$ T0 P# _
三、程序演示

　　rtc.h

1. #ifndef __RTC_H
   % q, B' I6 B( t# C/ D0 J4 }
2. #define __RTC_H
   3 p  g; T0 H1 E6 M, I8 q5 H
3. #include "stm32f10x.h"
   - b' V' g% L) y5 `4 f, C
4. 
   
5. //时间结构体
   
6. typedef struct
   
7. {
   
8.     vu8 hour;
     ?1 q5 v( z7 a8 `) x% q2 C
9.     vu8 min;
   % N; Y' Q- p- V3 G3 E
10.     vu8 sec;            
    6 ]5 O; a* z5 j) h
11.     //公历年月日周
    
12.     vu16 w_year;
    
13.     vu8  w_month;
    2 S* z$ p- f, S/ v. b5 R5 @
14.     vu8  w_date;
    5 i9 j  h; F$ }0 a! Y
15.     vu8  week;     
    # z- A: H1 y! s3 p
16. }_calendar_obj;                     
    : ?3 V: l2 u: v& R
17. extern _calendar_obj calendar;
    
18. void RCC_Configuration(void);
    + v' a2 J) k; Y# r  Q/ a! V
19. void RTC_Init(void);
    ' m- K7 y9 ]( E2 Y, C3 T) f7 K
20. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec);
    6 N9 H# }; j# a: _8 G1 A& A
21. u8 RTC_Get(void);
    
22. #endif

复制代码

; M: X- I5 i+ O- L" T/ j

　　rtc.c

1. #include "rtc.h"
   3 G# {/ T% U) {
2. _calendar_obj calendar;    //时钟结构体
   , F  E  M6 C2 s9 j
3. //平均的月份日期表
   
4. const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
   
5. /*rtc中断向量配置*/
   
6. void NVIC_Configuration(void)
   6 o9 @: B& r! \. P3 D9 j: z! h/ L
7. {
     K$ D' i7 J& g! N7 O; B
8.     NVIC_InitTypeDef NVIC_InitStructure;
   ! A5 }( b- p! I
9.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   
10.     NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
    
11.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    
12.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    - y* i; B" E2 N* z. y' X" j
13.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    2 t% _/ U. ~2 D8 z2 y# F
14.     NVIC_Init(&NVIC_InitStructure);
    
15. }
    6 a& ?$ ~! W" Z5 _, E
16. 
    
17. void RTC_Configuration(void)
      ^% w7 a) B% R7 g& v
18. 
    & x  x, v% u" q5 @% g7 |
19. {
    2 ~( ^4 X% b+ I) S: V/ d/ g
20.     /* 使能PWR和BKP时钟 */
    
21.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP,ENABLE);
    % Z, U  {0 ^+ z: |* ?( p6 g$ k+ s
22.     /* 使能对后备寄存器的访问 */
    
23.     PWR_BackupAccessCmd(ENABLE);
    8 c  o6 R1 t0 r) V) v% y5 ]
24.     /* 复位BKP寄存器 */
    , |& f3 A. p0 A0 `% V- X
25.     BKP_DeInit();
    
26.     /* 使能LSE */
    
27.     RCC_LSEConfig(RCC_LSE_ON);
    ( g3 `" _, Y3 r# R7 B, D0 f
28.     /*等待启动完成 */
    # m! i2 I  O( G1 Q9 d
29.     while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {}
    5 s: Y" s( W; U# x
30.     /* 将 RTC时钟设置为LSE这个32.768KHZ的晶振*/
    - j! q4 s: S0 E; K
31.     RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    
32.     /* 使能RTC Clock */
    
33.     RCC_RTCCLKCmd(ENABLE);
    - B8 t1 F; C' d& ~! F3 {" m
34.     /* 等待同步 */
    
35.     RTC_WaitForSynchro();
    
36.     /* 等待对RTC寄存器最后的写操作完成*/            
    
37.     RTC_WaitForLastTask();
    
38.     /* 配置了预分频值: 设置RTC时钟周期为1s */
    8 Y. N$ H- ?9 v' y( y
39.     RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1)*/
    
40.     /* 等待对RTC寄存器最后的写操作完成 */
    
41.     RTC_WaitForLastTask();
    * m8 B/ z  Y& a! J- j! |
42.     /* 使能RTC秒中断 */
    
43.     RTC_ITConfig(RTC_IT_SEC, ENABLE);
    
44.     /* 等待对RTC寄存器最后的写操作完成 */         
    / K( l" a3 f' F/ j, y" s7 p7 c: V+ O9 s
45.     RTC_WaitForLastTask();
    
46. 
    " e7 ?: f& ?$ i; `0 ^
47. void RTC_Init(void)
    
48. {
    
49.     /*如果是第一次配置时钟，则执行RCC_Configuration()进行配置*/
    1 \( o6 \7 X, y# `; u5 B/ [
50.     if(BKP_ReadBackupRegister(BKP_DR1)!=0x1016)
    
51.     {
    
52.             RCC_Configuration();
    
53.             RTC_Set(2016,5,11,9,7,55);
    
54.             GPIO_SetBits(GPIOD, GPIO_Pin_13);//点亮D1
    7 Q. @: ^- x6 [4 n0 P! U
55.             BKP_WriteBackupRegister(BKP_DR1, 0x1016);//向执行的后备寄存器中写入用户程序数据
    
56.     }
    + W6 u8 R. n  {9 l& O
57.     else
      `3 s/ @& Y( m7 B# v& M1 k# o9 d
58.     {
    7 @6 ~4 B# @" o9 ]: p5 s
59.         RTC_WaitForSynchro();//等待RTC寄存器同步完成
    
60.         RTC_ITConfig(RTC_IT_SEC, ENABLE);//使能RTC秒中断
    2 S9 r: L: w& I
61.         RTC_WaitForLastTask();//等待最近一次对RTC寄存器的写操作完成
    - L4 s4 U+ m0 [- l4 v
62.         GPIO_SetBits(GPIOG, GPIO_Pin_14);//点亮D2
    ) s: z4 T+ ?+ h% j+ m1 M7 }
63.     }
    
64.     NVIC_Configuration();
    % w+ c$ u9 ]- G& _" y" f6 l
65.     RTC_Get();//更新时间
    & @- {) D2 Y, U" q; p& U) Z
66. }
    / L1 g9 W8 X3 Q; J( g8 D
67. u8 Is_Leap_Year(u16 pyear)
    & X1 f% _) \0 f) t2 j8 s
68. {
    
69.     if(pyear%4==0)//首先需能被4整除
    5 S/ h  q5 _. P% y+ t4 N8 T1 E! s
70.     {
    
71.         if(pyear%100==0)
    $ H& _( g+ ]; U. G7 e7 ]# v8 Y
72.         {
    ) n: }. p% ]3 j% i2 f# ?, z8 S
73.             if(pyear%400==0)    return 1;//如果以00结尾，还要能被400整除
    
74.             else    return 0;
    8 T8 w1 Y0 r% g2 r6 W; p! P$ `$ w
75.         }
    ' H/ w0 ?% G8 q: d( \( e
76.         else
    % B4 U! A0 P% l1 M) g  z
77.             return 1;
    5 H2 Q5 u$ G" @9 {2 h2 M0 @  e
78.     }
    7 J5 m2 e$ v! U* D; a( ~, s+ q
79.     else
    
80.         return 0;
    ' T5 o; c  n6 ~3 M
81. }
    
82. /*
    
83. *设置时钟
    ! G( Z# o8 s- I8 M: m0 X
84. *把输入的时钟转换为秒钟
    , N. t0 ~6 Q; {; k) O# @+ P( Q
85. *以1970年1月1日为基准
    % l$ b8 B+ `# j; q) t; `4 L# s- E
86. *1970~2099年为合法年份
    
87. 返回值：0，成功；其它：错误
    7 G  v& [. I* O
88. */
    0 U% {) S1 i/ V0 z
89. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec)
    . p& g) H7 z! }* p1 f3 y7 f, m: d
90. {
    & [* ]: [9 r) o4 @8 t2 ]( \9 S9 b
91.     u16 t;
    
92.     u32 secCount=0;
    8 Z! W- D* D8 s
93.     if(year<1970||year>2099)
    
94.         return 1;//³ö´í
    
95.     for(t=1970;t<year;t++)    //把所有年份的秒钟相加
    % G3 B  ~$ I0 f/ i% H* v0 v" {
96.     {
    6 |0 c3 S6 A7 y+ d
97.         if(Is_Leap_Year(t))//闰年
    / o! G) m, C$ n0 U+ }) _) F$ J; T' u
98.             secCount+=31622400;//闰年的秒钟数
    
99.         else
    9 n' W4 c9 G( ^% c  p: a
100.             secCount+=31536000;   
     3 u: H5 h7 g: t1 S- K( e
101.     }
     ; A+ t) C* N3 W$ g/ b$ V" L4 m
102.     mon-=1;//先减掉一个月再算秒数（如现在是5月10日，则只需要算前4个月的天数，再加上10天，然后计算秒数）
     : W! }" k2 n) M. t! u
103.     for(t=0;t<mon;t++)
     + m1 }6 F3 b, D# w. e
104.     {
     * ~4 z, ~2 x3 q2 O9 |
105.         secCount+=(u32)mon_table[t]*86400;//月份秒钟数相加
     
106.         if(Is_Leap_Year(year)&&t==1)
     5 {" H! j: R; V; ^
107.             secCount+=86400;//闰年，2月份增加一天的秒钟数
     ; `8 V0 ]  k' Q5 x: b6 y
108.     }
     
109.    
     
110.     secCount+=(u32)(day-1)*86400;//把前面日期的秒钟数相加（这一天还没过完，所以-1）
     2 k- {' v. A9 H& |
111.     secCount+=(u32)hour*3600;//小时秒钟数
     % S+ f8 F, M7 T$ [- P/ u3 d
112.     secCount+=(u32)min*60;//分钟秒钟数
     
113.     secCount+=sec;
     - u6 Z, i! K- k" v3 D
114. //    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR    | RCC_APB1Periph_BKP,ENABLE);
     ; s# ]8 X. A1 I, A+ C
115. //    PWR_BackupAccessCmd(ENABLE);
     * }2 D/ X5 o9 v* _) ]
116.     RTC_SetCounter(secCount);//设置RTC计数器的值
     
117.     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
     
118.     RTC_Get();//更新时间
     ! f. x% g, {, U2 v% U4 v( k) [
119.     return 0;
     
120. }
     
121. 
     $ i: y. Q9 ], X% F
122. /*
     
123. 得到当前的时间
     
124. 成功返回0，错误返回其它
     
125. */
     
126. u8 RTC_Get(void)
     
127. {
     ( }8 ]9 @# x9 X  S" t
128.         static u16 dayCount=0;
     4 k' z% h1 c% R6 Z
129.         u32 secCount=0;
     
130.         u32 tmp=0;
     
131.         u16 tmp1=0;
     
132.         secCount=RTC_GetCounter();
     + L" L+ m+ I( S4 n* q( x
133.         tmp=secCount/86400;//得到天数
     
134.         if(dayCount!=tmp)//超过一天
     
135.         {
     ( g0 R8 M* d: h: W5 T4 l! J9 U4 ^
136.             dayCount=tmp;
     
137.             tmp1=1970;//从1970年开始
     
138.             while(tmp>=365)
       }5 f2 @) ^+ G' h
139.             {
     
140.                 if(Is_Leap_Year(tmp1))//是闰年
     
141.                 {
     
142.                     if(tmp>=366)   
     ) n' |. t+ m  o
143.                         tmp-=366;//减掉闰年的天数
     ' P* ~& X4 @8 }8 B7 P: P+ X4 l
144.                     else
     ' r8 @! a% K4 G8 `  \6 x6 v
145.                     {
     
146.                     //    tmp1++;
     ) i$ n. D) w2 b2 z1 H- A
147.                         break;
     
148.                     }
     4 u# `! B! X( E' p# d; z
149.                 }
     
150.                 else
     
151.                     tmp-=365;//平年
       |, @# G% p7 W
152.                 tmp1++;
     & c1 m0 m; p: p$ i+ r! H) U; `9 j
153.             }
     . G! [* ~' x# a9 C: ~- @
154.             calendar.w_year=tmp1;//得到年份
     $ W/ A) Y: X3 F3 S. s1 t# f
155.             tmp1=0;
     
156.             while(tmp>=28)//超过一个月
     . M$ n& [9 ~* ~  g* k# l5 M% E
157.             {
     
158.                 if(Is_Leap_Year(calendar.w_year)&&tmp1==1)/当年是闰年且轮循到2月
     
159.                 {
     
160.                     if(tmp>=29)   
     / E9 X$ H/ \4 N  x- z: F
161.                         tmp-=29;
     % U  ~9 F( {$ s; {7 Z
162.                     else
     5 u: s' T7 {9 G1 s* x" l! `
163.                         break;
     4 z1 l5 m7 U3 ?! |. ~
164.                 }
     ; R( |; j. Y; R4 J) A/ k
165.                 else
     
166.                 {
     1 [1 h& t' w$ b' J+ v: s" s
167.                     if(tmp>=mon_table[tmp1])//平年
     3 D5 w4 V8 o9 l7 l0 B
168.                         tmp-=mon_table[tmp1];
     2 h3 i0 L* a+ c/ S9 \" P
169.                     else
     
170.                         break;
     . |) n  k  d; o! p" [! o
171.                 }
     . f) T" N# v# s! M" \8 P
172.                 tmp1++;
     
173.             }
     
174.             calendar.w_month=tmp1+1;//得到月份，tmp1=0表示1月，所以要加1
     
175.             calendar.w_date=tmp+1;    //得到日期，因为这一天还没过完，所以tmp只到其前一天，但是显示的时候要显示正常日期
     
176.         }
     # S6 K# a1 L6 E! s+ ^0 v
177.         tmp=secCount%86400;//得到秒钟数
     
178.         calendar.hour=tmp/3600;//小时
     
179.         calendar.min=(tmp%3600)/60;//分钟
     7 _2 P9 r, I/ m. k( g2 l5 j$ `' t
180.         calendar.sec=(tmp%3600)%60;//秒
     ' R# u) l9 v" c2 Z7 `2 j8 u% _- A
181.         return 0;
     
182. }
     
183. /*
     1 K0 p, ]8 M) p) O3 D2 h6 N
184. RTC时钟中断
     
185. 每秒触发一次
     $ d( B. e1 k, E' a; O; ?( n) ?% w
186. */
     
187. void RTC_IRQHandler(void)
     
188. {         
     
189.     if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断
     9 c) Y- l' E: a% U9 Q  x
190.     {                           
     7 f9 ]2 a8 Q6 U1 \
191.         RTC_Get();//更新时间
     
192.       
     
193.      }
     $ ?' t% W. H8 q, O: y/ W6 B5 F
194.     if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断
       Y. V  b0 z& p& B% k* a
195.     {
     5 D) O9 R7 ?' d! u. y9 l
196.         RTC_ClearITPendingBit(RTC_IT_ALR);//清闹钟中断        
     . @3 `3 ^4 |% U* [; N" s! g
197.   }                                                   
     
198.     RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);//清闹钟中断
     
199.     RTC_WaitForLastTask();                                                   
     % ^! O, k% n# ]( E$ L$ _
200. }

复制代码

! u. d2 }3 l% ?1 x0 q: r6 V

　　main.c

1. #include "stm32f10x.h"
   9 Z! H. u; \2 f3 z" q( Z& F
2. #include "usart1.h"
   
3. #include "LED.h"
   
4. #include "delay.h"
   * X# N  Q* }6 M* A! Q# O4 m$ B
5. #include "flash.h"
   
6. #include "rtc.h"
   
7. #include "stdio.h"
   
8. int main(void)
   
9. {
   + E6 o/ P  t/ _% y; j  S! Z
10.     u8 t=0;
    , }; T' M$ V, }8 P' x+ Z% y
11.     USART1_Config();
    : a$ y; J# C3 D' s% }! I+ ]& j
12.     GPIO_Configuration();
    % [0 R! @% g+ N7 k& Z+ _# j' ^
13.     RTC_Init();
    
14.     while(1)
    
15.     {
    / Q. b2 W0 I) p7 d2 ]1 f' g! g, l' w( F
16.         if(t!=calendar.sec)
    
17.         {
    
18.             t=calendar.sec;
    ! v; B' N) I8 R1 ~; |
19.             printf("\r\n now is %d 年 %d 月 %d 日 %d 时 %d 分 %d 秒 \r\n ",
    
20. 　　　　　　　calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
    
21.         }
    , |. H/ k% e) m" R9 D4 i8 a: l
22.         Delay(0x02FFFF);
    % S/ v. L1 K0 b  Y& O
23.     }
    
24.    
    - d3 h0 [* E8 a
25.    
    8 ^5 L1 a. d; Y; O! g8 }( T* i9 @
26. }   

复制代码

8 I7 f# A' g  P