zhangzhaopeng
/
sdk-hwV1.3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
sdk-hwV1.3/lichee/xr806/appos/include/driver/chip/hal_rtc.h

338 lines
12 KiB
C
Executable File
Raw Blame History

/**
* @file hal_rtc.h
* @author XRADIO IOT WLAN Team
*/
/*
* Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of XRADIO TECHNOLOGY CO., LTD. nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _DRIVER_CHIP_HAL_RTC_H_
#define _DRIVER_CHIP_HAL_RTC_H_
#include "driver/chip/hal_def.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief RTC register block structure
*/
typedef struct {
__IO uint32_t CTRL; /* offset: 0x00, RTC control register */
uint32_t RESERVED0[3];
__IO uint32_t YYMMDD; /* offset: 0x10, RTC YYMMDD Register */
__IO uint32_t DDHHMMSS; /* offset: 0x14, RTC HHMMSS register */
uint32_t RESERVED1[2];
__IO uint32_t SEC_ALARM_LOAD_VAL; /* offset: 0x20, RTC second alarm load/interval value register */
__IO uint32_t SEC_ALARM_CUR_VAL; /* offset: 0x24, RTC second alarm current value register */
__IO uint32_t SEC_ALARM_EN; /* offset: 0x28, RTC second alarm enable register */
__IO uint32_t SEC_ALARM_IRQ_EN; /* offset: 0x2C, RTC second alarm IRQ enable register */
__IO uint32_t SEC_ALARM_IRQ_STATUS; /* offset: 0x30, RTC second alarm IRQ status register */
uint32_t RESERVED2[3];
__IO uint32_t WDAY_ALARM_HHMMSS; /* offset: 0x40, RTC week day alarm HHMMSS register */
__IO uint32_t WDAY_ALARM_WDAY_EN; /* offset: 0x44, RTC week day alarm enable register */
__IO uint32_t WDAY_ALARM_IRQ_EN; /* offset: 0x48, RTC week day alarm IRQ enable register */
__IO uint32_t WDAY_ALARM_IRQ_STATUS;/* offset: 0x4C, RTC week day alarm IRQ status register */
__IO uint32_t ALARM_WAKEUP_EN; /* offset: 0x50, RTC second and week day alarm wakeup register */
uint32_t RESERVED3[3];
__IO uint32_t FREERUN_CNT_L; /* offset: 0x60, Free running counter low register */
__IO uint32_t FREERUN_CNT_H; /* offset: 0x64, Free running counter high register */
} RTC_T;
#define RTC ((RTC_T *)RTC_BASE) /* address: 0x40041800*/
/*
* Bit field definition of RTC->CTRL
*/
#define RTC_TEST_MODE_BIT HAL_BIT(31)
#define RTC_SIMULATION_BIT HAL_BIT(30)
#define RTC_WDAY_ALARM_HHMMSS_ACCESS_BIT HAL_BIT(2)
#define RTC_DDHHMMSS_ACCESS_BIT HAL_BIT(1)
#define RTC_YYMMDD_ACCESS_BIT HAL_BIT(0)
/*
* Bit field definition of RTC->YYMMDD
*/
#define RTC_LEAP_YEAR_BIT HAL_BIT(24)
#define RTC_YEAR_SHIFT 16 /* R/W, [0, 255] */
#define RTC_YEAR_VMASK 0xFF
#define RTC_YEAR_MIN 0
#define RTC_YEAR_MAX 255
#define RTC_MONTH_SHIFT 8 /* R/W, [1, 12] */
#define RTC_MONTH_VMASK 0xF
#define RTC_MONTH_MIN 1
#define RTC_MONTH_MAX 12
#define RTC_MDAY_SHIFT 0 /* R/W, [1, 31] */
#define RTC_MDAY_VMASK 0x1F
#define RTC_MDAY_MIN 1
#define RTC_MDAY_MAX 31
/*
* Bit field definition of RTC->DDHHMMSS
*/
#define RTC_WDAY_SHIFT 29 /* R/W */
#define RTC_WDAY_VMASK 0x7
typedef enum {
RTC_WDAY_MONDAY = 0U,
RTC_WDAY_TUESDAY = 1U,
RTC_WDAY_WEDNESDAY = 2U,
RTC_WDAY_THURSDAY = 3U,
RTC_WDAY_FRIDAY = 4U,
RTC_WDAY_SATURDAY = 5U,
RTC_WDAY_SUNDAY = 6U
} RTC_WeekDay;
#define RTC_HOUR_SHIFT 16 /* R/W, [0, 23] */
#define RTC_HOUR_VMASK 0x1F
#define RTC_HOUR_MIN 0
#define RTC_HOUR_MAX 23
#define RTC_MINUTE_SHIFT 8 /* R/W, [0, 59] */
#define RTC_MINUTE_VMASK 0x3F
#define RTC_MINUTE_MIN 0
#define RTC_MINUTE_MAX 59
#define RTC_SECOND_SHIFT 0 /* R/W, [0, 59] */
#define RTC_SECOND_VMASK 0x3F
#define RTC_SECOND_MIN 0
#define RTC_SECOND_MAX 59
/* RTC->SEC_ALARM_LOAD_VAL */
/* RTC->SEC_ALARM_CUR_VAL */
/* RTC->SEC_ALARM_EN */
#define RTC_SEC_ALARM_EN_BIT HAL_BIT(0)
/* RTC->SEC_ALARM_IRQ_EN */
#define RTC_SEC_ALARM_IRQ_EN_BIT HAL_BIT(0)
/* RTC->SEC_ALARM_IRQ_STATUS */
#define RTC_SEC_ALARM_IRQ_PENDING_BIT HAL_BIT(0)
/* RTC->WDAY_ALARM_DDHHMMSS */
#define RTC_WDAY_ALARM_HOUR_SHIFT 16 /* R/W, [0, 23] */
#define RTC_WDAY_ALARM_HOUR_VMASK 0x1F
#define RTC_WDAY_ALARM_MINUTE_SHIFT 8 /* R/W, [0, 59] */
#define RTC_WDAY_ALARM_MINUTE_VMASK 0x3F
#define RTC_WDAY_ALARM_SECOND_SHIFT 0 /* R/W, [0, 59] */
#define RTC_WDAY_ALARM_SECOND_VMASK 0x3F
/* RTC->WDAY_ALARM_EN */
#define RTC_WDAY_ALARM_EN_BIT(wday) HAL_BIT(wday) /* day is RTC_WeekDay */
#define RTC_WDAY_ALARM_EN_MASK 0x7F
/* RTC->WDAY_ALARM_IRQ_EN */
#define RTC_WDAY_ALARM_IRQ_EN_BIT HAL_BIT(0)
/* RTC->WDAY_ALARM_IRQ_STATUS */
#define RTC_WDAY_ALARM_IRQ_PENDING_BIT HAL_BIT(0)
/* RTC->ALARM_WAKEUP_EN */
#define RTC_SEC_ALARM_WAKEUP_EN_BIT HAL_BIT(0)
#define RTC_WDAY_ALARM_WAKEUP_EN_BIT HAL_BIT(1)
/******************************************************************************/
/** @brief Type define of RTC alarm IRQ callback function */
typedef void (*RTC_AlarmIRQCallback) (void *arg);
/**
* @brief RTC second alarm starting parameters
*/
typedef struct {
uint32_t alarmSeconds; /* RTC second alarm's count down value */
RTC_AlarmIRQCallback callback; /* RTC second alarm IRQ callback function */
void *arg; /* Argument of RTC second alarm IRQ callback function */
} RTC_SecAlarmStartParam;
/**
* @brief RTC weekday alarm starting parameters
*/
typedef struct {
uint8_t alarmHour; /* RTC weekday alarm's hour, [0, 23] */
uint8_t alarmMinute; /* RTC weekday alarm's minute, [0, 59] */
uint8_t alarmSecond; /* RTC weekday alarm's second, [0, 59] */
uint8_t alarmWDayMask; /* RTC weekday alarm's weekday, bit mask of RTC_WDAY_ALARM_EN_BIT(RTC_WeekDay) */
RTC_AlarmIRQCallback callback; /* RTC weekday alarm IRQ callback function */
void *arg; /* Argument of RTC weekday alarm IRQ callback function */
} RTC_WDayAlarmStartParam;
/**
* @brief Set the RTC date, including leaf year flag, year, month and month day
* @param[in] isLeapYear Leap year flag set to the RTC.
* @arg !0 The year is a leap year
* @arg 0 The year is not a leap year
* @param[in] year Year set to the RTC, [0, 255]
* @param[in] month Month set to the RTC, [1, 12]
* @param[in] mday Month day set to the RTC, [1, 31]
* @return None
*
* @note The leap year flag is always set by the caller, but never changed after
* setting. So the leap year bit of the RTC maybe wrong.
* @note The value of year is not a real year, but year's offset relative to
* the base year defined by the caller.
* @note The correction of the combination of all the parameters is guaranteed
* by the caller.
*/
void HAL_RTC_SetYYMMDD(uint8_t isLeapYear, uint8_t year, uint8_t month, uint8_t mday);
/**
* @brief Set the RTC weekday and time including hour, minute and second
* @param[in] wday Weekday set to the RTC
* @param[in] hour Hour set to the RTC, [0, 23]
* @param[in] minute Minute set to the RTC, [0, 59]
* @param[in] second Second set to the RTC, [0, 59]
* @return None
*
* @note The correction of the weekday is guaranteed by the caller.
*/
void HAL_RTC_SetDDHHMMSS(RTC_WeekDay wday, uint8_t hour, uint8_t minute, uint8_t second);
void HAL_RTC_SetLeapYear(uint8_t isLeapYear);
/**
* @brief Get the RTC date, including leaf year flag, year, month and month day
* @param[out] isLeapYear The RTC's leap year flag. Don't use it because it
* maybe wrong.
* - 1 means the year is a leap year
* - 0 means the year is not a leap year
* @param[out] year The RTC's Year
* @param[out] month The RTC's Month
* @param[out] mday The RTC's Month day
* @return None
*
* @note Don't trust the RTC leap year flag, because it's never changed by the
* RTC hardware, and maybe wrong.
* @note The RTC's year is not a real year, but year offset relative to the
* base year defined by the caller.
*/
void HAL_RTC_GetYYMMDD(uint8_t *isLeapYear, uint8_t *year, uint8_t *month, uint8_t *mday);
/**
* @brief Get the RTC weekday and time including hour, minute and second
* @param[out] wday The RTC's Weekday
* @param[out] hour The RTC's hour
* @param[out] minute The RTC's minute
* @param[out] second The RTC's second
* @return None
*/
void HAL_RTC_GetDDHHMMSS(RTC_WeekDay *wday, uint8_t *hour, uint8_t *minute, uint8_t *second) ;
/**
* @brief Start the RTC second alarm once
*
* After starting, the RTC second alarm counts down from param->alarmSeconds
* to zero, and trigger interrupt when it reach zero. After alarming, the
* alarm stops automatically.
*
* @param[in] param Pointer to RTC_SecAlarmStartParam structure
* @return None
*
*/
void HAL_RTC_StartSecAlarm(const RTC_SecAlarmStartParam *param);
/**
* @brief Stop the RTC second alarm
* @return None
*/
void HAL_RTC_StopSecAlarm(void);
/**
* @brief Start the RTC weekday alarm
*
* After starting, the RTC weekday alarm will trigger interrupt when it reach
* the configured weekday time. After alarming, the alarm continues to running.
*
* @param[in] param Pointer to RTC_WDayAlarmStartParam structure
* @return None
*/
void HAL_RTC_StartWDayAlarm(const RTC_WDayAlarmStartParam *param);
/**
* @brief Stop the RTC weekday alarm
* @return None
*/
void HAL_RTC_StopWDayAlarm(void);
/**
* @brief Init the RTC module
* @return None
*/
void HAL_RTC_Init(void);
/**
* @brief Convert RTC's free running counts to time value (in microsecond)
* @param[in] cnt RTC's free running counts to be converted
* @return Time value (in microsecond) after converted
*/
uint64_t HAL_RTC_FreeRunCntToTime(uint64_t cnt);
/**
* @brief Convert time value (in microsecond) to RTC's Free running counts
* @param[in] us Time value (in microsecond) to be converted
* @return RTC's Free running counts after converted
*/
uint64_t HAL_RTC_FreeRunTimeToCnt(uint64_t us);
/**
* @brief Get The counts of the RTC's Free running counter
*
* Free running counter is a 48-bit counter which is driven by LFCLK and starts
* to count as soon as the system reset is released and the LFCLK is ready.
*
* @return The counts of RTC's Free running counter
*/
uint64_t HAL_RTC_GetFreeRunCnt(void);
/**
* @brief Get the time value (in microsecond) of the RTC's Free running counter
*
* Free running counter is a 48-bit counter which is driven by LFCLK and starts
* to count as soon as the system reset is released and the LFCLK is ready.
*
* The time unit of the counter is: (10^6 / LFCLK) us
*
* @return The time value (in microsecond) of the RTC's Free running counter.
* Its accuracy is about 32 us.
*/
uint64_t HAL_RTC_GetFreeRunTime(void);
#ifdef __cplusplus
}
#endif
#endif /* _DRIVER_CHIP_HAL_RTC_H_ */
Reference in New Issue View Git Blame Copy Permalink