em_leuart.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef EM_LEUART_H
#define EM_LEUART_H

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

#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif

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

typedef enum
{
  leuartDatabits8 = LEUART_CTRL_DATABITS_EIGHT,     
  leuartDatabits9 = LEUART_CTRL_DATABITS_NINE       
} LEUART_Databits_TypeDef;


typedef enum
{
  leuartDisable  = 0x0,

  leuartEnableRx = LEUART_CMD_RXEN,

  leuartEnableTx = LEUART_CMD_TXEN,

  leuartEnable   = (LEUART_CMD_RXEN | LEUART_CMD_TXEN)
} LEUART_Enable_TypeDef;


typedef enum
{
  leuartNoParity   = LEUART_CTRL_PARITY_NONE,    
  leuartEvenParity = LEUART_CTRL_PARITY_EVEN,    
  leuartOddParity  = LEUART_CTRL_PARITY_ODD      
} LEUART_Parity_TypeDef;


typedef enum
{
  leuartStopbits1 = LEUART_CTRL_STOPBITS_ONE,           
  leuartStopbits2 = LEUART_CTRL_STOPBITS_TWO            
} LEUART_Stopbits_TypeDef;


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

typedef struct
{
  LEUART_Enable_TypeDef   enable;

  uint32_t                refFreq;

  uint32_t                baudrate;

  LEUART_Databits_TypeDef databits;

  LEUART_Parity_TypeDef   parity;

  LEUART_Stopbits_TypeDef stopbits;
} LEUART_Init_TypeDef;

#define LEUART_INIT_DEFAULT                                                                 \
{                                                                                           \
  leuartEnable,      /* Enable RX/TX when init completed. */                                \
  0,                 /* Use current configured reference clock for configuring baudrate. */ \
  9600,              /* 9600 bits/s. */                                                     \
  leuartDatabits8,   /* 8 databits. */                                                      \
  leuartNoParity,    /* No parity. */                                                       \
  leuartStopbits1    /* 1 stopbit. */                                                       \
}


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

uint32_t LEUART_BaudrateCalc(uint32_t refFreq, uint32_t clkdiv);
uint32_t LEUART_BaudrateGet(LEUART_TypeDef *leuart);
void LEUART_BaudrateSet(LEUART_TypeDef *leuart,
                        uint32_t refFreq,
                        uint32_t baudrate);
void LEUART_Enable(LEUART_TypeDef *leuart, LEUART_Enable_TypeDef enable);
void LEUART_FreezeEnable(LEUART_TypeDef *leuart, bool enable);
void LEUART_Init(LEUART_TypeDef *leuart, LEUART_Init_TypeDef const *init);
void LEUART_TxDmaInEM2Enable(LEUART_TypeDef *leuart, bool enable);
void LEUART_RxDmaInEM2Enable(LEUART_TypeDef *leuart, bool enable);

/***************************************************************************/
__STATIC_INLINE void LEUART_IntClear(LEUART_TypeDef *leuart, uint32_t flags)
{
  leuart->IFC = flags;
}


/***************************************************************************/
__STATIC_INLINE void LEUART_IntDisable(LEUART_TypeDef *leuart, uint32_t flags)
{
  leuart->IEN &= ~flags;
}


/***************************************************************************/
__STATIC_INLINE void LEUART_IntEnable(LEUART_TypeDef *leuart, uint32_t flags)
{
  leuart->IEN |= flags;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LEUART_IntGet(LEUART_TypeDef *leuart)
{
  return leuart->IF;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LEUART_IntGetEnabled(LEUART_TypeDef *leuart)
{
  uint32_t tmp;

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

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


/***************************************************************************/
__STATIC_INLINE void LEUART_IntSet(LEUART_TypeDef *leuart, uint32_t flags)
{
  leuart->IFS = flags;
}


/***************************************************************************/
__STATIC_INLINE uint32_t LEUART_StatusGet(LEUART_TypeDef *leuart)
{
  return leuart->STATUS;
}

void LEUART_Reset(LEUART_TypeDef *leuart);
uint8_t LEUART_Rx(LEUART_TypeDef *leuart);
uint16_t LEUART_RxExt(LEUART_TypeDef *leuart);
void LEUART_Tx(LEUART_TypeDef *leuart, uint8_t data);
void LEUART_TxExt(LEUART_TypeDef *leuart, uint16_t data);


/***************************************************************************/
__STATIC_INLINE uint8_t LEUART_RxDataGet(LEUART_TypeDef *leuart)
{
  return (uint8_t)leuart->RXDATA;
}


/***************************************************************************/
__STATIC_INLINE uint16_t LEUART_RxDataXGet(LEUART_TypeDef *leuart)
{
  return (uint16_t)leuart->RXDATAX;
}


#ifdef __cplusplus
}
#endif

#endif /* defined(LEUART_COUNT) && (LEUART_COUNT > 0) */
#endif /* EM_LEUART_H */