1、RTC时钟简介

　　STM32 的实时时钟（RTC）是一个独立的定时器，在相应软件配置下，可提供时钟日历的功能。 详细资料请参考ALIENTEK的官方文档——《STM32F1开发指南（精英版-库函数版）》，以下为博主摘录要点：

• RTC 模块和时钟配置系统(RCC_BDCR 寄存器)在后备区域 ，系统复位后，会自动禁止访问后备寄存器和 RTC ，所以在要设置时间之前， 先要取消备份区域（BKP）的写保护
  ! ^6 b7 l9 b  V6 j" Q& n7 U# d% m
• RTC 内核完全独立于 RTC APB1 接口，而软件是通过 APB1 接口访问 RTC 的预分频值、计数器值和闹钟值，因此需要等待时钟同步，寄存器同步标志位（RSF）会硬件置1
  
• RTC相关寄存器包括：控制寄存器（CRH、CRL）、预分频装载寄存器（PRLH、PRLL）、预分频器余数寄存器（DIVH、DIVL）、计数寄存器（CNTH、CNTL）、闹钟寄存器（ALRH、ALRL）
• STM32备份寄存器，存RTC校验值和一些重要参数，最大字节84，可由VBAT供电
• 计数器时钟频率：RTCCLK频率/(预分频装载寄存器值+1)
  2 k0 T0 U3 c3 W; R4 ~4 G2 }
    C3 k% ?2 z# M. h9 g1 w

2、软硬件设计

　　由于RTC是STM32芯片自带的时钟资源，所以自主开发的时候只需要在设计时加上晶振电路和纽扣电池即可。编程时在HARDWARE文件夹新建 rtc.c、rtc.h 文件。

+ G( v: F* P: d
8 F7 P3 N  J1 y3、时钟配置与函数编写

　　为了使用RTC时钟，需要进行配置和时间获取，基本上按照例程来写就可以了。为避免零散，我将附上完整代码。函数说明如下：

rtc.c中需要编写的函数列表

RTC_Init（void）	配置时钟
RTC_NVIC_Config（void）	中断分组
RTC_IRQHandler(void)	秒中断处理
RTC_Set（u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec）	设置时间
RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)	闹钟设置
RTC_Get(void)	获取时钟
RTC_Get_Week(u16 year,u8 month,u8 day)	星期计算
Is_Leap_Year(u16 year)	闰年判断

　事实上，以上函数并不都要，闹钟没有用到的话就不要，秒中断也可以不作处理，看项目需求。

1.   1 #include "sys.h"
   
2.   2 #include "delay.h"
   
