em_lesense.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef EM_LESENSE_H
#define EM_LESENSE_H

#include "em_device.h"

#if defined(LESENSE_COUNT) && (LESENSE_COUNT > 0)
#include <stdint.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif


/***************************************************************************/
/***************************************************************************/
#define LESENSE_NUM_DECODER_STATES   (_LESENSE_DECSTATE_DECSTATE_MASK + 1)

#define LESENSE_NUM_CHANNELS         16

/*******************************************************************************
 ********************************   ENUMS   ************************************
 ******************************************************************************/

typedef enum
{
  lesenseClkDiv_1   = 0, 
  lesenseClkDiv_2   = 1, 
  lesenseClkDiv_4   = 2, 
  lesenseClkDiv_8   = 3, 
  lesenseClkDiv_16  = 4, 
  lesenseClkDiv_32  = 5, 
  lesenseClkDiv_64  = 6, 
  lesenseClkDiv_128 = 7  
} LESENSE_ClkPresc_TypeDef;


typedef enum
{
  lesenseScanStartPeriodic = LESENSE_CTRL_SCANMODE_PERIODIC,

  lesenseScanStartOneShot  = LESENSE_CTRL_SCANMODE_ONESHOT,

  lesenseScanStartPRS      = LESENSE_CTRL_SCANMODE_PRS
} LESENSE_ScanMode_TypeDef;


typedef enum
{
  lesensePRSCh0     = 0, 
  lesensePRSCh1     = 1, 
  lesensePRSCh2     = 2, 
  lesensePRSCh3     = 3, 
#if defined( LESENSE_CTRL_PRSSEL_PRSCH4 )
  lesensePRSCh4     = 4, 
#endif
#if defined( LESENSE_CTRL_PRSSEL_PRSCH5 )
  lesensePRSCh5     = 5, 
#endif
#if defined( LESENSE_CTRL_PRSSEL_PRSCH6 )
  lesensePRSCh6     = 6, 
#endif
#if defined( LESENSE_CTRL_PRSSEL_PRSCH7 )
  lesensePRSCh7     = 7,  
#endif
#if defined( LESENSE_CTRL_PRSSEL_PRSCH8 )
  lesensePRSCh8     = 8,  
#endif
#if defined( LESENSE_CTRL_PRSSEL_PRSCH9 )
  lesensePRSCh9     = 9,  
#endif
#if defined( LESENSE_CTRL_PRSSEL_PRSCH10 )
  lesensePRSCh10    = 10, 
#endif
#if defined( LESENSE_CTRL_PRSSEL_PRSCH11 )
  lesensePRSCh11    = 11, 
#endif
} LESENSE_PRSSel_TypeDef;


typedef enum
{
  lesenseAltExMapALTEX = _LESENSE_CTRL_ALTEXMAP_ALTEX,

#if defined(_LESENSE_CTRL_ALTEXMAP_ACMP)

  lesenseAltExMapACMP  = _LESENSE_CTRL_ALTEXMAP_ACMP,
#endif

#if defined(_LESENSE_CTRL_ALTEXMAP_CH)

  lesenseAltExMapCH  = _LESENSE_CTRL_ALTEXMAP_CH,
#endif
} LESENSE_AltExMap_TypeDef;


typedef enum
{
  lesenseBufTrigHalf = LESENSE_CTRL_BUFIDL_HALFFULL,

  lesenseBufTrigFull = LESENSE_CTRL_BUFIDL_FULL
} LESENSE_BufTrigLevel_TypeDef;


typedef enum
{
  lesenseDMAWakeUpDisable  = LESENSE_CTRL_DMAWU_DISABLE,

  lesenseDMAWakeUpBufValid = LESENSE_CTRL_DMAWU_BUFDATAV,

  lesenseDMAWakeUpBufLevel = LESENSE_CTRL_DMAWU_BUFLEVEL
} LESENSE_DMAWakeUp_TypeDef;


