一、关于时间

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

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

                2^31/3600/24/365 ≈ 68年
$ J1 l9 I; M+ z# B　　所以依照此“time_t”标准，在此格式能被表示的最后时间是2038年1月19日03:14:07，星期二（UTC）。超过此一瞬间，时间将会被掩盖（wrap around）且在内部被表示为一个负数，并造成程序无法工作，因为它们无法将此时间识别为2038年，而可能会依个别实作而跳回1970年或1901年。
　　对于PC机来说，时间开始于1980年1月1日，并以无正负符号的32位整数的形式按秒递增，这与UNIX时间非常类似。可以算得：
; D0 R8 d9 P8 r6 c0 E                 2^32/3600/24/365 ≈ 136年
　　到2116年，这个整数将溢出。
+ K$ z1 j6 d* U- ?: q7 U. d　　　　Windows NT使用64位整数来计时。但是，它使用100纳秒作为增量单位，且时间开始于1601年1月1日，所以NT将遇到2184年问题。
　　苹果公司声明，Mac在29,940年之前不会出现时间问题！
; U" d% ^2 P# p, O  z6 k2 _' s
8 N: v% r5 |7 G! G( l7 Q; U( y二、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 位来打开电源和后备接口的时钟
- C" }2 l0 k% N% l' b+ h% |　　　调用库函数：

　　　　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 的晶振。

　　　调用的库函数：　　

0 x4 ?' K8 |0 `  a5 @& c% a, o

　　　RCC_LSEConfig (RCC_LSE_ON);

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

+ _8 K6 j/ u7 M

　　　第五步：将 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 周期。
  

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

1. /* 1.    查询 RTOFF 位，直到 RTOFF 的值变为’1’ */
   
2. 
   2 i* n: y7 k4 p2 Q+ _4 F1 z
3. RTC_WaitForLastTask();//大家可以打开函数库看看这个函数内部的代码，就是查询 RTOFF的值
   ' Y& x8 I% B# i( C8 @; I* h9 ?
4. 
   
5. /*
   + o& ?# F" [: K5 k
6. 
   : g* u% a6 t# B% B' x% S% S% D' g
7. 2.置 CNF 值为 1 ，进入配置模式
   
8. 
   
9. 3.对一个或多个 RTC 寄存器进行写操作
   6 E$ p5 Q& [" D* I
10. 
    9 e( q6 V4 Z+ ^) S
11. 4.清除 CNF 标志位，退出配置模式
    8 S- V0 n+ k. \/ D: [6 f
12. 
      h: s. ?/ h. t7 `. J" r
13. */
    
14. 
    * n7 {) j4 q, q0 R- G0 D
15. RTC_SetPrescaler(32767); // 这里配置了预分频值，大家可以打开函数库看看这个函数的内部的代码，里面就有包含了 2、3、4 讲述的操作。
    
16. 
    
17. /*
    8 L1 [0 C' ?' q4 B! ?: E% o
18. 每完成一个操作一般都要查询 RTOFF 来判断是否 RTC 正在更新数据,如果是则等待它完成!!!
    1 V/ ^" g* D: P: w, a3 {
19. */
    
20. RTC_WaitForLastTask();//等待更新结束
    
21. 
    
22. RTC_ITConfig(RTC_IT_SEC, ENABLE);//配置秒中断
    
23. 
    . c& u: T( b$ Y
24. RTC_WaitForLastTask();//等待更新结束

复制代码

9 ]" l9 l+ T" ?! X8 {三、程序演示

　　rtc.h

1. #ifndef __RTC_H
   
2. #define __RTC_H
   
3. #include "stm32f10x.h"
   
4. 
   " E5 a  d8 G/ x. i
5. //时间结构体
   
6. typedef struct
   + m1 M2 Z  [% i
7. {
   % Q8 T4 F. G5 P- q% n+ g! G8 J
8.     vu8 hour;
   & i* L) H% m9 U
9.     vu8 min;
   
10.     vu8 sec;            
      z' `5 _- U) D
11.     //公历年月日周
    ( @7 @2 G$ M; @" i. j" B2 E
12.     vu16 w_year;
    
13.     vu8  w_month;
    8 X+ s3 B" n- m% Y! {
14.     vu8  w_date;
    
15.     vu8  week;     
    
16. }_calendar_obj;                     
    
17. extern _calendar_obj calendar;
    * Q+ M& O. Q6 q* |1 ~) ~
18. void RCC_Configuration(void);
    ! x0 Y% C7 V9 m# B- Y
19. void RTC_Init(void);
    
20. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec);
    - \, _6 v" d# T% {8 ]. ~0 I
21. u8 RTC_Get(void);
    2 c( h) M% V  x5 \/ r8 g' ?- b
22. #endif

复制代码

, }% ]5 [5 S* y. s& ~

　　rtc.c

1. #include "rtc.h"
   ; x; `; j5 _4 u% ~
2. _calendar_obj calendar;    //时钟结构体
   
3. //平均的月份日期表
   
4. const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
   7 t# t/ Y3 Z$ a8 x  v
5. /*rtc中断向量配置*/
   / c4 E" E* f: B. Z5 f, \1 q) L
6. void NVIC_Configuration(void)
   / a& l  `. A. P& M, z
7. {
   
8.     NVIC_InitTypeDef NVIC_InitStructure;
   ( J: I7 A0 [' F0 F, y
9.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   + m* U: A3 E, F" F. A7 e6 L
10.     NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
    ' [- Y8 N2 K4 j1 I5 M
11.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    / Y: `* T4 I' Q
12.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    3 A* @, d: O  C, F( P! ~2 F' K
13.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    8 i2 q1 q' b# W- l( A
14.     NVIC_Init(&NVIC_InitStructure);
    " B5 X7 H: `9 Q" ^* }; B$ @
15. }
    
16. 
    ' c  E) c7 C! X% V
17. void RTC_Configuration(void)
    / [  Z0 n# S- `! D
18. 
    
19. {
    / V- c  N% g1 d% W$ G1 _8 u9 ?4 [
20.     /* 使能PWR和BKP时钟 */
    ) K, B9 Y; J* C+ d* t: V
21.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP,ENABLE);
    
22.     /* 使能对后备寄存器的访问 */
    1 w* s  F' I& A3 q; C# w
23.     PWR_BackupAccessCmd(ENABLE);
    9 U5 n  r7 k7 `, Z4 \" @
24.     /* 复位BKP寄存器 */
    
25.     BKP_DeInit();
    
26.     /* 使能LSE */
    
27.     RCC_LSEConfig(RCC_LSE_ON);
    , v! a. m& ?* a( ~) L  \% O5 T
28.     /*等待启动完成 */
    
29.     while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {}
      n: X1 k% }0 f% M# c- }$ Q1 F
30.     /* 将 RTC时钟设置为LSE这个32.768KHZ的晶振*/
    
31.     RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    
32.     /* 使能RTC Clock */
    
33.     RCC_RTCCLKCmd(ENABLE);
    
34.     /* 等待同步 */
    
35.     RTC_WaitForSynchro();
    
36.     /* 等待对RTC寄存器最后的写操作完成*/            
    
37.     RTC_WaitForLastTask();
    * Y$ w0 f0 ]7 f% ]  ^! M
38.     /* 配置了预分频值: 设置RTC时钟周期为1s */
    
39.     RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1)*/
    
40.     /* 等待对RTC寄存器最后的写操作完成 */
    + L# O, ^2 y1 o3 _' h; m
41.     RTC_WaitForLastTask();
    9 [$ x2 G, F: h# @2 a: O
42.     /* 使能RTC秒中断 */
    ( M) i! J+ G2 H
43.     RTC_ITConfig(RTC_IT_SEC, ENABLE);
    - |& i2 I+ m2 L" s% |1 a  _
44.     /* 等待对RTC寄存器最后的写操作完成 */         
    
45.     RTC_WaitForLastTask();
    
46. 
    + i! s3 a: u3 n5 z! V
47. void RTC_Init(void)
    - q5 T0 I5 W: ~5 E+ X
48. {
    
49.     /*如果是第一次配置时钟，则执行RCC_Configuration()进行配置*/
    
50.     if(BKP_ReadBackupRegister(BKP_DR1)!=0x1016)
    * @! R6 J  F& h% c4 q+ T
51.     {
    6 l8 M7 f/ q# C' b6 K
52.             RCC_Configuration();
    
53.             RTC_Set(2016,5,11,9,7,55);
    # E3 a" `2 n3 W4 Z6 k0 v- r. }3 V
54.             GPIO_SetBits(GPIOD, GPIO_Pin_13);//点亮D1
    
55.             BKP_WriteBackupRegister(BKP_DR1, 0x1016);//向执行的后备寄存器中写入用户程序数据
    
56.     }
    + y4 x- H& x& x) r% ~
57.     else
      p% R8 r% G1 P$ ]; g9 I7 s( I- z
58.     {
    + o+ Y7 D4 I- I" B, n" _2 \; E
59.         RTC_WaitForSynchro();//等待RTC寄存器同步完成
    0 L. Q* L( R. @$ J
60.         RTC_ITConfig(RTC_IT_SEC, ENABLE);//使能RTC秒中断
    
61.         RTC_WaitForLastTask();//等待最近一次对RTC寄存器的写操作完成
    " s5 p  j# h- r
62.         GPIO_SetBits(GPIOG, GPIO_Pin_14);//点亮D2
    / o5 k/ P6 V" Z5 X
63.     }
    / \/ u% x# B5 j5 V5 L
64.     NVIC_Configuration();
    
65.     RTC_Get();//更新时间
    
66. }
    : l9 |9 q0 E2 p( V5 \
67. u8 Is_Leap_Year(u16 pyear)
    ! K' ^! Y- a- c" c6 E" m5 J6 y$ }2 M# a2 K
68. {
    
69.     if(pyear%4==0)//首先需能被4整除
    
70.     {
    * ~" f" I! x4 e8 }
71.         if(pyear%100==0)
    ; T. Q; @* J4 K" _/ `
72.         {
    % U/ D' e& [1 `
73.             if(pyear%400==0)    return 1;//如果以00结尾，还要能被400整除
    ( R* ]* {$ O* T! y4 A* [9 A
74.             else    return 0;
    
75.         }
      L- I6 I; D0 _9 q2 _
76.         else
    ' O( j* D9 v5 b5 R, L
77.             return 1;
    . p  @! A% Q) w9 j' g
78.     }
    - n6 a* g: }2 U. u) ~( f
79.     else
    # d" V( E# v1 P% ]- K( d1 }+ r
80.         return 0;
    
81. }
    5 g: \3 \% M* m9 ]$ l6 K) H
