一、RTC
RTC是什么？
RTC(Real Time Clock):实时时钟,是指可以像时钟一様输出实际时间的电子设备，一般会是集成电路，因此也称为时钟芯片。总之，RTC只是个能靠电池维持运行的32位定时器，并不像实时时钟芯片，读出来就是年月日。RTC就只一个定时器而已，掉电之后所有信息都会丢失，因此我们需要找一个地方来存储这些信息，于是就找到了备份寄存器（BKP）。因为它掉电后仍然可以通过纽扣电池供电，所以能时刻保存这些数据。 STM32 的实时时钟（RTC）是一个独立的定时器。 STM32 的 RTC 模块拥有一组连续计数的计数器，在相应软件配置下，可提供时钟日历的功能。修改计数器的值可以重新设置系统当前的时间和日期。
2 W9 P5 F# Y/ B2 l( ~6 z
8 @: s2 X  G8 I1 K' r2 L2 l5 p- fRTC和后备寄存器通过一个开关供电，在VDD有效时该开关选择VDD供电，否则由VBAT引脚供电。后备寄存器(10个16位的寄存器)可以用于在关闭VDD时，保存20个字节的用户应用数据。 RTC和后寄存器不会被系统或电源复位源复位；当从待机模式唤醒时，也不会被复位。实时时钟具有一组连续行的计数器，可以通过适当的软件提供日历时钟功能，还具有闹钟中断和阶段性中断功能。 RTC的驱动时钟可以是一个使用外部晶体的32.768kHz的振荡器、内部低功耗RC振荡器或高速的外部时钟经128分频。内部低功耗RC振荡器的典型频率为40kHz。为补偿天然晶体的偏差，可以通过输出一个512Hz的信号对RTC的时钟进行校准。 RTC具有一个32位的可编程计数器，使用比较寄存器可以进行长时间的测量。有一个20位的预分频器用于时基时钟，默认情况下时钟为32.768kHz时，它将产生一个1秒长的时间基准。

, y3 k! d% e1 i& t6 e7 a1 v因为RTC 模块和时钟配置系统(RCC_BDCR 寄存器)是在后备区域，即在系统复位或从待机模式唤醒后 RTC 的设置和时间维持不变。但是在系统复位后，会自动禁止访问后备寄存器和 RTC，以防止对后备区域(BKP)的意外写操作。所以在要设置时间之前， 先要取消备份区域（BKP）写保护，我们就先看一下，RTC的工作过程。

- m  F2 x4 B! w% |RTC工作过程及寄存器

- n1 r- V, O/ I3 B& t6 w
图中浅灰色的部分都是属于备份域的,在VDD掉电时可在VBAT的驱动下继续运行.这部分仅包括RTC的分频器,计数器,和闹钟控制器.若VDD电源有效,RTC可以触发RTC_Second(秒中断)、RTC_Overflow(溢出事件)和RTC_Alarm(闹钟中断).从结构图可以看到到,其中的定时器溢出事件无法被配置为中断.如果STM32原本处于待机状态,可由闹钟事件或WKUP事件(外部唤醒事件,属于EXTI模块,不属于RTC)使它退出待机模式.闹钟事件是在计数器RTC_CNT的值等于闹钟寄存器RTC_ALR的值时触发的.
/ s. k  E- N; K: X
4 K: `7 M# Z3 Y: d8 J  }7 E* ^4 c% y因为RTC的寄存器是属于备份域,所以它的所有寄存器都是16位的.它的计数RTC_CNT的32位由RTC_CNTL和RTC_CNTH两个寄存器组成,分别保存计数值的低16位和高16位.在配置RTC模块的时钟时,把输入的32768Hz的RTCCLK进行32768分频得到实际驱动计数器的时钟TR_CLK = RTCCLK/37768 = 1Hz,计时周期为1秒,计时器在TR_CLK的驱动下计数,即每秒计数器RTC_CNT的值加1(常用)
' z  x- R+ w* J2 L7 U
$ `  x* `0 l5 K3 H% J2 i7 ^9 URTC只是一个时钟，但与RTC相连的有两个系统时钟，一个是APB1接口的PCLK1另一个是RTC时钟。这样，RTC功能也就分为两个部分：第一部分，APB1接口部分，与APB1总线相连，MCU也就是通过这条总线对其进行读写操作。另一部分，RTC核，由一系列可编程计数器组成，这部分又再细分为两个组件：预分频模块与32位可编程计数器。预分频模块用来产生最长为1秒的RTC时间基准，而32位的可编程的计数器可被初始化为当前的系统时间。

% `; x, y: D$ G  J1 ?( v% ]RTC核心模块
6 E* d' Z6 H$ g9 l
8 Y. a, F* y6 `第一模块：RTC的预分频模块（可编程产生1s的RTC时间基准TR_CLK）20位的预分频器，如果在 RTC_CR 寄存器中设置了相应的允许位，则在每个TR_CLK 周期中 RTC 产生一个中断(秒中断)。

第二模块：32位计数器（可初始化当前系统时间），可被初始化为当前的系统时间，一个 32 位的时钟计数器，按秒钟计算，可以记录 4294967296 秒，约合 136 年 左右，作为一般应用，这已经是足够了的。（RTC_CNT是一个32位寄存器,可存储的最大值为(232-1),这样的话就是在232秒之后溢出,大概换算为:Time = 2 32 /365/24/60/60大约等于136年）感兴趣的可以看一下UNIX时间戳；

6 T% P9 J" D4 _闹钟寄存器RTC_ALR：
# ?/ S7 D. O9 n1 @& E
# l# m% q3 D. l& C% g- a( IRTC 还有一个闹钟寄存器 RTC_ALR，用于产生闹钟。系统时间按 TR_CLK 周期累加并与存储在 RTC_ALR 寄存器中的可编程时间相比较，如果 RTC_CR 控制寄存器中设置了相应允许位，比较匹配时将产生一个闹钟中断 由于RTC内核完全独立与APB1接口，软件只能通过APB1的接口访问RTC的预分频值、计数器值和闹钟值，相关的寄存器值是在APB1时钟进行重新同步的RTC上升沿被更新，所以在读取RTC寄存器曾经被禁止的APB1接口前，必须等待RTC_CRL寄存器的PSF位被置1。
需要了解一下RTC的原理，先来看一下相关的寄存器。
/ G: q& O6 P- s5 z9 ~6 S2 hRTC 的控制寄存器

RTC_CRL：

/ K. V/ F) E7 D* E0位：进入秒中断后，可判断该位为1决定发生了中断，必须写0清除

3位：寄存器同步标志位，没有同步之前，不被允许修改RTC_CRT/CRL的值，必须先判断该位为1时，同步了。
; y/ W: U0 h. Q$ q
4位：在修改RTC_CNT/RTC_ALR/RTC_PRL的值前，必须置该位为1，进入配置模式。
& X2 e7 ?5 a2 l9 a
: p1 b5 X) D  \6 R0 [: ]5位：RTC操作位，由硬件操作，软件只读，判断该位为1时，表示上一次操作已经完成，才可进行下一次操作。
. Z9 D, m: E$ ]1 c0 l
RTC_CRH：0-3位置1，允许溢出中断、闹钟中断、秒中断。

6 _4 R" f9 W" F: Q9 S8 w; o- ~RTC 总共有 2 个控制寄存器 RTC_CRH 和 RTC_CRL，且两个都是 16 位的。

8 T4 h. D9 W6 `, y5 |
. Y7 o& @/ V; `) X* p
该寄存器用来控制中断的，我们本次实验将要用到秒钟中断，所以在该寄存器必须设置最低位为 1，以允许秒钟中断。
' N# g& z: [8 B$ e

/ C6 ?6 X" i9 k# m
本次我们用到的是该寄存器的 0、3~5 这几个位。
/ U$ k& c3 R; ^% m4 _+ t
第 0 位是秒钟标志位，我们在进入闹钟中断的时候，通过判断这位来决定是不是发生了秒钟中断。然后必须通过软件将该位清零（写0）。
第 3 位为寄存器同步标志位，我们在修改控制寄存器 RTC_CRH/CRL 之前，必须先判断该位，是否已经同步了，如果没有则等待同步，在没同步的情况下修改 RTC_CRH/CRL 的值是不行的。
: f3 \9 }" d0 |* M) W) V! k- `第 4 位为配置标位，在软件修改 RTC_CNT/RTC_ALR/RTC_PRL 的值的时候，必须先软件置位该位，以允许进入配置模式。
9 D' R$ a% o4 o* D4 e第 5 位为 RTC 操作位，该位由硬件操作，软件只读。通过该位可以判断上次对 RTC 寄存器的操作是否完成，如果没有，我们必须等待上一次操作结束才能开始下一次操作。

