1111 lines
46 KiB
C
1111 lines
46 KiB
C
/*
|
|
PDD layer implementation for peripheral type CMT
|
|
(C) 2013 Freescale, Inc. All rights reserved.
|
|
|
|
This file is static and it is generated from API-Factory
|
|
*/
|
|
|
|
#if !defined(CMT_PDD_H_)
|
|
#define CMT_PDD_H_
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- Test if supported MCU is active
|
|
---------------------------------------------------------------------------- */
|
|
|
|
#if !defined(MCU_ACTIVE)
|
|
// No MCU is active
|
|
#error CMT PDD library: No derivative is active. Place proper #include with PDD memory map before including PDD library.
|
|
#elif \
|
|
!defined(MCU_MK10D10) /* CMT */ && \
|
|
!defined(MCU_MK10D5) /* CMT */ && \
|
|
!defined(MCU_MK10D7) /* CMT */ && \
|
|
!defined(MCU_MK10F12) /* CMT */ && \
|
|
!defined(MCU_MK10DZ10) /* CMT */ && \
|
|
!defined(MCU_MK11D5) /* CMT */ && \
|
|
!defined(MCU_MK11D5WS) /* CMT */ && \
|
|
!defined(MCU_MK12D5) /* CMT */ && \
|
|
!defined(MCU_MK20D10) /* CMT */ && \
|
|
!defined(MCU_MK20D5) /* CMT */ && \
|
|
!defined(MCU_MK20D7) /* CMT */ && \
|
|
!defined(MCU_MK20F12) /* CMT */ && \
|
|
!defined(MCU_MK20DZ10) /* CMT */ && \
|
|
!defined(MCU_MK21D5) /* CMT */ && \
|
|
!defined(MCU_MK21D5WS) /* CMT */ && \
|
|
!defined(MCU_MK21F12) /* CMT */ && \
|
|
!defined(MCU_MK21F12WS) /* CMT */ && \
|
|
!defined(MCU_MK22D5) /* CMT */ && \
|
|
!defined(MCU_MK22F12) /* CMT */ && \
|
|
!defined(MCU_MK24F12) /* CMT */ && \
|
|
!defined(MCU_MK30D10) /* CMT */ && \
|
|
!defined(MCU_MK30D7) /* CMT */ && \
|
|
!defined(MCU_MK30DZ10) /* CMT */ && \
|
|
!defined(MCU_MK40D10) /* CMT */ && \
|
|
!defined(MCU_MK40D7) /* CMT */ && \
|
|
!defined(MCU_MK40DZ10) /* CMT */ && \
|
|
!defined(MCU_MK40X256VMD100) /* CMT */ && \
|
|
!defined(MCU_MK50D10) /* CMT */ && \
|
|
!defined(MCU_MK50D7) /* CMT */ && \
|
|
!defined(MCU_MK50DZ10) /* CMT */ && \
|
|
!defined(MCU_MK51D10) /* CMT */ && \
|
|
!defined(MCU_MK51D7) /* CMT */ && \
|
|
!defined(MCU_MK51DZ10) /* CMT */ && \
|
|
!defined(MCU_MK52D10) /* CMT */ && \
|
|
!defined(MCU_MK52DZ10) /* CMT */ && \
|
|
!defined(MCU_MK53D10) /* CMT */ && \
|
|
!defined(MCU_MK53DZ10) /* CMT */ && \
|
|
!defined(MCU_MK60D10) /* CMT */ && \
|
|
!defined(MCU_MK60F12) /* CMT */ && \
|
|
!defined(MCU_MK60F15) /* CMT */ && \
|
|
!defined(MCU_MK60DZ10) /* CMT */ && \
|
|
!defined(MCU_MK60N512VMD100) /* CMT */ && \
|
|
!defined(MCU_MK61F12) /* CMT */ && \
|
|
!defined(MCU_MK61F15) /* CMT */ && \
|
|
!defined(MCU_MK61F12WS) /* CMT */ && \
|
|
!defined(MCU_MK61F15WS) /* CMT */ && \
|
|
!defined(MCU_MK63F12) /* CMT */ && \
|
|
!defined(MCU_MK63F12WS) /* CMT */ && \
|
|
!defined(MCU_MK64F12) /* CMT */ && \
|
|
!defined(MCU_MK65F18) /* CMT */ && \
|
|
!defined(MCU_MK65F18WS) /* CMT */ && \
|
|
!defined(MCU_MK66F18) /* CMT */ && \
|
|
!defined(MCU_MK70F12) /* CMT */ && \
|
|
!defined(MCU_MK70F15) /* CMT */ && \
|
|
!defined(MCU_MK70F12WS) /* CMT */ && \
|
|
!defined(MCU_MK70F15WS) /* CMT */ && \
|
|
!defined(MCU_MKW21D5) /* CMT */ && \
|
|
!defined(MCU_MKW21D5WS) /* CMT */ && \
|
|
!defined(MCU_MKW22D5) /* CMT */ && \
|
|
!defined(MCU_MKW22D5WS) /* CMT */ && \
|
|
!defined(MCU_MKW24D5) /* CMT */ && \
|
|
!defined(MCU_MKW24D5WS) /* CMT */ && \
|
|
!defined(MCU_PCK20L4) /* CMT */
|
|
// Unsupported MCU is active
|
|
#error CMT PDD library: Unsupported derivative is active.
|
|
#endif
|
|
|
|
#include "PDD_Types.h"
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- Method symbol definitions
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/* Enable baseband constants */
|
|
#define CMT_PDD_BASEBAND_DISABLED 0U /**< Disabled */
|
|
#define CMT_PDD_BASEBAND_ENABLED CMT_MSC_BASE_MASK /**< Enabled */
|
|
|
|
/* Enable FSK constants */
|
|
#define CMT_PDD_MODE_TIME_BASEBAND 0U /**< Time baseband */
|
|
#define CMT_PDD_MODE_FSK CMT_MSC_FSK_MASK /**< FSK */
|
|
|
|
/* Divider constants */
|
|
#define CMT_PDD_DIVIDER_1 0U /**< 1 */
|
|
#define CMT_PDD_DIVIDER_2 0x1U /**< 2 */
|
|
#define CMT_PDD_DIVIDER_4 0x2U /**< 4 */
|
|
#define CMT_PDD_DIVIDER_8 0x3U /**< 8 */
|
|
|
|
/* Prescaler constants */
|
|
#define CMT_PDD_PRESCALER_1 0U /**< 1 */
|
|
#define CMT_PDD_PRESCALER_2 0x1U /**< 2 */
|
|
#define CMT_PDD_PRESCALER_3 0x2U /**< 3 */
|
|
#define CMT_PDD_PRESCALER_4 0x3U /**< 4 */
|
|
#define CMT_PDD_PRESCALER_5 0x4U /**< 5 */
|
|
#define CMT_PDD_PRESCALER_6 0x5U /**< 6 */
|
|
#define CMT_PDD_PRESCALER_7 0x6U /**< 7 */
|
|
#define CMT_PDD_PRESCALER_8 0x7U /**< 8 */
|
|
#define CMT_PDD_PRESCALER_9 0x8U /**< 9 */
|
|
#define CMT_PDD_PRESCALER_10 0x9U /**< 10 */
|
|
#define CMT_PDD_PRESCALER_11 0xAU /**< 11 */
|
|
#define CMT_PDD_PRESCALER_12 0xBU /**< 12 */
|
|
#define CMT_PDD_PRESCALER_13 0xCU /**< 13 */
|
|
#define CMT_PDD_PRESCALER_14 0xDU /**< 14 */
|
|
#define CMT_PDD_PRESCALER_15 0xEU /**< 15 */
|
|
#define CMT_PDD_PRESCALER_16 0xFU /**< 16 */
|
|
|
|
/* IRO pin constants */
|
|
#define CMT_PDD_PIN_DISABLED 0U /**< Disabled */
|
|
#define CMT_PDD_PIN_ENABLED CMT_OC_IROPEN_MASK /**< Enabled */
|
|
|
|
/* CMT output polarity constants */
|
|
#define CMT_PDD_POLARITY_LOW 0U /**< Low */
|
|
#define CMT_PDD_POLARITY_HIGH CMT_OC_CMTPOL_MASK /**< High */
|
|
|
|
/* IRO latch constants */
|
|
#define CMT_PDD_LATCH_LOW 0U /**< Low */
|
|
#define CMT_PDD_LATCH_HIGH CMT_OC_IROL_MASK /**< High */
|
|
|
|
/* Enable DMA constants */
|
|
#define CMT_PDD_DMA_DISABLED 0U /**< Disabled */
|
|
#define CMT_PDD_DMA_ENABLED CMT_DMA_DMA_MASK /**< Enabled */
|
|
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- GetInterruptMask
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns interrupt mask.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_GetInterruptMask(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_GetInterruptMask(PeripheralBase) ( \
|
|
(uint8)(CMT_MSC_REG(PeripheralBase) & CMT_MSC_EOCIE_MASK) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- GetInterruptFlag
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns interrupt flag bit.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_GetInterruptFlag(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_GetInterruptFlag(PeripheralBase) ( \
|
|
(uint8)(CMT_MSC_REG(PeripheralBase) & CMT_MSC_EOCF_MASK) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- EnableInterrupt
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Enables the CMT interrupt.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_EnableInterrupt(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_EnableInterrupt(PeripheralBase) ( \
|
|
CMT_MSC_REG(PeripheralBase) |= \
|
|
CMT_MSC_EOCIE_MASK \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- DisableInterrupt
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Disables the CMT interrupt.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_DisableInterrupt(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_DisableInterrupt(PeripheralBase) ( \
|
|
CMT_MSC_REG(PeripheralBase) &= \
|
|
(uint8)(~(uint8)CMT_MSC_EOCIE_MASK) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ClearInterruptFlag
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Clears CMT interrupt flag.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_MSC, CMT_CMD2
|
|
* (depending on the peripheral).
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_ClearInterruptFlag(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ClearInterruptFlag(PeripheralBase) ( \
|
|
(void)CMT_MSC_REG(PeripheralBase), \
|
|
(void)CMT_CMD2_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- EnableBaseband
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Configures the freerun mode.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Baseband New value of the baseband. Use constants from group "Enable
|
|
* baseband constants". This parameter is 8 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_EnableBaseband(<peripheral>_BASE_PTR,
|
|
* CMT_PDD_BASEBAND_DISABLED);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_EnableBaseband(PeripheralBase, Baseband) ( \
|
|
CMT_MSC_REG(PeripheralBase) = \
|
|
(uint8)(( \
|
|
(uint8)(CMT_MSC_REG(PeripheralBase) & (uint8)(~(uint8)CMT_MSC_BASE_MASK))) | ( \
|
|
(uint8)(Baseband))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- SelectFskMode
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Configures the mode operation.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Mode New value of the mode. Use constants from group "Enable FSK
|
|
* constants". This parameter is 8 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_SelectFskMode(<peripheral>_BASE_PTR,
|
|
* CMT_PDD_MODE_TIME_BASEBAND);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_SelectFskMode(PeripheralBase, Mode) ( \
|
|
CMT_MSC_REG(PeripheralBase) = \
|
|
(uint8)(( \
|
|
(uint8)(CMT_MSC_REG(PeripheralBase) & (uint8)(~(uint8)CMT_MSC_FSK_MASK))) | ( \
|
|
(uint8)(Mode))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- EnableExtendedSpace
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Configures extended space.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Extended Extended space enabled/disabled. 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: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_EnableExtendedSpace(<peripheral>_BASE_PTR, PDD_DISABLE);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_EnableExtendedSpace(PeripheralBase, Extended) ( \
|
|
CMT_MSC_REG(PeripheralBase) = \
|
|
(uint8)(( \
|
|
(uint8)(CMT_MSC_REG(PeripheralBase) & (uint8)(~(uint8)CMT_MSC_EXSPC_MASK))) | ( \
|
|
(uint8)((uint8)(Extended) << CMT_MSC_EXSPC_SHIFT))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- EnableDevice
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Enables the CMT device.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param State Requested state of CMT device. 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: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_EnableDevice(<peripheral>_BASE_PTR, PDD_DISABLE);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_EnableDevice(PeripheralBase, State) ( \
|
|
CMT_MSC_REG(PeripheralBase) = \
|
|
(uint8)(( \
|
|
(uint8)(CMT_MSC_REG(PeripheralBase) & (uint8)(~(uint8)CMT_MSC_MCGEN_MASK))) | ( \
|
|
(uint8)(State))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- GetEnableDeviceStatus
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns current state of CMT device.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_GetEnableDeviceStatus(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_GetEnableDeviceStatus(PeripheralBase) ( \
|
|
(uint8)(CMT_MSC_REG(PeripheralBase) & CMT_MSC_MCGEN_MASK) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- SetDivider
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Sets clock divide prescale value.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Divider New value of the divider. Use constants from group "Divider
|
|
* constants". This parameter is 2 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_SetDivider(<peripheral>_BASE_PTR, CMT_PDD_DIVIDER_1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_SetDivider(PeripheralBase, Divider) ( \
|
|
CMT_MSC_REG(PeripheralBase) = \
|
|
(uint8)(( \
|
|
(uint8)(CMT_MSC_REG(PeripheralBase) & (uint8)(~(uint8)CMT_MSC_CMTDIV_MASK))) | ( \
|
|
(uint8)((uint8)(Divider) << CMT_MSC_CMTDIV_SHIFT))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- SetPrescaler
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Sets primary prescale value.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Prescaler New value of the prescaler. Use constants from group
|
|
* "Prescaler constants". This parameter is 4 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_PPS.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_SetPrescaler(<peripheral>_BASE_PTR, CMT_PDD_PRESCALER_1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_SetPrescaler(PeripheralBase, Prescaler) ( \
|
|
CMT_PPS_REG(PeripheralBase) = \
|
|
(uint8)(Prescaler) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- EnableIroPin
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Enables IRO signal.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Pin New value of the IROpin. Use constants from group "IRO pin
|
|
* constants". This parameter is 8 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_OC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_EnableIroPin(<peripheral>_BASE_PTR, CMT_PDD_PIN_DISABLED);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_EnableIroPin(PeripheralBase, Pin) ( \
|
|
CMT_OC_REG(PeripheralBase) = \
|
|
(uint8)(( \
|
|
(uint8)(CMT_OC_REG(PeripheralBase) & (uint8)(~(uint8)CMT_OC_IROPEN_MASK))) | ( \
|
|
(uint8)(Pin))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- SetPolarity
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Configures CMT output polarity.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Polarity New value of the polarity. Use constants from group "CMT
|
|
* output polarity constants". This parameter is 8 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_OC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_SetPolarity(<peripheral>_BASE_PTR, CMT_PDD_POLARITY_LOW);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_SetPolarity(PeripheralBase, Polarity) ( \
|
|
CMT_OC_REG(PeripheralBase) = \
|
|
(uint8)(( \
|
|
(uint8)(CMT_OC_REG(PeripheralBase) & (uint8)(~(uint8)CMT_OC_CMTPOL_MASK))) | ( \
|
|
(uint8)(Polarity))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- SetLatch
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Configures IRO latch.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param State New value of the latch. Use constants from group "IRO latch
|
|
* constants". This parameter is 8 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_OC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_SetLatch(<peripheral>_BASE_PTR, CMT_PDD_LATCH_LOW);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_SetLatch(PeripheralBase, State) ( \
|
|
CMT_OC_REG(PeripheralBase) = \
|
|
(uint8)(( \
|
|
(uint8)(CMT_OC_REG(PeripheralBase) & (uint8)(~(uint8)CMT_OC_IROL_MASK))) | ( \
|
|
(uint8)(State))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- EnableDMA
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Configures the dma mode.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New value of the DMA. Use constants from group "Enable DMA
|
|
* constants". This parameter is 8 bits wide.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_DMA.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_EnableDMA(<peripheral>_BASE_PTR, CMT_PDD_DMA_DISABLED);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_EnableDMA(PeripheralBase, Value) ( \
|
|
CMT_DMA_REG(PeripheralBase) = \
|
|
(uint8)(( \
|
|
(uint8)(CMT_DMA_REG(PeripheralBase) & (uint8)(~(uint8)CMT_DMA_DMA_MASK))) | ( \
|
|
(uint8)(Value))) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteHighData1Reg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the CGH1 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the CGH1 register. This parameter is a 8-bit
|
|
* value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_CGH1.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WriteHighData1Reg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WriteHighData1Reg(PeripheralBase, Value) ( \
|
|
CMT_CGH1_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadHighData1Reg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the CGH1 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_CGH1.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadHighData1Reg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadHighData1Reg(PeripheralBase) ( \
|
|
CMT_CGH1_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteLowData1Reg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the CGL1 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the CGL1 register. This parameter is a 8-bit
|
|
* value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_CGL1.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WriteLowData1Reg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WriteLowData1Reg(PeripheralBase, Value) ( \
|
|
CMT_CGL1_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadLowData1Reg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the CGL1 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_CGL1.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadLowData1Reg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadLowData1Reg(PeripheralBase) ( \
|
|
CMT_CGL1_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteHighData2Reg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the CGH2 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the CGH2 register. This parameter is a 8-bit
|
|
* value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_CGH2.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WriteHighData2Reg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WriteHighData2Reg(PeripheralBase, Value) ( \
|
|
CMT_CGH2_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadHighData2Reg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the CGH2 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_CGH2.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadHighData2Reg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadHighData2Reg(PeripheralBase) ( \
|
|
CMT_CGH2_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteLowData2Reg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the CGL2 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the CGL2 register. This parameter is a 8-bit
|
|
* value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_CGL2.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WriteLowData2Reg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WriteLowData2Reg(PeripheralBase, Value) ( \
|
|
CMT_CGL2_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadLowData2Reg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the CGL2 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_CGL2.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadLowData2Reg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadLowData2Reg(PeripheralBase) ( \
|
|
CMT_CGL2_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteOutputControlReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the OC register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the OC register. This parameter is a 8-bit value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_OC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WriteOutputControlReg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WriteOutputControlReg(PeripheralBase, Value) ( \
|
|
CMT_OC_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadOutputControlReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the OC register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_OC.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadOutputControlReg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadOutputControlReg(PeripheralBase) ( \
|
|
CMT_OC_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteStatusControlReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the MSC register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the MSC register. This parameter is a 8-bit value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WriteStatusControlReg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WriteStatusControlReg(PeripheralBase, Value) ( \
|
|
CMT_MSC_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadStatusControlReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the MSC register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_MSC.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadStatusControlReg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadStatusControlReg(PeripheralBase) ( \
|
|
CMT_MSC_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteMarkHighReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the CMD1 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the CMD1 register. This parameter is a 8-bit
|
|
* value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_CMD1.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WriteMarkHighReg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WriteMarkHighReg(PeripheralBase, Value) ( \
|
|
CMT_CMD1_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadMarkHighReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the CMD1 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_CMD1.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadMarkHighReg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadMarkHighReg(PeripheralBase) ( \
|
|
CMT_CMD1_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteMarkLowReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the CMD2 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the CMD2 register. This parameter is a 8-bit
|
|
* value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_CMD2.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WriteMarkLowReg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WriteMarkLowReg(PeripheralBase, Value) ( \
|
|
CMT_CMD2_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadMarkLowReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the CMD2 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_CMD2.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadMarkLowReg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadMarkLowReg(PeripheralBase) ( \
|
|
CMT_CMD2_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteSpaceHighReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the CMD3 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the CMD3 register. This parameter is a 8-bit
|
|
* value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_CMD3.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WriteSpaceHighReg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WriteSpaceHighReg(PeripheralBase, Value) ( \
|
|
CMT_CMD3_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadSpaceHighReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the CMD3 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_CMD3.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadSpaceHighReg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadSpaceHighReg(PeripheralBase) ( \
|
|
CMT_CMD3_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteSpaceLowReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the CMD4 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the CMD4 register. This parameter is a 8-bit
|
|
* value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_CMD4.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WriteSpaceLowReg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WriteSpaceLowReg(PeripheralBase, Value) ( \
|
|
CMT_CMD4_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadSpaceLowReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the CMD4 register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_CMD4.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadSpaceLowReg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadSpaceLowReg(PeripheralBase) ( \
|
|
CMT_CMD4_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WritePrimaryPrescalerReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the PPS register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the PPS register. This parameter is a 8-bit value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_PPS.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WritePrimaryPrescalerReg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WritePrimaryPrescalerReg(PeripheralBase, Value) ( \
|
|
CMT_PPS_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadPrimaryPrescalerReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the PPS register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_PPS.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadPrimaryPrescalerReg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadPrimaryPrescalerReg(PeripheralBase) ( \
|
|
CMT_PPS_REG(PeripheralBase) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- WriteDMAReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Writes value to the DMA register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @param Value New content of the DMA register. This parameter is a 8-bit value.
|
|
* @return Returns a value of void type.
|
|
* @remarks The macro accesses the following registers: CMT_DMA.
|
|
* @par Example:
|
|
* @code
|
|
* CMT_PDD_WriteDMAReg(<peripheral>_BASE_PTR, 1);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_WriteDMAReg(PeripheralBase, Value) ( \
|
|
CMT_DMA_REG(PeripheralBase) = \
|
|
(uint8)(Value) \
|
|
)
|
|
|
|
/* ----------------------------------------------------------------------------
|
|
-- ReadDMAReg
|
|
---------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Returns the content of the DMA register.
|
|
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
|
* base address). You can use the constant defined in the registers
|
|
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
|
* the peripheral initialization component header file
|
|
* (<component_name>_DEVICE).
|
|
* @return Returns a 8-bit value.
|
|
* @remarks The macro accesses the following registers: CMT_DMA.
|
|
* @par Example:
|
|
* @code
|
|
* uint8 result = CMT_PDD_ReadDMAReg(<peripheral>_BASE_PTR);
|
|
* @endcode
|
|
*/
|
|
#define CMT_PDD_ReadDMAReg(PeripheralBase) ( \
|
|
CMT_DMA_REG(PeripheralBase) \
|
|
)
|
|
#endif /* #if defined(CMT_PDD_H_) */
|
|
|
|
/* CMT_PDD.h, eof. */
|