CSEN - Capacitive Sense

Description

Capacitive Sense (CSEN) Peripheral API.

Provides functions to control the capacitive sense peripheral of Silicon Labs' 32-bit MCUs and SoCs. The CSEN includes a capacitance-to-digital circuit that measures capacitance on selected inputs. Measurements are performed using either a Successive Approximation Register (SAR) or a Delta Modulator (DM) analog to digital converter.

The CSEN can be configured to measure capacitance on a single port pin or to automatically measure multiple port pins in succession using scan mode. Also, several port pins can be shorted together to measure the combined capacitance.

The CSEN includes an accumulator, which can be configured to average multiple conversions on the selected input. Additionally, an Exponential Moving Average (EMA) calculator is included to provide data smoothing. A comparator is also included and can be used to terminate a continuous conversion when the configured threshold condition is met.

The following example shows how to initialize and start a single conversion on one input:

/* CSEN is a HFPERCLK peripheral. */
/* Initialize with default settings. */
CSEN_Init(CSEN, &csenInit);
/* Select the input pin and initialize the conversion mode. */
csenInitMode.singleSel = csenSingleSelAPORT1XCH0;
CSEN_InitMode(CSEN, &csenInitMode);
/* Enable CSEN and manually start the conversion. */
CSEN_Start(CSEN);

Data Structures

struct  CSEN_Init_TypeDef
 CSEN initialization structure, common for all measurement modes.
 
struct  CSEN_InitMode_TypeDef
 Measurement mode initialization structure.
 

Functions

void CSEN_DMBaselineSet (CSEN_TypeDef *csen, uint32_t up, uint32_t down)
 Set the DM integrator initial value.
 
void CSEN_Init (CSEN_TypeDef *csen, const CSEN_Init_TypeDef *init)
 Initialize CSEN.
 
void CSEN_InitMode (CSEN_TypeDef *csen, const CSEN_InitMode_TypeDef *init)
 Initialize a CSEN measurement mode.
 
void CSEN_Reset (CSEN_TypeDef *csen)
 Reset CSEN to same state that it was in after a hardware reset.
 
uint32_t CSEN_DataGet (CSEN_TypeDef *csen)
 Get the last conversion result.
 
uint32_t CSEN_EMAGet (CSEN_TypeDef *csen)
 Get the last exponential moving average.
 
void CSEN_EMASet (CSEN_TypeDef *csen, uint32_t ema)
 Set the exponential moving average initial value.
 
void CSEN_Disable (CSEN_TypeDef *csen)
 Disable CSEN.
 
void CSEN_Enable (CSEN_TypeDef *csen)
 Enable CSEN.
 
void CSEN_IntClear (CSEN_TypeDef *csen, uint32_t flags)
 Clear one or more pending CSEN interrupts.
 
void CSEN_IntDisable (CSEN_TypeDef *csen, uint32_t flags)
 Disable one or more CSEN interrupts.
 
void CSEN_IntEnable (CSEN_TypeDef *csen, uint32_t flags)
 Enable one or more CSEN interrupts.
 
uint32_t CSEN_IntGet (CSEN_TypeDef *csen)
 Get pending CSEN interrupt flags.
 
uint32_t CSEN_IntGetEnabled (CSEN_TypeDef *csen)
 Get enabled and pending CSEN interrupt flags.
 
void CSEN_IntSet (CSEN_TypeDef *csen, uint32_t flags)
 Set one or more pending CSEN interrupts from SW.
 
bool CSEN_IsBusy (CSEN_TypeDef *csen)
 Return CSEN conversion busy status.
 
void CSEN_Start (CSEN_TypeDef *csen)
 Start a scan sequence and/or a single conversion.
 

Macros

#define CSEN_INIT_DEFAULT
 CSEN default initialization.
 
#define CSEN_INITMODE_DEFAULT
 CSEN default mode initialization.
 

Enumerations

