LPC1700CMSIS Standard Peripheral Firmware Library: C:/nxpdrv/LPC1700CMSIS/Drivers/source/lpc17xx_rtc.c Source File

LPC1700CMSIS

previous page next page
C:/nxpdrv/LPC1700CMSIS/Drivers/source/lpc17xx_rtc.c

00001 
00021 /* Peripheral group ----------------------------------------------------------- */
00026 /* Includes ------------------------------------------------------------------- */
00027 #include "lpc17xx_rtc.h"
00028 #include "lpc17xx_clkpwr.h"
00029 
00030 
00031 /* If this source file built with example, the LPC17xx FW library configuration
00032  * file in each example directory ("lpc17xx_libcfg.h") must be included,
00033  * otherwise the default FW library configuration file must be included instead
00034  */
00035 #ifdef __BUILD_WITH_EXAMPLE__
00036 #include "lpc17xx_libcfg.h"
00037 #else
00038 #include "lpc17xx_libcfg_default.h"
00039 #endif /* __BUILD_WITH_EXAMPLE__ */
00040 
00041 
00042 #ifdef _RTC
00043 
00044 /* Public Functions ----------------------------------------------------------- */
00049 /********************************************************************/
00054 void RTC_Init (LPC_RTC_TypeDef *RTCx)
00055 {
00056         CHECK_PARAM(PARAM_RTCx(RTCx));
00057 
00058         /* Set up clock and power for RTC module */
00059         CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCRTC, ENABLE);
00060 
00061         // Clear all register to be default
00062         RTCx->ILR = 0x00;
00063         RTCx->CCR = 0x00;
00064         RTCx->CIIR = 0x00;
00065         RTCx->AMR = 0xFF;
00066         RTCx->CALIBRATION = 0x00;
00067 }
00068 
00069 
00070 /*********************************************************************/
00076 void RTC_DeInit(LPC_RTC_TypeDef *RTCx)
00077 {
00078         CHECK_PARAM(PARAM_RTCx(RTCx));
00079 
00080         RTCx->CCR = 0x00;
00081         // Disable power and clock for RTC module
00082         CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCRTC, DISABLE);
00083 }
00084 
00085 /*********************************************************************/
00090 void RTC_ResetClockTickCounter(LPC_RTC_TypeDef *RTCx)
00091 {
00092         CHECK_PARAM(PARAM_RTCx(RTCx));
00093 
00094         RTCx->CCR |= RTC_CCR_CTCRST;
00095         RTCx->CCR &= (~RTC_CCR_CTCRST) & RTC_CCR_BITMASK;
00096 }
00097 
00098 /*********************************************************************/
00106 void RTC_Cmd (LPC_RTC_TypeDef *RTCx, FunctionalState NewState)
00107 {
00108         CHECK_PARAM(PARAM_RTCx(RTCx));
00109         CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState));
00110 
00111         if (NewState == ENABLE)
00112         {
00113                 RTCx->CCR |= RTC_CCR_CLKEN;
00114         }
00115         else
00116         {
00117                 RTCx->CCR &= (~RTC_CCR_CLKEN) & RTC_CCR_BITMASK;
00118         }
00119 }
00120 
00121 
00122 /*********************************************************************/
00144 void RTC_CntIncrIntConfig (LPC_RTC_TypeDef *RTCx, uint32_t CntIncrIntType, \
00145                                                                 FunctionalState NewState)
00146 {
00147         CHECK_PARAM(PARAM_RTCx(RTCx));
00148         CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState));
00149         CHECK_PARAM(PARAM_RTC_TIMETYPE(CntIncrIntType));
00150 
00151         if (NewState ==  ENABLE)
00152         {
00153                 switch (CntIncrIntType)
00154                 {
00155                 case RTC_TIMETYPE_SECOND:
00156                         RTCx->CIIR |= RTC_CIIR_IMSEC;
00157                         break;
00158                 case RTC_TIMETYPE_MINUTE:
00159                         RTCx->CIIR |= RTC_CIIR_IMMIN;
00160                         break;
00161                 case RTC_TIMETYPE_HOUR:
00162                         RTCx->CIIR |= RTC_CIIR_IMHOUR;
00163                         break;
00164                 case RTC_TIMETYPE_DAYOFWEEK:
00165                         RTCx->CIIR |= RTC_CIIR_IMDOW;
00166                         break;
00167                 case RTC_TIMETYPE_DAYOFMONTH:
00168                         RTCx->CIIR |= RTC_CIIR_IMDOM;
00169                         break;
00170                 case RTC_TIMETYPE_DAYOFYEAR:
00171                         RTCx->CIIR |= RTC_CIIR_IMDOY;
00172                         break;
00173                 case RTC_TIMETYPE_MONTH:
00174                         RTCx->CIIR |= RTC_CIIR_IMMON;
00175                         break;
00176                 case RTC_TIMETYPE_YEAR:
00177                         RTCx->CIIR |= RTC_CIIR_IMYEAR;
00178                         break;
00179                 }
00180         }
00181         else
00182         {
00183                 switch (CntIncrIntType)
00184                 {
00185                 case RTC_TIMETYPE_SECOND:
00186                         RTCx->CIIR &= (~RTC_CIIR_IMSEC) & RTC_CIIR_BITMASK;
00187                         break;
00188                 case RTC_TIMETYPE_MINUTE:
00189                         RTCx->CIIR &= (~RTC_CIIR_IMMIN) & RTC_CIIR_BITMASK;
00190                         break;
00191                 case RTC_TIMETYPE_HOUR:
00192                         RTCx->CIIR &= (~RTC_CIIR_IMHOUR) & RTC_CIIR_BITMASK;
00193                         break;
00194                 case RTC_TIMETYPE_DAYOFWEEK:
00195                         RTCx->CIIR &= (~RTC_CIIR_IMDOW) & RTC_CIIR_BITMASK;
00196                         break;
00197                 case RTC_TIMETYPE_DAYOFMONTH:
00198                         RTCx->CIIR &= (~RTC_CIIR_IMDOM) & RTC_CIIR_BITMASK;
00199                         break;
00200                 case RTC_TIMETYPE_DAYOFYEAR:
00201                         RTCx->CIIR &= (~RTC_CIIR_IMDOY) & RTC_CIIR_BITMASK;
00202                         break;
00203                 case RTC_TIMETYPE_MONTH:
00204                         RTCx->CIIR &= (~RTC_CIIR_IMMON) & RTC_CIIR_BITMASK;
00205                         break;
00206                 case RTC_TIMETYPE_YEAR:
00207                         RTCx->CIIR &= (~RTC_CIIR_IMYEAR) & RTC_CIIR_BITMASK;
00208                         break;
00209                 }
00210         }
00211 }
00212 
00213 
00214 /*********************************************************************/
00236 void RTC_AlarmIntConfig (LPC_RTC_TypeDef *RTCx, uint32_t AlarmTimeType, \
00237                                                                 FunctionalState NewState)
00238 {
00239         CHECK_PARAM(PARAM_RTCx(RTCx));
00240         CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState));
00241         CHECK_PARAM(PARAM_RTC_TIMETYPE(AlarmTimeType));
00242 
00243         if (NewState == ENABLE)
00244         {
00245                 switch (AlarmTimeType)
00246                 {
00247                 case RTC_TIMETYPE_SECOND:
00248                         RTCx->AMR &= (~RTC_AMR_AMRSEC) & RTC_AMR_BITMASK;
00249                         break;
00250                 case RTC_TIMETYPE_MINUTE:
00251                         RTCx->AMR &= (~RTC_AMR_AMRMIN) & RTC_AMR_BITMASK;
00252                         break;
00253                 case RTC_TIMETYPE_HOUR:
00254                         RTCx->AMR &= (~RTC_AMR_AMRHOUR) & RTC_AMR_BITMASK;
00255                         break;
00256                 case RTC_TIMETYPE_DAYOFWEEK:
00257                         RTCx->AMR &= (~RTC_AMR_AMRDOW) & RTC_AMR_BITMASK;
00258                         break;
00259                 case RTC_TIMETYPE_DAYOFMONTH:
00260                         RTCx->AMR &= (~RTC_AMR_AMRDOM) & RTC_AMR_BITMASK;
00261                         break;
00262                 case RTC_TIMETYPE_DAYOFYEAR:
00263                         RTCx->AMR &= (~RTC_AMR_AMRDOY) & RTC_AMR_BITMASK;
00264                         break;
00265                 case RTC_TIMETYPE_MONTH:
00266                         RTCx->AMR &= (~RTC_AMR_AMRMON) & RTC_AMR_BITMASK;
00267                         break;
00268                 case RTC_TIMETYPE_YEAR:
00269                         RTCx->AMR &= (~RTC_AMR_AMRYEAR) & RTC_AMR_BITMASK;
00270                         break;
00271                 }
00272         }
00273         else
00274         {
00275                 switch (AlarmTimeType)
00276                 {
00277                 case RTC_TIMETYPE_SECOND:
00278                         RTCx->AMR |= (RTC_AMR_AMRSEC);
00279                         break;
00280                 case RTC_TIMETYPE_MINUTE:
00281                         RTCx->AMR |= (RTC_AMR_AMRMIN);
00282                         break;
00283                 case RTC_TIMETYPE_HOUR:
00284                         RTCx->AMR |= (RTC_AMR_AMRHOUR);
00285                         break;
00286                 case RTC_TIMETYPE_DAYOFWEEK:
00287                         RTCx->AMR |= (RTC_AMR_AMRDOW);
00288                         break;
00289                 case RTC_TIMETYPE_DAYOFMONTH:
00290                         RTCx->AMR |= (RTC_AMR_AMRDOM);
00291                         break;
00292                 case RTC_TIMETYPE_DAYOFYEAR:
00293                         RTCx->AMR |= (RTC_AMR_AMRDOY);
00294                         break;
00295                 case RTC_TIMETYPE_MONTH:
00296                         RTCx->AMR |= (RTC_AMR_AMRMON);
00297                         break;
00298                 case RTC_TIMETYPE_YEAR:
00299                         RTCx->AMR |= (RTC_AMR_AMRYEAR);
00300                         break;
00301                 }
00302         }
00303 }
00304 
00305 
00306 /*********************************************************************/
00321 void RTC_SetTime (LPC_RTC_TypeDef *RTCx, uint32_t Timetype, uint32_t TimeValue)
00322 {
00323         CHECK_PARAM(PARAM_RTCx(RTCx));
00324         CHECK_PARAM(PARAM_RTC_TIMETYPE(Timetype));
00325 
00326         switch ( Timetype)
00327         {
00328         case RTC_TIMETYPE_SECOND:
00329                 CHECK_PARAM(TimeValue < RTC_SECOND_MAX);
00330 
00331                 RTCx->SEC = TimeValue & RTC_SEC_MASK;
00332                 break;
00333 
00334         case RTC_TIMETYPE_MINUTE:
00335                 CHECK_PARAM(TimeValue < RTC_MINUTE_MAX);
00336 
00337                 RTCx->MIN = TimeValue & RTC_MIN_MASK;
00338                 break;
00339 
00340         case RTC_TIMETYPE_HOUR:
00341                 CHECK_PARAM(TimeValue < RTC_HOUR_MAX);
00342 
00343                 RTCx->HOUR = TimeValue & RTC_HOUR_MASK;
00344                 break;
00345 
00346         case RTC_TIMETYPE_DAYOFWEEK:
00347                 CHECK_PARAM(TimeValue < RTC_DAYOFWEEK_MAX);
00348 
00349                 RTCx->DOW = TimeValue & RTC_DOW_MASK;
00350                 break;
00351 
00352         case RTC_TIMETYPE_DAYOFMONTH:
00353                 CHECK_PARAM((TimeValue < RTC_DAYOFMONTH_MAX) \
00354                                 && (TimeValue > RTC_DAYOFMONTH_MIN));
00355 
00356                 RTCx->DOM = TimeValue & RTC_DOM_MASK;
00357                 break;
00358 
00359         case RTC_TIMETYPE_DAYOFYEAR:
00360                 CHECK_PARAM((TimeValue > RTC_DAYOFYEAR_MIN) \
00361                                 && (TimeValue < RTC_DAYOFYEAR_MAX));
00362 
00363                 RTCx->DOY = TimeValue & RTC_DOY_MASK;
00364                 break;
00365 
00366         case RTC_TIMETYPE_MONTH:
00367                 CHECK_PARAM((TimeValue > RTC_MONTH_MIN) \
00368                                 && (TimeValue < RTC_MONTH_MAX));
00369 
00370                 RTCx->MONTH = TimeValue & RTC_MONTH_MASK;
00371                 break;
00372 
00373         case RTC_TIMETYPE_YEAR:
00374                 CHECK_PARAM(TimeValue < RTC_YEAR_MAX);
00375 
00376                 RTCx->YEAR = TimeValue & RTC_YEAR_MASK;
00377                 break;
00378         }
00379 }
00380 
00381 /*********************************************************************/
00395 uint32_t RTC_GetTime(LPC_RTC_TypeDef *RTCx, uint32_t Timetype)
00396 {
00397         CHECK_PARAM(PARAM_RTCx(RTCx));
00398         CHECK_PARAM(PARAM_RTC_TIMETYPE(Timetype));
00399 
00400         switch (Timetype)
00401         {
00402         case RTC_TIMETYPE_SECOND:
00403                 return (RTCx->SEC & RTC_SEC_MASK);
00404                 break;
00405         case RTC_TIMETYPE_MINUTE:
00406                 return (RTCx->MIN & RTC_MIN_MASK);
00407                 break;
00408         case RTC_TIMETYPE_HOUR:
00409                 return (RTCx->HOUR & RTC_HOUR_MASK);
00410                 break;
00411         case RTC_TIMETYPE_DAYOFWEEK:
00412                 return (RTCx->DOW & RTC_DOW_MASK);
00413                 break;
00414         case RTC_TIMETYPE_DAYOFMONTH:
00415                 return (RTCx->DOM & RTC_DOM_MASK);
00416                 break;
00417         case RTC_TIMETYPE_DAYOFYEAR:
00418                 return (RTCx->DOY & RTC_DOY_MASK);
00419                 break;
00420         case RTC_TIMETYPE_MONTH:
00421                 return (RTCx->MONTH & RTC_MONTH_MASK);
00422                 break;
00423         case RTC_TIMETYPE_YEAR:
00424                 return (RTCx->YEAR & RTC_YEAR_MASK);
00425                 break;
00426         default:
00427                 return (0);
00428                 break;
00429         }
00430 }
00431 
00432 
00433 /*********************************************************************/
00440 void RTC_SetFullTime (LPC_RTC_TypeDef *RTCx, RTC_TIME_Type *pFullTime)
00441 {
00442         CHECK_PARAM(PARAM_RTCx(RTCx));
00443 
00444         RTCx->DOM = pFullTime->DOM & RTC_DOM_MASK;
00445         RTCx->DOW = pFullTime->DOW & RTC_DOW_MASK;
00446         RTCx->DOY = pFullTime->DOY & RTC_DOY_MASK;
00447         RTCx->HOUR = pFullTime->HOUR & RTC_HOUR_MASK;
00448         RTCx->MIN = pFullTime->MIN & RTC_MIN_MASK;
00449         RTCx->SEC = pFullTime->SEC & RTC_SEC_MASK;
00450         RTCx->MONTH = pFullTime->MONTH & RTC_MONTH_MASK;
00451         RTCx->YEAR = pFullTime->YEAR & RTC_YEAR_MASK;
00452 }
00453 
00454 
00455 /*********************************************************************/
00462 void RTC_GetFullTime (LPC_RTC_TypeDef *RTCx, RTC_TIME_Type *pFullTime)
00463 {
00464         CHECK_PARAM(PARAM_RTCx(RTCx));
00465 
00466         pFullTime->DOM = RTCx->DOM & RTC_DOM_MASK;
00467         pFullTime->DOW = RTCx->DOW & RTC_DOW_MASK;
00468         pFullTime->DOY = RTCx->DOY & RTC_DOY_MASK;
00469         pFullTime->HOUR = RTCx->HOUR & RTC_HOUR_MASK;
00470         pFullTime->MIN = RTCx->MIN & RTC_MIN_MASK;
00471         pFullTime->SEC = RTCx->SEC & RTC_SEC_MASK;
00472         pFullTime->MONTH = RTCx->MONTH & RTC_MONTH_MASK;
00473         pFullTime->YEAR = RTCx->YEAR & RTC_YEAR_MASK;
00474 }
00475 
00476 
00477 /*********************************************************************/
00492 void RTC_SetAlarmTime (LPC_RTC_TypeDef *RTCx, uint32_t Timetype, uint32_t ALValue)
00493 {
00494         CHECK_PARAM(PARAM_RTCx(RTCx));
00495 
00496         switch (Timetype)
00497         {
00498         case RTC_TIMETYPE_SECOND:
00499                 CHECK_PARAM(ALValue < RTC_SECOND_MAX);
00500 
00501                 RTCx->ALSEC = ALValue & RTC_SEC_MASK;
00502                 break;
00503 
00504         case RTC_TIMETYPE_MINUTE:
00505                 CHECK_PARAM(ALValue < RTC_MINUTE_MAX);
00506 
00507                 RTCx->ALMIN = ALValue & RTC_MIN_MASK;
00508                 break;
00509 
00510         case RTC_TIMETYPE_HOUR:
00511                 CHECK_PARAM(ALValue < RTC_HOUR_MAX);
00512 
00513                 RTCx->ALHOUR = ALValue & RTC_HOUR_MASK;
00514                 break;
00515 
00516         case RTC_TIMETYPE_DAYOFWEEK:
00517                 CHECK_PARAM(ALValue < RTC_DAYOFWEEK_MAX);
00518 
00519                 RTCx->ALDOW = ALValue & RTC_DOW_MASK;
00520                 break;
00521 
00522         case RTC_TIMETYPE_DAYOFMONTH:
00523                 CHECK_PARAM((ALValue < RTC_DAYOFMONTH_MAX) \
00524                                 && (ALValue > RTC_DAYOFMONTH_MIN));
00525 
00526                 RTCx->ALDOM = ALValue & RTC_DOM_MASK;
00527                 break;
00528 
00529         case RTC_TIMETYPE_DAYOFYEAR:
00530                 CHECK_PARAM((ALValue > RTC_DAYOFYEAR_MIN) \
00531                                 && (ALValue < RTC_DAYOFYEAR_MAX));
00532 
00533                 RTCx->ALDOY = ALValue & RTC_DOY_MASK;
00534                 break;
00535 
00536         case RTC_TIMETYPE_MONTH:
00537                 CHECK_PARAM((ALValue > RTC_MONTH_MIN) \
00538                                 && (ALValue < RTC_MONTH_MAX));
00539 
00540                 RTCx->ALMON = ALValue & RTC_MONTH_MASK;
00541                 break;
00542 
00543         case RTC_TIMETYPE_YEAR:
00544                 CHECK_PARAM(ALValue < RTC_YEAR_MAX);
00545 
00546                 RTCx->ALYEAR = ALValue & RTC_YEAR_MASK;
00547                 break;
00548         }
00549 }
00550 
00551 
00552 
00553 /*********************************************************************/
00567 uint32_t RTC_GetAlarmTime (LPC_RTC_TypeDef *RTCx, uint32_t Timetype)
00568 {
00569         switch (Timetype)
00570         {
00571         case RTC_TIMETYPE_SECOND:
00572                 return (RTCx->ALSEC & RTC_SEC_MASK);
00573                 break;
00574         case RTC_TIMETYPE_MINUTE:
00575                 return (RTCx->ALMIN & RTC_MIN_MASK);
00576                 break;
00577         case RTC_TIMETYPE_HOUR:
00578                 return (RTCx->ALHOUR & RTC_HOUR_MASK);
00579                 break;
00580         case RTC_TIMETYPE_DAYOFWEEK:
00581                 return (RTCx->ALDOW & RTC_DOW_MASK);
00582                 break;
00583         case RTC_TIMETYPE_DAYOFMONTH:
00584                 return (RTCx->ALDOM & RTC_DOM_MASK);
00585                 break;
00586         case RTC_TIMETYPE_DAYOFYEAR:
00587                 return (RTCx->ALDOY & RTC_DOY_MASK);
00588                 break;
00589         case RTC_TIMETYPE_MONTH:
00590                 return (RTCx->ALMON & RTC_MONTH_MASK);
00591                 break;
00592         case RTC_TIMETYPE_YEAR:
00593                 return (RTCx->ALYEAR & RTC_YEAR_MASK);
00594                 break;
00595         default:
00596                 return (0);
00597                 break;
00598         }
00599 }
00600 
00601 
00602 /*********************************************************************/
00609 void RTC_SetFullAlarmTime (LPC_RTC_TypeDef *RTCx, RTC_TIME_Type *pFullTime)
00610 {
00611         CHECK_PARAM(PARAM_RTCx(RTCx));
00612 
00613         RTCx->ALDOM = pFullTime->DOM & RTC_DOM_MASK;
00614         RTCx->ALDOW = pFullTime->DOW & RTC_DOW_MASK;
00615         RTCx->ALDOY = pFullTime->DOY & RTC_DOY_MASK;
00616         RTCx->ALHOUR = pFullTime->HOUR & RTC_HOUR_MASK;
00617         RTCx->ALMIN = pFullTime->MIN & RTC_MIN_MASK;
00618         RTCx->ALSEC = pFullTime->SEC & RTC_SEC_MASK;
00619         RTCx->ALMON = pFullTime->MONTH & RTC_MONTH_MASK;
00620         RTCx->ALYEAR = pFullTime->YEAR & RTC_YEAR_MASK;
00621 }
00622 
00623 
00624 /*********************************************************************/
00631 void RTC_GetFullAlarmTime (LPC_RTC_TypeDef *RTCx, RTC_TIME_Type *pFullTime)
00632 {
00633         CHECK_PARAM(PARAM_RTCx(RTCx));
00634 
00635         pFullTime->DOM = RTCx->ALDOM & RTC_DOM_MASK;
00636         pFullTime->DOW = RTCx->ALDOW & RTC_DOW_MASK;
00637         pFullTime->DOY = RTCx->ALDOY & RTC_DOY_MASK;
00638         pFullTime->HOUR = RTCx->ALHOUR & RTC_HOUR_MASK;
00639         pFullTime->MIN = RTCx->ALMIN & RTC_MIN_MASK;
00640         pFullTime->SEC = RTCx->ALSEC & RTC_SEC_MASK;
00641         pFullTime->MONTH = RTCx->ALMON & RTC_MONTH_MASK;
00642         pFullTime->YEAR = RTCx->ALYEAR & RTC_YEAR_MASK;
00643 }
00644 
00645 
00646 /*********************************************************************/
00658 IntStatus RTC_GetIntPending (LPC_RTC_TypeDef *RTCx, uint32_t IntType)
00659 {
00660         CHECK_PARAM(PARAM_RTCx(RTCx));
00661         CHECK_PARAM(PARAM_RTC_INT(IntType));
00662 
00663         return ((RTCx->ILR & IntType) ? SET : RESET);
00664 }
00665 
00666 
00667 /*********************************************************************/
00677 void RTC_ClearIntPending (LPC_RTC_TypeDef *RTCx, uint32_t IntType)
00678 {
00679         CHECK_PARAM(PARAM_RTCx(RTCx));
00680         CHECK_PARAM(PARAM_RTC_INT(IntType));
00681 
00682         RTCx->ILR = IntType;
00683 }
00684 
00685 /*********************************************************************/
00693 void RTC_CalibCounterCmd(LPC_RTC_TypeDef *RTCx, FunctionalState NewState)
00694 {
00695         CHECK_PARAM(PARAM_RTCx(RTCx));
00696         CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState));
00697 
00698         if (NewState == ENABLE)
00699         {
00700                 RTCx->CCR &= (~RTC_CCR_CCALEN) & RTC_CCR_BITMASK;
00701         }
00702         else
00703         {
00704                 RTCx->CCR |= RTC_CCR_CCALEN;
00705         }
00706 }
00707 
00708 
00709 /*********************************************************************/
00719 void RTC_CalibConfig(LPC_RTC_TypeDef *RTCx, uint32_t CalibValue, uint8_t CalibDir)
00720 {
00721         CHECK_PARAM(PARAM_RTCx(RTCx));
00722         CHECK_PARAM(PARAM_RTC_CALIB_DIR(CalibDir));
00723         CHECK_PARAM(CalibValue > RTC_CALIBRATION_MAX);
00724 
00725         RTCx->CALIBRATION = ((CalibValue - 1) & RTC_CALIBRATION_CALVAL_MASK) \
00726                         | ((CalibDir == RTC_CALIB_DIR_BACKWARD) ? RTC_CALIBRATION_LIBDIR : 0);
00727 }
00728 
00729 
00730 /*********************************************************************/
00741 void RTC_WriteGPREG (LPC_RTC_TypeDef *RTCx, uint8_t Channel, uint32_t Value)
00742 {
00743         uint32_t *preg;
00744 
00745         CHECK_PARAM(PARAM_RTCx(RTCx));
00746         CHECK_PARAM(PARAM_RTC_GPREG_CH(Channel));
00747 
00748         preg = (uint32_t *)&RTCx->GPREG0;
00749         preg += Channel;
00750         *preg = Value;
00751 }
00752 
00753 
00754 /*********************************************************************/
00764 uint32_t RTC_ReadGPREG (LPC_RTC_TypeDef *RTCx, uint8_t Channel)
00765 {
00766         uint32_t *preg;
00767         uint32_t value;
00768 
00769         CHECK_PARAM(PARAM_RTCx(RTCx));
00770         CHECK_PARAM(PARAM_RTC_GPREG_CH(Channel));
00771 
00772         preg = (uint32_t *)&RTCx->GPREG0;
00773         preg += Channel;
00774         value = *preg;
00775         return (value);
00776 }
00777 
00782 #endif /* _RTC */
00783 
00788 /* --------------------------------- End Of File ------------------------------ */
00789
Generated on Mon Feb 8 10:01:38 2010 for LPC1700CMSIS Standard Peripheral Firmware Library by
1.5.9
previous page start next page