一、RTC实时时钟特征与原理
$ `0 k" H. s) C( U( }查看STM32中文手册 16 实时时钟(RTC)（308页）


RTC (Real Time Clock)：实时时钟
/ m/ g) _( }# b8 b实时时钟是一个独立的定时器。RTC模块拥有一组连续计数的计数器，在相应软件配置下，可提供时钟日历的功能。修改计数器的值可以重新设置系统当前的时间和日期。
RTC模块和时钟配置系统(RCC_BDCR寄存器)处于后备区域，即在系统复位或从待机模式唤醒后， RTC的设置和时间维持不变。
) C& x) x; ^4 [( L+ Q$ j! M% B系统复位后，对后备寄存器和RTC的访问被禁止，这是为了防止对后备区域(BKP)的意外写操作。执行以下操作将使能对后备寄存器和RTC的访问：
5 S7 X' A% o  ?" J● 设置寄存器RCC_APB1ENR的PWREN和BKPEN位，使能电源和后备接口时钟
; o" Z( W% l- O' [" s● 设置寄存器PWR_CR的DBP位，使能对后备寄存器和RTC的访问。
& f! T2 d; Q- s- Z8 ^
: G2 ?2 ^. `( i: O
: a& ^8 D. U1 }, o& `9 yRTC特征
可编程的预分频系数：分频系数最高为220。
+ r3 d& }7 w/ {● 32位的可编程计数器，可用于较长时间段的测量。
● 2个分离的时钟：用于APB1接口的PCLK1和RTC时钟(RTC时钟的频率必须小于PCLK1时钟
频率的四分之一以上)。
● 可以选择以下三种RTC的时钟源：
1 w8 z, l0 \# d" T4 |# w! Z6 M— HSE时钟除以128；
% l  V3 a! m4 l% m+ _: }— LSE振荡器时钟；
" Z* i7 |! r! r/ ~; J4 ~— LSI振荡器时钟(详见6.2.8节RTC时钟)。
1 Z! ?. N3 G. s: ^9 W+ H2 N- E9 K● 2个独立的复位类型：
6 N- @, B( }* [9 S' @— APB1接口由系统复位；
— RTC核心(预分频器、闹钟、计数器和分频器)只能由后备域复位(详见6.1.3节)。
; s7 A; q+ K4 j' V$ ^● 3个专门的可屏蔽中断：
9 O  I, M' q% H' s/ j— 闹钟中断，用来产生一个软件可编程的闹钟中断。
9 [4 b$ S- j* j$ n" Y— 秒中断，用来产生一个可编程的周期性中断信号(最长可达1秒)。
+ T. G9 ]: G# J" ^) B— 溢出中断，指示内部可编程计数器溢出并回转为0的状态。


& ]+ h! O3 Y% q3 u二、RTC由两部分组成
**APB1接口：**用来和APB1总线相连。通过APB1接口可以访问RTC的相关寄存器（预分频值，计数器值，闹钟值）。
**RTC核心：**由一组可编程计数器组成。分两个主要模块。
第一个是RTC预分频模块，它可以编程产生最长1秒的RTC时间基TR_CLK。如果设置了秒中断允许位，可以产生秒中断。
) Z; u. ?$ H/ `% M+ e第二个是32位的可编程计数器，可被初始化为当前时间。系统时间按TR_CLK周期累加并与存储在RTC_ALR寄存器中的可编程时间相比，当匹配时候如果设置了闹钟中断允许位，可以产生闹钟中断。
2 w3 Y) [' e3 k2 U$ X3 R6 J
& Z4 Y' q; l: p9 A4 ]RTC内核完全独立于APB1接口，软件通过APB1接口对RTC相关寄存器访问。但是相关寄存器只在RTC APB1时钟进行重新同步的RTC时钟的上升沿被更新。所以软件必须先等待寄存器同步标志位（RTC_CRL的RSF位）被硬件置1才读。

' o8 u% E, }: W
三、RTC时钟源
首先讲一下时钟源：
6 p! W) i4 M: D0 y' m

