/* PDD layer implementation for peripheral type RTC (C) 2013 Freescale, Inc. All rights reserved. This file is static and it is generated from API-Factory */ #if !defined(RTC_PDD_H_) #define RTC_PDD_H_ /* ---------------------------------------------------------------------------- -- Test if supported MCU is active ---------------------------------------------------------------------------- */ #if !defined(MCU_ACTIVE) // No MCU is active #error RTC PDD library: No derivative is active. Place proper #include with PDD memory map before including PDD library. #elif \ !defined(MCU_MK10D10) /* RTC */ && \ !defined(MCU_MK10D5) /* RTC */ && \ !defined(MCU_MK10D7) /* RTC */ && \ !defined(MCU_MK10F12) /* RTC */ && \ !defined(MCU_MK10DZ10) /* RTC */ && \ !defined(MCU_MK11D5) /* RTC */ && \ !defined(MCU_MK11D5WS) /* RTC */ && \ !defined(MCU_MK12D5) /* RTC */ && \ !defined(MCU_MK20D10) /* RTC */ && \ !defined(MCU_MK20D5) /* RTC */ && \ !defined(MCU_MK20D7) /* RTC */ && \ !defined(MCU_MK20F12) /* RTC */ && \ !defined(MCU_MK20DZ10) /* RTC */ && \ !defined(MCU_MK21D5) /* RTC */ && \ !defined(MCU_MK21D5WS) /* RTC */ && \ !defined(MCU_MK21F12) /* RTC */ && \ !defined(MCU_MK21F12WS) /* RTC */ && \ !defined(MCU_MK22D5) /* RTC */ && \ !defined(MCU_MK22F12810) /* RTC */ && \ !defined(MCU_MK22F12) /* RTC */ && \ !defined(MCU_MK22F25612) /* RTC */ && \ !defined(MCU_MK22F51212) /* RTC */ && \ !defined(MCU_MK24F12) /* RTC */ && \ !defined(MCU_MK30D10) /* RTC */ && \ !defined(MCU_MK30D7) /* RTC */ && \ !defined(MCU_MK30DZ10) /* RTC */ && \ !defined(MCU_MK40D10) /* RTC */ && \ !defined(MCU_MK40D7) /* RTC */ && \ !defined(MCU_MK40DZ10) /* RTC */ && \ !defined(MCU_MK40X256VMD100) /* RTC */ && \ !defined(MCU_MK50D10) /* RTC */ && \ !defined(MCU_MK50D7) /* RTC */ && \ !defined(MCU_MK50DZ10) /* RTC */ && \ !defined(MCU_MK51D10) /* RTC */ && \ !defined(MCU_MK51D7) /* RTC */ && \ !defined(MCU_MK51DZ10) /* RTC */ && \ !defined(MCU_MK52D10) /* RTC */ && \ !defined(MCU_MK52DZ10) /* RTC */ && \ !defined(MCU_MK53D10) /* RTC */ && \ !defined(MCU_MK53DZ10) /* RTC */ && \ !defined(MCU_MK60D10) /* RTC */ && \ !defined(MCU_MK60F12) /* RTC */ && \ !defined(MCU_MK60F15) /* RTC */ && \ !defined(MCU_MK60DZ10) /* RTC */ && \ !defined(MCU_MK60N512VMD100) /* RTC */ && \ !defined(MCU_MK61F12) /* RTC */ && \ !defined(MCU_MK61F15) /* RTC */ && \ !defined(MCU_MK61F12WS) /* RTC */ && \ !defined(MCU_MK61F15WS) /* RTC */ && \ !defined(MCU_MK63F12) /* RTC */ && \ !defined(MCU_MK63F12WS) /* RTC */ && \ !defined(MCU_MK64F12) /* RTC */ && \ !defined(MCU_MK65F18) /* RTC */ && \ !defined(MCU_MK65F18WS) /* RTC */ && \ !defined(MCU_MK66F18) /* RTC */ && \ !defined(MCU_MK70F12) /* RTC */ && \ !defined(MCU_MK70F15) /* RTC */ && \ !defined(MCU_MK70F12WS) /* RTC */ && \ !defined(MCU_MK70F15WS) /* RTC */ && \ !defined(MCU_MKL03Z4) /* RTC */ && \ !defined(MCU_MKL04Z4) /* RTC */ && \ !defined(MCU_MKL05Z4) /* RTC */ && \ !defined(MCU_MKL14Z4) /* RTC */ && \ !defined(MCU_MKL15Z4) /* RTC */ && \ !defined(MCU_MKL16Z4) /* RTC */ && \ !defined(MCU_MKL24Z4) /* RTC */ && \ !defined(MCU_MKL25Z4) /* RTC */ && \ !defined(MCU_MKL26Z4) /* RTC */ && \ !defined(MCU_MKL34Z4) /* RTC */ && \ !defined(MCU_MKL36Z4) /* RTC */ && \ !defined(MCU_MKL46Z4) /* RTC */ && \ !defined(MCU_MKW01Z4) /* RTC */ && \ !defined(MCU_MKW21D5) /* RTC */ && \ !defined(MCU_MKW21D5WS) /* RTC */ && \ !defined(MCU_MKW22D5) /* RTC */ && \ !defined(MCU_MKW22D5WS) /* RTC */ && \ !defined(MCU_MKW24D5) /* RTC */ && \ !defined(MCU_MKW24D5WS) /* RTC */ && \ !defined(MCU_PCK20L4) /* RTC */ // Unsupported MCU is active #error RTC PDD library: Unsupported derivative is active. #endif #include "PDD_Types.h" /* ---------------------------------------------------------------------------- -- Method symbol definitions ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS))) /* Interrupt masks */ #define RTC_PDD_MOF_INT RTC_SR_MOF_MASK /**< Monotonic overflow interrupt mask */ #define RTC_PDD_TAF_INT RTC_SR_TAF_MASK /**< Alarm interrupt mask */ #define RTC_PDD_TOF_INT RTC_SR_TOF_MASK /**< Timer overflow interrupt mask */ #define RTC_PDD_TIF_INT RTC_SR_TIF_MASK /**< Time invalid interrupt mask */ #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK63F12)) || (defined(MCU_MK64F12)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKW01Z4)) || (defined(MCU_PCK20L4)) */ /* Interrupt masks */ #define RTC_PDD_TAF_INT RTC_SR_TAF_MASK /**< Alarm interrupt mask */ #define RTC_PDD_TOF_INT RTC_SR_TOF_MASK /**< Timer overflow interrupt mask */ #define RTC_PDD_TIF_INT RTC_SR_TIF_MASK /**< Time invalid interrupt mask */ #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK63F12)) || (defined(MCU_MK64F12)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKW01Z4)) || (defined(MCU_PCK20L4)) */ #if (defined(MCU_MK65F18WS)) /* Tamper interrupt masks */ #define RTC_PDD_TMF_INT RTC_TDR_TMF_MASK /**< Test mode tamper interrupt mask */ #define RTC_PDD_FSF_INT RTC_TDR_FSF_MASK /**< Flash security tamper interrupt mask */ #define RTC_PDD_TTF_INT RTC_TDR_TTF_MASK /**< Temperature tamper interrupt mask */ #define RTC_PDD_CTF_INT RTC_TDR_CTF_MASK /**< Clock tamper interrupt mask */ #define RTC_PDD_VTF_INT RTC_TDR_VTF_MASK /**< Volatge tamper interrupt mask */ #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5WS)) */ /* Tamper interrupt masks */ #define RTC_PDD_TMF_INT RTC_TDR_TMF_MASK /**< Test mode tamper interrupt mask */ #define RTC_PDD_FSF_INT RTC_TDR_FSF_MASK /**< Flash security tamper interrupt mask */ #define RTC_PDD_TTF_INT RTC_TDR_TTF_MASK /**< Temperature tamper interrupt mask */ #define RTC_PDD_CTF_INT RTC_TDR_CTF_MASK /**< Clock tamper interrupt mask */ #define RTC_PDD_VTF_INT RTC_TDR_VTF_MASK /**< Volatge tamper interrupt mask */ #define RTC_PDD_DTF_INT RTC_TDR_DTF_MASK /**< DryIce tamper interrupt mask */ #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5WS)) */ /* WakeUpPinState constants */ #define RTC_PDD_ASSERTED 0x8U /**< Pin is asserted */ #define RTC_PDD_NOT_ASSERTED 0U /**< Pin is not asserted */ /* ---------------------------------------------------------------------------- -- ReadTimeSecondsReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Time seconds register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_TSR. * @par Example: * @code * uint32 result = RTC_PDD_ReadTimeSecondsReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadTimeSecondsReg(PeripheralBase) ( \ RTC_TSR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteTimeSecondsReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Time seconds register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Time seconds register. This parameter is a * 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TSR. * @par Example: * @code * RTC_PDD_WriteTimeSecondsReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteTimeSecondsReg(PeripheralBase, Value) ( \ RTC_TSR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadTimePrescalerReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Time prescaler register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_TPR. * @par Example: * @code * uint32 result = RTC_PDD_ReadTimePrescalerReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadTimePrescalerReg(PeripheralBase) ( \ RTC_TPR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteTimePrescalerReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Time prescaler register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Time prescaler register. This parameter is * a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TPR. * @par Example: * @code * RTC_PDD_WriteTimePrescalerReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteTimePrescalerReg(PeripheralBase, Value) ( \ RTC_TPR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadTimeAlarmReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Time alarm register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_TAR. * @par Example: * @code * uint32 result = RTC_PDD_ReadTimeAlarmReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadTimeAlarmReg(PeripheralBase) ( \ RTC_TAR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteTimeAlarmReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Time alarm register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Time alarm register. This parameter is a * 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TAR. * @par Example: * @code * RTC_PDD_WriteTimeAlarmReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteTimeAlarmReg(PeripheralBase, Value) ( \ RTC_TAR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadTimeCompensationReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Time compensation register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_TCR. * @par Example: * @code * uint32 result = * RTC_PDD_ReadTimeCompensationReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadTimeCompensationReg(PeripheralBase) ( \ RTC_TCR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteTimeCompensationReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Time compensation register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Time compensation register. This parameter * is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TCR. * @par Example: * @code * RTC_PDD_WriteTimeCompensationReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteTimeCompensationReg(PeripheralBase, Value) ( \ RTC_TCR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadControlReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Control register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_CR. * @par Example: * @code * uint32 result = RTC_PDD_ReadControlReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadControlReg(PeripheralBase) ( \ RTC_CR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteControlReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Control register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Control register. This parameter is a * 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_CR. * @par Example: * @code * RTC_PDD_WriteControlReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteControlReg(PeripheralBase, Value) ( \ RTC_CR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- EnableUpdateMode ---------------------------------------------------------------------------- */ /** * @brief Enables/disables update mode. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. This parameter is of "Global enumeration used * for specifying general enable/disable states (PDD_DISABLE and PDD_ENABLE * defined in PDD_Types.h)" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_CR. * @par Example: * @code * RTC_PDD_EnableUpdateMode(_BASE_PTR, PDD_DISABLE); * @endcode */ #define RTC_PDD_EnableUpdateMode(PeripheralBase, State) ( \ ((State) == PDD_DISABLE) ? ( \ RTC_CR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_CR_REG(PeripheralBase) | RTC_CR_UM_MASK)) & ( \ (uint32)(~(uint32)0x4000U)))) : ( \ RTC_CR_REG(PeripheralBase) &= \ (uint32)((uint32)(~(uint32)RTC_CR_UM_MASK) & (uint32)(~(uint32)0x4000U))) \ ) /* ---------------------------------------------------------------------------- -- EnableSupervisorAccess ---------------------------------------------------------------------------- */ /** * @brief Enables/disables supervisor accesss. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. This parameter is of "Global enumeration used * for specifying general enable/disable states (PDD_DISABLE and PDD_ENABLE * defined in PDD_Types.h)" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_CR. * @par Example: * @code * RTC_PDD_EnableSupervisorAccess(_BASE_PTR, PDD_DISABLE); * @endcode */ #define RTC_PDD_EnableSupervisorAccess(PeripheralBase, State) ( \ ((State) == PDD_DISABLE) ? ( \ RTC_CR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_CR_REG(PeripheralBase) | RTC_CR_SUP_MASK)) & ( \ (uint32)(~(uint32)0x4000U)))) : ( \ RTC_CR_REG(PeripheralBase) &= \ (uint32)((uint32)(~(uint32)RTC_CR_SUP_MASK) & (uint32)(~(uint32)0x4000U))) \ ) /* ---------------------------------------------------------------------------- -- EnableWakeupPin ---------------------------------------------------------------------------- */ /** * @brief Enables/disables wakeup pin. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. This parameter is of "Global enumeration used * for specifying general enable/disable states (PDD_DISABLE and PDD_ENABLE * defined in PDD_Types.h)" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_CR. * @par Example: * @code * RTC_PDD_EnableWakeupPin(_BASE_PTR, PDD_DISABLE); * @endcode */ #define RTC_PDD_EnableWakeupPin(PeripheralBase, State) ( \ ((State) == PDD_DISABLE) ? ( \ RTC_CR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_CR_REG(PeripheralBase) | RTC_CR_WPE_MASK)) & ( \ (uint32)(~(uint32)0x4000U)))) : ( \ RTC_CR_REG(PeripheralBase) &= \ (uint32)((uint32)(~(uint32)RTC_CR_WPE_MASK) & (uint32)(~(uint32)0x4000U))) \ ) /* ---------------------------------------------------------------------------- -- ForceSwReset ---------------------------------------------------------------------------- */ /** * @brief Forces the equivalent of a VBAT POR to the rest of the RTC module, * except the access control registers. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_CR. * @par Example: * @code * RTC_PDD_ForceSwReset(_BASE_PTR); * @endcode */ #define RTC_PDD_ForceSwReset(PeripheralBase) ( \ (RTC_CR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_CR_REG(PeripheralBase) | RTC_CR_SWR_MASK)) & ( \ (uint32)(~(uint32)0x4000U)))), \ (RTC_CR_REG(PeripheralBase) &= \ (uint32)((uint32)(~(uint32)RTC_CR_SWR_MASK) & (uint32)(~(uint32)0x4000U))) \ ) /* ---------------------------------------------------------------------------- -- GetRtcInterruptMask ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the RTC interrupt enable register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * uint32 result = RTC_PDD_GetRtcInterruptMask(_BASE_PTR); * @endcode */ #define RTC_PDD_GetRtcInterruptMask(PeripheralBase) ( \ RTC_IER_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- SetRtcInterruptMask ---------------------------------------------------------------------------- */ /** * @brief Enables RTC interrupts defined by the Mask parameter. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Mask Imterrupt mask. This parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * RTC_PDD_SetRtcInterruptMask(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_SetRtcInterruptMask(PeripheralBase, Mask) ( \ RTC_IER_REG(PeripheralBase) = \ (uint32)(Mask) \ ) /* ---------------------------------------------------------------------------- -- EnableSecondsInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Seconds interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * RTC_PDD_EnableSecondsInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_EnableSecondsInterrupt(PeripheralBase) ( \ RTC_IER_REG(PeripheralBase) |= \ RTC_IER_TSIE_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableAlarmInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Alarm interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * RTC_PDD_EnableAlarmInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_EnableAlarmInterrupt(PeripheralBase) ( \ RTC_IER_REG(PeripheralBase) |= \ RTC_IER_TAIE_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableTimeOverflowInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Time overflow interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * RTC_PDD_EnableTimeOverflowInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_EnableTimeOverflowInterrupt(PeripheralBase) ( \ RTC_IER_REG(PeripheralBase) |= \ RTC_IER_TOIE_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableTimeInvalidInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Time invalid interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * RTC_PDD_EnableTimeInvalidInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_EnableTimeInvalidInterrupt(PeripheralBase) ( \ RTC_IER_REG(PeripheralBase) |= \ RTC_IER_TIIE_MASK \ ) /* ---------------------------------------------------------------------------- -- DisableSecondsInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Seconds interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * RTC_PDD_DisableSecondsInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableSecondsInterrupt(PeripheralBase) ( \ RTC_IER_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_IER_TSIE_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableAlarmInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Alarm interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * RTC_PDD_DisableAlarmInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableAlarmInterrupt(PeripheralBase) ( \ RTC_IER_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_IER_TAIE_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableTimeOverflowInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Time overflow interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * RTC_PDD_DisableTimeOverflowInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeOverflowInterrupt(PeripheralBase) ( \ RTC_IER_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_IER_TOIE_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableTimeInvalidInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Time invalid interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * RTC_PDD_DisableTimeInvalidInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeInvalidInterrupt(PeripheralBase) ( \ RTC_IER_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_IER_TIIE_MASK) \ ) /* ---------------------------------------------------------------------------- -- SetWakeUpPinState ---------------------------------------------------------------------------- */ /** * @brief Sets wake-up pin state. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. This parameter is of "WakeUpPinState constants" * type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_SR. * @par Example: * @code * RTC_PDD_SetWakeUpPinState(_BASE_PTR, RTC_PDD_ASSERTED); * @endcode */ #define RTC_PDD_SetWakeUpPinState(PeripheralBase, State) ( \ RTC_SR_REG(PeripheralBase) = \ (uint32)(State) \ ) /* ---------------------------------------------------------------------------- -- ReadStatusReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Status register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Use constants from group "Interrupt masks" for processing return * value. * @remarks The macro accesses the following registers: RTC_SR. * @par Example: * @code * uint32 result = RTC_PDD_ReadStatusReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadStatusReg(PeripheralBase) ( \ RTC_SR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteStatusReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS))) /** * @brief Writes value to the Status register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Status register. Use constants from group * "Interrupt masks". This parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_SR. * @par Example: * @code * RTC_PDD_WriteStatusReg(_BASE_PTR, RTC_PDD_MOF_INT); * @endcode */ #define RTC_PDD_WriteStatusReg(PeripheralBase, Value) ( \ RTC_SR_REG(PeripheralBase) = \ (uint32)(Value) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK63F12)) || (defined(MCU_MK64F12)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKW01Z4)) || (defined(MCU_PCK20L4)) */ /** * @brief Writes value to the Status register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Status register. Use constants from group * "Interrupt masks". This parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_SR. * @par Example: * @code * RTC_PDD_WriteStatusReg(_BASE_PTR, RTC_PDD_TAF_INT); * @endcode */ #define RTC_PDD_WriteStatusReg(PeripheralBase, Value) ( \ RTC_SR_REG(PeripheralBase) = \ (uint32)(Value) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK63F12)) || (defined(MCU_MK64F12)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKW01Z4)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- EnableCounter ---------------------------------------------------------------------------- */ /** * @brief Enables/disables seconds counter. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. This parameter is of "Global enumeration used * for specifying general enable/disable states (PDD_DISABLE and PDD_ENABLE * defined in PDD_Types.h)" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_SR. * @par Example: * @code * RTC_PDD_EnableCounter(_BASE_PTR, PDD_DISABLE); * @endcode */ #define RTC_PDD_EnableCounter(PeripheralBase, State) ( \ ((State) == PDD_DISABLE) ? ( \ RTC_SR_REG(PeripheralBase) = \ 0U) : ( \ RTC_SR_REG(PeripheralBase) = \ 0x10U) \ ) /* ---------------------------------------------------------------------------- -- GetEnableCounterStatus ---------------------------------------------------------------------------- */ /** * @brief Returns zero if the Time counter is disabled else return non-zero * value. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_SR. * @par Example: * @code * uint32 result = RTC_PDD_GetEnableCounterStatus(_BASE_PTR); * @endcode */ #define RTC_PDD_GetEnableCounterStatus(PeripheralBase) ( \ (uint32)(RTC_SR_REG(PeripheralBase) & RTC_SR_TCE_MASK) \ ) /* ---------------------------------------------------------------------------- -- ReadLockReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Lock register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * uint32 result = RTC_PDD_ReadLockReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadLockReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteLockReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Lock register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Lock register. This parameter is a 32-bit * value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_WriteLockReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteLockReg(PeripheralBase, Value) ( \ RTC_LR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- LockStatusReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockStatusReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockStatusReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_LR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_LR_SRL_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKW01Z4)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockStatusReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockStatusReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_LR_SRL_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKW01Z4)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- LockControlReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockControlReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockControlReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_LR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_LR_CRL_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKW01Z4)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockControlReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockControlReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_LR_CRL_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKW01Z4)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- LockTimeComensationReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockTimeComensationReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockTimeComensationReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_LR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_LR_TCL_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKW01Z4)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockTimeComensationReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockTimeComensationReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_LR_TCL_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKW01Z4)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- ReadWriteAccessReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Write access register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * uint32 result = RTC_PDD_ReadWriteAccessReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadWriteAccessReg(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteWriteAccessReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Write access register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Write access register. This parameter is a * 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_WriteWriteAccessReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteWriteAccessReg(PeripheralBase, Value) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- DisableInterruptEnableRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableInterruptEnableRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableInterruptEnableRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_IERW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableInterruptEnableRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableInterruptEnableRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_IERW_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableLockRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableLockRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableLockRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_LRW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableLockRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableLockRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_LRW_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableStatusRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableStatusRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableStatusRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_SRW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableStatusRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableStatusRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_SRW_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableControlRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableControlRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableControlRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_CRW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableControlRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableControlRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_CRW_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableTimeCompensationRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTimeCompensationRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeCompensationRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_TCRW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTimeCompensationRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeCompensationRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_TCRW_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableTimeAlarmRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTimeAlarmRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeAlarmRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_TARW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTimeAlarmRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeAlarmRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_TARW_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableTimePrescalerRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTimePrescalerRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimePrescalerRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_TPRW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTimePrescalerRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimePrescalerRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_TPRW_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableTimeSecondsRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTimeSecondsRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeSecondsRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_TSRW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTimeSecondsRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeSecondsRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_TSRW_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- ReadReadAccessReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Read access register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * uint32 result = RTC_PDD_ReadReadAccessReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadReadAccessReg(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteReadAccessReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Read access register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Read access register. This parameter is a * 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_WriteReadAccessReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteReadAccessReg(PeripheralBase, Value) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- DisableInterruptEnableRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableInterruptEnableRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableInterruptEnableRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_IERR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableInterruptEnableRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableInterruptEnableRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_IERR_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableLockRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableLockRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableLockRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_LRR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableLockRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableLockRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_LRR_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableStatusRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableStatusRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableStatusRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_SRR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableStatusRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableStatusRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_SRR_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableControlRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableControlRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableControlRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_CRR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableControlRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableControlRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_CRR_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableTimeCompensationRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTimeCompensationRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeCompensationRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_TCRR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTimeCompensationRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeCompensationRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_TCRR_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableTimeAlarmRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTimeAlarmRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeAlarmRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_TARR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTimeAlarmRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeAlarmRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_TARR_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableTimePrescalerRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTimePrescalerRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimePrescalerRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_TPRR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTimePrescalerRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimePrescalerRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_TPRR_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- DisableTimeSecondsRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTimeSecondsRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeSecondsRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_TSRR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTimeSecondsRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTimeSecondsRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_TSRR_MASK) \ ) #endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */ /* ---------------------------------------------------------------------------- -- EnableMonotonicOverflowInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Monotonic counter overflow interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * RTC_PDD_EnableMonotonicOverflowInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_EnableMonotonicOverflowInterrupt(PeripheralBase) ( \ RTC_IER_REG(PeripheralBase) |= \ RTC_IER_MOIE_MASK \ ) /* ---------------------------------------------------------------------------- -- DisableMonotonicOverflowInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Monotonic counter overflow interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_IER. * @par Example: * @code * RTC_PDD_DisableMonotonicOverflowInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicOverflowInterrupt(PeripheralBase) ( \ RTC_IER_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_IER_MOIE_MASK) \ ) /* ---------------------------------------------------------------------------- -- LockMonotonicCounterHighReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockMonotonicCounterHighReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockMonotonicCounterHighReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_LR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_LR_MCHL_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockMonotonicCounterHighReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockMonotonicCounterHighReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_LR_MCHL_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- LockMonotonicCounterLowReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockMonotonicCounterLowReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockMonotonicCounterLowReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_LR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_LR_MCLL_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockMonotonicCounterLowReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockMonotonicCounterLowReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_LR_MCLL_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- LockMonotonicEnableReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockMonotonicEnableReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockMonotonicEnableReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_LR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_LR_MEL_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockMonotonicEnableReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockMonotonicEnableReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_LR_MEL_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- LockTamperTimeSecondsReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockTamperTimeSecondsReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockTamperTimeSecondsReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_LR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_LR_TTSL_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockTamperTimeSecondsReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockTamperTimeSecondsReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_LR_TTSL_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- ReadTamperTimeSecondsReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Tamper time seconds register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_TTSR. * @par Example: * @code * uint32 result = * RTC_PDD_ReadTamperTimeSecondsReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadTamperTimeSecondsReg(PeripheralBase) ( \ RTC_TTSR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- GetTamperTime ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Tamper time in seconds. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_TTSR. * @par Example: * @code * uint32 result = RTC_PDD_GetTamperTime(_BASE_PTR); * @endcode */ #define RTC_PDD_GetTamperTime(PeripheralBase) ( \ RTC_TTSR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadMonotonicEnableReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Monotonic enable register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_MER. * @par Example: * @code * uint32 result = RTC_PDD_ReadMonotonicEnableReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadMonotonicEnableReg(PeripheralBase) ( \ RTC_MER_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteMonotonicEnableReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Monotonic enable register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Monotonic enable register. This parameter * is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_MER. * @par Example: * @code * RTC_PDD_WriteMonotonicEnableReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteMonotonicEnableReg(PeripheralBase, Value) ( \ RTC_MER_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- EnableMonotonicCounter ---------------------------------------------------------------------------- */ /** * @brief Enables/disables Monotonis counter counter. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param State Requested state. This parameter is of "Global enumeration used * for specifying general enable/disable states (PDD_DISABLE and PDD_ENABLE * defined in PDD_Types.h)" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_MER. * @par Example: * @code * RTC_PDD_EnableMonotonicCounter(_BASE_PTR, PDD_DISABLE); * @endcode */ #define RTC_PDD_EnableMonotonicCounter(PeripheralBase, State) ( \ ((State) == PDD_DISABLE) ? ( \ RTC_MER_REG(PeripheralBase) = \ 0U) : ( \ RTC_MER_REG(PeripheralBase) = \ 0x10U) \ ) /* ---------------------------------------------------------------------------- -- GetMonotonicCounterEnableStatus ---------------------------------------------------------------------------- */ /** * @brief Returns zero if the Monotonic counter is disabled else return non-zero * value. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_MER. * @par Example: * @code * uint32 result = * RTC_PDD_GetMonotonicCounterEnableStatus(_BASE_PTR); * @endcode */ #define RTC_PDD_GetMonotonicCounterEnableStatus(PeripheralBase) ( \ (uint32)(RTC_MER_REG(PeripheralBase) & RTC_MER_MCE_MASK) \ ) /* ---------------------------------------------------------------------------- -- ReadMonotonicCounterHighReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Monotonic counter high register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_MCHR. * @par Example: * @code * uint32 result = * RTC_PDD_ReadMonotonicCounterHighReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadMonotonicCounterHighReg(PeripheralBase) ( \ RTC_MCHR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteMonotonicCounterHigReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Monotonic counter high register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Monotonic counter high register. This * parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_MCHR. * @par Example: * @code * RTC_PDD_WriteMonotonicCounterHigReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteMonotonicCounterHigReg(PeripheralBase, Value) ( \ RTC_MCHR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadMonotonicCounterLowReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Monotonic counter low register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_MCLR. * @par Example: * @code * uint32 result = * RTC_PDD_ReadMonotonicCounterLowReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadMonotonicCounterLowReg(PeripheralBase) ( \ RTC_MCLR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteMonotonicCounterLowgReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Monotonic counter low register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Monotonic counter low register. This * parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_MCLR. * @par Example: * @code * RTC_PDD_WriteMonotonicCounterLowgReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteMonotonicCounterLowgReg(PeripheralBase, Value) ( \ RTC_MCLR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- DisableMonotonicCounterHighRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableMonotonicCounterHighRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicCounterHighRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_MCHW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableMonotonicCounterHighRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicCounterHighRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_MCHW_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- DisableMonotonicCounterLowRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableMonotonicCounterLowRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicCounterLowRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_MCLW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableMonotonicCounterLowRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicCounterLowRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_MCLW_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- DisableMonotonicEnableRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableMonotonicEnableRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicEnableRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_MERW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableMonotonicEnableRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicEnableRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_MERW_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- DisableTamperTimeSecondsRegWrite ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTamperTimeSecondsRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperTimeSecondsRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_WAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_WAR_TTSW_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTamperTimeSecondsRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperTimeSecondsRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_TTSW_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- DisableMonotonicCounterHighRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableMonotonicCounterHighRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicCounterHighRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_MCHR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableMonotonicCounterHighRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicCounterHighRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_MCHR_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- DisableMonotonicCounterLowRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableMonotonicCounterLowRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicCounterLowRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_MCLR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableMonotonicCounterLowRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicCounterLowRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_MCLR_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- DisableMonotonicEnableRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableMonotonicEnableRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicEnableRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_MERR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableMonotonicEnableRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableMonotonicEnableRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_MERR_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- DisableTamperTimeSecondsRegRead ---------------------------------------------------------------------------- */ #if ((defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21F12)) || (defined(MCU_MK22D5)) || (defined(MCU_MK22F12)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F15)) || (defined(MCU_MK66F18)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F15))) /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTamperTimeSecondsRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperTimeSecondsRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(RTC_RAR_REG(PeripheralBase) & (uint32)(~(uint32)RTC_RAR_TTSR_MASK))) | ( \ 0xF000U)) \ ) #else /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTamperTimeSecondsRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperTimeSecondsRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_TTSR_MASK) \ ) #endif /* (defined(MCU_MK11D5WS)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) */ /* ---------------------------------------------------------------------------- -- LockTamperInterruptReg ---------------------------------------------------------------------------- */ /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockTamperInterruptReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockTamperInterruptReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_LR_TIL_MASK) \ ) /* ---------------------------------------------------------------------------- -- LockTamperTrimReg ---------------------------------------------------------------------------- */ /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockTamperTrimReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockTamperTrimReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_LR_TTL_MASK) \ ) /* ---------------------------------------------------------------------------- -- LockTamperDetectReg ---------------------------------------------------------------------------- */ /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockTamperDetectReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockTamperDetectReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_LR_TDL_MASK) \ ) /* ---------------------------------------------------------------------------- -- LockTamperEnableReg ---------------------------------------------------------------------------- */ /** * @brief The lock register is used to block write accesses to certain registers * until the next VBAT_POR or software reset.Write accesses to a locked register * are ignored and do not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_LR. * @par Example: * @code * RTC_PDD_LockTamperEnableReg(_BASE_PTR); * @endcode */ #define RTC_PDD_LockTamperEnableReg(PeripheralBase) ( \ RTC_LR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_LR_TEL_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetRtcTamperInterruptMask ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the RTC tamper interrupt register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * uint32 result = * RTC_PDD_GetRtcTamperInterruptMask(_BASE_PTR); * @endcode */ #define RTC_PDD_GetRtcTamperInterruptMask(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- SetRtcTamperInterruptMask ---------------------------------------------------------------------------- */ /** * @brief Enables RTC tamper interrupts defined by the Mask parameter. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Mask Imterrupt mask. This parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_SetRtcTamperInterruptMask(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_SetRtcTamperInterruptMask(PeripheralBase, Mask) ( \ RTC_TIR_REG(PeripheralBase) = \ (uint32)(Mask) \ ) /* ---------------------------------------------------------------------------- -- EnableTestModeInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Test mode interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_EnableTestModeInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_EnableTestModeInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) |= \ RTC_TIR_TMIE_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableFlashSecurityInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Flash security interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_EnableFlashSecurityInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_EnableFlashSecurityInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) |= \ RTC_TIR_FSIE_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableTemperatureTamperInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Temperature tamper interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_EnableTemperatureTamperInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_EnableTemperatureTamperInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) |= \ RTC_TIR_TTIE_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableClockTamperInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Clock tamper interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_EnableClockTamperInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_EnableClockTamperInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) |= \ RTC_TIR_CTIE_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableVolatgeTamperInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the Voltage tamper interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_EnableVolatgeTamperInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_EnableVolatgeTamperInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) |= \ RTC_TIR_VTIE_MASK \ ) /* ---------------------------------------------------------------------------- -- EnableDryIceTamperInterrupt ---------------------------------------------------------------------------- */ /** * @brief Enables the DryIce tamper interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_EnableDryIceTamperInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_EnableDryIceTamperInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) |= \ RTC_TIR_DTIE_MASK \ ) /* ---------------------------------------------------------------------------- -- DisableTestModeInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Test mode interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_DisableTestModeInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTestModeInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_TIR_TMIE_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableFlashSecurityInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Flash security interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_DisableFlashSecurityInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableFlashSecurityInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_TIR_FSIE_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableTemperatureTamperInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Temperature tamper interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_DisableTemperatureTamperInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTemperatureTamperInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_TIR_TTIE_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableClockTamperInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Clock tamper interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_DisableClockTamperInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableClockTamperInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_TIR_CTIE_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableVolatgeTamperInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the Voltage tamper interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_DisableVolatgeTamperInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableVolatgeTamperInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_TIR_VTIE_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableDryIceTamperInterrupt ---------------------------------------------------------------------------- */ /** * @brief Disables the DryIce tamper interrupt. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TIR. * @par Example: * @code * RTC_PDD_DisableDryIceTamperInterrupt(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableDryIceTamperInterrupt(PeripheralBase) ( \ RTC_TIR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_TIR_DTIE_MASK) \ ) /* ---------------------------------------------------------------------------- -- ReadTamperDetectReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Tamper detect register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_TDR. * @par Example: * @code * uint32 result = RTC_PDD_ReadTamperDetectReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadTamperDetectReg(PeripheralBase) ( \ RTC_TDR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteTamperDetectReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Tamper detect register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Tamper detect register. This parameter is a * 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TDR. * @par Example: * @code * RTC_PDD_WriteTamperDetectReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteTamperDetectReg(PeripheralBase, Value) ( \ RTC_TDR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- DisableTamperInterruptRegWrite ---------------------------------------------------------------------------- */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTamperInterruptRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperInterruptRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_TIRW_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableTamperTrimRegWrite ---------------------------------------------------------------------------- */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTamperTrimRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperTrimRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_TTRW_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableTamperDetectRegWrite ---------------------------------------------------------------------------- */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTamperDetectRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperDetectRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_TDRW_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableTamperEnableRegWrite ---------------------------------------------------------------------------- */ /** * @brief Disables write accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_WAR. * @par Example: * @code * RTC_PDD_DisableTamperEnableRegWrite(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperEnableRegWrite(PeripheralBase) ( \ RTC_WAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_WAR_TERW_MASK) \ ) /* ---------------------------------------------------------------------------- -- ReadTamperTrimReg ---------------------------------------------------------------------------- */ /** * @brief Returns the content of the Tamper trim register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: RTC_TTR. * @par Example: * @code * uint32 result = RTC_PDD_ReadTamperTrimReg(_BASE_PTR); * @endcode */ #define RTC_PDD_ReadTamperTrimReg(PeripheralBase) ( \ RTC_TTR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- WriteTamperTrimReg ---------------------------------------------------------------------------- */ /** * @brief Writes value to the Tamper trim register. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param Value Value written to the Tamper trim register. This parameter is a * 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_TTR. * @par Example: * @code * RTC_PDD_WriteTamperTrimReg(_BASE_PTR, 1); * @endcode */ #define RTC_PDD_WriteTamperTrimReg(PeripheralBase, Value) ( \ RTC_TTR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- DisableTamperInterruptRegRead ---------------------------------------------------------------------------- */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTamperInterruptRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperInterruptRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_TIRR_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableTamperTrimRegRead ---------------------------------------------------------------------------- */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTamperTrimRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperTrimRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_TTRR_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableTamperDetectRegRead ---------------------------------------------------------------------------- */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTamperDetectRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperDetectRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_TDRR_MASK) \ ) /* ---------------------------------------------------------------------------- -- DisableTamperEnableRegRead ---------------------------------------------------------------------------- */ /** * @brief Disables read accesses to the register until the next chip system * reset. When accesses are blocked the bus access is not seen in the VBAT power * supply and does not generate a bus error. * @param PeripheralBase Pointer to a peripheral registers structure (peripheral * base address). You can use the constant defined in the registers * definition header file (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @return Returns a value of void type. * @remarks The macro accesses the following registers: RTC_RAR. * @par Example: * @code * RTC_PDD_DisableTamperEnableRegRead(_BASE_PTR); * @endcode */ #define RTC_PDD_DisableTamperEnableRegRead(PeripheralBase) ( \ RTC_RAR_REG(PeripheralBase) &= \ (uint32)(~(uint32)RTC_RAR_TERR_MASK) \ ) #endif /* #if defined(RTC_PDD_H_) */ /* RTC_PDD.h, eof. */