em_lcd.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef EM_LCD_H
#define EM_LCD_H

#include "em_device.h"

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

#ifdef __cplusplus
extern "C" {
#endif

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

typedef enum
{
  lcdMuxStatic     = LCD_DISPCTRL_MUX_STATIC,
  lcdMuxDuplex     = LCD_DISPCTRL_MUX_DUPLEX,
  lcdMuxTriplex    = LCD_DISPCTRL_MUX_TRIPLEX,
  lcdMuxQuadruplex = LCD_DISPCTRL_MUX_QUADRUPLEX,
#if defined(LCD_DISPCTRL_MUXE_MUXE)

  lcdMuxSextaplex  = LCD_DISPCTRL_MUXE_MUXE | LCD_DISPCTRL_MUX_DUPLEX,
  lcdMuxOctaplex   = LCD_DISPCTRL_MUXE_MUXE | LCD_DISPCTRL_MUX_QUADRUPLEX
#endif
} LCD_Mux_TypeDef;

typedef enum
{
  lcdBiasStatic    = LCD_DISPCTRL_BIAS_STATIC,
  lcdBiasOneHalf   = LCD_DISPCTRL_BIAS_ONEHALF,
  lcdBiasOneThird  = LCD_DISPCTRL_BIAS_ONETHIRD,
#if defined(LCD_DISPCTRL_BIAS_ONEFOURTH)

  lcdBiasOneFourth = LCD_DISPCTRL_BIAS_ONEFOURTH,
#endif
} LCD_Bias_TypeDef;

typedef enum
{
  lcdWaveLowPower = LCD_DISPCTRL_WAVE_LOWPOWER,
  lcdWaveNormal   = LCD_DISPCTRL_WAVE_NORMAL
} LCD_Wave_TypeDef;

typedef enum
{
  lcdVLCDSelVDD       = LCD_DISPCTRL_VLCDSEL_VDD,
  lcdVLCDSelVExtBoost = LCD_DISPCTRL_VLCDSEL_VEXTBOOST
} LCD_VLCDSel_TypeDef;

typedef enum
{
  lcdConConfVLCD = LCD_DISPCTRL_CONCONF_VLCD,
  lcdConConfGND  = LCD_DISPCTRL_CONCONF_GND
} LCD_ConConf_TypeDef;

typedef enum
{
  lcdVBoostLevel0 = LCD_DISPCTRL_VBLEV_LEVEL0, 
  lcdVBoostLevel1 = LCD_DISPCTRL_VBLEV_LEVEL1, 
  lcdVBoostLevel2 = LCD_DISPCTRL_VBLEV_LEVEL2, 
  lcdVBoostLevel3 = LCD_DISPCTRL_VBLEV_LEVEL3, 
  lcdVBoostLevel4 = LCD_DISPCTRL_VBLEV_LEVEL4, 
  lcdVBoostLevel5 = LCD_DISPCTRL_VBLEV_LEVEL5, 
  lcdVBoostLevel6 = LCD_DISPCTRL_VBLEV_LEVEL6, 
  lcdVBoostLevel7 = LCD_DISPCTRL_VBLEV_LEVEL7  
} LCD_VBoostLevel_TypeDef;

typedef enum
{
  lcdFCPrescDiv1 = LCD_BACTRL_FCPRESC_DIV1,
  lcdFCPrescDiv2 = LCD_BACTRL_FCPRESC_DIV2,
  lcdFCPrescDiv4 = LCD_BACTRL_FCPRESC_DIV4,
  lcdFCPrescDiv8 = LCD_BACTRL_FCPRESC_DIV8
} LCD_FCPreScale_TypeDef;

typedef enum
{
  lcdSegment0_3   = (1 << 0),
  lcdSegment4_7   = (1 << 1),
  lcdSegment8_11  = (1 << 2),
  lcdSegment12_15 = (1 << 3),
  lcdSegment16_19 = (1 << 4),
  lcdSegment20_23 = (1 << 5),
#if defined(_LCD_SEGD0L_MASK) && (_LCD_SEGD0L_MASK == 0x00FFFFFFUL)

  lcdSegmentAll   = (0x003f)
#elif defined(_LCD_SEGD0H_MASK) && (_LCD_SEGD0H_MASK == 0x000000FFUL)
  lcdSegment24_27 = (1 << 6),
  lcdSegment28_31 = (1 << 7),
  lcdSegment32_35 = (1 << 8),
  lcdSegment36_39 = (1 << 9),
  lcdSegmentAll   = (0x03ff)
#endif
} LCD_SegmentRange_TypeDef;

typedef enum
{
  lcdUpdateCtrlRegular    = LCD_CTRL_UDCTRL_REGULAR,
  lcdUpdateCtrlFCEvent    = LCD_CTRL_UDCTRL_FCEVENT,
  lcdUpdateCtrlFrameStart = LCD_CTRL_UDCTRL_FRAMESTART
} LCD_UpdateCtrl_TypeDef;

typedef enum
{
  lcdAnimShiftNone  = _LCD_BACTRL_AREGASC_NOSHIFT,
  lcdAnimShiftLeft  = _LCD_BACTRL_AREGASC_SHIFTLEFT,
  lcdAnimShiftRight = _LCD_BACTRL_AREGASC_SHIFTRIGHT
} LCD_AnimShift_TypeDef;

typedef enum
{
  lcdAnimLogicAnd = LCD_BACTRL_ALOGSEL_AND,
  lcdAnimLogicOr  = LCD_BACTRL_ALOGSEL_OR
} LCD_AnimLogic_TypeDef;


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

typedef struct
{
  bool                  enable;
  uint32_t              AReg;
  LCD_AnimShift_TypeDef AShift;
  uint32_t              BReg;
  LCD_AnimShift_TypeDef BShift;
  LCD_AnimLogic_TypeDef animLogic;
#if defined(LCD_BACTRL_ALOC)

  int                   startSeg;
#endif
} LCD_AnimInit_TypeDef;

typedef struct
{
  bool                   enable;
  uint32_t               top;
  LCD_FCPreScale_TypeDef prescale;
} LCD_FrameCountInit_TypeDef;

typedef struct
{
  bool                enable;
  LCD_Mux_TypeDef     mux;
  LCD_Bias_TypeDef    bias;
  LCD_Wave_TypeDef    wave;
  LCD_VLCDSel_TypeDef vlcd;
  LCD_ConConf_TypeDef contrast;
} LCD_Init_TypeDef;

#define LCD_INIT_DEFAULT \
{                        \
  true,                  \
  lcdMuxQuadruplex,      \
  lcdBiasOneThird,       \
  lcdWaveLowPower,       \
  lcdVLCDSelVDD,         \
  lcdConConfVLCD         \
}

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

void LCD_Init(const LCD_Init_TypeDef *lcdInit);
void LCD_VLCDSelect(LCD_VLCDSel_TypeDef vlcd);
void LCD_UpdateCtrl(LCD_UpdateCtrl_TypeDef ud);
void LCD_FrameCountInit(const LCD_FrameCountInit_TypeDef *fcInit);
void LCD_AnimInit(const LCD_AnimInit_TypeDef *animInit);

void LCD_SegmentRangeEnable(LCD_SegmentRange_TypeDef segment, bool enable);
void LCD_SegmentSet(int com, int bit, bool enable);
void LCD_SegmentSetLow(int com, uint32_t mask, uint32_t bits);
#if defined(_LCD_SEGD0H_MASK)
void LCD_SegmentSetHigh(int com, uint32_t mask, uint32_t bits);
#endif
void LCD_ContrastSet(int level);
void LCD_VBoostSet(LCD_VBoostLevel_TypeDef vboost);

#if defined(LCD_CTRL_DSC)
void LCD_BiasSegmentSet(int segment, int biasLevel);
void LCD_BiasComSet(int com, int biasLevel);
#endif

/***************************************************************************/
__STATIC_INLINE void LCD_Enable(bool enable)
{
  if (enable)
  {
    LCD->CTRL |= LCD_CTRL_EN;
  }
  else
  {
    LCD->CTRL &= ~LCD_CTRL_EN;
  }
}


/***************************************************************************/
__STATIC_INLINE void LCD_AnimEnable(bool enable)
{
  if (enable)
  {
    LCD->BACTRL |= LCD_BACTRL_AEN;
  }
  else
  {
    LCD->BACTRL &= ~LCD_BACTRL_AEN;
  }
}


/***************************************************************************/
__STATIC_INLINE void LCD_BlinkEnable(bool enable)
{
  if (enable)
  {
    LCD->BACTRL |= LCD_BACTRL_BLINKEN;
  }
  else
  {
    LCD->BACTRL &= ~LCD_BACTRL_BLINKEN;
  }
}


/***************************************************************************/
__STATIC_INLINE void LCD_BlankEnable(bool enable)
{
  if (enable)
  {
    LCD->BACTRL |= LCD_BACTRL_BLANK;
  }
  else
  {
    LCD->BACTRL &= ~LCD_BACTRL_BLANK;
  }
}


/***************************************************************************/
__STATIC_INLINE void LCD_FrameCountEnable(bool enable)
{
  if (enable)
  {
    LCD->BACTRL |= LCD_BACTRL_FCEN;
  }
  else
  {
    LCD->BACTRL &= ~LCD_BACTRL_FCEN;
  }
}


/***************************************************************************/
__STATIC_INLINE int LCD_AnimState(void)
{
  return (int)(LCD->STATUS & _LCD_STATUS_ASTATE_MASK) >> _LCD_STATUS_ASTATE_SHIFT;
}


/***************************************************************************/
__STATIC_INLINE int LCD_BlinkState(void)
{
  return (int)(LCD->STATUS & _LCD_STATUS_BLINK_MASK) >> _LCD_STATUS_BLINK_SHIFT;
}


/***************************************************************************/
__STATIC_INLINE void LCD_FreezeEnable(bool enable)
{
  if (enable)
  {
    LCD->FREEZE = LCD_FREEZE_REGFREEZE_FREEZE;
  }
  else
  {
    LCD->FREEZE = LCD_FREEZE_REGFREEZE_UPDATE;
  }
}


/***************************************************************************/
__STATIC_INLINE uint32_t LCD_SyncBusyGet(void)
{
  return LCD->SYNCBUSY;
}


/***************************************************************************/
__STATIC_INLINE void LCD_SyncBusyDelay(uint32_t flags)
{
  while (LCD->SYNCBUSY & flags)
    ;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LCD_IntGet(void)
{
  return LCD->IF;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LCD_IntGetEnabled(void)
{
  uint32_t ien;

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

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


/***************************************************************************/
__STATIC_INLINE void LCD_IntSet(uint32_t flags)
{
  LCD->IFS = flags;
}


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


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


/***************************************************************************/
__STATIC_INLINE void LCD_IntClear(uint32_t flags)
{
  LCD->IFC = flags;
}


#if defined(LCD_CTRL_DSC)
/***************************************************************************/
__STATIC_INLINE void LCD_DSCEnable(bool enable)
{
  if (enable)
  {
    LCD->CTRL |= LCD_CTRL_DSC;
  }
  else
  {
    LCD->CTRL &= ~LCD_CTRL_DSC;
  }
}
#endif

#ifdef __cplusplus
}
#endif

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

#endif /* EM_LCD_H */