3.   3 #include "rtc.h"            
   ( i( C  Z/ M8 H3 M2 I
4.   4        
   
5.   5 _calendar_obj calendar;//时钟结构体
   0 {3 r6 |6 }, Q
6.   6  
   
7.   7 static void RTC_NVIC_Config(void)
   
8.   8 {   
   
9.   9     NVIC_InitTypeDef NVIC_InitStructure;
   
10. 10     NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;        //RTC全局中断
    2 ^9 D3 A7 l- }- L+ n; o
11. 11     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;    //先占优先级1位,从优先级3位
    7 b7 u# h7 c- ?8 ^
12. 12     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;    //先占优先级0位,从优先级4位
    
13. 13     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;        //使能该通道中断
    / j- N3 M2 p4 X- S
14. 14     NVIC_Init(&NVIC_InitStructure);        //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
    . [8 x4 T4 a: ]+ T8 U
15. 15 }
    
16. 16
    
17. 17 //实时时钟配置
    & a/ l3 P! V! t+ r
18. 18 //初始化RTC时钟,同时检测时钟是否工作正常
    
19. 19 //BKP->DR1用于保存是否第一次配置的设置
    $ `+ K, \1 ~; d+ h6 w1 b$ `$ h5 B( G
20. 20 //返回0:正常
    
21. 21 //其他:错误代码
    
22. 22
    / }9 C6 Q+ ^# `! W
23. 23 u8 RTC_Init(void)
    
24. 24 {
    " z! C- u- U. R% K: F7 @8 P* I/ o
25. 25     //检查是不是第一次配置时钟
    % Q; D! a# u  u9 m& j
26. 26     u8 temp=0;
    
27. 27     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟   
    ; Q1 ~9 [  ~" `# m- F
28. 28     PWR_BackupAccessCmd(ENABLE);    //使能后备寄存器访问  
    
29. 29     if (BKP_ReadBackupRegister(BKP_DR1) != 0x5051)        //从指定的后备寄存器中读出数据:读出了与写入的指定数据不相乎
    
30. 30     {                  
    / P% h% ^2 N; h* i" y
31. 31         BKP_DeInit();    //复位备份区域     
    ! Q6 V* h1 `8 P3 h; D" p% l; `
32. 32         RCC_LSEConfig(RCC_LSE_ON);    //设置外部低速晶振(LSE),使用外设低速晶振
    & n9 v3 {; _) z* i! S% Z
33. 33         while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET&&temp<250)    //检查指定的RCC标志位设置与否,等待低速晶振就绪
    
34. 34         {
    9 y( i, O' u. j8 k+ H/ M
35. 35             temp++;
    
36. 36             delay_ms(10);
    8 `6 |  r7 r1 O" d% O7 O) O6 F
37. 37         }
    
38. 38         if(temp>=250)return 1;//初始化时钟失败,晶振有问题        
    & u5 A" n5 [4 D5 Z7 L2 Z$ n
39. 39         RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);        //设置RTC时钟(RTCCLK),选择LSE作为RTC时钟   
    
40. 40         RCC_RTCCLKCmd(ENABLE);    //使能RTC时钟  
    
41. 41         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
    
42. 42         RTC_WaitForSynchro();        //等待RTC寄存器同步  
    
43. 43         RTC_ITConfig(RTC_IT_SEC, ENABLE);        //使能RTC秒中断
    % r+ b: r/ v5 W
44. 44         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
    
45. 45         RTC_EnterConfigMode();/// 允许配置   
    
46. 46         RTC_SetPrescaler(32767); //设置RTC预分频的值
    ! K1 z0 T5 n  b
47. 47         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
    0 ^; A* S$ I8 ~# F, y
48. 48         RTC_Set(2018,4,2,17,37,00);  //设置时间   
    
49. 49         RTC_ExitConfigMode(); //退出配置模式  
    6 E9 }# i- b6 S6 h) H, Y
50. 50         BKP_WriteBackupRegister(BKP_DR1, 0X5051);    //向指定的后备寄存器中写入用户程序数据
    
51. 51     }
    ! {4 K! l  N* q/ ]6 O1 Q. t9 m
52. 52     else//系统继续计时
    
53. 53     {
    ! B0 J' L8 p( d# p7 j! a: c+ d& G* z
54. 54
    
55. 55         RTC_WaitForSynchro();    //等待最近一次对RTC寄存器的写操作完成
    
56. 56         RTC_ITConfig(RTC_IT_SEC, ENABLE);    //使能RTC秒中断
    
57. 57         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
    
58. 58     }
      z! T5 t3 z, E2 i/ t$ A
59. 59     RTC_NVIC_Config();//RCT中断分组设置                                 
    ; \( |, `% U1 U  n% B
60. 60     RTC_Get();//更新时间   
    
61. 61     return 0; //ok
    
62. 62
    1 K% z( G  B% f+ [3 @6 V7 q( [
63. 63 }                             
      P6 c% E- L1 a
64. 64 //RTC时钟中断
    
65. 65 //每秒触发一次  
    % U% {, l# r  O' F6 E* D3 ?8 M. `
66. 66 //extern u16 tcnt;
    
67. 67 void RTC_IRQHandler(void)
    
68. 68 {         
    
69. 69 //    if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断
    ( }+ D/ ?; e* b0 P
70. 70 //    {                           
    
71. 71 //        RTC_Get();//更新时间   
    
72. 72 //     }
    ) L) u+ n" m. Z5 N1 D3 ?! p1 K( v7 C. O
73. 73 //    if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断
    ! p/ g% x) x( ]" U' u3 y+ k  K
74. 74 //    {
    2 i" O. N' @3 E) @
75. 75 //        RTC_ClearITPendingBit(RTC_IT_ALR);        //清闹钟中断         
    , x, X+ P0 N- {" ~0 m( Y' a
76. 76 //      RTC_Get();                //更新时间   
    
77. 77 //      //printf("Alarm Time:%d-%d-%d %d:%d:%d\n",calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);//输出闹铃时间   
    
78. 78 //        
    0 a4 I6 z! a$ x$ A( N
79. 79 //      }                                                   
    
80. 80     RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);        //清闹钟中断
    ) t" z( h. |% f" w) ]' k8 ~
81. 81     RTC_WaitForLastTask();                                                   
    % u2 z6 {- a8 ]; v  I
82. 82 }
    
83. 83
    
84. 84
    
85. 85 //判断是否是闰年函数
    
86. 86 //月份   1  2  3  4  5  6  7  8  9  10 11 12
    + w: _- `$ x! l$ M% z1 C
87. 87 //闰年   31 29 31 30 31 30 31 31 30 31 30 31
    
88. 88 //非闰年 31 28 31 30 31 30 31 31 30 31 30 31
    
89. 89 //输入:年份
    % r5 Q* B. }; g- b4 ~
90. 90 //输出:该年份是不是闰年.1,是.0,不是
    
91. 91 u8 Is_Leap_Year(u16 year)
    
92. 92 {              
      _8 A) S* f6 {  x$ ~9 Q
93. 93     if(year%4==0) //必须能被4整除
    
94. 94     {
    2 B$ L9 Q/ k* |" c
95. 95         if(year%100==0)
    
96. 96         {
    8 b# M) v) _6 f
97. 97             if(year%400==0)return 1;//如果以00结尾,还要能被400整除        
    ; E2 k# o% I. S
98. 98             else return 0;   
    
99. 99         }else return 1;   
    . B; f% W8 |: d
100. 100     }else return 0;   
     
101. 101 }
     
102. 102
     4 c. B9 M" ~4 p9 z
103. 103
     
104. 104 //设置时钟
     , {5 s- F$ h: v; E/ O2 Q0 j# V
105. 105 //把输入的时钟转换为秒钟
     # d. T& L, q0 a! L/ h& G
106. 106 //以1970年1月1日为基准
     
107. 107 //1970~2099年为合法年份
     4 X) T2 P* _  ?& L: I' L
108. 108 //返回值:0,成功;其他:错误代码.
     & R, i' P, @! E4 q+ \0 c, t  ?" j2 T: o4 b
109. 109 //月份数据表                                             
     
110. 110 const u8  table_week[12]={0,3,3,6,1,4,6,2,5,0,3,5}; //月修正数据表      
     
111. 111 const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};//平年的月份日期表
     
112. 112
     " z7 S7 ^; ~6 S$ D
113. 113 u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
     , v& ^& t% L" x1 ?
114. 114 {
     
115. 115     u16 t;
     7 _: n1 h4 v  E
116. 116     u32 seccount=0;
     
117. 117     if(syear<1970||syear>2099)return 1;      
     
118. 118     for(t=1970;t<syear;t++)    //把所有年份的秒钟相加
     
119. 119     {
     ; E; H* F7 e" F4 j. z
120. 120         if(Is_Leap_Year(t))seccount+=31622400;//闰年的秒钟数
     
121. 121         else seccount+=31536000;              //平年的秒钟数
     
122. 122     }
     
123. 123     smon-=1;
     
124. 124     for(t=0;t<smon;t++)       //把前面月份的秒钟数相加
     2 S0 g0 I; w* L8 k, r# x( K. t
125. 125     {
     : u; y1 u& X1 e6 y4 U
126. 126         seccount+=(u32)mon_table[t]*86400;//月份秒钟数相加
     
127. 127         if(Is_Leap_Year(syear)&&t==1)seccount+=86400;//闰年2月份增加一天的秒钟数      
     7 c7 f9 @2 [6 n* q8 F4 o: R7 N
128. 128     }
     
129. 129     seccount+=(u32)(sday-1)*86400;//把前面日期的秒钟数相加
     7 T6 X2 ^3 W3 t1 z; \
130. 130     seccount+=(u32)hour*3600;//小时秒钟数
     
131. 131     seccount+=(u32)min*60;     //分钟秒钟数
     
132. 132     seccount+=sec;//最后的秒钟加上去
     : g& s% ~' G6 Y
133. 133
     
134. 134     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟  
     
135. 135     PWR_BackupAccessCmd(ENABLE);    //使能RTC和后备寄存器访问
     : W8 X" G+ e/ R5 o5 d
136. 136     RTC_SetCounter(seccount);    //设置RTC计数器的值
     
137. 137
     2 r5 u9 @' e: d9 L2 Q) a) }
138. 138     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成      
     
139. 139     return 0;        
     
140. 140 }
     
141. 141
     
142. 142 //初始化闹钟         
     
143. 143 //以1970年1月1日为基准
     ' I& n0 [3 W( a5 h
144. 144 //1970~2099年为合法年份
       f6 _, M! }( W6 }+ e1 e  g  a2 U
145. 145 //syear,smon,sday,hour,min,sec：闹钟的年月日时分秒   
     3 C6 a" C6 w- U  o/ x
146. 146 //返回值:0,成功;其他:错误代码.
     + ^! J# p7 m& l9 P" a" N! }
147. 147 u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
     
148. 148 {
     . }% v  m' S2 K: P3 L! F6 ]
149. 149     u16 t;
     
150. 150     u32 seccount=0;
       b% p  }; q/ K% z- `9 N2 T/ u
151. 151     if(syear<1970||syear>2099)return 1;      
     
152. 152     for(t=1970;t<syear;t++)    //把所有年份的秒钟相加
     9 Y3 I- E& o. c4 w+ H1 B- |
153. 153     {
     
154. 154         if(Is_Leap_Year(t))seccount+=31622400;//闰年的秒钟数
     
155. 155         else seccount+=31536000;              //平年的秒钟数
     
156. 156     }
     ! \/ b# D1 n  Y. ?1 u  o* E2 y
157. 157     smon-=1;
     1 D' T# c+ v. e, L3 _
158. 158     for(t=0;t<smon;t++)       //把前面月份的秒钟数相加
       U. y; r; m$ j
159. 159     {
     
160. 160         seccount+=(u32)mon_table[t]*86400;//月份秒钟数相加
     ' O, r* T- M! ]" Z  x, @& }
161. 161         if(Is_Leap_Year(syear)&&t==1)seccount+=86400;//闰年2月份增加一天的秒钟数      
     - j. Z3 \* i! @7 g  r5 T. P
162. 162     }
     
163. 163     seccount+=(u32)(sday-1)*86400;//把前面日期的秒钟数相加
     ; F3 u9 m( g0 H% I
164. 164     seccount+=(u32)hour*3600;//小时秒钟数
     2 T  J! b  f: \, e  T
165. 165     seccount+=(u32)min*60;     //分钟秒钟数
     
166. 166     seccount+=sec;//最后的秒钟加上去                 
     
167. 167     //设置时钟
     7 H  [' x/ T# ~
168. 168     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟   
     , ?4 E) |, J+ L3 p, W- z7 ~
169. 169     PWR_BackupAccessCmd(ENABLE);    //使能后备寄存器访问  
     
170. 170     //上面三步是必须的!
     
171. 171     
     
172. 172     RTC_SetAlarm(seccount);
     
173. 173  
     ' H: v6 W; l/ d4 R) c4 M! k
174. 174     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成      
     
175. 175     
     
176. 176     return 0;        
     # Y, k; @% ]7 e( _
177. 177 }
     4 L. @5 Q' d/ x# o" s% w* n
178. 178
     / V1 P9 a8 }4 j. E0 l/ t
179. 179
     
180. 180 //得到当前的时间
     % p, R% f( x/ a% h4 z6 P: J
181. 181 //返回值:0,成功;其他:错误代码.
     
182. 182 u8 RTC_Get(void)
     ; r0 _8 H$ ^9 l4 g
183. 183 {
     
184. 184     static u16 daycnt=0;
     
185. 185     u32 timecount=0;
     
186. 186     u32 temp=0;
     2 p- R9 L3 x; F: ~3 T
187. 187     u16 temp1=0;      
     & z) p7 u* U2 W. u* p
188. 188     timecount=RTC_GetCounter();     
     
189. 189      temp=timecount/86400;   //得到天数(秒钟数对应的)
     
190. 190     if(daycnt!=temp)//超过一天了
     
191. 191     {      
     
192. 192         daycnt=temp;
     & d8 L: s, s) T
193. 193         temp1=1970;    //从1970年开始
     
194. 194         while(temp>=365)
     
195. 195         {                 
     
196. 196             if(Is_Leap_Year(temp1))//是闰年
     
197. 197             {
     
198. 198                 if(temp>=366)temp-=366;//闰年的秒钟数
     ; T5 ?' {( C' H- W7 a
199. 199                 else {temp1++;break;}  
     
200. 200             }
     
201. 201             else temp-=365;      //平年
     
202. 202             temp1++;  
     
203. 203         }   
     
204. 204         calendar.w_year=temp1;//得到年份
     # `2 g! Q& ]3 I% f4 @3 I
205. 205         temp1=0;
     
206. 206         while(temp>=28)//超过了一个月
     
207. 207         {
     % H; V+ q$ J1 F
208. 208             if(Is_Leap_Year(calendar.w_year)&&temp1==1)//当年是不是闰年/2月份
     
209. 209             {
     * }7 y3 F# z- t8 O% Q) A2 Q
210. 210                 if(temp>=29)temp-=29;//闰年的秒钟数
     ( @, D1 y% ]8 M# A6 e
211. 211                 else break;
     : s. Z  F) M, S4 m9 Q$ ?9 [
212. 212             }
     2 a0 l& c7 ?) `, X$ R6 m
213. 213             else
     $ w5 i# W+ H/ u! Y
214. 214             {
     
215. 215                 if(temp>=mon_table[temp1])temp-=mon_table[temp1];//平年
     
216. 216                 else break;
     . v3 r& y# _( n5 x' e, w  ]
217. 217             }
     # F8 E, V1 |: T; Q. C( G- U5 X
218. 218             temp1++;  
     # H% J* t( s0 F, l" Z
219. 219         }
     ! g' u8 `% o) k# |
220. 220         calendar.w_month=temp1+1;    //得到月份
     / Z, e& o0 A* }) W% o7 n# W, o; k
