主要内容
1） RTC特征与原理；
1 A( y7 d. I' x, I2） BKP备份寄存器特征与原理；
3） RTC常用寄存器+库函数介绍；
4） 相关实验代码解读。
实验内容：
因为没有买LCD屏，所以计划通过串口实时更新时间。系统运行后，串口调试助手实时显示当前时间，可通过USMART工具，修改当前时间和闹钟时间，闹钟触发后，蜂鸣器会叫1s时长。板子正常运行时，LED0和LED1交替闪烁。

$ s) C" i# e2 G1 J6 x) M1. RTC实时时钟特征与原理
! h  y- Z* L8 q: U0 C4 p6 e1 |1.1 RTC (Real Time Clock)称实时时钟。RTC是独立的定时器，RTC模块拥有一个连续计数的计数器，在相应的软件配置下，可以提供时钟日历的功能，修改计数器的值可以重新设置当前时间和日期；
& y( r! e) Z0 ^  i0 t9 A5 F! E
1.2 RTC模块和时钟配置系统(RCC_BDCR寄存器)是在后备区域，即在系统复位或从待机模式唤醒后RTC的设置和时间维持不变。但是在系统复位后，会自动禁止访问后备寄存器和RTC，以防止对后备区域(BKP)的意外写操作。所以在要设置时间之前， 先要取消备份区域（BKP）写保护；

0 Q! d' W! p- a/ C7 z) X* C1.3 RTC特征如下图所示：



; ?" o0 z# ~3 S% k5 ~; _! y1.4 RTC工作原理框图

0 c* H; d9 A3 o; l2 N6 j

$ a; ?  d; |7 e$ p) M6 m1.4.1 RTC预分频器，RTCCLK除以RTC_PRL的重装载值后，值为分频后的TR_CLK的值，一般情况下TR_CLK设1Hz；
: k) n: [. h0 V) S/ r8 @9 Z1.4.2 RTC预分频器，RTC_DIV装载从RTC_PRL的重装载值，每个RTCCLK周期值减1，至0后会溢出；
0 n$ X: K! k- Q1 A: K; j1.4.3 待机时维持供电，RTC_CNT，每个TR_CLK周期加1，直至溢出，触发溢出中断；当RTC_ALR所设值等于RTC_CNT实时值时，触发闹钟中断；每个TR_CLK周期产生一次中断。
由原理框图可知RTC的组成：
APB1接口：用来和APB1总线相连。通过APB1接口可以访问RTC的相关寄存器（预分频值，计数器值，闹钟值）。
. G! ?7 h* e' ^; |9 B# sRTC核心：由一组可编程计数器组成，分两个主要模块：
1）第一个是RTC预分频模块，它可以编程产生最长1秒的RTC时间基TR_CLK。如果设置了秒中断允许位，可以产生秒中断；
2）第二个是32位的可编程计数器，可被初始化为当前时间。系统时间按TR_CLK周期累加并与存储在RTC_ALR寄存器中的可编程时间相比，当匹配时候如果设置了闹钟中断允许位，可以产生闹钟中断。
备注：RTC内核完全独立于APB1接口，软件通过APB1接口对RTC相关寄存器访问。但是相关寄存器只在RTC APB1时钟进行重新同步的RTC时钟的上升沿被更新。所以软件必须先等待寄存器同步标志位（RTC_CRL的RSF位）被硬件置1才读。

1.5 RTC时钟源（有三个时钟源可选，一般采用外部时钟）
1 K0 p0 M* N$ i) L& t3 C

2 q# N4 C& C; u: G* @
! u, `! C: W5 J: B3 x! @  c2. BKP备份寄存器
0 h! q- i1 c. b+ d7 s2.1 备份寄存器是42个16位的寄存器，可用来存储84个字节数据；
2.2 它们处在备份区域，当VDD电源切断，仍然由VBAT（板子上的纽扣电池）维持供电；
6 R; q+ [& Z( Q# N6 t, |0 S2.3 当系统在待机模式下被唤醒，或者系统复位或者电源复位，它们也不会复位；
2.4 执行以下操作将使能对后备寄存器和RTC访问：
2.4.1 置寄存器RCC_APB1ENR的PWREN和BKPEN位，使能电源和后备时钟；
2.4.2 设置寄存器PWR_CR的DBP位，使能对RTC和后备寄存器的访问。
( E2 Z3 x2 r+ W# ~7 d2.5 BKP备份寄存器常用来保存一些系统配置信息和相关标志位。
; R+ b  `- ]% T, L- e, s- K