三种不同的时钟源可被用来驱动系统时钟(SYSCLK)：
2 Z! q5 A( `4 i8 d' M6 I● HSI振荡器时钟
6 B* p0 V* v& H. v5 f● HSE振荡器时钟
● PLL时钟
( l: Y% \: p1 V6 `9 O这些设备有以下2种二级时钟源：
● 40kHz低速内部RC，可以用于驱动独立看门狗和通过程序选择驱动RTC。RTC用于从停机/待机模式下自动唤醒系统。
  {6 F" }) x3 i' m8 J8 ^) P1 }● 32.768kHz低速外部晶体也可用来通过程序选择驱动RTC(RTCCLK)。
6 H" E% l! t4 o. w8 v6 n+ k$ F

7 \! R0 l0 N2 ?; o2 L参看：STM32时钟系统


, L1 q6 q" q0 G0 F0 w/ g. @
当不被使用时，任一个时钟源都可被独立地启动或关闭，由此优化系统功耗。
用户可通过多个预分频器配置AHB、高速APB(APB2)和低速APB(APB1)域的频率。AHB和APB2域的最大频率是72MHz。APB1域的最大允许频率是36MHz。SDIO接口的时钟频率固定为HCLK/2。
9 @+ ^  X' ]! W7 uRCC通过AHB时钟(HCLK)8分频后作为Cortex系统定时器(SysTick)的外部时钟。通过对SysTick控制与状态寄存器的设置，可选择上述时钟或Cortex(HCLK)时钟作为SysTick时钟。ADC时钟由高速APB2时钟经2、 4、 6或8分频后获得。
% l$ U; p& P$ G, c4 ^7 {/ s( I6 ?定时器时钟频率分配由硬件按以下2种情况自动设置：

0 y# K* l/ m0 q8 j
  _6 I! J  A' y如果相应的APB预分频系数是1，定时器的时钟频率与所在APB总线频率一致。
否则，定时器的时钟频率被设为与其相连的APB总线频率的2倍。
( p( N0 i' c0 _6 e8 e如上图，有五个时钟源，为HSI、HSE、LSI、LSE、PLL。
, E6 N6 n) i) C+ F7 Z接下来我们一一看一下：
/ Y6 |+ [+ J, a2 _6 c+ U' i

/ z- S/ Y5 e  [& j1 lHSE时钟

**高速外部时钟信号(HSE)**由以下两种时钟源产生：
( K' \1 U1 ?) ^/ ]- p● HSE外部晶体/陶瓷谐振器
. W" X7 y; @+ m2 t4 s● HSE用户外部时钟
为了减少时钟输出的失真和缩短启动稳定时间，晶体/陶瓷谐振器和负载电容器必须尽可能地靠
% A2 B1 H' v' Y- f0 ^/ k近振荡器引脚。负载电容值必须根据所选择的振荡器来调整。
7 X' u6 ]+ a1 P, \8 I; S
外部时钟源(HSE旁路)
在这个模式里，必须提供外部时钟。它的频率最高可达25MHz。用户可通过设置在时钟控制寄存器中的HSEBYP和HSEON位来选择这一模式。外部时钟信号(50%占空比的方波、正弦波或三角波)必须连到SOC_IN引脚，同时保证OSC_OUT引脚悬空。见图9。
外部晶体/陶瓷谐振器(HSE晶体)
/ \% T2 ?# K+ D/ B; x# G9 h; K, ]**4~16Mz外部振荡器可为系统提供更为精确的主时钟。**相关的硬件配置可参考图9，进一步信息可参考数据手册的电气特性部分。
) v$ \2 G3 E  u2 K在时钟控制寄存器RCC_CR中的HSERDY位用来指示高速外部振荡器是否稳定。在启动时，直到这一位被硬件置’1’，时钟才被释放出来。如果在时钟中断寄存器RCC_CIR中允许产生中断，将会产生相应中断。
' U6 y5 U) |: i" ]HSE晶体可以通过设置时钟控制寄存器里RCC_CR中的HSEON位被启动和关闭。


$ J, Z! n& X9 M! b% EHSI时钟
1 \! Q2 L- Y6 e. Y+ v
' v  k3 \8 d$ R# y. A0 XHSI时钟信号由内部8MHz的RC振荡器产生，可直接作为系统时钟或在2分频后作为PLL输入。
HSI RC振荡器能够在不需要任何外部器件的条件下提供系统时钟。它的启动时间比HSE晶体振荡器短。然而，即使在校准之后它的时钟频率精度仍较差。
校准
2 Z) w: ^% C: E8 ]1 c/ W制造工艺决定了不同芯片的RC振荡器频率会不同，这就是为什么每个芯片的HSI时钟频率在出厂前已经被ST校准到1%(25°C)的原因。系统复位时，工厂校准值被装载到时钟控制寄存器的HSICAL[7:0]位。
如果用户的应用基于不同的电压或环境温度，这将会影响RC振荡器的精度。可以通过时钟控制寄存器里的HSITRIM[4:0]位来调整HSI频率。
- _, j0 m- j* F8 e3 V% X( J1 H时钟控制寄存器中的HSIRDY位用来指示HSI RC振荡器是否稳定。在时钟启动过程中，直到这一位被硬件置’1’， HSI RC输出时钟才被释放。HSI RC可由时钟控制寄存器中的HSION位来启动和关闭。
如果HSE晶体振荡器失效， HSI时钟会被作为备用时钟源。
( z8 G! D( k" |' [
" J8 S5 f& z6 m& O# i8 i) ?
PLL



内部PLL可以用来倍频HSI RC的输出时钟或HSE晶体输出时钟。
PLL的设置(选择HIS振荡器除2或HSE振荡器为PLL的输入时钟，和选择倍频因子)必须在其被激活前完成。一旦PLL被激活，这些参数就不能被改动。
+ @6 `2 v% V# o# h; X' \6 g如果PLL中断在时钟中断寄存器里被允许，当PLL准备就绪时，可产生中断申请。
  _7 h& n+ |' T8 B( s% K8 k* p) V如果需要在应用中使用USB接口， PLL必须被设置为输出48或72MHZ时钟，用于提供48MHz的USBCLK时钟。
4 p2 X# e) R8 C" n% ~
' q6 X9 H. Q3 s& j. T+ G
LSE时钟

8 O4 P: i% H" l4 O: S: h# Z

( F1 P8 `1 C1 n( a1 @2 _**LSE晶体是一个32.768kHz的低速外部晶体或陶瓷谐振器。**它为实时时钟或者其他定时功能提供一个低功耗且精确的时钟源。
- Z; d' y! }/ n! {( q8 ?LSE晶体通过在备份域控制寄存器(RCC_BDCR)里的LSEON位启动和关闭。
+ o) w' h) X4 J' I5 K在备份域控制寄存器(RCC_BDCR)里的LSERDY指示LSE晶体振荡是否稳定。在启动阶段，直到这个位被硬件置’1’后， LSE时钟信号才被释放出来。如果在时钟中断寄存器里被允许，可产生中断申请。
外部时钟源(LSE旁路)
在这个模式里必须提供一个32.768kHz频率的外部时钟源。你可以通过设置在备份域控制寄存器(RCC_BDCR)里的LSEBYP和LSEON位来选择这个模式。具有50%占空比的外部时钟信号(方波、正弦波或三角波)必须连到OSC32_IN引脚，同时保证OSC32_OUT引脚悬空，见图9。
  i; }) e% L" H) o% T  R
  J) W+ M; _. U! M& e& ^9 L/ A4 d
5 v3 r, ^, `, H3 f8 j# J% w) h* m$ ZLSI时钟


7 }. g6 q8 y9 i5 Y& k9 u( H
$ w8 t: ~" S" T8 B; l. G; u1 bLSI RC担当一个低功耗时钟源的角色，它可以在停机和待机模式下保持运行，为独立看门狗和自动唤醒单元提供时钟。**LSI时钟频率大约40kHz(在30kHz和60kHz之间)。**进一步信息请参考数据手册中有关电气特性部分。
LSI RC可以通过控制/状态寄存器(RCC_CSR)里的LSION位来启动或关闭。
在控制/状态寄存器(RCC_CSR)里的LSIRDY位指示低速内部振荡器是否稳定。在启动阶段，直到这个位被硬件设置为’1’后，此时钟才被释放。如果在时钟中断寄存器(RCC_CIR)里被允许，将产生LSI中断申请。
注意：只有大容量和互联型产品可以进行LSI校准
LSI校准
可以通过校准内部低速振荡器LSI来补偿其频率偏移，从而获得精度可接受的RTC时间基数，以及独立看门狗(IWDG)的超时时间(当这些外设以LSI为时钟源)。
**校准可以通过使用TIM5的输入时钟(TIM5_CLK)测量LSI时钟频率实现。**测量以HSE的精度为保证，软件可以通过调整RTC的20位预分频器来获得精确的RTC时钟基数，以及通过计算得到精确的独立看门狗(IWDG)的超时时间。
LSI校准步骤如下：
" @  Z5 L/ z. N3 m3 s4 Y$ L
$ f1 h& W' y) h8 T7 w; @
2 k3 ?3 J' n' c" \; e) o打开TIM5，设置通道4为输入捕获模式；
, }" ~: h& s9 x( `. o设置AFIO_MAPR的TIM5_CH4_IREMAP位为’1’，在内部把LSI连接到TIM5的通道4；
2 x  z" v& q( R. Q. e8 U通过TIM5的捕获/比较4事件或者中断来测量LSI时钟频率；
  \! M7 N$ ?# s: k根据测量结果和期望的RTC时间基数和独立看门狗的超时时间，设置20位预分频器。
四、RTC时钟
: ^0 n* q8 I" t7 F6 W, a2 e0 l% D**通 过 设 置 备 份 域 控 制 寄 存 器 (RCC_BDCR) 里 的 RTCSEL[1:0] 位 ， RTCCLK 时钟源可以由HSE/128、LSE或LSI时钟提供。**除非备份域复位，此选择不能被改变。
LSE时钟在备份域里，但HSE和LSI时钟不是。因此：
● 如果LSE被选为RTC时钟：
2 \2 y1 o) j+ u. w/ Q( O3 X— 只要VBAT维持供电，尽管VDD供电被切断， RTC仍继续工作。
/ @) K$ F, l6 b● 如果LSI被选为自动唤醒单元(AWU)时钟：
— 如果VDD供电被切断， AWU状态不能被保证。有关LSI校准，详见6.2.5节LSI时钟。
( }7 n/ t7 ]9 L; I. j● 如果HSE时钟128分频后作为RTC时钟：
+ u4 q" ?$ V, ~/ Q+ C8 M' r1 |# Z— 如果VDD供电被切断或内部电压调压器被关闭(1.8V域的供电被切断)，则RTC状态不确定。
— 必须设置电源控制寄存器(见4.4.1节)的DPB位(取消后备区域的写保护)为’1’。


* L+ x" k1 e0 L: g: V+ ^五、RTC寄存器
上面都是从STM32中文手册里摘取的。大概了解一下RTC和时钟。
不过讲的有点扯，里面有多好寄存器，不知道是干啥的。接下来重点看一下这些寄存器。
. }' Z$ Y% X3 _( M. l) }
9 {7 v2 `, ]" ~1 y) g
RTC控制寄存器高位（RTC_CRH)
* y( I/ p5 n3 b! s  U3 s
RTC控制寄存器低位(RTC_CRL)

+ a+ _6 Q* J9 u  N  u- H
: m1 v# I+ }" O# B
; r1 U3 W: X' h8 Q* `: u①修改CRH/CRL寄存器，必须先判断RSF位，确定已经同步。
②修改CNT,ALR,PRL的时候，必须先配置CNF位进入配置模式，修改完之后，设置CNF位为0退出配置模式
③同时在对RTC相关寄存器写操作之前，必须判断上一次写操作已经结束，也就是判断RTOFF位是否置位。


RTC预分频装载寄存器(RTC_PRLH/RTC_PRLL)
" V# Y6 d0 c3 V2 O8 x/ L& N$ a预分频装载寄存器用来保存RTC预分频器的周期计数值。它们受RTC_CR寄存器的RTOFF位保护，仅当RTOFF值为’1’时允许进行写操作。
' X& @& b2 P* [4 p
RTC预分频器余数寄存器(RTC_DIVH / RTC_DIVL)
7 R& S5 b5 ~4 L4 x* z$ D
/ t& r+ E7 |" X: d9 i( YRTC计数器寄存器 (RTC_CNTH / RTC_CNTL)
7 A- w9 t; ~  |3 w9 a
/ P: ?8 X" M3 \9 IRTC闹钟寄存器(RTC_ALRH/RTC_ALRL)

配置RTC寄存器
; `2 @+ u; ]8 g$ I. [+ s: U必须设置RTC_CRL 寄 存 器 中 的CNF位 ， 使RTC进入配置模式后 ， 才能写 入RTC_PRL、RTC_CNT、 RTC_ALR寄存器。
另外，对RTC任何寄存器的写操作，都必须在前一次写操作结束后进行。可以通过查询RTC_CR寄存器中的RTOFF状态位，判断RTC寄存器是否处于更新中。仅当RTOFF状态位是’1’时，才可以写入RTC寄存器。
配置过程：
5 l) _) z1 o) y- y" w5 B4 X8 b

查询RTOFF位，直到RTOFF的值变为’1’
+ n0 e6 y2 s: A9 i$ k! N  @; p置CNF值为1，进入配置模式
对一个或多个RTC寄存器进行写操作
8 U4 M$ F. H9 S- R2 v清除CNF标志位，退出配置模式
4 A! \4 s9 M1 T" ]查询RTOFF，直至RTOFF位变为’1’以确认写操作已经完成。
6 n9 o7 O. i: Y6 J( i" z仅当CNF标志位被清除时，写操作才能进行，这个过程至少需要3个RTCCLK周期。
读RTC寄存器
RTC核完全独立于RTC APB1接口。
$ j* T3 p5 R. o8 K软件通过APB1接口访问RTC的预分频值、 计数器值和闹钟值。但是，相关的可读寄存器只在与RTC APB1时钟进行重新同步的RTC时钟的上升沿被更新。RTC标志也是如此的。
" h! p9 k  e- j: R4 c1 s; y: E6 l这意味着，如果APB1接口曾经被关闭，而读操作又是在刚刚重新开启APB1之后，则在第一次的内部寄存器更新之前，从APB1上读出的RTC寄存器数值可能被破坏了(通常读到0)。下述几种
$ @! }' }9 U! o1 j情况下能够发生这种情形：
8 P- Q8 J$ A7 g) @- p● 发生系统复位或电源复位
, d8 Z( W+ l  G( Q8 ?2 S● 系统刚从待机模式唤醒(参见第4.3节：低功耗模式)。
, d0 R6 M, R) o8 f5 f! F. G% d9 s" a, O● 系统刚从停机模式唤醒(参见第4.3节：低功耗模式)。
1 F) V3 L( E' T8 h- U$ _% S所有以上情况中， APB1接口被禁止时(复位、无时钟或断电)RTC核仍保持运行状态。
因此，若在读取RTC寄存器时， RTC的APB1接口曾经处于禁止状态，则软件首先必须等待RTC_CRL寄存器中的RSF位(寄存器同步标志)被硬件置’1’。
) b6 t' i2 a" {; n5 w注：RTC的 APB1接口不受WFI和WFE等低功耗模式的影响


六、RTC相关库函数讲解
3 ~3 Y' ]2 Z( d. c/ E8 T库函数所在文件：stm32f10x_rtc.c / stm32f10x_rtc.h

, Y. g+ k( ]% j0 E, V' R: J% }
RTC时钟源和时钟操作函数：
* e& m- r8 B' n; A/ x

1. void RCC_RTCCLKConfig(uint32_t  CLKSource)；//时钟源选择
   
2. void RCC_RTCCLKCmd(FunctionalState NewState)//时钟使能

复制代码

RTC配置函数（预分频，计数值：
& f1 ?- V, \7 I; {# M* S# p8 ~

1. void RTC_SetPrescaler(uint32_t PrescalerValue);//预分频配置：PRLH/PRLL
   
2. void RTC_SetCounter(uint32_t CounterValue)；//设置计数器值：CNTH/CNTL
   
3. void RTC_SetAlarm(uint32_t AlarmValue)；//闹钟设置：ALRH/ALRL

复制代码

RTC中断设置函数：
9 b& |# L* X! g1 ^' j) ?$ \

1. void RTC_ITConfig(uint16_t RTC_IT, FunctionalState NewState);//CRH

复制代码

RTC允许配置和退出配置函数：
9 H6 @* C2 C6 i. X6 o

1. void RTC_ITConfig(uint16_t RTC_IT, FunctionalState NewState);//CRH

复制代码

同步函数：
6 R0 v: F* G  b

1. void RTC_WaitForLastTask(void)；//等待上次操作完成：CRL位RTOFF
   * J& h- P% R% {' w5 m- V
2. void RTC_WaitForSynchro(void)；//等待时钟同步：CRL位RSF

复制代码

相关状态位获取清除函数：

1. FlagStatus RTC_GetFlagStatus(uint16_t RTC_FLAG);
   
2. void RTC_ClearFlag(uint16_t RTC_FLAG);
   
3. ITStatus RTC_GetITStatus(uint16_t RTC_IT);
   
4. void RTC_ClearITPendingBit(uint16_t RTC_IT);

复制代码

其他相关函数（BKP等）
9 J7 u. q+ R# n1 i( a

1. PWR_BackupAccessCmd();//BKP后备区域访问使能
   
2. RCC_APB1PeriphClockCmd();//使能PWR和BKP时钟
   : m6 C* M' t/ |4 C
3. RCC_LSEConfig();//开启LSE，RTC选择LSE作为时钟源
   
4. PWR_BackupAccessCmd();//BKP后备区域访问使能
   6 u, ^3 @6 j' C7 L( m
5. uint16_t BKP_ReadBackupRegister(uint16_t BKP_DR);//读BKP寄存器
   ! G6 e$ I3 N- R
6. void BKP_WriteBackupRegister(uint16_t BKP_DR, uint16_t

复制代码

七、RTC配置一般步骤
6 X# O, A( T1 C- D/ G+ R1） 使能电源时钟和备份区域时钟。
前面已经介绍了，我们要访问 RTC 和备份区域就必须先使能电源时钟和备份区域时钟。

1. RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);

复制代码

2） 取消备份区写保护。
+ d8 H! l" ~1 F) J要向备份区域写入数据，就要先取消备份区域写保护（写保护在每次硬复位之后被使能），否则是无法向备份区域写入数据的。我们需要用到向备份区域写入一个字节，来标记时钟已经配置过了，这样避免每次复位之后重新配置时钟。取消备份区域写保护的库函数实现方法是：
  Z0 N" r6 ~: I' ^  q

1. PWR_BackupAccessCmd(ENABLE); //使能 RTC 和后备寄存器访问

复制代码

3） 复位备份区域，开启外部低速振荡器。
在取消备份区域写保护之后，我们可以先对这个区域复位，以清除前面的设置，当然这个操作不要每次都执行，因为备份区域的复位将导致之前存在的数据丢失，所以要不要复位，要看情况而定。然后我们使能外部低速振荡器，注意这里一般要先判断 RCC_BDCR 的 LSERDY位来确定低速振荡器已经就绪了才开始下面的操作。
" V# @) X, F# f- t% R2 }( V备份区域复位的函数是：

1. BKP_DeInit();//复位备份区域

复制代码

开启外部低速振荡器的函数是：

1. RCC_LSEConfig(RCC_LSE_ON);// 开启外部低速振荡器

复制代码

4） 选择 RTC 时钟，并使能。
5 {. l# y4 a" z0 d; Z这里我们将通过 RCC_BDCR 的 RTCSEL 来选择选择外部 LSI 作为 RTC 的时钟。然后通过RTCEN 位使能 RTC 时钟。库函数中，选择 RTC 时钟的函数是：
0 B* Z4 [8 u$ Z

1. RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE); //选择 LSE 作为 RTC 时钟

复制代码

对于 RTC 时钟的选择，还有 RCC_RTCCLKSource_LSI 和RCC_RTCCLKSource_HSE_Div128 这两个，顾名思义，前者为 LSI，后者为 HSE 的 128 分频，这在时钟系统章节有讲解过。
# B4 f9 {7 B5 M0 k使能 RTC 时钟的函数是：
% f, {. c$ L7 s  L. H

1. RCC_RTCCLKCmd(ENABLE); //使能 RTC 时钟

复制代码

5） 设置 RTC 的分频，以及配置 RTC 时钟。
' o7 Y4 M* v4 X- e' @- d, @5 O在开启了 RTC 时钟之后，我们要做的就是设置 RTC 时钟的分频数，通过 RTC_PRLH 和RTC_PRLL 来设置，然后等待 RTC 寄存器操作完成，并同步之后，设置秒钟中断。然后设置RTC 的允许配置位（RTC_CRH 的 CNF 位），设置时间（其实就是设置 RTC_CNTH 和 RTC_CNTL两个寄存器）。下面我们一一这些步骤用到的库函数：在进行 RTC 配置之前首先要打开允许配置位(CNF)，库函数是：
) A: B; F2 }* e" o4 n/ p* d/ A

1. RTC_EnterConfigMode();/// 允许配置

复制代码

在配置完成之后，千万别忘记更新配置同时退出配置模式，函数是：
7 p" M% n2 f, D/ R9 e0 V  ?# Z

1. RTC_ExitConfigMode();//退出配置模式， 更新配置

复制代码

设置 RTC 时钟分频数， 库函数是：

1. void RTC_SetPrescaler(uint32_t PrescalerValue);

复制代码

这个函数只有一个入口参数，就是 RTC 时钟的分频数，很好理解。
然后是设置秒中断允许， RTC 使能中断的函数是：

1. void RTC_ITConfig(uint16_t RTC_IT, FunctionalState NewState)；

复制代码

这个函数的第一个参数是设置秒中断类型，这些通过宏定义定义的。对于使能秒中断方法是：
4 ?  x% y! F& Y3 \

1. RTC_ITConfig(RTC_IT_SEC, ENABLE); //使能 RTC 秒中断

复制代码

八、RTC程序
这篇文章复制粘贴了这么多，感觉不到一丝有用的东西。算了，还是看一下，程序是怎么写的吧。
1 b& l' @$ r( m) i

4 ^) G3 @3 r) F2 Q& IRTC_Init

1. //实时时钟配置
   
2. 
   
3. //初始化 RTC 时钟,同时检测时钟是否工作正常
   
4. 
   
5. //BKP->DR1 用于保存是否第一次配置的设置
   
6. 
   ( o9 y1 D- W8 S) V4 x6 [; F+ ]
7. //返回 0:正常
   
8. 
   
9. //其他:错误代码
   % W% ?9 j5 \' y
10. 
    : _. |1 y( L7 K  Q7 n5 g7 E" t
11. u8 RTC_Init(void)
    ! R7 N! i$ G' w7 `! k
12. 
    
13. {
    
14. 
    4 D1 E; h) n# K4 H, x8 t
15. u8 temp=0;
    
16. 
    
17. //检查是不是第一次配置时钟
    
18. 
    
19. RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR |
    # n2 M$ {: k# C% E1 T: A" V
20. 
    
21. RCC_APB1Periph_BKP, ENABLE); //①使能 PWR 和 BKP 外设时钟
    & S" |: }. z- \4 G
22. 
    
23. PWR_BackupAccessCmd(ENABLE); //②使能后备寄存器访问
    
24. 
    " E4 Q: e: u  }3 H
25. if (BKP_ReadBackupRegister(BKP_DR1) != 0x5050) //从指定的后备寄存器中
    
26. 
    
27. //读出数据:读出了与写入的指定数据不相乎
    * w' _3 Y' w; i/ ]! F' z, i6 {
