LIBRERIA DE CODIGO LIBRE PARA COMUNICACIÓN USB HID

1. Clase de Visual C++ en software libre
para comunicación USB de HID
genéricos
Contenidos
1 Introduction
2 Public Methods
o 2.1 usbHidCommunication(System::Void) - Constructor
o 2.2 System::Void requestDeviceNotificationsToForm(System::IntPtr
handleOfWindow)
o 2.3 System::Void handleDeviceChangeMessages(Message% m,
System::Int16 vid, System::Int16 pid)
o 2.4 System::Boolean isDeviceAttached(System::Void)
o 2.5 System::Boolean isDeviceBroken(System::Void)
o 2.6 System::Void findDevice(System::Int16 usbVid, System::Int16
usbPid)
o 2.7 System::Boolean sendUsbCommandWriteOnly(System::Int16
usbCommandId)
o 2.8 System::Boolean sendUsbCommandWriteRead(System::Int16
usbCommandId)
o 2.9 System::Boolean writeToTheOutputBuffer(System::Int16
byteNumber, System::Byte value)
o 2.10 System::Byte readFromTheInputBuffer(System::Int16 byteNumber)
o 2.11 System::Void detachUsbDevice(System::Void)
3 Required include files
4 Status and Limitations
5 Further information about the class
6 Example code
7 Files for download
8 vea también
Introducción
Si han tratado de construir sus propios dispositivos PIC USB (tal vez usando mi tutorial anterior
“construyendo un dispositivo USB con PIC18) se habrán dado cuenta que el código anfitrión de
Windows (basado en la pila de ejemplos de USB de Microchip) es todo menos claro acerca de
cómo comunicarse con el dispositivo. Para hacer las cosas más fáciles para las personas que
están familiarizadas con lo intrincada que resulta ser la programación de Windows, y el USB
que yo he creado, una clase genérica de Visual C++ que maneja todos los problemas de
comunicación de dispositivos, incluyendo los aspectos plug & play de la detección de
acoplamiento y desacoplamiento de dispositivos.

2. La clase genérica es recomendable para todos los tipos de dispositivos USB HID genéricos
(incluyendo dispositivos que usen el protocolo genérico HID basado en un soporte con micro
controladores comunes que no sean los PIC18F)
En este artículo explicaré como usar esta clase, como funciona la clase y también daré algunos
ejemplos prácticos de cómo puede ser usada para hacer tu propio software para Windows.
Vea también: Framework en software libre para dispositivos USB HID genéricos basados en
PIC18F y Windows.
Métodos Públicos
Los métodos públicos de la clase son aquellos que son expuestos al programador usando la
clase. Tú puedes utilizar la clase usando estos métodos sin necesidad de indagar en el código y
entender cómo funciona. Las siguientes secciones detallan los métodos públicos, que hacen y
como invocarlos.
usbHidCommunication (System::Void) - Constructor
usbHidCommunication (System::Void) - Constructor
El método constructor debe ser llamado añadiendo una definición de la clase dentro de una
sección 'private:' del archivo .h de la forma, debería quedar de esta manera:
// Initialize the USB HID Communication object
private:usbHidCommunicationNameSpace::usbHidCommunication
a_usbHidCommunication;
Esta acción habilita a la clase para su uso (inicia un objeto desde la clase)

3. System::Void requestDeviceNotificationsToForm (System::IntPtr
handleOfWindow)
Este método solicita que las notificaciones del dispositivo sean enviadas a la forma principal
que permite a la clase recibir los mensajes de acoplamiento y desacoplamiento del dispositivo
desde el sistema operativo Windows. Tienes que pasa el “dominio “de la forma central al
método para que este sepa a dónde dirigir las notificaciones. Para simplificar esto pon el
siguiente código en la forma de construcción:
//
//TODO: Add the constructor code here
//
// Request that this form receives device notifications
a_usbHidCommunication.requestDeviceNotificationsToForm(this->Handle);
System::Void handleDeviceChangeMessages (Message% m,
System::Int16 vid, System::Int16 pid)
Este método es responsable de manejar los mensajes de notificación de cambios en los
dispositivos provenientes de Windows (los que le dicen a la clase cuando los dispositivos USB
se conectan o desconectan del anfitrión).Para usar esto tienes que incluir el siguiente código
en la clase de la forma principal:
// Esta función de devolución de llamada recibe los mensajes de
Windows que vienen hacia la forma.
protected: virtual void WndProc (Message% m) override
{
a_usbHidCommunication.handleDeviceChangeMessages (m,
VID, PID);
Form::WndProc( m );
} // END WndProc method
Tienes que pasar este método, el VID y el PID de tu dispositivo que puede ser hecho ya sea
directamente (simplemente especificando los números como 0x1234, 0x4321) o (como en el
ejemplo arriba) desde dos comandos #define en el inicio del archivo h. de tu forma
System::Boolean isDeviceAttached(System::Void)
Este método devuelve ‘verdadero’ si el dispositivo esta actualmente acoplado, y ‘falso’ si es
que no lo está, y puede ser usado para ver si el dispositivo USB está disponible para
comunicación.
System::Boolean isDeviceBroken(System::Void)
Este método devuelve ‘verdadero’ si un dispositivo está conectado pero, por alguna razón, es
considerado ‘interrumpido’ (problemas de comunicación de i.e., etc). Nótese que si esta

4. bandera es ‘verdadera’ el método isDeviceAttached devolverá ‘falso’. Esto te permite añadir
alguna información extra de alerta si algo inesperado le ocurre al dispositivo.
System::Void findDevice(System::Int16 usbVid, System::Int16 usbPid)
Este método intenta encontrar el dispositivo USB con el VID y PID alimentados. Si este tiene
éxito “isDeviceAttached” devolverá ‘verdadero’ cuando sea consultado. Debes realizar una
búsqueda inicial para el dispositivo cuando la forma principal sea creada, si el dispositivo es
conectado después la notificación del dispositivo hará que llame a este método
automáticamente. Debes incluir también, una llamada hacia este método en el constructor de
la forma central similar al siguiente código.
public:
Form1(void)
{
InitializeComponent();
//
//TODO: Add the constructor code here
//
// Request that this form receives device notifications
a_usbHidCommunication.requestDeviceNotificationsToForm(this-
>Handle);
// Perform an initial search for the desired USB device
a_usbHidCommunication.findDevice(VID, PID); // VID, PID
}
System::Boolean sendUsbCommandWriteOnly(System::Int16
usbCommandId)
Este método envía un comando (y probablemente algunos datos) al dispositivo USB, pero no
espera que el dispositivo USB le envíe algo en respuesta. Para usar esto tu simplemente
configuras usbCommandId hacia el valor que deseas enviar y llamar el método. El
commandId es de hecho el 1er byte del paquete de 64-bytes que el HID genérico usa para
comunicarse. Los otros 63 bytes están disponibles para datos y pueden ser configurados
usando el método writeToTheOutputBuffer() detallado a continuación.
Aquí está un ejemplo de este método en acción:
// Send the toggle LED command
if (a_usbHidCommunication.sendUsbCommandWriteOnly(0x80) != true)
this->lastErrorMessageLabel->Text = L"Read/Write command
failed";
else this->lastErrorMessageLabel->Text = L"Read/Write command
succeeded";