221. 221         calendar.w_date=temp+1;      //得到日期
     7 R- e: ^) U( |
222. 222     }
     
223. 223     temp=timecount%86400;             //得到秒钟数         
       e3 M" l& A2 E4 _
224. 224     calendar.hour=temp/3600;         //小时
     
225. 225     calendar.min=(temp%3600)/60;     //分钟   
     
226. 226     calendar.sec=(temp%3600)%60;     //秒钟
     
227. 227     calendar.week=RTC_Get_Week(calendar.w_year,calendar.w_month,calendar.w_date);//获取星期
     5 H6 M5 R; q4 D- A0 n3 M  p
228. 228     calendar.msec=(32767-RTC_GetDivider())*    1000/32767;
     
229. 229     return 0;
     
230. 230 }   
     
231. 231
     
232. 232
     # e/ @' x) T- x* t+ z7 ?: p: ]5 R
233. 233 //获得现在是星期几
     ) S5 @4 c7 X' ?9 M
234. 234 //功能描述:输入公历日期得到星期(只允许1901-2099年)
     
235. 235 //输入参数：公历年月日
     9 m+ R  q. b' c* R5 Y
236. 236 //返回值：星期号                                                                                         
     
237. 237 u8 RTC_Get_Week(u16 year,u8 month,u8 day)
     4 U( J4 z9 d2 ~% L, @
238. 238 {   
     0 N% T. j% D# ~8 C1 L: h
239. 239     u16 temp2;
     1 h% Q0 J# A/ F, ^
240. 240     u8 yearH,yearL;
     ( ]! `$ r6 k+ K7 k: w) C
241. 241     
     
242. 242     yearH=year/100;    yearL=year%100;
     , Y% {1 J3 u+ a- D
243. 243     // 如果为21世纪,年份数加100  
     - Q* K' f, u# V' l
244. 244     if (yearH>19)yearL+=100;
     7 |+ T4 T3 ~2 q4 X; n9 U. a
245. 245     // 所过闰年数只算1900年之后的  
       z2 z2 Z# F0 R3 [8 R
246. 246     temp2=yearL+yearL/4;
     
247. 247     temp2=temp2%7;
     & c+ e+ ]+ i/ }9 y# Q
248. 248     temp2=temp2+day+table_week[month-1];
     
249. 249     if (yearL%4==0&&month<3)temp2--;
     ! K) ~7 R) E' Q# Y' J% m
250. 250     return(temp2%7);
       P7 R1 g5 {% E
251. 251 }   

复制代码

1. 1 #include "sys.h"
   ' b0 h/ R6 `- j# Z% m
2. 2
   
3. 3 //时间结构体
   
4. 4 typedef struct
   
5. 5 {
   
6. 6     vu8 hour;//vu8
   
7. 7     vu8 min;
   
8. 8     vu8 sec;
   
9. 9     vu16 msec;
   9 s/ g  T) d+ q& y7 c
10. 10     
    
11. 11     //公历日月年周
    
12. 12     vu16 w_year;
    & j% I5 F9 q2 l6 u
13. 13     vu8  w_month;
    ) F( C  l! b2 e) X' P7 C
14. 14     vu8  w_date;
    
15. 15     vu8  week;         
    
16. 16 }_calendar_obj;                     
    0 L# _- S" J+ y0 Z; G+ o# J9 `
17. 17
    ( _1 E" `$ `' ]; I0 C: e
18. 18 extern _calendar_obj calendar;    //日历结构体
    8 t7 {3 I6 Y1 v3 N" O
19. 19 extern u8 const mon_table[12];    //月份日期数据表
    , K' k0 ~5 t) g- R
20. 20
    8 |1 Z3 f/ ~2 y" S# }
21. 21 u8 RTC_Init(void);        //初始化RTC,返回0,失败;1,成功;
    
22. 22 u8 Is_Leap_Year(u16 year);//平年,闰年判断
    , O5 A8 T! d2 t) N7 w
23. 23
    
24. 24 //u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);
    
25. 25 u8 RTC_Get(void);         //更新时间   
    % e4 i7 c" B  ]3 I+ b( w; D: P, t4 y
26. 26 u8 RTC_Get_Week(u16 year,u8 month,u8 day);
    0 ~2 [8 s  Y# j$ ^' o
27. 27 u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);//设置时间   

复制代码

& v, v, m$ z+ x# ], h# R4、秒钟计时原理

使用外部32.768KHz的晶振作为时钟的输入频率，设置预分频装载寄存器的值为32767，根据计算公式，刚好可以得到1秒的计数频率。时间基准设置为1970年1月1日0时0分0秒，后续的时间都以这个为基准进行计算。RTC计数器是32位的，理论上可以记录136年左右的时间。（注意不必在秒中断里更新时间）

" H6 w: S$ K+ {5、毫秒计时原理

如果要获取到毫秒级的时钟怎么办？在我的项目中就有这样的要求。事实上，获取毫秒时钟也非常简单。

查阅开发指南，RTC预分频器余数寄存器（RTC_DIVH、RTC_DIVL），这两个寄存器的作用就是用来获得比秒钟更为准确的时钟。 该寄存器的值自减的，用于保存还需要多少时钟周期获得一个秒信号。在一次秒钟更新后，由硬件重新装载。这两个寄存器和 RTC 预分频装载寄存器位数是一样的。也就是说，如果预分频装载寄存器的值为32767，那么余数寄存器就会在每一次秒更新时由硬件重新装载为32767，然后向下计数，计数到0表示一秒，也即1000ms。

　　因此，我们在时钟结构体中添加msec成员

1. 1 //时间结构体
   
2. 2 typedef struct
   
3. 3 {
   5 T5 X9 W+ u9 ]' r4 j
4. 4     vu8 hour;//vu8
   1 y3 v, A- R; [$ @9 s/ h1 n
5. 5     vu8 min;
   
6. 6     vu8 sec;
   # n6 Q' ?' `$ K1 z- D) \
7. 7     vu16 msec;
   5 b* ~  j6 K; z9 D1 ^. U. u9 m+ W
8. 8     
   
9. 9     //公历日月年周
   3 G) d! K2 U5 q* N. t0 @- J
10. 10     vu16 w_year;
    
11. 11     vu8  w_month;
    - A/ [: \- u" Q6 z: r0 U
12. 12     vu8  w_date;
    9 ~5 x& ~$ `- K4 t# o* a) |& K
13. 13     vu8  week;         
    
14. 14 }_calendar_obj;  

复制代码

" l  I3 t' l! l' u7 [/ p, W0 @4 S

　获取毫秒时间

1. 1 calendar.msec=(32767-RTC_GetDivider())*1000/32767;

复制代码

4 N* l: M& C3 ]9 a! I3 p7 Q6、修改时间　　

  　如果RTC时钟在使用的过程中不准了（我遇到的情况大概是掉电跑了2个月，重新测试的时候差了2分钟左右），可以重新校准时钟。我们在备份区域 BKP_DR1 中写入 0X5051 ，下次开机（或复位）的时候，先读取 BKP_DR1 的值，然后判断是否是 0X5051来决定是不是要配置。 如果要修改时间，请将0x5051改为其它数据，修改RTC_Set函数实参，再重新烧写一下程序即可。

1. if (BKP_ReadBackupRegister(BKP_DR1) != 0x5051)
   
2. {
   
3.     ...
   ' [7 ?$ R+ ]2 l% t$ e. U
4.     RTC_EnterConfigMode();/// 允许配置   
   3 V2 c9 B, w0 W0 _
5.     RTC_SetPrescaler(32767); //设置RTC预分频的值
   
6.     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
   % T: @* ?8 Y, w# A8 _
7.     RTC_Set(2018,4,2,17,37,00);  //设置时间   
   , ~/ G; }# r+ O5 _) `
8.     RTC_ExitConfigMode(); //退出配置模式  
   
9.     BKP_WriteBackupRegister(BKP_DR1, 0X5051);    //向指定的后备寄存器中写入用户程序数据   
   
10. }

复制代码