原创 RTC终于成功了啊!

/* Includes ------------------------------------------------------------------*/
#include "RTC.h"
#include "USART1.h"
#include "rprintf.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define RTCClockOutput_Enable  /* RTC Clock/64 is output on tamper pin(PC.13) */

/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/

vu32 TimeDisplay = 0;
/* Private functions ---------------------------------------------------------*/
/*******************************************************************************
* Function Name  : main
* Description    : Main program.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void  RTC_init(u32 y,u32 m,u32 d,u32 h,u32 mm,u32 s)
{
 
  if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
  {
    USART1_PutString("RTC 不曾配置....");
    RTC_Configuration();
    USART1_PutString("RTC 开始配置....");
    Time_Adjust( y, m, d, h, mm, s);
   BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
 
  }
  else
  {
   if(RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET)
    {
     USART1_PutString("\r\n电源复位....");
    }
  else if(RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET)
    {
     USART1_PutString("\r\n External Reset occurred....");
    }

    USART1_PutString("\r\n 不须要配置 RTC....");
    RTC_WaitForSynchro();
    RTC_ITConfig(RTC_IT_SEC, ENABLE);
    RTC_WaitForLastTask();
  }

#ifdef RTCClockOutput_Enable
 
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
  PWR_BackupAccessCmd(ENABLE);
  BKP_TamperPinCmd(DISABLE);
 
  BKP_RTCOutputConfig(BKP_RTCOutputSource_CalibClock);
 
#endif
    RCC_ClearFlag();
}
void RTC_Configuration(void)
{
 /* Enable PWR and BKP clocks */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
  /* Allow access to BKP Domain */
  PWR_BackupAccessCmd(ENABLE);
  /* Reset Backup Domain */
  BKP_DeInit();
  /* Enable LSE */
  RCC_LSEConfig(RCC_LSE_ON);
  /* Wait till LSE is ready */
  while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
  {}

  /* Select LSE as RTC Clock Source */
  RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
  /* Enable RTC Clock */
  RCC_RTCCLKCmd(ENABLE);
  /* Wait for RTC registers synchronization */
  RTC_WaitForSynchro();
  /* Wait until last write operation on RTC registers has finished */
  RTC_WaitForLastTask();
  /* Enable the RTC Second */
  RTC_ITConfig(RTC_IT_SEC, ENABLE);
  /* Wait until last write operation on RTC registers has finished */
  RTC_WaitForLastTask();
  /* Set RTC prescaler: set RTC period to 1sec */
  RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1) */
  /* Wait until last write operation on RTC registers has finished */
  RTC_WaitForLastTask();
}

/*******************************************************************************
* Function Name  : Time_Regulate
* Description    : Returns the time entered by user, using Hyperterminal.
* Input          : None
* Output         : None
* Return         : Current time RTC counter value
*******************************************************************************/

u32 Month_Days_Accu_C[13] = {0,31,59,90,120,151,181,212,243,273,304,334,365};
u32 Month_Days_Accu_L[13] = {0,31,60,91,121,152,182,213,244,274,305,335,366};
#define SecsPerDay (3600*24)

u32 Time_Regulate(u32 y,u32 m,u32 d,u32 h,u32 mm,u32 s)
{
  char data[20];
//#if 1
  u32 Tmp_Year=0xFFFF, Tmp_Month=0xFF, Tmp_Date=0xFF;
  u32 LeapY, ComY, TotSeconds, TotDays;
//#endif
  u32 Tmp_HH = 0xFF, Tmp_MM = 0xFF, Tmp_SS = 0xFF;

  USART1_PutString("\r\n==============Time Settings=====================================");
 
//#if 1
 USART1_PutString("\r\nSet Year");
  while(Tmp_Year == 0xFFFF)
  {
    /*32-bit counter at Second Unit--> 4*1024*1024(s) --> 49710(day) --> 136(year)*/
    Tmp_Year =y;
  }
   sprintf1(data,":  %d", Tmp_Year);
   USART1_PutString(data);
   while(Tmp_Month == 0xFF)
   {
    Tmp_Month = m;
   }
  sprintf1(data,":  %d", Tmp_Month);
  USART1_PutString(data);
  while(Tmp_Date == 0xFF)
  {
    Tmp_Date =d;
   }
  sprintf1(data,":  %d", Tmp_Date);
  USART1_PutString(data);
//#endif
  while(Tmp_HH == 0xFF)
  {
    Tmp_HH = h;
  }
  sprintf1(data,":  %d", Tmp_HH);
  USART1_PutString(data);
  USART1_PutString("\r\nSet Minutes");
  while(Tmp_MM == 0xFF)
  {
    Tmp_MM = mm;
  }
  sprintf1(data,":  %d", Tmp_MM);;
  USART1_PutString(data);
  while(Tmp_SS == 0xFF)
  {
    Tmp_SS = s;
  }
 sprintf1(data,":  %d", Tmp_SS);
 USART1_PutString(data);
//#if 1
  {
  /* change Year-Month-Data-Hour-Minute-Seconds into X(Second) to set RTC->CNTR */
    if(Tmp_Year==2000)
      LeapY = 0;
    else
      LeapY = (Tmp_Year - 2000 -1)/4 +1;
   
  ComY = (Tmp_Year - 2000)-(LeapY);
 
  if (Tmp_Year%4)
    //common year
    TotDays = LeapY*366 + ComY*365 + Month_Days_Accu_C[Tmp_Month-1] + (Tmp_Date-1);
  else
    //leap year
    TotDays = LeapY*366 + ComY*365 + Month_Days_Accu_L[Tmp_Month-1] + (Tmp_Date-1);
 
  TotSeconds = TotDays*SecsPerDay + (Tmp_HH*3600 + Tmp_MM*60 + Tmp_SS);
  }
//#endif
  return TotSeconds;
}

