uart.c File Reference

UART communication with BLE. More...

#include <uart.h>
#include "em_usart.h"
#include "pinout.h"
#include "em_cmu.h"
#include "em_gpio.h"
#include "ble.h"
#include <stdint.h>
#include "em_device.h"
#include "em_chip.h"
#include "em_emu.h"
#include "bsp.h"
#include "debug_dbprint.h"

Include dependency graph for uart.c:

Go to the source code of this file.

Data Structures
struct	circularBuffer

Macros
#define	BUFFERSIZE   256

Functions
void	uart_Init ()
	UART init. More...
uint8_t	uartGetChar ()
	uartGetChar function More...
void	uartPutChar (uint8_t ch)
	uartPutChar function More...
void	uartPutData (uint8_t *dataPtr, uint32_t dataLen)
	uartPutData function More...
uint32_t	uartGetData (uint8_t *dataPtr, uint32_t dataLen)
	uartGetData function More...
void	USART1_RX_IRQHandler (void)
	UART1 RX IRQ Handler. More...
void	USART1_TX_IRQHandler (void)
	UART1 TX IRQ Handler. More...

Variables
volatile struct circularBuffer	rxBuf
volatile struct circularBuffer	txBuf = { {0}, 0, 0, 0, false }

Detailed Description

UART communication with BLE.

Version

1.0

Author

Jona Cappelle

Definition in file uart.c.

Macro Definition Documentation

BUFFERSIZE

#define BUFFERSIZE   256

Definition at line 35 of file uart.c.

Function Documentation

uart_Init()

void uart_Init

(

)

UART init.

Inspired by Silabs demo code

Definition at line 57 of file uart.c.

{
 
    // Enable oscillator to GPIO and USART1 modules
    CMU_ClockEnable(cmuClock_HFPER, true);
    CMU_ClockEnable(cmuClock_GPIO, true);
    CMU_ClockEnable(cmuClock_USART1, true);
 
    // set pin modes for UART TX and RX pins
    GPIO_PinModeSet(BLE_PORT, BLE_PIN_RX, gpioModeInput, 0);
    GPIO_PinModeSet(BLE_PORT, BLE_PIN_TX, gpioModePushPull, 1);
 
    // Initialize USART asynchronous mode and route pins
    USART_InitAsync(BLE_USART, &init);
 
    /* Prepare UART Rx and Tx interrupts */
    USART_IntClear(BLE_USART, _USART_IFC_MASK);
    USART_IntEnable(BLE_USART, USART_IEN_RXDATAV);
    NVIC_ClearPendingIRQ(USART1_RX_IRQn);
    NVIC_ClearPendingIRQ(USART1_TX_IRQn);
    NVIC_EnableIRQ(USART1_RX_IRQn);
    NVIC_EnableIRQ(USART1_TX_IRQn);
 
    BLE_USART->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC0;
 
      /* Enable UART */
    USART_Enable(BLE_USART, usartEnable);
}

References BLE_PIN_RX, BLE_PIN_TX, BLE_PORT, and BLE_USART.

Referenced by BLE_Init().

uartGetChar()

uint8_t uartGetChar

(

)

uartGetChar function

Note that if there are no pending characters in the receive buffer, this function will hang until a character is received.

Definition at line 94 of file uart.c.

{
  uint8_t ch;
 
  /* Check if there is a byte that is ready to be fetched. If no byte is ready, wait for incoming data */
  if (rxBuf.pendingBytes < 1)
  {
    while (rxBuf.pendingBytes < 1) ;
  }
 
  /* Copy data from buffer */
  ch        = rxBuf.data[rxBuf.rdI];
  rxBuf.rdI = (rxBuf.rdI + 1) % BUFFERSIZE;
 
  /* Decrement pending byte counter */
  rxBuf.pendingBytes--;
 
  return ch;
}

References BUFFERSIZE, circularBuffer::data, circularBuffer::pendingBytes, circularBuffer::rdI, and rxBuf.

uartGetData()

uint32_t uartGetData	(	uint8_t *	dataPtr,
		uint32_t	dataLen
	)

uartGetData function

Definition at line 185 of file uart.c.

{
  uint32_t i = 0;
 
  /* Wait until the requested number of bytes are available */
  if (rxBuf.pendingBytes < dataLen)
  {
    while (rxBuf.pendingBytes < dataLen) ;
  }
 
  if (dataLen == 0)
  {
    dataLen = rxBuf.pendingBytes;
  }
 
  /* Copy data from Rx buffer to dataPtr */
  while (i < dataLen)
  {
    *(dataPtr + i) = rxBuf.data[rxBuf.rdI];
    rxBuf.rdI      = (rxBuf.rdI + 1) % BUFFERSIZE;
    i++;
  }
 
  /* Decrement pending byte counter */
  rxBuf.pendingBytes -= dataLen;
 
  return i;
}

