/************************************************************************************//**
** \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 ***/
/*
*Function name: LEUART0_IRQHandler
*Description : Interrupt Service Routine for LEUART0.
*/
void LEUART0_IRQHandler(void)
{
leuartif = LEUART_IntGet(LEUART0); // Store the interrupt flag
LEUART_IntClear(LEUART0, leuartif); //Clear interrupts
if (leuartif & LEUART_IF_SIGF)
{
int temp = 0, i = 0;
char tempChar[7]; // To store the Value of Temperature in char to transmit
char temp_string[TX_bufferSize]; // Concatenated string for Message and Temperature, this will be transfered
char copyCmp[sizeof(commandString)/sizeof(char)]; // string to store the Received string from Buffer to compare
// Stop the LEUART reception and DMA Transfers
for (i = 0; i < (strlen(commandString)); i++) // Run loop till the return message (RetTemp!) length and copy RX buffer to copyCmp for comparing
{
copyCmp[i] = RX_Buffer[i];
}
copyCmp[8]='\0';
/* To extract the digits of the temperature variable and put in tempChar. A basic digit extraction algorithm is used and then each digit is passed one by one. */
if (!strcmp(commandString,copyCmp)) // If valid Command is Received ie RetTemp!
{
temp = temperature*10;
tempChar[0] = (temp/100)+48;
temp = temp%100;
tempChar[1] = (temp/10)+48;
temp = temp%10;
tempChar[2] = '.';
tempChar[3] = (temp)+48;
tempChar[4] = 'C';
tempChar[5] = '\r';
tempChar[6] = '\n';
strcpy(temp_string,returnMsg); //Copy the returnMsg message in the temporary string
strcat(temp_string,tempChar); // Concatenate with tempChar to get the final message to be transfered
// Enable DMA wake-up from LEUART0 TX
LEUART0->CTRL = LEUART_CTRL_TXDMAWU; // Enable DMA wake up for LEUART TX in EM2
// Activate DMA for LEUART TX transfers
DMA_ActivateBasic(DMA_CHANNEL_TX, true, false, (void *)&(LEUART0->TXDATA), (void *)temp_string, strlen(temp_string)- 1); // -1 for the Null character which we wont transmit
}
else
{
LEUART0->CTRL = LEUART_CTRL_TXDMAWU; // Enable DMA wake up for LEUART0 TX in EM2
// Activate DMA for LEUART TX transfers
DMA_ActivateBasic(DMA_CHANNEL_TX, true, false, (void *)&(LEUART0->TXDATA), (void *)errorMsg, strlen(errorMsg)-2); // -1 for the Null character which we wont transmit
}
LEUART_IntEnable(LEUART0, LEUART_IF_RXDATAV); //Enable RXDATA Interrupt to check for received characters
DMA_ActivateBasic(DMA_CHANNEL_RX, true, false, NULL, NULL, LEUART0_BUFFER-1);
}
else if (leuartif & LEUART_IF_RXDATAV)
{
LEUART_IntDisable(LEUART0, LEUART_IF_RXDATAV); // Disable after receiving
}
}
void LEUART0_IRQHandler(void)
{
uint32_t flags = LEUART_IntGet(LEUART0);
LEUART_IntClear(LEUART0, flags);
if (flags & LEUART_IF_SIGF)
{
DMADRV_StopTransfer(dmaChannel);
xSemaphoreGiveFromISR(lineEndReceived, NULL);
}
portEND_SWITCHING_ISR(NULL);
}
/**************************************************************************//**
* @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;
}
