LESENSE
[EM_Library]

Low Energy Sensor (LESENSE) Peripheral API. More...

Collaboration diagram for LESENSE:

Data Structures

struct  LESENSE_CoreCtrlDesc_TypeDef
struct  LESENSE_TimeCtrlDesc_TypeDef
struct  LESENSE_PerCtrlDesc_TypeDef
struct  LESENSE_DecCtrlDesc_TypeDef
struct  LESENSE_Init_TypeDef
struct  LESENSE_ChDesc_TypeDef
struct  LESENSE_ChAll_TypeDef
struct  LESENSE_AltExDesc_TypeDef
struct  LESENSE_ConfAltEx_TypeDef
struct  LESENSE_DecStCond_TypeDef
struct  LESENSE_DecStDesc_TypeDef
struct  LESENSE_DecStAll_TypeDef

Defines

#define LESENSE_CORECTRL_DESC_DEFAULT
#define LESENSE_TIMECTRL_DESC_DEFAULT
#define LESENSE_PERCTRL_DESC_DEFAULT
#define LESENSE_DECCTRL_DESC_DEFAULT
#define LESENSE_INIT_DEFAULT
#define LESENSE_CH_CONF_DEFAULT
#define LESENSE_SCAN_CONF_DEFAULT
#define LESENSE_ALTEX_CH_CONF_DEFAULT
#define LESENSE_ALTEX_CONF_DEFAULT
#define LESENSE_ST_CONF_DEFAULT
#define LESENSE_DECODER_CONF_DEFAULT

Enumerations

enum  LESENSE_ClkPresc_TypeDef {
  lesenseClkDiv_1 = 0,
  lesenseClkDiv_2 = 1,
  lesenseClkDiv_4 = 2,
  lesenseClkDiv_8 = 3,
  lesenseClkDiv_16 = 4,
  lesenseClkDiv_32 = 5,
  lesenseClkDiv_64 = 6,
  lesenseClkDiv_128 = 7
}
enum  LESENSE_ScanMode_TypeDef {
  lesenseScanStartPeriodic = LESENSE_CTRL_SCANMODE_PERIODIC,
  lesenseScanStartOneShot = LESENSE_CTRL_SCANMODE_ONESHOT,
  lesenseScanStartPRS = LESENSE_CTRL_SCANMODE_PRS
}
enum  LESENSE_PRSSel_TypeDef {
  lesensePRSCh0 = 0,
  lesensePRSCh1 = 1,
  lesensePRSCh2 = 2,
  lesensePRSCh3 = 3
}
enum  LESENSE_AltExMap_TypeDef {
  lesenseAltExMapALTEX = _LESENSE_CTRL_ALTEXMAP_ALTEX,
  lesenseAltExMapACMP = _LESENSE_CTRL_ALTEXMAP_ACMP
}
enum  LESENSE_BufTrigLevel_TypeDef {
  lesenseBufTrigHalf = LESENSE_CTRL_BUFIDL_HALFFULL,
  lesenseBufTrigFull = LESENSE_CTRL_BUFIDL_FULL
}
enum  LESENSE_DMAWakeUp_TypeDef {
  lesenseDMAWakeUpDisable = LESENSE_CTRL_DMAWU_DISABLE,
  lesenseDMAWakeUpBufValid = LESENSE_CTRL_DMAWU_BUFDATAV,
  lesenseDMAWakeUpBufLevel = LESENSE_CTRL_DMAWU_BUFLEVEL
}
enum  LESENSE_BiasMode_TypeDef {
  lesenseBiasModeDutyCycle = LESENSE_BIASCTRL_BIASMODE_DUTYCYCLE,
  lesenseBiasModeHighAcc = LESENSE_BIASCTRL_BIASMODE_HIGHACC,
  lesenseBiasModeDontTouch = LESENSE_BIASCTRL_BIASMODE_DONTTOUCH
}
enum  LESENSE_ScanConfSel_TypeDef {
  lesenseScanConfDirMap = LESENSE_CTRL_SCANCONF_DIRMAP,
  lesenseScanConfInvMap = LESENSE_CTRL_SCANCONF_INVMAP,
  lesenseScanConfToggle = LESENSE_CTRL_SCANCONF_TOGGLE,
  lesenseScanConfDecDef = LESENSE_CTRL_SCANCONF_DECDEF
}
enum  LESENSE_ControlDACData_TypeDef {
  lesenseDACIfData = _LESENSE_PERCTRL_DACCH0DATA_DACDATA,
  lesenseACMPThres = _LESENSE_PERCTRL_DACCH0DATA_ACMPTHRES
}
enum  LESENSE_ControlDACConv_TypeDef {
  lesenseDACConvModeDisable = _LESENSE_PERCTRL_DACCH0CONV_DISABLE,
  lesenseDACConvModeContinuous = _LESENSE_PERCTRL_DACCH0CONV_CONTINUOUS,
  lesenseDACConvModeSampleHold = _LESENSE_PERCTRL_DACCH0CONV_SAMPLEHOLD,
  lesenseDACConvModeSampleOff = _LESENSE_PERCTRL_DACCH0CONV_SAMPLEOFF
}
enum  LESENSE_ControlDACOut_TypeDef {
  lesenseDACOutModeDisable = _LESENSE_PERCTRL_DACCH0OUT_DISABLE,
  lesenseDACOutModePin = _LESENSE_PERCTRL_DACCH0OUT_PIN,
  lesenseDACOutModeADCACMP = _LESENSE_PERCTRL_DACCH0OUT_ADCACMP,
  lesenseDACOutModePinADCACMP = _LESENSE_PERCTRL_DACCH0OUT_PINADCACMP
}
enum  LESENSE_DACRef_TypeDef {
  lesenseDACRefVdd = LESENSE_PERCTRL_DACREF_VDD,
  lesenseDACRefBandGap = LESENSE_PERCTRL_DACREF_BANDGAP
}
enum  LESENSE_ControlACMP_TypeDef {
  lesenseACMPModeDisable = _LESENSE_PERCTRL_ACMP0MODE_DISABLE,
  lesenseACMPModeMux = _LESENSE_PERCTRL_ACMP0MODE_MUX,
  lesenseACMPModeMuxThres = _LESENSE_PERCTRL_ACMP0MODE_MUXTHRES
}
enum  LESENSE_WarmupMode_TypeDef {
  lesenseWarmupModeNormal = LESENSE_PERCTRL_WARMUPMODE_NORMAL,
  lesenseWarmupModeACMP = LESENSE_PERCTRL_WARMUPMODE_KEEPACMPWARM,
  lesenseWarmupModeDAC = LESENSE_PERCTRL_WARMUPMODE_KEEPDACWARM,
  lesenseWarmupModeKeepWarm = LESENSE_PERCTRL_WARMUPMODE_KEEPACMPDACWARM
}
enum  LESENSE_DecInput_TypeDef {
  lesenseDecInputSensorSt = LESENSE_DECCTRL_INPUT_SENSORSTATE,
  lesenseDecInputPRS = LESENSE_DECCTRL_INPUT_PRS
}
enum  LESENSE_ChSampleMode_TypeDef {
  lesenseSampleModeCounter = LESENSE_CH_INTERACT_SAMPLE_COUNTER,
  lesenseSampleModeACMP = LESENSE_CH_INTERACT_SAMPLE_ACMP
}
enum  LESENSE_ChIntMode_TypeDef {
  lesenseSetIntNone = LESENSE_CH_INTERACT_SETIF_NONE,
  lesenseSetIntLevel = LESENSE_CH_INTERACT_SETIF_LEVEL,
  lesenseSetIntPosEdge = LESENSE_CH_INTERACT_SETIF_POSEDGE,
  lesenseSetIntNegEdge = LESENSE_CH_INTERACT_SETIF_NEGEDGE
}
enum  LESENSE_ChPinExMode_TypeDef {
  lesenseChPinExDis = LESENSE_CH_INTERACT_EXMODE_DISABLE,
  lesenseChPinExHigh = LESENSE_CH_INTERACT_EXMODE_HIGH,
  lesenseChPinExLow = LESENSE_CH_INTERACT_EXMODE_LOW,
  lesenseChPinExDACOut = LESENSE_CH_INTERACT_EXMODE_DACOUT
}
enum  LESENSE_ChPinIdleMode_TypeDef {
  lesenseChPinIdleDis = _LESENSE_IDLECONF_CH0_DISABLE,
  lesenseChPinIdleHigh = _LESENSE_IDLECONF_CH0_HIGH,
  lesenseChPinIdleLow = _LESENSE_IDLECONF_CH0_LOW,
  lesenseChPinIdleDACCh0 = _LESENSE_IDLECONF_CH0_DACCH0,
  lesenseChPinIdleDACCh1 = _LESENSE_IDLECONF_CH12_DACCH1
}
enum  LESENSE_ChClk_TypeDef {
  lesenseClkLF = _LESENSE_CH_INTERACT_EXCLK_LFACLK,
  lesenseClkHF = _LESENSE_CH_INTERACT_EXCLK_AUXHFRCO
}
enum  LESENSE_ChCompMode_TypeDef {
  lesenseCompModeLess = LESENSE_CH_EVAL_COMP_LESS,
  lesenseCompModeGreaterOrEq = LESENSE_CH_EVAL_COMP_GE
}
enum  LESENSE_AltExPinIdle_TypeDef {
  lesenseAltExPinIdleDis = _LESENSE_ALTEXCONF_IDLECONF0_DISABLE,
  lesenseAltExPinIdleHigh = _LESENSE_ALTEXCONF_IDLECONF0_HIGH,
  lesenseAltExPinIdleLow = _LESENSE_ALTEXCONF_IDLECONF0_LOW
}
enum  LESENSE_StTransAct_TypeDef {
  lesenseTransActNone = LESENSE_ST_TCONFA_PRSACT_NONE,
  lesenseTransActPRS0 = LESENSE_ST_TCONFA_PRSACT_PRS0,
  lesenseTransActPRS1 = LESENSE_ST_TCONFA_PRSACT_PRS1,
  lesenseTransActPRS01 = LESENSE_ST_TCONFA_PRSACT_PRS01,
  lesenseTransActPRS2 = LESENSE_ST_TCONFA_PRSACT_PRS2,
  lesenseTransActPRS02 = LESENSE_ST_TCONFA_PRSACT_PRS02,
  lesenseTransActPRS12 = LESENSE_ST_TCONFA_PRSACT_PRS12,
  lesenseTransActPRS012 = LESENSE_ST_TCONFA_PRSACT_PRS012,
  lesenseTransActUp = LESENSE_ST_TCONFA_PRSACT_UP,
  lesenseTransActDown = LESENSE_ST_TCONFA_PRSACT_DOWN,
  lesenseTransActUpAndPRS2 = LESENSE_ST_TCONFA_PRSACT_UPANDPRS2,
  lesenseTransActDownAndPRS2 = LESENSE_ST_TCONFA_PRSACT_DOWNANDPRS2
}

