383 lines
14 KiB
C
383 lines
14 KiB
C
/***************************************************************************//**
|
|
* @file em_leuart.h
|
|
* @brief Low Energy Universal Asynchronous Receiver/Transmitter (LEUART)
|
|
* peripheral API
|
|
* @version 5.1.2
|
|
*******************************************************************************
|
|
* @section License
|
|
* <b>Copyright 2016 Silicon Laboratories, Inc. http://www.silabs.com</b>
|
|
*******************************************************************************
|
|
*
|
|
* Permission is granted to anyone to use this software for any purpose,
|
|
* including commercial applications, and to alter it and redistribute it
|
|
* freely, subject to the following restrictions:
|
|
*
|
|
* 1. The origin of this software must not be misrepresented; you must not
|
|
* claim that you wrote the original software.
|
|
* 2. Altered source versions must be plainly marked as such, and must not be
|
|
* misrepresented as being the original software.
|
|
* 3. This notice may not be removed or altered from any source distribution.
|
|
*
|
|
* DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Silicon Labs has no
|
|
* obligation to support this Software. Silicon Labs is providing the
|
|
* Software "AS IS", with no express or implied warranties of any kind,
|
|
* including, but not limited to, any implied warranties of merchantability
|
|
* or fitness for any particular purpose or warranties against infringement
|
|
* of any proprietary rights of a third party.
|
|
*
|
|
* Silicon Labs will not be liable for any consequential, incidental, or
|
|
* special damages, or any other relief, or for any claim by any third party,
|
|
* arising from your use of this Software.
|
|
*
|
|
******************************************************************************/
|
|
|
|
#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
|
|
|
|
/***************************************************************************//**
|
|
* @addtogroup emlib
|
|
* @{
|
|
******************************************************************************/
|
|
|
|
/***************************************************************************//**
|
|
* @addtogroup LEUART
|
|
* @{
|
|
******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
******************************** ENUMS ************************************
|
|
******************************************************************************/
|
|
|
|
/** Databit selection. */
|
|
typedef enum
|
|
{
|
|
leuartDatabits8 = LEUART_CTRL_DATABITS_EIGHT, /**< 8 databits. */
|
|
leuartDatabits9 = LEUART_CTRL_DATABITS_NINE /**< 9 databits. */
|
|
} LEUART_Databits_TypeDef;
|
|
|
|
|
|
/** Enable selection. */
|
|
typedef enum
|
|
{
|
|
/** Disable both receiver and transmitter. */
|
|
leuartDisable = 0x0,
|
|
|
|
/** Enable receiver only, transmitter disabled. */
|
|
leuartEnableRx = LEUART_CMD_RXEN,
|
|
|
|
/** Enable transmitter only, receiver disabled. */
|
|
leuartEnableTx = LEUART_CMD_TXEN,
|
|
|
|
/** Enable both receiver and transmitter. */
|
|
leuartEnable = (LEUART_CMD_RXEN | LEUART_CMD_TXEN)
|
|
} LEUART_Enable_TypeDef;
|
|
|
|
|
|
/** Parity selection. */
|
|
typedef enum
|
|
{
|
|
leuartNoParity = LEUART_CTRL_PARITY_NONE, /**< No parity. */
|
|
leuartEvenParity = LEUART_CTRL_PARITY_EVEN, /**< Even parity. */
|
|
leuartOddParity = LEUART_CTRL_PARITY_ODD /**< Odd parity. */
|
|
} LEUART_Parity_TypeDef;
|
|
|
|
|
|
/** Stopbits selection. */
|
|
typedef enum
|
|
{
|
|
leuartStopbits1 = LEUART_CTRL_STOPBITS_ONE, /**< 1 stopbits. */
|
|
leuartStopbits2 = LEUART_CTRL_STOPBITS_TWO /**< 2 stopbits. */
|
|
} LEUART_Stopbits_TypeDef;
|
|
|
|
|
|
/*******************************************************************************
|
|
******************************* STRUCTS ***********************************
|
|
******************************************************************************/
|
|
|
|
/** Init structure. */
|
|
typedef struct
|
|
{
|
|
/** Specifies whether TX and/or RX shall be enabled when init completed. */
|
|
LEUART_Enable_TypeDef enable;
|
|
|
|
/**
|
|
* LEUART reference clock assumed when configuring baudrate setup. Set
|
|
* it to 0 if currently configurated reference clock shall be used.
|
|
*/
|
|
uint32_t refFreq;
|
|
|
|
/** Desired baudrate. */
|
|
uint32_t baudrate;
|
|
|
|
/** Number of databits in frame. */
|
|
LEUART_Databits_TypeDef databits;
|
|
|
|
/** Parity mode to use. */
|
|
LEUART_Parity_TypeDef parity;
|
|
|
|
/** Number of stopbits to use. */
|
|
LEUART_Stopbits_TypeDef stopbits;
|
|
} LEUART_Init_TypeDef;
|
|
|
|
/** Default config for LEUART init structure. */
|
|
#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);
|
|
|
|
/***************************************************************************//**
|
|
* @brief
|
|
* Clear one or more pending LEUART interrupts.
|
|
*
|
|
* @param[in] leuart
|
|
* Pointer to LEUART peripheral register block.
|
|
*
|
|
* @param[in] flags
|
|
* Pending LEUART interrupt source to clear. Use a bitwise logic OR
|
|
* combination of valid interrupt flags for the LEUART module (LEUART_IF_nnn).
|
|
******************************************************************************/
|
|
__STATIC_INLINE void LEUART_IntClear(LEUART_TypeDef *leuart, uint32_t flags)
|
|
{
|
|
leuart->IFC = flags;
|
|
}
|
|
|
|
|
|
/***************************************************************************//**
|
|
* @brief
|
|
* Disable one or more LEUART interrupts.
|
|
*
|
|
* @param[in] leuart
|
|
* Pointer to LEUART peripheral register block.
|
|
*
|
|
* @param[in] flags
|
|
* LEUART interrupt sources to disable. Use a bitwise logic OR combination of
|
|
* valid interrupt flags for the LEUART module (LEUART_IF_nnn).
|
|
******************************************************************************/
|
|
__STATIC_INLINE void LEUART_IntDisable(LEUART_TypeDef *leuart, uint32_t flags)
|
|
{
|
|
leuart->IEN &= ~flags;
|
|
}
|
|
|
|
|
|
/***************************************************************************//**
|
|
* @brief
|
|
* Enable one or more LEUART interrupts.
|
|
*
|
|
* @note
|
|
* Depending on the use, a pending interrupt may already be set prior to
|
|
* enabling the interrupt. Consider using LEUART_IntClear() prior to enabling
|
|
* if such a pending interrupt should be ignored.
|
|
*
|
|
* @param[in] leuart
|
|
* Pointer to LEUART peripheral register block.
|
|
*
|
|
* @param[in] flags
|
|
* LEUART interrupt sources to enable. Use a bitwise logic OR combination of
|
|
* valid interrupt flags for the LEUART module (LEUART_IF_nnn).
|
|
******************************************************************************/
|
|
__STATIC_INLINE void LEUART_IntEnable(LEUART_TypeDef *leuart, uint32_t flags)
|
|
{
|
|
leuart->IEN |= flags;
|
|
}
|
|
|
|
|
|
/***************************************************************************//**
|
|
* @brief
|
|
* Get pending LEUART interrupt flags.
|
|
*
|
|
* @note
|
|
* The event bits are not cleared by the use of this function.
|
|
*
|
|
* @param[in] leuart
|
|
* Pointer to LEUART peripheral register block.
|
|
*
|
|
* @return
|
|
* LEUART interrupt sources pending. A bitwise logic OR combination of valid
|
|
* interrupt flags for the LEUART module (LEUART_IF_nnn).
|
|
******************************************************************************/
|
|
__STATIC_INLINE uint32_t LEUART_IntGet(LEUART_TypeDef *leuart)
|
|
{
|
|
return leuart->IF;
|
|
}
|
|
|
|
|
|
/***************************************************************************//**
|
|
* @brief
|
|
* Get enabled and pending LEUART interrupt flags.
|
|
* Useful for handling more interrupt sources in the same interrupt handler.
|
|
*
|
|
* @param[in] leuart
|
|
* Pointer to LEUART peripheral register block.
|
|
*
|
|
* @note
|
|
* Interrupt flags are not cleared by the use of this function.
|
|
*
|
|
* @return
|
|
* Pending and enabled LEUART interrupt sources.
|
|
* The return value is the bitwise AND combination of
|
|
* - the OR combination of enabled interrupt sources in LEUARTx_IEN_nnn
|
|
* register (LEUARTx_IEN_nnn) and
|
|
* - the OR combination of valid interrupt flags of the LEUART module
|
|
* (LEUARTx_IF_nnn).
|
|
******************************************************************************/
|
|
__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;
|
|
}
|
|
|
|
|
|
/***************************************************************************//**
|
|
* @brief
|
|
* Set one or more pending LEUART interrupts from SW.
|
|
*
|
|
* @param[in] leuart
|
|
* Pointer to LEUART peripheral register block.
|
|
*
|
|
* @param[in] flags
|
|
* LEUART interrupt sources to set to pending. Use a bitwise logic OR
|
|
* combination of valid interrupt flags for the LEUART module (LEUART_IF_nnn).
|
|
******************************************************************************/
|
|
__STATIC_INLINE void LEUART_IntSet(LEUART_TypeDef *leuart, uint32_t flags)
|
|
{
|
|
leuart->IFS = flags;
|
|
}
|
|
|
|
|
|
/***************************************************************************//**
|
|
* @brief
|
|
* Get LEUART STATUS register.
|
|
*
|
|
* @param[in] leuart
|
|
* Pointer to LEUART peripheral register block.
|
|
*
|
|
* @return
|
|
* STATUS register value.
|
|
*
|
|
******************************************************************************/
|
|
__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);
|
|
|
|
|
|
/***************************************************************************//**
|
|
* @brief
|
|
* Receive one 8 bit frame, (or part of a 9 bit frame).
|
|
*
|
|
* @details
|
|
* This function is used to quickly receive one 8 bit frame by reading the
|
|
* RXDATA register directly, without checking the STATUS register for the
|
|
* RXDATAV flag. This can be useful from the RXDATAV interrupt handler,
|
|
* i.e. waiting is superfluous, in order to quickly read the received data.
|
|
* Please refer to @ref LEUART_RxDataXGet() for reception of 9 bit frames.
|
|
*
|
|
* @note
|
|
* Since this function does not check whether the RXDATA register actually
|
|
* holds valid data, it should only be used in situations when it is certain
|
|
* that there is valid data, ensured by some external program routine, e.g.
|
|
* like when handling an RXDATAV interrupt. The @ref LEUART_Rx() is normally a
|
|
* better choice if the validity of the RXDATA register is not certain.
|
|
*
|
|
* @note
|
|
* Notice that possible parity/stop bits are not
|
|
* considered part of specified frame bit length.
|
|
*
|
|
* @param[in] leuart
|
|
* Pointer to LEUART peripheral register block.
|
|
*
|
|
* @return
|
|
* Data received.
|
|
******************************************************************************/
|
|
__STATIC_INLINE uint8_t LEUART_RxDataGet(LEUART_TypeDef *leuart)
|
|
{
|
|
return (uint8_t)leuart->RXDATA;
|
|
}
|
|
|
|
|
|
/***************************************************************************//**
|
|
* @brief
|
|
* Receive one 8-9 bit frame, with extended information.
|
|
*
|
|
* @details
|
|
* This function is used to quickly receive one 8-9 bit frame with extended
|
|
* information by reading the RXDATAX register directly, without checking the
|
|
* STATUS register for the RXDATAV flag. This can be useful from the RXDATAV
|
|
* interrupt handler, i.e. waiting is superfluous, in order to quickly read
|
|
* the received data.
|
|
*
|
|
* @note
|
|
* Since this function does not check whether the RXDATAX register actually
|
|
* holds valid data, it should only be used in situations when it is certain
|
|
* that there is valid data, ensured by some external program routine, e.g.
|
|
* like when handling an RXDATAV interrupt. The @ref LEUART_RxExt() is normally
|
|
* a better choice if the validity of the RXDATAX register is not certain.
|
|
*
|
|
* @note
|
|
* Notice that possible parity/stop bits are not
|
|
* considered part of specified frame bit length.
|
|
*
|
|
* @param[in] leuart
|
|
* Pointer to LEUART peripheral register block.
|
|
*
|
|
* @return
|
|
* Data received.
|
|
******************************************************************************/
|
|
__STATIC_INLINE uint16_t LEUART_RxDataXGet(LEUART_TypeDef *leuart)
|
|
{
|
|
return (uint16_t)leuart->RXDATAX;
|
|
}
|
|
|
|
|
|
/** @} (end addtogroup LEUART) */
|
|
/** @} (end addtogroup emlib) */
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* defined(LEUART_COUNT) && (LEUART_COUNT > 0) */
|
|
#endif /* EM_LEUART_H */
|