+ U0 g9 O1 ~9 ]6 {# P4 zRTC 预分频装载寄存器
9 ?* ~* K: Z2 s0 q5 l0 @- g) m
% ^( P7 J4 c6 J  o6 `TRC_PRLH：低4位有效，存放PRL的19-16位
8 g: o8 c1 M2 Z' V% p* _" g5 ]
0 S8 ^' d5 e: `' s. nTRC_PRLL：存放PRL的前16位
5 B! A4 j# d% F' |' j9 Q: m% X
3 z. p  H' \% h8 i( D: e3 }也有 2 个寄存器组成， RTC_PRLH 和RTC_PRLL。这两个寄存器用来配置 RTC 时钟的分频数的，比如我们使用外部 32.768K 的晶振作为时钟的输入频率，那么我们要设置这两个寄存器的值为 32767，以得到一秒钟的计数频率。
' o9 `3 G1 e, C$ ]5 a* n! gRTC_PRLH 的各位描述如图 20.1.4 所示：



( a, n4 D0 d$ W1 V% D
  U9 h8 l: L6 |0 S2 N; |$ E$ C从图 20.1.4 可以看出， RTC_PRLH 只有低四位有效，用来存储 PRL 的 19~16 位。而 PRL的前 16 位，存放在 RTC_PRLL 里面，寄存器 RTC_PRLL 的各位描述如图 20.1.5 所示：



; S: P; G6 @9 w
RTC 预分频器余数寄存器

6 b2 \& F9 `! E+ V! @( y, Y该寄存器也有 2 个寄存器组成 RTC_DIVH 和 RTC_DIVL，这两个寄存器的作用就是用来获得比秒钟更为准确的时钟，比如可以得到 0.1 秒，或者 0.01 秒等。该寄存器的值自减的，用于保存还需要多少时钟周期获得一个秒信号。在一次秒钟更新后，由硬件重新装载。这两个寄存器和 RTC 预分频装载寄存器的各位是一样的。
) K: s- [* [  C* ]6 b  N: u
; @. r3 ?. c0 y5 y% n2 WRTC 计数器寄存器 RTC_CNT

2个16位寄存器组成，共32位RTC_CNTH、RTC_CNTL：用来存放秒钟值

$ w( R3 S& |) M' R% B: T3 m% B( h该寄存器由 2 个 16位的寄存器组成 RTC_CNTH 和 RTC_CNTL，总共 32 位，用来记录秒钟值（一般情况下）。此两个计数器也比较简单，我们也不多说了。注意一点，在修改这个寄存器的时候要先进入配置模式。
5 b8 b' X3 E, [- N3 R
RTC 闹钟寄存器

/ [0 h  K2 B0 ]6 a9 PRTC_ALRH、RTC_ALRL：

0 x  c  _8 ~: F' Y- e) U  N用来记录闹钟产生的时间，当RTC_CNT与RTC_ALR的值相等时，则产生闹钟中断，条件是使能了中断且进入了寄存器的配置模式了。

& P% L* g) Y) Z6 o3 r2 }0 X该寄存器也是由 2 个 16 为
的寄存器组成 RTC_ALRH 和 RTC_ALRL。总共也是 32 位，用来标记闹钟产生的时间（以秒为单位），如果 RTC_CNT 的值与 RTC_ALR 的值相等，并使能了中断的话，会产生一个闹钟中断。该寄存器的修改也要进入配置模式才能进行。

STM32 的备份寄存器

$ F2 y2 y* C0 p8 L& H执行如下操作对备份寄存器和RTC进行访问

1）设置寄存器RCC_APB1ENR的PWREN和BKPEN位打开电源和后备时钟
& \* [3 P  }8 E) b* B# h
1 L* L5 a9 R5 N  D& M2）电源后备寄存器（PWR_CR）的DBP位使能对后备寄存器和RTC的访问。
1 \( {0 {' }% M% ^9 i; H
备份寄存器是 42 个 16 位的寄存器（大容量），可用来存储 84 个字节的用户应用程序数据。他们处在备份域里，当 VDD 电源被切断，他们仍然由 VBAT （备用电源）维持供电。即使系统在待机模式下被唤醒，或系统复位或电源复位时，他们也不会被复位。此外， BKP 控制寄存器用来管理侵入检测和 RTC 校准功能，这里我们不作介绍。复位后，对备份寄存器和 RTC 的访问被禁止，并且备份域被保护以防止可能存在的意外的写操作。执行以下操作可以使能对备份寄存器和 RTC 的访问：
1）通过设置寄存器 RCC_APB1ENR 的 PWREN 和 BKPEN 位来打开电源和后备接口的时钟
7 J2 e% V+ W/ U- F2）电源控制寄存器(PWR_CR)的 DBP 位来使能对后备寄存器和 RTC 的访问。我们一般用 BKP 来存储 RTC 的校验值或者记录一些重要的数据，相当于一个 EEPROM，不过这个 EEPROM 并不是真正的 EEPROM，而是需要电池来维持它的数据。关于 BKP 的详细介绍请看《STM32 参考手册》的第 47 页， 5.1 一节。
4 ?$ e- G8 u! ^3 c5 y
备份区域控制寄存器RCC_BDCR
+ S& ]" J1 H2 o# J
) l4 @0 `/ B8 E6 s! J

& ]7 u' Q5 m5 }, y+ L* h
RTC 的时钟源选择及使能设置都是通过这个寄存器来实现的，所以我们在 RTC 操作之前先要通过这个寄存器选择 RTC 的时钟源，然后才能开始其他的操作。
$ O# I! C$ y2 u2 J7 G9 u# l提到时钟源，就要讲解一下,RTC的时钟源来源：
$ J; f4 G% \/ h  m8 K
1,高速外部时钟的128分频:HSE/128;
2,低速内部时钟LSI;
3,低速外部时钟LSE;

二、实验部分
! B, Y2 T8 [& S$ O步骤分解
# T8 y4 j( E6 ]4 ?7 D3 v1. 使能电源时钟和备份区域时钟
9 v6 q6 B$ h2 R0 G/ F6 ]( }2. 取消备份区写保护
/ T  C; N2 D! k3. 复位备份区域，开启外部低速振荡器
$ e+ J* |0 ?3 ]. C9 i, [) v4. 选择 RTC 时钟，并使能
7 ?$ u. M  n8 X  a' J# T$ F7 E* D5. 设置 RTC 的分频，以及配置 RTC 时钟
3 ^! @7 `% c3 B* n6. 更新配置，设置 RTC 中断分组
7. 编写中断服务函数
8 y/ k' L$ L; o  t/ L
RTC 相关的库函数在文件 stm32f10x_rtc.c 和 stm32f10x_rtc.h 文件中， BKP 相关的库函数在
文件 stm32f10x_bkp.c 和文件 stm32f10x_bkp.h 文件中

9 z' Y/ G; \; s% P1、RTC时钟源和时钟操作函数；
* L) H' n( h& c7 Qvoid RCC_RTCCLKConfig(uint32_t CLKSource);//时钟源选择；
void RCC_RTCCLKCmd(FunctionalState NewState);//时钟使能；
% P- E, t, [+ D: @6 k3 F. r! U2、RTC初始化函数
ErrorStatus RTC_Init(RTC_InitTypeDef* RTC_InitStruct);
trypedef struct
{
uint32_t RTC_HourFormat;//小时格式：24/12
8 O% ]( @$ Q/ G  d' iuint32_t RTC_AsynchPrediv;//异步分频系数
uint32_t RTC_SynchPrediv;//同步分频系数；
}RTC_InitTypeDef;
  P* L% t! g: h3、日历配置相关函数
ErrorStatus RTC_SetTime(uint32_t RTC_Format,RTC_TimeTypeDef* RTC_TimeStruct);
. x8 h& n" E( r; |' pvoid RTC_GetTime(uint32_t RTC_Format,RTC_TimeTypeDef* RTC_TimeStruct);
$ b% E. r) F, T" N2 _ErrorStatus RTC_SetDate(uint32_t RTC_Format,RTC_Dae TypeDef* RTC_DataStruct);
void RTC_GetDate(uint32_t RTC_Format,RTC_Date TypeDef* RTC_DateStruct);
( K5 y5 X' T6 [; `, n: [uint32_t RTC_GetSubSecond(void);
1 Q& z. M$ y+ \4、RTC闹钟相关函数
ErrorStatus RTC_AlarmCmd(uint32_t RTC_Alarm,FunctionalState NewState);
void RTC_SetAlarm();
void RTC_GetAlarm();
void RTC_AlarmSubSecondConfig();
uint32_t RTC_GetAlarmSubSecond(uint32_t RTC_Alarm);
5、RTC周期唤醒相关函数：
void RTC_WakeUpClockConfig();
8 Q7 a; J9 s# H3 o9 Fvoid RTC_SetWakeUpCounter();
uint32_t RTC_GetWakeUpCounter(void);
RTC_WakeUpCmd(DISABLE);//关闭WAKEUP
6、RTC中断配置以及状态相关函数
) B; [1 d) I9 D# \void RTC_ITConfig();
FlagStatus RTC_GetFlgStatus(uint32_t RTC_FLAG);
2 a0 ?7 G9 J+ f! [6 y  K" j7 p, qvoid RTC_ClearFlag(uint32_t RTC_FLAG);
ITStatus RTC_GetITStatus(uint32_t RTC_IT);
void RTC_ClearITPendingBit();
7、RTC相关约束函数
* v+ z; r4 M* o; S3 w4 i+ cvoid RTC_WriteProtectionCmd();//取消写保护
ErrorStatus RTC_EnterInitNode();//进入配hi模式，RTC_ISR_INITF位设置位1
void RTC_ExitInitMode(void);//退出初始化模式
8、其他函数
1 S1 X* `7 w7 T* puint32_t RTC_ReadBackupRegister();
void RTC_WriteBackupRegister();
void RTC_ITConfig();
; ]& Q+ p: A4 G2 {5 t9 V
3 w* w3 m3 V/ ~0 I# H1. 使能电源时钟和备份区域时钟
" X( X& d# P6 k: c& ?8 ^前面已经介绍了，我们要访问 RTC 和备份区域就必须先使能电源时钟和备份区域时钟。
/ g; C7 {& G* e8 X4 S

1. RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);

复制代码

2. 取消备份区写保护
要向备份区域写入数据，就要先取消备份区域写保护（写保护在每次硬复位之后被使能），否则是无法向备份区域写入数据的。我们需要用到向备份区域写入一个字节，来标记时钟已经配置过了，这样避免每次复位之后重新配置时钟。 取消备份区域写保护的库函数实现方法是：
. N, ?: d% i& l# ]; E6 {
, _9 m! [) o% \

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

复制代码

8 G; w: @: S. S0 Q1 B& W; z3. 复位备份区域，开启外部低速振荡器
4 H3 V  y  p' _" Q在取消备份区域写保护之后，我们可以先对这个区域复位，以清除前面的设置，当然这个
8 G" r1 J$ `3 o1 _2 C, {$ J操作不要每次都执行，因为备份区域的复位将导致之前存在的数据丢失，所以要不要复位，要看情况而定。然后我们使能外部低速振荡器，注意这里一般要先判断 RCC_BDCR 的 LSERDY位来确定低速振荡器已经就绪了才开始下面的操作。
0 l6 q" {2 v5 n. q' H: A
  ?/ l  T7 s/ H1 I0 K  D

1. BKP_DeInit();//复位备份区域
   
2. RCC_LSEConfig(RCC_LSE_ON);// 开启外部低速振荡器

复制代码

6 B& X6 y1 V' D( Q, w9 f4.选择 RTC 时钟，并使能。
7 `& G3 b9 ?) r/ H; y这里我们将通过 RCC_BDCR 的 RTCSEL 来选择选择外部 LSI 作为 RTC 的时钟。然后通过RTCEN 位使能 RTC 时钟。

2 U' `/ B* t4 b7 r- X- m6 b& V

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

复制代码

/ i( z0 b% [; H* L# [! ~对于 RTC 时钟的选择，还有 RCC_RTCCLKSource_LSI 和 RCC_RTCCLKSource_HSE_Div128两个，顾名思义，前者为 LSI，后者为 HSE 的 128 分频，这在时钟系统章节有讲解过。使能 RTC 时钟的函数是：
# C9 ~: b- i# @' I. G  h! L
- d4 R5 q6 e2 y" A, q% v

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

复制代码

5.设置 RTC 的分频，以及配置 RTC 时钟。
在开启了 RTC 时钟之后，我们要做的就是设置 RTC 时钟的分频数，通过 RTC_PRLH 和RTC_PRLL 来设置，然后等待 RTC 寄存器操作完成，并同步之后，设置秒钟中断。然后设置RTC 的允许配置位（RTC_CRH 的 CNF 位）， 设置时间（其实就是设置 RTC_CNTH 和 RTC_CNTL两个寄存器）。 下面我们一一这些步骤用到的库函数：在进行 RTC 配置之前首先要打开允许配置位(CNF)，库函数是：
: Q% ^4 D5 B% Q" W+ k" P
5 N7 S' W( s/ d2 j6 a) B

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

复制代码

在配置完成之后，千万别忘记更新配置同时退出配置模式，函数是：

* Q' U2 Y3 G' M3 Z, ?, G

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

复制代码

- {" A$ b" d. A+ J2 V# t7 G7 j( E设置 RTC 时钟分频数， 库函数是：

1. void RTC_SetPrescaler(uint32_t PrescalerValue);

复制代码

8 V1 n- ~" s# g4 z这个函数只有一个入口参数，就是 RTC 时钟的分频数，很好理解。
然后是设置秒中断允许， RTC 使能中断的函数是：
' x7 |; X3 a7 B8 e

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

复制代码

& B$ d7 j6 G& l3 k! F% X这个函数的第一个参数是设置秒中断类型，这些通过宏定义定义的。 对于使能秒中断方法是：

9 X9 }0 `( ]1 I) A

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

复制代码

+ i$ v8 m% p6 ^  \下一步便是设置时间了，设置时间实际上就是设置 RTC 的计数值，时间与计数值之间是需要换算的。库函数中设置 RTC 计数值的方法是：

1. void RTC_SetCounter(uint32_t CounterValue)//最后在配置完成之后

复制代码

6.更新配置，设置 RTC 中断分组。
+ C1 r& v8 u& [  j在设置完时钟之后，我们将配置更新同时退出配置模式，这里还是通过 RTC_CRH 的 CNF来实现。
" W  m+ U0 r4 r- T1 W
. c+ o3 I2 n1 ?! Q+ |  b( U/ W

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

复制代码

8 y; O5 I( `- z8 \在退出配置模式更新配置之后我们在备份区域 BKP_DR1 中写入 0X5050 代表我们已经初始化过时钟了，下次开机（或复位）的时候，先读取 BKP_DR1 的值，然后判断是否是 0X5050 来决定是不是要配置。接着我们配置 RTC 的秒钟中断，并进行分组。
# U9 A; H- }3 D9 z往备份区域写用户数据的函数是：
" a3 G1 E) \- \; G9 U$ k8 |1 \, n

1. void BKP_WriteBackupRegister(uint16_t BKP_DR, uint16_t Data)；

复制代码

1 @/ d# R6 a: U/ F" u这个函数的第一个参数就是寄存器的标号了，这个是通过宏定义定义的。 比如我们要往BKP_DR1 写入 0x5050，方法是：
' C9 x6 `' A8 y! _3 ^) c7 C

1. BKP_WriteBackupRegister(BKP_DR1, 0X5050);

复制代码

- d+ s: J' r1 I  _2 S6 G同时，有写便有读，读取备份区域指定寄存器的用户数据的函数是
( K+ j2 s  }$ }  V) z3 B
. T- o$ D3 S7 s: j' s

1. uint16_t BKP_ReadBackupRegister(uint16_t BKP_DR)；

复制代码

2 z! z$ A% j" W, b( f! w7. 编写中断服务函数
) \4 M5 c, w1 v+ @! u我们要编写中断服务函数，在秒钟中断产生的时候，读取当前的时间值，并显示到oled 模块上。
7 D0 @0 W' g5 c8 P( k2 Z6 I6 a+ L
* z; Q$ s+ n- r8 U代码部分
rtc.c文件代码

