void UART_Init() { __HAL_RCC_USART3_CLK_ENABLE(); __HAL_RCC_DMA1_CLK_ENABLE(); UART_HandleTypeDef huart3; huart3.Instance = USART3; huart3.Init.BaudRate = DEBUG_BAUD; huart3.Init.WordLength = UART_WORDLENGTH_8B; huart3.Init.StopBits = UART_STOPBITS_1; huart3.Init.Parity = UART_PARITY_NONE; huart3.Init.Mode = UART_MODE_TX; huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart3.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&huart3); USART3->CR3 |= USART_CR3_DMAT; // | USART_CR3_DMAR | USART_CR3_OVRDIS; GPIO_InitTypeDef GPIO_InitStruct; GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); DMA1_Channel2->CCR = 0; DMA1_Channel2->CPAR = (uint32_t) & (USART3->DR); DMA1_Channel2->CNDTR = 0; DMA1_Channel2->CCR = DMA_CCR_MINC | DMA_CCR_DIR; DMA1->IFCR = DMA_IFCR_CTCIF2 | DMA_IFCR_CHTIF2 | DMA_IFCR_CGIF2; }
uint8_t usart3_init(void) { //zmienna do zwracania statusu funkcji uint8_t usart_status; //inicjalizacja struktur od GPIO GPIO_InitTypeDef GPIO_InitStruct; usart_status = UART_INIT_ERROR; /* Enable GPIO clock */ __HAL_RCC_GPIOC_CLK_ENABLE(); // Enable clock for USART1 peripheral __HAL_RCC_USART3_CLK_ENABLE(); /* Configure USART Tx as alternate function */ GPIO_InitStruct.Pin = GPIO_PIN_4; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Alternate = GPIO_AF7_USART3; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /* Configure USART Rx as alternate function */ GPIO_InitStruct.Pin = GPIO_PIN_5; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Alternate = GPIO_AF7_USART3; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); //Priorytet przerwania NVIC_SetPriority(USART3_IRQn, 1); NVIC_EnableIRQ(USART3_IRQn); //Handle USART3_HandleStruct.Instance = USART3; USART3_HandleStruct.Init.BaudRate = BAUDRATE_USART3; USART3_HandleStruct.Init.StopBits = USART_STOPBITS_1; USART3_HandleStruct.Init.Parity = USART_PARITY_NONE; USART3_HandleStruct.Init.Mode = USART_MODE_TX_RX; //Init usart_status = HAL_UART_Init(&USART3_HandleStruct); //USART2 enable __HAL_UART_ENABLE(&USART3_HandleStruct); #ifdef USART3_IT_RX_ON USART3 -> CR1 |= USART_CR1_RXNEIE; #endif return usart_status; }
void BSP_UART_Init(void) { GPIO_InitTypeDef GPIO_InitStruct; __GPIOD_CLK_ENABLE() ; __HAL_RCC_USART3_CLK_ENABLE() ; GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_8; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART3; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); UART3_Handle.Instance = USART3; UART3_Handle.Init.BaudRate = 115200; UART3_Handle.Init.WordLength = UART_WORDLENGTH_8B; UART3_Handle.Init.StopBits = UART_STOPBITS_1; UART3_Handle.Init.Parity = UART_PARITY_NONE; UART3_Handle.Init.Mode = UART_MODE_TX_RX; UART3_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; UART3_Handle.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&UART3_Handle); HAL_NVIC_SetPriority(USART3_IRQn, 0, 1); HAL_NVIC_EnableIRQ(USART3_IRQn); HAL_UART_Receive_IT(&UART3_Handle, &dato, 1); }
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) { __USART1_FORCE_RESET(); __USART1_RELEASE_RESET(); __HAL_RCC_USART1_CLK_ENABLE(); obj->index = 0; } if (obj->uart == UART_2) { __USART2_FORCE_RESET(); __USART2_RELEASE_RESET(); __HAL_RCC_USART2_CLK_ENABLE(); obj->index = 1; } if (obj->uart == UART_3) { __USART3_FORCE_RESET(); __USART3_RELEASE_RESET(); __HAL_RCC_USART3_CLK_ENABLE(); obj->index = 2; } // Configure 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)); } }
/** * @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; if(huart->Instance == USART1) { __HAL_RCC_GPIOA_CLK_ENABLE(); /* Enable USARTx clock */ __HAL_RCC_USART1_CLK_ENABLE(); /* UART TX GPIO pin configuration */ GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Pin = GPIO_PIN_9; GPIO_InitStruct.Alternate = GPIO_AF7_USART1; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* UART RX GPIO pin configuration */ GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Alternate = GPIO_AF7_USART1; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); HAL_NVIC_SetPriority(USART1_IRQn, 0, 1); HAL_NVIC_EnableIRQ(USART1_IRQn); } else if(huart->Instance == USART3) { __HAL_RCC_GPIOC_CLK_ENABLE(); /* Enable USARTx clock */ __HAL_RCC_USART3_CLK_ENABLE(); /* UART TX GPIO pin configuration */ GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Alternate = GPIO_AF7_USART3; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /* UART RX GPIO pin configuration */ GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Pin = GPIO_PIN_11; GPIO_InitStruct.Alternate = GPIO_AF7_USART3; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); HAL_NVIC_SetPriority(USART3_IRQn, 0, 1); HAL_NVIC_EnableIRQ(USART3_IRQn); } }
void TUSART<ERegister::rUSART3>::init() { __HAL_RCC_USART3_CLK_ENABLE(); __HAL_RCC_GPIOC_CLK_ENABLE(); TPortPin<ERegister::rGPIOC, 10U> txPin(EPinMode::ALTERNATE_FUNCTION, EOutputType::PUSH_PULL, ESpeed::VERY_HIGH, EPullType::PULL_UP, EAlternateFunction::AF7); TPortPin<ERegister::rGPIOC, 11U> rxPin {EPinMode::ALTERNATE_FUNCTION, EOutputType::PUSH_PULL, ESpeed::VERY_HIGH, EPullType::PULL_UP, EAlternateFunction::AF7}; *sUSART_BRR |= 0x1114U; *sUSART_CR1 |= 0b0010000000001100U; *sUSART_CR2 |= 0b000000000000000U; *sUSART_CR3 |= 0b000000000000U; }
void HAL_UART_MspInit(UART_HandleTypeDef* huart) { GPIO_InitTypeDef GPIO_InitStruct; if(huart->Instance==USART1) { /* USER CODE BEGIN USART1_MspInit 0 */ /* USER CODE END USART1_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART1_CLK_ENABLE(); /**USART1 GPIO Configuration PA9 ------> USART1_TX PA10 ------> USART1_RX */ GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; // GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART1; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USER CODE BEGIN USART1_MspInit 1 */ HAL_NVIC_SetPriority(USART1_IRQn, 0, 1); HAL_NVIC_EnableIRQ(USART1_IRQn); /* USER CODE END USART1_MspInit 1 */ } else if(huart->Instance==USART2) { /* USER CODE BEGIN USART2_MspInit 0 */ /* USER CODE END USART2_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART2_CLK_ENABLE(); /**USART2 GPIO Configuration PD5 ------> USART2_TX PD6 ------> USART2_RX */ GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; // GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART2; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); /* USER CODE BEGIN USART2_MspInit 1 */ HAL_NVIC_SetPriority(USART2_IRQn, 0, 1); HAL_NVIC_EnableIRQ(USART2_IRQn); /* USER CODE END USART2_MspInit 1 */ } else if(huart->Instance==USART3) { /* USER CODE BEGIN USART3_MspInit 0 */ /* USER CODE END USART3_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART3_CLK_ENABLE(); /**USART3 GPIO Configuration PD8 ------> USART3_TX PD9 ------> USART3_RX */ 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_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART3; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); /* USER CODE BEGIN USART3_MspInit 1 */ /* USER CODE END USART3_MspInit 1 */ } }
void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle) { GPIO_InitTypeDef GPIO_InitStruct; if(uartHandle->Instance==USART1) { /* USER CODE BEGIN USART1_MspInit 0 */ /* USER CODE END USART1_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART1_CLK_ENABLE(); /**USART1 GPIO Configuration PA9 ------> USART1_TX PA10 ------> USART1_RX */ GPIO_InitStruct.Pin = GPIO_PIN_9; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_usart1_rx.Instance = DMA1_Channel5; hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart1_rx.Init.Mode = DMA_NORMAL; hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW; if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart1_rx); /* USER CODE BEGIN USART1_MspInit 1 */ __HAL_UART_ENABLE_IT(uartHandle,UART_IT_IDLE); __HAL_DMA_ENABLE_IT(&hdma_usart1_rx,DMA_IT_TC); /* USER CODE END USART1_MspInit 1 */ } else if(uartHandle->Instance==USART3) { /* USER CODE BEGIN USART3_MspInit 0 */ /* USER CODE END USART3_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART3_CLK_ENABLE(); /**USART3 GPIO Configuration PD8 ------> USART3_TX PD9 ------> USART3_RX */ GPIO_InitStruct.Pin = GPIO_PIN_8; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_9; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); __HAL_AFIO_REMAP_USART3_ENABLE(); /* USER CODE BEGIN USART3_MspInit 1 */ /* USER CODE END USART3_MspInit 1 */ } }
/** * Initialize the UART : set pins, enable clocks, set uart, enable interrupt * */ static inline void init(uint32_t baudrate, uint32_t mode) { GPIO_InitTypeDef GPIO_InitStruct; //General settings of pins TX/RX GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; switch (USART_ID) { case 1: UART.Instance = USART1; GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7; // Pins B6 (TX) and B7 (RX) GPIO_InitStruct.Alternate = GPIO_AF7_USART1; __HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_USART1_CLK_ENABLE(); NVIC_SetPriority(USART1_IRQn, 1); NVIC_EnableIRQ(USART1_IRQn); HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); break; case 2: // Série raspberry UART.Instance = USART2; GPIO_InitStruct.Pin = GPIO_PIN_5 | GPIO_PIN_6; // Pins D5 (TX) and D6 (RX) GPIO_InitStruct.Alternate = GPIO_AF7_USART2; __HAL_RCC_GPIOD_CLK_ENABLE(); __HAL_RCC_USART2_CLK_ENABLE(); NVIC_SetPriority(USART2_IRQn, 1); NVIC_EnableIRQ(USART2_IRQn); HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); break; case 3: // Série AX12 UART.Instance = USART3; // HAL_HalfDuplex_Init(&UART); // si un jour on a le temps de configurer correctement les AX12... GPIO_InitStruct.Pin = GPIO_PIN_10; // Pin B10 (TX) GPIO_InitStruct.Alternate = GPIO_AF7_USART3; __HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_USART3_CLK_ENABLE(); NVIC_SetPriority(USART3_IRQn, 1); NVIC_EnableIRQ(USART3_IRQn); HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); break; } //UART setting UART.Init.BaudRate = baudrate; UART.Init.WordLength = UART_WORDLENGTH_8B; // octet comme taille élémentaire (standard) UART.Init.StopBits = UART_STOPBITS_1; // bit de stop = 1 (standard) UART.Init.Parity = UART_PARITY_NONE; // pas de bit de parité (standard) UART.Init.Mode = mode; if (HAL_UART_Init(&UART) != HAL_OK) while(1); __HAL_UART_ENABLE_IT(&UART, UART_IT_RXNE); }
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; }
// 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; }
/** * @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 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; }
void cHAL::Init(void) { __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_CAN2_CLK_ENABLE(); __HAL_RCC_CAN1_CLK_ENABLE(); __HAL_RCC_USART3_CLK_ENABLE(); __HAL_RCC_UART4_CLK_ENABLE(); GPIO_InitTypeDef gi; HAL_StatusTypeDef status; //Enable UART gi.Pin = GPIO_PIN_10 | GPIO_PIN_11; //C10=TX, C11=RX gi.Mode = GPIO_MODE_AF_PP; gi.Pull = GPIO_PULLUP; gi.Speed = GPIO_SPEED_LOW; gi.Alternate = GPIO_AF7_USART3; HAL_GPIO_Init(GPIOC, &gi); InitAndTestUSART(); //Onboard LEDs gi.Mode = GPIO_MODE_OUTPUT_PP; gi.Alternate = 0; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_LOW; gi.Pin = GPIO_PIN_7; HAL_GPIO_Init(GPIOB, &gi); LOGI(BSP::SUCCESSFUL_STRING, "GPIO for LED"); if(InitDWTCounter()) { LOGI(BSP::SUCCESSFUL_STRING, "DWTCounter"); } else { LOGE(NOT_SUCCESSFUL_STRING, "DWTCounter"); } //MP3-Player gi.Pin = GPIO_PIN_0 | GPIO_PIN_1; //A0=USART4_TX, A1=USART4_RX, Kerbe nach oben; ansicht von Pinseite, rechts von oben //VCC, RX, TX, DACR, DACL, SPK1, GND, SPK2 //Also: PA0 --> RX gi.Mode = GPIO_MODE_AF_PP; gi.Pull = GPIO_PULLUP; gi.Speed = GPIO_SPEED_LOW; gi.Alternate = GPIO_AF8_UART4; HAL_GPIO_Init(GPIOA, &gi); BELL.Instance = UART4; BELL.Init.BaudRate = 9600; BELL.Init.WordLength = UART_WORDLENGTH_8B; BELL.Init.StopBits = UART_STOPBITS_1; BELL.Init.Parity = UART_PARITY_NONE; BELL.Init.Mode = UART_MODE_TX_RX; BELL.Init.HwFlowCtl = UART_HWCONTROL_NONE; BELL.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&BSP::BELL); LOGI(SUCCESSFUL_STRING, "UART4 for MP3-Module"); __I2C1_CLK_ENABLE(); __I2C2_CLK_ENABLE(); /* PB08 ------> I2C1_SCL PB09 ------> I2C1_SDA */ gi.Pin = GPIO_PIN_8 | GPIO_PIN_9; gi.Mode = GPIO_MODE_AF_OD; gi.Pull = GPIO_PULLUP; gi.Speed = GPIO_SPEED_MEDIUM; gi.Alternate = GPIO_AF4_I2C1; HAL_GPIO_Init(GPIOB, &gi); /* PB10 ------> I2C2_SCL PB11 ------> I2C2_SDA */ gi.Pin = GPIO_PIN_10 | GPIO_PIN_11; gi.Mode = GPIO_MODE_AF_OD; gi.Pull = GPIO_PULLUP; gi.Speed = GPIO_SPEED_MEDIUM; gi.Alternate = GPIO_AF4_I2C2; HAL_GPIO_Init(GPIOB, &gi); i2cbus[0].Instance = I2C1; i2cbus[0].Init.ClockSpeed = 100000; i2cbus[0].Init.DutyCycle = I2C_DUTYCYCLE_2; i2cbus[0].Init.OwnAddress1 = 0; i2cbus[0].Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; i2cbus[0].Init.DualAddressMode = I2C_DUALADDRESS_DISABLED; i2cbus[0].Init.OwnAddress2 = 0; i2cbus[0].Init.GeneralCallMode = I2C_GENERALCALL_DISABLED; i2cbus[0].Init.NoStretchMode = I2C_NOSTRETCH_DISABLED; HAL_I2C_Init(&i2cbus[0]); LOGI("I2C1 configured for onboard digital io"); i2cbus[1].Instance = I2C2; i2cbus[1].Init.ClockSpeed = 100000; i2cbus[1].Init.DutyCycle = I2C_DUTYCYCLE_2; i2cbus[1].Init.OwnAddress1 = 0; i2cbus[1].Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; i2cbus[1].Init.DualAddressMode = I2C_DUALADDRESS_DISABLED; i2cbus[1].Init.OwnAddress2 = 0; i2cbus[1].Init.GeneralCallMode = I2C_GENERALCALL_DISABLED; i2cbus[1].Init.NoStretchMode = I2C_NOSTRETCH_DISABLED; HAL_I2C_Init(&BSP::i2c2); LOGI(BSP::SUCCESSFUL_STRING, "I2C2 for 1wire and external"); if(drivers::cPCA9685::SoftwareReset(&BSP::i2c1)) { LOGI(SUCCESSFUL_STRING, "i2c1 reset"); } else { LOGE(NOT_SUCCESSFUL_STRING, "i2c1 reset"); } if(pca9685_U7.Setup())//next to CPU, all A-Pins @ GND b01 { LOGI(SUCCESSFUL_STRING, "pca9685_U7"); } else { LOGE(NOT_SUCCESSFUL_STRING, "pca9685_U7"); } if(pca9685_U9.Setup()) { LOGI(SUCCESSFUL_STRING, "pca9685_U9"); } else { LOGE(NOT_SUCCESSFUL_STRING, "pca9685_U9"); } //Interrupt-Pins for PCA9555 gi.Pin = GPIO_PIN_0|GPIO_PIN_1; gi.Mode = GPIO_MODE_INPUT; gi.Pull = GPIO_PULLUP; HAL_GPIO_Init(GPIOC, &gi); if(pca9555_U19.Setup()) { LOGI(BSP::SUCCESSFUL_STRING, "pca9555_U19"); } else { LOGE(BSP::NOT_SUCCESSFUL_STRING, "pca9555_U19"); } if(pca9555_U18.Setup()) { LOGI(BSP::SUCCESSFUL_STRING, "pca9555_U18"); } else { LOGE(BSP::NOT_SUCCESSFUL_STRING, "pca9555_U18"); } uint16_t tmp = pca9555_U18.GetInput(); inputState[WORD_I2C] = (inputState[WORD_I2C] & 0xFFFF0000) + tmp; tmp = pca9555_U19.GetInput(); inputState[WORD_I2C] = (inputState[WORD_I2C] & 0x0000FFFF) + (tmp << 16); rcSwitch.enableReceive(); if(drivers::cPCA9685::SoftwareReset(&BSP::i2c2)) { LOGI(SUCCESSFUL_STRING, "i2c2 reset"); } else { LOGE(NOT_SUCCESSFUL_STRING, "i2c2 reset"); } SearchI2C("I2C2", &i2c2); Init1wire(); //Enable Rotary Encoder Switch Input gi.Mode = GPIO_MODE_INPUT; gi.Alternate = 0; gi.Pull = GPIO_PULLUP; gi.Speed = GPIO_SPEED_LOW; gi.Pin = GPIO_PIN_13; HAL_GPIO_Init(GPIOC, &gi); LOGI(SUCCESSFUL_STRING, "GPIO for Rotary Encoder"); #ifdef DCF77 //DCF77 gi.Mode = GPIO_MODE_INPUT; gi.Alternate=0; gi.Pull=GPIO_PULLUP; gi.Speed=GPIO_SPEED_FREQ_LOW; gi.Pin=DCF77_PIN; HAL_GPIO_Init(DCF77_PORT, &gi); #endif #endif //=====PWM-Timers //=============== //Overall GPIO-Settings //All gpios enabled! gi.Mode = GPIO_MODE_AF_PP; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_HIGH; //Overall base timer settings TIM_HandleTypeDef TimHandle; TimHandle.Init.Prescaler = 0; TimHandle.Init.Period = UINT16_MAX; TimHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP; //Overall OC-settings TIM_OC_InitTypeDef sConfig; sConfig.OCMode = TIM_OCMODE_PWM1; sConfig.OCPolarity = TIM_OCPOLARITY_HIGH; sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH; sConfig.OCFastMode = TIM_OCFAST_DISABLE; sConfig.OCIdleState = TIM_OCIDLESTATE_RESET; sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET; sConfig.Pulse = 0; //===Slow Timers (84MHz) TIM4 and TIM12 //TIM1, TIM8 SystemCoreClock/1 //Others SystemCoreClock/2 //Prescaler (uint16_t) ((SystemCoreClock / 1 bzw 2) / TimerTickFrq) - 1; //Einstellungen führen zu PWM-Frequenz von 116,5Hz (rechnerisch ermittelt, per LogicAnalyzer bestätigt) #ifdef SENSACTHS07 TimHandle.Init.Prescaler = 10; //for 84MHz-Timers __TIM12_CLK_ENABLE() ; gi.Pin = GPIO_PIN_14 | GPIO_PIN_15; gi.Alternate = GPIO_AF9_TIM12; HAL_GPIO_Init(GPIOB, &gi); TimHandle.Instance = TIM12; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB14 O1.1 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); ///PB15 O1.2 CLEAR_BIT(TIM12->CCMR1, TIM_CCMR1_OC1PE); CLEAR_BIT(TIM12->CCMR1, TIM_CCMR1_OC2PE); LOGI(BSP::SUCCESSFUL_STRING, "TIM12"); //===Fast Timers (168MHz) TIM1 and TIM8 TimHandle.Init.Prescaler = 20; __TIM8_CLK_ENABLE() ; gi.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_9; gi.Alternate = GPIO_AF3_TIM8; HAL_GPIO_Init(GPIOC, &gi); TimHandle.Instance = TIM8; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //C6 O1.3 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //C7 O1.4 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4); //C9 O1.5 CLEAR_BIT(TIM8->CCMR1, TIM_CCMR1_OC1PE); CLEAR_BIT(TIM8->CCMR1, TIM_CCMR1_OC2PE); CLEAR_BIT(TIM8->CCMR2, TIM_CCMR2_OC4PE); LOGI(SUCCESSFUL_STRING, "TIM8"); __TIM1_CLK_ENABLE() ; gi.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10; gi.Alternate = GPIO_AF1_TIM1; HAL_GPIO_Init(GPIOA, &gi); TimHandle.Instance = TIM1; TIM_ClockConfigTypeDef sClockSourceConfig; TIM_MasterConfigTypeDef sMasterConfig; TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig; HAL_TIM_Base_Init(&TimHandle); sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL; HAL_TIM_ConfigClockSource(&TimHandle, &sClockSourceConfig); HAL_TIM_PWM_Init(&TimHandle); sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; HAL_TIMEx_MasterConfigSynchronization(&TimHandle, &sMasterConfig); sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE; sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE; sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF; sBreakDeadTimeConfig.DeadTime = 0; sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE; sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH; sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE; HAL_TIMEx_ConfigBreakDeadTime(&TimHandle, &sBreakDeadTimeConfig); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //A8 O1.6 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //A9 O1.7 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3); //A10 O1.8 CLEAR_BIT(TIM1->CCMR1, TIM_CCMR1_OC1PE); CLEAR_BIT(TIM1->CCMR1, TIM_CCMR1_OC2PE); CLEAR_BIT(TIM1->CCMR2, TIM_CCMR2_OC3PE); LOGI(SUCCESSFUL_STRING, "TIM1"); #endif #ifdef SENSACTHS04 TimHandle.Init.Prescaler = 10; //for 84MHz-Timers __TIM4_CLK_ENABLE(); gi.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9; gi.Alternate = GPIO_AF2_TIM4; HAL_GPIO_Init(GPIOB, &gi); TimHandle.Instance = TIM4; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB6 o2.1 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //PB7 o2.2 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3); //PB8 o1.1 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4); //PB9 o1.2 TIM4->CCMR1 &= ~TIM_CCMR1_OC1PE; TIM4->CCMR1 &= ~TIM_CCMR1_OC2PE; TIM4->CCMR2 &= ~TIM_CCMR2_OC3PE; TIM4->CCMR2 &= ~TIM_CCMR2_OC4PE; LOGI(SUCCESSFUL_STRING, "TIM4"); __TIM12_CLK_ENABLE(); gi.Pin = GPIO_PIN_14 | GPIO_PIN_15; gi.Alternate = GPIO_AF9_TIM12; HAL_GPIO_Init(GPIOB, &gi); TimHandle.Instance = TIM12; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB14 O7.2 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); ///PB15 O4.1 TIM12->CCMR1 &= ~TIM_CCMR1_OC1PE; TIM12->CCMR1 &= ~TIM_CCMR1_OC2PE; LOGI(SUCCESSFUL_STRING, "TIM12"); //===Fast Timers (168MHz) TIM1 and TIM8 TimHandle.Init.Prescaler = 20; __TIM1_CLK_ENABLE(); gi.Pin = GPIO_PIN_8; gi.Alternate = GPIO_AF1_TIM1; HAL_GPIO_Init(GPIOA, &gi); TimHandle.Instance = TIM1; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3); TIM1->CCMR1 &= ~TIM_CCMR1_OC1PE; TIM1->CCMR2 &= ~TIM_CCMR2_OC3PE; LOGI(SUCCESSFUL_STRING, "TIM1"); __TIM8_CLK_ENABLE(); gi.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_9; gi.Alternate = GPIO_AF3_TIM8; HAL_GPIO_Init(GPIOC, &gi); TimHandle.Instance = TIM8; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4); TIM8->CCMR1 &= ~TIM_CCMR1_OC1PE; TIM8->CCMR1 &= ~TIM_CCMR1_OC2PE; TIM8->CCMR2 &= ~TIM_CCMR2_OC4PE; LOGI(SUCCESSFUL_STRING, "TIM8"); #endif //===SPI for Relais //PA15=LATCH,PB3=CLK PB4=MISO, PB5=MOSI //DRV8066 DIN=2, CLK(low@inak)=3, Latch@pos edge=4 __SPI3_CLK_ENABLE() ; gi.Pin = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5; gi.Mode = GPIO_MODE_AF_PP; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_HIGH; gi.Alternate = GPIO_AF6_SPI3; HAL_GPIO_Init(GPIOB, &gi); #ifdef SENSACTHS07 BSP::spi.Init.DataSize = SPI_DATASIZE_8BIT; HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_SET); gi.Pin = GPIO_PIN_14; gi.Mode = GPIO_MODE_OUTPUT_PP; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_MEDIUM; HAL_GPIO_Init(GPIOC, &gi); #endif #ifdef SENSACTHS04 BSP::spi.Init.DataSize = SPI_DATASIZE_16BIT; HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET); gi.Pin = GPIO_PIN_15; gi.Mode = GPIO_MODE_OUTPUT_PP; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_MEDIUM; HAL_GPIO_Init(GPIOA, &gi); #endif BSP::spi.Instance = SPI3; BSP::spi.Init.Mode = SPI_MODE_MASTER; BSP::spi.Init.Direction = SPI_DIRECTION_2LINES; BSP::spi.Init.CLKPolarity = SPI_POLARITY_LOW; BSP::spi.Init.CLKPhase = SPI_PHASE_1EDGE; BSP::spi.Init.NSS = SPI_NSS_SOFT; BSP::spi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128; BSP::spi.Init.FirstBit = SPI_FIRSTBIT_MSB; BSP::spi.Init.TIMode = SPI_TIMODE_DISABLED; BSP::spi.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED; BSP::spi.Init.CRCPolynomial = 1; status = HAL_SPI_Init(&BSP::spi); if (status != HAL_OK) { LOGE("Unable to configure SPI for Relays"); while(1) {}; } uint8_t tx[] = {0, 0, 0}; #ifdef SENSACTHS07 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_RESET); HAL_SPI_Transmit(&BSP::spi, tx, 3, 100); HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_SET); LOGI(SUCCESSFUL_STRING, "SPI for DRV8860"); #endif #ifdef SENSACTHS04 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET); if (HAL_SPI_Transmit(&BSP::spi, tx, 1, 100) == HAL_OK) { LOGI(SUCCESSFUL_STRING, "SPI for DRV8860"); } else { LOGE(NOT_SUCCESSFUL_STRING, "SPI for DRV8860"); } HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET); #endif /**CAN2 GPIO Configuration PB12 ------> CAN2_RX PB13 ------> CAN2_TX */ gi.Pin = GPIO_PIN_12 | GPIO_PIN_13; gi.Mode = GPIO_MODE_AF_PP; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_LOW; gi.Alternate = GPIO_AF9_CAN2; HAL_GPIO_Init(GPIOB, &gi); InitCAN(); return; }
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 }
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); obj->baudrate = 9600; // Default excepted for LPUART_1 (see below) // Enable UART clock if (obj->uart == UART_1) { __HAL_RCC_USART1_CLK_ENABLE(); obj->index = 0; } if (obj->uart == UART_2) { __HAL_RCC_USART2_CLK_ENABLE(); obj->index = 1; } if (obj->uart == UART_3) { __HAL_RCC_USART3_CLK_ENABLE(); obj->index = 2; } if (obj->uart == UART_4) { __HAL_RCC_UART4_CLK_ENABLE(); obj->index = 3; } if (obj->uart == UART_5) { __HAL_RCC_UART5_CLK_ENABLE(); obj->index = 4; } if (obj->uart == LPUART_1) { __HAL_RCC_LPUART1_CLK_ENABLE(); obj->baudrate = 38400; // Maximum peripheral clock is 4096 x BR -> This is the minimum BR with 80 MHz peripheral clock. obj->index = 5; } // 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->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)); } }
/** * @brief UART MSP Initialization * This function configures the hardware resources used in this example * @param huart: UART handle pointer * @retval None */ void HAL_UART_MspInit(UART_HandleTypeDef* huart) { GPIO_InitTypeDef GPIO_InitStruct = {0}; if(huart->Instance==USART1) { /* USER CODE BEGIN USART1_MspInit 0 */ /* USER CODE END USART1_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART1_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); /**USART1 GPIO Configuration PA9 ------> USART1_TX PA10 ------> USART1_RX */ GPIO_InitStruct.Pin = GPIO_PIN_9; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USART1 interrupt Init */ HAL_NVIC_SetPriority(USART1_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART1_IRQn); /* USER CODE BEGIN USART1_MspInit 1 */ /* USER CODE END USART1_MspInit 1 */ } else if(huart->Instance==USART2) { /* USER CODE BEGIN USART2_MspInit 0 */ /* USER CODE END USART2_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART2_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); /**USART2 GPIO Configuration PA2 ------> USART2_TX PA3 ------> USART2_RX */ GPIO_InitStruct.Pin = GPIO_PIN_2; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_3; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USER CODE BEGIN USART2_MspInit 1 */ /* USER CODE END USART2_MspInit 1 */ } else if(huart->Instance==USART3) { /* USER CODE BEGIN USART3_MspInit 0 */ /* USER CODE END USART3_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART3_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); /**USART3 GPIO Configuration PB10 ------> USART3_TX PB11 ------> USART3_RX */ GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_11; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* USER CODE BEGIN USART3_MspInit 1 */ /* USER CODE END USART3_MspInit 1 */ } }
void HAL_UART_MspInit(UART_HandleTypeDef* huart) { GPIO_InitTypeDef GPIO_InitStruct; if(huart->Instance==UART5) { /* USER CODE BEGIN UART5_MspInit 0 */ /* USER CODE END UART5_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_UART5_CLK_ENABLE(); /**UART5 GPIO Configuration PC12 ------> UART5_TX PD2 ------> UART5_RX */ GPIO_InitStruct.Pin = GPIO_PIN_12; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF8_UART5; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_2; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF8_UART5; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_uart5_tx.Instance = DMA1_Stream7; hdma_uart5_tx.Init.Channel = DMA_CHANNEL_4; hdma_uart5_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_uart5_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_uart5_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_uart5_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_uart5_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_uart5_tx.Init.Mode = DMA_NORMAL; hdma_uart5_tx.Init.Priority = DMA_PRIORITY_LOW; hdma_uart5_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; HAL_DMA_Init(&hdma_uart5_tx); __HAL_LINKDMA(huart,hdmatx,hdma_uart5_tx); /* Peripheral interrupt init */ HAL_NVIC_SetPriority(UART5_IRQn, 0, 0); HAL_NVIC_EnableIRQ(UART5_IRQn); /* USER CODE BEGIN UART5_MspInit 1 */ /* USER CODE END UART5_MspInit 1 */ } else if(huart->Instance==USART3) { /* USER CODE BEGIN USART3_MspInit 0 */ /* USER CODE END USART3_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART3_CLK_ENABLE(); /**USART3 GPIO Configuration PB10 ------> USART3_TX PB11 ------> USART3_RX */ 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_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART3; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* USER CODE BEGIN USART3_MspInit 1 */ /* USER CODE END USART3_MspInit 1 */ } }
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); }
void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle) { GPIO_InitTypeDef GPIO_InitStruct; if(uartHandle->Instance==USART1) { /* USER CODE BEGIN USART1_MspInit 0 */ /* USER CODE END USART1_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART1_CLK_ENABLE(); /**USART1 GPIO Configuration PB6 ------> USART1_TX PB7 ------> USART1_RX */ GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* USER CODE BEGIN USART1_MspInit 1 */ /* USER CODE END USART1_MspInit 1 */ } else if(uartHandle->Instance==USART2) { /* USER CODE BEGIN USART2_MspInit 0 */ /* USER CODE END USART2_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART2_CLK_ENABLE(); /**USART2 GPIO Configuration PD5 ------> USART2_TX PD6 ------> USART2_RX */ GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART2; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); /* USER CODE BEGIN USART2_MspInit 1 */ /* USER CODE END USART2_MspInit 1 */ } else if(uartHandle->Instance==USART3) { /* USER CODE BEGIN USART3_MspInit 0 */ /* USER CODE END USART3_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART3_CLK_ENABLE(); /**USART3 GPIO Configuration PD8 ------> USART3_TX PD9 ------> USART3_RX */ 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_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART3; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); /* USER CODE BEGIN USART3_MspInit 1 */ /* USER CODE END USART3_MspInit 1 */ } }
void HAL_UART_MspInit(UART_HandleTypeDef* huart) { GPIO_InitTypeDef GPIO_InitStruct; if(huart->Instance==UART4) { /* USER CODE BEGIN UART4_MspInit 0 */ /* USER CODE END UART4_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_UART4_CLK_ENABLE(); /**UART4 GPIO Configuration PA0-WKUP ------> UART4_TX PA1 ------> UART4_RX */ GPIO_InitStruct.Pin = COMMS_TX_U4_Pin|COMMS_RX_U4_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF8_UART4; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_uart4_tx.Instance = DMA1_Stream4; hdma_uart4_tx.Init.Channel = DMA_CHANNEL_4; hdma_uart4_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_uart4_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_uart4_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_uart4_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_uart4_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_uart4_tx.Init.Mode = DMA_NORMAL; hdma_uart4_tx.Init.Priority = DMA_PRIORITY_LOW; hdma_uart4_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; if (HAL_DMA_Init(&hdma_uart4_tx) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(huart,hdmatx,hdma_uart4_tx); /* Peripheral interrupt init */ HAL_NVIC_SetPriority(UART4_IRQn, 5, 0); HAL_NVIC_EnableIRQ(UART4_IRQn); /* USER CODE BEGIN UART4_MspInit 1 */ /* USER CODE END UART4_MspInit 1 */ } else if(huart->Instance==USART1) { /* USER CODE BEGIN USART1_MspInit 0 */ /* USER CODE END USART1_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART1_CLK_ENABLE(); /**USART1 GPIO Configuration PA9 ------> USART1_TX PA10 ------> USART1_RX */ GPIO_InitStruct.Pin = EPS_TX_U1_Pin|EPS_RX_U1_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART1; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_usart1_tx.Instance = DMA2_Stream7; hdma_usart1_tx.Init.Channel = DMA_CHANNEL_4; hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart1_tx.Init.Mode = DMA_NORMAL; hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW; hdma_usart1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(huart,hdmatx,hdma_usart1_tx); /* Peripheral interrupt init */ HAL_NVIC_SetPriority(USART1_IRQn, 5, 0); HAL_NVIC_EnableIRQ(USART1_IRQn); /* USER CODE BEGIN USART1_MspInit 1 */ /* USER CODE END USART1_MspInit 1 */ } else if(huart->Instance==USART2) { /* USER CODE BEGIN USART2_MspInit 0 */ /* USER CODE END USART2_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART2_CLK_ENABLE(); /**USART2 GPIO Configuration PA2 ------> USART2_TX PA3 ------> USART2_RX */ GPIO_InitStruct.Pin = SU_TX_U2_Pin|SU_RX_U2_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART2; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_usart2_tx.Instance = DMA1_Stream6; hdma_usart2_tx.Init.Channel = DMA_CHANNEL_4; hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart2_tx.Init.Mode = DMA_NORMAL; hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW; hdma_usart2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; if (HAL_DMA_Init(&hdma_usart2_tx) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(huart,hdmatx,hdma_usart2_tx); /* Peripheral interrupt init */ HAL_NVIC_SetPriority(USART2_IRQn, 5, 0); HAL_NVIC_EnableIRQ(USART2_IRQn); /* USER CODE BEGIN USART2_MspInit 1 */ /* USER CODE END USART2_MspInit 1 */ } else if(huart->Instance==USART3) { /* USER CODE BEGIN USART3_MspInit 0 */ /* USER CODE END USART3_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART3_CLK_ENABLE(); /**USART3 GPIO Configuration PB10 ------> USART3_TX PB11 ------> USART3_RX */ GPIO_InitStruct.Pin = DBG_TX_U3_Pin|DBG_RX_U3_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART3; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_usart3_tx.Instance = DMA1_Stream3; hdma_usart3_tx.Init.Channel = DMA_CHANNEL_4; hdma_usart3_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_usart3_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart3_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart3_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart3_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart3_tx.Init.Mode = DMA_NORMAL; hdma_usart3_tx.Init.Priority = DMA_PRIORITY_LOW; hdma_usart3_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; if (HAL_DMA_Init(&hdma_usart3_tx) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(huart,hdmatx,hdma_usart3_tx); /* Peripheral interrupt init */ HAL_NVIC_SetPriority(USART3_IRQn, 5, 0); HAL_NVIC_EnableIRQ(USART3_IRQn); /* USER CODE BEGIN USART3_MspInit 1 */ /* USER CODE END USART3_MspInit 1 */ } else if(huart->Instance==USART6) { /* USER CODE BEGIN USART6_MspInit 0 */ /* USER CODE END USART6_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART6_CLK_ENABLE(); /**USART6 GPIO Configuration PC6 ------> USART6_TX PC7 ------> USART6_RX */ GPIO_InitStruct.Pin = ADCS_TX_U6_Pin|ADCS_RX_U6_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF8_USART6; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_usart6_tx.Instance = DMA2_Stream6; hdma_usart6_tx.Init.Channel = DMA_CHANNEL_5; hdma_usart6_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_usart6_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart6_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart6_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart6_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart6_tx.Init.Mode = DMA_NORMAL; hdma_usart6_tx.Init.Priority = DMA_PRIORITY_LOW; hdma_usart6_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; if (HAL_DMA_Init(&hdma_usart6_tx) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(huart,hdmatx,hdma_usart6_tx); /* Peripheral interrupt init */ HAL_NVIC_SetPriority(USART6_IRQn, 5, 0); HAL_NVIC_EnableIRQ(USART6_IRQn); /* USER CODE BEGIN USART6_MspInit 1 */ /* USER CODE END USART6_MspInit 1 */ } }
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)); } }
/*#####################################################*/ 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); }