enum  CSEN_CmpMode_TypeDef {
  csenCmpModeDisabled = 0,
  csenCmpModeGreater = CSEN_CTRL_CMPEN | CSEN_CTRL_CMPPOL_GT,
  csenCmpModeLessOrEqual = CSEN_CTRL_CMPEN | CSEN_CTRL_CMPPOL_LTE,
  csenCmpModeEMAWindow = CSEN_CTRL_EMACMPEN
}
 Comparator Mode.
 
enum  CSEN_ConvSel_TypeDef {
  csenConvSelSAR = CSEN_CTRL_CONVSEL_SAR,
  csenConvSelSARChop = CSEN_CTRL_CONVSEL_SAR | CSEN_CTRL_CHOPEN_ENABLE,
  csenConvSelDM = CSEN_CTRL_CONVSEL_DM,
  csenConvSelDMChop = CSEN_CTRL_CONVSEL_DM | CSEN_CTRL_CHOPEN_ENABLE
}
 Converter Select.
 
enum  CSEN_SampleMode_TypeDef {
  csenSampleModeBonded = CSEN_CTRL_CM_SGL | CSEN_CTRL_MCEN_ENABLE,
  csenSampleModeSingle = CSEN_CTRL_CM_SGL,
  csenSampleModeScan = CSEN_CTRL_CM_SCAN,
  csenSampleModeContBonded = CSEN_CTRL_CM_CONTSGL | CSEN_CTRL_MCEN_ENABLE,
  csenSampleModeContSingle = CSEN_CTRL_CM_CONTSGL,
  csenSampleModeContScan = CSEN_CTRL_CM_CONTSCAN
}
 Sample Mode.
 
enum  CSEN_TrigSel_TypeDef {
  csenTrigSelPRS = _CSEN_CTRL_STM_PRS,
  csenTrigSelTimer = _CSEN_CTRL_STM_TIMER,
  csenTrigSelStart = _CSEN_CTRL_STM_START
}
 Starts Trigger Select.
 
enum  CSEN_AccMode_TypeDef {
  csenAccMode1 = _CSEN_CTRL_ACU_ACC1,
  csenAccMode2 = _CSEN_CTRL_ACU_ACC2,
  csenAccMode4 = _CSEN_CTRL_ACU_ACC4,
  csenAccMode8 = _CSEN_CTRL_ACU_ACC8,
  csenAccMode16 = _CSEN_CTRL_ACU_ACC16,
  csenAccMode32 = _CSEN_CTRL_ACU_ACC32,
  csenAccMode64 = _CSEN_CTRL_ACU_ACC64
}
 Accumulator Mode Select.
 
enum  CSEN_SARRes_TypeDef {
  csenSARRes10 = _CSEN_CTRL_SARCR_CLK10,
  csenSARRes12 = _CSEN_CTRL_SARCR_CLK12,
  csenSARRes14 = _CSEN_CTRL_SARCR_CLK14,
  csenSARRes16 = _CSEN_CTRL_SARCR_CLK16
}
 Successive Approximation (SAR) Conversion Resolution.
 
enum  CSEN_DMRes_TypeDef {
  csenDMRes10 = _CSEN_DMCFG_CRMODE_DM10,
  csenDMRes12 = _CSEN_DMCFG_CRMODE_DM12,
  csenDMRes14 = _CSEN_DMCFG_CRMODE_DM14,
  csenDMRes16 = _CSEN_DMCFG_CRMODE_DM16
}
 Delta Modulator (DM) Conversion Resolution.
 
enum  CSEN_PCPrescale_TypeDef {
  csenPCPrescaleDiv1 = _CSEN_TIMCTRL_PCPRESC_DIV1,
  csenPCPrescaleDiv2 = _CSEN_TIMCTRL_PCPRESC_DIV2,
  csenPCPrescaleDiv4 = _CSEN_TIMCTRL_PCPRESC_DIV4,
  csenPCPrescaleDiv8 = _CSEN_TIMCTRL_PCPRESC_DIV8,
  csenPCPrescaleDiv16 = _CSEN_TIMCTRL_PCPRESC_DIV16,
  csenPCPrescaleDiv32 = _CSEN_TIMCTRL_PCPRESC_DIV32,
  csenPCPrescaleDiv64 = _CSEN_TIMCTRL_PCPRESC_DIV64,
  csenPCPrescaleDiv128 = _CSEN_TIMCTRL_PCPRESC_DIV128
}
 Period counter clock pre-scaler.
 
