RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2024-12-29 04:50:03 +01:00
Code Releases Activity

cpu/esp32: UART configuration approach changed

Browse Source 
UART devices are now configured using static array in header files instead of static variables in implementation to be able to define UART_NUMOF using the size of the array instead of a variable.
This commit is contained in:
Gunar Schorcht 2019-03-27 08:55:29 +01:00 committed by Schorcht
parent 9fc9ff2523
commit 3e79787bcc
2 changed files with 46 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
cpu/esp32/include/periph_cpu.h
View File

@ -423,25 +423,33 @@ extern const unsigned spi_bus_num;
* configuration and is always available. All ESP32 boards use it as standard * configuration and is always available. All ESP32 boards use it as standard
* configuration for the console. * configuration for the console.
* *
* UART_DEV(0).TXD GPIO1 * UART_DEV(0).TXD GPIO1
* UART_DEV(0).RXD GPIO3 * UART_DEV(0).RXD GPIO3
* *
* The pin configuration of UART_DEV(1) and UART_DEV(2) are defined in * The pin configuration of UART_DEV(1) and UART_DEV(2) are defined in
* board specific peripheral configuration by * board specific peripheral configuration by
* *
* UARTn_TXD, the GPIO used as TxD signal, and * - UARTn_TXD, the GPIO used as TxD signal, and
* UARTn_RXD, the GPIO used as RxD signal, * - UARTn_RXD, the GPIO used as RxD signal,
* *
* where n can be 2 or 3. If they are not defined, the UART interface * where n can be 1 or 2. If they are not defined, the according UART interface
* UART_DEV(n) is not used. * UART_DEV(n) is not used.
* *
* UART_NUMOF is determined automatically from the board-specific peripheral * UART_NUMOF is determined automatically from the board-specific peripheral
* definitions of UARTn_TXD and UARTn_RXD. * definitions of UARTn_*.
* *
* @{ * @{
*/ */
/** @} */
/**
* @brief UART configuration structure type
*/
typedef struct {
gpio_t txd; /**< GPIO used as TxD pin */
gpio_t rxd; /**< GPIO used as RxD pin */
} uart_conf_t;
/** @} */
#ifdef __cplusplus #ifdef __cplusplus
} }

74
cpu/esp32/periph/uart.c
View File

