static void TM_USART_INT_Init( USART_TypeDef* USARTx, TM_USART_PinsPack_t pinspack, uint32_t baudrate, TM_USART_HardwareFlowControl_t FlowControl, uint32_t Mode, uint32_t Parity, uint32_t StopBits, uint32_t WordLength ) { UART_HandleTypeDef UARTHandle; IRQn_Type irq; /* * Initialize USARTx pins * Set channel for USARTx NVIC */ #ifdef USART1 if (USARTx == USART1) { /* Enable USART clock */ __HAL_RCC_USART1_CLK_ENABLE(); __HAL_RCC_USART1_FORCE_RESET(); __HAL_RCC_USART1_RELEASE_RESET(); /* Init pins */ TM_USART1_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_USART1; } #endif #ifdef USART2 if (USARTx == USART2) { /* Enable USART clock */ __HAL_RCC_USART2_CLK_ENABLE(); __HAL_RCC_USART2_FORCE_RESET(); __HAL_RCC_USART2_RELEASE_RESET(); /* Init pins */ TM_USART2_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_USART2; } #endif #ifdef USART3 if (USARTx == USART3) { /* Enable USART clock */ __HAL_RCC_USART3_CLK_ENABLE(); __HAL_RCC_USART3_FORCE_RESET(); __HAL_RCC_USART3_RELEASE_RESET(); /* Init pins */ TM_USART3_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_USART3; } #endif #ifdef UART4 if (USARTx == UART4) { /* Enable UART clock */ __HAL_RCC_UART4_CLK_ENABLE(); __HAL_RCC_UART4_FORCE_RESET(); __HAL_RCC_UART4_RELEASE_RESET(); /* Init pins */ TM_UART4_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_UART4; } #endif #ifdef UART5 if (USARTx == UART5) { /* Enable UART clock */ __HAL_RCC_UART5_CLK_ENABLE(); __HAL_RCC_UART5_FORCE_RESET(); __HAL_RCC_UART5_RELEASE_RESET(); /* Init pins */ TM_UART5_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_UART5; } #endif #ifdef USART6 if (USARTx == USART6) { /* Enable UART clock */ __HAL_RCC_USART6_CLK_ENABLE(); __HAL_RCC_USART6_FORCE_RESET(); __HAL_RCC_USART6_RELEASE_RESET(); /* Init pins */ TM_USART6_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_USART6; } #endif #ifdef UART7 if (USARTx == UART7) { /* Enable UART clock */ __HAL_RCC_UART7_CLK_ENABLE(); __HAL_RCC_UART7_FORCE_RESET(); __HAL_RCC_UART7_RELEASE_RESET(); /* Init pins */ TM_UART7_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_UART7; } #endif #ifdef UART8 if (USARTx == UART8) { /* Enable UART clock */ __HAL_RCC_UART8_CLK_ENABLE(); __HAL_RCC_UART8_FORCE_RESET(); __HAL_RCC_UART8_RELEASE_RESET(); /* Init pins */ TM_UART8_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_UART8; } #endif /* STM32F0xx related */ #ifdef USART4 if (USARTx == USART4) { /* Enable UART clock */ __HAL_RCC_USART4_CLK_ENABLE(); __HAL_RCC_USART4_FORCE_RESET(); __HAL_RCC_USART4_RELEASE_RESET(); /* Init pins */ TM_USART4_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_USART4; } #endif #ifdef USART5 if (USARTx == USART5) { /* Enable UART clock */ __HAL_RCC_USART5_CLK_ENABLE(); __HAL_RCC_USART5_FORCE_RESET(); __HAL_RCC_USART5_RELEASE_RESET(); /* Init pins */ TM_USART5_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_USART5; } #endif #ifdef USART7 if (USARTx == USART7) { /* Enable UART clock */ __HAL_RCC_USART7_CLK_ENABLE(); __HAL_RCC_USART7_FORCE_RESET(); __HAL_RCC_USART7_RELEASE_RESET(); /* Init pins */ TM_USART7_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_USART7; } #endif #ifdef USART8 if (USARTx == USART8) { /* Enable UART clock */ __HAL_RCC_USART8_CLK_ENABLE(); __HAL_RCC_USART8_FORCE_RESET(); __HAL_RCC_USART8_RELEASE_RESET(); /* Init pins */ TM_USART8_InitPins(pinspack); /* Set IRQ channel */ irq = IRQ_USART8; } #endif /* Fill default settings */ UARTHandle.Instance = USARTx; UARTHandle.Init.BaudRate = baudrate; UARTHandle.Init.HwFlowCtl = FlowControl; UARTHandle.Init.Mode = Mode; UARTHandle.Init.Parity = Parity; UARTHandle.Init.StopBits = StopBits; UARTHandle.Init.WordLength = WordLength; UARTHandle.Init.OverSampling = UART_OVERSAMPLING_16; #if defined(STM32F0xx) UARTHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; #endif /* Disable IRQ */ HAL_NVIC_DisableIRQ(irq); /* Set priority */ HAL_NVIC_SetPriority(irq, USART_NVIC_PRIORITY, TM_USART_INT_GetSubPriority(USARTx)); /* Enable interrupt */ HAL_NVIC_EnableIRQ(irq); /* Clear interrupt */ HAL_NVIC_ClearPendingIRQ(irq); /* Init USART */ HAL_UART_Init(&UARTHandle); /* Enable RX interrupt */ USARTx->CR1 |= USART_CR1_RXNEIE; }
/** * @brief UART MSP Initialization * This function configures the hardware resources used in this example: * - Peripheral's clock enable * - Peripheral's GPIO Configuration * - NVIC configuration for UART interrupt request enable * @param huart: UART handle pointer * @retval None */ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { GPIO_InitTypeDef GPIO_InitStruct; switch((uint32_t)huart->Instance) { case (uint32_t)USART1 : { /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ __HAL_RCC_GPIOA_CLK_ENABLE(); /* Enable USARTx clock */ __HAL_RCC_USART1_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF1_USART1; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /*##-3- Configure the NVIC for UART ########################################*/ /* NVIC for USART */ HAL_NVIC_SetPriority(USART1_IRQn, 1, 0); HAL_NVIC_EnableIRQ(USART1_IRQn); } break; case (uint32_t)USART2 : { /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ __HAL_RCC_GPIOD_CLK_ENABLE(); /* Enable USARTx clock */ __HAL_RCC_USART2_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_5; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF0_USART2; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); /*##-3- Configure the NVIC for UART ########################################*/ /* NVIC for USART */ HAL_NVIC_SetPriority(USART2_IRQn, 1, 0); HAL_NVIC_EnableIRQ(USART2_IRQn); } break; case (uint32_t)USART3 : { /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ __HAL_RCC_GPIOD_CLK_ENABLE(); /* To allow the IT source identification */ __HAL_RCC_SYSCFG_CLK_ENABLE(); /* Enable USARTx clock */ __HAL_RCC_USART3_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_9; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF0_USART3; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); /*##-3- Configure the NVIC for UART ########################################*/ /* NVIC for USART */ HAL_NVIC_SetPriority(USART3_8_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART3_8_IRQn); } break; case (uint32_t)USART4 : { /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ __HAL_RCC_GPIOC_CLK_ENABLE(); /* To allow the IT source identification */ __HAL_RCC_SYSCFG_CLK_ENABLE(); /* Enable USARTx clock */ __HAL_RCC_USART4_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = GPIO_PIN_10 | GPIO_PIN_11; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF0_USART4; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /*##-3- Configure the NVIC for UART ########################################*/ /* NVIC for USART */ HAL_NVIC_SetPriority(USART3_8_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART3_8_IRQn); } break; case (uint32_t)USART5 : { /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ __HAL_RCC_GPIOB_CLK_ENABLE(); /* To allow the IT source identification */ __HAL_RCC_SYSCFG_CLK_ENABLE(); /* Enable USARTx clock */ __HAL_RCC_USART5_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = GPIO_PIN_3 | GPIO_PIN_4; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF4_USART5; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /*##-3- Configure the NVIC for UART ########################################*/ /* NVIC for USART */ HAL_NVIC_SetPriority(USART3_8_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART3_8_IRQn); } break; case (uint32_t)USART6 : { /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ __HAL_RCC_GPIOF_CLK_ENABLE(); /* To allow the IT source identification */ __HAL_RCC_SYSCFG_CLK_ENABLE(); /* Enable USARTx clock */ __HAL_RCC_USART6_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF1_USART6; HAL_GPIO_Init(GPIOF, &GPIO_InitStruct); /*##-3- Configure the NVIC for UART ########################################*/ /* NVIC for USART */ HAL_NVIC_SetPriority(USART3_8_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART3_8_IRQn); } break; case (uint32_t)USART7 : { /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ __HAL_RCC_GPIOF_CLK_ENABLE(); /* To allow the IT source identification */ __HAL_RCC_SYSCFG_CLK_ENABLE(); /* Enable USARTx clock */ __HAL_RCC_USART7_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = GPIO_PIN_3 | GPIO_PIN_2; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF1_USART7; HAL_GPIO_Init(GPIOF, &GPIO_InitStruct); /*##-3- Configure the NVIC for UART ########################################*/ /* NVIC for USART */ HAL_NVIC_SetPriority(USART3_8_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART3_8_IRQn); } break; case (uint32_t)USART8 : { /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ __HAL_RCC_GPIOC_CLK_ENABLE(); /* To allow the IT source identification */ __HAL_RCC_SYSCFG_CLK_ENABLE(); /* Enable USARTx clock */ __HAL_RCC_USART8_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_9; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF1_USART8; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /*##-3- Configure the NVIC for UART ########################################*/ /* NVIC for USART */ HAL_NVIC_SetPriority(USART3_8_IRQn, 1, 0); HAL_NVIC_EnableIRQ(USART3_8_IRQn); } break; } }
// assumes Init parameters have been set up correctly bool uart_init(pyb_uart_obj_t *uart_obj, uint32_t baudrate, uint32_t bits, uint32_t parity, uint32_t stop, uint32_t flow) { USART_TypeDef *UARTx; IRQn_Type irqn; int uart_unit; const pin_obj_t *pins[4] = {0}; switch (uart_obj->uart_id) { #if defined(MICROPY_HW_UART1_TX) && defined(MICROPY_HW_UART1_RX) case PYB_UART_1: uart_unit = 1; UARTx = USART1; irqn = USART1_IRQn; pins[0] = MICROPY_HW_UART1_TX; pins[1] = MICROPY_HW_UART1_RX; __HAL_RCC_USART1_CLK_ENABLE(); break; #endif #if defined(MICROPY_HW_UART2_TX) && defined(MICROPY_HW_UART2_RX) case PYB_UART_2: uart_unit = 2; UARTx = USART2; irqn = USART2_IRQn; pins[0] = MICROPY_HW_UART2_TX; pins[1] = MICROPY_HW_UART2_RX; #if defined(MICROPY_HW_UART2_RTS) if (flow & UART_HWCONTROL_RTS) { pins[2] = MICROPY_HW_UART2_RTS; } #endif #if defined(MICROPY_HW_UART2_CTS) if (flow & UART_HWCONTROL_CTS) { pins[3] = MICROPY_HW_UART2_CTS; } #endif __HAL_RCC_USART2_CLK_ENABLE(); break; #endif #if defined(MICROPY_HW_UART3_TX) && defined(MICROPY_HW_UART3_RX) case PYB_UART_3: uart_unit = 3; UARTx = USART3; #if defined(STM32F0) irqn = USART3_8_IRQn; #else irqn = USART3_IRQn; #endif pins[0] = MICROPY_HW_UART3_TX; pins[1] = MICROPY_HW_UART3_RX; #if defined(MICROPY_HW_UART3_RTS) if (flow & UART_HWCONTROL_RTS) { pins[2] = MICROPY_HW_UART3_RTS; } #endif #if defined(MICROPY_HW_UART3_CTS) if (flow & UART_HWCONTROL_CTS) { pins[3] = MICROPY_HW_UART3_CTS; } #endif __HAL_RCC_USART3_CLK_ENABLE(); break; #endif #if defined(MICROPY_HW_UART4_TX) && defined(MICROPY_HW_UART4_RX) case PYB_UART_4: uart_unit = 4; #if defined(STM32F0) UARTx = USART4; irqn = USART3_8_IRQn; __HAL_RCC_USART4_CLK_ENABLE(); #else UARTx = UART4; irqn = UART4_IRQn; __HAL_RCC_UART4_CLK_ENABLE(); #endif pins[0] = MICROPY_HW_UART4_TX; pins[1] = MICROPY_HW_UART4_RX; break; #endif #if defined(MICROPY_HW_UART5_TX) && defined(MICROPY_HW_UART5_RX) case PYB_UART_5: uart_unit = 5; #if defined(STM32F0) UARTx = USART5; irqn = USART3_8_IRQn; __HAL_RCC_USART5_CLK_ENABLE(); #else UARTx = UART5; irqn = UART5_IRQn; __HAL_RCC_UART5_CLK_ENABLE(); #endif pins[0] = MICROPY_HW_UART5_TX; pins[1] = MICROPY_HW_UART5_RX; break; #endif #if defined(MICROPY_HW_UART6_TX) && defined(MICROPY_HW_UART6_RX) case PYB_UART_6: uart_unit = 6; UARTx = USART6; #if defined(STM32F0) irqn = USART3_8_IRQn; #else irqn = USART6_IRQn; #endif pins[0] = MICROPY_HW_UART6_TX; pins[1] = MICROPY_HW_UART6_RX; #if defined(MICROPY_HW_UART6_RTS) if (flow & UART_HWCONTROL_RTS) { pins[2] = MICROPY_HW_UART6_RTS; } #endif #if defined(MICROPY_HW_UART6_CTS) if (flow & UART_HWCONTROL_CTS) { pins[3] = MICROPY_HW_UART6_CTS; } #endif __HAL_RCC_USART6_CLK_ENABLE(); break; #endif #if defined(MICROPY_HW_UART7_TX) && defined(MICROPY_HW_UART7_RX) case PYB_UART_7: uart_unit = 7; #if defined(STM32F0) UARTx = USART7; irqn = USART3_8_IRQn; __HAL_RCC_USART7_CLK_ENABLE(); #else UARTx = UART7; irqn = UART7_IRQn; __HAL_RCC_UART7_CLK_ENABLE(); #endif pins[0] = MICROPY_HW_UART7_TX; pins[1] = MICROPY_HW_UART7_RX; break; #endif #if defined(MICROPY_HW_UART8_TX) && defined(MICROPY_HW_UART8_RX) case PYB_UART_8: uart_unit = 8; #if defined(STM32F0) UARTx = USART8; irqn = USART3_8_IRQn; __HAL_RCC_USART8_CLK_ENABLE(); #else UARTx = UART8; irqn = UART8_IRQn; __HAL_RCC_UART8_CLK_ENABLE(); #endif pins[0] = MICROPY_HW_UART8_TX; pins[1] = MICROPY_HW_UART8_RX; break; #endif #if defined(MICROPY_HW_UART9_TX) && defined(MICROPY_HW_UART9_RX) case PYB_UART_9: uart_unit = 9; UARTx = UART9; irqn = UART9_IRQn; __HAL_RCC_UART9_CLK_ENABLE(); pins[0] = MICROPY_HW_UART9_TX; pins[1] = MICROPY_HW_UART9_RX; break; #endif #if defined(MICROPY_HW_UART10_TX) && defined(MICROPY_HW_UART10_RX) case PYB_UART_10: uart_unit = 10; UARTx = UART10; irqn = UART10_IRQn; __HAL_RCC_UART10_CLK_ENABLE(); pins[0] = MICROPY_HW_UART10_TX; pins[1] = MICROPY_HW_UART10_RX; break; #endif default: // UART does not exist or is not configured for this board return false; } uint32_t mode = MP_HAL_PIN_MODE_ALT; uint32_t pull = MP_HAL_PIN_PULL_UP; for (uint i = 0; i < 4; i++) { if (pins[i] != NULL) { bool ret = mp_hal_pin_config_alt(pins[i], mode, pull, AF_FN_UART, uart_unit); if (!ret) { return false; } } } uart_obj->uartx = UARTx; // init UARTx UART_HandleTypeDef huart; memset(&huart, 0, sizeof(huart)); huart.Instance = UARTx; huart.Init.BaudRate = baudrate; huart.Init.WordLength = bits; huart.Init.StopBits = stop; huart.Init.Parity = parity; huart.Init.Mode = UART_MODE_TX_RX; huart.Init.HwFlowCtl = flow; huart.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&huart); // Disable all individual UART IRQs, but enable the global handler uart_obj->uartx->CR1 &= ~USART_CR1_IE_ALL; uart_obj->uartx->CR2 &= ~USART_CR2_IE_ALL; uart_obj->uartx->CR3 &= ~USART_CR3_IE_ALL; NVIC_SetPriority(IRQn_NONNEG(irqn), IRQ_PRI_UART); HAL_NVIC_EnableIRQ(irqn); uart_obj->is_enabled = true; uart_obj->attached_to_repl = false; if (bits == UART_WORDLENGTH_9B && parity == UART_PARITY_NONE) { uart_obj->char_mask = 0x1ff; uart_obj->char_width = CHAR_WIDTH_9BIT; } else { if (bits == UART_WORDLENGTH_9B || parity == UART_PARITY_NONE) { uart_obj->char_mask = 0xff; } else { uart_obj->char_mask = 0x7f; } uart_obj->char_width = CHAR_WIDTH_8BIT; } uart_obj->mp_irq_trigger = 0; uart_obj->mp_irq_obj = NULL; return true; }
void serial_init(serial_t *obj, PinName tx, PinName rx) { // Determine the UART to use (UART_1, UART_2, ...) UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX); UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX); // Get the peripheral name (UART_1, UART_2, ...) from the pin and assign it to the object obj->uart = (UARTName)pinmap_merge(uart_tx, uart_rx); MBED_ASSERT(obj->uart != (UARTName)NC); // Enable USART clock if (obj->uart == UART_1) { __HAL_RCC_USART1_FORCE_RESET(); __HAL_RCC_USART1_RELEASE_RESET(); __HAL_RCC_USART1_CLK_ENABLE(); obj->index = 0; } #if defined USART2_BASE if (obj->uart == UART_2) { __HAL_RCC_USART2_FORCE_RESET(); __HAL_RCC_USART2_RELEASE_RESET(); __HAL_RCC_USART2_CLK_ENABLE(); obj->index = 1; } #endif #if defined USART3_BASE if (obj->uart == UART_3) { __HAL_RCC_USART3_FORCE_RESET(); __HAL_RCC_USART3_RELEASE_RESET(); __HAL_RCC_USART3_CLK_ENABLE(); obj->index = 2; } #endif #if defined USART4_BASE if (obj->uart == UART_4) { __HAL_RCC_USART4_FORCE_RESET(); __HAL_RCC_USART4_RELEASE_RESET(); __HAL_RCC_USART4_CLK_ENABLE(); obj->index = 3; } #endif #if defined USART5_BASE if (obj->uart == UART_5) { __HAL_RCC_USART5_FORCE_RESET(); __HAL_RCC_USART5_RELEASE_RESET(); __HAL_RCC_USART5_CLK_ENABLE(); obj->index = 4; } #endif #if defined USART6_BASE if (obj->uart == UART_6) { __HAL_RCC_USART6_FORCE_RESET(); __HAL_RCC_USART6_RELEASE_RESET(); __HAL_RCC_USART6_CLK_ENABLE(); obj->index = 5; } #endif #if defined USART7_BASE if (obj->uart == UART_7) { __HAL_RCC_USART7_FORCE_RESET(); __HAL_RCC_USART7_RELEASE_RESET(); __HAL_RCC_USART7_CLK_ENABLE(); obj->index = 6; } #endif #if defined USART8_BASE if (obj->uart == UART_8) { __HAL_RCC_USART8_FORCE_RESET(); __HAL_RCC_USART8_RELEASE_RESET(); __HAL_RCC_USART8_CLK_ENABLE(); obj->index = 7; } #endif // Configure the UART pins pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(rx, PinMap_UART_RX); if (tx != NC) { pin_mode(tx, PullUp); } if (rx != NC) { pin_mode(rx, PullUp); } // Configure UART obj->baudrate = 9600; obj->databits = UART_WORDLENGTH_8B; obj->stopbits = UART_STOPBITS_1; obj->parity = UART_PARITY_NONE; obj->pin_tx = tx; obj->pin_rx = rx; init_uart(obj); // For stdio management if (obj->uart == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }