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; }