82. /*
    
83. *设置时钟
    
84. *把输入的时钟转换为秒钟
    
85. *以1970年1月1日为基准
    
86. *1970~2099年为合法年份
    
87. 返回值：0，成功；其它：错误
    , _" C" d9 E) B: x
88. */
    * S$ [3 u8 z4 j4 Z8 S5 l& w6 _; Z" b
89. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec)
    ' R7 L! z8 Z+ S% r9 a% f
90. {
    1 P) d; e: W9 y* o* ?  b) l
91.     u16 t;
    2 ~9 Y0 P! q. s
92.     u32 secCount=0;
    
93.     if(year<1970||year>2099)
    
94.         return 1;//³ö´í
    
95.     for(t=1970;t<year;t++)    //把所有年份的秒钟相加
    : X2 P- J0 k( L5 W& n3 ~# B
96.     {
    
97.         if(Is_Leap_Year(t))//闰年
    % O4 f* q. l- D$ f
98.             secCount+=31622400;//闰年的秒钟数
    
99.         else
    
100.             secCount+=31536000;   
     3 s+ A$ D  l9 C
101.     }
     - v7 ?* J* h9 _# R/ I1 C/ S, |
102.     mon-=1;//先减掉一个月再算秒数（如现在是5月10日，则只需要算前4个月的天数，再加上10天，然后计算秒数）
     
103.     for(t=0;t<mon;t++)
     
104.     {
     * _9 n- A: m7 ~5 P* E- B
105.         secCount+=(u32)mon_table[t]*86400;//月份秒钟数相加
     
106.         if(Is_Leap_Year(year)&&t==1)
     2 k+ [- c! ^2 A5 f# V( Y# C
107.             secCount+=86400;//闰年，2月份增加一天的秒钟数
     
108.     }
     0 |' S" U4 f8 W8 `) A; Z+ o& Y! q
109.    
     / q. {' M+ l; e' o+ S2 ]+ N# [
110.     secCount+=(u32)(day-1)*86400;//把前面日期的秒钟数相加（这一天还没过完，所以-1）
     
111.     secCount+=(u32)hour*3600;//小时秒钟数
     
112.     secCount+=(u32)min*60;//分钟秒钟数
     
113.     secCount+=sec;
     . x3 v; }* d/ l1 |3 L! ^
114. //    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR    | RCC_APB1Periph_BKP,ENABLE);
     5 f& j$ j; m4 G& F% q- O
115. //    PWR_BackupAccessCmd(ENABLE);
     9 s& x! q( W  M; W0 N- W* k
116.     RTC_SetCounter(secCount);//设置RTC计数器的值
     
117.     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
     
118.     RTC_Get();//更新时间
     7 Y! B  a" c/ m) q2 y
119.     return 0;
     
120. }
     
121. 
     
122. /*
     & h1 C( s1 n. x% K' e, H5 D
123. 得到当前的时间
     
124. 成功返回0，错误返回其它
     1 v# `5 b& l8 B% V' k" [
125. */
     
126. u8 RTC_Get(void)
     4 y& ^; C5 \3 n  I/ [9 }' J
127. {
     
128.         static u16 dayCount=0;
     3 i' u, T% l" ]2 `( h
129.         u32 secCount=0;
     
130.         u32 tmp=0;
     
131.         u16 tmp1=0;
     , G$ J: o4 z! Z! l6 X- U
132.         secCount=RTC_GetCounter();
     - f- Q5 k8 A% ^- c2 S: _
133.         tmp=secCount/86400;//得到天数
     
134.         if(dayCount!=tmp)//超过一天
     
135.         {
     
136.             dayCount=tmp;
     
137.             tmp1=1970;//从1970年开始
     
138.             while(tmp>=365)
     
139.             {
     7 t1 X( R) G3 j! O- L& t
140.                 if(Is_Leap_Year(tmp1))//是闰年
     1 y; o' L; i8 ~! q$ p3 h
141.                 {
     , o' _2 \! f/ G# g* N0 B
142.                     if(tmp>=366)   
     % m5 K2 |8 s$ n. _3 H+ ?
143.                         tmp-=366;//减掉闰年的天数
     
144.                     else
     ( U# a% ]) k# J; }7 E
145.                     {
     
146.                     //    tmp1++;
     
147.                         break;
     . B6 R9 o0 X+ B8 Z4 V
148.                     }
     $ C1 O6 T; m1 M0 U4 k2 I5 [, Y7 g
149.                 }
     
150.                 else
     
151.                     tmp-=365;//平年
     ) h  }  F. d5 v+ ?
152.                 tmp1++;
     0 u6 r! G( m# H( b, k2 z  e
153.             }
     
154.             calendar.w_year=tmp1;//得到年份
     
155.             tmp1=0;
     
156.             while(tmp>=28)//超过一个月
     
157.             {
     
158.                 if(Is_Leap_Year(calendar.w_year)&&tmp1==1)/当年是闰年且轮循到2月
     
159.                 {
     
160.                     if(tmp>=29)   
     ' T8 z  L) Z4 V8 V" y, [
161.                         tmp-=29;
     ; ?7 _6 t: A" p4 Q4 x* t8 ]
162.                     else
     
163.                         break;
     
164.                 }
     
165.                 else
     6 A6 X, {0 p- e7 p: r9 W4 L) B1 z
166.                 {
     
167.                     if(tmp>=mon_table[tmp1])//平年
     ) @& w% h" h6 b
168.                         tmp-=mon_table[tmp1];
     $ @) @6 \  E. s% c7 w
169.                     else
     / [; ?/ L4 p2 n; \. m3 m3 Q
170.                         break;
     
171.                 }
     3 y: r( o8 {- P: }
172.                 tmp1++;
     
173.             }
     ; B5 M5 U4 ^9 W0 p
174.             calendar.w_month=tmp1+1;//得到月份，tmp1=0表示1月，所以要加1
     6 r0 a! O( P$ r+ [$ R0 G( }
175.             calendar.w_date=tmp+1;    //得到日期，因为这一天还没过完，所以tmp只到其前一天，但是显示的时候要显示正常日期
     
176.         }
     ) y1 o2 c! u" Z$ L) A
177.         tmp=secCount%86400;//得到秒钟数
     + B# F9 m- B" c2 s
178.         calendar.hour=tmp/3600;//小时
     / \5 \/ N# e7 @5 U$ L. s
179.         calendar.min=(tmp%3600)/60;//分钟
     
180.         calendar.sec=(tmp%3600)%60;//秒
     6 q! R' Q6 f; J1 L- p- ]
181.         return 0;
     ( b# ~% T: E  }5 A, r
182. }
     
183. /*
     
184. RTC时钟中断
     
185. 每秒触发一次
     
186. */
     
187. void RTC_IRQHandler(void)
     ' o8 q' J, X8 A' ]: V2 M5 q8 w
188. {         
     / C( O) K: Y; o# Q
189.     if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断
     
190.     {                           
     
191.         RTC_Get();//更新时间
     
192.       
     
193.      }
     
194.     if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断
     
195.     {
     ! Z! X# U7 m/ U- U9 g
196.         RTC_ClearITPendingBit(RTC_IT_ALR);//清闹钟中断        
     
197.   }                                                   
     + j( M9 L9 E# C: ?9 m" K2 x* B
198.     RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);//清闹钟中断
     . [/ ~0 _2 e: X* {
199.     RTC_WaitForLastTask();                                                   
     
200. }

复制代码

　　main.c

1. #include "stm32f10x.h"
   # k# ~. V' R; d* ]3 R! u" `( c
2. #include "usart1.h"
   
3. #include "LED.h"
   
4. #include "delay.h"
   
5. #include "flash.h"
   6 f. s( }2 e" a5 x
6. #include "rtc.h"
   % m! u7 D  n6 G+ H- {0 X
7. #include "stdio.h"
   
8. int main(void)
   0 ]; n! S- c+ C; H; m' e
9. {
   
10.     u8 t=0;
    
11.     USART1_Config();
    5 b) l' U: Y6 _' U* q# ]2 ^1 H
12.     GPIO_Configuration();
    
13.     RTC_Init();
    2 Q$ x; l! Q2 o1 s5 f( f2 K; X1 M6 U
14.     while(1)
    * l3 t' H' M2 @% u. z% }
15.     {
    
16.         if(t!=calendar.sec)
    
17.         {
    
18.             t=calendar.sec;
    % V# I6 E1 e- c( N* L: Q" |
19.             printf("\r\n now is %d 年 %d 月 %d 日 %d 时 %d 分 %d 秒 \r\n ",
    0 W( ^) {' f" J, I
20. 　　　　　　　calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
    
21.         }
    
22.         Delay(0x02FFFF);
    
23.     }
    9 ?' ~0 n8 \0 K+ ]( G
24.    
    0 Y6 V) C6 S' I0 ^
25.    
    
26. }   

复制代码

$ C, G1 }- t, g% s" S4 J
, b7 Z0 X7 y* |# h5 ]- A