drvrtc.c

cortex-m0 LCD1602程序

    }
    
    /*-----------------------------------------------------------------------------------------------------*/
    /* Second, set RTC 24/12 hour setting                                                                  */
    /*-----------------------------------------------------------------------------------------------------*/
    if (sPt->u8cClockDisplay == DRVRTC_CLOCK_12)
    {
        DrvRTC_WriteEnable();
 		RTC->TSSR.HR24_HR12 = DRVRTC_CLOCK_12;

        /*-------------------------------------------------------------------------------------------------*/
        /* important, range of 12-hour PM mode is 21 upto 32                                               */
        /*-------------------------------------------------------------------------------------------------*/
        if (sPt->u8cAmPm == DRVRTC_PM)
            sPt->u32cHour += 20;
    }
    else    
    {
        /* RTC_CLOCK_24 */
        DrvRTC_WriteEnable();
 		RTC->TSSR.HR24_HR12 = DRVRTC_CLOCK_24;
        RTCDEBUG ("RTC: 24-hour\n");
    }

    /*-----------------------------------------------------------------------------------------------------*/
    /* Set RTC Calender Loading                                                                            */
    /*-----------------------------------------------------------------------------------------------------*/
    u32Reg    = ((sPt->u32Year - DRVRTC_YEAR2000) / 10) << 20;
    u32Reg    |= (((sPt->u32Year - DRVRTC_YEAR2000) % 10) << 16);
    u32Reg    |= ((sPt->u32cMonth  / 10) << 12);
    u32Reg    |= ((sPt->u32cMonth  % 10) << 8);
    u32Reg    |= ((sPt->u32cDay    / 10) << 4);
    u32Reg    |= (sPt->u32cDay     % 10);
    g_u32Reg = u32Reg;
	
	DrvRTC_WriteEnable();
 	RTC->TSSR.HR24_HR12 = DRVRTC_CLOCK_24;
    outpw(&RTC->CLR, (uint32_t)g_u32Reg);

	/*-----------------------------------------------------------------------------------------------------*/
    /* Set RTC Time Loading                                                                                */
    /*-----------------------------------------------------------------------------------------------------*/
    u32Reg     = ((sPt->u32cHour / 10) << 20);
    u32Reg    |= ((sPt->u32cHour % 10) << 16);
    u32Reg    |= ((sPt->u32cMinute / 10) << 12);
    u32Reg    |= ((sPt->u32cMinute % 10) << 8);
    u32Reg    |= ((sPt->u32cSecond / 10) << 4);
    u32Reg    |= (sPt->u32cSecond % 10);
    g_u32Reg = u32Reg;

 	DrvRTC_WriteEnable();
    outpw(&RTC->TLR, (uint32_t)g_u32Reg);

	outpw(&RTC->DWR, sPt->u32cDayOfWeek);

	RTC->TTR.TWKE = sPt->u8IsEnableWakeUp;

	/* Waiting for RTC settings stable */
  	while(i32delay--);

    return E_SUCCESS;
}

