/*********************************************************************//** * @brief Get current time value for each type time type * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] Timetype Time Type, should be: * - RTC_TIMETYPE_SECOND * - RTC_TIMETYPE_MINUTE * - RTC_TIMETYPE_HOUR * - RTC_TIMETYPE_DAYOFWEEK * - RTC_TIMETYPE_DAYOFMONTH * - RTC_TIMETYPE_DAYOFYEAR * - RTC_TIMETYPE_MONTH * - RTC_TIMETYPE_YEAR * @return Value of time according to specified time type **********************************************************************/ uint32_t RTC_GetTime(LPC_RTC_Type *RTCx, uint32_t Timetype) { CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_RTC_TIMETYPE(Timetype)); switch (Timetype) { case RTC_TIMETYPE_SECOND: return (RTCx->SEC & RTC_SEC_MASK); case RTC_TIMETYPE_MINUTE: return (RTCx->MIN & RTC_MIN_MASK); case RTC_TIMETYPE_HOUR: return (RTCx->HRS & RTC_HOUR_MASK); case RTC_TIMETYPE_DAYOFWEEK: return (RTCx->DOW & RTC_DOW_MASK); case RTC_TIMETYPE_DAYOFMONTH: return (RTCx->DOM & RTC_DOM_MASK); case RTC_TIMETYPE_DAYOFYEAR: return (RTCx->DOY & RTC_DOY_MASK); case RTC_TIMETYPE_MONTH: return (RTCx->MONTH & RTC_MONTH_MASK); case RTC_TIMETYPE_YEAR: return (RTCx->YEAR & RTC_YEAR_MASK); default: return (0); } }
/********************************************************************//** * @brief Initializes the RTC peripheral. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @return None *********************************************************************/ void RTC_Init (LPC_RTC_Type *RTCx) { CHECK_PARAM(PARAM_RTCx(RTCx)); // Configure clock to RTC LPC_CREG->CREG0 &= ~((1<<3)|(1<<2)); // Reset 32Khz oscillator LPC_CREG->CREG0 |= (1<<1)|(1<<0); // Enable 32 kHz & 1 kHz on osc32k and release reset LPC_SCU->SFSCLK_0 = 1 | (0x3<<2); // function 1; CGU clk out, pull down LPC_CGU->BASE_OUT_CLK = (CGU_CLKSRC_32KHZ_OSC<<24) |(1<<11); // base clock out use 32KHz crystal and auto block do { /* Reset RTC clock*/ RTCx->CCR = RTC_CCR_CTCRST | RTC_CCR_CCALEN; } while(RTCx->CCR!=(RTC_CCR_CTCRST | RTC_CCR_CCALEN)); do { /* Finish resetting RTC clock*/ RTCx->CCR = RTC_CCR_CCALEN; } while(RTCx->CCR != RTC_CCR_CCALEN); /* Clear counter increment and alarm interrupt */ RTCx->ILR = RTC_IRL_RTCCIF | RTC_IRL_RTCALF; while(RTCx->ILR!=0); // Clear all register to be default RTCx->CIIR = 0x00; RTCx->AMR = 0xFF; RTCx->CALIBRATION = 0x00; }
/*********************************************************************//** * @brief Reset clock tick counter in RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @return None **********************************************************************/ void RTC_ResetClockTickCounter(LPC_RTC_Type *RTCx) { CHECK_PARAM(PARAM_RTCx(RTCx)); RTCx->CCR |= RTC_CCR_CTCRST; RTCx->CCR &= (~RTC_CCR_CTCRST) & RTC_CCR_BITMASK; }
/*********************************************************************//** * @brief Clear specified Location interrupt pending in * RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] IntType Interrupt location type, should be: * - RTC_INT_COUNTER_INCREASE :Clear Counter Increment Interrupt pending. * - RTC_INT_ALARM :Clear alarm interrupt pending * @return None **********************************************************************/ void RTC_ClearIntPending (LPC_RTC_Type *RTCx, uint32_t IntType) { CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_RTC_INT(IntType)); RTCx->ILR = IntType; }
/*********************************************************************//** * @brief Check whether if specified Location interrupt in * RTC peripheral is set or not * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] IntType Interrupt location type, should be: * - RTC_INT_COUNTER_INCREASE: Counter Increment Interrupt block generated an interrupt. * - RTC_INT_ALARM: Alarm generated an interrupt. * @return New state of specified Location interrupt in RTC peripheral * - SET * - RESET **********************************************************************/ IntStatus RTC_GetIntPending (LPC_RTC_Type *RTCx, uint32_t IntType) { CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_RTC_INT(IntType)); return ((RTCx->ILR & IntType) ? SET : RESET); }
/*********************************************************************//** * @brief Read value from General purpose registers * @param[in] RTCx RTC peripheral selected, should be RTC * @param[in] Channel General purpose registers Channel number, * should be in range from 0 to 4. * @return Read Value * Note: These General purpose registers can be used to store important * information when the main power supply is off. The value in these * registers is not affected by chip reset. **********************************************************************/ uint32_t RTC_ReadGPREG (RTC_TypeDef *RTCx, uint8_t Channel) { CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_RTC_GPREG_CH(Channel)); /* FIXME return RTCx->GPREGn[Channel]; */ }
/*********************************************************************//** * @brief Write value to General purpose registers * @param[in] RTCx RTC peripheral selected, should be RTC * @param[in] Channel General purpose registers Channel number, * should be in range from 0 to 4. * @param[in] Value Value to write * @return None * Note: These General purpose registers can be used to store important * information when the main power supply is off. The value in these * registers is not affected by chip reset. **********************************************************************/ void RTC_WriteGPREG (RTC_TypeDef *RTCx, uint8_t Channel, uint32_t Value) { CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_RTC_GPREG_CH(Channel)); /* FIXME RTCx->GPREGn[Channel] = Value; */ }
/*********************************************************************//** * @brief Set current time value for each time type in RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] Timetype Time Type, should be: * - RTC_TIMETYPE_SECOND * - RTC_TIMETYPE_MINUTE * - RTC_TIMETYPE_HOUR * - RTC_TIMETYPE_DAYOFWEEK * - RTC_TIMETYPE_DAYOFMONTH * - RTC_TIMETYPE_DAYOFYEAR * - RTC_TIMETYPE_MONTH * - RTC_TIMETYPE_YEAR * @param[in] TimeValue Time value to set * @return None **********************************************************************/ void RTC_SetTime (LPC_RTC_Type *RTCx, uint32_t Timetype, uint32_t TimeValue) { CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_RTC_TIMETYPE(Timetype)); switch ( Timetype) { case RTC_TIMETYPE_SECOND: CHECK_PARAM(TimeValue <= RTC_SECOND_MAX); RTCx->SEC = TimeValue & RTC_SEC_MASK; break; case RTC_TIMETYPE_MINUTE: CHECK_PARAM(TimeValue <= RTC_MINUTE_MAX); RTCx->MIN = TimeValue & RTC_MIN_MASK; break; case RTC_TIMETYPE_HOUR: CHECK_PARAM(TimeValue <= RTC_HOUR_MAX); RTCx->HRS = TimeValue & RTC_HOUR_MASK; break; case RTC_TIMETYPE_DAYOFWEEK: CHECK_PARAM(TimeValue <= RTC_DAYOFWEEK_MAX); RTCx->DOW = TimeValue & RTC_DOW_MASK; break; case RTC_TIMETYPE_DAYOFMONTH: CHECK_PARAM((TimeValue <= RTC_DAYOFMONTH_MAX) \ && (TimeValue >= RTC_DAYOFMONTH_MIN)); RTCx->DOM = TimeValue & RTC_DOM_MASK; break; case RTC_TIMETYPE_DAYOFYEAR: CHECK_PARAM((TimeValue >= RTC_DAYOFYEAR_MIN) \ && (TimeValue <= RTC_DAYOFYEAR_MAX)); RTCx->DOY = TimeValue & RTC_DOY_MASK; break; case RTC_TIMETYPE_MONTH: CHECK_PARAM((TimeValue >= RTC_MONTH_MIN) \ && (TimeValue <= RTC_MONTH_MAX)); RTCx->MONTH = TimeValue & RTC_MONTH_MASK; break; case RTC_TIMETYPE_YEAR: CHECK_PARAM(TimeValue <= RTC_YEAR_MAX); RTCx->YEAR = TimeValue & RTC_YEAR_MASK; break; } }
/*********************************************************************//** * @brief De-initializes the RTC peripheral registers to their * default reset values. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @return None **********************************************************************/ void RTC_DeInit(LPC_RTC_TypeDef *RTCx) { CHECK_PARAM(PARAM_RTCx(RTCx)); RTCx->CCR = 0x00; // Disable power and clock for RTC module CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCRTC, DISABLE); }
/*********************************************************************//** * @brief Set alarm time value for each time type * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] Timetype Time Type, should be: * - RTC_TIMETYPE_SECOND * - RTC_TIMETYPE_MINUTE * - RTC_TIMETYPE_HOUR * - RTC_TIMETYPE_DAYOFWEEK * - RTC_TIMETYPE_DAYOFMONTH * - RTC_TIMETYPE_DAYOFYEAR * - RTC_TIMETYPE_MONTH * - RTC_TIMETYPE_YEAR * @param[in] ALValue Alarm time value to set * @return None **********************************************************************/ void RTC_SetAlarmTime (LPC_RTC_Type *RTCx, uint32_t Timetype, uint32_t ALValue) { CHECK_PARAM(PARAM_RTCx(RTCx)); switch (Timetype) { case RTC_TIMETYPE_SECOND: CHECK_PARAM(ALValue <= RTC_SECOND_MAX); RTCx->ASEC = ALValue & RTC_SEC_MASK; break; case RTC_TIMETYPE_MINUTE: CHECK_PARAM(ALValue <= RTC_MINUTE_MAX); RTCx->AMIN = ALValue & RTC_MIN_MASK; break; case RTC_TIMETYPE_HOUR: CHECK_PARAM(ALValue <= RTC_HOUR_MAX); RTCx->AHRS = ALValue & RTC_HOUR_MASK; break; case RTC_TIMETYPE_DAYOFWEEK: CHECK_PARAM(ALValue <= RTC_DAYOFWEEK_MAX); RTCx->ADOW = ALValue & RTC_DOW_MASK; break; case RTC_TIMETYPE_DAYOFMONTH: CHECK_PARAM((ALValue <= RTC_DAYOFMONTH_MAX) \ && (ALValue >= RTC_DAYOFMONTH_MIN)); RTCx->ADOM = ALValue & RTC_DOM_MASK; break; case RTC_TIMETYPE_DAYOFYEAR: CHECK_PARAM((ALValue >= RTC_DAYOFYEAR_MIN) \ && (ALValue <= RTC_DAYOFYEAR_MAX)); RTCx->ADOY = ALValue & RTC_DOY_MASK; break; case RTC_TIMETYPE_MONTH: CHECK_PARAM((ALValue >= RTC_MONTH_MIN) \ && (ALValue <= RTC_MONTH_MAX)); RTCx->AMON = ALValue & RTC_MONTH_MASK; break; case RTC_TIMETYPE_YEAR: CHECK_PARAM(ALValue <= RTC_YEAR_MAX); RTCx->AYRS = ALValue & RTC_YEAR_MASK; break; } }
/*********************************************************************//** * @brief Set alarm time value for each time type * @param[in] RTCx RTC peripheral selected, should be RTC * @param[in] Timetype: Time Type, should be: * - RTC_TIMETYPE_SECOND * - RTC_TIMETYPE_MINUTE * - RTC_TIMETYPE_HOUR * - RTC_TIMETYPE_DAYOFWEEK * - RTC_TIMETYPE_DAYOFMONTH * - RTC_TIMETYPE_DAYOFYEAR * - RTC_TIMETYPE_MONTH * - RTC_TIMETYPE_YEAR * @param[in] ALValue Alarm time value to set * @return None **********************************************************************/ void RTC_SetAlarmTime (RTC_TypeDef *RTCx, uint32_t Timetype, uint32_t ALValue) { CHECK_PARAM(PARAM_RTCx(RTCx)); switch (Timetype) { case RTC_TIMETYPE_SECOND: CHECK_PARAM(ALValue < RTC_SECOND_MAX); RTCx->ALSEC = ALValue & RTC_SEC_MASK; break; case RTC_TIMETYPE_MINUTE: CHECK_PARAM(ALValue < RTC_MINUTE_MAX); RTCx->ALMIN = ALValue & RTC_MIN_MASK; break; case RTC_TIMETYPE_HOUR: CHECK_PARAM(ALValue < RTC_HOUR_MAX); RTCx->ALHOUR = ALValue & RTC_HOUR_MASK; break; case RTC_TIMETYPE_DAYOFWEEK: CHECK_PARAM(ALValue < RTC_DAYOFWEEK_MAX); RTCx->ALDOW = ALValue & RTC_DOW_MASK; break; case RTC_TIMETYPE_DAYOFMONTH: CHECK_PARAM((ALValue < RTC_DAYOFMONTH_MAX) \ && (ALValue > RTC_DAYOFMONTH_MIN)); RTCx->ALDOM = ALValue & RTC_DOM_MASK; break; case RTC_TIMETYPE_DAYOFYEAR: CHECK_PARAM((ALValue > RTC_DAYOFYEAR_MIN) \ && (ALValue < RTC_DAYOFYEAR_MAX)); RTCx->ALDOY = ALValue & RTC_DOY_MASK; break; case RTC_TIMETYPE_MONTH: CHECK_PARAM((ALValue > RTC_MONTH_MIN) \ && (ALValue < RTC_MONTH_MAX)); RTCx->ALMON = ALValue & RTC_MONTH_MASK; /* FIXME RTCx->ALMONTH = ALValue & RTC_MONTH_MASK; */ break; case RTC_TIMETYPE_YEAR: CHECK_PARAM(ALValue < RTC_YEAR_MAX); RTCx->ALYEAR = ALValue & RTC_YEAR_MASK; break; } }
/*********************************************************************//** * @brief Configures Calibration in RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] CalibValue Calibration value, should be in range from * 0 to 131,072 * @param[in] CalibDir Calibration Direction, should be: * - RTC_CALIB_DIR_FORWARD :Forward calibration * - RTC_CALIB_DIR_BACKWARD :Backward calibration * @return None **********************************************************************/ void RTC_CalibConfig(LPC_RTC_Type *RTCx, uint32_t CalibValue, uint8_t CalibDir) { CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_RTC_CALIB_DIR(CalibDir)); CHECK_PARAM(CalibValue < RTC_CALIBRATION_MAX); RTCx->CALIBRATION = ((CalibValue - 1) & RTC_CALIBRATION_CALVAL_MASK) \ | ((CalibDir == RTC_CALIB_DIR_BACKWARD) ? RTC_CALIBRATION_LIBDIR : 0); }
/*********************************************************************//** * @brief Write value to General purpose registers * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] Channel General purpose registers Channel number, * should be in range from 0 to 4. * @param[in] Value Value to write * @return None * Note: These General purpose registers can be used to store important * information when the main power supply is off. The value in these * registers is not affected by chip reset. **********************************************************************/ void RTC_WriteGPREG (LPC_RTC_TypeDef *RTCx, uint8_t Channel, uint32_t Value) { volatile uint32_t *preg; CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_RTC_GPREG_CH(Channel)); preg = (volatile uint32_t *)&RTCx->GPREG0; preg += Channel; *preg = Value; }
/*********************************************************************//** * @brief Write value to General purpose registers * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] Channel General purpose registers Channel number, * should be in range from 0 to 63. * @param[in] Value Value to write * @return None * Note: These General purpose registers can be used to store important * information when the main power supply is off. The value in these * registers is not affected by chip reset. **********************************************************************/ void RTC_WriteGPREG (LPC_RTC_Type *RTCx, uint8_t Channel, uint32_t Value) { uint32_t *preg; CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_RTC_GPREG_CH(Channel)); preg = (uint32_t *)RTC_GPREG_BASE; preg += Channel; *preg = Value; }
/*********************************************************************//** * @brief Enable/Disable Alarm interrupt for each time type * in RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] AlarmTimeType: Alarm Time Interrupt type, * an matching of this type value below with current time * in RTC will generates an interrupt, should be: * - RTC_TIMETYPE_SECOND * - RTC_TIMETYPE_MINUTE * - RTC_TIMETYPE_HOUR * - RTC_TIMETYPE_DAYOFWEEK * - RTC_TIMETYPE_DAYOFMONTH * - RTC_TIMETYPE_DAYOFYEAR * - RTC_TIMETYPE_MONTH * - RTC_TIMETYPE_YEAR * @param[in] NewState New State of this function, should be: * - ENABLE: Alarm interrupt for this time type are enabled * - DISABLE: Alarm interrupt for this time type are disabled * @return None **********************************************************************/ void RTC_AlarmIntConfig (LPC_RTC_Type *RTCx, uint32_t AlarmTimeType, \ FunctionalState NewState) { uint32_t tem; CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState)); CHECK_PARAM(PARAM_RTC_TIMETYPE(AlarmTimeType)); switch (AlarmTimeType) { case RTC_TIMETYPE_SECOND: tem = (RTC_AMR_AMRSEC); break; case RTC_TIMETYPE_MINUTE: tem = (RTC_AMR_AMRMIN); break; case RTC_TIMETYPE_HOUR: tem = (RTC_AMR_AMRHOUR); break; case RTC_TIMETYPE_DAYOFWEEK: tem = (RTC_AMR_AMRDOW); break; case RTC_TIMETYPE_DAYOFMONTH: tem = (RTC_AMR_AMRDOM); break; case RTC_TIMETYPE_DAYOFYEAR: tem = (RTC_AMR_AMRDOY); break; case RTC_TIMETYPE_MONTH: tem = (RTC_AMR_AMRMON); break; case RTC_TIMETYPE_YEAR: tem = (RTC_AMR_AMRYEAR); break; } if (NewState == ENABLE) { //do { RTCx->AMR &= (~tem) & RTC_AMR_BITMASK; } //while(RTCx->AMR & tem); } else { //do { RTCx->AMR |= (tem); } //while((RTCx->AMR & tem)== 0); } }
/*********************************************************************//** * @brief Enable/Disable Counter increment interrupt for each time type * in RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] CntIncrIntType: Counter Increment Interrupt type, * an increment of this type value below will generates * an interrupt, should be: * - RTC_TIMETYPE_SECOND * - RTC_TIMETYPE_MINUTE * - RTC_TIMETYPE_HOUR * - RTC_TIMETYPE_DAYOFWEEK * - RTC_TIMETYPE_DAYOFMONTH * - RTC_TIMETYPE_DAYOFYEAR * - RTC_TIMETYPE_MONTH * - RTC_TIMETYPE_YEAR * @param[in] NewState New State of this function, should be: * - ENABLE: Counter Increment interrupt for this time type are enabled * - DISABLE: Counter Increment interrupt for this time type are disabled * @return None **********************************************************************/ void RTC_CntIncrIntConfig (LPC_RTC_Type *RTCx, uint32_t CntIncrIntType, \ FunctionalState NewState) { uint32_t tem; CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState)); CHECK_PARAM(PARAM_RTC_TIMETYPE(CntIncrIntType)); switch (CntIncrIntType) { case RTC_TIMETYPE_SECOND: tem = RTC_CIIR_IMSEC; break; case RTC_TIMETYPE_MINUTE: tem = RTC_CIIR_IMMIN; break; case RTC_TIMETYPE_HOUR: tem = RTC_CIIR_IMHOUR; break; case RTC_TIMETYPE_DAYOFWEEK: tem = RTC_CIIR_IMDOW; break; case RTC_TIMETYPE_DAYOFMONTH: tem = RTC_CIIR_IMDOM; break; case RTC_TIMETYPE_DAYOFYEAR: tem = RTC_CIIR_IMDOY; break; case RTC_TIMETYPE_MONTH: tem = RTC_CIIR_IMMON; break; case RTC_TIMETYPE_YEAR: tem = RTC_CIIR_IMYEAR; break; } if (NewState == ENABLE) { //do { RTCx->CIIR |= tem; } //while((RTCx->CIIR & tem)== 0); } else { //do { RTCx->CIIR &= (~tem) & RTC_CIIR_BITMASK; } //while(RTCx->CIIR & tem); } }
/*********************************************************************//** * @brief Get full of alarm time in RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] pFullTime Pointer to a RTC_TIME_Type structure that * will be stored alarm time in full. * @return None **********************************************************************/ void RTC_GetFullAlarmTime (LPC_RTC_Type *RTCx, RTC_TIME_Type *pFullTime) { CHECK_PARAM(PARAM_RTCx(RTCx)); pFullTime->DOM = RTCx->ADOM & RTC_DOM_MASK; pFullTime->DOW = RTCx->ADOW & RTC_DOW_MASK; pFullTime->DOY = RTCx->ADOY & RTC_DOY_MASK; pFullTime->HOUR = RTCx->AHRS & RTC_HOUR_MASK; pFullTime->MIN = RTCx->AMIN & RTC_MIN_MASK; pFullTime->SEC = RTCx->ASEC & RTC_SEC_MASK; pFullTime->MONTH = RTCx->AMON & RTC_MONTH_MASK; pFullTime->YEAR = RTCx->AYRS & RTC_YEAR_MASK; }
/*********************************************************************//** * @brief Read value from General purpose registers * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] Channel General purpose registers Channel number, * should be in range from 0 to 4. * @return Read Value * Note: These General purpose registers can be used to store important * information when the main power supply is off. The value in these * registers is not affected by chip reset. **********************************************************************/ uint32_t RTC_ReadGPREG (LPC_RTC_Type *RTCx, uint8_t Channel) { uint32_t *preg; uint32_t value; CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_RTC_GPREG_CH(Channel)); preg = (uint32_t *)RTC_GPREG_BASE; preg += Channel; value = *preg; return (value); }
/*********************************************************************//** * @brief Read value from General purpose registers * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] Channel General purpose registers Channel number, * should be in range from 0 to 4. * @return Read Value * Note: These General purpose registers can be used to store important * information when the main power supply is off. The value in these * registers is not affected by chip reset. **********************************************************************/ uint32_t RTC_ReadGPREG (LPC_RTC_TypeDef *RTCx, uint8_t Channel) { volatile uint32_t *preg; uint32_t value; CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_RTC_GPREG_CH(Channel)); preg = (volatile uint32_t *)&RTCx->GPREG0; preg += Channel; value = *preg; return (value); }
/*********************************************************************//** * @brief Set full of time in RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] pFullTime Pointer to a RTC_TIME_Type structure that * contains time value in full. * @return None **********************************************************************/ void RTC_SetFullTime (LPC_RTC_Type *RTCx, RTC_TIME_Type *pFullTime) { CHECK_PARAM(PARAM_RTCx(RTCx)); RTCx->DOM = pFullTime->DOM & RTC_DOM_MASK; RTCx->DOW = pFullTime->DOW & RTC_DOW_MASK; RTCx->DOY = pFullTime->DOY & RTC_DOY_MASK; RTCx->HRS = pFullTime->HOUR & RTC_HOUR_MASK; RTCx->MIN = pFullTime->MIN & RTC_MIN_MASK; RTCx->SEC = pFullTime->SEC & RTC_SEC_MASK; RTCx->MONTH = pFullTime->MONTH & RTC_MONTH_MASK; RTCx->YEAR = pFullTime->YEAR & RTC_YEAR_MASK; }
/*********************************************************************//** * @brief Get full of alarm time in RTC peripheral * @param[in] RTCx RTC peripheral selected, should be RTC * @param[in] pFullTime Pointer to a RTC_TIME_Type structure that * will be stored alarm time in full. * @return None **********************************************************************/ void RTC_GetFullAlarmTime (RTC_TypeDef *RTCx, RTC_TIME_Type *pFullTime) { CHECK_PARAM(PARAM_RTCx(RTCx)); pFullTime->DOM = RTCx->ALDOM & RTC_DOM_MASK; pFullTime->DOW = RTCx->ALDOW & RTC_DOW_MASK; pFullTime->DOY = RTCx->ALDOY & RTC_DOY_MASK; pFullTime->HOUR = RTCx->ALHOUR & RTC_HOUR_MASK; pFullTime->MIN = RTCx->ALMIN & RTC_MIN_MASK; pFullTime->SEC = RTCx->ALSEC & RTC_SEC_MASK; pFullTime->MONTH = RTCx->ALMON & RTC_MONTH_MASK; /* FIXME pFullTime->MONTH = RTCx->ALMONTH & RTC_MONTH_MASK; */ pFullTime->YEAR = RTCx->ALYEAR & RTC_YEAR_MASK; }
/********************************************************************//** * @brief Initializes the RTC peripheral. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @return None *********************************************************************/ void RTC_Init (LPC_RTC_TypeDef *RTCx) { CHECK_PARAM(PARAM_RTCx(RTCx)); /* Set up clock and power for RTC module */ CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCRTC, ENABLE); // Clear all register to be default RTCx->ILR = 0x00; RTCx->CCR = 0x00; RTCx->CIIR = 0x00; RTCx->AMR = 0xFF; RTCx->CALIBRATION = 0x00; }
/*********************************************************************//** * @brief Enable/Disable calibration counter in RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] NewState New State of this function, should be: * - ENABLE: The calibration counter is enabled and counting * - DISABLE: The calibration counter is disabled and reset to zero * @return None **********************************************************************/ void RTC_CalibCounterCmd(LPC_RTC_TypeDef *RTCx, FunctionalState NewState) { CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState)); if (NewState == ENABLE) { RTCx->CCR &= (~RTC_CCR_CCALEN) & RTC_CCR_BITMASK; } else { RTCx->CCR |= RTC_CCR_CCALEN; } }
/*********************************************************************//** * @brief Start/Stop RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] NewState New State of this function, should be: * - ENABLE :The time counters are enabled * - DISABLE :The time counters are disabled * @return None **********************************************************************/ void RTC_Cmd (LPC_RTC_Type *RTCx, FunctionalState NewState) { CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState)); if (NewState == ENABLE) { do { RTCx->CCR |= RTC_CCR_CLKEN; } while((RTCx->CCR&RTC_CCR_CLKEN)==0); } else { RTCx->CCR &= (~RTC_CCR_CLKEN) & RTC_CCR_BITMASK; } }
/*********************************************************************//** * @brief De-initializes the RTC peripheral registers to their * default reset values. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @return None **********************************************************************/ void RTC_DeInit(LPC_RTC_Type *RTCx) { CHECK_PARAM(PARAM_RTCx(RTCx)); RTCx->CCR = 0x00; }
void RTC_AlarmConfig (LPC_RTC_TypeDef *RTCx, uint32_t AlarmTimeMask) { CHECK_PARAM(PARAM_RTCx(RTCx)); RTCx->AMR = ~AlarmTimeMask & RTC_AMR_BITMASK; }
/*********************************************************************//** * @brief Enable/Disable Counter increment interrupt for each time type * in RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] CntIncrIntType: Counter Increment Interrupt type, * an increment of this type value below will generates * an interrupt, should be: * - RTC_TIMETYPE_SECOND * - RTC_TIMETYPE_MINUTE * - RTC_TIMETYPE_HOUR * - RTC_TIMETYPE_DAYOFWEEK * - RTC_TIMETYPE_DAYOFMONTH * - RTC_TIMETYPE_DAYOFYEAR * - RTC_TIMETYPE_MONTH * - RTC_TIMETYPE_YEAR * @param[in] NewState New State of this function, should be: * - ENABLE: Counter Increment interrupt for this * time type are enabled * - DISABLE: Counter Increment interrupt for this * time type are disabled * @return None **********************************************************************/ void RTC_CntIncrIntConfig (LPC_RTC_TypeDef *RTCx, uint32_t CntIncrIntType, \ FunctionalState NewState) { CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState)); CHECK_PARAM(PARAM_RTC_TIMETYPE(CntIncrIntType)); if (NewState == ENABLE) { switch (CntIncrIntType) { case RTC_TIMETYPE_SECOND: RTCx->CIIR |= RTC_CIIR_IMSEC; break; case RTC_TIMETYPE_MINUTE: RTCx->CIIR |= RTC_CIIR_IMMIN; break; case RTC_TIMETYPE_HOUR: RTCx->CIIR |= RTC_CIIR_IMHOUR; break; case RTC_TIMETYPE_DAYOFWEEK: RTCx->CIIR |= RTC_CIIR_IMDOW; break; case RTC_TIMETYPE_DAYOFMONTH: RTCx->CIIR |= RTC_CIIR_IMDOM; break; case RTC_TIMETYPE_DAYOFYEAR: RTCx->CIIR |= RTC_CIIR_IMDOY; break; case RTC_TIMETYPE_MONTH: RTCx->CIIR |= RTC_CIIR_IMMON; break; case RTC_TIMETYPE_YEAR: RTCx->CIIR |= RTC_CIIR_IMYEAR; break; } } else { switch (CntIncrIntType) { case RTC_TIMETYPE_SECOND: RTCx->CIIR &= (~RTC_CIIR_IMSEC) & RTC_CIIR_BITMASK; break; case RTC_TIMETYPE_MINUTE: RTCx->CIIR &= (~RTC_CIIR_IMMIN) & RTC_CIIR_BITMASK; break; case RTC_TIMETYPE_HOUR: RTCx->CIIR &= (~RTC_CIIR_IMHOUR) & RTC_CIIR_BITMASK; break; case RTC_TIMETYPE_DAYOFWEEK: RTCx->CIIR &= (~RTC_CIIR_IMDOW) & RTC_CIIR_BITMASK; break; case RTC_TIMETYPE_DAYOFMONTH: RTCx->CIIR &= (~RTC_CIIR_IMDOM) & RTC_CIIR_BITMASK; break; case RTC_TIMETYPE_DAYOFYEAR: RTCx->CIIR &= (~RTC_CIIR_IMDOY) & RTC_CIIR_BITMASK; break; case RTC_TIMETYPE_MONTH: RTCx->CIIR &= (~RTC_CIIR_IMMON) & RTC_CIIR_BITMASK; break; case RTC_TIMETYPE_YEAR: RTCx->CIIR &= (~RTC_CIIR_IMYEAR) & RTC_CIIR_BITMASK; break; } } }
/*********************************************************************//** * @brief Enable/Disable Alarm interrupt for each time type * in RTC peripheral * @param[in] RTCx RTC peripheral selected, should be LPC_RTC * @param[in] AlarmTimeType: Alarm Time Interrupt type, * an matching of this type value below with current time * in RTC will generates an interrupt, should be: * - RTC_TIMETYPE_SECOND * - RTC_TIMETYPE_MINUTE * - RTC_TIMETYPE_HOUR * - RTC_TIMETYPE_DAYOFWEEK * - RTC_TIMETYPE_DAYOFMONTH * - RTC_TIMETYPE_DAYOFYEAR * - RTC_TIMETYPE_MONTH * - RTC_TIMETYPE_YEAR * @param[in] NewState New State of this function, should be: * - ENABLE: Alarm interrupt for this * time type are enabled * - DISABLE: Alarm interrupt for this * time type are disabled * @return None **********************************************************************/ void RTC_AlarmIntConfig (LPC_RTC_TypeDef *RTCx, uint32_t AlarmTimeType, \ FunctionalState NewState) { CHECK_PARAM(PARAM_RTCx(RTCx)); CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState)); CHECK_PARAM(PARAM_RTC_TIMETYPE(AlarmTimeType)); if (NewState == ENABLE) { switch (AlarmTimeType) { case RTC_TIMETYPE_SECOND: RTCx->AMR &= (~RTC_AMR_AMRSEC) & RTC_AMR_BITMASK; break; case RTC_TIMETYPE_MINUTE: RTCx->AMR &= (~RTC_AMR_AMRMIN) & RTC_AMR_BITMASK; break; case RTC_TIMETYPE_HOUR: RTCx->AMR &= (~RTC_AMR_AMRHOUR) & RTC_AMR_BITMASK; break; case RTC_TIMETYPE_DAYOFWEEK: RTCx->AMR &= (~RTC_AMR_AMRDOW) & RTC_AMR_BITMASK; break; case RTC_TIMETYPE_DAYOFMONTH: RTCx->AMR &= (~RTC_AMR_AMRDOM) & RTC_AMR_BITMASK; break; case RTC_TIMETYPE_DAYOFYEAR: RTCx->AMR &= (~RTC_AMR_AMRDOY) & RTC_AMR_BITMASK; break; case RTC_TIMETYPE_MONTH: RTCx->AMR &= (~RTC_AMR_AMRMON) & RTC_AMR_BITMASK; break; case RTC_TIMETYPE_YEAR: RTCx->AMR &= (~RTC_AMR_AMRYEAR) & RTC_AMR_BITMASK; break; } } else { switch (AlarmTimeType) { case RTC_TIMETYPE_SECOND: RTCx->AMR |= (RTC_AMR_AMRSEC); break; case RTC_TIMETYPE_MINUTE: RTCx->AMR |= (RTC_AMR_AMRMIN); break; case RTC_TIMETYPE_HOUR: RTCx->AMR |= (RTC_AMR_AMRHOUR); break; case RTC_TIMETYPE_DAYOFWEEK: RTCx->AMR |= (RTC_AMR_AMRDOW); break; case RTC_TIMETYPE_DAYOFMONTH: RTCx->AMR |= (RTC_AMR_AMRDOM); break; case RTC_TIMETYPE_DAYOFYEAR: RTCx->AMR |= (RTC_AMR_AMRDOY); break; case RTC_TIMETYPE_MONTH: RTCx->AMR |= (RTC_AMR_AMRMON); break; case RTC_TIMETYPE_YEAR: RTCx->AMR |= (RTC_AMR_AMRYEAR); break; } } }