基于STM32的RTC实时时钟实验_stm32 rtc闹钟脉冲测试

#define ADC_IT_EOC                                 ((uint16_t)0x0220)  
#define ADC_IT_AWD                                 ((uint16_t)0x0140)  
#define ADC_IT_JEOC                                ((uint16_t)0x0480)  

#define ADC_FLAG_AWD                               ((uint8_t)0x01)  
#define ADC_FLAG_EOC                               ((uint8_t)0x02)  
#define ADC_FLAG_JEOC                              ((uint8_t)0x04)  
#define ADC_FLAG_JSTRT                             ((uint8_t)0x08)  
#define ADC_FLAG_STRT                              ((uint8_t)0x10)  

RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE); // 外设时钟使能
 
RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE);  // 复位外设的总线时钟
  
RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, DISABLE); // 清除复位外设的总线时钟
  
USART_Init(USART1, &USART_InitStructure); // 重新初始化

#include "rtc.h"  
#include "usart.h"  
#include "delay.h"  
#include "stm32f10x.h"  
  
_calendar_obj calendar;//时钟结构体   
  
u8 RTC_initConfig()  
{  
    u8 temp = 0;  
    NVIC_InitTypeDef NVIC_InitStructure;  
      
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP|RCC_APB1Periph_PWR, ENABLE); // 使能APB1总线上的BKP与PWR的时钟  
    PWR_BackupAccessCmd(ENABLE); // 取消后备区域写保护  
    delay_init(); // delay函数初始化  
      
    NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;  
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;  
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;  
    NVIC_Init(&NVIC_InitStructure); // 配置RTC的NVIC中断通道  
      
    if(BKP_ReadBackupRegister(BKP_DR1) == 0x5050) // 首次执行程序段  
    {  
        BKP_DeInit(); // BKP外设时钟复位  
        RCC_LSEConfig(RCC_LSE_ON); // LSE低速时钟使能  
          
        while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET && temp < 250)  
        {  
            temp++;  
            delay_ms(10);  
        }  
        if(temp>=250) return 1;  
        RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);  
        RCC_RTCCLKCmd(ENABLE);  
          
        RTC_WaitForLastTask(); // 等待RTC操作完成  
        RTC_WaitForSynchro(); // 等待APB1与RTC时钟同步  
          
        RTC_EnterConfigMode(); // 进入RTC配置模式  
          
        RTC_WaitForLastTask(); // 等待RTC操作完成  
        RTC_WaitForSynchro(); // 等待APB1与RTC时钟同步  
          
        RTC_SetPrescaler(32768-1); // 1s溢出一次  
          
        RTC_WaitForLastTask(); // 等待RTC操作完成  
        RTC_WaitForSynchro(); // 等待APB1与RTC时钟同步  
          
        RTC_ITConfig(RTC_IT_OW|RTC_IT_SEC,ENABLE); // RTC中断配置  
          
        RTC_WaitForLastTask(); // 等待RTC操作完成  
        RTC_WaitForSynchro(); // 等待APB1与RTC时钟同步  
          
        RTC_Set(2015,1,14,17,42,55);  //将时间转化为以秒为单位的数值加载到32位可编程计数器当中      
          
        RTC_WaitForLastTask(); // 等待RTC操作完成  
        RTC_WaitForSynchro(); // 等待APB1与RTC时钟同步  
          
        RTC_ExitConfigMode(); // 退出配置模式，并且执行在此之前写入的命令  
          
        BKP_WriteBackupRegister(BKP_DR1,0x5050); // 向BKP_DR1(16位寄存器)寄存器写入0x5050这个16位数据  
    }  
    else // 再次进行执行的程序段(系统/电源复位后执行)  
    {  
        RTC_WaitForLastTask(); // 等待RTC操作完成  
        RTC_WaitForSynchro(); // 等待APB1与RTC时钟同步  
          
        RTC_ITConfig(RTC_IT_OW|RTC_IT_SEC,ENABLE); // 系统/电源复位后执行后，RTC的CR寄存器被复位因此需要重新配置RTC中断  
          
        RTC_WaitForLastTask(); // 等待RTC操作完成  
    }  
    return 0;  
}  
  
