em_letimer.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef EM_LETIMER_H
#define EM_LETIMER_H

#include <stdbool.h>
#include "em_device.h"
#if defined(LETIMER_COUNT) && (LETIMER_COUNT > 0)

#ifdef __cplusplus
extern "C" {
#endif

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

typedef enum
{
  letimerRepeatFree     = _LETIMER_CTRL_REPMODE_FREE,
  letimerRepeatOneshot  = _LETIMER_CTRL_REPMODE_ONESHOT,
  letimerRepeatBuffered = _LETIMER_CTRL_REPMODE_BUFFERED,
  letimerRepeatDouble   = _LETIMER_CTRL_REPMODE_DOUBLE
} LETIMER_RepeatMode_TypeDef;


typedef enum
{
  letimerUFOANone   = _LETIMER_CTRL_UFOA0_NONE,
  letimerUFOAToggle = _LETIMER_CTRL_UFOA0_TOGGLE,
  letimerUFOAPulse  = _LETIMER_CTRL_UFOA0_PULSE,
  letimerUFOAPwm    = _LETIMER_CTRL_UFOA0_PWM
} LETIMER_UFOA_TypeDef;

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

typedef struct
{
  bool                       enable;         
  bool                       debugRun;       
#if defined(LETIMER_CTRL_RTCC0TEN)
  bool                       rtcComp0Enable; 
  bool                       rtcComp1Enable; 
#endif
  bool                       comp0Top;       
  bool                       bufTop;         
  uint8_t                    out0Pol;        
  uint8_t                    out1Pol;        
  LETIMER_UFOA_TypeDef       ufoa0;          
  LETIMER_UFOA_TypeDef       ufoa1;          
  LETIMER_RepeatMode_TypeDef repMode;        
} LETIMER_Init_TypeDef;

#if defined(LETIMER_CTRL_RTCC0TEN)
#define LETIMER_INIT_DEFAULT                                                  \
{                                                                             \
  true,               /* Enable timer when init complete. */                  \
  false,              /* Stop counter during debug halt. */                   \
  false,              /* Do not start counting on RTC COMP0 match. */         \
  false,              /* Do not start counting on RTC COMP1 match. */         \
  false,              /* Do not load COMP0 into CNT on underflow. */          \
  false,              /* Do not load COMP1 into COMP0 when REP0 reaches 0. */ \
  0,                  /* Idle value 0 for output 0. */                        \
  0,                  /* Idle value 0 for output 1. */                        \
  letimerUFOANone,    /* No action on underflow on output 0. */               \
  letimerUFOANone,    /* No action on underflow on output 1. */               \
  letimerRepeatFree   /* Count until stopped by SW. */                        \
}
#else
#define LETIMER_INIT_DEFAULT                                                  \
{                                                                             \
  true,               /* Enable timer when init complete. */                  \
  false,              /* Stop counter during debug halt. */                   \
  false,              /* Do not load COMP0 into CNT on underflow. */          \
  false,              /* Do not load COMP1 into COMP0 when REP0 reaches 0. */ \
  0,                  /* Idle value 0 for output 0. */                        \
  0,                  /* Idle value 0 for output 1. */                        \
  letimerUFOANone,    /* No action on underflow on output 0. */               \
  letimerUFOANone,    /* No action on underflow on output 1. */               \
  letimerRepeatFree   /* Count until stopped by SW. */                        \
}
#endif

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

uint32_t LETIMER_CompareGet(LETIMER_TypeDef *letimer, unsigned int comp);
void LETIMER_CompareSet(LETIMER_TypeDef *letimer,
                        unsigned int comp,
                        uint32_t value);


/***************************************************************************/
__STATIC_INLINE uint32_t LETIMER_CounterGet(LETIMER_TypeDef *letimer)
{
  return(letimer->CNT);
}


void LETIMER_Enable(LETIMER_TypeDef *letimer, bool enable);
#if defined(_LETIMER_FREEZE_MASK)
void LETIMER_FreezeEnable(LETIMER_TypeDef *letimer, bool enable);
#endif
void LETIMER_Init(LETIMER_TypeDef *letimer, const LETIMER_Init_TypeDef *init);


/***************************************************************************/
__STATIC_INLINE void LETIMER_IntClear(LETIMER_TypeDef *letimer, uint32_t flags)
{
  letimer->IFC = flags;
}


/***************************************************************************/
__STATIC_INLINE void LETIMER_IntDisable(LETIMER_TypeDef *letimer, uint32_t flags)
{
  letimer->IEN &= ~flags;
}


/***************************************************************************/
__STATIC_INLINE void LETIMER_IntEnable(LETIMER_TypeDef *letimer, uint32_t flags)
{
  letimer->IEN |= flags;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LETIMER_IntGet(LETIMER_TypeDef *letimer)
{
  return letimer->IF;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LETIMER_IntGetEnabled(LETIMER_TypeDef *letimer)
{
  uint32_t ien;


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

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


/***************************************************************************/
__STATIC_INLINE void LETIMER_IntSet(LETIMER_TypeDef *letimer, uint32_t flags)
{
  letimer->IFS = flags;
}


uint32_t LETIMER_RepeatGet(LETIMER_TypeDef *letimer, unsigned int rep);
void LETIMER_RepeatSet(LETIMER_TypeDef *letimer,
                       unsigned int rep,
                       uint32_t value);
void LETIMER_Reset(LETIMER_TypeDef *letimer);


#ifdef __cplusplus
}
#endif

#endif /* defined(LETIMER_COUNT) && (LETIMER_COUNT > 0) */
#endif /* EM_LETIMER_H */