一、关于时间

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

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

                2^31/3600/24/365 ≈ 68年
4 k. T0 a# T- ^2 F9 O3 M　　所以依照此“time_t”标准，在此格式能被表示的最后时间是2038年1月19日03:14:07，星期二（UTC）。超过此一瞬间，时间将会被掩盖（wrap around）且在内部被表示为一个负数，并造成程序无法工作，因为它们无法将此时间识别为2038年，而可能会依个别实作而跳回1970年或1901年。
. f+ U* j2 r# Y/ {: ?　　对于PC机来说，时间开始于1980年1月1日，并以无正负符号的32位整数的形式按秒递增，这与UNIX时间非常类似。可以算得：
                 2^32/3600/24/365 ≈ 136年
! q9 V9 P& T8 D5 G　　到2116年，这个整数将溢出。
　　　　Windows NT使用64位整数来计时。但是，它使用100纳秒作为增量单位，且时间开始于1601年1月1日，所以NT将遇到2184年问题。
　　苹果公司声明，Mac在29,940年之前不会出现时间问题！
( z7 `7 o; ?, P: \7 C) `5 S: z
二、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，如下图：

　　

( k+ G+ W% }! o$ w1 a- h" a

　　　我们需要将 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 周期。
    K! n/ s0 W6 s5 R4 u

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

1. /* 1.    查询 RTOFF 位，直到 RTOFF 的值变为’1’ */
   
2. 
   
3. RTC_WaitForLastTask();//大家可以打开函数库看看这个函数内部的代码，就是查询 RTOFF的值
   
4. 
   ' O$ y# G: I% j5 n& S+ i7 d
5. /*
   0 a# y: C  O) _: U4 ]1 y3 Y
6. 
   
7. 2.置 CNF 值为 1 ，进入配置模式
   
8. 
   
9. 3.对一个或多个 RTC 寄存器进行写操作
   
10. 
    5 o; ~" g# m% ~3 l- |
11. 4.清除 CNF 标志位，退出配置模式
    8 N5 O& A/ W5 j( Q7 U: P1 p, T
12. 
    
13. */
    + H; Q+ G1 J. H* h6 |) F, ^- c' t
14. 
    
15. RTC_SetPrescaler(32767); // 这里配置了预分频值，大家可以打开函数库看看这个函数的内部的代码，里面就有包含了 2、3、4 讲述的操作。
    + @1 a9 y0 ^0 u+ |
16. 
    
17. /*
    : Z. ?6 l8 o5 G) u
18. 每完成一个操作一般都要查询 RTOFF 来判断是否 RTC 正在更新数据,如果是则等待它完成!!!
    ' c( Y4 s% r' B/ p7 [. E
19. */
    9 V3 Z! `1 t  k& c: z1 K6 O
20. RTC_WaitForLastTask();//等待更新结束
    % l- C1 ?- J; h4 x2 c
21. 
    
22. RTC_ITConfig(RTC_IT_SEC, ENABLE);//配置秒中断
    
23. 
    
24. RTC_WaitForLastTask();//等待更新结束

复制代码

. ~$ G1 G7 x  P: H$ k$ U
7 i, f+ n7 q& S; {4 G三、程序演示

　　rtc.h

1. #ifndef __RTC_H
   
2. #define __RTC_H
   
3. #include "stm32f10x.h"
   * R9 E' ]) y0 U2 b( Y5 e
4. 
   
5. //时间结构体
   & K6 b1 K- t5 _6 Q- c5 g4 g+ o
6. typedef struct
   9 z! o! w! N5 E7 P4 Q6 E. q
7. {
   8 d* \4 n; C9 Z, }
8.     vu8 hour;
   , M/ j7 K# e: `( ~$ X+ W
9.     vu8 min;
   $ Y. F* i  T& Y6 Y! L/ b) X
