em_dac.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef EM_DAC_H
#define EM_DAC_H

#include "em_device.h"

#if defined(DAC_COUNT) && (DAC_COUNT > 0)

#include "em_assert.h"
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif


/***************************************************************************/
/***************************************************************************/
#define DAC_REF_VALID(ref)    ((ref) == DAC0)

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

typedef enum
{
  dacConvModeContinuous = _DAC_CTRL_CONVMODE_CONTINUOUS, 
  dacConvModeSampleHold = _DAC_CTRL_CONVMODE_SAMPLEHOLD, 
  dacConvModeSampleOff  = _DAC_CTRL_CONVMODE_SAMPLEOFF   
} DAC_ConvMode_TypeDef;

typedef enum
{
  dacOutputDisable = _DAC_CTRL_OUTMODE_DISABLE, 
  dacOutputPin     = _DAC_CTRL_OUTMODE_PIN,     
  dacOutputADC     = _DAC_CTRL_OUTMODE_ADC,     
  dacOutputPinADC  = _DAC_CTRL_OUTMODE_PINADC   
} DAC_Output_TypeDef;


typedef enum
{
  dacPRSSELCh0 = _DAC_CH0CTRL_PRSSEL_PRSCH0, 
  dacPRSSELCh1 = _DAC_CH0CTRL_PRSSEL_PRSCH1, 
  dacPRSSELCh2 = _DAC_CH0CTRL_PRSSEL_PRSCH2, 
  dacPRSSELCh3 = _DAC_CH0CTRL_PRSSEL_PRSCH3, 
#if defined( _DAC_CH0CTRL_PRSSEL_PRSCH4 )
  dacPRSSELCh4 = _DAC_CH0CTRL_PRSSEL_PRSCH4, 
#endif
#if defined( _DAC_CH0CTRL_PRSSEL_PRSCH5 )
  dacPRSSELCh5 = _DAC_CH0CTRL_PRSSEL_PRSCH5, 
#endif
#if defined( _DAC_CH0CTRL_PRSSEL_PRSCH6 )
  dacPRSSELCh6 = _DAC_CH0CTRL_PRSSEL_PRSCH6, 
#endif
#if defined( _DAC_CH0CTRL_PRSSEL_PRSCH7 )
  dacPRSSELCh7 = _DAC_CH0CTRL_PRSSEL_PRSCH7, 
#endif
#if defined( _DAC_CH0CTRL_PRSSEL_PRSCH8 )
  dacPRSSELCh8 = _DAC_CH0CTRL_PRSSEL_PRSCH8, 
#endif
#if defined( _DAC_CH0CTRL_PRSSEL_PRSCH9 )
  dacPRSSELCh9 = _DAC_CH0CTRL_PRSSEL_PRSCH9, 
#endif
#if defined( _DAC_CH0CTRL_PRSSEL_PRSCH10 )
  dacPRSSELCh10 = _DAC_CH0CTRL_PRSSEL_PRSCH10, 
#endif
#if defined( _DAC_CH0CTRL_PRSSEL_PRSCH11 )
  dacPRSSELCh11 = _DAC_CH0CTRL_PRSSEL_PRSCH11, 
#endif
} DAC_PRSSEL_TypeDef;


typedef enum
{
  dacRef1V25 = _DAC_CTRL_REFSEL_1V25, 
  dacRef2V5  = _DAC_CTRL_REFSEL_2V5,  
  dacRefVDD  = _DAC_CTRL_REFSEL_VDD   
} DAC_Ref_TypeDef;


typedef enum
{
  dacRefresh8  = _DAC_CTRL_REFRSEL_8CYCLES,  
  dacRefresh16 = _DAC_CTRL_REFRSEL_16CYCLES, 
  dacRefresh32 = _DAC_CTRL_REFRSEL_32CYCLES, 
  dacRefresh64 = _DAC_CTRL_REFRSEL_64CYCLES  
} DAC_Refresh_TypeDef;


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

