/**
  ******************************************************************************
  * @file    fm33a0xxev_rtc.c
  * @author  FM33A0XXEV Application Team
  * @version V1.0.0
  * @date    16-April-2020
  * @brief   This file provides firmware functions to manage the following 
  *          functionalities of....:
  *
*/

/* Includes ------------------------------------------------------------------*/

#include "fm33a0xxev_rtc.h"

/** @addtogroup fm33a0xxev_StdPeriph_Driver
  * @{
  */

/** @defgroup RTC 
  * @brief RTC driver modules
  * @{
  */ 

/* RTCдʹÄܼĴæÆ÷£¬
µ±CPUÏòRTCWEдÈë0xACACACACʱ£¬ÔÊÐíCPUÏòRTCµÄBCDʱ¼ä¼Ä´æÆ÷дÈë³õÖµ£¬ÕâʱRTCWEÖÃ1£»µ±CPUÏòRTCWEдÈ벻Ϊ0xACACACACµÄÈÎÒâֵʱ»Ö¸´Ð´±£»¤,ÕâʱRTCWEÇå0¡£ Ïà¹Øº¯Êý */

void RTC_WER_Write(uint32_t SetValue)
{
	RTC->WER  = (SetValue );
}



void RTC_WER_RTCWE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->WER = RTC_WRITE_ENABLE;
	}
	else
	{
		RTC->WER = RTC_WRITE_DISABLE;
	}
}

FunState RTC_WER_RTCWE_Getable(void)
{
	if (RTC->WER & (RTC_WER_RTCWE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* µ÷УÖÜÆÚÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_ADJ_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_ADJ_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_ADJ_IE_Msk);
	}
}

FunState RTC_IER_ADJ_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_ADJ_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* ÄÖÖÓÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_ALARM_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_ALARM_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_ALARM_IE_Msk);
	}
}

FunState RTC_IER_ALARM_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_ALARM_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* 1khzÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_1KHZ_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_1KHZ_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_1KHZ_IE_Msk);
	}
}

FunState RTC_IER_1KHZ_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_1KHZ_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* 256hzÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_256HZ_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_256HZ_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_256HZ_IE_Msk);
	}
}

FunState RTC_IER_256HZ_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_256HZ_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* 64hzÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_64HZ_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_64HZ_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_64HZ_IE_Msk);
	}
}

FunState RTC_IER_64HZ_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_64HZ_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}


/* 16hzÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_16HZ_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_16HZ_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_16HZ_IE_Msk);
	}
}

FunState RTC_IER_16HZ_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_16HZ_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* 8hzÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_8HZ_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_8HZ_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_8HZ_IE_Msk);
	}
}

FunState RTC_IER_8HZ_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_8HZ_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* 4hzÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_4HZ_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_4HZ_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_4HZ_IE_Msk);
	}
}

FunState RTC_IER_4HZ_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_4HZ_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* 2hzÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_2HZ_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_2HZ_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_2HZ_IE_Msk);
	}
}

FunState RTC_IER_2HZ_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_2HZ_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* ÃëÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_SEC_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_SEC_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_SEC_IE_Msk);
	}
}

FunState RTC_IER_SEC_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_SEC_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* ·ÖÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_MIN_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_MIN_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_MIN_IE_Msk);
	}
}

FunState RTC_IER_MIN_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_MIN_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* СʱÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_HOUR_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_HOUR_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_HOUR_IE_Msk);
	}
}

FunState RTC_IER_HOUR_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_HOUR_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* ÌìÖжÏʹÄÜ¡£
1£ºÖжÏʹÄÜ´ò¿ª
0£ºÖжÏʹÄܽûÖ¹ Ïà¹Øº¯Êý */
void RTC_IER_DATE_IE_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->IER |= (RTC_IER_DATE_IE_Msk);
	}
	else
	{
		RTC->IER &= ~(RTC_IER_DATE_IE_Msk);
	}
}

FunState RTC_IER_DATE_IE_Getable(void)
{
	if (RTC->IER & (RTC_IER_DATE_IE_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* µ÷УÖÜÆÚÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_ADJ_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_ADJ_IF_Msk;
}

FlagStatus RTC_ISR_ADJ_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_ADJ_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* ÄÖÖÓÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_ALARM_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_ALARM_IF_Msk;
}

FlagStatus RTC_ISR_ALARM_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_ALARM_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* 1khzÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_1KHZ_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_1KHZ_IF_Msk;
}

