PROTOCOL UART
TOPICS
◼ Teoria de la comunicación
◼ Paralelo vs. Serial
◼ Dirección: Simplex, Half duplex, Full duplex
◼ Sincronización: Sincrono vs. Asincrono
◼ Linea de Código
◼ Protocolo UART
◼ UART en AVR
◼ Registros UART
◼ Algunos programas
2
PARALELO VS. SERIAL
Parallel
Para cortas distancias
No es aplicable a largas distancias
Mas cara
Problemas deCross-talk
3
DIRECIÓN
Simplex
Half Duplex
Full Duplex
4
SINCRONIZACIÓN
Sincrono
Asincrono
5
LINE CODING
Line coding: presenting data using signals
Digital
NRZ-L: Coding using level of voltage
TTL
RS232
NRZ-I: Inverting or not inverting
Analog: using sine waves TTL
ASK
FSK NRZ-I
PSK
RS232
6
UART PROTOCOL
Serial
Asynchronous
Full duplex
7
USART (UNIVERSAL SYNCHRONOUS ASYNCHRONOUS RECEIVE TRANSMIT)
USART puede ser usado para la comunicación asíncrono (UART)y síncrona.
Puesto que la capacidad síncrona USART ya no es usada, nos concentraremos en el
UART.
8
UART EN AVR
Registros de control: (inicializa la velocidad, tamaño del dato, paridad, etc.)
UBRR, UCSRA, UCSRB, and UCSRC
Registros de envio/recepción
UDR
Registro de estado
UCSRA
9
BAUD RATE
System
clock UART baud
rate
10
EJEMPLO: ENCOENTRAR EL VALOR DE UBRR PARA 9600 BPS.
◼ Solución:
11
ALGUNOS BAUD RATES ESTANDAR
1200
2400
4800
9600
19,200
38,400
57,600
115,200
12
UCSRB Registro de control y estado B del módulo USART AVR
• El bit7 RXCIE0 Al poner este bit a 1 se habilita el uso de la interrupción USART AVR por
recepción.
• El bit6 TXCIE0 Al poner este bit a 1 se habilita el uso de la interrupción USART AVR por
transmisión.
• El bit5 UDRIE0 Al poner este bit a 1 se habilita el uso de la interrupción USART AVR la
detección de que el registro UDR0 se quedó vacío.
• El bit4 RXEN0 Al poner este bit a 1 se habilita el uso del pin RXD para la recepción del módulo
USART AVR. Se habilita es uso de la recepción.
• El bit3 TXEN0 Al poner este bit a 1 se habilita el uso del pin TXD para la transmisión del
módulo USART AVR. Se habilita es uso de la transmisión.
• El bit2 UCSZ02 Este bit junto con los bits 2 y 1 del registro UCSR0C son para elegir de cuantos
bits serán los datos a recibir o transmitir en la comunicación serial.
• El bit1 RXB80 Si se elige la comunicación serial a 9 bits, este será el noveno bit en la recepción
del dato.
• El bit0 TXB80 Si se elige la comunicación serial a 9 bits, este será el noveno bit en la
transmisión del dato.
13
UCSRC Registro de control y estado C del módulo USART AVR
◼ UMSEL01:00 (Bits 7:6): USART Mode Select
◼ Son para elegir el modo de trabajo del módulo USART AVR:
◼ 00 = Asynchronous USART operation
◼ 01 = Synchronous USART operation
◼ 10 = Reserved
◼ 11 = Master SPI (MSPIM) UCSZ02 UCSZ01 UCSZ00 Char. size
◼ UPM01:00 (Bit 5:4): Parity Mode 0 0 0 5-bit
◼ Son para elegir si se utilizará o no algún bit de paridad para la detección de errores.
◼ 00 = Disabled 0 0 1 6-bit
◼ 01 = Reserved 0 1 0 7-bit
◼ 10 = Even Parity
◼ 11 = Odd Parity 0 1 1 8-bit
◼ USBS0 (Bit 3): Stop Bit Select 1 1 1 9-bit
◼ Selecciona el número de bits de parada que se inserta por el transmisor.
◼ 0 = 1 bit
◼ 1 = 2 bits
◼ UCSZ01:00 (Bit 2:1): Character Size
◼ junto con el bit2 UCSZ02 del registro UCSR0B son para elegir de cuantos bits serán los datos a recibir o transmitir en la
comunicación serial.
◼ UCPOL0 (Bit 0): Clock Polarity
◼ Este bit es utilizado en el bit síncrono, en el modo asíncrono se pondrá a 0.
14
UDR
15
UCSRA Registro de control y estado A del módulo USART AVR
• El bit7 RXC0 Este bit se pone a 1 automáticamente cuando se ha completado la recepción de algún dato en el registro
UDR0, se pondrá a 0 automáticamente cuando se haya leído el dato, si se a habilitado el uso de la interrupción por recepción
del módulo USART AVR, este bit se utiliza para detectar la interrupción.
• El bit6 TXC0 Este bit se pone a 1 automáticamente cuando se ha completado la transmisión de algún dato que se
encontraba en el registro UDR0, se pondrá a 0 automáticamente cuando se cargue otro dato en el registro UDR0 a ser
transmitido, si se a habilitado el uso de la interrupción por transmisión del módulo USART AVR, este bit se utiliza para
detectar la interrupción.
• El bit5 UDRE0 Este bit al ponerse a 1 en forma automática indica que el registro UDR0 está vacío por lo que se le podrá
cargar con algún dato. Cuando se cargue con algún valor el registro UDR0 este bit se pondrá automáticamente a 0. Se puede
habilitar la interrupción por detección de que el registro UDCR0 está vacío y este bit será el que indique esa interrupción.
• El bit4 FE0 Este bit se pondrá a 1 automáticamente cuando hay un error en la recepción de algún dato, el error se detecta
cuando el bit de parada del dato es un 0, el que normalmente debe de ser un 1. Se recomienda siempre poner este bit a 0
antes de recibir algún dato.
• El bit3 DOR0 Este bit se pondrá a 1 automáticamente cuando se sobreescribe algún dato del registro UDR0 que no haya
sido leído, se pondrá a 0 automáticamente cuando se lea el dato, se recomiendo poner este bit a 0 antes de recibir algún
dato.
• El bit2 UPE0 Este bit se pondrá a 1 automáticamente cuando se produce un error de paridad en la recepción de algún dato,
se pondrá a 0 automáticamente cuando se lea el dato, se recomiendo poner este bit a 0 antes de recibir algún dato.
• El bit1 U2X0 Este bit interviene en la velocidad de los datos, esto es en los baudio que es la cantidad de bits por segundo en
la comunicación serial, si es puesto a 0 se dice que la velocidad será normal y si es puesto a 1 se dice que será a
doble velocidad.
• El bit0 MPCM0 Este bit es utilizado en el modo síncrono y es para detectar cual de los microcontroladores esclavo a sido
elegido. en modo asíncrono se pondrá a 0. 16
PROGRAMA: ENVIAR EL CARACTER ‘G’ CONTINUAMENTE
#include <avr/io.h>
void usart_init (void)
{
UCSR0B = (1<<TXEN0);
UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);
UBRR0L = 103; //baud rate = 9600bps
}
void usart_send (unsigned char ch)
{
while (! (UCSR0A & (1<<UDRE0))); //espera hasta que UDR0 este vacio
UDR0 = ch; //transmite ch
}
int main (void)
{
usart_init(); //inicializa el USART
while(1) //hace siempre
usart_send ('G'); //transmite la letra ‘G’
return 0;
}
17
PROGRAMA 2: RECIBE BYTES DE DATOS SERIALMENTE Y LO COLOCA EN EL PORTB.
#include <avr/io.h>
int main (void)
{
DDRB = 0xFF; //Port B como salida
UCSR0B = (1<<RXEN0); //inicializa USART0
UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);
UBRR0L = 103;
while(1)
{
while (! (UCSR0A & (1<<RXC0))); //espera a un nuevo dato
PORTB = UDR0;
}
return 0;
}
18
PROGRAMA :
Configurar el microcontrolador para que trabaje a velocidad normal para transmisión y recepción a 8 bits, de
manera asíncrono, sin bit de paridad, 1 bit de parada a 8 bits con una tasa de 9600 baudios. La FCP es de
8Mhz
UCSR0A=0b00000000; // velocidad normal
UCSR0B=0b00011000; //transmisión y recepción habilitados a 8 bits
UCSR0C=0b00000110; //asíncrono, sin bit de paridad, 1 bit de parada a 8 bits
UBRR0=51; //para una velocidad de 9600 baudios con un oscilador de 8Mhz
SE PUEDE USAR FUNCIONES
void iniciar_uart(){
UCSR0B=0b00011000; //transmisión y recepción habilitados a 8 bits
UCSR0C=0b00000110; //asíncrono, sin bit de paridad, 1 bit de parada a 8 bits
UBRR0=51; //para una velocidad de 9600 baudios con un oscilador de 8Mhz
}
19
PROGRAMA :
Configurar el microcontrolador para que trabaje a velocidad normal para transmisión y recepción a 8 bits, de
manera asíncrono, sin bit de paridad, 1 bit de parada a 8 bits con una tasa de 9600 baudios. La FCP es de
8Mhz
SE PUEDE USAR FUNCIONES
Para la recepción de datos con el módulo USART AVR.
unsigned char recibe_caracter_uart(){
while (! (UCSR0A & (1<<RXC0))); //espera a un nuevo dato
return UDR0; //retorna 0
}
20
PROGRAMA :
Configurar el microcontrolador para que trabaje a velocidad normal para transmisión y recepción a 8 bits, de
manera asíncrono, sin bit de paridad, 1 bit de parada a 8 bits con una tasa de 9600 baudios. La FCP es de
8Mhz
SE PUEDE USAR FUNCIONES
Para la transmisión de datos con el módulo USART AVR.
void envia_caracter_uart(unsigned char caracter){
while(!(UCSR0A&(1<<5))); // mientras el registro UDR0 esté lleno espera
UDR0 = caracter; //cuando el el registro UDR0 está vacio se envia el caracter
}
Para la transmisión de cadenas de caracteres con el módulo USART AVR
void envia_cadena_uart(char* cadena){ //cadena de caracteres de tipo char
while(*cadena !=0x00){ //mientras el último valor de la cadena sea diferente
//a el caracter nulo
envia_caracter_usart(*cadena); //transmite los caracteres de cadena
cadena++; //incrementa la ubicación de los caracteres en cadena
//para enviar el siguiente caracter de cadena
}
} 21
PROGRAMA 3
En este ejemplo se realizará la comunicación serial entre 2 microcontroladores ATMEGA328P, mediante dos
pulsadores conectados en los pines PB0 y PB1 de uno de los AVR del que se utilizarán sus resistecias internas
pull up, se podrá encender o apagar un led conectado en el pin PC5 del otro AVR.
PROGRAMA 3
#define F_CPU 16000000UL
#include <avr/io.h>
#include "uart.h" //archivo de cabecera para utilizar el módulo UART
int main(void)
{
DDRB&=~((1<<0)|(1<<1)); //PB0 y PB1 como entradas digitales para los pulsadores
PORTB|=((1<<0)|(1<<1)); //habilita las resitencias pull up de PB0 y PB1
iniciar_uart(); //inicia el módulo UART
while(1)
{
if(!(PINB&(1<<0))){ //si se preciona el pulsador para encender el led
envia_caracter_uart('e'); //se transmitirá el caracter 'e' hacia PIC 2
}
if(!(PINB&(1<<1))){ //si se preciona el pulsador para apagar el led
envia_caracter_uart('a'); //se transmitirá el caracter 'a' hacia PIC 2
}
}
}
PROGRAMA 3
#define F_CPU 16000000UL
#include <avr/io.h>
#include "uart.h" //archivo de cabecera para utilizar el módulo UART AVR
int main(void)
{
unsigned char dato; //para guardar el dato de tipo caracter recibido
DDRB|=(1<<5); //PC5 como salida digitales para conectar el led a controlar desde el AVR1
PORTB&=~(1<<5); //El led inicia apagado
iniciar_uart(); //inicia el módulo UART
while(1)
{
dato=recibe_caracter_uart(); //para leer el caracter recibido del AVR1
if(dato=='e'){ //si el dato recibido es el caracter 'e'enciende el led
PORTB|=(1<<5);
}
if(dato=='a'){ //si el dato recibido es el caracter 'a'apaga el led
PORTB&=~(1<<5);
}
}
}
PROGRAMA 4
En este ejemplo se realizará la comunicación serial entre 2 microcontroladores ATMEGA328P, los datos leídos
del nibble bajo del PORTB del primer microcontrolador son trasmitidos de forma serial al segundo
microcontrolador, el cual los mostrara en nible bajo de su PORTB.
PROGRAMA 4
#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>
#include "uart.h" //archivo de cabecera para utilizar el módulo USART AVR
int main(void)
{
DDRB&=~((1<<0)|(1<<1)|(1<<2)|(1<<3));//PB0 y PB3 como entradas digitales
iniciar_uart(); //inicia el módulo UART
while(1)
{
envia_caracter_uart(PINB&0x0F); //se envia el nible bajo del PORTB
_delay_ms(10);
}
}
PROGRAMA 4
#define F_CPU 16000000UL //frecuencia de trabajo del AVR
#include <avr/io.h>
#include <util/delay.h>
#include "uart.h" //archivo de cabecera para utilizar el módulo USART AVR
int main(void)
{
DDRB|=((1<<0)|(1<<1)|(1<<2)|(1<<3)); //PB= a PB3 como salida digitales
iniciar_uart();//inicia el módulo USART AVR
while(1)
{
PORTB=recibe_caracter_uart();//para leer el caracter recibido del AVR1
}
}
PROGRAMA 5
En este ejemplo se realizará la comunicación serial entre el microcontrolador ATMEGA328P y una
computadora utilizando el archivo de cabecera uart.h, se encenderá y apagará un led conectado en el
microcontrolador, al presionar la tecla + de la computadora se encenderá el led, al presionar la tecla – de la
computadora se apagará el led.
#define F_CPU 16000000UL //frecuencia de trabajo del AVR
#include <avr/io.h>
#include <util/delay.h>
#include "uart.h" //archivo de cabecera para utilizar el módulo USART AVR
PROGRAMA 4 int main(void)
{
DDRB|=(1<<0); //Pin PB0 como salida digital para conectar el led
PORTB&=~(1<<0); //El led inicia apagado
iniciar_uart(); //inicia el módulo UART
unsigned char dato; //para guardar el caracter recibido del ordenador
envia_cadena_uart("*************************************");
envia_caracter_uart(13);//para retorno de carro
envia_cadena_uart("** MICROPROCESADORES II **");
envia_caracter_uart(13);//para retorno de carro
envia_cadena_uart("*************************************");
envia_caracter_uart(13);//para retorno de carro
envia_caracter_uart(13);
envia_caracter_uart(13);
envia_cadena_uart("PRESIONE + PARA ENCEDER EL LED");
envia_caracter_uart(13);//para retorno de carro
envia_cadena_uart("PRESIONE - PARA APAGAR EL LED");
envia_caracter_uart(13);
envia_caracter_uart(13);
while(1)//ciclo del programa
{
dato=recibe_caracter_uart(); //guarda en dato el caracter recibido de la computadora
if(dato=='+'){ //si el caracter recibido es '+'
PORTB|=(1<<0); //se enciende el led
envia_cadena_uart("LED ENCENDIDO"); //mensaje a enviar al ordenador que será visto
envia_caracter_uart(13); //para retorno de carro
}
else if(dato=='-'){ //sino si el caracter recibido es '-'
PORTB&=~(1<<0); //se apaga el led
envia_cadena_uart("LED APAGADO"); //mensaje a enviar al ordenador que será visto
envia_caracter_uart(13);//para retorno carro
}
}
}
CONVERTIDOR USB A SERIAL IN ARDUINO
30
MAX232
31
