RTC 时钟简介
STM32F103 的实时时钟（RTC）是一个独立的定时器。STM32 的 RTC 模块拥有一组连续 计数的计数器，在相对应的软件配置下，可提供时钟日历的功能。修改计数器的值可以重新设 置系统的当前时间和日期。
RTC 模块和时钟配置系统（RCC_BDCR 寄存器）是在后备区域，即在系统复位或从待机模 式唤醒后 RTC 的设置和时间维持不变，只要后备区域供电正常，那么 RTC 将可以一直运行。 但是在系统复位后，会自动禁止访问后备寄存器和 RTC，以防止对后备区域(BKP)的意外写操 作。所以在要设置时间之前，先要取消备份区域（BKP）写保护。
RTC 框图
下面先来学习 RTC 框图，通过学习 RTC 框图会有一个很好的整体掌握，同时对之后的编 程也会有一个清晰的思路。RTC 的框图，如图 27.1.1 所示：
我们在讲解 RTC 架构之前，说明一下框图中浅灰色的部分，他们是属于备份域的，在 VDD 掉电时可在 VBAT 的驱动下继续工作，这部分包括 RTC 的分频器，计数器以及闹钟控制器。在 寄存器部分才展开解释一下备用域。下面把 RTC 框图分成以下 2 个部分讲解：
① APB1 接口: 用来和 APB1 总线相连。通过 APB1 总线可以访问 RTC 相关的寄存器，对 其进行读写操作。
② RTC 核心: 由一组可编程计数器组成，主要分成两个模块。第一个模块是 RTC 的预分 频模块，它可编程产生 1 秒的 RTC 时间基准 TR_CLK。RTC 的预分频模块包括了一个 20 位的 可编程分频器(RTC 预分频器)。如果在 RTC_CR 寄存器中设置相对应的允许位，则在每个 TR_CLK 周期中 RTC 产生一个中断(秒中断)。第二个模块是一个 32 位的可编程计数器，可被 初始化为当前的系统时间，一个 32 位的时钟计数器，按秒钟计算，可以记录 4294967296 秒， 约合 136 年左右，作为一般应用足够了。
RTC 还有一个闹钟寄存器 RTC_ALR，用于产生闹钟。系统时间按 TR_CLK 周期累加并与 存储在 RTC_ALR 寄存器中的可编程时间相比较，如果 RTC_CR 控制寄存器中设置了相应允许 位，比较匹配时将产生一个闹钟中断。
由于备份域的存在，所以 RTC 内核可以完全独立于 RTC APB1 接口。而软件是通过 APB1 接口访问 RTC 的预分频值、计数器值和闹钟值的。但是相关可读寄存器只在 RTC APB1 时钟进 行重新同步的 RTC 时钟的上升沿被更新，RTC 标志也是如此。这就意味着，如果 APB1 接口刚 刚被开启之后，在第一次的内部寄存器更新之前，从 APB1 上读取的 RTC 寄存器值可能被破坏 了（通常读到 0）。因此，若在读取 RTC 寄存器曾经被禁止的 RTC APB1 接口，软件首先必须 等待 RTC_CRL 寄存器的 RSF 位（寄存器同步标志位，bit3）被硬件置 1。
代码
rtc.c
#include "./BSP/RTC/rtc.h"
#include "./BSP/LED/led.h"
#include "./SYSTEM/usart/usart.h"
#include "./SYSTEM/delay/delay.h"
RTC_HandleTypeDef g_rtc_handle; /* RTC控制句柄 */
_calendar_obj calendar; /* 时钟结构体 */
/**
* @brief RTC写入后备区域SRAM
* @param bkrx : 后备区寄存器编号,范围:0~41
对应 RTC_BKP_DR1~RTC_BKP_DR42
* @param data : 要写入的数据,16位长度
* @retval 无
*/
void rtc_write_bkr(uint32_t bkrx, uint16_t data)
{
HAL_PWR_EnableBkUpAccess(); /* 取消备份区写保护 */
HAL_RTCEx_BKUPWrite(&g_rtc_handle, bkrx + 1, data);
}
/**
* @brief RTC读取后备区域SRAM
* @param bkrx : 后备区寄存器编号,范围:0~41
对应 RTC_BKP_DR1~RTC_BKP_DR42
* @retval 读取到的值
*/
uint16_t rtc_read_bkr(uint32_t bkrx)
{
uint32_t temp = 0;
temp = HAL_RTCEx_BKUPRead(&g_rtc_handle, bkrx + 1);
return (uint16_t)temp; /* 返回读取到的值 */
}
/**
* @brief RTC初始化
* @note
* 默认尝试使用LSE,当LSE启动失败后,切换为LSI.
* 通过BKP寄存器0的值,可以判断RTC使用的是LSE/LSI:
* 当BKP0==0X5050时,使用的是LSE
* 当BKP0==0X5051时,使用的是LSI
* 注意:切换LSI/LSE将导致时间/日期丢失,切换后需重新设置.
*
* @param 无
* @retval 0,成功
* 1,进入初始化模式失败
*/
uint8_t rtc_init(void)
{
/* 检查是不是第一次配置时钟 */
uint16_t bkpflag = 0;
__HAL_RCC_PWR_CLK_ENABLE(); /* 使能电源时钟 */
__HAL_RCC_BKP_CLK_ENABLE(); /* 使能备份时钟 */
HAL_PWR_EnableBkUpAccess(); /* 取消备份区写保护 */
bkpflag = rtc_read_bkr(0); /* 读取BKP0的值 */
g_rtc_handle.Instance = RTC;
g_rtc_handle.Init.AsynchPrediv = 32767; /*时钟周期设置,理论值：32767, 这里也可以用 RTC_AUTO_1_SECOND */
g_rtc_handle.Init.OutPut = RTC_OUTPUTSOURCE_NONE;
if (HAL_RTC_Init(&g_rtc_handle) != HAL_OK)
{
return 1;
}
if ((bkpflag != 0X5050) && (bkpflag != 0x5051)) /* 之前未初始化过，重新配置 */
{
rtc_set_time(2023, 11, 6, 0, 13, 20); /* 设置时间 */
}
__HAL_RTC_ALARM_ENABLE_IT(&g_rtc_handle, RTC_IT_SEC); /* 允许秒中断 */
HAL_NVIC_SetPriority(RTC_IRQn, 0x2, 0); /* 优先级设置 */
HAL_NVIC_EnableIRQ(RTC_IRQn); /* 使能RTC中断通道 */
rtc_get_time(); /* 更新时间 */
return 0;
}
/**
* @brief RTC初始化
* @note
* RTC底层驱动，时钟配置,此函数会被HAL_RTC_Init()调用
* @param hrtc:RTC句柄
* @retval 无
*/
void HAL_RTC_MspInit(RTC_HandleTypeDef *hrtc)
{
uint16_t retry = 200;
__HAL_RCC_RTC_ENABLE(); /* RTC时钟使能 */
RCC_OscInitTypeDef rcc_oscinitstruct;
RCC_PeriphCLKInitTypeDef rcc_periphclkinitstruct;
/* 使用寄存器的方式去检测LSE是否可以正常工作 */
RCC->BDCR |= 1 << 0; /* 开启外部低速振荡器LSE */
while (retry && ((RCC->BDCR & 0X02) == 0)) /* 等待LSE准备好 */
{
retry--;
delay_ms(5);
}
if (retry == 0) /* LSE起振失败 使用LSI */
{
rcc_oscinitstruct.OscillatorType = RCC_OSCILLATORTYPE_LSI; /* 选择要配置的振荡器 */
rcc_oscinitstruct.LSEState = RCC_LSI_ON; /* LSI状态：开启 */
rcc_oscinitstruct.PLL.PLLState = RCC_PLL_NONE; /* PLL无配置 */
HAL_RCC_OscConfig(&rcc_oscinitstruct); /* 配置设置的rcc_oscinitstruct */
rcc_periphclkinitstruct.PeriphClockSelection = RCC_PERIPHCLK_RTC; /* 选择要配置的外设 RTC */
rcc_periphclkinitstruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI; /* RTC时钟源选择 LSI */
HAL_RCCEx_PeriphCLKConfig(&rcc_periphclkinitstruct); /* 配置设置的rcc_periphClkInitStruct */
rtc_write_bkr(0, 0X5051);
}
else
{
rcc_oscinitstruct.OscillatorType = RCC_OSCILLATORTYPE_LSE ; /* 选择要配置的振荡器 */
rcc_oscinitstruct.LSEState = RCC_LSE_ON; /* LSE状态：开启 */
rcc_oscinitstruct.PLL.PLLState = RCC_PLL_NONE; /* PLL不配置 */
HAL_RCC_OscConfig(&rcc_oscinitstruct); /* 配置设置的rcc_oscinitstruct */
rcc_periphclkinitstruct.PeriphClockSelection = RCC_PERIPHCLK_RTC; /* 选择要配置外设 RTC */
rcc_periphclkinitstruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE; /* RTC时钟源选择LSE */
HAL_RCCEx_PeriphCLKConfig(&rcc_periphclkinitstruct); /* 配置设置的rcc_periphclkinitstruct */
rtc_write_bkr(0, 0X5050);
}
}
/**
* @brief RTC时钟中断
* @note 秒钟中断服务函数,顺带处理闹钟标志
* 根据RTC_CRL寄存器的 SECF 和 ALRF 位区分是哪个中断
* @param 无
* @retval 无
*/
void RTC_IRQHandler(void)
{
if (__HAL_RTC_ALARM_GET_FLAG(&g_rtc_handle, RTC_FLAG_SEC) != RESET) /* 秒中断 */
{
rtc_get_time(); /* 更新时间 */
__HAL_RTC_ALARM_CLEAR_FLAG(&g_rtc_handle, RTC_FLAG_SEC); /* 清除秒中断 */
//printf("sec:%d\r\n", calendar.sec); /* 打印秒钟 */
}
/* 顺带处理闹钟标志 */
if (__HAL_RTC_ALARM_GET_FLAG(&g_rtc_handle, RTC_FLAG_ALRAF) != RESET) /* 闹钟标志 */
{
__HAL_RTC_ALARM_CLEAR_FLAG(&g_rtc_handle, RTC_FLAG_ALRAF); /* 清除闹钟标志 */
printf("Alarm Time:%d-%d-%d %d:%d:%d\n", calendar.year, calendar.month, calendar.date, calendar.hour, calendar.min, calendar.sec);
}
__HAL_RTC_ALARM_CLEAR_FLAG(&g_rtc_handle, RTC_FLAG_OW); /* 清除溢出中断标志 */
while (!__HAL_RTC_ALARM_GET_FLAG(&g_rtc_handle, RTC_FLAG_RTOFF)); /* 等待RTC寄存器操作完成, 即等待RTOFF == 1 */
}
/**
* @brief 判断年份是否是闰年
* @note 月份天数表:
* 月份 1 2 3 4 5 6 7 8 9 10 11 12
* 闰年 31 29 31 30 31 30 31 31 30 31 30 31
* 非闰年 31 28 31 30 31 30 31 31 30 31 30 31
* @param year : 年份
* @retval 0, 非闰年; 1, 是闰年;
*/
static uint8_t rtc_is_leap_year(uint16_t year)
{
/* 闰年规则: 四年闰百年不闰，四百年又闰 */
if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
{
return 1;
}
else
{
return 0;
}
}
/**
* @brief 设置时间, 包括年月日时分秒
* @note 以1970年1月1日为基准, 往后累加时间
* 合法年份范围为: 1970 ~ 2105年
HAL默认为年份起点为2000年
* @param syear : 年份
* @param smon : 月份
* @param sday : 日期
* @param hour : 小时
* @param min : 分钟
* @param sec : 秒钟
* @retval 0, 成功; 1, 失败;
*/
uint8_t rtc_set_time(uint16_t syear, uint8_t smon, uint8_t sday, uint8_t hour, uint8_t min, uint8_t sec)
{
uint32_t seccount = 0;
seccount = rtc_date2sec(syear, smon, sday, hour, min, sec); /* 将年月日时分秒转换成总秒钟数 */
__HAL_RCC_PWR_CLK_ENABLE(); /* 使能电源时钟 */
__HAL_RCC_BKP_CLK_ENABLE(); /* 使能备份域时钟 */
HAL_PWR_EnableBkUpAccess(); /* 取消备份域写保护 */
/* 上面三步是必须的! */
RTC->CRL |= 1 << 4; /* 允许配置 */
RTC->CNTL = seccount & 0xffff;
RTC->CNTH = seccount >> 16;
RTC->CRL &= ~(1 << 4); /* 配置更新 */
while (!__HAL_RTC_ALARM_GET_FLAG(&g_rtc_handle, RTC_FLAG_RTOFF)); /* 等待RTC寄存器操作完成, 即等待RTOFF == 1 */
return 0;
}
/**
* @brief 设置闹钟, 具体到年月日时分秒
* @note 以1970年1月1日为基准, 往后累加时间
* 合法年份范围为: 1970 ~ 2105年
* @param syear : 年份
* @param smon : 月份
* @param sday : 日期
* @param hour : 小时
* @param min : 分钟
* @param sec : 秒钟
* @retval 0, 成功; 1, 失败;
*/
uint8_t rtc_set_alarm(uint16_t syear, uint8_t smon, uint8_t sday, uint8_t hour, uint8_t min, uint8_t sec)
{
uint32_t seccount = 0;
seccount = rtc_date2sec(syear, smon, sday, hour, min, sec); /* 将年月日时分秒转换成总秒钟数 */
__HAL_RCC_PWR_CLK_ENABLE(); /* 使能电源时钟 */
__HAL_RCC_BKP_CLK_ENABLE(); /* 使能备份域时钟 */
HAL_PWR_EnableBkUpAccess(); /* 取消备份域写保护 */
/* 上面三步是必须的! */
RTC->CRL |= 1 << 4; /* 允许配置 */
RTC->ALRL = seccount & 0xffff;
RTC->ALRH = seccount >> 16;
RTC->CRL &= ~(1 << 4); /* 配置更新 */
while (!__HAL_RTC_ALARM_GET_FLAG(&g_rtc_handle, RTC_FLAG_RTOFF)); /* 等待RTC寄存器操作完成, 即等待RTOFF == 1 */
return 0;
}
/**
* @brief 得到当前的时间
* @note 该函数不直接返回时间, 时间数据保存在calendar结构体里面
* @param 无
* @retval 无
*/
void rtc_get_time(void)
{
static uint16_t daycnt = 0;
uint32_t seccount = 0;
uint32_t temp = 0;
uint16_t temp1 = 0;
const uint8_t month_table[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; /* 平年的月份日期表 */
seccount = RTC->CNTH; /* 得到计数器中的值(秒钟数) */
seccount <<= 16;
seccount += RTC->CNTL;
temp = seccount / 86400; /* 得到天数(秒钟数对应的) */
if (daycnt != temp) /* 超过一天了 */
{
daycnt = temp;
temp1 = 1970; /* 从1970年开始 */
while (temp >= 365)
{
if (rtc_is_leap_year(temp1)) /* 是闰年 */
{
if (temp >= 366)
{
temp -= 366; /* 闰年的秒钟数 */
}
else
{
break;
}
}
else
{
temp -= 365; /* 平年 */
}
temp1++;
}
calendar.year = temp1; /* 得到年份 */
temp1 = 0;
while (temp >= 28) /* 超过了一个月 */
{
if (rtc_is_leap_year(calendar.year) && temp1 == 1) /* 当年是不是闰年/2月份 */
{
if (temp >= 29)
{
temp -= 29; /* 闰年的秒钟数 */
}
else
{
break;
}
}
else
{
if (temp >= month_table[temp1])
{
temp -= month_table[temp1]; /* 平年 */
}
else
{
break;
}
}
temp1++;
}
calendar.month = temp1 + 1; /* 得到月份 */
calendar.date = temp + 1; /* 得到日期 */
}
temp = seccount % 86400; /* 得到秒钟数 */
calendar.hour = temp / 3600; /* 小时 */
calendar.min = (temp % 3600) / 60; /* 分钟 */
calendar.sec = (temp % 3600) % 60; /* 秒钟 */
calendar.week = rtc_get_week(calendar.year, calendar.month, calendar.date); /* 获取星期 */
}
/**
* @brief 将年月日时分秒转换成秒钟数
* @note 输入公历日期得到星期(起始时间为: 公元0年3月1日开始, 输入往后的任何日期, 都可以获取正确的星期)
* 使用 基姆拉尔森计算公式 计算, 原理说明见此贴:
* https://www.cnblogs.com/fengbohello/p/3264300.html
* @param syear : 年份
* @param smon : 月份
* @param sday : 日期
* @retval 0, 星期天; 1 ~ 6: 星期一 ~ 星期六
*/
uint8_t rtc_get_week(uint16_t year, uint8_t month, uint8_t day)
{
uint8_t week = 0;
if (month < 3)
{
month += 12;
--year;
}
week = (day + 1 + 2 * month + 3 * (month + 1) / 5 + year + (year >> 2) - year / 100 + year / 400) % 7;
return week;
}
/**
* @brief 将年月日时分秒转换成秒钟数
* @note 以1970年1月1日为基准, 1970年1月1日, 0时0分0秒, 表示第0秒钟
* 最大表示到2105年, 因为uint32_t最大表示136年的秒钟数(不包括闰年)!
* 本代码参考只linux mktime函数, 原理说明见此贴:
* http://www.openedv.com/thread-63389-1-1.html
* @param syear : 年份
* @param smon : 月份
* @param sday : 日期
* @param hour : 小时
* @param min : 分钟
* @param sec : 秒钟
* @retval 转换后的秒钟数
*/
static long rtc_date2sec(uint16_t syear, uint8_t smon, uint8_t sday, uint8_t hour, uint8_t min, uint8_t sec)
{
uint32_t Y, M, D, X, T;
signed char monx = smon; /* 将月份转换成带符号的值, 方便后面运算 */
if (0 >= (monx -= 2)) /* 1..12 -> 11,12,1..10 */
{
monx += 12; /* Puts Feb last since it has leap day */
syear -= 1;
}
Y = (syear - 1) * 365 + syear / 4 - syear / 100 + syear / 400; /* 公元元年1到现在的闰年数 */
M = 367 * monx / 12 - 30 + 59;
D = sday - 1;
X = Y + M + D - 719162; /* 减去公元元年到1970年的天数 */
T = ((X * 24 + hour) * 60 + min) * 60 + sec; /* 总秒钟数 */
return T;
}
rtc.h
#ifndef __RTC_H
#define __RTC_H
#include "./SYSTEM/sys/sys.h"
/* 时间结构体, 包括年月日周时分秒等信息 */
typedef struct
{
uint8_t hour; /* 时 */
uint8_t min; /* 分 */
uint8_t sec; /* 秒 */
/* 公历年月日周 */
uint16_t year; /* 年 */
uint8_t month; /* 月 */
uint8_t date; /* 日 */
uint8_t week; /* 周 */
} _calendar_obj;
extern _calendar_obj calendar; /* 时间结构体 */
/* 静态函数 */
static uint8_t rtc_is_leap_year(uint16_t year); /* 判断当前年份是不是闰年 */
static long rtc_date2sec(uint16_t syear, uint8_t smon, uint8_t sday, uint8_t hour, uint8_t min, uint8_t sec); /* 将年月日时分秒转换成秒钟数 */
/* 接口函数 */
uint8_t rtc_init(void); /* 初始化RTC */
void rtc_get_time(void); /* 获取RTC时间信息 */
uint16_t rtc_read_bkr(uint32_t bkrx); /* 读取后备寄存器 */
void rtc_write_bkr(uint32_t bkrx, uint16_t data); /* 写后备寄存器 */
uint8_t rtc_get_week(uint16_t year, uint8_t month, uint8_t day); /* 根据年月日获取星期几 */
uint8_t rtc_set_time(uint16_t syear, uint8_t smon, uint8_t sday, uint8_t hour, uint8_t min, uint8_t sec); /* 设置时间 */
uint8_t rtc_set_alarm(uint16_t syear, uint8_t smon, uint8_t sday, uint8_t hour, uint8_t min, uint8_t sec); /* 设置闹钟时间 */
#endif
main.c
#include "./SYSTEM/sys/sys.h"
#include "./SYSTEM/usart/usart.h"
#include "./SYSTEM/delay/delay.h"
#include "./BSP/LED/led.h"
#include "./BSP/RTC/rtc.h"
int main(void)
{
HAL_Init(); /* 初始化 HAL 库 */
sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
delay_init(72); /* 延时初始化 */
usart_init(115200); /* 初始化串口 */
led_init();
rtc_init();
while(1)
{
rtc_get_time();
printf("Date:%04d-%02d-%02d ", calendar.year, calendar.month, calendar.date);
printf("Time:%02d:%02d:%02d \r\n", calendar.hour, calendar.min,calendar.sec);
LED1_TOGGLE();
delay_ms(1000);
}
}
函数详解：
先看 RTC 的初始化函数，该函数用来初始化 RTC 配置以及日期和时钟，但是只在第一次的时候设置时间，以后如果 重新上电/复位都不会再进行时间设置了（前提是备份电池有电）。在第一次配置的时候，我们 是按照上面介绍的 RTC 初始化步骤调用函数 HAL_RTC_Init 来实现的。我们通过读取 BKP 寄存器 0 的值来判断是否需要进行时间的设置，对 BKP 寄存器 0 的写 操作是在 HAL_RTC_MspInit 回调函数中实现，下面会讲。第一次未对 RTC 进行初始化 BKP 寄 存器 0 的值非 0x5050 非 0x5051，当进行 RTC 初始化时，BKP 寄存器 0 的值就是 0x5050 或 0x5051，所以以上代码操作确保时间只会设置一次，复位时不会重新设置时间。电池正常供电 时，我们设置的时间不会因复位或者断电而丢失。
介绍完 RTC 初始化相关函数后，我们来介绍一下 rtc_set_time 函数，该函数用于设置时间，把我们输入的时间，转换为以 1970 年 1 月 1 日 0 时 0 分 0 秒做起 始时间的秒钟信号，后续的计算都以这个时间为基准，由于 STM32 的秒钟计数器可以保存 136 年的秒钟数据，这样我们就可以计时到 2106 年。
接着，我们介绍 rtc_set_alarma 函数，该函数用于设置闹钟时间，同 rtc_set_time 函数几乎 一模一样，主要区别：就是将RTC→CNTL和RTC→CNTH换成了RTC→ALRL和RTC→ALRH， 用于设置闹钟时间。RTC 其实是有闹钟中断的，我们这里并没有用到，本实验用到了秒中断， 所以在秒中断里顺带处理闹钟中断的事情。具体代码请参考本例程源码。特别提醒：假如只是使用 HAL 库的__HAL_RTC_ALARM_ENABLE_IT 函数来使能闹钟中 断，但是没有设置闹钟相关的 NVIC 和 EXTI，实际上不会产生闹钟中断，只会产生闹钟标志 （RTC->CRL 的 ALRL 置位）。可以通过读取闹钟标志来判断是否发生闹钟事件。
接着，我们介绍一下 rtc_get_time 函数，该函数其实就是将存储在秒钟寄存器 RTC->CNTL 和 RTC->CNTH 中的秒钟数据转换为真 正的时间和日期。该代码还用到了一个 calendar 的结构体，calendar 是我们在 rtc.h 里面将要定 义的一个时间结构体，用来存放时钟的年月日时分秒等信息。因为 STM32 的 RTC 只有秒钟计 数器，而年月日，时分秒则需要我们自己软件计算。我们把计算好的值保存在 calendar 里面， 方便其他函数调用。
接着，我们介绍一下使用多次数最多的函数 rtc_date2sec，该函数参考了 linux 的 mktime 函数，用于将年月日时分秒转化成秒钟数，进而被其他函数 使用，例如 rtc_set_time 和 rtc_set_alarm，那两个函数的形参是需要使用 rtc_date2sec 函数获取 秒钟数，进而操作寄存器的方法把总秒数写入特定的寄存器完成相对应的功能。
前面介绍的函数 rtc_init 中，存在 RTC 中断使能操作，那么这里必定是有中断服务函数， 接下来看中断服务函数，RTC_IRQHandle 中断服务函数用于 RTC 秒中断的，由于在 rtc_init 中已经配置好了时钟周 期为 1 秒，所以每一秒都会跳进 RTC 中断服务函数中。在函数中，判断秒中断是否触发，由于 每一次都是秒中断触发，所以可以先更新时间，然后把 printf 的注释去掉看一下效果，是不是 每一秒打印一下。接着判断闹钟标志是否置位，这个闹钟标志跟我们的 rtc_set_alarm 函数有关， 假设时间到了闹钟设置的时间，就会跳进该秒中断中顺带处理闹钟标志，执行函数体的指令。 执行完上述的任务之后，需要在最后清除溢出中断标志。
扫一扫
356
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