//RTC时钟中断  
//每秒触发一次    
//extern u16 tcnt;   
void RTC_IRQHandler(void)  
{          
    if (RTC_GetITStatus(RTC_IT_SEC) != RESET)//秒钟中断  
    {                             
        RTC_Get();//更新时间     
    }  
    if(RTC_GetITStatus(RTC_IT_ALR)!= RESET)//闹钟中断  
    {  
        RTC_ClearITPendingBit(RTC_IT_ALR);      //清闹钟中断       
        RTC_Get();              //更新时间     
        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);//输出闹铃时间    
    }                                                  
    RTC_ClearITPendingBit(RTC_IT_SEC|RTC_IT_OW);        //清闹钟中断  
    RTC_WaitForLastTask();                                             
}  
//判断是否是闰年函数  
//月份   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  
//输入:年份  
//输出:该年份是不是闰年.1,是.0,不是  
u8 Is_Leap_Year(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日为基准  
//1970~2099年为合法年份  
//返回值:0,成功;其他:错误代码.  
//月份数据表                                            
u8 const table_week[12]={0,3,3,6,1,4,6,2,5,0,3,5}; //月修正数据表     
//平年的月份日期表  
const u8 mon_table[12]={31,28,31,30,31,30,31,31,30,31,30,31};  
u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)  
{  
    u16 t;  
    u32 seccount=0;  
    if(syear<1970||syear>2099)return 1;        
    for(t=1970;t<syear;t++)  //把所有年份的秒钟相加  
    {  
        if(Is_Leap_Year(t))seccount+=31622400;//闰年的秒钟数  
        else seccount+=31536000;              //平年的秒钟数  
    }  
    smon-=1;  
    for(t=0;t<smon;t++)     //把前面月份的秒钟数相加  
    {  
        seccount+=(u32)mon_table[t]*86400;//月份秒钟数相加  
        if(Is_Leap_Year(syear)&&t==1)seccount+=86400;//闰年2月份增加一天的秒钟数         
    }  
    seccount+=(u32)(sday-1)*86400;//把前面日期的秒钟数相加   
    seccount+=(u32)hour*3600;//小时秒钟数  
    seccount+=(u32)min*60;   //分钟秒钟数  
    seccount+=sec;//最后的秒钟加上去  
  
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟    
    PWR_BackupAccessCmd(ENABLE);    //使能RTC和后备寄存器访问   
    RTC_SetCounter(seccount);   //设置RTC计数器的值  
  
    RTC_WaitForLastTask();  //等待最近一次对RTC寄存器的写操作完成     
    return 0;         
}  
  
//初始化闹钟         
//以1970年1月1日为基准  
//1970~2099年为合法年份  
//syear,smon,sday,hour,min,sec：闹钟的年月日时分秒     
//返回值:0,成功;其他:错误代码.  
u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec)  
{  
    u16 t;  
    u32 seccount=0;  
    if(syear<1970||syear>2099)return 1;        
    for(t=1970;t<syear;t++)  //把所有年份的秒钟相加  
    {  
        if(Is_Leap_Year(t))seccount+=31622400;//闰年的秒钟数  
        else seccount+=31536000;              //平年的秒钟数  
    }  
    smon-=1;  
    for(t=0;t<smon;t++)     //把前面月份的秒钟数相加  
    {  
        seccount+=(u32)mon_table[t]*86400;//月份秒钟数相加  
        if(Is_Leap_Year(syear)&&t==1)seccount+=86400;//闰年2月份增加一天的秒钟数         
    }  
    seccount+=(u32)(sday-1)*86400;//把前面日期的秒钟数相加   
    seccount+=(u32)hour*3600;//小时秒钟数  
    seccount+=(u32)min*60;   //分钟秒钟数  
    seccount+=sec;//最后的秒钟加上去                  
    //设置时钟  
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟     
    PWR_BackupAccessCmd(ENABLE);    //使能后备寄存器访问    
    //上面三步是必须的!  
      
    RTC_SetAlarm(seccount);  
   
    RTC_WaitForLastTask();  //等待最近一次对RTC寄存器的写操作完成     
      
    return 0;         
}  
  
  
//得到当前的时间  
//返回值:0,成功;其他:错误代码.  
u8 RTC_Get(void)  
{  
    static u16 daycnt=0;  
    u32 timecount=0;   
    u32 temp=0;  
    u16 temp1=0;        
    timecount=RTC_GetCounter();    
    temp=timecount/86400;   //得到天数(秒钟数对应的)  
    if(daycnt!=temp)//超过一天了  
    {       
        daycnt=temp;  
        temp1=1970; //从1970年开始  
        while(temp>=365)  
        {                  
            if(Is_Leap_Year(temp1))//是闰年  
            {  
                if(temp>=366)temp-=366;//闰年的秒钟数  
                else {temp1++;break;}    
            }  
            else temp-=365;   //平年   
            temp1++;    
        }     
        calendar.w_year=temp1; //得到年份  
        temp1=0;  
        while(temp>=28)//超过了一个月  
        {  
            if(Is_Leap_Year(calendar.w_year)&&temp1==1)//当年是不是闰年/2月份  
            {  
                if(temp>=29)temp-=29;//闰年的秒钟数  
                else break;   
            }  
            else   
            {  
                if(temp>=mon_table[temp1])temp-=mon_table[temp1];//平年  
                else break;  
            }  
            temp1++;    
        }  
        calendar.w_month=temp1+1;   //得到月份  
        calendar.w_date=temp+1;     //得到日期   
    }  
    temp=timecount%86400;           //得到秒钟数          
    calendar.hour=temp/3600;        //小时  
    calendar.min=(temp%3600)/60;    //分钟      
    calendar.sec=(temp%3600)%60;    //秒钟  
    calendar.week=RTC_Get_Week(calendar.w_year,calendar.w_month,calendar.w_date);//获取星期     
    return 0;  
}      
//获得现在是星期几  
//功能描述:输入公历日期得到星期(只允许1901-2099年)  
//输入参数：公历年月日   
//返回值：星期号                                                                                          
u8 RTC_Get_Week(u16 year,u8 month,u8 day)  
{     
    u16 temp2;  
    u8 yearH,yearL;  
      
    yearH=year/100; yearL=year%100;   
    // 如果为21世纪,年份数加100    
    if (yearH>19)yearL+=100;  
    // 所过闰年数只算1900年之后的    
    temp2=yearL+yearL/4;  
    temp2=temp2%7;   
    temp2=temp2+day+table_week[month-1];  
    if (yearL%4==0&&month<3)temp2--;  
    return(temp2%7);  
} 

#ifndef _RTC_H  
#define _RTC_H  
  
#include "sys.h"  
  
//时间结构体  
typedef struct   
{  
    vu8 hour;  
    vu8 min;  
    vu8 sec;              
    //公历日月年周  
    vu16 w_year;  
    vu8  w_month;  
    vu8  w_date;  
    vu8  week;         
}_calendar_obj;  
  
u8 RTC_initConfig();  
u8 Is_Leap_Year(u16 year);  
u8 RTC_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);  
u8 RTC_Alarm_Set(u16 syear,u8 smon,u8 sday,u8 hour,u8 min,u8 sec);  
u8 RTC_Get(void);  
u8 RTC_Get_Week(u16 year,u8 month,u8 day);  
  
#endif  

#include "delay.h"  
#include "sys.h"  
#include "lcd.h"  
#include "usart.h"     
#include "rtc.h"  
  
