static void leuartInit(void)
{
LEUART_Init_TypeDef leuart0Init;
leuart0Init.enable = leuartEnable; /* Activate data reception on LEUn_TX pin. */
leuart0Init.refFreq = 0; /* Inherit the clock frequenzy from the LEUART clock source */
leuart0Init.baudrate = LEUART0_BAUDRATE; /* Baudrate = 9600 bps */
leuart0Init.databits = leuartDatabits8; /* Each LEUART frame containes 8 databits */
leuart0Init.parity = leuartNoParity; /* No parity bits in use */
leuart0Init.stopbits = leuartStopbits2; /* Setting the number of stop bits in a frame to 2 bitperiods */
CMU_ClockEnable(cmuClock_CORELE, true);
CMU_ClockEnable(cmuClock_LEUART0, true);
LEUART_Reset(LEUART0);
LEUART_Init(LEUART0, &leuart0Init);
LEUART0->SIGFRAME = '\n';
/* Enable LEUART Signal Frame Interrupt */
LEUART_IntEnable(LEUART0, LEUART_IEN_SIGF);
/* Enable LEUART0 interrupt vector */
NVIC_SetPriority(LEUART0_IRQn, LEUART0_INT_PRIORITY);
LEUART0->ROUTE = LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN | LEUART0_LOCATION;
GPIO_PinModeSet(LEUART0_PORT, LEUART0_TX, gpioModePushPull, 1);
GPIO_PinModeSet(LEUART0_PORT, LEUART0_RX, gpioModeInputPull, 1);
lineEndReceived = xSemaphoreCreateBinary();
DMADRV_AllocateChannel(&dmaChannel, NULL);
}
void initLeuart(void)
{
static uint8_t leu_raw_tx_buf[300];
static uint8_t leu_raw_rx_buf[300];
leu_tx_buf = init_buf(leu_raw_tx_buf, sizeof(leu_raw_tx_buf));
leu_rx_buf = init_buf(leu_raw_rx_buf, sizeof(leu_raw_rx_buf));
CMU_ClockEnable(cmuClock_CORELE, true);
CMU_ClockEnable(cmuClock_GPIO, true);
CMU_ClockEnable(cmuClock_LEUART0, true);
LEUART_Reset(LEUART0);
LEUART_Init(LEUART0, &leuart0Init);
LEUART0->ROUTE = LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN | LEUART_ROUTE_LOCATION_LOC0;
/* Enable GPIO for LEUART0. RX is on D5 */
GPIO_PinModeSet(gpioPortD, /* Port */
5, /* Port number */
gpioModeInputPull, /* Pin mode is set to input only, with pull direction given bellow */
1); /* Pull direction is set to pull-up */
/* Enable GPIO for LEUART0. TX is on D4 */
GPIO_PinModeSet(gpioPortD, /* GPIO port */
4, /* GPIO port number */
gpioModePushPull, /* Pin mode is set to push pull */
1); /* High idle state */
LEUART0->IEN = LEUART_IF_RXDATAV; // enable RX interrupt
NVIC_EnableIRQ(LEUART0_IRQn);
}
/**************************************************************************//**
* @brief Deinitialize board controller communication support (BCC)
* functionality. Reverse actions performed by @ref BSP_BccInit().
*
* @return @ref BSP_STATUS_OK.
*****************************************************************************/
int BSP_BccDeInit( void )
{
/* Reset counters */
rxByteCount = 0xFFFFFFFFUL;
txByteCount = 0xFFFFFFFFUL;
BSP_BccPinsEnable( false );
#if defined( BSP_BCC_LEUART )
/* Reset LEUART */
LEUART_Reset( BSP_BCC_LEUART );
#else
/* Reset USART */
USART_Reset( BSP_BCC_USART );
#endif
/* Disable clock */
CMU_ClockEnable( BSP_BCC_CLK, false );
return BSP_STATUS_OK;
}
void debug_init ()
{
GPIO_PinModeSet(PORT_SPK, PIN_SPK, gpioModePushPull, 0);
LEUART_Init_TypeDef init = LEUART_INIT_DEFAULT;
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_GPIO, true);
CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFXO);
CMU_ClockDivSet(cmuClock_LEUART0, cmuClkDiv_1);
CMU_ClockEnable(cmuClock_LEUART0, true);
init.refFreq = 0; //14MHz / 2 pre-scaled by 4 = 1750000;
init.enable = leuartDisable;
init.baudrate = 9600;
init.databits = leuartDatabits8;
init.parity = leuartNoParity;
init.stopbits = leuartStopbits1;
// Reseting and initializing LEUART0
LEUART_Reset(LEUART0);
LEUART_Init(LEUART0, &init);
GPIO_PinModeSet(PORT_TXD, PIN_TXD, gpioModePushPull, 1);
GPIO_PinModeSet(PORT_RXD, PIN_RXD, gpioModeInput, 0);
LEUART0->ROUTE = LEUART_ROUTE_TXPEN | LEUART_ROUTE_RXPEN | LEUART_ROUTE_LOCATION_LOC0;
LEUART0->CMD = LEUART_CMD_TXDIS | LEUART_CMD_RXDIS | LEUART_CMD_CLEARTX | LEUART_CMD_CLEARRX;
LEUART0->CMD = LEUART_CMD_TXEN | LEUART_CMD_RXEN;
// Eventually enable UART
LEUART_Enable(LEUART0, leuartEnable);
// print banner
debug_str("\r\n============= DEBUG STARTED =============\r\n");
}
int uart_init_blocking(uart_t _uart, uint32_t baudrate)
{
#if UART_0_EN || UART_1_EN
USART_TypeDef *uart;
USART_InitAsync_TypeDef uartInit = USART_INITASYNC_DEFAULT;
#endif
#if UART_2_EN
LEUART_Init_TypeDef leuartInit;
#endif
switch(_uart) {
#if UART_0_EN
case UART_0:
uart = UART_0_DEV;
/* Enabling clock to USART0 */
CMU_ClockEnable(cmuClock_USART0, true);
/* Output PIN */
gpio_init(GPIO_T(UART_0_PORT, UART_0_TX_PIN), GPIO_DIR_PUSH_PULL,
GPIO_PULLUP);
gpio_init(GPIO_T(UART_0_PORT, UART_0_RX_PIN), GPIO_DIR_INPUT,
GPIO_PULLDOWN);
/* Prepare struct for initializing UART in asynchronous mode*/
uartInit.enable = usartDisable; /* Don't enable UART upon intialization */
uartInit.refFreq = 0; /* Provide information on reference frequency.
When set to 0, the reference frequency is */
uartInit.baudrate = baudrate; /* Baud rate */
uartInit.oversampling = usartOVS16; /* Oversampling. Range is 4x, 6x, 8x or 16x */
uartInit.databits = usartDatabits8; /* Number of data bits. Range is 4 to 10 */
uartInit.parity = usartNoParity; /* Parity mode */
uartInit.stopbits = usartStopbits1; /* Number of stop bits. Range is 0 to 2 */
uartInit.mvdis = false; /* Disable majority voting */
uartInit.prsRxEnable = false; /* Enable USART Rx via Peripheral Reflex System */
uartInit.prsRxCh = usartPrsRxCh0; /* Select PRS channel if enabled */
/* Initialize USART with uartInit struct */
USART_InitAsync(uart, &uartInit);
uart->ROUTE = UART_ROUTE_RXPEN | UART_ROUTE_TXPEN | UART_0_LOC;
USART_Enable(UART_0_DEV, usartEnable);
break;
#endif
#if UART_1_EN
case UART_1:
uart = UART_1_DEV;
/* Enabling clock to USART0 */
uart = UART_1_DEV;
CMU_ClockEnable(cmuClock_USART1, true);
/* Output PIN */
gpio_init(GPIO_T(UART_1_PORT, UART_1_TX_PIN), GPIO_DIR_PUSH_PULL,
GPIO_PULLUP);
gpio_init(GPIO_T(UART_1_PORT, UART_1_RX_PIN), GPIO_DIR_INPUT,
GPIO_PULLDOWN);
/* Prepare struct for initializing UART in asynchronous mode*/
uartInit.enable = usartDisable; /* Don't enable UART upon intialization */
uartInit.refFreq = 0; /* Provide information on reference frequency.
When set to 0, the reference frequency is */
uartInit.baudrate = baudrate; /* Baud rate */
uartInit.oversampling = usartOVS16; /* Oversampling. Range is 4x, 6x, 8x or 16x */
uartInit.databits = usartDatabits8; /* Number of data bits. Range is 4 to 10 */
uartInit.parity = usartNoParity; /* Parity mode */
uartInit.stopbits = usartStopbits1; /* Number of stop bits. Range is 0 to 2 */
uartInit.mvdis = false; /* Disable majority voting */
uartInit.prsRxEnable = false; /* Enable USART Rx via Peripheral Reflex System */
uartInit.prsRxCh = usartPrsRxCh0; /* Select PRS channel if enabled */
/* Initialize USART with uartInit struct */
USART_InitAsync(uart, &uartInit);
uart->ROUTE = UART_ROUTE_RXPEN | UART_ROUTE_TXPEN | UART_1_LOC;
USART_Enable(UART_1_DEV, usartEnable);
break;
#endif
#if UART_2_EN
case UART_2:
CMU_ClockEnable(cmuClock_LEUART0, true);
gpio_init(GPIO_T(UART_2_PORT, UART_2_TX_PIN), GPIO_DIR_PUSH_PULL,
GPIO_PULLUP);
gpio_init(GPIO_T(UART_2_PORT, UART_2_RX_PIN), GPIO_DIR_INPUT,
GPIO_PULLDOWN);
LEUART_Reset(UART_2_DEV);
leuartInit.enable = leuartEnable;
leuartInit.baudrate = baudrate;
leuartInit.databits = leuartDatabits8;
leuartInit.parity = leuartNoParity;
leuartInit.stopbits = leuartStopbits1;
leuartInit.refFreq = 0;
LEUART_Init(UART_2_DEV, &leuartInit);
UART_2_DEV->ROUTE =
LEUART_ROUTE_TXPEN | LEUART_ROUTE_RXPEN | UART_2_LOC;
LEUART_Enable(UART_2_DEV, usartEnable);
break;
#endif
default:
return -1;
}
return 0;
}
static int
leuart_configure (sBSPACMperiphUARTstate * usp,
const sBSPACMperiphUARTconfiguration * cfgp)
{
LEUART_TypeDef * leuart;
const sBSPACMdeviceEFM32periphLEUARTdevcfg * devcfgp;
if (! (usp && usp->uart)) {
return -1;
}
leuart = (LEUART_TypeDef *)usp->uart;
devcfgp = (const sBSPACMdeviceEFM32periphLEUARTdevcfg *)usp->devcfg.ptr;
/* Configure LFB's source, enable the low-energy peripheral clock, and the clock for the
* leuart itself */
if (cfgp) {
/* LFB is required for LEUART. Power-up is LFRCO which doesn't
* work so good; if we were told a source to use, override
* whatever was there. */
if (devcfgp->lfbsel) {
CMU_ClockSelectSet(cmuClock_LFB, devcfgp->lfbsel);
}
CMU_ClockEnable(cmuClock_CORELE, true);
CMU_ClockEnable(devcfgp->common.clock, true);
} else {
NVIC_DisableIRQ(devcfgp->irqn);
NVIC_ClearPendingIRQ(devcfgp->irqn);
}
LEUART_Reset(leuart);
leuart->FREEZE = LEUART_FREEZE_REGFREEZE;
leuart->CMD = LEUART_CMD_RXDIS | LEUART_CMD_TXDIS;
if (usp->rx_fifo_ni_) {
fifo_reset(usp->rx_fifo_ni_);
}
if (usp->tx_fifo_ni_) {
fifo_reset(usp->tx_fifo_ni_);
}
usp->tx_state_ = 0;
if (cfgp) {
unsigned int speed_baud = cfgp->speed_baud;
if (0 == speed_baud) {
speed_baud = 9600;
}
/* Configure the LEUART for rate at 8N1. */
leuart->CTRL = LEUART_CTRL_DATABITS_EIGHT | LEUART_CTRL_PARITY_NONE | LEUART_CTRL_STOPBITS_ONE;
LEUART_BaudrateSet(leuart, 0, speed_baud);
CMU_ClockEnable(cmuClock_GPIO, true);
}
/* Enable or disable UART pins. To avoid false start, when enabling
* configure TX as high. This relies on a comment in the EMLIB code
* that manipulating registers of disabled modules has no effect
* (unlike TM4C where it causes a HardFault). We'll see. */
vBSPACMdeviceEFM32pinmuxConfigure(&devcfgp->common.rx_pinmux, !!cfgp, 1);
vBSPACMdeviceEFM32pinmuxConfigure(&devcfgp->common.tx_pinmux, !!cfgp, 0);
if (cfgp) {
leuart->ROUTE = LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN | devcfgp->common.location;
/* Clear and enable RX interrupts at the device. Device TX
* interrupts are enabled at the peripheral when there's something
* to transmit. Clear then enable interrupts at the NVIC. */
leuart->IFC = _LEUART_IF_MASK;
leuart->IEN = LEUART_IF_RXDATAV;
NVIC_ClearPendingIRQ(devcfgp->irqn);
NVIC_EnableIRQ(devcfgp->irqn);
/* Configuration complete; enable the LEUART, and release the
* registers to synchronize. */
leuart->CMD = LEUART_CMD_RXEN | LEUART_CMD_TXEN;
leuart->FREEZE = 0;
} else {
CMU_ClockEnable(devcfgp->common.clock, false);
}
return 0;
}
