void serial_init(serial_t *obj, PinName tx, PinName rx)
{
uint32_t uart_tx = pinmap_peripheral(tx, PinMap_UART_TX);
uint32_t uart_rx = pinmap_peripheral(rx, PinMap_UART_RX);
obj->index = pinmap_merge(uart_tx, uart_rx);
MBED_ASSERT((int)obj->index != NC);
uart_config_t config;
UART_GetDefaultConfig(&config);
config.baudRate_Bps = 9600;
config.enableTx = false;
config.enableRx = false;
UART_Init(uart_addrs[obj->index], &config, CLOCK_GetFreq(uart_clocks[obj->index]));
pinmap_pinout(tx, PinMap_UART_TX);
pinmap_pinout(rx, PinMap_UART_RX);
if (tx != NC) {
UART_EnableTx(uart_addrs[obj->index], true);
pin_mode(tx, PullUp);
}
if (rx != NC) {
UART_EnableRx(uart_addrs[obj->index], true);
pin_mode(rx, PullUp);
}
if (obj->index == STDIO_UART) {
stdio_uart_inited = 1;
memcpy(&stdio_uart, obj, sizeof(serial_t));
}
}
/*!
* @brief Main function
*/
int main(void)
{
uart_config_t config;
BOARD_InitPins();
BOARD_BootClockRUN();
/*
* config.baudRate_Bps = 115200U;
* config.parityMode = kUART_ParityDisabled;
* config.stopBitCount = kUART_OneStopBit;
* config.txFifoWatermark = 0;
* config.rxFifoWatermark = 1;
* config.enableTx = false;
* config.enableRx = false;
*/
UART_GetDefaultConfig(&config);
config.baudRate_Bps = BOARD_DEBUG_UART_BAUDRATE;
config.enableTx = true;
config.enableRx = true;
UART_Init(DEMO_UART, &config, CLOCK_GetFreq(DEMO_UART_CLKSRC));
/* Send g_tipString out. */
UART_WriteBlocking(DEMO_UART, g_tipString, sizeof(g_tipString) / sizeof(g_tipString[0]));
/* Enable RX interrupt. */
UART_EnableInterrupts(DEMO_UART, kUART_RxDataRegFullInterruptEnable | kUART_RxOverrunInterruptEnable);
EnableIRQ(DEMO_UART_IRQn);
while (1)
{
/* Send data only when UART TX register is empty and ring buffer has data to send out. */
while ((kUART_TxDataRegEmptyFlag & UART_GetStatusFlags(DEMO_UART)) && (rxIndex != txIndex))
{
UART_WriteByte(DEMO_UART, demoRingBuffer[txIndex]);
txIndex++;
txIndex %= DEMO_RING_BUFFER_SIZE;
}
}
}
static int uart_mcux_init(struct device *dev)
{
const struct uart_mcux_config *config = dev->config->config_info;
uart_config_t uart_config;
u32_t clock_freq;
clock_freq = CLOCK_GetFreq(config->clock_source);
UART_GetDefaultConfig(&uart_config);
uart_config.enableTx = true;
uart_config.enableRx = true;
uart_config.baudRate_Bps = config->baud_rate;
UART_Init(config->base, &uart_config, clock_freq);
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
config->irq_config_func(dev);
#endif
return 0;
}
int
hal_uart_config(int port, int32_t speed, uint8_t databits, uint8_t stopbits,
enum hal_uart_parity parity, enum hal_uart_flow_ctl flow_ctl)
{
struct hal_uart *u;
uart_config_t uconfig;
if (port >= FSL_FEATURE_SOC_UART_COUNT) {
return -1;
}
u = &uarts[port];
if (!u->u_configured || u->u_open) {
return -1;
}
/* PIN config (all UARTs use kPORT_MuxAlt3) */
CLOCK_EnableClock(u->p_clock);
PORT_SetPinMux(u->p_base, u->u_pin_rx, kPORT_MuxAlt3);
PORT_SetPinMux(u->p_base, u->u_pin_tx, kPORT_MuxAlt3);
/* UART CONFIG */
UART_GetDefaultConfig(&uconfig);
uconfig.baudRate_Bps = speed;
/* TODO: only handles 8 databits currently */
switch (stopbits) {
case 1:
uconfig.stopBitCount = kUART_OneStopBit;
break;
case 2:
uconfig.stopBitCount = kUART_TwoStopBit;
break;
default:
return -1;
}
switch (parity) {
case HAL_UART_PARITY_NONE:
uconfig.parityMode = kUART_ParityDisabled;
break;
case HAL_UART_PARITY_ODD:
uconfig.parityMode = kUART_ParityOdd;
break;
case HAL_UART_PARITY_EVEN:
uconfig.parityMode = kUART_ParityEven;
break;
}
/* TODO: HW flow control not supported */
assert(flow_ctl == HAL_UART_FLOW_CTL_NONE);
u->u_open = 1;
u->u_tx_started = 0;
NVIC_SetVector(u->u_irq, (uint32_t)s_uartirqs[port]);
/* Initialize UART device */
UART_Init(u->u_base, &uconfig, CLOCK_GetFreq(u->clk_src));
UART_EnableTx(u->u_base, true);
UART_EnableRx(u->u_base, true);
UART_EnableInterrupts(u->u_base,
kUART_RxDataRegFullInterruptEnable |
kUART_RxOverrunInterruptEnable);
EnableIRQ(u->u_irq);
return 0;
}
void USB_UartGetDefaultConfiguratoion(usb_uartConfiguration *configuration)
{
UART_GetDefaultConfig(configuration);
}