10.     vu8 sec;            
    8 F+ |* {& u9 \2 W# T
11.     //公历年月日周
    3 A( Y+ C% z) p+ h  w
12.     vu16 w_year;
    ; q% B: ^# U( g9 `6 a$ F! T6 G
13.     vu8  w_month;
    
14.     vu8  w_date;
    
15.     vu8  week;     
    " n" \, {& d4 W4 U
16. }_calendar_obj;                     
    $ ?* M0 X: x* K( j
17. extern _calendar_obj calendar;
    + }' D. S% H( U1 B4 k4 `9 [
18. void RCC_Configuration(void);
    
19. void RTC_Init(void);
    " E$ S# @  I) o& u0 q
20. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec);
    1 [. P, K; `2 f1 @9 Z
21. u8 RTC_Get(void);
    ; U6 A) ?- ?8 V8 L$ M. W( j
22. #endif

复制代码

& \0 E8 y2 Q! }" a

　　rtc.c

1. #include "rtc.h"
   / n' h* `! W0 _9 }/ e8 }- ~
2. _calendar_obj calendar;    //时钟结构体
   
3. //平均的月份日期表
   ; o1 {8 U$ a8 r9 Q
4. const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
   
5. /*rtc中断向量配置*/
   ' N, j+ r2 U5 P# u
6. void NVIC_Configuration(void)
   ! v2 Z* R$ ^" {9 h& {. a4 }
7. {
   
8.     NVIC_InitTypeDef NVIC_InitStructure;
   % q% [7 A1 S6 N' C% `( E6 P
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;
    : l% p9 K* D( r% c3 M* T
13.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
14.     NVIC_Init(&NVIC_InitStructure);
    
15. }
    
16. 
    9 m2 t  b  ~: O
17. void RTC_Configuration(void)
    
18. 
    2 Q; D) N4 v: H. D5 b# ]
19. {
    
20.     /* 使能PWR和BKP时钟 */
    
21.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP,ENABLE);
    9 S" z. O8 J9 I' ~* J
22.     /* 使能对后备寄存器的访问 */
    , |1 E: X9 P" F" L# v
23.     PWR_BackupAccessCmd(ENABLE);
    
24.     /* 复位BKP寄存器 */
    7 j* V0 O. [) {" A/ m
25.     BKP_DeInit();
    6 {  V( q5 z5 O& Q9 V0 w3 O* G
26.     /* 使能LSE */
    ' f' M5 r, F1 D8 R' H) a1 ]
27.     RCC_LSEConfig(RCC_LSE_ON);
    ( C- |- |( G! F2 a$ l
28.     /*等待启动完成 */
    
29.     while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {}
    
30.     /* 将 RTC时钟设置为LSE这个32.768KHZ的晶振*/
    
31.     RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
      @7 ?, H) J$ X0 [1 u$ F- ^- G0 u
32.     /* 使能RTC Clock */
    ( Z' v$ X6 [" ^; B6 c, E
33.     RCC_RTCCLKCmd(ENABLE);
    % E# d1 x* M* z0 R6 w3 o+ [8 y
34.     /* 等待同步 */
    
35.     RTC_WaitForSynchro();
    ; m8 N' [( r( F  a
36.     /* 等待对RTC寄存器最后的写操作完成*/            
    & v  G* U- ?3 ~! D) s2 M+ ]
37.     RTC_WaitForLastTask();
    
38.     /* 配置了预分频值: 设置RTC时钟周期为1s */
    + A. l5 N0 ^1 v
39.     RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1)*/
    
40.     /* 等待对RTC寄存器最后的写操作完成 */
    
41.     RTC_WaitForLastTask();
    1 y+ S# c- E: `
42.     /* 使能RTC秒中断 */
    
43.     RTC_ITConfig(RTC_IT_SEC, ENABLE);
    # s. B# T" N" K9 X2 T
44.     /* 等待对RTC寄存器最后的写操作完成 */         
    
45.     RTC_WaitForLastTask();
    
46. 
    ( j. ~9 e9 K; i: i  Q
47. void RTC_Init(void)
    
48. {
    
49.     /*如果是第一次配置时钟，则执行RCC_Configuration()进行配置*/
    
50.     if(BKP_ReadBackupRegister(BKP_DR1)!=0x1016)
    ; j2 I; R# X$ \% L( U
51.     {
    
52.             RCC_Configuration();
    
53.             RTC_Set(2016,5,11,9,7,55);
    
54.             GPIO_SetBits(GPIOD, GPIO_Pin_13);//点亮D1
    & S* X$ `: @2 b& V
55.             BKP_WriteBackupRegister(BKP_DR1, 0x1016);//向执行的后备寄存器中写入用户程序数据
    
56.     }
    
57.     else
    $ N  r  g, x# W
58.     {
    
59.         RTC_WaitForSynchro();//等待RTC寄存器同步完成
    9 l; ]  e2 `$ K! E1 J. \  \9 w  g
60.         RTC_ITConfig(RTC_IT_SEC, ENABLE);//使能RTC秒中断
    # t% }$ V/ r2 ~3 G
61.         RTC_WaitForLastTask();//等待最近一次对RTC寄存器的写操作完成
    
62.         GPIO_SetBits(GPIOG, GPIO_Pin_14);//点亮D2
      L5 J8 l) _1 K$ ]6 l- S9 O
63.     }
    ) u4 u0 a+ i/ k, Z9 ?0 n: _* G$ T+ t6 T* g
64.     NVIC_Configuration();
    
65.     RTC_Get();//更新时间
    . `7 g8 C% c5 b# k5 l: C
66. }
      c0 S( W) b! ^; V' U5 m) _
67. u8 Is_Leap_Year(u16 pyear)
    5 B( V& ~1 o* Z. l
68. {
    
69.     if(pyear%4==0)//首先需能被4整除
    , ~* }2 t) Z6 f, w
70.     {
    . C+ M' l9 k  W: ]
71.         if(pyear%100==0)
    ! x1 R# E/ E8 {9 E
72.         {
    5 }. r9 ^; [) j: ~) m0 ?; t
73.             if(pyear%400==0)    return 1;//如果以00结尾，还要能被400整除
    
74.             else    return 0;
    2 P6 s  W) e0 s. R  W3 C
75.         }
    + N7 ]' Z: z4 `3 q' E2 j5 K
76.         else
    
77.             return 1;
    7 Y2 P2 F! B0 y" H1 v( `0 |
78.     }
    
79.     else
    
80.         return 0;
    
81. }
    ( s( @0 P- o4 c% U, V5 B5 O$ }
82. /*
    7 h: i7 @6 N8 z: o3 o& {  k
83. *设置时钟
    $ B( U- Q, g/ c7 W
84. *把输入的时钟转换为秒钟
    ; i8 {/ ^9 M+ \( b+ f) n8 m
85. *以1970年1月1日为基准
    5 {' d: Y; ?( f
86. *1970~2099年为合法年份
    
87. 返回值：0，成功；其它：错误
    ( h1 {! V0 [) I/ X; |4 \* W
88. */
    
89. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec)
    + e( ^# B0 ^" x2 c) Y1 D" g! {
90. {
    & V: ~* s1 P$ b: m. E0 |
91.     u16 t;
    $ ^+ u4 _# o, P9 \4 u" {
92.     u32 secCount=0;
    
93.     if(year<1970||year>2099)
    
94.         return 1;//³ö´í
    
95.     for(t=1970;t<year;t++)    //把所有年份的秒钟相加
    
96.     {
    
97.         if(Is_Leap_Year(t))//闰年
    6 C  F, v% A9 K0 y. t3 o
98.             secCount+=31622400;//闰年的秒钟数
    
99.         else
    
100.             secCount+=31536000;   
     
101.     }
     
102.     mon-=1;//先减掉一个月再算秒数（如现在是5月10日，则只需要算前4个月的天数，再加上10天，然后计算秒数）
     
103.     for(t=0;t<mon;t++)
     
104.     {
     
105.         secCount+=(u32)mon_table[t]*86400;//月份秒钟数相加
     ' G9 H' }8 e- k0 i
106.         if(Is_Leap_Year(year)&&t==1)
     
107.             secCount+=86400;//闰年，2月份增加一天的秒钟数
     
108.     }
     . ]9 Z$ e3 {  N- y5 M
109.    
     6 B9 p6 |9 i8 L$ a$ t! P# L
110.     secCount+=(u32)(day-1)*86400;//把前面日期的秒钟数相加（这一天还没过完，所以-1）
     7 J* D: Z, o/ k
111.     secCount+=(u32)hour*3600;//小时秒钟数
     . p( L$ c1 D/ \. p
112.     secCount+=(u32)min*60;//分钟秒钟数
     
113.     secCount+=sec;
     
114. //    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR    | RCC_APB1Periph_BKP,ENABLE);
     
115. //    PWR_BackupAccessCmd(ENABLE);
     * G/ m( j1 X7 L& Z2 G7 `' C
116.     RTC_SetCounter(secCount);//设置RTC计数器的值
     
117.     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
     ) X% I9 q- R% o* V1 p
118.     RTC_Get();//更新时间
     
119.     return 0;
     
120. }
     2 |- f' s5 o2 D7 W+ k* J
121. 
     
122. /*
     3 |9 A+ J; E& }
123. 得到当前的时间
     
124. 成功返回0，错误返回其它
     5 h, R# v! @7 [, N$ e
125. */
     
126. u8 RTC_Get(void)
     % V' `" d" R! [3 b* g+ W! l1 m! q
127. {
     " N9 s; |8 ?) q' N& L/ G
128.         static u16 dayCount=0;
     ( p; G  F* |) d
129.         u32 secCount=0;
     / L& {5 P+ c* R$ B) J/ A
130.         u32 tmp=0;
     # w" g, t1 \* m! L
131.         u16 tmp1=0;
     ! V, C# U% |+ g
132.         secCount=RTC_GetCounter();
     
133.         tmp=secCount/86400;//得到天数
     
134.         if(dayCount!=tmp)//超过一天
     
135.         {
     % i, K+ N" h9 L8 W5 V  L9 Z
136.             dayCount=tmp;
     0 D: I* o4 l' p# V/ r$ n
137.             tmp1=1970;//从1970年开始
     3 q# q$ k. w: I6 P
138.             while(tmp>=365)
     * @9 s" n/ i8 O( Z: d
139.             {
     * X( t1 w# P! W. V" T8 @0 l
140.                 if(Is_Leap_Year(tmp1))//是闰年
     
141.                 {
     
142.                     if(tmp>=366)   
     
143.                         tmp-=366;//减掉闰年的天数
     
144.                     else
     
145.                     {
     
146.                     //    tmp1++;
     
147.                         break;
     
148.                     }
     
149.                 }
     
150.                 else
     * ]5 t5 E' F% d
151.                     tmp-=365;//平年
     $ I, r* A( s; `! |. u5 D6 K/ |8 H
152.                 tmp1++;
     + {: G. v& c* w) O
153.             }
       ]' i) X( J& B; U
154.             calendar.w_year=tmp1;//得到年份
     
155.             tmp1=0;
     : P6 g% j! h: A
156.             while(tmp>=28)//超过一个月
     " [; M8 w1 u) [% W$ a* Z  P
157.             {
     5 Y$ o  c" A* }* t) }4 O& P, K
158.                 if(Is_Leap_Year(calendar.w_year)&&tmp1==1)/当年是闰年且轮循到2月
     6 ~* W8 a( z! ^, }8 P
159.                 {
     / l+ l4 @( _- _. r
160.                     if(tmp>=29)   
     5 w7 @& d' Y8 m1 f* p: F
161.                         tmp-=29;
     
162.                     else
     ) B9 t3 \& Q: P- u3 [
163.                         break;
     
164.                 }
     
165.                 else
     
166.                 {
     
167.                     if(tmp>=mon_table[tmp1])//平年
     
168.                         tmp-=mon_table[tmp1];
     
169.                     else
     ) K' R* U* y" n1 N: G2 I8 X6 r2 p
170.                         break;
     8 y" X9 a2 k" T
171.                 }
     ; n+ s* t4 {' y6 R6 E
172.                 tmp1++;
     
173.             }
     
174.             calendar.w_month=tmp1+1;//得到月份，tmp1=0表示1月，所以要加1
     
175.             calendar.w_date=tmp+1;    //得到日期，因为这一天还没过完，所以tmp只到其前一天，但是显示的时候要显示正常日期
     
176.         }
     
177.         tmp=secCount%86400;//得到秒钟数
     5 [- A9 X' e' p1 i; L
178.         calendar.hour=tmp/3600;//小时
     7 O  g! ], F1 O( {* Q4 n. b
179.         calendar.min=(tmp%3600)/60;//分钟
     , b( X' p# D5 p$ K2 N  ^6 K- f' _
180.         calendar.sec=(tmp%3600)%60;//秒
     + J/ u+ T9 W$ J. b
181.         return 0;
     
182. }
     ( f" ?5 L7 X6 x: K! M
183. /*
     9 N0 u8 o: w5 _  m+ A) E
184. RTC时钟中断
     
185. 每秒触发一次
     
186. */
     
187. void RTC_IRQHandler(void)
     / x9 K: v" [& K2 y8 j  E
188. {         
     ( G: y- }8 l# [/ K& h* s! ]
189.     if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断
     8 o5 ]1 |& z% p# {% T
190.     {                           
     
191.         RTC_Get();//更新时间
     
192.       
     & J9 x3 t9 D3 @" n0 U
193.      }
     
194.     if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断
     & T: W( p& X8 ?
195.     {
     
196.         RTC_ClearITPendingBit(RTC_IT_ALR);//清闹钟中断        
     
197.   }                                                   
     
198.     RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);//清闹钟中断
     ' D* N+ N" Q4 T; `8 {0 n2 V9 ?+ f
199.     RTC_WaitForLastTask();                                                   
     
200. }

复制代码

& ~% F8 ?/ r. `" Z% I, v) f

　　main.c

1. #include "stm32f10x.h"
   ! J& }( X9 x( S" j
2. #include "usart1.h"
   
3. #include "LED.h"
   
4. #include "delay.h"
   / l0 x0 U3 D" @
5. #include "flash.h"
   , k$ o& |9 X6 `' t
6. #include "rtc.h"
   
7. #include "stdio.h"
   - h- _  ^1 p# h: g8 G$ B0 A+ s
8. int main(void)
   , x+ n% w- V' R( w3 Q8 ^5 U0 s4 J+ |
9. {
   
10.     u8 t=0;
    
11.     USART1_Config();
    / t1 \; i1 o1 p9 U/ B
12.     GPIO_Configuration();
    8 S  y# B( g) I6 J, @1 d2 a
13.     RTC_Init();
    
14.     while(1)
    
15.     {
    , c3 L' i6 j  }  U" V. u
16.         if(t!=calendar.sec)
    1 C) V8 D$ g. P8 Q8 Z
17.         {
    
18.             t=calendar.sec;
    
19.             printf("\r\n now is %d 年 %d 月 %d 日 %d 时 %d 分 %d 秒 \r\n ",
    0 ^+ _5 ]; t9 o- j3 t  p9 H; I& r
20. 　　　　　　　calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
    7 H+ {  ~! Q# r' t0 J0 j
21.         }
    # ~0 |9 L3 J! g( N7 z& I& ?) d
22.         Delay(0x02FFFF);
    8 @7 D1 {+ G( M
23.     }
    
24.    
    
25.    
    
26. }   

复制代码

( m5 [' H# q7 E
9 p- M3 c4 a2 U! Q
, m/ |5 p+ K- I
2 ]% j' ]" _- A( ^8 ]8 L6 X' C; a