MICROCONTROLADORES ATEMEL
UNAC-FIEE
T EM E M A : U SA S A R T A V R Co C o m u n i c a c i ón ó n s e r i al al INTRODUCCION USART AVR, viene de receptor transmisor síncrono asíncrono universal, es una forma de comunicación comunicación entre entre dispositiv dispositivos os que tengan tengan esta capacidad capacidad,, donde los datos datos pueden pueden ser enviados en grupos de 5, 6, 7, 8 o de 9 bits pero bit por bit, esto es en serie, por eso se dice que esta es una comunicación serial, en esta sección se comentará sobre la comunicación serial asíncrona asíncrona utilizando utilizando el módulo USART del microcontro microcontrolador lador AVR, con el módulo USART AVR el microcontrolador puede comunicarse e intercambiar datos con el ordenador, con otros microcontroladores, etc. Para la comunicación serial asíncrona entre microcontroladores y para la comunicación entre el microcontrolad microcontrolador or y el ordenador, ordenador, se necesitan necesitan 2 hilos de conducción conducción para la transmisión transmisión y recepción de datos, y un hilo de conducción para la conexión de los comunes o GND que tienen que ser los los mismos, mismos, para la comunicación comunicación serial serial entre entre el microcon microcontrolad trolador or y el ordenador se seguirá la norma RS232.
En la comunicaci comunicación ón USART USART AVR AVR asíncrona asíncrona, uno de los hilos será para la transmisión de los datos de un dispositivo a otro y el otro hilo será para la recepción de datos entre un dispositivo a otro, la transmisión y la recepción pueden ocurrir en forma simultanea, lo que si se tiene que cumplir cumplir es que la frecuencia frecuencia de trabajo de ambos disposit dispositivos ivos tiene tiene que ser la misma, a esto se le conoce como los baudios que viene a ser la cantidad de bits por segundo que se transmitirán entre ambos dispositivos.
El microcontro microcontrolador lador AVR AVR utilizado utilizado como referenc referencia ia será el ATmega88, los pines de este microcontrolad microcontrolador or que trabajan con el módulo USART AVR son El pin RXD o pin receptor receptor y el pin TXD o pin transmisor , los que en la imagen están resalt resaltados ados . El pin RXD es el pin para la recepción de datos. El pin TXD es el pin para la transmisión de datos. El pin RXD RXD del AVR AVR tiene que que ser conectado conectado al pin TX o TXD del otro dispositi dispositivo. vo. El pin TXD del AVR tiene que ser conectado al pin RX o RXD del otro dispositivo Los comunes GND de ambos dispositivos también tienen que estar conectados entres si.
Los niveles de tensión Con los que trabajan trabajan los pines pines del módulo módulo USART USART AVR son de 0V y 5V un un bajo será será 0V mientras que un alto será 5V, por eso cuando la comunicación es entre microcontroladores la conexión entre pines se puede hacer directamente, pero cuando la comunicación es entre el microcontrolador y un ordenador la conexión entre pines tiene que hacerse a través de un Prof. MSc. Jacob Astocondor Villar
1
MICROCONTROLADORES ATEMEL
UNAC-FIEE
conversor de nivel como el MAX232, ya que los niveles de tensión para la comunicación serial del ordenador ordenador son mayores que que para el AVR típicamente típicamente entre entre -12V y 12V, además además de trabajar trabajar con lógica negativa, esto es para el ordenador un bajo será 12V mientras un alto será -12V.
Hay otra manera manera de conectar conectar el AVR con el ordenador ordenador para la comunicació comunicación n serial mediante mediante resistencia resistencias s y la compuerta compuerta inversora inversora tipo tipo Schmitt 74HC14 como se ve en la siguiente imagen.
El socket donde donde se conectará el AVR con el ordenador ordenador para la comunicación comunicación serial serial es del tipo DB9 y se conoce como puerto serie, pero resulta que este tipo de puerto ya no viene en los ordenadores portátiles que son los que hoy en día la mayoría utiliza, lo que traen ahora son puertos puertos USB, por lo que para realizar realizar la comunicación comunicación serial serial con el módulo USART USART AVR será necesario la utilización de un conversor SERIE-USB como el que se muestra en la siguiente imagen
El conector DB9 es el que se utiliza para la comunicación serial con el módulo USART AVR, este este conect conector or const consta a de de 9 pine pines, s, los los hay hembra hembra y mach macho, o, de este este conecto conectorr solo solo se utilizarán 3 pines, uno para el pin RX, otro para el pin TX y el otro para el tierra, estos pines tiene una numeración que hay que respetar.
Prof. MSc. Jacob Astocondor Villar
2
MICROCONTROLADORES ATEMEL
UNAC-FIEE
El conversor serie-USB viene con el conector DB9 macho, si el cable que trae es corto se tendrá que conseguir un cable serie DB9 del que la hembra se conectará al conector DB9 macho del conversor serie-USB y el DB9 macho del cable serie DB9 al microcontrolador AVR ya sea a través del MAX232 o con el uso de la compuerta inversora como se comentó lineas arriba, por lo que los pines a conectar del DB9 macho con el módulo USART AVR son en el siguiente orden: •
El pin 2 que es pin receptor RX del conector DB9 macho que viene del ordenador, se conectará a través del MAX232 o con el uso de la compuerta inversora y la resistencia de 1K al pin transmisor o pin TXD del microcontrolador AVR.
•
El pin 3 que es pin transmisor TX del conector DB9 macho que viene del ordenador, se conectará a través del MAX232 o con el uso de la compuerta inversora y la resistencia de 22K al pin receptor o pin RXD del microcontrolador AVR.
•
El pin 5 que es pin GND o tierra o común del conector DB9 macho que viene del ordenador, se conectará al pin GND del microcontrolador AVR.
Las conexiones del módulo USART AVR con el ordenador a través de la compuerta inversora y las resistencias, con el uso del conversor serie-USB será como se indica en la siguiente imagen.
USART AVR PROGRAMACIÓN Para programar el módulo USART AVR se recomienda mucho leer la hoja de datos del AVR utilizado, siguientes
como
referencia
se
verá
para
el ATmega88,
del
que
se
utilizan
los
registros, se verá que estos tienen una n, esto es porque algunos otros
microcontroladores AVR tienen mas de un módulo USART, el ATmega88 sólo tiene uno y en este caso n será 0 n=0, y será lo que se utilice en la descripción de los registros, los registros son:
Prof. MSc. Jacob Astocondor Villar
3
MICROCONTROLADORES ATEMEL
UNAC-FIEE
El registro UDRn, El registro UCSRnA, El registro UCSRnB, El registro UCSRnC, Los registros UBRRnL y UBRRnH, se pueden producir interrupciones USART AVR.
El registro UDR0 en este registro se pondrá el carácter que se quiera transmitir, y también se encontrará el carácter recibido, tiene esta doble función, n es reemplazado por 0.
El registro UCSR0A Registro de control y estado A del módulo USART AVR, n es reemplazado por 0.
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.
Prof. MSc. Jacob Astocondor Villar
4
MICROCONTROLADORES ATEMEL
UNAC-FIEE
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.
El registro UCSR0B Registro de control y estado B del módulo USART AVR, n es reemplazado por 0.
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.
El registro UCSR0C Registro de control y estado C del módulo USART AVR, n es reemplazado por 0.
El bit7 UMSEL01 y el bit6 UMSEL00 son para elegir el modo de trabajo del módulo USART AVR, según la siguiente tabla.
Se verá el modo asíncrono por lo que las combinaciones de estos bits serán 00.
El bit5 UPM01 y el bit4 UPM00 son para elegir si se utilizará o no algún bit de paridad para la detección de errores según la siguiente tabla:
Prof. MSc. Jacob Astocondor Villar
5
MICROCONTROLADORES ATEMEL
UNAC-FIEE
En los ejemplos a realizar no se utilizará el bit de paridad por lo que la combinación de estos bits será 00.
El bit3 USBS0 Este bit selecciona el número de bits de parada que se inserta por el transmisor. El receptor ignora este ajuste, según la siguiente tabla:
El bit2 UCSZ01 y el bit1 UCSZ00 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, según la siguiente tabla:
El bit0 UCPOL0 Este bit es utilizado en el bit síncrono, en el modo asíncrono se pondrá a 0. Los registros UBRR0L y UBRR0H Juntos estos registros hacen un solo registro de 16 bits el UBRR0, es donde se debe cargar el valor con el que se elige la velocidad de transmisión de los datos, esto es los baudios o la cantidad de bits por segundo que se enviarán en la comunicación serial con el módulo USART AVR, trabaja junto con el bit U2X0 del registro UCSR0A. El valor a cargar en el registro UBRR se calcula con las siguientes fórmulas que dependerán de la velocidad elegida con el bit U2X0, de la frecuencia del oscilador utilizado y de si la comunicación será síncrona o asíncrona.
Prof. MSc. Jacob Astocondor Villar
6
MICROCONTROLADORES ATEMEL
UNAC-FIEE
Los ejemplos que se harán serán para la transmisión asíncrona en el modo normal por lo que la fórmula que se utilizará será:
Velocidad en baudios=Fosc/(16*(UBRR0+1)) Es importante recordar que la velocidad en baudios de los dispositivos que se estén comunicando tienen que ser iguales, la mas común es la de 9600 baudios, si en la fórmula anterior se reemplaza y se despeja se tendrá: UBRR0=(Fosc/(16*9600))-1 de donde:
UBRR0=(Fosc/153600)-1 Por ejemplo si el oscilador es de 8MHz se tendrá
UBRR0=(8000000/153600)-1=51 Por lo que para obtener un una velocidad de 9600 baudios se tendrá que cargar el registro UBRR0 con 51. Hay un cuadro en la hoja de datos donde se tienen algunos valores a cargar en este registro para el modo síncrono y asíncrono dependiendo de la frecuencia del oscilador utilizado y de la velocidad elegida.
Prof. MSc. Jacob Astocondor Villar
7
MICROCONTROLADORES ATEMEL
UNAC-FIEE
USART AVR PROGRAMACIÓN en el ATMEL STUDIO Para la programación del módulo USART AVR en el ATMEL STUDIO, en este caso se comentará como se puede proceder para utilizar el módulo USART AVR en modo asíncrono del ATmega88 ,
lo
aquí
comentado
es
muy
similar
para
otros
microcontroladores AVR.
Para iniciar el módulo USART AVR. Los pines del ATmega88 para el manejo del módulo USART AVR son el pin PD0 para la recepción de datos por lo que en este caso se le llama pin RXD, y el pin PD1 para la transmisión de datos, en este caso se le llama pin TXD.
Configuración del registro UCSR0A Todos los bits de este registro se pondrán a 0 ya que a excepción del bit bit1 U2X0 y el bit0 todos los demás bits trabajan en forma automática, el bit1 se pone a 0 porque se trabajará en la velocidad de los baudios en forma normal, y el bit 0 se pone a 0 porque se usará el modo asíncrono. Luego en la inicialización del módulo USART AVR el registro UCSR0A en el ATMEL STUDIO quedará así:
UCSR0A=0b00000000;// velocidad normal Configuración del registro UCSR0B No se utilizarán interrupciones, se habilitarán los pines RXD y TXD para la comunicación serial y la comunicación será a 8 bits
El bit7 se pondrá a 0 porque no usará la interrupción USART AVR por recepción. El bit6 se pondrá a 0 porque no usará la interrupción USART AVR por transmisión. El bit5 se pondrá a 0 porque no usará la interrupción USART AVR la detección de que el registro UDR0 se quedó vacío.
Prof. MSc. Jacob Astocondor Villar
8
MICROCONTROLADORES ATEMEL
UNAC-FIEE
El bit4 se pondrá este bit a 1 para habilitar el uso del pin RXD en la recepción del módulo USART AVR. Se habilita es uso de la recepción.
El bit3 se pondrá este bit a 1 para habilitar el uso del pin TXD para la transmisión del módulo USART AVR. Se habilita es uso de la transmisión.
El bit2 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, se utilizará la comunicación serial a 8 bits, por lo que este bit se pondrá a 0.
El bit1 se pone a 0 ya que este bit será el noveno bit en la recepción del dato, si la comunicación es a 9 bits.
El bit0 se pone a 0 ya que este bit será el noveno bit en la transmisión del dato, si la comunicación es a 9 bits. Luego en la inicialización del módulo USART AVR el registro UCSR0B en el ATMEL STUDIO quedará así:
UCSR0B=0b00011000;//transmisión y recepción habilitados a 8 bits Configuración del registro UCSR0C se elegirá el modo asíncrono, sin bit de paridad, un bit de parada
Los bits 7 y 6 se ponen a 0 para elegir el modo asíncrono del módulo USART AVR. Los bits 5 y 4 se ponen a 0 para no utilizar bit de paridad. El bit3 se pone a 0 para elegir un solo bit de parada. Los bits 2 y 1 se ponen a 1 para elegir que la comunicación serial será a 8 bits. El bit0 Este bit es utilizado en el bit síncrono, en el modo asíncrono se pondrá a 0. Luego en la inicialización del módulo USART AVR el registro UCSR0B en el ATMEL STUDIO quedará así:
UCSR0C=0b00000110;//asíncrono, sin bit de paridad, 1 bit de parada a 8 bits Carga del registro UBRR0 para los baudios o la cantidad de bits por segundo para la comunicación
serial,
como
será
a
velocidad
normal por
lo
que
el
bit U2X0 del
registro UCSR0A se puso a 0 y en forma asíncrona, se utilizará la fórmula.
Velocidad en baudios=baudios=Fosc/(16*(UBRR0+1)) Al despejar se tendrá
UBRR0=(Fosc/(16*baudios))-1 En los ejemplos que se harán se utilizará una Fosc de 8Mhz y la velocidad será de 9600 baudios, por lo que al reemplazar se tendrá que el valor a cargar en el registro UBRR0 será de 51, luego en el ATMEL STUDIO será:
UBRR0=51;//para una velocidad de 9600 baudios con un oscilador de 8Mhz Entonces se puede iniciar el módulo USART AVR en el ATMEL STDIO de la siguiente manera: ////////////////////////////////////////////// //inicialización del módulo USART AVR en el ATMEL STUDIO modo asíncrono, a 8bits, //a 9600 baudios, sin bit de paridad, 1 bit de parada UCSR0A=0b00000000; UCSR0B=0b00011000; UCSR0C=0b00000110; UBRR0=51;
// velocidad normal //transmisión y recepción habilitados a 8 bits //asíncrono, sin bit de paridad, 1 bit de parada a 8 bits //para una velocidad de 9600 baudios con un oscilador de 8Mhz
Prof. MSc. Jacob Astocondor Villar
9
MICROCONTROLADORES ATEMEL
UNAC-FIEE
La inicialización podría hacerse dentro de una función a la que se le puede dar el nombre que se quiera, en este caso se la llamará iniciar_usart(), además el registro UCSR0A siempre se inicia a 0 por lo que no es necesario inicializarlo en este caso ya que se necesita que sea 0, lo que en el ATMEL STUDIO será así: //inicialización del módulo USART AVR modo asíncrono //en una función, a 8bits,a 9600 baudios, sin bit de paridad //1 bit de parada ///////////////////////////////////////////////////// void iniciar_usart(){ 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 }
Para la recepción de datos con el módulo USART AVR. Los datos que se reciben son de tipo caracter, cuando se va recibir un dato a través del pin RXD se tendrá que esperar a que el bit7 del registro UCSR0A se ponga a 1, este bit indica que se ha completado la recepción del dato, el dato recibido es de tipo caracter char y estará en el registro UDR0, cuando se lee el dato guardándolo en alguna variable de tipo caracter char este bit se pondrá automáticamente a 0, la recepción de los datos en el ATMEL STUDIO se hará en una función a la que se le puede llamar como se desee, en este caso se le llamará
recibe_caracter_usart(). ///////////////////////////////////////////// //recepción de datos del módulo USART AVR modo asíncrono //////////////////////////////////////////////////////////// unsigned char recibe_caracter_usart(){ if(UCSR0A&(1<<7)){ //si el bit7 del registro UCSR0A se ha puesto a 1 return UDR0; //devuelve el dato almacenado en el registro UDR0 } else//sino return 0;//retorna 0 }
Para la transmisión de datos con el módulo USART AVR. Los datos que se transmiten son de tipo caracter, cuando se va transmitir un dato a través del pin TXD se tendrá que esperar a que el registro UDR0 donde se ponen los datos que se van a enviar esté vacío, esto se hace esperando a que el bit5 UDRE0 del registro UCSR0A se ponga a 1, este bit indica que se ha completado la transmisión de un dato, el dato transmitido es de tipo caracter char, cuando se vuelve a cargar otro dato en el registro UDR0 este bit se pondrá automáticamente a 0, la transmisión de los datos en el ATMEL STUDIO se hará en una función a la que se le puede llamar como se desee, en este caso se le llamará envia_caracter_usart(). ////////////////////////////////////////////// //transmisión de datos del módulo USART AVR modo asíncrono /////////////////////////////////////////////// void envia_caracter_usart(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
Prof. MSc. Jacob Astocondor Villar
10
MICROCONTROLADORES ATEMEL
UNAC-FIEE
Se puede utilizar la función vista anteriormente para la transmisión de caracteres para enviar cadenas de caracteres, para ello se creará otra función que se puede llamar como se desee pero en este caso se le llamará envia_cadena_usart().
/////////////////////////////////////////////////////// ////////////////////////////////////////////// //transmisión de cadenas de caracteres con el módulo USART AVR modo asíncrono /////////////////////////////////////////////// void envia_cadena_usart(char* cadena){ while(*cadena !=0x00){ envia_caracter_usart(*cadena); cadena++;
//cadena de caracteres de tipo char //mientras el último valor de la cadena sea diferente //a el caracter nulo //transmite los caracteres de cadena //incrementa la ubicación de los caracteres en cadena //para enviar el siguiente caracter de cadena
} }
ARCHIVO DE CABECERA PARA EL USO DEL MÓDULO USART AVR EN EL ATMEL STUDIO Se puede agrupar todas la funciones vistas anteriormente para el uso del módulo USART AVR en el ATMEL STUDIO para el ATMEGA88 con una Fosc=8Mhz, en forma asíncrona, 8 bits, a 9600 baudios, sin bit de paridad, 1 bit de parada, en un archivo de cabecera al que se le llamará en este caso usart.h, aunque se le puede dar el nombre que se desee, se hará uso de este archivo de cabecera en los ejemplos que se realizarán con el ATMEGA88, si se utiliza otro AVR u otra velocidad de comunicación es fácil hacer los cam bios que se necesiten dentro del archivo usart.h, se verá algún ejemplo. //////////////////////////////////////////////////////////// //////// //Archivo de cabecera para el uso del módulo USART AVR con el ATMEL STUDIO/// /////////////////////////////////////////////////////////////////// #ifndef USART_H #define USART_H void iniciar_usart(); //función para iniciar el USART AVR asíncrono, 8 bits, 9600 baudios, //sin bit de paridad, 1 bit de parada unsigned char recibe_caracter_usart(); //función para la recepción de caracteres void envia_caracter_usart(unsigned char); //función para la transmisión de caracteres void envia_cadena_usart(char*); //función para la transmisión de cadenas de caracteres ///////////////////////////////////////////// //inicialización del módulo USART AVR modo asíncrono //en una función, a 8bits,a 9600 baudios, sin bit de paridad //1 bit de parada ///////////////////////////////////////////////////// void iniciar_usart(){ 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 } /////////////////////////////////////////////////////////// /////////////////////////////////////////////// //recepción de datos del módulo USART AVR modo asíncrono //////////////////////////////////////////////////////////// Prof. MSc. Jacob Astocondor Villar
11
MICROCONTROLADORES ATEMEL
UNAC-FIEE
unsigned char recibe_caracter_usart(){ if(UCSR0A&(1<<7)){ //si el bit7 del registro UCSR0A se ha puesto a 1 return UDR0; //devuelve el dato almacenado en el registro UDR0 } else//sino return 0;//retorna 0 } /////////////////////////////////////////////// //transmisión de datos del módulo USART AVR modo asíncrono /////////////////////////////////////////////// void envia_caracter_usart(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 } ////////////////////////////////////////////// //transmisión de cadenas de caracteres con el módulo USART AVR modo asíncrono /////////////////////////////////////////////// void envia_cadena_usart(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 } } #endif /* USART_H */
APLICACIONES
USART AVR ejemplos Prof. MSc. Jacob Astocondor Villar
12
MICROCONTROLADORES ATEMEL
UNAC-FIEE
Anterior: USART AVR Comunicación Serial. En esta sección se realizarán algunos ejemplos sencillos realizados con el ATMEL STUDIO sobre la utilización del módulo USART AVR en modo asíncrono, esta es la parte práctica de lo que se vio aquí.. Se utilizará el archivo de cabecera usart.h que se obtuvo para la transmisión y recepción de datos con el módulo USART AVR, el microcontrolador AVR para realizar el USART AVR ejemplos será el ATMEGA88 en un inicio, luego se complementará con otros AVR. El archivo de cabecera usart.h que se obtuvo para ser utilizado con el ATMEGA88 en el que la Fosc=8Mhz y la velocidad de comunicación será a 9600 baudios es el siguiente, con algunas pequeñas modificaciones se puede utilizar en cualquier otro AVR, si se utiliza otra Fosc y/o otra velocidad de comunicación hay que hacer los cálculos con
UBRR0=(Fosc/(16*baudios))-1 para el nuevo valor a cargar en UBRR0. ////////////////////////////////////////////////////////////////////
//Archivo de cabecera para el uso del módulo USART AVR con el ATMEL STUDIO/// /////////////////////////////////////////////////////////////////// #ifndef USART_H #define USART_H void iniciar_usart();
//función para iniciar el USART AVR asíncrono, 8 bits, 9600 baudios, //sin bit de paridad, 1 bit de parada
unsigned char recibe_caracter_usart(); //función para la recepción de caracteres void envia_caracter_usart(unsigned char); //función para la transmisión de caracteres void envia_cadena_usart(char*); //función para la transmisión de cadenas de caracteres ///////////////////////////////////////////// //inicialización del módulo USART AVR modo asíncrono //en una función, a 8bits,a 9600 baudios, sin bit de paridad //1 bit de parada ///////////////////////////////////////////////////// void iniciar_usart(){ 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 } /////////////////////////////////////////////////////////// //recepción de datos del módulo USART AVR modo asíncrono //////////////////////////////////////////////////////////// unsigned char recibe_caracter_usart(){ if(UCSR0A&(1<<7)){ //si el bit7 del registro UCSR0A se ha puesto a 1 return UDR0; //devuelve el dato almacenado en el registro UDR0 } else//sino return 0 ;//retorna 0 } ////////////////////////////////////////////////////// //transmisión de datos del módulo USART AVR modo asíncrono /////////////////////////////////////////////// void envia_caracter_usart(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 } ////////////////////////////////////////////////////// //transmisión de cadenas de caracteres con el módulo USART AVR modo asíncrono ///////////////////////////////////////////////
Prof. MSc. Jacob Astocondor Villar
13
MICROCONTROLADORES ATEMEL
UNAC-FIEE
void envia_cadena_usart(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 } } #endif
/* USART_H */
USART AVR ejemplos 1
Prof. MSc. Jacob Astocondor Villar
14
MICROCONTROLADORES ATEMEL
UNAC-FIEE
En este primer ejemplo se realizará la comunicación serial entre 2 microcontroladores ATMEGA88, 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. El ejemplo es sencillo para no complicar el código, pero se puede hacer lo que se quiera mediante la comunicación serial, la idea será la misma si se quiere hacer cualquier tipo de control de un microcontrolador con otro microcontrolador.
EJEMPLO1 ENUNCIADO En este ejemplo lo que se busca es que se vea como utilizar el archivo de cabecera usart.h ya que será el utilizado en los siguientes USART AVR ejemplos. En la siguiente imagen se ha creado un proyecto llamado usart1, con el archivo fuente llamado
usart_avr_ejemplos1.c, el la parte resaltada usart1 se hace click derecho y en Add se selecciona New Item…, en la ventana que aparece se selecciona Include File y en name se le da el nombre de usart.h, y se pulsa sobre Add así se creará el archivo llamado usart.h, luego se hace doble click sobre el archivo usart.h creado para que abrir el editor usart.h, se borra todo lo que el programa genere, que quede limpio, se copia el contenido mostrado lineas arriba para el archivo de cabecera y se pega dentro de usart.h, el resultado debe ser similar al que se ve en la siguiente imagen.
A partir de este momento ya se puede utilizar el archivo de cabecera usart.h para realizar la comunicación serial con el módulo USART AVR El circuito utilizado para el USART AVR ejemplos 1 es el siguiente:
Prof. MSc. Jacob Astocondor Villar
15
MICROCONTROLADORES ATEMEL
UNAC-FIEE
Con el pulsador del pin PB0 del AVR1 se encenderá el led del pin PC5 del AVR2, con el pulsador del pin PB1 del AVR1 se apagará el led del pin PC5 del AVR2. En el código para el AVR1 se tiene que hacer que al presionar el pulsador para encender el led se transmitirá el caracter ‘e’ al AVR2, al presionar el pulsador para apagar el led se transmitirá el caracter ‘a’ al AVR2, el siguiente será el código para el AVR1.
CODIGO PRIMER ATMEGA8 ////////////////////////////////////////////// ///////*********************************/////// ///*** microcontroladores ***//// ///////*****************************////////// //* USART AVR ejemplos 1 código para el AVR1* // ///////********************************/////// #define F_CPU 8000000UL //frecuencia de trabajo del AVR #include
#include "usart.h" //archivo de cabecera para utilizar el módulo USART AVR int main(void) { DDRB&=~((1<<0)|(1<<1));//PB0 y PB1 como entradas d igitales para los pulsadores PORTB|=((1<<0)|(1<<1));//habilita las resitencias internas pull up de PB0 y PB1 iniciar_usart();//inicia el módulo USART AVR while(1) { if(!(PINB&(1<<0))){//si se preciona el pulsador para encender el led envia_caracter_usart('e');//se transmitirá el caracter 'e' hacia PIC 2 } if(!(PINB&(1<<1))){//si se preciona el pulsador para apagar el led envia_caracter_usart('a');//se transmitirá el caracter 'a' hacia PIC 2 } } }
En el código para el AVR2 se tiene que hacer que cuando reciba el caracter ‘e’ el led se encienda y cuando reciba el caracter ‘a’ el led se apague. El siguiente será el código para el AVR2 ///////////////////////////////////////////// ///////*********************************/////// ///*** microcontroladores ***//// ///////*****************************////////// //* USART AVR ejemplos 1 código para el AVR2 *// ///////********************************/////// #define F_CPU 8000000UL //frecuencia de trabajo del AVR #include #include "usart.h" //archivo de cabecera para utilizar el módulo USART AVR
Prof. MSc. Jacob Astocondor Villar
16
MICROCONTROLADORES ATEMEL
UNAC-FIEE
int main(void) { unsigned char dato; //para guardar el dato de tipo caracter recibido DDRC|=(1<<5); //PC5 como salida digitales para conectar el led a controlar //desde el AVR1 PORTC|=(1<<5);//El led inicia apagado iniciar_usart();//inicia el módulo USART AVR while(1) { dato=recibe_caracter_usart(); //para leer el caracter recibido del AVR1 if(dato=='e'){ //si el dato recibido es el caracter 'e' PORTC|=(1<<5); //enciende el led } if(dato=='a'){ //si el dato recibido es el caracter 'a' PORTC&=~(1<<5); //apaga el led } } }
USART AVR ejemplo 2 Prof. MSc. Jacob Astocondor Villar
17
MICROCONTROLADORES ATEMEL
UNAC-FIEE
ENUNCIADO En este segundo ejemplo se realizará la comunicación serial entre 2 microcontroladores PIC, uno de ellos será el ATMEGA328P y el otro será el ATMEGA88, en el ATMEGA88 se creará una variable cuyo valor aumentará en una unidad cada medio segundo, el tiempo estará controlado por la interrupción por desborde del timer1 del ATMEGA88, cada 2 segundos se transmitirá un caracter desde el ATMEGA88 que puede ser ‘1’, ‘2’, ‘3’ o ‘4’ al ATMEGA328P, de acuerdo al caracter recibido por el ATMEGA328P se encenderá un led en el puerto C de este, ambos AVR trabajarán a 8Mhz y a una velocidad de comunicación de 9600 baudios. Para el ATMEGA328P no será necesario modificar en el archivo de cabecera usart.h dentro de la función iniciar_usart() ya que la ubicación de los pines TXD y RXD son los mismos que para el ATMEGA88. El circuito utilizado para el USART AVR ejemplos 2 es el siguiente:
En el código para el ATMEGA88 se creará la variable que aumentará en una unidad cada medio segundo, cuando aumente en cuatro unidades se transmitirá un caracter al ATMEGA328P, el código es el siguiente
///////////////////////////////////////////// ///////*********************************/////// ///*** microcontroladores-mrelberni.com ***//// ///////*****************************////////// //* USART AVR ejemplos 2 código para el ATMEGA88* // ///////********************************/////// #define F_CPU 8000000UL //frecuencia de trabajo del AVR #include #include //para el uso de interrupciones #include "usart.h" //archivo de cabecera para utilizar el módulo USART AVR uint8_t i=0;//variable auxiliar entera de 8 bits int main(void) { cli(); //deshabilita las interrupciones TCCR1B=0b00000100; //timer1 como termporizador y un prescaler d e 256 TIMSK1=0b00000001; //se utilizará la interrupción del timer1 por desborde sei(); //habilita las interrupciones globales TCNT1=49910; //se inicia a este valor para obtener 500ms iniciar_usart(); //inicia el módulo USART AVR
Prof. MSc. Jacob Astocondor Villar
18
MICROCONTROLADORES ATEMEL
UNAC-FIEE
while(1)//ciclo del programa { if(i>=0&&i<4){ //si la variable auxiliar esta entre 0 y 4 envia_caracter_usart('1'); //transmite el caracter '1' al ATMEGA328P } if(i>=4&&i<8){ //si la variable auxiliar esta entre 4 y 8 envia_caracter_usart('2'); //transmite el caracter '2' al ATMEGA328P } if(i>=8&&i<12){ //si la variable auxiliar esta entre 8 y 12 envia_caracter_usart('3'); //transmite el caracter '3' al ATMEGA328P } if(i>=12&&i<16){ //si la variable auxiliar esta entre 12 y 16 envia_caracter_usart('4'); //transmite el caracter '4' al ATMEGA328P } if(i==16)//si la variable se hace 16 i=0; //se reinicia a 0 para volver a comenzar } } ISR(TIMER1_OVF_vect){//rutina de atención a la interrupción timer1 por desborde TCNT1=49910;//se carga en cada interrupción para obtener los 500ms //tras cada interrupción i++; //en cada interrupción se incrementa en una unidad }
En el código para el ATMEGA328P se encenderá un led en el puerto C dependiendo del caracter recibido del ATMEGA88, el código para el ATMEGA328P es el siguiente: /////*********************************/////// ///*** microcontroladores-mrelberni.com ***//// ///////*****************************////////// //* USART AVR ejemplos 2 código para el ATMEGA328P* // ///////********************************/////// #define F_CPU 8000000UL //frecuencia de trabajo del ATMEGA328P #include #include "usart.h" //archivo de cabecera para utilizar el módulo USART AVR int main(void) { unsigned char dato;//variable tipo char para guardar el caracter recibido DDRC|=((1<<0)|(1<<1)|(1<<2)|(1<<3));//PC0, PC1, PC2, PC3 como salidas digitales PORTC&=~((1<<0)|(1<<1)|(1<<2)|(1<<3));//leds inician apagad os iniciar_usart();//inicia el módulo USART AVR para el ATMEGA328P while(1) { dato=recibe_caracter_usart();//para leer el caracter recibido del ATMEGA328 switch(dato){ case '1': //En caso el caracter recibido sea 1 PORTC|=(1<<0); //enciende el led en el pin PC0 PORTC&=~((1<<1)|(1<<2)|(1<<3)); //leds en PC1, PC2 y PC3 apagados break; case '2': //En caso el caracter recibido sea 2 PORTC|=(1<<1); //enciende el led en el pin PC1 PORTC&=~((1<<0)|(1<<2)|(1<<3)); //leds en PC0, PC2 y PC3 apagados break; case '3': //En caso el caracter recibido sea 3 PORTC|=(1<<2); //enciende el led en el pin PC2
Prof. MSc. Jacob Astocondor Villar
19
MICROCONTROLADORES ATEMEL
UNAC-FIEE
PORTC&=~((1<<0)|(1<<1)|(1<<3)); //leds en PC0, PC1 y PC3 apagados break; case '4': //En caso el caracter recibido sea 4 PORTC|=(1<<3); //enciende el led en el pin PC3 PORTC&=~((1<<0)|(1<<1)|(1<<2)); //leds en PC0, PC1 y PC2 apagados break; } } }
USART AVR ejemplos 3 Prof. MSc. Jacob Astocondor Villar
20
MICROCONTROLADORES ATEMEL
En este tercer ejemplo se
UNAC-FIEE
realizará la comunicación serial entre el microcontrolador
ATMEGA88 y el ordenador utilizando el archivo de cabecera usart.h, en este caso solo se enviará un mensaje para ser visto en el ordenador. Se necesitará una ventana conocida como terminal donde se podrá ver lo que se transmite del microcontrolador al ordenador, y también para ver los datos que se transmiten del ordenador al microcontrolador. Si se esta programando en Windows XP se utilizará el hyper terminal, si se esta programando en el Windows 7 u 8 no se tendrá el hyper terminal, y habrá que buscarse algún programa que cumpla la función del hyper terminal, en nuestro caso se está programando en Windows 8 y este no tiene el hyper terminal, por lo que se utilizará el TERA TERM el que se puede descargar desde aquí, en la siguiente imagen se puede ver el tera term.
Se utilizará el conversor serial-usb para la comunicación entre el ATMEGA88 y el ordenador; en el tera term se irá a setup luego a serial port para configurar el puerto serial donde se ubica el conversor serial-usb, normalmente lo detecta solo, también se puede establecer la comunicación serial utilizando el visual basic, el java, el matlab y muchos mas, pero para empezar se usará el tera term. El circuito a utilizar será el siguiente, hay que ser muy cuidadoso en cuanto a las conexiones a realizar entre el ordenador, el conversor serial-usb, la compuerta inversora, las resistencias y el microcontrolador.
En el código realizado en el ATMEGA88 para este ejemplo se enviará un mensaje al ordenador mediante la función enviar_cadena_usart() que se encuentra dentro del archivo de cabecera usart.h, el código es el siguiente: //////*********************************///////
Prof. MSc. Jacob Astocondor Villar
21
MICROCONTROLADORES ATEMEL
UNAC-FIEE
///*** microcontroladores ***//// ///////*****************************////////// //* USART AVR ejemplos 3 código para el ATMEGA88* // ///////********************************/////// #define F_CPU 8000000UL //frecuencia de trabajo del AVR #include #include #include "usart.h" //archivo de cabecera para utilizar el módulo USART AVR int main(void) { iniciar_usart(); //inicia el módulo USART AVR while(1)//ciclo del programa { envia_cadena_usart("USART AVR comuncacion serial");//mensaje a enviar al ordenador //que será visto en el tera term envia_caracter_usart(13);//para el salto de linea _delay_ms(200); //el mensaje será enviado cada 200ms } }
La siguiente es la imagen del mensaje visto en pantalla en el tera term
USART AVR ejemplos 4 En este cuarto ejemplo se
realizará la comunicación serial entre el microcontrolador
ATMEGA88 y el ordenador utilizando el archivo de cabecera usart.h, se encenderá y apagará un led conectado en el microcontrolador, al presionar la tecla + del ordenador se encenderá el Prof. MSc. Jacob Astocondor Villar
22
MICROCONTROLADORES ATEMEL
UNAC-FIEE
led, al presionar la tecla – del ordenador se apagará el led, se utilizará el TERA TERM para realizar la comunicación. El circuito a utilizar será el siguiente, hay que ser muy cuidadoso en cuanto a las conexiones a realizar entre el ordenador, el conversor serial-usb, la compuerta inversora, las resistencias y el microcontrolador
.
En
el
código
realizado
en
el
ATMEL
STUDIO se
utilizará
la
función recibe_caracter_usart() que está dentro de la función de cabecera usart.h para recibir el caracter transmitido por el ordenador, cuando el caracter sea ‘+’ se encenderá el led conectado al pin PB0, cuando el caracter sea ‘-‘ se apagará el led. El código es el siguiente: ///*** microcontroladores***//// ///////*****************************////////// //* USART AVR ejemplos 4 código para el ATMEGA88* // ///////********************************/////// #define F_CPU 8000000UL //frecuencia de trabajo del AVR #include #include #include "usart.h" //archivo de cabecera para utilizar el módulo USART AVR int main(void) { DDRB|=(1<<0); //Pin PB0 como salida digital para conectar el led PORTB&=~(1<<0); //El led inicia apagado iniciar_usart(); //inicia el módulo USART AVR unsigned char dato;//para guardar el caracter recibido del ordenador while(1)//ciclo del programa { dato=recibe_caracter_usart(); //guarda en daato el caracter recibido del //ordenador if(dato=='+'){ //si el caracter recibido es '+' PORTB|=(1<<0); //se enciende el led envia_cadena_usart("led encendido"); //mensaje a enviar al ordenador //que será visto en el tera term envia_caracter_usart(13);//para retorno de carro envia_caracter_usart(10);//para nueva linea } else if(dato=='-'){ //sino si el caracter recibido es '-' PORTB&=~(1<<0); //se apaga el led envia_cadena_usart("led apagado"); //mensaje a enviar al ordenador //que será visto en el tera term envia_caracter_usart(13);//para retorno carro envia_caracter_usart(10);//para nueva linea } Prof. MSc. Jacob Astocondor Villar
23
MICROCONTROLADORES ATEMEL
UNAC-FIEE
} }
La siguiente es la imagen del caracter enviado por el ordenador y del mensaje visto en pantalla en el tera term, para poder ver el caracter enviado, en el tera term hay que ir a setup -> terminal y habilitar Local echo.
Prof. MSc. Jacob Astocondor Villar
24
