/** * @brief UART MSP De-Initialization * This function frees the hardware resources used in this example: * - Disable the Peripheral's clock * - Revert GPIO configuration to their default state * @param huart: UART handle pointer * @retval None */ void HAL_UART_MspDeInit(UART_HandleTypeDef *huart) { /*##-1- Reset peripherals ##################################################*/ __HAL_RCC_USART1_FORCE_RESET(); __HAL_RCC_USART1_RELEASE_RESET(); /*##-2- Disable peripherals and GPIO Clocks #################################*/ /* Configure USART6 Tx as alternate function */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9); /* Configure USART6 Rx as alternate function */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_10); }
/** * @brief UART MSP De-Initialization * This function frees the hardware resources used in this application: * - Disable the Peripheral's clock * - Revert GPIO, and NVIC configuration to their default state * @param huart: UART handle pointer * @retval None */ void HAL_UART_MspDeInit(UART_HandleTypeDef *huart) { __HAL_RCC_USART1_FORCE_RESET(); __HAL_RCC_USART1_RELEASE_RESET(); /*##-2- Disable peripherals and GPIO Clocks #################################*/ /* Configure UART Tx as alternate function */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9); /* Configure UART Rx as alternate function */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_10); /*##-3- Disable the NVIC for UART ##########################################*/ HAL_NVIC_DisableIRQ(USART1_IRQn); }
void serial_free(serial_t *obj) { // Reset UART and disable clock if (obj->uart == UART_1) { __HAL_RCC_USART1_FORCE_RESET(); __HAL_RCC_USART1_RELEASE_RESET(); __HAL_RCC_USART1_CLK_DISABLE(); } if (obj->uart == UART_2) { __HAL_RCC_USART2_FORCE_RESET(); __HAL_RCC_USART2_RELEASE_RESET(); __HAL_RCC_USART2_CLK_DISABLE(); } if (obj->uart == UART_3) { __HAL_RCC_USART3_FORCE_RESET(); __HAL_RCC_USART3_RELEASE_RESET(); __HAL_RCC_USART3_CLK_DISABLE(); } if (obj->uart == UART_4) { __HAL_RCC_UART4_FORCE_RESET(); __HAL_RCC_UART4_RELEASE_RESET(); __HAL_RCC_UART4_CLK_DISABLE(); } if (obj->uart == UART_5) { __HAL_RCC_UART5_FORCE_RESET(); __HAL_RCC_UART5_RELEASE_RESET(); __HAL_RCC_UART5_CLK_DISABLE(); } if (obj->uart == LPUART_1) { __HAL_RCC_LPUART1_FORCE_RESET(); __HAL_RCC_LPUART1_RELEASE_RESET(); __HAL_RCC_LPUART1_CLK_DISABLE(); } // Configure GPIOs pin_function(obj->pin_tx, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0)); pin_function(obj->pin_rx, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0)); serial_irq_ids[obj->index] = 0; }
void serial_init(serial_t *obj, PinName tx, PinName rx) { struct serial_s *obj_s = SERIAL_S(obj); // 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_s->uart = (UARTName)pinmap_merge(uart_tx, uart_rx); MBED_ASSERT(obj_s->uart != (UARTName)NC); // Enable USART clock switch (obj_s->uart) { case UART_1: __HAL_RCC_USART1_FORCE_RESET(); __HAL_RCC_USART1_RELEASE_RESET(); __HAL_RCC_USART1_CLK_ENABLE(); obj_s->index = 0; break; case UART_2: __HAL_RCC_USART2_FORCE_RESET(); __HAL_RCC_USART2_RELEASE_RESET(); __HAL_RCC_USART2_CLK_ENABLE(); obj_s->index = 1; break; #if defined(USART3_BASE) case UART_3: __HAL_RCC_USART3_FORCE_RESET(); __HAL_RCC_USART3_RELEASE_RESET(); __HAL_RCC_USART3_CLK_ENABLE(); obj_s->index = 2; break; #endif #if defined(UART4_BASE) case UART_4: __HAL_RCC_UART4_FORCE_RESET(); __HAL_RCC_UART4_RELEASE_RESET(); __HAL_RCC_UART4_CLK_ENABLE(); obj_s->index = 3; break; #endif #if defined(UART5_BASE) case UART_5: __HAL_RCC_UART5_FORCE_RESET(); __HAL_RCC_UART5_RELEASE_RESET(); __HAL_RCC_UART5_CLK_ENABLE(); obj_s->index = 4; break; #endif #if defined(USART6_BASE) case UART_6: __HAL_RCC_USART6_FORCE_RESET(); __HAL_RCC_USART6_RELEASE_RESET(); __HAL_RCC_USART6_CLK_ENABLE(); obj_s->index = 5; break; #endif #if defined(UART7_BASE) case UART_7: __HAL_RCC_UART7_FORCE_RESET(); __HAL_RCC_UART7_RELEASE_RESET(); __HAL_RCC_UART7_CLK_ENABLE(); obj_s->index = 6; break; #endif #if defined(UART8_BASE) case UART_8: __HAL_RCC_UART8_FORCE_RESET(); __HAL_RCC_UART8_RELEASE_RESET(); __HAL_RCC_UART8_CLK_ENABLE(); obj_s->index = 7; break; #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_s->baudrate = 9600; obj_s->databits = UART_WORDLENGTH_8B; obj_s->stopbits = UART_STOPBITS_1; obj_s->parity = UART_PARITY_NONE; #if DEVICE_SERIAL_FC obj_s->hw_flow_ctl = UART_HWCONTROL_NONE; #endif obj_s->pin_tx = tx; obj_s->pin_rx = rx; init_uart(obj); // For stdio management if (obj_s->uart == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
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; }
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 UART clock if (obj->uart == UART_1) { __HAL_RCC_USART1_FORCE_RESET(); __HAL_RCC_USART1_RELEASE_RESET(); __USART1_CLK_ENABLE(); obj->index = 0; } if (obj->uart == UART_2) { __HAL_RCC_USART2_FORCE_RESET(); __HAL_RCC_USART2_RELEASE_RESET(); __USART2_CLK_ENABLE(); obj->index = 1; } if (obj->uart == UART_3) { __HAL_RCC_USART3_FORCE_RESET(); __HAL_RCC_USART3_RELEASE_RESET(); __USART3_CLK_ENABLE(); obj->index = 2; } #if defined(UART4_BASE) if (obj->uart == UART_4) { __HAL_RCC_UART4_FORCE_RESET(); __HAL_RCC_UART4_RELEASE_RESET(); __UART4_CLK_ENABLE(); obj->index = 3; } #endif #if defined(UART5_BASE) if (obj->uart == UART_5) { __HAL_RCC_UART5_FORCE_RESET(); __HAL_RCC_UART5_RELEASE_RESET(); __UART5_CLK_ENABLE(); obj->index = 4; } #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)); } }
void uart_deinit(pyb_uart_obj_t *self) { self->is_enabled = false; // Disable UART self->uartx->CR1 &= ~USART_CR1_UE; // Reset and turn off the UART peripheral if (self->uart_id == 1) { HAL_NVIC_DisableIRQ(USART1_IRQn); __HAL_RCC_USART1_FORCE_RESET(); __HAL_RCC_USART1_RELEASE_RESET(); __HAL_RCC_USART1_CLK_DISABLE(); } else if (self->uart_id == 2) { HAL_NVIC_DisableIRQ(USART2_IRQn); __HAL_RCC_USART2_FORCE_RESET(); __HAL_RCC_USART2_RELEASE_RESET(); __HAL_RCC_USART2_CLK_DISABLE(); #if defined(USART3) } else if (self->uart_id == 3) { #if !defined(STM32F0) HAL_NVIC_DisableIRQ(USART3_IRQn); #endif __HAL_RCC_USART3_FORCE_RESET(); __HAL_RCC_USART3_RELEASE_RESET(); __HAL_RCC_USART3_CLK_DISABLE(); #endif #if defined(UART4) } else if (self->uart_id == 4) { HAL_NVIC_DisableIRQ(UART4_IRQn); __HAL_RCC_UART4_FORCE_RESET(); __HAL_RCC_UART4_RELEASE_RESET(); __HAL_RCC_UART4_CLK_DISABLE(); #endif #if defined(USART4) } else if (self->uart_id == 4) { __HAL_RCC_USART4_FORCE_RESET(); __HAL_RCC_USART4_RELEASE_RESET(); __HAL_RCC_USART4_CLK_DISABLE(); #endif #if defined(UART5) } else if (self->uart_id == 5) { HAL_NVIC_DisableIRQ(UART5_IRQn); __HAL_RCC_UART5_FORCE_RESET(); __HAL_RCC_UART5_RELEASE_RESET(); __HAL_RCC_UART5_CLK_DISABLE(); #endif #if defined(USART5) } else if (self->uart_id == 5) { __HAL_RCC_USART5_FORCE_RESET(); __HAL_RCC_USART5_RELEASE_RESET(); __HAL_RCC_USART5_CLK_DISABLE(); #endif #if defined(UART6) } else if (self->uart_id == 6) { HAL_NVIC_DisableIRQ(USART6_IRQn); __HAL_RCC_USART6_FORCE_RESET(); __HAL_RCC_USART6_RELEASE_RESET(); __HAL_RCC_USART6_CLK_DISABLE(); #endif #if defined(UART7) } else if (self->uart_id == 7) { HAL_NVIC_DisableIRQ(UART7_IRQn); __HAL_RCC_UART7_FORCE_RESET(); __HAL_RCC_UART7_RELEASE_RESET(); __HAL_RCC_UART7_CLK_DISABLE(); #endif #if defined(USART7) } else if (self->uart_id == 7) { __HAL_RCC_USART7_FORCE_RESET(); __HAL_RCC_USART7_RELEASE_RESET(); __HAL_RCC_USART7_CLK_DISABLE(); #endif #if defined(UART8) } else if (self->uart_id == 8) { HAL_NVIC_DisableIRQ(UART8_IRQn); __HAL_RCC_UART8_FORCE_RESET(); __HAL_RCC_UART8_RELEASE_RESET(); __HAL_RCC_UART8_CLK_DISABLE(); #endif #if defined(USART8) } else if (self->uart_id == 8) { __HAL_RCC_USART8_FORCE_RESET(); __HAL_RCC_USART8_RELEASE_RESET(); __HAL_RCC_USART8_CLK_DISABLE(); #endif #if defined(UART9) } else if (self->uart_id == 9) { HAL_NVIC_DisableIRQ(UART9_IRQn); __HAL_RCC_UART9_FORCE_RESET(); __HAL_RCC_UART9_RELEASE_RESET(); __HAL_RCC_UART9_CLK_DISABLE(); #endif #if defined(UART10) } else if (self->uart_id == 10) { HAL_NVIC_DisableIRQ(UART10_IRQn); __HAL_RCC_UART10_FORCE_RESET(); __HAL_RCC_UART10_RELEASE_RESET(); __HAL_RCC_UART10_CLK_DISABLE(); #endif } }
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 UARTName instance = (UARTName)pinmap_merge(uart_tx, uart_rx); MBED_ASSERT(instance != (UARTName)NC); // Enable USART clock switch (instance) { case UART_1: __HAL_RCC_USART1_FORCE_RESET(); __HAL_RCC_USART1_RELEASE_RESET(); __HAL_RCC_USART1_CLK_ENABLE(); SERIAL_OBJ(index) = 0; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA2_CLK_ENABLE(); #endif break; case UART_2: __HAL_RCC_USART2_FORCE_RESET(); __HAL_RCC_USART2_RELEASE_RESET(); __HAL_RCC_USART2_CLK_ENABLE(); SERIAL_OBJ(index) = 1; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #if defined(USART3_BASE) case UART_3: __HAL_RCC_USART3_FORCE_RESET(); __HAL_RCC_USART3_RELEASE_RESET(); __HAL_RCC_USART3_CLK_ENABLE(); SERIAL_OBJ(index) = 2; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #endif #if defined(UART4_BASE) case UART_4: __HAL_RCC_UART4_FORCE_RESET(); __HAL_RCC_UART4_RELEASE_RESET(); __HAL_RCC_UART4_CLK_ENABLE(); SERIAL_OBJ(index) = 3; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #endif #if defined(UART5_BASE) case UART_5: __HAL_RCC_UART5_FORCE_RESET(); __HAL_RCC_UART5_RELEASE_RESET(); __HAL_RCC_UART5_CLK_ENABLE(); SERIAL_OBJ(index) = 4; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #endif #if defined(USART6_BASE) case UART_6: __HAL_RCC_USART6_FORCE_RESET(); __HAL_RCC_USART6_RELEASE_RESET(); __HAL_RCC_USART6_CLK_ENABLE(); SERIAL_OBJ(index) = 5; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA2_CLK_ENABLE(); #endif break; #endif #if defined(UART7_BASE) case UART_7: __HAL_RCC_UART7_FORCE_RESET(); __HAL_RCC_UART7_RELEASE_RESET(); __HAL_RCC_UART7_CLK_ENABLE(); SERIAL_OBJ(index) = 6; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #endif #if defined(UART8_BASE) case UART_8: __HAL_RCC_UART8_FORCE_RESET(); __HAL_RCC_UART8_RELEASE_RESET(); __HAL_RCC_UART8_CLK_ENABLE(); SERIAL_OBJ(index) = 7; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #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 SERIAL_OBJ(baudrate) = 9600; SERIAL_OBJ(databits) = UART_WORDLENGTH_8B; SERIAL_OBJ(stopbits) = UART_STOPBITS_1; SERIAL_OBJ(parity) = UART_PARITY_NONE; SERIAL_OBJ(pin_tx) = tx; SERIAL_OBJ(pin_rx) = rx; init_uart(obj, instance); #ifndef YOTTA_CFG_MBED_OS // For stdio management if ((int)(UartHandle[SERIAL_OBJ(index)].Instance) == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } #endif DEBUG_PRINTF("UART%u: Init\n", obj->serial.module+1); }
/** * @brief UART MSP De-Initialization * This function frees the hardware resources used in this example: * - Disable the Peripheral's clock * - Revert GPIO and NVIC configuration to their default state * @param huart: UART handle pointer * @retval None */ void HAL_UART_MspDeInit(UART_HandleTypeDef *huart) { switch((uint32_t)huart->Instance) { case (uint32_t)USART1 : { /*##-1- Reset peripherals ##################################################*/ __HAL_RCC_USART1_FORCE_RESET(); __HAL_RCC_USART1_RELEASE_RESET(); __HAL_RCC_USART1_CLK_DISABLE(); /*##-2- Disable peripherals and GPIO Clocks #################################*/ /* Configure UART Tx/Rx as alternate function */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9 | GPIO_PIN_10); /*##-3- Disable the NVIC for UART ##########################################*/ IRQ_Managment(__DISABLE, USART1_IRQn); } break; case (uint32_t)USART2 : { /*##-1- Reset peripherals ##################################################*/ __HAL_RCC_USART2_FORCE_RESET(); __HAL_RCC_USART2_RELEASE_RESET(); __HAL_RCC_USART2_CLK_DISABLE(); /*##-2- Disable peripherals and GPIO Clocks #################################*/ /* Configure UART Tx/Rx as alternate function */ HAL_GPIO_DeInit(GPIOD, GPIO_PIN_5 | GPIO_PIN_6); /*##-3- Disable the NVIC for UART ##########################################*/ IRQ_Managment(__DISABLE, USART2_IRQn); } break; case (uint32_t)USART3 : { /*##-1- Reset peripherals ##################################################*/ __HAL_RCC_USART3_FORCE_RESET(); __HAL_RCC_USART3_RELEASE_RESET(); __HAL_RCC_USART3_CLK_DISABLE(); /*##-2- Disable peripherals and GPIO Clocks #################################*/ /* Configure UART Tx/Rx as alternate function */ HAL_GPIO_DeInit(GPIOD, GPIO_PIN_9 | GPIO_PIN_10); /*##-3- Disable the NVIC for UART ##########################################*/ IRQ_Managment(__DISABLE, USART3_8_IRQn); } break; case (uint32_t)USART4 : { /*##-1- Reset peripherals ##################################################*/ __HAL_RCC_USART4_FORCE_RESET(); __HAL_RCC_USART4_RELEASE_RESET(); __HAL_RCC_USART4_CLK_DISABLE(); /*##-2- Disable peripherals and GPIO Clocks #################################*/ /* Configure UART Tx/Rx as alternate function */ HAL_GPIO_DeInit(GPIOC, GPIO_PIN_10 | GPIO_PIN_11); /*##-3- Disable the NVIC for UART ##########################################*/ IRQ_Managment(__DISABLE, USART3_8_IRQn); } break; case (uint32_t)USART5 : { /*##-1- Reset peripherals ##################################################*/ __HAL_RCC_USART5_FORCE_RESET(); __HAL_RCC_USART5_RELEASE_RESET(); __HAL_RCC_USART5_CLK_DISABLE(); /*##-2- Disable peripherals and GPIO Clocks #################################*/ /* Configure UART Tx/Rx as alternate function */ HAL_GPIO_DeInit(GPIOB, GPIO_PIN_3 | GPIO_PIN_4); /*##-3- Disable the NVIC for UART ##########################################*/ IRQ_Managment(__DISABLE, USART3_8_IRQn); } break; case (uint32_t)USART6 : { /*##-1- Reset peripherals ##################################################*/ __HAL_RCC_USART6_FORCE_RESET(); __HAL_RCC_USART6_RELEASE_RESET(); __HAL_RCC_USART6_CLK_DISABLE(); /*##-2- Disable peripherals and GPIO Clocks #################################*/ /* Configure UART Tx/Rx as alternate function */ HAL_GPIO_DeInit(GPIOF, GPIO_PIN_9 | GPIO_PIN_10); /*##-3- Disable the NVIC for UART ##########################################*/ IRQ_Managment(__DISABLE, USART3_8_IRQn); } break; case (uint32_t)USART7 : { /*##-1- Reset peripherals ##################################################*/ __HAL_RCC_USART7_FORCE_RESET(); __HAL_RCC_USART7_RELEASE_RESET(); __HAL_RCC_USART7_CLK_DISABLE(); /*##-2- Disable peripherals and GPIO Clocks #################################*/ /* Configure UART Tx/Rx as alternate function */ HAL_GPIO_DeInit(GPIOF, GPIO_PIN_2 | GPIO_PIN_3); /*##-3- Disable the NVIC for UART ##########################################*/ IRQ_Managment(__DISABLE, USART3_8_IRQn); } break; case (uint32_t)USART8 : { /*##-1- Reset peripherals ##################################################*/ __HAL_RCC_USART8_FORCE_RESET(); __HAL_RCC_USART8_RELEASE_RESET(); __HAL_RCC_USART8_CLK_DISABLE(); /*##-2- Disable peripherals and GPIO Clocks #################################*/ /* Configure UART Tx/Rx as alternate function */ HAL_GPIO_DeInit(GPIOC, GPIO_PIN_8 | GPIO_PIN_9); /*##-3- Disable the NVIC for UART ##########################################*/ IRQ_Managment(__DISABLE, USART3_8_IRQn); } break; } }