一、关于时间

　　在计算机应用上，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年。
　　对于PC机来说，时间开始于1980年1月1日，并以无正负符号的32位整数的形式按秒递增，这与UNIX时间非常类似。可以算得：
7 R7 X- _  a6 d: q" Z: v+ X4 x                 2^32/3600/24/365 ≈ 136年
' A3 Q: i) h" s* }& z3 {4 S) n% I" f　　到2116年，这个整数将溢出。
+ L1 A- h& q+ E; {! A　　　　Windows NT使用64位整数来计时。但是，它使用100纳秒作为增量单位，且时间开始于1601年1月1日，所以NT将遇到2184年问题。
　　苹果公司声明，Mac在29,940年之前不会出现时间问题！
' w8 T2 S! [) Z- A8 B1 U3 Y- Y: |6 `
二、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，如下图：

　　

　　　我们需要将 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 周期。
  

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

1. /* 1.    查询 RTOFF 位，直到 RTOFF 的值变为’1’ */
   1 e( j5 P6 ]  e1 S" h, [5 t4 E
2. 
   
3. RTC_WaitForLastTask();//大家可以打开函数库看看这个函数内部的代码，就是查询 RTOFF的值
   
4. 
   
5. /*
   # l1 W/ {  f# e7 j2 y  R
6. 
   9 p' w, P0 Z/ m9 k) P
7. 2.置 CNF 值为 1 ，进入配置模式
   
8. 
   ' y' \1 \$ S5 s1 y& F! ]( T1 L
9. 3.对一个或多个 RTC 寄存器进行写操作
   $ p0 B- C% k' q0 ^8 i
10. 
    
11. 4.清除 CNF 标志位，退出配置模式
    
12. 
    
13. */
    $ A, H, g) Z& u2 i) M
14. 
    
15. RTC_SetPrescaler(32767); // 这里配置了预分频值，大家可以打开函数库看看这个函数的内部的代码，里面就有包含了 2、3、4 讲述的操作。
    1 N7 b+ b2 [' P7 W% u( e
16. 
    
17. /*
    % V7 f, [& R* s; k! R. c6 o
18. 每完成一个操作一般都要查询 RTOFF 来判断是否 RTC 正在更新数据,如果是则等待它完成!!!
    4 S  y+ h: @$ Z& q. t  P
19. */
      j, E* Y  R7 W& c) m' q: m
20. RTC_WaitForLastTask();//等待更新结束
    
21. 
    6 D7 ]1 w' k3 `  {4 h* ^7 r) R
22. RTC_ITConfig(RTC_IT_SEC, ENABLE);//配置秒中断
    4 C, c; S8 e/ G
23. 
    ; A: _# ]  \8 `. @" Z# {8 I
24. RTC_WaitForLastTask();//等待更新结束

复制代码

三、程序演示

　　rtc.h

1. #ifndef __RTC_H
   
2. #define __RTC_H
   
3. #include "stm32f10x.h"
   
4. 
   
5. //时间结构体
   
6. typedef struct
   + {  i) o! o1 H
7. {
   ; K# u; l5 ^2 T
8.     vu8 hour;
   
9.     vu8 min;
   
10.     vu8 sec;            
    9 u8 P: ~6 I0 f' K; d
11.     //公历年月日周
    
12.     vu16 w_year;
    6 b6 ~+ c! q% j/ x
13.     vu8  w_month;
    " G, F9 W( k- X% T8 z$ u0 j
14.     vu8  w_date;
    
15.     vu8  week;     
    
16. }_calendar_obj;                     
    - m  b: u% @: l" P! D4 Z  o4 I
17. extern _calendar_obj calendar;
    + E( `/ z: c' {% l
18. void RCC_Configuration(void);
    8 q: _3 O- u% N
19. void RTC_Init(void);
    
20. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec);
    0 K$ U6 w' Z5 Y' E2 f7 Q
21. u8 RTC_Get(void);
    : o) Y4 }7 e& E. b
22. #endif

复制代码

1 ?2 t1 C, U3 n- M4 [
0 S: o- |3 {- A6 e/ O

　　rtc.c

1. #include "rtc.h"
   
2. _calendar_obj calendar;    //时钟结构体
   1 Y+ i1 x- Z) q
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)
   5 D# `" r' N8 ]
7. {
   
8.     NVIC_InitTypeDef NVIC_InitStructure;
   % c+ `2 n3 e; \
9.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   ; P+ O2 H5 a6 ?
10.     NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
    4 [& ?. S5 I: G. K2 l
11.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
      o7 G( B  T$ s/ h$ T  ~, P- ~
12.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    7 z' H* F+ {* d# v4 a: Q3 I
13.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    ( u: r0 h/ g3 D% M; T& f
14.     NVIC_Init(&NVIC_InitStructure);
    ( q: ^7 }  [+ o' Y( G+ w
15. }
    9 g4 n6 L5 @. q9 l, y- p0 g8 _4 P
16. 
    3 D$ x# {) Z4 S
17. void RTC_Configuration(void)
    
18. 
    
19. {
    ( A* I; Z) q% _
20.     /* 使能PWR和BKP时钟 */
    6 I! T- [& l$ {6 j- b  F; a
21.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP,ENABLE);
    ) T8 R# Z8 {# o5 w- V
22.     /* 使能对后备寄存器的访问 */
    " x$ `3 E  U( Y9 T) y( R2 @
23.     PWR_BackupAccessCmd(ENABLE);
    
24.     /* 复位BKP寄存器 */
    
25.     BKP_DeInit();
    . s0 u+ |% m* J. s6 T
26.     /* 使能LSE */
    2 F: @4 k8 N' c) w3 C2 @/ P" O# G$ O
27.     RCC_LSEConfig(RCC_LSE_ON);
    
28.     /*等待启动完成 */
    + D% p" v7 X% X( f( Q
29.     while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {}
    
30.     /* 将 RTC时钟设置为LSE这个32.768KHZ的晶振*/
    ; y2 O- D- _4 q2 q) _4 {* S! h; H
31.     RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    0 J" k; [4 w* [( V
32.     /* 使能RTC Clock */
    
33.     RCC_RTCCLKCmd(ENABLE);
    
34.     /* 等待同步 */
    5 H; n/ |) K  M; o5 O( j
35.     RTC_WaitForSynchro();
    4 t; B% H  N8 E
36.     /* 等待对RTC寄存器最后的写操作完成*/            
    
37.     RTC_WaitForLastTask();
    
38.     /* 配置了预分频值: 设置RTC时钟周期为1s */
    
39.     RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1)*/
    - |# w5 T( X0 V" X* @1 y
40.     /* 等待对RTC寄存器最后的写操作完成 */
    
41.     RTC_WaitForLastTask();
    & e: A* s0 p% T, g* H
42.     /* 使能RTC秒中断 */
    0 J, [; @; n4 j+ R! k
43.     RTC_ITConfig(RTC_IT_SEC, ENABLE);
    6 z6 ]& P9 o# L6 k
44.     /* 等待对RTC寄存器最后的写操作完成 */         
    ) _& k+ I( _2 T. w' B5 G, d
45.     RTC_WaitForLastTask();
    
46. 
    9 B8 k5 k# F  J, X
47. void RTC_Init(void)
    2 X6 {' n5 w6 \. ^! z$ `
48. {
    
49.     /*如果是第一次配置时钟，则执行RCC_Configuration()进行配置*/
    
50.     if(BKP_ReadBackupRegister(BKP_DR1)!=0x1016)
    ; ~6 U% N1 M2 e7 U! O
51.     {
    ' b$ v3 b' m  k* `9 A% _
52.             RCC_Configuration();
    
53.             RTC_Set(2016,5,11,9,7,55);
    & b, j- ]- |+ @9 w" ~
54.             GPIO_SetBits(GPIOD, GPIO_Pin_13);//点亮D1
    ) u* T$ a& ~* i+ v( K
55.             BKP_WriteBackupRegister(BKP_DR1, 0x1016);//向执行的后备寄存器中写入用户程序数据
    
56.     }
    : L, c1 L4 E' y6 f+ I3 C& L
57.     else
    
58.     {
    
59.         RTC_WaitForSynchro();//等待RTC寄存器同步完成
    # v# `9 T8 u" q
60.         RTC_ITConfig(RTC_IT_SEC, ENABLE);//使能RTC秒中断
    
61.         RTC_WaitForLastTask();//等待最近一次对RTC寄存器的写操作完成
    
62.         GPIO_SetBits(GPIOG, GPIO_Pin_14);//点亮D2
    
63.     }
    ! P3 J: x) C  H3 k! t
64.     NVIC_Configuration();
    
65.     RTC_Get();//更新时间
    3 B& P- d# O7 W  i/ I" n
66. }
    ( J) d- F9 i, x! n) b
67. u8 Is_Leap_Year(u16 pyear)
    , J; t# Z, I- \" r" s2 D& W1 F9 `' J
68. {
    $ U2 Y) [/ a5 Y$ _$ S9 h6 T% P
69.     if(pyear%4==0)//首先需能被4整除
    
70.     {
    9 N6 |- [: Q- [/ r
71.         if(pyear%100==0)
    
72.         {
    1 f3 U3 n- h7 C. Z# S. ^+ ]
73.             if(pyear%400==0)    return 1;//如果以00结尾，还要能被400整除
    
74.             else    return 0;
    
75.         }
    ) Y* n+ o* l2 G- i8 B
76.         else
    , R7 x" ~( ]1 F: a
77.             return 1;
    
78.     }
    
79.     else
    
80.         return 0;
    
81. }
    
82. /*
    ) w: b6 p$ n& K& V; _3 J
83. *设置时钟
    
84. *把输入的时钟转换为秒钟
      L* ?8 I& r: h2 z! ?) @6 [
85. *以1970年1月1日为基准
    3 O3 Y  {. X( p& Z
86. *1970~2099年为合法年份
    ! i4 L& O/ J9 D& ?( s- O
87. 返回值：0，成功；其它：错误
    
88. */
    
89. u8 RTC_Set(u16 year,u8 mon,u8 day,u8 hour,u8 min,u8 sec)
    
90. {
    ' H+ A. V* b2 O8 I" S4 r& |$ W
91.     u16 t;
    ' l$ y; K) F+ c. k
92.     u32 secCount=0;
    ! R( c$ S/ U& k/ a0 m
93.     if(year<1970||year>2099)
    2 @/ d% T9 a8 O6 W6 X  ~* Q
94.         return 1;//³ö´í
    
95.     for(t=1970;t<year;t++)    //把所有年份的秒钟相加
    
96.     {
    $ F4 N' R! f) T; _. h" m9 M' `
97.         if(Is_Leap_Year(t))//闰年
    
98.             secCount+=31622400;//闰年的秒钟数
    
99.         else
    
100.             secCount+=31536000;   
     7 g" r. ?3 Y7 c4 B4 {
101.     }
     
102.     mon-=1;//先减掉一个月再算秒数（如现在是5月10日，则只需要算前4个月的天数，再加上10天，然后计算秒数）
     
103.     for(t=0;t<mon;t++)
     
104.     {
     * d3 y$ O9 _2 u' W* P4 L
105.         secCount+=(u32)mon_table[t]*86400;//月份秒钟数相加
     1 Y4 J" F! D/ O) L
106.         if(Is_Leap_Year(year)&&t==1)
     
107.             secCount+=86400;//闰年，2月份增加一天的秒钟数
     
108.     }
     
109.    
     3 n" @( i0 s: d. [& |0 ~  C: V2 d$ C
110.     secCount+=(u32)(day-1)*86400;//把前面日期的秒钟数相加（这一天还没过完，所以-1）
     
111.     secCount+=(u32)hour*3600;//小时秒钟数
     9 ~% p( W7 A& B* e9 Q9 ^
112.     secCount+=(u32)min*60;//分钟秒钟数
     
113.     secCount+=sec;
     : H) o1 B! d, X3 I
114. //    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR    | RCC_APB1Periph_BKP,ENABLE);
     # y' ?- n4 P0 e. P$ N1 @
115. //    PWR_BackupAccessCmd(ENABLE);
     
116.     RTC_SetCounter(secCount);//设置RTC计数器的值
     ! i( H/ d8 s! J% N8 ]
117.     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
     1 i0 G6 n$ D3 T0 n9 M0 |0 d3 N
118.     RTC_Get();//更新时间
     ( M2 Z; `- v/ L! Q
119.     return 0;
     ; u0 }# S$ T. J) k% s
120. }
     7 n) P: [6 z3 `$ m3 }; W
121. 
     ) {% y' ?" S: O5 E7 g
122. /*
     * n" ~- M4 j, n: A9 ^
123. 得到当前的时间
     * ^2 y* Y4 B' v1 `$ f5 Q
124. 成功返回0，错误返回其它
     
125. */
     
126. u8 RTC_Get(void)
     
127. {
       V- _, V1 s1 {3 O2 B
128.         static u16 dayCount=0;
     , z4 z  c8 C$ w2 w7 E
129.         u32 secCount=0;
     
130.         u32 tmp=0;
     
131.         u16 tmp1=0;
     
132.         secCount=RTC_GetCounter();
     
133.         tmp=secCount/86400;//得到天数
     
134.         if(dayCount!=tmp)//超过一天
     
135.         {
     2 w: u1 a( S" J( r
136.             dayCount=tmp;
     
137.             tmp1=1970;//从1970年开始
     
138.             while(tmp>=365)
     
139.             {
     % b' u! w" X* Z9 C
140.                 if(Is_Leap_Year(tmp1))//是闰年
     
141.                 {
     
142.                     if(tmp>=366)   
     ! k. A- Z% }) r6 O) u
143.                         tmp-=366;//减掉闰年的天数
     
144.                     else
     8 j/ Q" Q  U! I: z' X  x
145.                     {
     4 S% u& o1 J; t0 y! f: F1 w
146.                     //    tmp1++;
     2 }6 q1 J* u0 }$ b( a
147.                         break;
     $ p# f, g7 ]5 l) Y
148.                     }
     
149.                 }
     
150.                 else
     
151.                     tmp-=365;//平年
     1 T3 ^$ z- l/ W% O! Q$ v, K) L( S
152.                 tmp1++;
     ( j+ G- ~" h* Z) A/ T
153.             }
     
154.             calendar.w_year=tmp1;//得到年份
     
155.             tmp1=0;
     
156.             while(tmp>=28)//超过一个月
     
157.             {
     7 M9 _* c$ e6 s. _2 B0 h5 u2 r4 P  c2 t
158.                 if(Is_Leap_Year(calendar.w_year)&&tmp1==1)/当年是闰年且轮循到2月
     
159.                 {
     
160.                     if(tmp>=29)   
     2 [% Q  ~! c9 ~( f  s
161.                         tmp-=29;
     
162.                     else
     6 z) w  I1 O3 P
163.                         break;
     
164.                 }
     
165.                 else
     6 j+ a$ B. t# A4 ?5 h
166.                 {
     
167.                     if(tmp>=mon_table[tmp1])//平年
       p( D, L! K  P* ^- J4 h2 Z5 n& c
168.                         tmp-=mon_table[tmp1];
       ]; u: n- o! K1 m4 V! S) D# q
169.                     else
     : @1 }) H' `2 s, P, q1 U8 |2 s
170.                         break;
     
171.                 }
     
172.                 tmp1++;
     - ?( ?% N5 o6 H* M
173.             }
     3 p; ?3 j0 Z3 k  ^% b
174.             calendar.w_month=tmp1+1;//得到月份，tmp1=0表示1月，所以要加1
     
175.             calendar.w_date=tmp+1;    //得到日期，因为这一天还没过完，所以tmp只到其前一天，但是显示的时候要显示正常日期
     3 d, o7 ]8 @% h5 K! H
176.         }
     
177.         tmp=secCount%86400;//得到秒钟数
     
178.         calendar.hour=tmp/3600;//小时
     
179.         calendar.min=(tmp%3600)/60;//分钟
     - d; m& I: |8 k; o  t
180.         calendar.sec=(tmp%3600)%60;//秒
     1 }9 H* Q# J$ t! m! P