typedef struct
{
  DAC_Refresh_TypeDef  refresh;

  DAC_Ref_TypeDef      reference;

  DAC_Output_TypeDef   outMode;

  DAC_ConvMode_TypeDef convMode;

  uint8_t              prescale;

  bool                 lpEnable;

  bool                 ch0ResetPre;

  bool                 outEnablePRS;

  bool                 sineEnable;

  bool                 diff;
} DAC_Init_TypeDef;

#define DAC_INIT_DEFAULT                                               \
{                                                                      \
  dacRefresh8,              /* Refresh every 8 prescaled cycles. */    \
  dacRef1V25,               /* 1.25V internal reference. */            \
  dacOutputPin,             /* Output to pin only. */                  \
  dacConvModeContinuous,    /* Continuous mode. */                     \
  0,                        /* No prescaling. */                       \
  false,                    /* Do not enable low pass filter. */       \
  false,                    /* Do not reset prescaler on ch0 start. */ \
  false,                    /* DAC output enable always on. */         \
  false,                    /* Disable sine mode. */                   \
  false                     /* Single ended mode. */                   \
}


typedef struct
{
  bool               enable;

  bool               prsEnable;

  bool               refreshEnable;

  DAC_PRSSEL_TypeDef prsSel;
} DAC_InitChannel_TypeDef;

#define DAC_INITCHANNEL_DEFAULT                                         \
{                                                                       \
  false,              /* Leave channel disabled when init done. */      \
  false,              /* Disable PRS triggering. */                     \
  false,              /* Channel not refreshed automatically. */        \
  dacPRSSELCh0        /* Select PRS ch0 (if PRS triggering enabled). */ \
}


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

void DAC_Enable(DAC_TypeDef *dac, unsigned int ch, bool enable);
void DAC_Init(DAC_TypeDef *dac, const DAC_Init_TypeDef *init);
void DAC_InitChannel(DAC_TypeDef *dac,
                     const DAC_InitChannel_TypeDef *init,
                     unsigned int ch);
void DAC_ChannelOutputSet(DAC_TypeDef *dac,
                          unsigned int channel,
                          uint32_t     value);

/***************************************************************************/
__STATIC_INLINE void DAC_Channel0OutputSet( DAC_TypeDef *dac,
                                            uint32_t     value )
{
  EFM_ASSERT(value<=_DAC_CH0DATA_MASK);
  dac->CH0DATA = value;
}


/***************************************************************************/
__STATIC_INLINE void DAC_Channel1OutputSet( DAC_TypeDef *dac,
                                            uint32_t     value )
{
  EFM_ASSERT(value<=_DAC_CH1DATA_MASK);
  dac->CH1DATA = value;
}


/***************************************************************************/
__STATIC_INLINE void DAC_IntClear(DAC_TypeDef *dac, uint32_t flags)
{
  dac->IFC = flags;
}


/***************************************************************************/
__STATIC_INLINE void DAC_IntDisable(DAC_TypeDef *dac, uint32_t flags)
{
  dac->IEN &= ~flags;
}


/***************************************************************************/
__STATIC_INLINE void DAC_IntEnable(DAC_TypeDef *dac, uint32_t flags)
{
  dac->IEN |= flags;
}


/***************************************************************************/
__STATIC_INLINE uint32_t DAC_IntGet(DAC_TypeDef *dac)
{
  return dac->IF;
}


/***************************************************************************/
__STATIC_INLINE uint32_t DAC_IntGetEnabled(DAC_TypeDef *dac)
{
  uint32_t ien;

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

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


/***************************************************************************/
__STATIC_INLINE void DAC_IntSet(DAC_TypeDef *dac, uint32_t flags)
{
  dac->IFS = flags;
}

uint8_t DAC_PrescaleCalc(uint32_t dacFreq, uint32_t hfperFreq);
void DAC_Reset(DAC_TypeDef *dac);

#ifdef __cplusplus
}
#endif

#endif /* defined(DAC_COUNT) && (DAC_COUNT > 0) */
#endif /* EM_DAC_H */