3. RTC常用寄存器
3.1 RTC控制寄存器 (RTC_CRH（高位）， RTC_CRL（低位）)；
  G. S& H/ M& I* H9 G' k

) j4 B0 @+ [( k1 t

4 l# z: x" H# d/ [8 Y' w
3.1.1 修改CRH/CRL寄存器，必须先判断RSF位，确定已经同步；
  n  T0 Y$ N% L3.1.2 修改CNT,ALR,PRL的时候，必须先配置CNF位进入配置模式，修改完之后，设置CNF位为0退出配置模式；
3.1.3 同时在对RTC相关寄存器写操作之前，必须判断上一次写操作已经结束，也就是判断RTOFF位是否置位。
# g1 A; k$ B" V3 B1 @. v1 R! B1 v3.2 RTC预分频装载寄存器 (RTC_PRLH， RTC_PRLL)；



. ~& k8 t$ t% W5 |! t3.3 RTC预分频余数寄存器 (RTC_DIVH， RTC_DIVL)；
  L; B0 X! B- p  c# t' s2 C" R4 o
$ ?( o  x7 I6 [5 K5 C; ^) H) i

3.4 RTC计数器寄存器 (RTC_CNTH， RTC_CNTL)；
. H9 I3 _. N- K" {7 m7 U

# ^# N8 Q7 D# q! N* A6 @8 [
0 e+ Y1 h0 a+ w0 \# R4 m3.5 RTC闹钟寄存器 (RTC_ALRH， RTC_ALRL)；
- s6 t* N+ n4 i' Z2 c" ^/ @' K1 B

: u2 N. h, U& t
, E% K" P0 Z7 {0 T1 {# b  |, D3.6 配置RTC寄存器

7 L1 K0 A8 \& r& G; A/ \

3.7 读RTC寄存器

+ y& G+ J7 h2 ^4 e, e- z
' `! C* k. N6 N1 V# Y0 S' Z
4. RTC常用库函数
" i& d' X2 c5 n; \4.1 STM32提供的官方库函数文件名为：
. q( Q8 j% h5 W+ Gstm32f10x_rtc.c 和stm32f10x_rtc.h;
4.2 具体库函数为：
- u( U3 B" O: ?( R6 e
1 s. a8 K9 O+ ^" w. l

1. void RTC_ITConfig(uint16_t RTC_IT, FunctionalStateNewState);
   
2. void RTC_EnterConfigMode(void);
   ' i3 a" t: w6 a5 K& \# B5 v
3. void RTC_ExitConfigMode(void);
   2 }) ]6 y6 P, i* I: \
4. uint32_t  RTC_GetCounter(void);
   
5. void RTC_SetCounter(uint32_t CounterValue);
   
6. void RTC_SetPrescaler(uint32_t PrescalerValue);
     o1 W& p, Z0 |% \- J" T3 M% i
7. void RTC_SetAlarm(uint32_t AlarmValue);
   
8. uint32_t  RTC_GetDivider(void);
   ! Q, [; {, l3 }. y4 G
9. void RTC_WaitForLastTask(void);
   0 H, E% S; I( Y5 j: [: I# b. ]
10. void RTC_WaitForSynchro(void);
    $ M& ?" t1 \# D5 h! U. x5 w
11. FlagStatus RTC_GetFlagStatus(uint16_t RTC_FLAG);
    ! g! b6 z. `3 h% w
12. void RTC_ClearFlag(uint16_t RTC_FLAG);
    ' U( y, |: \* {8 g+ w
13. ITStatus RTC_GetITStatus(uint16_t RTC_IT);
    2 ?6 n- |  b" n( B
14. void RTC_ClearITPendingBit(uint16_t RTC_IT);

复制代码

4.3 RTC时钟源和时钟操作函数：

% e. C# w! S8 w

1. void RCC_RTCCLKConfig(uint32_t  CLKSource);      //时钟源选择
   ( D( X. R& H' ]3 P8 L8 y$ Q8 g) W# J
2. void RCC_RTCCLKCmd(FunctionalState NewState);    //时钟使能

复制代码

+ C9 d* e8 D3 E! c8 U1 `' s! _4.4 RTC配置函数（预分频，计数值）：
6 i& J$ D# n( O- X) h7 T, ?

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
   4 c* s+ p) T8 Y: N. r- l

复制代码

4.5 RTC中断设置函数：

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

复制代码

4.6 RTC允许配置和退出配置函数：

* t8 V' q4 @9 m4 g. p& C1 x

1. void RTC_EnterConfigMode(void);                                  //允许RTC配置  : CRL位 CNF
   - o* T- J1 A7 H; c4 G6 H. w% _6 {' O
2. void RTC_ExitConfigMode(void);                                   //退出配置模式 : CRL位 CNF

复制代码

4.7 同步函数：

* D7 y8 u5 e4 `" |, D0 M. \0 I

1. void RTC_WaitForLastTask(void);                                 //等待上次操作完成：CRL位RTOFF
   ; V% v% C& ?) g7 w5 [" }2 A# y
2. void RTC_WaitForSynchro(void);                                  //等待时钟同步：CRL位RSF

复制代码

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

1. FlagStatus RTC_GetFlagStatus(uint16_t RTC_FLAG);
   
2. void RTC_ClearFlag(uint16_t RTC_FLAG);      
   # d2 ?8 E6 p/ z5 w1 _
3. ITStatus RTC_GetITStatus(uint16_t RTC_IT);
   
4. void RTC_ClearITPendingBit(uint16_t RTC_IT);

复制代码

* X) V* C& F8 j9 ^& i6 ^! s1.9 其他相关函数（BKP等）

1. PWR_BackupAccessCmd();                                         //BKP后备区域访问使能
   " z7 x4 ]& ~. a
2. RCC_APB1PeriphClockCmd();                                      //使能PWR和BKP时钟        
   
3. RCC_LSEConfig();                                               //开启LSE，RTC选择LSE作为时钟源        
   
4. PWR_BackupAccessCmd();                                         //BKP后备区域访问使能        
   9 F$ A4 s5 \4 ]9 P
5. uint16_t BKP_ReadBackupRegister(uint16_t BKP_DR);              //读BKP寄存器      
   
6. void BKP_WriteBackupRegister(uint16_t BKP_DR, uint16_t Data);  //写BKP

复制代码

& y/ c. F% I+ t8 \( u) H9 e$ ~3 r$ P5. RTC一般配置步骤
5.1 使能PWR和BKP时钟：

1. RCC_APB1PeriphClockCmd();

复制代码

3 I* @2 |: |' y; o- r; G7 y5.2 使能后备寄存器访问：

% g. o4 E1 i7 @

1. PWR_BackupAccessCmd();

复制代码

5.3
配置RTC时钟源，使能RTC时钟：
) G3 t6 v. o' r" C% p$ A' y6 a% s

1. RCC_RTCCLKConfig();
   
2. RCC_RTCCLKCmd();

复制代码

如果使用LSE，要打开LSE：RCC_LSEConfig(RCC_LSE_ON)；

5.4 设置RTC预分频系数：

; S! L+ q+ Y1 T  K

1. RTC_SetPrescaler();

复制代码

% p' p. h% }9 S5.5 设置时间：

1. RTC_SetCounter();

复制代码

- n! t# c9 @, W; u7 F, m( D5.6 开启相关中断（如果需要）：

1. RTC_ITConfig();

复制代码

5.7 编写中断服务函数：

1. RTC_IRQHandler();

复制代码

5.8 部分操作要等待写操作完成和同步。
0 c" g2 t6 E& u& T# j$ [
# _' c4 v0 ~& ~7 `

1. RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
   $ w. ?6 o5 ?, a' C! b* x, w4 j
2. RTC_WaitForSynchro();     //等待RTC寄存器同步

复制代码

. N0 H, P3 v  l* ?6. 相关实验代码
6.1 rtc.h头文件代码
/ ]! @% d# t: J9 ?3 @  ]: \
3 y& ~- q) \* h

1. #ifndef __RTC_H
     V) N/ J! c9 }0 s# o: o
