AimBot/Chassis
14
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7260fe9fba44fa6bb2bee0041dd9a02c0dabb5dc
Chassis/libraries/sdk/ti/driverlib/dl_rtc_common.h
T
SkyLi b5be64b642 init:初始框架
2026-06-06 20:50:54 +08:00

3353 lines
111 KiB
C
Raw Blame History

/*
* Copyright (c) 2023, Texas Instruments Incorporated
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * 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.
*
* * Neither the name of Texas Instruments Incorporated 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 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 TfHEORY 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.
*/
/*!****************************************************************************
* @file dl_rtc_common.h
* @brief Real Time Clock A (RTC Common) Peripheral Interface
* @defgroup Common Real Time Clock (RTC_Common)
*
* @anchor ti_devices_msp_dl_rtc_common_Overview
* # Overview
* The RTC Common Driver Library allows full configuration of the MSPM0 RTC Common module.
* The real-time clock (RTC Common) module provides clock counters with calendar mode,
* a flexible programmable alarm, offset calibration, and a provision for
* temperature compensation. The module also provides a separate time stamp calendar
* capable of capturing a time stamp event upon loss of VDD or detection of a tamper event
* on a tamper I/O pin.
*
* <hr>
******************************************************************************
*/
/** @addtogroup RTC_Common
* @{
*/
#ifndef ti_dl_dl_rtc_common__include
#define ti_dl_dl_rtc_common__include
#include <stdbool.h>
#include <stdint.h>
#include <ti/devices/msp/msp.h>
#include <ti/driverlib/dl_common.h>
#if defined __MSPM0_HAS_RTC_A__ || defined __MSPM0_HAS_RTC_B__ || \
defined __MSPM0_HAS_RTC__ || defined(DOXYGEN__INCLUDE)
#ifdef __cplusplus
extern "C" {
#endif
/* clang-format off */
/** @addtogroup DL_RTC_COMMON_INTERRUPT
* @{
*/
/**
* @brief RTC Common alarm 1 interrupt
*/
#define DL_RTC_COMMON_INTERRUPT_CALENDAR_ALARM1 (RTC_CPU_INT_IMASK_RTCA1_SET)
/**
* @brief RTC Common alarm 2 interrupt
*/
#define DL_RTC_COMMON_INTERRUPT_CALENDAR_ALARM2 (RTC_CPU_INT_IMASK_RTCA2_SET)
/**
* @brief RTC Common prescaler 0 interrupt
*/
#define DL_RTC_COMMON_INTERRUPT_PRESCALER0 (RTC_CPU_INT_IMASK_RT0PS_SET)
/**
* @brief RTC Common prescaler 1 interrupt
*/
#define DL_RTC_COMMON_INTERRUPT_PRESCALER1 (RTC_CPU_INT_IMASK_RT1PS_SET)
#ifdef __MSPM0_HAS_RTC_A__
/**
* @brief RTC Common prescaler 2 interrupt
*/
#define DL_RTC_COMMON_INTERRUPT_PRESCALER2 (RTC_CPU_INT_IMASK_RT2PS_SET)
#endif
/**
* @brief RTC Common interval timer interrupt
*/
#define DL_RTC_COMMON_INTERRUPT_INTERVAL_ALARM (RTC_CPU_INT_IMASK_RTCTEV_SET)
/**
* @brief RTC Common ready interrupt
*/
#define DL_RTC_COMMON_INTERRUPT_READY (RTC_CPU_INT_IMASK_RTCRDY_SET)
#ifdef __MSPM0_HAS_RTC_A__
/**
* @brief RTC Time Stamp Event interrupt
*/
#define DL_RTC_COMMON_INTERRUPT_TSEVT (RTC_CPU_INT_IMASK_TSEVT_SET)
#endif
/** @}*/
/** @addtogroup DL_RTC_COMMON_EVENT
* @{
*/
/**
* @brief RTC Common alarm 1 event
*/
#define DL_RTC_COMMON_EVENT_CALENDAR_ALARM1 (RTC_GEN_EVENT_IMASK_RTCA1_SET)
/**
* @brief RTC Common alarm 2 event
*/
#define DL_RTC_COMMON_EVENT_CALENDAR_ALARM2 (RTC_GEN_EVENT_IMASK_RTCA2_SET)
/**
* @brief RTC Common prescaler 0 event
*/
#define DL_RTC_COMMON_EVENT_PRESCALER0 (RTC_GEN_EVENT_IMASK_RT0PS_SET)
/**
* @brief RTC Common prescaler 1 event
*/
#define DL_RTC_COMMON_EVENT_PRESCALER1 (RTC_GEN_EVENT_IMASK_RT1PS_SET)
#ifdef __MSPM0_HAS_RTC_A__
/**
* @brief RTC Common prescaler 2 event
*/
#define DL_RTC_COMMON_EVENT_PRESCALER2 (RTC_GEN_EVENT_IMASK_RT2PS_SET)
#endif
/**
* @brief RTC Common interval timer event
*/
#define DL_RTC_COMMON_EVENT_INTERVAL_ALARM (RTC_GEN_EVENT_IMASK_RTCTEV_SET)
/**
* @brief RTC Common ready event
*/
#define DL_RTC_COMMON_EVENT_READY (RTC_GEN_EVENT_IMASK_RTCRDY_SET)
#ifdef __MSPM0_HAS_RTC_A__
/**
* @brief RTC Common time stamp event
*/
#define DL_RTC_COMMON_EVENT_TSEVT (RTC_GEN_EVENT_IMASK_TSEVT_SET)
#endif
/** @}*/
#ifdef __MSPM0_HAS_RTC_A__
/** @addtogroup DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE
* @{
*/
/**
* @brief Tamper IO 0 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_0 (RTC_TSSTAT_TSTIOEVT0_SET)
/**
* @brief Tamper IO 1 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_1 (RTC_TSSTAT_TSTIOEVT1_SET)
/**
* @brief Tamper IO 2 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_2 (RTC_TSSTAT_TSTIOEVT2_SET)
/**
* @brief Tamper IO 3 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_3 (RTC_TSSTAT_TSTIOEVT3_SET)
/**
* @brief Tamper IO 4 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_4 (RTC_TSSTAT_TSTIOEV4_SET)
/**
* @brief Tamper IO 5 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_5 (RTC_TSSTAT_TSTIOEVT5_SET)
/**
* @brief Tamper IO 6 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_6 (RTC_TSSTAT_TSTIOEVT6_SET)
/**
* @brief Tamper IO 7 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_7 (RTC_TSSTAT_TSTIOEVT7_SET)
/**
* @brief Tamper IO 8 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_8 (RTC_TSSTAT_TSTIOEV8_SET)
/**
* @brief Tamper IO 9 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_9 (RTC_TSSTAT_TSTIOEVT9_SET)
/**
* @brief Tamper IO 10 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_10 (RTC_TSSTAT_TSTIOEVT10_SET)
/**
* @brief Tamper IO 11 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_11 (RTC_TSSTAT_TSTIOEVT11_SET)
/**
* @brief Tamper IO 12 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_12 (RTC_TSSTAT_TSTIOEVT12_SET)
/**
* @brief Tamper IO 13 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_13 (RTC_TSSTAT_TSTIOEVT13_SET)
/**
* @brief Tamper IO 14 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_14 (RTC_TSSTAT_TSTIOEVT14_SET)
/**
* @brief Tamper IO 15 caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_TIO_15 (RTC_TSSTAT_TSTIOEVT15_SET)
/**
* @brief Loss of VDD caused the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE_VDD_LOSS (RTC_TSSTAT_TSVDDEVT_SET)
/** @}*/
/** @addtogroup DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE
* @{
*/
/**
* @brief Enable Tamper IO 0 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_0 (RTC_TSCTL_TSTIOEN0_ENABLE)
/**
* @brief Enable Tamper IO 1 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_1 (RTC_TSCTL_TSTIOEN1_ENABLE)
/**
* @brief Enable Tamper IO 2 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_2 (RTC_TSCTL_TSTIOEN2_ENABLE)
/**
* @brief Enable Tamper IO 3 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_3 (RTC_TSCTL_TSTIOEN3_ENABLE)
/**
* @brief Enable Tamper IO 4 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_4 (RTC_TSCTL_TSTIOEN4_ENABLE)
/**
* @brief Enable Tamper IO 5 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_5 (RTC_TSCTL_TSTIOEN5_ENABLE)
/**
* @brief Enable Tamper IO 6 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_6 (RTC_TSCTL_TSTIOEN6_ENABLE)
/**
* @brief Enable Tamper IO 7 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_7 (RTC_TSCTL_TSTIOEN8_ENABLE)
/**
* @brief Enable Tamper IO 8 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_8 (RTC_TSCTL_TSTIOEN8_ENABLE)
/**
* @brief Enable Tamper IO 9 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_9 (RTC_TSCTL_TSTIOEN9_ENABLE)
/**
* @brief Enable Tamper IO 10 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_10 (RTC_TSCTL_TSTIOEN10_ENABLE)
/**
* @brief Enable Tamper IO 11 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_11 (RTC_TSCTL_TSTIOEN11_ENABLE)
/**
* @brief Enable Tamper IO 12 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_12 (RTC_TSCTL_TSTIOEN12_ENABLE)
/**
* @brief Enable Tamper IO 13 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_13 (RTC_TSCTL_TSTIOEN13_ENABLE)
/**
* @brief Enable Tamper IO 14 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_14 (RTC_TSCTL_TSTIOEN14_ENABLE)
/**
* @brief Enable Tamper IO 15 as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_TIO_15 (RTC_TSCTL_TSTIOEN15_ENABLE)
/**
* @brief Enable VDD loss detection as a source to trigger the time stamp event
*/
#define DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE_VDD_LOSS (RTC_TSCTL_TSVDDEN_ENABLE)
/** @}*/
#endif
/*! @enum DL_RTC_COMMON_STATUS */
typedef enum {
/*! RTC Common is safe for reading */
DL_RTC_COMMON_STATUS_READY = RTC_STA_RTCRDY_READY,
/*! RTC Common is not safe for reading */
DL_RTC_COMMON_STATUS_NOT_READY = RTC_STA_RTCRDY_NOT_READY
} DL_RTC_COMMON_STATUS;
/*! @enum DL_RTC_COMMON_COMPENSATION_STATUS */
typedef enum {
/*! RTC Common ready to get new compensation values */
DL_RTC_COMMON_COMPENSATION_STATUS_READY = RTC_STA_RTCTCRDY_READY,
/*! RTC Common not ready to get new compensaiton values */
DL_RTC_COMMON_COMPENSATION_STATUS_NOT_READY = RTC_STA_RTCTCRDY_NOT_READY
} DL_RTC_COMMON_COMPENSATION_STATUS;
/*! @enum DL_RTC_COMMON_COMPENSATION_WRITE_RESULT */
typedef enum {
/*! Compensation write successful */
DL_RTC_COMMON_COMPENSATION_WRITE_RESULT_OK = RTC_STA_RTCTCOK_OK,
/*! Compensation write unsuccessful */
DL_RTC_COMMON_COMPENSATION_WRITE_RESULT_NOT_OK = RTC_STA_RTCTCOK_NOT_OK
} DL_RTC_COMMON_COMPENSATION_WRITE_RESULT;
/*! @enum DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN */
typedef enum {
/*! Calibration frequency adjusted down */
DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN_DOWN = RTC_CAL_RTCOCALS_DOWN,
/*! Calibration frequency adjusted up */
DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN_UP = RTC_CAL_RTCOCALS_UP
} DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN;
/*! @enum DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY */
typedef enum {
#ifdef __MSPM0_HAS_RTC__
/*! No frequency output to RTCCLK pin */
DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY_OFF = RTC_CAL_RTCCALFX_OFF,
#endif
#ifdef __MSPM0_HAS_RTC_A__
/*! 32 kHz frequency output to RTCLK pin */
DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY_32_KHZ = LFSS_CAL_RTCCALFX_F32KHZ,
#endif
/*! 512 Hz frequency output to RTCLK pin */
DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY_512 = RTC_CAL_RTCCALFX_F512HZ,
/*! 256 Hz frequency output to RTCLK pin */
DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY_256 = RTC_CAL_RTCCALFX_F256HZ,
/*! 1 Hz frequency output to RTCLK pin */
DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY_1 = RTC_CAL_RTCCALFX_F1HZ
} DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY;
/*! @enum DL_RTC_COMMON_TEMP_CALIBRATION */
typedef enum {
/*! Calibrate at steps of -1 */
DL_RTC_COMMON_TEMP_CALIBRATION_DOWN1PPM = RTC_TCMP_RTCTCMPS_DOWN,
/*! Calibrate at steps of +1 */
DL_RTC_COMMON_TEMP_CALIBRATION_UP1PPM = RTC_TCMP_RTCTCMPS_UP
} DL_RTC_COMMON_TEMP_CALIBRATION;
/*! @enum DL_RTC_COMMON_FORMAT */
typedef enum {
/*! Select binary format for the real-time clock */
DL_RTC_COMMON_FORMAT_BINARY = RTC_CTL_RTCBCD_BINARY,
/*! Select BCD format for the real-time clock */
DL_RTC_COMMON_FORMAT_BCD = RTC_CTL_RTCBCD_BCD
} DL_RTC_COMMON_FORMAT;
/*! @enum DL_RTC_COMMON_INTERVAL_ALARM */
typedef enum {
/*! Assert Calendar interrupt on every minute */
DL_RTC_COMMON_INTERVAL_ALARM_MINUTECHANGE = RTC_CTL_RTCTEVTX_MINUTE,
/*! Assert Calendar interrupt on every hour */
DL_RTC_COMMON_INTERVAL_ALARM_HOURCHANGE = RTC_CTL_RTCTEVTX_HOUR,
/*! Assert Calendar interrupt when hour is 12 */
DL_RTC_COMMON_INTERVAL_ALARM_NOON = RTC_CTL_RTCTEVTX_NOON,
/*! Assert Calendar interrupt when hour is 0 */
DL_RTC_COMMON_INTERVAL_ALARM_MIDNIGHT = RTC_CTL_RTCTEVTX_MIDNIGHT
} DL_RTC_COMMON_INTERVAL_ALARM;
/*! @enum DL_RTC_COMMON_PRESCALER0_DIVIDE */
typedef enum {
/*! Prescaler 0 Divide by 8 */
DL_RTC_COMMON_PRESCALER0_DIVIDE_8 = RTC_PSCTL_RT0IP_DIV8,
/*! Prescaler 0 Divide by 16 */
DL_RTC_COMMON_PRESCALER0_DIVIDE_16 = RTC_PSCTL_RT0IP_DIV16,
/*! Prescaler 0 Divide by 32 */
DL_RTC_COMMON_PRESCALER0_DIVIDE_32 = RTC_PSCTL_RT0IP_DIV32,
/*! Prescaler 0 Divide by 64 */
DL_RTC_COMMON_PRESCALER0_DIVIDE_64 = RTC_PSCTL_RT0IP_DIV64,
/*! Prescaler 0 Divide by 128 */
DL_RTC_COMMON_PRESCALER0_DIVIDE_128 = RTC_PSCTL_RT0IP_DIV128,
/*! Prescaler 0 Divide by 256 */
DL_RTC_COMMON_PRESCALER0_DIVIDE_256 = RTC_PSCTL_RT0IP_DIV256
} DL_RTC_COMMON_PRESCALER0_DIVIDE;
/*! @enum DL_RTC_COMMON_PRESCALER1_DIVIDE */
typedef enum {
/*! Prescaler 1 Divide by 2 */
DL_RTC_COMMON_PRESCALER1_DIVIDE_2 = RTC_PSCTL_RT1IP_DIV2,
/*! Prescaler 1 Divide by 4 */
DL_RTC_COMMON_PRESCALER1_DIVIDE_4 = RTC_PSCTL_RT1IP_DIV4,
/*! Prescaler 1 Divide by 8 */
DL_RTC_COMMON_PRESCALER1_DIVIDE_8 = RTC_PSCTL_RT1IP_DIV8,
/*! Prescaler 1 Divide by 16 */
DL_RTC_COMMON_PRESCALER1_DIVIDE_16 = RTC_PSCTL_RT1IP_DIV16,
/*! Prescaler 1 Divide by 32 */
DL_RTC_COMMON_PRESCALER1_DIVIDE_32 = RTC_PSCTL_RT1IP_DIV32,
/*! Prescaler 1 Divide by 64 */
DL_RTC_COMMON_PRESCALER1_DIVIDE_64 = RTC_PSCTL_RT1IP_DIV64,
/*! Prescaler 1 Divide by 128 */
DL_RTC_COMMON_PRESCALER1_DIVIDE_128 = RTC_PSCTL_RT1IP_DIV128,
/*! Prescaler 1 Divide by 256 */
DL_RTC_COMMON_PRESCALER1_DIVIDE_256 = RTC_PSCTL_RT1IP_DIV256
} DL_RTC_COMMON_PRESCALER1_DIVIDE;
/*! @enum DL_RTC_COMMON_PRESCALER2_DIVIDE */
typedef enum {
/*! Interval every 4 seconds */
DL_RTC_COMMON_PRESCALER2_4_SEC = RTC_EXTPSCTL_RT2PS_INT4S,
/*! Interval every 8 seconds */
DL_RTC_COMMON_PRESCALER2_8_SEC = RTC_EXTPSCTL_RT2PS_INT8S,
/*! Interval every 16 seconds */
DL_RTC_COMMON_PRESCALER2_16_SEC = RTC_EXTPSCTL_RT2PS_INT16S
} DL_RTC_COMMON_PRESCALER2_DIVIDE;
/*! @enum DL_RTC_COMMON_IIDX */
typedef enum {
/*! RTC Common interrupt index for alarm 1 */
DL_RTC_COMMON_IIDX_ALARM1 = RTC_CPU_INT_IIDX_STAT_RTCA1,
/*! RTC Common interrupt index for alarm 2 */
DL_RTC_COMMON_IIDX_ALARM2 = RTC_CPU_INT_IIDX_STAT_RTCA2,
/*! RTC Common interrupt index for prescaler 0 */
DL_RTC_COMMON_IIDX_PRESCALER0 = RTC_CPU_INT_IIDX_STAT_RT0PS,
/*! RTC Common interrupt index for prescaler 1 */
DL_RTC_COMMON_IIDX_PRESCALER1 = RTC_CPU_INT_IIDX_STAT_RT1PS,
/*! RTC Common interrupt index for prescaler 2 */
DL_RTC_COMMON_IIDX_PRESCALER2 = RTC_CPU_INT_IIDX_STAT_RT2PS,
/*! RTC Common interrupt index for interval timer */
DL_RTC_COMMON_IIDX_INTERVAL_TIMER = RTC_CPU_INT_IIDX_STAT_RTCTEV,
/*! RTC Common interrupt index for RTC Common ready */
DL_RTC_COMMON_IIDX_READY = RTC_CPU_INT_IIDX_STAT_RTCRDY,
/*! RTC Common interrupt index for Time Stamp */
#ifdef __MSPM0_HAS_RTC_A__
DL_RTC_COMMON_IIDX_TSEVT = RTC_CPU_INT_IIDX_STAT_TSEVT,
/*! RTC Common interrupt index for Tamper IO 0 */
DL_RTC_COMMON_IIDX_TAMPER_IO_0 = RTC_CPU_INT_IIDX_STAT_TIO0,
/*! RTC Common interrupt index for Tamper IO 1 */
DL_RTC_COMMON_IIDX_TAMPER_IO_1 = RTC_CPU_INT_IIDX_STAT_TIO1,
/*! RTC Common interrupt index for Tamper IO 2 */
DL_RTC_COMMON_IIDX_TAMPER_IO_2 = RTC_CPU_INT_IIDX_STAT_TIO2,
/*! RTC Common interrupt index for Tamper IO 3 */
DL_RTC_COMMON_IIDX_TAMPER_IO_3 = RTC_CPU_INT_IIDX_STAT_TIO3,
/*! RTC Common interrupt index for Tamper IO 4 */
DL_RTC_COMMON_IIDX_TAMPER_IO_4 = RTC_CPU_INT_IIDX_STAT_TIO4,
/*! RTC Common interrupt index for Tamper IO 5 */
DL_RTC_COMMON_IIDX_TAMPER_IO_5 = RTC_CPU_INT_IIDX_STAT_TIO5,
/*! RTC Common interrupt index for Tamper IO 6 */
DL_RTC_COMMON_IIDX_TAMPER_IO_6 = RTC_CPU_INT_IIDX_STAT_TIO6,
/*! RTC Common interrupt index for Tamper IO 7 */
DL_RTC_COMMON_IIDX_TAMPER_IO_7 = RTC_CPU_INT_IIDX_STAT_TIO7,
/*! RTC Common interrupt index for Tamper IO 8 */
DL_RTC_COMMON_IIDX_TAMPER_IO_8 = RTC_CPU_INT_IIDX_STAT_TIO8,
/*! RTC Common interrupt index for Tamper IO 9 */
DL_RTC_COMMON_IIDX_TAMPER_IO_9 = RTC_CPU_INT_IIDX_STAT_TIO9,
/*! RTC Common interrupt index for Tamper IO 10 */
DL_RTC_COMMON_IIDX_TAMPER_IO_10 = RTC_CPU_INT_IIDX_STAT_TIO10,
/*! RTC Common interrupt index for Tamper IO 11 */
DL_RTC_COMMON_IIDX_TAMPER_IO_11 = RTC_CPU_INT_IIDX_STAT_TIO11,
/*! RTC Common interrupt index for Tamper IO 12 */
DL_RTC_COMMON_IIDX_TAMPER_IO_12 = RTC_CPU_INT_IIDX_STAT_TIO12,
/*! RTC Common interrupt index for Tamper IO 13 */
DL_RTC_COMMON_IIDX_TAMPER_IO_13 = RTC_CPU_INT_IIDX_STAT_TIO13,
/*! RTC Common interrupt index for Tamper IO 14 */
DL_RTC_COMMON_IIDX_TAMPER_IO_14 = RTC_CPU_INT_IIDX_STAT_TIO14,
/*! RTC Common interrupt index for Tamper IO 15 */
DL_RTC_COMMON_IIDX_TAMPER_IO_15 = RTC_CPU_INT_IIDX_STAT_TIO15,
#endif
} DL_RTC_COMMON_IIDX;
#ifdef __MSPM0_HAS_RTC_A__
/*! @enum DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE */
typedef enum {
/*! Time stamp holds RTC capture at first occurrence of time stamp event */
DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE_FIRST = RTC_TSCTL_TSCAPTURE_FIRST,
/*! Time stamp holds RTC capture at last occurrence of time stamp event */
DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE_LAST = RTC_TSCTL_TSCAPTURE_LAST,
} DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE;
#endif
/* clang-format on */
/**
* @brief Alarm struct to use in DL_RTC_Common_setCalendarAlarm
*
* @note All struct values must be in the same format (Binary OR BCD).
* RTC Common format is set during initialization.
*/
typedef struct {
/** The minute to set the Alarm time to. Valid values are 0-59 in Binary
* format OR 0x0-0x59 in BCD format. */
uint8_t minutes;
/** The hour to set the Alarm time to. Valid values are 0-23 in Binary
* format OR 0x0-0x23 in BCD format. */
uint8_t hours;
/** The day of the week to set the Alarm time to. Valid values are 0-6
* in Binary format OR 0x0-0x6 in BCD format. */
uint8_t dayOfWeek;
/** The day of the month to set the Alarm time to. Valid values are 1-31
* in Binary format OR 0x1-0x31 in BCD format. */
uint8_t dayOfMonth;
} DL_RTC_Common_CalendarAlarm;
/**
* @brief Calendar struct to use in DL_RTC_Common_initCalendar()
*
* @note All struct values must be in the same format (Binary OR BCD).
* RTC Common format is set during initialization.
*/
typedef struct {
/** The second to set the Calendar time to. Valid values are 0-59 in Binary
* format OR 0x0-0x59 in BCD format. */
uint8_t seconds;
/** The minute to set the Calendar time to. Valid values are 0-59 in Binary
* format OR 0x0-0x59 in BCD format. */
uint8_t minutes;
/** The hour to set the Calendar time to. Valid values are 0-23 in Binary
* format OR 0x0-0x23 in BCD format. */
uint8_t hours;
/** The day of the week to set the Calendar time to. Valid values are 0-6
* in Binary format OR 0x0-0x6 in BCD format. */
uint8_t dayOfWeek;
/** The day of the month to set the Calendar time to. Valid values are 1-31
* in Binary format OR 0x1-0x31 in BCD format. */
uint8_t dayOfMonth;
/** The month to set the Calendar time to. Valid values are 1-12 in Binary
* format OR 0x1-0x12 in BCD format. */
uint8_t month;
/** The year to set the Calendar time to. Valid values are 0-4095 in Binary
* format OR 0x0-0x4095 in BCD format. */
uint16_t year;
} DL_RTC_Common_Calendar;
/**
* @brief Returns if LFCLK is selected as clock source
*
* If the LFCLK is enabled, the RTC Common module will select it as the clock source.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return true If LFCLK is selected as the clock source
* @return false If LFCLK is not selected as the clock source
*/
__STATIC_INLINE bool DL_RTC_Common_isClockSourceLFCLK(
const RTC_Regs *rtc_common)
{
return ((rtc_common->CLKSEL & RTC_CLKSEL_LFCLK_SEL_MASK) ==
RTC_CLKSEL_LFCLK_SEL_MASK);
}
/**
* @brief Enables the supply of the 32kHz clock to the RTC Common. It will not
* power up the 32kHz crystal oscillator. This needs to be done
* in the Clock System Module.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*/
__STATIC_INLINE void DL_RTC_Common_enableClockControl(RTC_Regs *rtc_common)
{
rtc_common->CLKCTL = RTC_CLKCTL_MODCLKEN_ENABLE;
}
/**
* @brief Disables the supply of the 32kHz clock to the RTC Common.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*/
__STATIC_INLINE void DL_RTC_Common_disableClockControl(RTC_Regs *rtc_common)
{
rtc_common->CLKCTL = RTC_CLKCTL_MODCLKEN_DISABLE;
}
/**
* @brief Enables the Peripheral Write Enable (PWREN) register for the RTC
*
* Before any peripheral registers can be configured by software, the
* peripheral itself must be enabled by writing the ENABLE bit together with
* the appropriate KEY value to the peripheral's PWREN register.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*/
__STATIC_INLINE void DL_RTC_Common_enablePower(RTC_Regs *rtc_common)
{
rtc_common->GPRCM.PWREN =
(RTC_PWREN_KEY_UNLOCK_W | RTC_PWREN_ENABLE_ENABLE);
}
/**
* @brief Disables the Peripheral Write Enable (PWREN) register for the RTC
*
* When the PWREN.ENABLE bit is cleared, the peripheral's registers are not
* accessible for read/write operations.
*
* @note This API does not provide large power savings.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*/
__STATIC_INLINE void DL_RTC_Common_disablePower(RTC_Regs *rtc_common)
{
rtc_common->GPRCM.PWREN =
(RTC_PWREN_KEY_UNLOCK_W | RTC_PWREN_ENABLE_DISABLE);
}
/**
* @brief Returns if the Peripheral Write Enable (PWREN) register for the RTC
* is enabled
*
* Before any peripheral registers can be configured by software, the
* peripheral itself must be enabled by writing the ENABLE bit together with
* the appropriate KEY value to the peripheral's PWREN register.
*
* When the PWREN.ENABLE bit is cleared, the peripheral's registers are not
* accessible for read/write operations.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return true if peripheral register access is enabled
* @return false if peripheral register access is disabled
*/
__STATIC_INLINE bool DL_RTC_Common_isPowerEnabled(const RTC_Regs *rtc_common)
{
return ((rtc_common->GPRCM.PWREN & RTC_PWREN_ENABLE_MASK) ==
RTC_PWREN_ENABLE_ENABLE);
}
/**
* @brief Resets all registers in the RTC Common module.
*
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*/
__STATIC_INLINE void DL_RTC_Common_reset(RTC_Regs *rtc_common)
{
rtc_common->GPRCM.RSTCTL =
(RTC_RSTCTL_KEY_UNLOCK_W | RTC_RSTCTL_RESETSTKYCLR_CLR |
RTC_RSTCTL_RESETASSERT_ASSERT);
}
/**
* @brief Returns if the RTC Common module was reset
*
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return true if module was reset
* @return false if module was not reset
*/
__STATIC_INLINE bool DL_RTC_Common_isReset(const RTC_Regs *rtc_common)
{
return ((rtc_common->GPRCM.STAT & RTC_STAT_RESETSTKY_MASK) ==
RTC_STAT_RESETSTKY_RESET);
}
/**
* @brief Enables interrupts when the CPU is in debug mode. Interrupt
* requests are signaled to the interrupt controller.
*
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*/
__STATIC_INLINE void DL_RTC_Common_enableDebugInterrupts(RTC_Regs *rtc_common)
{
rtc_common->DBGCTL |= RTC_DBGCTL_DBGINT_ON;
}
/**
* @brief Disables interrupts when the CPU is in debug mode. Interrupts
* of the RTC Common module will not be captured. There will be no
* updates to the RTCRIS, RTCMISC and RTCIIDX registers.
*
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*/
__STATIC_INLINE void DL_RTC_Common_disableDebugInterrupts(RTC_Regs *rtc_common)
{
rtc_common->DBGCTL &= ~(RTC_DBGCTL_DBGINT_MASK);
}
/**
* @brief Enables the RTC Common modules debug mode.
*
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*/
__STATIC_INLINE void DL_RTC_Common_enableDebugMode(RTC_Regs *rtc_common)
{
rtc_common->DBGCTL |= RTC_DBGCTL_DBGRUN_RUN;
}
/**
* @brief Disables the RTC Common modules debug mode.
*
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*/
__STATIC_INLINE void DL_RTC_Common_disableDebugMode(RTC_Regs *rtc_common)
{
rtc_common->DBGCTL &= ~(RTC_DBGCTL_DBGRUN_MASK);
}
/**
* @brief Set the format of the real-time clock
*
* The format must be selected before the time is set.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] formatSelect Selectable format the RTC Common peripheral will
* provide time in. One of @ref DL_RTC_COMMON_FORMAT
*/
__STATIC_INLINE void DL_RTC_Common_setClockFormat(
RTC_Regs *rtc_common, DL_RTC_COMMON_FORMAT formatSelect)
{
rtc_common->CTL |= (uint32_t) formatSelect;
}
/**
* @brief Get the format currently being used for counting the
* real-time clock.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return Format for counting the real-time clock.
*
* @retval One of @ref DL_RTC_COMMON_FORMAT
*/
__STATIC_INLINE DL_RTC_COMMON_FORMAT DL_RTC_Common_getClockFormat(
const RTC_Regs *rtc_common)
{
uint32_t format = (rtc_common->CTL & RTC_CTL_RTCBCD_MASK);
return (DL_RTC_COMMON_FORMAT)(format);
}
/**
* @brief Sets the interval alarm event condition
*
* The interval alarm can be configured to generate an interval alarm event
* when one of the following events occurs:
* - MIN changes
* - HOUR changes
* - Every day at midnight (00:00:00)
* - Every day at noon (12:00:00)
*
* The interval alarm sources the @ref DL_RTC_COMMON_INTERRUPT_INTERVAL_ALARM interrupt
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] alarmEvent The interval alarm interrupt condition. One of
* @ref DL_RTC_COMMON_INTERVAL_ALARM
*/
__STATIC_INLINE void DL_RTC_Common_setIntervalAlarm(
RTC_Regs *rtc_common, DL_RTC_COMMON_INTERVAL_ALARM alarmEvent)
{
DL_Common_updateReg(
&rtc_common->CTL, (uint32_t) alarmEvent, RTC_CTL_RTCTEVTX_MASK);
}
/**
* @brief Gets the interval alarm event condition
*
* The interval alarm can be configured to generate an interval alarm event
* when one of the following events occurs:
* - MIN changes
* - HOUR changes
* - Every day at midnight (00:00:00)
* - Every day at noon (12:00:00)
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return DL_RTC_COMMON_INTERVAL_ALARM
*/
__STATIC_INLINE DL_RTC_COMMON_INTERVAL_ALARM DL_RTC_Common_getIntervalAlarm(
const RTC_Regs *rtc_common)
{
uint32_t alarm = (rtc_common->CTL & RTC_CTL_RTCTEVTX_MASK);
return (DL_RTC_COMMON_INTERVAL_ALARM)(alarm);
}
/**
* @brief Checks if RTC Common is safe for reading
*
* This API checks if the counter/calender registers can be safely read.
*
* The RTC Common counter/calendar registers are updated once per second. To prevent
* reading any counter/calendar register at the time of an update (which could
* result in an invalid time being read), a keep-out window is provided. The
* keep-out window is approximately 128/32768 seconds before the counters
* update.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return true if RTC Common is safe for reading
* @return false if RTC Common values are in transition
*
*/
__STATIC_INLINE bool DL_RTC_Common_isSafeToRead(const RTC_Regs *rtc_common)
{
return ((rtc_common->STA & RTC_STA_RTCRDY_MASK) == RTC_STA_RTCRDY_READY);
}
/**
* @brief Checks if RTC Common is ready to get new calibration values
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return true if RTC Common can get new calibration values
* @return false if RTC Common is not ready to get new calibration values
*
*/
__STATIC_INLINE bool DL_RTC_Common_isReadyToCalibrate(
const RTC_Regs *rtc_common)
{
return (
(rtc_common->STA & RTC_STA_RTCTCRDY_MASK) == RTC_STA_RTCTCRDY_READY);
}
/**
* @brief Checks if RTC Common new calibration values were written OK
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return true if calibration write was successful
* @return false if calibration write was unsuccessful
*
*/
__STATIC_INLINE bool DL_RTC_Common_isCalibrationWriteResultOK(
const RTC_Regs *rtc_common)
{
return ((rtc_common->STA & RTC_STA_RTCTCOK_MASK) == RTC_STA_RTCTCOK_OK);
}
/**
* @brief Sets output frequency for offset calibration
*
* Sets the frequency output to RTC_OUT pin for calibration measurement.
* The corresponding port must be configured for the peripheral module
* function.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] offsetFrequency The frequency of offset calibration.
* Valid values are one of
* @ref DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY
*/
__STATIC_INLINE void DL_RTC_Common_setOffsetCalibrationFrequency(
RTC_Regs *rtc_common,
DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY offsetFrequency)
{
DL_Common_updateReg(
&rtc_common->CAL, (uint32_t) offsetFrequency, RTC_CAL_RTCCALFX_MASK);
}
/**
* @brief Sets the offset error calibration adjustment value.
*
* Each LSB represents approximately +1ppm (RTCOCALXS = 1) or
* -1ppm (RTCOCALXS = 0) adjustment in frequency. Maximum effective calibration
* value is +/-240ppm.
* Excess values written above +/-240ppm will be ignored by hardware.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] offsetSign The sign of offset calibration.
* Valid values are one of
* @ref DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN
* @param[in] offsetValue The value that the offset will be a factor of.
* Must be any integer from 1-240.
*/
__STATIC_INLINE void DL_RTC_Common_setOffsetCalibrationAdjValue(
RTC_Regs *rtc_common, DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN offsetSign,
uint8_t offsetValue)
{
DL_Common_updateReg(&rtc_common->CAL,
((uint32_t) offsetSign | (uint32_t) offsetValue),
(RTC_CAL_RTCOCALX_MASK | RTC_CAL_RTCOCALS_MASK));
}
/**
* @brief Sets the offset error calibration.
*
* Each LSB represents approximately +1ppm (RTCOCALXS = 1) or
* -1ppm (RTCOCALXS = 0) adjustment in frequency. Maximum effective calibration
* value is +/-240ppm.
* Excess values written above +/-240ppm will be ignored by hardware.
*
* Sets the frequency output to RTCCLK pin for calibration measurement.
* The corresponding port must be configured for the peripheral module
* function.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] offsetFrequency The frequency of offset calibration.
* Valid values are one of
* @ref DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY
* @param[in] offsetSign The sign of offset calibration.
* Valid values are one of
* @ref DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN
* @param[in] offsetValue The value that the offset will be a factor of.
* Must be any integer from 1-240.
*/
__STATIC_INLINE void DL_RTC_Common_setOffsetCalibration(RTC_Regs *rtc_common,
DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY offsetFrequency,
DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN offsetSign, uint8_t offsetValue)
{
rtc_common->CAL = (offsetValue & RTC_CAL_RTCOCALX_MASK) |
(uint32_t) offsetFrequency | (uint32_t) offsetSign;
}
/**
* @brief Gets the offset calibration frequency.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return Frequency used in offset calibration.
*
* @retval One of @ref DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY
*/
__STATIC_INLINE DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY
DL_RTC_Common_getOffsetCalibrationFrequency(const RTC_Regs *rtc_common)
{
uint32_t freq = (rtc_common->CAL & RTC_CAL_RTCCALFX_MASK);
return (DL_RTC_COMMON_OFFSET_CALIBRATION_FREQUENCY)(freq);
}
/**
* @brief Gets the offset calibration sign.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return Sign used in offset calibration.
*
* @retval One of @ref DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN
*/
__STATIC_INLINE DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN
DL_RTC_Common_getOffsetCalibrationSign(const RTC_Regs *rtc_common)
{
uint32_t sign = (rtc_common->CAL & RTC_CAL_RTCOCALS_MASK);
return (DL_RTC_COMMON_OFFSET_CALIBRATION_SIGN)(sign);
}
/**
* @brief Set the specified RTC Common temperature compensation.
*
* This function sets the calibration offset to make the RTC Common as accurate as
* possible. The offsetDirection can be either +1-ppm or -1-ppm, and the
* offsetValue should be from 1-240 and is multiplied by the direction setting
* (i.e. +1-ppm * 8 (offsetValue) = +8-ppm).
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common
* peripheral
* @param[in] offsetDirection The direction that the calibration offset
* will go. Valid values are one of
* @ref DL_RTC_COMMON_TEMP_CALIBRATION
* @param[in] offsetValue The value that the offset will be a factor of.
* Must be any integer from 1-240.
*/
__STATIC_INLINE void DL_RTC_Common_setTemperatureCompensation(
RTC_Regs *rtc_common, DL_RTC_COMMON_TEMP_CALIBRATION offsetDirection,
uint32_t offsetValue)
{
rtc_common->TCMP =
(offsetValue & RTC_TCMP_RTCTCMPX_MASK) | (uint32_t) offsetDirection;
}
/**
* @brief Get the RTC Common temperature compensation.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The cumulative temperature compensation
*
* @retval Signed addition of RTCOCALX and RTCTCMPX values, and
* the updated sign bit (RTCTCMPS) of the addition result.
*
*/
__STATIC_INLINE uint32_t DL_RTC_Common_getTemperatureCompensation(
const RTC_Regs *rtc_common)
{
return (rtc_common->TCMP);
}
/**
* @brief Set the seconds in BCD in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] seconds Value for the seconds of the RTC Common calendar
* Valid values are 0x0-0x59.
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarSecondsBCD(
RTC_Regs *rtc_common, uint8_t seconds)
{
rtc_common->SEC = ((uint32_t) seconds << RTC_SEC_SECLOWBCD_OFS) &
(RTC_SEC_SECLOWBCD_MASK | RTC_SEC_SECHIGHBCD_MASK);
}
/**
* @brief Get the seconds in in BCD the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The seconds in the RTC Common calendar
*
* @retval Value in range: 0x0-0x59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarSecondsBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->SEC &
(RTC_SEC_SECLOWBCD_MASK | RTC_SEC_SECHIGHBCD_MASK)) >>
RTC_SEC_SECLOWBCD_OFS);
}
/**
* @brief Set the minutes in in BCD the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] minutes Value for the minutes of the RTC Common calendar
* Valid values are 0x0-0x59.
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarMinutesBCD(
RTC_Regs *rtc_common, uint8_t minutes)
{
rtc_common->MIN = ((uint32_t) minutes << RTC_MIN_MINLOWBCD_OFS) &
(RTC_MIN_MINLOWBCD_MASK | RTC_MIN_MINHIGHBCD_MASK);
}
/**
* @brief Get the minutes in in BCD the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The minutes in the RTC Common calendar
*
* @retval Value in range: 0x0-0x59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarMinutesBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->MIN &
(RTC_MIN_MINLOWBCD_MASK | RTC_MIN_MINHIGHBCD_MASK)) >>
RTC_MIN_MINLOWBCD_OFS);
}
/**
* @brief Set the hours in in BCD the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] hours Value for the hours of the RTC Common calendar
* Valid values are 0x0-0x23
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarHoursBCD(
RTC_Regs *rtc_common, uint8_t hours)
{
rtc_common->HOUR = ((uint32_t) hours << RTC_HOUR_HOURLOWBCD_OFS) &
(RTC_HOUR_HOURLOWBCD_MASK | RTC_HOUR_HOURHIGHBCD_MASK);
}
/**
* @brief Get the hours in in BCD the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The hours in the RTC Common calendar
*
* @retval Value in range: 0x0-0x23
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarHoursBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->HOUR & (RTC_HOUR_HOURLOWBCD_MASK |
RTC_HOUR_HOURHIGHBCD_MASK)) >>
RTC_HOUR_HOURLOWBCD_OFS);
}
/**
* @brief Set the day of the week in BCD in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the week of the RTC Common calendar
* Valid values are 0x0-0x6
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarDayOfWeekBCD(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->DAY, day, RTC_DAY_DOW_MASK);
}
/**
* @brief Get the day of the week in BCD in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The day of the week in the RTC Common calendar
*
* @retval Value in range: 0x0-0x6
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarDayOfWeekBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->DAY & RTC_DAY_DOW_MASK);
}
/**
* @brief Set the day of the month in BCD in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the month of the RTC Common calendar
* Valid values are 0x1-0x31
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarDayOfMonthBCD(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->DAY,
(uint32_t) day << RTC_DAY_DOMLOWBCD_OFS,
(RTC_DAY_DOMLOWBCD_MASK | RTC_DAY_DOMHIGHBCD_MASK));
}
/**
* @brief Get the day of the month in BCD in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The day of the month in the RTC Common calendar
*
* @retval Value in range: 0x1-0x31
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarDayOfMonthBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->DAY &
(RTC_DAY_DOMLOWBCD_MASK | RTC_DAY_DOMHIGHBCD_MASK)) >>
RTC_DAY_DOMLOWBCD_OFS);
}
/**
* @brief Set the month in in BCD the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] month Value for the month of the RTC Common calendar
* Valid values are 0x1-0x12
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarMonthBCD(
RTC_Regs *rtc_common, uint8_t month)
{
rtc_common->MON = ((uint32_t) month << RTC_MON_MONLOWBCD_OFS) &
(RTC_MON_MONLOWBCD_MASK | RTC_MON_MONHIGHBCD_MASK);
}
/**
* @brief Get the month of the year in BCD in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The month of the year in the RTC Common calendar
*
* @retval Value in range: 0x1-0x12
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarMonthBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->MON &
(RTC_MON_MONLOWBCD_MASK | RTC_MON_MONHIGHBCD_MASK)) >>
RTC_MON_MONLOWBCD_OFS);
}
/**
* @brief Set the year in in BCD the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] year Value for the year of the RTC Common calendar
* Valid values are 0x0-0x4095
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarYearBCD(
RTC_Regs *rtc_common, uint16_t year)
{
rtc_common->YEAR =
((uint32_t) year << RTC_YEAR_YEARLOWESTBCD_OFS) &
(RTC_YEAR_YEARLOWESTBCD_MASK | RTC_YEAR_DECADEBCD_MASK |
RTC_YEAR_CENTLOWBCD_MASK | RTC_YEAR_CENTHIGHBCD_MASK);
}
/**
* @brief Get the year in in BCD the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The year in the RTC Common calendar
*
* @retval Value in range: 0x0-0x4095
*
*/
__STATIC_INLINE uint16_t DL_RTC_Common_getCalendarYearBCD(
const RTC_Regs *rtc_common)
{
return (uint16_t)(
(rtc_common->YEAR &
(RTC_YEAR_YEARLOWESTBCD_MASK | RTC_YEAR_DECADEBCD_MASK |
RTC_YEAR_CENTLOWBCD_MASK | RTC_YEAR_CENTHIGHBCD_MASK)) >>
RTC_YEAR_YEARLOWESTBCD_OFS);
}
/**
* @brief Enable minutes in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm1MinutesBCD(RTC_Regs *rtc_common)
{
rtc_common->A1MIN |= RTC_A1MIN_AMINAEBCD_ENABLE;
}
/**
* @brief Disable minutes in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm1MinutesBCD(
RTC_Regs *rtc_common)
{
rtc_common->A1MIN &= ~(RTC_A1MIN_AMINAEBCD_MASK);
}
/**
* @brief Set the minutes in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] minutes Value for the minutes of alarm 1
* Valid values are 0x0-0x59
*
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm1MinutesBCD(
RTC_Regs *rtc_common, uint8_t minutes)
{
rtc_common->A1MIN =
((uint32_t) minutes << RTC_A1MIN_AMINLOWBCD_OFS) &
(RTC_A1MIN_AMINLOWBCD_MASK | RTC_A1MIN_AMINHIGHBCD_MASK);
}
/**
* @brief Get the minutes in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The minutes of alarm 1
*
* @retval Value in range: 0x0-0x59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1MinutesBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->A1MIN & (RTC_A1MIN_AMINLOWBCD_MASK |
RTC_A1MIN_AMINHIGHBCD_MASK)) >>
RTC_A1MIN_AMINLOWBCD_OFS);
}
/**
* @brief Enable hours in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm1HoursBCD(RTC_Regs *rtc_common)
{
rtc_common->A1HOUR |= RTC_A1HOUR_AHOURAEBIN_ENABLE;
}
/**
* @brief Disable hours in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm1HoursBCD(RTC_Regs *rtc_common)
{
rtc_common->A1HOUR &= ~(RTC_A1HOUR_AHOURAEBIN_MASK);
}
/**
* @brief Set the hours in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] hours Value for the hours of alarm 1
* Valid values are 0x0-0x23
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm1HoursBCD(
RTC_Regs *rtc_common, uint8_t hours)
{
rtc_common->A1HOUR =
((uint32_t) hours << RTC_A1HOUR_AHOURLOWBCD_OFS) &
(RTC_A1HOUR_AHOURLOWBCD_MASK | RTC_A1HOUR_AHOURHIGHBCD_MASK);
}
/**
* @brief Get the hours in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The hours of alarm 1
*
* @retval Value in range: 0x0-0x23
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1HoursBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)(
(rtc_common->A1HOUR &
(RTC_A1HOUR_AHOURLOWBCD_MASK | RTC_A1HOUR_AHOURHIGHBCD_MASK)) >>
RTC_A1HOUR_AHOURLOWBCD_OFS);
}
/**
* @brief Enable day of the week in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm1DayOfWeekBCD(
RTC_Regs *rtc_common)
{
rtc_common->A1DAY |= RTC_A1DAY_ADOWAE_ENABLE;
}
/**
* @brief Disable day of the week in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm1DayOfWeekBCD(
RTC_Regs *rtc_common)
{
rtc_common->A1DAY &= ~(RTC_A1DAY_ADOWAE_MASK);
}
/**
* @brief Set the day of the week in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the week of the RTC Common calendar
* Valid values are 0x0-0x6
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm1DayOfWeekBCD(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->A1DAY, day, RTC_A1DAY_ADOW_MASK);
}
/**
* @brief Get the day of the week in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The day of the week in the RTC Common calendar
*
* @retval Value in range: 0x0-0x6
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1DayOfWeekBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->DAY & RTC_A1DAY_ADOW_MASK);
}
/**
* @brief Enable day of the month in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm1DayOfMonthBCD(
RTC_Regs *rtc_common)
{
rtc_common->A1DAY |= RTC_A1DAY_ADOMAEBCD_ENABLE;
}
/**
* @brief Disable day of the month in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm1DayOfMonthBCD(
RTC_Regs *rtc_common)
{
rtc_common->A1DAY &= ~(RTC_A1DAY_ADOMAEBCD_MASK);
}
/**
* @brief Set the day of the month in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the month of the RTC Common calendar
* Valid values are 0x1-0x31
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm1DayOfMonthBCD(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->A1DAY,
(uint32_t) day << RTC_A1DAY_ADOMLOWBCD_OFS,
(RTC_A1DAY_ADOMLOWBCD_MASK | RTC_A1DAY_ADOMHIGHBCD_MASK));
}
/**
* @brief Get the day of the month in BCD for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The day of the month in the RTC Common calendar
*
* @retval Value in range: 0x1-0x31
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1DayOfMonthBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->A1DAY & (RTC_A1DAY_ADOMLOWBCD_MASK |
RTC_A1DAY_ADOMHIGHBCD_MASK)) >>
RTC_A1DAY_ADOMLOWBCD_OFS);
}
/**
* @brief Enable minutes in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm2MinutesBCD(RTC_Regs *rtc_common)
{
rtc_common->A2MIN |= RTC_A2MIN_AMINAEBCD_ENABLE;
}
/**
* @brief Disable minutes in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm2MinutesBCD(
RTC_Regs *rtc_common)
{
rtc_common->A2MIN &= ~(RTC_A2MIN_AMINAEBCD_MASK);
}
/**
* @brief Set the minutes in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] minutes Value for the minutes of alarm 2
* Valid values are 0x0-0x59
*
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm2MinutesBCD(
RTC_Regs *rtc_common, uint8_t minutes)
{
rtc_common->A2MIN =
((uint32_t) minutes << RTC_A2MIN_AMINLOWBCD_OFS) &
(RTC_A2MIN_AMINLOWBCD_MASK | RTC_A2MIN_AMINHIGHBCD_MASK);
}
/**
* @brief Get the minutes in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The minutes of alarm 2
*
* @retval Value in range: 0x0-0x59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2MinutesBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->A2MIN & (RTC_A2MIN_AMINLOWBCD_MASK |
RTC_A2MIN_AMINHIGHBCD_MASK)) >>
RTC_A2MIN_AMINLOWBCD_OFS);
}
/**
* @brief Enable hours in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm2HoursBCD(RTC_Regs *rtc_common)
{
rtc_common->A2HOUR |= RTC_A2HOUR_AHOURAEBIN_ENABLE;
}
/**
* @brief Disable hours in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm2HoursBCD(RTC_Regs *rtc_common)
{
rtc_common->A2HOUR &= ~(RTC_A2HOUR_AHOURAEBIN_MASK);
}
/**
* @brief Set the hours in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] hours Value for the hours of alarm 2
* Valid values are 0x0-0x23
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm2HoursBCD(
RTC_Regs *rtc_common, uint8_t hours)
{
rtc_common->A2HOUR =
((uint32_t) hours << RTC_A2HOUR_AHOURLOWBCD_OFS) &
(RTC_A2HOUR_AHOURLOWBCD_MASK | RTC_A2HOUR_AHOURHIGHBCD_MASK);
}
/**
* @brief Get the hours in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The hours of alarm 2
*
* @retval Value in range: 0x0-0x23
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2HoursBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)(
(rtc_common->A2HOUR &
(RTC_A2HOUR_AHOURLOWBCD_MASK | RTC_A2HOUR_AHOURHIGHBCD_MASK)) >>
RTC_A2HOUR_AHOURLOWBCD_OFS);
}
/**
* @brief Enable day of the week in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm2DayOfWeekBCD(
RTC_Regs *rtc_common)
{
rtc_common->A2DAY |= RTC_A2DAY_ADOWAE_ENABLE;
}
/**
* @brief Disable day of the week in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm2DayOfWeekBCD(
RTC_Regs *rtc_common)
{
rtc_common->A2DAY &= ~(RTC_A2DAY_ADOWAE_MASK);
}
/**
* @brief Set the day of the week in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the week of the RTC Common calendar
* Valid values are 0x0-0x6
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm2DayOfWeekBCD(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->A2DAY, day, RTC_A2DAY_ADOW_MASK);
}
/**
* @brief Get the day of the week in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The day of the week in the RTC Common calendar
*
* @retval Value in range: 0x0-0x6
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2DayOfWeekBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->DAY & RTC_A2DAY_ADOW_MASK);
}
/**
* @brief Enable day of the month in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm2DayOfMonthBCD(
RTC_Regs *rtc_common)
{
rtc_common->A2DAY |= RTC_A2DAY_ADOMAEBCD_ENABLE;
}
/**
* @brief Disable day of the month in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm2DayOfMonthBCD(
RTC_Regs *rtc_common)
{
rtc_common->A2DAY &= ~(RTC_A2DAY_ADOMAEBCD_MASK);
}
/**
* @brief Set the day of the month in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the month of the RTC Common calendar
* Valid values are 0x1-0x31
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm2DayOfMonthBCD(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->A2DAY,
(uint32_t) day << RTC_A2DAY_ADOMLOWBCD_OFS,
(RTC_A2DAY_ADOMLOWBCD_MASK | RTC_A2DAY_ADOMHIGHBCD_MASK));
}
/**
* @brief Get the day of the month in BCD for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The day of the month in the RTC Common calendar
*
* @retval Value in range: 0x1-0x31
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2DayOfMonthBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->A2DAY & (RTC_A2DAY_ADOMLOWBCD_MASK |
RTC_A2DAY_ADOMHIGHBCD_MASK)) >>
RTC_A2DAY_ADOMLOWBCD_OFS);
}
/**
* @brief Set the seconds in binary the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] seconds Value for the seconds of the RTC Common calendar
* Valid values are 0-59
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarSecondsBinary(
RTC_Regs *rtc_common, uint8_t seconds)
{
rtc_common->SEC = (seconds & RTC_SEC_SECBIN_MASK);
}
/**
* @brief Get the seconds in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The seconds in the RTC Common calendar
*
* @retval Value in range: 0-59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarSecondsBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->SEC & RTC_SEC_SECBIN_MASK);
}
/**
* @brief Set the minutes in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] minutes Value for the minutes of the RTC Common calendar
* Valid values are 0-59
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarMinutesBinary(
RTC_Regs *rtc_common, uint8_t minutes)
{
rtc_common->MIN = (minutes & RTC_MIN_MINBIN_MASK);
}
/**
* @brief Get the minutes in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The minutes in the RTC Common calendar
*
* @retval Value in range: 0-59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarMinutesBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->MIN & RTC_MIN_MINBIN_MASK);
}
/**
* @brief Set the hours in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] hours Value for the hours of the RTC Common calendar
* Valid values are 0-23
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarHoursBinary(
RTC_Regs *rtc_common, uint8_t hours)
{
rtc_common->HOUR = (hours & RTC_HOUR_HOURBIN_MASK);
}
/**
* @brief Get the hours in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The hours in the RTC Common calendar
*
* @retval Value in range: 0-23
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarHoursBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->HOUR & RTC_HOUR_HOURBIN_MASK);
}
/**
* @brief Set the day of the week in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the week of the RTC Common calendar
* Valid values are 0-6
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarDayOfWeekBinary(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->DAY, day, RTC_DAY_DOW_MASK);
}
/**
* @brief Get the day of the week in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The day of the week in the RTC Common calendar
*
* @retval Value in range: 0-6
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarDayOfWeekBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->DAY & RTC_DAY_DOW_MASK);
}
/**
* @brief Set the day of the month in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the month of the RTC Common calendar
* Valid values are 1-31
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarDayOfMonthBinary(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->DAY, (uint32_t) day << RTC_DAY_DOMBIN_OFS,
RTC_DAY_DOMBIN_MASK);
}
/**
* @brief Get the day of the month in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The day of the month in the RTC Common calendar
*
* @retval Value in range: 1-31
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarDayOfMonthBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(
(rtc_common->DAY & RTC_DAY_DOMBIN_MASK) >> RTC_DAY_DOMBIN_OFS);
}
/**
* @brief Set the month in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] month Value for the month of the RTC Common calendar
* Valid values are 1-12
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarMonthBinary(
RTC_Regs *rtc_common, uint8_t month)
{
rtc_common->MON = (month & RTC_MON_MONBIN_MASK);
}
/**
* @brief Get the month of the year in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The month of the year in the RTC Common calendar
*
* @retval Value in range: 1-12
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getCalendarMonthBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->MON & RTC_MON_MONBIN_MASK);
}
/**
* @brief Set the year in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] year Value for the year of the RTC Common calendar
* Valid values are 0-4095
*/
__STATIC_INLINE void DL_RTC_Common_setCalendarYearBinary(
RTC_Regs *rtc_common, uint16_t year)
{
rtc_common->YEAR = ((uint32_t) year & (RTC_YEAR_YEARLOWBIN_MASK |
RTC_YEAR_YEARHIGHBIN_MASK));
}
/**
* @brief Get the year in binary in the RTC Common calendar
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The year in the RTC Common calendar
*
* @retval Value in range: 0-4095
*
*/
__STATIC_INLINE uint16_t DL_RTC_Common_getCalendarYearBinary(
const RTC_Regs *rtc_common)
{
return (uint16_t)(rtc_common->YEAR &
(RTC_YEAR_YEARLOWBIN_MASK | RTC_YEAR_YEARHIGHBIN_MASK));
}
/**
* @brief Enable minutes in binary in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm1MinutesBinary(
RTC_Regs *rtc_common)
{
rtc_common->A1MIN |= RTC_A1MIN_AMINAEBIN_ENABLE;
}
/**
* @brief Disable minutes in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm1MinutesBinary(
RTC_Regs *rtc_common)
{
rtc_common->A1MIN &= ~(RTC_A1MIN_AMINAEBIN_MASK);
}
/**
* @brief Set the minutes in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] minutes Value for the minutes of alarm 1
* Valid values are 0-59
*
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm1MinutesBinary(
RTC_Regs *rtc_common, uint8_t minutes)
{
rtc_common->A1MIN = (minutes & RTC_A1MIN_AMINBIN_MASK);
}
/**
* @brief Get the minutes in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The minutes of alarm 1
*
* @retval Value in range: 0-59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1MinutesBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->A1MIN & RTC_A1MIN_AMINBIN_MASK);
}
/**
* @brief Enable hours in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm1HoursBinary(
RTC_Regs *rtc_common)
{
rtc_common->A1HOUR |= RTC_A1HOUR_AHOURAEBIN_ENABLE;
}
/**
* @brief Disable hours in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm1HoursBinary(
RTC_Regs *rtc_common)
{
rtc_common->A1HOUR &= ~(RTC_A1HOUR_AHOURAEBIN_MASK);
}
/**
* @brief Set the hours in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] hours Value for the hours of alarm 1
* Valid values are 0-23
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm1HoursBinary(
RTC_Regs *rtc_common, uint8_t hours)
{
rtc_common->A1HOUR = (hours & RTC_A1HOUR_AHOURBIN_MASK);
}
/**
* @brief Get the hours in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The hours of alarm 1
*
* @retval Value in range: 0-23
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1HoursBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->A1HOUR & RTC_A1HOUR_AHOURBIN_MASK);
}
/**
* @brief Enable day of the week in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm1DayOfWeekBinary(
RTC_Regs *rtc_common)
{
rtc_common->A1DAY |= RTC_A1DAY_ADOWAE_ENABLE;
}
/**
* @brief Disable day of the week in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm1DayOfWeekBinary(
RTC_Regs *rtc_common)
{
rtc_common->A1DAY &= ~(RTC_A1DAY_ADOWAE_MASK);
}
/**
* @brief Set the day of the week in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the week of the RTC Common calendar
* Valid values are 0-6
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm1DayOfWeekBinary(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->A1DAY, day, RTC_A1DAY_ADOW_MASK);
}
/**
* @brief Get the day of the week in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The day of the week in the RTC Common calendar
*
* @retval Value in range: 0-6
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1DayOfWeekBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->A1DAY & RTC_A1DAY_ADOW_MASK);
}
/**
* @brief Enable day of the month in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm1DayOfMonthBinary(
RTC_Regs *rtc_common)
{
rtc_common->A1DAY |= RTC_A1DAY_ADOMAEBIN_ENABLE;
}
/**
* @brief Disable day of the month in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm1DayOfMonthBinary(
RTC_Regs *rtc_common)
{
rtc_common->A1DAY &= ~(RTC_A1DAY_ADOMAEBIN_MASK);
}
/**
* @brief Set the day of the month in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the month of the RTC Common calendar
* Valid values are 1-31
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm1DayOfMonthBinary(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->A1DAY,
(uint32_t) day << RTC_A1DAY_ADOMBIN_OFS, RTC_A1DAY_ADOMBIN_MASK);
}
/**
* @brief Get the day of the month in binary for RTC Common Calendar Alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The day of the month in the RTC Common calendar
*
* @retval Value in range: 1-31
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm1DayOfMonthBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(
(rtc_common->A1DAY & RTC_A1DAY_ADOMBIN_MASK) >> RTC_A1DAY_ADOMBIN_OFS);
}
/**
* @brief Enable minutes in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm2MinutesBinary(
RTC_Regs *rtc_common)
{
rtc_common->A2MIN |= RTC_A2MIN_AMINAEBIN_ENABLE;
}
/**
* @brief Disable minutes in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm2MinutesBinary(
RTC_Regs *rtc_common)
{
rtc_common->A2MIN &= ~(RTC_A2MIN_AMINAEBIN_MASK);
}
/**
* @brief Set the minutes in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] minutes Value for the minutes of alarm 2
* Valid values are 0-59
*
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm2MinutesBinary(
RTC_Regs *rtc_common, uint8_t minutes)
{
rtc_common->A2MIN = (minutes & RTC_A2MIN_AMINBIN_MASK);
}
/**
* @brief Get the minutes in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The minutes of alarm 2
*
* @retval Value in range: 0-59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2MinutesBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->A2MIN & RTC_A2MIN_AMINBIN_MASK);
}
/**
* @brief Enable hours in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm2HoursBinary(
RTC_Regs *rtc_common)
{
rtc_common->A2HOUR |= RTC_A2HOUR_AHOURAEBIN_ENABLE;
}
/**
* @brief Disable hours in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm2HoursBinary(
RTC_Regs *rtc_common)
{
rtc_common->A2HOUR &= ~(RTC_A2HOUR_AHOURAEBIN_MASK);
}
/**
* @brief Set the hours in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] hours Value for the hours of alarm 2
* Valid values are 0-23
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm2HoursBinary(
RTC_Regs *rtc_common, uint8_t hours)
{
rtc_common->A2HOUR = (hours & RTC_A2HOUR_AHOURBIN_MASK);
}
/**
* @brief Get the hours in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The hours of alarm 2
*
* @retval Value in range: 0-23
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2HoursBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->A2HOUR & RTC_A2HOUR_AHOURBIN_MASK);
}
/**
* @brief Enable day of the week in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm2DayOfWeekBinary(
RTC_Regs *rtc_common)
{
rtc_common->A2DAY |= RTC_A2DAY_ADOWAE_ENABLE;
}
/**
* @brief Disable day of the week in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm2DayOfWeekBinary(
RTC_Regs *rtc_common)
{
rtc_common->A2DAY &= ~(RTC_A2DAY_ADOWAE_MASK);
}
/**
* @brief Set the day of the week in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the week of the RTC Common calendar
* Valid values are 0-6
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm2DayOfWeekBinary(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->A2DAY, day, RTC_A2DAY_ADOW_MASK);
}
/**
* @brief Get the day of the week in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The day of the week in the RTC Common calendar
*
* @retval Value in range: 0-6
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2DayOfWeekBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->A2DAY & RTC_A2DAY_ADOW_MASK);
}
/**
* @brief Enable day of the month in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_enableAlarm2DayOfMonthBinary(
RTC_Regs *rtc_common)
{
rtc_common->A2DAY |= RTC_A2DAY_ADOMAEBIN_ENABLE;
}
/**
* @brief Disable day of the month in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
__STATIC_INLINE void DL_RTC_Common_disableAlarm2DayOfMonthBinary(
RTC_Regs *rtc_common)
{
rtc_common->A2DAY &= ~(RTC_A2DAY_ADOMAEBIN_MASK);
}
/**
* @brief Set the day of the month in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] day Value for the day of the month of the RTC Common calendar
* Valid values are 1-31
*/
__STATIC_INLINE void DL_RTC_Common_setAlarm2DayOfMonthBinary(
RTC_Regs *rtc_common, uint8_t day)
{
DL_Common_updateReg(&rtc_common->A2DAY,
(uint32_t) day << RTC_A2DAY_ADOMBIN_OFS, RTC_A2DAY_ADOMBIN_MASK);
}
/**
* @brief Get the day of the month in binary for RTC Common Calendar Alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The day of the month in the RTC Common calendar
*
* @retval Value in range: 1-31
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getAlarm2DayOfMonthBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(
(rtc_common->A2DAY & RTC_A2DAY_ADOMBIN_MASK) >> RTC_A2DAY_ADOMBIN_OFS);
}
/**
* @brief Set prescale interrupt interval for timer 0 and 1
*
* Set prescale timer interrupt interval to DL_RTC_COMMON_PRESCALE_NONE to keep the
* timer disabled.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @param[in] prescaler0Divider Value to set for prescaler 0
* interrupt interval
* One of @ref DL_RTC_COMMON_PRESCALER0_DIVIDE
*
* @param[in] prescaler1Divider Value to set for prescaler 1
* interrupt interval
* One of @ref DL_RTC_COMMON_PRESCALER1_DIVIDE
* @param[in] prescaler2Divider Value to set for prescaler 2
* interrupt interval.
* One of @ref DL_RTC_COMMON_PRESCALER2_DIVIDE
*/
__STATIC_INLINE void DL_RTC_Common_setPrescalerEvents(RTC_Regs *rtc_common,
DL_RTC_COMMON_PRESCALER0_DIVIDE prescaler0Divider,
DL_RTC_COMMON_PRESCALER1_DIVIDE prescaler1Divider,
DL_RTC_COMMON_PRESCALER2_DIVIDE prescaler2Divider)
{
rtc_common->PSCTL =
(((uint32_t) prescaler0Divider & RTC_PSCTL_RT0IP_MASK) |
((uint32_t) prescaler1Divider & RTC_PSCTL_RT1IP_MASK));
rtc_common->EXTPSCTL =
((uint32_t) prescaler2Divider & RTC_EXTPSCTL_RT2PS_MASK);
}
/**
* @brief Set periodic alarm 0
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @param[in] prescaler0Divider Value to set for prescaler 0 interrupt
* interval. One of @ref DL_RTC_COMMON_PRESCALER0_DIVIDE
*
*/
__STATIC_INLINE void DL_RTC_Common_setPeriodicAlarm0(
RTC_Regs *rtc_common, DL_RTC_COMMON_PRESCALER0_DIVIDE prescaler0Divider)
{
DL_Common_updateReg(&rtc_common->PSCTL, (uint32_t) prescaler0Divider,
RTC_PSCTL_RT0IP_MASK);
}
/**
* @brief Set periodic alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @param[in] prescaler1Divider Value to set for prescaler 1 interrupt
* interval. One of @ref DL_RTC_COMMON_PRESCALER1_DIVIDE
*/
__STATIC_INLINE void DL_RTC_Common_setPeriodicAlarm1(
RTC_Regs *rtc_common, DL_RTC_COMMON_PRESCALER1_DIVIDE prescaler1Divider)
{
DL_Common_updateReg(&rtc_common->PSCTL, (uint32_t) prescaler1Divider,
RTC_PSCTL_RT1IP_MASK);
}
/**
* @brief Set periodic alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @param[in] prescaler2Divider Value to set for prescaler 2 interrupt
* interval. One of @ref DL_RTC_COMMON_PRESCALER2_DIVIDE
*/
__STATIC_INLINE void DL_RTC_Common_setPeriodicAlarm2(
RTC_Regs *rtc_common, DL_RTC_COMMON_PRESCALER2_DIVIDE prescaler2Divider)
{
DL_Common_updateReg(&rtc_common->EXTPSCTL, (uint32_t) prescaler2Divider,
RTC_EXTPSCTL_RT2PS_MASK);
}
/**
* @brief Get prescaler 0 interrupt interval
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return Value for prescaler 0 interrupt interval
*
* @retval One of @ref DL_RTC_COMMON_PRESCALER0_DIVIDE
*
*/
__STATIC_INLINE DL_RTC_COMMON_PRESCALER0_DIVIDE DL_RTC_Common_getPrescaler0(
const RTC_Regs *rtc_common)
{
uint32_t prescaler = (rtc_common->PSCTL & RTC_PSCTL_RT0IP_MASK);
return (DL_RTC_COMMON_PRESCALER0_DIVIDE)(prescaler);
}
/**
* @brief Get prescaler 1 interrupt interval
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return Value for prescaler 1 interrupt interval
*
* @retval One of @ref DL_RTC_COMMON_PRESCALER1_DIVIDE
*/
__STATIC_INLINE DL_RTC_COMMON_PRESCALER1_DIVIDE DL_RTC_Common_getPrescaler1(
const RTC_Regs *rtc_common)
{
uint32_t prescaler = (rtc_common->PSCTL & RTC_PSCTL_RT1IP_MASK);
return (DL_RTC_COMMON_PRESCALER1_DIVIDE)(prescaler);
}
/**
* @brief Get prescaler 2 interrupt interval
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return Value for prescaler 2 interrupt interval
*
* @retval One of @ref DL_RTC_COMMON_PRESCALER2_DIVIDE
*/
__STATIC_INLINE DL_RTC_COMMON_PRESCALER2_DIVIDE DL_RTC_Common_getPrescaler2(
const RTC_Regs *rtc_common)
{
uint32_t prescaler = (rtc_common->EXTPSCTL & RTC_EXTPSCTL_RT2PS_MASK);
return (DL_RTC_COMMON_PRESCALER2_DIVIDE)(prescaler);
}
/**
* @brief Get the seconds in BCD in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The seconds in the time stamp
*
* @retval Value in range: 0x0-0x59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampSecondsBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->TSSEC & (RTC_TSSEC_SECLOWBCD_MASK |
RTC_TSSEC_SECHIGHBCD_MASK)) >>
RTC_TSSEC_SECLOWBCD_OFS);
}
/**
* @brief Get the minutes in BCD in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The minutes in the time stamp
*
* @retval Value in range: 0x0-0x59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampMinutesBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->TSMIN & (RTC_TSMIN_MINLOWBCD_MASK |
RTC_TSMIN_MINHIGHBCD_MASK)) >>
RTC_TSMIN_MINLOWBCD_OFS);
}
/**
* @brief Get the hours in BCD in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The hours in the time stamp
*
* @retval Value in range: 0x0-0x23
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampHoursBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->TSHOUR & (RTC_TSHOUR_HOURLOWBCD_MASK |
RTC_TSHOUR_HOURHIGHBCD_MASK)) >>
RTC_TSHOUR_HOURLOWBCD_OFS);
}
/**
* @brief Get the day of the week in BCD in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The day of the week in the time stamp
*
* @retval Value in range: 0x0-0x6
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampDayOfWeekBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->TSDAY & RTC_TSDAY_DOW_MASK);
}
/**
* @brief Get the day of the month in BCD in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The day of the month in the time stamp
*
* @retval Value in range: 0x1-0x31
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampDayOfMonthBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->TSDAY & (RTC_TSDAY_DOMLOWBCD_MASK |
RTC_TSDAY_DOMHIGHBCD_MASK)) >>
RTC_TSDAY_DOMLOWBCD_OFS);
}
/**
* @brief Get the month of the year in BCD in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The month of the year in the time stamp
*
* @retval Value in range: 0x1-0x12
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampMonthBCD(
const RTC_Regs *rtc_common)
{
return (uint8_t)((rtc_common->TSMON & (RTC_TSMON_MONLOWBCD_MASK |
RTC_TSMON_MONHIGHBCD_MASK)) >>
RTC_TSMON_MONLOWBCD_OFS);
}
/**
* @brief Get the year in BCD in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The year in the time stamp
*
* @retval Value in range: 0x0-0x4095
*
*/
__STATIC_INLINE uint16_t DL_RTC_Common_getTimeStampYearBCD(
const RTC_Regs *rtc_common)
{
return (uint16_t)(
(rtc_common->TSYEAR &
(RTC_TSYEAR_YERARLOWESTBCD_MASK | RTC_TSYEAR_DECADEBCD_MASK |
RTC_TSYEAR_CENTLOWBCD_MASK | RTC_TSYEAR_CENTHIGHBCD_MASK)) >>
RTC_TSYEAR_YERARLOWESTBCD_OFS);
}
/**
* @brief Get the seconds in binary in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The seconds in the time stamp
* @retval Value in range: 0-59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampSecondsBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->TSSEC & RTC_TSSEC_SECBIN_MASK);
}
/**
* @brief Get the minutes in binary in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The minutes in the time stamp
*
* @retval Value in range: 0-59
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampMinutesBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->TSMIN & RTC_TSMIN_MINBIN_MASK);
}
/**
* @brief Get the hours in binary in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The hours in the time stamp
*
* @retval Value in range: 0-23
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampHoursBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->TSHOUR & RTC_TSHOUR_HOURBIN_MASK);
}
/**
* @brief Get the day of the week in binary in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The day of the week in the time stamp
*
* @retval Value in range: 0-6
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampDayOfWeekBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->TSDAY & RTC_TSDAY_DOW_MASK);
}
/**
* @brief Get the day of the month in binary in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The day of the month in the time stamp
*
* @retval Value in range: 1-31
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampDayOfMonthBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(
(rtc_common->TSDAY & RTC_TSDAY_DOMBIN_MASK) >> RTC_TSDAY_DOMBIN_OFS);
}
/**
* @brief Get the month of the year in binary in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The month of the year in the time stamp
*
* @retval Value in range: 1-12
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getTimeStampMonthBinary(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->TSMON & RTC_TSMON_MONBIN_MASK);
}
/**
* @brief Get the year in binary in the time stamp
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @pre To prevent reading any counter/calendar registers while those registers
* are being updated, the user can call @ref DL_RTC_Common_isSafeToRead to ensure that
* the registers are safe to read.
*
* @return The year in the time stamp
*
* @retval Value in range: 0-4095
*
*/
__STATIC_INLINE uint16_t DL_RTC_Common_getTimeStampYearBinary(
const RTC_Regs *rtc_common)
{
return (uint16_t)(rtc_common->TSYEAR & (RTC_TSYEAR_YEARLOWBIN_MASK |
RTC_TSYEAR_YEARHIGHBIN_MASK));
}
/**
* @brief Enable RTC Common interrupts
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @param[in] interruptMask Bit mask of interrupts to enable. Logical OR of
* @ref DL_RTC_COMMON_INTERRUPT.
*/
__STATIC_INLINE void DL_RTC_Common_enableInterrupt(
RTC_Regs *rtc_common, uint32_t interruptMask)
{
rtc_common->CPU_INT.IMASK |= interruptMask;
}
/**
* @brief Disable RTC Common interrupts
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @param[in] interruptMask Bit mask of interrupts to enable. Logical OR of
* @ref DL_RTC_COMMON_INTERRUPT
*/
__STATIC_INLINE void DL_RTC_Common_disableInterrupt(
RTC_Regs *rtc_common, uint32_t interruptMask)
{
rtc_common->CPU_INT.IMASK &= ~(interruptMask);
}
/**
* @brief Check which RTC Common interrupts are enabled
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @param[in] interruptMask Bit mask of interrupts to check. Logical OR of
* @ref DL_RTC_COMMON_INTERRUPT
*
* @return Which of the requested RTC Common interrupts are enabled
*
* @retval Logical OR of @ref DL_RTC_COMMON_INTERRUPT values
*/
__STATIC_INLINE uint32_t DL_RTC_Common_getEnabledInterrupts(
const RTC_Regs *rtc_common, uint32_t interruptMask)
{
return (rtc_common->CPU_INT.IMASK & interruptMask);
}
/**
* @brief Check interrupt flag of enabled RTC Common interrupts
*
* Checks if any of the RTC Common interrupts that were previously enabled are
* pending.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @param[in] interruptMask Bit mask of interrupts to check. Logical OR of
* @ref DL_RTC_COMMON_INTERRUPT
*
* @return Which of the requested RTC Common interrupts are pending
*
* @retval Logical OR of @ref DL_RTC_COMMON_INTERRUPT values
*
* @sa DL_RTC_COMMON_enableInterrupt
*/
__STATIC_INLINE uint32_t DL_RTC_Common_getEnabledInterruptStatus(
const RTC_Regs *rtc_common, uint32_t interruptMask)
{
return (rtc_common->CPU_INT.MIS & interruptMask);
}
/**
* @brief Check interrupt flag of any RTC Common interrupt
*
* Checks if any of the RTC Common interrupts are pending. Interrupts do not have to
* be previously enabled.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @param[in] interruptMask Bit mask of interrupts to check. Logical OR of
* @ref DL_RTC_COMMON_INTERRUPT
*
* @return Which of the requested RTC Common interrupts are pending
*
* @retval Logical OR of @ref DL_RTC_COMMON_INTERRUPT values
*/
__STATIC_INLINE uint32_t DL_RTC_Common_getRawInterruptStatus(
const RTC_Regs *rtc_common, uint32_t interruptMask)
{
return (rtc_common->CPU_INT.RIS & interruptMask);
}
/**
* @brief Get highest priority pending RTC Common interrupt
*
* Checks if any of the RTC Common interrupts are pending. Interrupts do not have to
* be previously enabled.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The highest priority pending RTC Common interrupt
*
* @retval One of @ref DL_RTC_COMMON_IIDX
*/
__STATIC_INLINE DL_RTC_COMMON_IIDX DL_RTC_Common_getPendingInterrupt(
const RTC_Regs *rtc_common)
{
return (DL_RTC_COMMON_IIDX)(rtc_common->CPU_INT.IIDX);
}
/**
* @brief Clear pending RTC Common interrupts
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @param[in] interruptMask Bit mask of interrupts to check. Logical OR of
* @ref DL_RTC_COMMON_INTERRUPT
*/
__STATIC_INLINE void DL_RTC_Common_clearInterruptStatus(
RTC_Regs *rtc_common, uint32_t interruptMask)
{
rtc_common->CPU_INT.ICLR = interruptMask;
}
/**
* @brief Enable RTC Common event
*
* @param[in] rtc_common Pointer to the register overlay for the peripheral
* @param[in] eventMask Bit mask of interrupts to enable. Bitwise OR of
* @ref DL_RTC_COMMON_EVENT.
*/
__STATIC_INLINE void DL_RTC_Common_enableEvent(
RTC_Regs *rtc_common, uint32_t eventMask)
{
rtc_common->GEN_EVENT.IMASK |= (eventMask);
}
/**
* @brief Disable RTC Common event
*
* @param[in] rtc_common Pointer to the register overlay for the peripheral
* @param[in] eventMask Bit mask of interrupts to enable. Bitwise OR of
* @ref DL_RTC_COMMON_EVENT.
*/
__STATIC_INLINE void DL_RTC_Common_disableEvent(
RTC_Regs *rtc_common, uint32_t eventMask)
{
rtc_common->GEN_EVENT.IMASK &= ~(eventMask);
}
/**
* @brief Check which RTC Common events are enabled
*
* @param[in] rtc_common Pointer to the register overlay for the peripheral
* @param[in] eventMask Bit mask of interrupts to check. Bitwise OR of
* @ref DL_RTC_COMMON_EVENT.
*
* @return Which of the requested RTC Common interrupts are enabled
*
* @retval Bitwise OR of @ref DL_RTC_COMMON_EVENT values
*/
__STATIC_INLINE uint32_t DL_RTC_Common_getEnabledEvents(
const RTC_Regs *rtc_common, uint32_t eventMask)
{
return ((rtc_common->GEN_EVENT.IMASK) & (eventMask));
}
/**
* @brief Check event flag of enabled RTC Common event
*
* Checks if any of the RTC Common events that were previously enabled are
* pending.
*
* @param[in] rtc_common Pointer to the register overlay for the peripheral
* @param[in] eventMask Bit mask of interrupts to check. Bitwise OR of
* @ref DL_RTC_COMMON_EVENT.
*
* @return Which of the requested RTC Common interrupts are pending
*
* @retval Bitwise OR of @ref DL_RTC_COMMON_EVENT values
*
* @sa DL_RTC_COMMON_enableInterrupt
*/
__STATIC_INLINE uint32_t DL_RTC_Common_getEnabledEventStatus(
const RTC_Regs *rtc_common, uint32_t eventMask)
{
return ((rtc_common->GEN_EVENT.MIS) & eventMask);
}
/**
* @brief Check interrupt flag of any RTC Common event
*
* Checks if any events are pending. Events do not have to
* be previously enabled.
*
* @param[in] rtc_common Pointer to the register overlay for the peripheral
* @param[in] eventMask Bit mask of interrupts to check. Bitwise OR of
* @ref DL_RTC_COMMON_EVENT.
*
* @return Which of the requested RTC Common interrupts are pending
*
* @retval Bitwise OR of @ref DL_RTC_COMMON_EVENT values
*/
__STATIC_INLINE uint32_t DL_RTC_Common_getRawEventsStatus(
const RTC_Regs *rtc_common, uint32_t eventMask)
{
return ((rtc_common->GEN_EVENT.RIS) & eventMask);
}
/**
* @brief Clear pending RTC Common events
*
* @param[in] rtc_common Pointer to the register overlay for the peripheral
* @param[in] eventMask Bit mask of interrupts to clear. Bitwise OR of
* @ref DL_RTC_COMMON_EVENT.
*/
__STATIC_INLINE void DL_RTC_Common_clearEventsStatus(
RTC_Regs *rtc_common, uint32_t eventMask)
{
rtc_common->GEN_EVENT.ICLR |= (eventMask);
}
/**
* @brief Sets the event publisher channel ID
*
* @param[in] rtc_common Pointer to the register overlay for the
* peripheral
* @param[in] chanID Channel ID number. Valid range 0-15. If ChanID == 0
* publisher is disconnected.
*/
__STATIC_INLINE void DL_RTC_Common_setPublisherChanID(
RTC_Regs *rtc_common, uint8_t chanID)
{
rtc_common->FPUB_0 = (chanID & RTC_FPUB_0_CHANID_MAXIMUM);
}
/**
* @brief Gets the event publisher channel ID
*
* @param[in] rtc_common Pointer to the register overlay for the
* peripheral
*
* @return Event publisher channel ID
*
*/
__STATIC_INLINE uint8_t DL_RTC_Common_getPublisherChanID(
const RTC_Regs *rtc_common)
{
return (uint8_t)(rtc_common->FPUB_0 & RTC_FPUB_0_CHANID_MAXIMUM);
}
#ifdef __MSPM0_HAS_RTC_A__
/**
* @brief Gets the cause of the time stamp event
* @param[in] rtc_common Pointer to the register overlay for the peripheral
* @param[in] tsEventMask Bit mask of events to check. Logical OR of
* @ref DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE.
*
* @return The cause of the time stamp event
*
* @retval Logical OR of @ref DL_RTC_COMMON_TIME_STAMP_EVENT_CAUSE values
*/
__STATIC_INLINE uint32_t DL_RTC_Common_getTimeStampEventCause(
const RTC_Regs *rtc_common, uint32_t tsEventMask)
{
return (rtc_common->TSSTAT & tsEventMask);
}
#endif
/**
* @brief Initializes the settings to operate the RTC Common in Calendar mode.
*
* @param[in] rtc_common Pointer to the register overlay for the
* RTC Common peripheral
* @param[in] calendarTime Structure containing the values for the
* Calendar to be initialized to
* @param[in] formatSelect Selectable format the RTC Common peripheral will
* provide time in.
* @ref DL_RTC_COMMON_FORMAT
*
*/
void DL_RTC_Common_initCalendar(RTC_Regs *rtc_common,
DL_RTC_Common_Calendar calendarTime, DL_RTC_COMMON_FORMAT formatSelect);
/**
* @brief Returns the Calendar Time
*
* @param[in] rtc_common Pointer to the register overlay for the
* RTC Common peripheral
*
* This function returns the current Calendar Time in the form of a Calendar
* structure.
* The time returned will be in the previously selected format.
*
* @return A Calendar structure containing the current time.
*
*/
DL_RTC_Common_Calendar DL_RTC_Common_getCalendarTime(
const RTC_Regs *rtc_common);
/**
* @brief Set calendar alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the
* RTC Common peripheral
* @param[in] alarmTime Structure containing the values for the
* alarm to be set to
*
*/
void DL_RTC_Common_setCalendarAlarm1(
RTC_Regs *rtc_common, DL_RTC_Common_CalendarAlarm alarmTime);
/**
* @brief Get calendar alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the
* RTC Common peripheral
*
* @return A Alarm structure containing the set time for alarm 1
*
*/
DL_RTC_Common_CalendarAlarm DL_RTC_Common_getCalendarAlarm1(
const RTC_Regs *rtc_common);
/**
* @brief Enable calendar alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the
* RTC Common peripheral
*
*/
void DL_RTC_Common_enableCalendarAlarm1(RTC_Regs *rtc_common);
/**
* @brief Disable calendar alarm 1
*
* @param[in] rtc_common Pointer to the register overlay for the
* RTC Common peripheral
*
*/
void DL_RTC_Common_disableCalendarAlarm1(RTC_Regs *rtc_common);
/**
* @brief Set calendar alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] alarmTime Structure containing the values for the
* alarm to be set to
*
*/
void DL_RTC_Common_setCalendarAlarm2(
RTC_Regs *rtc_common, DL_RTC_Common_CalendarAlarm alarmTime);
/**
* @brief Get calendar alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return A Alarm structure containing the set time for alarm 2
*
*/
DL_RTC_Common_CalendarAlarm DL_RTC_Common_getCalendarAlarm2(
const RTC_Regs *rtc_common);
/**
* @brief Enable calendar alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
void DL_RTC_Common_enableCalendarAlarm2(RTC_Regs *rtc_common);
/**
* @brief Disable calendar alarm 2
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
*/
void DL_RTC_Common_disableCalendarAlarm2(RTC_Regs *rtc_common);
#ifdef __MSPM0_HAS_RTC_A__
/**
* @brief Set the sources to trigger a time stamp capture event
*
* The timestamp event can be triggered by an edge detection of any of the
* tamper IO. This API sets which source(s) will trigger a time stamp capture
* event.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] sourceMask The sources that can trigger a time stamp capture
* event. Logical OR of
* @ref DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE
*/
__STATIC_INLINE void DL_RTC_Common_setTimeStampEventSource(
RTC_Regs *rtc_common, uint32_t sourceMask)
{
rtc_common->TSCTL |= (RTC_TSCTL_KEY_UNLOCK_W | sourceMask);
}
/**
* @brief Get the sources that can trigger a time stamp capture event
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] sourceMask The sources that can trigger a time stamp capture
* event. Logical OR of
* @ref DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE
*
* @return The sources of the time stamp event
*
* @retval Logical OR of @ref DL_RTC_COMMON_TIME_STAMP_EVENT_SOURCE values
*/
__STATIC_INLINE uint32_t DL_RTC_Common_getTimeStampEventSource(
const RTC_Regs *rtc_common, uint32_t sourceMask)
{
return (rtc_common->TSCTL & sourceMask);
}
/**
* @brief Set the capture method when a time stamp capture event occurs
*
* The timestamp event can be triggered by an edge detection of any of the
* tamper IO. This API sets whether the first or last occurrence of the event
* is captured.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
* @param[in] capture The capture method for the time stamp event.
* One of @ref DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE
*/
__STATIC_INLINE void DL_RTC_Common_setTimeStampEventCapture(
RTC_Regs *rtc_common, DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE capture)
{
DL_Common_updateReg(&rtc_common->TSCTL,
(RTC_TSCTL_KEY_UNLOCK_W | (uint32_t) capture),
(RTC_TSCTL_TSCAPTURE_MASK | RTC_TSCTL_KEY_MASK));
}
/**
* @brief Get the capture method when a time stamp capture event occurs
*
* The timestamp event can be triggered by an edge detection of any of the
* tamper IO. This API sets whether the first or last occurrence of the event
* is captured.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return The capture method for a time stamp capture event
*
* @retval One of @ref DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE
*/
__STATIC_INLINE DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE
DL_RTC_Common_getTimeStampEventCapture(const RTC_Regs *rtc_common)
{
uint32_t capture = (rtc_common->TSCTL & RTC_TSCTL_TSCAPTURE_MASK);
return (DL_RTC_COMMON_TIME_STAMP_EVENT_CAPTURE)(capture);
}
/**
* @brief Clear the time stamp and time stamp event status
*
* The time stamp and the time stamp event status are sticky, and will stay
* active until cleared by software.
*
* @param[in] rtc_common Pointer to the register overlay for the peripheral
*/
__STATIC_INLINE void DL_RTC_Common_clearTimeStamp(RTC_Regs *rtc_common)
{
rtc_common->TSCLR = (RTC_TSCLR_KEY_UNLOCK_W | RTC_TSCLR_CLR_CLR);
}
/**
* @brief Enable write protection lock of the CLKCTL, SEC, MIN, HOUR,
* DAY, MON, YEAR and LFSSRST registers from accidental updates
*
* When enabled, the CLKCTL, SEC, MIN, HOUR, DAY, MON, YEAR and LFSSRST
* registers will have read-only properties.
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*/
__STATIC_INLINE void DL_RTC_Common_enableWriteProtect(RTC_Regs *rtc_common)
{
rtc_common->RTCLOCK = (RTC_RTCLOCK_PROTECT_SET | RTC_RTCLOCK_KEY_UNLOCK_W);
}
/**
* @brief Checks if write protection lock of the CLKCTL, SEC, MIN, HOUR,
* DAY, MON, YEAR and LFSSRST registers is enabled
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*
* @return Returns the enabled status of the write protection lock
*
* @retval true Write protection lock is enabled
* @retval false Write protection lock is disabled
*/
__STATIC_INLINE bool DL_RTC_Common_isWriteProtectEnabled(
const RTC_Regs *rtc_common)
{
return ((rtc_common->RTCLOCK & RTC_RTCLOCK_PROTECT_MASK) ==
RTC_RTCLOCK_PROTECT_SET);
}
/**
* @brief Disable write protection lock of the CLKCTL, SEC, MIN, HOUR,
* DAY, MON, YEAR and LFSSRST registers
*
* @param[in] rtc_common Pointer to the register overlay for the RTC Common peripheral
*/
__STATIC_INLINE void DL_RTC_Common_disableWriteProtect(RTC_Regs *rtc_common)
{
rtc_common->RTCLOCK = (RTC_RTCLOCK_PROTECT_CLR | RTC_RTCLOCK_KEY_UNLOCK_W);
}
#endif
#ifdef __cplusplus
}
#endif
#endif /* __MSPM0_HAS_RTC_A__ || __MSPM0_HAS_RTC_B__ || __MSPM0_HAS_RTC__ */
#endif /* ti_dl_dl_rtc_common__include */
/** @}*/
Reference in New Issue View Git Blame Copy Permalink