382 lines
14 KiB
C
382 lines
14 KiB
C
/*
|
||
* Copyright 2017-2020 NXP
|
||
* All rights reserved.
|
||
*
|
||
* SPDX-License-Identifier: BSD-3-Clause
|
||
*/
|
||
#ifndef __FSL_CAPT_H__
|
||
#define __FSL_CAPT_H__
|
||
|
||
#include "fsl_common.h"
|
||
|
||
/*! @addtogroup capt */
|
||
/*! @{*/
|
||
|
||
/*! @file */
|
||
|
||
/*******************************************************************************
|
||
* Definitions
|
||
******************************************************************************/
|
||
|
||
/*! @name Driver version */
|
||
/*@{*/
|
||
/*! @brief CAPT driver version. */
|
||
#define FSL_CAPT_DRIVER_VERSION (MAKE_VERSION(2, 1, 0))
|
||
/*@}*/
|
||
|
||
#define CAPT_GET_XMAX_NUMBER(mask) (((CAPT_STATUS_XMAX_MASK & (mask)) >> CAPT_STATUS_XMAX_SHIFT) + 1)
|
||
|
||
/*!
|
||
* @brief The enumeration for X pins.
|
||
*/
|
||
enum _capt_xpins
|
||
{
|
||
kCAPT_X0Pin = 1U << 0U, /*!< CAPT_X0 pin. */
|
||
kCAPT_X1Pin = 1U << 1U, /*!< CAPT_X1 pin. */
|
||
kCAPT_X2Pin = 1U << 2U, /*!< CAPT_X2 pin. */
|
||
kCAPT_X3Pin = 1U << 3U, /*!< CAPT_X3 pin. */
|
||
kCAPT_X4Pin = 1U << 4U, /*!< CAPT_X4 pin. */
|
||
kCAPT_X5Pin = 1U << 5U, /*!< CAPT_X5 pin. */
|
||
kCAPT_X6Pin = 1U << 6U, /*!< CAPT_X6 pin. */
|
||
kCAPT_X7Pin = 1U << 7U, /*!< CAPT_X7 pin. */
|
||
kCAPT_X8Pin = 1U << 8U, /*!< CAPT_X8 pin. */
|
||
kCAPT_X9Pin = 1U << 9U, /*!< CAPT_X9 pin. */
|
||
kCAPT_X10Pin = 1U << 10U, /*!< CAPT_X10 pin. */
|
||
kCAPT_X11Pin = 1U << 11U, /*!< CAPT_X11 pin. */
|
||
kCAPT_X12Pin = 1U << 12U, /*!< CAPT_X12 pin. */
|
||
kCAPT_X13Pin = 1U << 13U, /*!< CAPT_X13 pin. */
|
||
kCAPT_X14Pin = 1U << 14U, /*!< CAPT_X14 pin. */
|
||
kCAPT_X15Pin = 1U << 15U, /*!< CAPT_X15 pin. */
|
||
};
|
||
|
||
/*!
|
||
* @brief The enumeration for enabling/disabling interrupts.
|
||
*/
|
||
enum _capt_interrupt_enable
|
||
{
|
||
kCAPT_InterruptOfYesTouchEnable =
|
||
CAPT_INTENSET_YESTOUCH_MASK, /*!< Generate interrupt when a touch has been detected. */
|
||
kCAPT_InterruptOfNoTouchEnable =
|
||
CAPT_INTENSET_NOTOUCH_MASK, /*!< Generate interrupt when a no-touch has been detected. */
|
||
kCAPT_InterruptOfPollDoneEnable = CAPT_INTENSET_POLLDONE_MASK, /*!< Genarate interrupt at the end of a polling
|
||
round, or when a POLLNOW completes. */
|
||
kCAPT_InterruptOfTimeOutEnable = CAPT_INTENSET_TIMEOUT_MASK, /*!< Generate interrupt when the count reaches the
|
||
time-out count value before a trigger occurs. */
|
||
kCAPT_InterruptOfOverRunEnable = CAPT_INTENSET_OVERUN_MASK, /*!< Generate interrupt when the Touch Data register has
|
||
been up-dated before software has read the previous
|
||
data, and the touch has been detected. */
|
||
};
|
||
|
||
/*!
|
||
* @brief The enumeration for interrupt status flags.
|
||
*/
|
||
enum _capt_interrupt_status_flags
|
||
{
|
||
kCAPT_InterruptOfYesTouchStatusFlag = CAPT_INTSTAT_YESTOUCH_MASK, /*!< YESTOUCH interrupt status flag. */
|
||
kCAPT_InterruptOfNoTouchStatusFlag = CAPT_INTSTAT_NOTOUCH_MASK, /*!< NOTOUCH interrupt status flag. */
|
||
kCAPT_InterruptOfPollDoneStatusFlag = CAPT_INTSTAT_POLLDONE_MASK, /*!< POLLDONE interrupt status flag. */
|
||
kCAPT_InterruptOfTimeOutStatusFlag = CAPT_INTSTAT_TIMEOUT_MASK, /*!< TIMEOUT interrupt status flag. */
|
||
kCAPT_InterruptOfOverRunStatusFlag = CAPT_INTSTAT_OVERUN_MASK, /*!< OVERRUN interrupt status flag. */
|
||
};
|
||
|
||
/*!
|
||
* @brief The enumeration for CAPT status flags.
|
||
*/
|
||
enum _capt_status_flags
|
||
{
|
||
kCAPT_BusyStatusFlag = CAPT_STATUS_BUSY_MASK, /*!< Set while a poll is currently in progress, otherwise cleared. */
|
||
kCAPT_XMAXStatusFlag = CAPT_STATUS_XMAX_MASK, /*!< The maximum number of X pins available for a given device is
|
||
equal to XMAX+1. */
|
||
};
|
||
|
||
/*!
|
||
* @brief The enumeration for CAPT trigger mode.
|
||
*/
|
||
typedef enum _capt_trigger_mode
|
||
{
|
||
kCAPT_YHPortTriggerMode = 0U, /*!< YH port pin trigger mode. */
|
||
kCAPT_ComparatorTriggerMode = 1U, /*!< Analog comparator trigger mode. */
|
||
} capt_trigger_mode_t;
|
||
|
||
/*!
|
||
* @brief The enumeration for the inactive X pins mode.
|
||
*/
|
||
typedef enum _capt_inactive_xpins_mode
|
||
{
|
||
kCAPT_InactiveXpinsHighZMode =
|
||
0U, /*!< Xpins enabled in the XPINSEL field are controlled to HIGH-Z mode when not active. */
|
||
kCAPT_InactiveXpinsDrivenLowMode =
|
||
1U, /*!< Xpins enabled in the XPINSEL field are controlled to be driven low mode when not active. */
|
||
} capt_inactive_xpins_mode_t;
|
||
|
||
/*!
|
||
* @brief The enumeration for the delay of measuring voltage state.
|
||
*/
|
||
typedef enum _capt_measurement_delay
|
||
{
|
||
kCAPT_MeasureDelayNoWait = 0U, /*!< Don’t wait. */
|
||
kCAPT_MeasureDelayWait3FCLKs = 1U, /*!< Wait 3 divided FCLKs. */
|
||
kCAPT_MeasureDelayWait5FCLKs = 2U, /*!< Wait 5 divided FCLKs. */
|
||
kCAPT_MeasureDelayWait9FCLKs = 3U, /*!< Wait 9 divided FCLKs. */
|
||
} capt_measurement_delay_t;
|
||
|
||
/*!
|
||
* @brief The enumeration for the delay of reseting or draining Cap.
|
||
*/
|
||
typedef enum _capt_reset_delay
|
||
{
|
||
kCAPT_ResetDelayNoWait = 0U, /*!< Don’t wait. */
|
||
kCAPT_ResetDelayWait3FCLKs = 1U, /*!< Wait 3 divided FCLKs. */
|
||
kCAPT_ResetDelayWait5FCLKs = 2U, /*!< Wait 5 divided FCLKs. */
|
||
kCAPT_ResetDelayWait9FCLKs = 3U, /*!< Wait 9 divided FCLKs. */
|
||
} capt_reset_delay_t;
|
||
|
||
/*!
|
||
* @brief The enumeration of CAPT polling mode.
|
||
*/
|
||
typedef enum _capt_polling_mode
|
||
{
|
||
kCAPT_PollInactiveMode =
|
||
0U, /*!< No measurements are taken, no polls are performed. The module remains in the Reset/ Draining Cap. */
|
||
kCAPT_PollNowMode = 1U, /*!< Immediately launches (ignoring Poll Delay) a one-time-only, simultaneous poll of all X
|
||
pins that are enabled in the XPINSEL field of the Control register, then stops, returning
|
||
to Reset/Draining Cap. */
|
||
kCAPT_PollContinuousMode =
|
||
2U, /*!< Polling rounds are continuously performed, by walking through the enabled X pins. */
|
||
} capt_polling_mode_t;
|
||
|
||
/*!
|
||
* @brief The enumeration of CAPT DMA trigger mode.
|
||
*/
|
||
typedef enum _capt_dma_mode
|
||
{
|
||
kCAPT_DMATriggerOnTouchMode = 1U, /*!< Trigger on touch. */
|
||
kCAPT_DMATriggerOnBothMode = 2U, /*!< Trigger on both touch and no-touch. */
|
||
kCAPT_DMATriggerOnAllMode = 3U, /*!< Trigger on all touch, no-touch and time-out. */
|
||
} capt_dma_mode_t;
|
||
|
||
/*!
|
||
* @brief The structure for CAPT basic configuration.
|
||
*/
|
||
typedef struct _capt_config
|
||
{
|
||
bool enableWaitMode; /*!< If enable the wait mode, when the touch event occurs, the module will wait until the TOUCH
|
||
register is read
|
||
before starting the next measurement. Other-wise, measurements continue. */
|
||
bool enableTouchLower; /*!< enableTouchLower = true: Trigger at count < TCNT is a touch. Trigger at count > TCNT is
|
||
a no-touch.
|
||
enableTouchLower = false: Trigger at count > TCNT is a touch. Trigger at count < TCNT is
|
||
a no-touch.
|
||
Notice: TCNT will be set by "CAPT_DoCalibration" API. */
|
||
uint8_t clockDivider; /*!< Function clock divider. The function clock is divided by clockDivider+1 to produce the
|
||
divided FCLK for the module.
|
||
The available range is 0-15. */
|
||
uint8_t timeOutCount; /*!< Sets the count value at which a time-out event occurs if a measurement has not triggered.
|
||
The time-out count value is calculated as 2^timeOutCount. The available range is 0-12. */
|
||
uint8_t pollCount; /*!< Sets the time delay between polling rounds (successive sets of X measurements). After each
|
||
polling round completes,
|
||
the module will wait 4096 x PollCount divided FCLKs before starting the next polling round.
|
||
The available range is 0-255. */
|
||
uint16_t enableXpins; /*!< Selects which of the available X pins are enabled. Please refer to '_capt_xpins'.
|
||
For example, if want to enable X0, X2 and X3 pins, you can set "enableXpins = kCAPT_X0Pin
|
||
| kCAPT_X2Pin
|
||
| kCAPT_X3Pin". */
|
||
capt_trigger_mode_t
|
||
triggerMode; /*!< Select the menthods of measuring the voltage across the measurement capacitor. */
|
||
capt_inactive_xpins_mode_t
|
||
XpinsMode; /*!< Determines how X pins enabled in the XPINSEL field are controlled when not active. */
|
||
capt_measurement_delay_t mDelay; /*!< Set the time delay after entering step 3 (measure voltage state), before
|
||
sampling the YH port pin or analog comarator output. */
|
||
capt_reset_delay_t rDelay; /*!< Set the number of divided FCLKs the module will remain in Reset or Draining Cap. */
|
||
} capt_config_t;
|
||
|
||
/*!
|
||
* @brief The structure for storing touch data.
|
||
*/
|
||
typedef struct _capt_touch_data
|
||
{
|
||
bool yesTimeOut; /*!< 'true': if the measurement resulted in a time-out event, 'false': otherwise. */
|
||
bool yesTouch; /*!< 'true': if the trigger is due to a touch even, 'false': if the trigger is due to a no-touch
|
||
event. */
|
||
uint8_t XpinsIndex; /*!< Contains the index of the X pin for the current measurement, or lowest X for a
|
||
multiple-pin poll now measurement. */
|
||
uint8_t sequenceNumber; /*!< Contains the 4-bit(0-7) sequence number, which increments at the end of each polling
|
||
round. */
|
||
uint16_t count; /*!< Contains the count value reached at trigger or time-out. */
|
||
} capt_touch_data_t;
|
||
|
||
/*******************************************************************************
|
||
* API
|
||
******************************************************************************/
|
||
#if defined(__cplusplus)
|
||
extern "C" {
|
||
#endif /* __cplusplus*/
|
||
|
||
/*!
|
||
* @name Initialization
|
||
* @{
|
||
*/
|
||
|
||
/*!
|
||
* @brief Initialize the CAPT module.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
* @param config Pointer to "capt_config_t" structure.
|
||
*/
|
||
void CAPT_Init(CAPT_Type *base, const capt_config_t *config);
|
||
|
||
/*!
|
||
* @brief De-initialize the CAPT module.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
*/
|
||
void CAPT_Deinit(CAPT_Type *base);
|
||
|
||
/*!
|
||
* @brief Gets an available pre-defined settings for the CAPT's configuration.
|
||
*
|
||
* This function initializes the converter configuration structure with available settings. The default values are:
|
||
* @code
|
||
* config->enableWaitMode = false;
|
||
* config->enableTouchLower = true;
|
||
* config->clockDivider = 15U;
|
||
* config->timeOutCount = 12U;
|
||
* config->pollCount = 0U;
|
||
* config->enableXpins = 0U;
|
||
* config->triggerMode = kCAPT_YHPortTriggerMode;
|
||
* config->XpinsMode = kCAPT_InactiveXpinsDrivenLowMode;
|
||
* config->mDelay = kCAPT_MeasureDelayNoWait;
|
||
* config->rDelay = kCAPT_ResetDelayWait9FCLKs;
|
||
* @endcode
|
||
* @param config Pointer to the configuration structure.
|
||
*/
|
||
void CAPT_GetDefaultConfig(capt_config_t *config);
|
||
|
||
/*!
|
||
* @brief Set Sets the count threshold in divided FCLKs between touch and no-touch.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
* @param count The count threshold.
|
||
*/
|
||
static inline void CAPT_SetThreshold(CAPT_Type *base, uint32_t count)
|
||
{
|
||
base->POLL_TCNT = ((base->POLL_TCNT & ~CAPT_POLL_TCNT_TCNT_MASK) | CAPT_POLL_TCNT_TCNT(count));
|
||
}
|
||
|
||
/*!
|
||
* @brief Set the CAPT polling mode.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
* @param mode The selection of polling mode.
|
||
*/
|
||
void CAPT_SetPollMode(CAPT_Type *base, capt_polling_mode_t mode);
|
||
|
||
#if defined(FSL_FEATURE_CAPT_HAS_CTRL_DMA) && FSL_FEATURE_CAPT_HAS_CTRL_DMA
|
||
/*!
|
||
* @brief Enable DMA feature.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
* @param mode Select how DMA triggers are generated.
|
||
*/
|
||
void CAPT_EnableDMA(CAPT_Type *base, capt_dma_mode_t mode);
|
||
|
||
/*!
|
||
* @brief Disable DMA feature.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
*/
|
||
void CAPT_DisableDMA(CAPT_Type *base);
|
||
#endif /*FSL_FEATURE_CAPT_HAS_CTRL_DMA*/
|
||
|
||
/*!
|
||
* @brief Enable interrupt features.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
* @param mask The mask of enabling interrupt features. Please refer to "_capt_interrupt_enable".
|
||
*/
|
||
static inline void CAPT_EnableInterrupts(CAPT_Type *base, uint32_t mask)
|
||
{
|
||
base->INTENSET = mask;
|
||
}
|
||
|
||
/*!
|
||
* @brief Disable interrupt features.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
* @param mask The mask of disabling interrupt features. Please refer to "_capt_interrupt_enable".
|
||
*/
|
||
static inline void CAPT_DisableInterrupts(CAPT_Type *base, uint32_t mask)
|
||
{
|
||
base->INTENCLR = mask;
|
||
}
|
||
|
||
/*!
|
||
* @brief Get CAPT interrupts' status flags.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
* @return The mask of interrupts' status flags. please refer to "_capt_interrupt_status_flags".
|
||
*/
|
||
static inline uint32_t CAPT_GetInterruptStatusFlags(CAPT_Type *base)
|
||
{
|
||
return base->INTSTAT;
|
||
}
|
||
|
||
/*!
|
||
* @brief Clear the interrupts' status flags.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
* @param mask The mask of clearing the interrupts' status flags, please refer to "_capt_interrupt_status_flags".
|
||
*/
|
||
static inline void CAPT_ClearInterruptStatusFlags(CAPT_Type *base, uint32_t mask)
|
||
{
|
||
base->STATUS = mask;
|
||
}
|
||
|
||
/*!
|
||
* @brief Get CAPT status flags.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
* @return The mask of CAPT status flags. Please refer to "_capt_status_flags"
|
||
* Or use CAPT_GET_XMAX_NUMBER(mask) to get XMAX number.
|
||
*/
|
||
static inline uint32_t CAPT_GetStatusFlags(CAPT_Type *base)
|
||
{
|
||
return base->STATUS;
|
||
}
|
||
|
||
/*!
|
||
* @brief Get CAPT touch data.
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
* @param data The structure to store touch data.
|
||
*
|
||
* @return If return 'true', which means get valid data.
|
||
* if return 'false', which means get invalid data.
|
||
*/
|
||
bool CAPT_GetTouchData(CAPT_Type *base, capt_touch_data_t *data);
|
||
|
||
/*!
|
||
* @brief Start touch data polling using poll-now method.
|
||
*
|
||
* This function starts new data polling using polling-now method, CAPT stops when
|
||
* the polling is finished, application could check the status or monitor interrupt
|
||
* to know when the progress is finished.
|
||
*
|
||
* Note that this is simultaneous poll of all X pins, all enabled X pins are
|
||
* activated concurrently, rather than walked one-at-a-time
|
||
*
|
||
* @param base CAPT peripheral base address.
|
||
* @param enableXpins The X pins enabled in this polling.
|
||
*/
|
||
void CAPT_PollNow(CAPT_Type *base, uint16_t enableXpins);
|
||
|
||
/*@}*/
|
||
|
||
#if defined(__cplusplus)
|
||
}
|
||
#endif /* __cplusplus*/
|
||
|
||
/*@}*/
|
||
|
||
#endif /* _FSL_CAPT_H_ */
|