enum  CSEN_EMASample_TypeDef {
  csenEMASampleW1 = _CSEN_EMACTRL_EMASAMPLE_W1,
  csenEMASampleW2 = _CSEN_EMACTRL_EMASAMPLE_W2,
  csenEMASampleW4 = _CSEN_EMACTRL_EMASAMPLE_W4,
  csenEMASampleW8 = _CSEN_EMACTRL_EMASAMPLE_W8,
  csenEMASampleW16 = _CSEN_EMACTRL_EMASAMPLE_W16,
  csenEMASampleW32 = _CSEN_EMACTRL_EMASAMPLE_W32,
  csenEMASampleW64 = _CSEN_EMACTRL_EMASAMPLE_W64
}
 Exponential Moving Average sample weight.
 
enum  CSEN_ResetPhaseSel_TypeDef {
  csenResetPhaseSel0 = 0,
  csenResetPhaseSel1 = 1,
  csenResetPhaseSel2 = 2,
  csenResetPhaseSel3 = 3,
  csenResetPhaseSel4 = 4,
  csenResetPhaseSel5 = 5,
  csenResetPhaseSel6 = 6,
  csenResetPhaseSel7 = 7
}
 Reset Phase Timing Select (units are microseconds).
 
enum  CSEN_DriveSel_TypeDef {
  csenDriveSelFull = 0,
  csenDriveSel1 = 1,
  csenDriveSel2 = 2,
  csenDriveSel3 = 3,
  csenDriveSel4 = 4,
  csenDriveSel5 = 5,
  csenDriveSel6 = 6,
  csenDriveSel7 = 7
}
 Drive Strength Select.
 
enum  CSEN_GainSel_TypeDef {
  csenGainSel1X = 0,
  csenGainSel2X = 1,
  csenGainSel3X = 2,
  csenGainSel4X = 3,
  csenGainSel5X = 4,
  csenGainSel6X = 5,
  csenGainSel7X = 6,
  csenGainSel8X = 7
}
 Gain Select.
 
enum  CSEN_PRSSel_TypeDef {
  csenPRSSELCh0 = _CSEN_PRSSEL_PRSSEL_PRSCH0,
  csenPRSSELCh1 = _CSEN_PRSSEL_PRSSEL_PRSCH1,
  csenPRSSELCh2 = _CSEN_PRSSEL_PRSSEL_PRSCH2,
  csenPRSSELCh3 = _CSEN_PRSSEL_PRSSEL_PRSCH3,
  csenPRSSELCh4 = _CSEN_PRSSEL_PRSSEL_PRSCH4,
  csenPRSSELCh5 = _CSEN_PRSSEL_PRSSEL_PRSCH5,
  csenPRSSELCh6 = _CSEN_PRSSEL_PRSSEL_PRSCH6,
  csenPRSSELCh7 = _CSEN_PRSSEL_PRSSEL_PRSCH7,
  csenPRSSELCh8 = _CSEN_PRSSEL_PRSSEL_PRSCH8,
  csenPRSSELCh9 = _CSEN_PRSSEL_PRSSEL_PRSCH9,
  csenPRSSELCh10 = _CSEN_PRSSEL_PRSSEL_PRSCH10,
  csenPRSSELCh11 = _CSEN_PRSSEL_PRSSEL_PRSCH11
}
 Peripheral Reflex System signal used to trigger conversion.
 
