Escolar Documentos
Profissional Documentos
Cultura Documentos
FACULTAD DE INGENIERÍA
PRESENTA:
DIRECTOR DE TESIS:
Albert Einstein
Agradecimientos
I. INTRODUCCIÓN ............................................................................................. 1
IV. RESULTADOS........................................................................................... 23
REFERENCIAS ................................................................................................... 28
ANEXOS .............................................................................................................. 30
ÍNDICE DE FIGURAS
Figura 3. Diagrama de flujo de programa por parte del dispositivo periférico ......... 7
Figura A4. Caja de diálogo para agregar Nueva biblioteca a NetBeans IDE……..32
Figura A15. Localización del archivo usb_desc_cdc.h dentro del entorno de PCW
Compiler…………………………………………………………………………………..50
Las interfaces de usuario se han ido mejorando gradualmente y cada vez es más
fácil manejarlas, tal es el caso de las pantallas táctiles donde la interfaz de entrada
es la misma que la de salida.
Existen sin embargo sistemas en los cuales este tipo de interfaces no cubren con
las necesidades de las personas, especialmente personas con capacidades
diferentes, las cuales podrían verse beneficiadas con interfaces basadas en voz.
El usuario puede interactuar con estos dispositivos vía voz parecido a la forma en
que lo haría con otro ser humano llevando la interacción hombre-máquina a otro
nivel.
Esta plataforma podría servir como punto de partida para poder iniciar la
exploración de temas de investigación como: procesamiento de voz, diseño e
implementación de sistemas embebidos, estudio de protocolos de comunicación
entre el host y sistemas ad-hoc, entre otros.
1
II. ANÁLISIS DE FUNDAMENTOS
Uno de los primeros trabajos con relación con el reconocimiento del habla se
atribuye a los sacerdotes griegos los cuales utilizaban sintetizadores mecánicos
dentro de la boca de una estatua para producir señales auditivas. [1]
2
el teléfono el cual fue un invento que revolucionó por completo la forma de
comunicarse a distancia haciendo uso de aparatos electro-mecánicos. [2]
Para 1939 Homer Dudley presentó en la feria mundial de Nueva York el primer
sintetizador de voz el cual es conocido como VODER o Voice Operating
Demonstration. [4]
3
Otro elemento importante en la evolución de los dispositivos de reconocimiento de
voz es su costo y funcionalidades ofrecidas. Las aplicaciones comerciales bajaron
durante esta década y los vocabularios de palabras se volvieron cada vez más
grandes, incluso se llegó a alcanzar uno de 20,000 palabras en 1986. [8]
4
III. IMPLEMENTACIÓN
Reconocedor/
Micro
Sintetizador de PC
controlador
voz
5
Se utiliza un cristal de 12 MHz que es el que genera la base de tiempos o reloj. Un
capacitor de 470nF es conectado a tierra y al pin del microcontrolador que habilita
el uso del puerto USB. Además se cuenta con un botón de reinicio para el
microcontrolador el cual va conectado al pin destinado para realizar dicha tarea.
6
Inicio
Se leen datos
desde del puerto
USB
7
biblioteca que contiene las funciones necesarias para utilizar la pantalla LCD. Las
siguientes líneas de código muestran la forma de agregar estos archivos al
proyecto.
#include <usb_cdc.h>
#include <18F4455.h>
#include <lcd.c>
8
que es la velocidad que viene configurada por defecto. La línea de código es la
siguiente:
La pantalla LCD debe ser inicializada para poder mostrar caracteres en ella. Esto
se realiza dentro de la función principal del programa:
lcd_init();
while(TRUE) {
//Verifica si se reciben datos desde el puerto USB
if(usb_cdc_getc()=='Dato')
{
//Coloca el cursor de la pantalla LCD en la coordenada 1,1
lcd_gotoxy(1,1);
//Muestra la cadena deseada
printf(lcd_putc,"Hola Mundo");
//Se envía señal en alto hacia el pin correspondiente
output_high(PIN_B7);
//Se envía señal en bajo hacia el pin correspondiente
output_low(PIN_B6);
}
}
9
Una vez compilado el código se generan los archivos de cabecera y bibliotecas
declaradas anteriormente. El archivo usb_desc_cdc.h contiene las líneas de
código referentes a los identificadores del vendedor y del producto del dispositivo.
La sección de código donde se encuentran esas líneas es en la sección de
configuración del dispositivo USB. Se seleccionan los identificadores de producto y
de vendedor, los cuales pueden ser elegidos a elección del programador. Los
identificadores están compuestos por 4 dígitos hexadecimales, los cuales se
declaran por parejas de derecha a izquierda tal como se muestra en el siguiente
código:
Una vez elegidos los identificadores se compila de nuevo el código para que se
genere un archivo con extensión .HEX el cual contiene el código del programa con
las configuraciones previamente establecidas en formato hexadecimal. Este
archivo es el que se graba en el microcontrolador utilizando la herramienta de
grabación de preferencia. En los anexos se ofrece una guía sobre cómo realizar
este proceso de grabación.
10
En la sección de anexos se ofrece una guía sobre cómo generar el driver
utilizando la herramienta propuesta anteriormente.
#JSGF V1.0;
grammar javax.speech.demo;
public <sentence> =comando 1 | comando 2 | comando N;
Existen varias compañías que desarrollan librerías con funciones de síntesis y/o
reconocimiento de voz. En este proyecto se utilizan las librerías proveídas por la
11
compañía Cloud Garden las cuales llevan por nombre TalkingJava SDK versión
1.7.0. [17]
Una vez agregadas las librerías al proyecto se debe crear una clase de Java, la
cual contendrá el código del programa.
Primero se hará el análisis del código del reconocedor de voz. Para poder hacer
uso de los recursos de reconocimiento de voz es necesario importar ciertas
librerías, las cuales se muestran a continuación.
//Contiene los elementos necesarios para hacer uso de los recursos de audio de la
computadora
import javax.speech.*;
import javax.speech.recognition.*;
import java.io.FileReader;
import java.util.Locale
12
parámetros necesarios para su uso. Algunas líneas de código son explícitas pero
se explican las más importantes para su mejor comprensión:
rec = Central.createRecognizer(
new EngineModeDesc(Locale.ENGLISH));
rec.allocate();
gram.setEnabled(true);
rec.addResultListener(new CLASE());
rec.commitChanges();
rec.requestFocus();
rec.resume();
13
3.4.2.1 Procesamiento de cadenas de texto
//Declaración de objetos
static Recognizer rec;
//Método que recibe la cadena de texto proveniente del archivo grammar
public void resultAccepted(ResultEvent e){
Result r = (Result)(e.getSource());
//Se obtienen uno por uno los de elementos de la cadena de texto
ResultToken tokens[] = r.getBestTokens();
//Cadena que guardará la palabra o frase concatenada
String Palabra;
//Cadena que será utilizada para la cincatenación de los elementos
individuales generados por la librería de reconocimiento de voz
StringBuffer cad=new StringBuffer();
for (int i = 0; i < tokens.length; i++)
14
{
//Ciclo que concatena un elemento recibido después de otro hasta formas
una palabra o frase
cad.append((tokens[i].getSpokenText()+" "));
}
Palabra = cad.toString();
}
Una vez agregada la librería al proyecto se puede proceder a hacer uso de las
bondades que ofrece. Antes de comenzar a usar las funciones de comunicación
serial es necesario importar al proyecto las librerías dentro del área de código. En
el siguiente bloque se puede observar las líneas de código necesarias para
realizar dicho fin:
import java.util.List;
15
//Funciones generales de comunicación serial
import giovynet.nativelink.SerialPort;
import giovynet.serial.Baud;
import giovynet.serial.Com;
//Configuración de parámetros
import giovynet.serial.Parameters;
16
//Se crea el objeto que guardará los parámetros de configuración
Parameters parameters = new Parameters();
//Se selecciona puerto a utilizar
parameters.setPort(portsFree.get(0));
//Se determina la velocidad de transmisión de datos
parameters.setBaudRate(Baud._9600);
//Se crea un objeto el cual contiene la configuración previamente
establecida y el cual será al que se hará referencia cuando se quiera utilizar
el puerto serie
objCOM = new Com(parameters);
}
Una vez configurado el puerto serie se puede proceder al envío de datos a través
del mismo. Este bloque de código debe de estar dentro del método resultAccepted
para que los datos sean enviados cada vez que sea aceptado un comando. La
instrucción para realizar dicha tarea se encuentra dentro del siguiente bloque de
código:
//Declaración de objetos
static Com pcom;
17
El reconocedor de voz estará en estado de escucha hasta que se liberen los
recursos a los que accede. Para que el estado de escucha sea continuo se genera
un ciclo; no se podrá salir del ciclo a menos de que el usuario diga la palabra
asignada para la liberación de los recursos de reconocimiento de voz.
while(Palabra.equals("exit "))
{
rec.deallocate();
}
import javax.speech.*;
import java.util.Locale;
18
Una vez importadas las librerías correspondientes se puede llamar al sintetizador,
el cual puede ser invocado en cualquier clase del código principal. La
configuración del sintetizador de voz es la siguiente:
19
Inicio
Recepción de comandos de
voz a través del micrófono de la
PC Se devuelve una cadena de
texto con el comando
No seleccionado al programa
principal
20
PC
Interacción por voz
Usuario
Envío de instrucciones
Activar actuadores
Actuador µC
21
El prototipo real se puede observar en las siguientes imágenes:
22
IV. RESULTADOS
Una vez implementado el prototipo se hicieron pruebas para medir el alcance del
mismo, en las cuales cinco personas fueron invitadas para interactuar con el
sistema. Las pruebas consistieron en dictar comandos de una a cinco palabras.
Aunque no se tienen pruebas exhaustivas puesto que la población de los sujetos
de pruebas es reducida, los experimentos desarrollados con el sistema ayudaron a
probar las limitaciones y las bondades del prototipo.
23
Figura 8. Ondas generadas durante una secuencia de comandos de voz
24
Si se compara el desempeño del sistema durante el experimento anterior contra
uno de los experimentos no controlados se observó que el sistema puede
responder de forma incierta cuando los comandos son dictados con mayor
velocidad.
Dentro de los resultados obtenidos por los distintos experimentos destaca el hecho
de que el prototipo sea capaz de reconocer distintos tipos de comandos y activar
diferentes eventos a nivel hardware. Aunque ya existen aplicaciones comerciales
capaces de reconocer comandos de voz el objetivo fue recrear una experiencia
propia en la implementación de un sistema de este tipo. El prototipo en cuestión se
puede adecuar dependiendo de la aplicación final deseada, además cuenta con la
capacidad de manejar una gran cantidad de comandos en caso de ser necesario.
25
V. CONCLUSIONES Y RECOMENDACIONES
Las pruebas desarrolladas con el prototipo son un aliciente, ya que fue posible
mostrar cómo se pueden ofrecer escenarios de interacción entre el humano y la
computación con interfaces diferentes al tradicional teclado y ratón. Aunque
básico, nuestro prototipo podría ser utilizado como plataforma para seguir
explorando distintas áreas de la ingeniería computacional tales como
reconocimiento de voz, automatización de tareas del medio, sistemas embebidos,
entre otros.
A pesar de que el desempeño del prototipo fue “aceptable” existen, sin embargo,
factores que pueden influir en el comportamiento del sistema. La orientación dela
persona respecto al micrófono es un factor importante para el reconocimiento de
los comandos. Pero existen otros factores como ruido ambiental y rapidez del
habla que al parecer también afectan el desempeño del sistema, y que no fueron
probados de forma exhaustiva.
26
Otra área de oportunidad podría ser los dispositivos móviles apoyándose en el
paquete de librerías Java Mobile Edition para poder utilizar el reconocimiento de
voz en dispositivos móviles.
27
REFERENCIAS
[1] MILAN, S., Voice Recognition by Computer, Marburg, Tectum, Verlag, 2003,
ISBN 3-8288-8492-X, p. 8.
[2] LEMETTY, S., Review of Speech Synthesis Technology [tesis de maestría],
Espoo (FIN), Helsinki University of Techonology, 1999. También disponible en:
http://www.acoustics.hut.fi/publications/files/theses/lemmetty_mst/thesis.pdf
[3] ROJAS BELLO, R. N., Diseño y desarrollo de prototipo de sistema de
traducción instantánea de habla y transmisión en tiempo real, sobre el protocolo
RTP utilizando tecnologías de reconocimiento de voz [tesis de licenciatura],
Valdivia (CHL), Universidad Austral de Chile, 2005. También disponible en:
http://cybertesis.uach.cl/tesis/uach/2005/bmfcir741d/doc/bmfcir741d.pdf
[4] 120 Years of Electronic Music, The Voder & Vocoder, Fuente consultada en
Septiembre de 2010. Disponible en http://120years.net/machines/vocoder/
[5] JUANG, B.H., RABINER, L. R., Automatic Speech Recognition – A Brief History
of the Technology Development, Elsevier Encyclopedia of Language and
Linguistics, Second Edition, 2005. Disponible en:
http://www.ece.ucsb.edu/Faculty/Rabiner/ece259/
[6] JURAFSKY, D., MARTIN, J. H., Speech and Language Processing: An
Introduction to Natural Language Processing, Computacional Linguistics and
Speech Recognition, 2ª ed., Prentice Hall, 2008, ISBN 978-0-13-187321-6, p.331
[7] LEVINSON, D., Encyclopedia of crime and punishment: Vol 4, 1ª ed., United
States of America, Berkshire Publishing Group, 2002, p. 1692
[8] AHUACTZIN L., A., Diccionario español/inglés para el aprendizaje de
vocabulario utilizando una interfaz de voz [tesis de licenciatura], Puebla (MX),
Escuela de Ingeniería de la Universidad de las Américas, 1999.
[9] 54-9: El sitio argentino sobre celulares, 25 años de telefonía celular: la historia
según Motorola, Octubre 2008, Fuente consultada en septiembre de 2010.
http://54-9.com.ar/celulares/25-anos-de-telefonia-celular-la-historia-segun-motorola
[10] ROSENCRANCE, L., IBM, Honda deliver in-car-speech-recognition navigation
system: IBM's embedded ViaVoice technology recognizes spoken street and city
names, Octubre 2004, Fuente consultada en septiembre de 2010.
28
http://www.computerworld.com/s/article/95684/IBM_Honda_deliver_in_car_speech
_recognition_navigation_system
[11] FALCONI CEPEDA, L. F., JIMENEZ YEDRA, C. R., Estudio e implementación
de domótica activado por comandos de voz y comunicación en ZigBee [tesis de
licenciatura], Riobamba (ECU), Facultad de Informática y Electrónica de la Escuela
Superior Politécnica de Chimborazo, 2009. También disponible en:
http://dspace.espoch.edu.ec/bitstream/123456789/165/1/38T00156.pdf
[12] NUANCE, Software de reconocimiento de voz Dragon Naturally Speaking,
España, Fuente consultada en marzo de 2011. http://www.nuance.es/
[13] TOLEDO, M. T., Kirschning, I., Icatiani: un Sistema de Apoyo para la
Adquisición del Lenguaje [Memorias del 3er Simposium Internacional en
Tecnologías Inteligentes], Tlaxcala (MX), 2002. También disponible en:
http://ict.udlap.mx/people/ingrid/ingrid/Icatiani1.pdf
[14] CCS, Compilador de lenguaje C para microcontroladores Microchip, Fuente
consultada en marzo de 2011. http://www.ccsinfo.com/
[15] Generador de archivos .inf para los drivers USB de Microchip, Fuente
consultada en marzo de 2011.
http://www.unpocodelectronica.netau.net/generador-de-inf-para-los-drivers-usb-de-
microchip
[16] NetBeans IDE, Entorno de desarrollo con soporte para lenguaje Java. Fuente
consultada en marzo de 2011. http://netbeans.org/
[17] CLOUD GARDEN, Talking Java SDK, Paquete de librerías de síntesis y
reconocimiento de voz compatible con el lenguaje Java. Fuente consultada en
marzo de 2011. http://www.cloudgarden.com/
[18] JAVA SPEECH API, Interfaz de programación de aplicaciones con soporte de
síntesis y reconocimiento de voz. Fuente consultada en marzo de 2011.
http://java.sun.com/products/java-media/speech/
[19] GIOVYNET DRIVER, Paquete de librerías de comunicación serial
desarrolladas para lenguaje Java. Fuente consultada en marzo de 2011.
http://java.giovynet.com/Giovynet/
29
ANEXOS
30
Ir a la barra de menú y seleccionar Herramientas -> Bibliotecas
31
Poner nombre a la biblioteca y pulsar en aceptar
Figura A4. Caja de diálogo para agregar Nueva biblioteca a NetBeans IDE.
32
Una vez seleccionada la librería se pulsa en Agregar archivo JAR/Carpeta. Con
esto se guardará la librería y estará disponible para ser utilizada.
33
Luego se debe de seleccionar la opción de Bibliotecas de las categorías
mostradas a la izquierda de la ventana y pulsar el botón de Añadir Biblioteca
34
Una vez añadida la librería del reconocimiento de voz se debe proceder a agregar
la librería de comunicación con el puerto serie de la PC de la misma manera que
se agregó la librería de reconocimiento de voz. La librería que se utiliza en este
proyecto es Giovynet Driver versión 1.0.
Instaladas las librerías es necesario crear un nuevo proyecto en Java para poder
comenzar el desarrollo de la interfaz. Los pasos son los siguientes:
Ir a Archivo->Proyecto Nuevo…
35
Figura A10. Caja de diálogo para la selección del tipo de proyecto.
Figura A11. Caja de diálogo para la selección del nombre y la ubicación del
proyecto.
36
Ahora hay que colocar el siguiente código en la clase creada:
import java.util.List;
import app.Com;
import app.Parameters;
import core.SerialPort;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.speech.*;
import javax.speech.synthesis.*;
import javax.speech.recognition.*;
import java.io.FileReader;
import java.util.Locale;
@Override
public void resultAccepted(ResultEvent e){
String Palabra;
StringBuffer cad=new StringBuffer();
Result r = (Result)(e.getSource());
ResultToken tokens[] = r.getBestTokens();
System.out.println();
try {
for(int i=0;i<6;i++){
pcom.sendSingleData('1');}
System.out.print("start/reset");
37
} catch (Exception ex) {
Logger.getLogger(JSUSB.class.getName()).log(Level.SEVERE, null, ex);
}
try {
for(int i=0;i<6;i++){
pcom.sendSingleData('3');}
System.out.print("more light");
} catch (Exception ex) {
Logger.getLogger(JSUSB.class.getName()).log(Level.SEVERE, null, ex);
}
}
if(Palabra.equals("less light ")){
try {
for(int i=0;i<6;i++){
pcom.sendSingleData('4');}
System.out.print("less light");
} catch (Exception ex) {
Logger.getLogger(JSUSB.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.print("light at half");
38
} catch (Exception ex) {
Logger.getLogger(JSUSB.class.getName()).log(Level.SEVERE, null, ex);
}
}
System.out.print("full light");
} catch (Exception ex) {
Logger.getLogger(JSUSB.class.getName()).log(Level.SEVERE, null, ex);
}
}
while(Palabra.equals("exit "))
{
try{
System.out.print("exit");
rec.deallocate();
}
catch(Exception ex)
{}
try {
synth.allocate();
synth.resume();
synth.waitEngineState(Synthesizer.QUEUE_EMPTY);
synth.deallocate();
} catch (Exception es) {
es.printStackTrace();
}
System.exit(0);
}
}
39
public static void main(String args[])throws Exception {
synth.allocate();
synth.resume();
synth.speakPlainText("Welcome to the world of voice
recognition", null);
synth.speakPlainText("You can turn on, or turn off led's,
by using voice commands", null);
synth.speakPlainText("Please refer to the command's
list, to know how to operate the system", null);
synth.waitEngineState(Synthesizer.QUEUE_EMPTY);
synth.deallocate();
rec = Central.createRecognizer(
new EngineModeDesc(Locale.ENGLISH));
rec.allocate();
rec.commitChanges();
rec.requestFocus();
rec.resume();
}
40
El contenido del archivo grammar debe de ser de la siguiente forma:
#JSGF V1.0;
grammar javax.speech.demo;
public <sentence> = start | turn off light | more light | less light | light at half | full
light | reset | exit;
41
serial por lo que al conectar el PIC a la computadora ésta lo reconocerá como un
dispositivo de comunicación serial. Dicho código será modificado cuanto sea
necesario para que se adapte a las necesidades del proyecto.
#define __USB_PIC_PERIF__ 1
#if !defined(__PCH__)
#error USB CDC Library requires PIC18
#endif
#if __USB_PIC_PERIF__
#include <18F4455.h>
#fuses
HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL3,CPUDIV1,VRE
GEN
#use delay(clock=48000000)
#else
#include <18F452.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#endif
42
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
#include <usb_cdc.h>
#include <lcd.c>
void usb_debug_task(void) {
static int8 last_connected;
static int8 last_enumerated;
int8 new_connected;
int8 new_enumerated;
static int8 last_cdc;
int8 new_cdc;
new_connected=usb_attached();
new_enumerated=usb_enumerated();
new_cdc=usb_cdc_connected();
43
if (new_cdc && !last_cdc) {
printf("Serial program initiated on USB<->UART COM Port\r\n\n");
last_connected=new_connected;
last_enumerated=new_enumerated;
last_cdc=new_cdc;
}
void main(void) {
char c;
lcd_init();
output_high(PIN_D0);
output_high(PIN_D1);
output_low(PIN_D2);
output_low(PIN_B7);
output_low(PIN_B6);
output_low(PIN_B5);
output_low(PIN_B4);
lcd_gotoxy(1,1);
printf(lcd_putc,"Esperando ");
lcd_gotoxy(1,2);
printf(lcd_putc,"Comandos ");
#ifdef __PCH__
printf("PCH: v");
printf(__PCH__);
#else
printf("PCM: v");
printf(__PCM__);
#endif
printf("\r\n");
usb_init_cs();
#if !(__USB_PIC_PERIF__)
printf("USBN: 0x%X", usbn_get_version());
printf("\r\n\n");
#endif
while(TRUE) {
usb_task();
44
usb_debug_task();
if (usb_enumerated())
{
if(usb_cdc_kbhit())
{
if(usb_cdc_getc()=='1')
{
lcd_gotoxy(1,1);
printf(lcd_putc,"Bienvenido ");
lcd_gotoxy(1,2);
printf(lcd_putc," ");
output_high(PIN_B7);
output_low(PIN_B6);
output_low(PIN_B5);
output_low(PIN_B4);
delay_ms(150);
}
if(usb_cdc_getc()=='2')
{
printf(lcd_putc,"\f");
lcd_gotoxy(1,1);
printf(lcd_putc,"Luz ");
lcd_gotoxy(1,2);
printf(lcd_putc,"Apagada ");
output_low(PIN_B7);
output_low(PIN_B6);
output_low(PIN_B5);
output_low(PIN_B4);
delay_ms(150);
}
if(usb_cdc_getc()=='3')
{
if(!input(PIN_B7)){
lcd_gotoxy(1,1);
printf(lcd_putc,"Aumentando ");
lcd_gotoxy(1,2);
printf(lcd_putc,"Luz ");
output_high(PIN_B7);
output_low(PIN_B6);
45
output_low(PIN_B5);
output_low(PIN_B4);
//delay_ms(150);
else if(input(PIN_B7)&&!input(PIN_B6)){
lcd_gotoxy(1,1);
printf(lcd_putc,"Aumentando ");
lcd_gotoxy(1,2);
printf(lcd_putc,"Luz ");
output_high(PIN_B7);
output_high(PIN_B6);
output_low(PIN_B5);
output_low(PIN_B4);
//delay_ms(150);
}
else if(input(PIN_B6)&&!input(PIN_B5)){
lcd_gotoxy(1,1);
printf(lcd_putc,"Aumentando ");
lcd_gotoxy(1,2);
printf(lcd_putc,"Luz ");
output_high(PIN_B7);
output_high(PIN_B6);
output_high(PIN_B5);
output_low(PIN_B4);
//delay_ms(150);
}
else if(input(PIN_B5)&&!input(PIN_B4)){
lcd_gotoxy(1,1);
printf(lcd_putc,"Aumentando ");
lcd_gotoxy(1,2);
printf(lcd_putc,"Luz ");
output_high(PIN_B7);
output_high(PIN_B6);
output_high(PIN_B5);
output_high(PIN_B4);
//delay_ms(150);
}
46
}
if(usb_cdc_getc()=='4')
{
if(input(PIN_B4)&&input(PIN_B5)){
lcd_gotoxy(1,1);
printf(lcd_putc,"Disminuyendo");
lcd_gotoxy(1,2);
printf(lcd_putc,"Luz ");
output_high(PIN_B7);
output_high(PIN_B6);
output_high(PIN_B5);
output_low(PIN_B4);
//delay_ms(150);
}
else if(!input(PIN_B4)&&input(PIN_B5)){
lcd_gotoxy(1,1);
printf(lcd_putc,"Disminuyendo");
lcd_gotoxy(1,2);
printf(lcd_putc,"Luz ");
output_high(PIN_B7);
output_high(PIN_B6);
output_low(PIN_B5);
output_low(PIN_B4);
//delay_ms(150);
}
else if(!input(PIN_B5)&&input(PIN_B6)){
lcd_gotoxy(1,1);
printf(lcd_putc,"Disminuyendo");
lcd_gotoxy(1,2);
printf(lcd_putc,"Luz ");
output_high(PIN_B7);
output_low(PIN_B6);
output_low(PIN_B5);
output_low(PIN_B4);
//delay_ms(150);
}
else if(!input(PIN_B6)&&input(PIN_B7)){
lcd_gotoxy(1,1);
printf(lcd_putc,"Disminuyendo");
47
lcd_gotoxy(1,2);
printf(lcd_putc,"Luz ");
output_low(PIN_B7);
output_low(PIN_B6);
output_low(PIN_B5);
output_low(PIN_B4);
//delay_ms(150);
}
}
if(usb_cdc_getc()=='5')
{
lcd_gotoxy(1,1);
printf(lcd_putc,"Media ");
lcd_gotoxy(1,2);
printf(lcd_putc,"Luz ");
output_high(PIN_B7);
output_high(PIN_B6);
output_low(PIN_B5);
output_low(PIN_B4);
delay_ms(150);
}
if(usb_cdc_getc()=='6')
{
lcd_gotoxy(1,1);
printf(lcd_putc,"Luz ");
lcd_gotoxy(1,2);
printf(lcd_putc,"Completa ");
output_high(PIN_B7);
output_high(PIN_B6);
output_high(PIN_B5);
output_high(PIN_B4);
delay_ms(150);
}
}
}
}
48
Una vez colocado el código se pulsa en la pestaña de Compilar y se compila el
código para que genere los archivos necesarios para la creación del archivo HEX
que es el necesario para grabar el programa en el microcontrolador.
49
Una vez compilado el proyecto se generan archivos de cabecera y demás. Uno
muy importante que se genera es el archivo usb_desc_cdc.h que es el archivo que
contiene el VID&PID (identificadores del vendedor y fabricante) del dispositivo.
Para abrir este archivo se busca en el lado izquierdo del IDE donde hay una
pestaña llamada Files, ahí se selecciona tal archivo y se pulsa dos veces el botón
izquierdo del ratón.
Las líneas de código que poseen el VID y el PID son las siguientes:
50
0x61,0x04, //vendor id (0x04D8 is Microchip, or is it 0x0461 ??) ==8,9
0x61,0x04, //product id ==10,11
0x00,0x01, //device release number ==12,13
0x01, //index of string description of manufacturer. therefore we point
to string_1 array (see below) ==14
0x02, //index of string descriptor of the product ==15
0x00, //index of string descriptor of serial number ==16
USB_NUM_CONFIGURATIONS //number of possible configurations
==17
};
51
Para comenzar hay que conectar el grabador por medio del puerto USB de la PC y
colocar el PIC en el grabador. Ahora se selecciona la familia del dispositivo tal
como se muestra en la imagen:
Una vez realizado esto se procede a cargar el archivo HEX correspondiente, para
esto se debe acceder al menú de herramientas y seguir la siguiente ruta: File-
>Import HEX o en su defecto presionar Ctrl+I.
52
Una vez que se selecciona el archivo se procederá a grabarlo en el PIC. Pero
primero se debe borrar la información previa que tenga grabada el PIC, esto se
realiza mediante el botón de Erase. Luego se puede verificar si la memoria del PIC
ya está vacía mediante el botón de Blank Check.
Una vez que ya se tienen las conexiones de hardware correctas y que se tiene
grabado el programa correcto en el microcontrolador se procede a la generación
del driver para el host. Como la PC generalmente ya posee drivers para
dispositivos de comunicación (Puerto COM) el PIC será reconocido al instante en
cuanto se conecte, no obstante es necesario instalar el driver con las
especificaciones del VID y el PID para que cada vez que sea conectado la
computadora lo reconozca satisfactoriamente. Para esto se utiliza una herramienta
llamada V3.1 – INF Enumeración Datos uC PIC-USB en la cual se le especifica el
VID y PID del dispositivo. Es muy importante comprobar que el VID y el PID del
archivo a generar sean exactamente iguales al VID y PID grabados en el PIC.
Una vez ingresados los datos correctos se pulsa en Guardar para que se genere
el archivo correspondiente. El cual se guardará en la computadora para ser
utilizado cuando se solicite el driver correspondiente para el PIC.
53
Figura A20. Interfaz de la herramienta generadora de archivos .INF para los
drivers de microcontroladores de Microchip.
;------------------------------------------------------------------------------
; Vendor and Product ID Definitions
;------------------------------------------------------------------------------
[SourceDisksFiles]
[SourceDisksNames]
[DeviceList]
%DESCRIPTION%=DriverInstall, USB\VID_0461&PID_0461
[DeviceList.NTamd64]
%DESCRIPTION%=DriverInstall, USB\VID_0461&PID_0461
54
Con esto ya se tiene configurado todo para la prueba del prototipo, ahora solo hay
que conectar los componentes tal y como se muestra en el diagrama de
conexiones al principio de esta sección. Es importante tener en cuenta la
configuración del cable USB con el cual se conectará el microcontrolador a la
computadora:
Los cables verde y blanco sirven para el envío de datos, el verde envía y el
blanco recibe.
55