Functions

void LESENSE_Init (LESENSE_Init_TypeDef const *init, bool const reqReset)
 Initialize the LESENSE module.
void LESENSE_Reset (void)
 Reset the LESENSE module.
uint32_t LESENSE_ScanFreqSet (uint32_t refFreq, uint32_t const scanFreq)
 Set scan frequency for periodic scanning.
void LESENSE_ScanModeSet (LESENSE_ScanMode_TypeDef const scanMode, bool const start)
 Set scan mode of the LESENSE channels.
void LESENSE_StartDelaySet (uint8_t const startDelay)
 Set start delay of sensor interaction on each channel.
void LESENSE_ClkDivSet (LESENSE_ChClk_TypeDef const clk, LESENSE_ClkPresc_TypeDef const clkDiv)
 Set clock division for LESENSE timers.
void LESENSE_ChannelAllConfig (LESENSE_ChAll_TypeDef const *confChAll)
 Configure all (16) LESENSE sensor channels.
void LESENSE_ChannelConfig (LESENSE_ChDesc_TypeDef const *confCh, uint32_t const chIdx)
 Configure a single LESENSE sensor channel.
void LESENSE_ChannelEnable (uint8_t const chIdx, bool const enaScanCh, bool const enaPin)
 Enable/disable LESENSE scan channel and the pin assigned to it.
void LESENSE_ChannelEnableMask (uint16_t chMask, uint16_t pinMask)
 Enable/disable LESENSE scan channel and the pin assigned to it.
void LESENSE_ChannelTimingSet (uint8_t const chIdx, uint8_t const exTime, uint8_t const sampleDelay, uint8_t const measDelay)
 Set LESENSE channel timing parameters.
void LESENSE_ChannelThresSet (uint8_t const chIdx, uint16_t const acmpThres, uint16_t const cntThres)
 Set LESENSE channel threshold parameters.
void LESENSE_AltExConfig (LESENSE_ConfAltEx_TypeDef const *confAltEx)
 Configure the LESENSE alternate excitation modes.
void LESENSE_DecoderStateAllConfig (LESENSE_DecStAll_TypeDef const *confDecStAll)
 Configure all LESENSE decoder states.
void LESENSE_DecoderStateConfig (LESENSE_DecStDesc_TypeDef const *confDecSt, uint32_t const decSt)
 Configure a single LESENSE decoder state.
void LESENSE_DecoderStateSet (uint32_t decSt)
 Set LESENSE decoder state.
uint32_t LESENSE_DecoderStateGet (void)
 Get the current state of the LESENSE decoder.
void LESENSE_ScanStart (void)
 Start scanning of sensors.
void LESENSE_ScanStop (void)
 Stop scanning of sensors.
void LESENSE_DecoderStart (void)
 Start LESENSE decoder.
void LESENSE_ResultBufferClear (void)
 Clear result buffer.
__STATIC_INLINE void LESENSE_DecoderStop (void)
 Stop LESENSE decoder.
__STATIC_INLINE uint32_t LESENSE_StatusGet (void)
 Get the current status of LESENSE.
__STATIC_INLINE void LESENSE_StatusWait (uint32_t flag)
 Wait until the status of LESENSE is equal to what requested.
__STATIC_INLINE uint32_t LESENSE_ChannelActiveGet (void)
 Get the currently active channel index.
__STATIC_INLINE uint32_t LESENSE_ScanResultGet (void)
 Get the latest scan comparison result (1 bit / channel).
__STATIC_INLINE uint32_t LESENSE_ScanResultDataGet (void)
 Get the oldest unread data from the result buffer.
__STATIC_INLINE uint32_t LESENSE_ScanResultDataBufferGet (uint32_t idx)
 Get data from the result data buffer.
__STATIC_INLINE uint32_t LESENSE_SensorStateGet (void)
 Get the current state of the LESENSE sensor.
__STATIC_INLINE void LESENSE_RAMPowerDown (void)
 Shut off power to the LESENSE RAM, disables LESENSE.
__STATIC_INLINE void LESENSE_IntClear (uint32_t flags)
 Clear one or more pending LESENSE interrupts.
__STATIC_INLINE void LESENSE_IntEnable (uint32_t flags)
 Enable one or more LESENSE interrupts.
__STATIC_INLINE void LESENSE_IntDisable (uint32_t flags)
 Disable one or more LESENSE interrupts.
__STATIC_INLINE void LESENSE_IntSet (uint32_t flags)
 Set one or more pending LESENSE interrupts from SW.