extern _calendar_obj calendar;//时钟结构体   
  
 int main(void)  
 {     
    u8 t=0;  
    delay_init();            //延时函数初始化      
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级  
    uart_init(115200);      //串口初始化为115200  
    LCD_Init();       
    RTC_initConfig(); // RTC初始化  
    POINT_COLOR=RED;//设置字体为红色   
    LCD_ShowString(60,50,200,16,16,"WarShip STM32");      
    LCD_ShowString(60,70,200,16,16,"RTC TEST");   
    LCD_ShowString(60,90,200,16,16,"ATOM@ALIENTEK");  
    LCD_ShowString(60,110,200,16,16,"2015/1/14");         
    //显示时间  
    POINT_COLOR=BLUE;//设置字体为蓝色  
    LCD_ShowString(60,130,200,16,16,"    -  -  ");       
    LCD_ShowString(60,162,200,16,16,"  :  :  ");              
    while(1)  
    {                                     
        if(t!=calendar.sec)  
        {  
            t=calendar.sec;  
            LCD_ShowNum(60,130,calendar.w_year,4,16);                                       
            LCD_ShowNum(100,130,calendar.w_month,2,16);                                     
            LCD_ShowNum(124,130,calendar.w_date,2,16);     
            switch(calendar.week)  
            {  
                case 0:  
                    LCD_ShowString(60,148,200,16,16,"Sunday   ");  
                    break;  
                case 1:  
                    LCD_ShowString(60,148,200,16,16,"Monday   ");  
                    break;  
                case 2:  
                    LCD_ShowString(60,148,200,16,16,"Tuesday  ");  
                    break;  
                case 3:  
                    LCD_ShowString(60,148,200,16,16,"Wednesday");  
                    break;  
                case 4:  
                    LCD_ShowString(60,148,200,16,16,"Thursday ");  
                    break;  
                case 5:  
                    LCD_ShowString(60,148,200,16,16,"Friday   ");  
                    break;  
                case 6:  
                    LCD_ShowString(60,148,200,16,16,"Saturday ");  
                    break;    
            }  
            LCD_ShowNum(60,162,calendar.hour,2,16);                                     
            LCD_ShowNum(84,162,calendar.min,2,16);                                      
            LCD_ShowNum(108,162,calendar.sec,2,16);  
        }     
        delay_ms(10);                                   
    };    
 } 

RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟     
PWR_BackupAccessCmd(ENABLE);    //使能后备寄存器访问   

BKP_DeInit();   //复位备份区域      
RCC_LSEConfig(RCC_LSE_ON);  //设置外部低速晶振(LSE),使用外设低速晶振  
while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET&&temp<250)    //检查指定的RCC标志位设置与否,等待低速晶振就绪  
{  
    temp++;  
    delay_ms(10);  
}  
if(temp>=250)return 1;//初始化时钟失败,晶振有问题          
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);     //设置RTC时钟(RTCCLK),选择LSE作为RTC时钟      
RCC_RTCCLKCmd(ENABLE);  //使能RTC时钟   

RTC_WaitForLastTask();  //等待最近一次对RTC寄存器的写操作完成  
RTC_WaitForSynchro();       //等待RTC寄存器同步  

RTC_EnterConfigMode();/// 允许配置   

RTC_ITConfig(RTC_IT_SEC, ENABLE);       //使能RTC秒中断  

RTC_SetPrescaler(32767); //设置RTC预分频的值——1s溢出一次  

RTC_Set(2015,1,14,17,42,55);  //正点原子封装的函数用于设置时间，本质上就是计算出来一个值将此值赋给32位可编程计数器

RTC_ExitConfigMode(); //退出配置模式  

BKP_WriteBackupRegister(BKP_DR1, 0X5050);   //向指定的后备寄存器中写入用户程序数据(小于16位的数据，因为寄存器为16位的)

while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET&&temp<250)    //检查指定的RCC标志位设置与否,等待低速晶振就绪  
{  
    temp++;  
    delay_ms(10);  
}  
if(temp>=250)return 1;//初始化时钟失败,晶振有问题 

if(temp>=250)return 1;//初始化时钟失败,晶振有问题