1. //注意：代码中的乱码，复制在keil5中可以恢复，便于读者编译运行。
   ! W/ x5 m& `: Y* k8 }- S2 U1 _7 S% R/ I2 z& X
2. #include "sys.h"
   - F' q2 Q/ J9 V/ H2 i: S8 U; }
3. #include "delay.h"
   5 v9 M9 a/ i. f- V  P
4. #include "usart.h"
   
5. #include "rtc.h"                     
   
6. 
   
7. _calendar_obj calendar;//ʱÖӽṹÌå
   ! `" l& ]/ _; \) h6 z
8. 
   * }: l# [4 G  u! x- ~
9. static void RTC_NVIC_Config(void)
   
10. {        
    ) ^2 U! [6 Q( j' a7 s, f5 g) r
11.   NVIC_InitTypeDef NVIC_InitStructure;
    ! s) h8 Z- a  x/ o
12.         NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;                //RTCÈ«¾ÖÖжÏ
    
13.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;        //ÏÈÕ¼ÓÅÏȼ¶1λ,´ÓÓÅÏȼ¶3λ
    
14.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;        //ÏÈÕ¼ÓÅÏȼ¶0λ,´ÓÓÅÏȼ¶4λ
    
15.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                //ʹÄܸÃͨµÀÖжÏ
    ( S( z0 d- t; j5 r
16.         NVIC_Init(&NVIC_InitStructure);                //¸ù¾ÝNVIC_InitStructÖÐÖ¸¶¨µÄ²ÎÊý³õʼ»¯ÍâÉèNVIC¼Ä´æÆ÷
    
17. }
    ! T% B& Z9 C( f/ T
18. 
    
19. //ʵʱʱÖÓÅäÖÃ
    
20. //³õʼ»¯RTCʱÖÓ,ͬʱ¼ì²âʱÖÓÊÇ·ñ¹¤×÷Õý³£
    
21. //BKP->DR1ÓÃÓÚ±£´æÊÇ·ñµÚÒ»´ÎÅäÖõÄÉèÖÃ
    . m+ `- x9 T1 K" ]$ E
22. //·µ»Ø0:Õý³£
    
23. //ÆäËû:´íÎó´úÂë
    6 U, W: T2 e8 a: P$ q7 M. f4 ?- Y+ |
24. 
    7 C4 Q: J- w' G3 o
25. u8 RTC_Init(void)
    # a5 b1 l; `% g) L# T, `! t- ^, r
26. {
    2 n1 e  e1 S2 |# ]* e
27.         //¼ì²éÊDz»ÊǵÚÒ»´ÎÅäÖÃʱÖÓ
    
28.         u8 temp=0;
    
29.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);        //ʹÄÜPWRºÍBKPÍâÉèʱÖÓ   
    . w) V! J1 t4 w, c& J) o0 a* _