__STATIC_INLINE uint32_t LESENSE_IntGet (void)
 Get pending LESENSE interrupt flags.
__STATIC_INLINE uint32_t LESENSE_IntGetEnabled (void)
 Get enabled and pending LESENSE interrupt flags.

Detailed Description

Low Energy Sensor (LESENSE) Peripheral API.


Define Documentation

#define LESENSE_ALTEX_CH_CONF_DEFAULT
Value:
{                                                                            \
    true,                  /* Alternate excitation enabled.*/                  \
    lesenseAltExPinIdleDis,/* Alternate excitation pin is disabled in idle. */ \
    false                  /* Excite only for corresponding channel. */        \
  }

Default configuration for alternate excitation channel.

Definition at line 881 of file em_lesense.h.

#define LESENSE_ALTEX_CONF_DEFAULT
Value:
{                                                                        \
    lesenseAltExMapACMP,                                                   \
    {                                                                      \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 0. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 1. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 2. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 3. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 4. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 5. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 6. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 7. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 8. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 9. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 10. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 11. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 12. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 13. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT, /* Alternate excitation channel 14. */ \
      LESENSE_ALTEX_CH_CONF_DEFAULT  /* Alternate excitation channel 15. */ \
    }                                                                      \
  }

Default configuration for all alternate excitation channels.

Definition at line 889 of file em_lesense.h.

#define LESENSE_CH_CONF_DEFAULT
Value:
{                                                                                                   \
    true,                  /* Enable scan channel. */                                                 \
    true,                  /* Enable the assigned pin on scan channel. */                             \
    true,                  /* Enable interrupts on channel. */                                        \
    lesenseChPinExHigh,    /* Channel pin is high during the excitation period. */                    \
    lesenseChPinIdleLow,   /* Channel pin is low during the idle period. */                           \
    false,                 /* Don't use alternate excitation pins for excitation. */                  \
    false,                 /* Disabled to shift results from this channel to the decoder register. */ \
    false,                 /* Disabled to invert the scan result bit. */                              \
    false,                 /* Disabled to store counter value in the result buffer. */                \
    lesenseClkLF,          /* Use the LF clock for excitation timing. */                              \
    lesenseClkLF,          /* Use the LF clock for sample timing. */                                  \
    0x03U,                 /* Excitation time is set to 3(+1) excitation clock cycles. */             \
    0x09U,                 /* Sample delay is set to 9(+1) sample clock cycles. */                    \
    0x06U,                 /* Measure delay is set to 6 excitation clock cycles.*/                    \
    0x00U,                 /* ACMP threshold has been set to 0. */                                    \
    lesenseSampleModeACMP, /* ACMP output will be used in comparison. */                              \
    lesenseSetIntNone,     /* No interrupt is generated by the channel. */                            \
    0xFFU,                 /* Counter threshold has bee set to 0xFF. */                               \
    lesenseCompModeLess    /* Compare mode has been set to trigger interrupt on "less". */            \
  }

Default configuration for scan channel.

Definition at line 788 of file em_lesense.h.

#define LESENSE_CORECTRL_DESC_DEFAULT
Value:
{                                                                                                   \
    lesenseScanStartPeriodic,  /* Start new scan each time the period counter overflows. */           \
    lesensePRSCh0,             /* Default PRS channel is selected. */                                 \
    lesenseScanConfDirMap,     /* Direct mapping SCANCONF register usage strategy. */                 \
    false,                     /* Don't invert ACMP0 output. */                                       \
    false,                     /* Don't invert ACMP1 output. */                                       \
    false,                     /* Disable dual sampling. */                                           \
    true,                      /* Store scan result after each scan. */                               \
    true,                      /* Overwrite result buffer register even if it is full. */             \
    lesenseBufTrigHalf,        /* Trigger interrupt and DMA request if result buffer is half full. */ \
    lesenseDMAWakeUpDisable,   /* Don't wake up on DMA from EM2. */                                   \
    lesenseBiasModeDontTouch,  /* Don't touch bias configuration. */                                  \
    true                       /* Keep LESENSE running in debug mode. */                              \
  }

Default configuration for LESENSE_CtrlDesc_TypeDef structure.

Definition at line 519 of file em_lesense.h.

#define LESENSE_DECCTRL_DESC_DEFAULT
Value:
{                                  \
    lesenseDecInputSensorSt,     \
    0U,                          \
    false,                       \
    true,                        \
    true,                        \
    true,                        \
    true,                        \
    true,                        \
    false,                       \
    lesensePRSCh0,               \
    lesensePRSCh1,               \
    lesensePRSCh2,               \
    lesensePRSCh3,               \
  }

Default configuration for LESENSE_PerCtrl_TypeDef structure.

Definition at line 658 of file em_lesense.h.

#define LESENSE_DECODER_CONF_DEFAULT
Value:
{  /* chain |   Descriptor A         |   Descriptor B   */ \
    {                                                                                                                \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 0. */                            \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 1. */                            \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 2. */                            \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 3. */                            \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 4. */                            \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 5. */                            \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 6. */                            \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 7. */                            \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 8. */                            \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 9. */                            \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 10. */                           \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 11. */                           \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 12. */                           \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 13. */                           \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 14. */                           \
      { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT } /* Decoder state 15. */                            \
    }                                                                                                                \
  }

Default configuration for all decoder states.

Definition at line 973 of file em_lesense.h.

#define LESENSE_INIT_DEFAULT
Value:
{                                                 \
    .coreCtrl = LESENSE_CORECTRL_DESC_DEFAULT, /* Default core control parameters. */ \
    .timeCtrl = LESENSE_TIMECTRL_DESC_DEFAULT, /* Default time control parameters. */ \
    .perCtrl  = LESENSE_PERCTRL_DESC_DEFAULT,  /* Default peripheral control parameters. */ \
    .decCtrl  = LESENSE_DECCTRL_DESC_DEFAULT   /* Default decoder control parameters. */ \
  }

Default configuration for LESENSE_Init_TypeDef structure.

Definition at line 693 of file em_lesense.h.

#define LESENSE_PERCTRL_DESC_DEFAULT
#define LESENSE_SCAN_CONF_DEFAULT
Value:
{                                                   \
    {                                                 \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 0. */  \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 1. */  \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 2. */  \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 3. */  \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 4. */  \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 5. */  \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 6. */  \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 7. */  \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 8. */  \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 9. */  \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 10. */ \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 11. */ \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 12. */ \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 13. */ \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 14. */ \
      LESENSE_CH_CONF_DEFAULT, /* Scan channel 15. */ \
    }                                                 \
  }

Default configuration for all sensor channels.

Definition at line 812 of file em_lesense.h.

#define LESENSE_ST_CONF_DEFAULT
Value:
{                                                                      \
    0x0FU,               /* Compare value set to 0x0F. */                \
    0x00U,               /* All decoder inputs masked. */                \
    0U,                  /* Next state is state 0. */                    \
    lesenseTransActNone, /* No PRS action performed on compare match. */ \
    false                /* No interrupt triggered on compare match. */  \
  }

Default configuration for decoder state condition.

Definition at line 938 of file em_lesense.h.

#define LESENSE_TIMECTRL_DESC_DEFAULT
Value:
{                                       \
    0U /* No sensor interaction delay. */ \
  }

Default configuration for LESENSE_TimeCtrlDesc_TypeDef structure.

Definition at line 545 of file em_lesense.h.


Enumeration Type Documentation

Locations of the alternate excitation function.

Enumerator:
lesenseAltExMapALTEX 

Alternate excitation is mapped to the LES_ALTEX pins.

lesenseAltExMapACMP 

Alternate excitation is mapped to the pins of the other ACMP.

Definition at line 136 of file em_lesense.h.

Idle phase configuration of alternate excitation channels.