@ -74,8 +74,11 @@ static struct uart_hw_t _uarts[] = {
.data = UART_DATA_BITS_8, .data = UART_DATA_BITS_8,
.stop = UART_STOP_BITS_1, .stop = UART_STOP_BITS_1,
.parity = UART_PARITY_NONE, .parity = UART_PARITY_NONE,
.mod = PERIPH_UART0_MODULE,
.signal_txd = U0TXD_OUT_IDX, .signal_txd = U0TXD_OUT_IDX,
.signal_rxd = U0RXD_IN_IDX, .signal_rxd = U0RXD_IN_IDX,
.baudrate = STDIO_UART_BAUDRATE,
.used = false,
.int_src = ETS_UART0_INTR_SOURCE .int_src = ETS_UART0_INTR_SOURCE
}, },
#if defined(UART1_TXD) && defined(UART1_RXD) #if defined(UART1_TXD) && defined(UART1_RXD)
@ -87,8 +90,13 @@ static struct uart_hw_t _uarts[] = {
.data = UART_DATA_BITS_8, .data = UART_DATA_BITS_8,
.stop = UART_STOP_BITS_1, .stop = UART_STOP_BITS_1,
.parity = UART_PARITY_NONE, .parity = UART_PARITY_NONE,
{
.regs = &UART1,
.mod = PERIPH_UART1_MODULE,
.signal_txd = U1TXD_OUT_IDX, .signal_txd = U1TXD_OUT_IDX,
.signal_rxd = U1RXD_IN_IDX, .signal_rxd = U1RXD_IN_IDX,
.baudrate = STDIO_UART_BAUDRATE,
.used = false,
.int_src = ETS_UART1_INTR_SOURCE .int_src = ETS_UART1_INTR_SOURCE
}, },
#endif #endif
@ -101,11 +109,15 @@ static struct uart_hw_t _uarts[] = {
.data = UART_DATA_BITS_8, .data = UART_DATA_BITS_8,
.stop = UART_STOP_BITS_1, .stop = UART_STOP_BITS_1,
.parity = UART_PARITY_NONE, .parity = UART_PARITY_NONE,
{
.regs = &UART2,
.mod = PERIPH_UART2_MODULE,
.signal_txd = U2TXD_OUT_IDX, .signal_txd = U2TXD_OUT_IDX,
.signal_rxd = U2RXD_IN_IDX, .signal_rxd = U2RXD_IN_IDX,
.baudrate = STDIO_UART_BAUDRATE,
.used = false,
.int_src = ETS_UART2_INTR_SOURCE .int_src = ETS_UART2_INTR_SOURCE
} }
#endif
}; };
/* declaration of external functions */ /* declaration of external functions */
@ -131,30 +143,29 @@ int uart_init(uart_t uart, uint32_t baudrate, uart_rx_cb_t rx_cb, void *arg)
if (uart == UART_DEV(1) || uart == UART_DEV(2)) { if (uart == UART_DEV(1) || uart == UART_DEV(2)) {
/* reset the pins when they were already used as UART pins */ /* reset the pins when they were already used as UART pins */
if (gpio_get_pin_usage(_uarts[uart].pin_txd) == _UART) { if (gpio_get_pin_usage(uart_config[uart].txd) == _UART) {
gpio_set_pin_usage(_uarts[uart].pin_txd, _GPIO); gpio_set_pin_usage(uart_config[uart].txd, _GPIO);
} }
if (gpio_get_pin_usage(_uarts[uart].pin_rxd) == _UART) { if (gpio_get_pin_usage(uart_config[uart].rxd) == _UART) {
gpio_set_pin_usage(_uarts[uart].pin_rxd, _GPIO); gpio_set_pin_usage(uart_config[uart].rxd, _GPIO);
} }
/* try to initialize the pins as GPIOs first */ /* try to initialize the pins as GPIOs first */
if (gpio_init (_uarts[uart].pin_rxd, GPIO_IN) || if (gpio_init (uart_config[uart].rxd, GPIO_IN) ||
gpio_init (_uarts[uart].pin_txd, GPIO_OUT)) { gpio_init (uart_config[uart].txd, GPIO_OUT)) {
return -1; return -1;
} }
/* store the usage type in GPIO table */ /* store the usage type in GPIO table */
gpio_set_pin_usage(_uarts[uart].pin_txd, _UART); gpio_set_pin_usage(uart_config[uart].txd, _UART);
gpio_set_pin_usage(_uarts[uart].pin_rxd, _UART); gpio_set_pin_usage(uart_config[uart].rxd, _UART);
/* connect TxD pin to the TxD output signal through the GPIO matrix */ /* connect TxD pin to the TxD output signal through the GPIO matrix */
GPIO.func_out_sel_cfg[_uarts[uart].pin_txd].func_sel = _uarts[uart].signal_txd; GPIO.func_out_sel_cfg[uart_config[uart].txd].func_sel = _uarts[uart].signal_txd;
/* connect RxD input signal to the RxD pin through the GPIO matrix */ /* connect RxD input signal to the RxD pin through the GPIO matrix */
GPIO.func_in_sel_cfg[_uarts[uart].signal_rxd].sig_in_sel = 1; GPIO.func_in_sel_cfg[_uarts[uart].signal_rxd].sig_in_sel = 1;
GPIO.func_in_sel_cfg[_uarts[uart].signal_rxd].sig_in_inv = 0; GPIO.func_in_sel_cfg[_uarts[uart].signal_rxd].sig_in_inv = 0;
GPIO.func_in_sel_cfg[_uarts[uart].signal_rxd].func_sel = _uarts[uart].pin_rxd; GPIO.func_in_sel_cfg[_uarts[uart].signal_rxd].func_sel = uart_config[uart].rxd;
} }
_uarts[uart].baudrate = baudrate; _uarts[uart].baudrate = baudrate;
@ -187,40 +198,17 @@ void uart_write(uart_t uart, const uint8_t *data, size_t len)
void uart_poweron (uart_t uart) void uart_poweron (uart_t uart)
{ {
switch (uart) { CHECK_PARAM (uart < UART_NUMOF);
#if UART_NUMOF
case 0: periph_module_enable(PERIPH_UART0_MODULE); periph_module_enable(_uarts[uart].mod);
_uart_config(uart); _uart_config(uart);
break;
#endif
#if UART_NUMOF > 1
case 1: periph_module_enable(PERIPH_UART1_MODULE);
_uart_config(uart);
break;
#endif
#if UART_NUMOF > 2
case 2: periph_module_enable(PERIPH_UART2_MODULE);
_uart_config(uart);
break;
#endif
default: break;
}
} }
void uart_poweroff (uart_t uart) void uart_poweroff (uart_t uart)
{ {
switch (uart) { CHECK_PARAM (uart < UART_NUMOF);
#if UART_NUMOF
case 0: periph_module_disable(PERIPH_UART0_MODULE); break; periph_module_disable(_uarts[uart].mod);
#endif
#if UART_NUMOF > 1
case 1: periph_module_disable(PERIPH_UART1_MODULE); break;
#endif
#if UART_NUMOF > 2
case 2: periph_module_disable(PERIPH_UART2_MODULE); break;
#endif
default: break;
}
} }
/* systemwide UART initializations */ /* systemwide UART initializations */
@ -236,7 +224,7 @@ void uart_print_config(void)
{ {
for (unsigned uart = 0; uart < UART_NUMOF; uart++) { for (unsigned uart = 0; uart < UART_NUMOF; uart++) {
ets_printf("\tUART_DEV(%d)\ttxd=%d rxd=%d\n", uart, ets_printf("\tUART_DEV(%d)\ttxd=%d rxd=%d\n", uart,
_uarts[uart].pin_txd, _uarts[uart].pin_rxd); uart_config[uart].txd, uart_config[uart].rxd);
} }
} }