30.         PWR_BackupAccessCmd(ENABLE);        //ʹÄܺ󱸼ĴæÆ÷·ÃÎÊ  
    
31.         if (BKP_ReadBackupRegister(BKP_DR1) != 0x5050)                //´ÓÖ¸¶¨µÄºó±¸¼Ä´æÆ÷ÖжÁ³öÊý¾Ý:¶Á³öÁËÓëдÈëµÄÖ¸¶¨Êý¾Ý²»Ïàºõ
    
32.                 {                                 
    $ L0 c7 d7 N8 ~2 C* z% C
33.                 BKP_DeInit();        //¸´Î»±¸·ÝÇøÓò         
    9 {" L+ P$ y/ y5 B  c
34.                 RCC_LSEConfig(RCC_LSE_ON);        //ÉèÖÃÍⲿµÍËÙ¾§Õñ(LSE),ʹÓÃÍâÉèµÍËÙ¾§Õñ
    
35.                 while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET&&temp<250)        //¼ì²éÖ¸¶¨µÄRCC±ê־λÉèÖÃÓë·ñ,µÈ´ýµÍËÙ¾§Õñ¾ÍÐ÷
    
36.                         {
    : d2 @+ M7 {1 u/ h! q8 V1 ^
37.                         temp++;
    3 y; _" s9 j- Y' f' n" s
38.                         delay_ms(10);
    ' ?  W( Y: m7 p9 v' t1 p
39.                         }
    
40.                 if(temp>=250)return 1;//³õʼ»¯Ê±ÖÓʧ°Ü,¾§ÕñÓÐÎÊÌâ            
    % l! |6 R. C- V/ D9 {# y" F  q, ]
41.                 RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);                //ÉèÖÃRTCʱÖÓ(RTCCLK),Ñ¡ÔñLSE×÷ΪRTCʱÖÓ   
      Q& B; w9 H: E; v
42.                 RCC_RTCCLKCmd(ENABLE);        //ʹÄÜRTCʱÖÓ  
    
43.                 RTC_WaitForLastTask();        //µÈ´ý×î½üÒ»´Î¶ÔRTC¼Ä´æÆ÷µÄд²Ù×÷Íê³É
    2 A( p3 E$ L+ L6 }4 t; N* n% I
44.                 RTC_WaitForSynchro();                //µÈ´ýRTC¼Ä´æÆ÷ͬ²½  
    
45.                 RTC_ITConfig(RTC_IT_SEC, ENABLE);                //ʹÄÜRTCÃëÖжÏ
    $ {/ X" V* R5 x7 S, U- C" Q
46.                 RTC_WaitForLastTask();        //µÈ´ý×î½üÒ»´Î¶ÔRTC¼Ä´æÆ÷µÄд²Ù×÷Íê³É
    
47.                 RTC_EnterConfigMode();/// ÔÊÐíÅäÖà       
    
48.                 RTC_SetPrescaler(32767); //ÉèÖÃRTCÔ¤·ÖƵµÄÖµ
    
49.                 RTC_WaitForLastTask();        //µÈ´ý×î½üÒ»´Î¶ÔRTC¼Ä´æÆ÷µÄд²Ù×÷Íê³É
    
50.                 RTC_Set(2021,2,9,17,40,00);  //ÉèÖÃʱ¼ä        
    / M; L% C/ a3 |+ ?: y$ y
51.                 RTC_ExitConfigMode(); //Í˳öÅäÖÃģʽ  
    
52.                 BKP_WriteBackupRegister(BKP_DR1, 0X5050);        //ÏòÖ¸¶¨µÄºó±¸¼Ä´æÆ÷ÖÐдÈëÓû§³ÌÐòÊý¾Ý
    3 O3 N7 Q4 g, x/ M. d
53.                 }
    ( D; m1 f0 j2 Y8 u
54.         else//ϵͳ¼ÌÐø¼Æʱ
    " {# e8 k9 E( s$ s6 F. Q4 a2 _& R+ d' E2 m
55.                 {
    1 a4 `$ K2 I' {9 X4 e! `
56. 
    ( n1 o- a5 \$ n: b' ]) K5 p6 a
57.                 RTC_WaitForSynchro();        //µÈ´ý×î½üÒ»´Î¶ÔRTC¼Ä´æÆ÷µÄд²Ù×÷Íê³É
      h0 B2 V; y% [& S6 O+ _
58.                 RTC_ITConfig(RTC_IT_SEC, ENABLE);        //ʹÄÜRTCÃëÖжÏ
    / B' S+ u  z) z+ |
59.                 RTC_WaitForLastTask();        //µÈ´ý×î½üÒ»´Î¶ÔRTC¼Ä´æÆ÷µÄд²Ù×÷Íê³É
    7 ~7 {  y0 @2 B, o( {
60.                 }
    
61.         RTC_NVIC_Config();//RCTÖжϷÖ×éÉèÖà                                                        
    % N# x2 [! ~* c2 P9 J
62.         RTC_Get();//¸üÐÂʱ¼ä        
    
63.         return 0; //ok
    ) _3 [* V! s  R+ c! i: o
64. 
    $ n6 s& @+ g: L4 Y2 g, V
65. }                                                     
    
66. //RTCʱÖÓÖжÏ
    5 y3 [  F; A1 K/ ~0 ]# c: }1 I
67. //ÿÃë´¥·¢Ò»´Î  
    2 F$ c& }: N! j: i/ I0 n2 C
68. //extern u16 tcnt;
    
69. void RTC_IRQHandler(void)
      W# s0 c0 ?2 W. y. z; F9 i% i
70. {                 
    . d1 T+ g$ g1 U6 p9 M
71.         if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//ÃëÖÓÖжÏ
    6 d& d  O5 [4 _$ h3 z
72.         {                                                        
    * V+ \1 D7 o& U9 H  J* y/ T
73.                 RTC_Get();//¸üÐÂʱ¼ä   
    2 Y1 J) b" c- ~: W" A$ x2 t
74.          }
    / b4 N! D3 v0 f
75.         if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//ÄÖÖÓÖжÏ
    
76.         {
    1 ^( [9 s: R1 ?8 L% m- h7 J- I
77.                 RTC_ClearITPendingBit(RTC_IT_ALR);                //ÇåÄÖÖÓÖжϠ                 
    
78.           RTC_Get();                                //¸üÐÂʱ¼ä   
    ! e6 h0 D0 f- m. N! [2 S- }
79.           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);//Êä³öÄÖÁåʱ¼ä        
    0 Z. Y4 p6 v& ?* c: E' p' m
80.                
    
81.           }                                                                                                   
    
82.         RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);                //ÇåÄÖÖÓÖжÏ
    
83.         RTC_WaitForLastTask();                                                                                          
    9 j& v, j5 ~& d' T5 e( k
84. }
    
85. //ÅжÏÊÇ·ñÊÇÈòÄ꺯Êý
    4 o2 b! E' D8 e$ r7 P
86. //Ô·ݠ  1  2  3  4  5  6  7  8  9  10 11 12
    7 w; @4 r0 n6 Z$ O8 i9 w% c. {
87. //ÈòÄê   31 29 31 30 31 30 31 31 30 31 30 31
    2 m$ Q9 p9 A1 `& e; z* L( B* w
88. //·ÇÈòÄê 31 28 31 30 31 30 31 31 30 31 30 31
    
89. //ÊäÈë:Äê·Ý
    
90. //Êä³ö:¸ÃÄê·ÝÊDz»ÊÇÈòÄê.1,ÊÇ.0,²»ÊÇ
    & n2 U4 F8 ^) Q3 |2 t9 ?: {
91. u8 Is_Leap_Year(u16 year)
    
92. {                          
    , q6 s: j# N5 L
93.         if(year%4==0) //±ØÐëÄܱ»4Õû³ý
    ; s& q& Z5 I" c+ N  U3 w
94.         {
    
95.                 if(year%100==0)
    1 D  ]6 a& T7 T' D; |7 w% @
96.                 {
    ; V4 M* `5 Y3 c8 t4 m/ v+ k
97.                         if(year%400==0)return 1;//Èç¹ûÒÔ00½áβ,»¹ÒªÄܱ»400Õû³ý            
    ; t. |: Y; h* x0 D$ W! D+ k
98.                         else return 0;   
    
99.                 }else return 1;   
    - Q0 g5 l0 b0 _2 t/ _( q
100.         }else return 0;        
     3 r$ |) f/ H9 m& `1 j0 V
101. }                                    
     5 B" V& x9 U- |  ]
102. //ÉèÖÃʱÖÓ
       I+ P! _5 ~- Z& V' K1 z
103. //°ÑÊäÈëµÄʱÖÓת»»ÎªÃëÖÓ
     4 H$ f+ O' m5 J, Q
104. //ÒÔ1970Äê1ÔÂ1ÈÕΪ»ù×¼
     
105. //1970~2099ÄêΪºÏ·¨Äê·Ý
     2 n  Y$ j8 s: j9 x0 S8 Q+ f0 `) B0 ~% |& S
106. //·µ»ØÖµ:0,³É¹¦;ÆäËû:´íÎó´úÂë.
     
107. //Ô·ÝÊý¾Ý±í                                                                                         
     % l4 K& N1 I- Z3 L8 y4 z: O
108. u8 const table_week[12]={0,3,3,6,1,4,6,2,5,0,3,5}; //ÔÂÐÞÕýÊý¾Ý±í         
     ( s! F) ~8 K: B# ^
109. //ƽÄêµÄÔ·ÝÈÕÆÚ±í
     : i( D: C: x7 Y
110. const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
     + E9 ]" O! t9 J. ~/ Z1 j
111. u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
     * l: }! K8 a4 Z
112. {
     , \% ?7 X+ c  n: e
113.         u16 t;
     
114.         u32 seccount=0;
     
115.         if(syear<1970||syear>2099)return 1;           
     
116.         for(t=1970;t<syear;t++)        //°ÑËùÓÐÄê·ÝµÄÃëÖÓÏà¼Ó
     3 N+ r9 Q* x. L0 h0 y2 Q0 p) z" h
117.         {
     
118.                 if(Is_Leap_Year(t))seccount+=31622400;//ÈòÄêµÄÃëÖÓÊý
     
119.                 else seccount+=31536000;                          //ƽÄêµÄÃëÖÓÊý
     
120.         }
     0 O0 Y4 S: ^4 V5 J3 R' Z5 G( \
121.         smon-=1;
     1 P' T7 S, ~, O& h: e( W  L# W
122.         for(t=0;t<smon;t++)           //°ÑÇ°ÃæÔ·ݵÄÃëÖÓÊýÏà¼Ó
     
123.         {
     
124.                 seccount+=(u32)mon_table[t]*86400;//Ô·ÝÃëÖÓÊýÏà¼Ó
       K7 J$ Q  D! M0 U5 b7 V" t
125.                 if(Is_Leap_Year(syear)&&t==1)seccount+=86400;//ÈòÄê2Ô·ÝÔö¼ÓÒ»ÌìµÄÃëÖÓÊý           
     
126.         }
     / ?4 V. h5 b4 w$ Q# k3 t1 t
127.         seccount+=(u32)(sday-1)*86400;//°ÑÇ°ÃæÈÕÆÚµÄÃëÖÓÊýÏà¼Ó
     6 Z9 [7 B* m0 m! l
128.         seccount+=(u32)hour*3600;//СʱÃëÖÓÊý
     
129.     seccount+=(u32)min*60;         //·ÖÖÓÃëÖÓÊý
     
130.         seccount+=sec;//×îºóµÄÃëÖÓ¼ÓÉÏÈ¥
     ! R/ o# ^' I, d/ T: `
131. 
     
132.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);        //ʹÄÜPWRºÍBKPÍâÉèʱÖÓ  
     
133.         PWR_BackupAccessCmd(ENABLE);        //ʹÄÜRTCºÍºó±¸¼Ä´æÆ÷·ÃÎÊ
     
134.         RTC_SetCounter(seccount);        //ÉèÖÃRTC¼ÆÊýÆ÷µÄÖµ
     ! \3 ^4 K9 U5 p3 v, m/ v
135. 
     
136.         RTC_WaitForLastTask();        //µÈ´ý×î½üÒ»´Î¶ÔRTC¼Ä´æÆ÷µÄд²Ù×÷Íê³É         
     $ n1 n7 ?" y% S: f
137.         return 0;            
     ) _$ \+ w0 h" W6 V" s. m
138. }
     
139. 
     - Q% c* M8 o. A6 d8 _. W9 e
140. //³õʼ»¯ÄÖÖÓ                  
     
141. //ÒÔ1970Äê1ÔÂ1ÈÕΪ»ù×¼
     ) O1 ~. e9 Z+ i' `. o& ]  ?
142. //1970~2099ÄêΪºÏ·¨Äê·Ý
     3 O6 j) ~' t# C  \1 j  J- ?
143. //syear,smon,sday,hour,min,sec£ºÄÖÖÓµÄÄêÔÂÈÕʱ·ÖÃë   
     
144. //·µ»ØÖµ:0,³É¹¦;ÆäËû:´íÎó´úÂë.
     ! ^; S- l8 I" `- J% a
145. u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
     
146. {
     " I. g! e0 H* V- U
147.         u16 t;
     : \, u0 k! R3 i
148.         u32 seccount=0;
     
149.         if(syear<1970||syear>2099)return 1;           
     
150.         for(t=1970;t<syear;t++)        //°ÑËùÓÐÄê·ÝµÄÃëÖÓÏà¼Ó
     
151.         {
     $ c' }( Z4 B2 t' a
152.                 if(Is_Leap_Year(t))seccount+=31622400;//ÈòÄêµÄÃëÖÓÊý
     
153.                 else seccount+=31536000;                          //ƽÄêµÄÃëÖÓÊý
     
154.         }
     % q) i' M3 h8 J5 q  M
155.         smon-=1;
     8 V% Z* F- X) L) ]$ P
156.         for(t=0;t<smon;t++)           //°ÑÇ°ÃæÔ·ݵÄÃëÖÓÊýÏà¼Ó
     
