主要内容
1） RTC特征与原理；
2 u) S$ N! G8 v. x- E9 X1 P2） BKP备份寄存器特征与原理；
. m, x) y! p% N) r) g. `3） RTC常用寄存器+库函数介绍；
0 y" Q+ c: `2 f; O4） 相关实验代码解读。
实验内容：
) r% t- X* W! J4 G- A因为没有买LCD屏，所以计划通过串口实时更新时间。系统运行后，串口调试助手实时显示当前时间，可通过USMART工具，修改当前时间和闹钟时间，闹钟触发后，蜂鸣器会叫1s时长。板子正常运行时，LED0和LED1交替闪烁。
4 ]9 i" ^5 h  P8 N
1 M0 m" M4 d$ i# ]/ Z1. RTC实时时钟特征与原理
1.1 RTC (Real Time Clock)称实时时钟。RTC是独立的定时器，RTC模块拥有一个连续计数的计数器，在相应的软件配置下，可以提供时钟日历的功能，修改计数器的值可以重新设置当前时间和日期；
& O9 P! F' E2 W4 `5 A
1.2 RTC模块和时钟配置系统(RCC_BDCR寄存器)是在后备区域，即在系统复位或从待机模式唤醒后RTC的设置和时间维持不变。但是在系统复位后，会自动禁止访问后备寄存器和RTC，以防止对后备区域(BKP)的意外写操作。所以在要设置时间之前， 先要取消备份区域（BKP）写保护；
- N: P5 s6 ]/ {( U# v- A
+ {1 C9 }! |2 P7 h1.3 RTC特征如下图所示：
. g5 B4 X- D5 V' a


- S5 T2 Z& u# I5 X8 ^  A1.4 RTC工作原理框图



3 T: {; J$ f* U6 r. l3 U( Q6 I/ I1.4.1 RTC预分频器，RTCCLK除以RTC_PRL的重装载值后，值为分频后的TR_CLK的值，一般情况下TR_CLK设1Hz；
' S* e* k1 {! P  N' z" L/ u+ L1.4.2 RTC预分频器，RTC_DIV装载从RTC_PRL的重装载值，每个RTCCLK周期值减1，至0后会溢出；
1.4.3 待机时维持供电，RTC_CNT，每个TR_CLK周期加1，直至溢出，触发溢出中断；当RTC_ALR所设值等于RTC_CNT实时值时，触发闹钟中断；每个TR_CLK周期产生一次中断。
由原理框图可知RTC的组成：
6 a6 ?4 `: }# b/ n8 H  S- MAPB1接口：用来和APB1总线相连。通过APB1接口可以访问RTC的相关寄存器（预分频值，计数器值，闹钟值）。
2 J0 j8 t+ Y$ y0 B/ X# L9 Q( X3 R: DRTC核心：由一组可编程计数器组成，分两个主要模块：
3 ]6 n$ Q' n: n5 J1）第一个是RTC预分频模块，它可以编程产生最长1秒的RTC时间基TR_CLK。如果设置了秒中断允许位，可以产生秒中断；
! k) }5 G/ y% P3 J! K" C2）第二个是32位的可编程计数器，可被初始化为当前时间。系统时间按TR_CLK周期累加并与存储在RTC_ALR寄存器中的可编程时间相比，当匹配时候如果设置了闹钟中断允许位，可以产生闹钟中断。
- h4 s6 V. f9 T- w+ h: n. S备注：RTC内核完全独立于APB1接口，软件通过APB1接口对RTC相关寄存器访问。但是相关寄存器只在RTC APB1时钟进行重新同步的RTC时钟的上升沿被更新。所以软件必须先等待寄存器同步标志位（RTC_CRL的RSF位）被硬件置1才读。

1.5 RTC时钟源（有三个时钟源可选，一般采用外部时钟）
- K6 L6 b7 h: x, S# n6 l5 K) ?7 r
- G/ k( E! Y& a  G6 F- D

2. BKP备份寄存器
2.1 备份寄存器是42个16位的寄存器，可用来存储84个字节数据；
0 J: z& H: X( S+ N2 I8 S  ^2.2 它们处在备份区域，当VDD电源切断，仍然由VBAT（板子上的纽扣电池）维持供电；
! O% a+ U: q* q2.3 当系统在待机模式下被唤醒，或者系统复位或者电源复位，它们也不会复位；
) p: }8 M5 `5 B/ X2.4 执行以下操作将使能对后备寄存器和RTC访问：
2.4.1 置寄存器RCC_APB1ENR的PWREN和BKPEN位，使能电源和后备时钟；
2.4.2 设置寄存器PWR_CR的DBP位，使能对RTC和后备寄存器的访问。
2.5 BKP备份寄存器常用来保存一些系统配置信息和相关标志位。


% \3 ?* @. N4 o6 T3 f
3. RTC常用寄存器
7 ~8 f8 @+ _4 W5 k* e; p( ~0 X4 ~: d5 X3.1 RTC控制寄存器 (RTC_CRH（高位）， RTC_CRL（低位）)；
: K* d2 E* T4 g# I! F" q5 B; J
- t- X- D, t  [4 h2 K. L/ {



8 m8 M6 y6 P  `3.1.1 修改CRH/CRL寄存器，必须先判断RSF位，确定已经同步；
8 m# P( [. Y9 i. f3.1.2 修改CNT,ALR,PRL的时候，必须先配置CNF位进入配置模式，修改完之后，设置CNF位为0退出配置模式；
3.1.3 同时在对RTC相关寄存器写操作之前，必须判断上一次写操作已经结束，也就是判断RTOFF位是否置位。
3.2 RTC预分频装载寄存器 (RTC_PRLH， RTC_PRLL)；
: z! U' t5 N: p; f( z

5 w- A4 h% R9 c% C/ C
+ X4 {$ G# A3 @5 F3.3 RTC预分频余数寄存器 (RTC_DIVH， RTC_DIVL)；

' ~1 B4 ^' Y, A, h6 \5 @
" x0 {4 R3 i( a" h5 y
+ h- L, d; c& w$ |3.4 RTC计数器寄存器 (RTC_CNTH， RTC_CNTL)；
, Z; J$ g8 |3 q
5 `. G' m* Z5 I) b7 y" \

3.5 RTC闹钟寄存器 (RTC_ALRH， RTC_ALRL)；



, H$ U7 o( _: j4 n3 }3.6 配置RTC寄存器

& P8 d2 R" M7 o5 h

( f. }7 U8 k- g3.7 读RTC寄存器

6 t  Z. b3 s* a; d2 J: y
' y: k: Z: P6 w0 ]1 e" _
4. RTC常用库函数
4.1 STM32提供的官方库函数文件名为：
stm32f10x_rtc.c 和stm32f10x_rtc.h;
0 T  o- [) a' P, M/ N4.2 具体库函数为：

0 a% m1 W" \$ z; {) g% _

1. void RTC_ITConfig(uint16_t RTC_IT, FunctionalStateNewState);
   
2. void RTC_EnterConfigMode(void);
   
3. void RTC_ExitConfigMode(void);
   + X4 Z- d4 V/ g7 I( a* T' X5 ?
4. uint32_t  RTC_GetCounter(void);
   ( \' z9 |$ a' d
5. void RTC_SetCounter(uint32_t CounterValue);
   
6. void RTC_SetPrescaler(uint32_t PrescalerValue);
   
7. void RTC_SetAlarm(uint32_t AlarmValue);
   / P- M8 F" {6 v( {
8. uint32_t  RTC_GetDivider(void);
   3 f) `. ^$ k% D
9. void RTC_WaitForLastTask(void);
   9 t( Y- Q+ @/ b. t4 {2 P' N
10. void RTC_WaitForSynchro(void);
    
11. FlagStatus RTC_GetFlagStatus(uint16_t RTC_FLAG);
    
12. void RTC_ClearFlag(uint16_t RTC_FLAG);
    
13. ITStatus RTC_GetITStatus(uint16_t RTC_IT);
    
14. void RTC_ClearITPendingBit(uint16_t RTC_IT);

复制代码

% w! E) c% O1 I4.3 RTC时钟源和时钟操作函数：

1. void RCC_RTCCLKConfig(uint32_t  CLKSource);      //时钟源选择
   ' Y% Y9 B! X, k# g; O0 h
2. void RCC_RTCCLKCmd(FunctionalState NewState);    //时钟使能

复制代码

5 E" c. F6 X# F' q1 A$ w1 {4.4 RTC配置函数（预分频，计数值）：
; w+ q! Z) A! u
$ q5 y  h* [; l

1. void RTC_SetPrescaler(uint32_t PrescalerValue);  //预分频配置：PRLH/PRLL
   9 W' w! [1 j4 W2 w) v
2. void RTC_SetCounter(uint32_t CounterValue);      //设置计数器值：CNTH/CNTL
   : o! V8 e# h) r: I
3. void RTC_SetAlarm(uint32_t AlarmValue);          //闹钟设置：ALRH/ALRL
   

复制代码

4.5 RTC中断设置函数：

( }, \: i4 ~5 l. H8 J' Z

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

复制代码

! |& X+ W5 X$ s2 b' |4.6 RTC允许配置和退出配置函数：
- L4 D5 G& r2 b% ~- g
7 d; R7 T. B( ~4 E1 f7 k( Y4 U

1. void RTC_EnterConfigMode(void);                                  //允许RTC配置  : CRL位 CNF
   . e$ P3 @; {6 x2 B6 j7 N1 k! O
2. void RTC_ExitConfigMode(void);                                   //退出配置模式 : CRL位 CNF

复制代码

+ l+ E3 P& C& E1 B9 Z4.7 同步函数：

1 z) z5 K1 A3 S) B+ B) L9 Q

1. void RTC_WaitForLastTask(void);                                 //等待上次操作完成：CRL位RTOFF
   
2. void RTC_WaitForSynchro(void);                                  //等待时钟同步：CRL位RSF

复制代码

2 N2 Y3 H: }6 s5 i! y" e9 q' ]: S. A4.8 相关状态位获取清除函数：
* E# J8 I4 p: V2 z0 \: ]8 z, F

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);

复制代码

; }& p9 g7 |3 U. E9 j/ x1.9 其他相关函数（BKP等）
  ]2 [9 _2 @1 h8 G) Z
  J0 m; P/ E$ k8 r9 d& o& ^* n

1. PWR_BackupAccessCmd();                                         //BKP后备区域访问使能
   * H4 \- b  g/ o  e8 I
2. RCC_APB1PeriphClockCmd();                                      //使能PWR和BKP时钟        
   . N. r* |2 [8 X0 _( K5 A
3. RCC_LSEConfig();                                               //开启LSE，RTC选择LSE作为时钟源        
   - w& ~) P' T4 n# H- r
4. PWR_BackupAccessCmd();                                         //BKP后备区域访问使能        
   
5. uint16_t BKP_ReadBackupRegister(uint16_t BKP_DR);              //读BKP寄存器      
   
6. void BKP_WriteBackupRegister(uint16_t BKP_DR, uint16_t Data);  //写BKP

复制代码

! A* K6 X3 F; K/ @4 ^2 p: _0 ]4 P5. RTC一般配置步骤
5.1 使能PWR和BKP时钟：

1. RCC_APB1PeriphClockCmd();

复制代码

5.2 使能后备寄存器访问：
0 ?1 o; l8 v1 O- y; c# g) [2 ~

1. PWR_BackupAccessCmd();

复制代码

5.3
配置RTC时钟源，使能RTC时钟：

1. RCC_RTCCLKConfig();
   4 n' o+ ~' [( x# o7 f" H8 ~) P4 p
2. RCC_RTCCLKCmd();

复制代码

8 y6 t! Z! g% `. B  y如果使用LSE，要打开LSE：RCC_LSEConfig(RCC_LSE_ON)；
% _" Q/ Y5 b8 D) M6 V1 [  ~, ^3 ?
5.4 设置RTC预分频系数：

1. RTC_SetPrescaler();

复制代码

5.5 设置时间：

0 T" k( H/ M# |5 L

1. RTC_SetCounter();

复制代码

5.6 开启相关中断（如果需要）：

1. RTC_ITConfig();

复制代码

5.7 编写中断服务函数：

1. RTC_IRQHandler();

复制代码

" Q4 U! [2 z& p/ ^. M& t5.8 部分操作要等待写操作完成和同步。

1. RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
   
2. RTC_WaitForSynchro();     //等待RTC寄存器同步

复制代码

6. 相关实验代码
5 `8 J; d' N( W6.1 rtc.h头文件代码

% o8 u) @( u! U" G

1. #ifndef __RTC_H
     E  r4 C; ^: G0 K" M  U& ~: u
2. #define __RTC_H     
   
3. #include "stm32f10x.h"
   
4. //定义一个时间结构体//
   % [; r& \3 @: b1 Z
5. typedef struct
   
6. {
   / V: _$ R. [. ?+ l4 d; {1 [
7. vu8 hour;     //时
   
8. vu8 min;      //分
   % G% ]5 Q, ~$ O+ p
9. vu8 sec;      //秒
   - t9 t) G0 v  d- Z
10. vu16 w_year;  //年
    
11. vu8  w_month; //月
      t& i- k) g$ w2 Q% Q, j
12. vu8  w_date;  //日
    ; L7 U8 ~( E& [3 J& T
13. vu8  week;    //周
    
14. }_calendar_obj;      
    
15. extern _calendar_obj calendar;                //日历结构体，已在rtc.c中申明了//
    2 E9 d7 L3 q1 h" K8 d$ B
16. extern u8 const mon_table[12];                //月份日期数据表，常数
    
17. void Disp_Time(u8 x,u8 y,u8 size);            //在制定位置开始显示时间
    
18. void Disp_Week(u8 x,u8 y,u8 size,u8 lang);    //在指定位置显示星期
    . R; \# \: d6 B! A' C2 f$ e
19. u8 RTC_Init(void);                            //初始化RTC,返回0,失败;1,成功;
    
20. u8 Is_Leap_Year(u16 year);                    //平年,闰年判断，返回1是，0不是
    
21. u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);  //闹钟设定
    
22. u8 RTC_Get(void);                             //获取时间   
    7 r$ e4 b4 y$ M6 Z; z9 B, y+ G. L) J
23. u8 RTC_Get_Week(u16 year,u8 month,u8 day);    //获取日期，返回0成功，其他失败
    ) y8 b. F. X6 Q/ I
24. u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);        //设置时间   
    1 U+ z& q0 p- n2 B8 m7 p
25. #endif

复制代码

  @( O* O8 b$ M  V6 Z6.2 rtc.c文件代码
5 B7 V' s) W6 Y+ e1 O
: ]) _4 s8 c9 `

1. #include "beep.h"
   5 T" B. R3 u1 m; i8 S3 d
2. #include "rtc.h"  
   
3. #include "sys.h"
   # z) U& h% f  z4 C7 q$ p
4. #include "delay.h"
   
5. #include "usart.h"
   / t/ E7 w" a- ^: h1 {+ g8 J! F
6. //时钟结构体//
     r! v! ]( z& }' E  E
7. _calendar_obj calendar;                                      
   
8. static void RTC_NVIC_Config(void)
     R9 q9 x( V6 t; c
9. {
   1 s( a8 H' u# s2 G5 }, j
10. NVIC_InitTypeDef NVIC_InitStructure;
    
11. NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;             //RTC全局中断
    
12. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  //先占优先级1位,从优先级3位
    
13. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;         //抢占优先级0位,从优先级4位
    2 X+ P, x/ v; I/ K! C2 E
14. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            //使能该通道中断
    
15. NVIC_Init(&NVIC_InitStructure);  
    ' S" I2 X3 c% E! b! Q. B7 i
16. }
    
17. //实时时钟配置
    
18. //初始化RTC时钟,同时检测时钟是否工作正常
    * V- N7 ?4 r; f3 d/ {1 \
19. //BKP->DR1用于保存是否第一次配置的设置
    
20. //返回0:正常; 其他:错误代码
    8 \8 t" x) E7 Q/ {% V, p
21. u8 RTC_Init(void)
    
22. {
    
23. //检查是不是第一次配置时钟//
    
24. u8 temp=0;
    ' \. u) U: w& I# n1 A& d% B
25. //*****第一步*****//
    
26. //电源控制PWR，当主电源VDD掉电后，通过VBAT脚为实时时钟(RTC)和备份寄存器(BKP)提供电源//
    & l9 _6 v" \5 n+ Q
27. //使能PWR和BKP外设时钟//  
    8 P2 N. U# I/ R: m  a; C5 L
28. RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
      }9 Z5 l6 c5 g2 ~6 a
29. //*****第二步*****//
    4 J+ a4 o/ x# H2 v9 i8 n! [
30. //使能后备寄存器访问，位带操作，实际对电源控制寄存器PWR_CR的第八位DBP写1，允许写入RTC和BKP//
    + p4 H7 Q! j* P$ g- {- C4 a+ y
31. PWR_BackupAccessCmd(ENABLE);
    
32. //读取BKP_DR1寄存器0~15位的值，判断是否与0x5050一致//
    
33. if (BKP_ReadBackupRegister(BKP_DR1) != 0x5050)  
    - S, A, J/ H5 G
34.   {
    
35.    //如果不一致，说明第一次配置，则进行如下操作//   
    % J6 k/ F5 L0 J$ {% _& O
36.    BKP_DeInit();                           //复位备份区域//  
    # v" J7 i! f6 X0 O% y
37.    RCC_LSEConfig(RCC_LSE_ON);              //设置外部低速晶振(LSE),使用外设低速晶振//
    - e& q2 Q. N: e( J. C
38.    //备份域控制寄存器RCC_BDCR，位1，LSERDY为0时未就绪，为1时就绪//
    
39.    while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET&&temp<250)
    
40.     {
    
41.      temp++;
    " Q: @. ~# y8 q+ `( P
42.      delay_ms(10);
    
43.     }
    % G% y; x; e3 L6 `- J8 G
44.    if(temp>=250)return 1;                   //初始化时钟失败,晶振有问题，结束u8 RTC_Init(void)函数//
    # T3 \6 i. \' _
45.    //若temp＜250，则继续//
    
46.    //*****第三步*****//   
    ; ^" d6 u1 K- N% D1 r9 F0 R/ \
47.    RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);  //设置RTC时钟(RTCCLK),选择LSE作为RTC时钟//   
    7 Q( l. K  K$ o2 A$ a0 M
48.    RCC_RTCCLKCmd(ENABLE);                   //使能RTC时钟//  
    
49.    //*****配置RTC寄存器开始*****//   
    
50.    //*****第六步*****//
    
51.    //RTC控制寄存器低位(RTC_CRL)，位5，RTOFF为0时仍在写操作，为1时写操作完成，该函数循环执行，直到RTOFF为1//
    4 H6 G% S' z$ g5 ]
52.    RTC_WaitForLastTask();   
    3 s0 T. v4 n& _8 H! q, O# i
53.    //RTC控制寄存器低位(RTC_CRL)，位3，RSF为0时寄存器未同步，为1时寄存器同步，该函数循环执行，直到 RSF 为1//
    
54.    //因为修改CRH/CRL寄存器，必须先判断RSF位，确定已经同步//  
    
55.    RTC_WaitForSynchro();                     
    7 k. }% p  E% v" s* o3 C- E
56.    RTC_ITConfig(RTC_IT_SEC | RTC_IT_ALR, ENABLE);     //对控制寄存器高位(RTC_CRH)操作，使能RTC秒中断//
    
57.    RTC_WaitForLastTask();                             //等待最近一次对RTC寄存器的写操作完成//   
    
58.    //*****第四步和第五步*****//
    / H. Q' z  m' \: y% \
59.    //RTC控制寄存器低位(RTC_CRL)，位4，CNF置1，进入配置模式//
    9 c8 P; U7 `$ M; l; y
60.    RTC_EnterConfigMode();                    
    $ J1 Z& p' \: n/ Y( }$ y$ b5 |- ^
61.    RTC_SetPrescaler(32767);                           //设置RTC预分频的值//
    
62.    RTC_WaitForLastTask();                             //等待最近一次对RTC寄存器的写操作完成//
    ! @$ e7 s. j% Y8 U- G
63.    RTC_Set(2015,1,14,17,42,55);                       //设置时间，纯c语言代码//
    9 ]. h* T5 R$ h2 }+ d6 X
64.    //RTC控制寄存器低位(RTC_CRL)，位4，CNF置0，退出配置模式//
    : d9 \7 \  T: \( y* j
65.    RTC_ExitConfigMode();                     
    
66.    //写入BKP_DR1寄存器0~15位的值//
    
67.    BKP_WriteBackupRegister(BKP_DR1, 0X5050);          //向指定的后备寄存器中写入用户程序数据//
    
68.   }
    2 E) l% T' y" e! Q! V
69. else                                                 //如果，不是第一次配置，系统继续计时//
    ! c' X+ T* z9 W
70.   {
    0 x7 y# r" B5 J" k5 I4 [0 \- O' u: |
71.     RTC_WaitForSynchro();                             //等待寄存器同步//
    
72.     RTC_ITConfig(RTC_IT_SEC | RTC_IT_ALR, ENABLE);         
    
73.     RTC_WaitForLastTask();                            //等待最近一次对RTC寄存器的写操作完成//
    
74.   }
    & Z9 c* T& m  l5 D' b, ]
75. RTC_NVIC_Config();                                   //RCT中断分组设置//               
    & ]# x9 S5 r" ^3 [( D
76. RTC_Get();                                           //更新时间//
    
77. return 0;                                            //ok//
    3 Q( H+ E- x( E) t& f3 y
78. }           
    
79. //*****第七步，编写中断服务函数*****//
    ) T& B2 \& W# g1 x+ _
80. //秒中断发生，更新时间，闹钟中断发生，更新时间并向串口发送时间//
    / h# r* l" @3 w: a1 i
81. void RTC_IRQHandler(void)
    
82. {   
    " r# `% A% a  E5 {, A' P
83. if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)              //判断闹钟中断是否发生//
    1 O8 C2 |# x" d1 \$ A; {( M8 i
84. {
    
85.   //RTC控制寄存器低位(RTC_CRL)，位1，ALRF置0，清闹钟中断//
    
86.   RTC_ClearITPendingBit(RTC_IT_ALR);           
    
87.   RTC_Get();                                          //更新时间//  
    : t( \) O$ @; H2 e" a
88.   printf("闹钟时间:%d-%d-%d %d:%d:%d\n",calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
    
89.   BEEP=1;
    
90.   delay_ms(1000);
    $ X. P* j  j, h* p4 `  H$ z* ?, N
91.   BEEP=0;      
    
92.   }   
    
93. if (RTC_GetITStatus(RTC_IT_SEC) != RESET)            //判断秒钟中断是否发生//
    
94. {      
    ' [# J$ q( t% F- D2 K8 M/ \* O5 S$ c
95. RTC_Get();
    7 W0 z, q5 l) ?# y. L& @0 N
96. printf("闹钟时间:%d-%d-%d %d:%d:%d\n",calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);
    ; h: F$ o2 K% [
97. }   
    
98. 
    
99. RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);         //清闹钟中断和溢出标志//
    + @: F+ G5 e* C# l5 e+ j2 I6 Y
100. RTC_WaitForLastTask();                               //等待最近一次对RTC寄存器的写操作完成//   
     ( g4 j: l4 w: D, n: @
101. }
     1 f" R4 ^6 U# w
102. //判断是否是闰年函数，能被4整除，但不能被100整除的年是闰年，能被400整除的年是闰年//
     * l4 X; k- Y+ h
103. //月份        1  2  3  4  5  6  7  8  9  10 11 12
     
104. //闰年        31 29 31 30 31 30 31 31 30 31 30 31
     : x0 g. q3 P3 [
105. //非闰年/平年 31 28 31 30 31 30 31 31 30 31 30 31
     
106. //输入:年份
     % S, S+ h- O) w7 i
107. //输出:该年份是不是闰年.1,是.0,不是
     4 a# V: M/ d) ?& O
108. u8 Is_Leap_Year(u16 year)
     6 s/ u6 Q! x( v7 s% `
109. {     
     
110. if(year%4==0)                              //判断是否能被4整除，能则继续；不能则不是闰年，且返回0//
     7 J! H. c7 y$ }6 n7 e
111. {
     
112.   if(year%100==0)                           //判断是否能被100整除,能则继续；不能则是闰年，且返回1//
     , `2 L, d7 f' [4 [) @
113.   {
     
114.    if(year%400==0)return 1;                 //判断是否能被400整除，能则是闰年，且返回1；不能则不是闰年，且返回0//   
     
115.    else return 0;   
       }, P3 q7 }1 r: ?+ y$ R; {8 ?: x$ N& u
116.   }else return 1;   
     . \" W* U, n+ Y; {
117. }else return 0;
     . o2 P+ |1 C5 t- N
118. }        
     + G7 u% i; g+ ?' ^8 h' N
119. //设置时钟，把输入的时钟转换为秒钟，以1970年1月1日为基准，1970~2099年为合法年份//
     ( X8 U/ U; v0 L: u" x' H
120. //并将值传至RTC计数器寄存器高位(RTC_CNTH)和RTC计数器寄存器低位(RTC_CNTL)中//
     0 Q" m: H! C* n+ c' \- D
121. //返回值:0,成功;其他:错误代码//           
     9 T8 Q7 m! T: D6 U* U
122. //平年的月份日期表，闰年的话，就把28改29//
     % H$ Q/ w, }+ G4 G# y7 X
123. const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
       ]8 Q8 u  n/ k" A1 p- F* F' \
124. u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
     
125. {
     
126. u16 t;
     
127. u32 seccount=0;
     9 J' K- ]/ ^/ J& E
128. if(syear<1970||syear>2099)return 1;               //如果年份不在1970~2099年之内，则报错，函数停止//
     ' Y7 H0 f1 u+ j' t" k2 v; r  n
129. for(t=1970;t<syear;t++)                           //把所有年份的秒钟相加//
     ' r! A0 `! G) y
130. {
     
131.   if(Is_Leap_Year(t))seccount+=31622400;           //闰年的秒钟数//
     
132.   else seccount+=31536000;                         //平年的秒钟数，少一天//
     
133. }
     
134. smon-=1;
     
135. for(t=0;t<smon;t++)                               //把前面月份的秒钟数相加//
     2 o" `& m8 f5 I( L. A
136. {
     
137.   seccount+=(u32)mon_table[t]*86400;               //月份秒钟数相加//
     
138.   if(Is_Leap_Year(syear)&&t==1)seccount+=86400;    //闰年2月份增加一天的秒钟数 //   
     8 h% Q4 H- |8 l) ^3 |4 l/ x
139. }
     - l& r0 I  l6 n1 |! U! B( |
140. seccount+=(u32)(sday-1)*86400;                    //把前面日期的秒钟数相加//
     0 r1 E8 w4 i5 G* k3 [, C+ `
141. seccount+=(u32)hour*3600;                         //小时秒钟数//
     . c- I% {2 n; G- Q% w
142. seccount+=(u32)min*60;                            //分钟秒钟数//
     8 c* E( t0 L* ^2 Z% O1 T! V
143. seccount+=sec;                                    //最后的秒钟加上去//
     
144. //以上，已经把某年某月某日某时某分某秒的时间，用秒计数起来//
       c  \1 d/ b( J4 o. f* C7 }
145. RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE); //使能PWR和BKP外设时钟//  
     ! E  [! h& F1 K
146. PWR_BackupAccessCmd(ENABLE);                                             //使能RTC和BKP访问//
     7 S. c) _) L$ a/ J/ c4 z  L
147. RTC_SetCounter(seccount);                                                //设置RTC计数器的值//
     
148. RTC_WaitForLastTask();   
     7 O' q. E* [! z
149. return 0;     
     0 b4 b7 o' u+ `: A  c$ L" d
150. }
     0 i8 o/ d; y# J- a% X6 O1 x1 I* B; q
151. //初始化闹钟，以1970年1月1日为基准，1970~2099年为合法年份，syear,smon,sday,hour,min,sec：年月日时分秒//   
     + l$ b% ]2 I5 Q
152. //返回值:0,成功;其他:错误代码.//
     
153. u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
     
154. {
     ) t3 Y, F. c. r8 a* C2 [
155. u16 t;
     + g+ k& k2 s5 K9 e, v
156. u32 seccount=0;
     3 m' D) H' E; f: a+ Y0 ]
157. if(syear<1970||syear>2099)return 1;   
     
158. for(t=1970;t<syear;t++)                        //把所有年份的秒钟相加//
     7 }( \2 B6 A: {7 P9 Z  A, a# M
159. {
     
160.   if(Is_Leap_Year(t))seccount+=31622400;        //闰年的秒钟数//
     / ]' p; F5 S; |; p
161.   else seccount+=31536000;                      //平年的秒钟数//
     
162. }
     ; L2 W; c5 L6 y5 ~$ @( o7 [) o+ ~7 v
163. smon-=1;
     : e- X0 L2 Y$ o: m
164. for(t=0;t<smon;t++)                            //把前面月份的秒钟数相加//
     
165. {
     , P% N3 d! E0 P4 c' q" _/ Q0 w
166.   seccount+=(u32)mon_table[t]*86400;            //月份秒钟数相加//
     
167.   if(Is_Leap_Year(syear)&&t==1)seccount+=86400; //闰年2月份增加一天的秒钟数//   
     
168. }
     
169. seccount+=(u32)(sday-1)*86400;                 //把前面日期的秒钟数相加//
     
170. seccount+=(u32)hour*3600;                      //小时秒钟数//
     
171.     seccount+=(u32)min*60;                      //分钟秒钟数//
     / H! |$ @: Z9 O- o  w  ]
172. seccount+=sec;                                 //最后的秒钟加上去//      
     3 I0 |# {' h6 Z; z# W
173. //设置时钟//
     % ~, B; O3 X/ R. S, a6 {
174. RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);  //使能PWR和BKP外设时钟//   
     1 _! M4 A4 Y8 ?2 a" U4 |" X
175. PWR_BackupAccessCmd(ENABLE);                                              //使能RTC和BKP访问//  
     
176. RTC_SetAlarm(seccount);                                                   //设置RTC闹钟寄存器值//
     
177. RTC_WaitForLastTask();   
     
178. return 0;     
     
179. }
     
180. //得到当前的时间，将秒转换成年月日时分秒//
     
181. //返回值:0,成功;其他:错误代码.//
     
182. u8 RTC_Get(void)
     
183. {
     ) y4 i5 k* i6 {3 {. B, o
184. static u16 daycnt=0;
     ; P+ i- K; B3 g& v4 g) M& ]4 L% |+ O
185. u32 timecount=0;
     : T5 Q  A) N9 _8 i. t
186. u32 temp=0;
     & n. Y. U: T. |. n) H
187. u16 temp1=0;   
     
188.   timecount=RTC_GetCounter();   //获取16位RTC计数器寄存器高位RTC_CNTH和低位RTC_CNTL的值，返回32位数据//
     
189.   temp=timecount/86400;         //得到天数//
     
190. if(daycnt!=temp)               //超过一天了
     
191. {   
     $ E+ Z% b4 n$ I; b
192.   daycnt=temp;
     
193.   temp1=1970;                   //从1970年开始//
     - o; |" a4 y5 K( H
194.   while(temp>=365)              //当temp≥365天时//
     - q) L' f3 e" W
195.   {     
     5 L  |3 w  ~5 b
196.    if(Is_Leap_Year(temp1))      //闰年判断，闰年366天，平年365天//
     / m) f* a5 E+ `* B/ H) T. s
197.    {
     # w7 Q9 g6 v2 G& [% h' k- W6 W
198.     if(temp>=366)
     $ n2 R/ S3 e' u; w6 \0 @
199.      temp-=366;                 //闰年，temp减366天//
     * J" I# T" Y1 `; u4 G
200.     else break;                 //当年是闰年，且是365天时，跳出循环//
     
201.    }
     - i' d0 ^# i. a1 k1 D9 v
202.    else  temp-=365;             //平年，temp减365天//
     
203.    temp1++;                     //平年，temp1加1年//
     9 Y5 `0 }- G, v$ u. i. H  O
204.   }   
     
205.   calendar.w_year=temp1;        //得到年份temp1//
     ' ?8 H4 |4 Z8 E4 W. M$ b/ h
206.   temp1=0;                      //temp1至0，开始计算月份//
     2 r3 w7 f* P, Z- L3 ?- I
207.   while(temp>=28)               //当28≤temp＜365天时//
     ! M5 f7 M# z& i4 N/ }* X- V6 p
208.   {
     
209.    //temp1从0至11分别对应1月到12月//
     
210.    if(Is_Leap_Year(calendar.w_year)&&temp1==1)         //当是闰年，且为2月份时，执行下面语句//
     2 {: A& U- M2 J2 J2 z' f4 I9 k
211.    {
     0 v/ G) S- X% h% f2 {* H* k
212.     if(temp>=29)temp-=29;                              
     - t9 S6 f; K7 e  o2 `' [* f
213.     else break;
     
214.    }
     8 ~, H8 o% m9 q+ t! x9 p
215.    else                                                //平年，执行else//
       j' P  Q; t" W3 b& c  _9 w
216.    {
     
217.     if(temp>=mon_table[temp1])                        
     
218.      temp-=mon_table[temp1];                          
     
219.     else break;
     
220.    }
     
221.    temp1++;  
     3 d" u/ n1 M4 j) f8 i8 M
222.   }
     
223.   calendar.w_month=temp1+1;                            //得到月份//
     
224.   calendar.w_date=temp+1;                              //得到日期//
     
225. }
     
226. temp=timecount%86400;                                 //得到秒钟数//      
     2 d' u8 o! X, G* b* Z$ {
227. calendar.hour=temp/3600;                              //小时//
     6 Z: |3 E3 b5 z, x& b
228. calendar.min=(temp%3600)/60;                          //分钟//
     + a) m7 y9 {# S  g, V
229. calendar.sec=(temp%3600)%60;                          //秒钟//
     2 I, u4 l% s7 P2 Z6 b$ A
230. calendar.week=RTC_Get_Week(calendar.w_year,calendar.w_month,calendar.w_date); //获取星期//   
     + A% h: x* @7 c; m5 W: w
231. return 0;
     ' ~9 s' ^4 Q  b6 K
232. }  
     
233. //获得现在是星期几
     
234. //功能描述:输入公历日期得到星期(只允许1901-2099年)
     ) h+ [9 e# c0 P/ f3 [
235. //输入参数：公历年月日
     
236. //返回值：星期号  
     
237. u8 const table_week[12]={0,3,3,6,1,4,6,2,5,0,3,5};        //月修正数据表?//
     ! e& h2 B+ y- y
238. u8 RTC_Get_Week(u16 year,u8 month,u8 day)
     
239. {
     
240. u16 temp2;
     , H0 E. D% R! R5 u9 b0 o0 h# {
241. u8 yearH,yearL;
     
242. yearH=year/100; yearL=year%100;
     
243. //如果为21世纪,年份数加100//  
     
244. if (yearH>19)
     
245.   yearL+=100;
     
246. //所过闰年数只算1900年之后的//  
     
247. temp2=yearL+yearL/4;
     - P( `" z. T& t
248. temp2=temp2%7;
     
249. temp2=temp2+day+table_week[month-1];
     
250. if (yearL%4==0&&month<3)temp2--;
     ; }% }% X  \& j3 L+ V9 M0 m
251. return(temp2%7);
     $ \! ^; {# Z6 A( _
252. }  

复制代码

6.3 main.c文件代码

( R% ?- ^0 P, ]  j1 w7 x9 K

1. #include "led.h"
   2 C  _! M3 j: `) b+ A, X
2. #include "beep.h"
   
3. #include "rtc.h"
   : d# \- X" |$ i
4. #include "delay.h"
   
5. #include "sys.h"
   
6. #include "usart.h"
   
7. #include "usmart.h"
   ( ~0 C+ ~& Y$ e- \2 P, E6 `
8. //主函数//
   ) L: T. B3 V* K7 l" M( U
9. int main(void)
   ) y" v/ ~+ z0 d1 _1 V! `
10. {  
    
11. u8 t=0;
    
12. delay_init();                                      //延时函数初始化//   
    # Y0 g% H$ a  T3 I& i1 ?9 B
13. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);    //设置中断优先级分组为组2：2位抢占优先级，2位响应优先级//
    
14. uart_init(115200);                                 //串口初始化为115200//
    : W" n( e7 I$ m9 h' x4 t
15. LED_Init();                                        //LED端口初始化//
    
16. BEEP_Init();
    
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初始化//   
    
23. while(1)
    
24. {            
    1 E# V& j4 m* x+ d- \
25.   if(t!=calendar.sec)
    ' I4 B  M( `9 O$ s; A, r5 u3 F
26.   {
    + C# p0 W; q" D4 [" x! g0 O. z
27.    t=calendar.sec;                                  //如果calendar.sec不更新，则t不更新//
    
28.    LED0=!LED0;                                      //每次calendar.sec更新，LED0和LED1交替闪烁//
    ! E- I3 a1 J5 X7 O) |
29.    LED1=!LED1;
    3 u! t& F& j% d" A7 h* B0 P
30.   }
    1 e' {# K) w2 m. O3 q5 L6 g) w
31.   delay_ms(10);         
    
32. }  
    # w+ Y& f, i7 d. _$ ^
33. }

复制代码

最后调试效果如下图所示
! }9 b# e  A9 G0 ~  o8 o6 {5 V* A
  f: t8 |: _$ f+ x" n

( h( n/ {5 H7 E8 h8 C————————————————
. d! a& M; W$ P( Q版权声明：天亮继续睡

6 Z0 z5 D7 ]5 h2 u2 r
) d7 n; f1 q" D& K