28. 
    
29. {
    
30. 
    
31. BKP_DeInit(); //③复位备份区域
    4 W5 `# f2 N+ M0 w! Y
32. 
    " ^# [; @) k8 \% n
33. RCC_LSEConfig(RCC_LSE_ON); //设置外部低速晶振(LSE)
    + Q; J1 b) U: E. @+ m- A
34. 
    
35. while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET&&temp<250)
    ) h; B3 E2 H) }8 b( y# L' C+ y
36. 
    
37. //检查指定的 RCC 标志位设置与否,等待低速晶振就绪
    
38. 
    
39. {
    
40. 
    8 @" i3 z  f- u( C3 {/ x
41. temp++;
    
42. 
    
43. delay_ms(10);
      P4 v( N0 c0 B$ N0 k3 c1 A3 }
44. 
    * m* J. @$ y3 N  x1 N1 u
45. }
    / J8 T: P0 v5 K# ^# ]% M6 a. D
46. 
    * V9 @6 m3 D) S/ H
47. if(temp>=250)return 1;//初始化时钟失败,晶振有问题
    
48. 
    8 L1 q! @" B: N$ x) L
49. RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE); //设置 RTC 时钟
    
50. 
    
51. //(RTCCLK),选择 LSE 作为 RTC 时钟
    
52. 
    2 I0 S8 V! H3 D+ d: q
53. RCC_RTCCLKCmd(ENABLE); //使能 RTC 时钟
    8 Q/ c9 ^: W3 B' \
54. 
    8 L! L+ F( c- b/ Z1 R2 V* W
55. RTC_WaitForLastTask(); //等待最近一次对 RTC 寄存器的写操作完成
    / K) n# f% ]$ \# [
56. 
    
57. RTC_WaitForSynchro(); //等待 RTC 寄存器同步
    / }- C- @: i7 x3 F+ }% h
58. 
    
59. RTC_ITConfig(RTC_IT_SEC, ENABLE); //使能 RTC 秒中断
    $ Y( {8 n) ~. ~- ~1 U# W0 K8 g
60. 
    % h3 y! m# R* t& B% J
61. RTC_WaitForLastTask(); //等待最近一次对 RTC 寄存器的写操作完成
    
62. 
    
63. RTC_EnterConfigMode(); // 允许配置
    
64. 
    / N9 ]6 l6 ^9 b, B6 S& K  c" r6 M
65. RTC_SetPrescaler(32767); //设置 RTC 预分频的值
    - ^- M1 q! Z* _' n$ ~
66. 
    , S5 [, g3 A  _/ q* q5 D
67. RTC_WaitForLastTask(); //等待最近一次对 RTC 寄存器的写操作完成
    ( E; Q& T4 s5 m6 ^* V7 q6 k
68. 
    
69. RTC_Set(2015,1,14,17,42,55); //设置时间
    
70. 
    " [# _* B; C7 `' W) U. t+ V- z9 X
71. RTC_ExitConfigMode(); //退出配置模式
    
72. 
    
73. BKP_WriteBackupRegister(BKP_DR1, 0X5050); //向指定的后备寄存器中
    
74. 
    
75. //写入用户程序数据 0x5050
    ; X1 K4 U& \9 X0 G1 K6 R
76. 
    8 K. g* m, \9 G3 F  O& z
77. }
    