5. Este método devuelve ‘verdadero’ si la escritura fue exitosa y ‘falso’ si falla.
System::Boolean sendUsbCommandWriteRead(System::Int16
usbCommandId)
Este método es similar al método sendUsbCommandWriteOnly(), sin embargo este espera
que el dispositivo USB conteste al comando. La respuesta del dispositivo USB es obtenida
usando el comando readFromTheInputBuffer() detallado a continuación.
Aquí está el método en acción:
// Check the status of the switch
a_usbHidCommunication.sendUsbCommandWriteRead(0x81);
if (a_usbHidCommunication.readFromTheInputBuffer(2) == 0)
this->switchStatusLabel->Text = L"Switch ON";
else this->switchStatusLabel->Text = L"Switch OFF";
System::Boolean writeToTheOutputBuffer(System::Int16 byteNumber,
System::Byte value)
Este método te permite escribir bytes en el buffer de salida para ser enviados cuando el
siguiente método de envío de comandos sea llamado. Tu simplemente proporcionas el
numero de byte (2-64) del byte que quieres configurar (los bytes 0 y 1 están reservados para
comunicación) y el valor del byte. El método devuelve ‘verdadero’ si es exitoso y ‘falso’ si no
tiene éxito.
System::Byte readFromTheInputBuffer(System::Int16 byteNumber)
Este método te permite leer bytes desde el buffer de entrada (datos que son devueltos
después de que un método sendUsbCommandWriteRead() es llamado). Simplemente
especifica el número de byte en el cual estás interesado (2-64), y el método devuelve el valor.
System::Void detachUsbDevice(System::Void)
Este método remueve el dispositivo USB de tu código y limpia cualquier identificador de
archivo, amenazas, etc. dejando la clase en el estado que poseía cuando fue construida. Esto
es útil si deseas desacoplar el dispositivo por alguna razón. Nota: como esta clase está en
‘user-space’ la misma no desacopla el dispositivo del anfitrión, tan solo de tu aplicación.
Archivos que se deben incluir necesariamente
Para usar esta clase se tiene que incluir las cuatro librerías requeridas en tu archivo stdafx.h.
Debería quedar similar al que se muestra a continuación:
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
#pragma once

6. // TODO: reference additional headers your program requires here
#include <Windows.h>
#include <setupapi.h>
#include <Dbt.h>
Estado y limitaciones
Esta clase es relativamente nueva y no se ha probado. Si la usas y encuentran algo incorrecto o
que pueda ser hecho de mejor manera por favor déjenme saber, me encantaría oír de ustedes.
La principal limitante de esta clase es que solo puede manejar un dispositivo a la vez, es decir,
si tienes 2 o más dispositivos con el mismo VID y PID esta simplemente elegirá el primero que
encuentre. Espero remover esta limitante en un futuro próximo.
Información adicional acerca de la clase
Si les gustaría saber más acerca de los trabajos de esta clase por favor siéntase con todo el
derecho de mirar directamente en el código fuente. Invertí mucho tiempo haciendo este
código lo más claro posible así como incluyendo muchos comentarios acerca de cómo funciona
y lo que está pasando.
Código de ejemplo
A continuación encontraran una aplicación de Windows de ejemplo con el código clase
incluido. Este código está diseñado para trabajar con mi simple dispositivo genérico HID del
PIC18F el cual pueden encontrar en esta página.
Está diseñado para usar el mismo firmware del PIC como el proyecto original. Obviamente este
es dispositivo bastante simple, sin embargo la clase debería permitirte construir dispositivos
mucho más complejos sin tener que preocuparte acerca de los detalles de bajo nivel
pertenecientes a la programación de USB HID en Windows.
Este código compilará en Visual C++ 2008 para ambas, Visual Studio 2008 (versión gratuita) y
la versión profesional. Para compilar carga el archivo del proyecto y selecciona compilar dentro
de Visual Studio.
Para usar la clase en tu propio código simplemente hagan su propio código y cópienlo sobre el
archivo usbHidCommunication.h en su directorio de proyecto.

7. Estructura de Software Libre para dispositivos genéricos USB
HID basados en el PIC18F y Windows
Contenidos
1 Introduction
2 Version 2_0_0_0
3 Reference Hardware
o 3.1 Circuit Schematic
o 3.2 Breadboard Layout
o 3.3 Self-Powered USB Devices
4 Reference Firmware
5 Reference Application
6 The USB Generic HID C# Class Library
o 6.1 Using the class-library
 6.1.1 findTargetDevice()
 6.1.2 handleDeviceNotificationMessages()
 6.1.3 onUsbEvent()
 6.1.4 readMultipleReportsFromDevice()
 6.1.5 readSingleReportFromDevice()
 6.1.6 registerForDeviceNotifications()
 6.1.7 writeRawReportToDevice()
 6.1.8 isDeviceAttached
7 Conclusions
8 Files for download
9 Example Application - USB LCD Screen Device
10 See also
Introducción

8. Si has incursionado con micro controladores PIC18F y con estándar USB HID genérico antes (tal
vez has intentado al menos mi construcción de un proyecto de dispositivo USB con PIC18F)
entonces habrás notado que hay mucha complejidad en el soporte USB, tanto en el lado del
PIC18F como por el lado del anfitrión Windows.
Yendo más allá de lo básico como: leer un Smith y hacer titilar un LED (por cierto cuantos
proyectos has construido para hacer titilar LED’s), es realmente una extenuante tarea con una
curva de aprendizaje escarpada.
Para facilitar las cosas al aficionado que desea ahondar en proyectos más emocionantes, he
desarrollado una estructura para producir dispositivos USB que cubren tanto; el lado de
desarrollo de aplicaciones del anfitrión Windows, y la estructura misma del PIC18F. La
estructura consiste en una librería de clases en Visual Studio C# (que maneja todo el problema
de lidiar con los SDK’s específicos de Windows y los requerimientos del sistema operativo), una
aplicación de referencia de Windows (la cual indica cómo usar la librería de clases y actúa
como fronnt-end de prueba para la librería), un simple diseño de hardware USB de referencia y
(al final pero no menos importante) un firmware para PIC18F45550 que se comunica con la
librería de clases.
En esencia esto significa que tu puedes desarrollar rápidamente un dispositivo USB y probarlo
junto con la aplicación anfitriona de Windows con un mínimo de conocimiento de protocolo de
USB HID genérico. La librería de clases te da una interfaz muy simple hacia el dispositivo USB
desde C# y el firmware sirve como ejemplo de cómo crear el software especifico necesario en
el PIC para el diseño de tu dispositivo.

9. La estructura incluye la habilidad de pasar comandos y respuestas desde y hacia el dispositivo
USB así como transferencia en masa bidireccional de datos, permitiéndote construir
aplicaciones más complejas de captura de datos que requieren que más información sea
pasada rápidamente desde el anfitrión al dispositivo y viceversa.
En este artículo yo me detendré en cada elemento de la estructura y mostraré como pueden
usarlo para desarrollar sus propios dispositivos USB creativos.
Para los impacientes, aquí les va un rápido video de YouTube de la estructura en acción. El
ejemplo del operador (driver) de LCD mostrado en el video puede ser descargado en el
siguiente vínculo:
Versión 2_0_0_0
Versión 2 de la librería USB y el firmware no está disponible (2010-12-03). He hecho algunas
mejoras a la librería así como el arreglo de algunos bichos (bugs). Aquí esta una lista de las
mejoras y cambios:
Firmware
o Añadí la habilidad de depuración en secuencia desde el firmware hasta el
anfitrión para permitir una depuración fácil de firmware’s complejos.
o Moví las direcciones de mapeo de memoria a memorymap.h para permitir un
acoplamiento de puertos a dispositivos diferentes al PIC18F2550 y PIC18F4550
o Añadí directrices que controlan la compilación del firmware dependiendo de si
es usado un 2550 o un 4550; ahora puedes compilar para cualquier chip sin
alterar el código del firmware
o Las definiciones de PID y VID fueron movidas a HardwareProfile.h para hacer
más simple de entender el cómo cambiar identificadores de dispositivos
o Los productos, fabricantes y números de serie fueron movidos a
HardwareProfile.h para que el cambio de los mismos sea más fácil
o El firmware de referencia automáticamente remapea los LED’s en el hardware
de referencia desde el PUERTO D al PUERTO B cuando se está usando un
PIC18F2550
o Limpieza (enceramiento) del código general
Aplicación de referencia del anfitrión
o Añadí una ‘ventana’ de depuración demostrando como usar la nueva función
de secuencia de registro en el firmware
o Arregle un problema de localización, donde el desacoplamiento del dispositivo
no era detectado en ciertas localidades
o Limpieza (enceramiento) del código general
Por favor asegúrese de especificar que versión de librería de USB está usando cuando pregunta
por ayuda en los foros
Hardware de referencia

