Pic Comunicación Serial PDF

http://microcontroladores-mrelberni.
com/usart-pic-comunicacion-serial/
USART PIC Comunicación serial
USART PIC, viene de receptor transmisor síncrono asíncrono universal, es una forma de
comunicación entre dispositivos que tengan esta capacidad, donde los datos son enviados
en grupos de 8 bits 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 este tipo de comunicación
utilizando el módulo USART del microcontrolador PIC, con el módulo USART PIC el
microcontrolador puede comunicarse e intercambiar datos con el ordenador, con otros
microcontroladores, etc.
Para la comunicación entre microcontroladores y para la comunicación entre el
microcontrolador y el ordenador, se necesitan 2 hilos de conducción para la 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 mismos, para la comunicación serial entre el microcontrolador y el
ordenador se seguirá la norma RS232.
Si la comunicación USART PIC es 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 es que la frecuencia de trabajo de ambos dispositivos 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.
Si la comunicación USART PIC es síncrona, uno de los hilos será utilizado tanto para
la transmisión y la recepción de datos por lo que la transmisión no puede ocurrir en forma
simultanea, el otro hilo será utilizado para enviar la señal de reloj de sincronización entre
ambos dispositivos, en este caso uno de los dispositivos es llamado maestro y el otro
esclavo, el maestro es el que controla la señal de reloj y cuando se inicia o finaliza la
comunicación.
http://microcontroladores-mrelberni.com/usart-pic-comunicacion-serial/ página 1
http://microcontroladores-mrelberni.com/usart-pic-comunicacion-serial/
El microcontrolador PIC utilizado como modelo será el PIC16F877A, los pines de este
microcontrolador que trabajan con el módulo USART PIC son el pin RX o pin receptor y
el pin TX o pin transmisor, los que en la imagen están resaltados resaltados.
El pin RX es el pin para la recepción de datos y tendrá que ser configurado como una
entrada digital.
El pin TX es el pin para la transmisión de datos y tendrá que ser configurado como una
salida digital.
El pin RX del PIC tiene que ser conectado al pin TX del otro dispositivo.
El pin TX del PIC tiene que ser conectado al pin RX del otro dispositivo
Los comunes de ambos dispositivos también tienen que estar conectados entres si.
Los niveles de tensión con los que trabajan los pines del módulo USART PIC son de 0V y
5V un bajo 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 conversor de nivel como el MAX232, ya que los niveles de
tensión para la comunicación serial del ordenador son mayores que para el PIC
típicamente entre -12V y 12V, además de trabajar con lógica negativa, esto es para el
ordenador un bajo será 12V mientras un alto será -12V.
Hay otra manera de conectar el PIC con el ordenador para la comunicación serial mediante
resistencias y la compuerta inversora tipo Schmitt 74HC14 como se ve en la siguiente
imagen.
El socket donde se conectará el PIC con el ordenador para la comunicación 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 USB, por lo que para realizar la comunicación serial con el módulo
USART PIC 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 PIC,
este conector consta de de 9 pines, los hay hembra y macho, de este conector 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.
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 PIC ya sea a través del MAX232 o
con el uso de la compuerta inversora como se comento lineas arriba, por lo que los pines a conectar
del DB9 macho con el módulo USART PIC 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 TX del microcontrolador.
•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 RX del microcontrolador.
•El pin 5 que es pin GND o tierra o común del conector DB9 macho que viene del
ordenador, se conectará al pin Vss del microcontrolador.
Las conexiones del módulo USART PIC 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 PIC PROGRAMACIÓN

