/* PDD layer implementation for peripheral type PORT (C) 2013 Freescale, Inc. All rights reserved. This file is static and it is generated from API-Factory */ #if !defined(PORT_PDD_H_) #define PORT_PDD_H_ /* ---------------------------------------------------------------------------- -- Test if supported MCU is active ---------------------------------------------------------------------------- */ #if !defined(MCU_ACTIVE) // No MCU is active #error PORT PDD library: No derivative is active. Place proper #include with PDD memory map before including PDD library. #elif \ !defined(MCU_MK10D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK10D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK10D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK10F12) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MK10DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK11D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK11D5WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK12D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK20D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK20D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK20D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK20F12) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MK20DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK21D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK21D5WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK21F12) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK21F12WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK22D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK22F12810) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK22F12) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK22F25612) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK22F51212) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK24F12) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK30D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK30D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK30DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK40D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK40D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK40DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK40X256VMD100) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK50D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK50D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK50DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK51D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK51D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK51DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK52D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK52DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK53D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK53DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK60D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK60F12) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MK60F15) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MK60DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK60N512VMD100) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK61F12) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MK61F15) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MK61F12WS) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MK61F15WS) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MK63F12) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK63F12WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK64F12) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK65F18) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK65F18WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK66F18) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MK70F12) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MK70F15) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MK70F12WS) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MK70F15WS) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \ !defined(MCU_MKE02Z2) /* PORT */ && \ !defined(MCU_MKE02Z4) /* PORT */ && \ !defined(MCU_SKEAZN642) /* PORT */ && \ !defined(MCU_MKE04Z1284) /* PORT */ && \ !defined(MCU_MKE04Z4) /* PORT */ && \ !defined(MCU_SKEAZN84) /* PORT */ && \ !defined(MCU_MKE06Z4) /* PORT */ && \ !defined(MCU_MKL02Z4) /* PORTA, PORTB */ && \ !defined(MCU_MKL03Z4) /* PORTA, PORTB */ && \ !defined(MCU_MKL04Z4) /* PORTA, PORTB */ && \ !defined(MCU_MKL05Z4) /* PORTA, PORTB */ && \ !defined(MCU_MKL14Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKL15Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKL16Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKL24Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKL25Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKL26Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKL34Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKL36Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKL46Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKV10Z7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKV31F12810) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKV31F25612) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKV31F51212) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKW01Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKW21D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKW21D5WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKW22D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKW22D5WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKW24D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_MKW24D5WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_PCK20L4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \ !defined(MCU_SKEAZ1284) /* PORT */ // Unsupported MCU is active #error PORT PDD library: Unsupported derivative is active. #endif #include "PDD_Types.h" /* ---------------------------------------------------------------------------- -- Method symbol definitions ---------------------------------------------------------------------------- */ /* Pin masks */ #define PORT_PDD_PIN_0 0x1U /**< Pin 0 mask */ #define PORT_PDD_PIN_1 0x2U /**< Pin 1 mask */ #define PORT_PDD_PIN_2 0x4U /**< Pin 2 mask */ #define PORT_PDD_PIN_3 0x8U /**< Pin 3 mask */ #define PORT_PDD_PIN_4 0x10U /**< Pin 4 mask */ #define PORT_PDD_PIN_5 0x20U /**< Pin 5 mask */ #define PORT_PDD_PIN_6 0x40U /**< Pin 6 mask */ #define PORT_PDD_PIN_7 0x80U /**< Pin 7 mask */ #define PORT_PDD_PIN_8 0x100U /**< Pin 8 mask */ #define PORT_PDD_PIN_9 0x200U /**< Pin 9 mask */ #define PORT_PDD_PIN_10 0x400U /**< Pin 10 mask */ #define PORT_PDD_PIN_11 0x800U /**< Pin 11 mask */ #define PORT_PDD_PIN_12 0x1000U /**< Pin 12 mask */ #define PORT_PDD_PIN_13 0x2000U /**< Pin 13 mask */ #define PORT_PDD_PIN_14 0x4000U /**< Pin 14 mask */ #define PORT_PDD_PIN_15 0x8000U /**< Pin 15 mask */ #define PORT_PDD_PIN_16 0x10000U /**< Pin 16 mask */ #define PORT_PDD_PIN_17 0x20000U /**< Pin 17 mask */ #define PORT_PDD_PIN_18 0x40000U /**< Pin 18 mask */ #define PORT_PDD_PIN_19 0x80000U /**< Pin 19 mask */ #define PORT_PDD_PIN_20 0x100000U /**< Pin 20 mask */ #define PORT_PDD_PIN_21 0x200000U /**< Pin 21 mask */ #define PORT_PDD_PIN_22 0x400000U /**< Pin 22 mask */ #define PORT_PDD_PIN_23 0x800000U /**< Pin 23 mask */ #define PORT_PDD_PIN_24 0x1000000U /**< Pin 24 mask */ #define PORT_PDD_PIN_25 0x2000000U /**< Pin 25 mask */ #define PORT_PDD_PIN_26 0x4000000U /**< Pin 26 mask */ #define PORT_PDD_PIN_27 0x8000000U /**< Pin 27 mask */ #define PORT_PDD_PIN_28 0x10000000U /**< Pin 28 mask */ #define PORT_PDD_PIN_29 0x20000000U /**< Pin 29 mask */ #define PORT_PDD_PIN_30 0x40000000U /**< Pin 30 mask */ #define PORT_PDD_PIN_31 0x80000000U /**< Pin 31 mask */ #if ((defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN84))) /* List of pins offering high drive capability */ #define PORT_PDD_PTB5 0x2U /**< PTB5 mask */ #define PORT_PDD_PTC1 0x4U /**< PTC1 mask */ #define PORT_PDD_PTC5 0x8U /**< PTC5 mask */ #else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) */ /* List of pins offering high drive capability */ #define PORT_PDD_PTB4 0x1U /**< PTB4 mask */ #define PORT_PDD_PTB5 0x2U /**< PTB5 mask */ #define PORT_PDD_PTD0 0x4U /**< PTD0 mask */ #define PORT_PDD_PTD1 0x8U /**< PTD1 mask */ #define PORT_PDD_PTE0 0x10U /**< PTE0 mask */ #define PORT_PDD_PTE1 0x20U /**< PTE1 mask */ #define PORT_PDD_PTH0 0x40U /**< PTH0 mask */ #define PORT_PDD_PTH1 0x80U /**< PTH1 mask */ #endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) */ /* Filter selection */ #define PORT_PDD_NO_FILTER 0U /**< No filter */ #define PORT_PDD_BUSCLK 0U /**< BUSCLK */ #define PORT_PDD_FLTDIV1 0x1U /**< FLTDIV1 */ #define PORT_PDD_FLTDIV2 0x2U /**< FLTDIV2 */ #define PORT_PDD_FLTDIV3 0x3U /**< FLTDIV3 */ #if ((defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN84))) /* Modules offering input pin filtering capability */ #define PORT_PDD_PTA 0U /**< Selects filter for input from PTA */ #define PORT_PDD_PTB 0x2U /**< Selects filter for input from PTB */ #define PORT_PDD_PTC 0x4U /**< Selects filter for input from PTC */ #define PORT_PDD_RST 0x10U /**< Selects filter for input from RST */ #define PORT_PDD_KBI0 0x12U /**< Selects filter for input from KBI0 */ #define PORT_PDD_KBI1 0x14U /**< Selects filter for input from KBI1 */ #define PORT_PDD_NMI 0x16U /**< Selects filter for input from NMI */ #define PORT_PDD_IIC 0xAU /**< Selects filter for input from IIC */ #define PORT_PDD_FTM0 0xCU /**< Selects filter for input from FTM0 */ #define PORT_PDD_PWT 0xEU /**< Selects filter for input from PWT */ #elif ((defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_SKEAZN642))) /* Modules offering input pin filtering capability */ #define PORT_PDD_PTA 0U /**< Selects filter for input from PTA */ #define PORT_PDD_PTB 0x2U /**< Selects filter for input from PTB */ #define PORT_PDD_PTC 0x4U /**< Selects filter for input from PTC */ #define PORT_PDD_PTD 0x6U /**< Selects filter for input from PTD */ #define PORT_PDD_PTE 0x8U /**< Selects filter for input from PTE */ #define PORT_PDD_PTF 0xAU /**< Selects filter for input from PTF */ #define PORT_PDD_PTG 0xCU /**< Selects filter for input from PTG */ #define PORT_PDD_PTH 0xEU /**< Selects filter for input from PTH */ #define PORT_PDD_RST 0x10U /**< Selects filter for input from RST */ #define PORT_PDD_KBI0 0x12U /**< Selects filter for input from KBI0 */ #define PORT_PDD_KBI1 0x14U /**< Selects filter for input from KBI1 */ #define PORT_PDD_NMI 0x16U /**< Selects filter for input from NMI */ #else /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */ /* Modules offering input pin filtering capability */ #define PORT_PDD_PTA 0U /**< Selects filter for input from PTA */ #define PORT_PDD_PTB 0x2U /**< Selects filter for input from PTB */ #define PORT_PDD_PTC 0x4U /**< Selects filter for input from PTC */ #define PORT_PDD_PTD 0x6U /**< Selects filter for input from PTD */ #define PORT_PDD_PTE 0x8U /**< Selects filter for input from PTE */ #define PORT_PDD_PTF 0xAU /**< Selects filter for input from PTF */ #define PORT_PDD_PTG 0xCU /**< Selects filter for input from PTG */ #define PORT_PDD_PTH 0xEU /**< Selects filter for input from PTH */ #define PORT_PDD_RST 0x10U /**< Selects filter for input from RST */ #define PORT_PDD_KBI0 0x12U /**< Selects filter for input from KBI0 */ #define PORT_PDD_KBI1 0x14U /**< Selects filter for input from KBI1 */ #define PORT_PDD_NMI 0x16U /**< Selects filter for input from NMI */ #define PORT_PDD_PTI 0U /**< Selects filter for input from PTI */ #define PORT_PDD_IRQ 0x4U /**< Selects filter for input from IRQ */ #define PORT_PDD_FTM0 0x6U /**< Selects filter for input from FTM0 */ #define PORT_PDD_FTM1 0x8U /**< Selects filter for input from FTM1 */ #define PORT_PDD_PWT 0xAU /**< Selects filter for input from PWT */ #define PORT_PDD_I2C0 0xCU /**< Selects filter for input from I2C0 */ #define PORT_PDD_I2C1 0xEU /**< Selects filter for input from I2C1 */ #endif /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */ /* Constants for pull type selection */ #define PORT_PDD_PULL_DOWN 0U /**< Pull down */ #define PORT_PDD_PULL_UP 0x1U /**< Pull up */ /* Constants for pull enabling/disabling */ #define PORT_PDD_PULL_DISABLE 0U /**< Pull resistor disabled */ #define PORT_PDD_PULL_ENABLE 0x2U /**< Pull resistor enabled */ /* Constants for slew rate setting */ #define PORT_PDD_SLEW_RATE_FAST 0U /**< Fast slew rate */ #define PORT_PDD_SLEW_RATE_SLOW 0x4U /**< Slow slew rate */ /* Constants for slew rate setting */ #define PORT_PDD_PASSIVE_FILTER_DISABLE 0U /**< Passive filter disabled */ #define PORT_PDD_PASSIVE_FILTER_ENABLE 0x10U /**< Passive filter enabled */ /* Constants for open drain setting */ #define PORT_PDD_OPEN_DRAIN_DISABLE 0U /**< Open drain disabled */ #define PORT_PDD_OPEN_DRAIN_ENABLE 0x20U /**< Open drain enabled */ /* Constants for drive strength setting */ #define PORT_PDD_DRIVE_STRENGTH_LOW 0U /**< Low drive strength */ #define PORT_PDD_DRIVE_STRENGTH_HIGH 0x40U /**< High drive strength */ /* Constants for mux control setting */ #define PORT_PDD_MUX_CONTROL_DISABLE 0U /**< Mux control disabled */ #define PORT_PDD_MUX_CONTROL_ALT1 0x100U /**< Pin used with alternate 1 functionality */ #define PORT_PDD_MUX_CONTROL_ALT2 0x200U /**< Pin used with alternate 2 functionality */ #define PORT_PDD_MUX_CONTROL_ALT3 0x300U /**< Pin used with alternate 3 functionality */ #define PORT_PDD_MUX_CONTROL_ALT4 0x400U /**< Pin used with alternate 4 functionality */ #define PORT_PDD_MUX_CONTROL_ALT5 0x500U /**< Pin used with alternate 5 functionality */ #define PORT_PDD_MUX_CONTROL_ALT6 0x600U /**< Pin used with alternate 6 functionality */ #define PORT_PDD_MUX_CONTROL_ALT7 0x700U /**< Pin used with alternate 7 functionality */ /* Constants for pin lock setting */ #define PORT_PDD_PIN_CONTROL_UNLOCK 0U /**< Pin control unlocked */ #define PORT_PDD_PIN_CONTROL_LOCK 0x8000U /**< Pin control locked */ /* Constants for interrupt configuration setting */ #define PORT_PDD_INTERRUPT_DMA_DISABLED 0U /**< Interrupt and DMA disabled */ #define PORT_PDD_DMA_ON_RISING 0x10000U /**< DMA enabled on rising edge */ #define PORT_PDD_DMA_ON_FALLING 0x20000U /**< DMA enabled on falling edge */ #define PORT_PDD_DMA_ON_RISING_FALLING 0x30000U /**< DMA enabled on rising and falling edges */ #define PORT_PDD_INTERRUPT_ON_ZERO 0x80000U /**< Interrupt enabled on low level */ #define PORT_PDD_INTERRUPT_ON_RISING 0x90000U /**< Interrupt enabled on rising edge */ #define PORT_PDD_INTERRUPT_ON_FALLING 0xA0000U /**< Interrupt enabled on falling edge */ #define PORT_PDD_INTERRUPT_ON_RISING_FALLING 0xB0000U /**< Interrupt enabled on rising and falling edges */ #define PORT_PDD_INTERRUPT_ON_ONE 0xC0000U /**< Interrupt enabled on high level */ /* Constants for digital clock source setting */ #define PORT_PDD_BUS_CLOCK 0U /**< Bus clock as filter clock source */ #define PORT_PDD_LPO_CLOCK 0x1U /**< LPO clock as filter clock source */ /* Constants for Filter Division Set 1 */ #define PORT_PDD_BUSCLK_DIV_2 0U /**< BUSCLK/2 */ #define PORT_PDD_BUSCLK_DIV_4 0x1000000U /**< BUSCLK/4 */ #define PORT_PDD_BUSCLK_DIV_8 0x2000000U /**< BUSCLK/8 */ #define PORT_PDD_BUSCLK_DIV_16 0x3000000U /**< BUSCLK/16 */ /* Constants for Filter Division Set 2 */ #define PORT_PDD_BUSCLK_DIV_32 0U /**< BUSCLK/32 */ #define PORT_PDD_BUSCLK_DIV_64 0x4000000U /**< BUSCLK/64 */ #define PORT_PDD_BUSCLK_DIV_128 0x8000000U /**< BUSCLK/128 */ #define PORT_PDD_BUSCLK_DIV_256 0xC000000U /**< BUSCLK/256 */ #define PORT_PDD_BUSCLK_DIV_512 0x10000000U /**< BUSCLK/512 */ #define PORT_PDD_BUSCLK_DIV_1024 0x14000000U /**< BUSCLK/1024 */ #define PORT_PDD_BUSCLK_DIV_2048 0x18000000U /**< BUSCLK/2048 */ #define PORT_PDD_BUSCLK_DIV_4096 0x1C000000U /**< BUSCLK/4096 */ /* Constants for Filter Division Set 3 */ #define PORT_PDD_LPOCLK 0U /**< LPOCLK */ #define PORT_PDD_LPOCLK_DIV_2 0x20000000U /**< LPOCLK/2 */ #define PORT_PDD_LPOCLK_DIV_4 0x40000000U /**< LPOCLK/4 */ #define PORT_PDD_LPOCLK_DIV_8 0x60000000U /**< LPOCLK/8 */ #define PORT_PDD_LPOCLK_DIV_16 0x80000000U /**< LPOCLK/16 */ #define PORT_PDD_LPOCLK_DIV_32 0xA0000000U /**< LPOCLK/32 */ #define PORT_PDD_LPOCLK_DIV_64 0xC0000000U /**< LPOCLK/64 */ #define PORT_PDD_LPOCLK_DIV_128 0xE0000000U /**< LPOCLK/128 */ /* ---------------------------------------------------------------------------- -- GetPinPullSelect ---------------------------------------------------------------------------- */ /** * @brief Gets which pull resistor is selected. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @return Returns a value of "Constants for pull type selection" type. The * value is cast to "uint32". * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * uint32 result = PORT_PDD_GetPinPullSelect(_BASE_PTR, * periphID); * @endcode */ #define PORT_PDD_GetPinPullSelect(PeripheralBase, PinIndex) ( \ (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_PS_MASK) \ ) /* ---------------------------------------------------------------------------- -- SetPinPullSelect ---------------------------------------------------------------------------- */ /** * @brief Sets pull type. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @param Type Pull type. This parameter is of "Constants for pull type * selection" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * PORT_PDD_SetPinPullSelect(_BASE_PTR, periphID, * PORT_PDD_PULL_DOWN); * @endcode */ #define PORT_PDD_SetPinPullSelect(PeripheralBase, PinIndex, Type) ( \ PORT_PCR_REG(PeripheralBase,(PinIndex)) = \ (uint32)(( \ (uint32)(( \ PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \ (uint32)(~(uint32)PORT_PCR_PS_MASK)) & ( \ (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \ (uint32)(Type))) \ ) /* ---------------------------------------------------------------------------- -- GetPinPullEnable ---------------------------------------------------------------------------- */ /** * @brief Gets whether pull resistor is enabled. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @return Returns a value of "Constants for pull enabling/disabling" type. The * value is cast to "uint32". * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * uint32 result = PORT_PDD_GetPinPullEnable(_BASE_PTR, * periphID); * @endcode */ #define PORT_PDD_GetPinPullEnable(PeripheralBase, PinIndex) ( \ (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_PE_MASK) \ ) /* ---------------------------------------------------------------------------- -- SetPinPullEnable ---------------------------------------------------------------------------- */ /** * @brief Sets pull type. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @param State Requested state of pull enable. This parameter is of "Constants * for pull enabling/disabling" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * PORT_PDD_SetPinPullEnable(_BASE_PTR, periphID, * PORT_PDD_PULL_DISABLE); * @endcode */ #define PORT_PDD_SetPinPullEnable(PeripheralBase, PinIndex, State) ( \ PORT_PCR_REG(PeripheralBase,(PinIndex)) = \ (uint32)(( \ (uint32)(( \ PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \ (uint32)(~(uint32)PORT_PCR_PE_MASK)) & ( \ (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \ (uint32)(State))) \ ) /* ---------------------------------------------------------------------------- -- GetPinSlewRate ---------------------------------------------------------------------------- */ /** * @brief Gets how slew rate is set. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @return Returns a value of "Constants for slew rate setting" type. The value * is cast to "uint32". * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * uint32 result = PORT_PDD_GetPinSlewRate(_BASE_PTR, * periphID); * @endcode */ #define PORT_PDD_GetPinSlewRate(PeripheralBase, PinIndex) ( \ (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_SRE_MASK) \ ) /* ---------------------------------------------------------------------------- -- SetPinSlewRate ---------------------------------------------------------------------------- */ /** * @brief Sets slew rate. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @param State Requested state of slew rate. This parameter is of "Constants * for slew rate setting" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * PORT_PDD_SetPinSlewRate(_BASE_PTR, periphID, * PORT_PDD_SLEW_RATE_FAST); * @endcode */ #define PORT_PDD_SetPinSlewRate(PeripheralBase, PinIndex, State) ( \ PORT_PCR_REG(PeripheralBase,(PinIndex)) = \ (uint32)(( \ (uint32)(( \ PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \ (uint32)(~(uint32)PORT_PCR_SRE_MASK)) & ( \ (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \ (uint32)(State))) \ ) /* ---------------------------------------------------------------------------- -- GetPinPassiveFilter ---------------------------------------------------------------------------- */ /** * @brief Gets whether passive filter is enabled. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @return Returns a value of "Constants for slew rate setting" type. The value * is cast to "uint32". * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * uint32 result = PORT_PDD_GetPinPassiveFilter(_BASE_PTR, * periphID); * @endcode */ #define PORT_PDD_GetPinPassiveFilter(PeripheralBase, PinIndex) ( \ (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_PFE_MASK) \ ) /* ---------------------------------------------------------------------------- -- SetPinPassiveFilter ---------------------------------------------------------------------------- */ /** * @brief Sets passive filter. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @param State Requested state of passive filter. This parameter is of * "Constants for slew rate setting" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * PORT_PDD_SetPinPassiveFilter(_BASE_PTR, periphID, * PORT_PDD_PASSIVE_FILTER_DISABLE); * @endcode */ #define PORT_PDD_SetPinPassiveFilter(PeripheralBase, PinIndex, State) ( \ PORT_PCR_REG(PeripheralBase,(PinIndex)) = \ (uint32)(( \ (uint32)(( \ PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \ (uint32)(~(uint32)PORT_PCR_PFE_MASK)) & ( \ (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \ (uint32)(State))) \ ) /* ---------------------------------------------------------------------------- -- GetPinOpenDrain ---------------------------------------------------------------------------- */ /** * @brief Gets whether open drain is enabled. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @return Returns a value of "Constants for open drain setting" type. The value * is cast to "uint32". * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * uint32 result = PORT_PDD_GetPinOpenDrain(_BASE_PTR, * periphID); * @endcode */ #define PORT_PDD_GetPinOpenDrain(PeripheralBase, PinIndex) ( \ (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_ODE_MASK) \ ) /* ---------------------------------------------------------------------------- -- SetPinOpenDrain ---------------------------------------------------------------------------- */ /** * @brief Sets open drain. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @param State Requested state of open drain. This parameter is of "Constants * for open drain setting" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * PORT_PDD_SetPinOpenDrain(_BASE_PTR, periphID, * PORT_PDD_OPEN_DRAIN_DISABLE); * @endcode */ #define PORT_PDD_SetPinOpenDrain(PeripheralBase, PinIndex, State) ( \ PORT_PCR_REG(PeripheralBase,(PinIndex)) = \ (uint32)(( \ (uint32)(( \ PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \ (uint32)(~(uint32)PORT_PCR_ODE_MASK)) & ( \ (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \ (uint32)(State))) \ ) /* ---------------------------------------------------------------------------- -- GetPinDriverStrength ---------------------------------------------------------------------------- */ /** * @brief Gets how drive strength is set. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @return Returns a value of "Constants for drive strength setting" type. The * value is cast to "uint32". * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * uint32 result = PORT_PDD_GetPinDriverStrength(_BASE_PTR, * periphID); * @endcode */ #define PORT_PDD_GetPinDriverStrength(PeripheralBase, PinIndex) ( \ (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_DSE_MASK) \ ) /* ---------------------------------------------------------------------------- -- SetPinDriveStrength ---------------------------------------------------------------------------- */ /** * @brief Sets drive strength. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @param State Requested state of drive strength. This parameter is of * "Constants for drive strength setting" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * PORT_PDD_SetPinDriveStrength(_BASE_PTR, periphID, * PORT_PDD_DRIVE_STRENGTH_LOW); * @endcode */ #define PORT_PDD_SetPinDriveStrength(PeripheralBase, PinIndex, State) ( \ PORT_PCR_REG(PeripheralBase,(PinIndex)) = \ (uint32)(( \ (uint32)(( \ PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \ (uint32)(~(uint32)PORT_PCR_DSE_MASK)) & ( \ (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \ (uint32)(State))) \ ) /* ---------------------------------------------------------------------------- -- GetPinMuxControl ---------------------------------------------------------------------------- */ /** * @brief Gets how mux control is set. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @return Returns a value of "Constants for mux control setting" type. The * value is cast to "uint32". * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * uint32 result = PORT_PDD_GetPinMuxControl(_BASE_PTR, * periphID); * @endcode */ #define PORT_PDD_GetPinMuxControl(PeripheralBase, PinIndex) ( \ (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_MUX_MASK) \ ) /* ---------------------------------------------------------------------------- -- SetPinMuxControl ---------------------------------------------------------------------------- */ /** * @brief Sets mux control. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @param State Requested state of Mux control. This parameter is of "Constants * for mux control setting" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * PORT_PDD_SetPinMuxControl(_BASE_PTR, periphID, * PORT_PDD_MUX_CONTROL_DISABLE); * @endcode */ #define PORT_PDD_SetPinMuxControl(PeripheralBase, PinIndex, State) ( \ PORT_PCR_REG(PeripheralBase,(PinIndex)) = \ (uint32)(( \ (uint32)(( \ PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \ (uint32)(~(uint32)PORT_PCR_MUX_MASK)) & ( \ (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \ (uint32)(State))) \ ) /* ---------------------------------------------------------------------------- -- GetPinControlLock ---------------------------------------------------------------------------- */ /** * @brief Gets how pin lock is set. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @return Returns a value of "Constants for pin lock setting" type. The value * is cast to "uint32". * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * uint32 result = PORT_PDD_GetPinControlLock(_BASE_PTR, * periphID); * @endcode */ #define PORT_PDD_GetPinControlLock(PeripheralBase, PinIndex) ( \ (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_LK_MASK) \ ) /* ---------------------------------------------------------------------------- -- LockPinControl ---------------------------------------------------------------------------- */ /** * @brief Locks pin control such as settings of pull, slew rate, passive filter, * open drain, mux control and pin lock. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @param State Requested state of pin lock. This parameter is of "Constants for * pin lock setting" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * PORT_PDD_LockPinControl(_BASE_PTR, periphID, * PORT_PDD_PIN_CONTROL_UNLOCK); * @endcode */ #define PORT_PDD_LockPinControl(PeripheralBase, PinIndex, State) ( \ PORT_PCR_REG(PeripheralBase,(PinIndex)) = \ (uint32)(( \ (uint32)(( \ PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \ (uint32)(~(uint32)PORT_PCR_LK_MASK)) & ( \ (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \ (uint32)(State))) \ ) /* ---------------------------------------------------------------------------- -- GetPinInterruptConfiguration ---------------------------------------------------------------------------- */ /** * @brief Gets how interupt configuration is set. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @return Returns a value of "Constants for interrupt configuration setting" * type. The value is cast to "uint32". * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * uint32 result = * PORT_PDD_GetPinInterruptConfiguration(_BASE_PTR, periphID); * @endcode */ #define PORT_PDD_GetPinInterruptConfiguration(PeripheralBase, PinIndex) ( \ (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_IRQC_MASK) \ ) /* ---------------------------------------------------------------------------- -- SetPinInterruptConfiguration ---------------------------------------------------------------------------- */ /** * @brief Sets interrupt configuration. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @param State Requested state of interrupt configuration. This parameter is of * "Constants for interrupt configuration setting" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * PORT_PDD_SetPinInterruptConfiguration(_BASE_PTR, periphID, * PORT_PDD_INTERRUPT_DMA_DISABLED); * @endcode */ #define PORT_PDD_SetPinInterruptConfiguration(PeripheralBase, PinIndex, State) ( \ PORT_PCR_REG(PeripheralBase,(PinIndex)) = \ (uint32)(( \ (uint32)(( \ PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \ (uint32)(~(uint32)PORT_PCR_IRQC_MASK)) & ( \ (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \ (uint32)(State))) \ ) /* ---------------------------------------------------------------------------- -- GetPinInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Returns interrupt flags. * @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 PinIndex Pin index inside the port. This parameter is of index type. * @return Returns a 32-bit value. * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * uint32 result = PORT_PDD_GetPinInterruptFlag(_BASE_PTR, * periphID); * @endcode */ #define PORT_PDD_GetPinInterruptFlag(PeripheralBase, PinIndex) ( \ (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_ISF_MASK) \ ) /* ---------------------------------------------------------------------------- -- GetInterruptFlags ---------------------------------------------------------------------------- */ /** * @brief Returns interrupt flags. * @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: PORTA_ISFR, PORTB_ISFR, * PORTC_ISFR, PORTD_ISFR, PORTE_ISFR, PORTF_ISFR (depending on the * peripheral). * @par Example: * @code * uint32 result = PORT_PDD_GetInterruptFlags(_BASE_PTR); * @endcode */ #define PORT_PDD_GetInterruptFlags(PeripheralBase) ( \ PORT_ISFR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ClearPinInterruptFlag ---------------------------------------------------------------------------- */ /** * @brief Clears 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 (_BASE_PTR) or the constant defined in * the peripheral initialization component header file * (_DEVICE). * @param PinIndex Pin index inside the port. This parameter is of index type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PCR[PinIndex]. * @par Example: * @code * PORT_PDD_ClearPinInterruptFlag(_BASE_PTR, periphID); * @endcode */ #define PORT_PDD_ClearPinInterruptFlag(PeripheralBase, PinIndex) ( \ PORT_PCR_REG(PeripheralBase,(PinIndex)) |= \ PORT_PCR_ISF_MASK \ ) /* ---------------------------------------------------------------------------- -- ClearInterruptFlags ---------------------------------------------------------------------------- */ /** * @brief Clears interrupt flag bits defined by 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 Mask of pins to clearing theirs interrupt flags. Use constants * from group "Pin masks". This parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORTA_ISFR, PORTB_ISFR, * PORTC_ISFR, PORTD_ISFR, PORTE_ISFR, PORTF_ISFR (depending on the * peripheral). * @par Example: * @code * PORT_PDD_ClearInterruptFlags(_BASE_PTR, PORT_PDD_PIN_0); * @endcode */ #define PORT_PDD_ClearInterruptFlags(PeripheralBase, Mask) ( \ PORT_ISFR_REG(PeripheralBase) = \ (uint32)(Mask) \ ) /* ---------------------------------------------------------------------------- -- SetGlobalPinControl ---------------------------------------------------------------------------- */ /** * @brief Sets required pin control for required pins of whole port. * @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 Mask of pins in port where the bit 0 corresponds with the pin * which has index 0 within the port and the bit 31 corresponds with the pin * which has index 31 within the port. This parameter is a 32-bit value. * @param Value Settings of pull, slew rate, passive filter, open drain, mux * control and pin lock . This parameter is a 16-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORTA_GPCLR, * PORTA_GPCHR, PORTB_GPCLR, PORTB_GPCHR, PORTC_GPCLR, PORTC_GPCHR, PORTD_GPCLR, * PORTD_GPCHR, PORTE_GPCLR, PORTE_GPCHR, PORTF_GPCLR, PORTF_GPCHR * (depending on the peripheral). * @par Example: * @code * PORT_PDD_SetGlobalPinControl(_BASE_PTR, 1, 1); * @endcode */ #define PORT_PDD_SetGlobalPinControl(PeripheralBase, Mask, Value) ( \ (PORT_GPCLR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)((uint32)((uint32)(Mask) & 0xFFFFU) << PORT_GPCLR_GPWE_SHIFT)) | ( \ (uint32)(Value)))), \ (PORT_GPCHR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)((uint32)(Mask) & (uint32)(~(uint32)0xFFFFU))) | ( \ (uint32)(Value)))) \ ) /* ---------------------------------------------------------------------------- -- SetGlobalPinControlLow ---------------------------------------------------------------------------- */ /** * @brief Sets required pin control for required pins from low part of port. * @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 Mask of pins in port where the bit 0 corresponds with the pin * which has index 0 within the port and the bit 15 corresponds with the pin * which has index 15 within the port. This parameter is a 16-bit value. * @param Value Settings of pull, slew rate, passive filter, open drain, mux * control and pin lock . This parameter is a 16-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORTA_GPCLR, * PORTB_GPCLR, PORTC_GPCLR, PORTD_GPCLR, PORTE_GPCLR, PORTF_GPCLR (depending on * the peripheral). * @par Example: * @code * PORT_PDD_SetGlobalPinControlLow(_BASE_PTR, 1, 1); * @endcode */ #define PORT_PDD_SetGlobalPinControlLow(PeripheralBase, Mask, Value) ( \ PORT_GPCLR_REG(PeripheralBase) = \ (uint32)((uint32)((uint32)(Mask) << PORT_GPCLR_GPWE_SHIFT) | (uint32)(Value)) \ ) /* ---------------------------------------------------------------------------- -- SetGlobalPinControlHigh ---------------------------------------------------------------------------- */ /** * @brief Sets required pin control for required pins from high part of port. * @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 Mask of pins in port where the bit 0 corresponds with the pin * which has index 16 within the port and the bit 15 corresponds with the pin * which has index 31 within the port. This parameter is a 16-bit value. * @param Value Settings of pull, slew rate, passive filter, open drain, mux * control and pin lock . This parameter is a 16-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORTA_GPCHR, * PORTB_GPCHR, PORTC_GPCHR, PORTD_GPCHR, PORTE_GPCHR, PORTF_GPCHR (depending on * the peripheral). * @par Example: * @code * PORT_PDD_SetGlobalPinControlHigh(_BASE_PTR, 1, 1); * @endcode */ #define PORT_PDD_SetGlobalPinControlHigh(PeripheralBase, Mask, Value) ( \ PORT_GPCHR_REG(PeripheralBase) = \ (uint32)((uint32)((uint32)(Mask) << PORT_GPCHR_GPWE_SHIFT) | (uint32)(Value)) \ ) /* ---------------------------------------------------------------------------- -- GetEnableDigitalFilterStatusMask ---------------------------------------------------------------------------- */ /** * @brief Returns enable status of digital filter for whole port. * @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: PORTA_DFER, PORTB_DFER, * PORTC_DFER, PORTD_DFER, PORTE_DFER, PORTF_DFER (depending on the * peripheral). * @par Example: * @code * uint32 result = * PORT_PDD_GetEnableDigitalFilterStatusMask(_BASE_PTR); * @endcode */ #define PORT_PDD_GetEnableDigitalFilterStatusMask(PeripheralBase) ( \ PORT_DFER_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- EnableDigitalFilters ---------------------------------------------------------------------------- */ /** * @brief Enables digital filters. * @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 Mask of pins. Use constants from group "Pin masks". This * parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORTA_DFER, PORTB_DFER, * PORTC_DFER, PORTD_DFER, PORTE_DFER, PORTF_DFER (depending on the * peripheral). * @par Example: * @code * PORT_PDD_EnableDigitalFilters(_BASE_PTR, PORT_PDD_PIN_0); * @endcode */ #define PORT_PDD_EnableDigitalFilters(PeripheralBase, Mask) ( \ PORT_DFER_REG(PeripheralBase) |= \ (uint32)(Mask) \ ) /* ---------------------------------------------------------------------------- -- DisableDigitalFilters ---------------------------------------------------------------------------- */ /** * @brief Disables digital filters. * @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 Mask of pins. Use constants from group "Pin masks". This * parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORTA_DFER, PORTB_DFER, * PORTC_DFER, PORTD_DFER, PORTE_DFER, PORTF_DFER (depending on the * peripheral). * @par Example: * @code * PORT_PDD_DisableDigitalFilters(_BASE_PTR, PORT_PDD_PIN_0); * @endcode */ #define PORT_PDD_DisableDigitalFilters(PeripheralBase, Mask) ( \ PORT_DFER_REG(PeripheralBase) &= \ (uint32)(~(uint32)(Mask)) \ ) /* ---------------------------------------------------------------------------- -- GetFilterClockSource ---------------------------------------------------------------------------- */ /** * @brief Gets how filter clock source is set. * @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 "Constants for digital clock source setting" type. * The value is cast to "uint32". * @remarks The macro accesses the following registers: PORTA_DFCR, PORTB_DFCR, * PORTC_DFCR, PORTD_DFCR, PORTE_DFCR, PORTF_DFCR (depending on the * peripheral). * @par Example: * @code * uint32 result = PORT_PDD_GetFilterClockSource(_BASE_PTR); * @endcode */ #define PORT_PDD_GetFilterClockSource(PeripheralBase) ( \ (uint32)(PORT_DFCR_REG(PeripheralBase) & PORT_DFCR_CS_MASK) \ ) /* ---------------------------------------------------------------------------- -- SetFilterClockSource ---------------------------------------------------------------------------- */ /** * @brief Sets filter clock source. * @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 of filter clock source. This parameter is of * "Constants for digital clock source setting" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORTA_DFCR, PORTB_DFCR, * PORTC_DFCR, PORTD_DFCR, PORTE_DFCR, PORTF_DFCR (depending on the * peripheral). * @par Example: * @code * PORT_PDD_SetFilterClockSource(_BASE_PTR, * PORT_PDD_BUS_CLOCK); * @endcode */ #define PORT_PDD_SetFilterClockSource(PeripheralBase, State) ( \ PORT_DFCR_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(PORT_DFCR_REG(PeripheralBase) & (uint32)(~(uint32)PORT_DFCR_CS_MASK))) | ( \ (uint32)(State))) \ ) /* ---------------------------------------------------------------------------- -- GetFilterLength ---------------------------------------------------------------------------- */ /** * @brief Returns filter length in clock cycles. * @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: PORTA_DFWR, PORTB_DFWR, * PORTC_DFWR, PORTD_DFWR, PORTE_DFWR, PORTF_DFWR (depending on the * peripheral). * @par Example: * @code * uint32 result = PORT_PDD_GetFilterLength(_BASE_PTR); * @endcode */ #define PORT_PDD_GetFilterLength(PeripheralBase) ( \ PORT_DFWR_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- SetFilterLength ---------------------------------------------------------------------------- */ /** * @brief Sets filter length in clock cycles. * @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 Parameter specifying new value. This parameter is a 5-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORTA_DFWR, PORTB_DFWR, * PORTC_DFWR, PORTD_DFWR, PORTE_DFWR, PORTF_DFWR (depending on the * peripheral). * @par Example: * @code * PORT_PDD_SetFilterLength(_BASE_PTR, 1); * @endcode */ #define PORT_PDD_SetFilterLength(PeripheralBase, Value) ( \ PORT_DFWR_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- GetFilterDivisionSet1 ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284))) /** * @brief Gets configuration of the Filter Division Set 1. * @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 "Constants for Filter Division Set 1" type. The * value is cast to "uint32". * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * uint32 result = PORT_PDD_GetFilterDivisionSet1(_BASE_PTR); * @endcode */ #define PORT_PDD_GetFilterDivisionSet1(PeripheralBase) ( \ (uint32)(PORT_IOFLT0_REG(PeripheralBase) & PORT_IOFLT0_FLTDIV1_MASK) \ ) #else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /** * @brief Gets configuration of the Filter Division Set 1. * @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 "Constants for Filter Division Set 1" type. The * value is cast to "uint32". * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * uint32 result = PORT_PDD_GetFilterDivisionSet1(_BASE_PTR); * @endcode */ #define PORT_PDD_GetFilterDivisionSet1(PeripheralBase) ( \ (uint32)(PORT_IOFLT_REG(PeripheralBase) & PORT_IOFLT_FLTDIV1_MASK) \ ) #endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /* ---------------------------------------------------------------------------- -- SetFilterDivisionSet1 ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284))) /** * @brief Configures Filter Division Set 1. * @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 FilterDivision Filter division 1. This parameter is of "Constants for * Filter Division Set 1" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_SetFilterDivisionSet1(_BASE_PTR, * PORT_PDD_BUSCLK_DIV_2); * @endcode */ #define PORT_PDD_SetFilterDivisionSet1(PeripheralBase, FilterDivision) ( \ PORT_IOFLT0_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(( \ PORT_IOFLT0_REG(PeripheralBase)) & ( \ (uint32)(~(uint32)PORT_IOFLT0_FLTDIV1_MASK)))) | ( \ (uint32)(FilterDivision))) \ ) #else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /** * @brief Configures Filter Division Set 1. * @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 FilterDivision Filter division 1. This parameter is of "Constants for * Filter Division Set 1" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_SetFilterDivisionSet1(_BASE_PTR, * PORT_PDD_BUSCLK_DIV_2); * @endcode */ #define PORT_PDD_SetFilterDivisionSet1(PeripheralBase, FilterDivision) ( \ PORT_IOFLT_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(( \ PORT_IOFLT_REG(PeripheralBase)) & ( \ (uint32)(~(uint32)PORT_IOFLT_FLTDIV1_MASK)))) | ( \ (uint32)(FilterDivision))) \ ) #endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /* ---------------------------------------------------------------------------- -- GetFilterDivisionSet2 ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284))) /** * @brief Gets configuration of the Filter Division Set 2. * @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 "Constants for Filter Division Set 2" type. The * value is cast to "uint32". * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * uint32 result = PORT_PDD_GetFilterDivisionSet2(_BASE_PTR); * @endcode */ #define PORT_PDD_GetFilterDivisionSet2(PeripheralBase) ( \ (uint32)(PORT_IOFLT0_REG(PeripheralBase) & PORT_IOFLT0_FLTDIV2_MASK) \ ) #else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /** * @brief Gets configuration of the Filter Division Set 2. * @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 "Constants for Filter Division Set 2" type. The * value is cast to "uint32". * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * uint32 result = PORT_PDD_GetFilterDivisionSet2(_BASE_PTR); * @endcode */ #define PORT_PDD_GetFilterDivisionSet2(PeripheralBase) ( \ (uint32)(PORT_IOFLT_REG(PeripheralBase) & PORT_IOFLT_FLTDIV2_MASK) \ ) #endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /* ---------------------------------------------------------------------------- -- SetFilterDivisionSet2 ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284))) /** * @brief Configures Filter Division Set 2. * @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 FilterDivision Filter division 2. This parameter is of "Constants for * Filter Division Set 2" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_SetFilterDivisionSet2(_BASE_PTR, * PORT_PDD_BUSCLK_DIV_32); * @endcode */ #define PORT_PDD_SetFilterDivisionSet2(PeripheralBase, FilterDivision) ( \ PORT_IOFLT0_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(( \ PORT_IOFLT0_REG(PeripheralBase)) & ( \ (uint32)(~(uint32)PORT_IOFLT0_FLTDIV2_MASK)))) | ( \ (uint32)(FilterDivision))) \ ) #else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /** * @brief Configures Filter Division Set 2. * @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 FilterDivision Filter division 2. This parameter is of "Constants for * Filter Division Set 2" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_SetFilterDivisionSet2(_BASE_PTR, * PORT_PDD_BUSCLK_DIV_32); * @endcode */ #define PORT_PDD_SetFilterDivisionSet2(PeripheralBase, FilterDivision) ( \ PORT_IOFLT_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(( \ PORT_IOFLT_REG(PeripheralBase)) & ( \ (uint32)(~(uint32)PORT_IOFLT_FLTDIV2_MASK)))) | ( \ (uint32)(FilterDivision))) \ ) #endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /* ---------------------------------------------------------------------------- -- GetFilterDivisionSet3 ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284))) /** * @brief Gets configuration of the Filter Division Set 3. * @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 "Constants for Filter Division Set 3" type. The * value is cast to "uint32". * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * uint32 result = PORT_PDD_GetFilterDivisionSet3(_BASE_PTR); * @endcode */ #define PORT_PDD_GetFilterDivisionSet3(PeripheralBase) ( \ (uint32)(PORT_IOFLT0_REG(PeripheralBase) & PORT_IOFLT0_FLTDIV3_MASK) \ ) #else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /** * @brief Gets configuration of the Filter Division Set 3. * @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 "Constants for Filter Division Set 3" type. The * value is cast to "uint32". * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * uint32 result = PORT_PDD_GetFilterDivisionSet3(_BASE_PTR); * @endcode */ #define PORT_PDD_GetFilterDivisionSet3(PeripheralBase) ( \ (uint32)(PORT_IOFLT_REG(PeripheralBase) & PORT_IOFLT_FLTDIV3_MASK) \ ) #endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /* ---------------------------------------------------------------------------- -- SetFilterDivisionSet3 ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284))) /** * @brief Configures Filter Division Set 3. * @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 FilterDivision Filter division 3. This parameter is of "Constants for * Filter Division Set 3" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_SetFilterDivisionSet3(_BASE_PTR, PORT_PDD_LPOCLK); * @endcode */ #define PORT_PDD_SetFilterDivisionSet3(PeripheralBase, FilterDivision) ( \ PORT_IOFLT0_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(( \ PORT_IOFLT0_REG(PeripheralBase)) & ( \ (uint32)(~(uint32)PORT_IOFLT0_FLTDIV3_MASK)))) | ( \ (uint32)(FilterDivision))) \ ) #else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /** * @brief Configures Filter Division Set 3. * @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 FilterDivision Filter division 3. This parameter is of "Constants for * Filter Division Set 3" type. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_SetFilterDivisionSet3(_BASE_PTR, PORT_PDD_LPOCLK); * @endcode */ #define PORT_PDD_SetFilterDivisionSet3(PeripheralBase, FilterDivision) ( \ PORT_IOFLT_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(( \ PORT_IOFLT_REG(PeripheralBase)) & ( \ (uint32)(~(uint32)PORT_IOFLT_FLTDIV3_MASK)))) | ( \ (uint32)(FilterDivision))) \ ) #endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /* ---------------------------------------------------------------------------- -- GetFilter ---------------------------------------------------------------------------- */ /** * @brief Gets filter configuration for module input pins. * @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 Module Module. Use constants from group "Modules offering input pin * filtering capability". This parameter is 5 bits wide. * @return Use constants from group "Filter selection" for processing return * value. The value is cast to "uint8". * @remarks The macro accesses the following registers: PORT_IOFLT. * @par Example: * @code * uint8 result = PORT_PDD_GetFilter(_BASE_PTR, * PORT_PDD_PTA); * @endcode */ #define PORT_PDD_GetFilter(PeripheralBase, Module) ( \ (uint8)((uint8)(PORT_IOFLT_REG(PeripheralBase) >> (uint8)(Module)) & (uint8)0x3U) \ ) /* ---------------------------------------------------------------------------- -- SetFilter ---------------------------------------------------------------------------- */ /** * @brief Sets filter for module input pins. * @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 Module Module to be configured. Use constants from group "Modules * offering input pin filtering capability". This parameter is 5 bits wide. * @param Filter Selected filter. Use constants from group "Filter selection". * This parameter is 2 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT. * @par Example: * @code * PORT_PDD_SetFilter(_BASE_PTR, PORT_PDD_PTA, * PORT_PDD_NO_FILTER); * @endcode */ #define PORT_PDD_SetFilter(PeripheralBase, Module, Filter) ( \ PORT_IOFLT_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(( \ PORT_IOFLT_REG(PeripheralBase)) & ( \ (uint32)(~(uint32)((uint32)0x3U << (uint8)(Module)))))) | ( \ (uint32)((uint32)(Filter) << (uint8)(Module)))) \ ) /* ---------------------------------------------------------------------------- -- WritePortFilterReg ---------------------------------------------------------------------------- */ /** * @brief Writes port filter 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 to be written into IOFLT0 register. This parameter is a * 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT. * @par Example: * @code * PORT_PDD_WritePortFilterReg(_BASE_PTR, 1); * @endcode */ #define PORT_PDD_WritePortFilterReg(PeripheralBase, Value) ( \ PORT_IOFLT_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadPortFilterReg ---------------------------------------------------------------------------- */ /** * @brief Reads port filter 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: PORT_IOFLT. * @par Example: * @code * uint32 result = PORT_PDD_ReadPortFilterReg(_BASE_PTR); * @endcode */ #define PORT_PDD_ReadPortFilterReg(PeripheralBase) ( \ PORT_IOFLT_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- EnablePullupLowPortMask ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284))) /** * @brief Enables/Disables pullup resistors on low port pins specified by mask * parameters. * @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 PullupDisableMask Mask of low port pins to be disabled. Use constants * from group "Pin masks". This parameter is 32 bits wide. * @param PullupEnableMask Mask of low port pins to be enabled. Use constants * from group "Pin masks". This parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_PUEL, PORT_PUE0 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_EnablePullupLowPortMask(_BASE_PTR, PORT_PDD_PIN_0, * PORT_PDD_PIN_0); * @endcode */ #define PORT_PDD_EnablePullupLowPortMask(PeripheralBase, PullupDisableMask, PullupEnableMask) ( \ PORT_PUE0_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(PORT_PUE0_REG(PeripheralBase) & (uint32)(~(uint32)(PullupDisableMask)))) | ( \ (uint32)(PullupEnableMask))) \ ) #else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /** * @brief Enables/Disables pullup resistors on low port pins specified by mask * parameters. * @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 PullupDisableMask Mask of low port pins to be disabled. Use constants * from group "Pin masks". This parameter is 32 bits wide. * @param PullupEnableMask Mask of low port pins to be enabled. Use constants * from group "Pin masks". This parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_PUEL, PORT_PUE0 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_EnablePullupLowPortMask(_BASE_PTR, PORT_PDD_PIN_0, * PORT_PDD_PIN_0); * @endcode */ #define PORT_PDD_EnablePullupLowPortMask(PeripheralBase, PullupDisableMask, PullupEnableMask) ( \ PORT_PUEL_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(PORT_PUEL_REG(PeripheralBase) & (uint32)(~(uint32)(PullupDisableMask)))) | ( \ (uint32)(PullupEnableMask))) \ ) #endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /* ---------------------------------------------------------------------------- -- WritePullupEnableLowReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284))) /** * @brief Writes pullup enable 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 Parameter specifying mask of the new pullup enable setting for * low port pins. Bit #0 of the mask controls pullup setting of the low * port pin #0, bit #31 controls setting of the pin #31. Bit value 0 disables * pullup for associated low port pin, bit value 1 enables pullup for * associated low port pin. This parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_PUEL, PORT_PUE0 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_WritePullupEnableLowReg(_BASE_PTR, 1); * @endcode */ #define PORT_PDD_WritePullupEnableLowReg(PeripheralBase, Value) ( \ PORT_PUE0_REG(PeripheralBase) = \ (uint32)(Value) \ ) #else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /** * @brief Writes pullup enable 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 Parameter specifying mask of the new pullup enable setting for * low port pins. Bit #0 of the mask controls pullup setting of the low * port pin #0, bit #31 controls setting of the pin #31. Bit value 0 disables * pullup for associated low port pin, bit value 1 enables pullup for * associated low port pin. This parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_PUEL, PORT_PUE0 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_WritePullupEnableLowReg(_BASE_PTR, 1); * @endcode */ #define PORT_PDD_WritePullupEnableLowReg(PeripheralBase, Value) ( \ PORT_PUEL_REG(PeripheralBase) = \ (uint32)(Value) \ ) #endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /* ---------------------------------------------------------------------------- -- ReadPullupEnableLowReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284))) /** * @brief Reads pullup enable configuration of the low port pins. Bit #0 of * return value contains pullup setting of the low port pin #0, bit #31 contains * setting of the pin #31. * @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: PORT_PUEL, PORT_PUE0 * (depending on the peripheral). * @par Example: * @code * uint32 result = * PORT_PDD_ReadPullupEnableLowReg(_BASE_PTR); * @endcode */ #define PORT_PDD_ReadPullupEnableLowReg(PeripheralBase) ( \ PORT_PUE0_REG(PeripheralBase) \ ) #else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /** * @brief Reads pullup enable configuration of the low port pins. Bit #0 of * return value contains pullup setting of the low port pin #0, bit #31 contains * setting of the pin #31. * @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: PORT_PUEL, PORT_PUE0 * (depending on the peripheral). * @par Example: * @code * uint32 result = * PORT_PDD_ReadPullupEnableLowReg(_BASE_PTR); * @endcode */ #define PORT_PDD_ReadPullupEnableLowReg(PeripheralBase) ( \ PORT_PUEL_REG(PeripheralBase) \ ) #endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */ /* ---------------------------------------------------------------------------- -- EnablePullupHighPortMask ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_SKEAZN642))) /** * @brief Enables/Disables pullup resistors on high port pins specified by mask * parameters. * @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 PullupDisableMask Mask of high port pins with pullup to be disabled. * Use constants from group "Pin masks". This parameter is 32 bits wide. * @param PullupEnableMask Mask of high port pins with pullup to be enabled. Use * constants from group "Pin masks". This parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_PUEH, PORT_PUE1 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_EnablePullupHighPortMask(_BASE_PTR, * PORT_PDD_PIN_0, PORT_PDD_PIN_0); * @endcode */ #define PORT_PDD_EnablePullupHighPortMask(PeripheralBase, PullupDisableMask, PullupEnableMask) ( \ PORT_PUEH_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(PORT_PUEH_REG(PeripheralBase) & (uint32)(~(uint32)(PullupDisableMask)))) | ( \ (uint32)(PullupEnableMask))) \ ) #else /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */ /** * @brief Enables/Disables pullup resistors on high port pins specified by mask * parameters. * @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 PullupDisableMask Mask of high port pins with pullup to be disabled. * Use constants from group "Pin masks". This parameter is 32 bits wide. * @param PullupEnableMask Mask of high port pins with pullup to be enabled. Use * constants from group "Pin masks". This parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_PUEH, PORT_PUE1 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_EnablePullupHighPortMask(_BASE_PTR, * PORT_PDD_PIN_0, PORT_PDD_PIN_0); * @endcode */ #define PORT_PDD_EnablePullupHighPortMask(PeripheralBase, PullupDisableMask, PullupEnableMask) ( \ PORT_PUE1_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(PORT_PUE1_REG(PeripheralBase) & (uint32)(~(uint32)(PullupDisableMask)))) | ( \ (uint32)(PullupEnableMask))) \ ) #endif /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */ /* ---------------------------------------------------------------------------- -- WritePullupEnableHighReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_SKEAZN642))) /** * @brief Writes pullup enable 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 Parameter specifying mask of the new pullup enable setting for * high port pins. Bit #0 of the mask controls pullup setting of the high * port pin #0, bit #31 controls setting of the pin #31. Bit value 0 * disables pullup for associated high port pin, bit value 1 enables pullup for * associated high port pin. This parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_PUEH, PORT_PUE1 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_WritePullupEnableHighReg(_BASE_PTR, 1); * @endcode */ #define PORT_PDD_WritePullupEnableHighReg(PeripheralBase, Value) ( \ PORT_PUEH_REG(PeripheralBase) = \ (uint32)(Value) \ ) #else /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */ /** * @brief Writes pullup enable 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 Parameter specifying mask of the new pullup enable setting for * high port pins. Bit #0 of the mask controls pullup setting of the high * port pin #0, bit #31 controls setting of the pin #31. Bit value 0 * disables pullup for associated high port pin, bit value 1 enables pullup for * associated high port pin. This parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_PUEH, PORT_PUE1 * (depending on the peripheral). * @par Example: * @code * PORT_PDD_WritePullupEnableHighReg(_BASE_PTR, 1); * @endcode */ #define PORT_PDD_WritePullupEnableHighReg(PeripheralBase, Value) ( \ PORT_PUE1_REG(PeripheralBase) = \ (uint32)(Value) \ ) #endif /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */ /* ---------------------------------------------------------------------------- -- ReadPullupEnableHighReg ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_SKEAZN642))) /** * @brief Reads pullup enable configuration of the high port pins. Bit #0 of * return value contains pullup setting of the high port pin #0, bit #31 contains * setting of the pin #31. * @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: PORT_PUEH, PORT_PUE1 * (depending on the peripheral). * @par Example: * @code * uint32 result = * PORT_PDD_ReadPullupEnableHighReg(_BASE_PTR); * @endcode */ #define PORT_PDD_ReadPullupEnableHighReg(PeripheralBase) ( \ PORT_PUEH_REG(PeripheralBase) \ ) #else /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */ /** * @brief Reads pullup enable configuration of the high port pins. Bit #0 of * return value contains pullup setting of the high port pin #0, bit #31 contains * setting of the pin #31. * @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: PORT_PUEH, PORT_PUE1 * (depending on the peripheral). * @par Example: * @code * uint32 result = * PORT_PDD_ReadPullupEnableHighReg(_BASE_PTR); * @endcode */ #define PORT_PDD_ReadPullupEnableHighReg(PeripheralBase) ( \ PORT_PUE1_REG(PeripheralBase) \ ) #endif /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */ /* ---------------------------------------------------------------------------- -- EnableHighDriveMask ---------------------------------------------------------------------------- */ #if ((defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN84))) /** * @brief Enables/Disables high current drive capability on port pins specified * by mask parameters. * @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 HighDriveDisableMask Mask of pins with high drive to be disabled. Use * constants from group "List of pins offering high drive capability". * This parameter is 32 bits wide. * @param HighDriveEnableMask Mask of pins with high drive to be enabled. Use * constants from group "List of pins offering high drive capability". This * parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_HDRVE. * @par Example: * @code * PORT_PDD_EnableHighDriveMask(_BASE_PTR, PORT_PDD_PTB5, * PORT_PDD_PTB5); * @endcode */ #define PORT_PDD_EnableHighDriveMask(PeripheralBase, HighDriveDisableMask, HighDriveEnableMask) ( \ PORT_HDRVE_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(PORT_HDRVE_REG(PeripheralBase) & (uint32)(~(uint32)(HighDriveDisableMask)))) | ( \ (uint32)(HighDriveEnableMask))) \ ) #else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) */ /** * @brief Enables/Disables high current drive capability on port pins specified * by mask parameters. * @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 HighDriveDisableMask Mask of pins with high drive to be disabled. Use * constants from group "List of pins offering high drive capability". * This parameter is 32 bits wide. * @param HighDriveEnableMask Mask of pins with high drive to be enabled. Use * constants from group "List of pins offering high drive capability". This * parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_HDRVE. * @par Example: * @code * PORT_PDD_EnableHighDriveMask(_BASE_PTR, PORT_PDD_PTB4, * PORT_PDD_PTB4); * @endcode */ #define PORT_PDD_EnableHighDriveMask(PeripheralBase, HighDriveDisableMask, HighDriveEnableMask) ( \ PORT_HDRVE_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(PORT_HDRVE_REG(PeripheralBase) & (uint32)(~(uint32)(HighDriveDisableMask)))) | ( \ (uint32)(HighDriveEnableMask))) \ ) #endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) */ /* ---------------------------------------------------------------------------- -- WriteHighDriveEnableReg ---------------------------------------------------------------------------- */ /** * @brief Writes high drive 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 Parameter specifying mask of the new high drive enable setting * for associated pins. Pins supporting high drive capability are defined * by High drive pin list. This parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_HDRVE. * @par Example: * @code * PORT_PDD_WriteHighDriveEnableReg(_BASE_PTR, 1); * @endcode */ #define PORT_PDD_WriteHighDriveEnableReg(PeripheralBase, Value) ( \ PORT_HDRVE_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadHighDriveEnableReg ---------------------------------------------------------------------------- */ /** * @brief Reads high drive enable configuration of the associated pins. Pins * supporting high drive capability are defined by High drive pin list. * @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: PORT_HDRVE. * @par Example: * @code * uint32 result = * PORT_PDD_ReadHighDriveEnableReg(_BASE_PTR); * @endcode */ #define PORT_PDD_ReadHighDriveEnableReg(PeripheralBase) ( \ PORT_HDRVE_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- GetFilter0 ---------------------------------------------------------------------------- */ /** * @brief Gets filter 0 configuration for module input pins. * @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 Module Module. Use constants from group "Modules offering input pin * filtering capability". This parameter is 5 bits wide. * @return Use constants from group "Filter selection" for processing return * value. The value is cast to "uint8". * @remarks The macro accesses the following registers: PORT_IOFLT0. * @par Example: * @code * uint8 result = PORT_PDD_GetFilter0(_BASE_PTR, * PORT_PDD_PTA); * @endcode */ #define PORT_PDD_GetFilter0(PeripheralBase, Module) ( \ (uint8)(( \ (uint8)(PORT_IOFLT0_REG(PeripheralBase) >> (uint8)(Module))) & ( \ (uint8)0x3U)) \ ) /* ---------------------------------------------------------------------------- -- GetFilter1 ---------------------------------------------------------------------------- */ /** * @brief Gets filter 1 configuration for module input pins. * @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 Module Module. Use constants from group "Modules offering input pin * filtering capability". This parameter is 5 bits wide. * @return Use constants from group "Filter selection" for processing return * value. The value is cast to "uint8". * @remarks The macro accesses the following registers: PORT_IOFLT1. * @par Example: * @code * uint8 result = PORT_PDD_GetFilter1(_BASE_PTR, * PORT_PDD_PTA); * @endcode */ #define PORT_PDD_GetFilter1(PeripheralBase, Module) ( \ (uint8)(( \ (uint8)(PORT_IOFLT1_REG(PeripheralBase) >> (uint8)(Module))) & ( \ (uint8)0x3U)) \ ) /* ---------------------------------------------------------------------------- -- SetFilter0 ---------------------------------------------------------------------------- */ /** * @brief Sets filter 0 for module input pins. * @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 Module Module to be configured. Use constants from group "Modules * offering input pin filtering capability". This parameter is 5 bits wide. * @param Filter Selected filter. Use constants from group "Filter selection". * This parameter is 2 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT0. * @par Example: * @code * PORT_PDD_SetFilter0(_BASE_PTR, PORT_PDD_PTA, * PORT_PDD_NO_FILTER); * @endcode */ #define PORT_PDD_SetFilter0(PeripheralBase, Module, Filter) ( \ PORT_IOFLT0_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(( \ PORT_IOFLT0_REG(PeripheralBase)) & ( \ (uint32)(~(uint32)((uint32)0x3U << (uint8)(Module)))))) | ( \ (uint32)((uint32)(Filter) << (uint8)(Module)))) \ ) /* ---------------------------------------------------------------------------- -- SetFilter1 ---------------------------------------------------------------------------- */ /** * @brief Sets filter 1 for module input pins. * @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 Module Module to be configured. Use constants from group "Modules * offering input pin filtering capability". This parameter is 5 bits wide. * @param Filter Selected filter. Use constants from group "Filter selection". * This parameter is 2 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT1. * @par Example: * @code * PORT_PDD_SetFilter1(_BASE_PTR, PORT_PDD_PTA, * PORT_PDD_NO_FILTER); * @endcode */ #define PORT_PDD_SetFilter1(PeripheralBase, Module, Filter) ( \ PORT_IOFLT1_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(( \ PORT_IOFLT1_REG(PeripheralBase)) & ( \ (uint32)(~(uint32)((uint32)0x3U << (uint8)(Module)))))) | ( \ (uint32)((uint32)(Filter) << (uint8)(Module)))) \ ) /* ---------------------------------------------------------------------------- -- WritePortFilter0Reg ---------------------------------------------------------------------------- */ /** * @brief Writes port filter 0 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 to be written into IOFLT1 register. This parameter is a * 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT0. * @par Example: * @code * PORT_PDD_WritePortFilter0Reg(_BASE_PTR, 1); * @endcode */ #define PORT_PDD_WritePortFilter0Reg(PeripheralBase, Value) ( \ PORT_IOFLT0_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- WritePortFilter1Reg ---------------------------------------------------------------------------- */ /** * @brief Writes port filter 1 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 to be written into IOFLT register. This parameter is a * 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_IOFLT1. * @par Example: * @code * PORT_PDD_WritePortFilter1Reg(_BASE_PTR, 1); * @endcode */ #define PORT_PDD_WritePortFilter1Reg(PeripheralBase, Value) ( \ PORT_IOFLT1_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadPortFilter0Reg ---------------------------------------------------------------------------- */ /** * @brief Reads port filter 0 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: PORT_IOFLT0. * @par Example: * @code * uint32 result = PORT_PDD_ReadPortFilter0Reg(_BASE_PTR); * @endcode */ #define PORT_PDD_ReadPortFilter0Reg(PeripheralBase) ( \ PORT_IOFLT0_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- ReadPortFilter1Reg ---------------------------------------------------------------------------- */ /** * @brief Reads port filter 1 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: PORT_IOFLT1. * @par Example: * @code * uint32 result = PORT_PDD_ReadPortFilter1Reg(_BASE_PTR); * @endcode */ #define PORT_PDD_ReadPortFilter1Reg(PeripheralBase) ( \ PORT_IOFLT1_REG(PeripheralBase) \ ) /* ---------------------------------------------------------------------------- -- EnablePullupPort2Mask ---------------------------------------------------------------------------- */ /** * @brief Enables/Disables pullup resistors on port 2 pins specified by mask * parameters. * @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 PullupDisableMask Mask of high port pins with pullup to be disabled. * Use constants from group "Pin masks". This parameter is 32 bits wide. * @param PullupEnableMask Mask of high port pins with pullup to be enabled. Use * constants from group "Pin masks". This parameter is 32 bits wide. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_PUE2. * @par Example: * @code * PORT_PDD_EnablePullupPort2Mask(_BASE_PTR, PORT_PDD_PIN_0, * PORT_PDD_PIN_0); * @endcode */ #define PORT_PDD_EnablePullupPort2Mask(PeripheralBase, PullupDisableMask, PullupEnableMask) ( \ PORT_PUE2_REG(PeripheralBase) = \ (uint32)(( \ (uint32)(PORT_PUE2_REG(PeripheralBase) & (uint32)(~(uint32)(PullupDisableMask)))) | ( \ (uint32)(PullupEnableMask))) \ ) /* ---------------------------------------------------------------------------- -- WritePort2PullupEnableReg ---------------------------------------------------------------------------- */ /** * @brief Writes port 2 pullup enable 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 Parameter specifying mask of the new pullup enable setting for * high port pins. Bit #0 of the mask controls pullup setting of the high * port pin #0, bit #31 controls setting of the pin #31. Bit value 0 * disables pullup for associated high port pin, bit value 1 enables pullup for * associated high port pin. This parameter is a 32-bit value. * @return Returns a value of void type. * @remarks The macro accesses the following registers: PORT_PUE2. * @par Example: * @code * PORT_PDD_WritePort2PullupEnableReg(_BASE_PTR, 1); * @endcode */ #define PORT_PDD_WritePort2PullupEnableReg(PeripheralBase, Value) ( \ PORT_PUE2_REG(PeripheralBase) = \ (uint32)(Value) \ ) /* ---------------------------------------------------------------------------- -- ReadPort2PullupEnableReg ---------------------------------------------------------------------------- */ /** * @brief Reads port 2 pullup enable configuration of the high port pins. Bit #0 * of return value contains pullup setting of the high port pin #0, bit #31 * contains setting of the pin #31. * @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: PORT_PUE2. * @par Example: * @code * uint32 result = * PORT_PDD_ReadPort2PullupEnableReg(_BASE_PTR); * @endcode */ #define PORT_PDD_ReadPort2PullupEnableReg(PeripheralBase) ( \ PORT_PUE2_REG(PeripheralBase) \ ) #endif /* #if defined(PORT_PDD_H_) */ /* PORT_PDD.h, eof. */