Documente Academic
Documente Profesional
Documente Cultură
PIC18F2550
Control de dispositivos mediante el
puerto USB: Desarrollo de
proyectos en Visual C#
En este manual veremos como crear una pequeña aplicación en Visual C# y CCS para
poder controlar dispositivos USB usando el microcontrolador PIC18F2550. Este
apartado no pretende ser una explicación completa del funcionamiento del puerto USB,
sino una guía para poder crear aplicaciones de manera rápida.
Con esto ya podemos empezar a crear una aplicación demo o aplicación de prueba, con
la que demostraremos como comunicar nuestra placa con la PC mediante USB.
Todas las aplicaciones que escribiremos son compatibles y fueron testeadas con
Windows 7 y Windows XP, así también como versiones intermedias.
2
Introducción a Visual C#:
Como habíamos dicho anteriormente, diseñaremos una aplicación para la PC en visual
C#. Para esto debemos tener instalada la suite Visual Studio 2008 o en su defecto
Visual C# 2008 Express. Para el desarrollo de este curso usaré Visual Studio 2008, que
es la herramienta que tengo a mano.
Visual C# Express es la versión gratuita del programa la cuál podemos descargarla
directamente de la página de Microsoft.
Para poder crear un nuevo proyecto de Visual C#, nos dirigimos hacia Archivo –
Nuevo Proyecto. Una vez realizado esto, nos aparecerá una ventana con los diferentes
tipos de lenguajes disponibles y los tipos de aplicaciones que se pueden llegar a crear
con ellos. También aparecerá al costado derecho, la plataforma de trabajo elegida, a la
que conocemos por Framework. En mi proyecto usaremos .Net Framework 3.5.
3
En la Fig. nº 2, podemos apreciar los tipos de proyectos que se pueden crear con
Visual C#.
Ahora tenemos listo nuestro proyecto para empezar a trabajar, pero antes lo guardaremos
en caso de alguna eventualidad. Para ello presionaremos sobre el botón Guardar todo;
cuando nos aparezca el cartel para guardar tenemos que elegir la carpeta donde se
guardará y quitar la opción que dice: Crear directorio para esta solución.
4
Fig. nº 4:
Lo primero que vamos hacer es configurar el espacio de diseño para poder trabajar
cómodos. Lo que haremos será dejar fija la barra de herramientas para tenerla siempre a
mano como lo muestra la Fig. nº 5:
Ya tenemos todo listo para empezar a programar, pero antes veremos un poco del
entorno de trabajo de visual C#.
5
Algo que usaremos muy a menudo para crear “La interfaz gráfica” será el llamado
cuadro de herramientas el cuál podemos ver en la Fig. nº 7.
6
El explorador de soluciones que vimos más arriba sirve para administrar archivos,
proyectos y configuraciones de la aplicación.
La primera acción que realizaremos será tomar 4 GroupBox del cuadro de herramientas
y los añadiremos al formulario. No importa el orden, a medida que vallamos avanzando
los iremos configurando.
En este momento tiene que quedar como lo muestra la Fig. nº 9:
7
Ahora, a cada uno de los elementos creados les cambiaremos el nombre. Por ejemplo al
primer Groupbox, llamado groupBox1, le pondremos “SALIDAS DIGITALES”
correspondiente al control que contendrá los botones que activarán o desactivarán las
salidas digitales del entrenador.
Para poder cambiar el nombre del control pulsamos con el botón derecho sobre el mismo
y hacemos clic en propiedades.
Parámetro Valor
Name CONTENEDOR_SALIDAS
Text SALIDAS DIGITALES
Para el grouBox2.
Parámetro Valor
Name CONTENEDOR_IN_DIGITALES
Text ENTRADAS DIGITALES
Para el grouBox3.
Parámetro Valor
Name CONTENEDOR_ANALOGICAS
Text ENTRADAS ANALOGICAS
8
Para el grouBox4.
Parámetro Valor
Name CONTENEDOR_PWM
Text CONTROL PWM
Una vez que se han modificado los parámetros de todos los controles nos tiene que
quedar el formulario como se ve en la Fig. nº 10:
Ahora ya tenemos los contenedores listos, por lo tanto, hay que empezar a añadir los
controles asociados a esos contenedores. Primero agregamos los botones
correspondientes a las salidas digitales, quedándonos una ventana como la que se ve en
la Fig. nº 11:
9
En total tenemos que insertar 4 Buttons de la barra de herramientas y ordenarlos de
modo tal que coincidan con la anterior imagen. Ahora, hay que modificar sus parámetros
al igual que hicimos con los contenedores. Como tenemos 4 salidas digitales
representadas por 4 led’s, nombraremos los botones de la siguiente manera:
- Salida 1
- Salida 2
- Salida 3
- Salida 4
Hacemos clic derecho sobre los botones y en las propiedades de cada uno cambiamos los
siguientes parámetros:
Para el button1.
Para el button3.
10
Para el button4.
Cada uno de estos botones comandará una salida del entrenador USB. Nuestra aplicación,
luego de las modificaciones tendría que quedar como muestra la Fig. nº 12.
Para las entradas digitales, incluiremos 4 PictureBox, los mismos nos indicarán
mediante un cambio en su color si un interruptor ha sido presionado. Una vez añadidos
los controles, el formulario tendría que quedar como muestra la Fig. nº 13:
11
Ya ordenados los diferentes PictureBox, procedemos a modificar sus parámetros.
Para el PictureBox 1.
Parámetros Valor
(Name) IN _ DIGITAL_1
BorderStyle FixedSingle
BackColor DarkSeaGreen
Para el PictureBox 2.
Parámetros Valor
(Name) IN _ DIGITAL_2
BorderStyle FixedSingle
BackColor DarkSeaGreen
Para el PictureBox 3.
Parámetros Valor
(Name) IN _ DIGITAL_3
BorderStyle FixedSingle
BackColor DarkSeaGreen
Para el PictureBox 4.
Parámetros Valor
(Name) IN _ DIGITAL_4
BorderStyle FixedSingle
BackColor DarkSeaGreen
Con todos los parámetros configurados, el formulario tendría que tener el siguiente
aspecto:
Fig. nº 14
12
Para las entradas analógicas, utilizaremos 2 barras de progreso llamadas ProgressBar,
que me indicarán el valor que presenta la salida del CAD (Convertidor analógico –
digital).
Fig. nº 15
Este es el aspecto del formulario con los controles añadidos. Ahora, hay que configurar 2
parámetros básicos para poder utilizarlos.
Para el ProgressBar 1:
Parámetros Valor
(Name) ADC1_VALUE
Maximum 1024
Para el ProgressBar 2:
Parámetros Valor
(Name) ADC2_VALUE
Maximum 1024
El valor 1024, dentro del parámetro “Maximum”, significa el valor máximo que puede
tomar el control y coincide con la resolución máxima de 10 bits del CAD (Convertidor
analógico digital).
Por último, nos queda el control de PWM (Pulse Width Modulation), que consiste en 2
barra de desplazamiento llamadas HSscrollBar. A través de este control, podremos
controlar el ciclo de trabajo de los 2 PWM definidos por software.
13
Esto quiere decir que tendremos la capacidad de variar el tiempo Ton (Tiempo en que la
señal PWM está en alto) y el tiempo Toff (tiempo en que la señal PWM está en bajo).
Por lo tanto controlaremos la potencia aplicada y en consiguiente el brillo de los led’s
PWM, según el valor que tome la barra de desplazamiento.
Los 2 PWM definidos por software tienen una resolución máxima de 8 bits. Esto nos da
255 valores de brillo diferente para los led’s. Por lo que la barra tiene que tomar un valor
que no supere 255; este valor lo configuraremos en los parámetros de dicho control.
Fig. nº 16
Para el hsScrollBar 1.
Parámetros Valor
(Name) PWM_CONTROL_1
Maximum 255
Para el hsScrollBar 2.
Parámetros Valor
(Name) PWM_CONTROL_2
Maximum 255
Además de los controles que ya hemos visto, necesitamos 2 elementos más dentro de la
aplicación: Un botón para conectar el dispositivo (hardware USB), con la aplicación de
control y un cuadro de texto donde se muestren los diferentes eventos que ocurran dentro
y fuera de la aplicación.
14
Fig. Nº 17
Como podemos ver, hemos redimensionado los demás controles para obtener una mejor
estética final de la aplicación. Los parámetros de los nuevos controles son los siguientes:
Para el button.
Parámetros Valor
(Name) CONECTAR _ DISPOSITIVO
Text CONECTAR DISPOSITIVO
Para el ListBox.
Parámetros Valor
(Name) MENSAJES_USB
Backcolor 255, 255, 128 (Amarillo)
Por último para darle un mejor aspecto al formulario, vamos a configurarle los siguientes
parámetros:
Parámetros Valor
(Name) USB_HID
Backcolor 224, 224, 224 (Gris plateado)
FormBorderStyle FixedSingle
Text USB HID Demo
StartPosition CenterScreen
MaximizeBox False
Icon Elegimos un icono predeterminado
15
Finalmente la Interfaz de usuario nos tendría que quedar como muestra la Fig. nº 18:
Aún faltan controles por agregar pero no afectan a la funcionalidad del programa por lo
que podemos empezar a introducir código de programación.
Para poder agregar la clase tenemos que agregar al directorio donde se encuentra nuestro
proyecto 2 archivos:
16
En la Fig. nº 19, vemos como quedan agregados ambos archivos a nuestro proyecto:
Ahora que los archivos están incluidos a la carpeta del proyecto tenemos que agregarlos
a nuestro entorno de trabajo. Para esto hacemos clic en Proyecto – Agregar nuevo
elemento existente.
Fig. nº 20
Una vez que anexamos la clase y la librería al proyecto ya podemos trabajar con ellas.
En este momento hacemos clic derecho sobre el formulario y ponemos ver código; nos
tendría que quedar algo así:
17
Fig. nº 21
Hemos agregado algunos elementos de código que están comentados en verde. Los
mismos son necesarios para poder usar las funciones incluidas en la librería mcHID.dll.
En este momento ya estamos listos para poder comenzar a escribir las funciones de
control, pero antes vamos a echar un vistazo a la clase donde están definidas las
diferentes funciones.
Explicaremos el código paso por paso para un mejor entendimiento del mismo.
18
Acá definimos los mensajes que obtenemos del controlador HID cuando ocurre un
evento.
Más abajo tenemos las llamadas a las diferentes funciones incluidas en la librería
mcHID.dll. Entre ellas podemos destacar las siguientes:
Leemos el reporte de entrada para ver si hay datos provenientes del dispositivo. El
tamaño del reporte dependerá de la constante BUFFER_IN_SIZE. La función retorna 1
si hay datos disponibles para leer y 0 si no los hay.
Escribimos un reporte de salida con los datos almacenados en la variable pData, que es
un puntero a un buffer no administrado. El tamaño del reporte dependerá de la variable
BUFFER_OUT_SIZE. La función retorna 1 si se ha podido enviar el reporte y 0 en el
caso contrario.
Activamos el servicio de notificaciones para recibir mensajes cada vez que se produce
un evento de lectura. El servicio se activa una vez que el dispositivo ya se ha conectado
al controlador.
19
Con esto ya hemos explicado todas las funciones que se usarán en el programa. Ahora
veremos el desarrollo de 2 de ellas: Write y Read, correspondientes a las funciones para
leer y escribir datos.
Esta función lee el reporte de entrada para ver si hay datos disponibles.
En primera instancia asigna memoria con un tamaño igual a BUFFER_IN_SIZE a un
puntero:
A través del método try, crea un buffer llamado pData. Como es una porción de
memoria no administrada, usa Marshal nuevamente y copia los datos usando el puntero
creado con anterioridad en el buffer pData, quedando los datos del reporte guardados en
este último.
Como el espacio de memoria que al que hacía alusión el puntero no se utiliza más y es
memoria no administrada, usamos Marshal para liberarla para otros procesos.
20
Esta función escribe un dato en el reporte de salida.
En primer instancia es igual que la función anterior, salvo que la variable result se le
asigna un valor luego de copiar los datos en el reporte de salida; para poder indicar si los
datos se han escrito correctamente.
Esta función toma los mensajes de Windows, los procesa y según el valor que tomen
podemos realizar diferentes acciones. Por ello crearemos 3 funciones:
21
- Dispositivo _ conectado (En caso que el dispositivo esté conectado al host)
- Dispositivo _ desconectado (En caso de que desconectemos el dispositivo)
- Lee _ dispositivo (Si se recibe el mensaje de que hay datos disponibles)
El parámetro de cada una de las 3 funciones se da según el mensaje que se recibe por
parte del controlador, con lo cuál la función que mostramos más arriba queda de la
siguiente manera.
Con esto, cada vez que se produzca una notificación podremos realizar diferentes
acciones en consecuencia. Las 3 funciones las desarrollaremos más adelante ahora nos
encargaremos de los controles principales.
22
Ahora es momento de añadirle los elementos de la función:
Para poder ver si realmente estamos conectados con el entrenador USB hacemos uso de
la función:
Con esto podemos detectar cualquier dispositivo conectado que coincida con el VID,
PID declarado en la aplicación.
Ahora es momento de ejecutar nuestro programa por primera vez, para esto conectamos
el entrenador al host, pulsamos F5 y hacemos clic en el botón “conectar dispositivo”.
Nos tendría que quedar como muestra la Fig. nº 22:
23
Vemos que al pulsar el botón “conectar dispositivo”, busca el dispositivo y nos muestra
el VID, PID del mismo. Si ahora lo desconectamos y volvemos a presionar sobre el
botón “conectar dispositivo”, veremos la Fig. nº 23:
Para comenzar, hacemos clic en cada uno de los 4 botones asignados al control de
salidas digitales. Con lo cuál nos quedará el siguiente código:
Las 4 funciones corresponden a los eventos que se producen al hacer clic en cada uno de
los botones. Ahora agregaremos algunos trozos de código para enviar un comando de
control y otro de datos hacia el dispositivo USB. Con el fin de manejar los led’s de
salida.
Como podemos ver, dentro de la función que envía el reporte de salida hay un parámetro
que no hemos visto en detalle:
26
Ahora pulsaremos F5, conectaremos el dispositivo y cambiaremos el estado de cada uno
de los 4 indicadores led que se encuentran en el entrenador.
Al hacer clic en cada uno de los botones, la función enviará un mensaje de notificación
indicando el cambio de estado de los led’s. Como lo muestra la Fig. nº 24:
27
Para ver mejor como trabaja la aplicación pueden ver el video: Prueba de
funcionamiento Nº 1, anexado a la carpeta del manual.
Al próximo control al cuál nos enfocaremos serán las entradas digitales. Para esto
tenemos que trabajar sobre la función:
Vamos a agregar código dentro de la función que nos permita indicar de forma gráfica y
textual si un pulsador del entrenador USB ha sido presionado.
28
Como se puede apreciar usamos la función easyHID.red para leer el reporte de entrada.
Según los datos que se reciben se activan los indicadores correspondientes y se entregan
mensajes de confirmación.
Luego de agregar el código que se muestra más arriba conectamos el dispositivo USB y
presionamos F5. Una vez que el dispositivo está conectado presionamos los 4 botones
que tiene el entrenador y veremos como cambian de color los indicadores del programa
mientras se reciben los mensajes de confirmación.
Para ver mejor como trabaja la aplicación pueden ver el video: Prueba de
funcionamiento Nº 2 anexado a la carpeta del manual.
Para poder insertar código en dichos controles, hacemos doble clic en las barras de
desplazamiento con lo cuál nos tendría que quedar las siguientes funciones dentro del
código principal:
Ambos PWM tienen una resolución máxima de 8 bits. Esto se debe a que a mayor
resolución se necesita mayor velocidad de refresco; al utilizar PWM por software la
señal inyectada a los led’s puede ser inestable debido a la cantidad de procesos que se
ejecutan dentro del programa principal del PIC.
29
En una posible actualización se podría usar PWM por hardware lo que nos daría más
resolución sin perder estabilidad en la señal generada.
Para ver mejor como trabaja la aplicación pueden ver el video: Prueba de
funcionamiento Nº 3, anexado a la carpeta del manual.
En este momento solo falta un control para programar: Las entradas analógicas.
Para mostrar el valor que toma el CAD (convertidor analógico – digital), tenemos 2
barras de progreso ADC1_Valor y ADC2_Valor. Las mismas muestran de forma gráfica
el valor de voltaje presente en los pines de las entradas analógicas.
Ambas barras de progreso pueden tomar un valor máximo de 1024, correspondiente al
valor máximo que puede tomar la lectura del CAD. Que tiene una resolución máxima de
10 bits.
Para ver mejor como trabaja la aplicación pueden ver el video: Prueba de
funcionamiento Nº 4 anexado a la carpeta del manual.
En este punto ya hemos visto todos los procesos que se realizan con el dispositivo
conectado. Una vez que el dispositivo se desconecta, hay que cerrar la comunicación con
el controlador.
30
Añadimos las siguientes sentencias de código a la función:
Con este código, cada vez que el dispositivo USB se desconecta del host, se
desconectará del controlador y nos notificará el evento mediante un mensaje.
Lo primero que haremos será definir 2 funciones. Una de ellas habilitará los controles
cuando conectemos el dispositivo y la otra desactivará los controles cuando lo
desconectemos.
31
Ahora añadimos código para ver su funcionamiento:
32
En este momento ya tenemos nuestra aplicación funcional, por lo que procederemos a
añadir los controles faltantes al formulario.
Dentro del menú opciones creamos la función “salir” y dentro del menú ayuda:
El menú de ayuda es un menú informativo para que el usuario se guíe dentro del
programa además de presentar información relativa al autor, información de contacto,
etc.
Con lo anterior la apariencia de la aplicación nos tiene que quedar como muestra la
Fig. nº 26 y 27:
33
Ahora comenzaremos a añadir código para hacer funcionales dichos elementos.
Primero que nada hacemos doble clic en “Salir” e introducimos el siguiente código:
Parámetros Valor
ShortCutKeys Control+ S
Yéndonos al menú ayuda tenemos la primera función “Acerca de HID Demo”. Hacemos
clic en ella y agregamos las siguientes sentencias.
Este código mostrará una ventana informativa sobre el creador del programa, contacto,
licencia, etc.
34
Podemos agregarle teclas de acceso rápido. Para esto modificamos el siguiente
parámetro:
Parámetros Valor
ShortCutKeys F1
Fig. nº 29
Luego hacemos doble clic en “Web del proyecto” y agregamos el siguiente código:
Para agregarle teclas de acceso rápido. Para esto modificamos el siguiente parámetro:
Parámetros Valor
ShortCutKeys Ctrl+W
35
En este código, trata de abrir el manual de usuario de la aplicación. En caso de no poder,
muestra un mensaje alternativo de advertencia como el que está a continuación.
Fig. nº 30
Parámetros Valor
ShortCutKeys Ctrl+A
Dentro del elemento podemos ver un menú desplegable allí elegimos el control llamado
“StatusLabel” y le modificamos el siguiente parámetro:
Parámetros Valor
Text hh:mm:ss
Para poder obtener la hora hacemos doble clic sobre el timer y le agregamos el siguiente
código:
El siguiente código:
Fig. nº 32
37
Como podemos ver le hemos añadido algunos indicadores adicionales a los controles
para mejorar el aspecto visual del mismo, como así también redimensionamos algunos
controles.
Un último control funcional que tendremos que agregar a la aplicación será un ToolTip.
Este control muestra información cuando se pasa el puntero del Mouse sobre el control
asociado.
Finalmente lo que nos queda por hacer es añadirle un icono al programa y modificar la
información de ensamblado para agregar información personal.
Podemos ver varias cosas entre las que destaco las siguientes:
- Nombre de ensamblado y espacio de nombres: Aquí pondremos el nombre de la
aplicación.
- Información de ensamblado: Información que se incrusta al programa compilado
(.exe), respecto del autor, versión, fecha de ensamblado, revisión, etc.
Fig. nº 35
39
- Por ultimo el icono y manifiesto que seleccionaremos del icono agregado a la
aplicación previamente.
En este punto hemos terminado con la aplicación para la PC y nos queda únicamente
explicar el código del microcontrolador para terminar con la guía.
Explicaremos los puntos clave a tener en cuenta con el firmware del microcontrolador.
Como compilador utilizaremos el CCS v4.114, ya que ofrece una gran facilidad en el
uso de las librerías USB.
El entorno de trabajo del CCS permite compilar y también suministra una gran variedad
de herramientas auxiliares. En la Fig. nº 37, se muestran los distintos elementos básicos
del entorno de trabajo. Existen 2 formas de iniciar una sesión: abriendo un fichero de
código fuente o creando un proyecto.
40
Para abrir un fichero fuente directamente se realiza una pulsación sobre el icono para el
manejo de ficheros (Fig. nº 38) y aparece un menú donde podemos crear, abrir, guardar
o cerrar ficheros. Con el comando New podemos crear un fichero fuente, un proyecto, un
fichero RTF o un fichero de diagrama de flujo.
Con la opción New –> Source file, el programa pide el nombre del nuevo fichero y crea
una nueva ventana en blanco donde podemos empezar a escribir, como lo muestra la
Fig. nº 39.
41
Una vez explicado esto, procederemos a crear nuestra aplicación de control.
42
Una vez que ya tenemos el archivo cargado, vamos bajando y vemos la primer sentencia
de código:
A través del uso de esta directiva, le decimos al compilador que trabajaremos con el
CAD (Convertidor analógico a digital) con 10 bits de resolución y justificación a la
derecha (Los bits más significativos del registro ADRESH, son leídos como “0”).
Los “fuses” (o mejor dicho palabra de configuración) son muy importantes ya que
determinan muchos parámetros del microcontrolador. Los que se encuentran ordenados
en la figura anterior tienen las siguientes funciones:
Acá declaramos la frecuencia de trabajo para que el compilador pueda calcular los
retardos en las funciones de delay.
43
Usando la directiva #include agregamos todas las librerías necesarias para gestionar la
comunicación USB.
Por el momento explicaremos 2 de ellas:
- APLICACIÓN_HID.h
- Descriptor_easyHID.h
A través del uso de etiquetas #define le añadimos nombres a las entradas y salidas para
poder facilitar la programación y recordar donde se ubican los diferentes componentes.
Definimos el tamaño que debe tener el edpoint de entrada y de salida, en este caso el
valor “32” nos indica que recibirá 32 bytes desde el host y transmitirá 32 bytes hacia el
host.
Para dejar bien en claro el significado de endpoint, les dejo el siguiente enunciado:
"Los dispositivos (o mejor dicho, las funciones) tienen asociados unos canales
lógicos unidireccionales (llamados pipes) que conectan al host (PC) controlador con
una entidad lógica en el dispositivo (PIC) llamada endpoint. Los datos son enviados
en paquetes de largo variable (potencia de 2). Típicamente estos paquetes son
de 64, 128 o más bytes.
Estos endpoints (y sus respectivos pipes) son numerados del 0 al 15 en cada
dirección, por lo cual un dispositivo puede tener hasta 32 endpoints (16 de
entrada y 16 de salida). La dirección se considera siempre desde el punto de
vista del host controlador. Así un endpoint de salida será un canal que
transmite datos desde el host controlador al dispositivo. Un endpoint solo
puede tener una única dirección. El endpoint 0 (en ambas direcciones) está
reservado para el control del bus."
44
La cita anterior fue extraída del trabajo de grado que se encuentra en el siguiente link:
http://pablohoffman.com/oscusb/doc/
Estas definiciones está íntimamente ligadas con las funciones de control que se
encuentran en la aplicación de Visual C# estudiada anteriormente. Esto lo veremos más
adelante.
Estos macros son usados para el control de las salidas digitales para no tener que usar las
funciones predefinidas más costosas de recordar. Ayudan al desarrollo del programa.
Luego hay 2 funciones más, pero su explicación es redundante ya que están muy bien
documentadas en la librería.
Estas 2 directivas nos permiten utilizar los puertos sin necesidad de configurarlos cada
vez que se usan. Lo que si debemos tener en cuenta es configurar que pines serán
entradas y que pines serán salidas usando las siguientes sentencias:
Una vez configurados los puertos pueden usarse libremente los que nos ahorra RAM y
ROM dentro una vez que compilamos el programa.
45
Esta función ya se encuentra explicada en la librería, pero dentro de ella tiene una
sentencia que no ha sido desarrollada.
Esta función se encuentra dentro de la librería: USB.c, lo que hace es esperar hasta que
el host enumere el dispositivo y prender el LED verde. En caso de que no lo hiciera el
dispositivo no puede comunicarse con la aplicación de control y el LED rojo permanece
encendido.
Con estas 2 sentencias inicializamos los 2 PWM y apagamos los led’s asociados.
Una función muy importante ya que inicializa el stack USB, conecta el dispositivo al
host, habilita las interrupciones, etc. Trabaja en conjunto con USB stack; esta función
asume que el USB está conectado siempre al host, por lo que mantiene al dispositivo
permanentemente conectado.
46
Esta función inicializa el hardware USB, las interrupciones, etc. Trabaja en conjunto con
USB_init (). En caso de usar USB_init_cs (), hay que llamarla periódicamente desde el
main (), pero normalmente se llama una sola vez.
Ya dentro del bucle infinito que se muestra a continuación, todas las funciones que se
encuentren dentro del mismo se ejecutarán indefinidamente.
Estas 2 funciones son idénticas y nos permiten controlar el ciclo de trabajo de ambos
PWM. La variable ValorPWMx_H, corresponde al semiciclo positivo de la señal y la
variable ValorPWMx_L, al semiciclo negativo.
Modificando el valor de ambas variables según el valor que se reciba de la PC, podemos
modificar el ciclo de trabajo, por lo tanto la potencia aplicada a los led’s PWM
(modificamos el brillo de los mismos).
47
Estas 4 sentencias son idénticas, lo que hacen es ver el estado de los pulsadores y enviar
guardar el valor en el buffer “envía”.
Ambos grupos de sentencias son iguales, lo que hacen es lo siguiente, enumerado para
una mejor comprensión:
Esta función envía el arreglo de datos “envía” hacia el host para luego poder visualizar
los datos en la aplicación. La función tiene 4 parámetros que enumeraremos para un
mejor entendimiento:
48
Al principio se ejecuta un bucle condicional, el mismo se fija, mediante la función que
tiene asociada si hay datos en el endpoint indicado. En este caso dentro del paréntesis
hay indicado un “1”, refiriéndose al endpoint 1.
En caso de que haya datos provenientes del host para leer, los tomamos y guardamos
usando la función usb_get_packet. La misma tiene 3 parámetros:
Una vez tomados los datos del host los procesaremos como muestran las siguientes
funciones:
Para darnos una idea de como trabaja la aplicación con el hardware vamos a poner la
función:
49
Vemos que la función envía el comando para activar los led’s y luego el dato
correspondiente al led 1. Cuando el PIC los recibe, cambia el estado del led 1 como
muestra la sentencia de código:
Para el caso de los PWM se cumple lo mismo: Se recibe el comando de control, recibe el
valor procedente de las barras de desplazamiento y lo guarda en las variables que
contienen el ciclo de trabajo.
Con esto ya hemos visto tanto la aplicación para la PC, como el firmware para el
microcontrolador y estamos listos para poder crear nuestras propias aplicaciones a partir
de la guía.
Algo que habíamos omitido hasta el momento es la explicación del hardware utilizado.
Aunque su utilización sea sencilla vale la pena detallar como está compuesto, además es
necesario nombrar los elementos que lo componen para un mejor entendimiento del
mismo.
50
Entrenador USB v0.1:
Como elemento hardware para el desarrollo de esta guía usaremos un entrenador de bajo
costo diseñado para comprender el funcionamiento del puerto USB y posibles
aplicaciones de control.
El entrenador también puede ser usado para aprender a programar debido a que posee los
periféricos básicos que se usan en los entrenadores estudiantiles.
Para tener una vista general del hardware utilizado, miremos la Fig. nº 41.
51
El nombre de cada pin es el siguiente:
Por último podemos ver el diseño del circuito impreso y el esquema de nuestro
entrenador USB en las Fig. nº 44 y 45 respectivamente:
52
Con esto damos por terminada nuestra guía, espero les sirva.
Un saludo !
53
54
55