enum  CSEN_InputSel_TypeDef {
  csenInputSelDefault = _CSEN_SCANINPUTSEL0_INPUT0TO7SEL_DEFAULT,
  csenInputSelAPORT1CH0TO7 = _CSEN_SCANINPUTSEL0_INPUT0TO7SEL_APORT1CH0TO7,
  csenInputSelAPORT1CH8TO15 = _CSEN_SCANINPUTSEL0_INPUT0TO7SEL_APORT1CH8TO15,
  csenInputSelAPORT1CH16TO23 = _CSEN_SCANINPUTSEL0_INPUT0TO7SEL_APORT1CH16TO23,
  csenInputSelAPORT1CH24TO31 = _CSEN_SCANINPUTSEL0_INPUT0TO7SEL_APORT1CH24TO31,
  csenInputSelAPORT3CH0TO7 = _CSEN_SCANINPUTSEL0_INPUT0TO7SEL_APORT3CH0TO7,
  csenInputSelAPORT3CH8TO15 = _CSEN_SCANINPUTSEL0_INPUT0TO7SEL_APORT3CH8TO15,
  csenInputSelAPORT3CH16TO23 = _CSEN_SCANINPUTSEL0_INPUT0TO7SEL_APORT3CH16TO23,
  csenInputSelAPORT3CH24TO31 = _CSEN_SCANINPUTSEL0_INPUT0TO7SEL_APORT3CH24TO31
}
 APORT channel to CSEN input selection.
 
enum  CSEN_SingleSel_TypeDef {
  csenSingleSelDefault = _CSEN_SINGLECTRL_SINGLESEL_DEFAULT,
  csenSingleSelAPORT1XCH0 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH0,
  csenSingleSelAPORT1YCH1 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH1,
  csenSingleSelAPORT1XCH2 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH2,
  csenSingleSelAPORT1YCH3 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH3,
  csenSingleSelAPORT1XCH4 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH4,
  csenSingleSelAPORT1YCH5 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH5,
  csenSingleSelAPORT1XCH6 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH6,
  csenSingleSelAPORT1YCH7 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH7,
  csenSingleSelAPORT1XCH8 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH8,
  csenSingleSelAPORT1YCH9 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH9,
  csenSingleSelAPORT1XCH10 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH10,
  csenSingleSelAPORT1YCH11 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH11,
  csenSingleSelAPORT1XCH12 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH12,
  csenSingleSelAPORT1YCH13 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH13,
  csenSingleSelAPORT1XCH14 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH14,
  csenSingleSelAPORT1YCH15 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH15,
  csenSingleSelAPORT1XCH16 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH16,
  csenSingleSelAPORT1YCH17 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH17,
  csenSingleSelAPORT1XCH18 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH18,
  csenSingleSelAPORT1YCH19 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH19,
  csenSingleSelAPORT1XCH20 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH20,
  csenSingleSelAPORT1YCH21 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH21,
  csenSingleSelAPORT1XCH22 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH22,
  csenSingleSelAPORT1YCH23 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH23,
  csenSingleSelAPORT1XCH24 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH24,
  csenSingleSelAPORT1YCH25 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH25,
  csenSingleSelAPORT1XCH26 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH26,
  csenSingleSelAPORT1YCH27 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH27,
  csenSingleSelAPORT1XCH28 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH28,
  csenSingleSelAPORT1YCH29 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH29,
  csenSingleSelAPORT1XCH30 = _CSEN_SINGLECTRL_SINGLESEL_APORT1XCH30,
  csenSingleSelAPORT1YCH31 = _CSEN_SINGLECTRL_SINGLESEL_APORT1YCH31,
  csenSingleSelAPORT3XCH0 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH0,
  csenSingleSelAPORT3YCH1 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH1,
  csenSingleSelAPORT3XCH2 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH2,
  csenSingleSelAPORT3YCH3 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH3,
  csenSingleSelAPORT3XCH4 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH4,
  csenSingleSelAPORT3YCH5 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH5,
  csenSingleSelAPORT3XCH6 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH6,
  csenSingleSelAPORT3YCH7 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH7,
  csenSingleSelAPORT3XCH8 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH8,
  csenSingleSelAPORT3YCH9 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH9,
  csenSingleSelAPORT3XCH10 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH10,
  csenSingleSelAPORT3YCH11 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH11,
  csenSingleSelAPORT3XCH12 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH12,
  csenSingleSelAPORT3YCH13 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH13,
  csenSingleSelAPORT3XCH14 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH14,
  csenSingleSelAPORT3YCH15 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH15,
  csenSingleSelAPORT3XCH16 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH16,
  csenSingleSelAPORT3YCH17 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH17,
  csenSingleSelAPORT3XCH18 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH18,
  csenSingleSelAPORT3YCH19 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH19,
  csenSingleSelAPORT3XCH20 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH20,
  csenSingleSelAPORT3YCH21 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH21,
  csenSingleSelAPORT3XCH22 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH22,
  csenSingleSelAPORT3YCH23 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH23,
  csenSingleSelAPORT3XCH24 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH24,
  csenSingleSelAPORT3YCH25 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH25,
  csenSingleSelAPORT3XCH26 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH26,
  csenSingleSelAPORT3YCH27 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH27,
  csenSingleSelAPORT3XCH28 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH28,
  csenSingleSelAPORT3YCH29 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH29,
  csenSingleSelAPORT3XCH30 = _CSEN_SINGLECTRL_SINGLESEL_APORT3XCH30,
  csenSingleSelAPORT3YCH31 = _CSEN_SINGLECTRL_SINGLESEL_APORT3YCH31
}
 APORT channel to CSEN single input selection.
 

