/************************************************************************************//** ** \brief Initializes the UART communication interface. ** \return none. ** ****************************************************************************************/ static void BootComUartInit(void) { LEUART_Init_TypeDef init = LEUART_INIT_DEFAULT; /* configure GPIO pins */ CMU_ClockEnable(cmuClock_GPIO, true); /* to avoid false start, configure output as high */ GPIO_PinModeSet(gpioPortC, 6, gpioModePushPull, 1); GPIO_PinModeSet(gpioPortC, 7, gpioModeInput, 0); /* enable CORE LE clock in order to access LE modules */ CMU_ClockEnable(cmuClock_CORELE, true); /* select LFXO for LEUARTs (and wait for it to stabilize) */ CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFXO); /* do not prescale clock */ CMU_ClockDivSet(cmuClock_LEUART1, cmuClkDiv_1); /* enable LEUART1 clock */ CMU_ClockEnable(cmuClock_LEUART1, true); /* configure LEUART */ init.enable = leuartDisable; LEUART_Init(LEUART1, &init); LEUART_BaudrateSet(LEUART1, 0, BOOT_COM_UART_BAUDRATE); /* enable pins at default location */ LEUART1->ROUTE = LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN; /* clear previous RX interrupts */ LEUART_IntClear(LEUART1, LEUART_IF_RXDATAV); /* finally enable it */ LEUART_Enable(LEUART1, leuartEnable); } /*** end of BootUartComInit ***/
static int efm32_uart_setup(struct uart *dev, const struct uart_params *params) { LEUART_TypeDef *leuart = (void *) dev->base_addr; LEUART_Init_TypeDef init = LEUART_INIT_DEFAULT; /* Enable CORE LE clock in order to access LE modules */ CMU_ClockEnable(cmuClock_HFPER, true); /* Enable CORE LE clock in order to access LE modules */ CMU_ClockEnable(cmuClock_GPIO, true); /* Enable CORE LE clock in order to access LE modules */ CMU_ClockEnable(cmuClock_CORELE, true); /* Select LFXO for LEUARTs (and wait for it to stabilize) */ CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFXO); CMU_ClockEnable(cmuClock_LEUART0, true); /* Do not prescale clock */ CMU_ClockDivSet(cmuClock_LEUART0, cmuClkDiv_1); /* Configure GPIO pin for UART TX */ /* To avoid false start, configure output as high. */ GPIO_PinModeSet( BSP_BCC_TXPORT, BSP_BCC_TXPIN, gpioModePushPull, 1 ); /* Configure GPIO pin for UART RX */ GPIO_PinModeSet( BSP_BCC_RXPORT, BSP_BCC_RXPIN, gpioModeInput, 1 ); /* Configure LEUART */ init.enable = leuartDisable; init.baudrate = 9600; LEUART_Init(leuart, &init); /* Enable the switch that enables UART communication. */ GPIO_PinModeSet( BSP_BCC_ENABLE_PORT, BSP_BCC_ENABLE_PIN, gpioModePushPull, 1 ); BSP_BCC_LEUART->ROUTE |= LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN | BSP_BCC_LOCATION; /* Finally enable it */ LEUART_Enable(leuart, leuartEnable); return 0; }
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"); }
/**************************************************************************//** * @brief UART/LEUART IRQ Handler *****************************************************************************/ void RETARGET_IRQ_NAME(void) { #if defined(RETARGET_USART) if (RETARGET_UART->STATUS & USART_STATUS_RXDATAV) { #else if (RETARGET_UART->IF & LEUART_IF_RXDATAV) { #endif /* Store Data */ rxBuffer[rxWriteIndex] = RETARGET_RX(RETARGET_UART); rxWriteIndex++; rxCount++; if (rxWriteIndex == RXBUFSIZE) { rxWriteIndex = 0; } /* Check for overflow - flush buffer */ if (rxCount > RXBUFSIZE) { rxWriteIndex = 0; rxCount = 0; rxReadIndex = 0; } } } /** @} (end group RetargetIo) */ /**************************************************************************//** * @brief UART/LEUART toggle LF to CRLF conversion * @param on If non-zero, automatic LF to CRLF conversion will be enabled *****************************************************************************/ void RETARGET_SerialCrLf(int on) { if (on) LFtoCRLF = 1; else LFtoCRLF = 0; } /**************************************************************************//** * @brief Intializes UART/LEUART *****************************************************************************/ void RETARGET_SerialInit(void) { /* Enable peripheral clocks */ CMU_ClockEnable(cmuClock_HFPER, true); /* Configure GPIO pins */ CMU_ClockEnable(cmuClock_GPIO, true); /* To avoid false start, configure output as high */ GPIO_PinModeSet(RETARGET_TXPORT, RETARGET_TXPIN, gpioModePushPull, 1); GPIO_PinModeSet(RETARGET_RXPORT, RETARGET_RXPIN, gpioModeInput, 0); #if defined(RETARGET_USART) USART_TypeDef *usart = RETARGET_UART; USART_InitAsync_TypeDef init = USART_INITASYNC_DEFAULT; /* Enable DK RS232/UART switch */ RETARGET_PERIPHERAL_ENABLE(); CMU_ClockEnable(RETARGET_CLK, true); /* Configure USART for basic async operation */ init.enable = usartDisable; USART_InitAsync(usart, &init); /* Enable pins at correct UART/USART location. */ #if defined( USART_ROUTEPEN_RXPEN ) usart->ROUTEPEN = USART_ROUTEPEN_RXPEN | USART_ROUTEPEN_TXPEN; usart->ROUTELOC0 = ( usart->ROUTELOC0 & ~( _USART_ROUTELOC0_TXLOC_MASK | _USART_ROUTELOC0_RXLOC_MASK ) ) | ( RETARGET_TX_LOCATION << _USART_ROUTELOC0_TXLOC_SHIFT ) | ( RETARGET_RX_LOCATION << _USART_ROUTELOC0_RXLOC_SHIFT ); #else usart->ROUTE = USART_ROUTE_RXPEN | USART_ROUTE_TXPEN | RETARGET_LOCATION; #endif /* Clear previous RX interrupts */ USART_IntClear(RETARGET_UART, USART_IF_RXDATAV); NVIC_ClearPendingIRQ(RETARGET_IRQn); /* Enable RX interrupts */ USART_IntEnable(RETARGET_UART, USART_IF_RXDATAV); NVIC_EnableIRQ(RETARGET_IRQn); /* Finally enable it */ USART_Enable(usart, usartEnable); #else LEUART_TypeDef *leuart = RETARGET_UART; LEUART_Init_TypeDef init = LEUART_INIT_DEFAULT; /* Enable DK LEUART/RS232 switch */ RETARGET_PERIPHERAL_ENABLE(); /* Enable CORE LE clock in order to access LE modules */ CMU_ClockEnable(cmuClock_CORELE, true); #if defined(RETARGET_VCOM) /* Select HFXO/2 for LEUARTs (and wait for it to stabilize) */ CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_CORELEDIV2); #else /* Select LFXO for LEUARTs (and wait for it to stabilize) */ CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFXO); #endif CMU_ClockEnable(RETARGET_CLK, true); /* Do not prescale clock */ CMU_ClockDivSet(RETARGET_CLK, cmuClkDiv_1); /* Configure LEUART */ init.enable = leuartDisable; #if defined(RETARGET_VCOM) init.baudrate = 115200; #endif LEUART_Init(leuart, &init); /* Enable pins at default location */ leuart->ROUTE = LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN | RETARGET_LOCATION; /* Clear previous RX interrupts */ LEUART_IntClear(RETARGET_UART, LEUART_IF_RXDATAV); NVIC_ClearPendingIRQ(RETARGET_IRQn); /* Enable RX interrupts */ LEUART_IntEnable(RETARGET_UART, LEUART_IF_RXDATAV); NVIC_EnableIRQ(RETARGET_IRQn); /* Finally enable it */ LEUART_Enable(leuart, leuartEnable); #endif #if !defined(__CROSSWORKS_ARM) && defined(__GNUC__) setvbuf(stdout, NULL, _IONBF, 0); /*Set unbuffered mode for stdout (newlib)*/ #endif initialized = true; }
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; }