Unknow/beyon-motion
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
03325b95023005758f9c31172b8666ef448c7962
beyon-motion/TMC2209/lib/tmc/hal/Landungsbruecke/freescale/PDD/PORT_PDD.h

2376 lines
116 KiB
C
Raw Normal View History

Initial commit
2026-03-31 13:10:37 +02:00
/*
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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_DEVICE).
* @return Returns a 32-bit value.
* @remarks The macro accesses the following registers: PORT_IOFLT.
* @par Example:
* @code
* uint32 result = PORT_PDD_ReadPortFilterReg(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_DEVICE).
* @return Returns a 32-bit value.
* @remarks The macro accesses the following registers: PORT_HDRVE.
* @par Example:
* @code
* uint32 result =
* PORT_PDD_ReadHighDriveEnableReg(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_DEVICE).
* @return Returns a 32-bit value.
* @remarks The macro accesses the following registers: PORT_IOFLT0.
* @par Example:
* @code
* uint32 result = PORT_PDD_ReadPortFilter0Reg(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_DEVICE).
* @return Returns a 32-bit value.
* @remarks The macro accesses the following registers: PORT_IOFLT1.
* @par Example:
* @code
* uint32 result = PORT_PDD_ReadPortFilter1Reg(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_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(<peripheral>_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 (<peripheral>_BASE_PTR) or the constant defined in
* the peripheral initialization component header file
* (<component_name>_DEVICE).
* @return Returns a 32-bit value.
* @remarks The macro accesses the following registers: PORT_PUE2.
* @par Example:
* @code
* uint32 result =
* PORT_PDD_ReadPort2PullupEnableReg(<peripheral>_BASE_PTR);
* @endcode
*/
#define PORT_PDD_ReadPort2PullupEnableReg(PeripheralBase) ( \
PORT_PUE2_REG(PeripheralBase) \
)
#endif /* #if defined(PORT_PDD_H_) */
/* PORT_PDD.h, eof. */
Reference in New Issue Copy Permalink