rtc_001.h

Go to the documentation of this file.

/*
 * @brief Real Time Clock registers and control functions
 *
 * @note
 * Copyright(C) NXP Semiconductors, 2012
 * All rights reserved.
 *
 * @par
 * Software that is described herein is for illustrative purposes only
 * which provides customers with programming information regarding the
 * LPC products.  This software is supplied "AS IS" without any warranties of
 * any kind, and NXP Semiconductors and its licensor disclaim any and
 * all warranties, express or implied, including all implied warranties of
 * merchantability, fitness for a particular purpose and non-infringement of
 * intellectual property rights.  NXP Semiconductors assumes no responsibility
 * or liability for the use of the software, conveys no license or rights under any
 * patent, copyright, mask work right, or any other intellectual property rights in
 * or to any products. NXP Semiconductors reserves the right to make changes
 * in the software without notification. NXP Semiconductors also makes no
 * representation or warranty that such application will be suitable for the
 * specified use without further testing or modification.
 *
 * @par
 * Permission to use, copy, modify, and distribute this software and its
 * documentation is hereby granted, under NXP Semiconductors' and its
 * licensor's relevant copyrights in the software, without fee, provided that it
 * is used in conjunction with NXP Semiconductors microcontrollers.  This
 * copyright, permission, and disclaimer notice must appear in all copies of
 * this code.
 */

#ifndef __RTC_001_H_
#define __RTC_001_H_

#include "sys_config.h"
#include "cmsis.h"