Enumerator:
lesenseAltExPinIdleDis 

ALTEX output is disabled in idle phase. Note: this value could be used for all alternate excitation channels.

lesenseAltExPinIdleHigh 

ALTEX output is high in idle phase. Note: this value could be used for all alternate excitation channels.

lesenseAltExPinIdleLow 

ALTEX output is low in idle phase. Note: this value could be used for all alternate excitation channels.

Definition at line 414 of file em_lesense.h.

Bias modes.

Enumerator:
lesenseBiasModeDutyCycle 

Duty cycle bias module between low power and high accuracy mode.

lesenseBiasModeHighAcc 

Bias module is always in high accuracy mode.

lesenseBiasModeDontTouch 

Bias module is controlled by the EMU and not affected by LESENSE.

Definition at line 174 of file em_lesense.h.

Result buffer interrupt and DMA trigger levels.

Enumerator:
lesenseBufTrigHalf 

DMA and interrupt flags are set when result buffer is halffull.

lesenseBufTrigFull 

DMA and interrupt flags set when result buffer is full.

Definition at line 147 of file em_lesense.h.

Clock used for excitation and sample delay timing.

Enumerator:
lesenseClkLF 

LFACLK (LF clock) is used.

lesenseClkHF 

AUXHFRCO (HF clock) is used.

Definition at line 390 of file em_lesense.h.

Compare modes for counter comparison.

Enumerator:
lesenseCompModeLess 

Set interrupt flag if counter value is less than CTRTHRESHOLD, or if the ACMP output is 0.

lesenseCompModeGreaterOrEq 

Set interrupt flag if counter value is greater than, or equal to CTRTHRESHOLD, or if the ACMP output is 1.

Definition at line 401 of file em_lesense.h.

Interrupt generation setup for CHx interrupt flag.

Enumerator:
lesenseSetIntNone 

No interrupt is generated.

lesenseSetIntLevel 

Set interrupt flag if the sensor triggers.

lesenseSetIntPosEdge 

Set interrupt flag on positive edge of the sensor state.

lesenseSetIntNegEdge 

Set interrupt flag on negative edge of the sensor state.

Definition at line 331 of file em_lesense.h.

Channel pin mode for the excitation phase of the scan sequence.

Enumerator:
lesenseChPinExDis 

Channel pin is disabled.

lesenseChPinExHigh 

Channel pin is configured as push-pull, driven HIGH.

lesenseChPinExLow 

Channel pin is configured as push-pull, driven LOW.

lesenseChPinExDACOut 

DAC output (only available on channel 0, 1, 2, 3, 12, 13, 14 and 15)

Definition at line 348 of file em_lesense.h.

Channel pin mode for the idle phase of the scan sequence.

Enumerator:
lesenseChPinIdleDis 

Channel pin is disabled in idle phase. Note: this value could be used for all channels.

lesenseChPinIdleHigh 

Channel pin is configured as push-pull, driven HIGH in idle phase. Note: this value could be used for all channels.

lesenseChPinIdleLow 

Channel pin is configured as push-pull, driven LOW in idle phase. Note: this value could be used for all channels.

lesenseChPinIdleDACCh0 

Channel pin is connected to DAC CH0 output in idle phase. Note: only applies to channel 0, 1, 2, 3.

lesenseChPinIdleDACCh1 

Channel pin is connected to DAC CH1 output in idle phase. Note: only applies to channel 12, 13, 14, 15.

Definition at line 365 of file em_lesense.h.

Compare source selection for sensor sampling.

Enumerator:
lesenseSampleModeCounter 

Counter output will be used in comparison.

lesenseSampleModeACMP 

ACMP output will be used in comparison.

Definition at line 320 of file em_lesense.h.

Clock divisors for controlling the prescaling factor of the period counter. Note: these enumeration values are being used for different clock division related configuration parameters (hfPresc, lfPresc, pcPresc).

Enumerator:
lesenseClkDiv_1 

Divide clock by 1.

lesenseClkDiv_2 

Divide clock by 2.

lesenseClkDiv_4 

Divide clock by 4.

lesenseClkDiv_8 

Divide clock by 8.

lesenseClkDiv_16 

Divide clock by 16.

lesenseClkDiv_32 

Divide clock by 32.

lesenseClkDiv_64 

Divide clock by 64.

lesenseClkDiv_128 

Divide clock by 128.

Definition at line 72 of file em_lesense.h.

ACMPx control configuration.

Enumerator:
lesenseACMPModeDisable 

LESENSE does not control the ACMPx. Note: this value could be used for both ACMP0 and ACMP1.

lesenseACMPModeMux 

LESENSE controls the input mux of ACMPx. Note: this value could be used for both ACMP0 and ACMP1.

lesenseACMPModeMuxThres 

LESENSE controls the input mux of and the threshold value of ACMPx. Note: this value could be used for both ACMP0 and ACMP1.

Definition at line 275 of file em_lesense.h.

DAC channel x conversion mode configuration.

Enumerator:
lesenseDACConvModeDisable 

LESENSE doesn't control DAC channel x. Note: this value could be used for both DAC Ch0 and Ch1.

lesenseDACConvModeContinuous 

DAC channel x is driven in continuous mode. Note: this value could be used for both DAC Ch0 and Ch1.

lesenseDACConvModeSampleHold 

DAC channel x is driven in sample hold mode. Note: this value could be used for both DAC Ch0 and Ch1.

lesenseDACConvModeSampleOff 

DAC channel x is driven in sample off mode. Note: this value could be used for both DAC Ch0 and Ch1.

Definition at line 222 of file em_lesense.h.

DAC CHx data control configuration.

Enumerator:
lesenseDACIfData 

DAC channel x data is defined by DAC_CHxDATA register. Note: this value could be used for both DAC Ch0 and Ch1.

lesenseACMPThres 

DAC channel x data is defined by ACMPTHRES in LESENSE_CHx_INTERACT. Note: this value could be used for both DAC Ch0 and Ch1.

Definition at line 209 of file em_lesense.h.

DAC channel x output mode configuration.

Enumerator:
lesenseDACOutModeDisable 

DAC CHx output to pin and ACMP/ADC disabled. Note: this value could be used for both DAC Ch0 and Ch1.

lesenseDACOutModePin 

DAC CHx output to pin enabled, output to ADC and ACMP disabled. Note: this value could be used for both DAC Ch0 and Ch1.

lesenseDACOutModeADCACMP 

DAC CHx output to pin disabled, output to ADC and ACMP enabled. Note: this value could be used for both DAC Ch0 and Ch1.

lesenseDACOutModePinADCACMP 

DAC CHx output to pin, ADC, and ACMP enabled. Note: this value could be used for both DAC Ch0 and Ch1.

Definition at line 243 of file em_lesense.h.

DAC reference configuration.

Enumerator:
lesenseDACRefVdd 

DAC uses VDD reference.

lesenseDACRefBandGap 

DAC uses bandgap reference.

Definition at line 264 of file em_lesense.h.

Decoder input source configuration.

Enumerator:
lesenseDecInputSensorSt 

The SENSORSTATE register is used as input to the decoder.

lesenseDecInputPRS 

PRS channels are used as input to the decoder.

Definition at line 309 of file em_lesense.h.

Modes of operation for DMA wakeup from EM2.

Enumerator:
lesenseDMAWakeUpDisable 

No DMA wakeup from EM2.

lesenseDMAWakeUpBufValid 

DMA wakeup from EM2 when data is valid in the result buffer.

lesenseDMAWakeUpBufLevel 

DMA wakeup from EM2 when the resultbuffer is full/halffull, depending on RESBIDL configuration in LESENSE_CTRL register (selected by resBufTrigLevel in LESENSE_ResBufTrigLevel_TypeDef descriptor structure).

