一、关于时间

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

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

                2^31/3600/24/365 ≈ 68年
　　所以依照此“time_t”标准，在此格式能被表示的最后时间是2038年1月19日03:14:07，星期二（UTC）。超过此一瞬间，时间将会被掩盖（wrap around）且在内部被表示为一个负数，并造成程序无法工作，因为它们无法将此时间识别为2038年，而可能会依个别实作而跳回1970年或1901年。
9 C; i( Z* V% N0 Y　　对于PC机来说，时间开始于1980年1月1日，并以无正负符号的32位整数的形式按秒递增，这与UNIX时间非常类似。可以算得：
                 2^32/3600/24/365 ≈ 136年
( u+ b- V: Q2 M9 {/ D- z　　到2116年，这个整数将溢出。
　　　　Windows NT使用64位整数来计时。但是，它使用100纳秒作为增量单位，且时间开始于1601年1月1日，所以NT将遇到2184年问题。
　　苹果公司声明，Mac在29,940年之前不会出现时间问题！

二、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控制寄存器中设置了相应允许位，比较匹配时，将产生一个闹钟中断。

　　

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

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

　　　　RCC_APB1PeriphClockCmd (RCC_APB1Periph_PWR | RCC_APB1Periph_BKP,ENABLE );

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

　　　调用库函数：

　　　　PWR_BackupAccessCmd(ENABLE );

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

　　　调用库函数：

　　　BKP_DeInit ();

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

　　

6 ~- ~* {& [0 ?9 E9 t" B( G1 z

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

　　　调用的库函数：　　

　　　RCC_LSEConfig (RCC_LSE_ON);

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

　　　第五步：将 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 周期。
  7 A' ?# U  V0 k) I

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

1. /* 1.    查询 RTOFF 位，直到 RTOFF 的值变为’1’ */
   
2. 
   / S/ L# Z; K7 ^1 d
3. RTC_WaitForLastTask();//大家可以打开函数库看看这个函数内部的代码，就是查询 RTOFF的值
   
4. 
   # I* G* u: x0 c9 F  [6 m
5. /*
   
6. 
   
7. 2.置 CNF 值为 1 ，进入配置模式
   
8. 
   
9. 3.对一个或多个 RTC 寄存器进行写操作
   
10. 
    ( p9 o( g' }1 ^- [0 r" P
11. 4.清除 CNF 标志位，退出配置模式
    
12. 
    2 @3 E5 W9 ~7 E7 |4 @
13. */
    1 \+ m: A) Y6 }1 a# o8 N
14. 
    * ?7 Y1 L9 Y% o& E% \
15. RTC_SetPrescaler(32767); // 这里配置了预分频值，大家可以打开函数库看看这个函数的内部的代码，里面就有包含了 2、3、4 讲述的操作。
    
16. 
    
17. /*
    4 J8 ]/ Q+ s- q3 S8 u8 J( P
18. 每完成一个操作一般都要查询 RTOFF 来判断是否 RTC 正在更新数据,如果是则等待它完成!!!
    / F% D4 m0 p4 G/ E6 n) \
19. */
    
20. RTC_WaitForLastTask();//等待更新结束
    $ o! y  k& J0 |
21. 
    : o: t, ~7 d; G9 c) V8 x# J
22. RTC_ITConfig(RTC_IT_SEC, ENABLE);//配置秒中断
    , M% q1 V0 e  D' u1 s6 ?3 u/ o
23. 
    
24. RTC_WaitForLastTask();//等待更新结束

复制代码

8 l6 K" f$ }) e& D/ K
/ J3 e  S9 r5 \" ]. E三、程序演示

　　rtc.h

1. #ifndef __RTC_H
   
2. #define __RTC_H
   5 Z, _5 M5 q: N: X5 A
3. #include "stm32f10x.h"
   $ Z  `8 c9 a$ m( t! o
4. 
   ; N; \% q0 c0 c( S: K8 e, a
5. //时间结构体
   
6. typedef struct
   - b' e  ^; X# f# P
7. {
   ' r: w- P$ x: m( ?. x
8.     vu8 hour;
   2 s7 R1 l- {& m$ X7 s
9.     vu8 min;
   ; c# T( L/ F! @$ r0 C
10.     vu8 sec;            
    # ?1 l! ^3 e/ l1 \- C4 s% v5 j8 c4 [
11.     //公历年月日周
    . U1 F4 N& I/ y) D1 Y& j
12.     vu16 w_year;
    . g% g% D' s9 O  r) P  G
13.     vu8  w_month;
    
14.     vu8  w_date;
    
15.     vu8  week;     
    ) _2 R( N  \7 D" P9 a
16. }_calendar_obj;                     
    , @! k" ^7 {3 Z8 t4 i3 L1 r
17. extern _calendar_obj calendar;
    5 A# v0 s5 j+ Y: r
18. void RCC_Configuration(void);
    
19. void RTC_Init(void);
    
20. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec);
    
21. u8 RTC_Get(void);
    . E9 B' O  K- P9 W! j
22. #endif

复制代码

1 x) n8 y! S+ b3 u0 K
# E; s  v) y6 l, M( l- O' ]9 I

　　rtc.c

1. #include "rtc.h"
   
2. _calendar_obj calendar;    //时钟结构体
   ! `: z3 i( _5 z% {/ _
3. //平均的月份日期表
   
4. const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
   8 P0 U: p' Z* B6 \! I7 e
5. /*rtc中断向量配置*/
   1 ?9 F. B7 K0 v4 G/ L0 L
6. void NVIC_Configuration(void)
   
7. {
   
8.     NVIC_InitTypeDef NVIC_InitStructure;
   
9.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   
10.     NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
    / p) D- _# u3 |
11.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    
12.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
13.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    ; s/ R) K6 `6 \" q# k3 [: i3 B. i
14.     NVIC_Init(&NVIC_InitStructure);
    ( C' x) u- q+ {4 e6 w' S0 y# F; U
15. }
    
16. 
    
17. void RTC_Configuration(void)
    * }* p& i0 x0 m9 a9 H
18. 
    
19. {
    # c7 [& O. I# o- U
20.     /* 使能PWR和BKP时钟 */
    ! q9 l! p2 Y% {
21.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP,ENABLE);
    
22.     /* 使能对后备寄存器的访问 */
    
23.     PWR_BackupAccessCmd(ENABLE);
    
24.     /* 复位BKP寄存器 */
    % w/ i% l9 ]8 M* \
25.     BKP_DeInit();
    ' H6 @& h' ]# H4 G  `$ W
26.     /* 使能LSE */
    . Q' w: o9 l5 A( n. ~! d$ K$ }1 v
27.     RCC_LSEConfig(RCC_LSE_ON);
    
28.     /*等待启动完成 */
    $ }4 K7 v9 G: I' j' `
29.     while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {}
    
30.     /* 将 RTC时钟设置为LSE这个32.768KHZ的晶振*/
    
31.     RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    # f5 n; Z9 m6 G2 P; B
32.     /* 使能RTC Clock */
    + \" r. @% E$ b1 E  O* |
33.     RCC_RTCCLKCmd(ENABLE);
    
34.     /* 等待同步 */
    / X4 S# j; E) B) J' N
35.     RTC_WaitForSynchro();
    
36.     /* 等待对RTC寄存器最后的写操作完成*/            
    
37.     RTC_WaitForLastTask();
    
38.     /* 配置了预分频值: 设置RTC时钟周期为1s */
    % c9 V+ z  T. d+ i9 ?- Y/ }
39.     RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1)*/
    
40.     /* 等待对RTC寄存器最后的写操作完成 */
    , p" q! d- |4 `" i
41.     RTC_WaitForLastTask();
    
42.     /* 使能RTC秒中断 */
    
43.     RTC_ITConfig(RTC_IT_SEC, ENABLE);
    + N4 x& p9 z5 P. L# v- _5 ?+ _* W! g( {
44.     /* 等待对RTC寄存器最后的写操作完成 */         
    ' K  ^( V) z  s% v( u% \5 q# L$ _' z
45.     RTC_WaitForLastTask();
    9 f2 }, A9 }3 _" }
46. 
    
47. void RTC_Init(void)
    + U( _" o4 N( m# d' I0 p
48. {
    + _. o2 U: J7 q
49.     /*如果是第一次配置时钟，则执行RCC_Configuration()进行配置*/
    8 f3 i4 O. X) O. d! Q2 m0 f  H
50.     if(BKP_ReadBackupRegister(BKP_DR1)!=0x1016)
    2 [0 G$ H) E) L# B, w" }
51.     {
    # u4 ^- V0 _. ?+ ]7 X7 B8 E& F5 S
52.             RCC_Configuration();
    
53.             RTC_Set(2016,5,11,9,7,55);
    5 W  q, ?0 l( e4 i" W
54.             GPIO_SetBits(GPIOD, GPIO_Pin_13);//点亮D1
    6 j+ t/ [! O1 s' l9 u
55.             BKP_WriteBackupRegister(BKP_DR1, 0x1016);//向执行的后备寄存器中写入用户程序数据
    + b3 X! V7 J1 K: @
56.     }
    ) `9 Q) t/ d. z. y1 t: |) h
57.     else
    ! f9 @8 w  T, ^
58.     {
    
59.         RTC_WaitForSynchro();//等待RTC寄存器同步完成
    
60.         RTC_ITConfig(RTC_IT_SEC, ENABLE);//使能RTC秒中断
    
61.         RTC_WaitForLastTask();//等待最近一次对RTC寄存器的写操作完成
    , {7 }2 `4 l: W% x% z
62.         GPIO_SetBits(GPIOG, GPIO_Pin_14);//点亮D2
    - q4 w' e# X$ b$ g$ \8 c
63.     }
    * a% J4 l3 z2 h% e6 ?
64.     NVIC_Configuration();
    
65.     RTC_Get();//更新时间
    ; F( w, y& R8 w1 G9 Y
66. }
    0 a8 T1 r( Q% q
67. u8 Is_Leap_Year(u16 pyear)
    
68. {
    * Z5 k1 _/ `& i% I1 j+ c) i& W+ V
69.     if(pyear%4==0)//首先需能被4整除
    
70.     {
    
71.         if(pyear%100==0)
    
72.         {
    
73.             if(pyear%400==0)    return 1;//如果以00结尾，还要能被400整除
    
74.             else    return 0;
    
75.         }
    1 F: ^( @- p! }2 b! L
76.         else
    9 D  a8 N; J* D) n( P9 a4 w. X: j
77.             return 1;
    . R+ F. X3 t0 P! E4 f2 n+ \
78.     }
    1 b& F( W, S2 \# P5 S9 a
79.     else
    " h* E! S, i3 s
80.         return 0;
    $ B8 x) s9 q9 j  ]
81. }
    , W# O! I# c4 ?
82. /*
    
83. *设置时钟
    5 c- F; {4 `2 B/ c) ]) ^: \
84. *把输入的时钟转换为秒钟
    - s" ~" {5 @+ L% o% ^' l! f; p. A
85. *以1970年1月1日为基准
    # g& g& F# R4 O' h
86. *1970~2099年为合法年份
    
87. 返回值：0，成功；其它：错误
    
88. */
    
89. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec)
    3 w5 z3 k; J# F. ]