FlagStatus RTC_ISR_1KHZ_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_1KHZ_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* 256hzÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_256HZ_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_256HZ_IF_Msk;
}

FlagStatus RTC_ISR_256HZ_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_256HZ_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* 64hzÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_64HZ_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_64HZ_IF_Msk;
}

FlagStatus RTC_ISR_64HZ_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_64HZ_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}


/* 16hzÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_16HZ_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_16HZ_IF_Msk;
}

FlagStatus RTC_ISR_16HZ_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_16HZ_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* 8hzÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_8HZ_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_8HZ_IF_Msk;
}

FlagStatus RTC_ISR_8HZ_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_8HZ_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* 4hzÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_4HZ_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_4HZ_IF_Msk;
}

FlagStatus RTC_ISR_4HZ_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_4HZ_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* 2hzÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_2HZ_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_2HZ_IF_Msk;
}

FlagStatus RTC_ISR_2HZ_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_2HZ_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* ÃëÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_SEC_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_SEC_IF_Msk;
}

FlagStatus RTC_ISR_SEC_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_SEC_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* ·ÖÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_MIN_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_MIN_IF_Msk;
}

FlagStatus RTC_ISR_MIN_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_MIN_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* СʱÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_HOUR_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_HOUR_IF_Msk;
}

FlagStatus RTC_ISR_HOUR_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_HOUR_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* ÌìÖжϱêÖ¾¡£Ð´1ÇåÁã
1£ºÖжÏÖÃλ
0£ºÎÞÖжϲúÉú Ïà¹Øº¯Êý */
void RTC_ISR_DATE_IF_Clr(void)
{
	RTC->ISR = RTC_ISR_DATE_IF_Msk;
}

FlagStatus RTC_ISR_DATE_IF_Chk(void)
{
	if (RTC->ISR & RTC_ISR_DATE_IF_Msk)
	{
		return SET;
	}
	else
	{
		return RESET;
	}
}

/* Ãëʱ¼äÊýÖµ£¬BCD¸ñʽ¡£ Ïà¹Øº¯Êý */
void RTC_BCDSEC_Write(uint32_t SetValue)
{
	RTC->BCDSEC = (SetValue & RTC_BCDSEC_BCDSEC_Msk);
}

uint32_t RTC_BCDSEC_Read(void)
{
	return (RTC->BCDSEC & RTC_BCDSEC_BCDSEC_Msk);
}

/* ·ÖÖÓʱ¼äÊýÖµ£¬BCD¸ñʽ¡£ Ïà¹Øº¯Êý */
void RTC_BCDMIN_Write(uint32_t SetValue)
{
	RTC->BCDMIN = (SetValue & RTC_BCDMIN_BCDMIN_Msk);
}

uint32_t RTC_BCDMIN_Read(void)
{
	return (RTC->BCDMIN & RTC_BCDMIN_BCDMIN_Msk);
}

/* СʱÊýÖµ£¬BCD¸ñʽ¡£ Ïà¹Øº¯Êý */
void RTC_BCDHOUR_Write(uint32_t SetValue)
{
	RTC->BCDHOUR = (SetValue & RTC_BCDHOUR_BCDHOUR_Msk);
}

uint32_t RTC_BCDHOUR_Read(void)
{
	return (RTC->BCDHOUR & RTC_BCDHOUR_BCDHOUR_Msk);
}

/* СʱÊýÖµ£¬BCD¸ñʽ¡£ Ïà¹Øº¯Êý */
void RTC_BCDDATE_Write(uint32_t SetValue)
{
	RTC->BCDDATE = (SetValue & RTC_BCDDATE_BCDDATE_Msk);
}

uint32_t RTC_BCDDATE_Read(void)
{
	return (RTC->BCDDATE & RTC_BCDDATE_BCDDATE_Msk);
}


/* ÖÜÊýÖµ£¬BCD¸ñʽ¡£ Ïà¹Øº¯Êý */
void RTC_BCDWEEK_Write(uint32_t SetValue)
{
	RTC->BCDWEEK = (SetValue & RTC_BCDWEEK_BCDWEEK_Msk);
}

