Reporte de Practica 11

“Comunicación USART”
Microcomputadoras Automotrices I
Lugo Peñaloza Armando Fabian
7SV1

Integrantes:
Avalos García Saúl
Cervantes Hernández Gustavo
González Gallegos Abraham

18 de mayo de 2024
 ÍNDICE
Contenido

Introducción 3
Parte 1: 6
Diagrama y Simulación 10
Circuito armado y funcionando 10
Código usado (C) – Arduino como ATMEGA328p 12
Código usado (C) – ATMEGA328p 13
Conclusiones 15
Referencias 16
Introducción
Un receptor-transmisor síncrono y asíncrono universal (USART, interfaz de
comunicaciones programable o PCI) es un tipo de dispositivo de interfaz serie que se
puede programar para comunicarse de forma asíncrona o síncrona.
Los USART en modo síncrono transmiten datos en tramas. En operación síncrona, los
caracteres deben proporcionarse a tiempo hasta que se complete un cuadro; si el
procesador controlador no lo hace, se trata de un "error de insuficiencia de datos " y se
cancela la transmisión de la trama.
Los USART que operaban como dispositivos síncronos utilizaban el modo orientado a
caracteres o a bits. En los modos de caracteres (STR y BSC), el dispositivo se basaba
en caracteres particulares para definir los límites de la trama; En modos de bits (HDLC y
SDLC), los dispositivos anteriores se basaban en señales de capa física, mientras que
los dispositivos posteriores se hicieron cargo del reconocimiento de patrones de bits en
la capa física.
Una línea sincrónica nunca guarda silencio; cuando el módem está transmitiendo, los
datos fluyen. Cuando la capa física indica que el módem está activo, un USART enviará
un flujo constante de relleno, ya sea caracteres o bits, según corresponda al dispositivo
y protocolo.

Material:
● Protoboard
● Conexiones
● Placa de Arduino
● Resistencias 220 Ω y 560 Ω
● ATmega328p
● Sensor LM35
● potenciómetro 50K
● Pantalla LCD
Diagrama de bloques
Señal de reloj

USART Control and Status Registers (UCSR0A, UCSR0B, UCSR0C):

● UCSR0A: Contiene indicadores que muestran el estado del USART, como el
registro de datos vacío (UDRE0) y la recepción completa (RXC0).
● UCSR0B: Controla la habilitación del transmisor (TXEN0) y el receptor (RXEN0),
entre otras funciones.
● UCSR0C: Configura el formato del marco (por ejemplo, número de bits de datos,
paridad, bits de parada).
● Ejemplo: UCSR0B = (1 << RXEN0) | (1 << TXEN0); habilita tanto el receptor
como el transmisor.
● USART Baud Rate Register
Parte 1:
LCD
Las pantallas LCD alfanuméricas son la opción
ideal para proyectos que requieren una interfaz de
usuario no gráfica simple. Como ofrecen una
funcionalidad básica, también requieren menos
electricidad que los módulos de display más
complicados, y además son una opción más
asequible.
Para elegir el módulo de display LCD
alfanumérico adecuado, se debe tener en cuenta
la tecnología que utiliza el display. Existen varias
opciones disponibles como TN, HTN, STN y
FSTN, que se diferencian principalmente en su
velocidad, nitidez y contraste. Otra opción que se
debe tener en cuenta es la retroiluminación. La retroiluminación LED RGB que ofrece
una luz blanca nítida también se puede programar para mostrar otros colores. Los
módulos transflectivos, reflexivos y transmisivos están disponibles como displays
estándares del sector, y además es posible elegir entre diferentes modos de display de
caracteres. Evidentemente, el tamaño del display también se debe tener en cuenta. Al
medir el tamaño, se debe tratar de garantizar que la pantalla se adapte bien al dispositivo
y que sea lo suficientemente grande para leer y operar de forma efectiva.
Las pantallas LCD son comunes en los dispositivos de consumo portátiles, como las
cámaras digitales, los relojes, las calculadoras y los teléfonos móviles, incluyendo los
smartphones. Las pantallas LCD también se utilizan en los productos electrónicos de
consumo, como los reproductores de DVD, los aparatos de videojuegos y los relojes. Las
pantallas LCD están disponibles en una amplia variedad de tamaños, que van desde
pantallas pequeñas para relojes digitales hasta pantallas grandes para televisores.
Instrucciones
 LM35