#ifdef __cplusplus
extern "C" {
#endif

#if defined(CHIP_LPC177X_8X) || defined(CHIP_LPC407X_8X) || defined(CHIP_LPC18XX) || defined(CHIP_LPC43XX)
#define RTC_EV_SUPPORT      1    /* Event Monitor/Recorder support */
#endif

typedef enum IP_RTC_TIMEINDEX {
 RTC_TIMETYPE_SECOND,  
 RTC_TIMETYPE_MINUTE,  
 RTC_TIMETYPE_HOUR,   
 RTC_TIMETYPE_DAYOFMONTH, 
 RTC_TIMETYPE_DAYOFWEEK,  
 RTC_TIMETYPE_DAYOFYEAR,  
 RTC_TIMETYPE_MONTH,   
 RTC_TIMETYPE_YEAR,   
 RTC_TIMETYPE_LAST
} IP_RTC_TIMEINDEX_T;

#if RTC_EV_SUPPORT

typedef enum IP_RTC_EV_CHANNEL {
 RTC_EV_CHANNEL_1 = 0,
 RTC_EV_CHANNEL_2,
 RTC_EV_CHANNEL_3,
 RTC_EV_CHANNEL_NUM,
} IP_RTC_EV_CHANNEL_T;
#endif /*RTC_EV_SUPPORT*/

typedef struct {       
 __IO uint32_t  ILR;      
 __I  uint32_t  RESERVED0;
 __IO uint32_t  CCR;      
 __IO uint32_t  CIIR;     
 __IO uint32_t  AMR;      
 __I  uint32_t  CTIME[3];    
 __IO uint32_t  TIME[RTC_TIMETYPE_LAST]; 
 __IO uint32_t  CALIBRATION;    
#if defined(CHIP_LPC177X_8X) || defined(CHIP_LPC407X_8X) || defined(CHIP_LPC175X_6X)
 __IO uint32_t GPREG[5];     
 __IO uint32_t RTC_AUXEN;    
 __IO uint32_t RTC_AUX;     
#else
 __I  uint32_t  RESERVED1[7];
#endif
 __IO uint32_t  ALRM[RTC_TIMETYPE_LAST]; 
#if RTC_EV_SUPPORT
 __IO uint32_t ERSTATUS;     
 __IO uint32_t ERCONTROL;    
 __I  uint32_t ERCOUNTERS;    
 __I  uint32_t RESERVED2;
 __I  uint32_t ERFIRSTSTAMP[RTC_EV_CHANNEL_NUM];   
 __I  uint32_t RESERVED3;
 __I  uint32_t ERLASTSTAMP[RTC_EV_CHANNEL_NUM];   
#endif /*RTC_EV_SUPPORT*/
} IP_RTC_001_T;

#define RTC_ILR_BITMASK         ((0x00000003))

#define RTC_IRL_RTCCIF          ((1 << 0))

#define RTC_IRL_RTCALF          ((1 << 1))

#define RTC_CCR_BITMASK         ((0x00000013))

#define RTC_CCR_CLKEN           ((1 << 0))

#define RTC_CCR_CTCRST          ((1 << 1))

#define RTC_CCR_CCALEN          ((1 << 4))

#define RTC_AMR_CIIR_IMSEC          ((1 << 0))

#define RTC_AMR_CIIR_IMMIN          ((1 << 1))

#define RTC_AMR_CIIR_IMHOUR         ((1 << 2))

#define RTC_AMR_CIIR_IMDOM          ((1 << 3))

#define RTC_AMR_CIIR_IMDOW          ((1 << 4))

#define RTC_AMR_CIIR_IMDOY          ((1 << 5))

#define RTC_AMR_CIIR_IMMON          ((1 << 6))

#define RTC_AMR_CIIR_IMYEAR         ((1 << 7))

#define RTC_AMR_CIIR_BITMASK        ((0xFF))

#define RTC_AUX_RTC_OSCF        ((1 << 4))
#if defined(CHIP_LPC177X_8X) || defined(CHIP_LPC407X_8X)

#define RTC_AUX_RTC_PDOUT       ((1 << 6)) 
#endif

#define RTC_AUXEN_RTC_OSCFEN    ((1 << 4))

#define RTC_CTIME0_SECONDS_MASK     ((0x3F))
#define RTC_CTIME0_MINUTES_MASK     ((0x3F00))
#define RTC_CTIME0_HOURS_MASK       ((0x1F0000))
#define RTC_CTIME0_DOW_MASK         ((0x7000000))

#define RTC_CTIME1_DOM_MASK         ((0x1F))
#define RTC_CTIME1_MONTH_MASK       ((0xF00))
#define RTC_CTIME1_YEAR_MASK        ((0xFFF0000))

#define RTC_CTIME2_DOY_MASK         ((0xFFF))

#define RTC_SEC_MASK            (0x0000003F)

#define RTC_MIN_MASK            (0x0000003F)

#define RTC_HOUR_MASK           (0x0000001F)

#define RTC_DOM_MASK            (0x0000001F)

#define RTC_DOW_MASK            (0x00000007)

#define RTC_DOY_MASK            (0x000001FF)

#define RTC_MONTH_MASK          (0x0000000F)

#define RTC_YEAR_MASK           (0x00000FFF)

#define RTC_SECOND_MAX      59 
#define RTC_MINUTE_MAX      59 
#define RTC_HOUR_MAX        23 
#define RTC_MONTH_MIN       1 
#define RTC_MONTH_MAX       12 
#define RTC_DAYOFMONTH_MIN  1 
#define RTC_DAYOFMONTH_MAX  31 
#define RTC_DAYOFWEEK_MAX   6 
#define RTC_DAYOFYEAR_MIN   1 
#define RTC_DAYOFYEAR_MAX   366 
#define RTC_YEAR_MAX        4095
#define RTC_CALIBRATION_CALVAL_MASK     ((0x1FFFF))

#define RTC_CALIBRATION_LIBDIR          ((1 << 17))

#define RTC_CALIBRATION_MAX             ((0x20000))

#define RTC_CALIB_DIR_FORWARD           ((uint8_t) (0))
#define RTC_CALIB_DIR_BACKWARD          ((uint8_t) (1))

#if RTC_EV_SUPPORT

#define RTC_ERCTRL_BITMASK          ((uint32_t) 0xC0F03C0F)

#define RTC_ERCTRL_INTWAKE_EN       ((uint32_t) (1 << 0))

#define RTC_ERCTRL_GPCLEAR_EN       ((uint32_t) (1 << 1))

#define RTC_ERCTRL_POL_NEGATIVE     (0)  /* Event as positive edge */
#define RTC_ERCTRL_POL_POSITIVE     ((uint32_t) (1 << 2)) /* Event as negative edge */

#define RTC_ERCTRL_INPUT_EN         ((uint32_t) (1 << 3))

#define RTC_ERCTRL_CHANNEL_CONFIG_BITMASK(ch)   ((uint32_t) (0x0F << (10 * ch)))
#define RTC_ERCTRL_CHANNEL_CONFIG(ch, flag) ((uint32_t) (flag << (10 * ch)))

#define RTC_ERCTRL_MODE_MASK                (((uint32_t) 3) << 30)
#define RTC_ERCTRL_MODE_CLK_DISABLE         (((uint32_t) 0) << 30)
#define RTC_ERCTRL_MODE_16HZ                (((uint32_t) 1) << 30)
#define RTC_ERCTRL_MODE_64HZ                (((uint32_t) 2) << 30)
#define RTC_ERCTRL_MODE_1KHZ                (((uint32_t) 3) << 30)
#define RTC_ERCTRL_MODE(n)                  (((uint32_t) n) << 30)

#define RTC_ERSTATUS_CHANNEL_EV(ch)               ((uint32_t) (1 << ch))  /* At least 1 event has occurred on a specific channel */

#define RTC_ERSTATUS_GPCLEARED            ((uint32_t) (1 << 3))

#define RTC_ERSTATUS_WAKEUP            ((uint32_t) (((uint32_t) 1) << 31))

#define RTC_ER_COUNTER(ch, n)            ((uint32_t) ((n >> (8 * ch)) & 0x07))

#define RTC_ER_TIMESTAMP_SEC(n)             ((uint32_t) (n & 0x3F))
#define RTC_ER_TIMESTAMP_MIN(n)             ((uint32_t) ((n >> 6) & 0x3F))
#define RTC_ER_TIMESTAMP_HOUR(n)            ((uint32_t) ((n >> 12) & 0x1F))
#define RTC_ER_TIMESTAMP_DOY(n)             ((uint32_t) ((n >> 17) & 0x1FF))

typedef enum IP_RTC_EV_MODE {
 RTC_EV_MODE_DISABLE = 0,  
 RTC_EV_MODE_ENABLE_16HZ =  1, 
 RTC_EV_MODE_ENABLE_64HZ = 2, 
 RTC_EV_MODE_ENABLE_1KHZ = 3, 
 RTC_EV_MODE_LAST,
} IP_RTC_EV_MODE_T;

typedef struct {
 uint8_t     sec;  
 uint8_t     min;  
 uint8_t     hour;  
 uint16_t    dayofyear; 
} IP_RTC_EV_TIMESTAMP_T;

#endif /*RTC_EV_SUPPORT*/

typedef enum IP_RTC_INT_OPT {
 RTC_INT_COUNTER_INCREASE = RTC_IRL_RTCCIF, 
 RTC_INT_ALARM = RTC_IRL_RTCALF    
} IP_RTC_INT_OPT_T;

typedef struct {
 uint32_t time[RTC_TIMETYPE_LAST];
} IP_RTC_TIME_T;

void IP_RTC_Init(IP_RTC_001_T *pRTC);

STATIC INLINE void IP_RTC_DeInit(IP_RTC_001_T *pRTC)
{
 pRTC->CCR = 0x00;
}

void IP_RTC_ResetClockTickCounter(IP_RTC_001_T *pRTC);

void IP_RTC_Enable(IP_RTC_001_T *pRTC, FunctionalState NewState);

void IP_RTC_CntIncrIntConfig(IP_RTC_001_T *pRTC, uint32_t cntrMask, FunctionalState NewState);

void IP_RTC_AlarmIntConfig(IP_RTC_001_T *pRTC, uint32_t alarmMask, FunctionalState NewState);

void IP_RTC_SetTime(IP_RTC_001_T *pRTC, IP_RTC_TIMEINDEX_T Timetype, uint32_t TimeValue);

uint32_t IP_RTC_GetTime(IP_RTC_001_T *pRTC, IP_RTC_TIMEINDEX_T Timetype);

void IP_RTC_SetFullTime(IP_RTC_001_T *pRTC, IP_RTC_TIME_T *pFullTime);

void IP_RTC_GetFullTime(IP_RTC_001_T *pRTC, IP_RTC_TIME_T *pFullTime);

void IP_RTC_SetAlarmTime(IP_RTC_001_T *pRTC, IP_RTC_TIMEINDEX_T Timetype, uint32_t ALValue);

uint32_t IP_RTC_GetAlarmTime(IP_RTC_001_T *pRTC, IP_RTC_TIMEINDEX_T Timetype);

void IP_RTC_SetFullAlarmTime(IP_RTC_001_T *pRTC, IP_RTC_TIME_T *pFullTime);

void IP_RTC_GetFullAlarmTime(IP_RTC_001_T *pRTC, IP_RTC_TIME_T *pFullTime);

void IP_RTC_CalibCounterCmd(IP_RTC_001_T *pRTC, FunctionalState NewState);

void IP_RTC_CalibConfig(IP_RTC_001_T *pRTC, uint32_t CalibValue, uint8_t CalibDir);

STATIC INLINE void IP_RTC_ClearIntPending(IP_RTC_001_T *pRTC, uint32_t IntType)
{
 pRTC->ILR = IntType;
}

STATIC INLINE IntStatus IP_RTC_GetIntPending(IP_RTC_001_T *pRTC, uint32_t IntType)
{
 return (pRTC->ILR & IntType) ? SET : RESET;
}

#if RTC_EV_SUPPORT

STATIC INLINE void IP_RTC_EV_Config(IP_RTC_001_T *pRTC, IP_RTC_EV_CHANNEL_T ch, uint32_t flag)
{
 uint32_t temp;

 temp = pRTC->ERCONTROL & (~(RTC_ERCTRL_CHANNEL_CONFIG_BITMASK(ch))) & RTC_ERCTRL_BITMASK;
 pRTC->ERCONTROL = temp | (RTC_ERCTRL_CHANNEL_CONFIG(ch, flag) & RTC_ERCTRL_BITMASK);
}

STATIC INLINE void IP_RTC_EV_SetMode(IP_RTC_001_T *pRTC, IP_RTC_EV_MODE_T mode)
{
 uint32_t temp;

 temp = pRTC->ERCONTROL & (~RTC_ERCTRL_MODE_MASK) & RTC_ERCTRL_BITMASK;
 pRTC->ERCONTROL = temp | RTC_ERCTRL_MODE(mode);
}

STATIC INLINE uint32_t IP_RTC_EV_GetStatus(IP_RTC_001_T *pRTC)
{
 return pRTC->ERSTATUS & (RTC_ERSTATUS_GPCLEARED | RTC_ERSTATUS_WAKEUP);
}

STATIC INLINE void IP_RTC_EV_ClearStatus(IP_RTC_001_T *pRTC, uint32_t flag)
{
 pRTC->ERSTATUS = flag & (RTC_ERSTATUS_GPCLEARED | RTC_ERSTATUS_WAKEUP);
}

STATIC INLINE FlagStatus IP_RTC_EV_GetChannelStatus(IP_RTC_001_T *pRTC, IP_RTC_EV_CHANNEL_T ch)
{
 return (pRTC->ERSTATUS & RTC_ERSTATUS_CHANNEL_EV(ch)) ? SET : RESET;
}

STATIC INLINE void IP_RTC_EV_ClearChannelStatus(IP_RTC_001_T *pRTC, IP_RTC_EV_CHANNEL_T ch)
{
 pRTC->ERSTATUS = RTC_ERSTATUS_CHANNEL_EV(ch);
}

STATIC INLINE uint8_t IP_RTC_EV_GetCounter(IP_RTC_001_T *pRTC, IP_RTC_EV_CHANNEL_T ch)
{
 return RTC_ER_COUNTER(ch, pRTC->ERCOUNTERS);
}

void IP_RTC_EV_GetFirstTimeStamp(IP_RTC_001_T *pRTC, IP_RTC_EV_CHANNEL_T ch, IP_RTC_EV_TIMESTAMP_T *pTimeStamp);

void IP_RTC_EV_GetLastTimeStamp(IP_RTC_001_T *pRTC, IP_RTC_EV_CHANNEL_T ch, IP_RTC_EV_TIMESTAMP_T *pTimeStamp);

#endif /*RTC_EV_SUPPORT*/

#ifdef __cplusplus
}
#endif

#endif /* __RTC_001_H_ */