10. El hardware de referencia es extremadamente simple y puede ser construido en una
protoboard si se necesita. Yo puse los pines de salida de del hardware idénticos al tablero del
PIC DEM FS USB disponible de Microchip para permitirle comprar un tablero de referencia (si
es que se desea!) también puedes usar mi clon de la placa de Microchip – el tablero de
desarrollo de PIC USB. Si no tienes tiempo/dinero/interés para hacer un tablero (placa) de
referencia aquí está un circuito de esquema del hardware mínimo requerido para el tablero de
referencia:
Esquema del circuito
Diseño de la protoboard
La siguiente figura muestra el hardware de referencia construido en una protoboard
experimental. Mira que puedes usar el PIC18F4550 (si no tienes un 18F4550 a la mano) He
puesto algunas notas en el código fuente del firmware explicando lo que se necesita cambiar.

11. El hardware de referencia provee 4 LED's que son usados para mostrar el estado del
dispositivo USB mientras este procesa todas las peticiones que pueden ser enviadas hacia este
desde la aplicación anfitriona en Windows. Los 4 LEDs (de izquierda a derecha) significan:
1. Dispositivo encendido – dispositivo listo
2. USB enumerado – dispositivo listo para comunicarse
3. Indicador de éxito (titila mientras los datos son procesados correctamente)
4. Indicador de fallo (titila si un comando no fue correctamente procesado)
La Protoboard provee todo lo que necesitas para añadir lo necesario a tus dispositivos y
circuitería, incluso puedes retirar los LEDs, la única parte que el firmware realmente requiere
es el puerto USB y su hardware asociado.
Dispositivos autoalimentados
El hardware de referencia mostrado anteriormente es para un dispositivo USB alimentado por
el bus (toma su energía directamente de la computadora anfitriona) Este requiere un número
mínimo de partes y da un circuito bastante simple, sin embargo el consumo de corriente del
dispositivo está limitada a 100mA. Si deseas construir dispositivos que consuman más energía
(para manejar más hardware como relays, motores, arreglos de LEDs, etc.) Necesitaras hacer
autoalimentado al dispositivo.
El siguiente esquemático muestra una versión simple autoalimentada de la protoboard de
referencia. Un regulador LM7805 5V es añadido para regular la entrada de CD y un diodo
1N5817 es usado para protección de la polaridad ( esto ayuda a proteger tu PIC y PC cuando se
está experimentando) La entrada de 5V desde el bus USB es dirigida hacia RA0 en el
PIC18F4550 el cual permite al firmware detectar cuando el cable USB está conectado o

12. desconectado. Puedes omitir esta función de censado de voltaje, sin embargo esto significa
que tu firmware necesitará censar constantemente la pila USB para saber si un cable USB está
conectado.
Firmware de Referencia
El firmware de referencia está basado la versión 2.6 de la pila USB de Microchip. Las
modificaciones más significativas que hice están contenidas mayormente en el archivo main.c.
Aparte de eso he llevado la pila para el compilador HiTechPIC18F (la cual yo creo que es
superior a la del C18 – pero esto probablemente es cuestión de gustos) y la especialicé
particularmente para soportar el protocolo HID USB Genérico.
En el firmware encontrarás (localizado en el archivo fuente main.c) una implementación para
algunos comandos que se reflejan en la aplicación de referencia:
0x80: Escritura de paquete único al dispositivo - Este comando recibe un comando y un
paquete únicos desde el anfitrión (que es de 64 bytes) y luego los números del 1 al 63
en los bytes restantes. Esto permite al firmware confirmar que todo el paquete ha sido
recibido correctamente.
0x81: Escirtura/lectura de paquete único – Esta es similar a la 0x80, sin embargo el
firmware genera un paquete de retorno (lleno de datos similares) y lo pasa de vuelta al
anfitrión.
0x82: Escritura de paquete único, lectura de 128 paquetes – este comando recibe un
paquete único desde el anfitrión y, a cambio, envía de regreso 128 paquetes de 64
bytes que contienen datos. Este comando simula los requerimientos de trasferencia de
datos en forma masiva desde el dispositivo hacia el anfitrión (para aplicaciones como
captura de datos, etc.)

13. 0x83: Escritura de 128 paquetes, lectura de paquete único – Este comando recibe un
comando del administrador seguido de 128 paquetes de 64 bytes que contienen
datos. Esto es básicamente el opuesto de 0x82 donde el anfitrión está transfiriendo
datos en forma masiva hacia el dispositivo USB (usado en aplicaciones como driver
para display, etc.)
0x84: Escritura de paquete único, tiempo de espera en la lectura – Este comando es un
poco diferente de los otros. Es usado para simular un escenario de falla en el lado del
anfitrión donde un comando es enviado y el anfitrión espera una contestación, pero el
firmware no contesta (simulando un bicho “bug” en el firmware) Este realmente no
hace mucho en el lado del dispositivo PIC, pero es útil para probar lo que hace la
aplicación en el administrador cuando dicho evento ocurre.
El software de referencia no solo provee un entorno de prueba para la librería de clase del
anfitrión, sino que también sirve como ejemplo de cómo comunicarse de manera bidireccional
con el anfitrión. Esto para comando simple y respuesta, así como para transferencia de datos
en forma masiva.
El firmware de referencia un software libre a base de GPL, entonces son libres de usarlo y
adaptarlo a sus requerimientos. También si tienen sugerencias para el mejoramiento me
encantaría saber de ustedes en el foro.
Aplicación de Referencia
La aplicación de referencia usa la librería de clases de C# para comunicarse con el firmware de
referencia. Este provee una interfaz simple hacia los 5 comandos disponibles permitiéndote
seleccionar que comando desearías enviar. La aplicación también crea los comandos y datos
para enviar a los dispositivos, así como también interpreta los datos y respuestas enviadas de
regreso por el firmware para confirmar que todo está trabajando como debería.
Aquí se puede ver la interfaz GUI desde la aplicación de referencia ejecutándose en una
computadora con Windows 7:

14. Las 5 pruebas corresponden a los 5 comandos provistos por el firmware. Cuando se hace clic
en el botón de prueba el comando es enviado al firmware y a ambos: el firmware (a través de
los LED’s de éxito y falla) y el anfitrión (proveyendo un mensaje ‘test passed’ o ‘test failed’)
provee retroalimentación en la prueba de éxito.
Además, la librería de clase C# provee ‘events’ del dispositivo USB a la aplicación dejándola
saber cuando el dispositivo USB está acoplado o desacoplado al anfitrión. Esto se prueba
conectando y desconectando el conector USB y al mismo tiempo se mira la barra de estado al
fondo de la ventana. Si todo está bien se debería ver los mensajes ‘device attached’ o ‘device
detached’. También, la aplicación desabilita los botones de prueba cuando ningún dispositivo
es encontrado.

