COMUNICACIÓN DE PUERTO SERIAL A TRAVÉS DE

API’S DE JAVA, PROTEUS, PIC C Y

MICROCONTROLADOR (PIC16F877A)
Movimiento de servo motores (simulación Proteus) a través de una instrucción
desde java.

La práctica consiste en poder realizar una comunicación entre una aplicación de Java y la simulación de
un circuito en Proteus, a través del puerto serial, mandando una instrucción desde la aplicación echa en
NetBeans (Java) y hacer mover un servo motor en la simulación del circuito en Isis Proteus.
Para ello se hizo uso de API’s de java (Librería rxtxcomm.jar), el diseño del circuito en la aplicación
de Isis Proteus (específicamente el uso de microcontroladores, COMPIM “Puerto Virtual”), PIC C
(Comunicación RS232, haciendo uso del archivo .hex de la clase generada) y NetBeans IDE 6.7.1.

Diseño de Circuito en Proteus.

El circuito que vamos a diseñar está compuesto por:
PIC16F877a
MOTOR-PWMSERVO
LM016L
COMPIM

PIC16F877A Es micro que usaremos para nuestro diseño, la configuración que vamos a usar es un
Clock de 20 MHz, como control de LCD a los puerto B, los motores se conectar al puerto A y la
interfaz seria a los puerto TX y RX.
MOTOR-PWMSERVO Los motores Servos se van a conectar a una fuente de 5 v y GND
respectivamente y la salida de control a un puerto RA respectivamente iniciando desde RA1 a RA3.

LM016L El uso de una LCD es muy importante ya que en ella, vamos a mostrar los grados de
movimiento de cada motor así como mensajes de control del circuito. La configuración que se va
ocupar es la de 4 bits.

COMPIM este componente es el la simulación de nuestro puerto DB9 el este caso solo usaremos dos
pines de este puerto RXD y TXD, este componente requiere de configurar su velocidad de
comunicación esto se hace en la opción de editar propiedades.
Ya que tenemos todos los componentes y como funciona cada uno, es hora de armar muestro circuito.
En la siguiente tabla se muestran los puerto que se asignaran a cada componente como ya había
mencionado las distribución de los puerto quedan de la siguiente manera.
Componentes Puertos
LCD E RB0
RS RB1
RW RB2
D4 RB4
D5 RB5
D6 RB6
D7 RB7
MOTOR SERVO A RA1
SERVO B RA2
SERVO C RA3
COMPIM TX RC6/TX
RX RC7/RX

Diseño del circuito

CREACION DE LA CLASE EN PC C
1.- Seleccionamos el menú ProyectPic Wizard

2.- Se selecciona la ubicación y el nombre donde se guardara el archivo.

3.- En la opción General seleccionamos el Pic a utilizar (PIC16F877A), en Fuses (High speed Osc(>
4mhz), Power Up Timer, Reset when brownout detected).

En la opción de Communications activamos la casilla Use RS232 y pulsamos el botón de OK

Se genera el siguiente código:

Después de a ver configurado todo nuestro proyecto comenzaremos con nuestro código
Lo primero que tenemos que hacer es incluir la librería de LCD los cual se hace da la siguiente manera
#include <lcd.c>
El uso de esta librería facilitara el manejo de la LCD bastara con configurar la librería para que
funcione con el puerto B de nuestro PIC. Esto es bastante sencillo solo debemos entrar al archivo lcd.c
y des comentar las siguiente línea de código.
#define use_portb_lcd TRUE
Esto librería te permite mandar a imprimir en la LCD mansajes con el uso del siguiente comando
printf(lcd_putc,"Motor 0");
Después de a ver configurado correctamente la LCD es hora de trabajar con el puerto
Mandar un valor por el puerto basta con ejecutar la siguiente comando.
printf("\r\n MENU DE COMANDO \r\n");
printf("comando 1 \r\n");
printf("[ENTER] EL COMANDO HA SIDO INTRODUCIDO \r\n");

Para poder leer un carácter del puerto es necesario usar la interrupción #int_rda y el comando getc()
que es que contiene el carácter enviado desde el puerto.

#int_rda
void procesa(void){
comando=getc(); //leer carácter
}
Esto nos permite guardar un carácter, pero en el proyecto se requiere guardar un conjunto de caracteres
el cual va representar un comando. Para esto se requiere de crea algunas funciones extras las cuales se
muestra en las siguiente líneas de código.