References BUFFERSIZE, circularBuffer::data, circularBuffer::pendingBytes, circularBuffer::rdI, and rxBuf.

Referenced by BLE_readData().

uartPutChar()

void uartPutChar

(

uint8_t

ch

)

uartPutChar function

Definition at line 121 of file uart.c.

{
  /* Check if Tx queue has room for new data */
  if ((txBuf.pendingBytes + 1) > BUFFERSIZE)
  {
    /* Wait until there is room in queue */
    while ((txBuf.pendingBytes + 1) > BUFFERSIZE) ;
  }
 
  /* Copy ch into txBuffer */
  txBuf.data[txBuf.wrI] = ch;
  txBuf.wrI             = (txBuf.wrI + 1) % BUFFERSIZE;
 
  /* Increment pending byte counter */
  txBuf.pendingBytes++;
 
  /* Enable interrupt on USART TX Buffer*/
  USART_IntEnable(BLE_USART, USART_IEN_TXBL);
}

References BLE_USART, BUFFERSIZE, circularBuffer::data, circularBuffer::pendingBytes, txBuf, and circularBuffer::wrI.

uartPutData()

void uartPutData	(	uint8_t *	dataPtr,
		uint32_t	dataLen
	)

uartPutData function

Definition at line 148 of file uart.c.

{
  uint32_t i = 0;
 
  /* Check if buffer is large enough for data */
  if (dataLen > BUFFERSIZE)
  {
    /* Buffer can never fit the requested amount of data */
    return;
  }
 
  /* Check if buffer has room for new data */
  if ((txBuf.pendingBytes + dataLen) > BUFFERSIZE)
  {
    /* Wait until room */
    while ((txBuf.pendingBytes + dataLen) > BUFFERSIZE) ;
  }
 
  /* Fill dataPtr[0:dataLen-1] into txBuffer */
  while (i < dataLen)
  {
    txBuf.data[txBuf.wrI] = *(dataPtr + i);
    txBuf.wrI             = (txBuf.wrI + 1) % BUFFERSIZE;
    i++;
  }
 
  /* Increment pending byte counter */
  txBuf.pendingBytes += dataLen;
 
  /* Enable interrupt on USART TX Buffer*/
  USART_IntEnable(BLE_USART, USART_IEN_TXBL);
}

References BLE_USART, BUFFERSIZE, circularBuffer::data, circularBuffer::pendingBytes, txBuf, and circularBuffer::wrI.

Referenced by BLE_sendData(), and BLE_set_output_power().

USART1_RX_IRQHandler()

void USART1_RX_IRQHandler

(

void

)

UART1 RX IRQ Handler.

Set up the interrupt prior to use

Note that this function handles overflows in a very simple way.

Definition at line 223 of file uart.c.

{
  /* Check for RX data valid interrupt */
  if (BLE_USART->IF & USART_IF_RXDATAV)
  {
    /* Copy data into RX Buffer */
    uint8_t rxData = USART_Rx(BLE_USART);
    rxBuf.data[rxBuf.wrI] = rxData;
    rxBuf.wrI             = (rxBuf.wrI + 1) % BUFFERSIZE;
    rxBuf.pendingBytes++;
 
    /* Flag Rx overflow */
    if (rxBuf.pendingBytes > BUFFERSIZE)
    {
      rxBuf.overflow = true;
    }
  }
}

References BLE_USART, BUFFERSIZE, circularBuffer::data, circularBuffer::overflow, circularBuffer::pendingBytes, rxBuf, and circularBuffer::wrI.

USART1_TX_IRQHandler()

void USART1_TX_IRQHandler

(

void

)

UART1 TX IRQ Handler.

Set up the interrupt prior to use

Definition at line 250 of file uart.c.

{
  /* Check TX buffer level status */
  if (BLE_USART->IF & USART_IF_TXBL)
  {
    if (txBuf.pendingBytes > 0)
    {
      /* Transmit pending character */
      USART_Tx(BLE_USART, txBuf.data[txBuf.rdI]);
      txBuf.rdI = (txBuf.rdI + 1) % BUFFERSIZE;
      txBuf.pendingBytes--;
    }
 
    /* Disable Tx interrupt if no more bytes in queue */
    if (txBuf.pendingBytes == 0)
    {
      USART_IntDisable(BLE_USART, USART_IEN_TXBL);
    }
  }
}

References BLE_USART, BUFFERSIZE, circularBuffer::data, circularBuffer::pendingBytes, circularBuffer::rdI, and txBuf.

Variable Documentation

rxBuf

volatile struct circularBuffer rxBuf

Referenced by uartGetChar(), uartGetData(), and USART1_RX_IRQHandler().

txBuf

volatile struct circularBuffer txBuf = { {0}, 0, 0, 0, false }

Referenced by uartPutChar(), uartPutData(), and USART1_TX_IRQHandler().