typedef enum
{
  lesenseBiasModeDutyCycle = LESENSE_BIASCTRL_BIASMODE_DUTYCYCLE,

  lesenseBiasModeHighAcc   = LESENSE_BIASCTRL_BIASMODE_HIGHACC,

  lesenseBiasModeDontTouch = LESENSE_BIASCTRL_BIASMODE_DONTTOUCH
} LESENSE_BiasMode_TypeDef;


typedef enum
{
  lesenseScanConfDirMap = LESENSE_CTRL_SCANCONF_DIRMAP,

  lesenseScanConfInvMap = LESENSE_CTRL_SCANCONF_INVMAP,

  lesenseScanConfToggle = LESENSE_CTRL_SCANCONF_TOGGLE,

  lesenseScanConfDecDef = LESENSE_CTRL_SCANCONF_DECDEF
} LESENSE_ScanConfSel_TypeDef;


typedef enum
{
  lesenseDACIfData = _LESENSE_PERCTRL_DACCH0DATA_DACDATA,

#if defined(_LESENSE_PERCTRL_DACCH0DATA_ACMPTHRES)

  lesenseACMPThres = _LESENSE_PERCTRL_DACCH0DATA_ACMPTHRES,
#endif

#if defined(_LESENSE_PERCTRL_DACCH0DATA_THRES)

  lesenseThres     = _LESENSE_PERCTRL_DACCH0DATA_THRES,
#endif
} LESENSE_ControlDACData_TypeDef;

#if defined(_LESENSE_PERCTRL_DACCH0CONV_MASK)

typedef enum
{
  lesenseDACConvModeDisable    = _LESENSE_PERCTRL_DACCH0CONV_DISABLE,

  lesenseDACConvModeContinuous = _LESENSE_PERCTRL_DACCH0CONV_CONTINUOUS,

  lesenseDACConvModeSampleHold = _LESENSE_PERCTRL_DACCH0CONV_SAMPLEHOLD,

  lesenseDACConvModeSampleOff  = _LESENSE_PERCTRL_DACCH0CONV_SAMPLEOFF
} LESENSE_ControlDACConv_TypeDef;
#endif

#if defined(_LESENSE_PERCTRL_DACCH0OUT_MASK)

typedef enum
{
  lesenseDACOutModeDisable    = _LESENSE_PERCTRL_DACCH0OUT_DISABLE,

  lesenseDACOutModePin        = _LESENSE_PERCTRL_DACCH0OUT_PIN,

  lesenseDACOutModeADCACMP    = _LESENSE_PERCTRL_DACCH0OUT_ADCACMP,

  lesenseDACOutModePinADCACMP = _LESENSE_PERCTRL_DACCH0OUT_PINADCACMP
} LESENSE_ControlDACOut_TypeDef;
#endif


#if defined(_LESENSE_PERCTRL_DACREF_MASK)

typedef enum
{
  lesenseDACRefVdd     = LESENSE_PERCTRL_DACREF_VDD,

  lesenseDACRefBandGap = LESENSE_PERCTRL_DACREF_BANDGAP
} LESENSE_DACRef_TypeDef;
#endif


typedef enum
{
  lesenseACMPModeDisable  = _LESENSE_PERCTRL_ACMP0MODE_DISABLE,

  lesenseACMPModeMux      = _LESENSE_PERCTRL_ACMP0MODE_MUX,

  lesenseACMPModeMuxThres = _LESENSE_PERCTRL_ACMP0MODE_MUXTHRES
} LESENSE_ControlACMP_TypeDef;


typedef enum
{
  lesenseWarmupModeNormal   = LESENSE_PERCTRL_WARMUPMODE_NORMAL,

  lesenseWarmupModeACMP     = LESENSE_PERCTRL_WARMUPMODE_KEEPACMPWARM,

  lesenseWarmupModeDAC      = LESENSE_PERCTRL_WARMUPMODE_KEEPDACWARM,

  lesenseWarmupModeKeepWarm = LESENSE_PERCTRL_WARMUPMODE_KEEPACMPDACWARM
} LESENSE_WarmupMode_TypeDef;


typedef enum
{
  lesenseDecInputSensorSt = LESENSE_DECCTRL_INPUT_SENSORSTATE,

  lesenseDecInputPRS      = LESENSE_DECCTRL_INPUT_PRS
} LESENSE_DecInput_TypeDef;


