STM32F1xx HAL UART Recieve

Navega tus respuestas
1

Estoy intentando enviar y recibir datos hacia y desde un STM32F1xx. Tengo el STM32 para enviar con éxito los datos a la computadora. Hice eso usando el siguiente código. 

__HAL_RCC_USART1_CLK_ENABLE();
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

//Setup UART RX Pin
GPIO_InitStruct.Pin = GPIO_PIN_10;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

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;

//Error handling
if(HAL_UART_DeInit(&UartHandle) != HAL_OK) {
    Error_Handler();
}
if(HAL_UART_Init(&UartHandle) != HAL_OK) {
    Error_Handler();
}
char msg[] = "testing\n\r";
while(1) {
  HAL_UART_Transmit(&UartHandle, (uint8_t*)msg, sizeof(msg), 10);
}

El código de arriba funciona perfectamente. Luego intenté enviar datos desde la computadora al STM32. Probé el siguiente código 

 if(HAL_UART_Receive_IT(&UartHandle, (uint8_t*)msg, 5) == HAL_OK) {
          char msg[] = "HAL_OK";
          HAL_UART_Transmit(&UartHandle, (uint8_t*)msg, sizeof(msg), 10);
 }

y no funcionó. No se enviaron datos a la computadora cuando envié un byte al STM32. Hice algo de depuración y la función de recepción devuelve HAL_OK una vez al inicio y luego, después de eso, devuelve HAL_BUSY. Esto me hace pensar que tienes que usar interrupciones, pero lo estoy usando con Receive_IT. ¿Cómo resuelvo este problema?

    
pregunta Tom Eaton

1 respuesta

3

No veo que habilites la interrupción de UART o que llames a los controladores de IRQ apropiados y eso podría ser un problema.

Este es un ejemplo completo de una aplicación UART Echo realizada con HAL que escribí para el tema de documentación SO STM32. Como la documentación SO se cerrará, he citado todo el ejemplo. Fue escrito para un STM32F4 pero con HAL es casi lo mismo para un STM32F1.

Aplicación de eco - biblioteca HAL

En este ejemplo, el microcontrolador devuelve los bytes recibidos al remitente utilizando la interrupción de RX de UART. 

#include "stm32f4xx.h"

UART_HandleTypeDef huart2;

/* Single byte to store input */
uint8_t byte;

void SystemClock_Config(void);

/* UART2 Interrupt Service Routine */
void USART2_IRQHandler(void)
{
  HAL_UART_IRQHandler(&huart2);
}

/* This callback is called by the HAL_UART_IRQHandler when the given number of bytes are received */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  if (huart->Instance == USART2)
  {
    /* Transmit one byte with 100 ms timeout */
    HAL_UART_Transmit(&huart2, &byte, 1, 100);

    /* Receive one byte in interrupt mode */ 
    HAL_UART_Receive_IT(&huart2, &byte, 1);
  }
}

void uart_gpio_init()
{
  GPIO_InitTypeDef GPIO_InitStruct;

  __GPIOA_CLK_ENABLE();

  /**USART2 GPIO Configuration
  PA2     ------> USART2_TX
  PA3     ------> USART2_RX
  */
  GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_3;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

void uart_init()
{
  __USART2_CLK_ENABLE();

  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);

  /* Peripheral interrupt init*/
  HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(USART2_IRQn);
}

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

  uart_gpio_init();
  uart_init();

  HAL_UART_Receive_IT(&huart2, &byte, 1);

  while(1)
  {

  }
}

Este ejemplo utiliza un descubrimiento STM32F4 (STM32F407VG), GPIO y los valores de función alternativos deben cambiarse de acuerdo con el microcontrolador STM32 en uso.

    
respondido por el Bence Kaulics

Lea otras preguntas en las etiquetas

VFD: Disparo de sobretensión regenerativa durante la desaceleración o parada ¿Qué componentes / tableros adicionales se necesitan para usar CAN con un STM32?