LM35 es un sensor de temperatura con dimensiones reducidas, tiene un encapsulado
TO-92 de 3 pines. Su salida es analógica y lineal con una pendiente de 10mV /ºC. Permite
medir temperatura desde −55°C a 150°C, te ayudara a realizar aplicaciones como
termómetros, termostatos, sistemas de monitoreo y más.
El LM35 es sencillo de usar, no necesita de ningún circuito adicional para ser usado. Se
alimenta directamente con una fuente de 5V y entrega una salida analógica entre 0V a
1.5V. Este voltaje analógico puede ser leído por el ADC de un microcontrolador o tarjeta
de desarrollo como Arduino, ESP32, Raspberry Pi Pico, PICs y más.
Es un componente electrónico muy preciso y fácil de usar, ya que proporciona una señal
analógica directamente proporcional a la temperatura en grados Celsius. El LM35 es un
sensor de temperatura pasivo, lo que significa que no necesita ninguna fuente de
alimentación externa para funcionar. En su lugar, utiliza la energía de la señal de salida
para alimentarse, lo que lo hace muy eficiente en términos de consumo de energía. El
LM35 es muy sensible y puede medir temperaturas con una precisión del ±0.5 grados
Celsius. Es muy útil en aplicaciones donde se requiere una medida precisa de la
temperatura, como sistemas de control de temperatura, sistemas de seguridad y equipos
de medición.

Especificaciones
● Modelo: LM35
● Encapsulado: TO-92
● Pines: 3
● Montaje: Through Hole Technology (THT)
● Voltaje de Operación: 4 a 30 V (5V Recomendado)
● Rango de medición: -55°C a +150°C
● Precisión en el rango de -10°C hasta +85°C: ±0.5°C
● Pendiente: 10mV/ºC
● Bajo consumo energético: 60uA
● No necesita componentes adicionales
● Baja impedancia de salida
● Peso: 0.24 g

Pines:
● +VCC: Pin (+) Conexión a fuente de alimentación
● VOUT: Salida analógica del sensor
● GND: Pin (-) Conexión a GND o Tierra de la fuente de alimentación
Diagrama y Simulación

Circuito armado y funcionando

Temperatura normal
Midiendo la temperatura con un multímetro

Calentando el sensor con un encendedor

Código usado (C) – Arduino como ATMEGA328p
1 #define F_CPU 16000000UL // Frecuencia de la CPU del Arduino
2 #include <avr/io.h>
3 #include <util/delay.h>
4
5 // Definir el pin para el sensor LM35
6 #define LM35Pin PC0 // Pin A0
7
8 // Función para inicializar USART
9 void USART_Init(unsigned int ubrr) {
10 UBRR0H = (unsigned char)(ubrr >> 8);
11 UBRR0L = (unsigned char)ubrr;
12 UCSR0B = (1 << RXEN0) | (1 << TXEN0); // Habilitar transmisor y
13 receptor
14 UCSR0C = (1 << UCSZ01) | (1 << UCSZ00); // 8-bit data, 1 stop bit
15 }
16
17 // Función para enviar datos
18 void USART_Transmit(unsigned char data) {
19 while (!(UCSR0A & (1 << UDRE0))); // Esperar a que el buffer esté
20 vacío
21 UDR0 = data; // Colocar los datos en el buffer, envía los datos
22 }
23
24 int main(void) {
25 // Inicializar USART con baud rate de 9600
26 unsigned int ubrr = 51; // Para 16 MHz y baud rate de 9600
27 USART_Init(ubrr);
28
29 // Inicializar el ADC
30 ADMUX = (1 << REFS0); // Referencia AVcc con capacitor en AREF
31 ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1); // Habilitar ADC,
32 preescalador de 64
33
34 while (1) {
35 // Iniciar una conversión ADC
36 ADMUX = (ADMUX & 0xF8) | LM35Pin; // Seleccionar canal
37 ADCSRA |= (1 << ADSC); // Iniciar conversión
38 while (ADCSRA & (1 << ADSC)); // Esperar a que la conversión
39 termine
40
41 // Leer el valor ADC
42 int sensorValue = ADC;
43
44 // Convertir el valor a temperatura en grados Celsius
45 float temperature = sensorValue * (5.0 / 1023.0) * 100;
46
47 // Enviar la temperatura al ATmega328p
48 char buffer[10];
49 dtostrf(temperature, 6, 2, buffer); // Convertir float a string
50 for (int i = 0; buffer[i] != '\0'; i++) {
51 USART_Transmit(buffer[i]);
52 }
53 USART_Transmit('\n'); // Enviar carácter de nueva línea

_delay_ms(500); // Esperar un segundo antes de la próxima lectura

}
}

