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)); } }
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 SERIAL_OBJ(uart) = (UARTName)pinmap_merge(uart_tx, uart_rx); MBED_ASSERT(SERIAL_OBJ(uart) != (UARTName)NC); // Enable USART clock switch (SERIAL_OBJ(uart)) { case UART_1: __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_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_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_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_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_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_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_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); // For stdio management if (SERIAL_OBJ(uart) == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
void systemInit(void) { // Priority grouping should be setup before any irq prio is set. HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITY_GROUPING); // GPIO ports are always used so it makes sense to just enable the clocks to the available ports #ifdef GPIOA __HAL_RCC_GPIOA_CLK_ENABLE(); #endif #ifdef GPIOB __HAL_RCC_GPIOB_CLK_ENABLE(); #endif #ifdef GPIOC __HAL_RCC_GPIOC_CLK_ENABLE(); #endif #ifdef GPIOD __HAL_RCC_GPIOD_CLK_ENABLE(); #endif #ifdef GPIOE __HAL_RCC_GPIOE_CLK_ENABLE(); #endif #ifdef GPIOF __HAL_RCC_GPIOF_CLK_ENABLE(); #endif // It makes it all lot easier if we just enable to DMA clocks, the additional idle current is neglectable #ifdef DMA1 __HAL_RCC_DMA1_CLK_ENABLE(); #endif #ifdef DMA2 __HAL_RCC_DMA2_CLK_ENABLE(); #endif /* Select SysClk as source of USART1 clocks */ RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit; RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1; RCC_PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_SYSCLK; HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit); // Init clocks of used peripherals #ifdef USE_USART1 __HAL_RCC_USART1_CLK_ENABLE(); #endif #ifdef USE_USART2 __HAL_RCC_USART2_CLK_ENABLE(); #endif #ifdef USE_USART3 __HAL_RCC_USART3_CLK_ENABLE(); #endif #ifdef USE_USART4 __HAL_RCC_UART4_CLK_ENABLE(); #endif #ifdef USE_USART5 __HAL_RCC_UART5_CLK_ENABLE(); #endif #ifdef USE_USART6 __HAL_RCC_USART6_CLK_ENABLE(); #endif #ifdef USE_USART7 __HAL_RCC_UART7_CLK_ENABLE(); #endif #ifdef USE_USART8 __HAL_RCC_UART8_CLK_ENABLE(); #endif }
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; }
//-------------------------------------------------------------- // interne Funktion // init vom Comport //-------------------------------------------------------------- static void P_BSP_COM_Init(UART_NAME_t uart) { GPIO_InitTypeDef gpio_init_structure; #if USE_UART1 == 1 if (uart == COM1) { // GPIO Clock Enable UB_System_ClockEnable(COM1_TX_PORT); UB_System_ClockEnable(COM1_RX_PORT); // UART Clock Enable __HAL_RCC_USART1_CLK_ENABLE(); // GPIO TX gpio_init_structure.Pin = COM1_TX_PIN; gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Speed = GPIO_SPEED_FAST; gpio_init_structure.Pull = GPIO_PULLUP; gpio_init_structure.Alternate = GPIO_AF7_USART1; HAL_GPIO_Init(COM1_TX_PORT, &gpio_init_structure); // GPIO RX gpio_init_structure.Pin = COM1_RX_PIN; gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Alternate = GPIO_AF7_USART1; HAL_GPIO_Init(COM1_RX_PORT, &gpio_init_structure); } #endif #if USE_UART6 == 1 if (uart == COM6) { // GPIO Clock Enable memset(&rx_buf6[0], 0, RX_BUF_SIZE + 1); // ** WK ** UB_System_ClockEnable(COM6_TX_PORT); UB_System_ClockEnable(COM6_RX_PORT); // UART Clock Enable __HAL_RCC_USART6_CLK_ENABLE(); // GPIO TX gpio_init_structure.Pin = COM6_TX_PIN; gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Speed = GPIO_SPEED_FAST; gpio_init_structure.Pull = GPIO_PULLUP; gpio_init_structure.Alternate = GPIO_AF8_USART6; HAL_GPIO_Init(COM6_TX_PORT, &gpio_init_structure); // GPIO RX gpio_init_structure.Pin = COM6_RX_PIN; gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Alternate = GPIO_AF8_USART6; HAL_GPIO_Init(COM6_RX_PORT, &gpio_init_structure); } #endif #if USE_UART7 == 1 if (uart == COM7) { // GPIO Clock Enable UB_System_ClockEnable(COM7_TX_PORT); UB_System_ClockEnable(COM7_RX_PORT); // UART Clock Enable __HAL_RCC_UART7_CLK_ENABLE(); // GPIO TX gpio_init_structure.Pin = COM7_TX_PIN; gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Speed = GPIO_SPEED_FAST; gpio_init_structure.Pull = GPIO_PULLUP; gpio_init_structure.Alternate = GPIO_AF8_UART7; HAL_GPIO_Init(COM7_TX_PORT, &gpio_init_structure); // GPIO RX gpio_init_structure.Pin = COM7_RX_PIN; gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Alternate = GPIO_AF8_UART7; HAL_GPIO_Init(COM7_RX_PORT, &gpio_init_structure); } #endif }
void enableGPIOPowerUsageAndNoiseReductions(void) { // AHB1 __HAL_RCC_BKPSRAM_CLK_ENABLE(); __HAL_RCC_DTCMRAMEN_CLK_ENABLE(); __HAL_RCC_DMA2_CLK_ENABLE(); __HAL_RCC_USB_OTG_HS_CLK_ENABLE(); __HAL_RCC_USB_OTG_HS_ULPI_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_GPIOD_CLK_ENABLE(); __HAL_RCC_GPIOE_CLK_ENABLE(); __HAL_RCC_GPIOF_CLK_ENABLE(); __HAL_RCC_GPIOG_CLK_ENABLE(); __HAL_RCC_GPIOH_CLK_ENABLE(); __HAL_RCC_GPIOI_CLK_ENABLE(); #ifndef STM32F722xx __HAL_RCC_DMA2D_CLK_ENABLE(); __HAL_RCC_GPIOJ_CLK_ENABLE(); __HAL_RCC_GPIOK_CLK_ENABLE(); #endif //APB1 __HAL_RCC_TIM2_CLK_ENABLE(); __HAL_RCC_TIM3_CLK_ENABLE(); __HAL_RCC_TIM4_CLK_ENABLE(); __HAL_RCC_TIM5_CLK_ENABLE(); __HAL_RCC_TIM6_CLK_ENABLE(); __HAL_RCC_TIM7_CLK_ENABLE(); __HAL_RCC_TIM12_CLK_ENABLE(); __HAL_RCC_TIM13_CLK_ENABLE(); __HAL_RCC_TIM14_CLK_ENABLE(); __HAL_RCC_LPTIM1_CLK_ENABLE(); __HAL_RCC_SPI2_CLK_ENABLE(); __HAL_RCC_SPI3_CLK_ENABLE(); __HAL_RCC_USART2_CLK_ENABLE(); __HAL_RCC_USART3_CLK_ENABLE(); __HAL_RCC_UART4_CLK_ENABLE(); __HAL_RCC_UART5_CLK_ENABLE(); __HAL_RCC_I2C1_CLK_ENABLE(); __HAL_RCC_I2C2_CLK_ENABLE(); __HAL_RCC_I2C3_CLK_ENABLE(); __HAL_RCC_CAN1_CLK_ENABLE(); __HAL_RCC_DAC_CLK_ENABLE(); __HAL_RCC_UART7_CLK_ENABLE(); __HAL_RCC_UART8_CLK_ENABLE(); #ifndef STM32F722xx __HAL_RCC_I2C4_CLK_ENABLE(); __HAL_RCC_CAN2_CLK_ENABLE(); __HAL_RCC_CEC_CLK_ENABLE(); #endif //APB2 __HAL_RCC_TIM1_CLK_ENABLE(); __HAL_RCC_TIM8_CLK_ENABLE(); __HAL_RCC_USART1_CLK_ENABLE(); __HAL_RCC_USART6_CLK_ENABLE(); __HAL_RCC_ADC1_CLK_ENABLE(); __HAL_RCC_ADC2_CLK_ENABLE(); __HAL_RCC_ADC3_CLK_ENABLE(); __HAL_RCC_SDMMC1_CLK_ENABLE(); __HAL_RCC_SPI1_CLK_ENABLE(); __HAL_RCC_SPI4_CLK_ENABLE(); __HAL_RCC_TIM9_CLK_ENABLE(); __HAL_RCC_TIM10_CLK_ENABLE(); __HAL_RCC_TIM11_CLK_ENABLE(); __HAL_RCC_SPI5_CLK_ENABLE(); __HAL_RCC_SAI1_CLK_ENABLE(); __HAL_RCC_SAI2_CLK_ENABLE(); #ifndef STM32F722xx __HAL_RCC_SPI6_CLK_ENABLE(); #endif // // GPIO_InitTypeDef GPIO_InitStructure; // GPIO_StructInit(&GPIO_InitStructure); // GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; // default is un-pulled input // // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; // GPIO_InitStructure.GPIO_Pin &= ~(GPIO_Pin_11 | GPIO_Pin_12); // leave USB D+/D- alone // // GPIO_InitStructure.GPIO_Pin &= ~(GPIO_Pin_13 | GPIO_Pin_14); // leave JTAG pins alone // GPIO_Init(GPIOA, &GPIO_InitStructure); // // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; // GPIO_Init(GPIOB, &GPIO_InitStructure); // // GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; // GPIO_Init(GPIOC, &GPIO_InitStructure); // GPIO_Init(GPIOD, &GPIO_InitStructure); // GPIO_Init(GPIOE, &GPIO_InitStructure); }
// 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; }
// assumes Init parameters have been set up correctly STATIC bool uart_init2(pyb_uart_obj_t *uart_obj) { 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 (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_RTS) { pins[2] = MICROPY_HW_UART2_RTS; } #endif #if defined(MICROPY_HW_UART2_CTS) if (uart_obj->uart.Init.HwFlowCtl & 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; irqn = USART3_IRQn; pins[0] = MICROPY_HW_UART3_TX; pins[1] = MICROPY_HW_UART3_RX; #if defined(MICROPY_HW_UART3_RTS) if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_RTS) { pins[2] = MICROPY_HW_UART3_RTS; } #endif #if defined(MICROPY_HW_UART3_CTS) if (uart_obj->uart.Init.HwFlowCtl & 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; UARTx = UART4; irqn = UART4_IRQn; pins[0] = MICROPY_HW_UART4_TX; pins[1] = MICROPY_HW_UART4_RX; __HAL_RCC_UART4_CLK_ENABLE(); break; #endif #if defined(MICROPY_HW_UART5_TX) && defined(MICROPY_HW_UART5_RX) case PYB_UART_5: uart_unit = 5; UARTx = UART5; irqn = UART5_IRQn; pins[0] = MICROPY_HW_UART5_TX; pins[1] = MICROPY_HW_UART5_RX; __HAL_RCC_UART5_CLK_ENABLE(); break; #endif #if defined(MICROPY_HW_UART6_TX) && defined(MICROPY_HW_UART6_RX) case PYB_UART_6: uart_unit = 6; UARTx = USART6; irqn = USART6_IRQn; pins[0] = MICROPY_HW_UART6_TX; pins[1] = MICROPY_HW_UART6_RX; #if defined(MICROPY_HW_UART6_RTS) if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_RTS) { pins[2] = MICROPY_HW_UART6_RTS; } #endif #if defined(MICROPY_HW_UART6_CTS) if (uart_obj->uart.Init.HwFlowCtl & 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; UARTx = UART7; irqn = UART7_IRQn; pins[0] = MICROPY_HW_UART7_TX; pins[1] = MICROPY_HW_UART7_RX; __HAL_RCC_UART7_CLK_ENABLE(); break; #endif #if defined(MICROPY_HW_UART8_TX) && defined(MICROPY_HW_UART8_RX) case PYB_UART_8: uart_unit = 8; UARTx = UART8; irqn = UART8_IRQn; pins[0] = MICROPY_HW_UART8_TX; pins[1] = MICROPY_HW_UART8_RX; __HAL_RCC_UART8_CLK_ENABLE(); 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->irqn = irqn; uart_obj->uart.Instance = UARTx; // init UARTx HAL_UART_Init(&uart_obj->uart); uart_obj->is_enabled = true; return true; }
/*#####################################################*/ bool _uart_open(Uart_t* UartSettings) { GPIO_InitTypeDef GPIO_InitStruct; /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ _gpio_init(UartSettings->TxPort); _gpio_init(UartSettings->RxPort); //USARTx_TX_GPIO_CLK_ENABLE(); //USARTx_RX_GPIO_CLK_ENABLE(); /* Enable USART1 clock */ switch(UartSettings->UartNr) { #ifdef __HAL_RCC_USART1_CLK_ENABLE case 0: __HAL_RCC_USART1_CLK_ENABLE(); break; #endif #ifdef __HAL_RCC_USART2_CLK_ENABLE case 1: __HAL_RCC_USART2_CLK_ENABLE(); break; #endif #ifdef __HAL_RCC_USART3_CLK_ENABLE case 2: __HAL_RCC_USART3_CLK_ENABLE(); break; #endif #ifdef __HAL_RCC_UART4_CLK_ENABLE case 3: __HAL_RCC_UART4_CLK_ENABLE(); break; #endif #ifdef __HAL_RCC_UART5_CLK_ENABLE case 4: __HAL_RCC_UART5_CLK_ENABLE(); break; #endif #ifdef __HAL_RCC_USART6_CLK_ENABLE case 5: __HAL_RCC_USART6_CLK_ENABLE(); break; #endif #ifdef __HAL_RCC_UART7_CLK_ENABLE case 6: __HAL_RCC_UART7_CLK_ENABLE(); break; #endif #ifdef __HAL_RCC_UART8_CLK_ENABLE case 7: __HAL_RCC_UART8_CLK_ENABLE(); break; #endif } //USARTx_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = 1 << UartSettings->TxPin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; switch(UartSettings->UartNr) { case 0: case 1: case 2: GPIO_InitStruct.Alternate = GPIO_AF7_USART1; break; case 3: case 4: case 5: case 6: case 7: GPIO_InitStruct.Alternate = GPIO_AF8_UART4; break; default: return false; } //GPIO_InitStruct.Alternate = USARTx_TX_AF; HAL_GPIO_Init(GET_GPIO_PORT_ADDR[UartSettings->TxPort], &GPIO_InitStruct); /* UART RX GPIO pin configuration */ GPIO_InitStruct.Pin = 1 << UartSettings->RxPin; //GPIO_InitStruct.Alternate = USARTx_RX_AF; HAL_GPIO_Init(GET_GPIO_PORT_ADDR[UartSettings->RxPort], &GPIO_InitStruct); UartSettings->udata = calloc(1, sizeof(UART_HandleTypeDef)); if(!UartSettings->udata) return false; UART_HandleTypeDef *UartHandle = (UART_HandleTypeDef *)UartSettings->udata; //USART_DeInit(COM_USART[UartSettings->UartNr]); //UART_nvic_config(UartSettings); UartSettings->BaseAddr = (unsigned int)UartSettings; UartHandle->Instance = COM_USART[UartSettings->UartNr]; UartHandle->Init.BaudRate = UartSettings->BaudRate; UartHandle->Init.WordLength = UART_WORDLENGTH_8B; UartHandle->Init.StopBits = UART_STOPBITS_1; UartHandle->Init.Parity = UART_PARITY_NONE; UartHandle->Init.HwFlowCtl = UART_HWCONTROL_NONE; UartHandle->Init.Mode = UART_MODE_TX_RX; UartHandle->Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(UartHandle); return true;//UartOpen(UartSettings); }