COMUNICACIÓN MEDIALTE EL MODULO USART

STM32
GERSON A. PEREZ VILLARROEL
 MODULO USART
La librería CubeHAL abstrae el modulo USART usando dos campos de la estructura UART_HandleTypeDef, los
cuales son:
USART_TypeDef *Instance Velocidad de trasmisión de datos (Valores estándares)
Este es un puntero al descriptor USART:
Especifica el número de bits del dato que se transmitirán o
UART_InitTypeDef Init recibirán, pueden ser:
Esta se debe configura para el uso de este periférico • UART_WORDLENGTH_8B
typedef struct • UART_WORDLENGTH_9B
{
Especifica el número de bits de fin de transmisión, indicando
uint32_t BaudRat;
que pueden ser 1 o 2 bits para el fin del paquete, pueden ser:
uint32_t WordLength;
• UART_STOPBITS_1
uint32_t StopBits;
• UART_STOPBITS_2
uint32_t Parity ;
uint32_t Mode; Especifica el modo de paridad, para realizar la transferencia
uint32_t HwFlowCtl; con paridad o sin paridad, puede tomar los siguientes valores:
uint32_t OverSampling; • UART_PARITY_NONE Sin paridad
}UART_InitTypeDef; • UART_PARITY_EVEN Bit de paridad impar
• UART_PARITY_ODD Bit de parida par
 MODULO USART
La librería CubeHAL abstrae el modulo USART usando dos campos de la estructura UART_HandleTypeDef, los
cuales son:
USART_TypeDef *Instance
Este es un puntero al descriptor USART:
UART_InitTypeDef Init
Especifica si se va a transmitir, recibir o ambos, puede ser:
Esta se debe configura para el uso de este periférico
• UART_MODE_RX Modo recepción
typedef struct • UART_MODE_TX Modo transmisión
{ • UART_MODE_TX_RX Modo transmisión y recepción
uint32_t BaudRat;
uint32_t WordLength; Especifica si esta habilitado en control de flujo por hardware
uint32_t StopBits; del RS232, refiriéndose si serán usadas las líneas RTS y CTS,
uint32_t Parity ; puede ser:
uint32_t Mode; • UART_HWCONTROL_NONE Control deshabilitado
• UART_HWCONTROL_RTS Request To Send habilitado
uint32_t HwFlowCtl;
• UART_HWCONTROL_CTS Clear To Send habilitado
uint32_t OverSampling;
• UART_HWCONTROL_RTS_CTS RTS y CTS habilitados
}UART_InitTypeDef;
 MODULO USART
La librería CubeHAL abstrae el modulo USART usando dos campos de la estructura UART_HandleTypeDef, los
cuales son:
USART_TypeDef *Instance
Este es un puntero al descriptor USART:
UART_InitTypeDef Init
Esta se debe configura para el uso de este periférico
typedef struct Discrimina los datos validos de entrada de ruido, permitiendo
{ un equilibrio entre la máxima velocidad de comunicación
uint32_t BaudRat; ruido/reloj, ya que el modulo toma una muestra de las señales
uint32_t WordLength; para calcular la cantidad de 1 o 0 que constituyen el mensaje;
uint32_t StopBits; los valores que pueden tomar este campo son:
uint32_t Parity ; • UART_OVERSAMPLING_8 Realiza 8 muestras del paquete
uint32_t Mode; recibido.
uint32_t HwFlowCtl; • UART_OVERSAMPLING_16 Realiza 16 muestras del
uint32_t OverSampling; paquete recibido.
}UART_InitTypeDef;
 MODULO USART – COMUNICACIÓN POR SONDEO
La comunicación por sondeo espera la transmisión o recepción de datos en la función principal.

La librería CubeHAL ofrece las siguientes funciones:

PARA LA TRANSMISIÓN:
HAL_UART_Transmit(UART_HandleTypeDef, *huart, unit8_t *pData, uint16_t Size, uint32_t Timeout)

