uart.c

Go to the documentation of this file.

/***************************************************************************/
/*
 * uart.c
 *
 *  Created on: Mar 8, 2020
 *      Author: jonac
 */
 
#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 "em_cmu.h"
#include "em_gpio.h"
#include "em_usart.h"
#include "bsp.h"
 
#include "debug_dbprint.h"
 
/* Declare a circular buffer structure to use for Rx and Tx queues */
#define BUFFERSIZE          256
 
volatile struct circularBuffer
{
  uint8_t  data[BUFFERSIZE];  /* data buffer */
  uint32_t rdI;               /* read index */
  uint32_t wrI;               /* write index */
  uint32_t pendingBytes;      /* count of how many bytes are not yet handled */
  bool     overflow;          /* buffer overflow indicator */
} rxBuf, txBuf = { {0}, 0, 0, 0, false };
 
static USART_InitAsync_TypeDef init = USART_INITASYNC_DEFAULT;
 
/**************************************************************************/
void uart_Init()
{
 
    // 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);
}
 
 
/****************************************************************************/
uint8_t uartGetChar( )
{
  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;
}
 
 
 
 
/****************************************************************************/
void uartPutChar(uint8_t ch)
{
  /* 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);
}
 
 
 
 
/****************************************************************************/
void uartPutData(uint8_t * dataPtr, uint32_t dataLen)
{
  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);
}
 
/****************************************************************************/
uint32_t uartGetData(uint8_t * dataPtr, uint32_t dataLen)
{
  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;
}
 
/**************************************************************************/
#if DEBUG_DBPRINT == 0 /* DEBUG_DBPRINT */
void USART1_RX_IRQHandler(void)
{
  /* 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;
    }
  }
}
#endif /* DEBUG_DBPRINT */
 
/**************************************************************************/
#if DEBUG_DBPRINT == 0 /* DEBUG_DBPRINT */
void USART1_TX_IRQHandler(void)
{
  /* 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);
    }
  }
}
#endif /* DEBUG_DBPRINT */