Instituto Politécnico Nacional
“Escuela Superior De Ingeniería Mecánica
y Eléctrica”
Ingeniería en Sistemas Automotrices.
Interfaces y microcontroladores.
Alumno: JIMENEZ AGUILAR CRISTIAN ALEJANDRO.
Boleta: 2020300502.
Grupo: 7SV1.
Profesor: Jimenez López Rodrigo.
Practica: Programación básica del microcontrolador
STM32F103C8 – UART
OBJETIVO GENERAL:
1
Enviar por el puerto serie (UART1) los valores y registros de la practica 1, que en
resumen corresponden al valor registrado en el ADC, cuando se detecten las
siguientes condiciones:
- Se encuentre presionado un BOTON0 ó BOTON1, y
- Se encuentre un nivel de señal mayor que 1.6 V en una entrada analógica del
ADC.
Así mismo debe encender los LEDs externos de manera continua (BOTON0 ->
LEDe0 y BOTON1 -> LEDe1), adicionalmente el LED conectado en PC_13 debe
parpadear. Cuando deje de presionarse los botones o no se tenga un nivel mayor
que 1.6 V, debe cesar la comunicación por el puerto serie (UART1), así mismo los
LEDs externos y el LED de la tarjeta deben apagarse.
INTRODUCCIÓN:
El microcontrolador STM32F103C8 cuenta con periféricos
USART(Síncrono)/UART(Asíncrono), así
como GPIO y ADC, los cuales permiten que dicho microcontrolador pueda enviar
por el puerto
serie el registro de señales de entrada digitales y ejecutar procesos que resulten
en la activación
de señales digitales de salida, así mismo pueden registrar señales de entrada
analógicas y ejecutar
procesos que resulten en la activación de señales digitales de salida.
MATERIAL Y/O HERRAMIENTAS:
2
Microcontrolador STM32F103C8T6 Computadora con puerto USB.
Programador ST Link V2 Cuatro cables Dupont.
2 LED 2 PUSH BOTON
3
4 RESISTENCIAS DE 1K OHMS 1 POTENCIOMETRO DE 10K OHMS
CABLE STM32CUBEIDE
Convertidor USB-TTL y su cable mini USB
MARCO TEORICO:
4
El STM32F103C8T6, también conocido como "Blue Pill", es un microcontrolador
de la familia STM32 de STMicroelectronics. Uno de los periféricos más comunes y
útiles en muchos microcontroladores, incluido el STM32F103C8T6, es el UART
(Universal Asynchronous Receiver/Transmitter), que permite la comunicación
serial asíncrona. En este ensayo, exploraremos la configuración y el uso del
periférico UART en el STM32F103C8T6.
Configuración del UART:
Inicialización del periférico UART:
Para usar el UART en el STM32F103C8T6, primero debes habilitar el reloj
correspondiente al módulo UART que deseas utilizar.
Luego, configura los pines GPIO necesarios como alternativa de función UART
utilizando el registro GPIOx_AFIO_CR.
Después, configura los registros de configuración del UART (como el Baud rate,
número de bits de datos, bits de parada, etc.) a través de los registros del
periférico USARTx_CRx.
Configuración de la velocidad de transmisión (Baud rate):
El Baud rate determina la velocidad de transmisión de datos. Debes configurarlo
correctamente para garantizar una comunicación confiable entre dispositivos.
Calcula el valor necesario para el registro BRR (Baud Rate Register) utilizando la
fórmula proporcionada en el manual del microcontrolador.
Configuración de los parámetros de trama:
Esto incluye el número de bits de datos, el número de bits de parada, la paridad,
etc. Configura estos parámetros según los requisitos de tu aplicación.
Habilitar la transmisión y recepción:
Una vez configurados todos los parámetros, activa la transmisión y recepción del
UART configurando los bits correspondientes en los registros de control.
Uso del UART:
Transmisión de datos:
Para enviar datos a través del UART, escribe los datos a transmitir en el registro
de datos (USART_DR).
Puedes esperar a que se complete la transmisión verificando el bit TC
(Transmission Complete) en el registro de estado (USART_SR), o usar
interrupciones para manejar la transmisión asincrónica.
5
Recepción de datos:
Para recibir datos a través del UART, lee los datos recibidos del registro de datos
(USART_DR).
Puedes esperar a que lleguen datos verificando el bit RXNE (Receive Not Empty)
en el registro de estado (USART_SR), o usar interrupciones para manejar la
recepción asincrónica.
Manejo de errores:
Monitorea los bits de error en el registro de estado para detectar y manejar errores
de comunicación, como errores de paridad, overrun, framing, etc.
Flujo de control (opcional):
Si es necesario, puedes implementar el control de flujo de hardware (RTS/CTS)
para controlar la transmisión y recepción de datos entre dispositivos.
Usaremos el siguiente diagrama eléctrico:
DESARROLLO DE LA PRACTICA:
6
PROCESO IMAGEN
Iniciamos
un nuevo
proyecto
del
programa
IDE.
Seleccionamo
s la pestaña
Pinout &
Configuration,
el submenu
RCC, en
Mode High
Speed Clock
seleccionamo
s
Crystal/Cera
mic
Resonator
7
En SYS
opcion Debug
seleccionamo
s Serial Wire
En la pestaña
Clock
configuration
cambiamos la
frecuencia de
8MHz a 72
MHz.
En la pestaña Pinout y
opción GPIO en la terminal
PC13, abrimos el menú y
seleccionamos
GPIO_Output, para
después cambiarle el
nombre a LEDI.
Y en las terminales PB0 y
PB1 los seleccionamos
como output y le ponemos
las etiquetas LED0 y LED1.
8
Siguiendo el
diagrama
seleccionamo
s PB9 y PB8
como input y
les damos la
etiqueta de
BOTON1 y
BOTON0
respectivame
nte.
Abrimos la
pestaña
Analog
(ADC1) y
seleccionamo
s IN5 para
cambiar el
continuous
mode a
enabled.
9
En la entrada
PA5 le
ponemos una
etiqueta de
POT1.
Abrimos el
menú de
connectivity y
seleccionamo
s la opción
USART.
Seleccionamo
s Enabled en
la opción de
NVIC
10
Seleccionamo
s Save para
generar el
código y
clickamos en
Yes.
Iniciamos
colocando
nuevas
librerías.
Buscamos la
línea 45 y
pondremos lo
siguiente:
Agregamos
las variables
para el UART.
11
Nos dirigimos
a la línea
donde se
encuentra el
while para
poner las
siguientes
líneas de
código:
12
Posteriorment
e vamos el
CODE BEGIN
ADC1_Init 2
donde
colocaremos
lo siguiente:
Después
crearemos el
[Link]
con los
siguientes
pasos:
seleccionar
Poject
Explorer
“practpot” y
con click
derecho
properties,
seleccionam
mos C/C++
Build y
Settings, Tool
settings.
Seleccionamo
s “MCU/Post
build
outputs” y
posteriorment
e aparecerán
otras
opciones en
el recuadro
del lado
izquierdo, en
éstas
activaremos
la palomita en
13
la opción
“Convert to
Intel Hex file
(-O binary)”,
Apply and
Close.
También
incluimos los
valores
flotantes.
Compilamos
nuestro
programa
presionando
sobre el icono
Build Debug.
Nos sale un
mensaje con
0 errors y 0
warnings.
14
Abrimos el
programa
realterm y
podremos ver
el valor en el
ADC, el Vcc y
si el botón se
encuentra en
0 o 1.
CÓDIGO:
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2024 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
15
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "string.h"
#include "stdio.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;
UART_HandleTypeDef huart1;
/* USER CODE BEGIN PV */
volatile uint16_t adc_val,adc_res=4095;
volatile uint16_t tiempo = 50;
volatile float vcc_in = 3.3, vcc_out;
volatile uint8_t boton0_val,
boton1_val,
led0_val = GPIO_PIN_SET,
led1_val = GPIO_PIN_RESET,
ledi = GPIO_PIN_RESET;
///// Variables para el UART
char rx_dato[1], tx_dato[60];/*variables para los datos de recepción (Rx) y
envio(Tx) */
uint8_t estado;/*variable de estado de recepción por el UART*/
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) /*Cuando se reciben
datos exitosamente por UART (interrupción de recepción) se llama esta función */
{
HAL_UART_Receive_IT(&huart1, (uint8_t*)rx_dato, 1);/*Llena la variable
"rx_dato" con el dato recibido por el UART */
estado = 1;/*Cuando la variable "estado = 1" indica que se recibieron datos por
el UART */
}
/* USER CODE END PV */
16
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
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_ADC1_Init();
MX_USART1_UART_Init();
/* USER CODE BEGIN 2 */
HAL_UART_Receive_IT(&huart1, (uint8_t*)rx_dato, 1);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
17
adc_val = HAL_ADC_GetValue(&hadc1); //Obtiene el valor del ADC1 en el
pin PA5
vcc_out = adc_val * vcc_in/adc_res; //Calcula el valor correspondiente
en volts
boton0_val = HAL_GPIO_ReadPin(BOTON0_GPIO_Port, BOTON0_Pin);//Obtiene
el valor del BOTON0
boton1_val = HAL_GPIO_ReadPin(BOTON1_GPIO_Port, BOTON1_Pin);//Obtiene
el valor del BOTON1
if((boton0_val == 0 || boton1_val == 1) && vcc_out > 1.6)//Si se
presiona cualquier botón y el vcc_out es mayor que 1.6 volts
{
if(boton0_val == 0) //Si el boton0 se presiona ->
HAL_GPIO_ReadPin(BOTON0_GPIO_Port, BOTON0_Pin) == 0
{
HAL_GPIO_WritePin(LED0_GPIO_Port, LED0_Pin, GPIO_PIN_SET); //LEDe0 = 1
(se prende)
HAL_GPIO_TogglePin(LEDI_GPIO_Port, LEDI_Pin); //LEDi = parpadea
HAL_Delay(tiempo);
//Transmite por el UART lo que tenga la variable "tx_dato", cuando se
presiona el Boto0
sprintf(tx_dato, "Valor en el ADC: %u, Vcc: %1.3f, Boton0: %u, Boton1:
%u\r\n", adc_val, vcc_out, boton0_val, boton1_val);
HAL_UART_Transmit(&huart1, (uint8_t*)tx_dato, strlen(tx_dato),
HAL_MAX_DELAY);
}
else if(boton1_val == 1) //Si el boton1 se presiona ->
HAL_GPIO_ReadPin(BOTON1_GPIO_Port, BOTON1_Pin) == 1
{
HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, GPIO_PIN_RESET); //LEDe1 =
0 (se prende)
HAL_GPIO_TogglePin(LEDI_GPIO_Port, LEDI_Pin); //LEDi = parpadea
HAL_Delay(tiempo);
//Transmite por el UART lo que tenga la variable "tx_dato", cuando se
presiona el Boto1
sprintf(tx_dato, "Valor en el ADC: %u, Vcc: %1.3f, Boton0: %u, Boton1:
%u\r\n", adc_val, vcc_out, boton0_val, boton1_val);
HAL_UART_Transmit(&huart1, (uint8_t*)tx_dato, strlen(tx_dato),
HAL_MAX_DELAY);
}
}
else
{
HAL_GPIO_WritePin(LED0_GPIO_Port, LED0_Pin, GPIO_PIN_RESET); //LEDe0 =
0 (se apaga)
HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, GPIO_PIN_SET); //LEDe1 = 1
(se apaga)
HAL_GPIO_WritePin(LEDI_GPIO_Port, LEDI_Pin, GPIO_PIN_SET); //LEDi = 1
(se apaga)
}
////////////////////Codigo para la recepción por el UART mediante
Interrupciones/////////////
if(estado == 1) //Cuando la variable "estado = 1" indica que se
recibieron datos por el UART
{
18
char numero_letra = rx_dato[0]; //Llena la variable "numero_letra" con
el dato recibido por el UART capturado en "rx_dato"
switch(numero_letra)
{
case '0'://Cuando la variable "numero_letra == '0', caracter ASCII '0'
o número decimal 48 o número exadecimal 0x30"
HAL_GPIO_WritePin(LED0_GPIO_Port, LED0_Pin, GPIO_PIN_SET); //LEDe0 = 1
(se prende)
HAL_GPIO_TogglePin(LEDI_GPIO_Port, LEDI_Pin); //LEDi = parpadea
HAL_Delay(tiempo);
sprintf(tx_dato, "LEDe0: prendido\r\n"); //Llena la variable "tx_dato"
para indicar que el LEDe0: prendido
break;
case '1'://Cuando la variable "numero_letra == '1', caracter ASCII '1'
o número decimal 49 o número exadecimal 0x31"
HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, GPIO_PIN_RESET); //LEDe1 =
0 (se prende)
HAL_GPIO_TogglePin(LEDI_GPIO_Port, LEDI_Pin); //LEDi = parpadea
HAL_Delay(tiempo);
sprintf(tx_dato, "LED1: prendido\r\n"); //Llena la variable "tx_dato"
para indicar que el LEDe1: prendido
break;
case 'a'://Cuando la variable "numero_letra == 'a', caracter ASCII 'a'
o número decimal 97 o número exadecimal 0x61"
sprintf(tx_dato, "Valor en el ADC: %u, Vcc: %1.3f\r\n", adc_val,
vcc_out);//Llena la variable "tx_dato" para indicar el valor del ADC
break;
case 'b'://Cuando la variable "numero_letra == 'b', caracter ASCII 'b'
o número decimal 98 o número exadecimal 0x62"
sprintf(tx_dato, "Estado BOTON0: %u, Estado BOTON1: %u\r\n",
boton0_val, boton1_val);//Llena la variable "tx_dato" para indicar el estado de
los Botones
break;
//case 't'://Cuando la variable "numero_letra == 't', caracter ASCII
't' o número decimal 116 o número exadecimal 0x74"
//case 116://Cuando la variable "numero_letra == 't', caracter ASCII
't' o número decimal 116 o número exadecimal 0x74"
case 0x74://Cuando la variable "numero_letra == 't', caracter ASCII 't'
o número decimal 116 o número exadecimal 0x74"
sprintf(tx_dato, "Valor en el ADC: %u, Vcc: %1.3f, Boton0: %u, Boton1:
%u\r\n", adc_val, vcc_out, boton0_val, boton1_val);
break;
default:
sprintf(tx_dato, "Solo se reconocen los numeros o letras: 0, 1, a, b,
t\r\n");
break;
}
HAL_UART_Transmit(&huart1, (uint8_t*)tx_dato, strlen(tx_dato),
HAL_MAX_DELAY);//Tranmite por el UART lo que tenga la variable "tx_dato"
estado = 0;//Cuando la variable "estado = 0" se reinicia la bandera de
estado para la recepción de más datos por el UART
}
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
19
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.[Link] = RCC_PLL_ON;
RCC_OscInitStruct.[Link] = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.[Link] = RCC_PLL_MUL9;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses 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_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
[Link] = RCC_PERIPHCLK_ADC;
[Link] = RCC_ADCPCLK2_DIV6;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief ADC1 Initialization Function
* @param None
* @retval None
*/
20
static void MX_ADC1_Init(void)
{
/* USER CODE BEGIN ADC1_Init 0 */
/* USER CODE END ADC1_Init 0 */
ADC_ChannelConfTypeDef sConfig = {0};
/* USER CODE BEGIN ADC1_Init 1 */
/* USER CODE END ADC1_Init 1 */
/** Common config
*/
[Link] = ADC1;
[Link] = ADC_SCAN_DISABLE;
[Link] = ENABLE;
[Link] = DISABLE;
[Link] = ADC_SOFTWARE_START;
[Link] = ADC_DATAALIGN_RIGHT;
[Link] = 1;
if (HAL_ADC_Init(&hadc1) != HAL_OK)
{
Error_Handler();
}
/** Configure Regular Channel
*/
[Link] = ADC_CHANNEL_5;
[Link] = ADC_REGULAR_RANK_1;
[Link] = ADC_SAMPLETIME_1CYCLE_5;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN ADC1_Init 2 */
HAL_ADC_Stop(&hadc1);
while(HAL_ADCEx_Calibration_Start(&hadc1));
HAL_ADC_Start(&hadc1);
/* USER CODE END ADC1_Init 2 */
/**
* @brief USART1 Initialization Function
* @param None
* @retval None
*/
static void MX_USART1_UART_Init(void)
{
/* USER CODE BEGIN USART1_Init 0 */
/* USER CODE END USART1_Init 0 */
21
/* USER CODE BEGIN USART1_Init 1 */
/* USER CODE END USART1_Init 1 */
[Link] = USART1;
[Link] = 115200;
[Link] = UART_WORDLENGTH_8B;
[Link] = UART_STOPBITS_1;
[Link] = UART_PARITY_NONE;
[Link] = UART_MODE_TX_RX;
[Link] = UART_HWCONTROL_NONE;
[Link] = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART1_Init 2 */
/* USER CODE END USART1_Init 2 */
/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(LEDI_GPIO_Port, LEDI_Pin, GPIO_PIN_SET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOB, LED0_Pin|LED1_Pin, GPIO_PIN_SET);
/*Configure GPIO pin : LEDI_Pin */
GPIO_InitStruct.Pin = LEDI_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(LEDI_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pins : LED0_Pin LED1_Pin */
GPIO_InitStruct.Pin = LED0_Pin|LED1_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
22
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pin : BOTON0_Pin */
GPIO_InitStruct.Pin = BOTON0_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(BOTON0_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pin : BOTON1_Pin */
GPIO_InitStruct.Pin = BOTON1_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(BOTON1_GPIO_Port, &GPIO_InitStruct);
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
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 /* USE_FULL_ASSERT */
23
APLICACIONES AUTOMOTRICES:
Comunicación OBD-II (On-Board Diagnostics):
El UART puede utilizarse para implementar protocolos de comunicación como
OBD-II, permitiendo la lectura de códigos de diagnóstico, datos en tiempo real del
vehículo y el monitoreo de sensores.
Interfaz con Sensores y Actuadores:
24
El UART puede conectar el STM32F103C8T6 con una variedad de sensores y
actuadores dentro del vehículo, como sensores de temperatura, presión, posición
del acelerador, etc., así como actuadores como válvulas de control.
Sistemas de Información y Entretenimiento (Infotainment):
El UART puede ser utilizado para la comunicación entre el microcontrolador y
dispositivos de audio, pantallas táctiles, sistemas de navegación, permitiendo la
implementación de sistemas de información y entretenimiento en el vehículo.
Telemetría y Comunicación Inalámbrica:
El UART puede ser utilizado para enviar datos de telemetría del vehículo, como la
velocidad, la temperatura del motor, el consumo de combustible, etc., a
dispositivos externos a través de módulos de comunicación inalámbrica como
Bluetooth o Wi-Fi.
Control de Dispositivos Externos:
El UART puede ser utilizado para controlar dispositivos externos conectados al
vehículo, como sistemas de iluminación, sistemas de seguridad, actuadores para
apertura de puertas, etc.
25
CONCLUSIÓN:
Se ha obtenido un conocimiento sobre el funcionamiento del UART, incluyendo su
configuración, parámetros de comunicación, y métodos de transmisión y recepción de
datos.
Se ha explorado el papel del UART en aplicaciones automotrices, comprendiendo su importancia en
sistemas de diagnóstico, telemetría, control de dispositivos y comunicación con sensores y
actuadores. Esto proporciona una visión práctica sobre cómo los microcontroladores STM32
pueden ser utilizados en el diseño y desarrollo de sistemas electrónicos para vehículos.
26
27
28