15. La librería de clase subyacente HID USB genérico de C# provee una clase base en la cual se
puede construir aplicaciones. La aplicación de referencia define una clase ‘especializada’ para
su propio dispositivo USB la que asume todas las funciones accesibles de la clase base. La
aplicación entonces extiende la clase base para incluir sus propios métodos para la
comunicación con el dispositivo. Simplemente pon, la clase especializada tiene que proveer
una interfaz de los comandos que el dispositivo debe soportar (0x80, 0x81, etc.) para el envío
en masa y recibe métodos provistos por la clase.
Esto te permite ser muy flexible en cómo te comunicas con el firmware ya que eres libre de
definir tus propios comandos de cualquier manera que desees.
Cada vez que se hagan cambios, arreglo de bichos (bugs), o modificaciones en la librería de
clase HID USB genérico puedes usar el firmware de referencia y la aplicación para probar y
asegurar que la librería todavía está funcionando correctamente, esto ahorra mucho tiempo
después o cuando aparecen imprevistos (como siempre pasa!)
La librería de clases HID USB genérico de C#
Hay dos vías a saber para acceder a la librería de clases: “¿Cómo la uso?” y “¿Cómo trabaja?”.
Si estás interesado en el funcionamiento interno de la librería de clase sugiero cargarlo en
Visual Studio y mirar el código. He tratado de estructurarlo y comentarlo lo más claro posible.
La mayor parte de la complejidad es tomada, adaptada y (en algunos casos!) escrita desde
cero. Por medio de hacer a la librería de clases específica para asuntos de comunicaciones de
HID genérico con micro controladores. Me las he arreglado para remover bastante de la
complejidad del proceso de escribir verdaderos drivers genéricos.
También hay mucha información incorporada acerca de depuración. Si compilas la aplicación
de referencia en el modo de depuración de Visual Studio, verás un registro completo de las
actividades de la aplicación (y su librería de clase) una vez que salgas de la aplicación.
Usando la librería de clase
Una vez que has incluido la librería de clases en tu proyecto (por ejemplo para saber cómo
hacer esto simplemente mira los archivos de proyecto de la aplicación de referencia los cuales
están incluidos a continuación), necesitaras añadir en algunas líneas del código C# hacia la
forma principal (main), para poder poner la librería de clase en funcionamiento.
Primero subir este código el cual necesita ir dentro del constructor de clase de la forma central
usualmente llamada (Form1()):
public Form1()
{
InitializeComponent();
// Create the USB reference device object (passing VID and
PID)
theReferenceUsbDevice = new usbReferenceDevice(0x04D8,
0x0045);
// Register for device change notifications