Function Documentation

◆ CSEN_DMBaselineSet()

void CSEN_DMBaselineSet ( CSEN_TypeDef *  csen,
uint32_t  up,
uint32_t  down 
)

Set the DM integrator initial value.

Sets the initial value of the integrator(s) for the Delta Modulation (DM) converter. The initial value for the ramp-down integrator has no effect if the low-frequency attenuation was not selected by the mode initialization function CSEN_InitMode().

Note
Confirm CSEN is idle before calling this function.
Parameters
[in]csenA pointer to the CSEN peripheral register block.
[in]upAn initial value for the ramp-up integrator.
[in]downAn initial value for the ramp-down integrator. Has no effect if low-frequency attenuation is not configured.

◆ CSEN_Init()

void CSEN_Init ( CSEN_TypeDef *  csen,
const CSEN_Init_TypeDef init 
)

Initialize CSEN.

Initializes common functionality for all measurement types. In addition, measurement mode must be configured. See CSEN_InitMode().

Note
This function will stop any ongoing conversion and disable CSEN.
Parameters
[in]csenA pointer to the CSEN peripheral register block.
[in]initA pointer to the CSEN initialization structure.

◆ CSEN_InitMode()

void CSEN_InitMode ( CSEN_TypeDef *  csen,
const CSEN_InitMode_TypeDef init 
)

Initialize a CSEN measurement mode.

Used to configure any type of measurement mode. After the measurement has been configured, calling CSEN_Enable() will enable CSEN and allow it to start a conversion from the selected trigger source. To manually start a conversion, use CSEN_Start(). To check if a conversion is in progress, use CSEN_IsBusy(), or alternatively use the interrupt flags returned by CSEN_IntGet() to detect when a conversion is completed.

Note
This function will stop any ongoing conversion and disable CSEN.
Parameters
[in]csenA pointer to the CSEN peripheral register block.
[in]initA pointer to the CSEN measurement mode initialization structure.

◆ CSEN_Reset()

void CSEN_Reset ( CSEN_TypeDef *  csen)

Reset CSEN to same state that it was in after a hardware reset.

Parameters
[in]csenA pointer to the CSEN peripheral register block.

◆ CSEN_DataGet()

uint32_t CSEN_DataGet ( CSEN_TypeDef *  csen)
inline

Get the last conversion result.

Note
Check the conversion busy flag before calling this function. In addition, the result width and format depend on the parameters passed to the CSEN_InitMode() function.
Parameters
[in]csenPointer to a CSEN peripheral register block.
Returns
Result data from last conversion.

◆ CSEN_EMAGet()

uint32_t CSEN_EMAGet ( CSEN_TypeDef *  csen)
inline

Get the last exponential moving average.

Note
Confirm that CSEN is idle before calling this function.
Parameters
[in]csenPointer to a CSEN peripheral register block.
Returns
Exponential moving average from last conversion.

