2151 lines
104 KiB
C
2151 lines
104 KiB
C
/*
|
||
PDD layer implementation for peripheral type I2C
|
||
(C) 2013 Freescale, Inc. All rights reserved.
|
||
|
||
This file is static and it is generated from API-Factory
|
||
*/
|
||
|
||
#if !defined(I2C_PDD_H_)
|
||
#define I2C_PDD_H_
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- Test if supported MCU is active
|
||
---------------------------------------------------------------------------- */
|
||
|
||
#if !defined(MCU_ACTIVE)
|
||
// No MCU is active
|
||
#error I2C PDD library: No derivative is active. Place proper #include with PDD memory map before including PDD library.
|
||
#elif \
|
||
!defined(MCU_MK10D10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK10D5) /* I2C0 */ && \
|
||
!defined(MCU_MK10D7) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK10F12) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK10DZ10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK11D5) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK11D5WS) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK12D5) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK20D10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK20D5) /* I2C0 */ && \
|
||
!defined(MCU_MK20D7) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK20F12) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK20DZ10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK21D5) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK21D5WS) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK21F12) /* I2C0, I2C1, I2C2 */ && \
|
||
!defined(MCU_MK21F12WS) /* I2C0, I2C1, I2C2 */ && \
|
||
!defined(MCU_MK22D5) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK22F12810) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK22F12) /* I2C0, I2C1, I2C2 */ && \
|
||
!defined(MCU_MK22F25612) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK22F51212) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK24F12) /* I2C0, I2C1, I2C2 */ && \
|
||
!defined(MCU_MK30D10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK30D7) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK30DZ10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK40D10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK40D7) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK40DZ10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK40X256VMD100) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK50D10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK50D7) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK50DZ10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK51D10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK51D7) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK51DZ10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK52D10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK52DZ10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK53D10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK53DZ10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK60D10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK60F12) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK60F15) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK60DZ10) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK60N512VMD100) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK61F12) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK61F15) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK61F12WS) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK61F15WS) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK63F12) /* I2C0, I2C1, I2C2 */ && \
|
||
!defined(MCU_MK63F12WS) /* I2C0, I2C1, I2C2 */ && \
|
||
!defined(MCU_MK64F12) /* I2C0, I2C1, I2C2 */ && \
|
||
!defined(MCU_MK65F18) /* I2C0, I2C1, I2C2, I2C3 */ && \
|
||
!defined(MCU_MK65F18WS) /* I2C0, I2C1, I2C2, I2C3 */ && \
|
||
!defined(MCU_MK66F18) /* I2C0, I2C1, I2C2, I2C3 */ && \
|
||
!defined(MCU_MK70F12) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK70F15) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK70F12WS) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MK70F15WS) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKE02Z2) /* I2C0 */ && \
|
||
!defined(MCU_MKE02Z4) /* I2C0 */ && \
|
||
!defined(MCU_SKEAZN642) /* I2C0 */ && \
|
||
!defined(MCU_MKE04Z1284) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKE04Z4) /* I2C0 */ && \
|
||
!defined(MCU_SKEAZN84) /* I2C0 */ && \
|
||
!defined(MCU_MKE06Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKL02Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKL03Z4) /* I2C0 */ && \
|
||
!defined(MCU_MKL04Z4) /* I2C0 */ && \
|
||
!defined(MCU_MKL05Z4) /* I2C0 */ && \
|
||
!defined(MCU_MKL14Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKL15Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKL16Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKL24Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKL25Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKL26Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKL34Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKL36Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKL46Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKV10Z7) /* I2C0 */ && \
|
||
!defined(MCU_MKV31F12810) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKV31F25612) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKV31F51212) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKW01Z4) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKW21D5) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKW21D5WS) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKW22D5) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKW22D5WS) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKW24D5) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_MKW24D5WS) /* I2C0, I2C1 */ && \
|
||
!defined(MCU_PCK20L4) /* I2C0 */ && \
|
||
!defined(MCU_SKEAZ1284) /* I2C0, I2C1 */
|
||
// Unsupported MCU is active
|
||
#error I2C PDD library: Unsupported derivative is active.
|
||
#endif
|
||
|
||
#include "PDD_Types.h"
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- Method symbol definitions
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/* Status flags constants (for ReadStatusReg, GetInterruptFlags,
|
||
ClearInterruptFlags macros). */
|
||
#define I2C_PDD_RX_ACKNOWLEDGE I2C_S_RXAK_MASK /**< Receive acknowledge. */
|
||
#define I2C_PDD_INTERRUPT_FLAG I2C_S_IICIF_MASK /**< Interrupt flag. */
|
||
#define I2C_PDD_SLAVE_TRANSMIT I2C_S_SRW_MASK /**< Slave read/write request. */
|
||
#define I2C_PDD_RANGE_ADDRESS_MATCH I2C_S_RAM_MASK /**< Range address match. */
|
||
#define I2C_PDD_ARBIT_LOST I2C_S_ARBL_MASK /**< Arbitration lost. */
|
||
#define I2C_PDD_BUS_IS_BUSY I2C_S_BUSY_MASK /**< Bus busy - set when a START signal is detected. */
|
||
#define I2C_PDD_ADDRESSED_AS_SLAVE I2C_S_IAAS_MASK /**< Addressed as a slave. */
|
||
#define I2C_PDD_TX_COMPLETE I2C_S_TCF_MASK /**< Transfer complete flag. */
|
||
|
||
/* SCL timeout flags constants (for GetSCLTimeoutInterruptFlags,
|
||
ClearSCLTimeoutInterruptFlags macros). */
|
||
#define I2C_PDD_SCL_LOW_TIMEOUT I2C_SMB_SLTF_MASK /**< SCL low timeout flag. */
|
||
#define I2C_PDD_SCL_HI_AND_SDA_HI_TIMEOUT I2C_SMB_SHTF1_MASK /**< SCL high timeout flag - sets when SCL and SDA are held high more than clock × LoValue / 512. */
|
||
#define I2C_PDD_SCL_HI_AND_SDA_LOW_TIMEOUT I2C_SMB_SHTF2_MASK /**< SCL high timeout flag - sets when SCL is held high and SDA is held low more than clock × LoValue/512. */
|
||
|
||
#if ((defined(MCU_MKL02Z4)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKV10Z7)) || (defined(MCU_MKW01Z4)))
|
||
/* Status flags constants. */
|
||
#define I2C_PDD_BUS_STOP_FLAG I2C_FLT_STOPF_MASK /**< Stop detected on I2C bus */
|
||
|
||
#else /* (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE04Z4)) || (defined(MCU_MKE06Z4)) || (defined(MCU_MKV31F12810)) || (defined(MCU_MKV31F25612)) || (defined(MCU_MKV31F51212)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
|
||
/* Status flags constants. */
|
||
#define I2C_PDD_BUS_STOP_FLAG I2C_FLT_STOPF_MASK /**< Stop detected on I2C bus */
|
||
#define I2C_PDD_BUS_START_FLAG I2C_FLT_STARTF_MASK /**< Start detected on I2C bus */
|
||
|
||
#endif /* (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE04Z4)) || (defined(MCU_MKE06Z4)) || (defined(MCU_MKV31F12810)) || (defined(MCU_MKV31F25612)) || (defined(MCU_MKV31F51212)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
|
||
/* Frequency multiplier constants (for SetFrequencyMultiplier macro). */
|
||
#define I2C_PDD_FREQUENCY_MUL_1 0U /**< Multiplier factor = 1 */
|
||
#define I2C_PDD_FREQUENCY_MUL_2 0x1U /**< Multiplier factor = 2 */
|
||
#define I2C_PDD_FREQUENCY_MUL_4 0x2U /**< Multiplier factor = 4 */
|
||
|
||
/* Master mode constants (for MasterMode, GetMasterMode macros). */
|
||
#define I2C_PDD_MASTER_MODE 0x20U /**< Master mode. */
|
||
#define I2C_PDD_SLAVE_MODE 0U /**< Slave mode. */
|
||
|
||
/* Transmit mode constants (for SetTransmitMode, GetTransmitMode macros). */
|
||
#define I2C_PDD_TX_DIRECTION 0x10U /**< SDA pin set as output. */
|
||
#define I2C_PDD_RX_DIRECTION 0U /**< SDA pin set as input. */
|
||
|
||
/* BUS status constants (for GetBusStatus macro). */
|
||
#define I2C_PDD_BUS_IDLE 0U /**< Bus is idle. */
|
||
#define I2C_PDD_BUS_BUSY 0x20U /**< Bus is busy. */
|
||
|
||
/* Fast SMBus Acknowledge constants (for GetFastSmBusAcknowledge macro). */
|
||
#define I2C_PDD_ACK_FOLLOWING_RX_DATA 0U /**< ACK or NACK is sent on the following receiving data byte. */
|
||
#define I2C_PDD_ACK_AFTER_RX_DATA 0x80U /**< ACK or NACK is sent after receiving a data byte. */
|
||
|
||
/* Clock source constants (for SetSCLTimeoutBusClockSource macro). */
|
||
#define I2C_PDD_BUS_CLOCK 0x10U /**< Bus clock frequency */
|
||
#define I2C_PDD_BUS_CLOCK_DIV64 0U /**< Bus clock / 64 frequency */
|
||
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetSlaveAddress7bits
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes to the address register and set address length to 7 bits.
|
||
* @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 AddrValue Slave address value[0..127]. This parameter is a 7-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_A1, I2C0_C2,
|
||
* I2C1_A1, I2C1_C2, I2C2_A1, I2C2_C2, I2C3_A1, I2C3_C2 (depending on the
|
||
* peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetSlaveAddress7bits(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetSlaveAddress7bits(PeripheralBase, AddrValue) ( \
|
||
(I2C_A1_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_A1_REG(PeripheralBase) & (uint8)(~(uint8)I2C_A1_AD_MASK))) | ( \
|
||
(uint8)((uint8)(AddrValue) << I2C_A1_AD_SHIFT)))), \
|
||
(I2C_C2_REG(PeripheralBase) &= \
|
||
(uint8)(~(uint8)I2C_C2_ADEXT_MASK)) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetSlaveAddress10bits
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes to the address register and set address length to 10 bits.
|
||
* @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 AddrValue Slave address value[0..1023]. This parameter is a 10-bit
|
||
* value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_A1, I2C0_C2,
|
||
* I2C1_A1, I2C1_C2, I2C2_A1, I2C2_C2, I2C3_A1, I2C3_C2 (depending on the
|
||
* peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetSlaveAddress10bits(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetSlaveAddress10bits(PeripheralBase, AddrValue) ( \
|
||
(I2C_A1_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_A1_REG(PeripheralBase) & (uint8)(~(uint8)I2C_A1_AD_MASK))) | ( \
|
||
(uint8)((uint8)((uint16)(AddrValue) & 0x7FU) << I2C_A1_AD_SHIFT)))), \
|
||
(I2C_C2_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_C2_REG(PeripheralBase) & (uint8)(~(uint8)I2C_C2_AD_MASK))) | (( \
|
||
(uint8)((uint16)(AddrValue) >> 7U)) | ( \
|
||
I2C_C2_ADEXT_MASK)))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadAddress1Reg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Reads address 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 8-bit value.
|
||
* @remarks The macro accesses the following registers: I2C0_A1, I2C1_A1,
|
||
* I2C2_A1, I2C3_A1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_ReadAddress1Reg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadAddress1Reg(PeripheralBase) ( \
|
||
I2C_A1_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteAddress1Reg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes new value specified by the Value parameter into address 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 to the baud rate register. This parameter is
|
||
* a 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_A1, I2C1_A1,
|
||
* I2C2_A1, I2C3_A1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteAddress1Reg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteAddress1Reg(PeripheralBase, Value) ( \
|
||
I2C_A1_REG(PeripheralBase) = \
|
||
(uint8)(Value) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetFrequencyDivider
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Sets the prescaler to configure the I2C clock for the bit-rate
|
||
* selection.
|
||
* @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 FreqDividerValue Frequency divider value[0..63]. This parameter is a
|
||
* 6-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_F, I2C1_F, I2C2_F,
|
||
* I2C3_F (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetFrequencyDivider(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetFrequencyDivider(PeripheralBase, FreqDividerValue) ( \
|
||
I2C_F_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_F_REG(PeripheralBase) & (uint8)(~(uint8)I2C_F_ICR_MASK))) | ( \
|
||
(uint8)(FreqDividerValue))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetFrequencyMultiplier
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Sets the factor, what is used along with frequency divider to generate
|
||
* the I2C baud 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 FreqMultiplierValue Frequency multiplier value[0..2]. This parameter
|
||
* is a 2-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_F, I2C1_F, I2C2_F,
|
||
* I2C3_F (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetFrequencyMultiplier(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetFrequencyMultiplier(PeripheralBase, FreqMultiplierValue) ( \
|
||
I2C_F_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_F_REG(PeripheralBase) & (uint8)(~(uint8)I2C_F_MULT_MASK))) | ( \
|
||
(uint8)((uint8)(FreqMultiplierValue) << I2C_F_MULT_SHIFT))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadFrequencyDividerReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Reads frequency divider register.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a 8-bit value.
|
||
* @remarks The macro accesses the following registers: I2C0_F, I2C1_F, I2C2_F,
|
||
* I2C3_F (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_ReadFrequencyDividerReg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadFrequencyDividerReg(PeripheralBase) ( \
|
||
I2C_F_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteFrequencyDividerReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes new value specified by the Value parameter into frequency
|
||
* divider 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 to the frequency divider register. This
|
||
* parameter is a 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_F, I2C1_F, I2C2_F,
|
||
* I2C3_F (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteFrequencyDividerReg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteFrequencyDividerReg(PeripheralBase, Value) ( \
|
||
I2C_F_REG(PeripheralBase) = \
|
||
(uint8)(Value) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableDevice
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables/disables I2C device.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @param State Requested state of device. This parameter is of "Global
|
||
* enumeration used for specifying general enable/disable states (PDD_DISABLE and
|
||
* PDD_ENABLE defined in PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableDevice(<peripheral>_BASE_PTR, PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableDevice(PeripheralBase, State) ( \
|
||
I2C_C1_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_C1_REG(PeripheralBase) & (uint8)(~(uint8)I2C_C1_IICEN_MASK))) | ( \
|
||
(uint8)((uint8)(State) << I2C_C1_IICEN_SHIFT))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableInterrupt
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables the I2C interrupt.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableInterrupt(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableInterrupt(PeripheralBase) ( \
|
||
I2C_C1_REG(PeripheralBase) |= \
|
||
I2C_C1_IICIE_MASK \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- DisableInterrupt
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Disables the I2C interrupt.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_DisableInterrupt(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_DisableInterrupt(PeripheralBase) ( \
|
||
I2C_C1_REG(PeripheralBase) &= \
|
||
(uint8)(~(uint8)I2C_C1_IICIE_MASK) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetMasterMode
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Puts the I2C to the master or slave mode.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @param MasterMode I2C mode value. The user should use one from the enumerated
|
||
* values. This parameter is of "Master mode constants (for MasterMode,
|
||
* GetMasterMode macros)." type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetMasterMode(<peripheral>_BASE_PTR, I2C_PDD_MASTER_MODE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetMasterMode(PeripheralBase, MasterMode) ( \
|
||
I2C_C1_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_C1_REG(PeripheralBase) & (uint8)(~(uint8)I2C_C1_MST_MASK))) | ( \
|
||
(uint8)(MasterMode))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- GetMasterMode
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Returns the current operating mode.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of "Master mode constants (for MasterMode,
|
||
* GetMasterMode macros)." type. The value is cast to "uint8".
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_GetMasterMode(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_GetMasterMode(PeripheralBase) ( \
|
||
(uint8)(I2C_C1_REG(PeripheralBase) & I2C_C1_MST_MASK) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetTransmitMode
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Sets data pin to the output or input direction.
|
||
* @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 TransmitMode Direction I2C pins. The user should use one from the
|
||
* enumerated values. This parameter is of "Transmit mode constants (for
|
||
* SetTransmitMode, GetTransmitMode macros)." type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetTransmitMode(<peripheral>_BASE_PTR, I2C_PDD_TX_DIRECTION);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetTransmitMode(PeripheralBase, TransmitMode) ( \
|
||
I2C_C1_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_C1_REG(PeripheralBase) & (uint8)(~(uint8)I2C_C1_TX_MASK))) | ( \
|
||
(uint8)(TransmitMode))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- GetTransmitMode
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Returns the current direction mode.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of "Transmit mode constants (for SetTransmitMode,
|
||
* GetTransmitMode macros)." type. The value is cast to "uint8".
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_GetTransmitMode(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_GetTransmitMode(PeripheralBase) ( \
|
||
(uint8)(I2C_C1_REG(PeripheralBase) & I2C_C1_TX_MASK) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableTransmitAcknowledge
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables/disables an acknowledge signal to be sent to the bus at the
|
||
* ninth clock bit after receiving one byte of data.
|
||
* @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 acknowledge signal. This parameter is of
|
||
* "Global enumeration used for specifying general enable/disable states
|
||
* (PDD_DISABLE and PDD_ENABLE defined in PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableTransmitAcknowledge(<peripheral>_BASE_PTR, PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableTransmitAcknowledge(PeripheralBase, State) ( \
|
||
((State) == PDD_DISABLE) ? ( \
|
||
I2C_C1_REG(PeripheralBase) |= \
|
||
I2C_C1_TXAK_MASK) : ( \
|
||
I2C_C1_REG(PeripheralBase) &= \
|
||
(uint8)(~(uint8)I2C_C1_TXAK_MASK)) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- RepeatStart
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Generates a repeated START condition.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_RepeatStart(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_RepeatStart(PeripheralBase) ( \
|
||
I2C_C1_REG(PeripheralBase) |= \
|
||
I2C_C1_RSTA_MASK \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableWakeUp
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables or disables the wakeup function in stop3 mode.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @param State Requested state of wakeup function. This parameter is of "Global
|
||
* enumeration used for specifying general enable/disable states
|
||
* (PDD_DISABLE and PDD_ENABLE defined in PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableWakeUp(<peripheral>_BASE_PTR, PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableWakeUp(PeripheralBase, State) ( \
|
||
I2C_C1_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_C1_REG(PeripheralBase) & (uint8)(~(uint8)I2C_C1_WUEN_MASK))) | ( \
|
||
(uint8)((uint8)(State) << I2C_C1_WUEN_SHIFT))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableDmaRequest
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables or disables the DMA transfer.
|
||
* @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 DMA function. This parameter is of "Global
|
||
* enumeration used for specifying general enable/disable states
|
||
* (PDD_DISABLE and PDD_ENABLE defined in PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableDmaRequest(<peripheral>_BASE_PTR, PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableDmaRequest(PeripheralBase, State) ( \
|
||
I2C_C1_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_C1_REG(PeripheralBase) & (uint8)(~(uint8)I2C_C1_DMAEN_MASK))) | ( \
|
||
(uint8)(State))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadControl1Reg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Reads control 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 8-bit value.
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_ReadControl1Reg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadControl1Reg(PeripheralBase) ( \
|
||
I2C_C1_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteControl1Reg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes new value specified by the Value parameter into control 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 to the control 1 register. This parameter is
|
||
* a 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C1, I2C1_C1,
|
||
* I2C2_C1, I2C3_C1 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteControl1Reg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteControl1Reg(PeripheralBase, Value) ( \
|
||
I2C_C1_REG(PeripheralBase) = \
|
||
(uint8)(Value) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadStatusReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Returns the value of the status register.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Use constants from group "Status flags constants (for ReadStatusReg,
|
||
* GetInterruptFlags, ClearInterruptFlags macros)." for processing return
|
||
* value.
|
||
* @remarks The macro accesses the following registers: I2C0_S, I2C1_S, I2C2_S,
|
||
* I2C0_S1, I2C1_S1, I2C3_S (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_ReadStatusReg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadStatusReg(PeripheralBase) ( \
|
||
I2C_S_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- GetBusStatus
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Returns status of the BUS.
|
||
* @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 "BUS status constants (for GetBusStatus macro)."
|
||
* type. The value is cast to "uint8".
|
||
* @remarks The macro accesses the following registers: I2C0_S, I2C1_S, I2C2_S,
|
||
* I2C0_S1, I2C1_S1, I2C3_S (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_GetBusStatus(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_GetBusStatus(PeripheralBase) ( \
|
||
(uint8)(I2C_S_REG(PeripheralBase) & I2C_S_BUSY_MASK) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- GetInterruptFlags
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Returns a value that represents a mask of active (pending) interrupts.
|
||
* @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 Use constants from group "Status flags constants (for ReadStatusReg,
|
||
* GetInterruptFlags, ClearInterruptFlags macros)." for processing return
|
||
* value.
|
||
* @remarks The macro accesses the following registers: I2C0_S, I2C1_S, I2C2_S,
|
||
* I2C0_S1, I2C1_S1, I2C3_S (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_GetInterruptFlags(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_GetInterruptFlags(PeripheralBase) ( \
|
||
(uint8)(( \
|
||
I2C_S_REG(PeripheralBase)) & ( \
|
||
(uint8)(( \
|
||
I2C_S_TCF_MASK) | (( \
|
||
I2C_S_IICIF_MASK) | (( \
|
||
I2C_S_RAM_MASK) | (( \
|
||
I2C_S_ARBL_MASK) | ( \
|
||
I2C_S_IAAS_MASK))))))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ClearInterruptFlags
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Clears interrupt flags of interrupts specified by Mask.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @param Mask Mask of interrupt clear requests. Use constants from group
|
||
* "Status flags constants (for ReadStatusReg, GetInterruptFlags,
|
||
* ClearInterruptFlags macros).". This parameter is 8 bits wide.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_S, I2C1_S, I2C2_S,
|
||
* I2C0_S1, I2C1_S1, I2C3_S (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_ClearInterruptFlags(<peripheral>_BASE_PTR,
|
||
* I2C_PDD_RX_ACKNOWLEDGE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ClearInterruptFlags(PeripheralBase, Mask) ( \
|
||
I2C_S_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(( \
|
||
I2C_S_REG(PeripheralBase)) & ( \
|
||
(uint8)(~(uint8)(I2C_S_IICIF_MASK | I2C_S_ARBL_MASK))))) | ( \
|
||
(uint8)(Mask))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteStatusReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes new value specified by the Value parameter into status register.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @param Value Value to be written to the status register. This parameter is a
|
||
* 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_S, I2C1_S, I2C2_S,
|
||
* I2C0_S1, I2C1_S1, I2C3_S (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteStatusReg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteStatusReg(PeripheralBase, Value) ( \
|
||
I2C_S_REG(PeripheralBase) = \
|
||
(uint8)(Value) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadDataReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Returns the content of the data register.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a 8-bit value.
|
||
* @remarks The macro accesses the following registers: I2C0_D, I2C1_D, I2C2_D,
|
||
* I2C3_D (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_ReadDataReg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadDataReg(PeripheralBase) ( \
|
||
I2C_D_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteDataReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes data to the data 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 Data Data value. This parameter is a 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_D, I2C1_D, I2C2_D,
|
||
* I2C3_D (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteDataReg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteDataReg(PeripheralBase, Data) ( \
|
||
I2C_D_REG(PeripheralBase) = \
|
||
(uint8)(Data) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableGeneralCallAddress
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables or disables general call address.
|
||
* @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 general call address function. This parameter
|
||
* is of "Global enumeration used for specifying general enable/disable
|
||
* states (PDD_DISABLE and PDD_ENABLE defined in PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C2, I2C1_C2,
|
||
* I2C2_C2, I2C3_C2 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableGeneralCallAddress(<peripheral>_BASE_PTR, PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableGeneralCallAddress(PeripheralBase, State) ( \
|
||
I2C_C2_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_C2_REG(PeripheralBase) & (uint8)(~(uint8)I2C_C2_GCAEN_MASK))) | ( \
|
||
(uint8)((uint8)(State) << I2C_C2_GCAEN_SHIFT))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableAddressExtension
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables or disables extension address.
|
||
* @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 extension address. This parameter is of
|
||
* "Global enumeration used for specifying general enable/disable states
|
||
* (PDD_DISABLE and PDD_ENABLE defined in PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C2, I2C1_C2,
|
||
* I2C2_C2, I2C3_C2 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableAddressExtension(<peripheral>_BASE_PTR, PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableAddressExtension(PeripheralBase, State) ( \
|
||
I2C_C2_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_C2_REG(PeripheralBase) & (uint8)(~(uint8)I2C_C2_ADEXT_MASK))) | ( \
|
||
(uint8)((uint8)(State) << I2C_C2_ADEXT_SHIFT))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetPadsNormalDriveMode
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Sets control the drive capability of the I2C pads to normal drive mode.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C2, I2C1_C2,
|
||
* I2C2_C2, I2C3_C2 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetPadsNormalDriveMode(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetPadsNormalDriveMode(PeripheralBase) ( \
|
||
I2C_C2_REG(PeripheralBase) &= \
|
||
(uint8)(~(uint8)I2C_C2_HDRS_MASK) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetPadsHighDriveMode
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Sets control the drive capability of the I2C pads to high drive mode.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C2, I2C1_C2,
|
||
* I2C2_C2, I2C3_C2 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetPadsHighDriveMode(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetPadsHighDriveMode(PeripheralBase) ( \
|
||
I2C_C2_REG(PeripheralBase) |= \
|
||
I2C_C2_HDRS_MASK \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableSlaveBaudControlByMaster
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables or disables slave baud rate control by master device.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @param State Requested state of slave baud rate control. This parameter is of
|
||
* "Global enumeration used for specifying general enable/disable states
|
||
* (PDD_DISABLE and PDD_ENABLE defined in PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C2, I2C1_C2,
|
||
* I2C2_C2, I2C3_C2 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableSlaveBaudControlByMaster(<peripheral>_BASE_PTR,
|
||
* PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableSlaveBaudControlByMaster(PeripheralBase, State) ( \
|
||
((State) == PDD_DISABLE) ? ( \
|
||
I2C_C2_REG(PeripheralBase) |= \
|
||
I2C_C2_SBRC_MASK) : ( \
|
||
I2C_C2_REG(PeripheralBase) &= \
|
||
(uint8)(~(uint8)I2C_C2_SBRC_MASK)) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableRangeAddressMatch
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables or disables range address matching.
|
||
* @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 range address matching function. This
|
||
* parameter is of "Global enumeration used for specifying general enable/disable
|
||
* states (PDD_DISABLE and PDD_ENABLE defined in PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C2, I2C1_C2,
|
||
* I2C2_C2, I2C3_C2 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableRangeAddressMatch(<peripheral>_BASE_PTR, PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableRangeAddressMatch(PeripheralBase, State) ( \
|
||
I2C_C2_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_C2_REG(PeripheralBase) & (uint8)(~(uint8)I2C_C2_RMEN_MASK))) | ( \
|
||
(uint8)((uint8)(State) << I2C_C2_RMEN_SHIFT))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadControl2Reg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Reads control 2 register.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a 8-bit value.
|
||
* @remarks The macro accesses the following registers: I2C0_C2, I2C1_C2,
|
||
* I2C2_C2, I2C3_C2 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_ReadControl2Reg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadControl2Reg(PeripheralBase) ( \
|
||
I2C_C2_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteControl2Reg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes new value specified by the Value parameter into control 2
|
||
* 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 to the control 2 register. This parameter is
|
||
* a 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_C2, I2C1_C2,
|
||
* I2C2_C2, I2C3_C2 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteControl2Reg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteControl2Reg(PeripheralBase, Value) ( \
|
||
I2C_C2_REG(PeripheralBase) = \
|
||
(uint8)(Value) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetInputGlitchFilter
|
||
---------------------------------------------------------------------------- */
|
||
|
||
#if ((defined(MCU_MKL02Z4)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKV10Z7)) || (defined(MCU_MKW01Z4)))
|
||
/**
|
||
* @brief Sets the programming controls for the width of glitch (in terms of bus
|
||
* clock cycles) the filter must absorb.
|
||
* @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 FilterFactorValue Input glitch filter value[0..31]. This parameter is
|
||
* a 5-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetInputGlitchFilter(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetInputGlitchFilter(PeripheralBase, FilterFactorValue) ( \
|
||
I2C_FLT_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(( \
|
||
I2C_FLT_REG(PeripheralBase)) & (( \
|
||
(uint8)(~(uint8)I2C_FLT_FLT_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_FLT_STOPF_MASK))))) | ( \
|
||
(uint8)(FilterFactorValue))) \
|
||
)
|
||
#elif ((defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE04Z4)) || (defined(MCU_MKE06Z4)) || (defined(MCU_MKV31F12810)) || (defined(MCU_MKV31F25612)) || (defined(MCU_MKV31F51212)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)))
|
||
/**
|
||
* @brief Sets the programming controls for the width of glitch (in terms of bus
|
||
* clock cycles) the filter must absorb.
|
||
* @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 FilterFactorValue Input glitch filter value[0..15]. This parameter is
|
||
* a 4-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetInputGlitchFilter(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetInputGlitchFilter(PeripheralBase, FilterFactorValue) ( \
|
||
I2C_FLT_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(( \
|
||
I2C_FLT_REG(PeripheralBase)) & (( \
|
||
(uint8)(~(uint8)I2C_FLT_FLT_MASK)) & (( \
|
||
(uint8)(~(uint8)I2C_FLT_STARTF_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_FLT_STOPF_MASK)))))) | ( \
|
||
(uint8)(FilterFactorValue))) \
|
||
)
|
||
#else /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */
|
||
/**
|
||
* @brief Sets the programming controls for the width of glitch (in terms of bus
|
||
* clock cycles) the filter must absorb.
|
||
* @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 FilterFactorValue Input glitch filter value[0..31]. This parameter is
|
||
* a 5-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetInputGlitchFilter(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetInputGlitchFilter(PeripheralBase, FilterFactorValue) ( \
|
||
I2C_FLT_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_FLT_REG(PeripheralBase) & (uint8)(~(uint8)I2C_FLT_FLT_MASK))) | ( \
|
||
(uint8)(FilterFactorValue))) \
|
||
)
|
||
#endif /* (defined(MCU_MK10D10)) || (defined(MCU_MK10D5)) || (defined(MCU_MK10D7)) || (defined(MCU_MK10DZ10)) || (defined(MCU_MK10F12)) || (defined(MCU_MK11D5)) || (defined(MCU_MK11D5WS)) || (defined(MCU_MK12D5)) || (defined(MCU_MK20D10)) || (defined(MCU_MK20D5)) || (defined(MCU_MK20D7)) || (defined(MCU_MK20DZ10)) || (defined(MCU_MK20F12)) || (defined(MCU_MK21D5)) || (defined(MCU_MK21D5WS)) || (defined(MCU_MK22D5)) || (defined(MCU_MK30D10)) || (defined(MCU_MK30D7)) || (defined(MCU_MK30DZ10)) || (defined(MCU_MK40D10)) || (defined(MCU_MK40D7)) || (defined(MCU_MK40DZ10)) || (defined(MCU_MK40X256VMD100)) || (defined(MCU_MK50D10)) || (defined(MCU_MK50D7)) || (defined(MCU_MK50DZ10)) || (defined(MCU_MK51D10)) || (defined(MCU_MK51D7)) || (defined(MCU_MK51DZ10)) || (defined(MCU_MK52D10)) || (defined(MCU_MK52DZ10)) || (defined(MCU_MK53D10)) || (defined(MCU_MK53DZ10)) || (defined(MCU_MK60D10)) || (defined(MCU_MK60DZ10)) || (defined(MCU_MK60F12)) || (defined(MCU_MK60F15)) || (defined(MCU_MK60N512VMD100)) || (defined(MCU_MK61F12)) || (defined(MCU_MK61F12WS)) || (defined(MCU_MK61F15)) || (defined(MCU_MK61F15WS)) || (defined(MCU_MK70F12)) || (defined(MCU_MK70F12WS)) || (defined(MCU_MK70F15)) || (defined(MCU_MK70F15WS)) || (defined(MCU_MKW21D5)) || (defined(MCU_MKW21D5WS)) || (defined(MCU_MKW22D5)) || (defined(MCU_MKW22D5WS)) || (defined(MCU_MKW24D5)) || (defined(MCU_MKW24D5WS)) || (defined(MCU_PCK20L4)) */
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadInputGlitchFilterReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Reads input glitch 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 8-bit value.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result =
|
||
* I2C_PDD_ReadInputGlitchFilterReg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadInputGlitchFilterReg(PeripheralBase) ( \
|
||
I2C_FLT_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteInputGlitchFilterReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes new value specified by the Value parameter into input glitch
|
||
* 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 to the input glitch filter register. This
|
||
* parameter is a 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteInputGlitchFilterReg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteInputGlitchFilterReg(PeripheralBase, Value) ( \
|
||
I2C_FLT_REG(PeripheralBase) = \
|
||
(uint8)(Value) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetRangeAddress
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Sets the range slave address.
|
||
* @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 RangeAddressValue Range Address value[0..127]. This parameter is a
|
||
* 7-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_RA, I2C1_RA,
|
||
* I2C2_RA, I2C3_RA (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetRangeAddress(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetRangeAddress(PeripheralBase, RangeAddressValue) ( \
|
||
I2C_RA_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_RA_REG(PeripheralBase) & (uint8)(~(uint8)I2C_RA_RAD_MASK))) | ( \
|
||
(uint8)((uint8)(RangeAddressValue) << I2C_RA_RAD_SHIFT))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadRangeAddressReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Reads value of range address register.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a 8-bit value.
|
||
* @remarks The macro accesses the following registers: I2C0_RA, I2C1_RA,
|
||
* I2C2_RA, I2C3_RA (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_ReadRangeAddressReg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadRangeAddressReg(PeripheralBase) ( \
|
||
I2C_RA_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteRangeAddressReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes new value specified by the Value parameter into range address
|
||
* 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 to the range address register. This
|
||
* parameter is a 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_RA, I2C1_RA,
|
||
* I2C2_RA, I2C3_RA (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteRangeAddressReg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteRangeAddressReg(PeripheralBase, Value) ( \
|
||
I2C_RA_REG(PeripheralBase) = \
|
||
(uint8)(Value) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableFastSmBusNackAck
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables or disables fast SMBus NACK/ACK.
|
||
* @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 Parameter specifying if SMBus alert response will be enabled or
|
||
* disabled. This parameter is of "Global enumeration used for specifying
|
||
* general enable/disable states (PDD_DISABLE and PDD_ENABLE defined in
|
||
* PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_SMB, I2C1_SMB,
|
||
* I2C2_SMB, I2C3_SMB (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableFastSmBusNackAck(<peripheral>_BASE_PTR, PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableFastSmBusNackAck(PeripheralBase, State) ( \
|
||
I2C_SMB_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(( \
|
||
I2C_SMB_REG(PeripheralBase)) & (( \
|
||
(uint8)(~(uint8)I2C_SMB_FACK_MASK)) & (( \
|
||
(uint8)(~(uint8)I2C_SMB_SHTF2_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_SMB_SLTF_MASK)))))) | ( \
|
||
(uint8)((uint8)(State) << I2C_SMB_FACK_SHIFT))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- GetFastSmBusAcknowledge
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Fast NACK/ACK enable bit.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of "Fast SMBus Acknowledge constants (for
|
||
* GetFastSmBusAcknowledge macro)." type. The value is cast to "uint8".
|
||
* @remarks The macro accesses the following registers: I2C0_SMB, I2C1_SMB,
|
||
* I2C2_SMB, I2C3_SMB (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_GetFastSmBusAcknowledge(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_GetFastSmBusAcknowledge(PeripheralBase) ( \
|
||
(uint8)(I2C_SMB_REG(PeripheralBase) & I2C_SMB_FACK_MASK) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableSmBusAlertResponseAddress
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables or disables SMBus alert response address.
|
||
* @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 Parameter specifying if SMBus alert response will be enabled or
|
||
* disabled. This parameter is of "Global enumeration used for specifying
|
||
* general enable/disable states (PDD_DISABLE and PDD_ENABLE defined in
|
||
* PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_SMB, I2C1_SMB,
|
||
* I2C2_SMB, I2C3_SMB (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableSmBusAlertResponseAddress(<peripheral>_BASE_PTR,
|
||
* PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableSmBusAlertResponseAddress(PeripheralBase, State) ( \
|
||
I2C_SMB_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(( \
|
||
I2C_SMB_REG(PeripheralBase)) & (( \
|
||
(uint8)(~(uint8)I2C_SMB_ALERTEN_MASK)) & (( \
|
||
(uint8)(~(uint8)I2C_SMB_SHTF2_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_SMB_SLTF_MASK)))))) | ( \
|
||
(uint8)((uint8)(State) << I2C_SMB_ALERTEN_SHIFT))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableSecondI2CAddress
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables or disables SMBus device default address.
|
||
* @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 Parameter specifying if SMBus device default address will be
|
||
* enabled or disabled. This parameter is of "Global enumeration used for
|
||
* specifying general enable/disable states (PDD_DISABLE and PDD_ENABLE
|
||
* defined in PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_SMB, I2C1_SMB,
|
||
* I2C2_SMB, I2C3_SMB (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableSecondI2CAddress(<peripheral>_BASE_PTR, PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableSecondI2CAddress(PeripheralBase, State) ( \
|
||
I2C_SMB_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(( \
|
||
I2C_SMB_REG(PeripheralBase)) & (( \
|
||
(uint8)(~(uint8)I2C_SMB_SIICAEN_MASK)) & (( \
|
||
(uint8)(~(uint8)I2C_SMB_SHTF2_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_SMB_SLTF_MASK)))))) | ( \
|
||
(uint8)((uint8)(State) << I2C_SMB_SIICAEN_SHIFT))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetSCLTimeoutBusClockSource
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Sets clock source of the timeout counter to Bus clock or Bus clock/64
|
||
* frequency.
|
||
* @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 ClockSource SCL timeout BUS clock source value. The user should use
|
||
* one from the enumerated values. This parameter is of "Clock source
|
||
* constants (for SetSCLTimeoutBusClockSource macro)." type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_SMB, I2C1_SMB,
|
||
* I2C2_SMB, I2C3_SMB (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetSCLTimeoutBusClockSource(<peripheral>_BASE_PTR,
|
||
* I2C_PDD_BUS_CLOCK);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetSCLTimeoutBusClockSource(PeripheralBase, ClockSource) ( \
|
||
I2C_SMB_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(( \
|
||
I2C_SMB_REG(PeripheralBase)) & (( \
|
||
(uint8)(~(uint8)I2C_SMB_TCKSEL_MASK)) & (( \
|
||
(uint8)(~(uint8)I2C_SMB_SHTF2_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_SMB_SLTF_MASK)))))) | ( \
|
||
(uint8)(ClockSource))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- GetSCLTimeoutInterruptFlags
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Returns a value that represents a mask of active (pending) interrupts.
|
||
* @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 Use constants from group "SCL timeout flags constants (for
|
||
* GetSCLTimeoutInterruptFlags, ClearSCLTimeoutInterruptFlags macros)." for
|
||
* processing return value.
|
||
* @remarks The macro accesses the following registers: I2C0_SMB, I2C1_SMB,
|
||
* I2C2_SMB, I2C3_SMB (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result =
|
||
* I2C_PDD_GetSCLTimeoutInterruptFlags(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_GetSCLTimeoutInterruptFlags(PeripheralBase) ( \
|
||
(uint8)(( \
|
||
I2C_SMB_REG(PeripheralBase)) & ( \
|
||
(uint8)(I2C_SMB_SLTF_MASK | (I2C_SMB_SHTF1_MASK | I2C_SMB_SHTF2_MASK)))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ClearSCLTimeoutInterruptFlags
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Clears interrupt flags of interrupts specified by Mask.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @param Mask Mask of interrupt clear requests. Use constants from group "SCL
|
||
* timeout flags constants (for GetSCLTimeoutInterruptFlags,
|
||
* ClearSCLTimeoutInterruptFlags macros).". This parameter is 8 bits wide.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_SMB, I2C1_SMB,
|
||
* I2C2_SMB, I2C3_SMB (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_ClearSCLTimeoutInterruptFlags(<peripheral>_BASE_PTR,
|
||
* I2C_PDD_SCL_LOW_TIMEOUT);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ClearSCLTimeoutInterruptFlags(PeripheralBase, Mask) ( \
|
||
I2C_SMB_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(( \
|
||
I2C_SMB_REG(PeripheralBase)) & ( \
|
||
(uint8)(~(uint8)(I2C_SMB_SLTF_MASK | I2C_SMB_SHTF2_MASK))))) | ( \
|
||
(uint8)(Mask))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableSCLTimeoutInterrupt
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables SCL high and SDA low timeout interrupt.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_SMB, I2C1_SMB,
|
||
* I2C2_SMB, I2C3_SMB (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableSCLTimeoutInterrupt(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableSCLTimeoutInterrupt(PeripheralBase) ( \
|
||
I2C_SMB_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_SMB_REG(PeripheralBase) | I2C_SMB_SHTF2IE_MASK)) & (( \
|
||
(uint8)(~(uint8)I2C_SMB_SHTF2_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_SMB_SLTF_MASK)))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- DisableSCLTimeoutInterrupt
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Disables SCL high and SDA low timeout interrupt.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_SMB, I2C1_SMB,
|
||
* I2C2_SMB, I2C3_SMB (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_DisableSCLTimeoutInterrupt(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_DisableSCLTimeoutInterrupt(PeripheralBase) ( \
|
||
I2C_SMB_REG(PeripheralBase) &= \
|
||
(uint8)(( \
|
||
(uint8)(~(uint8)I2C_SMB_SHTF2IE_MASK)) & (( \
|
||
(uint8)(~(uint8)I2C_SMB_SHTF2_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_SMB_SLTF_MASK)))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadSMBusControlAndStatusReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Reads SMBus control and status register.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a 8-bit value.
|
||
* @remarks The macro accesses the following registers: I2C0_SMB, I2C1_SMB,
|
||
* I2C2_SMB, I2C3_SMB (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result =
|
||
* I2C_PDD_ReadSMBusControlAndStatusReg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadSMBusControlAndStatusReg(PeripheralBase) ( \
|
||
I2C_SMB_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteSMBusControlAndStatusReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes new value specified by the Value parameter into SMBus control
|
||
* and status register.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @param Value Value to be written to the SMBus control and status register.
|
||
* This parameter is a 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_SMB, I2C1_SMB,
|
||
* I2C2_SMB, I2C3_SMB (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteSMBusControlAndStatusReg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteSMBusControlAndStatusReg(PeripheralBase, Value) ( \
|
||
I2C_SMB_REG(PeripheralBase) = \
|
||
(uint8)(Value) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetSMBusSlaveAddress
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Sets SMBus address to the address 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 SMBusSlaveAddrValue SMBus slave address value[0..127]. This parameter
|
||
* is a 7-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_A2, I2C1_A2,
|
||
* I2C2_A2, I2C3_A2 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetSMBusSlaveAddress(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetSMBusSlaveAddress(PeripheralBase, SMBusSlaveAddrValue) ( \
|
||
I2C_A2_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_A2_REG(PeripheralBase) & (uint8)(~(uint8)I2C_A2_SAD_MASK))) | ( \
|
||
(uint8)((uint8)(SMBusSlaveAddrValue) << I2C_A2_SAD_SHIFT))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadAddress2Reg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Reads address 2 register.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a 8-bit value.
|
||
* @remarks The macro accesses the following registers: I2C0_A2, I2C1_A2,
|
||
* I2C2_A2, I2C3_A2 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_ReadAddress2Reg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadAddress2Reg(PeripheralBase) ( \
|
||
I2C_A2_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteAddress2Reg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes new value specified by the Value parameter into address 2
|
||
* 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 to the address 2 register. This parameter is
|
||
* a 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_A2, I2C1_A2,
|
||
* I2C2_A2, I2C3_A2 (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteAddress2Reg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteAddress2Reg(PeripheralBase, Value) ( \
|
||
I2C_A2_REG(PeripheralBase) = \
|
||
(uint8)(Value) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- SetSCLLowTimeout
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Sets SCL low timeout value that determines the timeout period of SCL
|
||
* low.
|
||
* @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 SCLLowTimeoutValue SCL low timeout value[0..65535]. This parameter is
|
||
* a 16-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_SLTL, I2C0_SLTH,
|
||
* I2C1_SLTL, I2C1_SLTH, I2C2_SLTL, I2C2_SLTH, I2C3_SLTL, I2C3_SLTH
|
||
* (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_SetSCLLowTimeout(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_SetSCLLowTimeout(PeripheralBase, SCLLowTimeoutValue) ( \
|
||
(I2C_SLTL_REG(PeripheralBase) = \
|
||
(uint8)(SCLLowTimeoutValue)), \
|
||
(I2C_SLTH_REG(PeripheralBase) = \
|
||
(uint8)((uint16)(SCLLowTimeoutValue) >> 8U)) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadSclLowTimeoutHighReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Reads SCL low timeout 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).
|
||
* @return Returns a 8-bit value.
|
||
* @remarks The macro accesses the following registers: I2C0_SLTH, I2C1_SLTH,
|
||
* I2C2_SLTH, I2C3_SLTH (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result =
|
||
* I2C_PDD_ReadSclLowTimeoutHighReg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadSclLowTimeoutHighReg(PeripheralBase) ( \
|
||
I2C_SLTH_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteSclLowTimeoutHighReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes new value specified by the Value parameter into SCL low timeout
|
||
* 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 Value to be written to the SCL low timeout high register. This
|
||
* parameter is a 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_SLTH, I2C1_SLTH,
|
||
* I2C2_SLTH, I2C3_SLTH (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteSclLowTimeoutHighReg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteSclLowTimeoutHighReg(PeripheralBase, Value) ( \
|
||
I2C_SLTH_REG(PeripheralBase) = \
|
||
(uint8)(Value) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadSclLowTimeoutLowReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Reads SCL low timeout 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).
|
||
* @return Returns a 8-bit value.
|
||
* @remarks The macro accesses the following registers: I2C0_SLTL, I2C1_SLTL,
|
||
* I2C2_SLTL, I2C3_SLTL (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_ReadSclLowTimeoutLowReg(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadSclLowTimeoutLowReg(PeripheralBase) ( \
|
||
I2C_SLTL_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- WriteSclLowTimeoutLowReg
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Writes new value specified by the Value parameter into SCL low timeout
|
||
* 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 Value to be written to the SCL low timeout low register. This
|
||
* parameter is a 8-bit value.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_SLTL, I2C1_SLTL,
|
||
* I2C2_SLTL, I2C3_SLTL (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_WriteSclLowTimeoutLowReg(<peripheral>_BASE_PTR, 1);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_WriteSclLowTimeoutLowReg(PeripheralBase, Value) ( \
|
||
I2C_SLTL_REG(PeripheralBase) = \
|
||
(uint8)(Value) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableStopHoldOffMode
|
||
---------------------------------------------------------------------------- */
|
||
|
||
#if ((defined(MCU_MKL02Z4)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKV10Z7)) || (defined(MCU_MKW01Z4)))
|
||
/**
|
||
* @brief Enables/disables stop mode holdoff.
|
||
* @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 stop mode holdoff. This parameter is of
|
||
* "Global enumeration used for specifying general enable/disable states
|
||
* (PDD_DISABLE and PDD_ENABLE defined in PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableStopHoldOffMode(<peripheral>_BASE_PTR, PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableStopHoldOffMode(PeripheralBase, State) ( \
|
||
I2C_FLT_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(( \
|
||
I2C_FLT_REG(PeripheralBase)) & (( \
|
||
(uint8)(~(uint8)I2C_FLT_SHEN_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_FLT_STOPF_MASK))))) | ( \
|
||
(uint8)((uint8)(State) << I2C_FLT_SHEN_SHIFT))) \
|
||
)
|
||
#else /* (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE04Z4)) || (defined(MCU_MKE06Z4)) || (defined(MCU_MKV31F12810)) || (defined(MCU_MKV31F25612)) || (defined(MCU_MKV31F51212)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
|
||
/**
|
||
* @brief Enables/disables stop mode holdoff.
|
||
* @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 stop mode holdoff. This parameter is of
|
||
* "Global enumeration used for specifying general enable/disable states
|
||
* (PDD_DISABLE and PDD_ENABLE defined in PDD_Types.h)" type.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableStopHoldOffMode(<peripheral>_BASE_PTR, PDD_DISABLE);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableStopHoldOffMode(PeripheralBase, State) ( \
|
||
I2C_FLT_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(( \
|
||
I2C_FLT_REG(PeripheralBase)) & (( \
|
||
(uint8)(~(uint8)I2C_FLT_SHEN_MASK)) & (( \
|
||
(uint8)(~(uint8)I2C_FLT_STARTF_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_FLT_STOPF_MASK)))))) | ( \
|
||
(uint8)((uint8)(State) << I2C_FLT_SHEN_SHIFT))) \
|
||
)
|
||
#endif /* (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE04Z4)) || (defined(MCU_MKE06Z4)) || (defined(MCU_MKV31F12810)) || (defined(MCU_MKV31F25612)) || (defined(MCU_MKV31F51212)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ReadBusStatusFlags
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Returns the value of the bus status 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 Use constants from group "Status flags constants." for processing
|
||
* return value.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* uint8 result = I2C_PDD_ReadBusStatusFlags(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ReadBusStatusFlags(PeripheralBase) ( \
|
||
I2C_FLT_REG(PeripheralBase) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- ClearBusStatusInterruptFlags
|
||
---------------------------------------------------------------------------- */
|
||
|
||
#if ((defined(MCU_MKL02Z4)) || (defined(MCU_MKL03Z4)) || (defined(MCU_MKL04Z4)) || (defined(MCU_MKL05Z4)) || (defined(MCU_MKL14Z4)) || (defined(MCU_MKL15Z4)) || (defined(MCU_MKL16Z4)) || (defined(MCU_MKL24Z4)) || (defined(MCU_MKL25Z4)) || (defined(MCU_MKL26Z4)) || (defined(MCU_MKL34Z4)) || (defined(MCU_MKL36Z4)) || (defined(MCU_MKL46Z4)) || (defined(MCU_MKV10Z7)) || (defined(MCU_MKW01Z4)))
|
||
/**
|
||
* @brief Clears bus status interrupt flags of interrupts specified by Mask.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @param Mask Mask of interrupt clear requests. Use constants from group
|
||
* "Status flags constants.". This parameter is 8 bits wide.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_ClearBusStatusInterruptFlags(<peripheral>_BASE_PTR,
|
||
* I2C_PDD_BUS_STOP_FLAG);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ClearBusStatusInterruptFlags(PeripheralBase, Mask) ( \
|
||
I2C_FLT_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_FLT_REG(PeripheralBase) & (uint8)(~(uint8)I2C_FLT_STOPF_MASK))) | ( \
|
||
(uint8)(Mask))) \
|
||
)
|
||
#else /* (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE04Z4)) || (defined(MCU_MKE06Z4)) || (defined(MCU_MKV31F12810)) || (defined(MCU_MKV31F25612)) || (defined(MCU_MKV31F51212)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
|
||
/**
|
||
* @brief Clears bus status interrupt flags of interrupts specified by Mask.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @param Mask Mask of interrupt clear requests. Use constants from group
|
||
* "Status flags constants.". This parameter is 8 bits wide.
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_ClearBusStatusInterruptFlags(<peripheral>_BASE_PTR,
|
||
* I2C_PDD_BUS_STOP_FLAG);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_ClearBusStatusInterruptFlags(PeripheralBase, Mask) ( \
|
||
I2C_FLT_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(( \
|
||
I2C_FLT_REG(PeripheralBase)) & ( \
|
||
(uint8)(~(uint8)(I2C_FLT_STOPF_MASK | I2C_FLT_STARTF_MASK))))) | ( \
|
||
(uint8)(Mask))) \
|
||
)
|
||
#endif /* (defined(MCU_MK21F12)) || (defined(MCU_MK21F12WS)) || (defined(MCU_MK22F12)) || (defined(MCU_MK22F12810)) || (defined(MCU_MK22F25612)) || (defined(MCU_MK22F51212)) || (defined(MCU_MK24F12)) || (defined(MCU_MK63F12)) || (defined(MCU_MK63F12WS)) || (defined(MCU_MK64F12)) || (defined(MCU_MK65F18)) || (defined(MCU_MK65F18WS)) || (defined(MCU_MK66F18)) || (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE04Z4)) || (defined(MCU_MKE06Z4)) || (defined(MCU_MKV31F12810)) || (defined(MCU_MKV31F25612)) || (defined(MCU_MKV31F51212)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableBusStopOrStartInterrupt
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables the bus stop or start interrupt.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableBusStopOrStartInterrupt(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableBusStopOrStartInterrupt(PeripheralBase) ( \
|
||
I2C_FLT_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_FLT_REG(PeripheralBase) | I2C_FLT_SSIE_MASK)) & (( \
|
||
(uint8)(~(uint8)I2C_FLT_STARTF_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_FLT_STOPF_MASK)))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- DisableBusStopOrStartInterrupt
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Disables the bus stop or start interrupt.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT,
|
||
* I2C2_FLT, I2C3_FLT (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_DisableBusStopOrStartInterrupt(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_DisableBusStopOrStartInterrupt(PeripheralBase) ( \
|
||
I2C_FLT_REG(PeripheralBase) &= \
|
||
(uint8)(( \
|
||
(uint8)(~(uint8)I2C_FLT_SSIE_MASK)) & (( \
|
||
(uint8)(~(uint8)I2C_FLT_STARTF_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_FLT_STOPF_MASK)))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- EnableBusStopInterrupt
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Enables the bus stop interrupt.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT
|
||
* (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_EnableBusStopInterrupt(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_EnableBusStopInterrupt(PeripheralBase) ( \
|
||
I2C_FLT_REG(PeripheralBase) = \
|
||
(uint8)(( \
|
||
(uint8)(I2C_FLT_REG(PeripheralBase) | I2C_FLT_STOPIE_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_FLT_STOPF_MASK))) \
|
||
)
|
||
|
||
/* ----------------------------------------------------------------------------
|
||
-- DisableBusStopInterrupt
|
||
---------------------------------------------------------------------------- */
|
||
|
||
/**
|
||
* @brief Disables the bus stop interrupt.
|
||
* @param PeripheralBase Pointer to a peripheral registers structure (peripheral
|
||
* base address). You can use the constant defined in the registers
|
||
* definition header file (<peripheral>_BASE_PTR) or the constant defined in
|
||
* the peripheral initialization component header file
|
||
* (<component_name>_DEVICE).
|
||
* @return Returns a value of void type.
|
||
* @remarks The macro accesses the following registers: I2C0_FLT, I2C1_FLT
|
||
* (depending on the peripheral).
|
||
* @par Example:
|
||
* @code
|
||
* I2C_PDD_DisableBusStopInterrupt(<peripheral>_BASE_PTR);
|
||
* @endcode
|
||
*/
|
||
#define I2C_PDD_DisableBusStopInterrupt(PeripheralBase) ( \
|
||
I2C_FLT_REG(PeripheralBase) &= \
|
||
(uint8)(( \
|
||
(uint8)(~(uint8)I2C_FLT_STOPIE_MASK)) & ( \
|
||
(uint8)(~(uint8)I2C_FLT_STOPF_MASK))) \
|
||
)
|
||
#endif /* #if defined(I2C_PDD_H_) */
|
||
|
||
/* I2C_PDD.h, eof. */
|