• PY32F003F18之RTC

    一、RTC振荡器

    PY32F003F18实时时钟的振荡器是内部RC振荡器，频率为32.768KHz。它也可以使用HSE时钟，不建议使用。HAL库提到LSE振荡器，但PY32F003F18实际上没有这个振荡器。

    缺点：CPU掉电后，需要重新配置RTC，这个确实不太友好，有点像是鸡肋，在要求不严格的场合，凑合使用吧。

    RTC时钟框图如下：

    二、RTC的HAL库有一个不是很严重的bug

     PY32F003F18的HAL库润年函数中有一个BUG，不是很严重，因为2400年是一个闰年，它把年定义为字节型变量，是没有办法分辨出是不是闰年。

    闰年的计算方法：年数能被4整除，但不能被100年整除，为闰年；若年数能400年整除，也为闰年。

    HAL库确实不大好，它喜欢用全局变量来实现其功能，让人受不了。我改了，让它适合自己需要的。HAL处的好处，就是我们可以从中抠出自己需要的部分，修修改改，就可以了，比HAL库的灵活多了。时刻不忘黑它一把，因为人云亦云的人太多了。

    三、非完全HAL库测试程序

    如果你觉得HAL库，就用HAL中的程序，也是可以的。

    1. #include "RTC.h"
    2. #include "LED.h"
    3. #include "stdio.h"  //getchar(),putchar(),scanf(),printf(),puts(),gets(),sprintf()
    4.  
    5. uint8_t Century;//世纪,21世纪用20表示
    6. RTC_DateTypeDef  RTC_DateStructureure;//用来保存读到的"年月日"
    7. RTC_TimeTypeDef  RTC_TimeStructureure;//用来保存读到的"时分秒"
    8. RTC_AlarmTypeDef RTC_AlarmStructureure;
    9.  
    10. void RTC_Init(void);
    11. void RTC_Display(void);
    12.  
    13. //函数功能:读"RTC计数寄存器"
    14. uint32_t Read_RTC_Time_Counter(void)
    15. {
    16.   uint16_t high1 = 0U, high2 = 0U, low = 0U;
    17.   uint32_t timecounter = 0U;
    18.  
    19.   high1 = READ_REG(RTC->CNTH & RTC_CNTH_RTC_CNT);//读"RTC计数寄存器高位RTC_CNTH"
    20.   low   = READ_REG(RTC->CNTL & RTC_CNTL_RTC_CNT);//读"RTC计数寄存器低位RTC_CNTL"
    21.   high2 = READ_REG(RTC->CNTH & RTC_CNTH_RTC_CNT);//读"RTC计数寄存器高位RTC_CNTH"
    22.  
    23.   if (high1 != high2)
    24.   {//读"RTC计数寄存器低位RTC_CNTL"时,发现"RTC计数寄存器高位RTC_CNTH"中的数据发生改变了
    25.     //In this case the counter roll over during reading of CNTL and CNTH registers,
    26.     //read again CNTL register then return the counter value
    27.     timecounter = (((uint32_t) high2 << 16U) | READ_REG(RTC->CNTL & RTC_CNTL_RTC_CNT));
    28.   }
    29.   else
    30.   {
    31.     //No counter roll over during reading of CNTL and CNTH registers, 
    32. 		//counter value is equal to first value of CNTL and CNTH
    33.     timecounter = (((uint32_t) high1 << 16U) | low);
    34.   }
    35.  
    36.   return timecounter;
    37. }
    38.  
    39. //函数功能:
    40. //等待RTC写操作结束
    41. //返回0,表示退出RTC配置模式,开始更新RTC寄存器
    42. HAL_StatusTypeDef Enter_RTC_Init_Mode(void)
    43. {
    44.   uint32_t tickstart = 0U;
    45.  
    46.   tickstart = HAL_GetTick();
    47.   /* Wait till RTC is in INIT state and if Time out is reached exit */
    48.   while ( (RTC->CRL & RTC_CRL_RTOFF) == (uint32_t)RESET )
    49.   {//读"RTC控制寄存器RTC_CRL"中的RTOFF,若RTOFF=0,则上一次对RTC寄存器的写操作仍在进行
    50.     if ((HAL_GetTick() - tickstart) >  RTC_TIMEOUT_VALUE)
    51.     {//RTC_TIMEOUT_VALUE=2000,最大等待时间为2000ms
    52.       return HAL_TIMEOUT;
    53.     }
    54.   }
    55.  
    56.   _HAL_RTC_WRITEPROTECTION_DISABLE(RTC);
    57. 	//将"RTC控制寄存器RTC_CRL"中的CNF=0,退出配置模式,开始更新RTC寄存器
    58. 	//Disable the write protection for RTC registers
    59.  
    60.   return HAL_OK;
    61. }
    62.  
    63. //函数功能:
    64. //等待RTC写操作结束
    65. //返回0,表示RTC写操作结束
    66. HAL_StatusTypeDef Exit_RTC_Init_Mode(void)
    67. {
    68.   uint32_t tickstart = 0U;
    69.  
    70.   _HAL_RTC_WRITEPROTECTION_ENABLE(RTC);
    71. 	//将"RTC控制寄存器RTC_CRL"中的CNF=1,进入RTC配置模式
    72. 	
    73. 	tickstart = HAL_GetTick();
    74.   while ((RTC->CRL & RTC_CRL_RTOFF) == RTC_CRL_RTOFF)
    75.   {//读"RTC控制寄存器RTC_CRL"中的RTOFF,若RTOFF=1,则上一次对RTC寄存器的写操作已经完成
    76.     if ((HAL_GetTick() - tickstart) >  RTC_RTOFF_RESET_TIMEOUT_VALUE)
    77.     {//RTC_RTOFF_RESET_TIMEOUT_VALUE=4,最大等待时间为4ms
    78.       break;
    79.     }
    80.   }
    81.  
    82.   tickstart = HAL_GetTick();
    83.   while ((RTC->CRL & RTC_CRL_RTOFF) == (uint32_t)RESET)
    84.   {//读"RTC控制寄存器RTC_CRL"中的RTOFF,若RTOFF=0,则上一次对RTC寄存器的写操作仍在进行
    85.     if ((HAL_GetTick() - tickstart) >  RTC_TIMEOUT_VALUE)
    86.     {//RTC_TIMEOUT_VALUE=2000,最大等待时间为2000ms
    87.       return HAL_TIMEOUT;
    88.     }
    89.   }
    90.  
    91.   return HAL_OK;
    92. }
    93.  
    94. //函数功能:将TimeCounter写入"RTC计数寄存器"
    95. HAL_StatusTypeDef Write_RTC_Time_Counter( uint32_t TimeCounter )
    96. {
    97.   HAL_StatusTypeDef status = HAL_OK;
    98.  
    99.   if (Enter_RTC_Init_Mode() != HAL_OK)
    100.   {//等待RTC写操作结束
    101.     //返回0,表示退出RTC配置模式,开始更新RTC寄存器
    102.     status = HAL_ERROR;
    103.   }
    104.   else
    105.   {
    106.     WRITE_REG(RTC->CNTH, (TimeCounter >> 16U));
    107. 		//写"RTC计数寄存器高位RTC_CNTH"
    108. 		//Set RTC COUNTER MSB word
    109.     WRITE_REG(RTC->CNTL, (TimeCounter & RTC_CNTL_RTC_CNT));
    110. 		//写"RTC计数寄存器低位RTC_CNTL"
    111. 		//Set RTC COUNTER LSB word
    112.     if (Exit_RTC_Init_Mode() != HAL_OK)
    113.     {//等待RTC写操作结束
    114.       status = HAL_ERROR;
    115.     }
    116.   }
    117.  
    118.   return status;
    119. }
    120.  
    121. //函数功能:读"RTC闹钟寄存器"
    122. uint32_t Read_RTC_Alarm_Counter(void)
    123. {
    124.   uint16_t high1 = 0U, low = 0U;
    125.  
    126.   high1 = READ_REG(RTC->ALRH & RTC_CNTH_RTC_CNT);
    127. 	//读"RTC闹钟寄存器高位RTC_ALRH"
    128.   low   = READ_REG(RTC->ALRL & RTC_CNTL_RTC_CNT);
    129. 	//读"RTC闹钟寄存器低位RTC_ALRL"
    130.  
    131.   return (((uint32_t) high1 << 16U) | low);
    132. }
    133.  
    134. //函数功能:将AlarmCounter写入"RTC闹钟寄存器"
    135. HAL_StatusTypeDef Write_RTC_Alarm_Counter( uint32_t AlarmCounter)
    136. {
    137.   HAL_StatusTypeDef status = HAL_OK;
    138.  
    139.   /* Set Initialization mode */
    140.   if (Enter_RTC_Init_Mode() != HAL_OK)
    141.   {//等待RTC写操作结束
    142.    //返回0,表示退出RTC配置模式,开始更新RTC寄存器
    143.     status = HAL_ERROR;
    144.   }
    145.   else
    146.   {
    147.     WRITE_REG(RTC->ALRH, (AlarmCounter >> 16U));
    148. 		//写"RTC闹钟寄存器高位RTC_ALRH",Set RTC COUNTER MSB word
    149.     WRITE_REG(RTC->ALRL, (AlarmCounter & RTC_ALRL_RTC_ALR));
    150. 		//写"RTC闹钟寄存器低位RTC_ALRL",Set RTC COUNTER LSB word
    151.  
    152.     /* Wait for synchro */
    153.     if (Exit_RTC_Init_Mode() != HAL_OK)
    154.     {//等待RTC写操作结束
    155.       status = HAL_ERROR;
    156.     }
    157.   }
    158.  
    159.   return status;
    160. }
    161.  
    162. //函数功能:返回0表示闰年
    163. uint8_t Is_LeapYear(uint16_t nYear)
    164. {
    165. 	uint16_t y;
    166.  
    167. 	y=Century;//2023年9月26日
    168. 	y=y*100;//2023年9月26日
    169. 	nYear=y+nYear;//2023年9月26日
    170.  
    171.   if ((nYear % 4U) != 0U)
    172.   {
    173.     return 0U;
    174.   }
    175.  
    176.   if ((nYear % 100U) != 0U)
    177.   {
    178.     return 1U;
    179.   }
    180.  
    181.   if ((nYear % 400U) == 0U)
    182.   {
    183.     return 1U;
    184.   }
    185.   else
    186.   {
    187.     return 0U;
    188.   }
    189. }
    190.  
    191. //函数功能;读取星期几的值
    192. uint8_t Read_RTC_WeekDay(uint32_t nYear, uint8_t nMonth, uint8_t nDay)
    193. {
    194.   uint32_t year = 0U, weekday = 0U;
    195.  
    196.   year = 2000U + nYear;
    197.  
    198.   if (nMonth < 3U)
    199.   {
    200.     /*D = { [(23 x month)/9] + day + 4 + year + [(year-1)/4] - [(year-1)/100] + [(year-1)/400] } mod 7*/
    201.     weekday = (((23U * nMonth) / 9U) + nDay + 4U + year + ((year - 1U) / 4U) - ((year - 1U) / 100U) + ((year - 1U) / 400U)) % 7U;
    202.   }
    203.   else
    204.   {
    205.     /*D = { [(23 x month)/9] + day + 4 + year + [year/4] - [year/100] + [year/400] - 2 } mod 7*/
    206.     weekday = (((23U * nMonth) / 9U) + nDay + 4U + year + (year / 4U) - (year / 100U) + (year / 400U) - 2U) % 7U;
    207.   }
    208.  
    209.   return (uint8_t)weekday;
    210. }
    211.  
    212. void Update_RTC_Date(RTC_DateTypeDef *update_RTCDate, uint32_t DayElapsed)
    213. {
    214.   uint32_t year = 0U, month = 0U, day = 0U;
    215.   uint32_t loop = 0U;
    216.  
    217.   /* Get the current year*/
    218.   year = update_RTCDate->Year;
    219.  
    220.   /* Get the current month and day */
    221.   month = update_RTCDate->Month;
    222.   day = update_RTCDate->Date;
    223.  
    224.   for (loop = 0U; loop < DayElapsed; loop++)
    225.   {
    226.     if ((month == 1U) || (month == 3U) || (month == 5U) || (month == 7U) || \
    227.         (month == 8U) || (month == 10U) || (month == 12U))
    228.     {
    229.       if (day < 31U)
    230.       {
    231.         day++;
    232.       }
    233.       /* Date structure member: day = 31 */
    234.       else
    235.       {
    236.         if (month != 12U)
    237.         {
    238.           month++;
    239.           day = 1U;
    240.         }
    241.         /* Date structure member: day = 31 & month =12 */
    242.         else
    243.         {
    244.           month = 1U;
    245.           day = 1U;
    246.           year++;
    247.         }
    248.       }
    249.     }
    250.     else if ((month == 4U) || (month == 6U) || (month == 9U) || (month == 11U))
    251.     {
    252.       if (day < 30U)
    253.       {
    254.         day++;
    255.       }
    256.       /* Date structure member: day = 30 */
    257.       else
    258.       {
    259.         month++;
    260.         day = 1U;
    261.       }
    262.     }
    263.     else if (month == 2U)
    264.     {
    265.       if (day < 28U)
    266.       {
    267.         day++;
    268.       }
    269.       else if (day == 28U)
    270.       {
    271.         if (Is_LeapYear(year))//不闰年
    272.         {//返回0表示闰年
    273.           day++;
    274.         }
    275.         else //闰年
    276.         {
    277.           month++;
    278.           day = 1U;
    279.         }
    280.       }
    281.       else if (day == 29U)
    282.       {
    283.         month++;
    284.         day = 1U;
    285.       }
    286.     }
    287.   }
    288.  
    289. 	if(year>=100)//2023年9月26日
    290. 	{
    291. 		Century++;
    292. 		year=year-100;
    293. 	}
    294.  
    295.   /* Update year */
    296.   update_RTCDate->Year = year;
    297.  
    298.   /* Update day and month */
    299.   update_RTCDate->Month = month;
    300.   update_RTCDate->Date = day;
    301.  
    302.   /* Update day of the week */
    303.   update_RTCDate->WeekDay = Read_RTC_WeekDay(year, month, day);
    304. 	//读取星期几的值
    305. }
    306.  
    307. HAL_StatusTypeDef Read_RTC_Time(RTC_DateTypeDef *update_RTCDate, RTC_TimeTypeDef *sTime)
    308. {
    309.   uint32_t counter_time = 0U, counter_alarm = 0U, days_elapsed = 0U, hours = 0U;
    310.  
    311.   counter_time = Read_RTC_Time_Counter();//读"RTC计数寄存器",总秒数
    312.   hours = counter_time / 3600U;//计算有多少小时
    313.   sTime->Minutes  = (uint8_t)((counter_time % 3600U) / 60U);//计算分钟数值
    314.   sTime->Seconds  = (uint8_t)((counter_time % 3600U) % 60U);//计算秒数值
    315.  
    316.   if (hours >= 24U)
    317.   {
    318.     days_elapsed = (hours / 24U);//计算"天"
    319.     sTime->Hours = (hours % 24U);//计算今天的"小时时间"
    320.  
    321.     counter_alarm = Read_RTC_Alarm_Counter();
    322. 		//读"RTC闹钟寄存器"
    323. 		//Read Alarm counter in RTC registers
    324.  
    325.     /* Calculate remaining time to reach alarm (only if set and not yet expired)*/
    326.     if ((counter_alarm != 0xFFFFFFFF) && (counter_alarm > counter_time))
    327.     {//RTC_ALARM_RESETVALUE=0xFFFFFFFFU
    328.       counter_alarm -= counter_time;//计算"距离报警时间的差值"
    329.     }
    330.     else
    331.     {
    332.       /* In case of counter_alarm < counter_time */
    333.       /* Alarm expiration already occurred but alarm not deactivated */
    334.       counter_alarm = 0xFFFFFFFF;
    335. 			//RTC_ALARM_RESETVALUE=0xFFFFFFFFU
    336.     }
    337.  
    338.     /* Set updated time in decreasing counter by number of days elapsed */
    339.     counter_time -= (days_elapsed * 24U * 3600U);//计算"今天的总秒数"
    340.  
    341.     /* Write time counter in RTC registers */
    342.     if (Write_RTC_Time_Counter(counter_time) != HAL_OK)
    343.     {//将"今天的总秒数"counter_time写入"RTC计数寄存器"
    344.       return HAL_ERROR;
    345.     }
    346.  
    347.     /* Set updated alarm to be set */
    348.     if (counter_alarm != 0xFFFFFFFF)
    349.     {//RTC_ALARM_RESETVALUE=0xFFFFFFFFU
    350.       counter_alarm += counter_time;
    351. 			//报警时间 = "距离报警时间的差值" + "今天的总秒数"
    352.       if (Write_RTC_Alarm_Counter(counter_alarm) != HAL_OK)
    353.       {//将AlarmCounter写入"RTC闹钟寄存器"
    354.         return HAL_ERROR;
    355.       }
    356.     }
    357.     else
    358.     {
    359.       /* Alarm already occurred. Set it to reset values to avoid unexpected expiration */
    360.       if (Write_RTC_Alarm_Counter(counter_alarm) != HAL_OK)
    361.       {//将AlarmCounter写入"RTC闹钟寄存器"
    362.         return HAL_ERROR;
    363.       }
    364.     }
    365.  
    366.     /* Update date */
    367.     Update_RTC_Date(update_RTCDate, days_elapsed);
    368.   }
    369.   else
    370.   {
    371.     sTime->Hours = hours;
    372.   }
    373.  
    374.   return HAL_OK;
    375. }
    376.  
    377. HAL_StatusTypeDef Read_RTC_Date(RTC_DateTypeDef *update_RTCDate,RTC_DateTypeDef *sDate)
    378. {
    379.   RTC_TimeTypeDef stime = {0U};
    380.  
    381.   /* Call HAL_RTC_GetTime function to update date if counter higher than 24 hours */
    382.   if (Read_RTC_Time(update_RTCDate, &stime) != HAL_OK)
    383.   {
    384.     return HAL_ERROR;
    385.   }
    386.  
    387.   /* Fill the structure fields with the read parameters */
    388.   sDate->WeekDay  = update_RTCDate->WeekDay;
    389.   sDate->Year     = update_RTCDate->Year;
    390.   sDate->Month    = update_RTCDate->Month;
    391.   sDate->Date     = update_RTCDate->Date;
    392.  
    393.   return HAL_OK;
    394. }
    395.  
    396. void RTC_Init(void)
    397. {
    398. 	RTC_HandleTypeDef RTC_HandleStructureure;
    399.   RCC_OscInitTypeDef        RCC_OscInit_Structureure;
    400.   RCC_PeriphCLKInitTypeDef  PeriphClkInit_Structureure;
    401.   
    402. 	Century=20;//世纪,21世纪用20表示
    403.  
    404.   RTC_HandleStructureure.Instance = RTC;                       //选择RTC
    405.   RTC_HandleStructureure.Init.AsynchPrediv = RTC_AUTO_1_SECOND; //RTC一秒时基自动计算
    406.  
    407. //HAL_RTC_MspInit函数开始//
    408.   RCC_OscInit_Structureure.OscillatorType =  RCC_OSCILLATORTYPE_LSI;
    409.  
    410.   RCC_OscInit_Structureure.LSIState = RCC_LSI_ON;
    411. 	HAL_RCC_OscConfig(&RCC_OscInit_Structureure);
    412.  
    413.   PeriphClkInit_Structureure.PeriphClockSelection = RCC_PERIPHCLK_RTC;
    414.   PeriphClkInit_Structureure.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
    415. 	HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit_Structureure);
    416.  
    417.   __HAL_RCC_RTCAPB_CLK_ENABLE();
    418. 	//使能RTC APB外部设备时钟,Enable RTC peripheral Clocks
    419.   __HAL_RCC_RTC_ENABLE();//使能RTC时钟,Enable RTC Clock
    420.  
    421.   HAL_NVIC_SetPriority(RTC_IRQn, 0x01, 0);
    422. 	//设置RTC中断优先级为0x01,0无意义
    423.   NVIC_EnableIRQ(RTC_IRQn);//使能RTC中断
    424.  
    425.   __HAL_RTC_OVERFLOW_ENABLE_IT(&RTC_HandleStructureure, RTC_IT_OW);//使能溢出中断,Overflow interrupt
    426.   __HAL_RTC_ALARM_ENABLE_IT(&RTC_HandleStructureure, RTC_IT_ALRA);//使能报警中断,Alarm interrupt
    427.   __HAL_RTC_SECOND_ENABLE_IT(&RTC_HandleStructureure, RTC_IT_SEC);//使能秒中断,Second interrupt
    428. //HAL_RTC_MspInit函数结束//
    429.  
    430. 	HAL_RTC_Init(&RTC_HandleStructureure);//RTC初始化
    431.  
    432. /设置日期: 2023/9/27 星期三/
    433.   RTC_DateStructureure.Year = 23;
    434.   RTC_DateStructureure.Month =9;
    435.   RTC_DateStructureure.Date = 27;
    436.   RTC_DateStructureure.WeekDay = RTC_WEEKDAY_WEDNESDAY;
    437. 	HAL_RTC_SetDate(&RTC_HandleStructureure, &RTC_DateStructureure, RTC_FORMAT_BIN);
    438. 	//设置RTC日期
    439.  
    440. /设置时间: 09:00:00/
    441.   RTC_TimeStructureure.Hours = 9;
    442.   RTC_TimeStructureure.Minutes =00;
    443.   RTC_TimeStructureure.Seconds = 00;
    444. 	HAL_RTC_SetTime(&RTC_HandleStructureure, &RTC_TimeStructureure, RTC_FORMAT_BIN);
    445. 	//设置RTC时间
    446.  
    447. /设置RTC闹钟，时间到09:01:00产生中断/
    448.   RTC_AlarmStructureure.AlarmTime.Hours = 9;
    449.   RTC_AlarmStructureure.AlarmTime.Minutes = 1;
    450.   RTC_AlarmStructureure.AlarmTime.Seconds = 00;
    451. 	HAL_RTC_SetAlarm_IT(&RTC_HandleStructureure, &RTC_AlarmStructureure, RTC_FORMAT_BIN);
    452. }
    453.  
    454. void RTC_Display(void)
    455. {
    456. 	Read_RTC_Time(&RTC_DateStructureure,&RTC_TimeStructureure);
    457. //	Read_RTC_Date(&RTC_DateStructureure,&RTC_DateStructureure);
    458.  
    459. //	RTC_HandleTypeDef RTC_HandleStructureure;
    460.  
    461. //	RTC_HandleStructureure.Instance = RTC;//选择RTC
    462. //  printf("RTC_IT_SEC\r\n");
    463. //  HAL_RTC_GetTime(&RTC_HandleStructureure, &RTC_TimeStructureure, RTC_FORMAT_BIN);//读取"RTC时间"
    464. //  HAL_RTC_GetDate(&RTC_HandleStructureure, &RTC_DateStructureure, RTC_FORMAT_BIN);//读取"RTC日期"
    465.   printf("%02d%02d-%02d-%02d %02d:%02d:%02d\r\n", Century,RTC_DateStructureure.Year,RTC_DateStructureure.Month,RTC_DateStructureure.Date,RTC_TimeStructureure.Hours, RTC_TimeStructureure.Minutes, RTC_TimeStructureure.Seconds);
    466. 	//显示时间格式为 : YY-MM-DD hh:mm:ss
    467. 	if(RTC_DateStructureure.WeekDay==RTC_WEEKDAY_SUNDAY) printf("Sunday\r\n");
    468. 	if(RTC_DateStructureure.WeekDay==RTC_WEEKDAY_MONDAY) printf("Monday\r\n");
    469. 	if(RTC_DateStructureure.WeekDay==RTC_WEEKDAY_TUESDAY) printf("Tuesday\r\n");
    470. 	if(RTC_DateStructureure.WeekDay==RTC_WEEKDAY_WEDNESDAY) printf("Wednesday\r\n");
    471. 	if(RTC_DateStructureure.WeekDay==RTC_WEEKDAY_THURSDAY) printf("Thursday\r\n");
    472. 	if(RTC_DateStructureure.WeekDay==RTC_WEEKDAY_FRIDAY) printf("Friday\r\n");
    473. 	if(RTC_DateStructureure.WeekDay==RTC_WEEKDAY_SATURDAY) printf("Saturday\r\n");
    474. }
    475.  
    476. //函数功能;RTC中断服务函数
    477. void RTC_IRQHandler(void)
    478. {
    479. 	if (_HAL_RTC_SECOND_GET_FLAG(RTC,RTC_FLAG_SEC))
    480. 	{
    481. 		if (_HAL_RTC_SECOND_GET_FLAG(RTC, RTC_FLAG_OW))
    482. 		{//RTC计数器溢出中断
    483. /HAL_RTCEx_RTCEventCallback函数开始/
    484.       printf("%s","\r\nRTC Overflow!!!\r\n");
    485. /HAL_RTCEx_RTCEventCallback函数结束/
    486.  
    487.       _HAL_RTC_OVERFLOW_CLEAR_FLAG(RTC, RTC_FLAG_OW);
    488. 			//清除溢出中断
    489. 		}
    490. 		else
    491. 		{//RTC产生秒中断
    492. /HAL_RTCEx_RTCEventCallback函数开始/
    493.         MCU_LED_Toggle();
    494. /HAL_RTCEx_RTCEventCallback函数结束/
    495. 		}
    496. 		_HAL_RTC_SECOND_CLEAR_FLAG(RTC, RTC_FLAG_SEC);
    497. 	}
    498.  
    499. 	if (_HAL_RTC_ALARM_GET_FLAG(RTC, RTC_FLAG_ALRAF) != (uint32_t)RESET)
    500. 	{//RTC产生报警中断
    501. /HAL_RTC_AlarmAEventCallback函数开始/
    502. 		printf("%s","\r\nRTC Alarm!!!\r\n");
    503. /HAL_RTC_AlarmAEventCallback函数结束/
    504. 		_HAL_RTC_ALARM_CLEAR_FLAG(RTC, RTC_FLAG_ALRAF);
    505. 		//Clear the Alarm interrupt pending bit
    506. 	}
    507. }
    1. #ifndef __RTC_H
    2. #define __RTC_H
    3.  
    4. #include "py32f0xx_hal.h"
    5.  
    6. #define _HAL_RTC_SECOND_GET_FLAG(__INSTANCE__, __FLAG__)        (((((__INSTANCE__)->CRL) & (__FLAG__)) != RESET)? SET : RESET)
    7. #define _HAL_RTC_OVERFLOW_CLEAR_FLAG(__INSTANCE__, __FLAG__)      ((__INSTANCE__)->CRL) = ~(__FLAG__)
    8. #define _HAL_RTC_SECOND_CLEAR_FLAG(__INSTANCE__, __FLAG__)      ((__INSTANCE__)->CRL) = ~(__FLAG__)
    9. #define _HAL_RTC_ALARM_GET_FLAG(__INSTANCE__, __FLAG__)        (((((__INSTANCE__)->CRL) & (__FLAG__)) != RESET)? SET : RESET)
    10. #define _HAL_RTC_ALARM_CLEAR_FLAG(__INSTANCE__, __FLAG__)      ((__INSTANCE__)->CRL) = ~(__FLAG__)
    11. //#define _HAL_RTC_ALARM_ENABLE_IT(__INSTANCE__, __INTERRUPT__)  SET_BIT((__INSTANCE__)->CRH, (__INTERRUPT__))
    12.  
    13. #define _HAL_RTC_WRITEPROTECTION_ENABLE(__INSTANCE__)          CLEAR_BIT((__INSTANCE__)->CRL, RTC_CRL_CNF)
    14. //将"RTC控制寄存器RTC_CRL"中的CNF=1,进入RTC配置模式
    15.  
    16. #define _HAL_RTC_WRITEPROTECTION_DISABLE(__INSTANCE__)         SET_BIT((__INSTANCE__)->CRL, RTC_CRL_CNF)
    17. //将"RTC控制寄存器RTC_CRL"中的CNF=0,退出配置模式,开始更新RTC寄存器
    18. extern void RTC_Init(void);
    19. extern void RTC_Display(void);
    20.  
    21. #endif /* __RTC_H */
    1. #include "py32f0xx_hal.h"
    2. #include "SystemClock.h"
    3. #include "delay.h"
    4. #include "LED.h"
    5. #include "SystemClock.h"
    6. #include "USART2.h"
    7. #include "stdio.h"  //getchar(),putchar(),scanf(),printf(),puts(),gets(),sprintf()
    8. #include "string.h" //使能strcpy(),strlen(),memset()
    9. #include "RTC.h"
    10.  
    11. const char CPU_Reset_REG[]="\r\nCPU reset!\r\n";
    12. int main(void)
    13. {
    14. 	HSE_Config();
    15. //	HAL_Init();//systick初始化
    16.   delay_init();
    17. 	HAL_Delay(1000);
    18.  
    19. 	USART2_Init(115200);
    20. //PA0是为USART2_TX,PA1是USART2_RX
    21. //中断优先级为0x01
    22. //波特率为115200,数字为8位,停止位为1位,无奇偶校验,允许发送和接收数据,只允许接收中断,并使能串口
    23. 	printf("%s",CPU_Reset_REG);
    24.  
    25. 	MCU_LED_Init();
    26. 	RTC_Init();
    27.  
    28.   while (1)
    29.   {
    30. 		delay_ms(1000);
    31. 		RTC_Display();
    32.   }
    33. }

    四、误差分析

    误差： 每10分钟误差6秒。1%的误差，还行。

  • 相关阅读:
    JS 流行框架（八）：ScrollReveal
    MySQL数据库管理基本操作
    【图像配准】Canny边缘检测+模板配准红外可见光双路数据
    python+django车辆违章信息查询管理系统pycharm项目
    js看代码说输出
    MC Layer Target
    React知识点系列（4）-每天10个小知识
    设计模式之美 - 如何理解单例模式中的唯一性？
    注塑行业MES系统解决方案，打造数字化智能工厂 先达智控
    CAPL学习之路-DoIP相关函数
  • 原文地址：https://blog.csdn.net/weixin_42550185/article/details/133338811