//primero hay que declarar las variables a utilizar

int const lenbuff = 4; //tamaño de comando
char cbuff[lenbuff]; //arreglo donde se almacenara el comando
int xbuff=0; // apuntador de arreglo
int1 banderaChivas=0; //bandera de estado

#int_rda //bloque de interrupción

void serie(void){
char rcvchar=0x00; // variable para el almacenamiento temporal del dato
if(kbhit()){ // indica que sea presión una tecla
rcvchar=getc(); // se pasa el dato tecleado a la variable temporal
comando=rcvchar; //
add2Buff(rcvchar); //se pasa el dato tecleado para almacenar o descartar
eco_sel(rcvchar); // método que nos permite producir un eco en pantalla
}
}

Crear funciones para agregar caracteres en el arreglo cbuff, así como hacer cambio de la bandera de
estado que permitirá la ejecución del comando en el momento de inserta un enter.

void add2buff(char c){ //función para agregar carácter al arreglo cbuff

switch(c){
case 0x0D: //en caso de introducir un enter
printf(lcd_putc,"\f"); //limpiar LCD
banderaChivas=1; //activar la bandera para ejecutar el comando
break;
default:
if(xbuff<'3'){ //limitar el comando a cuatro valores
cbuff[xbuff++]=c; //agregar el carácter al arreglo cbuff

}
}
}
Función para crear un eco al insertar un dato esto permite ver en pantalla el dato enviado y en el caso
de presionar el enter visualizar en pantalla un mensaje de [intro].

void eco_sel(char c){

switch(c){
case 0x0d:
printf("\r\n[intro]\r\n");
break;
default:
printf(lcd_putc,"%c",c);
putc(c);
}
}
Una vez que se almaceno el comando se debe ejecutar este, esto va a suceder en el momento en que se
inserte un enter para eso se usa una bandera la cual indica si sea presionado esta tecla. Si esta bandera
esta en alto o sea en 1 el comando se debe ejecutar. Nuestros comandos validos son los siguientes

COMAND
OS
MOTOR MOVER 0 MOVER 90 MOVER 180 OSCILAR
A A001 A002 A003 A004
B B001 B002 B003 B004
C C001 C002 C003 C004

Para la esto se valida el primer carácter almacenado en el arreglo xbuff el cual representa que motor
desean mover, y esto a su vez llama la función para dicha operación.

//función para ejecutar comando

void command_process(){
banderaChivas=0; //se pone es estado bajo la bandera
printf("COMANDO PROCESADO \r\n");
printf("%s \r\n ",cbuff); //imprime el comando a ejecutar
if(cbuff[3]=='1'){ //bloque de selección de motor
f1();
}
if(cbuff[3]=='2'){
f2();
}
if(cbuff[3]=='3'){
f3();
}
if(cbuff[3]=='4'){
f4();
} //fin de bloque de selección de motor
init_buff(); //función para inicializar los valores del variables
command_menu();
}
//función de inicialización de variables
void init_buff (void){
int i;
for(i=0;i<lenbuff;i++){
cbuff[i]=0;
}
xbuff=0;
}

Aquí se queda la clase completa

http://rapidshare.com/files/301730325/clase_c_comando.rar.html
CREACION DEL PROYECTO EN NETBEANS (JAVA)
Para crear un nuevo proyecto seleccionamos la opción Archivo Proyecto Nuevo

Se selecciona el proyecto a crear (en este caso una aplicación en Java) y pulsamos la tecla de siguiente
Se pone el nombre al nuevo proyecto y pulsamos la tecla terminar.

En el proyecto creado, seleccionamos el paquete del proyecto (nombre del

proyecto)NuevoFormulario Jframe
Se realiza este diseño de interface:

Agregamos una clase. En el proyecto creado, seleccionamos el paquete del proyecto (nombre del
proyecto)NuevoClase Java
Se coloca el nombre de la clase (en este caso “Comandos”) y se pulsa el botón Terminar

Para hacer uso de la librería RXTXcomm.jar seleccionamos el paquete de BibliotecasAgregar

Archivo JAR/Carpeta
Y se selecciona la ubicación del archivo .jar y se pulsa el botón Abrir

Si todo lo anterior sale bien ya podemos comenzar a programar, para poder hacer uso de la librería
RXTXcomm solo basta con importa esta librería a nuestro proyecto.

import gnu.io.*;

Algunas funciones que nos permite esta API son obtener puertos disponibles, abrir puerto y establecer
la comunicación, Resolver colisiones, saber si el puerto esta utilizado y por quien,…

El Objeto CommPortIdentifier almacena el puerto que se desea utilizar.

CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier("COM2");

getPortIdentifier(String) Nos dará el objeto correspondiente al puerto que se le pase como parámetro,
este será el método que normalmente usaremos ya que lo normal es que siempre nos conectemos por el
mismo puerto.

A su vez este método deberá saber tratar la excepción NoSuchPortException que saltara en el caso de
que solicitemos un puerto inexistente.
El siguiente código permite identificar el puerto COM2 en caso de no existir se cacha en la excepción
mostrando un mensaje de ERROR
try
{
portId = CommPortIdentifier.getPortIdentifier("COM2");

} catch (NoSuchPortException e)
{
System.err.println("ERROR al identificar puerto");
}
La clase SerialPort que hereda de la clase CommPort, esta clase permite hacer una petición del puerto,
configurar la velocidad de comunicación y así como la trasmisión y recepción de datos.

Pedir el uso del puerto. SerialPort requiere de abrir el puerto esto se hace el método open de la clase
CommPortIdentifier.

open(String, int) abre y por lo tanto reserva un puerto, en el caso de que intentemos abrir un puerto
que ya se encuentre en uso saltara la excepción PortInUseException. Los parámetros que le
debemos pasar son un:
• String con el nombre de la aplicación que reserva el puerto
• int que indica el tiempo de espera para abrir el puerto.

En este segmento de código se puede apreciar el uso del metodo open el cual pide el uso del puerto por
un tiempo determinado en caso de que el puerto no esté disponible se manda un mensaje de
puerto en uso.

try {
serialPort = (SerialPort) portId.open("SimpleWrite", 2000);
} catch (PortInUseException e) {
System.out.println("Puerto en Uso.");
}

El siguiente paso es establecer los valores de comunicación para esto es necesario el uso del método.

setSerialPortParams(int, int, int, int)

Los parámetros del método son:
• La velocidad de trasmisión
• El segundo parámetro son los bits de datos. Para indicar el valor utilizaremos las constantes de
la clase que se tiene para lo mismo (DATABITS_5, DATABITS_6, DATABITS_7 o
DATABITS_8).
• El bit o bits de stop que utilizaremos y que puede ser 1,2 o uno y medio. Las constantes que
definen estas configuraciones son: STOPBITS_1, STOPBITS_2 y STOPBITS_1_5
respectivamente.
• Paridad que utilizaremos y que puede ser PARITY_NONE en el caso de no utilizar paridad,
PARITY_ODD para la paridad impar, PARITY_EVEN paridad par, PARITY_MARK paridad
por marca y PARITY_SPACE paridad por espacio.

Código de implementación:
try {
serialPort.setSerialPortParams(9600,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);
} catch (UnsupportedCommOperationException e) {}

Con la siguiente línea de código establecemos que la escritura de datos por el puerto se establecerá por
medio de la variable outputStream.

try {
outputStream = serialPort.getOutputStream();
} catch (IOException e) {}

Para enviar un dato por el Puerto.

outputStream.write(dato);

Por último es necesario cerrar la conexión del puerto.

serialPort.close();
Con la implantación de estos métodos permiten la comunicación del puerto Paralelo en desde nuestra
aplicación java.

Aquí puedes descargar la aplicación de java creada en Netbeans

http://rapidshare.com/files/301956040/comunicacionPic.rar.html
Todo esta funcionando bien, no tenemos ningún problema en abril los puertos y pues en la simulación
hasta ahora todo va bien.

Nuestro motor a se a movido a 0 grados ahora si queremos que se mueve mas solo introducimos en
comando necesario, sabemos que es lo que esta haciendo con el mensaje que se nos manda en el area de
texto.
El motor a 90 grados como en la imagen anterior y en mensaje también dice que se movio.

Motor a 180 grados, todo esto es manejado desde la aplicación de java.

Finalmente el ultimo punto que es poner al motor a oscilar y el mensaje lo dice, pero para detenerlo
solo tenemos que introducir la letra “x” y el motor que se este manipulando se detendrá.

Así como se muestra en la imagen. Si nos damos cuenta cada uno trabajo con el otro desde el principio, si alguno de ellos
no funciona ten por seguro que la simulación no se llevara acabo de manera correcta.