void uart6_init( void ) {
uart_periph_init(&uart6);
uart6.reg_addr = (void *)USART6;
/* enable uart clock */
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_USART6EN);
/* init RCC and GPIOs */
#if USE_UART6_TX
gpio_setup_pin_af(UART6_GPIO_PORT_TX, UART6_GPIO_TX, UART6_GPIO_AF, TRUE);
#endif
#if USE_UART6_RX
gpio_setup_pin_af(UART6_GPIO_PORT_RX, UART6_GPIO_RX, UART6_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART6_IRQ);
#if UART6_HW_FLOW_CONTROL
#warning "USING UART6 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS pins */
gpio_setup_pin_af(UART6_GPIO_PORT_CTS, UART6_GPIO_CTS, UART6_GPIO_AF, FALSE);
gpio_setup_pin_af(UART6_GPIO_PORT_RTS, UART6_GPIO_RTS, UART6_GPIO_AF, TRUE);
#endif
/* Configure USART Tx,Rx and hardware flow control*/
uart_periph_set_mode(&uart6, USE_UART6_TX, USE_UART6_RX, UART6_HW_FLOW_CONTROL);
uart_periph_set_baudrate(&uart6, UART6_BAUD);
}
void uart3_init( void ) {
uart_periph_init(&uart3);
uart3.reg_addr = (void *)USART3;
/* init RCC */
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_USART3EN);
#if USE_UART3_TX
gpio_setup_pin_af(UART3_GPIO_PORT_TX, UART3_GPIO_TX, UART3_GPIO_AF, TRUE);
#endif
#if USE_UART3_RX
gpio_setup_pin_af(UART3_GPIO_PORT_RX, UART3_GPIO_RX, UART3_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART3_IRQ);
#if UART3_HW_FLOW_CONTROL && defined(STM32F4)
#warning "USING UART3 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS pins */
gpio_setup_pin_af(UART3_GPIO_PORT_CTS, UART3_GPIO_CTS, UART3_GPIO_AF, FALSE);
gpio_setup_pin_af(UART3_GPIO_PORT_RTS, UART3_GPIO_RTS, UART3_GPIO_AF, TRUE);
#endif
/* Configure USART Tx,Rx, and hardware flow control*/
uart_periph_set_mode(&uart3, USE_UART3_TX, USE_UART3_RX, UART3_HW_FLOW_CONTROL);
/* Configure USART */
uart_periph_set_baudrate(&uart3, UART3_BAUD);
}
void uart1_init(void)
{
uart_periph_init(&uart1);
uart1.reg_addr = (void *)USART1;
/* init RCC and GPIOs */
rcc_periph_clock_enable(RCC_USART1);
#if USE_UART1_TX
gpio_setup_pin_af(UART1_GPIO_PORT_TX, UART1_GPIO_TX, UART1_GPIO_AF, TRUE);
#endif
#if USE_UART1_RX
gpio_setup_pin_af(UART1_GPIO_PORT_RX, UART1_GPIO_RX, UART1_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART1_IRQ);
#if UART1_HW_FLOW_CONTROL
#warning "USING UART1 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS gpios */
gpio_setup_pin_af(UART1_GPIO_PORT_CTS, UART1_GPIO_CTS, UART1_GPIO_AF, FALSE);
gpio_setup_pin_af(UART1_GPIO_PORT_RTS, UART1_GPIO_RTS, UART1_GPIO_AF, TRUE);
#endif
/* Configure USART1, enable hardware flow control*/
uart_periph_set_mode(&uart1, USE_UART1_TX, USE_UART1_RX, UART1_HW_FLOW_CONTROL);
/* Set USART1 parameters and enable interrupt */
uart_periph_set_bits_stop_parity(&uart1, UART1_BITS, UART1_STOP, UART1_PARITY);
uart_periph_set_baudrate(&uart1, UART1_BAUD);
}
void uart2_init(void)
{
uart_periph_init(&uart2);
uart2.reg_addr = (void *)USART2;
/* init RCC and GPIOs */
rcc_periph_clock_enable(RCC_USART2);
#if USE_UART2_TX
gpio_setup_pin_af(UART2_GPIO_PORT_TX, UART2_GPIO_TX, UART2_GPIO_AF, TRUE);
#endif
#if USE_UART2_RX
gpio_setup_pin_af(UART2_GPIO_PORT_RX, UART2_GPIO_RX, UART2_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART2_IRQ);
#if UART2_HW_FLOW_CONTROL && defined(STM32F4)
#warning "USING UART2 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS pins */
gpio_setup_pin_af(UART2_GPIO_PORT_CTS, UART2_GPIO_CTS, UART2_GPIO_AF, FALSE);
gpio_setup_pin_af(UART2_GPIO_PORT_RTS, UART2_GPIO_RTS, UART2_GPIO_AF, TRUE);
#endif
/* Configure USART Tx,Rx, and hardware flow control*/
uart_periph_set_mode(&uart2, USE_UART2_TX, USE_UART2_RX, UART2_HW_FLOW_CONTROL);
/* Configure USART */
uart_periph_set_bits_stop_parity(&uart2, UART2_BITS, UART2_STOP, UART2_PARITY);
uart_periph_set_baudrate(&uart2, UART2_BAUD);
}
void uart5_init( void ) {
uart_periph_init(&uart5);
uart5.reg_addr = (void *)UART5;
/* init RCC and GPIOs */
#if defined(STM32F4)
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_UART5EN);
set_uart_pin(UART5_GPIO_PORT_RX, UART5_GPIO_RX, UART5_GPIO_AF);
set_uart_pin(UART5_GPIO_PORT_TX, UART5_GPIO_TX, UART5_GPIO_AF);
#elif defined(STM32F1)
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_UART5EN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPCEN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPDEN);
gpio_set_mode(GPIO_BANK_UART5_TX, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_UART5_TX);
gpio_set_mode(GPIO_BANK_UART5_RX, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO_UART5_RX);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_UART5_IRQ);
/* Configure USART */
uart_periph_set_mode(&uart5, USE_UART5_TX, USE_UART5_RX, FALSE);
uart_periph_set_baudrate(&uart5, UART5_BAUD);
}
void uart4_init( void ) {
uart_periph_init(&uart4);
uart4.reg_addr = (void *)UART4;
/* init RCC and GPIOs */
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_UART4EN);
set_uart_pin(UART4_GPIO_PORT_RX, UART4_GPIO_RX, UART4_GPIO_AF);
set_uart_pin(UART4_GPIO_PORT_TX, UART4_GPIO_TX, UART4_GPIO_AF);
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_UART4_IRQ);
/* Configure USART */
uart_periph_set_mode(&uart4, USE_UART4_TX, USE_UART4_RX, FALSE);
uart_periph_set_baudrate(&uart4, UART4_BAUD);
}
void uart1_init( void ) {
uart_periph_init(&uart1);
uart1.reg_addr = (void *)USART1;
/* init RCC and GPIOs */
#if defined(STM32F4)
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_USART1EN);
set_uart_pin(UART1_GPIO_PORT_RX, UART1_GPIO_RX, UART1_GPIO_AF);
set_uart_pin(UART1_GPIO_PORT_TX, UART1_GPIO_TX, UART1_GPIO_AF);
#elif defined(STM32F1)
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_USART1EN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN);
gpio_set_mode(GPIO_BANK_USART1_TX, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_USART1_TX);
gpio_set_mode(GPIO_BANK_USART1_RX, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO_USART1_RX);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART1_IRQ);
#if UART1_HW_FLOW_CONTROL
#warning "USING UART1 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS gpios */
#if defined(STM32F4)
set_uart_pin(UART1_GPIO_PORT_CTS, UART1_GPIO_CTS, UART1_GPIO_AF);
set_uart_pin(UART1_GPIO_PORT_RTS, UART1_GPIO_RTS, UART1_GPIO_AF);
#elif defined(STM32F1)
gpio_set_mode(GPIO_BANK_USART1_RTS, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_USART1_RTS);
gpio_set_mode(GPIO_BANK_USART1_CTS, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO_USART1_CTS);
#endif
#endif
/* Configure USART1, enable hardware flow control*/
uart_periph_set_mode(&uart1, USE_UART1_TX, USE_UART1_RX, UART1_HW_FLOW_CONTROL);
/* Set USART1 baudrate and enable interrupt */
uart_periph_set_baudrate(&uart1, UART1_BAUD);
}
void uart5_init( void ) {
uart_periph_init(&uart5);
uart5.reg_addr = (void *)UART5;
/* init RCC and GPIOs */
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_UART5EN);
#if USE_UART5_TX
gpio_setup_pin_af(UART5_GPIO_PORT_TX, UART5_GPIO_TX, UART5_GPIO_AF, TRUE);
#endif
#if USE_UART5_RX
gpio_setup_pin_af(UART5_GPIO_PORT_RX, UART5_GPIO_RX, UART5_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_UART5_IRQ);
/* Configure USART */
uart_periph_set_mode(&uart5, USE_UART5_TX, USE_UART5_RX, FALSE);
uart_periph_set_baudrate(&uart5, UART5_BAUD);
}
void uart3_init( void ) {
uart_periph_init(&uart3);
uart3.reg_addr = (void *)USART3;
/* init RCC */
#if defined(STM32F4)
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_USART3EN);
set_uart_pin(UART3_GPIO_PORT_RX, UART3_GPIO_RX, UART3_GPIO_AF);
set_uart_pin(UART3_GPIO_PORT_TX, UART3_GPIO_TX, UART3_GPIO_AF);
#elif defined(STM32F1)
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_USART3EN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPCEN);
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_AFIOEN);
AFIO_MAPR |= AFIO_MAPR_USART3_REMAP_PARTIAL_REMAP;
gpio_set_mode(GPIO_BANK_USART3_PR_TX, GPIO_MODE_OUTPUT_50_MHZ,
GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_USART3_PR_TX);
gpio_set_mode(GPIO_BANK_USART3_PR_RX, GPIO_MODE_INPUT,
GPIO_CNF_INPUT_FLOAT, GPIO_USART3_PR_RX);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_USART3_IRQ);
#if UART3_HW_FLOW_CONTROL && defined(STM32F4)
#warning "USING UART3 FLOW CONTROL. Make sure to pull down CTS if you are not connecting any flow-control-capable hardware."
/* setup CTS and RTS pins */
set_uart_pin(UART3_GPIO_PORT_CTS, UART3_GPIO_CTS, UART3_GPIO_AF);
set_uart_pin(UART3_GPIO_PORT_RTS, UART3_GPIO_RTS, UART3_GPIO_AF);
#endif
/* Configure USART Tx,Rx, and hardware flow control*/
uart_periph_set_mode(&uart3, USE_UART3_TX, USE_UART3_RX, UART3_HW_FLOW_CONTROL);
/* Configure USART */
uart_periph_set_baudrate(&uart3, UART3_BAUD);
}
void uart5_init( void ) {
uart_periph_init(&uart5);
uart5.reg_addr = (void *)UART5;
/* init RCC and GPIOs */
rcc_periph_clock_enable(RCC_UART5);
#if USE_UART5_TX
gpio_setup_pin_af(UART5_GPIO_PORT_TX, UART5_GPIO_TX, UART5_GPIO_AF, TRUE);
#endif
#if USE_UART5_RX
gpio_setup_pin_af(UART5_GPIO_PORT_RX, UART5_GPIO_RX, UART5_GPIO_AF, FALSE);
#endif
/* Enable USART interrupts in the interrupt controller */
usart_enable_irq(NVIC_UART5_IRQ);
/* Configure USART */
uart_periph_set_mode(&uart5, USE_UART5_TX, USE_UART5_RX, FALSE);
uart_periph_set_bits_stop_parity(&uart5, UART5_BITS, UART5_STOP, UART5_PARITY);
uart_periph_set_baudrate(&uart5, UART5_BAUD);
}