90. {
    
91.     u16 t;
    
92.     u32 secCount=0;
    
93.     if(year<1970||year>2099)
    
94.         return 1;//³ö´í
    
95.     for(t=1970;t<year;t++)    //把所有年份的秒钟相加
    % @. |( v: ~0 m6 T9 B9 n. v# k
96.     {
    
97.         if(Is_Leap_Year(t))//闰年
    
98.             secCount+=31622400;//闰年的秒钟数
    , V" I5 `! q1 M: |: S& l
99.         else
    2 W+ x0 c! x- G! Q
100.             secCount+=31536000;   
     7 P1 Y$ T7 X  p9 e! e6 l* Q9 b/ E
101.     }
     
102.     mon-=1;//先减掉一个月再算秒数（如现在是5月10日，则只需要算前4个月的天数，再加上10天，然后计算秒数）
     - Q6 }) V( _' |2 D4 i9 }
103.     for(t=0;t<mon;t++)
     + [2 r0 p9 b& p
104.     {
     
105.         secCount+=(u32)mon_table[t]*86400;//月份秒钟数相加
     ; L$ e5 `% s! p, C3 P0 L
106.         if(Is_Leap_Year(year)&&t==1)
     : r$ e5 [2 J8 ~8 |$ Q) K
107.             secCount+=86400;//闰年，2月份增加一天的秒钟数
     
108.     }
     
109.    
       P4 M8 }8 e' I9 @' I  X1 Y
110.     secCount+=(u32)(day-1)*86400;//把前面日期的秒钟数相加（这一天还没过完，所以-1）
     
111.     secCount+=(u32)hour*3600;//小时秒钟数
     
112.     secCount+=(u32)min*60;//分钟秒钟数
     ; v& S% v6 E+ N# I" x
113.     secCount+=sec;
     2 f( `6 v% K, r' u! Q# ^( r
114. //    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR    | RCC_APB1Periph_BKP,ENABLE);
     
115. //    PWR_BackupAccessCmd(ENABLE);
     
116.     RTC_SetCounter(secCount);//设置RTC计数器的值
     / h" R& D8 S+ S) V
117.     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
     ( }7 m) y) _4 I# Z* H
118.     RTC_Get();//更新时间
     
119.     return 0;
     
120. }
     
121. 
     