Para programar el módulo USART PIC en el PIC16F877A, se utilizan los siguientes
registros: el registro TXSTA, el registro RCSTA, el registro SPBRG, el registro TXREG, el
registro RXREG, y si se utilizan interrupciones USART PIC los registros PIE1 y PIR1.
El registro TXSTA es el registro de control de la transmisión de datos.
El bit7 CSRC es útil cuando se utiliza la comunicación serial síncrona, mediante este bit
se elige la fuente de reloj esto es quien de los dispositivos será el maestro, en la
comunicación serial asíncrona este bit no tiene efecto.
El bit6 TX9 Es para elegir si la transmisión de datos será a 9 bits o a 8 bits, si este bit se
pone a 1 la transmisión será a 9 bits y se este bit se pone a 0 la transmisión será a 8 bits.
El bit5 TXEN Este es el bit que habilita la transmisión de datos, al ponerlo a 1 se habilita
la transmisión de datos y si se lo pone a 0 la transmisión de datos estará deshabilitada.
El bit4 SYNC Con este bit se elige el tipo de comunicación serial a utilizar con el módulo
USART PIC, al ponerlo a 1 la comunicación serial será síncrona y al ponerlo a 0 la
comunicación será asíncrona.
El bit3 no se utiliza.
El bit2 BRGH Este bit es para seleccionar la velocidad de los baudios, que es la cantidad
de bits que se enviarán por segundo en el modo asíncrono, si se pone a 1 será de alta
velocidad, si se pone a 0 será de baja velocidad.
El bit1 TRMT Este bit indica el estado del registro TSR utilizado para la transmisión de
datos, trabaja automáticamente, si está a 1 indica que el registro esta vació, si está a 0
indica que el registro está lleno.
El bit 0 TX9D Este bit será el noveno bit se se utilizan 9 bits en la transmisión de datos.
El Registro RCSTA Es el registro de control de la recepción de datos.
El bit7 SPEN Este bit es que permite la habilitación del uso del módulo USART PIC, si se
pone a 1 se habilita el uso del módulo USART PIC, si se pone a 0 no es posible utilizar el
módulo USART PIC.
El bit6 RX9 Es para elegir si la recepción de datos será a 9 bits o a 8 bits, si este bit se
pone a 1 la recepción será a 9 bits y se este bit se pone a 0 la recepción será a 8 bits.
El bit5 SREN Este es el bit se utiliza en el modo síncrono para habilitar la recepción
síncrona, en el modo asíncrono no es utilizado.
El bit4 CREN Con este bit se habilita la recepción continua de datos al ponerlo a 1, si se
pone a 0 la recepción continua de datos está deshabilitada.
El bit3 ADDEN Es utilizado en el modo asíncrono si la recepción de datos es de 9 bits. Si

la recepción de datos es a 8 bits no es utilizado
El bit2 FERR Este bit trabaja automáticamente si se pone a 1 es que se ha recibido un

dato no válido.
El bit1 OERR Este bit trabaja automáticamente y se pondrá a 1 si se ha producido un

