STM32 UART/USART Ausgabe erhalten (ohne Unterbrechung)

Ich versuche, auf dem PC zu übertragen und Empfangen von Daten über UART/USART auf stm32L476 Entdeckung Board Terminal. Ich bin in der Lage, die Daten an den PC zu übertragen, aber ich kann keine empfangen.STM32 UART/USART Ausgabe erhalten (ohne Unterbrechung)

Mein Code ist wie folgt:

/* Includes ------------------------------------------------------------------*/ 
#include "main.h" 
#include "stm32l4xx_hal.h" 

/* USER CODE BEGIN Includes */ 

/* USER CODE END Includes */ 

/* Private variables ---------------------------------------------------------*/ 
UART_HandleTypeDef huart2; 

/* USER CODE BEGIN PV */ 
/* Private variables ---------------------------------------------------------*/ 

/* USER CODE END PV */ 

/* Private function prototypes -----------------------------------------------*/ 
void SystemClock_Config(void); 
static void MX_GPIO_Init(void); 
static void MX_USART2_UART_Init(void); 

/* USER CODE BEGIN PFP */ 
/* Private function prototypes -----------------------------------------------*/ 

/* USER CODE END PFP */ 
uint8_t cmd[] = {4,7,8,9}; 
uint8_t data[10]; 
uint8_t data1[10]; 
uint32_t err_code = 0; 
int count = 0; 
/* USER CODE BEGIN 0 */ 
int stat_re; 
int mydata = 1; 
/* USER CODE END 0 */ 

int main(void) 
{ 

    /* USER CODE BEGIN 1 */ 

    /* USER CODE END 1 */ 

    /* MCU Configuration----------------------------------------------------------*/ 

    /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ 
    HAL_Init(); 

    /* USER CODE BEGIN Init */ 

    /* USER CODE END Init */ 

    /* Configure the system clock */ 
    SystemClock_Config(); 

    /* USER CODE BEGIN SysInit */ 

    /* USER CODE END SysInit */ 

    /* Initialize all configured peripherals */ 
    MX_GPIO_Init(); 
    MX_USART2_UART_Init(); 

    /* USER CODE BEGIN 2 */ 

    /* USER CODE END 2 */ 

    /* Infinite loop */ 
    /* USER CODE BEGIN WHILE */ 
    while (1) 
    { 
    /* USER CODE END WHILE */ 

     // HAL_UART_Transmit(&huart2,(uint8_t*) cmd, 4, 5); 
     // HAL_Delay(1000); 

     /* 
     while (!(USART_ISR_RXNE)); 
     mydata = (int)(USART_RDR_RDR & 0xFF);*/ 


    HAL_UART_Receive(&huart2, data, 10, 5000) 
     data1[10] = data[10]; 

    } 


} 

/** System Clock Configuration 
*/ 
void SystemClock_Config(void) 
{ 

    RCC_OscInitTypeDef RCC_OscInitStruct; 
    RCC_ClkInitTypeDef RCC_ClkInitStruct; 
    RCC_PeriphCLKInitTypeDef PeriphClkInit; 

    /**Initializes the CPU, AHB and APB busses clocks 
    */ 
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI; 
    RCC_OscInitStruct.MSIState = RCC_MSI_ON; 
    RCC_OscInitStruct.MSICalibrationValue = 0; 
    RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_6; 
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; 
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_MSI; 
    RCC_OscInitStruct.PLL.PLLM = 1; 
    RCC_OscInitStruct.PLL.PLLN = 40; 
    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7; 
    RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2; 
    RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2; 
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) 
    { 
    _Error_Handler(__FILE__, __LINE__); 
    } 

    /**Initializes the CPU, AHB and APB busses clocks 
    */ 
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK 
           |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2; 
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; 
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; 
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1; 
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1; 

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK) 
    { 
    _Error_Handler(__FILE__, __LINE__); 
    } 

    PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2; 
    PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_SYSCLK; 
    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) 
    { 
    _Error_Handler(__FILE__, __LINE__); 
    } 

    HAL_RCC_MCOConfig(RCC_MCO1, RCC_MCO1SOURCE_SYSCLK, RCC_MCODIV_1); 

    /**Configure the main internal regulator output voltage 
    */ 
    if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK) 
    { 
    _Error_Handler(__FILE__, __LINE__); 
    } 

    /**Configure the Systick interrupt time 
    */ 
    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000); 

    /**Configure the Systick 
    */ 
    HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK); 

    /* SysTick_IRQn interrupt configuration */ 
    HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0); 
} 

/* USART2 init function */ 
static 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; 
    huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; 
    huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; 
    if (HAL_UART_Init(&huart2) != HAL_OK) 
    { 
    _Error_Handler(__FILE__, __LINE__); 
    } 

} 

/** Configure pins as 
     * Analog 
     * Input 
     * Output 
     * EVENT_OUT 
     * EXTI 
    PA8 ------> RCC_MCO 
*/ 
static void MX_GPIO_Init(void) 
{ 

    GPIO_InitTypeDef GPIO_InitStruct; 

    /* GPIO Ports Clock Enable */ 
    __HAL_RCC_GPIOA_CLK_ENABLE(); 
    __HAL_RCC_GPIOB_CLK_ENABLE(); 
    __HAL_RCC_GPIOE_CLK_ENABLE(); 

    /*Configure GPIO pin : PB2 */ 
    GPIO_InitStruct.Pin = GPIO_PIN_2; 
    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; 
    GPIO_InitStruct.Pull = GPIO_NOPULL; 
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); 

    /*Configure GPIO pin : PE8 */ 
    GPIO_InitStruct.Pin = GPIO_PIN_8; 
    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; 
    GPIO_InitStruct.Pull = GPIO_NOPULL; 
    HAL_GPIO_Init(GPIOE, &GPIO_InitStruct); 

    /*Configure GPIO pin : PA8 */ 
    GPIO_InitStruct.Pin = GPIO_PIN_8; 
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; 
    GPIO_InitStruct.Pull = GPIO_NOPULL; 
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; 
    GPIO_InitStruct.Alternate = GPIO_AF0_MCO; 
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); 

} 

/* USER CODE BEGIN 4 */ 

/* USER CODE END 4 */ 

/** 
    * @brief This function is executed in case of error occurrence. 
    * @param None 
    * @retval None 
    */ 
void _Error_Handler(char * file, int line) 
{ 
    /* USER CODE BEGIN Error_Handler_Debug */ 
    /* User can add his own implementation to report the HAL error return state */ 
    while(1) 
    { 
    } 
    /* USER CODE END Error_Handler_Debug */ 
} 

#ifdef USE_FULL_ASSERT 

/** 
    * @brief Reports the name of the source file and the source line number 
    * where the assert_param error has occurred. 
    * @param file: pointer to the source file name 
    * @param line: assert_param error line source number 
    * @retval None 
    */ 
void assert_failed(uint8_t* file, uint32_t line) 
{ 
    /* USER CODE BEGIN 6 */ 
    /* User can add his own implementation to report the file name and line number, 
    ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */ 
    /* USER CODE END 6 */ 

} 

#endif 

/** 
    * @} 
    */ 

/** 
    * @} 
*/ 

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

Bitte lassen Sie mich wissen, wenn Sie das Problem kennen. Ich habe versucht, den Widerstand zu entfernen, der mit dem Joystick verbunden ist, der auch mit dem Empfangspin von USART2 verbunden ist.

Quelle

2017-09-04 user8398475

Haben Sie etwas von dem ursprünglichen Beispiel verändert? –

Wenn Sie ein Array wie dieses haben 'uint8_t data [10]; 'dann ist der Zugriff auf das letzte Element wie folgt:' data1 [10] = data [10]; 'ist fehlerhaft. Das letzte Element eines 10 langen Arrays befindet sich auf Index 9, da der erste Index 0 ist. –

Sie scheinen GPIO-Konfiguration zu fehlen.

Für diese spezielle MCU kann die USART2 RX-Alternativfunktion entweder PA3 oder PD6 zugewiesen werden. TX ist entweder PA2 oder PD5. Wählen Sie die gewünschte Variante und initialisieren Sie die Pins - in beiden Fällen ist es AF7. Stellen Sie außerdem sicher, dass die Uhren für USART und GPIO aktiviert sind.

Quelle

2017-09-04 14:47:41

Ihr Code blockiert so lange, bis 10 Bytes empfangen wurden oder 5 Sekunden abgelaufen sind. Dann versuchen Sie, 1 Byte im Array zu lesen, aber Ihr Lesen ist außerhalb der Grenzen. Um zu überprüfen, dass die UART richtig funktioniert Sie ein sehr einfaches Echo wie diese könnten versuchen:

while(1) 
{ 
    uint8_t echo; 
    //Blocks indefinitely until 1 byte is received 
    HAL_UART_Receive(&huart2, &echo, 1, HAL_MAX_DELAY); 
    //Sends back the byte 
    HAL_UART_Transmit(&huart2, &echo, 1, HAL_MAX_DELAY); 
}

Quelle

2017-09-04 19:02:42

STM32 UART/USART Ausgabe erhalten (ohne Unterbrechung)

Antwort

Verwandte Themen