122. /*
     
123. 得到当前的时间
     
124. 成功返回0，错误返回其它
     
125. */
     : I% o1 {% i% t9 r9 L
126. u8 RTC_Get(void)
     4 J" j/ O2 s% U  P* R8 ?) c
127. {
     + Y: b+ t9 L/ ?5 l
128.         static u16 dayCount=0;
     
129.         u32 secCount=0;
     1 H6 ~1 |- |( Z# L# {4 L0 n% r
130.         u32 tmp=0;
     
131.         u16 tmp1=0;
     $ x; X* {! C& m/ {
132.         secCount=RTC_GetCounter();
     9 V) ?- b3 V: j4 o
133.         tmp=secCount/86400;//得到天数
     
134.         if(dayCount!=tmp)//超过一天
     
135.         {
     
136.             dayCount=tmp;
     $ V/ R- c4 H9 e# {7 A8 Q8 \
137.             tmp1=1970;//从1970年开始
     
138.             while(tmp>=365)
     
139.             {
     ! I/ j) O- D! o4 c1 e, d
140.                 if(Is_Leap_Year(tmp1))//是闰年
     
141.                 {
     
142.                     if(tmp>=366)   
     
143.                         tmp-=366;//减掉闰年的天数
     # y; W! {' X! {4 U7 x4 A# N
144.                     else
     / |* V/ p+ W3 U# i& i4 F# r; C8 w
145.                     {
     , [, H& T6 m/ a+ |7 s, m
146.                     //    tmp1++;
     ( W% _; g/ o( g7 u) E% ]
147.                         break;
     ! m& Z9 {& g: E5 |- R* b' E% s" _
148.                     }
     7 C! S- `4 n4 g% U* }
149.                 }
     
150.                 else
     
151.                     tmp-=365;//平年
     # \2 ^1 j/ @' R: \
152.                 tmp1++;
     3 j- L, t5 q5 z& s, {5 j! e
153.             }
     " H$ j2 i+ f4 f3 D6 r  ]3 \6 z
154.             calendar.w_year=tmp1;//得到年份
     
155.             tmp1=0;
     : x7 v$ A6 B) I( _- y
156.             while(tmp>=28)//超过一个月
     
157.             {
     
158.                 if(Is_Leap_Year(calendar.w_year)&&tmp1==1)/当年是闰年且轮循到2月
     " ], O! O% @! K/ r8 e" Z7 |
159.                 {
     
160.                     if(tmp>=29)   
     
161.                         tmp-=29;
     
162.                     else
     5 k. \4 g# S7 P! X& d6 H
163.                         break;
     , q; I! o$ |" X/ Y
164.                 }
     
165.                 else
     1 `5 [8 N/ c6 G7 Q/ r, w; l& @0 J
166.                 {
     
167.                     if(tmp>=mon_table[tmp1])//平年
     
168.                         tmp-=mon_table[tmp1];
     
169.                     else
     
170.                         break;
     
171.                 }
     ! Z% n+ A1 W7 Y  X
172.                 tmp1++;
     
173.             }
     0 Y0 z; u6 O/ ^: u! L4 q6 x  `
174.             calendar.w_month=tmp1+1;//得到月份，tmp1=0表示1月，所以要加1
     
175.             calendar.w_date=tmp+1;    //得到日期，因为这一天还没过完，所以tmp只到其前一天，但是显示的时候要显示正常日期
     
176.         }
     . a1 m1 p( q! z4 F) b& K! g6 S
177.         tmp=secCount%86400;//得到秒钟数
     - B* C& u* o. i" {
178.         calendar.hour=tmp/3600;//小时
     
179.         calendar.min=(tmp%3600)/60;//分钟
     
180.         calendar.sec=(tmp%3600)%60;//秒
     ; @# r5 R  P8 \: f9 `
181.         return 0;
     
182. }
     ) ~5 B% q; Z- j8 [- G  j- a. h8 f
183. /*
     
184. RTC时钟中断
     
185. 每秒触发一次
     & ~5 h7 A$ ?! p5 t- A& Z2 z
186. */
     " \- i) F) K8 c5 Y. w
187. void RTC_IRQHandler(void)
     
188. {         
     
189.     if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断
     - W( i# S2 n& C  I* ]: `2 n
190.     {                           
     
191.         RTC_Get();//更新时间
     
192.       
     
193.      }
     / o  @! Z& k" Q' Q3 Q) l" c. `
194.     if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断
     ; q% A0 j$ m+ O
195.     {
     
196.         RTC_ClearITPendingBit(RTC_IT_ALR);//清闹钟中断        
     
197.   }                                                   
     
198.     RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);//清闹钟中断
     
199.     RTC_WaitForLastTask();                                                   
     : w; t. ^5 |% l
200. }

复制代码

! Z6 N' L: N" d, n" ~- l2 k+ N

　　main.c

1. #include "stm32f10x.h"
   ; x# s# ?  ?5 x! H
2. #include "usart1.h"
   ( g# d" B, n; A- w
3. #include "LED.h"
   : y8 s) r' J# V
4. #include "delay.h"
   " D' }- [- e+ h; |8 p
5. #include "flash.h"
   
6. #include "rtc.h"
   
7. #include "stdio.h"
   1 v" _, ^' `. C/ [
8. int main(void)
   6 A" h+ b# o" ?$ Y- v8 g
9. {
   
10.     u8 t=0;
    0 p& z! K- p" e7 V7 c( r
11.     USART1_Config();
    5 W( J  ]7 E$ h) f9 V3 X
12.     GPIO_Configuration();
    
13.     RTC_Init();
    
14.     while(1)
    9 I: `/ p8 h1 V$ W
15.     {
    + {% E7 ?! e2 W( Z( O. L
16.         if(t!=calendar.sec)
    
17.         {
    
18.             t=calendar.sec;
    / a2 j7 U, N) V0 T- _  X7 [
19.             printf("\r\n now is %d 年 %d 月 %d 日 %d 时 %d 分 %d 秒 \r\n ",
    ; n; N$ [7 @* [3 s9 v" q
20. 　　　　　　　calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
    ' V" t8 z& b( a3 a* j5 F/ J
21.         }
    7 u* U4 @' w3 c
22.         Delay(0x02FFFF);
    ' W+ `( L% _, m' G$ b. q
23.     }
    
24.    
    
25.    
    
26. }   

复制代码

5 U2 J( X* B' q) F) U; m& o( n
. P. X4 b" [/ H1 G  A3 ]