157.         {
     
158.                 seccount+=(u32)mon_table[t]*86400;//Ô·ÝÃëÖÓÊýÏà¼Ó
     
159.                 if(Is_Leap_Year(syear)&&t==1)seccount+=86400;//ÈòÄê2Ô·ÝÔö¼ÓÒ»ÌìµÄÃëÖÓÊý           
     % n; e& x5 Y1 g0 M( P" S; N# ~: V1 b
160.         }
     9 O/ E, Z/ q0 `) A/ d
161.         seccount+=(u32)(sday-1)*86400;//°ÑÇ°ÃæÈÕÆÚµÄÃëÖÓÊýÏà¼Ó
     8 A3 }/ `  n$ ^9 F! V/ P+ |6 p
162.         seccount+=(u32)hour*3600;//СʱÃëÖÓÊý
     8 [; q/ L! y0 k1 J
163.     seccount+=(u32)min*60;         //·ÖÖÓÃëÖÓÊý
     
164.         seccount+=sec;//×îºóµÄÃëÖÓ¼ÓÉÏÈ¥                             
     , t7 O8 X/ M; S. ~" U
165.         //ÉèÖÃʱÖÓ
     
166.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);        //ʹÄÜPWRºÍBKPÍâÉèʱÖÓ   
     
167.         PWR_BackupAccessCmd(ENABLE);        //ʹÄܺ󱸼ĴæÆ÷·ÃÎÊ  
     
168.         //ÉÏÃæÈý²½ÊDZØÐëµÄ!
     
169.         
     
170.         RTC_SetAlarm(seccount);
     $ P, k( C' W* {# f5 Q
171. 
     
172.         RTC_WaitForLastTask();        //µÈ´ý×î½üÒ»´Î¶ÔRTC¼Ä´æÆ÷µÄд²Ù×÷Íê³É         
     ; P' O: ?4 v% A9 _
173.         
     ' d5 H' ~0 L( B! K% P8 u
174.         return 0;            
     
175. }
     % s+ a' @) W0 ?8 D% `9 v
176. 
     
177. 
     8 X( e( }" S6 `5 X6 c' `
178. //µÃµ½µ±Ç°µÄʱ¼ä
     
179. //·µ»ØÖµ:0,³É¹¦;ÆäËû:´íÎó´úÂë.
     + @, }8 ~$ I* l0 P
180. u8 RTC_Get(void)
     7 S7 v, y# E* o5 T' j* ^% N0 n
181. {
     
182.         static u16 daycnt=0;
     
183.         u32 timecount=0;
     ! y3 I' x/ T6 s! i8 S
184.         u32 temp=0;
     ; k2 x! y# b- B8 {, R
185.         u16 temp1=0;         
     
186.     timecount=RTC_GetCounter();         
     
187.          temp=timecount/86400;   //µÃµ½ÌìÊý(ÃëÖÓÊý¶ÔÓ¦µÄ)
     # N. p  h8 G! ]: \- [. l
188.         if(daycnt!=temp)//³¬¹ýÒ»ÌìÁË
     ( F& P  N) q  `, {7 @$ G
189.         {         
     
190.                 daycnt=temp;
     
191.                 temp1=1970;        //´Ó1970Ä꿪ʼ
     
192.                 while(temp>=365)
     
193.                 {                                 
     ; H/ P' {, q5 ?4 C
194.                         if(Is_Leap_Year(temp1))//ÊÇÈòÄê
     
195.                         {
     
196.                                 if(temp>=366)temp-=366;//ÈòÄêµÄÃëÖÓÊý
     
197.                                 else {temp1++;break;}  
     # F5 a1 ?; o9 y9 B# d
198.                         }
     " X1 X% X( H' G! [
199.                         else temp-=365;          //ƽÄê
     
200.                         temp1++;  
     
201.                 }   
     - r' V: x- a; N# k! L
202.                 calendar.w_year=temp1;//µÃµ½Äê·Ý
     " j. M) k' G' p, _. @" p
203.                 temp1=0;
     
204.                 while(temp>=28)//³¬¹ýÁËÒ»¸öÔÂ
     . b# ]( F  s+ l, C- `* x
205.                 {
     ( c, |7 G# A! A0 }! w3 q( S
206.                         if(Is_Leap_Year(calendar.w_year)&&temp1==1)//µ±ÄêÊDz»ÊÇÈòÄê/2Ô·Ý
     
207.                         {
     2 B  v) o, q2 {
208.                                 if(temp>=29)temp-=29;//ÈòÄêµÄÃëÖÓÊý
     % g% u4 Y# |+ B: p
209.                                 else break;
     
210.                         }
     2 t! I2 }6 w3 h, u. z
211.                         else
     
212.                         {
     
213.                                 if(temp>=mon_table[temp1])temp-=mon_table[temp1];//ƽÄê
     
214.                                 else break;
     " }3 L+ T9 U) W
215.                         }
     
216.                         temp1++;  
     
217.                 }
     
218.                 calendar.w_month=temp1+1;        //µÃµ½Ô·Ý
     
219.                 calendar.w_date=temp+1;          //µÃµ½ÈÕÆÚ
     
220.         }
     
221.         temp=timecount%86400;                     //µÃµ½ÃëÖÓÊý              
     8 \! k; ~  I; u4 b- h
222.         calendar.hour=temp/3600;             //Сʱ
     
223.         calendar.min=(temp%3600)/60;         //·ÖÖÓ        
     
224.         calendar.sec=(temp%3600)%60;         //ÃëÖÓ
     
225.         calendar.week=RTC_Get_Week(calendar.w_year,calendar.w_month,calendar.w_date);//»ñÈ¡ÐÇÆÚ   
     
226.         return 0;
     " G( F5 v- h  x& ?0 L! U0 l0 \
227. }         
     6 p& o% Z. ~0 J2 N( f
228. //»ñµÃÏÖÔÚÊÇÐÇÆÚ¼¸
     
229. //¹¦ÄÜÃèÊö:ÊäÈ빫ÀúÈÕÆڵõ½ÐÇÆÚ(Ö»ÔÊÐí1901-2099Äê)
     " ~+ |; t6 F* Z2 J* m: L8 z
230. //ÊäÈë²ÎÊý£º¹«ÀúÄêÔÂÈÕ
     * C6 j: _( o" @: q0 Z" Z7 Y1 K! P( m
231. //·µ»ØÖµ£ºÐÇÆںŠ                                                                                                                                                                                
     
232. u8 RTC_Get_Week(u16 year,u8 month,u8 day)
     1 w' l* Q: o& |) q0 t& d
233. {        
     
234.         u16 temp2;
     $ Y5 Q1 }  _% B8 U9 l
235.         u8 yearH,yearL;
     ! X6 n1 T0 B5 X2 v
236.         
     
237.         yearH=year/100;        yearL=year%100;
     ( J- R1 j0 A# C& _
238.         // Èç¹ûΪ21ÊÀ¼Í,Äê·ÝÊý¼Ó100  
     0 L6 P* |, y9 F' M; s2 A
239.         if (yearH>19)yearL+=100;
     - t* s9 S9 z' B; w( V$ n) b
240.         // Ëù¹ýÈòÄêÊýÖ»Ëã1900ÄêÖ®ºóµÄ  
     3 z* U' u2 Y) s7 O% I
241.         temp2=yearL+yearL/4;
     2 F* ~' c! u; \! ~% Z6 o  T; f
242.         temp2=temp2%7;
     1 A( J5 y9 e; c8 s) ^  {
243.         temp2=temp2+day+table_week[month-1];
     $ N0 l6 K# [" B6 C1 F4 \
244.         if (yearL%4==0&&month<3)temp2--;
     
245.         return(temp2%7);
     ) M+ z9 }* p. X) F% y
246. }        
     " u4 D( }' Q* Z: a0 ~6 U" c" K: y0 H9 b

复制代码

* {" y, ^4 O. A5 cmain.c文件

, o- R9 ?5 p! s

1. #include "delay.h"
   
2. #include "sys.h"
   
3. #include "usart.h"        
   / L( X8 H" h' l+ ~: T1 |# N/ ^8 A* Z
4. #include "rtc.h"
   
5. #include "stm32f10x.h"
   1 J! n8 c9 ^4 D+ f  `
6. 
   
7. int main(void)
   6 [0 [% z% f1 r. w" d& C2 g: |* J" G( M
8. {
   
9.         u8 t=1;
   
10.         delay_init();        
    
11.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    5 |  h4 X0 d; K/ h; l) T8 b4 X4 F
12.         OLED_Init();
    
13.         RTC_Init();
    % T) ?, S- r! M5 n
14.          while (1)
    0 {" L6 j3 ?5 P8 Q. u7 N$ h' V: N
15.         {
    + y! L8 b" k7 J  }% R' k- @
16.                 if(t!=calendar.sec)
    4 {: C+ R- K+ L, r5 w
17.                 {
    5 P: a2 _7 c- b* _
18.                         t=calendar.sec;
    
19.                         /*OLED_ShowNum(0,0,calendar.w_year,2,24);
    
20.                         OLED_ShowString(24,0,"-",24);
    4 y; m+ I. e, H9 W8 M; h6 t
21.                         OLED_ShowNum(36,0,calendar.w_month,2,24);
    
22.                         OLED_ShowString(60,0,"-",24);
    
23.                         OLED_ShowNum(72,0,calendar.w_date,2,24);
    1 ?8 F! p# j* I; x5 n3 {$ u
24.                         */
    . g9 p) Z) G# S8 N0 j
25.                         switch(calendar.week)
    
26.                         {
    % S& ~; ^+ V8 d$ `# Y
27.                                 case 0:
    & N) S( ?# S$ C6 r$ O: s# b( z
28.                                         OLED_ShowString(0,24,"Sunday",24);break;
    7 p# ?* Q, D, N% p9 [$ u0 h* r
29.                                 case 1:
    2 W, r* e  h) j) ]1 u
30.                                         OLED_ShowString(0,24,"Monday",24);break;
    1 U( R! x( V/ _
31.                                 case 2:
    
32.                                         OLED_ShowString(0,24,"Tuesday",24);break;
    
33.                                 case 3:
    ; _& W2 e6 J) M  K
34.                                         OLED_ShowString(0,24,"Wednesday",24);break;
    " J1 j. D1 R' F6 [
35.                                 case 4:
    7 a2 z/ d$ g1 g1 |
36.                                         OLED_ShowString(0,24,"Thursday",24);break;
    
37.                                 case 5:
    ( x8 z) G; }/ k' @) ~0 Y) {
38.                                         OLED_ShowString(0,24,"friday",24);break;
    & i, g1 X" E& T; J- k
39.                                 case 6:
    ( ?0 }# A+ r+ @$ E0 g# G
40.                                         OLED_ShowString(0,24,"Saturday",24);break;
    
41.                         }
    
42.                         
    
43.                         OLED_ShowNum(0,0,calendar.hour,2,24);
    
44.                         OLED_ShowString(24,0,"-",24);
    2 U5 d4 X0 j% k* T9 k' N  ^* y
45.                         OLED_ShowNum(36,0,calendar.min,2,24);
    7 ?9 O! c' X' ]9 e0 I
46.                         OLED_ShowString(60,0,"-",24);
    
47.                         OLED_ShowNum(72,0,calendar.sec,2,24);
    
48.                         OLED_Refresh_Gram();
    2 B$ p7 F$ s8 k* Q
49.                 }
    % F+ V3 ^( h% E  }6 F7 O( p
50.                 delay_ms(10);
    
51.         }
    
52.         
    
53. 
    ) b* N! K! H9 e' m# Z' \
54. }
    5 {, O4 R+ P8 e
55. 
    # b) k) a* E. W7 V; C( q

复制代码

9 U/ r/ S- L7 O. k% \

: \) S# h' x: ~" A. i# c( {0 v
& N9 h% a) [! B

4 `- k7 u" j2 l: u; U* B2 V