Definition at line 158 of file em_lesense.h.

PRS sources. Note: these enumeration values are being used for different PRS related configuration parameters.

Enumerator:
lesensePRSCh0 

PRS channel 0.

lesensePRSCh1 

PRS channel 1.

lesensePRSCh2 

PRS channel 2.

lesensePRSCh3 

PRS channel 3.

Definition at line 102 of file em_lesense.h.

Scan configuration.

Enumerator:
lesenseScanConfDirMap 

The channel configuration registers (CHx_CONF) used are directly mapped to the channel number.

lesenseScanConfInvMap 

The channel configuration registers used are CHx+8_CONF for channels 0-7 and CHx-8_CONF for channels 8-15.

lesenseScanConfToggle 

The channel configuration registers used toggles between CHX_SCANCONF and CHX+8_SCANCONF when channel x triggers.

lesenseScanConfDecDef 

The decoder state defines the channel configuration register (CHx_CONF) to be used.

Definition at line 188 of file em_lesense.h.

Scan modes.

Enumerator:
lesenseScanStartPeriodic 

New scan is started each time the period counter overflows.

lesenseScanStartOneShot 

Single scan is performed when LESENSE_ScanStart() is called.

lesenseScanStartPRS 

New scan is triggered by pulse on PRS channel.

Definition at line 86 of file em_lesense.h.

Transition action modes.

Enumerator:
lesenseTransActNone 

No PRS pulses generated (if PRSCOUNT == 0). Do not count (if PRSCOUNT == 1).

lesenseTransActPRS0 

Generate pulse on LESPRS0 (if PRSCOUNT == 0).

lesenseTransActPRS1 

Generate pulse on LESPRS1 (if PRSCOUNT == 0).

lesenseTransActPRS01 

Generate pulse on LESPRS0 and LESPRS1 (if PRSCOUNT == 0).

lesenseTransActPRS2 

Generate pulse on LESPRS2 (for both PRSCOUNT == 0 and PRSCOUNT == 1).

lesenseTransActPRS02 

Generate pulse on LESPRS0 and LESPRS2 (if PRSCOUNT == 0).

lesenseTransActPRS12 

Generate pulse on LESPRS1 and LESPRS2 (if PRSCOUNT == 0).

lesenseTransActPRS012 

Generate pulse on LESPRS0, LESPRS1 and LESPRS2 (if PRSCOUNT == 0).

lesenseTransActUp 

Count up (if PRSCOUNT == 1).

lesenseTransActDown 

Count down (if PRSCOUNT == 1).

lesenseTransActUpAndPRS2 

Count up and generate pulse on LESPRS2 (if PRSCOUNT == 1).

lesenseTransActDownAndPRS2 

Count down and generate pulse on LESPRS2 (if PRSCOUNT == 1).

Definition at line 431 of file em_lesense.h.

Warm up modes. ACMP and DAC duty cycle mode configuration.

Enumerator:
lesenseWarmupModeNormal 

ACMPs and DACs are shut down when LESENSE is idle.

lesenseWarmupModeACMP 

ACMPs are kept powered up when LESENSE is idle.

lesenseWarmupModeDAC 

The DAC is kept powered up when LESENSE is idle.

lesenseWarmupModeKeepWarm 

ACMPs and the DAC are kept powered up when LESENSE is idle.

Definition at line 292 of file em_lesense.h.


Function Documentation

void LESENSE_AltExConfig ( LESENSE_ConfAltEx_TypeDef const *  confAltEx  ) 

Configure the LESENSE alternate excitation modes.

This function configures the alternate excitation channels of the LESENSE interface. Please refer to the configuration parameter type definition (LESENSE_ConfAltEx_TypeDef) for more details.

Note:
Parameter useAltEx must be true in the channel configuration structrure (LESENSE_ChDesc_TypeDef) in order to use alternate excitation pins on the channel.
Parameters:
[in] confAltEx Configuration structure for LESENSE alternate excitation pins.

Definition at line 607 of file em_lesense.c.

References LESENSE_ConfAltEx_TypeDef::AltEx, LESENSE_ConfAltEx_TypeDef::altExMap, LESENSE_AltExDesc_TypeDef::alwaysEx, BITBAND_Peripheral(), LESENSE_AltExDesc_TypeDef::enablePin, LESENSE_AltExDesc_TypeDef::idleConf, lesenseAltExMapACMP, and lesenseAltExMapALTEX.

Here is the call graph for this function:

__STATIC_INLINE uint32_t LESENSE_ChannelActiveGet ( void   ) 

Get the currently active channel index.

Returns:
This function returns the value of LESENSE_CHINDEX register that contains the index of the currently active channel (0-15).

Definition at line 1126 of file em_lesense.h.

void LESENSE_ChannelAllConfig ( LESENSE_ChAll_TypeDef const *  confChAll  ) 

Configure all (16) LESENSE sensor channels.

This function configures all the sensor channels of LESENSE interface. Please refer to the configuration parameter type definition (LESENSE_ChAll_TypeDef) for more details.

Note:
Channels can be configured individually using LESENSE_ChannelConfig() function. Notice that pins used by the LESENSE module must be properly configured by the user explicitly, in order for the LESENSE to work as intended. (When configuring pins, one should remember to consider the sequence of configuration, in order to avoid unintended pulses/glitches on output pins.)
Parameters:
[in] confChAll Configuration structure for all (16) LESENSE sensor channels.

Definition at line 467 of file em_lesense.c.

References LESENSE_ChAll_TypeDef::Ch, and LESENSE_ChannelConfig().

Here is the call graph for this function:

void LESENSE_ChannelConfig ( LESENSE_ChDesc_TypeDef const *  confCh,
uint32_t const   chIdx 
)

Configure a single LESENSE sensor channel.

This function configures a single sensor channel of the LESENSE interface. Please refer to the configuration parameter type definition (LESENSE_ChDesc_TypeDef) for more details.

Note:
This function has been designed to minimize the effects of sensor channel reconfiguration while LESENSE is in operation, however one shall be aware of these effects and the right timing of calling this function. Parameter useAltEx must be true in the channel configuration in order to use alternate excitation pins.
Parameters:
[in] confCh Configuration structure for a single LESENSE sensor channel.
[in] chIdx Channel index to configure (0-15).

Definition at line 503 of file em_lesense.c.

References LESENSE_ChDesc_TypeDef::acmpThres, BITBAND_Peripheral(), LESENSE_ChDesc_TypeDef::chPinExMode, LESENSE_ChDesc_TypeDef::chPinIdleMode, LESENSE_ChDesc_TypeDef::cntThres, LESENSE_ChDesc_TypeDef::compMode, LESENSE_ChDesc_TypeDef::enaInt, LESENSE_ChDesc_TypeDef::enaPin, LESENSE_ChDesc_TypeDef::enaScanCh, LESENSE_ChDesc_TypeDef::exClk, LESENSE_ChDesc_TypeDef::exTime, LESENSE_ChDesc_TypeDef::intMode, LESENSE_ChDesc_TypeDef::invRes, LESENSE_ChannelThresSet(), LESENSE_ChannelTimingSet(), lesenseChPinExDACOut, lesenseChPinIdleDACCh0, lesenseChPinIdleDACCh1, LESENSE_ChDesc_TypeDef::measDelay, LESENSE_ChDesc_TypeDef::sampleClk, LESENSE_ChDesc_TypeDef::sampleDelay, LESENSE_ChDesc_TypeDef::sampleMode, LESENSE_ChDesc_TypeDef::shiftRes, LESENSE_ChDesc_TypeDef::storeCntRes, and LESENSE_ChDesc_TypeDef::useAltEx.

Referenced by LESENSE_ChannelAllConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

void LESENSE_ChannelEnable ( uint8_t const   chIdx,
bool const   enaScanCh,
bool const   enaPin 
)

