/* 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();
}
}