Código usado (C) – ATMEGA328p

1
#define F_CPU 8000000UL
2
#include <avr/io.h>
3
#include <util/delay.h>
4
#include <stdlib.h> // Para itoa
5
6
// Definir conexiones para la LCD
7
#define RS PB5
8
#define EN PB4
9
#define D4 PB0
10
#define D5 PB1
11
#define D6 PB2
12
#define D7 PB3
13
14
// Funciones auxiliares para el control de la LCD
15
void pulseEnable(void) {
16
PORTB |= (1 << EN);
17
_delay_us(1);
18
PORTB &= ~(1 << EN);
19
_delay_us(100);
20
}
21
22
void send4bits(uint8_t data) {
23
PORTB = (PORTB & 0xF0) | (data & 0x0F);
24
pulseEnable();
25
}
26
27
void sendCommand(uint8_t command) {
28
PORTB &= ~(1 << RS);
29
send4bits(command >> 4);
30
send4bits(command);
31
_delay_ms(2); // Espera para comandos
32
}
33
34
void sendData(uint8_t data) {
35
PORTB |= (1 << RS);
36
send4bits(data >> 4);
37
send4bits(data);
38
_delay_ms(2); // Espera para datos
39
}
40
41
void init_LCD(void) {
42
// Configurar pines de la LCD como salida
43
44 DDRB |= (1 << RS) | (1 << EN) | (1 << D4) | (1 << D5) | (1 << D6) | (1
45 << D7);
46 _delay_ms(50); // Esperar a que la LCD se inicie
47 send4bits(0x03);
48 _delay_ms(5);
49 send4bits(0x03);
50 _delay_us(150);
51 send4bits(0x03);
52 send4bits(0x02); // Modo de 4 bits
53 sendCommand(0x28); // Configurar la LCD: 2 líneas, modo 4 bits
54 sendCommand(0x0C); // Encender la pantalla, sin cursor
55 sendCommand(0x06); // Modo de entrada
56 sendCommand(0x01); // Limpiar pantalla
57 _delay_ms(2); // Esperar para que la pantalla se limpie
58 }
59
60 void lcd_setCursor(uint8_t col, uint8_t row) {
61 uint8_t address = (row == 0) ? col : col + 0x40;
62 sendCommand(0x80 | address);
63 }
64
65 void lcd_print(const char *str) {
66 while (*str) {
67 sendData(*str++);
68 }
69 }
70
71 void lcd_clear(void) {
72 sendCommand(0x01);
73 _delay_ms(2);
74 }
75
76 // Función para inicializar USART
77 void USART_Init(unsigned int ubrr) {
78 // Set baud rate
79 UBRR0H = (unsigned char)(ubrr >> 8);
80 UBRR0L = (unsigned char)ubrr;
81 // Enable receiver and transmitter
82 UCSR0B = (1 << RXEN0) | (1 << TXEN0);
83 // Set frame format: 8 data bits, 1 stop bit
84 UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
85 }
86
87 // Función para recibir datos
88 unsigned char USART_Receive(void) {
89 // Wait for data to be received
90 while (!(UCSR0A & (1 << RXC0)));
91 // Get and return received data from buffer
92 return UDR0;
93 }
94
95 // Función principal
 96 int main(void) {
97 // Inicializar la LCD
98 init_LCD();
99
100 // Set baud rate for 9600 bps
101 unsigned int ubrr = 51; // Para 8 MHz y baud rate de 9600
102 USART_Init(ubrr);
103
104 char temperatureData[10];
105 int index = 0;
106 char receivedChar;
107
108 while (1) {
109 receivedChar = USART_Receive();
110
111 // Si se recibe un carácter de nueva línea, tenemos un mensaje
112 completo
113 if (receivedChar == '\n') {
114 temperatureData[index] = '\0'; // Terminar la cadena
115 lcd_clear(); // Limpiar la pantalla LCD
116 lcd_setCursor(0, 0);
117 lcd_print("Temp: ");
118 lcd_print(temperatureData);
119 lcd_print(" C");
120
121 index = 0; // Reiniciar el índice para el próximo mensaje
122 } else {
123 if (index < 9) { // Evitar desbordamiento del buffer
124 temperatureData[index] = receivedChar;
125 index++;
126 }
127 }
128 }

return 0;
}

Conclusiones

Al implementar la comunicación USART entre el Arduino y el ATmega328P,

demostramos un método confiable para la transferencia de datos en serie, destacando
la eficiencia de utilizar las capacidades de hardware USART del ATmega328P para la
comunicación entre microcontroladores. La correcta inicialización y control del LCD
fueron cruciales para mostrar los datos correctamente. Esto se logró configurando
meticulosamente los registros de dirección de datos y aplicando los retardos apropiados,
asegurando que el LCD operara en modo de 4 bits y mostrara las lecturas de temperatura
con precisión. La funcionalidad ADC en el Arduino facilitó mediciones precisas de
temperatura del sensor LM35 al establecer el voltaje de referencia y el prescaler
adecuados, lo que resultó en lecturas estables y precisas que luego se convirtieron a un
formato legible.

Convertir los valores de temperatura de punto flotante a cadenas y transmitirlos a través

de USART requirió un manejo cuidadoso de los datos para mantener la integridad,
utilizando funciones como dtostrf para formatear las lecturas de temperatura de manera
eficiente. Asegurar la integridad de los datos durante la transmisión y recepción se
gestionó verificando los caracteres de fin de línea, permitiendo al receptor procesar
mensajes completos y evitar datos parciales o corruptos. La integración de hardware
(Arduino, ATmega328P, sensor LM35 y LCD) con software (código en C para el control
de USART y LCD) subrayó la importancia de comprender tanto las capacidades del
hardware como los requisitos del software. Las conexiones adecuadas, las secuencias
de inicialización y el manejo de los retardos fueron críticos para la funcionalidad del
sistema.

El proceso de desarrollo enfatizó la depuración y solución de problemas sistemáticos,

identificando y resolviendo problemas como configuraciones incorrectas de la tasa de
baudios y una inicialización inadecuada del LCD a través de pruebas metódicas. Los
aprendizajes clave incluyeron la necesidad de configurar correctamente los registros
periféricos para una operación confiable, la importancia crítica de los tiempos y retardos
para periféricos como los LCD, los beneficios del desarrollo de código modular para la
legibilidad y el mantenimiento, y el valor de protocolos de comunicación robustos para
mejorar la fiabilidad de la transmisión de datos.

Las mejoras futuras podrían implicar una mejor comprobación y manejo de errores para
asegurar la integridad de los datos, la optimización del consumo de energía mediante
técnicas de ahorro de energía, la escalabilidad para acomodar múltiples o diferentes tipos
de sensores, y mejoras en la interfaz de usuario en el LCD para mostrar más información,
mejor formato y, potencialmente, elementos interactivos.

Referencias
Wikipedia contributors. (2023, 13 mayo). Universal synchronous and asynchronous receiver-

transmitter. Wikipedia.
 https://en.wikipedia.org/wiki/Universal_synchronous_and_asynchronous_receiver-

transmitter

AbrahamG. (2024, 7 mayo). Comunicación entre dos Arduinos con el Puerto Serie.

Automatización Para Todos. https://www.automatizacionparatodos.com/comunicacion-

entre-dos-arduinos-con-el-puerto-serie/