Enable/disable LESENSE scan channel and the pin assigned to it.

Use this function to enable/disable a selected LESENSE scan channel and the pin assigned to.

Note:
Users can enable/disable scan channels and the channel pin by LESENSE_ChannelConfig() function, but only with a significant overhead. This simple function serves the purpose of controlling these parameters after the channel has been configured.
Parameters:
[in] chIdx Identifier of the scan channel. Valid range: 0-15.
[in] enaScanCh Enable/disable the selected scan channel by setting this parameter to true/false respectively.
[in] enaPin Enable/disable the pin assigned to the channel selected by chIdx.

Definition at line 690 of file em_lesense.c.

References BITBAND_Peripheral().

Here is the call graph for this function:

void LESENSE_ChannelEnableMask ( uint16_t  chMask,
uint16_t  pinMask 
)

Enable/disable LESENSE scan channel and the pin assigned to it.

Use this function to enable/disable LESENSE scan channels and the pins assigned to them using a mask.

Note:
Users can enable/disable scan channels and channel pins by using LESENSE_ChannelAllConfig() function, but only with a significant overhead. This simple function serves the purpose of controlling these parameters after the channel has been configured.
Parameters:
[in] chMask Set the corresponding bit to 1 to enable, 0 to disable the selected scan channel.
[in] pinMask Set the corresponding bit to 1 to enable, 0 to disable the pin on selected channel.

Definition at line 731 of file em_lesense.c.

void LESENSE_ChannelThresSet ( uint8_t const   chIdx,
uint16_t const   acmpThres,
uint16_t const   cntThres 
)

Set LESENSE channel threshold parameters.

Use this function to set threshold parameters on a selected LESENSE channel.

Note:
Users can configure the channel threshold parameters by LESENSE_ChannelConfig() function, but only with a significant overhead. This simple function serves the purpose of controlling these parameters after the channel has been configured.
Parameters:
[in] chIdx Identifier of the scan channel. Valid range: 0-15.
[in] acmpThres ACMP threshold.

  • If perCtrl.dacCh0Data or perCtrl.dacCh1Data is set to lesenseDACIfData, acmpThres defines the 12-bit DAC data in the corresponding data register of the DAC interface (DACn_CH0DATA and DACn_CH1DATA). In this case, the valid range is: 0-4095 (12 bits).
  • If perCtrl.dacCh0Data or perCtrl.dacCh1Data is set to lesenseACMPThres, acmpThres defines the 6-bit Vdd scaling factor of ACMP negative input (VDDLEVEL in ACMP_INPUTSEL register). In this case, the valid range is: 0-63 (6 bits).
[in] cntThres Decision threshold for counter comparison. Valid range: 0-65535 (16 bits).

Definition at line 822 of file em_lesense.c.

Referenced by LESENSE_ChannelConfig().

Here is the caller graph for this function:

void LESENSE_ChannelTimingSet ( uint8_t const   chIdx,
uint8_t const   exTime,
uint8_t const   sampleDelay,
uint8_t const   measDelay 
)

Set LESENSE channel timing parameters.

Use this function to set timing parameters on a selected LESENSE channel.

Note:
Users can configure the channel timing parameters by LESENSE_ChannelConfig() function, but only with a significant overhead. This simple function serves the purpose of controlling these parameters after the channel has been configured.
Parameters:
[in] chIdx Identifier of the scan channel. Valid range: 0-15.
[in] exTime Excitation time on chIdx. Excitation will last exTime+1 excitation clock cycles. Valid range: 0-63 (6 bits).
[in] sampleDelay Sample delay on chIdx. Sampling will occur after sampleDelay+1 sample clock cycles. Valid range: 0-127 (7 bits).
[in] measDelay Measure delay on chIdx. Sensor measuring is delayed for measDelay+1 excitation clock cycles. Valid range: 0-127 (7 bits).

Definition at line 768 of file em_lesense.c.

Referenced by LESENSE_ChannelConfig().

Here is the caller graph for this function:

void LESENSE_ClkDivSet ( LESENSE_ChClk_TypeDef const   clk,
LESENSE_ClkPresc_TypeDef const   clkDiv 
)

Set clock division for LESENSE timers.

Use this function to configure the clock division for the LESENSE timers used for excitation timing. The division setting is global, but the clock source can be selected for each channel using LESENSE_ChannelConfig() function, please refer to the documentation of it for more details.

Note:
If AUXHFRCO is used for excitation timing, LFACLK can not exceed 500kHz. LFACLK can not exceed 50kHz if the ACMP threshold level (ACMPTHRES) is not equal for all channels.
Parameters:
[in] clk Select clock to prescale.

  • lesenseClkHF - set AUXHFRCO clock divisor for HF timer.
  • lesenseClkLF - set LFACLKles clock divisor for LF timer.
[in] clkDiv Clock divisor value. Valid range depends on the clk value.

Definition at line 399 of file em_lesense.c.

References lesenseClkDiv_8, lesenseClkHF, and lesenseClkLF.

void LESENSE_DecoderStart ( void   ) 

Start LESENSE decoder.

Note:
This function will wait for any pending previous write operation to the CMD register to complete before accessing the CMD register. It will also wait for the write operation to the CMD register to complete before returning. Each write operation to the CMD register may take up to 3 LF clock cycles, so the user should expect some delay. The user may implement a separate function to write multiple command bits in the CMD register in one single operation in order to optimize an application.

Definition at line 1049 of file em_lesense.c.

void LESENSE_DecoderStateAllConfig ( LESENSE_DecStAll_TypeDef const *  confDecStAll  ) 

Configure all LESENSE decoder states.

This function configures all the decoder states of the LESENSE interface. Please refer to the configuration parameter type definition (LESENSE_DecStAll_TypeDef) for more details.

Note:
Decoder states can be configured individually using LESENSE_DecoderStateConfig() function.
Parameters:
[in] confDecStAll Configuration structure for all (16) LESENSE decoder states.

Definition at line 868 of file em_lesense.c.

References LESENSE_DecoderStateConfig(), and LESENSE_DecStAll_TypeDef::St.

Here is the call graph for this function:

void LESENSE_DecoderStateConfig ( LESENSE_DecStDesc_TypeDef const *  confDecSt,
uint32_t const   decSt 
)

Configure a single LESENSE decoder state.

This function configures a single decoder state of the LESENSE interface. Please refer to the configuration parameter type definition (LESENSE_DecStDesc_TypeDef) for more details.

Parameters:
[in] confDecSt Configuration structure for a single LESENSE decoder state.
[in] decSt Decoder state index to configure (0-15).

Definition at line 897 of file em_lesense.c.

References LESENSE_DecStDesc_TypeDef::chainDesc, LESENSE_DecStCond_TypeDef::compMask, LESENSE_DecStCond_TypeDef::compVal, LESENSE_DecStDesc_TypeDef::confA, LESENSE_DecStDesc_TypeDef::confB, LESENSE_DecStCond_TypeDef::nextState, LESENSE_DecStCond_TypeDef::prsAct, and LESENSE_DecStCond_TypeDef::setInt.

Referenced by LESENSE_DecoderStateAllConfig().

Here is the caller graph for this function:

uint32_t LESENSE_DecoderStateGet ( void   ) 

Get the current state of the LESENSE decoder.

Returns:
This function returns the value of LESENSE_DECSTATE register that represents the current state of the LESENSE decoder.

Definition at line 971 of file em_lesense.c.

void LESENSE_DecoderStateSet ( uint32_t  decSt  ) 

Set LESENSE decoder state.

This function can be used for setting the initial state of the LESENSE decoder.

Note:
Make sure the LESENSE decoder state is initialized by this function before enabling the decoder!
Parameters:
[in] decSt Decoder state to set as current state. Valid range: 0-15

