你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

【经验分享】STM32-RTC实时时钟-毫秒计时实现

[复制链接]
STMCU小助手 发布时间:2022-1-13 20:47
1、RTC时钟简介
  STM32 的实时时钟(RTC)是一个独立的定时器,在相应软件配置下,可提供时钟日历的功能。 详细资料请参考ALIENTEK的官方文档——《STM32F1开发指南(精英版-库函数版)》,以下为博主摘录要点:
  • RTC 模块和时钟配置系统(RCC_BDCR 寄存器)在后备区域 ,系统复位后,会自动禁止访问后备寄存器和 RTC ,所以在要设置时间之前, 先要取消备份区域(BKP)的写保护" a3 t& M3 _+ F+ o' ~
  • RTC 内核完全独立于 RTC APB1 接口,而软件是通过 APB1 接口访问 RTC 的预分频值、计数器值和闹钟值,因此需要等待时钟同步,寄存器同步标志位(RSF)会硬件置1- N4 X1 h$ q  p  [3 K& v; E+ G
  • RTC相关寄存器包括:控制寄存器(CRH、CRL)、预分频装载寄存器(PRLH、PRLL)、预分频器余数寄存器(DIVH、DIVL)、计数寄存器(CNTH、CNTL)、闹钟寄存器(ALRH、ALRL)
  • STM32备份寄存器,存RTC校验值和一些重要参数,最大字节84,可由VBAT供电
  • 计数器时钟频率:RTCCLK频率/(预分频装载寄存器值+1)
    7 H5 q8 K: j) z' d+ |9 `
    # [* l! z0 G; n% O: U, i7 [

7 Z1 K- T7 ^$ T4 f) C  K2、软硬件设计
  由于RTC是STM32芯片自带的时钟资源,所以自主开发的时候只需要在设计时加上晶振电路和纽扣电池即可。编程时在HARDWARE文件夹新建 rtc.c、rtc.h 文件。

3 h. e# R/ ]5 Q; Y+ U2 ~" L0 o1 f1 f' [9 j9 \
3、时钟配置与函数编写
  为了使用RTC时钟,需要进行配置和时间获取,基本上按照例程来写就可以了。为避免零散,我将附上完整代码。函数说明如下:
rtc.c中需要编写的函数列表
RTC_Init(void)
配置时钟
RTC_NVIC_Config(void)
中断分组
RTC_IRQHandler(void)
秒中断处理
RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
设置时间
RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
闹钟设置
RTC_Get(void)
获取时钟
RTC_Get_Week(u16 year,u8 month,u8 day)
星期计算
Is_Leap_Year(u16 year)
闰年判断