181.         return 0;
     
182. }
     
183. /*
     
184. RTC时钟中断
     $ {5 F; L  ]8 T7 I- {
185. 每秒触发一次
     9 T2 j2 Y: Q0 |
186. */
     1 ~+ x, ?- P% y+ V
187. void RTC_IRQHandler(void)
     " i3 p0 F3 @% u, g# ^; O
188. {         
     / Q& k4 m, T) Z% Y  w
189.     if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断
     
190.     {                           
     
191.         RTC_Get();//更新时间
     
192.       
     9 N1 |6 i; r8 p+ ]9 _) `
193.      }
     8 b0 U8 v( x% a. e' w: q1 e$ ?2 ]( F
194.     if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断
     
195.     {
     
196.         RTC_ClearITPendingBit(RTC_IT_ALR);//清闹钟中断        
     4 Q2 K1 y; O% n# I
197.   }                                                   
     
198.     RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);//清闹钟中断
     
199.     RTC_WaitForLastTask();                                                   
     
200. }

复制代码

% a/ p* N! j" r: |3 j
4 u# f( ~( k) x6 j% [

　　main.c

1. #include "stm32f10x.h"
   
2. #include "usart1.h"
   8 D/ h$ A) q. J0 C7 k6 E
3. #include "LED.h"
   ; t5 @, o9 [9 L" l
4. #include "delay.h"
   
5. #include "flash.h"
   5 Q/ \. i4 A4 j6 ]  F# r8 B
6. #include "rtc.h"
   # E) y# s. g2 X' a6 i
7. #include "stdio.h"
   
8. int main(void)
   ' Z* Z! m. \6 }/ N/ f& z7 L& }
9. {
   ' Q. f4 m6 ?% U
10.     u8 t=0;
    
11.     USART1_Config();
    
12.     GPIO_Configuration();
    , ]8 y: }9 x$ E( v, J: }
13.     RTC_Init();
    4 u" L8 L8 _: S* j
14.     while(1)
    
15.     {
    ; |, {, R' h4 N/ X- S: {! V( {
16.         if(t!=calendar.sec)
    
17.         {
      U- X: W; w- E: W) U0 W: r  a) r  i
18.             t=calendar.sec;
    ' ^0 z0 ?9 K+ S) V
19.             printf("\r\n now is %d 年 %d 月 %d 日 %d 时 %d 分 %d 秒 \r\n ",
    ' k0 Q7 @* b' I/ J- |
20. 　　　　　　　calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
    ( ^  e4 j' P, l( z. E3 o% @
21.         }
    . n# U4 H* B/ x' l
22.         Delay(0x02FFFF);
    
23.     }
    ) ^; E# t/ {$ X7 ?# W( @- k$ V
24.    
    
25.    
    8 B, j; E! e: g3 e! z
26. }   

复制代码

2 M6 l1 e4 B4 m) ~% i, ]6 f
4 a7 H6 p  o* o) C  _! [" P