/*******************************************************************************
* Function Name  : Time_Adjust
* Description    : Adjusts time.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void Time_Adjust(u32 y,u32 m,u32 d,u32 h,u32 mm,u32 s)
{
  /* Wait until last write operation on RTC registers has finished */
  RTC_WaitForLastTask();
  /* Change the current time */
  RTC_SetCounter(Time_Regulate(y,m,d,h,mm,s));
  /* Wait until last write operation on RTC registers has finished */
  RTC_WaitForLastTask();
}

/*******************************************************************************
* Function Name  : Time_Display
* Description    : Displays the current time.
* Input          : - TimeVar: RTC counter value.
* Output         : None
* Return         : None
*******************************************************************************/
#define SecsPerComYear  3153600//(365*3600*24)
#define SecsPerLeapYear 31622400//(366*3600*24)
#define SecsPerFourYear 126230400//((365*3600*24)*3+(366*3600*24))
#define SecsPerDay      (3600*24)

s32 Year_Secs_Accu[5]={0,
                      31622400,
                      63158400,
                      94694400,
                      126230400};

s32 Month_Secs_Accu_C[13] = { 0,
                            2678400,
                            5097600,
                            7776000,
                            10368000,
                            13046400,
                            15638400,
                            18316800,
                            20995200,
                            23587200,
                            26265600,
                            28857600,
                            31536000};
s32 Month_Secs_Accu_L[13] = {0,
                            2678400,
                            5184000,
                            7862400, 
                            10454400,
                            13132800,
                            15724800,
                            18403200,
                            21081600,
                            23673600,
                            26352000,
                            28944000,
                            31622400};

void Time_Display(u32 TimeVar)
{
  char data[80];
#if 1
  u32 TY = 0, TM = 1, TD = 0;
  s32 Num4Y,NumY, OffSec, Off4Y = 0;
  u32 i;
  s32 NumDay;
#endif
  u32 THH = 0, TMM = 0, TSS = 0;
#if 0
  /* Compute  hours */
  THH = TimeVar/3600;
  /* Compute minutes */
  TMM = (TimeVar % 3600)/60;
  /* Compute seconds */
  TSS = (TimeVar % 3600)% 60;
#endif
#if 1
  {
    Num4Y = TimeVar/SecsPerFourYear;
    OffSec = TimeVar%SecsPerFourYear;

    i="1";
    while(OffSec > Year_Secs_Accu[i++])
      Off4Y++;
 
    /* Numer of Complete Year */
    NumY = Num4Y*4 + Off4Y;
      /* 2000,2001,...~2000+NumY-1 complete year before, so this year is 2000+NumY*/
    TY = 2000+NumY;
   
    OffSec = OffSec - Year_Secs_Accu[i-2];
   
    /* Month (TBD with OffSec)*/
    i="0";
    if(TY%4)
    {// common year
      while(OffSec > Month_Secs_Accu_C[i++]);
      TM = i-1;
      OffSec = OffSec - Month_Secs_Accu_C[i-2];
    }
    else
    {// leap year
      while(OffSec > Month_Secs_Accu_L[i++]);
      TM = i-1;
      OffSec = OffSec - Month_Secs_Accu_L[i-2];
    }
   
    /* Date (TBD with OffSec) */
    NumDay = OffSec/SecsPerDay;
    OffSec = OffSec%SecsPerDay;
    TD = NumDay+1;

      /* Compute  hours */
  THH = OffSec/3600;
  /* Compute minutes */
  TMM = (OffSec % 3600)/60;
  /* Compute seconds */
  TSS = (OffSec % 3600)% 60;
  }
#endif

  sprintf1(data,"Date: %0.4d-%0.2d-%0.2d\r\nTime: %0.2d:%0.2d:%0.2d\r\n",TY, TM, TD,THH, TMM, TSS);
  USART1_PutString(data);
}

/*******************************************************************************
* Function Name  : Time_Show
* Description    : Shows the current time (HH:MM:SS) on the Hyperterminal.
* Input          : None
* Output         : None
* Return         : None
******************************************************************************/
void Time_Show(void)
{
  USART1_PutString("\n\r");
 
  /* Infinite loop */
  while (1)
  {
    // If 1s has paased
    if(TimeDisplay == 1)
    {   
      // Display current time
      Time_Display(RTC_GetCounter());
      TimeDisplay = 0;
    }
  }
}

/*******************************************************************************
* Function Name  : RTC_IRQHandler
* Description    : This function handles RTC global interrupt request.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void RTC_IRQHandler(void)
{
  if(RTC_GetITStatus(RTC_IT_SEC) != RESET)
  {
    /* Clear the RTC Second interrupt */
    RTC_ClearITPendingBit(RTC_IT_SEC);
    /* Enable time update */
    TimeDisplay = 1;
    /* Wait until last write operation on RTC registers has finished */
    RTC_WaitForLastTask();
    /* Reset RTC Counter when Time is 23:59:59 */
    if(RTC_GetCounter() == 0x00015180)
    {
      RTC_SetCounter(0x0);
      /* Wait until last write operation on RTC registers has finished */
     RTC_WaitForLastTask();
    }
  }
}