PARA LA RECEPCIÓN:
HAL_UART_Receive(UART_HandleTypeDef, *huart, unit8_t *pData, uint16_t Size, uint32_t Timeout)

huart: puntero a la estructura UART_HandleTypeDef que contiene la información de configuración para el módulo
UART (puerto utilizado) especificado.
pData: variable o apuntador que contendrá los datos provenientes del puerto, estos tienen que ser de tipo uint8_t..
Size: Cantidad de datos a recibir de tipo uint16_t
Timeout: tiempo de espera (ms), este dato tiene que se de tipo uint32_t.
 MODULO USART – COMUNICACIÓN POR SONDEO

EJEMPLO:

PARA LA TRANSMISIÓN:
HAL_UART_Transmit(UART_HandleTypeDef, *huart, unit8_t *pData, uint16_t Size, uint32_t Timeout)
HAL_UART_Transmit(&huart3, (uint8_t*)bufer, (unit16_t)strlen(bufer), (uint32_t)100)

PARA LA RECEPCIÓN:
HAL_UART_Receive(UART_HandleTypeDef, *huart, unit8_t *pData, uint16_t Size, uint32_t Timeout)
 MODULO USART – COMUNICACIÓN POR SONDEO
EJEMPLO 1:
Escribir un programa que encienda y apague un LED desde la computador, y luego informar a la computadora que se
encendió o apago el LED. Para encender el LED se de be enviar desde la computadora la letra E y para apagar el LED
se debe enviar la letra A
 MODULO USART – COMUNICACIÓN POR SONDEO
EJEMPLO 1:
Se realizará la comunicación RS232.
Utilizaremos el recurso “USART 1”, así
que lo buscamos en la parte izquierda
de la ventana “Pinout”, lo
seleccionamos y lo habilitamos y en la
parte donde dice “Modo”
seleccionamos la opción de
“Asynchronous”, y en el apartado que
dice “Hardware Flow Control (RS232)”
lo dejamos en la opción “Disable”,
como podemos observar los pines
correspondientes a “TX” y a “RX”, son
habilitados y puestos de color verde.
Configuramos el Pin PC13 para
conectar el LED que se apara o
encenderá
MODULO USART – COMUNICACIÓN POR SONDEO
EJEMPLO 1:
MODULO USART – COMUNICACIÓN POR SONDEO
EJEMPLO 1: #include "main.h"
#include "stm32f1xx_hal.h"
#include "string.h"

UART_HandleTypeDef huart1;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);

int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_USART1_UART_Init();

char encendido[20]="LED ENCENDIDO /r/n";

char apagado[20]="LED APAGADO /r/n";
uint8_t DatoRecibido[1];
MODULO USART – COMUNICACIÓN POR SONDEO
EJEMPLO 1:
while (1)
{
HAL_UART_Receive(&huart1, DatoRecibido,(uint16_t)1,(uint32_t)100);
if(DatoRecibido[0]=='E')
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
HAL_UART_Transmit(&huart1, (uint8_t*)encendido, strlen(encendido), (uint32_t)100);
}
if(DatoRecibido[0]=='A')
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
HAL_UART_Transmit(&huart1, (uint8_t*)apagado, sizeof(apagado), (uint32_t)100);
}
}

}
MODULO USART – COMUNICACIÓN POR SONDEO
EJEMPLO 1:
static 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;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}

}
 MODULO USART – COMUNICACIÓN POR INTERRUPCIÓN
La comunicación por interrupción espera la transmisión o recepción de datos como un evento separado y o no
relacionado con la función principal.

La librería CubeHAL ofrece las siguientes funciones:

PARA LA TRANSMISIÓN:
HAL_UART_Transmit_IT(UART_HandleTypeDef, *huart, unit8_t *pData, uint16_t Size,)

PARA LA RECEPCIÓN:
HAL_UART_Receive_IT(UART_HandleTypeDef, *huart, unit8_t *pData, uint16_t Size)

huart: puntero a la estructura UART_HandleTypeDef que contiene la información de configuración para el módulo
UART (puerto utilizado) especificado.
pData: variable o apuntador que contendrá los datos provenientes del puerto, estos tienen que ser de tipo uint8_t..
Size: Cantidad de datos a recibir de tipo uint16_t
 MODULO USART – COMUNICACIÓN POR INTERRUPCIÓN
Para realizar la comunicación por Interrupción se necesita:
Habilitar la interrupción USARTx_TRQn e implementar el bloque de interrupción UARTx_IRQHandler();
Estas funciones :

HAL_UART_Transmit_IT(UART_HandleTypeDef, *huart, unit8_t *pData, uint16_t Size,)

HAL_UART_Receive_IT(UART_HandleTypeDef, *huart, unit8_t *pData, uint16_t Size)

Llaman a la rutina de interrupción:

HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
Esta rutina a su vez llamara a una subrutina dependiendo de las banderas asociadas al registro de USART en
interrupción, las subrutinas mas importantes corresponden a las banderas de transmisión/recepción completa en estas
es donde hay que escribir el código para realizar una acción.
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
Estas rutinas se ejecutan cuando se haya llenado el buffer y cuando la transferencia se haya completado
respectivamente.
 MODULO USART – COMUNICACIÓN POR INTERRUPCIÓN
EJEMPLO 2:
Escribir un programa que encienda y apague un LED desde la computador, y luego informar a la computadora que se
encendió o apago el LED. Para encender el LED se de be enviar desde la computadora la letra E y para apagar el LED
se debe enviar la letra A. Usar Interrupciones en la comunicación.
 MODULO USART – COMUNICACIÓN POR INTERRUPCIÓN
EJEMPLO 2:
Se realizará la comunicación RS232.
Utilizaremos el recurso “USART 3”, así
que lo buscamos en la parte izquierda
de la ventana “Pinout”, lo
seleccionamos y lo habilitamos y en la
parte donde dice “Modo”
seleccionamos la opción de
“Asynchronous”, y en el apartado que
dice “Hardware Flow Control (RS232)”
lo dejamos en la opción “Disable”,
como podemos observar los pines
correspondientes a “TX” y a “RX”, son
habilitados y puestos de color verde.
Configuramos el Pin PC13 para
conectar el LED que se apara o
encenderá
MODULO USART – COMUNICACIÓN POR INTERRUPCIÓN
EJEMPLO 2:
MODULO USART – COMUNICACIÓN POR INTERRUPCIÓN
EJEMPLO 2: #include "main.h"
#include "stm32f1xx_hal.h"
#include "string.h"

UART_HandleTypeDef huart3;
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART3_UART_Init(void);

char encendido[20]="LED ENCENDIDO /r/n";

char apagado[20]="LED APAGADO /r/n";
uint8_t DatoRecibido[1];
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_USART3_UART_Init();
HAL_UART_Receive_IT(&huart3, DatoRecibido, 1);
while (1)
{ }
}
MODULO USART – COMUNICACIÓN POR INTERRUPCIÓN
EJEMPLO 2: void USART3_IRQHandler(void)
{
HAL_UART_IRQHandler(&huart3);
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if (huart->Instance == USART3)
{
if(DatoRecibido[0]=='E')
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
HAL_UART_Transmit(&huart3, (uint8_t*)encendido, strlen(encendido), (uint32_t)100);
}
if(DatoRecibido[0]=='A')
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
HAL_UART_Transmit(&huart3, (uint8_t*)apagado, sizeof(apagado), HAL_MAX_DELAY);
}
HAL_UART_Receive_IT(&huart3, DatoRecibido, 1);
}
}
MODULO USART – COMUNICACIÓN POR INTERRUPCIÓN
EJEMPLO 2:
static void MX_USART3_UART_Init(void)
{

huart3.Instance = USART3;
huart3.Init.BaudRate = 9600;
huart3.Init.WordLength = UART_WORDLENGTH_8B;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = UART_PARITY_NONE;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart3) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}