typedef enum
{
  lesenseSampleModeCounter = 0x0 << _LESENSE_CH_INTERACT_SAMPLE_SHIFT,

  lesenseSampleModeACMP    = LESENSE_CH_INTERACT_SAMPLE_ACMP,

#if defined(LESENSE_CH_INTERACT_SAMPLE_ADC)

  lesenseSampleModeADC     = LESENSE_CH_INTERACT_SAMPLE_ADC,

  lesenseSampleModeADCDiff = LESENSE_CH_INTERACT_SAMPLE_ADCDIFF,
#endif
} LESENSE_ChSampleMode_TypeDef;


typedef enum
{
  lesenseSetIntNone    = LESENSE_CH_INTERACT_SETIF_NONE,

  lesenseSetIntLevel   = LESENSE_CH_INTERACT_SETIF_LEVEL,

  lesenseSetIntPosEdge = LESENSE_CH_INTERACT_SETIF_POSEDGE,

  lesenseSetIntNegEdge = LESENSE_CH_INTERACT_SETIF_NEGEDGE
} LESENSE_ChIntMode_TypeDef;


typedef enum
{
  lesenseChPinExDis    = LESENSE_CH_INTERACT_EXMODE_DISABLE,

  lesenseChPinExHigh   = LESENSE_CH_INTERACT_EXMODE_HIGH,

  lesenseChPinExLow    = LESENSE_CH_INTERACT_EXMODE_LOW,

  lesenseChPinExDACOut = LESENSE_CH_INTERACT_EXMODE_DACOUT
} LESENSE_ChPinExMode_TypeDef;


typedef enum
{
  lesenseChPinIdleDis    = _LESENSE_IDLECONF_CH0_DISABLE,

  lesenseChPinIdleHigh   = _LESENSE_IDLECONF_CH0_HIGH,

  lesenseChPinIdleLow    = _LESENSE_IDLECONF_CH0_LOW,

#if defined(_LESENSE_IDLECONF_CH0_DAC)

  lesenseChPinIdleDACC   = _LESENSE_IDLECONF_CH0_DAC
#else

  lesenseChPinIdleDACCh0 = _LESENSE_IDLECONF_CH0_DACCH0,

  lesenseChPinIdleDACCh1 = _LESENSE_IDLECONF_CH12_DACCH1,
#endif
} LESENSE_ChPinIdleMode_TypeDef;


typedef enum
{
  lesenseClkLF = _LESENSE_CH_INTERACT_EXCLK_LFACLK,

  lesenseClkHF = _LESENSE_CH_INTERACT_EXCLK_AUXHFRCO
} LESENSE_ChClk_TypeDef;


typedef enum
{
  lesenseCompModeLess        = LESENSE_CH_EVAL_COMP_LESS,

  lesenseCompModeGreaterOrEq = LESENSE_CH_EVAL_COMP_GE
} LESENSE_ChCompMode_TypeDef;


#if defined(_LESENSE_CH_EVAL_MODE_MASK)

typedef enum
{
  lesenseEvalModeThreshold        = _LESENSE_CH_EVAL_MODE_THRES,

  lesenseEvalModeSlidingWindow    = _LESENSE_CH_EVAL_MODE_SLIDINGWIN,

  lesenseEvalModeStepDetection    = _LESENSE_CH_EVAL_MODE_STEPDET,
} LESENSE_ChEvalMode_TypeDef;
#endif


typedef enum
{
  lesenseAltExPinIdleDis  = _LESENSE_ALTEXCONF_IDLECONF0_DISABLE,

  lesenseAltExPinIdleHigh = _LESENSE_ALTEXCONF_IDLECONF0_HIGH,

  lesenseAltExPinIdleLow  = _LESENSE_ALTEXCONF_IDLECONF0_LOW
} LESENSE_AltExPinIdle_TypeDef;


typedef enum
{
  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
} LESENSE_StTransAct_TypeDef;


/*******************************************************************************
 *******************************   STRUCTS   ***********************************
 ******************************************************************************/

typedef struct
{
  LESENSE_ScanMode_TypeDef     scanStart;

  LESENSE_PRSSel_TypeDef       prsSel;

  LESENSE_ScanConfSel_TypeDef  scanConfSel;

  bool                         invACMP0;

  bool                         invACMP1;

  bool                         dualSample;

  bool                         storeScanRes;

  bool                         bufOverWr;

  LESENSE_BufTrigLevel_TypeDef bufTrigLevel;

  LESENSE_DMAWakeUp_TypeDef    wakeupOnDMA;

  LESENSE_BiasMode_TypeDef     biasMode;

  bool                         debugRun;
} LESENSE_CoreCtrlDesc_TypeDef;

#define LESENSE_CORECTRL_DESC_DEFAULT                                                               \
{                                                                                                   \
  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. */                              \
}

typedef struct
{
  uint8_t startDelay;

  bool    delayAuxStartup;
} LESENSE_TimeCtrlDesc_TypeDef;

#define LESENSE_TIMECTRL_DESC_DEFAULT            \
{                                                \
  0U,   /* No sensor interaction delay. */       \
  false /* Don't delay the AUXHFRCO startup. */  \
}


typedef struct
{
  LESENSE_ControlDACData_TypeDef dacCh0Data;

#if defined(_LESENSE_PERCTRL_DACCH0CONV_MASK)

  LESENSE_ControlDACConv_TypeDef dacCh0ConvMode;

  LESENSE_ControlDACOut_TypeDef  dacCh0OutMode;
#endif

  LESENSE_ControlDACData_TypeDef dacCh1Data;

#if defined(_LESENSE_PERCTRL_DACCH1CONV_MASK)

  LESENSE_ControlDACConv_TypeDef dacCh1ConvMode;

  LESENSE_ControlDACOut_TypeDef  dacCh1OutMode;
#endif

#if defined(_LESENSE_PERCTRL_DACPRESC_MASK)

  uint8_t                        dacPresc;
#endif

#if defined(_LESENSE_PERCTRL_DACREF_MASK)

  LESENSE_DACRef_TypeDef         dacRef;
#endif

  LESENSE_ControlACMP_TypeDef    acmp0Mode;

  LESENSE_ControlACMP_TypeDef    acmp1Mode;

  LESENSE_WarmupMode_TypeDef     warmupMode;

#if defined(_LESENSE_PERCTRL_DACCONVTRIG_MASK)

  bool                           dacScan;
#endif
} LESENSE_PerCtrlDesc_TypeDef;

#if defined(_SILICON_LABS_32B_SERIES_0)
#define LESENSE_PERCTRL_DESC_DEFAULT  \
{                                     \
  lesenseDACIfData,          /* DAC channel 0 data is defined by DAC_CH0DATA register */             \
  lesenseDACConvModeDisable, /* LESENSE does not control DAC CH0. */                                 \
  lesenseDACOutModeDisable,  /* DAC channel 0 output to pin disabled. */                             \
  lesenseDACIfData,          /* DAC channel 1 data is defined by DAC_CH1DATA register */             \
  lesenseDACConvModeDisable, /* LESENSE does not control DAC CH1. */                                 \
  lesenseDACOutModeDisable,  /* DAC channel 1 output to pin disabled. */                             \
  0U,                        /* DAC prescaling factor of 1 (0+1). */                                 \
  lesenseDACRefVdd,          /* DAC uses VDD reference. */                                           \
  lesenseACMPModeMuxThres,   /* LESENSE controls the input mux and the threshold value of ACMP0. */  \
  lesenseACMPModeMuxThres,   /* LESENSE controls the input mux and the threshold value of ACMP1. */  \
  lesenseWarmupModeKeepWarm, /* Keep both ACMPs and the DAC powered up when LESENSE is idle. */      \
}
#else
#define LESENSE_PERCTRL_DESC_DEFAULT                                                                 \
{                                                                                                    \
  lesenseDACIfData,          /* DAC channel 0 data is defined by DAC_CH0DATA register. */            \
  lesenseDACIfData,          /* DAC channel 1 data is defined by DAC_CH1DATA register. */            \
  lesenseACMPModeMuxThres,   /* LESENSE controls the input mux and the threshold value of ACMP0. */  \
  lesenseACMPModeMuxThres,   /* LESENSE controls the input mux and the threshold value of ACMP1. */  \
  lesenseWarmupModeKeepWarm, /* Keep both ACMPs and the DAC powered up when LESENSE is idle. */      \
  false,                     /* DAC is enable for before every channel measurement. */               \
}
#endif

typedef struct
{
  LESENSE_DecInput_TypeDef decInput;

  uint32_t                 initState;

  bool                     chkState;

  bool                     intMap;

  bool                     hystPRS0;

  bool                     hystPRS1;

  bool                     hystPRS2;

  bool                     hystIRQ;

  bool                     prsCount;

  LESENSE_PRSSel_TypeDef   prsChSel0;

  LESENSE_PRSSel_TypeDef   prsChSel1;

  LESENSE_PRSSel_TypeDef   prsChSel2;

  LESENSE_PRSSel_TypeDef   prsChSel3;
} LESENSE_DecCtrlDesc_TypeDef;

#define LESENSE_DECCTRL_DESC_DEFAULT  \
{                                     \
  lesenseDecInputSensorSt, /* The SENSORSTATE register is used as input to the decoder. */   \
  0U,                      /* State 0 is the initial state of the decoder. */                \
  false,                   /* Disable check of current state. */                             \
  true,                    /* Enable channel x % 16 interrupt on state x change. */          \
  true,                    /* Enable decoder hysteresis on PRS0 output. */                   \
  true,                    /* Enable decoder hysteresis on PRS1 output. */                   \
  true,                    /* Enable decoder hysteresis on PRS2 output. */                   \
  true,                    /* Enable decoder hysteresis on PRS3 output. */                   \
  false,                   /* Disable count mode on decoder PRS channels 0 and 1*/           \
  lesensePRSCh0,           /* PRS Channel 0 as input for bit 0 of the LESENSE decoder. */    \
  lesensePRSCh1,           /* PRS Channel 1 as input for bit 1 of the LESENSE decoder. */    \
  lesensePRSCh2,           /* PRS Channel 2 as input for bit 2 of the LESENSE decoder. */    \
  lesensePRSCh3,           /* PRS Channel 3 as input for bit 3 of the LESENSE decoder. */    \
}


typedef struct
{
  LESENSE_CoreCtrlDesc_TypeDef coreCtrl;

  LESENSE_TimeCtrlDesc_TypeDef timeCtrl;

  LESENSE_PerCtrlDesc_TypeDef  perCtrl;

  LESENSE_DecCtrlDesc_TypeDef  decCtrl;
} LESENSE_Init_TypeDef;

#define LESENSE_INIT_DEFAULT                                                              \
{                                                                                         \
  .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. */    \
}


typedef struct
{
  bool                          enaScanCh;

  bool                          enaPin;

  bool                          enaInt;

  LESENSE_ChPinExMode_TypeDef   chPinExMode;

  LESENSE_ChPinIdleMode_TypeDef chPinIdleMode;

  bool                          useAltEx;

  bool                          shiftRes;

  bool                          invRes;

  bool                          storeCntRes;

  LESENSE_ChClk_TypeDef         exClk;

  LESENSE_ChClk_TypeDef         sampleClk;

  uint8_t                       exTime;

  uint8_t                       sampleDelay;

  uint16_t                       measDelay;

  uint16_t                     acmpThres;

  LESENSE_ChSampleMode_TypeDef sampleMode;

  LESENSE_ChIntMode_TypeDef    intMode;

  uint16_t                     cntThres;

  LESENSE_ChCompMode_TypeDef   compMode;

#if defined(_LESENSE_CH_EVAL_MODE_MASK)

  LESENSE_ChEvalMode_TypeDef   evalMode;
#endif

} LESENSE_ChDesc_TypeDef;


typedef struct
{
  LESENSE_ChDesc_TypeDef Ch[LESENSE_NUM_CHANNELS];
} LESENSE_ChAll_TypeDef;

#if defined(_LESENSE_CH_EVAL_MODE_MASK)
#define LESENSE_CH_CONF_DEFAULT                                                                       \
{                                                                                                     \
  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". */            \
  lesenseEvalModeThreshold /* Compare mode has been set to trigger interrupt on "less". */            \
}
#else
#define LESENSE_CH_CONF_DEFAULT                                                                     \
{                                                                                                   \
  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". */            \
}
#endif


#define LESENSE_SCAN_CONF_DEFAULT                   \
{                                                   \
  {                                                 \
    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. */ \
  }                                                 \
}


typedef struct
{
  bool                         enablePin;

  LESENSE_AltExPinIdle_TypeDef idleConf;

  bool                         alwaysEx;
} LESENSE_AltExDesc_TypeDef;


typedef struct
{
  LESENSE_AltExMap_TypeDef  altExMap;

  LESENSE_AltExDesc_TypeDef AltEx[16];

} LESENSE_ConfAltEx_TypeDef;


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

#if defined(_LESENSE_CTRL_ALTEXMAP_ACMP)
#define LESENSE_ALTEX_CONF_DEFAULT                                        \
{                                                                         \
  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. */ \
  }                                                                       \
}
#else
#define LESENSE_ALTEX_CONF_DEFAULT                                        \
{                                                                         \
  lesenseAltExMapCH,                                                      \
  {                                                                       \
    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. */ \
  }                                                                       \
}
#endif

typedef struct
{
  uint8_t                    compVal;

  uint8_t                    compMask;

  uint8_t                    nextState;

  LESENSE_StTransAct_TypeDef prsAct;

  bool                       setInt;
} LESENSE_DecStCond_TypeDef;

#define LESENSE_ST_CONF_DEFAULT                                        \
{                                                                      \
  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. */  \
}


typedef struct
{
  bool                      chainDesc;

  LESENSE_DecStCond_TypeDef confA;

  LESENSE_DecStCond_TypeDef confB;
} LESENSE_DecStDesc_TypeDef;


typedef struct
{
  LESENSE_DecStDesc_TypeDef St[LESENSE_NUM_DECODER_STATES];
} LESENSE_DecStAll_TypeDef;

#if defined(_SILICON_LABS_32B_SERIES_0)
#define LESENSE_DECODER_CONF_DEFAULT                                                     \
{  /* 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. */ \
  }                                                                                      \
}
#else
#define LESENSE_DECODER_CONF_DEFAULT                                                     \
{  /* 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. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 16. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 17. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 18. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 19. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 20. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 21. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 22. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 23. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 24. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 25. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 26. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 27. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 28. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 29. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }, /* Decoder state 30. */ \
    { false, LESENSE_ST_CONF_DEFAULT, LESENSE_ST_CONF_DEFAULT }  /* Decoder state 31. */ \
  }                                                                                      \
}
#endif

/*******************************************************************************
 *****************************   PROTOTYPES   **********************************
 ******************************************************************************/
void LESENSE_Init(const LESENSE_Init_TypeDef * init, bool reqReset);
void LESENSE_Reset(void);

uint32_t LESENSE_ScanFreqSet(uint32_t refFreq, uint32_t scanFreq);
void LESENSE_ScanModeSet(LESENSE_ScanMode_TypeDef scanMode, bool start);
void LESENSE_StartDelaySet(uint8_t startDelay);
void LESENSE_ClkDivSet(LESENSE_ChClk_TypeDef clk,
                       LESENSE_ClkPresc_TypeDef clkDiv);

void LESENSE_ChannelAllConfig(const LESENSE_ChAll_TypeDef * confChAll);
void LESENSE_ChannelConfig(const LESENSE_ChDesc_TypeDef * confCh,
                           uint32_t chIdx);
void LESENSE_ChannelEnable(uint8_t chIdx,
                           bool enaScanCh,
                           bool enaPin);
void LESENSE_ChannelEnableMask(uint16_t chMask, uint16_t pinMask);
void LESENSE_ChannelTimingSet(uint8_t chIdx,
                              uint8_t exTime,
                              uint8_t sampleDelay,
                              uint16_t measDelay);