16. theReferenceUsbDevice.registerForDeviceNotifications(this.Handle);
// Add a listener for usb events
theReferenceUsbDevice.usbEvent +=
new
usbReferenceDevice.usbEventsHandler(usbEvent_receiver);
// Perform an initial search for the target device
theReferenceUsbDevice.findTargetDevice();
}
Este código hace 4 cosas:
1. Primeramente inicia la clase usbReferenceDevice (la cual es una forma especializada
de las librerías base de clase) y pasa el VID y PID del dispositivo blanco
2. A continuación el controlador de la ventana de formas a una clase que registra la
ventana para recibir eventos desde Windows acerca de las notificaciones del
dispositivo
3. Añade una función ‘listener’ a la forma, esta recíbelos eventos generados por el
dispositivo USB (acoplar y desacoplar dispositivos)
4. Finalmente ejecuta el primer intento para encontrar el dispositivo USB que se tiene
por objetivo (el dispositivo puede estar ya conectado, por ende no se enviarán
notificaciones, a pesar de que el dispositivo esté ahí
Lo siguiente son tres artículos más requeridos por la clase de biblioteca:
// Create an instance of the USB performance meter
private usbReferenceDevice theReferenceUsbDevice;
// Callback method for WndProc
protected override void WndProc(ref Message m)
{
// Pass the message to our message handler
theReferenceUsbDevice.handleDeviceNotificationMessages(m);
// Pass the message on to the base WndProc
base.WndProc(ref m);
}
// Listener for USB events
private void usbEvent_receiver(object o, EventArgs e)
{
// Check the status of the USB device and update the form
accordingly
if (theReferenceUsbDevice.isDeviceAttached)
{
// Device is attached, do tasks here
}
else
{
// Device is detached, do tasks here
}
}

17. El primer comando genera una ‘instancia’ de la clase de dispositivo USB que es usada por el
primer código de ejemplo para poner la clase en funcionamiento.
El segundo método (o procedimiento) intercepta los eventos de notificación de Windows y los
pasa a la librería de clase para su procesamiento.
El tercer método es el detector de eventos USB que es llamado por la clase cuando el
dispositivo USB está acoplado o desacoplado y permite a la aplicación realizar tareas tales
como actualizar la barra de estado y activando/desactivando los controles de la forma (este
método provocado por evento, evita los mecanismos habituales de sondeo que usan la
mayoría de aplicaciones de forma para monitorear el estado del USB, y mucho más eficiente)
Una vez que esto se ha hecho eres libre de añadir cualquier ventana, botón y control que tu
aplicación necesite. La integración primaria de la librería de clases es deliberadamente lo más
simple posible. Sin embargo, para comunicarte con tu dispositivo USB aun se deben hacer algo
más.
Para representar tu propio dispositivo USB se debe generar una clase que represente al
dispositivo. Esto es tan simple como añadir una clase al proyecto. La clase debe heredar la
librería de clase base y también definir algunos métodos para permitir a tu aplicación
comunicarse con el dispositivo USB. No te preocupes si esto suena complicado, porque
realmente no lo es, y la aplicación de referencia provee todo el código de ejemplo que se
necesita en el archivo fuente usbReferenceDevice.cs.
La primera parte de esta clase define la clase misma y crea su propio ‘constructor’ para
permitirte añadir cualquier inicialización que tu dispositivo pueda necesitar. El código se ve de
esta manera:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
namespace USB_Generic_HID_reference_application
{
using usbGenericHidCommunications;
class usbReferenceDevice : usbGenericHidCommunication
{
// Class constructor - place any initialisation here
public usbReferenceDevice(int vid, int pid) : base(vid, pid)
{
}
En el código ejemplo se puede ver la forma correcta de definir la clase (usando la librería de
clases como la base) y, como pasar el VID y PID desde tu constructor hasta la librería de clases.
Una vez que esto está hecho se puede incluir tranquilamente cualquier método que el
dispositivo requiera. Primariamente, estos serán métodos que comunican hacia y desde tu
dispositivo. En la aplicación de referencia tienes cinco ejemplos de métodos los cuales usan los
cuatro tipos diferentes de comandos soportados por el firmware de referencia (así como el
quinto comando el cuál es netamente para demostrar cómo reacciona la clase a bichos del
firmware)
Aquí está un método de ejemplo que envía un comando al dispositivo USB:

18. public bool test1()
{
// Test 1 - Send a single write packet to the USB device
// Declare our output buffer
Byte[] outputBuffer = new Byte[65];
// Byte 0 must be set to 0
outputBuffer[0] = 0;
// Byte 1 must be set to our command
outputBuffer[1] = 0x80;
// Fill the rest of the buffer with known data
int bufferPointer;
Byte data = 0;
for (bufferPointer = 2; bufferPointer < 65;
bufferPointer++)
{
// We send the numbers 0 to 63 to the device
outputBuffer[bufferPointer] = data;
data++;
}
// Perform the write command
bool success;
success = writeRawReportToDevice(outputBuffer);
// We can't tell if the device received the data ok, we
are
// only indicating that the write was error free.
return success;
}
Como pueden ver desde la clase es muy simple, la librería de clases se ocupa de todos los
detalles. Tú simplemente ensamblas el comando y los que deseas enviar y haces la llamada
para escribir el método, después todo lo que resta es probar el resultado para asegurar que
fue exitoso.
Hay pocos métodos ‘públicos’ que la clase provee, pero aquí está una lista de ellos y para qué
son usados:
findTargetDevice()
Este método busca el dispositivo USB basado en el VID y PID que fueron proporcionados
cuando el objeto fue creado.
handleDeviceNotificationMessages()
Este método se ocupa de interpretar las notificaciones recibidas de la aplicación y de ver si
estas se relacionan con el dispositivo USB. Si lo hacen, entonces el método empieza a buscar el
dispositivo USB, o lo registra como desacoplado dependiendo de los mensajes recibidos.
onUsbEvent()
Este método es parte del mecanismo de evento usado por la librería de clases para informar a
tu aplicación si el dispositivo USB está siendo acoplado o desacoplado.

19. readMultipleReportsFromDevice()
Este metodo es usado para transferencias de datos en masa entrantes, ver el archivo
usbReferenceDevice.cs (en la aplicación de referencia) para detalles de cómo es su uso.
readSingleReportFromDevice()
Este método es usado para obtener un paquete único de reporte desde el dispositivo USB. Una
vez más usbReference.cs es el mejor lugar para encontrar un ejemplo de cómo se usa este.
registerForDeviceNotifications()
Este método es usado para indicar a Windows como enviar notificaciones del dispositivo a tu
aplicación (las cuales son después recogidas por handleDeviceNotificationMessages() para su
procesamiento)
writeRawReportToDevice()
Este metodo es usado para enviar comandos y datos al dispositivo USB. Una vez más
usbReference.cs es el mejor lugar para encontrar un ejemplo de cómo se usa este.
isDeviceAttached
Esta propiedad se puede probar para ver si el dispositivo USB está presente. Tiene un valor
verdadero si el dispositivo está conectado y falso si el dispositivo está desconectado.
La librería de clases C# y la aplicación de referencia son las dos publicada bajo el GPL por ende
las puedes usar y adaptar a tus necesidades libremente. No pretendo ser un experto en C#(!)
así que si tienen algunas sugerencias para mejoras, o reporte de errores, acérquense al foro y
déjenme saber!
Conclusiones
Con un entorno completo de referencia y una serie de pruebas tienes todo lo que necesitas
para crear tus propios proyectos USB avanzados. No hay límite en el hardware que se puede
interfazar a tu PC usando USB y micro controladores PIC. Inclusive si no eres un fanático de los
PIC, la librería de clases es genérica para todos los micros controladores que soportan el
protocolo de comunicaciones Genérico HID.
Como en todas las experiencias de aprendizaje, empiecen con algo simple. Y, lenta y
gradualmente profundicen en la manera como la librería de clases opera y como las
aplicaciones de Windows son creadas en C#. Existe una infinidad de posibilidades para su
próximo truco!
Actualmente la librería de clase no soporta más de un dispositivo USB con el mismo PID y VID
haciendo el proceso de selección de dispositivos más difícil (tanto para la librería como para la
aplicación) He incluido algunos métodos de enumeración de dispositivos muy fáciles de
entender, en la clase; así que añadir soporte debe ser fácil. Espero pronto apoyar esto en una
versión actualizada de la librería.
Construyendo un dispositivo USB para PIC18F

20. Contenidos
1 Actualización
2 Introducción
3 Hardware
4 Firmware
o 4.1 Enumeración de dispositivos
o 4.2 Comunicación con el anfitrión
o 4.3 Comprensión del código fuente del firmware
o 4.4 Conexión del dispositivo
5 Software anfitrión
6 ¿Que sigue después?
7 Archivos para descargar
Actualización
Recientemente publique una clase de comunicación para USB HID genérico en
software libre C++. Por favor revisen acerca de más información detallada acerca de la
programación de aplicaciones de Windows para HID genérico y una aplicación de
Windows actualizada para este proyecto – Simon (2010-03-30)
Hay ahora una versión de librerías en C# usadas para la comunicación manejada por
Windows. Se la puede leer aquí here - Simon (2010-05-05).
Introducción
Recibo muchos correos cada mes, preguntando ¿Cómo crear dispositivos USB usando el micro
controlador PIC18F?Después de haber visto proyectos como mi Atari Joystick USB Adaptor
“adaptador USB para Joystick de Atari” y C64 VICE Front-End, parece existir una demanda
de mayor información acerca de cómo hackear uno propio.
En este artículo les mostraré como implementar en una protoboard un simple dispositivo USB
HID genérico, creando el firmware y finalmente creando la interfaz de Windows para el
dispositivo. La que te ayudará a controlar un LED desde la PC y leer el estado de un pulsador
del dispositivo. Desde la llegada de Windows 7 se necesita una costosa certificación de
validación de Windows para crear controladores USB propios (si esto la mayoría de usuarios ni
siquiera podrán instalar tu software) Usar los controladores embebidos para dispositivos HID
genéricos proveen un método simple de crear dispositivos compatibles con Windows y Linux y
también realiza la creación del firmware y software de una manera mucho más simple. Debido
a que el estándar HID genérico no requiere controladores propios, no necesitaras obtener un
certificado para tu controlador, también Windows y Linux tienen librerías incorporadas para
ayudarte a comunicarte.

21. Para este artículo nos vamos a regir a un dispositivo USB bastante básico. El dispositivo te
permitirá controlar un LED desde Windows y también ver el estado de un pulsador en el
dispositivo. Este será hecho de una manera simple usando los principios básicos de la
comunicación USB de 2 vías, permitiéndote progresar hacia proyectos más complejos.
Para mantener la dificultad y los costos lo más bajos posible me concentrare en la construcción
del hardware en la protoboard usando pocos componentes, el firmware del PIC18F4550 se
basará en el compilador C, MPLAB y Hitech (disponible de forma gratuita) El software será
creado usando la versión express de Microsoft Visual C++ 2008 (que también se pude
descargar de forma gratuita)
Sin bien este artículo se basa en el micro controlador PIC18F4550, este se puede sustituir
fácilmente por el PIC18F2550 que es más pequeño y barato. Y, cuyo código es compatible con
el 4550.
Si quieres seguir con este artículo te sugiero que vayas hacia el final de la página y descargues
el software que lo acompaña. También asegúrate de que tienes instalados: MPLAB, Hi Tech C
para el PIC18F4550 y Microsoft Visual Studio 2008 express.
Noten que todas las fotos del programa anfitrión fueron tomadas de un maquina con Windows
7, si necesitan encontrar las misma cosas o similares en una versión más antigua de Windows
por favor vayan a Google donde encontraran bastante información acerca de la ubicación de
cada ítem en su máquina Windows Me.

22. Hardware
Para empezar necesitamos construir un dispositivo USB con el cual comunicarnos. El
dispositivo incluye un conector ICSP (In Circuit Serial Programing) y una conexión USB tipo B.
además hay un solo LED y un solo pulsador para representar los dispositivos de entrada y
salida.
Este circuito es muy simple (si no entiendes este nivel de electrónica de micro controladores te
sugiero que construyas alguno de los muchos tutoriales de prender LED´s y pulsadores,
disponibles en la web antes de intentar realizar esto) El PIC 18F4550 será alimentado por el
bus; esto significa que el dispositivo tomara su energía del USB anfitrión (tu PC) por ende no se
requiere regulación de voltaje. El capacitor de 470nF (C3) es necesario para que el PIC opere la
circuitería USB interna (esta ayuda a regular los voltajes USB requeridos por la interfaz USB
incorporada en el PIC)
El conector ICSP permite conectar un programador PIC, yo sugiero usar el económico
programador PICkit2, claro que cualquier otro programador compatible con ICSP debería
trabajar bien también. El oscilador de 20MHz es requerido para aplicaciones USB. Este le
permite al PIC usar PLL, el mismo que eleva la velocidad del reloj hasta los 48MHz necesarios
para comunicación USB.
(Un lector [Jason] me envío un email indicándome que un cristal de 20MHz no es
estrictamente necesario cuando se usa el USB incorporado de los PIC18F, que es muy exacto.
Puedes usar varios cristales provistos en el mercado, siempre y cuando cambies la
configuración de fusibles del PIC. Revisa la hoja de datos del PIC18F4550 en las páginas 29-30
para más información – gracias Jason!)

23. La siguiente fotografía muestra el circuito construido en una protoboard para aficionados. He
añadido algunas etiquetas a la fotografía para indicar el lugar de cada componente. Por favor
tengan en cuenta que, para programar estaremos usando la tensión de 5V que entrega el
programador. Como este es un dispositivo USB alimentado por el bus las líneas de 5V también
estarán conectadas al conector USB. Esto significa que si el programador y el cable USB están
conectados al mismo tiempo existe solo el potencial del programador para suministrar 5V al
anfitrión USB, lo cual no es recomendable según los estándares USB. Personalmente no he
visto un caso donde esto importe (para propósitos de experimentación), pero si deseas,
puedes añadir un diodo de barrera al conector USB para prevenir esto. En mis proyectos
generalmente uso un diodo de barrera schottky 1N5817.
Si no tienes un conector USB para tu protoboard puedes simplemente hacer uno usando una
placa perforada (como mi adaptador simple en la fotografía de arriba), o también puedes
cortar una punta de un cable USB, pelar los cables y ponerlos directamente en la protoboard.
Yo recomendaría tomarse el tiempo para hacer un adaptador, este reduce el riesgo de que se
suelten algunos cables cuando se conecta o desconecta el cable USB de la computadora.
(Un lector [Brandon] me envió un email preguntando acerca de los valores de las
resistencias y capacitores en este proyecto – resistencias de ¼ de vatio indicadas para
cualquier cosa mayor a 5 voltios son perfectas para este proyecto (sin embargo
resistencia más altas deberían trabajar bien también) También la ubicación de los pines
del PIC18F4550 en el esquemático es ´lógico´ (a diferencia de los diagramas físicos en
la hoja de datos) sin embargo la numeración de los pines es la misma en los dos.
Entonces, siempre y cuando sigas la numeración no deberías tener problemas – Gracias
Brandon!)

24. Si estas inseguro del cableado para el cable USB la siguiente figura muestra la salida de los
pines para un sócalo USB (hembra tipo B) y el código de colores de los cables estándar:
Una vez que has construido el circuito de arriba asegúrate de revisar que no haya cortos en las
conexiones de alimentación positiva y negativa antes de conectar el dispositivo en tu PC. No
querrás dañar tu computadora. Siempre asegúrate de revisar todo antes de conectar el cable
USB o tu programador para evitar gastos de reparación altos!
Firmware
Para conectar tu dispositivo USB a la computadora primero necesitaras escribir y compilar un
firmware para el PIC18F4550. Microchip (el fabricante del micro controlador PIC) provee una
pila USB gratuita para descargar especial para este propósito. Para hacer las cosas más fáciles
he escrito un firmware simple para manejar el dispositivo, puedes usar esto para empezar y
también como una base para entender cómo opera el firmware. Una vez que has logrado
hacer funcionar tu primer dispositivo encontraras más fácil entender cómo puedes adaptarlo
para aplicaciones más complejas.
Enumeración de Dispositivos
Lo primero es la enumeración de dispositivos USB - esta característica que suena algo
compleja es en realidad la comunicación inicial con el anfitrión USB (el ordenador) cuando el
dispositivo le dice al anfitrión que es y como desea comunicarse. La comunicación USB es
realizada usando ‘endpoints’ (directivas en los extremos), las que envían información, ya sea al
anfitrión o al dispositivo. Así como el dispositivo debe configurar los canales comunicación,
también debe pasar su propio nombre de dispositivo y otros dos datos importantes: VID Y PID.
El VID es la identificación del vendedor e identifica a los fabricantes del dispositivo. Para
obtener tu propio VID necesitas pagar más o menos mil dólares al cuerpo de normas USB. En
este ejemplo usaremos el VID de microchip para minimizar costos. Si de verdad quieres
producir y vender dispositivos, necesitarás registrar un VID propio.
El PID es la identificación del producto. Juntos con el VID forman una identificación única para
tu dispositivo. Cuando tu dispositivo enumere primero a Windows guardará la combinación
VIP y PID para este dispositivo; esto se cumple incluso si usas un manejador genérico como el
HID ya que reduce el tiempo que Windows necesita para alistar el dispositivo. Esto es
importante, ya que si tú decides cambiar la información de enumeración de tu dispositivo
(añadir endpoints, etc.), también necesitaras cambiar por lo menos el PID antes de reconectar
el dispositivo. Si no haces esto recibirás errores de ‘Device not started’ incluso si tu código es

25. perfecto (por experiencia he notado que Linux no es tan quisquilloso y no tiende a crear
problemas si conservas la misma combinación PID/VID)
Comunicación con el anfitrión
La segunda tarea importante que efectúa el firmware es la comunicación en sí entre el
anfitrión y el dispositivo. Cada comunicación es identificada por un ‘comando’. Cuando usas el
estándar genérico HID el ‘comando’ le dice al anfitrión y al dispositivo como interpretar la
información, que es pasada con el comando. Esta información podría ser cualquier cosa (¡no lo
llaman ‘genérico’ por nada!) y es así como se puede lograr una gran flexibilidad en las tareas
que tu dispositivo desempeñe.
Una vez que tu dispositivo está enumerado el anfitrión sondeará al dispositivo eventualmente,
esto siempre es iniciado por el anfitrión y no por el dispositivo (sin embargo habrán
excepciones después cuando te adentres más en los protocolos de comunicación) En cada
sondeo el anfitrión puede enviar un comando y datos al dispositivo, así como también puede
recibir un comando y datos del dispositivo.
La parte principal del firmware que debes buscar es la sección que se ocupa con las solicitudes
de sondeo del anfitrión u realiza las acciones necesarias para hacer trabajar al dispositivo.
Entendiendo el código fuente del firmware
En el archivo zip del dispositivo HID genérico del PIC18F incluido con este artículo encontrarás
un firmware completo y listo para usar para el PIC18F4550. Simplemente descomprime el
archivo en el directorio de tu proyecto favorito de MPLAB y después usa MPLAB para abrir el
proyecto. He separado los archivos de código fuente y archivos de encabezado en código que
deberías mirar y, a continuación, las partes más genéricas de la pila de Microchip (guardadas
en el navegador del proyecto bajo subdirecciones en la ‘pila USB’) Los archivos en los
directorios de la ‘pila USB’ son interesantes, pero para proseguir rápidamente no deberías
preocuparte por adentrarte tanto en el código hasta que te familiarices con los niveles
avanzados.
Ahora que los VIP/PID y el resto de información de enumeración esta lista deberías empezar
realizando una compilación de todo el proyecto, y después descarga el firmware resultante a
tu PIC18F. Por supuesto que necesitaras un entorno de compilación nimio para que esto
trabaje, aunque hay muchísimas fuentes vía Google si estas teniendo problemas con tu
entorno. Intenta algunos ejemplos simples para asegurarte de que todo está bien antes de
recargar el proyecto e intentarlo de nuevo.
El firmware provee 3 comandos:
0x80 – Intercambia el estado del LED
0x81 – Lee el estado del pulsador
0x82 – Lee el estado de LED
El código que ejecuta estos comandos está localizado en el archivo fuente main.c en la función
ProcessIO(). Esta función es responsable de determinar el comando requerido y después
enviar y recibir datos según corresponda. Esto es muy sencillo ya que la pila USB se ocupa de
toda la complejidad subyacente; dale un vistazo al código fuente y te darás cuenta de lo simple

26. que es. La única revisión extra realizada por esta función es para ver si el dispositivo esta en
‘estado configurado’; esto significa que el dispositivo está conectado al anfitrión y la
enumeración ha sido exitosa.
La función principal simplemente llama a la pila USB para realizar cualquier tarea de bajo nivel
del dispositivo y luego la función ProcessIO una y otra vez. Es posible hacer esto usando
interrupciones en lugar de un lazo, sin embargo en este firmware lo he conservado lo más
simple posible.
Para entender un poco más acerca del proceso de enumeración revisa el archivo
usb_descriptors.c que contiene la información que pasada al anfitrión cuando el dispositivo es
conectado por primera vez. En la fuente encontraras la información VID y PID para este
dispositivo así como también una serie de descriptores de configuración que explican al
anfitrión que tipo de interfaces tiene el dispositivo y las capacidades de las mismas. Los
‘endpoints’ son conectores para los conductos explicados anteriormente. Hay también algunos
strings que describen al fabricante y al producto tesxtualmente. Windows usualmente usa
estos strings cuando nombra dispositivos USB.
Entender el proceso de enumeración y los formatos del descriptor es algo complejo y está
cubierto por las varias especificaciones USB así como también en un gran libro de Jan Axelson
llamado 'USB Complete - Everything you need to develop custom USB peripherals' (ISBN 978-
1931448086). Si estás disfrutando este artículo y quieres entrar más de lleno en el tema USB,
recomiendo mucho obtener una copia de este libro que realmente me ayudo cuando yo
estaba aprendiendo.
Más allá de todo el firmware es bastante simple, todo lo que necesitas para comenzar a
comunicarte dese y hacia el anfitrión está incluido. Obviamente puedes hacer esto tan
complicado como gustes, pero para los propósitos de este artículo (encaminarte en el asunto
USB) hay muchísimo con que experimentar.
Conectando el dispositivo
Una vez que has seguido los pasos indicados arriba y has descargado el firmware al tu
dispositivo USB estás listo para conectarlo a tu PC. Ya que estamos usando los manejadores
USB del HID genérico, no hay nada que instalar en la PC antes de conectar. Simplemente
conecta el cable USB en tu dispositivo y luego conecta el otro extremo del cable USB den tu PC.
Windows 7 debería detectar un nuevo dispositivo y mostrar el usual mensaje ‘instalando
dispositivo’. Después de unos pocos segundos deberías ver la ventana de dialogo:

27. Si después navegas hacia tu menú de inicio y seleccionas ‘dispositivos e impresoras’ (si tienes
una versión antigua de Windows necesitas buscar en algún otro lado del panel de control, pero
el resultado es exactamente el mismo. Todas estas ilustraciones son de Windows 7) verás el
dispositivo mostrado en la pantalla. Deberías ver algo así como la siguiente ventana:
¡Eso es todo, tu primer dispositivo USB está enumerado y listo para usarse! Ahora podemos
movernos hacia el lado de la programación del anfitrión y buscar cómo te puedes comunicar
con tu dispositivo usando Microsoft Visual C++ 2008. Nota: El estado del LED por defecto es
encendido, este debería encenderse un instante después de conectar el dispositivo.
Software Anfitrión
Por favor note que: software actualizado para este proyecto está ahora disponible desde la
página de software libre de la clase de Visual C++ para comunicación con HID de USB
genéricos.
El software del anfitrión es bastante sencillo y básicamente consiste en 3 partes todas ellas
contenidas en el archivo Form1.h:
Monitorear el dispositivo USB para asegurar que está conectado (y, deshabilitar la
entrada del usuario y la comunicación del dispositivo si no lo está)
Mostrar y procesar la forma de la interfaz del usuario para permitir al usuario
interactuar con la aplicación
Comunicarse con el dispositivo USB y actualizar el estatus del dispositivo
He basado el software anfitrión en el software PnP del HID genérico de Microchip que viene
con la pila USB. De cualquier forma, así como para el firmware, he tratado de hacerlo un poco
más fácil de entender.
Para correr el software anfitrión descomprime el archivo zip de Visual Studio 2008 express y
navega hacia el directorio ‘Release’, después haz doble clic en el archivo ‘WFF Generic HID
Demo.exe’. Entonces te debería aparecer el siguiente dialogo:

28. Para probar el dispositivo simplemente desconecta el cable ESB de tu PC. El dialogo debería
cambiar a lo siguiente:
Ahora conecta el dispositivo USB, espera hasta que la ventana de dialogo se actualice (y
muestre dispositivo conectado), ahora intenta hacer clic en el botón ‘Toggle Led’. Deberías ver
entonces el LED en la protoboard prendiéndose y apangándose…. ¿Chévere no?
Ahora asegúrate que la etiqueta de estado del LED en la ventana coincida con el estado actual
del LED. Este es el comando 0x82 del firmware en acción. Finalmente intenta presionar el
pulsador en la protoboard, entonces debería cambiar el estado de la etiqueta ‘push button’ en
concordancia con el pulsador.
Felicitaciones, eres ahora el orgulloso dueño de primer dispositivo USB hecho por ti mismo!
He incluido el código fuente completo en el archivo zip Visual Studio, por lo cual podrás ver el
proyecto en Visual Studio para tener una mejor idea de su funcionamiento.
¿Y ahora qué?
La interfaz HID genérica USB es uno de los tantos tipos de interfaces disponibles en el estándar
USB (aunque es posiblemente el más útil para los programadores de PIC) Usando exactamente
las mismas técnicas mostradas en este articulo puedes construir registros de datos, interfaces
robóticas, hardware de interfaz personalizada, etc, etc. La lista es interminable.
Por fortuna este artículo te ha dado un vistazo de lo que es posible, para tus próximos pasos
recomiendo que revises la pila USB de Microchip y algunos de los grandes libros de
programación de PIC, interfaces USB y programación en Visual C++.

29. Por otra parte, si te gustaría seguir experimentando pero quisieras un ambiente de referencia
más potente por favor revisa mi tablero de desarrollo PIC USB que te permite fácilmente
experimentar con muchos más diseños e interfaces USB.
Tablero de desarrollo PIC USB
De WFFwikki
Ya que quería hacer algunos trabajos de desarrollo USB con la placa del PIC18F4550 y del
PIC18F2550 (para proyectos como mi C64 VICE fornt-end y un adaptador para un joystick
Atari) necesitaba una placa de referencia USB para desarrollar el software. Inicialmente llevé la
pila USB de Microchip al Hi-Tech C18 pro con la ayuda de Richard Stagg.
En este artículo te mostraré como hacer tu propia placa de desarrollo USB que es compatible
con la PICDEM USB FS de Microchip, pero construirla tu mismo es una opción mucho más
barata.
Con esta placa puedes compilar y cargar los ejemplos de la pila USB de Microchip directamente
sin alterar el código. Tú simplemente necesitas compilar los proyectos de la PICDEM FS USB
que están incluidos con los ejemplos de la pila.
Construcción de la placa PIC DEM FS USB
El esquemático del circuito para la placa original está disponible en internet en la página de
Microchip, las publicaron como parte de un manual de usuario para la placa. Yo usé la

30. ubicación de los pines para el micro controlador PIC, pero simplifique el diseño para hacer su
construcción más fácil y barata.
Primeramente simplifique la regulación de poder y removí el puerto serial físico y el chip
manejador serial en línea.
Aquí está el circuito esquemático para la placa:
Como puedes ver en el diagrama todos los periféricos montados en la placa están conectados
a ‘jumpers’ físicos permitiéndoles ser deshabilitados. La razón para esto es que intenté poner
conectores SIL de 20 pines en cada lado del procesador permitiéndote conectar fácilmente la
placa a la protoboard. Esto permite una creación de prototipos USB más rápida ( lo que hace a
esta placa mucho más útil que la versión original de Microchip).
También se puede seleccionar entre la alimentación desde el bus o alimentación propia
usando un jumper. La placa tiene una protección de polarización y un regulador de 5V.
También diodos de barrera protegen el puerto USB de un regreso de corriente no deseado
(para hacerlo más seguro para tu PC)
Y como quería ser capaz de hacer la placa yo mismo necesité diseñar una baquelita de una sola
cara que pueda ser fácilmente grabada. Yo también quise dejar espacio para unas ‘patitas’ en
la baquelita, para que se pueda usar sin una caja protectora (lo que haría difícil el acceso a los
conectores SIL)
Aquí está la ilustración del diseño resultante de la baquelita:

31. Adición de un puerto físico RS232
Como una opción conectable para esta placa también puedes construir un adaptador RS232
que simplemente se inserta en los conectores SIL del lado derecho del procesador. Ya que el
UART Tx/Rx y las líneas de poder están disponibles, la placa es un simple chip MAX 232 con 4
capacitores de 1uF y uno de 10uF.
Aquí está una figura de la placa RS232 conectada a la mini placa PICDEM FS USB:

32. Como el circuito era tan simple no necesité hacer un esquemático, pero aquí está la ilustración
del diseño resultante de la baquelita. (Los valores de los componentes están marcados en el
diseño)

34. Caso PC USB LCD
Contenidos
Introducción
Hardware
Firmware
Software anfitrión de Windows
Montado de la LCD
Archivos para descargar
Introducción
Para la primera versión de mi framework en software libre para dispositivos HID USB genéricos
basados en el PIC18F y Windows, hice un ejemplo rápido de cómo usar la librería empleando
una interfaz para una LCD. Ahora que he completado la segunda versión de la librería pienso
que sería divertido mejorar el proyecto de la LCD a un modulo LCD independiente que cabría
en el espacio de 5.25 pulgadas de la PC.
Este proyecto explica cómo puede ser configurado el módulo LCD con el firmware del PIC y el
software anfitrión de Windows escrito en base a la librería HID USB genérica en C#. Para el
código anfitrión de ejemplo la utilización de la CPU y la memoria es mostrada en la LCD junto
con el tiempo actual. El hardware es del mismo tamaño que la misma LCD y puede ser
montado directamente detrás del modulo LCD ATM1602B 2*16 para proveer una LCD
compacta alimentada por el anfitrión, para muchas aplicaciones.

35. Hardware
El diseño del hardware es extremadamente simple y puede ser construido usando el diseño de
la baquelita provisto o en una placa perforada. El circuito consiste en un PIC18F2550 con un
oscilador de 20MHz y los componentes requeridos para la pantalla LCD y el USB.
La ilustración del diseño de la baquelita necesaria para construir la placa de control esta
disponible en los archivos zip al final de este articulo.
Aquí está el esquemático del circuito para la placa de control de la LCD:

36. La placa del circuito usa principalmente dispositivos de montaje superficial (claro que podrías
usar dispositivos DIL en el mismo espacio pero lo otro ahorra tiempo ya que no tienes que
taladrar los orificios) También la conexión USB es provista por un conector mini-USB de
montaje superficial lo que hace a todo el modulo muy delgado y ahorra espacio. Solo se usa
baquelita de una sola capa (y no hay puentes) Aquí les pongo una foto de la placa completada:

37. Como puedes ver en la foto, el display está conectado a la placa de control usando un alambre
de una sola tira. Simplemente sueldas el cable a la placa de control y después montas la LCD
sobre ella usando tornillos (yo use algunas tuercas M6 como espaciadores) y luego sueldas los
alambres a la LCD.
El potenciómetro para controlar el contraste está montado bajo la placa para permitir una fácil
ajuste después de que la LCD ha sido montada. El diodo puede ser soldado en la parte superior
de la placa; decidí ponerlo en la parte superior para que el modulo terminado se vea más
elegante.
Firmware
El firmware está basado en el software disponible de mi framework en software libre para
dispositivos HID USB genéricos basados en los PIC18F y Windows (Versión 2_0_0_0) e
implementa varios comandos USB permitiendo al anfitrión limpiar la pantalla, mover el cursor,
texto de salida y escritura de un bit ‘puro’ en la LCD. El comando del bit puro permite al
anfitrión enviar comandos personalizados a la LCD para que puedas implementar cosas como
caracteres especiales de la LCD sin tener que alterar el firmware del PIC (si es que tienes algo
de conocimiento acerca de la comunicación que es posible con la ATM1602B) a parte de este
no hay razón para que puedas usar el mismo firmware para comunicarte con versiones más
grandes como la pantalla de 4*16. Yo escogí la de 2*16 porque puede encajar en uno solo de
los espacios de la carcasa de la PC.
Software anfitrión de Windows
El software anfitrión está escrito usando Visual Studio C# 2010 y ha sido probado con Windows
7 (sin embargo debería trabajar bien con vista y XP)

38. El software anfitrión implementa los contadores de rendimiento y pasa las cadenas apropiadas
de texto al firmware del PIC. El mecanismo es muy simple y debe ser extremadamente flexible
si deseas implementar tu propia información en la pantalla.
Adicional a esto, la versión 2 de la librería HID USB implementa una secuencia de registro de
depuración de ejemplo, desde el firmware USB hasta el anfitrión lo que es demostrado en el
código anfitrión.
Aquí está una foto del GUI:
Como puedes ver en la foto están ambos monitores de la aplicación, el del uso de la CPU y uso
de la memoria empleando los contadores de rendimiento incluidos en Windows. Además hay
un cuadro de texto que muestra en tiempo real la información del proceso de depuración que
viene desde el firmware del USB (que es extremadamente útil para diseño y depuración de
firmware más complejo)
Montaje de la LCD
Junto con el diseño de la baquelita y el esquemático hay una plantilla para cortar la cubierta en
el espacio estándar de 5,25 pulgadas de la carcasa de la PC y puedas instalarlo. Aquí hay una
foto de la pantalla montada en mi PC: