em_pcnt.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef EM_PCNT_H
#define EM_PCNT_H

#include "em_device.h"
#if defined(PCNT_COUNT) && (PCNT_COUNT > 0)

#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif

/***************************************************************************/
/***************************************************************************/
/*******************************************************************************
 *******************************   DEFINES   ***********************************
 ******************************************************************************/
#if defined(_EFM32_GECKO_FAMILY)
#define PCNT0_CNT_SIZE    (8)   /* PCNT0 counter is  8 bits. */
#else
#define PCNT0_CNT_SIZE   (16)   /* PCNT0 counter is 16 bits. */
#endif

#ifdef PCNT1

#define PCNT1_CNT_SIZE    (8)   /* PCNT1 counter is  8 bits. */
#endif

#ifdef PCNT2

#define PCNT2_CNT_SIZE    (8)   /* PCNT2 counter is  8 bits. */
#endif


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

typedef enum
{
  pcntModeDisable   = _PCNT_CTRL_MODE_DISABLE,

  pcntModeOvsSingle = _PCNT_CTRL_MODE_OVSSINGLE,

  pcntModeExtSingle = _PCNT_CTRL_MODE_EXTCLKSINGLE,

  pcntModeExtQuad   = _PCNT_CTRL_MODE_EXTCLKQUAD,

#if defined(_PCNT_CTRL_MODE_OVSQUAD1X)

  pcntModeOvsQuad1  = _PCNT_CTRL_MODE_OVSQUAD1X,

  pcntModeOvsQuad2  = _PCNT_CTRL_MODE_OVSQUAD2X,

  pcntModeOvsQuad4  = _PCNT_CTRL_MODE_OVSQUAD4X,
#endif
} PCNT_Mode_TypeDef;


#if defined(_PCNT_CTRL_CNTEV_MASK)

typedef enum
{
  pcntCntEventBoth = _PCNT_CTRL_CNTEV_BOTH,

  pcntCntEventUp   = _PCNT_CTRL_CNTEV_UP,

  pcntCntEventDown = _PCNT_CTRL_CNTEV_DOWN,

  pcntCntEventNone = _PCNT_CTRL_CNTEV_NONE
} PCNT_CntEvent_TypeDef;
#endif


#if defined(_PCNT_INPUT_MASK)

typedef enum
{
  pcntPRSCh0 = 0,     
  pcntPRSCh1 = 1,     
  pcntPRSCh2 = 2,     
  pcntPRSCh3 = 3,     
#if defined(PCNT_INPUT_S0PRSSEL_PRSCH4)
  pcntPRSCh4 = 4,     
#endif
#if defined(PCNT_INPUT_S0PRSSEL_PRSCH5)
  pcntPRSCh5 = 5,     
#endif
#if defined(PCNT_INPUT_S0PRSSEL_PRSCH6)
  pcntPRSCh6 = 6,     
#endif
#if defined(PCNT_INPUT_S0PRSSEL_PRSCH7)
  pcntPRSCh7 = 7,     
#endif
#if defined(PCNT_INPUT_S0PRSSEL_PRSCH8)
  pcntPRSCh8 = 8,     
#endif
#if defined(PCNT_INPUT_S0PRSSEL_PRSCH9)
  pcntPRSCh9 = 9,     
#endif
#if defined(PCNT_INPUT_S0PRSSEL_PRSCH10)
  pcntPRSCh10 = 10,   
#endif
#if defined(PCNT_INPUT_S0PRSSEL_PRSCH11)
  pcntPRSCh11 = 11    
#endif
} PCNT_PRSSel_TypeDef;


typedef enum
{
  pcntPRSInputS0 = 0, 
  pcntPRSInputS1 = 1  
} PCNT_PRSInput_TypeDef;
#endif


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

typedef struct
{
  PCNT_Mode_TypeDef     mode;

  uint32_t              counter;

  uint32_t              top;

  bool                  negEdge;

  bool                  countDown;

  bool                  filter;

#if defined(PCNT_CTRL_HYST)

  bool                  hyst;

  bool                  s1CntDir;

  PCNT_CntEvent_TypeDef cntEvent;

  PCNT_CntEvent_TypeDef auxCntEvent;

  PCNT_PRSSel_TypeDef   s0PRS;

  PCNT_PRSSel_TypeDef   s1PRS;
#endif
} PCNT_Init_TypeDef;

#if !defined(PCNT_CTRL_HYST)

#define PCNT_INIT_DEFAULT                                                         \
{                                                                                 \
  pcntModeDisable,                          /* Disabled by default. */            \
  _PCNT_CNT_RESETVALUE,                     /* Default counter HW reset value. */ \
  _PCNT_TOP_RESETVALUE,                     /* Default counter HW reset value. */ \
  false,                                    /* Use positive edge. */              \
  false,                                    /* Up-counting. */                    \
  false                                     /* Filter disabled. */                \
}
#else

#define PCNT_INIT_DEFAULT                                                                      \
{                                                                                              \
  pcntModeDisable,                          /* Disabled by default. */                         \
  _PCNT_CNT_RESETVALUE,                     /* Default counter HW reset value. */              \
  _PCNT_TOP_RESETVALUE,                     /* Default counter HW reset value. */              \
  false,                                    /* Use positive edge. */                           \
  false,                                    /* Up-counting. */                                 \
  false,                                    /* Filter disabled. */                             \
  false,                                    /* Hysteresis disabled. */                         \
  true,                                     /* Counter direction is given by CNTDIR. */        \
  pcntCntEventUp,                           /* Regular counter counts up on upcount events. */ \
  pcntCntEventNone,                         /* Auxiliary counter doesn't respond to events. */ \
  pcntPRSCh0,                               /* PRS channel 0 selected as S0IN. */              \
  pcntPRSCh0                                /* PRS channel 0 selected as S1IN. */              \
}
#endif

#if defined(PCNT_OVSCFG_FILTLEN_DEFAULT)

typedef struct
{
  uint8_t               filtLen;

  bool                  flutterrm;
} PCNT_Filter_TypeDef;
#endif

#if defined(PCNT_OVSCFG_FILTLEN_DEFAULT)
#define PCNT_FILTER_DEFAULT                                                                     \
{                                                                                               \
  0,                                        /* Default length is 5 LFACLK cycles */             \
  false                                     /* No flutter removal */                            \
}
#endif

#if defined(PCNT_CTRL_TCCMODE_DEFAULT)

typedef enum
{
  tccModeDisabled       = _PCNT_CTRL_TCCMODE_DISABLED,

  tccModeLFA            = _PCNT_CTRL_TCCMODE_LFA,

  tccModePRS            = _PCNT_CTRL_TCCMODE_PRS
} PCNT_TCCMode_TypeDef;

typedef enum
{
  tccPrescDiv1          = _PCNT_CTRL_TCCPRESC_DIV1,

  tccPrescDiv2          = _PCNT_CTRL_TCCPRESC_DIV2,

  tccPrescDiv4          = _PCNT_CTRL_TCCPRESC_DIV4,

  tccPrescDiv8          = _PCNT_CTRL_TCCPRESC_DIV8
} PCNT_TCCPresc_Typedef;

typedef enum
{
  tccCompLTOE           = _PCNT_CTRL_TCCCOMP_LTOE,

  tccCompGTOE           = _PCNT_CTRL_TCCCOMP_GTOE,

  tccCompRange          = _PCNT_CTRL_TCCCOMP_RANGE
} PCNT_TCCComp_Typedef;

typedef struct
{
  PCNT_TCCMode_TypeDef      mode;

  PCNT_TCCPresc_Typedef     prescaler;

  PCNT_TCCComp_Typedef      compare;

  PCNT_PRSSel_TypeDef       tccPRS;

  bool                      prsPolarity;

  bool                      prsGateEnable;
} PCNT_TCC_TypeDef;

#define PCNT_TCC_DEFAULT                                                                            \
{                                                                                                   \
  tccModeDisabled,                              /* Disabled by default */                           \
  tccPrescDiv1,                                 /* Do not prescale LFA clock in LFA mode */         \
  tccCompLTOE,                                  /* Clear when CNT <= TOP */                         \
  pcntPRSCh0,                                   /* Select PRS channel 0 as input to TCC */          \
  false,                                        /* PRS polarity is rising edge, and gate when 1 */  \
  false                                         /* Do not gate the PCNT counter input */            \
}

#endif
/* defined(PCNT_CTRL_TCCMODE_DEFAULT) */

/*******************************************************************************
 *****************************   PROTOTYPES   **********************************
 ******************************************************************************/

/***************************************************************************/
__STATIC_INLINE uint32_t PCNT_CounterGet(PCNT_TypeDef *pcnt)
{
  return pcnt->CNT;
}

#if defined(_PCNT_AUXCNT_MASK)
/***************************************************************************/
__STATIC_INLINE uint32_t PCNT_AuxCounterGet(PCNT_TypeDef *pcnt)
{
  return pcnt->AUXCNT;
}
#endif

void PCNT_CounterReset(PCNT_TypeDef *pcnt);
void PCNT_CounterTopSet(PCNT_TypeDef *pcnt, uint32_t count, uint32_t top);

/***************************************************************************/
__STATIC_INLINE void PCNT_CounterSet(PCNT_TypeDef *pcnt, uint32_t count)
{
  PCNT_CounterTopSet(pcnt, count, pcnt->TOP);
}

void PCNT_Enable(PCNT_TypeDef *pcnt, PCNT_Mode_TypeDef mode);
void PCNT_FreezeEnable(PCNT_TypeDef *pcnt, bool enable);
void PCNT_Init(PCNT_TypeDef *pcnt, const PCNT_Init_TypeDef *init);

#if defined(PCNT_OVSCFG_FILTLEN_DEFAULT)
void PCNT_FilterConfiguration(PCNT_TypeDef *pcnt, const PCNT_Filter_TypeDef *config, bool enable);
#endif

#if defined(_PCNT_INPUT_MASK)
void PCNT_PRSInputEnable(PCNT_TypeDef *pcnt,
                         PCNT_PRSInput_TypeDef prsInput,
                         bool enable);
#endif

#if defined(PCNT_CTRL_TCCMODE_DEFAULT)
void PCNT_TCCConfiguration(PCNT_TypeDef *pcnt, const PCNT_TCC_TypeDef *config);
#endif
/***************************************************************************/
__STATIC_INLINE void PCNT_IntClear(PCNT_TypeDef *pcnt, uint32_t flags)
{
  pcnt->IFC = flags;
}

/***************************************************************************/
__STATIC_INLINE void PCNT_IntDisable(PCNT_TypeDef *pcnt, uint32_t flags)
{
  pcnt->IEN &= ~flags;
}

/***************************************************************************/
__STATIC_INLINE void PCNT_IntEnable(PCNT_TypeDef *pcnt, uint32_t flags)
{
  pcnt->IEN |= flags;
}

/***************************************************************************/
__STATIC_INLINE uint32_t PCNT_IntGet(PCNT_TypeDef *pcnt)
{
  return pcnt->IF;
}

/***************************************************************************/
__STATIC_INLINE uint32_t PCNT_IntGetEnabled(PCNT_TypeDef *pcnt)
{
  uint32_t ien;


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

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

/***************************************************************************/
__STATIC_INLINE void PCNT_IntSet(PCNT_TypeDef *pcnt, uint32_t flags)
{
  pcnt->IFS = flags;
}

void PCNT_Reset(PCNT_TypeDef *pcnt);

/***************************************************************************/
__STATIC_INLINE uint32_t PCNT_TopBufferGet(PCNT_TypeDef *pcnt)
{
  return pcnt->TOPB;
}

void PCNT_TopBufferSet(PCNT_TypeDef *pcnt, uint32_t val);

/***************************************************************************/
__STATIC_INLINE uint32_t PCNT_TopGet(PCNT_TypeDef *pcnt)
{
  return pcnt->TOP;
}

void PCNT_TopSet(PCNT_TypeDef *pcnt, uint32_t val);

#ifdef __cplusplus
}
#endif

#endif /* defined(PCNT_COUNT) && (PCNT_COUNT > 0) */
#endif /* EM_PCNT_H */