Definition at line 955 of file em_lesense.c.

Referenced by LESENSE_Init().

Here is the caller graph for this function:

__STATIC_INLINE void LESENSE_DecoderStop ( void   ) 

Stop LESENSE decoder.

This function disables the LESENSE decoder by setting the command to the LESENSE_DECCTRL register.

Definition at line 1064 of file em_lesense.h.

void LESENSE_Init ( LESENSE_Init_TypeDef const *  init,
bool const   reqReset 
)

Initialize the LESENSE module.

This function configures the main parameters of the LESENSE interface. Please refer to the initialization parameter type definition (LESENSE_Init_TypeDef) for more details.

Note:
LESENSE_Init() has been designed for initializing LESENSE once in an operation cycle. Be aware of the effects of reconfiguration if using this function from multiple sources in your code. This function has not been designed to be re-entrant. Requesting reset by setting reqReset to true is required in each reset or power-on cycle in order to configure the default values of the RAM mapped LESENSE registers. Notice that GPIO pins used by the LESENSE module must be properly configured by the user explicitly, in order for the LESENSE to work as intended. (When configuring pins, one should remember to consider the sequence of configuration, in order to avoid unintended pulses/glitches on output pins.)
Parameters:
[in] init LESENSE initialization structure.
[in] reqReset Request to call LESENSE_Reset() first in order to initialize all LESENSE registers with the default value.

Definition at line 97 of file em_lesense.c.

References LESENSE_PerCtrlDesc_TypeDef::acmp0Mode, LESENSE_PerCtrlDesc_TypeDef::acmp1Mode, LESENSE_CoreCtrlDesc_TypeDef::biasMode, LESENSE_CoreCtrlDesc_TypeDef::bufOverWr, LESENSE_CoreCtrlDesc_TypeDef::bufTrigLevel, LESENSE_DecCtrlDesc_TypeDef::chkState, LESENSE_Init_TypeDef::coreCtrl, LESENSE_PerCtrlDesc_TypeDef::dacCh0ConvMode, LESENSE_PerCtrlDesc_TypeDef::dacCh0Data, LESENSE_PerCtrlDesc_TypeDef::dacCh0OutMode, LESENSE_PerCtrlDesc_TypeDef::dacCh1ConvMode, LESENSE_PerCtrlDesc_TypeDef::dacCh1Data, LESENSE_PerCtrlDesc_TypeDef::dacCh1OutMode, LESENSE_PerCtrlDesc_TypeDef::dacPresc, LESENSE_PerCtrlDesc_TypeDef::dacRef, LESENSE_CoreCtrlDesc_TypeDef::debugRun, LESENSE_Init_TypeDef::decCtrl, LESENSE_DecCtrlDesc_TypeDef::decInput, LESENSE_CoreCtrlDesc_TypeDef::dualSample, LESENSE_DecCtrlDesc_TypeDef::hystIRQ, LESENSE_DecCtrlDesc_TypeDef::hystPRS0, LESENSE_DecCtrlDesc_TypeDef::hystPRS1, LESENSE_DecCtrlDesc_TypeDef::hystPRS2, LESENSE_DecCtrlDesc_TypeDef::initState, LESENSE_DecCtrlDesc_TypeDef::intMap, LESENSE_CoreCtrlDesc_TypeDef::invACMP0, LESENSE_CoreCtrlDesc_TypeDef::invACMP1, LESENSE_DecoderStateSet(), LESENSE_Reset(), LESENSE_ScanModeSet(), LESENSE_StartDelaySet(), LESENSE_Init_TypeDef::perCtrl, LESENSE_DecCtrlDesc_TypeDef::prsChSel0, LESENSE_DecCtrlDesc_TypeDef::prsChSel1, LESENSE_DecCtrlDesc_TypeDef::prsChSel2, LESENSE_DecCtrlDesc_TypeDef::prsChSel3, LESENSE_DecCtrlDesc_TypeDef::prsCount, LESENSE_CoreCtrlDesc_TypeDef::prsSel, LESENSE_CoreCtrlDesc_TypeDef::scanConfSel, LESENSE_CoreCtrlDesc_TypeDef::scanStart, LESENSE_TimeCtrlDesc_TypeDef::startDelay, LESENSE_CoreCtrlDesc_TypeDef::storeScanRes, LESENSE_Init_TypeDef::timeCtrl, LESENSE_CoreCtrlDesc_TypeDef::wakeupOnDMA, and LESENSE_PerCtrlDesc_TypeDef::warmupMode.

Here is the call graph for this function:

__STATIC_INLINE void LESENSE_IntClear ( uint32_t  flags  ) 

Clear one or more pending LESENSE interrupts.

Parameters:
[in] flags Pending LESENSE interrupt sources to clear. Use a set of interrupt flags OR-ed together to clear multiple interrupt sources of the LESENSE module (LESENSE_IF_nnn).

Definition at line 1231 of file em_lesense.h.

__STATIC_INLINE void LESENSE_IntDisable ( uint32_t  flags  ) 

Disable one or more LESENSE interrupts.

Parameters:
[in] flags LESENSE interrupt sources to disable. Use a set of interrupt flags OR-ed together to disable multiple interrupt sources of the LESENSE module (LESENSE_IF_nnn).

Definition at line 1261 of file em_lesense.h.

__STATIC_INLINE void LESENSE_IntEnable ( uint32_t  flags  ) 

Enable one or more LESENSE interrupts.

Parameters:
[in] flags LESENSE interrupt sources to enable. Use a set of interrupt flags OR-ed together to enable multiple interrupt sources of the LESENSE module (LESENSE_IF_nnn).

Definition at line 1246 of file em_lesense.h.

__STATIC_INLINE uint32_t LESENSE_IntGet ( void   ) 

Get pending LESENSE interrupt flags.

Note:
The event bits are not cleared by the use of this function.
Returns:
Pending LESENSE interrupt sources. The OR combination of valid interrupt flags of the LESENSE module (LESENSE_IF_nnn).

Definition at line 1293 of file em_lesense.h.

__STATIC_INLINE uint32_t LESENSE_IntGetEnabled ( void   ) 

Get enabled and pending LESENSE interrupt flags.

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

Note:
The event bits are not cleared by the use of this function.
Returns:
Pending and enabled LESENSE interrupt sources. The return value is the bitwise AND combination of
  • the OR combination of enabled interrupt sources in LESENSE_IEN_nnn register (LESENSE_IEN_nnn) and
  • the OR combination of valid interrupt flags of the LESENSE module (LESENSE_IF_nnn).

Definition at line 1317 of file em_lesense.h.

__STATIC_INLINE void LESENSE_IntSet ( uint32_t  flags  ) 

Set one or more pending LESENSE interrupts from SW.

Parameters:
[in] flags LESENSE interrupt sources to set to pending. Use a set of interrupt flags OR-ed together to set multiple interrupt sources of the LESENSE module (LESENSE_IFS_nnn).

Definition at line 1276 of file em_lesense.h.

__STATIC_INLINE void LESENSE_RAMPowerDown ( void   ) 

Shut off power to the LESENSE RAM, disables LESENSE.

This function shuts off the LESENSE RAM in order to decrease the leakage current of EFM32 if LESENSE is not used in your application.

Note:
Warning! Once the LESENSE RAM is powered down, it cannot be powered up again.

Definition at line 1215 of file em_lesense.h.

void LESENSE_Reset ( void   ) 

Reset the LESENSE module.

Use this function to reset the LESENSE registers.

Note:
Resetting LESENSE registers is required in each reset or power-on cycle in order to configure the default values of the RAM mapped LESENSE registers. LESENSE_Reset() can be called on initialization by setting the reqReset parameter to true in LESENSE_Init().