78. 
    
79. else//系统继续计时
    
80. 
    
81. {
    
82. 
    
83. RTC_WaitForSynchro(); //等待最近一次对 RTC 寄存器的写操作完成
    / ]7 [$ b# |4 D6 L2 c0 X( g- X& W
84. 
    
85. RTC_ITConfig(RTC_IT_SEC, ENABLE); //使能 RTC 秒中断
    
86. 
    : y9 t3 B+ e. k( F' l& k6 ^
87. RTC_WaitForLastTask(); //等待最近一次对 RTC 寄存器的写操作完成
    
88. 
    
89. }
    
90. 
    
91. RTC_NVIC_Config(); //RCT 中断分组设置
    + D( m( G6 }2 C* M/ O
92. 
    
93. RTC_Get(); //更新时间
    
94. 
    
95. return 0; //ok
    1 Y, v9 ?* A  X! b. F. X. i  _
96. 
    7 ^$ T4 V- y. y0 u% H! O0 ?/ u" V
97. }

复制代码

RTC_Set

1. //设置时钟
   2 x1 H8 |, a1 G" [3 k
2. 
   
3. //把输入的时钟转换为秒钟
   # W2 l! A7 A) ^, G
4. 
   
5. //以 1970 年 1 月 1 日为基准
   
6. 
   
7. //1970~2099 年为合法年份
   
8. 
   
9. //返回值:0,成功;其他:错误代码.
   ! [, k' a9 H7 x+ [! A( }
10. 
    ' Y# K( l( |3 ~- C' ]
11. //月份数据表
    
12. 
    
13. u8 const table_week[12]={0,3,3,6,1,4,6,2,5,0,3,5}; //月修正数据表
    
14. 
    
15. //平年的月份日期表
    4 a9 @& o6 G* G! [
16. 
    
17. const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
    
18. 
    
19. u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
    
20. 
    1 y4 e' \6 V, a* A/ n1 [8 K
21. {
    " f( K4 K) \; Z  b: u% D5 q% _
22. 
    
23. u16 t;
    ( U- O2 h! v* _8 n; q8 |
24. 
    $ B1 c4 r$ S6 ?% U2 V: G& S
25. u32 seccount=0;
    - x# d/ _6 B* q; l/ u/ p7 ^9 Q
26. 
    
27. if(syear<1970||syear>2099)return 1;
    
28. 
    7 d8 n# V+ n9 p& I4 H
29. for(t=1970;t<syear;t++) //把所有年份的秒钟相加
    
30. 
    
31. { if(Is_Leap_Year(t))seccount+=31622400;//闰年的秒钟数
    . z& j* H5 O% L/ \8 l" K
32. 
    
33. else seccount+=31536000; //平年的秒钟数
    
34. 
    % r: R! Q5 Y: ~$ c# u) H
35. }
    
36. 
    
37. smon-=1;
    0 @* b; [: `8 G1 c7 q- T2 {) y
38. 
    & O# ?% Z+ g- W1 }7 W
39. for(t=0;t<smon;t++) //把前面月份的秒钟数相加
    ) o- ^. Q% e! ~3 d6 k1 X( G$ f
40. 
    
41. { seccount+=(u32)mon_table[t]*86400; //月份秒钟数相加
    
42. 
    
43. if(Is_Leap_Year(syear)&&t==1)seccount+=86400;//闰年 2 月份增加一天的秒钟数
    3 l* J3 d* d2 {  K2 l
44. 
    ' C8 Y! ^0 d2 Z8 i5 N, ~' r
45. }
    
46. 
    
47. seccount+=(u32)(sday-1)*86400; //把前面日期的秒钟数相加
    & `! c/ \$ ]) l" k" C
48. 
    " W. J0 Y% h# M- r+ [6 O% p& P6 ~
49. seccount+=(u32)hour*3600; //小时秒钟数
    2 z0 B& g" X. y  |
50. 
    
51. seccount+=(u32)min*60; //分钟秒钟数
    7 i3 f  _$ Y6 Z' h8 @4 N' ]
52. 
    7 |' @/ `% O6 z% ]1 n7 o
53. seccount+=sec; //最后的秒钟加上去
    
54. 
    7 h$ n9 K4 c% |! k+ A3 ?: n, r3 a  {
55. RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR |
    
56. 
    ) {& L  r! w3 r( ~7 N
57. RCC_APB1Periph_BKP, ENABLE); //使能 PWR 和 BKP 外设时钟
    2 v! D' L6 }) Y2 i0 O# m
58. 
    $ l2 D* m9 f( L8 |: F( I
59. PWR_BackupAccessCmd(ENABLE); //使能 RTC 和后备寄存器访问
    " d0 p# ]& F# T: M+ X( Z
60. 
    
61. RTC_SetCounter(seccount); //设置 RTC 计数器的值
    / u7 B3 x1 u; b* Q+ P. k
62. 
    
63. RTC_WaitForLastTask(); //等待最近一次对 RTC 寄存器的写操作完成
    7 h- U$ s& g( w9 ~0 G* M2 q
64. 
    & r4 o  K: b) [, P. c
65. return 0;
    & }. ?0 U1 M9 d! Z
66. 
    
67. }

复制代码

RTC_Get

1. //得到当前的时间，结果保存在 calendar 结构体里面
   + R3 l# k6 Y4 c$ ^& S" a' E
2. 
   ; _, T+ O5 r. j* ]2 g, o1 m* A$ t
3. //返回值:0,成功;其他:错误代码.
   
4. 
   - K: w' b. D% ^
5. u8 RTC_Get(void)
   
6. 
   # z2 P. z& s& ]+ N- I  l- [5 u6 }
7. { static u16 daycnt=0;
   7 Y& e) D3 B8 ~
8. 
   
9. u32 timecount=0;
   
10. 
    
11. u32 temp=0;
    
12. 
    5 T6 d0 C6 i" i/ \
13. u16 temp1=0;
    7 _1 ~  \) b/ E4 p
14. 
    3 H* [5 c' @4 y% K6 m& h+ D
15. timecount=RTC->CNTH; //得到计数器中的值(秒钟数)
    
16. 
    ! \- e6 _6 @8 M+ n* X
17. timecount<<=16;
    : g% i- b% R% S% r" o0 p7 @
18. 
    1 y% Q) U8 l8 q, E; Q* S# \, P8 L5 c2 x$ m
19. timecount+=RTC->CNTL;
    ( D5 k: q/ J! o; F7 N; E* _
20. 
    3 z1 E" N$ _9 R' [2 {/ Y, |
21. temp=timecount/86400; //得到天数(秒钟数对应的)
    . [" x. k* v* Z) X) v
22. 
    8 R1 j/ O0 S9 @2 I- I( e& W. p
23. if(daycnt!=temp) //超过一天了
    
24. 
    
25. {
    
26. 
    
27. daycnt=temp;
    & k1 L: @0 Z; e, x# Q" z
28. 
    
29. temp1=1970; //从 1970 年开始
    + G: G* @, {4 r, K
30. 
    ( [* ?% r0 u5 y
31. while(temp>=365)
    
32. 
    
33. {
    ' _' c9 N2 N% N- u
34. 
    
35. if(Is_Leap_Year(temp1)) //是闰年
    
36. 
    
37. {
    
38. 
    
39. if(temp>=366)temp-=366; //闰年的秒钟数
    
40. 
    2 l4 f2 F3 q  y
41. else break;
    
42. 
    
43. }
    4 y) |( K' w1 C8 R" O( k; s: Z
44. 
    
45. else temp-=365; //平年
    
46. 
    
47. temp1++;
    ; h  }( x4 L6 k$ G
48. 
    
49. }
    ( L& O( ?2 K, y
50. 
    $ h/ ^- t+ m8 [" z
51. calendar.w_year=temp1; //得到年份
    
52. 
    
53. temp1=0;
    # I3 p: P. k/ u, Q/ w) J
54. 
    
55. while(temp>=28) //超过了一个月
    
56. 
    
57. {
    
58. 
    
59. if(Is_Leap_Year(calendar.w_year)&&temp1==1)//当年是不是闰年/2 月份
    
60. 
    
61. {
    
62. 
    , C7 A8 C# O* e
63. if(temp>=29)temp-=29;//闰年的秒钟数
    
64. 
    
65. else break;
      y% e( h% [  i: ?: b
66. 
    1 K" O6 w2 R* }5 a7 w
67. }
    
68. 
    
69. else
    * G# u; L0 ~& ?0 C& Z4 N
70. 
    . {( w' c; e$ V* t  d2 h3 o8 m6 [% m
71. { if(temp>=mon_table[temp1])temp-=mon_table[temp1];//平年
    ; C! D- G- ]9 s9 n1 `' ?/ w
72. 
    2 q; C0 T/ P& {' a1 t9 t5 G
73. else break;
    
74. 
    - L! U  T) t+ i, X5 ~3 @
75. }
    2 ^; @: A4 s  y1 W' D, D6 I
76. 
    6 J0 W0 S  c4 P* M2 y3 i; h% T$ b
77. temp1++;
    
78. 
    / X7 a9 K2 r: y. [
79. }
    
80. 
    
81. calendar.w_month=temp1+1; //得到月份
    / t2 P9 |: s7 x: ^' T
82. 
    
83. calendar.w_date=temp+1; //得到日期
    
84. 
    " `  ]' o% M- k4 p" M9 {& f% o4 w
85. }
    
86. 
    
87. temp=timecount%86400; //得到秒钟数
    / u1 H4 z% N3 K% C% B8 U
88. 
    $ O" x( i& @; V+ T3 u
89. calendar.hour=temp/3600; //小时
    
90. 
    ; M* W+ v/ X# `. E5 H) `
91. calendar.min=(temp%3600)/60; //分钟
    
92. 
    ) ]! |8 t- E: ~( [. R4 O
93. calendar.sec=(temp%3600)%60; //秒钟
    
94. 
    9 M8 H! C1 O0 K/ T
95. calendar.week=RTC_Get_Week(calendar.w_year,calendar.w_month,calendar.w_date);
    - B2 o: J% x/ l8 _* k7 N( h% w
96. 
    
97. //获取星期
    & x6 o2 t. R( @6 w* p7 f
98. 
    6 A8 `  w: a/ [  C2 }# Y
99. return 0;
    
100. 
     ' Z: \: x5 F5 z2 q4 Q
101. }

复制代码

RTC_NVIC_Config
0 Y+ k" b6 \9 d8 z! t

1. static void RTC_NVIC_Config(void)
   : m9 _' w& C9 h3 Q9 ]3 [# u( \
2. 
   . ~9 t' C8 c9 ?' z
3. {       
   
4. 
   
5. NVIC_InitTypeDef NVIC_InitStructure;
   
6. 
   2 h* v% d  @  Q- b" H  o
7.         NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;                //RTC全局中断
   
8. 
   
9.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;        //先占优先级1位,从优先级3位
   
10. 
    
11.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;        //先占优先级0位,从优先级4位
    - p. Q# d6 N, ?9 `8 N- W* j
12. 
    
13.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                //使能该通道中断
    1 J- K5 n  S/ m
14. 
    
15.         NVIC_Init(&NVIC_InitStructure);                //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
    
16. 
    
17. }

复制代码

RTC_IRQHandler

1. //RTC 时钟中断
   
2. 
   " t6 h- k) e: s$ o& S/ I
3. //每秒触发一次
   
4. 
   
5. void RTC_IRQHandler(void)
   
6. 
   
7. {
   
8. 
   4 X% h& P+ f1 Z" b9 R
9. if (RTC_GetITStatus(RTC_IT_SEC) != RESET) //秒钟中断
   # c: v' ^& _7 E- J; z2 F! n. Y4 }
10. 
    
11. {
    
12. 
    ) k; n5 T% ]: A: M: c
13. RTC_Get(); //更新时间
    5 C- j9 z8 f, k- \( R, L
14. 
    * V' C. }, m9 x5 n0 S& A' K* @& b+ h
15. }
    
16. 
    
17. if(RTC_GetITStatus(RTC_IT_ALR)!= RESET) //闹钟中断
    % D2 T4 w+ {  a/ [2 m# T
18. 
    ' i# u/ N3 Y- N3 b8 O
19. {
    ) v: c. {$ i* |9 M) f% L8 @
20. 
    8 _; F, h% m. `5 I! H  o9 W
21. RTC_ClearITPendingBit(RTC_IT_ALR); //清闹钟中断
    
22. 
    
23. RTC_Get(); //更新时间
    : G2 d' i& y3 b: Q% X6 A3 W. R+ K
24. 
    ! {5 P9 P0 o! T: ^
25. printf("Alarm Time:%d-%d-%d %d:%d:%d\n",calendar.w_year,calendar.w_month,
    
26. 
    2 X4 n- y8 ~; p% c5 {& B0 F
27. calendar.w_date,calendar.hour,calendar.min,calendar.sec);//输出闹铃时间
    1 g) h- A5 N  v* H7 N
28. 
    
29. }
    - F! f  {, `, E( j
30. 
      K; w5 o4 `: r, c
31. RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW); //清闹钟中断
    
32. 
    
33. RTC_WaitForLastTask();
    8 u$ h) F) A3 [9 F9 r4 ^! Y0 O( k
34. 
    
35. }

复制代码

九、项目代码
, n0 Q4 Y# d$ K- w

1. void BSP_RTC_Init(void)
   
2. 
   
3. {
   
4. 
   
5.         u32 i = 0;
   8 @; \2 M8 h8 j/ X0 W9 r3 [! x: [
6. 
   $ e; Z7 J2 i, Z* n. N# k
7.         #if(INFO_OUT_RTC_INIT_EN > 0)
   6 O5 B5 E7 c9 b
8. 
   * L& X3 G) ^# @$ a" Y" W
9.         u8        tmpBuf[60]="";
   . y& h! q8 F& f1 `* U  C
10. 
    
11.         #endif
    
12. 
    
13. 
    
14. 
    
15.         /* Clear reset flags */
    % f- X% e* k, R$ z. L- Y0 c
16. 
    3 U8 T& T' n* k/ z! |, k
17.         RCC_ClearFlag();
    
18. 
    
19. 
    
20. 
    
21.         // 这里标志必须跟测试程序一致否则时间被复位成默认
    
22. 
    / H7 J9 K  @2 Y$ d3 n* C$ a9 z' a
23.         if (BKP_ReadBackupRegister(BKP_DR1) != RTC_SAVE_FLAG)
      G; s" L- E6 L/ V6 l2 L
24. 
    + G! `2 J: e* |
25.         {
    
26. 
    
27.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
    & q' g" _0 O1 m6 K% ~9 |
28. 
    " [1 W6 S4 x. c) R
29.                 /* Allow access to BKP Domain */
    
30. 
    
31.                 PWR_BackupAccessCmd(ENABLE);
    ; e; b$ Y* B! f( f
32. 
    5 S: _: R) H3 @) f9 Q' {3 {1 m8 o
33. 
    
34. 
    * u6 @+ K/ `) C9 I2 |. S7 U
35.                 /* Backup data register value is not correct or not yet programmed (when
    , \: h, P; P" c* U2 Q1 @/ \
36. 
    * V8 G- a% [1 m4 c  A
37.                 the first time the program is executed) */
    
38. 
      K; f! x2 Q+ v5 V" ?
39. 
    % ]+ Y, {- j1 V! j
40. 
    
41.                 /* RTC Configuration */
    ; q% d5 f( ^4 Q. l" @  h
42. 
    1 F  H5 R7 p8 @, h2 s9 j; y2 Q
43.                 BSP_RTC_Config();
    ( |5 ^# `+ }/ q# j1 J0 ?; E
44. 
    - v! t7 S0 T7 P  J
45. 
    
46. 
    - [+ W$ c& o/ z0 f; ]9 q
47.                 #if(DEF_RTCINFO_OUTPUTEN > 0)
    
48. 
    % i4 Y, F! ~5 H
49.                 if(dbgInfoSwt & DBG_INFO_RTC)
    + _- `+ X" @" y) A; D7 h
50. 
    ( `, \- b3 v# y+ R& m
51.                         myPrintf("[RTC]: RTC finish configured....\r\n");
    
52. 
    6 u# v9 a2 @, L& C9 H- D
53.                 #endif
    
54. 
    
55. 
    
56. 
    
57.                 /* Set default time */
    
58. 
    # V. |* c) ]6 [
59.                 SYS_RTC.year                =                Default_year;
    9 L+ ~7 S7 b" Y+ M# s
60. 
    
61.                 SYS_RTC.month                =                Default_month;
    - n1 e5 l3 z# `0 ?; v" w! w3 p; [2 T1 L
62. 
    
63.                 SYS_RTC.day                        =                Default_day;       
    
64. 
    " S3 o0 O! o# E8 _- v5 r0 E
65.                 SYS_RTC.hour                =                Default_hour;
    
66. 
    
67.                 SYS_RTC.minute            =                Default_minute;
    
68. 
    
69.                 SYS_RTC.second            =                Default_second;
    ; N4 `& I" V" N) L6 E% l
70. 
    
71. 
    ' ~& H5 x0 R+ v2 L
72. 
    $ S. ]# o6 U7 }' K# L2 D5 {) W
73.                 /* Adjust time by values entred by the user on the hyperterminal */
    8 w& T; F$ H6 O  |7 S
74. 
    ! n. E# `1 {* d. e9 j9 H
75.                 BSP_RTC_Set_Current(&SYS_RTC);
    
76. 
    
77. 
    
78. 
    
79.                 BKP_WriteBackupRegister(BKP_DR1, RTC_SAVE_FLAG);
    1 U) Z5 ?  L- Q( A8 b+ g
80. 
    
81.         }
    ( m3 S$ m! B  z) v. f' k" A
82. 
    
83.         else
    % z8 s/ i# n0 F1 O6 a0 z
84. 
    
85.         {
    : B8 i" H" t  x. r
86. 
    
87.                 /* Enable PWR and BKP clocks */
    
88. 
    
89.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
    
90. 
    & S* v- p6 F/ e1 C3 f: h0 l: y# y- @
91. 
    
92. 
    
93.                 /* Allow access to BKP Domain */
    1 [, l; t' Z( q
94. 
    
95.                 PWR_BackupAccessCmd(ENABLE);
    4 Z" ^8 \) c, n* N8 ]3 j3 n
96. 
      n3 O7 }) ?9 L6 X1 u) I/ i
97. 
    - w1 r& I7 ?$ A! S1 {9 U3 K! h; r
98. 
    
99.                 /* Wait for RTC registers synchronization */
    - y* K. N' c% Y$ C* E
100. 
     
101.                 RTC_WaitForSynchro();
     
102. 
     
103. 
     
104. 
     
105.                 /* Wait until last write operation on RTC registers has finished */
     
106. 
     
107.                 RTC_WaitForLastTask();
     
108. 
     
109. 
     
110. 
     
111.                 /* Enable the RTC Second */
     
112. 
     
113.                 //RTC_ITConfig(RTC_IT_SEC, ENABLE);                                                                // 不能在系统运行前使能中断
     6 G5 ]  G, |. Z
114. 
     
115.                 //RTC_ITConfig(RTC_IT_ALR, ENABLE);                                                                // 系统闹钟中断
     
116. 
     0 ~6 D7 b1 G) t9 D& l
117.                 /* Wait until last write operation on RTC registers has finished */
     
118. 
     
119.                 //RTC_WaitForLastTask();                                                                                                        // 不能在系统运行前使能中断
     ; \5 z- T2 ]+ k0 p" v! t
120. 
     
121. 
     4 ?  e8 J' s  J
122. 
     ! I$ u' V4 w  e* r* P9 b, S$ }- k4 i
123.                 /* Initialize Date structure */
     
124. 
     , V+ n0 ~, R# F2 J7 ?; z# Y: f
125.                 SYS_RTC.year         = BKP_ReadBackupRegister(BKP_DR4);
     " g: `! `0 B3 k) A0 r
126. 
     
127.                 SYS_RTC.month        = BKP_ReadBackupRegister(BKP_DR3);
     9 U; W4 h+ J) o' n4 q
128. 
     
129.                 SYS_RTC.day         = BKP_ReadBackupRegister(BKP_DR2);
     
130. 
     
131. 
     : Z# ?7 E0 ?  g) R5 D
132. 
     
133.                 if(RTC_GetCounter() / 86399 != 0)
     
134. 
     
135.                 {
     
136. 
     & r' i/ ^) F! H3 ^" G
137.                         for(i = 0; i < (RTC_GetCounter() / 86399); i++)
     
138. 
     * Z5 e; A8 l. |8 p8 i( W8 x7 |
139.                         {
     
140. 
     ; j3 e1 W9 D0 R  F1 q- U
141.                                 BSP_Date_Update(&SYS_RTC);
     4 p' i7 D( u, X. l, n& s$ Q
142. 
     
143.                         }
     1 j0 r5 }! b# \6 S. x/ g+ {% W$ v
144. 
     % }1 T5 _* N5 y. E
145. 
     
146. 
     
147.                         /* Wait until last write operation on RTC registers has finished */
     ) O5 _/ X" M! w) g
148. 
     , s2 F$ K! J" b5 R! c
149.                         RTC_WaitForLastTask();
     3 L# v/ j5 y. E6 G' D0 C1 W
150. 
     
151.                         RTC_SetCounter(RTC_GetCounter() % 86399);
     8 s0 S! l* ]6 ?, G; K
152. 
     # T; U' e  C& Q6 C* l: z3 W
153.                         /* Wait until last write operation on RTC registers has finished */
     9 o, [+ i7 Z7 t
154. 
     
155.                         RTC_WaitForLastTask();
     / k+ b9 L2 }/ v$ f% R& I
156. 
     
157. 
     
158. 
     
159.                         BKP_WriteBackupRegister(BKP_DR4, SYS_RTC.year);
     4 s$ d/ P; |6 U
160. 
     
161.                         BKP_WriteBackupRegister(BKP_DR3, SYS_RTC.month);
     5 |% H+ ~8 @# y5 Q% X! Z
162. 
     
163.                         BKP_WriteBackupRegister(BKP_DR2, SYS_RTC.day);
     
164. 
     / ]+ H9 l: P& ^! T. s( {3 a0 ~$ U
165.                 }
     8 f1 N- h5 I+ M1 h  l
166. 
     
167.         }
     - _6 Z1 y' n8 L, ^9 z
168. 
     0 y. g( c) K1 f, S2 X) W
169.         /* Clear the RTC Second Interrupt pending bit */
     8 J3 C- B' F' F9 P0 \( u
170. 
     
171.         RTC_ClearITPendingBit(RTC_IT_SEC);                                                                                // 防止系统初始化未完成前进入中断程序
     
172. 
     9 t9 U) g" k5 d- r% t$ `" n
173.         RTC_ClearFlag(RTC_IT_SEC);
     
174. 
     
175. 
     
176. 
     ) @  i% v0 ~$ r0 u* s$ C
177.         /* Enable  one second interrupe */
     
178. 
     % e& J, G( j. @) T5 h
179.         //RTC_ITConfig(RTC_IT_SEC,        ENABLE);                                                                        // 不能在系统运行前使能中断
     2 X" A% ^8 c( G
180. 
     
181.         rtcInitFinish        =1;                // 设置初始化完成标志
     
182. 
     1 O. A4 h7 g( D  n/ h4 B
183. }

复制代码

1. void BSP_RTC_Config(void)
   
2. 
   * j5 ]8 y; c# s8 K; M, s4 z9 K* s
3. {
   
4. 
   
5.         //u32 counter = 0;
   9 v0 ^7 v# k1 H& u8 c
6. 
   
7.           uint32_t tmp = 0;
   ' Z! E% J9 v; A' i8 k* {
8. 
   : _  u* M8 d7 J. }
9.           RCC_ClocksTypeDef RCC_Clocks;
   - U4 ~/ L4 L* C5 [
10. 
    
11.           TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    1 V) K- }- f& X: v4 B
12. 
    
13.           TIM_ICInitTypeDef  TIM_ICInitStructure;
    ( G0 U  F7 q, \1 Z# D8 L+ P
14. 
    ' c+ ]# b/ G8 w# H0 Z
15. 
    
16. 
    * h3 Z) B" i/ O, Y
17.         /* Enable PWR and BKP clocks */
    * j6 O; M( }: x0 K' D
18. 
    - w# w" H% F; X7 l& M
19.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
    # V/ @2 s- D  N1 M% t; l
20. 
    * _$ t& V( A! p* @" C( q
21.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    . S+ s+ ?0 f% u7 k; ]& i
22. 
    4 P8 j. s- j5 I9 N
23.         /* Allow access to BKP Domain */
    
24. 
    
25.         PWR_BackupAccessCmd(ENABLE);
    
26. 
    + o  _; }- A& D
27.         /* Reset Backup Domain */
    
28. 
    # w( d! e. P5 H) E: E) |8 [0 h% z
29.         BKP_DeInit();
    8 {6 A3 A4 ^" R0 b' t- b& g
30. 
    4 r1 i$ @. P2 G7 u% I; Z; N; _
31.         RCC_LSICmd(ENABLE); //启用LSI       
    ; U, C  m7 [! r9 ?
32. 
    
33.         while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET)
    
34. 
    7 k0 C: _: w. w0 X5 S$ L
35.           {}
    . }8 ?6 f# d0 [! A
36. 
    
37.           RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
    
38. 
    2 D" l/ v* [" M& J! Z
39.         RCC_RTCCLKCmd(ENABLE);  //  Enable RTC Clock
    8 p0 M0 \: ?7 b- H7 Q* I
40. 
    
41.         RTC_WaitForSynchro();
    
42. 
    
43.         RTC_WaitForLastTask();
    
44. 
    
45.         RTC_SetPrescaler(40000); // RTC period = RTCCLK/RTC_PR = (4 KHz)/(4000+1) LSI
    ' W  }0 w  D7 y, S3 j6 r
46. 
    
47.         RTC_WaitForLastTask();
    6 u( M2 L/ }1 p0 p8 |+ m7 e
48. 
    
49.         BKP_TamperPinCmd(DISABLE);
    
50. 
    / K. @4 s6 M+ X6 y9 Q! k9 y
51.         BKP_RTCOutputConfig(BKP_RTCOutputSource_Second);
    
52. 
    
53.         RCC_GetClocksFreq(&RCC_Clocks);
    
54. 
    4 w: h/ r. h+ a" ^8 R
55.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE);
    ) n( D1 x* O4 ?7 x8 N" F
56. 
    
57.         GPIO_PinRemapConfig(GPIO_Remap_TIM5CH4_LSI, ENABLE);
    
58. 
    
59.           TIM_TimeBaseStructure.TIM_Prescaler = 0;
    
60. 
    5 `; F! W& x( k/ a5 @6 Y
61.           TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    5 h5 e* G" b) L3 x
62. 
    3 C- e0 p, Q0 I& x0 n
63.           TIM_TimeBaseStructure.TIM_Period = 0xFFFF;
    
64. 
    5 g' I7 D3 L% F" v4 @/ b
65.           TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    
66. 
    - f! f9 Y, ^/ {) _, {  W
67.           TIM_TimeBaseInit(TIM5, &TIM_TimeBaseStructure);
    % S0 {" h  Z% A1 H$ u
68. 
    ! M3 o* i* _+ E8 S( e' r
69.           TIM_ICInitStructure.TIM_Channel = TIM_Channel_4;
    
70. 
    % d. C; N% N  A1 B4 `
71.           TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
    
72. 
    $ |( t$ a! G) S; S; q  r. M: p& T
73.           TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
    
74. 
    0 j) g  L! C# e- g. R
75.           TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
    
76. 
    " \* r- M$ g3 V7 n2 m
77.           TIM_ICInitStructure.TIM_ICFilter = 0;
    
78. 
    8 {# L! ^( B, R7 n3 |8 g7 h
79.           TIM_ICInit(TIM5, &TIM_ICInitStructure);
    - p/ e- |9 w' [) a
80. 
    ( |. q' c1 K# ^
81.           OperationComplete = 0;
    
82. 
    
83.           TIM_Cmd(TIM5, ENABLE);
    
84. 
    
85.           TIM5->SR = 0;
    
86. 
    
87.         //TIM_ITConfig(TIM5, TIM_IT_CC4, ENABLE);
    2 \! Y% R0 v+ R* `3 [& f1 b. J+ a
88. 
    4 U7 e' A0 {& l
89. 
    
90. 
    2 D0 w  s  J1 G: ?
91.           while (OperationComplete != 2)
    
92. 
    
93.           {
    
94. 
    0 Z% Y5 D8 W: Q$ U2 l
95.                   if (TIM_GetFlagStatus(TIM5, TIM_FLAG_CC4) == SET)
    
96. 
    
97.             {
    
98. 
    5 f& X' j2 j3 f; U: e# g' i
99.                       tmpCC4[IncrementVar_OperationComplete()] = (uint16_t)(TIM5->CCR4);
    
100. 
     $ n4 C0 ?, y' M$ P' W( T5 X
101.                       TIM_ClearFlag(TIM5, TIM_FLAG_CC4);
     
102. 
     
103.                       if (GetVar_OperationComplete() >= 2)
     0 k# u) E& M5 u5 j0 o$ h: m3 \
104. 
     
105.                       {
     2 |% p3 K& _4 A
106. 
     
107.                               tmp = (uint16_t)(tmpCC4[1] - tmpCC4[0] + 1);
     
108. 
       l, Z: O+ X& ]8 v; H
109.                               SetVar_PeriodValue(tmp);
     
110. 
     2 s& C" R1 M* m; T: d: q
111.                       }
     
112. 
     
113.             }
     
114. 
     
115.         }
     
116. 
     
117.           if (PeriodValue != 0)
     
118. 
     
119.           {
     
120. 
     8 W8 J* E; e* r4 e8 p! a
121. #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)
     1 m/ _% m1 c% \" h  v. i9 J
122. 
     
123.             LsiFreq = (uint32_t)((uint32_t)(RCC_Clocks.PCLK1_Frequency) / (uint32_t)PeriodValue);
     4 H/ f/ |9 A1 K4 \% O& m
124. 
     1 Q- K0 c/ O% R* P2 J
125. #else
     , l* e! `/ _3 @3 L9 N$ X
126. 
     7 x. a0 W+ w1 M+ u. U% g  \& y/ i( z
127.             LsiFreq = (uint32_t)((uint32_t)(RCC_Clocks.PCLK1_Frequency * 2) / (uint32_t)PeriodValue);
     
128. 
     
129. #endif
     
130. 
     
131.           }
     - ~. [" g- V  _: h3 B$ h
132. 
     . u- ~& R# T' y
133.           RTC_SetPrescaler(LsiFreq - 1);
     
134. 
     
135.           RTC_WaitForLastTask();
     5 J% \  d* p2 A& f
136. 
     
137. 
     / R6 U% h( O1 p+ v6 x6 P
138. 
     
139.         TIM_DeInit( TIM5 );       
     
140. 
     ' Z$ G# k2 {8 I3 d, f$ p5 D* ~
141. }
     % O& Y) O& u- X2 }! B+ l/ |
142. 
     

复制代码

十、HSE作为RTC时钟源

1. void RTC_Configuration(void)
   0 J0 ]- m' g0 K6 O: `& J
2. 
   
3. {
   
4. 
   ' {* L% ^8 g# H3 h* ]
5. RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
   
6. 
   
7. PWR_BackupAccessCmd(ENABLE);
   
8. 
   3 n  @/ L2 f. F: Q9 f: w% O7 c
9. /* Reset Backup Domain */
   $ o$ o, O7 M1 W5 m: k& T: c: S* @
10. 
    $ B. S8 l5 h0 C' H
11. BKP_DeInit();
    1 R5 K" `# _. I" }% h6 m, M
12. 
    0 B3 S% V6 {$ u7 T1 ~# j
13. //使用外部高速晶振8M/128 = 62.5K
    
14. 
    % |/ g& g! d5 ]; w9 ?' m
15. RCC_RTCCLKConfig(RCC_RTCCLKSource_HSE_Div128);
    
16. 
    
17. //允许RTC
    ) w4 B5 m7 W. i3 R* z4 n5 f
18. 
    ) z; m5 K" n/ R: k
19. RCC_RTCCLKCmd(ENABLE);
    
20. 
    $ c% w" C' C. o( l  d- B) w/ A7 [
21. //等待RTC寄存器同步
    
22. 
    
23. RTC_WaitForSynchro();
    : z2 I; t; Z6 F1 e4 V0 b
24. 
    ; a, z3 l: G2 d  K4 F6 L
25. 
    : {. p" }9 L( Q, P' y) y/ N
26. 
    
27. RTC_WaitForLastTask();
    
28. 
    ' L8 z' [6 r! w9 i+ F# S: G" G0 |+ p' U
29. //允许RTC的秒中断(还有闹钟中断和溢出中断可设置)
    
30. 
    9 t( m+ n& T6 D$ B  _
31. RTC_ITConfig(RTC_IT_SEC, ENABLE);
    
32. 
    
33. 
    * ], P3 \- v/ I2 ]( y
34. 
    
35. RTC_WaitForLastTask();
    
36. 
    
37. //62500晶振预分频值是62500,不过一般来说晶振都不那么准
    6 b' c2 I+ J8 \' |/ V% p& X9 b- s
38. 
    
39. RTC_SetPrescaler(62498); //如果需要校准晶振,可修改此分频值
    % _" l/ k/ d8 K0 I/ B$ G0 e. H
40. 
    
41. RTC_WaitForLastTask();
    1 a8 {' g+ B3 Q3 B" t( _
42. 
    
43. //清除标志
    
44. 
    
45. RCC_ClearFlag();
    
46. 
    
47. }

复制代码

# y: C. _  D4 }( k& ?6 @0 k! c5 G: B! U
4 c( q" t0 j& @: p
; H  T9 ?, [8 G. c5 j0 b

走时准吗？
计数时钟不准 走时也跟着不准吧
/ t* ^( [! A/ N1 k