void LESENSE_ChannelThresSet(uint8_t chIdx,
                             uint16_t acmpThres,
                             uint16_t cntThres);
#if defined(_LESENSE_CH_EVAL_MODE_MASK)
void LESENSE_ChannelSlidingWindow(uint8_t chIdx,
                                  uint32_t windowSize,
                                  uint32_t initValue);
void LESENSE_ChannelStepDetection(uint8_t chIdx,
                                  uint32_t stepSize,
                                  uint32_t initValue);
void LESENSE_WindowSizeSet(uint32_t windowSize);
void LESENSE_StepSizeSet(uint32_t stepSize);
#endif

void LESENSE_AltExConfig(const LESENSE_ConfAltEx_TypeDef * confAltEx);

void LESENSE_DecoderStateAllConfig(const LESENSE_DecStAll_TypeDef * confDecStAll);
void LESENSE_DecoderStateConfig(const LESENSE_DecStDesc_TypeDef * confDecSt,
                                uint32_t decSt);
void LESENSE_DecoderStateSet(uint32_t decSt);
uint32_t LESENSE_DecoderStateGet(void);
#if defined(_LESENSE_PRSCTRL_MASK)
void LESENSE_DecoderPrsOut(bool enable, uint32_t decMask, uint32_t decCmp);
#endif

void LESENSE_ScanStart(void);
void LESENSE_ScanStop(void);
void LESENSE_DecoderStart(void);
void LESENSE_ResultBufferClear(void);


/***************************************************************************/
__STATIC_INLINE void LESENSE_DecoderStop(void)
{
  /* Stop the decoder */
  LESENSE->DECCTRL |= LESENSE_DECCTRL_DISABLE;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LESENSE_StatusGet(void)
{
  return LESENSE->STATUS;
}


/***************************************************************************/
__STATIC_INLINE void LESENSE_StatusWait(uint32_t flag)
{
  while (!(LESENSE->STATUS & flag))
    ;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LESENSE_ChannelActiveGet(void)
{
  return LESENSE->CURCH;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LESENSE_ScanResultGet(void)
{
  return LESENSE->SCANRES & _LESENSE_SCANRES_SCANRES_MASK;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LESENSE_ScanResultDataGet(void)
{
  return LESENSE->BUFDATA;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LESENSE_ScanResultDataBufferGet(uint32_t idx)
{
  /* Note: masking is needed to avoid over-indexing! */
  return LESENSE->BUF[idx & 0x0FU].DATA;
}

/***************************************************************************/
__STATIC_INLINE uint32_t LESENSE_SensorStateGet(void)
{
  return LESENSE->SENSORSTATE;
}


#if defined(LESENSE_POWERDOWN_RAM)
/***************************************************************************/
__STATIC_INLINE void LESENSE_RAMPowerDown(void)
{
  /* Power down LESENSE RAM */
  LESENSE->POWERDOWN = LESENSE_POWERDOWN_RAM;
}
#endif


/***************************************************************************/
__STATIC_INLINE void LESENSE_IntClear(uint32_t flags)
{
  LESENSE->IFC = flags;
}


/***************************************************************************/
__STATIC_INLINE void LESENSE_IntEnable(uint32_t flags)
{
  LESENSE->IEN |= flags;
}


/***************************************************************************/
__STATIC_INLINE void LESENSE_IntDisable(uint32_t flags)
{
  LESENSE->IEN &= ~flags;
}


/***************************************************************************/
__STATIC_INLINE void LESENSE_IntSet(uint32_t flags)
{
  LESENSE->IFS = flags;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LESENSE_IntGet(void)
{
  return LESENSE->IF;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LESENSE_IntGetEnabled(void)
{
  uint32_t tmp;

  /* Store LESENSE->IEN in temporary variable in order to define explicit order
   * of volatile accesses. */
  tmp = LESENSE->IEN;

  /* Bitwise AND of pending and enabled interrupts */
  return LESENSE->IF & tmp;
}


#ifdef __cplusplus
}
#endif

#endif /* defined(LESENSE_COUNT) && (LESENSE_COUNT > 0) */

#endif /* EM_LESENSE_H */