Definition at line 1104 of file em_lesense.c.

Referenced by LESENSE_Init().

Here is the caller graph for this function:

void LESENSE_ResultBufferClear ( void   ) 

Clear result buffer.

Note:
This function will wait for any pending previous write operation to the CMD register to complete before accessing the CMD register. It will also wait for the write operation to the CMD register to complete before returning. Each write operation to the CMD register may take up to 3 LF clock cycles, so the user should expect some delay. The user may implement a separate function to write multiple command bits in the CMD register in one single operation in order to optimize an application.

Definition at line 1077 of file em_lesense.c.

uint32_t LESENSE_ScanFreqSet ( uint32_t  refFreq,
uint32_t const   scanFreq 
)

Set scan frequency for periodic scanning.

This function only applies to LESENSE if period counter is being used as a trigger for scan start. The calculation is based on the following formula: Fscan = LFACLKles / ((1+PCTOP)*2^PCPRESC)

Note:
Note that the calculation does not necessarily result in the requested scan frequency due to integer division. Check the return value for the resulted scan frequency.
Parameters:
[in] refFreq Select reference LFACLK clock frequency in Hz. If set to 0, the current clock frequency is being used as a reference.
[in] scanFreq Set the desired scan frequency in Hz.
Returns:
Frequency in Hz calculated and set by this function. Users can use this to compare the requested and set values.

Definition at line 232 of file em_lesense.c.

References CMU_ClockFreqGet(), cmuClock_LESENSE, and lesenseClkDiv_128.

Here is the call graph for this function:

void LESENSE_ScanModeSet ( LESENSE_ScanMode_TypeDef const   scanMode,
bool const   start 
)

Set scan mode of the LESENSE channels.

This function configures how the scan start is being triggered. It can be used for re-configuring the scan mode while running the application but it is also used by LESENSE_Init() for initialization.

Note:
Users can configure the scan mode by LESENSE_Init() function, but only with a significant overhead. This simple function serves the purpose of controlling this parameter after the channel has been configured. Please be aware the effects of the non-atomic Read-Modify-Write cycle!
Parameters:
[in] scanMode Select where to map LESENSE alternate excitation channels.

  • lesenseScanStartPeriodic - New scan is started each time the period counter overflows.
  • lesenseScanStartOneShot - Single scan is performed when LESENSE_ScanStart() is called.
  • lesenseScanStartPRS - New scan is triggered by pulse on PRS channel.
[in] start If true, LESENSE_ScanStart() is immediately issued after configuration.

Definition at line 314 of file em_lesense.c.

References LESENSE_ScanStart().

Referenced by LESENSE_Init().

Here is the call graph for this function:

Here is the caller graph for this function:

__STATIC_INLINE uint32_t LESENSE_ScanResultDataBufferGet ( uint32_t  idx  ) 

Get data from the result data buffer.

Note:
Make sure that the STORERES bit is set in LESENSE_CHx_EVAL, or STRSCANRES bit is set in LESENSE_CTRL, otherwise this function will return undefined value.
Parameters:
[in] idx Result data buffer index. Valid range: 0-15.
Returns:
This function returns the selected word from the result data buffer.

Definition at line 1183 of file em_lesense.h.

__STATIC_INLINE uint32_t LESENSE_ScanResultDataGet ( void   ) 

Get the oldest unread data from the result buffer.

Note:
Make sure that the STORERES bit is set in LESENSE_CHx_EVAL, or STRSCANRES bit is set in LESENSE_CTRL, otherwise this function will return undefined value.
Returns:
This function returns the value of LESENSE_RESDATA register that contains the oldest unread counter result from the result buffer.

Definition at line 1162 of file em_lesense.h.

__STATIC_INLINE uint32_t LESENSE_ScanResultGet ( void   ) 

Get the latest scan comparison result (1 bit / channel).

Returns:
This function returns the value of LESENSE_SCANRES register that contains the comparison result of the last scan on all channels. Bit x is set if a comparison triggered on channel x, which means that the LESENSE counter met the comparison criteria set in LESENSE_CHx_EVAL by COMPMODE and CNTTHRES.

Definition at line 1143 of file em_lesense.h.

void LESENSE_ScanStart ( void   ) 

Start scanning of sensors.

Note:
This function will wait for any pending previous write operation to the CMD register to complete before accessing the CMD register. It will also wait for the write operation to the CMD register to complete before returning. Each write operation to the CMD register may take up to 3 LF clock cycles, so the user should expect some delay. The user may implement a separate function to write multiple command bits in the CMD register in one single operation in order to optimize an application.

Definition at line 990 of file em_lesense.c.

Referenced by LESENSE_ScanModeSet().

Here is the caller graph for this function:

void LESENSE_ScanStop ( void   ) 

Stop scanning of sensors.

Note:
This function will wait for any pending previous write operation to the CMD register to complete before accessing the CMD register. It will also wait for the write operation to the CMD register to complete before returning. Each write operation to the CMD register may take up to 3 LF clock cycles, so the user should expect some delay. The user may implement a separate function to write multiple command bits in the CMD register in one single operation in order to optimize an application.
If issued during a scan, the command takes effect after scan completion.

Definition at line 1021 of file em_lesense.c.

__STATIC_INLINE uint32_t LESENSE_SensorStateGet ( void   ) 

Get the current state of the LESENSE sensor.

Returns:
This function returns the value of LESENSE_SENSORSTATE register that represents the current state of the LESENSE sensor.

Definition at line 1197 of file em_lesense.h.

void LESENSE_StartDelaySet ( uint8_t const   startDelay  ) 

Set start delay of sensor interaction on each channel.

This function sets start delay of sensor interaction on each channel. It can be used for adjusting the start delay while running the application but it is also used by LESENSE_Init() for initialization.

Note:
Users can configure the start delay by LESENSE_Init() function, but only with a significant overhead. This simple function serves the purpose of controlling this parameter after the channel has been configured. Please be aware the effects of the non-atomic Read-Modify-Write cycle!
Parameters:
[in] startDelay Number of LFACLK cycles to delay. Valid range: 0-3 (2 bit).

Definition at line 356 of file em_lesense.c.

Referenced by LESENSE_Init().

Here is the caller graph for this function:

__STATIC_INLINE uint32_t LESENSE_StatusGet ( void   ) 

Get the current status of LESENSE.

Returns:
This function returns the value of LESENSE_STATUS register that contains the OR combination of the following status bits:
  • LESENSE_STATUS_RESV - Result data valid. Set when data is available in the result buffer. Cleared when the buffer is empty.
  • LESENSE_STATUS_RESFULL - Result buffer full. Set when the result buffer is full.
  • LESENSE_STATUS_RUNNING - LESENSE is active.
  • LESENSE_STATUS_SCANACTIVE - LESENSE is currently interfacing sensors.

Definition at line 1085 of file em_lesense.h.

__STATIC_INLINE void LESENSE_StatusWait ( uint32_t  flag  ) 

Wait until the status of LESENSE is equal to what requested.

This function is polling the LESENSE_STATUS register and waits until the requested combination of flags are set.

Parameters:
[in] flag The OR combination of the following status bits:

  • LESENSE_STATUS_BUFDATAV - Result data valid. Set when data is available in the result buffer. Cleared when the buffer is empty.
  • LESENSE_STATUS_BUFHALFFULL - Result buffer half full. Set when the result buffer is half full.
  • LESENSE_STATUS_BUFFULL - Result buffer full. Set when the result buffer is full.
  • LESENSE_STATUS_RUNNING - LESENSE is active.
  • LESENSE_STATUS_SCANACTIVE - LESENSE is currently interfacing sensors.
  • LESENSE_STATUS_DACACTIVE - The DAC interface is currently active.

Definition at line 1111 of file em_lesense.h.