2. #define __RTC_H     
   
3. #include "stm32f10x.h"
   ( A! u. @  l& k$ a. h; _0 O
4. //定义一个时间结构体//
   : @' U9 V0 F: K
5. typedef struct
   
6. {
     d3 e# s3 n2 q) {+ z
7. vu8 hour;     //时
   
8. vu8 min;      //分
   * t. N/ R- |. r# Q& k
9. vu8 sec;      //秒
   8 F, R/ [( _' @9 ~( H1 c
10. vu16 w_year;  //年
    , l5 D* D' x6 y; {7 S
11. vu8  w_month; //月
    
12. vu8  w_date;  //日
    8 N/ g- k8 u7 h; u
13. vu8  week;    //周
    
14. }_calendar_obj;      
    1 l/ E( V4 Z, s3 @
15. extern _calendar_obj calendar;                //日历结构体，已在rtc.c中申明了//
    
16. extern u8 const mon_table[12];                //月份日期数据表，常数
    3 Q  e0 b8 P  C3 O
17. void Disp_Time(u8 x,u8 y,u8 size);            //在制定位置开始显示时间
    
18. void Disp_Week(u8 x,u8 y,u8 size,u8 lang);    //在指定位置显示星期
    : _. K$ D% n4 ^/ _: P6 O- `0 `
19. u8 RTC_Init(void);                            //初始化RTC,返回0,失败;1,成功;
    * E. I9 |- ]; t' q
20. u8 Is_Leap_Year(u16 year);                    //平年,闰年判断，返回1是，0不是
    ( D5 L- J7 n4 X6 P. U/ H
21. u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);  //闹钟设定
    + W! G. q6 Q  F; c! O
22. u8 RTC_Get(void);                             //获取时间   
    
23. u8 RTC_Get_Week(u16 year,u8 month,u8 day);    //获取日期，返回0成功，其他失败
    8 G; S) |4 T6 Y* e& C
24. u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);        //设置时间   
    : d; ~9 Y2 F+ F, \4 |5 y8 d  ^
25. #endif

复制代码

* }9 ^7 d( J4 x8 D6.2 rtc.c文件代码

1. #include "beep.h"
   ( i1 Y) l! s: X2 ^
2. #include "rtc.h"  
   
3. #include "sys.h"
   1 P2 Z0 Y+ D& F
4. #include "delay.h"
   
5. #include "usart.h"
   
6. //时钟结构体//
   + z; q* ^; d0 w$ ~6 ^3 \
7. _calendar_obj calendar;                                      
   " T* H) P7 }* c1 I& a
8. static void RTC_NVIC_Config(void)
   
9. {
   5 W6 S: n' k8 I# r( I
10. NVIC_InitTypeDef NVIC_InitStructure;
    ' `9 g! T* g$ d" M4 w% `4 N5 M6 C
11. NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;             //RTC全局中断
    
12. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  //先占优先级1位,从优先级3位
    " ?, o- J) D5 V3 F- b. O7 M
13. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;         //抢占优先级0位,从优先级4位
    
14. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            //使能该通道中断
    . n" {6 a& m5 ?7 y. |' _* u
15. NVIC_Init(&NVIC_InitStructure);  
    
16. }
    
17. //实时时钟配置
    7 r. f5 D3 M& [, h6 B* [0 G3 Y3 \
18. //初始化RTC时钟,同时检测时钟是否工作正常
    
19. //BKP->DR1用于保存是否第一次配置的设置
    
20. //返回0:正常; 其他:错误代码
    1 S# u, O4 N5 m! o1 }
21. u8 RTC_Init(void)
    1 ~" ]; p* q/ @& a
22. {
    ' b1 |% O. @! W6 [8 J0 D2 U; W
23. //检查是不是第一次配置时钟//
    / Q, I: N- V) B3 ?7 U
24. u8 temp=0;
    
25. //*****第一步*****//
    . t8 f3 N4 Z  N
26. //电源控制PWR，当主电源VDD掉电后，通过VBAT脚为实时时钟(RTC)和备份寄存器(BKP)提供电源//
    * U. u. e# M4 L
27. //使能PWR和BKP外设时钟//  
    * ^& D& U! r3 O
28. RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
    " P8 `) e7 m- k7 ?# p
29. //*****第二步*****//
    ' W# F/ m( {: }2 S: Z) A# V6 E6 w) I
30. //使能后备寄存器访问，位带操作，实际对电源控制寄存器PWR_CR的第八位DBP写1，允许写入RTC和BKP//
    ! o$ c2 q# C# j
31. PWR_BackupAccessCmd(ENABLE);
    - c" d* R  k4 Y( e" h- ^- S
32. //读取BKP_DR1寄存器0~15位的值，判断是否与0x5050一致//
    ( t- U7 F' t1 F/ A0 y1 E
33. if (BKP_ReadBackupRegister(BKP_DR1) != 0x5050)  
    
34.   {
    
35.    //如果不一致，说明第一次配置，则进行如下操作//   
    5 `" \: o. M& f# I; D  {! b
36.    BKP_DeInit();                           //复位备份区域//  
    
37.    RCC_LSEConfig(RCC_LSE_ON);              //设置外部低速晶振(LSE),使用外设低速晶振//
    3 A5 t( I" @. e+ N8 [
38.    //备份域控制寄存器RCC_BDCR，位1，LSERDY为0时未就绪，为1时就绪//
    3 k1 ]) Z/ t2 z' _6 k
39.    while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET&&temp<250)
    . A- M# k  E3 V- h9 _1 q- g% x
40.     {
    
41.      temp++;
    + z5 b; u% _! ^- Q1 x% o, o
42.      delay_ms(10);
    & I$ i' I- {( \5 G
43.     }
    
44.    if(temp>=250)return 1;                   //初始化时钟失败,晶振有问题，结束u8 RTC_Init(void)函数//
      X; |9 o. Z5 R9 \
45.    //若temp＜250，则继续//
    
46.    //*****第三步*****//   
    
47.    RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);  //设置RTC时钟(RTCCLK),选择LSE作为RTC时钟//   
    
48.    RCC_RTCCLKCmd(ENABLE);                   //使能RTC时钟//  
    5 N* K) c' u& R8 c6 R. P% g
49.    //*****配置RTC寄存器开始*****//   
    " m7 m5 \$ [- e, a2 }7 J
50.    //*****第六步*****//
    
51.    //RTC控制寄存器低位(RTC_CRL)，位5，RTOFF为0时仍在写操作，为1时写操作完成，该函数循环执行，直到RTOFF为1//
    $ @% v2 U; a2 B4 i) D* B
52.    RTC_WaitForLastTask();   
    ( f; f: H9 `( j4 g/ N  G, S
53.    //RTC控制寄存器低位(RTC_CRL)，位3，RSF为0时寄存器未同步，为1时寄存器同步，该函数循环执行，直到 RSF 为1//
    
54.    //因为修改CRH/CRL寄存器，必须先判断RSF位，确定已经同步//  
    4 r" ~! [7 E, O' g; M- Z. I
55.    RTC_WaitForSynchro();                     
    " I, U. ~% g" D( g* t% p
56.    RTC_ITConfig(RTC_IT_SEC | RTC_IT_ALR, ENABLE);     //对控制寄存器高位(RTC_CRH)操作，使能RTC秒中断//
    % Q9 W/ E* w: r# }( y# M
57.    RTC_WaitForLastTask();                             //等待最近一次对RTC寄存器的写操作完成//   
    
58.    //*****第四步和第五步*****//
    
59.    //RTC控制寄存器低位(RTC_CRL)，位4，CNF置1，进入配置模式//
    7 a5 W8 m( L) i5 n2 N6 V) Z2 k( z( G
60.    RTC_EnterConfigMode();                    
    , ~1 S0 O, t5 n% `  U
61.    RTC_SetPrescaler(32767);                           //设置RTC预分频的值//
    , x% m% j9 }$ \% F- y0 @
62.    RTC_WaitForLastTask();                             //等待最近一次对RTC寄存器的写操作完成//
    ' F8 K% ]% ], S# I
63.    RTC_Set(2015,1,14,17,42,55);                       //设置时间，纯c语言代码//
    
64.    //RTC控制寄存器低位(RTC_CRL)，位4，CNF置0，退出配置模式//
    
65.    RTC_ExitConfigMode();                     
    , x  U- R0 k( E0 n! f+ E! n( Q: J
66.    //写入BKP_DR1寄存器0~15位的值//
    * }$ h  F' s9 g
67.    BKP_WriteBackupRegister(BKP_DR1, 0X5050);          //向指定的后备寄存器中写入用户程序数据//
    ( ?" B7 }7 `* z' W
68.   }
    . r+ B, x- A' l
69. else                                                 //如果，不是第一次配置，系统继续计时//
    6 ^2 ~# Q7 M; N$ Q( P! P
70.   {
    
71.     RTC_WaitForSynchro();                             //等待寄存器同步//
    1 h/ s8 c/ s$ e' R
72.     RTC_ITConfig(RTC_IT_SEC | RTC_IT_ALR, ENABLE);         
    
73.     RTC_WaitForLastTask();                            //等待最近一次对RTC寄存器的写操作完成//
    ; v0 r* y  y) s# H
74.   }
    
75. RTC_NVIC_Config();                                   //RCT中断分组设置//               
    
76. RTC_Get();                                           //更新时间//
    
77. return 0;                                            //ok//
    . n- e7 e$ f2 @' Y# S; F4 w, x% p6 @7 v, e
78. }           
    
79. //*****第七步，编写中断服务函数*****//
    
80. //秒中断发生，更新时间，闹钟中断发生，更新时间并向串口发送时间//
    
81. void RTC_IRQHandler(void)
    
82. {   
    ( K/ L, L2 u1 {: U# O
83. if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)              //判断闹钟中断是否发生//
    
84. {
    
85.   //RTC控制寄存器低位(RTC_CRL)，位1，ALRF置0，清闹钟中断//
    
86.   RTC_ClearITPendingBit(RTC_IT_ALR);           
    
87.   RTC_Get();                                          //更新时间//  
    / M9 k8 v  _# ?7 F8 z
88.   printf("闹钟时间:%d-%d-%d %d:%d:%d\n",calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
    " a2 I' p$ U6 O, V+ f/ |1 t7 H
89.   BEEP=1;
    
90.   delay_ms(1000);
    
91.   BEEP=0;      
    
92.   }   
    6 z8 ^) Q# k  e7 T/ j: e
93. if (RTC_GetITStatus(RTC_IT_SEC) != RESET)            //判断秒钟中断是否发生//
    
94. {      
    ; D3 j% ^7 }+ O' K$ Y- A) u( l9 E1 L9 F
95. RTC_Get();
    % c, i  G8 U1 B% @0 @8 D% }7 x
96. printf("闹钟时间:%d-%d-%d %d:%d:%d\n",calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
    
97. }   
    
98. 
    ' o! y/ O- N8 I' t  M! F$ D+ q
99. RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);         //清闹钟中断和溢出标志//
    
100. RTC_WaitForLastTask();                               //等待最近一次对RTC寄存器的写操作完成//   
     
101. }
     + L( n0 \- o$ @  e
102. //判断是否是闰年函数，能被4整除，但不能被100整除的年是闰年，能被400整除的年是闰年//
     9 J8 ^' {) w  h, o, }. ]) G
103. //月份        1  2  3  4  5  6  7  8  9  10 11 12
     ( k9 V' N: S$ a- z  h8 k" N
104. //闰年        31 29 31 30 31 30 31 31 30 31 30 31
     + v& ^# f, |7 K9 ^& c
105. //非闰年/平年 31 28 31 30 31 30 31 31 30 31 30 31
     
106. //输入:年份
     
107. //输出:该年份是不是闰年.1,是.0,不是
     + g+ b- J+ x' X
108. u8 Is_Leap_Year(u16 year)
     - ]& @) t" q" n) N
109. {     
     6 @! V+ z+ S9 \  G
110. if(year%4==0)                              //判断是否能被4整除，能则继续；不能则不是闰年，且返回0//
     $ ^4 f1 @2 {  C% Q  X/ v6 U) N
111. {
     
112.   if(year%100==0)                           //判断是否能被100整除,能则继续；不能则是闰年，且返回1//
     % g" {8 R  N4 _4 K, |
113.   {
     " ]# }8 y5 W+ C% z3 Y
114.    if(year%400==0)return 1;                 //判断是否能被400整除，能则是闰年，且返回1；不能则不是闰年，且返回0//   
     9 ~- x: g- u; {; N, E
115.    else return 0;   
     
116.   }else return 1;   
     3 ^: ]# m8 {3 G/ I& Z
117. }else return 0;
     ' H' I# d  e# \2 L8 Q
118. }        
     , B# Q; w7 s9 k/ z2 i: A
119. //设置时钟，把输入的时钟转换为秒钟，以1970年1月1日为基准，1970~2099年为合法年份//
     % z. s$ l; O9 Q1 {0 m! d
120. //并将值传至RTC计数器寄存器高位(RTC_CNTH)和RTC计数器寄存器低位(RTC_CNTL)中//
     
121. //返回值:0,成功;其他:错误代码//           
     
122. //平年的月份日期表，闰年的话，就把28改29//
     
123. const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
     
124. u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
     ' f: o$ ~7 v* Q# V5 |" T: J0 m
125. {
     
126. u16 t;
     
127. u32 seccount=0;
     
128. if(syear<1970||syear>2099)return 1;               //如果年份不在1970~2099年之内，则报错，函数停止//
     
129. for(t=1970;t<syear;t++)                           //把所有年份的秒钟相加//
     
130. {
     
131.   if(Is_Leap_Year(t))seccount+=31622400;           //闰年的秒钟数//
     1 `' Q/ h. f* c/ a+ _6 k
132.   else seccount+=31536000;                         //平年的秒钟数，少一天//
     * |2 l4 K9 a7 Q1 n
133. }
     
134. smon-=1;
     + g$ Q2 v5 p$ V; @
135. for(t=0;t<smon;t++)                               //把前面月份的秒钟数相加//
     
136. {
     7 M- f0 Y0 Y/ ?1 z: a# L: ]
137.   seccount+=(u32)mon_table[t]*86400;               //月份秒钟数相加//
     / w- A4 R# ~4 h" A
138.   if(Is_Leap_Year(syear)&&t==1)seccount+=86400;    //闰年2月份增加一天的秒钟数 //   
     
139. }
     " O( V8 l1 F6 Z8 B0 R5 L$ O
140. seccount+=(u32)(sday-1)*86400;                    //把前面日期的秒钟数相加//
     $ c: z- E9 j) A
141. seccount+=(u32)hour*3600;                         //小时秒钟数//
     & b. r% O+ V' L( e2 V! x+ v
142. seccount+=(u32)min*60;                            //分钟秒钟数//
     $ e- h- V0 R. M7 T8 A" ?
143. seccount+=sec;                                    //最后的秒钟加上去//
     
144. //以上，已经把某年某月某日某时某分某秒的时间，用秒计数起来//
     
145. RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE); //使能PWR和BKP外设时钟//  
     
146. PWR_BackupAccessCmd(ENABLE);                                             //使能RTC和BKP访问//
     $ b8 ?  _- U" S7 V9 J# Y
147. RTC_SetCounter(seccount);                                                //设置RTC计数器的值//
     
148. RTC_WaitForLastTask();   
     * S  P5 t2 `+ n* r  g
149. return 0;     
     % |7 k" v7 S+ [3 |# i
150. }
     * q% f+ o& v  @' w! O  L: |
151. //初始化闹钟，以1970年1月1日为基准，1970~2099年为合法年份，syear,smon,sday,hour,min,sec：年月日时分秒//   
     
152. //返回值:0,成功;其他:错误代码.//
     , u% d; v! A( P
153. u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
     
154. {
     . @7 C" c: }( \& I% u# l9 k
155. u16 t;
     # D/ o! B4 D7 g6 v* _/ H- m# ]
156. u32 seccount=0;
     8 k% X/ }' ]/ d/ S$ B) K
157. if(syear<1970||syear>2099)return 1;   
     
158. for(t=1970;t<syear;t++)                        //把所有年份的秒钟相加//
     3 Q  G! p, a  z1 o9 h
159. {
     
160.   if(Is_Leap_Year(t))seccount+=31622400;        //闰年的秒钟数//
     9 K! ^7 Y% H$ W) K; K, m5 ]
161.   else seccount+=31536000;                      //平年的秒钟数//
     5 r0 Y2 s6 j7 b6 R) t2 c( P/ X& B/ I& [
162. }
     
163. smon-=1;
     
164. for(t=0;t<smon;t++)                            //把前面月份的秒钟数相加//
     
165. {
     : v) W3 r. N- K3 e0 S6 G, K
166.   seccount+=(u32)mon_table[t]*86400;            //月份秒钟数相加//
     
167.   if(Is_Leap_Year(syear)&&t==1)seccount+=86400; //闰年2月份增加一天的秒钟数//   
     ; i6 B; |6 r9 t* v
168. }
     
169. seccount+=(u32)(sday-1)*86400;                 //把前面日期的秒钟数相加//
     
170. seccount+=(u32)hour*3600;                      //小时秒钟数//
     
171.     seccount+=(u32)min*60;                      //分钟秒钟数//
     , u8 Y+ ~% u$ Y5 o- G
172. seccount+=sec;                                 //最后的秒钟加上去//      
     ; G& P. ~* w) o  L  B# F' f8 h
173. //设置时钟//
     - e0 H0 h$ e7 U- w' I
174. RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);  //使能PWR和BKP外设时钟//   
     
175. PWR_BackupAccessCmd(ENABLE);                                              //使能RTC和BKP访问//  
     ! q2 A& O3 w% n0 V& T
176. RTC_SetAlarm(seccount);                                                   //设置RTC闹钟寄存器值//
     
177. RTC_WaitForLastTask();   
     ( W. `! p# R+ N+ B1 L; Y4 p5 l  Q5 z
178. return 0;     
     6 _* y* p5 r; E+ h
179. }
     9 ]+ [+ G4 B' H+ s3 Q  E- {
180. //得到当前的时间，将秒转换成年月日时分秒//
     : J* m# K/ g! j# s* d7 n; ]
181. //返回值:0,成功;其他:错误代码.//
     
182. u8 RTC_Get(void)
     8 |  e. v" F3 ~% G
183. {
     
184. static u16 daycnt=0;
     
185. u32 timecount=0;
     
186. u32 temp=0;
     
187. u16 temp1=0;   
     9 f' c% k/ m1 j5 t; T$ }
188.   timecount=RTC_GetCounter();   //获取16位RTC计数器寄存器高位RTC_CNTH和低位RTC_CNTL的值，返回32位数据//
     
189.   temp=timecount/86400;         //得到天数//
     # W; j$ s) A! e) ]; r- i
190. if(daycnt!=temp)               //超过一天了
     9 I; x$ F' O. ]3 g$ l" R. X* D
191. {   
     , ~8 w* r: h, y
192.   daycnt=temp;
     
193.   temp1=1970;                   //从1970年开始//
     
194.   while(temp>=365)              //当temp≥365天时//
     
195.   {     
     
196.    if(Is_Leap_Year(temp1))      //闰年判断，闰年366天，平年365天//
     + b1 f) h# X, M
197.    {
     
198.     if(temp>=366)
     
199.      temp-=366;                 //闰年，temp减366天//
     
200.     else break;                 //当年是闰年，且是365天时，跳出循环//
     
201.    }
     
202.    else  temp-=365;             //平年，temp减365天//
     
203.    temp1++;                     //平年，temp1加1年//
     ; S# Q  S7 V) k& `9 J3 }9 N
204.   }   
     + F: J4 s8 s8 R% ~6 B' j; i
205.   calendar.w_year=temp1;        //得到年份temp1//
     
206.   temp1=0;                      //temp1至0，开始计算月份//
     
207.   while(temp>=28)               //当28≤temp＜365天时//
     ! O( E9 Q+ v2 K1 G
208.   {
     $ [, K6 q, l9 ~- J& G. R1 x) T
209.    //temp1从0至11分别对应1月到12月//
     
210.    if(Is_Leap_Year(calendar.w_year)&&temp1==1)         //当是闰年，且为2月份时，执行下面语句//
     2 i8 e7 [, Z! n' Y3 ~) F+ d
211.    {
     
212.     if(temp>=29)temp-=29;                              
     
213.     else break;
     ! b" a1 {; y* u! C) {
214.    }
     5 L4 Q( q: g6 X4 h: I! ?, E1 z
215.    else                                                //平年，执行else//
     . l7 w; t! e+ C2 n5 m
216.    {
     
217.     if(temp>=mon_table[temp1])                        
     
218.      temp-=mon_table[temp1];                          
     8 ~' g4 w5 M0 i+ C8 e
219.     else break;
     
220.    }
     / h" Z( P" z4 g3 G3 S, l. F
221.    temp1++;  
     
222.   }
     - |2 k; w# n9 i* {) p$ B8 w8 C
223.   calendar.w_month=temp1+1;                            //得到月份//
     
224.   calendar.w_date=temp+1;                              //得到日期//
     & `  W9 P8 u- @$ A5 k
225. }
     
226. temp=timecount%86400;                                 //得到秒钟数//      
     
227. calendar.hour=temp/3600;                              //小时//
     0 M: d( _3 f( e& f. o
228. calendar.min=(temp%3600)/60;                          //分钟//
     
229. calendar.sec=(temp%3600)%60;                          //秒钟//
     
230. calendar.week=RTC_Get_Week(calendar.w_year,calendar.w_month,calendar.w_date); //获取星期//   
     
231. return 0;
     1 C0 q; T8 G& t& H1 H
232. }  
     7 ?# j. C& N4 K, F  Z/ D
233. //获得现在是星期几
     
234. //功能描述:输入公历日期得到星期(只允许1901-2099年)
     6 A3 ~. ?+ ~/ G+ g2 L  ?
235. //输入参数：公历年月日
     
236. //返回值：星期号  
     2 O# }) J" o7 a  N* S4 i0 h
237. u8 const table_week[12]={0,3,3,6,1,4,6,2,5,0,3,5};        //月修正数据表?//
     
238. u8 RTC_Get_Week(u16 year,u8 month,u8 day)
     % w. J  U/ Q$ C  {+ d
239. {
     ' v: A3 x/ e1 N2 U0 ^! b
240. u16 temp2;
     
241. u8 yearH,yearL;
     5 z5 [" _6 f3 v0 ]' k+ c" f' z2 d
242. yearH=year/100; yearL=year%100;
     
243. //如果为21世纪,年份数加100//  
     
244. if (yearH>19)
     7 n  G5 V! X' g- q! ]
245.   yearL+=100;
     
246. //所过闰年数只算1900年之后的//  
     6 o6 @6 L" t# Q; x4 M9 W: j. A. u* u% y0 c
247. temp2=yearL+yearL/4;
     , }5 Y  w' t6 q, ^- O' X8 c
248. temp2=temp2%7;
     
249. temp2=temp2+day+table_week[month-1];
     - @1 S% L8 b( W  r4 n
250. if (yearL%4==0&&month<3)temp2--;
     , _+ e/ |% d7 s$ ?, j
251. return(temp2%7);
     
252. }  

复制代码

3 y& o+ W+ g; r* _; V# k) Q7 k& X- e: Y6.3 main.c文件代码
3 J& J( R" h4 D( A+ U  X

1. #include "led.h"
   
2. #include "beep.h"
   
3. #include "rtc.h"
   2 p, T# a: Y  [6 y! z; ?* v$ _
4. #include "delay.h"
   
5. #include "sys.h"
   
6. #include "usart.h"
   
7. #include "usmart.h"
   
8. //主函数//
   
9. int main(void)
   * S9 o2 t6 Z! \0 v
10. {  
    
11. u8 t=0;
    
12. delay_init();                                      //延时函数初始化//   
    5 G" r, y; E( ?$ @" V3 ^) U! i
13. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);    //设置中断优先级分组为组2：2位抢占优先级，2位响应优先级//
    ' ^5 v+ o# L; a3 N) N2 I0 t% e
14. uart_init(115200);                                 //串口初始化为115200//
    ' _4 t& b! D  j' B  N) {9 v5 @
15. LED_Init();                                        //LED端口初始化//
    3 R* G4 p) {1 v+ b
16. BEEP_Init();
    % B9 ~' H# [, Z6 L
17. BEEP=1;
    
18. delay_ms(1000);
    
19. BEEP=0;
    
20. LED0=0;                                            //LED0亮//
    
21. usmart_dev.init(SystemCoreClock/1000000);          //初始化USMART//
    
22. RTC_Init();                                        //RTC初始化//   
    : C8 C5 y: S4 V" z$ I' O
23. while(1)
    
24. {            
    
25.   if(t!=calendar.sec)
    / K, k( q9 M5 @% k+ A" |' B' X& r) B; a
26.   {
    
27.    t=calendar.sec;                                  //如果calendar.sec不更新，则t不更新//
    
28.    LED0=!LED0;                                      //每次calendar.sec更新，LED0和LED1交替闪烁//
    6 h3 D) c' Q) D4 @/ F
29.    LED1=!LED1;
    
30.   }
    
31.   delay_ms(10);         
    
32. }  
    ! _9 J: o& X, N) c% R
33. }

复制代码

& N$ x& ]6 I+ C( M最后调试效果如下图所示

/ H+ K0 R( N5 ?# }! R1 V+ [! e

# t" l' I# r* \3 h# N————————————————
版权声明：天亮继续睡

) [0 _5 B9 [5 Y! B) |