error por sobreescritura del dato recibido.
El bit 0 RX9D Este bit será el noveno bit se se utilizan 9 bits en la recepción de datos.
El registro SPBRG Es el registro 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 PIC, trabaja
junto con el bit BRGH del registro TXSTA.
El valor a cargar en el registro SPBFG se calcula con las siguientes fórmulas que
dependerán de la velocidad elegida con el bit BRGH, de la frecuencia del oscilador utilizado
y de si la comunicación será síncrona o asíncrona.
Los ejemplos que se harán serán para la transmisión asíncrona a alta velocidad por lo que la fórmula
que se utilizará será:
Velocidad en baudios=Fosc/(16*(SPBRG+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á:
SPBRG=(Fosc/(16*9600))-1
de donde:
SPBRG=(Fosc/153600)-1
Por ejemplo si el oscilador es de 4MHz se tendrá
SPBRG=(4000000/153600)-1=25
Por lo que para obtener un una velocidad de 9600 baudios se tendrá que cargar el registro
SPBRG con 25.
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.
El registro TXREG Es el registro donde se debe escribir el dato que se quiera enviar el la
comunicación serial con el módulo USART PIC.
El registro RCREG Es el registro donde se debe leer al recibir algún dato en la
comunicación serial con el módulo USART PIC.
El registro PIE1 Al poner el bit4 de este registro a 1 se habilita el uso de interrupciones

por la finalización de la transmisión del dato y al poner el bit5 de este registro a 1 se
habilita el uso de las interrupciones por la finalización de la recepción del dato.
El registro PIR1 El bit bit4 de este registro se pondrá a 1 cuando se ha terminado la

transmisión del dato, luego se pondrá automáticamente a 0, si esta habilitada la
interrupción por finalización de la transmisión del dato este bit será el que indica que ha
ocurrido la interrupción. El bit5 de este registro se pondrá a 1 cuando se ha terminado la
recepción del dato, luego se pondrá automáticamente a 0, si esta habilitada la
interrupción por finalización de la recepción del dato este bit será el que indica que ha
ocurrido la interrupción.
USART PIC PROGRAMACIÓN en el XC8

Para la programación del módulo USART PIC se utilizará el XC8, ya que este permite
trabajar directamente con los registros y esto es de gran ayuda para conocer mucho mas
sobre el manejo de los microcontroladores PIC, en este caso se comentará como se puede
proceder para utilizar el módulo USART PIC del PIC16F877A, lo aquí comentado es muy
similar para otros microcontroladores PIC
Para iniciar el módulo USART PIC.
Los pines del PIC116F877A para el manejo del módulo USART PIC son el pin RC7 para la
recepción de datos por lo que en este caso se le llama pin RX, y el pin RC6 para la
transmisión de datos, en este caso se le llama pin TX, el pin RX se tiene que configurar
como una entrada digital y el pin TX se tiene que configurar como una salida digital, esto
en el XC8 se puede hacer así:
TRISCbits.TRISC7=1;//pin RX como una entrada digital
TRISCbits.TRISC6=0;//pin RX como una salida digital
Configuración del registro TXSTA para el control de la transmisión de datos, en este

caso se hará para que la transmisión sea a 8 bits en forma asíncrona de alta velocidad por
lo que:
El bit7 en modo asíncrono no se usa por lo que se pondrá a 0.
El bit6 se pondrá a 0 para que la transmisión sea a 8 bits.
El bit5 se pondrá a 1 para que esté habilitada la transmisión de datos.
El bit4 se pondrá a 0 porque la transmisión será asíncrona.
El bit3 no se utiliza por lo que se lo pondrá a 0.
El bit2 se pondrá a 1 para que el módulo USART PIC trabaje a alta velocidad.
El bit1 es un bit de estado trabaja automáticamente e indica cuando el registro donde se
coloca el dato a transmitir está lleno o vacío, se lo puede poner a 1 o a 0 para iniciar, en
este caso se lo pondrá a 1 porque se está iniciando y tendría que estar vacío.
El bit0 no se utiliza porque es el bit de paridad cuando se utiliza la transmisión de 9 bits

pero como se utilizará la transmisión a 8 bits no influye y se lo pondrá a 0.
Luego en la inicialización del módulo USART PIC el registro TXSTA en el XC8 quedará así:
TXSTA=0b00100110;// 8bits, transmisión habilitada, asíncrono, alta velocidad
Configuración del registro RCSTA para el control de la recepción de datos, en este caso
se hará para que la recepción sea a 8 bits en forma asíncrona de alta velocidad por lo que:
El bit7 se pondrá a 1 para habilitar el uso del módulo USART PIC.
El bit6 se pondrá a 0 para que la recepción sea a 8 bits.
El bit5 se pone a 0 porque no se usa en la comunicación asíncrona.
El bit4 se pone a 1 para habilitar la recepción de datos.
El bit3 se pone a 0 porque la recepción será a 8 bit.
El bit2 este bit trabaja automáticamente cuando se pone a 1 indica que se ha recibido un
dato no válido.
El bit1 este bit trabaja automáticamente cuando se pone a 1 indica que se ha producido
un error por sobreescritura de algún dato recibido.
El bit0 no se utiliza porque es el bit de paridad cuando se utiliza la recepción de 9 bits

pero como se utilizará la recepción a 8 bits no influye y se lo pondrá a 0.
Luego en la inicialización del módulo USART PIC el registro RCSTA en el XC8 quedará así:
RCSTA=0b10010000;//habilitado el USART PIC, recepción 8 bits, habilitada, asíncrono
Carga del registro SPBRG para los baudios o la cantidad de bits por segundo para la
comunicación serial, como será a alta velocidad por lo que el bit BRGH del registro TXSTA
se puso a 1 y en forma asíncrona, se utilizará la fórmula.
Velocidad en baudios=baudios=Fosc/(16*(SPBRG+1))
Al despejar se tendrá SPBRG=(Fosc/(16*baudios))-1
En los ejemplos que se harán se utilizará una Fosc de 4Mhz y la velocidad será de 9600
baudios, por lo que al reemplazar se tendrá que el valor a cargar en el registro SPBRG
será de 25, luego en el XC8 será:
SPBRG=25;//para una velocidad de 9600baudios con un oscilador de 4Mhz
Entonces se puede iniciar el módulo USART PIC en el XC8 de la siguiente manera:
//inicialización del módulo USART PIC en el XC8 modo asíncrono, a 8bits,

//a 9600 baudios
TRISCbits.TRISC6=0;//pin TX como una salida digital
RCSTA=0b10010000;//habilitado el USART PIC, recepción 8 bits,
//habilitada, asíncrono
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() lo que en el XC8 será así:
//inicialización del módulo USART PIC modo asíncrono

//en una función, a 8bits,a 9600 baudios
/////////////////////////////////////////////////////
void iniciar_usart(){
TRISCbits.TRISC6=0;//pin RX como una salida digital
}
Para la recepción de datos con el módulo USART PIC.

Los datos que se reciben son de tipo caracter, cuando se va recibir un dato a través del pin
RX se tendrá que esperar a que el bit5 del registro PIR1 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 RCREG, 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 XC8
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 PIC modo asíncrono

////////////////////////////////////////////////////////////
unsigned char recibe_caracter_usart(){
if(PIR1bits.RCIF==1){//si el bit5 del registro PIR1 se ha puesto a 1
return RCREG;//devuelve el dato almacenado en el registro RCREG
}
else//sino
return;//retorna sin hacer nada
}
Para la transmisión de datos con el módulo USART PIC.
Los datos que se transmiten son de tipo caracter, cuando se va transmitir un dato a través
del pin TX se tendrá que esperar a que el registro TSR donde se ponen los datos que se
van a enviar esté vacío, esto se hace esperando a que el bit1 TRMT del registro TXSTA se
ponga a 1, este bit indica que se ha completado la transmisión de un dato anterior
mientras el dato que está en espera se coloca en el registro TXREG, cuando se vacíe el
registro TSR se podrá enviar el otro dato que está esperando en el registro TXREG
pasándolo en forma automática al registro TSR, el dato transmitido es de tipo caracter
char, cuando se pasa el dato del registro TXREG al registro TSR este bit se pondrá
automáticamente a 0, la transmisión de los datos en el XC8 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 PIC modo asíncrono

///////////////////////////////////////////////
void envia_caracter_usart(unsigned char caracter){
while(TXSTAbits.TRMT==0);// mientras el registro TSR esté lleno espera
TXREG = caracter;//cuando el el registro TSR está vacio se envia el caracter
}
Para la transmisión de cadenas de caracteres con el módulo USART PIC 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().
Para la transmisión de cadenas de caracteres con el módulo USART PIC 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 PIC 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
//de 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
}
}
ARCHIVO DE CABECERA PARA EL USO DEL MÓDULO USART PIC

EN EL XC8
Se puede agrupar todas la funciones vistas anteriormente para el uso del módulo USART
PIC en el XC8 en forma asíncrona, 8 bits y a 9600 baudios 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
PIC16F877A, si se utiliza otro pic u otra velocidad de comunicación es fácil hacer los
cambios que se necesiten dentro del archivo usart.h, se verá algún ejemplo.
////////////////////////////////////////////////////////////////////
//Archivo de cabecera para el uso del módulo USART PIC con el XC8///
///////////////////////////////////////////////////////////////////
#ifndef USART_H
#define USART_H
void iniciar_usart();//función para iniciar el USART PIC asíncron, 8 bits, 9600 baudios
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 PIC modo asíncrono
//en una función, a 8bits,a 9600 baudios
/////////////////////////////////////////////////////
void iniciar_usart(){

TRISCbits.TRISC6=0;//pin TX como una salida digital
}
///////////////////////////////////////////////
//recepción de datos del módulo USART PIC modo asíncrono
////////////////////////////////////////////////////////////
unsigned char recibe_caracter_usart(){
if(PIR1bits.RCIF==1){//si el bit5 del registro PIR1 se ha puesto a 1
return RCREG;//devuelve el dato almacenado en el registro RCREG
}
else//sino
return;//retorna sin hacer nada
}
///////////////////////////////////////////////
//transmisión de datos del módulo USART PIC modo asíncrono
///////////////////////////////////////////////
void envia_caracter_usart(unsigned char caracter){
while(TXSTAbits.TRMT==0);// mientras el registro TSR esté lleno espera
TXREG = caracter;//cuando el el registro TSR está vacio se envia el caracter
}
///////////////////////////////////////////////
//transmisión de cadenas de caracteres con el módulo USART PIC 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
//de 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 PIC PROGRAMACIÓN Ejemplos en

