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

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

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

      o/ r0 K1 T% g3 V# q

" W$ H. j6 {0 k. D6 l+ P2、软硬件设计
  由于RTC是STM32芯片自带的时钟资源,所以自主开发的时候只需要在设计时加上晶振电路和纽扣电池即可。编程时在HARDWARE文件夹新建 rtc.c、rtc.h 文件。

9 i$ S" ^/ [' S. e( G( g) {" ]8 B* [
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)
闰年判断

0 k3 q1 E1 T1 l7 [. }
 事实上,以上函数并不都要,闹钟没有用到的话就不要,秒中断也可以不作处理,看项目需求。
  1.   1 #include "sys.h"
    . I4 `6 A4 n. m
  2.   2 #include "delay.h"
    & o& Z7 h  d% [4 Q$ x8 k7 R  o3 k
  3.   3 #include "rtc.h"            
    " f- C$ V  k' _7 J6 c
  4.   4        
    & P) G+ p5 S2 I: R4 W% x9 k3 q* b
  5.   5 _calendar_obj calendar;//时钟结构体
    ( e- C& a2 B/ d1 q- \5 t
  6.   6  / d& R6 n5 h  q4 V+ r9 d
  7.   7 static void RTC_NVIC_Config(void)1 D4 o+ _, E% B" c2 P: C
  8.   8 {    % a& o$ n0 W7 U
  9.   9     NVIC_InitTypeDef NVIC_InitStructure;
    7 r+ y( I; o9 \7 s( ~. F, v' i
  10. 10     NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;        //RTC全局中断
    . M) b. G, T5 c
  11. 11     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;    //先占优先级1位,从优先级3位1 v% o( P- a8 h9 @2 R; I8 t2 a
  12. 12     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;    //先占优先级0位,从优先级4位
    - n0 v3 ?6 ]0 C3 Y! c" d! |7 z
  13. 13     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;        //使能该通道中断, ^5 i& y3 s% {" E
  14. 14     NVIC_Init(&NVIC_InitStructure);        //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器: U: ]  X3 j( \5 i
  15. 15 }* M& t1 Y4 a$ S  z& \
  16. 16
    8 A  N3 X! k: w( n7 ^" e
  17. 17 //实时时钟配置
    & }# i' ?$ A# @6 K
  18. 18 //初始化RTC时钟,同时检测时钟是否工作正常3 h9 k2 x2 X$ s2 S1 d8 t
  19. 19 //BKP->DR1用于保存是否第一次配置的设置
    + g3 u& Z1 D1 V( ]9 G
  20. 20 //返回0:正常! D" b! v! E$ G) H4 \  h9 c+ j
  21. 21 //其他:错误代码, f4 d1 }8 G! ~) |! U4 d
  22. 22 2 v8 ], |2 A7 K  J1 y
  23. 23 u8 RTC_Init(void)) ?% y* z1 e# I! L( s/ c- h+ \: B: t
  24. 24 {  d3 D  z% G/ T0 E1 |2 [+ `
  25. 25     //检查是不是第一次配置时钟
    6 F' X% E# V: T/ {
  26. 26     u8 temp=0;# x! D% o; d, l  P2 S0 e
  27. 27     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟   
    - ?/ o" {* h4 V4 V- R, M8 U( e% J: ~
  28. 28     PWR_BackupAccessCmd(ENABLE);    //使能后备寄存器访问  5 ^- w& |4 c/ ^3 C) @
  29. 29     if (BKP_ReadBackupRegister(BKP_DR1) != 0x5051)        //从指定的后备寄存器中读出数据:读出了与写入的指定数据不相乎. u$ V' o6 B5 z: l' M0 u
  30. 30     {                  
    2 `8 }! ^$ w$ k- v% ?: ^
  31. 31         BKP_DeInit();    //复位备份区域     
    ( m& d6 y, S- u8 [% H* ^( R
  32. 32         RCC_LSEConfig(RCC_LSE_ON);    //设置外部低速晶振(LSE),使用外设低速晶振
    2 Z, Z+ f! }* u: y
  33. 33         while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET&&temp<250)    //检查指定的RCC标志位设置与否,等待低速晶振就绪8 C* O! i. C* I3 \) c' Z
  34. 34         {: Y0 {* B  s7 H: F$ |" ]# `4 u; D
  35. 35             temp++;
    3 S. Z" Y+ E) ]% A: g- {$ A: s: U$ Q* c
  36. 36             delay_ms(10);7 m5 o* n4 o! u5 A* }! x6 Y3 B% z
  37. 37         }
    # G3 Z7 F5 O' i$ n4 J& c
  38. 38         if(temp>=250)return 1;//初始化时钟失败,晶振有问题        
    6 ^) a5 B7 s! Q2 F8 I( T
  39. 39         RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);        //设置RTC时钟(RTCCLK),选择LSE作为RTC时钟   
    - A) k: ?# b* K  y3 T# d$ _
  40. 40         RCC_RTCCLKCmd(ENABLE);    //使能RTC时钟  
    & X% D" x- v1 S
  41. 41         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成0 \/ Q+ d2 F( G" M4 b% b
  42. 42         RTC_WaitForSynchro();        //等待RTC寄存器同步  
    * k! s1 F0 ]' N9 Z/ k
  43. 43         RTC_ITConfig(RTC_IT_SEC, ENABLE);        //使能RTC秒中断
    $ O" h) W& \" q" O* d
  44. 44         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
    , A2 E+ U. U  I6 i
  45. 45         RTC_EnterConfigMode();/// 允许配置    / |6 U5 z7 L/ _- M" a1 y
  46. 46         RTC_SetPrescaler(32767); //设置RTC预分频的值* w; w3 f" G% p9 [. b7 }
  47. 47         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成. h4 P% s% ~6 F% }$ T8 u
  48. 48         RTC_Set(2018,4,2,17,37,00);  //设置时间    6 D6 L+ t+ F$ l, c6 b7 f6 g
  49. 49         RTC_ExitConfigMode(); //退出配置模式  
    ) {5 S+ M, _0 e
  50. 50         BKP_WriteBackupRegister(BKP_DR1, 0X5051);    //向指定的后备寄存器中写入用户程序数据% |! f$ r+ T; f( J/ \6 f* w
  51. 51     }, P( I/ I3 W0 n3 T  j; z/ l
  52. 52     else//系统继续计时6 a7 a$ O) P+ M
  53. 53     {4 E9 n- ^3 k( b5 W( [+ G
  54. 54
    4 y. j4 O; c  L& c) O. z6 H
  55. 55         RTC_WaitForSynchro();    //等待最近一次对RTC寄存器的写操作完成, y3 ?1 ~8 p; x  a" a6 q
  56. 56         RTC_ITConfig(RTC_IT_SEC, ENABLE);    //使能RTC秒中断* a' U4 M9 f" \4 F
  57. 57         RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成) F; B: W6 Z. K( s. n
  58. 58     }7 r! O& _9 P- t( g2 W
  59. 59     RTC_NVIC_Config();//RCT中断分组设置                                 ' f' _0 o7 K$ @6 v" H' T
  60. 60     RTC_Get();//更新时间    2 f% F8 D( v1 p9 T: t6 k
  61. 61     return 0; //ok& \* U, k4 Y* u  L4 e4 S, R2 Z9 S
  62. 62 3 D# |7 I( c1 k
  63. 63 }                             
    - @& l: X0 G5 ^5 T; |# ^
  64. 64 //RTC时钟中断
    9 c' e1 V8 x9 e0 B* w  M7 h
  65. 65 //每秒触发一次  
    & j9 M' Y! G6 }5 N3 {, g" ?! M
  66. 66 //extern u16 tcnt;
    # U" s) z! w; Z2 ]* z4 `, o- f$ a
  67. 67 void RTC_IRQHandler(void), B2 \( J% _$ s$ {' e
  68. 68 {         
    ) |7 O+ Q' s; O
  69. 69 //    if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断
      {. l% g, C/ ?
  70. 70 //    {                           
    8 T( w# e9 K5 R9 F
  71. 71 //        RTC_Get();//更新时间   
    # ?8 A. Q  C2 u% Y0 j/ j+ I
  72. 72 //     }6 O# D- m5 p) d  T9 {% q3 I8 X
  73. 73 //    if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断
    " s6 A% s/ n2 N- G
  74. 74 //    {6 Z! J4 k. R& J; Y  l
  75. 75 //        RTC_ClearITPendingBit(RTC_IT_ALR);        //清闹钟中断         
    * O, C6 k  g$ g
  76. 76 //      RTC_Get();                //更新时间     i# Y, J) d- F2 m' m
  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);//输出闹铃时间    3 y( o+ ?6 o4 w9 i
  78. 78 //        ( f. J# ^# u! [1 I) \1 ?
  79. 79 //      }                                                   
    ' ]# G/ L* d- N8 y
  80. 80     RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);        //清闹钟中断
    $ w& \3 P9 [1 \( b" o1 F" q8 S
  81. 81     RTC_WaitForLastTask();                                                   ' d. J- f/ m- P6 y
  82. 82 }
    , f! q4 o, ~& L4 J+ t# X- j9 I0 b( l8 x
  83. 83 7 n- x6 W5 T: |
  84. 84
    . e* v+ J; G" L3 e
  85. 85 //判断是否是闰年函数
    ' n7 H" C/ c4 V' L
  86. 86 //月份   1  2  3  4  5  6  7  8  9  10 11 12
    " ^5 V. z3 P! U3 |# k1 b4 q& j
  87. 87 //闰年   31 29 31 30 31 30 31 31 30 31 30 31
    4 z' _1 O* C* C3 o
  88. 88 //非闰年 31 28 31 30 31 30 31 31 30 31 30 31. A1 {7 {( U- Z  Y1 W" z0 j
  89. 89 //输入:年份; ~; D5 \4 u0 V3 |9 j  X
  90. 90 //输出:该年份是不是闰年.1,是.0,不是
    % _' u4 K1 |* j- O+ X- M$ i6 {
  91. 91 u8 Is_Leap_Year(u16 year)
    & ]9 W- ?+ T/ k) g" D
  92. 92 {              9 c- l, ]8 G4 V( c; _
  93. 93     if(year%4==0) //必须能被4整除6 U+ e* |) ?+ S( s1 c1 C3 Z7 r& T2 s
  94. 94     { % s( S0 V( z! \: \/ c; f
  95. 95         if(year%100==0) 8 Y; R) `0 `# D5 B: [
  96. 96         {
    : W5 k5 R! X- |2 p9 S% r. a* m
  97. 97             if(year%400==0)return 1;//如果以00结尾,还要能被400整除        . P6 x; t- k: }6 R: e$ x
  98. 98             else return 0;   , D( z  k* |$ s9 \* {9 g
  99. 99         }else return 1;   
    + ^2 h" ^  S6 `+ _
  100. 100     }else return 0;    9 U. o7 B% T7 w8 ^6 [, g
  101. 101 }3 `6 i$ m/ z: _6 C. a( m
  102. 102 * R/ Q- [# l: k
  103. 103
    + H5 I* ?6 j4 n; ]8 G( Y8 y
  104. 104 //设置时钟! m8 E: r0 `- ^8 @) Z  D' R
  105. 105 //把输入的时钟转换为秒钟) U: C" |7 c! j, P
  106. 106 //以1970年1月1日为基准/ f5 b% @- t8 z! g0 O# C
  107. 107 //1970~2099年为合法年份1 W6 n9 ^4 ?" s3 J- w' Y2 y7 d  M
  108. 108 //返回值:0,成功;其他:错误代码.- J4 e# g# |# u% p1 {* J! @
  109. 109 //月份数据表                                             
    + _) y  B, {. @& U$ }
  110. 110 const u8  table_week[12]={0,3,3,6,1,4,6,2,5,0,3,5}; //月修正数据表      ) {6 ]3 ^& F* V
  111. 111 const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};//平年的月份日期表
    1 O7 `# Q, ], {  b. R# d4 c0 O: s5 q3 W
  112. 112 5 H& f# o4 y2 M# v2 ]
  113. 113 u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)) v, v% F1 M9 }2 R$ I2 q
  114. 114 {# i# ~8 I1 G# O  k# N
  115. 115     u16 t;' m# A* W# {- W" t! t) c! H
  116. 116     u32 seccount=0;
    4 }. {/ g! M5 Y: e
  117. 117     if(syear<1970||syear>2099)return 1;       6 |. U( s5 [8 ]7 j
  118. 118     for(t=1970;t<syear;t++)    //把所有年份的秒钟相加
    8 z3 E% R! o& l3 M1 X
  119. 119     {
    2 ?0 Z4 v. R9 G; r) n! V
  120. 120         if(Is_Leap_Year(t))seccount+=31622400;//闰年的秒钟数
    , A& B# F9 }- ~5 R( b1 `$ Z8 F% N
  121. 121         else seccount+=31536000;              //平年的秒钟数1 \) N8 N( X8 b. E' ^( w' d
  122. 122     }
    0 i/ y5 T4 ]1 _& C& Z/ O
  123. 123     smon-=1;0 d# I* s5 F, x3 K: w
  124. 124     for(t=0;t<smon;t++)       //把前面月份的秒钟数相加
    0 k9 k5 i1 ~% p. B- T2 Y
  125. 125     {
    5 a5 G* ~: Z) f
  126. 126         seccount+=(u32)mon_table[t]*86400;//月份秒钟数相加5 P" L( I6 O* W2 ~- k
  127. 127         if(Is_Leap_Year(syear)&&t==1)seccount+=86400;//闰年2月份增加一天的秒钟数      
    . ]7 i5 e& h! y) Z$ X
  128. 128     }& Q- o' h5 ]0 p, K$ P, A# H# g+ J
  129. 129     seccount+=(u32)(sday-1)*86400;//把前面日期的秒钟数相加 # E2 v8 C. c$ `5 U2 p- O
  130. 130     seccount+=(u32)hour*3600;//小时秒钟数2 K# k$ a6 Y4 Z+ |( T9 \9 S
  131. 131     seccount+=(u32)min*60;     //分钟秒钟数. _0 R8 T8 p$ \( S# f
  132. 132     seccount+=sec;//最后的秒钟加上去
    3 @+ k8 V) K7 \6 I+ l
  133. 133 / X( \; k/ A8 E. I7 V
  134. 134     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟  3 `, ?, _: G/ j7 }. G
  135. 135     PWR_BackupAccessCmd(ENABLE);    //使能RTC和后备寄存器访问 * i$ [$ C( o4 x; X  R
  136. 136     RTC_SetCounter(seccount);    //设置RTC计数器的值
    ' r- M3 [+ @1 D
  137. 137 . y1 y- y, C: d
  138. 138     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成      / ~7 X" U- u# z1 k: W$ u! t
  139. 139     return 0;        ' E; O6 ^. O; T, Z0 n
  140. 140 }. V( K7 P) w; V0 |% h
  141. 141 3 t3 s) f& B# b0 J5 ?7 C
  142. 142 //初始化闹钟          ! e# i2 ^0 S0 F
  143. 143 //以1970年1月1日为基准& Y" A  u" a- ?1 ^  p
  144. 144 //1970~2099年为合法年份( V  z3 n& f% h- p  K% ~) ?
  145. 145 //syear,smon,sday,hour,min,sec:闹钟的年月日时分秒   5 I' u. v& f( {- J/ W6 M
  146. 146 //返回值:0,成功;其他:错误代码.
    % `. c; N* G7 U1 r& X
  147. 147 u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec), Z3 X( K# b, z# k
  148. 148 {' G- u+ L6 I$ M$ i. e" y0 w
  149. 149     u16 t;
    " e' r: C! J; q/ I" X1 {8 a
  150. 150     u32 seccount=0;
    % s1 z1 ^4 F! `1 n: o" b% X
  151. 151     if(syear<1970||syear>2099)return 1;      
    " z# W& L& ]# r0 V, O" a
  152. 152     for(t=1970;t<syear;t++)    //把所有年份的秒钟相加
    0 K. {, c5 F/ n
  153. 153     {5 C, f% s3 C& X
  154. 154         if(Is_Leap_Year(t))seccount+=31622400;//闰年的秒钟数/ ]3 `' _1 p! C% j- t/ u6 O. T: H
  155. 155         else seccount+=31536000;              //平年的秒钟数; O" `  H4 L9 L
  156. 156     }5 E8 U( w, w# Y3 O* ^0 H2 B7 J. |; E
  157. 157     smon-=1;6 ^9 z$ O$ p2 |0 j
  158. 158     for(t=0;t<smon;t++)       //把前面月份的秒钟数相加( o# B1 n; |$ D; _
  159. 159     {1 M2 b5 Z6 G- }# ~) t" v8 l7 K
  160. 160         seccount+=(u32)mon_table[t]*86400;//月份秒钟数相加
    8 }5 G9 }! `- A" z$ t
  161. 161         if(Is_Leap_Year(syear)&&t==1)seccount+=86400;//闰年2月份增加一天的秒钟数       9 k* V1 F7 g) X/ r% ]! p9 z
  162. 162     }
    : Y1 j( f' I4 q0 `% g- @
  163. 163     seccount+=(u32)(sday-1)*86400;//把前面日期的秒钟数相加
    + W- a1 _( m2 o  x' P$ B
  164. 164     seccount+=(u32)hour*3600;//小时秒钟数
    ! u0 _6 u3 _0 Z& ~
  165. 165     seccount+=(u32)min*60;     //分钟秒钟数
    3 Z* J. V4 F- Y
  166. 166     seccount+=sec;//最后的秒钟加上去                 
    ) V* ^6 c5 H( J  [/ Z
  167. 167     //设置时钟4 }( l! K" a; l  Y4 R
  168. 168     RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟   
    - K6 J  W# z, r
  169. 169     PWR_BackupAccessCmd(ENABLE);    //使能后备寄存器访问  
      ?+ G. ^* O! ]0 M5 I, t
  170. 170     //上面三步是必须的!
    ; b" w% r0 G0 a7 ]* S
  171. 171     
    1 T9 K0 \4 Q  c3 c) H
  172. 172     RTC_SetAlarm(seccount);
    $ N3 Y7 O! H" p* ^- S: W% C& g# T* V
  173. 173  
    . W  M' ?& J1 e
  174. 174     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成      
    7 Q- t- k; U# d" V6 f. `
  175. 175     
    , p' F- a. a- U- o  c; E( ^" R
  176. 176     return 0;        
    - o. o2 N' u2 G  ~8 B7 \  f6 E" [
  177. 177 }+ D6 C" a5 Q  P+ [
  178. 178 ( r+ ]/ s: t% L7 }  _6 \
  179. 179
      k# ^8 |9 w' g* f) ^; o+ {& r
  180. 180 //得到当前的时间
    3 o9 O, f8 s; [( b
  181. 181 //返回值:0,成功;其他:错误代码.
    4 B; ^  h) g( U1 [) _
  182. 182 u8 RTC_Get(void)' ]# z6 Q9 h1 F1 b& M! V8 ?% b
  183. 183 {
    * L1 U1 }) Y% t
  184. 184     static u16 daycnt=0;: Y" n' ]/ ^6 M( L# @- J2 }
  185. 185     u32 timecount=0; " A+ ?$ `. D; B+ f
  186. 186     u32 temp=0;
    - C5 e6 z3 [3 S6 G' ?1 \" F7 q/ s- a
  187. 187     u16 temp1=0;      4 E! J& m- h5 p% Y3 R  ]
  188. 188     timecount=RTC_GetCounter();     $ {5 j4 P& y5 T  Q. S# h
  189. 189      temp=timecount/86400;   //得到天数(秒钟数对应的)$ P3 K2 Z( P1 ^2 ~. A7 b3 O/ L
  190. 190     if(daycnt!=temp)//超过一天了0 N3 }" R* ~& h5 d/ k
  191. 191     {      2 {0 c  o$ g2 e
  192. 192         daycnt=temp;
    7 |: D5 L. h9 w1 P" y4 q
  193. 193         temp1=1970;    //从1970年开始
    0 W; ?0 ~. F7 m: j; d0 o
  194. 194         while(temp>=365)
    ' T$ ^! g3 O/ z! k! a7 e& \
  195. 195         {                 
      s, P  @( ~$ w: `( U) G2 P
  196. 196             if(Is_Leap_Year(temp1))//是闰年1 c9 }' L5 K' m4 x4 V, M
  197. 197             {
    $ J" U' u  y& z5 {  |
  198. 198                 if(temp>=366)temp-=366;//闰年的秒钟数
    5 Q) E1 C1 k) z1 |- H# p
  199. 199                 else {temp1++;break;}  / l$ u' }, p/ r: T. p( |
  200. 200             }6 O1 S* `7 v) u8 ^" @; Y
  201. 201             else temp-=365;      //平年 4 H* ~% @, I7 a4 z7 k; w$ w
  202. 202             temp1++;  ' ~; `% r, C' ]+ _  i* z
  203. 203         }   $ f: {. u% z% t
  204. 204         calendar.w_year=temp1;//得到年份# k" V+ l5 u7 @8 o9 S
  205. 205         temp1=0;3 w) c$ G2 F, H
  206. 206         while(temp>=28)//超过了一个月& p- s& k; Q+ h# U* V- a6 p- k
  207. 207         {" i1 u- K) ~0 r5 Z  q
  208. 208             if(Is_Leap_Year(calendar.w_year)&&temp1==1)//当年是不是闰年/2月份
    6 M: E2 Q4 i4 z5 c# O
  209. 209             {+ j- r' |9 G. ]. X
  210. 210                 if(temp>=29)temp-=29;//闰年的秒钟数
    ) C& u6 y7 F2 T- m
  211. 211                 else break; 1 ]6 ]) i, H+ l) ^  u) B2 G% v
  212. 212             }
    0 a  m7 {- ^; p+ D4 R
  213. 213             else
    + b9 V) i! b; g* {6 B# h: _& F
  214. 214             {5 G* H: R$ o+ T7 y  X! ~$ F
  215. 215                 if(temp>=mon_table[temp1])temp-=mon_table[temp1];//平年: V3 I3 j/ q5 r; t( h1 Y# E
  216. 216                 else break;
    9 t  Q6 @" S8 k$ l, H- ~& [
  217. 217             }; O. k" n! b( G' V) C
  218. 218             temp1++;  4 D/ \, ~% ?* o3 k# [
  219. 219         }
    ! a; N! N! R9 N/ K/ u6 F
  220. 220         calendar.w_month=temp1+1;    //得到月份, p7 ]8 i" n5 B7 A* o: y% j
  221. 221         calendar.w_date=temp+1;      //得到日期
    % b0 y  w* n& i9 G& E, A" a8 E
  222. 222     }
    * g) ?+ a- X' F- I% A; m/ S
  223. 223     temp=timecount%86400;             //得到秒钟数          ; `- V7 d  L2 t$ ?
  224. 224     calendar.hour=temp/3600;         //小时6 c$ V, e9 T1 t5 v+ B# A! k
  225. 225     calendar.min=(temp%3600)/60;     //分钟    . f9 _& @: h$ F% D4 E, _7 K
  226. 226     calendar.sec=(temp%3600)%60;     //秒钟/ R& p1 r% t' w9 @) ]. U, x' A" a
  227. 227     calendar.week=RTC_Get_Week(calendar.w_year,calendar.w_month,calendar.w_date);//获取星期; L4 }! w/ D' A
  228. 228     calendar.msec=(32767-RTC_GetDivider())*    1000/32767;
    # e- i( x1 T3 W. ?; e
  229. 229     return 0;/ W. i( Z  r1 P7 {/ [6 ~4 I) T8 q
  230. 230 }    5 _- v# C& D4 P
  231. 231
    + f# d( ]  |, `9 J
  232. 232
    3 x1 ~( E9 w2 a! M. @
  233. 233 //获得现在是星期几
    , b4 S, j0 h7 o& b( k
  234. 234 //功能描述:输入公历日期得到星期(只允许1901-2099年)
    % g" k/ S0 A; u5 E5 x
  235. 235 //输入参数:公历年月日 / B8 B; m3 A4 m3 {
  236. 236 //返回值:星期号                                                                                         , u* r; m' m- u. M
  237. 237 u8 RTC_Get_Week(u16 year,u8 month,u8 day)1 O: I1 o, g; W& D! x: W
  238. 238 {    ; h) a2 a# c1 s6 c( Q& n- K! z
  239. 239     u16 temp2;
    7 D0 x2 ?: E( m$ x; z
  240. 240     u8 yearH,yearL;* a6 B5 F( O1 h7 N
  241. 241     
    % F# ?) ]2 o$ E4 X8 ~
  242. 242     yearH=year/100;    yearL=year%100; 8 l6 H9 L8 T- Q' C7 u5 e
  243. 243     // 如果为21世纪,年份数加100  - P( Y' v* _3 |0 v  {4 u
  244. 244     if (yearH>19)yearL+=100;
    0 U" P4 n$ z0 }
  245. 245     // 所过闰年数只算1900年之后的  
    7 [9 y$ v3 `9 h& `  w
  246. 246     temp2=yearL+yearL/4;
    % y& p+ ~4 S7 `' d
  247. 247     temp2=temp2%7;
    + {, y0 g7 l7 C
  248. 248     temp2=temp2+day+table_week[month-1];
    7 P6 I7 t* ^" m. Y8 h
  249. 249     if (yearL%4==0&&month<3)temp2--;- m8 v# D$ [% t* r
  250. 250     return(temp2%7);% Q9 g  @" e1 O2 J
  251. 251 }   
复制代码
  1. 1 #include "sys.h"6 [% H% K' \' d
  2. 2 8 _; ^# y8 P! V5 [' z6 j
  3. 3 //时间结构体
    $ F; f6 @) h4 U& h
  4. 4 typedef struct
    ( Y! G) P( ^  V) Y
  5. 5 {& v/ q) X! l& e  {, I
  6. 6     vu8 hour;//vu8" X% f5 o- _" y6 b: A% o
  7. 7     vu8 min;
    2 T$ `; y9 Z" N% Q
  8. 8     vu8 sec;: I. j6 Z$ O( h* x
  9. 9     vu16 msec;
    & h6 ^2 V/ o) w: b+ t$ V& e
  10. 10     
    2 z7 k' z3 j1 V" x3 ~+ n# _0 d' J
  11. 11     //公历日月年周7 _# |) B6 Z- _; T7 |
  12. 12     vu16 w_year;
    $ S) \; a1 c  T3 f. L
  13. 13     vu8  w_month;
    * Z% T$ n4 f! I4 [. _9 j
  14. 14     vu8  w_date;
    0 ^( s9 @: Q, W2 {2 D& v
  15. 15     vu8  week;         2 v. i# D  J, k$ ~) X3 t7 P( B& _" T  o) {' n
  16. 16 }_calendar_obj;                     " s# ~1 h* ]" J! D8 r- b
  17. 17
    3 w1 k- j/ k4 b$ m
  18. 18 extern _calendar_obj calendar;    //日历结构体2 N- e9 n- M% {0 i# D8 k
  19. 19 extern u8 const mon_table[12];    //月份日期数据表6 r) p+ R& ]* `6 N9 ]8 s- o
  20. 20 % X# I5 S5 C2 n  L" {
  21. 21 u8 RTC_Init(void);        //初始化RTC,返回0,失败;1,成功;
    - K4 `/ x  ]. A: Q
  22. 22 u8 Is_Leap_Year(u16 year);//平年,闰年判断$ N. ~4 a: Z/ {( `4 r
  23. 23 ' F) h, J* O) g# F+ B
  24. 24 //u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);
    7 O6 v3 Z" O3 N! a1 D
  25. 25 u8 RTC_Get(void);         //更新时间   
    & n% o) w: j/ Q( o9 A
  26. 26 u8 RTC_Get_Week(u16 year,u8 month,u8 day);9 p% o+ g+ z% b# X( m  E
  27. 27 u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);//设置时间   
复制代码
' Y' U) m2 |8 p9 v4 G
4、秒钟计时原理
使用外部32.768KHz的晶振作为时钟的输入频率,设置预分频装载寄存器的值为32767,根据计算公式,刚好可以得到1秒的计数频率。时间基准设置为1970年1月1日0时0分0秒,后续的时间都以这个为基准进行计算。RTC计数器是32位的,理论上可以记录136年左右的时间。(注意不必在秒中断里更新时间)
2 l1 I3 X% J; P5 L- @7 A: w
: k# K5 H. M' B4 d
5、毫秒计时原理
如果要获取到毫秒级的时钟怎么办?在我的项目中就有这样的要求。事实上,获取毫秒时钟也非常简单。
查阅开发指南,RTC预分频器余数寄存器(RTC_DIVH、RTC_DIVL),这两个寄存器的作用就是用来获得比秒钟更为准确的时钟。 该寄存器的值自减的,用于保存还需要多少时钟周期获得一个秒信号。在一次秒钟更新后,由硬件重新装载。这两个寄存器和 RTC 预分频装载寄存器位数是一样的。也就是说,如果预分频装载寄存器的值为32767,那么余数寄存器就会在每一次秒更新时由硬件重新装载为32767,然后向下计数,计数到0表示一秒,也即1000ms。
  因此,我们在时钟结构体中添加msec成员
  1. 1 //时间结构体
    ! E& l1 Q, ?( q# Y
  2. 2 typedef struct 1 Y; E: v, F% r: C0 ?/ q" w. J
  3. 3 {
      |' X" a! d9 c# M0 x4 O
  4. 4     vu8 hour;//vu8$ |2 B. M: }8 U, \. h
  5. 5     vu8 min;
    1 @. v2 ~4 i- O3 n. E, c7 P
  6. 6     vu8 sec;& M: y# ~$ ]. H. Y
  7. 7     vu16 msec;
    8 V% K1 O% \6 U4 q: ?6 U- s
  8. 8     
    / C  k4 F$ r7 H, i, ^
  9. 9     //公历日月年周
    ' \5 p8 t5 c" p3 n
  10. 10     vu16 w_year;4 l. H7 B3 }$ Y  r9 z
  11. 11     vu8  w_month;8 k& c( u/ i% l3 {
  12. 12     vu8  w_date;: k% F, W! Q( u* R' P' n
  13. 13     vu8  week;         8 G% `: l) ^: z% M! L
  14. 14 }_calendar_obj;  
复制代码
  t, }" {# A' [- ]/ z
 获取毫秒时间
  1. 1 calendar.msec=(32767-RTC_GetDivider())*1000/32767;
复制代码
: b1 u  I) U/ I
6、修改时间  
   如果RTC时钟在使用的过程中不准了(我遇到的情况大概是掉电跑了2个月,重新测试的时候差了2分钟左右),可以重新校准时钟。我们在备份区域 BKP_DR1 中写入 0X5051 ,下次开机(或复位)的时候,先读取 BKP_DR1 的值,然后判断是否是 0X5051来决定是不是要配置。 如果要修改时间,请将0x5051改为其它数据,修改RTC_Set函数实参,再重新烧写一下程序即可。
; A2 G# K+ k& O0 Q" A" o1 _* k; M9 h
  1. if (BKP_ReadBackupRegister(BKP_DR1) != 0x5051)6 \/ E0 x8 H  A3 e
  2. {9 ?0 r- K5 o) H! d$ h
  3.     ...$ A' D" u& [& _+ Q% M6 @0 F( E6 S
  4.     RTC_EnterConfigMode();/// 允许配置    ; T0 i: t& m6 [! K' J
  5.     RTC_SetPrescaler(32767); //设置RTC预分频的值
    1 Y# v2 ]" V* @/ `& X
  6.     RTC_WaitForLastTask();    //等待最近一次对RTC寄存器的写操作完成
    : J3 S4 O( J! K2 O& K9 x
  7.     RTC_Set(2018,4,2,17,37,00);  //设置时间    7 k. B/ {/ n- D. l
  8.     RTC_ExitConfigMode(); //退出配置模式  
    3 H: B! J; ^$ l7 @1 Y
  9.     BKP_WriteBackupRegister(BKP_DR1, 0X5051);    //向指定的后备寄存器中写入用户程序数据   
    1 v/ @, s$ \/ O4 U. |1 T
  10. }
复制代码

* B3 J  g+ }. `. e# D5 W
赞 收藏 1 评论0 发布时间:2022-1-13 20:47

举报

0个回答

所属标签

相似技术帖

官网相关资源

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