6 k. O  r. f0 D" f8 \
 事实上,以上函数并不都要,闹钟没有用到的话就不要,秒中断也可以不作处理,看项目需求。
  1.   1 #include "sys.h"/ {* k% c9 E$ \8 B( j. X* p
  2.   2 #include "delay.h"
    & B0 I: s1 @' ?! e" [2 |
  3.   3 #include "rtc.h"            
    % H; m/ U& L  F
  4.   4        ; p2 b9 U7 q7 T% Z0 Y# C3 P: m) v4 r
  5.   5 _calendar_obj calendar;//时钟结构体
    8 X1 d9 g" W) P# w, R- F- y4 D) _
  6.   6  5 c1 \/ a. W0 O& f4 R% R7 v
  7.   7 static void RTC_NVIC_Config(void)8 w+ i, X# z. X) O) @
  8.   8 {   
    6 P& _& X# b+ ^3 I* O. q
  9.   9     NVIC_InitTypeDef NVIC_InitStructure;: O4 G1 O& d& r: C& s
  10. 10     NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;        //RTC全局中断# X; W. S1 z% [8 j
  11. 11     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;    //先占优先级1位,从优先级3位% |+ J1 I9 |# Q* o( @
  12. 12     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;    //先占优先级0位,从优先级4位
    * e$ P4 o6 t$ z4 l6 ]  x
  13. 13     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;        //使能该通道中断$ f5 Y9 {: {) t& N7 e
  14. 14     NVIC_Init(&NVIC_InitStructure);        //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器# b" y6 C0 e+ m/ u; _$ k, n& B  t
  15. 15 }
    4 V+ j2 A9 S0 Y! C# e" A0 @
  16. 16
    + Y2 D- K& [' t- d2 t* ~# ~
  17. 17 //实时时钟配置, K9 w9 z2 b8 N& j: |
  18. 18 //初始化RTC时钟,同时检测时钟是否工作正常
    - n" n( |/ Z% V+ v1 f& p) }' R
  19. 19 //BKP->DR1用于保存是否第一次配置的设置4 q& N  a- A$ W$ j* b' T9 N
  20. 20 //返回0:正常
    7 N  r+ M: l8 Z5 B" m
  21. 21 //其他:错误代码
    1 c2 k/ Z- `7 {+ B$ U/ [4 H- d! {
  22. 22
    5 h: x4 ^5 C! f( ^" p3 `! q8 q
  23. 23 u8 RTC_Init(void)
    . S8 i' |9 n4 w8 S/ I  L+ P- |, p
  24. 24 {
    0 S0 {" k6 J" @: P- e8 _+ _
  25. 25     //检查是不是第一次配置时钟1 w$ z1 b( r, w% y
  26. 26     u8 temp=0;! W( K: _6 ~; W  ]
  27. 27     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟   . T8 C8 |6 P2 G
  28. 28     PWR_BackupAccessCmd(ENABLE);    //使能后备寄存器访问  
    4 k9 N$ J, l, a( b) P! v2 J/ }' s
  29. 29     if (BKP_ReadBackupRegister(BKP_DR1) != 0x5051)        //从指定的后备寄存器中读出数据:读出了与写入的指定数据不相乎, x4 `4 w" N( A# [8 U/ O" L
  30. 30     {                  4 l3 P, _& b' w
  31. 31         BKP_DeInit();    //复位备份区域     9 @4 P/ x- c- E
  32. 32         RCC_LSEConfig(RCC_LSE_ON);    //设置外部低速晶振(LSE),使用外设低速晶振
      G1 a, u: n) ?9 {" j; ~1 Y
  33. 33         while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET&&temp<250)    //检查指定的RCC标志位设置与否,等待低速晶振就绪* ]/ r* b# s- S4 m2 h% v
  34. 34         {4 \$ Y7 n9 O* [' P' v5 T
  35. 35             temp++;, ?' t- F2 p1 E) x
  36. 36             delay_ms(10);
    : A! u: i, Z0 L$ I0 ?8 {4 W2 `
  37. 37         }
    ! b2 d3 t1 N) W0 J
  38. 38         if(temp>=250)return 1;//初始化时钟失败,晶振有问题          ^" M& N' ^+ |6 \5 h- n
  39. 39         RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);        //设置RTC时钟(RTCCLK),选择LSE作为RTC时钟    # G1 A6 [6 b0 ^$ |- d! E3 a( J3 G
  40. 40         RCC_RTCCLKCmd(ENABLE);    //使能RTC时钟  ( S& Q5 ^. X. Y; n
  41. 41         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
    " k1 v- B- ~& r5 d3 ]" V, E/ m
  42. 42         RTC_WaitForSynchro();        //等待RTC寄存器同步  
    9 E  j+ t+ a7 |- `& R6 ]
  43. 43         RTC_ITConfig(RTC_IT_SEC, ENABLE);        //使能RTC秒中断% c( H$ e2 Q, M$ X3 G
  44. 44         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
    / i- j! \; K1 t, ^7 b
  45. 45         RTC_EnterConfigMode();/// 允许配置   
    0 l5 ?+ D3 C  i5 q( z1 P4 P3 X% ~
  46. 46         RTC_SetPrescaler(32767); //设置RTC预分频的值
    ' h- V& }) {+ o1 _
  47. 47         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成  v' F5 I# P+ V  d6 q5 j4 d
  48. 48         RTC_Set(2018,4,2,17,37,00);  //设置时间   
      |, A6 |1 r% h7 R
  49. 49         RTC_ExitConfigMode(); //退出配置模式  
    ' N% M5 S: W8 b4 ~, D% [7 ]( C$ _
  50. 50         BKP_WriteBackupRegister(BKP_DR1, 0X5051);    //向指定的后备寄存器中写入用户程序数据
    $ N1 ]" B: T; }" w+ b
  51. 51     }. d1 ~% V& r) T5 ^& U5 s
  52. 52     else//系统继续计时& U6 ?. f9 N2 ^% j' \* L7 Q
  53. 53     {
    5 N: v+ B! Z% ~- d8 r" b
  54. 54
    ; M. t, C% G5 r; ^7 F
  55. 55         RTC_WaitForSynchro();    //等待最近一次对RTC寄存器的写操作完成
    ; m" v, Z" N1 R# W1 w' C
  56. 56         RTC_ITConfig(RTC_IT_SEC, ENABLE);    //使能RTC秒中断
    4 E2 I# {! ]: ~# l. G4 J' R
  57. 57         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成# i' Y- f. M- J0 K/ V) t5 N8 [1 Y
  58. 58     }
    # E6 r  [! Q/ h2 b# e) Z8 h
  59. 59     RTC_NVIC_Config();//RCT中断分组设置                                 
    ' Z+ C5 n5 z: [0 d, D% F
  60. 60     RTC_Get();//更新时间   
    ! ]8 G' p. q' f; Y/ H2 |
  61. 61     return 0; //ok
    $ ^" I; X6 `4 M3 [, n0 o0 [* t9 H
  62. 62
    / A! O- R0 s. j
  63. 63 }                             
    ( d2 u& c% e, ^& y9 O3 S9 e
  64. 64 //RTC时钟中断
    & Y; W$ ^4 e% ?) o* G' y# s% h# j
  65. 65 //每秒触发一次  - s9 `, D5 z  |$ Y+ T  B: X* [
  66. 66 //extern u16 tcnt; ! I4 }$ Y! l- N; P2 k5 X2 |- X8 \
  67. 67 void RTC_IRQHandler(void)9 o0 A) t+ P0 t4 x) y% _5 t( b
  68. 68 {         3 c, p2 X2 b8 _$ _! H9 {
  69. 69 //    if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断
    % p# m6 T7 ]  U; `
  70. 70 //    {                           
      d/ n$ i3 v* y
  71. 71 //        RTC_Get();//更新时间   " b+ E2 U; G2 l
  72. 72 //     }
    ; l- E- ?( v& V
  73. 73 //    if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断% r5 H1 J9 A" T
  74. 74 //    {1 {5 q2 {* w! U, h' S9 C7 D! f
  75. 75 //        RTC_ClearITPendingBit(RTC_IT_ALR);        //清闹钟中断          ; a- @3 i- j/ c  s' g2 i
  76. 76 //      RTC_Get();                //更新时间   ; e+ m: V5 d. n, o; C. \
  77. 77 //      //printf("Alarm Time:%d-%d-%d %d:%d:%d\n",calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);//输出闹铃时间   
    , |( R9 S$ \# \- @8 }- o1 G
  78. 78 //        
    * W, Z: {5 V  n1 @
  79. 79 //      }                                                    " O5 F( U2 N: x
  80. 80     RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);        //清闹钟中断- D8 v5 Z8 j* }. o! G" k
  81. 81     RTC_WaitForLastTask();                                                   
    / v# a7 `6 R! G8 u- H% L; `
  82. 82 }
    ; t2 r5 n; X' s4 {3 ^0 h
  83. 83
    ' [6 h' ]0 s; m
  84. 84 ( c" w. e0 f/ k5 w/ m( ?1 n% |
  85. 85 //判断是否是闰年函数
    6 U- z" t" D$ c8 o1 c- _
  86. 86 //月份   1  2  3  4  5  6  7  8  9  10 11 12' _: @1 u0 j7 t! r8 Y+ z& ?+ l( S
  87. 87 //闰年   31 29 31 30 31 30 31 31 30 31 30 31# v: k7 N4 p. ?# _: k
  88. 88 //非闰年 31 28 31 30 31 30 31 31 30 31 30 31
    ; A  a- `  L! a) k& U4 H2 M
  89. 89 //输入:年份# X( r. u! G/ i* d% I1 N- S6 `" }0 P( M
  90. 90 //输出:该年份是不是闰年.1,是.0,不是- e$ L1 `" O- `' C- m7 W
  91. 91 u8 Is_Leap_Year(u16 year)
    % K; X7 E$ b' S$ X; j! n
  92. 92 {              
    & b" S3 j) r  D/ Y* _% x
  93. 93     if(year%4==0) //必须能被4整除
    9 d% q2 T/ g9 C" k2 T2 u" U. j
  94. 94     { 3 \& J" F+ S/ A1 t, Y2 c
  95. 95         if(year%100==0)
    2 L+ P0 I0 |) c9 r  k4 N, d
  96. 96         { 5 w6 j7 x$ u/ W9 }& @
  97. 97             if(year%400==0)return 1;//如果以00结尾,还要能被400整除        ( }) @/ J/ g4 V$ I1 E- t/ S" k8 u: U# c
  98. 98             else return 0;   
    , k. A/ P% |6 _6 I: ]* z) W  R
  99. 99         }else return 1;   / }9 m4 I) V7 w+ s  m0 v
  100. 100     }else return 0;   
    * s. D. d" ]7 N- g, B
  101. 101 }
    / C# ?5 Y1 o* S: x# ?
  102. 102 1 k0 [. q- g1 Q+ d1 C' x4 y
  103. 103 2 h& l) K/ b* K, Z3 b8 ?2 G% J" ^
  104. 104 //设置时钟" b& [/ `5 @4 e$ k
  105. 105 //把输入的时钟转换为秒钟7 ]( @! J" k/ g% c  F% I5 n
  106. 106 //以1970年1月1日为基准3 D0 B7 v$ y; w' w( v6 U
  107. 107 //1970~2099年为合法年份' [  o& o7 K" J
  108. 108 //返回值:0,成功;其他:错误代码.
    - L# t6 x0 I8 s3 e" [+ S3 t- M
  109. 109 //月份数据表                                             
    / Q/ f/ n% m" Z. s  O* s4 @! M
  110. 110 const u8  table_week[12]={0,3,3,6,1,4,6,2,5,0,3,5}; //月修正数据表      
    . u+ R0 ~/ I& Y6 y
  111. 111 const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};//平年的月份日期表  L( X' K0 C4 r. u$ f6 o- P% o
  112. 112
    8 M. j: l3 y5 V: o3 e: t; h. x' E6 o' X
  113. 113 u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
    : w/ e6 \* Q9 d/ t5 ?: h
  114. 114 {
    $ i0 Z4 _  y0 U$ J- i7 e) v
  115. 115     u16 t;$ A0 G! s) K  }6 J. p* C  _) V0 K' T
  116. 116     u32 seccount=0;7 |; U2 l3 L6 n3 C6 J" \
  117. 117     if(syear<1970||syear>2099)return 1;      
    ; h3 L9 }6 q" z6 z4 Q0 e, a
  118. 118     for(t=1970;t<syear;t++)    //把所有年份的秒钟相加
    1 e! m' U! O: C& O. i" [# o
  119. 119     {
    . s8 [( \4 j/ O" \3 g
  120. 120         if(Is_Leap_Year(t))seccount+=31622400;//闰年的秒钟数
    4 \3 I' Z* Z& C( N: M& }# B
  121. 121         else seccount+=31536000;              //平年的秒钟数3 F' D7 o( X, l- R+ \; Z; [5 y) V
  122. 122     }9 S! b% w6 p* Z/ J% `
  123. 123     smon-=1;
    ) E! C/ s4 ]  p7 o! o* X
  124. 124     for(t=0;t<smon;t++)       //把前面月份的秒钟数相加* x* ~5 `- ]7 e  \+ P
  125. 125     {9 s- ]+ b/ d8 m1 B/ H
  126. 126         seccount+=(u32)mon_table[t]*86400;//月份秒钟数相加
    6 v6 K& [2 v8 X4 x
  127. 127         if(Is_Leap_Year(syear)&&t==1)seccount+=86400;//闰年2月份增加一天的秒钟数       2 A# {8 w+ r: [' P! ~
  128. 128     }
    ! \  v: l7 D: X' x! Q; T
  129. 129     seccount+=(u32)(sday-1)*86400;//把前面日期的秒钟数相加 7 K- o, V) {7 j# T6 w. b3 {
  130. 130     seccount+=(u32)hour*3600;//小时秒钟数
    9 o9 a/ x7 A; w
  131. 131     seccount+=(u32)min*60;     //分钟秒钟数
    1 n$ d. M& q/ j2 u6 U
  132. 132     seccount+=sec;//最后的秒钟加上去, ?8 f3 ?) d$ N& T5 W# U" ?
  133. 133 6 g, N2 Q" O4 n6 p' ^. ~  P
  134. 134     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟  0 f. L- M+ p) j/ Y* P% u- A. [- b
  135. 135     PWR_BackupAccessCmd(ENABLE);    //使能RTC和后备寄存器访问 & x, q# j* x5 y$ K
  136. 136     RTC_SetCounter(seccount);    //设置RTC计数器的值+ |3 Q  v+ m( Z4 @1 c- u/ |" ^
  137. 137
    0 Y; }" H0 C$ A( n3 b& j8 V
  138. 138     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成      ! V4 U4 p+ @3 Y% K- u
  139. 139     return 0;        0 d# Z+ p% H1 F+ A# O' [0 }. `' p5 d: _
  140. 140 }
    ' `% {1 \; x4 M8 N8 C
  141. 141 7 d7 _- a! O; l
  142. 142 //初始化闹钟         
    # j+ q% _7 S: {% r% K
  143. 143 //以1970年1月1日为基准
    5 u3 {) P' O2 b( q% J
  144. 144 //1970~2099年为合法年份
    5 q7 |, A9 `# v* ]
  145. 145 //syear,smon,sday,hour,min,sec:闹钟的年月日时分秒   
    2 \+ ^7 J  O" h: n) a8 v
  146. 146 //返回值:0,成功;其他:错误代码.0 t# Q; h$ Z& O! ]; E, @
  147. 147 u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)
    + O3 d5 C" B% @4 i: S% ]* k% \
  148. 148 {
    / P+ P4 h/ b2 ~. T
  149. 149     u16 t;
    0 D& v9 V$ o- I% w8 D% b
  150. 150     u32 seccount=0;
    $ D! I8 I% M/ D7 I7 I+ X
  151. 151     if(syear<1970||syear>2099)return 1;       ) D4 C3 F7 G4 t% @: t4 z* k* K0 k
  152. 152     for(t=1970;t<syear;t++)    //把所有年份的秒钟相加
    ! z3 L  N4 \0 g) [1 b5 `) t
  153. 153     {
    / P$ B: m  f/ v$ m8 n
  154. 154         if(Is_Leap_Year(t))seccount+=31622400;//闰年的秒钟数
    " Q$ y: p! r3 B1 z, \4 U
  155. 155         else seccount+=31536000;              //平年的秒钟数
    % {4 G; q; U: o9 v
  156. 156     }& k* V+ K4 r* U  ]' b, \
  157. 157     smon-=1;/ L' S. U# Z- |! J
  158. 158     for(t=0;t<smon;t++)       //把前面月份的秒钟数相加
    ! T' z1 y5 q" H/ K# v& d  D
  159. 159     {
    6 \$ g* H! O$ W, b+ i8 X
  160. 160         seccount+=(u32)mon_table[t]*86400;//月份秒钟数相加
    $ u! v& l2 D$ ^0 q  x9 D* r
  161. 161         if(Is_Leap_Year(syear)&&t==1)seccount+=86400;//闰年2月份增加一天的秒钟数       : ^6 K% H+ r1 `0 l. u
  162. 162     }
    5 ?& r; l% y: r/ X2 }7 b: Y6 S! j
  163. 163     seccount+=(u32)(sday-1)*86400;//把前面日期的秒钟数相加 - {+ d* S1 }" L8 S5 \% u
  164. 164     seccount+=(u32)hour*3600;//小时秒钟数& \4 G% c/ d' @' E9 P' F! ^
  165. 165     seccount+=(u32)min*60;     //分钟秒钟数0 y+ W; ~) g* s5 I" z6 Q8 `
  166. 166     seccount+=sec;//最后的秒钟加上去                 
      N' c" B9 h8 k: d. v
  167. 167     //设置时钟7 W' I+ Z. S0 R8 h- C/ e$ Y
  168. 168     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟   6 C3 h3 b( Z8 J- Q6 _$ C
  169. 169     PWR_BackupAccessCmd(ENABLE);    //使能后备寄存器访问  % d  K5 Y  H  Y
  170. 170     //上面三步是必须的!/ `* J& Z! |3 T% N
  171. 171     
    + y- W! ^& q. I: B' G: _& F4 G
  172. 172     RTC_SetAlarm(seccount);" P6 w2 H4 H+ u
  173. 173  * L& k/ |3 w3 ]: g
  174. 174     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成      / w2 h7 V- }& w
  175. 175     $ m/ J3 ?# F! n' d# Y& [; F
  176. 176     return 0;        
    ' |/ p& `; W' ?8 B3 D" c
  177. 177 }  o1 A6 X. k6 M
  178. 178
    6 C& y! u, e' {. \
  179. 179 . V7 j; h' R0 t7 u- {! q/ }
  180. 180 //得到当前的时间
    ( [9 d0 g: t1 ?* L" x
  181. 181 //返回值:0,成功;其他:错误代码.
    ! E6 f" E4 E7 a4 Q3 q# g
  182. 182 u8 RTC_Get(void)- s( f4 @. H' N8 U- D( \
  183. 183 {
    5 O6 V. m5 X6 D5 @( N8 c
  184. 184     static u16 daycnt=0;
    + v9 A3 e& ~# f( u
  185. 185     u32 timecount=0; ; P/ [8 L7 x* |1 R! V- ?
  186. 186     u32 temp=0;8 ^% C4 O  X( s$ M  Q+ y9 Y
  187. 187     u16 temp1=0;      
    3 z* q/ H0 S+ q& V3 o
  188. 188     timecount=RTC_GetCounter();     
    0 C$ m5 _* [" U1 g2 Y* V5 Z
  189. 189      temp=timecount/86400;   //得到天数(秒钟数对应的)+ V( G% \3 x8 L1 b. k
  190. 190     if(daycnt!=temp)//超过一天了
    $ `" P( B) S6 k% w# O. [7 a2 P7 ~7 ?
  191. 191     {      $ X1 m' C; T4 _; s0 l$ ~& m! s
  192. 192         daycnt=temp;
    ; t$ v& x( d3 |
  193. 193         temp1=1970;    //从1970年开始
    * v. V( {" q! n" }/ t9 \
  194. 194         while(temp>=365)
    5 R/ R+ V% ]' [* j9 H
  195. 195         {                 . b) f$ \9 e' \) F& ]. E( K
  196. 196             if(Is_Leap_Year(temp1))//是闰年
    8 a8 S5 x# Q, ]
  197. 197             {
    ! n0 a2 w  D. v# k/ J' T4 ~
  198. 198                 if(temp>=366)temp-=366;//闰年的秒钟数
    $ K% C7 r# S! Y  y
  199. 199                 else {temp1++;break;}  
    2 p" d/ |" S/ R
  200. 200             }) a& n1 Z1 j* w1 R3 g# R6 m
  201. 201             else temp-=365;      //平年 " m. A! f8 D* ^  A/ K6 I
  202. 202             temp1++;  
    ! r: q9 |; c7 X) ~
  203. 203         }   
    ) ^9 ^6 F" P' {+ h
  204. 204         calendar.w_year=temp1;//得到年份
    # B2 h' L- H( j9 C$ P( ~5 h
  205. 205         temp1=0;
    3 l' \6 Z8 @. T9 ]4 F0 }; r  b
  206. 206         while(temp>=28)//超过了一个月
    ' S) n' i3 a0 Y& ~" ^9 p' J
  207. 207         {
    4 C# G+ d  I. r' M9 k0 e' k
  208. 208             if(Is_Leap_Year(calendar.w_year)&&temp1==1)//当年是不是闰年/2月份
    2 [. l" B% |. _7 s
  209. 209             {. f! N+ i3 k* }. f) R: [
  210. 210                 if(temp>=29)temp-=29;//闰年的秒钟数  I3 _9 U/ f3 ?9 V& W
  211. 211                 else break;
    5 O) x( N& _8 x
  212. 212             }# B# Z: D; V" T
  213. 213             else ; y% O. z- g# d( a
  214. 214             {( F8 B8 R: w; e0 Z
  215. 215                 if(temp>=mon_table[temp1])temp-=mon_table[temp1];//平年1 d+ f2 ?) ?/ z
  216. 216                 else break;
    % R. g; b! {4 y
  217. 217             }
      _- K" V2 |. {. i: U9 _+ w
  218. 218             temp1++;  
    & Z7 P% ^" s) K" t3 K
  219. 219         }& Y  X- ]& o# q" M0 Q" _4 ^% L
  220. 220         calendar.w_month=temp1+1;    //得到月份
    ; {' O4 {& o0 ?' M
  221. 221         calendar.w_date=temp+1;      //得到日期 / }8 ~( D7 c( Z, B* Y% s
  222. 222     }
    # B9 z& z3 m5 z8 i3 V' V
  223. 223     temp=timecount%86400;             //得到秒钟数         
    - `0 L' O4 r( U( o3 J! d& N
  224. 224     calendar.hour=temp/3600;         //小时
    , y$ c5 O8 g$ ~2 ~# ]2 H
  225. 225     calendar.min=(temp%3600)/60;     //分钟    $ a! ^8 i/ U2 e+ d; b2 p
  226. 226     calendar.sec=(temp%3600)%60;     //秒钟
    ) [0 c# ~/ G$ _1 i! h
  227. 227     calendar.week=RTC_Get_Week(calendar.w_year,calendar.w_month,calendar.w_date);//获取星期# W$ A, E5 o! D/ C# S
  228. 228     calendar.msec=(32767-RTC_GetDivider())*    1000/32767;
    - c  {! V( l" [
  229. 229     return 0;! j! e/ a- i8 D
  230. 230 }    8 N$ L) T3 u( n7 O% Q" n
  231. 231 0 N) N# H8 @- j7 N. A5 V
  232. 232 $ `. L" _0 D8 s- I; Y5 N$ c/ w
  233. 233 //获得现在是星期几" w) p. f$ w- j- g/ J6 }7 i+ S% G5 |
  234. 234 //功能描述:输入公历日期得到星期(只允许1901-2099年)
    + ]( ~3 C4 }7 @" x/ u2 _9 X7 o* [
  235. 235 //输入参数:公历年月日
    $ |' z% K' w1 F( ^* k# _3 S( N; G
  236. 236 //返回值:星期号                                                                                         : Q9 S% {3 Q. l. Y) v) t: w
  237. 237 u8 RTC_Get_Week(u16 year,u8 month,u8 day)( A1 y: u' T5 F5 O
  238. 238 {   
    / w! w  ?  y- n
  239. 239     u16 temp2;: @+ f7 k, M$ I3 w" @& f& k
  240. 240     u8 yearH,yearL;) |, g5 N* i; B* J8 J. N
  241. 241     
    6 j" H9 \3 A6 ^* a' l
  242. 242     yearH=year/100;    yearL=year%100;
    2 L4 i; s9 E! ^9 n
  243. 243     // 如果为21世纪,年份数加100  
    3 K9 B" X7 d9 G. ~+ Y, @( ^' A
  244. 244     if (yearH>19)yearL+=100;. b" V9 v- E# Z7 X& i
  245. 245     // 所过闰年数只算1900年之后的  5 z" g9 ^7 K4 F6 e4 `% W
  246. 246     temp2=yearL+yearL/4;# `4 ?- Z; h/ [" d2 @- ?
  247. 247     temp2=temp2%7; 2 M( Q" g6 ~% K: r
  248. 248     temp2=temp2+day+table_week[month-1];
    6 A4 \/ h0 e9 h6 m( n
  249. 249     if (yearL%4==0&&month<3)temp2--;& o, j8 ^# h" [* r# f
  250. 250     return(temp2%7);
    5 f5 M- m& O1 f* Q4 c
  251. 251 }   
复制代码
  1. 1 #include "sys.h"
    9 T+ m/ H* @2 v& X. n
  2. 2 ; p0 e( x) t& W! @$ L
  3. 3 //时间结构体
    7 z, |5 X- r' \  y
  4. 4 typedef struct / _3 B8 ^4 g, r. O6 H
  5. 5 {8 S- R* v. \+ I- E' ]7 e
  6. 6     vu8 hour;//vu8; ?( n# |& K0 w  o* s$ Q0 y, [
  7. 7     vu8 min;
    : W9 H, N8 S4 _- g' u
  8. 8     vu8 sec;/ A- y4 `0 b$ x" h% r& Z/ x
  9. 9     vu16 msec;
    9 c2 L, q8 P+ w* C3 j+ A0 K  p
  10. 10     ( t. o* ^8 b& R& x
  11. 11     //公历日月年周
      f( H6 G* k. R) }( Q
  12. 12     vu16 w_year;; {+ I4 d# m- {7 ^, E( g5 S0 ~5 m
  13. 13     vu8  w_month;
    ; z4 H' A/ T3 E, ?) K7 a
  14. 14     vu8  w_date;
    - [. g& R% G. O  }
  15. 15     vu8  week;         
    * Z; Y$ x6 b) s5 _
  16. 16 }_calendar_obj;                     
    ! {, \; K/ X6 ]  }/ U
  17. 17
    7 H/ ]  e1 W! q9 E  Q
  18. 18 extern _calendar_obj calendar;    //日历结构体  Z; P" N' q# z. s" J
  19. 19 extern u8 const mon_table[12];    //月份日期数据表, ]$ m: p2 q" W% D/ _
  20. 20
    ) H# Z- d: i; k. T5 j' y
  21. 21 u8 RTC_Init(void);        //初始化RTC,返回0,失败;1,成功;
    + a" d, J1 x6 ^9 l( ?; Z* m
  22. 22 u8 Is_Leap_Year(u16 year);//平年,闰年判断
    ' `! H: W: L. l8 K/ b- l& p) _
  23. 23 ( B6 V& ~; J7 E% A
  24. 24 //u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);5 B) b6 `0 p6 A5 T
  25. 25 u8 RTC_Get(void);         //更新时间   5 f. ]# Q: ~: O9 \
  26. 26 u8 RTC_Get_Week(u16 year,u8 month,u8 day);# z% L6 n! y, t
  27. 27 u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);//设置时间   
复制代码
0 Q; b3 `4 }& {' r
4、秒钟计时原理
使用外部32.768KHz的晶振作为时钟的输入频率,设置预分频装载寄存器的值为32767,根据计算公式,刚好可以得到1秒的计数频率。时间基准设置为1970年1月1日0时0分0秒,后续的时间都以这个为基准进行计算。RTC计数器是32位的,理论上可以记录136年左右的时间。(注意不必在秒中断里更新时间)
/ F0 l* w" x$ O3 H
& a0 ~1 J4 M4 y+ g* [! ^9 s
5、毫秒计时原理
如果要获取到毫秒级的时钟怎么办?在我的项目中就有这样的要求。事实上,获取毫秒时钟也非常简单。
查阅开发指南,RTC预分频器余数寄存器(RTC_DIVH、RTC_DIVL),这两个寄存器的作用就是用来获得比秒钟更为准确的时钟。 该寄存器的值自减的,用于保存还需要多少时钟周期获得一个秒信号。在一次秒钟更新后,由硬件重新装载。这两个寄存器和 RTC 预分频装载寄存器位数是一样的。也就是说,如果预分频装载寄存器的值为32767,那么余数寄存器就会在每一次秒更新时由硬件重新装载为32767,然后向下计数,计数到0表示一秒,也即1000ms。
  因此,我们在时钟结构体中添加msec成员
  1. 1 //时间结构体+ v" P- y- t7 m
  2. 2 typedef struct
    8 L2 M" q3 a' n- p% q9 r6 T6 d3 k
  3. 3 {( m+ s7 Z) z9 }$ D$ X
  4. 4     vu8 hour;//vu8
    $ v9 y9 \/ C  m6 I0 V: A
  5. 5     vu8 min;3 H. h8 M: V! n  d6 x0 V0 [
  6. 6     vu8 sec;- z3 a' b  ^% C# y) u# {- N
  7. 7     vu16 msec;
    ) a7 k$ s! H2 W5 {- z' t. Z
  8. 8     
    * H$ ?+ e! V0 H/ f
  9. 9     //公历日月年周# k" B/ ?' H2 u7 ~+ N, J, I9 g
  10. 10     vu16 w_year;/ I* r5 Q0 l6 H$ R
  11. 11     vu8  w_month;
    , B7 p* V7 B* w: K+ G% Z; Y
  12. 12     vu8  w_date;) x! f+ d' q3 q+ }6 k8 {/ N5 e
  13. 13     vu8  week;         5 n. Z: ?+ Y1 x1 v3 S# A
  14. 14 }_calendar_obj;  
复制代码

* d& v$ K: V& d" I/ ~
 获取毫秒时间
  1. 1 calendar.msec=(32767-RTC_GetDivider())*1000/32767;
复制代码

: U+ o9 G1 V& r' o6、修改时间  
   如果RTC时钟在使用的过程中不准了(我遇到的情况大概是掉电跑了2个月,重新测试的时候差了2分钟左右),可以重新校准时钟。我们在备份区域 BKP_DR1 中写入 0X5051 ,下次开机(或复位)的时候,先读取 BKP_DR1 的值,然后判断是否是 0X5051来决定是不是要配置。 如果要修改时间,请将0x5051改为其它数据,修改RTC_Set函数实参,再重新烧写一下程序即可。
0 b) O. u5 }$ E  _6 O+ Z" g
  1. if (BKP_ReadBackupRegister(BKP_DR1) != 0x5051)
    7 z, N( d) g+ N0 B5 P
  2. {9 r% M6 I3 Z3 @; P; V3 g3 U
  3.     ...6 d1 {: g; k6 y3 Z4 J
  4.     RTC_EnterConfigMode();/// 允许配置    , @. q; Z& P# @. I
  5.     RTC_SetPrescaler(32767); //设置RTC预分频的值
    ( j3 ?5 O) P7 ]
  6.     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成0 e7 D# d7 L5 ~
  7.     RTC_Set(2018,4,2,17,37,00);  //设置时间    9 t% L1 H" l; S7 o
  8.     RTC_ExitConfigMode(); //退出配置模式  7 d1 u; s2 B5 i) _
  9.     BKP_WriteBackupRegister(BKP_DR1, 0X5051);    //向指定的后备寄存器中写入用户程序数据    ; d2 M2 G1 ]/ D% H" O
  10. }
复制代码

& Z  x7 _  J, P' a5 g
赞 收藏 1 评论0 发布时间:2022-1-13 20:47

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版