el XC8
Para ver los ejemplos del manejo del módulo USART PIC visitar este enlace.
USART PIC EJEMPLOS
USART PIC ejemplos 1 En este primer ejemplo se realizará la comunicación serial entre
2 microcontroladores PIC16F877A, mediante dos pulsadores conectados en los pines RA0
y RA1 de uno de los PIC se podrá encender o apagar un led conectado en el pin RB1 del
otro PIC.
Para utilizar los pines RA0 y RA1 como entradas digitales, aparte configurarlos con el
registro TRISA, es necesario poner el registro ADCON1 del módulo ADC a 6, esto es
ADCON1=6.
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.
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 PIC ejemplos.
En la siguiente imagen se ha creado un proyecto llamado usart1, con el archivo fuente

llamado usart_pic_ejemplos1.c, el la parte resaltada Header Files se hace click
derecho y en New se selecciona C Header File…,en la ventana que aparece dentro
de File Name se le da el nombre de usart en Extension debe estar selecciona da la
opción h, y se pulsa sobre Finish 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
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 PIC
El circuito utilizado para el USART PIC ejemplos 1 es el siguiente:
Con el pulsador del pin RA0 del PIC 1 se encenderá el led del pin RB1 del PIC 2, con el
pulsador del pin RA1 del PIC 1 se apagará el led del pin RB1 del PIC 2.
En el código para el PIC 1 se tiene que hacer que al presionar el pulsador para encender el
led se transmitirá el caracter ‘e’ al PIC 2, al presionar el pulsador para apagar el led se
transmitirá el caracter ‘a’ al PIC 2, el siguiente será el código para el PIC 1.
///////////////////////////////////////////////
///////*********************************///////
///*** microcontroladores-mrelberni.com ***////
///////*****************************//////////
//* USART PIC ejemplos 1 código para el PIC 1* //
///////********************************///////
//bits de configuración del PIC16F877A

#pragma config FOSC = XT // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT enabled)
#pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled)
#pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit S
#pragma config CPD = OFF // Data EEPROM Memory Code Protection bit
#pragma config WRT = OFF // Flash Program Memory Write Enable bits
#pragma config CP = OFF // Flash Program Memory Code Protection bit
#define _XTAL_FREQ 4000000

#include <xc.h>
#include "usart.h"//incluye el archivo de cabecera el que se ha creado
//en Header Files, para el uso del módulo USART PIC
void main(void)
{
ADCON1=6;//para que RA0 y RA1 sean entradas digitales
TRISAbits.TRISA0=1;//como entrada para el pulsador de encender el led

TRISAbits.TRISA1=1;//como entrada para el pulsador de apagar el led
iniciar_usart();//inicia el módulo USART PIC
while(1){
if(PORTAbits.RA0==0){//si se preciona el pulsador para encender el led
envia_caracter_usart('e');//se transmitirá el caracter 'e' hacia PIC 2
}
if(PORTAbits.RA1==0){//si se preciona el pulsador para apagar el led
envia_caracter_usart('a');//se transmitirá el caracter 'a' hacia PIC 2
}
}
return;
}
En el código para el PIC 2 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 PIC 2
///////*********************************///////
///////*****************************//////////
//* USART PIC ejemplos 1 código para el PIC 2* //
///////********************************///////
//bits de configuración del PIC16F877A
#pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit S
#define _XTAL_FREQ 4000000

#include <xc.h>
#include "usart.h"//incluye el archivo de cabecera el que se ha creado
//en Header Files, para el uso del módulo USART PIC
void main(void)
{
unsigned char dato;//para guardar el dato de tipo caracter recibido
TRISBbits.TRISB1=0;//como salida para conectar el led

PORTBbits.RB1=0;//el led inicia apagado
while(1){
dato=recibe_caracter_usart();//para leer el caracter recibido de PIC 1
if(dato=='e'){//si el dato recibido es el caracter 'e'

PORTBbits.RB1=1;//enciende el led
}
if(dato=='a'){//si el dato recibido es el caracter 'a'
PORTBbits.RB1=0;//apaga el led
}
}
return;
}
USART PIC ejemplos 2 En este segundo ejemplo se realizará la comunicación serial

entre 2 microcontroladores PIC, uno de ellos será el PIC16F88 y el otro será el
PIC16F877A, en el PIC16F88 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 PIC16F88, cada 2 segundos se transmitirá un caracter que puede ser ‘1’, ‘2’, ‘3’
o ‘4’ al PIC16F877A, de acuerdo al caracter recibido por el PIC16F877A se encenderá un
led en el puerto D de este.
Para el PIC16F88 será necesario modificar en el archivo de cabecera usart.h dentro de la

función iniciar_usart() la ubicación de los pines TX y RX del PIC16F88, modificando el
registro tris correspondiente, el pin RX está en el pin RB2 y el pin TX está en el pin RB5.
El circuito utilizado para el USART PIC ejemplos 2 es el siguiente:
En el código para el PIC16F88 se creará la variable que aumentará en una unidad cada
medio segundo, cuando aumente en cuatro unidades se transmitirá un caracter al
PIC16F877A, el código es el siguiente:
//////////////////////////////////////////////////
/////*********************************///////
///////*****************************//////////
//* USART PIC ejemplos 2 código para el PIC16F88 * //
///////********************************///////
//bits de configuración para el PIC16F88

#pragma config FOSC = INTOSCIO // Oscillator Selection bits (INTRC oscillator)
#pragma config MCLRE = ON // RA5/MCLR/VPP Pin Function Select bit

#pragma config LVP = OFF // Low-Voltage Programming Enable bit
#pragma config CPD = OFF // Data EE Memory Code Protection bit (Code protection off)
#pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off)
#pragma config CCPMX = RB0 // CCP1 Pin Selection bit (CCP1 function on RB0)
#pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off)
// CONFIG2
#pragma config FCMEN = ON // Fail-Safe Clock Monitor Enable bit
#pragma config IESO = ON
#define _XTAL_FREQ 4000000 //fracuenciadel oscilador del PIC16F88

#include <xc.h>
#include <stdint.h> //para utilizar uint8_t
#include "usart.h" //incluye el archivo de cabecera el que se ha creado
//en Header Files, para el uso del módulo USART PIC, se
//se tiene que modificar los pines para RX y TX en el PIC16F88
uint8_t i=0;//variable auxiliar entera de 8 bits
void main(void) {
OSCCON=0b01101110;//selecciona oscilador interno del PIC16F88 a 4MHz
INTCON=0b11000000;//habilita uso de interrupciones

PIE1bits.TMR1IE=1;//habilita el uso de la interrupción por desborde del timer1
PIR1bits.TMR1IF=0;//bandera indicadora de interrupción del timer1 a 0
T1CON=0b00110001;//timer1 como temporizador prescaler de 8

TMR1=3035;//se inicia a este valor para obtener 500ms
iniciar_usart();//inicia el módulo USART PIC para el PIC16F88
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 PIC16F877A
}
if(i>=4&&i<8){
envia_caracter_usart('2');
}
if(i>=8&&i<12){
}
if(i>=12&&i<16){
}
if(i==16)
i=0;
}
return;
}
void interrupt int_timer1(){//Rutina de atención a las interrupciones

if(PIR1bits.TMR1IF){//si ha ocurrido la interrupción por desborde del timer1
TMR1=3035;//se carga con este valor para temporizar 500ms
i++;//en cada interrupción se incrementa en una unidad
PIR1bits.TMR1IF=0;//bandera nuevamente a 0 para seguir detectando la

//interrupción timer1 por desborde
}
}
En el código para el PIC16F877A se encenderá un led en el puerto D dependiendo del