/*---------------------------------------------------------------------------------------------------------*/
/* Function:     DrvRTC_Read                                                                               */
/*                                                                                                         */
/* Parameter:                                                                                              */
/*               eTime                    		Currnet_Timer/ Alarm_Time                                  */
/*               S_DRVRTC_TIME_DATA_T *spt   	Time Data                                                  */
/* Returns:                                                                                                */
/*               E_SUCCESS               Success.                                                          */
/*               E_DRVRTC_ERR_EIO		 Initial RTC FAILED.                                               */
/*                                                                                                         */
/* DESCRIPTION                                                                                             */
/*               Read current date/time or alarm date/time from RTC setting                                */
//*--------------------------------------------------------------------------------------------------------*/
int32_t DrvRTC_Read(E_DRVRTC_TIME_SELECT eTime, S_DRVRTC_TIME_DATA_T *sPt)
{
    uint32_t u32Tmp;
    
    sPt->u8cClockDisplay = RTC->TSSR.HR24_HR12;     /* 12/24-hour */
    sPt->u32cDayOfWeek   = RTC->DWR.DWR;            /* Day of week */

    switch (eTime)
    {
        case DRVRTC_CURRENT_TIME:		    /* Get Current Time */
        {
			g_u32hiYear  = RTC->CLR.YEAR10 ;
    		g_u32loYear  = RTC->CLR.YEAR1;
    		g_u32hiMonth = RTC->CLR.MON10;
    		g_u32loMonth = RTC->CLR.MON1;
    		g_u32hiDay   = RTC->CLR.DAY10;
    		g_u32loDay   = RTC->CLR.DAY1;

		    g_u32hiHour =  RTC->TLR.HR10;
    		g_u32loHour =  RTC->TLR.HR1;
    		g_u32hiMin  =  RTC->TLR.MIN10;
    		g_u32loMin  =  RTC->TLR.MIN1;
    		g_u32hiSec  =  RTC->TLR.SEC10;
    		g_u32loSec  =  RTC->TLR.SEC1;
            break;
		}
        case DRVRTC_ALARM_TIME:		        /* Get Alarm Time */
        {
			g_u32hiYear  = RTC->CAR.YEAR10 ;
    		g_u32loYear  = RTC->CAR.YEAR1;
    		g_u32hiMonth = RTC->CAR.MON10;
    		g_u32loMonth = RTC->CAR.MON1;
    		g_u32hiDay   = RTC->CAR.DAY10;
    		g_u32loDay   = RTC->CAR.DAY1;

		    g_u32hiHour =  RTC->TAR.HR10;
    		g_u32loHour =  RTC->TAR.HR1;
    		g_u32hiMin  =  RTC->TAR.MIN10;
    		g_u32loMin  =  RTC->TAR.MIN1;
    		g_u32hiSec  =  RTC->TAR.SEC10;
    		g_u32loSec  =  RTC->TAR.SEC1;
            break;
        }
        default:
        {
            return E_DRVRTC_ERR_ENOTTY;
        }
    }

    u32Tmp = (g_u32hiYear * 10);	                    /* Compute to 20XX year */
    u32Tmp+= g_u32loYear;
    sPt->u32Year   =   u32Tmp  + DRVRTC_YEAR2000;
    
    u32Tmp = (g_u32hiMonth * 10);			            /* Compute 0~12 month */
    sPt->u32cMonth = u32Tmp + g_u32loMonth;
    
    u32Tmp = (g_u32hiDay * 10);					        /* Compute 0~31 day */
    sPt->u32cDay   =  u32Tmp  + g_u32loDay;

    if (sPt->u8cClockDisplay == DRVRTC_CLOCK_12)	    /* Compute12/24 hout */
    {
        u32Tmp = (g_u32hiHour * 10);
        u32Tmp+= g_u32loHour;
        sPt->u32cHour = u32Tmp;                         /* AM: 1~12. PM: 21~32. */

        if (sPt->u32cHour >= 21)
        {
            sPt->u8cAmPm = DRVRTC_PM;
            sPt->u32cHour -= 20;
        }
        else
        {
            sPt->u8cAmPm = DRVRTC_AM;
        }
        
        u32Tmp = (g_u32hiMin  * 10);
        u32Tmp+= g_u32loMin;
        sPt->u32cMinute = u32Tmp;
        
        u32Tmp = (g_u32hiSec  * 10);
        u32Tmp+= g_u32loSec;
        sPt->u32cSecond = u32Tmp;

    }
    else
    {   									            /* RTC_CLOCK_24 */
        u32Tmp = (g_u32hiHour * 10);
        u32Tmp+= g_u32loHour;
        sPt->u32cHour   = u32Tmp;
        
        u32Tmp = (g_u32hiMin  * 10);
        u32Tmp+= g_u32loMin;
        sPt->u32cMinute = u32Tmp;
        
        u32Tmp = (g_u32hiSec  * 10);
        u32Tmp+= g_u32loSec;
        sPt->u32cSecond = u32Tmp;
    }

    return E_SUCCESS;

}

/*---------------------------------------------------------------------------------------------------------*/
/* Function:     DrvRTC_Write                                                                              */
/*                                                                                                         */
/* Parameter:                                                                                              */
/*               eTime                    		Currnet_Timer/ Alarm_Time                                  */
/*               S_DRVRTC_TIME_DATA_T *sPt      Time Data                                                  */
/* Returns:                                                                                                */
/*               E_SUCCESS               Success.                                                          */
/*               E_DRVRTC_ERR_EIO        Initial RTC FAILED.                                               */
/*                                                                                                         */
/* DESCRIPTION                                                                                             */
/*               Update current date/time or alarm date/time from RTC                                      */
//*--------------------------------------------------------------------------------------------------------*/
int32_t DrvRTC_Write(E_DRVRTC_TIME_SELECT eTime, S_DRVRTC_TIME_DATA_T *sPt)
{
    uint32_t u32Reg;

    /*-----------------------------------------------------------------------------------------------------*/
    /* Check RTC time data value is reasonable or not.                                                     */
    /*-----------------------------------------------------------------------------------------------------*/
    if ( ((sPt->u32Year - DRVRTC_YEAR2000) > 99)|
         ((sPt->u32cMonth == 0) || (sPt->u32cMonth > 12))|
         ((sPt->u32cDay   == 0) || (sPt->u32cDay   > 31)))
    {
        RTCDEBUG ("\nRTC: Year value is incorrect\n");
        return E_DRVRTC_ERR_FAILED;
    }

    if ((sPt->u32Year - DRVRTC_YEAR2000) > 99)
    {
        RTCDEBUG ("\nRTC: Year value is incorrect\n");
        return E_DRVRTC_ERR_FAILED;
    }

    if ((sPt->u32cMonth == 0) || (sPt->u32cMonth > 12))
    {
        RTCDEBUG ("\nRTC: Month value is incorrect\n");
        return E_DRVRTC_ERR_FAILED;
    }

    if ((sPt->u32cDay == 0) || (sPt->u32cDay > 31))
    {
        RTCDEBUG ("\nRTC: Day value is incorrect\n");
        return E_DRVRTC_ERR_FAILED;
    }

    if (sPt->u8cClockDisplay == DRVRTC_CLOCK_12)
    {
        if ((sPt->u32cHour == 0) || (sPt->u32cHour > 12))
        {
            RTCDEBUG ("\nRTC: Hour value is incorrect\n");
            return E_DRVRTC_ERR_FAILED;
        }
    }
    else if (sPt->u8cClockDisplay == DRVRTC_CLOCK_24)
    {
        if (sPt->u32cHour > 23)
        {
            RTCDEBUG ("\nRTC: Hour value is incorrect\n");
            return E_DRVRTC_ERR_FAILED;
        }
    }
    else
    {
        RTCDEBUG ("\nRTC: Clock mode is incorrect\n");
        return E_DRVRTC_ERR_FAILED;
    }

    if (sPt->u32cMinute > 59)
    {
        RTCDEBUG ("\nRTC: Minute value is incorrect\n");
        return E_DRVRTC_ERR_FAILED;
    }

    if (sPt->u32cSecond > 59)
    {
        RTCDEBUG ("\nRTC: Second value is incorrect\n");
        return E_DRVRTC_ERR_FAILED;
    }

    if (sPt->u32cDayOfWeek > 6)
    {
        RTCDEBUG ("\nRTC: Day of week value is incorrect\n");
        return E_DRVRTC_ERR_FAILED;
    }

    /*-----------------------------------------------------------------------------------------------------*/
    /* Important, call RTC_Open() before write data into any register.                                     */
    /*-----------------------------------------------------------------------------------------------------*/
    g_u32Reg = DrvRTC_WriteEnable();
    if (g_u32Reg != 0)
    {
        return E_DRVRTC_ERR_FAILED;
    }

    switch (eTime)
    {

        case DRVRTC_CURRENT_TIME:
            /*---------------------------------------------------------------------------------------------*/
            /* Second, set RTC time data.                                                                  */
            /*---------------------------------------------------------------------------------------------*/
            if (sPt->u8cClockDisplay == DRVRTC_CLOCK_12)
            {
                g_chHourMode = DRVRTC_CLOCK_12;
				RTC->TSSR.HR24_HR12 = DRVRTC_CLOCK_12;
                RTCDEBUG ("RTC: 12-hour\n");
                /*-----------------------------------------------------------------------------------------*/
                /* important, range of 12-hour PM mode is 21 upto 32                                       */
                /*-----------------------------------------------------------------------------------------*/
                if (sPt->u8cAmPm == DRVRTC_PM)
                    sPt->u32cHour += 20;
            }
            else                                                                  
            {
                /* RTC_CLOCK_24 */
                g_chHourMode = DRVRTC_CLOCK_24;
    			RTC->TSSR.HR24_HR12 = DRVRTC_CLOCK_24;