◆ CSEN_EMASet()

void CSEN_EMASet ( CSEN_TypeDef *  csen,
uint32_t  ema 
)
inline

Set the exponential moving average initial value.

Note
Call this function before starting a conversion.
Parameters
[in]csenPointer to a CSEN peripheral register block.
[in]emaInitial value for the exponential moving average.

◆ CSEN_Disable()

void CSEN_Disable ( CSEN_TypeDef *  csen)
inline

Disable CSEN.

Parameters
[in]csenPointer to a CSEN peripheral register block.

◆ CSEN_Enable()

void CSEN_Enable ( CSEN_TypeDef *  csen)
inline

Enable CSEN.

Parameters
[in]csenPointer to a CSEN peripheral register block.

◆ CSEN_IntClear()

void CSEN_IntClear ( CSEN_TypeDef *  csen,
uint32_t  flags 
)
inline

Clear one or more pending CSEN interrupts.

Parameters
[in]csenPointer to a CSEN peripheral register block.
[in]flagsPending CSEN interrupt source to clear. Use a bitwise logic OR combination of valid interrupt flags for the CSEN module (CSEN_IF_nnn).

◆ CSEN_IntDisable()

void CSEN_IntDisable ( CSEN_TypeDef *  csen,
uint32_t  flags 
)
inline

Disable one or more CSEN interrupts.

Parameters
[in]csenPointer to a CSEN peripheral register block.
[in]flagsCSEN interrupt sources to disable. Use a bitwise logic OR combination of valid interrupt flags for the CSEN module (CSEN_IF_nnn).

◆ CSEN_IntEnable()

void CSEN_IntEnable ( CSEN_TypeDef *  csen,
uint32_t  flags 
)
inline

Enable one or more CSEN interrupts.

Note
Depending on the use case, a pending interrupt may already be set prior to enabling the interrupt. Consider using CSEN_IntClear() prior to enabling if such a pending interrupt should be ignored.
Parameters
[in]csenPointer to a CSEN peripheral register block.
[in]flagsCSEN interrupt sources to enable. Use a bitwise logic OR combination of valid interrupt flags for the CSEN module (CSEN_IF_nnn).

◆ CSEN_IntGet()

uint32_t CSEN_IntGet ( CSEN_TypeDef *  csen)
inline

Get pending CSEN interrupt flags.

Note
The event bits are not cleared by the use of this function.
Parameters
[in]csenPointer to a CSEN peripheral register block.
Returns
CSEN interrupt sources pending. A bitwise logic OR combination of valid interrupt flags for the CSEN module (CSEN_IF_nnn).

◆ CSEN_IntGetEnabled()

uint32_t CSEN_IntGetEnabled ( CSEN_TypeDef *  csen)
inline

Get enabled and pending CSEN interrupt flags.

Useful for handling more interrupt sources in the same interrupt handler.

Parameters
[in]csenPointer to a CSEN peripheral register block.
Note
Interrupt flags are not cleared by the use of this function.
Returns
Pending and enabled CSEN interrupt sources. The return value is the bitwise AND combination of
  • the OR combination of enabled interrupt sources in CSENx_IEN_nnn register (CSENx_IEN_nnn) and
  • the OR combination of valid interrupt flags of the CSEN module (CSENx_IF_nnn).

◆ CSEN_IntSet()

void CSEN_IntSet ( CSEN_TypeDef *  csen,
uint32_t  flags 
)
inline

Set one or more pending CSEN interrupts from SW.

Parameters
[in]csenPointer to a CSEN peripheral register block.
[in]flagsCSEN interrupt sources to set to pending. Use a bitwise logic OR combination of valid interrupt flags for the CSEN module (CSEN_IF_nnn).

◆ CSEN_IsBusy()

bool CSEN_IsBusy ( CSEN_TypeDef *  csen)
inline

Return CSEN conversion busy status.

Parameters
[in]csenPointer to a CSEN peripheral register block.
Returns
True if CSEN conversion is in progress.

◆ CSEN_Start()