caracter recibido del PIC16F88, el código para el PIC161F877A es el siguiente:
//////////////////////////////////////////////////
/////*********************************///////
///////*****************************//////////
//* USART PIC ejemplos 2 código para el PIC16F877A * //
///////********************************///////
//bits de configuración para el PIC16F877A

#pragma config LVP = OFF // Low-Voltage (Single-Supply)
#pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#define _XTAL_FREQ 4000000 //fracuencia del oscilador del PIC16F877A

#include <xc.h>
#include "usart.h" //incluye el archivo de cabecera, el que se ha creado
//en Header Files, para el uso del módulo USART PIC16F877A
void main(void)
{
unsigned char dato;//variable tipo char para guardar el caracter recibido
TRISD&=~((1<<4)|(1<<5)|(1<<6)|(1<<7));//RD4, RD5, RD6 y RD7 como salidas digitales
PORTD&=~((1<<4)|(1<<5)|(1<<6)|(1<<7));//leds inician apagador
iniciar_usart();//inicia el módulo USART PIC para el PIC16F877A
while(1){//ciclo de programa
dato=recibe_caracter_usart();//para leer el caracter recibido del PIC16F877A
switch(dato){
case '1'://En caso el caracter recibido sea 1
PORTD|=(1<<4);//enciende el led en el pin RD4
PORTD&=~((1<<5)|(1<<6)|(1<<7));//leds en RD5, RD6 y RD7 apagados
break;
break;
break;
break;
}
}
return;
}
USART PIC ejemplos 3 En este tercer ejemplo se realizará la comunicación serial

entre el microcontrolador PIC16F877A 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 PIC16F877A 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.
a imagen siguiente es el circuito montado en el protoboar con el conversor serial-usb
En el código realizado en el XC8 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:
//////////////////////////////////////////////////
/////*********************************///////
///////*****************************//////////
///////********************************///////

#pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off
#define _XTAL_FREQ 4000000 //frecuencia del oscilador del PIC16F877A

#include <xc.h>
void main(void)
{
while(1){
envia_cadena_usart("microcontroladores-mrelberni.com");//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
}
return;
}
La siguiente es la imagen del mensaje visto en pantalla en el tera term
USART PIC ejemplos 4 En este cuarto ejemplo se realizará la comunicación serial

entre el microcontrolador PIC16F877A 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 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 XC8 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 RD1, cuando el
caracter sea ‘-‘ se apagará el led. El código es el siguiente:
//////////////////////////////////////////////////
/////*********************************///////
///////*****************************//////////
///////********************************///////

#define _XTAL_FREQ 4000000 //fracuencia del oscilador del PIC16F877A

#include <xc.h>
void main(void)
{
unsigned char dato;//para guardar el caracter recibido del ordenador
TRISDbits.TRISD1=0;//RD1 como salida donde se conectará el led a controlar

PORTDbits.RD1=0;//El led inicia apagado
while(1){
dato=recibe_caracter_usart();//guarda en daato el caracter recibido del
//ordenador
if(dato=='+'){//si el caracter recibido es '+'
PORTDbits.RD1=1;//se enciende el led
envia_cadena_usart("led encendido");//mensaje a enviar al ordenador
envia_caracter_usart(13);//para retorno de carro
envia_caracter_usart(10);//para nueva linea
}
else if(dato=='-'){//sino si el caracter recibido es '-'
PORTDbits.RD1=0;//se apaga el led

envia_cadena_usart("led apagao");//mensaje a enviar al ordenador
envia_caracter_usart(13);//para retorno carro
envia_caracter_usart(10);//para nueva linea
}
return;
}
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.
El módulo USART PIC también puede ser utilizado mediante interrupciones, la forma de
proceder en este caso se puede ver aquí.

Pic Comunicación Serial PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Pic Comunicación Serial PDF

Cargado por

Copyright:

Formatos disponibles

http://microcontroladores-mrelberni.

USART PIC Comunicación serial

USART PIC PROGRAMACIÓN

El registro TXSTA es el registro de control de la transmisión de datos.

El Registro RCSTA Es el registro de control de la recepción de datos.

El bit3 ADDEN Es utilizado en el modo asíncrono si la recepción de datos es de 9 bits. Si

El bit2 FERR Este bit trabaja automáticamente si se pone a 1 es que se ha recibido un

El bit1 OERR Este bit trabaja automáticamente y se pondrá a 1 si se ha producido un

Es importante recordar que la velocidad en baudios de los dispositivos que se estén

Por ejemplo si el oscilador es de 4MHz se tendrá

El registro PIE1 Al poner el bit4 de este registro a 1 se habilita el uso de interrupciones

El registro PIR1 El bit bit4 de este registro se pondrá a 1 cuando se ha terminado la

USART PIC PROGRAMACIÓN en el XC8

Para iniciar el módulo USART PIC.

TRISCbits.TRISC7=1;//pin RX como una entrada digital

TRISCbits.TRISC6=0;//pin RX como una salida digital

Configuración del registro TXSTA para el control de la transmisión de datos, en este

El bit7 en modo asíncrono no se usa por lo que se pondrá a 0.

El bit6 se pondrá a 0 para que la transmisión sea a 8 bits.

El bit5 se pondrá a 1 para que esté habilitada la transmisión de datos.

El bit4 se pondrá a 0 porque la transmisión será asíncrona.

El bit3 no se utiliza por lo que se lo pondrá a 0.

El bit0 no se utiliza porque es el bit de paridad cuando se utiliza la transmisión de 9 bits

TXSTA=0b00100110;// 8bits, transmisión habilitada, asíncrono, alta velocidad

El bit7 se pondrá a 1 para habilitar el uso del módulo USART PIC.

El bit6 se pondrá a 0 para que la recepción sea a 8 bits.

El bit5 se pone a 0 porque no se usa en la comunicación asíncrona.

El bit4 se pone a 1 para habilitar la recepción de datos.

El bit3 se pone a 0 porque la recepción será a 8 bit.

El bit0 no se utiliza porque es el bit de paridad cuando se utiliza la recepción de 9 bits

RCSTA=0b10010000;//habilitado el USART PIC, recepción 8 bits, habilitada, asíncrono

Al despejar se tendrá SPBRG=(Fosc/(16*baudios))-1

SPBRG=25;//para una velocidad de 9600baudios con un oscilador de 4Mhz

Entonces se puede iniciar el módulo USART PIC en el XC8 de la siguiente manera:

//inicialización del módulo USART PIC en el XC8 modo asíncrono, a 8bits,

//inicialización del módulo USART PIC modo asíncrono

Para la recepción de datos con el módulo USART PIC.

//recepción de datos del módulo USART PIC modo asíncrono

Para la transmisión de datos con el módulo USART PIC.

//transmisión de datos del módulo USART PIC modo asíncrono

Para la transmisión de cadenas de caracteres con el módulo USART PIC se puede

Para la transmisión de cadenas de caracteres con el módulo USART PIC se puede

//transmisión de cadenas de caracteres con el módulo USART PIC modo asíncrono

ARCHIVO DE CABECERA PARA EL USO DEL MÓDULO USART PIC

TRISCbits.TRISC7=1;//pin RX como una entrada digital

USART PIC PROGRAMACIÓN Ejemplos en

USART PIC EJEMPLOS

En este ejemplo lo que se busca es que se vea como utilizar el archivo de

En la siguiente imagen se ha creado un proyecto llamado usart1, con el archivo fuente

El circuito utilizado para el USART PIC ejemplos 1 es el siguiente:

//bits de configuración del PIC16F877A

#define _XTAL_FREQ 4000000

TRISAbits.TRISA0=1;//como entrada para el pulsador de encender el led

iniciar_usart();//inicia el módulo USART PIC

#define _XTAL_FREQ 4000000

TRISBbits.TRISB1=0;//como salida para conectar el led

iniciar_usart();//inicia el módulo USART PIC

if(dato=='e'){//si el dato recibido es el caracter 'e'

USART PIC ejemplos 2 En este segundo ejemplo se realizará la comunicación serial

Para el PIC16F88 será necesario modificar en el archivo de cabecera usart.h dentro de la

El circuito utilizado para el USART PIC ejemplos 2 es el siguiente:

//bits de configuración para el PIC16F88

#pragma config MCLRE = ON // RA5/MCLR/VPP Pin Function Select bit