/* USART2 init function */ void MX_USART2_UART_Init(void) { huart2.Instance = USART2; huart2.Init.BaudRate = 38400; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX_RX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart2.Init.OverSampling = UART_OVERSAMPLING_16; huart2.Init.OneBitSampling = UART_ONEBIT_SAMPLING_DISABLED ; huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; HAL_UART_Init(&huart2); }
/** * @brief Initializes the CDC media low layer * @param None * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Itf_Init(void) { /*##-1- Configure the UART peripheral ######################################*/ /* Put the USART peripheral in the Asynchronous mode (UART Mode) */ /* USART configured as follow: - Word Length = 8 Bits - Stop Bit = One Stop bit - Parity = No parity - BaudRate = 115200 baud - Hardware flow control disabled (RTS and CTS signals) */ UartHandle.Instance = USARTx; UartHandle.Init.BaudRate = 115200; 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; if(HAL_UART_Init(&UartHandle) != HAL_OK) { /* Initialization Error */ Error_Handler(); } /*##-2- Put UART peripheral in IT reception process ########################*/ /* Any data received will be stored in "UserTxBuffer" buffer */ if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)UserTxBuffer, 1) != HAL_OK) { /* Transfer error in reception process */ Error_Handler(); } /*##-3- Configure the TIM Base generation #################################*/ TIM_Config(); /*##-4- Start the TIM Base generation in interrupt mode ####################*/ /* Start Channel1 */ if(HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK) { /* Starting Error */ Error_Handler(); } /*##-5- Set Application Buffers ############################################*/ USBD_CDC_SetTxBuffer(&USBD_Device_HS, UserTxBuffer, 0); USBD_CDC_SetRxBuffer(&USBD_Device_HS, UserRxBuffer); return (USBD_OK); }
static void uart_init(void) { UartHandle.Instance = USART2; UartHandle.Init.BaudRate = 115200; 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; if(HAL_UART_Init(&UartHandle) != HAL_OK) { Error_Handler(); } }
void MX_USART2_UART_Init(void) { huart2.Instance = USART2; huart2.Init.BaudRate = 921600; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX_RX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart2.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&huart2); }
/** * @brief Initializes the UART * @param None * @retval None */ ErrorStatus UART1_Init() { /* Make sure we only initialize it once */ if (!prvInitialized) { /* Init GPIO */ UART_GPIO_CLK_ENABLE(); GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.Pin = UART_TX_PIN; GPIO_InitStructure.Mode = GPIO_MODE_AF_PP; GPIO_InitStructure.Pull = GPIO_NOPULL; GPIO_InitStructure.Speed = GPIO_SPEED_HIGH; HAL_GPIO_Init(UART_PORT, &GPIO_InitStructure); GPIO_InitStructure.Pin = UART_RX_PIN; GPIO_InitStructure.Mode = GPIO_MODE_AF_INPUT; HAL_GPIO_Init(UART_PORT, &GPIO_InitStructure); /* Init the RX Buffer */ prvRxBufferIn = &prvRxBuffer[0]; prvRxBufferOut = &prvRxBuffer[0]; prvRxBufferCount = 0; /* Enable UART clock */ __HAL_RCC_USART1_CLK_ENABLE(); /* Init the UART */ UART_Handle.Instance = USART1; UART_Handle.Init.BaudRate = 115200; UART_Handle.Init.WordLength = UART_WORDLENGTH_8B; UART_Handle.Init.StopBits = UART_STOPBITS_1; UART_Handle.Init.Parity = UART_PARITY_NONE; UART_Handle.Init.Mode = UART_MODE_TX_RX; UART_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; if (HAL_UART_Init(&UART_Handle) != HAL_OK) return ERROR; /* Enable the UART Data Register not empty Interrupt */ __HAL_UART_ENABLE_IT(&UART_Handle, UART_IT_RXNE); /* NVIC for USART */ HAL_NVIC_SetPriority(USART1_IRQn, 0, 1); HAL_NVIC_EnableIRQ(USART1_IRQn); prvInitialized = true; return SUCCESS; } return ERROR; }
/* Uplink DMA 2 (port-to-port) setup */ void UplinkDMA2_Setup(UART_HandleTypeDef* huartSrc, UART_HandleTypeDef* huartDst) { /* UART RX DMA (DMA1 Ch3) */ if (huartSrc->Instance == USART1) { __HAL_DMA1_REMAP(HAL_DMA1_CH3_USART1_RX); } else if (huartSrc->Instance == USART2) { __HAL_DMA1_REMAP(HAL_DMA1_CH3_USART2_RX); } else if (huartSrc->Instance == USART3) { __HAL_DMA1_REMAP(HAL_DMA1_CH3_USART3_RX); } else if (huartSrc->Instance == USART4) { __HAL_DMA1_REMAP(HAL_DMA1_CH3_USART4_RX); } else if (huartSrc->Instance == USART5) { __HAL_DMA1_REMAP(HAL_DMA1_CH3_USART5_RX); } else if (huartSrc->Instance == USART6) { __HAL_DMA1_REMAP(HAL_DMA1_CH3_USART6_RX); } else if (huartSrc->Instance == USART7) { __HAL_DMA1_REMAP(HAL_DMA1_CH3_USART7_RX); } else if (huartSrc->Instance == USART8) { __HAL_DMA1_REMAP(HAL_DMA1_CH3_USART8_RX); } __HAL_LINKDMA(huartSrc,hdmarx,uplinkDMA2); /* Setup streaming baudrate */ huartSrc->Init.BaudRate = 3000000; HAL_UART_Init(huartSrc); huartDst->Init.BaudRate = 3000000; HAL_UART_Init(huartDst); /* DMA interrupt init */ HAL_NVIC_SetPriority(DMA1_Ch2_3_DMA2_Ch1_2_IRQn, 0, 0); HAL_NVIC_EnableIRQ(DMA1_Ch2_3_DMA2_Ch1_2_IRQn); /* Start DMA stream */ huartSrc->State = HAL_UART_STATE_READY; HAL_UART_Receive_DMA(huartSrc, (uint8_t *)(&(huartDst->Instance->TDR)), 1); }
void HardwareSerial::begin(uint32_t baud) { HAL_StatusTypeDef status; if ( huart6.Init.BaudRate != baud ) { HAL_UART_DeInit(&huart6); huart6.Init.BaudRate = baud; HAL_UART_Init(&huart6); } this->tx_in_progress = false; this->rx_buffer_bytes_available = 0; this->rx_buffer_index = 0; receive_request_pending = false; status = HAL_UART_Receive_IT(&huart6, &this->rx_buffer[this->rx_buffer_index], 1); }
/* USART6 init function */ static void MX_USART6_UART_Init(void) { huart6.Instance = USART6; huart6.Init.BaudRate = 115200; huart6.Init.WordLength = UART_WORDLENGTH_8B; huart6.Init.StopBits = UART_STOPBITS_1; huart6.Init.Parity = UART_PARITY_NONE; huart6.Init.Mode = UART_MODE_TX_RX; huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart6.Init.OverSampling = UART_OVERSAMPLING_16; if (HAL_UART_Init(&huart6) != HAL_OK) { Error_Handler(); } }
void LBF_UART1_Init (void) { // Based on Cube MX huart1.Instance = USART1; huart1.Init.BaudRate = 115200; huart1.Init.WordLength = UART_WORDLENGTH_8B; huart1.Init.StopBits = UART_STOPBITS_1; huart1.Init.Parity = UART_PARITY_NONE; huart1.Init.Mode = UART_MODE_TX_RX; huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart1.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&huart1); }
/* USART2 init function */ void MX_USART2_UART_Init(void){ huart2.Instance = USART2; huart2.Init.BaudRate = 115200; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX_RX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart2.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&huart2); // initilisation de l'affichage à chaque Reset SendStr("\n\r UART "); SendStr("\r\n control :# "); }
void board_uart_init (long baud_rate) { // see Clive Example that works fine (uses old Std Lib, not HAL) //#if defined(USES_CONSOLE_WRITE) || defined(USES_CONSOLE_READ) || defined(USES_DEBUG_LOG) GPIO_InitTypeDef GPIO_InitStruct; //-------------------------------------------------- // Configure the GPIOs that used for the UART pins // Most Nucleos use: // PA.2 = USART2_TX PA.3 = USART2_RX // But L4 Discovery uses: // PD.5 = USART2_TX PD.6 = USART2_RX //-------------------------------------------------- // change to internal pin_MuxConfig() instead ??? !!! WVD ??? !!! #if defined(USE_STM32L476G_DISCO_REVB) GPIO_InitStruct.Pin = GPIO_PIN_5 | GPIO_PIN_6; // PD5 / PD6 #else GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_3; // PA2 / PA3 #endif GPIO_InitStruct.Alternate = GPIO_AF7_USART2; // set Alt Function = UART GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; #if defined(USE_STM32L476G_DISCO_REVB) HAL_GPIO_Init (GPIOD, &GPIO_InitStruct); // Setup UART GPIO D port pins #else HAL_GPIO_Init (GPIOA, &GPIO_InitStruct); // Setup UART GPIO A port pins #endif //-------------------------------------------------- // Configure the UART module. //-------------------------------------------------- __HAL_RCC_USART2_CLK_ENABLE(); // Turn on UART clocks _g_UartHandle.Instance = USART2; // Set UART module to use _g_UartHandle.Init.BaudRate = baud_rate; _g_UartHandle.Init.WordLength = UART_WORDLENGTH_8B; // setup as 8N1 _g_UartHandle.Init.StopBits = UART_STOPBITS_1; _g_UartHandle.Init.Parity = UART_PARITY_NONE; // no parity KEY ! _g_UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE; // No flow ctl _g_UartHandle.Init.OverSampling = UART_OVERSAMPLING_16; _g_UartHandle.Init.Mode = UART_MODE_TX_RX; // Enable RX and TX HAL_UART_Init (&_g_UartHandle); //#endif }
uart::uart ( void) { huart.Instance = USARTx; huart.Init.BaudRate = 115200; huart.Init.WordLength = UART_WORDLENGTH_8B; huart.Init.StopBits = UART_STOPBITS_1; huart.Init.Parity = UART_PARITY_NONE; huart.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart.Init.Mode = UART_MODE_TX_RX; huart.Init.OverSampling = UART_OVERSAMPLING_16; GPIO_InitTypeDef GPIO_InitStruct; /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ USARTx_TX_GPIO_CLK_ENABLE(); USARTx_RX_GPIO_CLK_ENABLE(); /* Enable USART1 clock */ USARTx_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = USARTx_TX_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Alternate = USARTx_TX_AF; HAL_GPIO_Init(USARTx_TX_GPIO_PORT, &GPIO_InitStruct); /* UART RX GPIO pin configuration */ GPIO_InitStruct.Pin = USARTx_RX_PIN; GPIO_InitStruct.Alternate = USARTx_RX_AF; HAL_GPIO_Init(USARTx_RX_GPIO_PORT, &GPIO_InitStruct); /*##-3- Configure the NVIC for UART ########################################*/ /* NVIC for USARTx */ HAL_NVIC_SetPriority(USARTx_IRQn, 0, 1); HAL_NVIC_EnableIRQ(USARTx_IRQn); if( HAL_UART_Init( &huart) != HAL_OK) asm("bkpt 0"); HAL_StatusTypeDef status; status=HAL_UART_Receive_IT( &huart, (uint8_t *)0x01, 1); // dummy call to switch RX on if( status != HAL_OK) asm("bkpt 0"); }
/** * @brief Main program * @param None * @retval None */ int main(void) { /* STM32F3xx HAL library initialization: - Configure the Flash prefetch - Configure the Systick to generate an interrupt each 1 msec - Set NVIC Group Priority to 4 - Low Level Initialization */ HAL_Init(); /* Configure the system clock to 64 MHz */ SystemClock_Config(); /* Initialize BSP Led for LED2 */ BSP_LED_Init(LED2); /*##-1- Configure the UART peripheral ######################################*/ /* Put the USART peripheral in the Asynchronous mode (UART Mode) */ /* UART configured as follows: - Word Length = 8 Bits (7 data bit + 1 parity bit) : BE CAREFUL : Program 7 data bits + 1 parity bit in PC HyperTerminal - Stop Bit = One Stop bit - Parity = ODD parity - BaudRate = 9600 baud - Hardware flow control disabled (RTS and CTS signals) */ UartHandle.Instance = USARTx; UartHandle.Init.BaudRate = 9600; UartHandle.Init.WordLength = UART_WORDLENGTH_8B; UartHandle.Init.StopBits = UART_STOPBITS_1; UartHandle.Init.Parity = UART_PARITY_ODD; UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE; UartHandle.Init.Mode = UART_MODE_TX_RX; if (HAL_UART_Init(&UartHandle) != HAL_OK) { /* Initialization Error */ Error_Handler(); } /* Output a message on Hyperterminal using printf function */ printf("\n\r UART Printf Example: retarget the C library printf function to the UART\n\r"); printf("** Test finished successfully. ** \n\r"); /* Infinite loop */ while (1) { } }
/***************************************************************** Name : void UART_BAUD(uint32_t value) Fuction : config the uart baud Input : baud value Output : void Author : @hiyangdong Version : V0.1 Time : 30 Nov. 2015 *****************************************************************/ void UART_BAUD(uint32_t value) { #if BLE_UART == huart1 BLE_UART.Instance = USART1; #elif BLE_UART == huart2 BLE_UART.Instance = USART2; #endif BLE_UART.Init.BaudRate = value; BLE_UART.Init.WordLength = UART_WORDLENGTH_8B; BLE_UART.Init.StopBits = UART_STOPBITS_1; BLE_UART.Init.Parity = UART_PARITY_NONE; BLE_UART.Init.Mode = UART_MODE_TX_RX; BLE_UART.Init.HwFlowCtl = UART_HWCONTROL_NONE; BLE_UART.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&BLE_UART); }
void USART_Configuration(UART_HandleTypeDef* usartHandle) { usartHandle->Instance = USART1; usartHandle->Init.BaudRate = 9600; usartHandle->Init.WordLength = UART_WORDLENGTH_8B; usartHandle->Init.StopBits = UART_STOPBITS_1; usartHandle->Init.Parity = UART_PARITY_NONE; usartHandle->Init.HwFlowCtl = UART_HWCONTROL_NONE; usartHandle->Init.Mode = UART_MODE_TX_RX; usartHandle->Init.OverSampling = UART_OVERSAMPLING_16; if (HAL_UART_Init(usartHandle) != HAL_OK) { errorHandler("USART_INIT"); } __HAL_UART_ENABLE(usartHandle); }
/** * @brief Enables the RS232 interface with the current settings * @param None * @retval None */ static void prvEnableRs232Interface() { /* Enable UART clock */ __UART4_CLK_ENABLE(); /* Configure priority and enable interrupt */ HAL_NVIC_SetPriority(UART4_IRQn, configLIBRARY_LOWEST_INTERRUPT_PRIORITY, 0); HAL_NVIC_EnableIRQ(UART4_IRQn); /* Enable the UART */ HAL_UART_Init(&UART_Handle); /* If we are in RX mode we should start receiving data */ if (UART_Handle.Init.Mode == UARTMode_RX || UART_Handle.Init.Mode == UARTMode_TX_RX) HAL_UART_Receive_IT(&UART_Handle, &prvReceivedByte, 1); }
/*====================================================================================================*/ void Serial_Config( void ) { GPIO_InitTypeDef GPIO_InitStruct; /* UART Clk ******************************************************************/ UARTx_TX_GPIO_CLK_ENABLE(); UARTx_RX_GPIO_CLK_ENABLE(); UARTx_CLK_ENABLE(); /* UART Pin ******************************************************************/ GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Pin = GPIO_PIN_15; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_7; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Pin = UARTx_TX_PIN; GPIO_InitStruct.Alternate = UARTx_TX_AF; HAL_GPIO_Init(UARTx_TX_GPIO_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = UARTx_RX_PIN; GPIO_InitStruct.Alternate = UARTx_RX_AF; HAL_GPIO_Init(UARTx_RX_GPIO_PORT, &GPIO_InitStruct); /* UART Init *****************************************************************/ Serial_HandleStruct.Instance = UARTx; Serial_HandleStruct.Init.BaudRate = UARTx_BAUDRATE; Serial_HandleStruct.Init.WordLength = UARTx_BYTESIZE; Serial_HandleStruct.Init.StopBits = UARTx_STOPBITS; Serial_HandleStruct.Init.Parity = UARTx_PARITY; Serial_HandleStruct.Init.HwFlowCtl = UARTx_HARDWARECTRL; Serial_HandleStruct.Init.Mode = UARTx_MODE; Serial_HandleStruct.Init.OverSampling = UARTx_OVERSAMPLE; HAL_UART_Init(&Serial_HandleStruct); /* UART Enable ***************************************************************/ __HAL_UART_ENABLE(&Serial_HandleStruct); __HAL_UART_CLEAR_FLAG(&Serial_HandleStruct, UART_FLAG_TC); }
/** * @brief CDC_Init_FS * Initializes the CDC media low layer over the FS USB IP * @param None * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL */ static int8_t CDC_Init_FS(void) { husb = &hUsbDeviceFS; /* Configure the USART with some sensible defaults TODO: If possible, don't drive TX high while CDC is "closed"? */ huart2.Instance = USART2; huart2.Init.BaudRate = 115200; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX_RX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart2.Init.OverSampling = UART_OVERSAMPLING_16; huart2.Init.OneBitSampling = UART_ONEBIT_SAMPLING_DISABLED ; huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; HAL_UART_Init(&huart2); /* Enable USART2 in NVIC, set priority to high */ NVIC_SetPriority(USART2_IRQn, USART_IRQ_PRIORITY); NVIC_EnableIRQ(USART2_IRQn); /* UART2 receives data to the CDC transmit buffer, byte at a time :( */ if(HAL_UART_Receive_IT(&huart2, usart2cdc_rx, 1) != HAL_OK) return USBD_FAIL; /* Configure USB transmit timer */ husbtimer.Instance = TIM3; husbtimer.Init.Period = 10000 - 1; /* approx 10ms, I think... */ husbtimer.Init.Prescaler = 48-1; husbtimer.Init.ClockDivision = 0; husbtimer.Init.CounterMode = TIM_COUNTERMODE_UP; if(HAL_TIM_Base_Init(&husbtimer) != HAL_OK) return USBD_FAIL; __TIM3_CLK_ENABLE(); NVIC_SetPriority(TIM3_IRQn, USB_TIMER_IRQ_PRIORITY); NVIC_EnableIRQ(TIM3_IRQn); /* Set Application USB Buffers */ USBD_CDC_SetTxBuffer(husb, usart2cdc_tx, 0); /* don't send anything now */ USBD_CDC_SetRxBuffer(husb, cdc2usart_buf_a); /* read into here if CDC data comes */ return USBD_OK; }
/*! * @brief enable or disable CTS hardware flow control on open device * @retval 0 on success * @retval -1 on failure * @param[in] obj pointer to object instance * @param[in] enabled non-zero value enable flow control * @note serial port must be opened */ int serial_set_cts_flow(serial *obj, int enable) { struct_uart *uart; serial_private *prv; prv = (serial_private *)obj->prv; uart = (struct_uart *)(prv->fd); if (prv->fd < 0) { return(-1); } if(HAL_UART_Init(uart->handle) != HAL_OK){ return 1; } return 0; }
/***************************************************************** Name : void BLE_BAUD(uint32_t value) Fuction : config the Baud Input : baud value Output : void Author : @hiyangdong Version : V0.1 Time : 30 Nov. 2015 *****************************************************************/ void BLE_BAUD(uint32_t value) { BLE_CFG(CFG); HAL_Delay(100); if(value == 4800) HAL_UART_Transmit(&huart2 , "<BAUD4800>", 12, 100); if(value == 9600) HAL_UART_Transmit(&huart2 , "<BAUD9600>", 12, 100); if(value == 19200) HAL_UART_Transmit(&huart2 , "<BAUD19200>", 12, 100); if(value == 38400) HAL_UART_Transmit(&huart2 , "<BAUD38400>", 12, 100); if(value == 57600) HAL_UART_Transmit(&huart2 , "<BAUD57600>", 12, 100); if(value == 115200) HAL_UART_Transmit(&huart2 , "<BAUD115200>", 12, 100); if(value == 256000) HAL_UART_Transmit(&huart2 , "<BAUD256000>", 12, 100); HAL_Delay(100); BLE_CFG(TRA); huart2.Init.BaudRate = value; HAL_UART_Init(&huart2); }
/** * @brief Main program * @param None * @retval None */ int main(void) { /* STM32F4xx HAL library initialization: - Configure the Flash prefetch, instruction and Data caches - Configure the Systick to generate an interrupt each 1 msec - Set NVIC Group Priority to 4 - Global MSP (MCU Support Package) initialization */ HAL_Init(); /* Configure the system clock to 100 MHz */ SystemClock_Config(); /*##-1- Configure the UART peripheral ######################################*/ /* Put the USART peripheral in the Asynchronous mode (UART Mode) */ /* UART1 configured as follows: - Word Length = 7 Bits - Stop Bit = One Stop bit - Parity = ODD parity - BaudRate = 9600 baud - Hardware flow control disabled (RTS and CTS signals) */ UartHandle.Instance = USARTx; UartHandle.Init.BaudRate = 9600; UartHandle.Init.WordLength = UART_WORDLENGTH_8B; UartHandle.Init.StopBits = UART_STOPBITS_1; UartHandle.Init.Parity = UART_PARITY_ODD; UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE; UartHandle.Init.Mode = UART_MODE_TX_RX; UartHandle.Init.OverSampling = UART_OVERSAMPLING_16; if(HAL_UART_Init(&UartHandle) != HAL_OK) { /* Initialization Error */ Error_Handler(); } /* Output a message on Hyperterminal using printf function */ printf("\n\r UART Printf Example: retarget the C library printf function to the UART\n\r"); /* Infinite loop */ while (1) { } }
/** * @brief Uart Initialization Function. * @param numUart: numero della periferica UART da inizializzare. * numUart può assumere uno dei seguenti valori: * @arg HELPER_UART1: periferica UART 1; * @arg HELPER_UART2: periferica UART 2. * @arg HELPER_UART3: periferica UART 3; * @arg HELPER_UART4: periferica UART 4. * @arg HELPER_UART5: periferica UART 5; * @arg HELPER_UART6: periferica UART 6. * * @retval Stato, che può assumere uno dei seguenti valori: * @arg HELPER_UART_OK: inizializzazione avvenuta con successo; * @arg HELPER_UART_ERROR: Errore qualsiasi avvenuto durante l'Inizializzazione. */ HELPER_UART_Status_TypeDef HELPER_UART_Init(HELPER_UART_TypeDef numUart){ //A seconda della periferica mi riferisco ad un Handle Specifico UART_HandleTypeDef *UartHandle_x=HELPER_UART_GetHandle(numUart); if(HAL_UART_GetState(UartHandle_x) == HAL_UART_STATE_RESET) { /* UART configuration -----------------------------------------------------*/ UartHandle_x->Instance = HELPER_UART(numUart); UartHandle_x->Init.Mode = HELPER_UART_MODE(numUart); UartHandle_x->Init.WordLength = HELPER_UART_LENGHT(numUart); UartHandle_x->Init.StopBits = HELPER_UART_STOP_B(numUart); UartHandle_x->Init.Parity = HELPER_UART_PARITY(numUart); UartHandle_x->Init.BaudRate = HELPER_UART_BAUDRATE(numUart); UartHandle_x->Init.HwFlowCtl = HELPER_UART_HWCONTROL(numUart); UartHandle_x->Init.OverSampling= HELPER_UART_OVERSAMPLING(numUart); //La HAL_UART_MspInit(UartHandle_x) sarà chiamata internamente dalla HAL_XYZ_Init(..) HAL_StatusTypeDef status = 0; switch(HELPER_UART_FUNCTIONAL_MODE(numUart)) { case HELPER_UART_HALF_DUPLEX_MODE: status = HAL_HalfDuplex_Init(UartHandle_x);break; case HELPER_UART_LIN_MODE: status = HAL_LIN_Init(UartHandle_x,UART_LINBREAKDETECTLENGTH_11B);break; case HELPER_UART_MULTIPROCESSOR_MODE: status = HAL_MultiProcessor_Init(UartHandle_x, HELPER_UART_MULTIPROCESSOR_ADDRESS(numUart), HELPER_UART_MULTIPROCESSOR_WAKEUP_METHOD(numUart) ); break; default: status = HAL_UART_Init(UartHandle_x); } if(status!=HAL_OK) return HELPER_UART_ERROR; else return HELPER_UART_OK; } else return HELPER_UART_ERROR; }
void UART_Config(void) { /* -- Configure UART/DEBUG interface -- */ UART_DBG_Handle.Instance = UART_DBG; UART_DBG_Handle.Init.BaudRate = 115200; UART_DBG_Handle.Init.WordLength = UART_WORDLENGTH_8B; UART_DBG_Handle.Init.StopBits = UART_STOPBITS_1; UART_DBG_Handle.Init.Parity = UART_PARITY_NONE; UART_DBG_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; UART_DBG_Handle.Init.Mode = UART_MODE_TX; UART_DBG_Handle.Init.OverSampling = UART_OVERSAMPLING_16; if (HAL_UART_Init(&UART_DBG_Handle) != HAL_OK) { error_handler(); } }
/********************************** 函数实现区 *********************************/ void console_init(void) { s_uart_handle.Instance = CONSOLE_UART; s_uart_handle.Init.BaudRate = CONSOLE_BAUDRATE; s_uart_handle.Init.WordLength = UART_WORDLENGTH_8B; s_uart_handle.Init.StopBits = UART_STOPBITS_1; s_uart_handle.Init.Parity = UART_PARITY_NONE; s_uart_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; s_uart_handle.Init.Mode = UART_MODE_TX_RX; s_uart_handle.Init.OverSampling = UART_OVERSAMPLING_16; if(HAL_UART_Init(&s_uart_handle) != HAL_OK) { while(1); } return; }
/** * This is a brief description. * This is a detail description. * @param[in] inArgName input argument description. * @param[out] outArgName output argument description. * @retval * @retval * @par * * @par * * @par History * 2016-5-21 Huang Shengda */ void CP15UsartInit() { /* Put the UART peripheral in the Asynchronous mode (UART Mode) */ UartHandle_cp15.Instance = UART_CP15; UartHandle_cp15.Init.BaudRate = 9600; UartHandle_cp15.Init.WordLength = UART_WORDLENGTH_8B; UartHandle_cp15.Init.StopBits = UART_STOPBITS_1; UartHandle_cp15.Init.Parity = UART_PARITY_NONE; UartHandle_cp15.Init.HwFlowCtl = UART_HWCONTROL_NONE; UartHandle_cp15.Init.Mode = UART_MODE_TX_RX; UartHandle_cp15.Init.OverSampling = UART_OVERSAMPLING_8; if(HAL_UART_Init(&UartHandle_cp15) != HAL_OK) { /* Initialization Error */ } }
int main(void) { //-- HAL 초기화 // HAL_Init(); //-- BSP 초기화 // BSP_LED_Init(LED2); // Configure the system clock to 84 MHz // SystemClock_Config(); UartHandle.Instance = USARTx; UartHandle.Init.BaudRate = 115200; 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; if(HAL_UART_Init(&UartHandle) != HAL_OK) { /* Initialization Error */ Error_Handler(); } /* Output a message on Hyperterminal using printf function */ printf("\n\r UART Printf Example: retarget the C library printf function to the UART\n\r"); /* Infinite loop */ while (1) { BSP_LED_Toggle(LED2); HAL_Delay(1000); printf("UART Printf \n\r"); } }
void vigserialInit(int mode) { if (mode!=CMD_INTERACTIVE) return; GPIO_InitTypeDef GPIO_InitStruct; /* Configure the GPIO pins for the UART */ __GPIOC_CLK_ENABLE(); GPIO_InitStruct.Pin = GPIO_PIN_5; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = 7; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_4; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = 7; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); __USART1_CLK_ENABLE(); /* Put the USART peripheral in the Asynchronous mode (UART Mode) */ /* UART configured as follows: - Word Length = 8 Bits - Stop Bit = One Stop bit - Parity = ODD parity - BaudRate = UARTBAUDRATE baud - Hardware flow control disabled (RTS and CTS signals) */ UartHandle.Instance = USART1; UartHandle.Init.BaudRate = 9600; 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; if (HAL_UART_Init(&UartHandle) != HAL_OK) { /* Initialization Error */ Error_Handler(); } printf("UART Initialiser\n"); }
void MX_USART1_UART_Init(void) { huart1.Instance = USART1; huart1.Init.BaudRate = 115200; huart1.Init.WordLength = UART_WORDLENGTH_8B; huart1.Init.StopBits = UART_STOPBITS_1; huart1.Init.Parity = UART_PARITY_NONE; huart1.Init.Mode = UART_MODE_TX_RX; huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart1.Init.OverSampling = UART_OVERSAMPLING_16; huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; if (HAL_UART_Init(&huart1) != HAL_OK) { Error_Handler(); } }
static void init_uart(serial_t *obj) { UartHandle.Instance = (USART_TypeDef *)(obj->uart); UartHandle.Init.BaudRate = obj->baudrate; UartHandle.Init.WordLength = obj->databits; UartHandle.Init.StopBits = obj->stopbits; UartHandle.Init.Parity = obj->parity; UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE; if (obj->pin_rx == NC) { UartHandle.Init.Mode = UART_MODE_TX; } else if (obj->pin_tx == NC) { UartHandle.Init.Mode = UART_MODE_RX; } else { UartHandle.Init.Mode = UART_MODE_TX_RX; } HAL_UART_Init(&UartHandle); }
void Init_Peripheral(void) { /*##-1- Configure the UART peripheral ######################################*/ /* Put the USART peripheral in the Asynchronous mode (UART Mode) */ /* UART1 configured as follow: - Word Length = 8 Bits - Stop Bit = One Stop bit - Parity = None - BaudRate = 9600 baud - Hardware flow control disabled (RTS and CTS signals) */ UartHandle.Instance = USARTx; UartHandle.Init.BaudRate = 9600; 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; if(HAL_UART_Init(&UartHandle) != HAL_OK) { Error_Handler(); } /*##-1- Configure the I2C peripheral #######################################*/ I2CxHandle_2.Instance = I2Cx_2; I2CxHandle_2.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; I2CxHandle_2.Init.ClockSpeed = 400000; I2CxHandle_2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE; I2CxHandle_2.Init.DutyCycle = I2C_DUTYCYCLE_16_9; I2CxHandle_2.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE; I2CxHandle_2.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE; I2CxHandle_2.Init.OwnAddress1 = I2C_2_ADDRESS; I2CxHandle_2.Init.OwnAddress2 = 0; if(HAL_I2C_Init(&I2CxHandle_2) != HAL_OK) { /* Initialization Error */ Error_Handler(); } }