uint32_t RTC_BCDWEEK_Read(void)
{
	return (RTC->BCDWEEK & RTC_BCDWEEK_BCDWEEK_Msk);
}

/* ÔÂÊýÖµ£¬BCD¸ñʽ¡£ Ïà¹Øº¯Êý */
void RTC_BCDMONTH_Write(uint32_t SetValue)
{
	RTC->BCDMONTH = (SetValue & RTC_BCDMONTH_BCDMONTH_Msk);
}

uint32_t RTC_BCDMONTH_Read(void)
{
	return (RTC->BCDMONTH & RTC_BCDMONTH_BCDMONTH_Msk);
}

/* ÄêÊýÖµ£¬BCD¸ñʽ¡£ Ïà¹Øº¯Êý */
void RTC_BCDYEAR_Write(uint32_t SetValue)
{
	RTC->BCDYEAR = (SetValue & RTC_BCDYEAR_BCDYEAR_Msk);
}

uint32_t RTC_BCDYEAR_Read(void)
{
	return (RTC->BCDYEAR & RTC_BCDYEAR_BCDYEAR_Msk);
}

/* ÄÖÖÓ¹¦ÄÜʹÄÜ (alarm enable)
1£ºÊ¹ÄÜAlarm¹¦ÄÜ
0£º½ûÖ¹Alarm¹¦ÄÜ Ïà¹Øº¯Êý */
void RTC_ALARM_ALMEN_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->ALARM |= (RTC_ALARM_ALMEN_Msk);
	}
	else
	{
		RTC->ALARM &= ~(RTC_ALARM_ALMEN_Msk);
	}
}

FunState RTC_ALARM_ALMEN_Getable(void)
{
	if (RTC->ALARM & (RTC_ALARM_ALMEN_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* ÄÖÖÓµÄСʱÊýÖµ¡£ Ïà¹Øº¯Êý */
void RTC_ALARM_ALARMHOUR_Set(uint32_t SetValue)
{
	uint32_t tmpreg;
	tmpreg = RTC->ALARM;
	tmpreg &= ~(RTC_ALARM_ALARMHOUR_Msk);
	tmpreg |= (SetValue & RTC_ALARM_ALARMHOUR_Msk);
	RTC->ALARM = tmpreg;
}

uint32_t RTC_ALARM_ALARMHOUR_Get(void)
{
	return (RTC->ALARM & RTC_ALARM_ALARMHOUR_Msk) >> RTC_ALARM_ALARMHOUR_Pos;
}

/* ÄÖÖӵķÖÊýÖµ¡£ Ïà¹Øº¯Êý */
void RTC_ALARM_ALARMMIN_Set(uint32_t SetValue)
{
	uint32_t tmpreg;
	tmpreg = RTC->ALARM;
	tmpreg &= ~(RTC_ALARM_ALARMMIN_Msk);
	tmpreg |= (SetValue & RTC_ALARM_ALARMMIN_Msk);
	RTC->ALARM = tmpreg;
}

uint32_t RTC_ALARM_ALARMMIN_Get(void)
{
	return (RTC->ALARM & RTC_ALARM_ALARMMIN_Msk) >> RTC_ALARM_ALARMMIN_Pos;
}

/* ÄÖÖÓµÄÃëÊýÖµ¡£ Ïà¹Øº¯Êý */
void RTC_ALARM_ALARMSEC_Set(uint32_t SetValue)
{
	uint32_t tmpreg;
	tmpreg = RTC->ALARM;
	tmpreg &= ~(RTC_ALARM_ALARMSEC_Msk);
	tmpreg |= (SetValue & RTC_ALARM_ALARMSEC_Msk);
	RTC->ALARM = tmpreg;
}

uint32_t RTC_ALARM_ALARMSEC_Get(void)
{
	return (RTC->ALARM & RTC_ALARM_ALARMSEC_Msk) >> RTC_ALARM_ALARMSEC_Pos;
}

/* ƵÂÊÊä³öÑ¡ÔñÐźţº
0000£ºÊä³öPLL·ÖƵµÃµ½µÄ¾«È·1Ãë·½²¨ 
0001£ºÊä³öPLL·ÖƵµÄ¿É±äÕ¼¿Õ±ÈµÄ¾«È·Ãëʱ±ê 
0010£ºÊä³öÃë¼ÆÊýÆ÷½øλÐźţ¬¸ßµçƽ¿í¶È1s
0011£ºÊä³ö·Ö¼ÆÊýÆ÷½øλÐźţ¬¸ßµçƽ¿í¶È1s
0100£ºÊä³öСʱ¼ÆÊýÆ÷½øλÐźţ¬¸ßµçƽ¿í¶È1s
0101£ºÊä³öÌì¼ÆÊýÆ÷½øλÐźţ¬¸ßµçƽ¿í¶È1s
0110£ºÊä³öÄÖÖÓÆ¥ÅäÐźÅ
0111£ºÊä³ö256Ãë·½²¨ÐźÅ
1000£º·´ÏòÊä³öPLL·ÖƵµÄ¿É±äÕ¼¿Õ±ÈµÄ¾«È·Ãëʱ±ê
1001£º·´ÏòÊä³öÃë¼ÆÊýÆ÷½øλÐźÅ
1010£º·´ÏòÊä³ö·Ö¼ÆÊýÆ÷½øλÐźÅ
1011£º·´ÏòÊä³öСʱ¼ÆÊýÆ÷½øλÐźÅ
1100£º·´ÏòÊä³öÌì¼ÆÊýÆ÷½øλÐźÅ
1101£º·´ÏòÊä³öÄÖÖÓÆ¥ÅäÐźÅ
1110£º·´ÏòÊä³öPLL·ÖƵµÄ¾«È·1s·½²¨ÐźÅ
1111£ºÊä³öRTCÄÚ²¿Ãëʱ±ê·½²¨ Ïà¹Øº¯Êý */
void RTC_TMSEL_Write(uint32_t SetValue)
{
	RTC->TMSEL = (SetValue & RTC_TMSEL_FSEL_Msk);
}

uint32_t RTC_TMSEL_Read(void)
{
	return (RTC->TMSEL & RTC_TMSEL_FSEL_Msk);
}

/* LTBC²¹³¥µ÷ÕûÊýÖµ£¨Ô­Âë¸ñʽ£© Ïà¹Øº¯Êý */
void RTC_ADJUST_Write(uint32_t SetValue)
{
	RTC->ADJUST = (SetValue & RTC_ADJUST_ADJUST_Msk);
}

uint32_t RTC_ADJUST_Read(void)
{
	return (RTC->ADJUST & RTC_ADJUST_ADJUST_Msk);
}

/* LTBC²¹³¥·½Ïò
0£º±íʾÔö¼Ó¼ÆÊý³õÖµ
1£º±íʾ¼õÉÙ¼ÆÊý³õÖµ Ïà¹Øº¯Êý */
void RTC_ADSIGN_ADSIGN_Set(uint32_t SetValue)
{
	uint32_t tmpreg;
	tmpreg = RTC->ADSIGN;
	tmpreg &= ~(RTC_ADSIGN_ADSIGN_Msk);
	tmpreg |= (SetValue & RTC_ADSIGN_ADSIGN_Msk);
	RTC->ADSIGN = tmpreg;
}

uint32_t RTC_ADSIGN_ADSIGN_Get(void)
{
	return (RTC->ADSIGN & RTC_ADSIGN_ADSIGN_Msk);
}

/* ÐéÄâµ÷УʹÄÜÐźÅ
0£º±íʾ½ûÖ¹ÐéÄâµ÷У¹¦ÄÜ
1£º±íʾʹÄÜÐéÄâµ÷У¹¦ÄÜ Ïà¹Øº¯Êý */
void RTC_VCAL_PR1SEN_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->VCAL |= (RTC_VCAL_PR1SEN_Msk);
	}
	else
	{
		RTC->VCAL &= ~(RTC_VCAL_PR1SEN_Msk);
	}
}

FunState RTC_VCAL_PR1SEN_Getable(void)
{
	if (RTC->VCAL & (RTC_VCAL_PR1SEN_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* ºÁÃë¼ÆÊýÆ÷
CALSTEP=00/11£ºÓÐЧλ8bit£¬¾«¶È3.9ms
CALSTEP=01£ºÓÐЧֵ7bit£¬¾«¶È7.8ms
CALSTEP=10£ºÓÐЧֵ6bit£¬¾«¶È15.625ms Ïà¹Øº¯Êý */
void RTC_MSCNT_Write(uint32_t SetValue)
{
	RTC->MSCNT = (SetValue & RTC_MSCNT_MSCNT_Msk);
}

uint32_t RTC_MSCNT_Read(void)
{
	return (RTC->MSCNT & RTC_MSCNT_MSCNT_Msk);
}

/* LTBC×îСµ÷У²½³¤Ñ¡Ôñ
10£º0.06ppm£¨¾«¶È+/-0.03ppm£©
01£º0.119ppm£¨¾«¶È+/-0.06ppm£©
00/11£º0.238ppm£¨¾«¶È+/-0.119ppm£© Ïà¹Øº¯Êý */
void RTC_CALSTEP_CALSTEP_Set(uint32_t SetValue)
{
	uint32_t tmpreg;
	tmpreg = RTC->CALSTEP;
	tmpreg &= ~(RTC_CALSTEP_CALSTEP_Msk);
	tmpreg |= (SetValue & RTC_CALSTEP_CALSTEP_Msk);
	RTC->CALSTEP = tmpreg;
}

uint32_t RTC_CALSTEP_CALSTEP_Get(void)
{
	return (RTC->CALSTEP & RTC_CALSTEP_CALSTEP_Msk);
}

uint32_t RTC_ADCNT_Read(void)
{
	return (RTC->ADCNT & RTC_ADCNT_ADJCNT_Msk);
}



/* ÑÇÃë¼ÆÊýÆ÷ (sub-second counter register)
¼ÆÊý²½³¤15.625ms Ïà¹Øº¯Êý */
uint32_t RTC_SSR_Read(void)
{
	return (RTC->SSR & RTC_SSR_SSR_Msk);
}

/* ÑÇÃëÄÖÖÓʹÄÜ (sub-second alarm enable)
1£ºÊ¹ÄÜÑÇÃëÄÖÖÓ¹¦ÄÜ
0£º½ûÖ¹ÑÇÃëÄÖÖÓ¹¦ÄÜ Ïà¹Øº¯Êý */
void RTC_SSA_SSAEN_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->SSA |= (RTC_SSA_SSAEN_Msk);
	}
	else
	{
		RTC->SSA &= ~(RTC_SSA_SSAEN_Msk);
	}
}

FunState RTC_SSA_SSAEN_Getable(void)
{
	if (RTC->SSA & (RTC_SSA_SSAEN_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}

/* ÑÇÃëÄÖÖÓ (sub-second alarm)
µ±SSAEN=1£¬²¢ÇÒSSR¼ÆÊýÖµµÈÓÚSS_ALARMʱ£¬ÖжϱêÖ¾ÖÃλ¡£ Ïà¹Øº¯Êý */
void RTC_SSA_SS_ALARM_Set(uint32_t SetValue)
{
	uint32_t tmpreg;
	tmpreg = RTC->SSA;
	tmpreg &= ~(RTC_SSA_SS_ALARM_Msk);
	tmpreg |= (SetValue & RTC_SSA_SS_ALARM_Msk);
	RTC->SSA = tmpreg;
}

uint32_t RTC_SSA_SS_ALARM_Get(void)
{
	return (RTC->SSA & RTC_SSA_SS_ALARM_Msk);
}

/* RTCÐéÄâÃëʱ±êÊä³öÕ¼¿Õ±È£¬¶¨Òå1ÃëÖÜÆÚÄڸߵçƽ³¤¶È£¬¸´Î»Ä¬ÈÏÖµÊÇ80ms¸ßµçƽ Ïà¹Øº¯Êý */
void RTC_DTR_Write(uint32_t SetValue)
{
	RTC->DTR = (SetValue & RTC_DTR_DUTY_Msk);
}

uint32_t RTC_DTR_Read(void)
{
	return (RTC->DTR & RTC_DTR_DUTY_Msk);
}

/* RTCʱÖÓºÍÈÕÀúʹÄÜ (RTC_A Enable)
1£ºÊ¹ÄÜRTC×ßʱ
0£ºÍ£Ö¹RTC×ßʱ

´Ë¼Ä´æÆ÷ÓÃÓÚÃÅ¿ØLSCLKÊäÈ룬Èç¹ûÇåÁ㣬RTC½«Á¢¼´Í£Ö¹×ßʱ£»µ«ÊÇÐéÄâµ÷У¹¦Äܲ»Êܴ˼ĴæÆ÷Ó°Ïì¡£ Ïà¹Øº¯Êý */
void RTC_CR_RTC_EN_Setable(FunState NewState)
{
	if (NewState == ENABLE)
	{
		RTC->CR |= (RTC_CR_RTC_EN_Msk);
	}
	else
	{
		RTC->CR &= ~(RTC_CR_RTC_EN_Msk);
	}
}

FunState RTC_CR_RTC_EN_Getable(void)
{
	if (RTC->CR & (RTC_CR_RTC_EN_Msk))
	{
		return ENABLE;
	}
	else
	{
		return DISABLE;
	}
}


void RTC_AlarmTime_SetEx(RTC_AlarmTmieTypeDef* para)
{
	RTC_ALARM_ALARMSEC_Set(((uint32_t)para->Second<<RTC_ALARM_ALARMSEC_Pos));
	RTC_ALARM_ALARMMIN_Set(((uint32_t)para->Minute<<RTC_ALARM_ALARMMIN_Pos));
	RTC_ALARM_ALARMHOUR_Set(((uint32_t)para->Hour<<RTC_ALARM_ALARMHOUR_Pos));
}


/********************************
 RTCÉèÖÃʱ¼äº¯Êý
¹¦ÄÜ:ÉèÖÃʱ¼ä£¬Ã룬·Ö£¬Ê±£¬Ì죬Ô£¬Ä꣬ÖÜ£¬BCD¸ñʽ
ÊäÈ룺ҪÇóÉèÖõÄʱ¼äÊý×é
		
********************************/
void RTC_TimeDate_SetEx(RTC_TimeDateTypeDef* para)
{
	RTC_BCDSEC_Write((uint32_t)para->Second);
	RTC_BCDMIN_Write((uint32_t)para->Minute);
	RTC_BCDHOUR_Write((uint32_t)para->Hour);
	RTC_BCDDATE_Write((uint32_t)para->Date);
	RTC_BCDMONTH_Write((uint32_t)para->Month);
	RTC_BCDYEAR_Write((uint32_t)para->Year);
	RTC_BCDWEEK_Write((uint32_t)para->Week);	
}

/********************************
 RTC¶Áȡʱ¼äº¯Êý
¹¦ÄÜ:¶Áȡʱ¼ä£¬Ã룬·Ö£¬Ê±£¬Ì죬Ô£¬Ä꣬ÖÜ£¬BCD¸ñʽ
Êä³ö£º¶ÁÈ¡µ±Ç°Ê±¼ä£¬±£´æΪÊý×é
		
********************************/
void RTC_TimeDate_GetEx(RTC_TimeDateTypeDef* para)
{
	para->Second = RTC_BCDSEC_Read();
	para->Minute = RTC_BCDMIN_Read();
	para->Hour = RTC_BCDHOUR_Read();
	para->Date = RTC_BCDDATE_Read();
	para->Month = RTC_BCDMONTH_Read();
	para->Year = RTC_BCDYEAR_Read();
	para->Week = RTC_BCDWEEK_Read();	
}






void RTC_Deinit(void)
{
	//RTC->WER = 0x00000000;
	//RTC->IER = 0x00000000;
	//RTC->ISR = 0x00000000;
	//RTC->BCDSEC = 0x00000000;
	//RTC->BCDMIN = 0x00000000;
	//RTC->BCDHOUR = 0x00000000;
	//RTC->BCDWEEK = 0x00000000;
	//RTC->BCDMONTH = 0x00000000;
	//RTC->BCDYEAR = 0x00000000;
	//RTC->ALARM = 0x00000000;
	//RTC->TMSEL = 0x00000000;
	//RTC->ADJUST = 0x00000000;
	//RTC->ADSIGN = 0x00000000;
	//RTC->VCAL = 0x00000000;
	//RTC->MSCNT = 0x00000000;
	//RTC->CALSTEP = 0x00000000;
	//RTC->ADCNT = ;
	//RTC->SSR = 0x00000000;
	//RTC->SSA = 0x00000000;
	//RTC->DTR = 0x00000001;
	//RTC->CR = 0x00000000;
}

/******END OF FILE****/