stm32 RTC实时时钟[操作寄存器+库函数]
"RTC"是Real Time Clock 的简称，意为实时时钟。stm32提供了一个秒中断源和一个闹钟中断源。
RTC的技术器是一个32位的计数器，使用32.768khz的外部晶振。
2038年问题
在计算机应用上，2038年问题可能会导致某些软件在2038年无法正常工作。所有使用UNIX时间表示时间的程序都将受其影响，因为它们以自1970年1月1日经过的秒数（忽略闰秒）来表示时间。这种时间表示法在类Unix（Unix-like）操作系统上是一个标准，并会影响以其C编程语言开发给其他大部份操作系统使用的软件。
在大部份的32位操作系统上，此“time_t”数据模式使用一个有正负号的32位元整数（signedint32)存储计算的秒数。也就是说最大可以计数的秒数为 2^31次方 可以算得：
2^31/3600/24/365 ≈ 68年
所以依照此“time_t”标准，在此格式能被表示的最后时间是2038年1月19日03:14:07，星期二（UTC）。超过此一瞬间，时间将会被掩盖（wrap around）且在内部被表示为一个负数，并造成程序无法工作，因为它们无法将此时间识别为2038年，而可能会依个别实作而跳回1970年或1901年。
对于PC机来说，时间开始于1980年1月1日，并以无正负符号的32位整数的形式按秒递增，这与UNIX时间非常类似。可以算得：
2^32/3600/24/365 ≈ 136年
到2116年，这个整数将溢出。
Windows NT使用64位整数来计时。但是，它使用100纳秒作为增量单位，且时间开始于1601年1月1日，所以NT将遇到2184年问题。
苹果公司声明，Mac在29,940年之前不会出现时间问题！
由于RTC是一个32位计数器，同样其计时时间是有限的。库函数中使用到了C标准时间库，时间库中的计时起始时间是1900年，可以知道时间库中不是用 有符号位的32位整数来表示时间的，否则在1968年就已经溢出了。如果用32位无符号整数计时，其溢出时间为2036年左右，所以会遇到这个问题。
直接操作寄存器中，可以自由设定这个时间戳起始的年份，RTC的32位寄存器存储的只是距离这个起始年份的总秒数，所以不会遇到这个问题。而且可以用无符号32位的二进制表示时间，这意味着此类系统的时间戳可以表示更多的秒数。但是由于其使用32位寄存器表示秒数，最大只能计时到136年后。
本例实现使用stm32每秒输出一次当前的时间，并设置一个闹钟，到时间时输出提醒信息。
直接操作寄存器
RTC实时时钟的操作原则是 在每次读写前都要保证上一次读写完成。
代码较多，使用到的寄存器请参见手册 （system.h 和 stm32f10x_it.h 等相关代码参照 stm32 直接操作寄存器开发环境配置）
User/main.c
#include
#include "system.h"
#include "usart.h"
#include "rtc.h"
#define LED1 PAout(4)
#define LED2 PAout(5)
void Gpio_Init(void);
extern const u8* Week_Table[7];
int main(void)
{
Rcc_Init(9); //系统时钟设置
Usart1_Init(72,9600);
Nvic_Init(0,0,RTC_IRQChannel,0); //设置中断
Gpio_Init();
Rtc_Init();
//Rtc_TIME_AutoSet(); //将当前编译时间作为RTC开始时间
Rtc_TIME_Set(2012,7,7,20,50,0); //设定开始时间 参数说明：年，月，日，时，分，秒
Rtc_ALARM_Set(2012,7,7,20,50,30); //设定闹钟事件时间
LED1 = 1;
while(1);
}
void Gpio_Init(void)
{
RCC->APB2ENR|=1<<2; //使能PORTA时钟
GPIOA->CRL&=0x0000FFFF; // PA0~3设置为浮空输入，PA4~7设置为推挽输出
GPIOA->CRL|=0x33334444;
//USART1 串口I/O设置
GPIOA -> CRH&=0xFFFFF00F; //设置USART1 的Tx(PA.9)为第二功能推挽，50MHz；Rx(PA.10)为浮空输入
GPIOA -> CRH|=0x000008B0;
}
User/stm32f103x_it.c
#include "stm32f10x_it.h"
#include "system.h"
#include "stdio.h"
#include "rtc.h"
#define LED1 PAout(4)
#define LED2 PAout(5)
#define LED3 PAout(6)
#define LED4 PAout(7)
//extern void Wwdg_Feed(void);
//extern u16 Read_Bkp(u8 reg);
extern void Rtc_Get(void);
extern const u8* Week_Table[7];
void RTC_IRQHandler(void)
{
if(RTC->CRL&0x0001) //秒钟中断
{
LED4 = !LED4;
Rtc_Get();
printf("\r\n Time : %d - %d - %d,%d : %d : %d ,Today is %s \r\n",
timer.year,
timer.month,
timer.date,
timer.hour,
timer.minute,
timer.second,
Week_Table[timer.week]
);
}
if(RTC->CRL&0x0002) //闹钟中断
{
LED3 = 1;
printf("\r\nIt's time to do sth.\r\n");
RTC->CRL &= ~(0x0002); //清除闹钟中断
}
RTC->CRL &= 0x0FFA; //清除溢出，秒钟中断
while(!(RTC->CRL &(1<<5))); //等待RTC寄存器操作完成
}
Library/src/rtc.c
#include
#include "rtc.h"
#include "stdio.h"
tm timer; //定义时钟结构体,主函数直接可以调用此结构体读出时间
//平年的月份日期表,月份缩写表
const u8 Days_Table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
const u8 Month_Table[12][3]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
const u8* Week_Table[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
//月修正数据表
u8 const _Week[12]={0,3,3,6,1,4,6,2,5,0,3,5};
void Rtc_Init(void)
{
RCC->APB1ENR |= 1<<28; //使能PWR时钟
RCC->APB1ENR |= 1<<27; //使能BKP时钟,RTC校准在BKP相关寄存器中
PWR->CR |= 1<<8; //取消BKP相关寄存器写保护
//RCC->BDCR |= 1<<16; //备份区域软复位
//RCC->BDCR |= ~(1<<16); //备份区域软复位结束
RCC->BDCR |= 1<<0; //外部低速时钟（LSE）使能
while(!(RCC->BDCR & 0x02)); //等待外部时钟就绪
RCC->BDCR |= 1<<8; //LSE作为RTC时钟
RCC->BDCR |= 1<<15; //RTC时钟使能
while(!(RTC->CRL & (1<<5))); //等待RTC寄存器最后一次操作完成
while(!(RTC->CRL & (1<<3))); //等待RTC寄存器同步完成
RTC->CRH |= 0x07; //允许溢出中断[2]，闹钟中断[1]，秒中断[0],CRH寄存器低三位有效
while(!(RTC->CRL & (1<<5))); //等待RTC寄存器最后一次操作完成
RTC->CRL |= 1<<4; //进入配置模式
RTC->PRLH = 0x0000;
RTC->PRLL = 32767; //设定分频值
//Rtc_TIME_AutoSet(); //将当前编译时间写入寄存器
//Rtc_TIME_Set(2012,7,7,20,50,0); //年，月，日，时，分，秒
RTC->CRL &= ~(1<<4); //退出配置模式，开始更新RTC寄存器
while(!(RTC->CRL & (1<<5))); //等待RTC寄存器最后一次操作完成
}
//设定RTC开始计时时间
void Rtc_TIME_Set(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second)
{
u32 sec;
sec = Date_TO_Sec(year,month,date,hour,minute,second);
//printf("\nRtc TIME Set Sec = %x\n",sec);
RCC->APB1ENR |= 1<<28; //使能PWR时钟,方便独立调用此函数
RCC->APB1ENR |= 1<<27; //使能BKP时钟
PWR->CR |= 1<<8; //取消写保护
RTC-> CRL |= 1<<4; //允许配置
RTC-> CNTL = sec&0xffff; //取低16位
RTC-> CNTH = sec>>16; //取高16位
RTC-> CRL &= ~(1<<4); //开始RTC寄存器更新
while(!(RTC->CRL&(1<<5))); //等待RTC寄存器操作完成
}
//判断是否是闰年函数
//
//判断方法：
// 普通年能整除4且不能整除100的为闰年。（如2004年就是闰年,1900年不是闰年）
// 世纪年能整除400的是闰年。(如2000年是闰年，1900年不是闰年)
//
//返回: 1,是闰年 0,不是闰年
u8 Is_LeapYear(u16 year)
{
if(year%4==0) //必须能被4整除
{
if(year%100==0)
{
if(year%400==0)
return 1; //如果以00结尾,还要能被400整除
else
return 0;
}else{
return 1;
}
}else{
return 0;
}
}
//将时间转化为到1970年1月1日的总秒数
//Bugs:此函数秒数会多20左右，所以函数返回值做了校正,校正后没有问题
//待优化
u32 Date_TO_Sec(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second)
{
u16 t;
u32 sec;
if(year >= 1970 && year<= 2106) //判断是否为合法年份，RTC的时间是从1970开始，只能由32位表示秒数，最大只能到2106年左右
{
for(t= 1970 ;tCNTH; //读取RTC的当前时间值（距1970年的总秒数）
secs <<= 16;
secs += RTC->CNTL;
//printf("\nRtc_Get Sec = %x\n",secs);
days = secs/86400;
if(days > 0) //超过一天
{
temp = days;
while(temp >= 365)
{
if(Is_LeapYear(years)) //是闰年
{
if(temp >= 366)
temp -= 366; //闰年的天数
else
break;
}else{
temp -= 365;
}
years++;
}
timer.year = years; //得到年份
while(days >= 28)
{
if(Is_LeapYear(years) && months ==1) //判断是否为闰年的第二月
{
if(temp >= 29)
temp -= 29;
else
break;
}else{
if(temp >= Days_Table[months])
temp -= Days_Table[months];
else
break;
}
months++;
}
timer.month = months+1; //得到月数
timer.date = temp+1; //得到日期
}
temp = secs % 86400; //得到剩余秒数
timer.hour = temp/3600; //得到小时
timer.minute = (temp%3600)/60;
timer.second = (temp%3600)%60;
timer.week = Rtc_DAY_Get(timer.year,timer.month,timer.date);
}
//判断当前为星期几
u8 Rtc_DAY_Get(u16 year,u8 month,u8 day)
{
u16 temp;
u8 yearH,yearL;
yearH = year/100;
yearL = year%100;
// 如果为21世纪,年份数加100
if( yearH > 19 ) yearL += 100;
// 所过闰年数只算1900年之后的
temp = yearL+yearL/4;
temp = temp%7;
temp = temp + day + _Week[month-1];
if( yearL%4 == 0 && month < 3 ) temp--;
return(temp%7);
}
//设定闹钟时间
void Rtc_ALARM_Set(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second)
{
u32 sec;
sec = Date_TO_Sec(year,month,date,hour,minute,second);
RTC-> CRL |= 1<<4; //允许配置
//while(!(RTC->CRL&(1<<5))); //RTOFF为1 才可以写入ALRL和ALRH寄存器
RTC-> ALRL = sec&0xffff; //取低16位
RTC-> ALRH = sec>>16; //取高16位
RTC-> CRL &= ~(1<<4); //开始RTC寄存器更新
while(!(RTC->CRL&(1<<5))); //等待RTC寄存器操作完成
}
Library/inc/rtc.h
#include
typedef struct
{
u8 hour;
u8 minute;
u8 second;
u16 year;
u8 month;
u8 date;
u8 week;
}tm;
extern tm timer;
void Rtc_Init(void);
void Rtc_TIME_Set(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second);
u8 Is_LeapYear(u16 year);
u32 Date_TO_Sec(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second);
void Rtc_TIME_AutoSet(void);
void Rtc_Get(void);
void Rtc_ALARM_Set(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second);
u8 Rtc_DAY_Get(u16 year,u8 month,u8 day);
这里用到了MDK的两个关键字 __DATE__ 和 __TIME__获得当前编译的日期和时间，详见代码注释
库函数操作
ANSI C语言所提供的time.h的头文件中关于unix时间戳是从1900年开始的，和直接操作寄存器不同，所以如果unix时间戳中读出年份为100，则正确年份为1900+100=2000
代码如下:
main.c
#include "stm32f10x.h"
#include "stdio.h"
#include "time.h"
#define PRINTF_ON 1
void RCC_Configuration(void);
void GPIO_Configuration(void);
void NVIC_Configuration(void);
void USART_Configuration(void);
void RTC_Configuration(void);
void TimeShow(void);
void SetAlarm(struct tm t);
void SetCalendarTime(struct tm t);
void SetUnixTime(time_t);
struct tm ConvUnixToCalendar(time_t t);
u32 ConvCalendarToUnix(struct tm t);
u32 GetUnixTime(void);
vu32 Display;
struct tm CurrentTime = {0,30,10,11,4,2011};
struct tm AlarmTime = {5,30,10,11,4,2011};
int main(void)
{
RCC_Configuration();
GPIO_Configuration();
NVIC_Configuration();
USART_Configuration();
RTC_Configuration();
SetCalendarTime(CurrentTime);
SetAlarm(AlarmTime);
while(1){ TimeShow(); }
}
void TimeShow(void)
{
u32 Time = 0;
if(Display)
{
Time = GetUnixTime();
CurrentTime = ConvUnixToCalendar(Time);
printf("\r\n Time : %d - %d - %d，%d : %d : %d \r\n",
CurrentTime.tm_year,
CurrentTime.tm_mon,
CurrentTime.tm_mday,
CurrentTime.tm_hour,
CurrentTime.tm_min,
CurrentTime.tm_sec);
Display = 0;
}
}
void SetCalendarTime(struct tm t)
{
SetUnixTime(ConvCalendarToUnix(t));
}
void SetUnixTime(time_t t)
{
RTC_WaitForLastTask();
RTC_SetCounter((u32)t);
RTC_WaitForLastTask();
}
void SetAlarm(struct tm t)
{
RTC_WaitForLastTask();
RTC_SetAlarm(ConvCalendarToUnix(t));
RTC_WaitForLastTask();
}
u32 GetUnixTime(void)
{
return (u32)RTC_GetCounter();
}
u32 ConvCalendarToUnix(struct tm t)
{
t.tm_year -=1900;
return mktime(&t);
}
struct tm ConvUnixToCalendar(time_t t)
{
struct tm *t_tm;
t_tm = localtime(&t);
t_tm->tm_year += 1900;
return *t_tm;
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA , &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA , &GPIO_InitStructure);
}
void RTC_Configuration(void)
{
PWR_BackupAccessCmd(ENABLE);
BKP_DeInit();
RCC_LSEConfig(RCC_LSE_ON);
while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET);
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
RCC_RTCCLKCmd(ENABLE);
RTC_WaitForSynchro();
RTC_WaitForLastTask();
RTC_ITConfig(RTC_IT_SEC|RTC_IT_ALR,ENABLE);
RTC_WaitForLastTask();
RTC_SetPrescaler(32767);
RTC_WaitForLastTask();
}
void RCC_Configuration(void)
{
/* 定义枚举类型变量 HSEStartUpStatus */
ErrorStatus HSEStartUpStatus;
/* 复位系统时钟设置*/
RCC_DeInit();
/* 开启HSE*/
RCC_HSEConfig(RCC_HSE_ON);
/* 等待HSE起振并稳定*/
HSEStartUpStatus = RCC_WaitForHSEStartUp();
/* 判断HSE起是否振成功，是则进入if()内部 */
if(HSEStartUpStatus == SUCCESS)
{
/* 选择HCLK（AHB）时钟源为SYSCLK 1分频 */
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* 选择PCLK2时钟源为 HCLK（AHB） 1分频 */
RCC_PCLK2Config(RCC_HCLK_Div1);
/* 选择PCLK1时钟源为 HCLK（AHB） 2分频 */
RCC_PCLK1Config(RCC_HCLK_Div2);
/* 设置FLASH延时周期数为2 */
FLASH_SetLatency(FLASH_Latency_2);
/* 使能FLASH预取缓存 */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
/* 选择锁相环（PLL）时钟源为HSE 1分频，倍频数为9，则PLL输出频率为 8MHz * 9 = 72MHz */
RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
/* 使能PLL */
RCC_PLLCmd(ENABLE);
/* 等待PLL输出稳定 */
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
/* 选择SYSCLK时钟源为PLL */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* 等待PLL成为SYSCLK时钟源 */
while(RCC_GetSYSCLKSource() != 0x08);
}
/* 打开APB2总线上的GPIOA时钟*/
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP, ENABLE);
}
void USART_Configuration(void)
{
USART_InitTypeDef USART_InitStructure;
USART_ClockInitTypeDef USART_ClockInitStructure;
USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
USART_ClockInit(USART1 , &USART_ClockInitStructure);
USART_InitStructure.USART_BaudRate = 9600;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx;
USART_Init(USART1,&USART_InitStructure);
USART_Cmd(USART1,ENABLE);
}
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
#if PRINTF_ON
int fputc(int ch,FILE *f)
{
USART_SendData(USART1,(u8) ch);
while(USART_GetFlagStatus(USART1,USART_FLAG_TC) == RESET);
return ch;
}
#endif
stm32f10x_it.c:
#include "stm32f10x_it.h"
#include "stdio.h"
extern vu32 Display;
void RTC_IRQHandler(void)
{
if(RTC_GetFlagStatus(RTC_FLAG_ALR) != RESET){
printf("\r\nIt's time to do sth.\r\n");
}else{
Display =1 ;
}
RTC_ClearITPendingBit(RTC_IT_ALR|RTC_IT_SEC);
}