Conecta tus proyectos al puerto USB

ELECTRÓNICA / HARDWARE

etiquetas: hardware, tutoriales

HTTP://WWW.NEOTEO.COM/CONECTA-TUS-PROYECTOS-AL-PUERTO-USB/

El puerto serie y el puerto paralelo ya quedaron atrás. Con la superpoblación de ordenadores portátiles, el espacio de acción de los enlaces por puerto serie comienza a reducirse. Lo mismo ocurre con las conexiones por puerto paralelo. Ya ni siquiera los ordenadores de mesa traen un puerto de este tipo utilizado antiguamente para las impresoras. Hoy todo trae conectividad USB. El mouse, el teclado, la impresora multifunción, el teléfono móvil, el pen drive, el disco duro portátil, el Blu-ray Player, el módem, el router, todo se conecta a través de un puerto USB. En este artículo veremos la manera más sencilla de realizar un circuito con un microcontrolador, encender y apagar un LED desde nuestro ordenador portátil, en una aplicación hecha por ti mismo a través del puerto USB. Conéctate.

Las antiguas conexiones de puerto serie o paralelo permitían velocidades de transferencia de datos de hasta 115 kbps., mientras que una conexión USB 1.1 alcanza los 1.2 Mbps. y una USB 2.0 logra 480 Mbps. Sin contar con la sencillez que supone utilizar un único tipo de conector para todos los periféricos necesarios, la posibilidad de conectar y desconectar sin tener que reiniciar el ordenador a cada cambio de equipo es una ventaja que ha llevado al trabajo móvil hasta su máximo potencial. Disponer de instrumentos de campo o de equipos portátiles que permitan monitorear el clima en el lugar de los hechos es, gracias al ordenador móvil, un avance que complementado con la practicidad de los puertos USB se ha ganado la preferencia de la mayoría de los usuarios. Es hora entonces que comiences a transitar el camino de las aplicaciones basadas en conectividad USB.

El programa Proton Development Suite posee entre sus herramientas más importantes la que conocemos como EasyHID USB Wizard. Esta prestación se encarga de manera automática de generar los programas necesarios para poder utilizar los microcontroladores de la línea PIC 18F2455, 18F2550, 18F4455 y 18F4550, que será el que utilizaremos para nuestro ejemplo. El código para el PIC, lo genera tanto para Pic Basic Pro como para Proton, mientras que para el ordenador, se encarga de generar el código en Borland Delphi, Visual C++ y Visual Basic. Por supuesto que todos estos parámetros se pueden seleccionar mientras se avanza en la preparación del software. En apenas muy pocos pasos, ya podemos tener una aplicación HID USB lista para comenzar a cargarla de código. Tanto desde elMicrocode Studio Plus como desde Proton Development Suite, al iniciar la aplicación, nos encontraremos con pantallas a las que les iremos cargando los datos que el sistema nos vaya pidiendo.

En la primer pantalla puedes cargar el nombre del producto que estás desarrollando

No cambies los números de la segunda pantalla, utiliza los que aparecen de muestra Como a este sistema lo estamos preparando para manejar y operar el receptor multibanda NeoTeo, los datos que le agregaremos estarán en coincidencia con esta aplicación. De allí surgen los nombres que ves en las imágenes. Aquí, en esta pequeña guía, sólo te daremos un ejemplo práctico para que te vayas familiarizando con el sistema y sus pequeños secretos para lograr una conexión exitosa. Las pantallas que comiencen a aparecer son las que ves en imagen; tú les colocarás el nombre de la aplicación que más desees. Lo que NO debes cambiar en la segunda pantalla son los números deVendor ID y Product ID. Estos números son asignados por el organismo que regula la autenticidad de los productos USB donde puedes comprar por U$S 4mil una membresía anual con números otorgados exclusivamente a tu desarrollo. Por lo tanto, nuestro consejo es que utilices los números de muestra que provee la aplicación para los proyectos domésticos que realices.

En las primeras aplicaciones te recomendamos utilizar los parámetros preestablecidos

Pantalla final de selección de PIC y destino de carpetas Luego avanzas a la pantalla que te permite ajustar los valores de tiempo en que el ordenador controlará la existencia de la conexión USB (Polling). Este punto es muy importante porque el ordenador interrogará por el enlace y, si no lo encuentra (Atached), te expulsará la conexión y quedarás inactivo (Dettached). Esta acción de comprobación puede ser realizada en forma constante mediante una interrupción con un Timer (TMR1) del microcontrolador o a través de un programa organizado y estructurado de manera apropiada dentro del PIC. El tamaño de los Buffers de entrada y salida quedará en 8 bytes. Hasta que no logres tener buena práctica en la realización de esta clase de aplicaciones, te recomendamos utilizar siempre los valores indicados por default. Son más que suficientes para las aplicaciones a nivel inicial como la que haremos en esta entrega.

En la pantalla siguiente puedes seleccionar el lugar donde guardarás los archivos que se cargarán en dos carpetas individuales: una para el programa base del microcontrolador y otra para el software de aplicación que utilizarás en el ordenador. Siempre trata de buscar una locación de nombre corto que se encuentre cercana al árbol raíz del disco duro porque con nombres extensos el compilador puede generar errores al armar los programas. Debajo de la selección del PIC, tienes un casillero para habilitar la generación automática de un programa manejado con interrupciones que mantengan “viva” la conexión USB durante todo el tiempo que estés conectado. Como puedes ver, no tendrás que preocuparte por realizar un programa con los tiempos bien ajustados. Listo, eso es todo. A la siguiente pantalla, el sistema comenzará a organizar y armar el código; tú sólo debes esperar a que termine su trabajo sin errores.

Una vez que hayas realizado estos cinco sencillos pasos, tendrás los programas listos para comenzar a trabajar. Lo primero que debes hacer es definir el tipo de hardware que utilizarás alrededor del microcontrolador seleccionado y en función de él organizar todo el resto de la aplicación. Es decir, en este caso, sólo colocaremos un pulsador y un LED como componentes adicionales y un LCD de 16 caracteres y dos líneas. Además de definir el hardware que utilizarás, también aquí se define la idea básica del software que crearás para utilizar y controlar tu aplicación desde el ordenador. Para nosotros es importante poder controlar de manera autónoma el dispositivo que hemos ideado con el PIC y poder hacerlo a través del ordenador, si es que lo deseamos. En este último caso, al conectarlo al ordenador portátil, los mandos en el hardware dejarán de funcionar y el LCD nos indicará que estamos conectados al ordenador y podremos así operar el hardware directamente a través del puerto USB.

El circuito En el circuito podemos ver claramente definidos los sectores más importantes del desarrollo: el PIC 18F4550, al centro de la imagen, el display LCD 16X2, el conector USB, el conector ICSP para poder programar el PIC en forma serial y sin necesidad de extraerlo del proyecto, el cristal de 20Mhz, el pulsador, el LED que elegimos de color verde y, por último, el ingreso de la señal de 5 volts provenientes desde el ordenador a través del conector USB. Muchos desarrollos basan su alimentación en esta tensión que extraen desde el conector. Un ejemplo de esto es el mecanismo de la carga de baterías de muchos MPX (MP3, MP4, MP5, etc.) o de algún GPS. Los quemadores de PICs suelen extraer alimentación desde este puerto y muchas otras aplicaciones también lo hacen. Debes tener en cuenta que esta salida de tensión tiene un máximo posible de 500 miliamperes; si te excedes de este consumo, puedes dañar la salida del puerto. En muchas oportunidades bastará con reponer un resistor fusible en el motherboard, pero te aconsejamos no jugar con esta suerte.

Además, debes recordar que en la tercera pantalla del EasyHID USB Wizard, por default, esta corrientese limita a 50 mA. Este pequeño valor será suficiente para extraer de allí la información que le daremos al programa del PIC para indicarle que nos estamos conectando al ordenador. Pero antes de escribir siquiera una línea de código de programa, debemos grabar el PIC con el firmware que nos generó elEasyHID (previo compilarlo y obtener el .HEX). Luego de grabarlo, procederemos a conectarlo al ordenador para que éste lo reconozca como un nuevo dispositivo HID (Human Interface Device) y para que estemos seguros de que no hayan existido errores en la generación del código, al menos, en el correspondiente al microcontrolador.

Las imágenes aparecerán como al instalar cualquier dispositivo USB

Por último, verificas que el dispositivo funcione correctamente El nombre del producto seleccionado en la primera imagen deberá aparecer al conectar el dispositivo avisando que ha encontrado un nuevo hardware. Luego de esto veremos el mensaje que indica que se trata de un dispositivo de interfaz humana USB. Si todo marcha correcto, finalizará la instalación indicando que el dispositivo se ha instalado con éxito y que funciona correctamente. Si todo es así, dentro de Configuración > Panel de Control > Sistema > Hardware > Administrador de Dispositivos, encontrarás una imagen como la que puedes ver a la derecha. Esto es válido para el SO XP.Importante: No intentes ponerte a jugar queriendo insertar y extraer varias veces el conector del ordenador ya que el dispositivo creado se identificará una vez y, para que el ordenador vuelva a reconocerlo, debes reiniciarlo o apagarlo y volver a conectarlo (a tu proyecto). Esto es debido a la estructura del programa que ya veremos cómo funciona y qué parámetros podremos aprender a dominar y manejar a gusto.

El programa dentro del PIC, en el código que genera EasyHID, tiene una lógica muy sencilla pero a la vez muy rígida y al principio complicada de entender. Pero una vez que comprendes el mecanismo de trabajo, tus desarrollos se harán realidad en pocos minutos. La rutina se basa en interrogar, en primera instancia, si el dispositivo está conectado al puerto USB. Si no lo está, queda en un bucle infinito del que no sale hasta detectar la conexión o hasta que se reinicia el PIC. Esto sucede en la última parte donde vemos la etiqueta AttachToUSB. Como puedes ver, allí se repite en un lazo infinito hasta que (UNTIL) el registro interno del PIC detecte la conexión al puerto USB. Para ser claro: si antes de esto pensabas poner un destellador, un blinker, un reproductor de MP3 o lo que se te ocurra dentro de tu PIC, debes saber que hasta que no lo conectes a un puerto USB, el código del programa quedará muerto en ese lazo.

Es por esto que con el simple agregado de una línea de código puedes esquivar esta atadura y salir del lazo. Para esto vamos a utilizar la tensión de entrada de 5Volts que trae el puerto USB, ingresando a través de R6 y R5 a RC0. Si RC0 no detecta tensión de entrada, deberá sacarnos del bucle y llevarnos hacia otro lugar del programa “que agregaremos nosotros” donde no sea necesario estar conectado a un puerto USB y donde podamos realizar cualquier función tal como hacemos con cualquier otro microcontrolador. Dentro de ese lazo cerrado que utilizaremos para realizar una actividad autónoma, podremos escribir/leer una memoria EEPROM, interpretar un teclado, manejar un display LCD y cualquier otra cosa a la que ya estemos acostumbrados.

De esta forma, cuando encendamos nuestro dispositivo, apenas caiga en la instrucción de verificar la inserción en el puerto USB, será enviado “fuera” de ese lazo cerrado y pasará a funcionar de manera autónoma. Nosotros hemos decidido mostrar este funcionamiento en el display LCD con el mensaje alusivo correspondiente. Es en esta sección del programa creada por nosotros mismos en la que delinearemos el funcionamiento autónomo del desarrollo. Aquí decidiremos qué hará por sí sola nuestra creación. Para el caso de muestra que nos convoca, sólo encenderemos y apagaremos un LED con un pulsador. Pero tú puedes expandir la aplicación a un sistema de adquisición de datos para aplicaciones de campo que guarde en una tarjeta SD o en memorias EEPROM de gran capacidad datos que después pueden ser analizados en laboratorio. O lo que sea. Nosotros, por ejemplo, utilizaremos esta base para controlar nuestro receptor de VHF-UHF que venimos entregando por secciones cada sábado. También puedes construir un Holter Cardíaco para monitorear pacientes con insuficienciacardiovascular. O lo que tu imaginación sea capaz de lograr.

La condición de funcionamiento de este sistema “dual” se basa en la colocación – en la mayor parte que sea posible – de la rutina que detecte que el USB se ha conectado, es decir, que RC0 se vuelve igual a uno. Aquí ocurrirán dos cosas: por un lado, el programa puede seguir siendo operado desde su teclado nativo (en nuestro ejemplo, un solo botón) o no. En nuestro ejemplo, el botón deja de funcionar; pasa a interesarnos el trabajo a través del ordenador. Y por el otro lado, ya debes ir preparando algunas líneas de programa para el software que hayas seleccionado. Nosotros hemos optado por una aplicación en VB6 que nos muestra varias cosas: por ejemplo, que el sistema se conecta y se desconecta del puerto de manera efectiva y sin inconvenientes (funcionamiento óptimo de la instrucción de PORTC.0). Luego vemos un botón que se encargará de prender y apagar el LED en el dispositivo y un círculo de color que emula esta acción, tal como sucede en el equipo mientras es controlado en forma remota. Por último, un pequeño texto que cambia de “Encendido” a “Apagado” acompañando la acción del LED.

Tal como se podía ver en el circuito, hemos conectado al LED en PORTC.1 y al botón en PORTC.2. La aplicación es sencilla pero intenta ser didáctica para que comiences a hacer tus primeros pasos en el manejo del puerto USB. Debes tener conciencia que dominar este puerto es la llave de salida para que tus diseños puedan tener aplicaciones exitosas, efectivas y prácticas, sobre todo, en el mundo de los ordenadores portátiles.

Volviendo a la programación del microcontrolador, que es la más compleja, debemos seguir aclarando puntos difíciles dentro de la rutina del servicio USB. Entre las cuestiones que suelen traernos dolores de cabeza están los “buffers” y su ubicación o numeración dentro del PIC respecto a la numeración que llevarán en el software dentro del ordenador. En Visual Basic, la posición 0 no se puede emplear ya que se la utiliza para el reporte del dispositivo, tal como lo expresa el código generado: … first byte is the report ID, e.g. BufferIn(0) the other bytes are the data from the microcontrolller… Por lo tanto, la enumeración debe iniciarse desde el 1 hasta el 8 y esto corresponderá dentro del PIC en posiciones de Buffer que irán del 0 al 7. Es decir, que lo que en el PIC sea USBBuffer[2] y sea un dato para transmitir, en VB6 será BufferIn(3). Compara entre los listados de los programas que te entregamos, observa este detalle y expándelo utilizando otros botones, otros LEDs, en fin, otros recursos para ampliar las prestaciones del dispositivo remoto desde el ordenador.

Observa que además tienes dos lazos cerrados que si el programa del PIC cae allí dentro se “cuelga” y no sale más hasta que lo reinicies. Estos puntos son los momentos en los que entrega los datos al bus desde el buffer (DoUSBOut) o aquellas instancias en las que solicita los datos cargados dentro del buffer (DoUSBIn). Si en cualquiera de los casos no encuentra valores, se quedará allí esperando que lleguen y tú debes advertirlo rápidamente para sacarlo de esa situación. Por eso te entregamos los programas completos. Para que puedas experimentar a partir de un modelo que sabemos que funciona. Ahora depende de tu imaginación y tu creación. Esto recién comienza, amigo. Proton eEasyHID lograron hacerlo muy fácil, ahora la conectividad USB está en tus manos.

Download :Soft para el PIC y el Ordenador

'****************************************************************

'* Name : USBNeoTeo.BAS <NOMBRE DEL DESARROLLO> *

'* Author : Mario G. Sacco *

'* Notice : Copyright (c) 2009 *

'* : All Rights Reserved *

'* Date : 13/11/2009 *

'* Version : 1.0 *

'* Notes : *

'* : *

'****************************************************************

'SELECCIONAMOS EL PIC Y LA FRECUENCIA DE TRABAJO (48Mhz PARA USB)

Device = 18F4550

Xtal = 48

'ESTA FILA LA GENERA EL MISMO "EASYHID USB WIZARD" Y LA COLOCA

'JUNTO A ESTE ARCHIVO .BAS DONDE TRABAJAREMOS LA APLICACIÓN

'(EN LA MISMA CARPETA)

USB_Descriptor = "Receptor2DESC.inc"

'SETEO EL LCD 16X2 PARA 4 CABLES

LCD_DTPin = PORTB.4

LCD_RSPin = PORTB.3

LCD_ENPin = PORTB.2

LCD_Interface = 4

LCD_Lines = 2

LCD_Type = 0

'LOS TAMAÑOS DEL BUFFER USB

Symbol USBBufferSizeMax = 8

Symbol USBBufferSizeTX = 8

Symbol USBBufferSizeRX = 8

Dim USBBuffer[USBBufferSizeMax] As Byte

'VARIABLES AGREGADAS POR MÍ PARA ESTE EJEMPLO

Symbol LED = PORTC.1 'LED SE VÁ A LLAMAR LA SALIDA DE PORTC.1

Dim LEDUSB As Bit 'ESTADO DEL LED (APAGADO O ENCENDIDO)

Dim A As Word 'VARIABLE MULTIFUNCIÓN

Dim B As Bit 'VARIABLE BIESTADO EN LA QUE RECIBO EL BOTÓN

'PARA PRENDER Y APAGAR EL LED

'REGISTROS Y BANDERAS

Dim PP0 As Byte System ' REGISTRO DENTRO DEL PIC USBPOLL STATUS

Symbol CARRY_FLAG = STATUS.0 ' EN ESTADO ALTO SI EL PIC NO TIENE

' EL CONTROL SOBRE EL BUFFER

Symbol ATTACHED_STATE = 6 ' SI USB ESTÁ CONECTADO

Cls 'LIMPIO DISPLAY AL INICIAR

Clear 'LIMPIO LA RAM AL INICIAR

A= 0:B = 0 'PONGO LAS VARIABLES A CERO

GoSub AttachToUSB 'ME VOY A VER SI ESTÀ CONECTADO

'AL INICIAR EL PROGRAMA

' *****************************************************************

' *****************************************************************

' * LAZO PRINCIPAL DEL PROGRAMA MIENTRAS SE ESTÁ CONECTADO A USB; *

' * RECUERDA QUE DEBES MANTENER LA CONEXIÓN "VIVA" CON LLAMADOS *

' * CONSTANTES A LAS RUTINAS USBPoll, USBIn or USBOut CADA ALGUNOS*

' * MILISEGUNDOS O MÁS *

' *****************************************************************

' *****************************************************************

ProgramLoop:

Print At 1,1," Conectado " 'ESCRIBO EN EL LCD QUE ENTRAMOS

Print At 2,1," al bus USB " 'EN EL LAZO DE CONEXIÓN USB

USBBuffer[0] = 0 'EL PRIMER BYTE ES DE REPORTE DE CONEXIÓN

USBBuffer[1] = LED 'EL SEGUNDO BYTE SERÁ EL ESTADO DEL LED

'Y HARÁ CAMBIAR EN LA APLICACIÓN EN VB6

'EL COLOR DEL SHAPE DEL LED DE ROJO A VERDE

'EL DE CONEXIÓN, CAMBIA AL DETECTAR

'"PP0 = ATTACHED_STATE"

GoSub DoUSBOut 'TRANSMITO LO ALMACENADO EN EL BUFFER

DelayMS 1 'DOY UN TIEMPO DE DEMORA

GoSub DoUSBIn 'ME VOY A LEER EL BUFFER DE ENTRADA

B = USBBuffer[2] 'UTILIZO OTRO REGISTRO DEL BUFFER

'(TENGO 8 POSIBLES) Y AL VALOR OBTENIDO LO

'CARGO EN LA VARIABLE "B"

If B = 0 Then 'SI NO HAY DATO INGRESADO

GoTo ProgramLoop 'CIERRO EL LAZO DE ESPERA

Else 'SI HAY DATO EN EL LUGAR CORRESPONDIENTE

Toggle LED 'ES PORQUE SE PULSÓ EL BOTÓN EN PANTALLA

End If 'ENTONCES CAMBIO EL ESTADO DEL LED

GoTo ProgramLoop 'CIERRO EL LAZO DESPUÉS DE TODO EL TRABAJO

' ************************************************************

' * RUTINA DE RECEPCIÓN DE DATOS *

' ************************************************************

DoUSBIn:

If PORTC.0 = 0 Then GoTo FUERA 'CONTROLO SI SE DESCONECTÓ DE USB

USBIn 1, USBBuffer, USBBufferSizeRX, DoUSBIn

Return

' ************************************************************

' * RUTINA DE TRANSMISIÓN DE DATOS *

' ************************************************************

DoUSBOut:

If PORTC.0 = 0 Then GoTo FUERA 'CONTROLO SI SE DESCONECTÓ DE USB

USBOut 1, USBBuffer, USBBufferSizeTX, DoUSBOut

Return

' ************************************************************

' * ESPERA HASTA QUE EL USB SE CONECTE *

' ************************************************************

AttachToUSB:

If PORTC.0 = 0 Then GoTo FUERA 'CONTROLO SI SE DESCONECTÓ DE USB

Repeat

USBPoll

Until PP0 = ATTACHED_STATE

Return

'******************************************************************************

'******************************************************************************

'** PROGRAMA QUE SE DESARROLLA DE FORMA AUTÓNOMA **

'******************************************************************************

'******************************************************************************

FUERA: 'RUTINA FUERA DEL CONTACTO USB

Cls 'LIMPIO LA PANTALLA AL INICIAR

FUERA2: 'COMIENZO LAZO CERRADO HASTA

'VOLVER A CONECTAR A USB

Print At 1,1," AUTONOMO " 'PUEDO IMPRIMIR

Print At 2,1," SIN USB " 'UN TEXTO EJEMPLO

If LED = 1 Then 'CONTROLAR EL ESTADO DE UNA VARIABLE

Print At 1,14,"LED" 'ESCRIBIR SEGÚN EL ESTADO

Print At 2,14,"ON " 'DE DICHA VARIABLE

Else 'SINO

Print At 1,14,"LED" 'ESCRIBIR OTRO TEXTO

Print At 2,14,"OFF"

EndIf 'FINALIZO LA RUTINA DE CONTROL

For A = 1 To 500 'VOY A CONTROLAR DURANTE EL TIEMPO

'QUE DETERMINE "A"

If PORTC.0 = 1 Then GoTo ProgramLoop 'CONTROLO SI SE CONECTÓ A USB

If PORTC.2 = 0 Then 'SI SE PULSA EL BOTÓN

DelayMS 400 '(DOY UN TIEMPO PARA ELLO)

Toggle LED 'CAMBIO EL ESTADO DEL LED

EndIf 'FINALIZA LA CONDICIÓN DE CONTROL DEL BOTÓN

DelayMS 1 'DURANTE ESTE TIEMPO EL LCD HABRÁ ESTADO

Next 'ENCENDIDO

Print At 1,1," " 'BORRO EL LCD

Print At 2,1," "

If LED = 1 Then 'INTERROGO EL ESTADO DEL LED

Print At 1,14,"LED" 'Y LO EXPONGO EN EL LCD

Print At 2,14,"ON "

Else

Print At 1,14,"LED"

Print At 2,14,"OFF"

EndIf

For A = 1 To 500 'VOY A CONTROLAR DURANTE EL TIEMPO

'QUE DETERMINE "A"

If PORTC.0 = 1 Then GoTo ProgramLoop 'CONTROLO SI SE CONECTÓ A USB

If PORTC.2 = 0 Then 'SI SE PULSA EL BOTÓN

DelayMS 400 '(DOY UN TIEMPO PARA ELLO)

Toggle LED 'CAMBIO EL ESTADO DEL LED

EndIf 'FINALIZA LA CONDICIÓN DE CONTROL DEL BOTÓN

DelayMS 1 'DURANTE ESTE TIEMPO EL LCD HABRÁ ESTADO

Next 'APAGADO

If PORTC.0 = 1 Then GoTo ProgramLoop 'CONTROLO SI SE CONECTÓ A USB

GoTo FUERA2 'CIERRO EL LAZO EJEMPLO DE ACTIVIDADES QUE

'PUEDE ESTENDERSE A LA CANTIDAD QUE NECESITEMOS

'DURANTE EL FUNCIONAMIENTO SIN CONEXIÓN USB

VISUAL

Attribute VB_Name = "HIDDLLInterface"

' this is the interface to the HID controller DLL - you should not

' normally need to change anything in this file.

'

' WinProc() calls your main form 'event' procedures - these are currently

' set to..

'

' MainForm.OnPlugged(ByVal pHandle as long)

' MainForm.OnUnplugged(ByVal pHandle as long)

' MainForm.OnChanged()

' MainForm.OnRead(ByVal pHandle as long)

Option Explicit

' HID interface API declarations...

Declare Function hidConnect Lib "mcHID.dll" Alias "Connect" (ByVal pHostWin As Long) As

Boolean

Declare Function hidDisconnect Lib "mcHID.dll" Alias "Disconnect" () As Boolean

Declare Function hidGetItem Lib "mcHID.dll" Alias "GetItem" (ByVal pIndex As Long) As

Long

Declare Function hidGetItemCount Lib "mcHID.dll" Alias "GetItemCount" () As Long

Declare Function hidRead Lib "mcHID.dll" Alias "Read" (ByVal pHandle As Long, ByRef pData

As Byte) As Boolean

Declare Function hidWrite Lib "mcHID.dll" Alias "Write" (ByVal pHandle As Long, ByRef

pData As Byte) As Boolean

Declare Function hidReadEx Lib "mcHID.dll" Alias "ReadEx" (ByVal pVendorID As Long, ByVal

pProductID As Long, ByRef pData As Byte) As Boolean

Declare Function hidWriteEx Lib "mcHID.dll" Alias "WriteEx" (ByVal pVendorID As Long,

ByVal pProductID As Long, ByRef pData As Byte) As Boolean

Declare Function hidGetHandle Lib "mcHID.dll" Alias "GetHandle" (ByVal pVendoID As Long,

ByVal pProductID As Long) As Long

Declare Function hidGetVendorID Lib "mcHID.dll" Alias "GetVendorID" (ByVal pHandle As

Long) As Long

Declare Function hidGetProductID Lib "mcHID.dll" Alias "GetProductID" (ByVal pHandle As

Long) As Long

Declare Function hidGetVersion Lib "mcHID.dll" Alias "GetVersion" (ByVal pHandle As Long)

As Long

Declare Function hidGetVendorName Lib "mcHID.dll" Alias "GetVendorName" (ByVal pHandle As

Long, ByVal pText As String, ByVal pLen As Long) As Long

Declare Function hidGetProductName Lib "mcHID.dll" Alias "GetProductName" (ByVal pHandle

As Long, ByVal pText As String, ByVal pLen As Long) As Long

Declare Function hidGetSerialNumber Lib "mcHID.dll" Alias "GetSerialNumber" (ByVal

pHandle As Long, ByVal pText As String, ByVal pLen As Long) As Long

Declare Function hidGetInputReportLength Lib "mcHID.dll" Alias "GetInputReportLength"

(ByVal pHandle As Long) As Long

Declare Function hidGetOutputReportLength Lib "mcHID.dll" Alias "GetOutputReportLength"

(ByVal pHandle As Long) As Long

Declare Sub hidSetReadNotify Lib "mcHID.dll" Alias "SetReadNotify" (ByVal pHandle As

Long, ByVal pValue As Boolean)

Declare Function hidIsReadNotifyEnabled Lib "mcHID.dll" Alias "IsReadNotifyEnabled"

(ByVal pHandle As Long) As Boolean

Declare Function hidIsAvailable Lib "mcHID.dll" Alias "IsAvailable" (ByVal pVendorID As

Long, ByVal pProductID As Long) As Boolean

' windows API declarations - used to set up messaging...

Private Declare Function CallWindowProc Lib "user32" Alias "CallWindowProcA" (ByVal

lpPrevWndFunc As Long, ByVal hwnd As Long, ByVal Msg As Long, ByVal wParam As Long, ByVal

lParam As Long) As Long

Private Declare Function SetWindowLong Lib "user32" Alias "SetWindowLongA" (ByVal hwnd As

Long, ByVal nIndex As Long, ByVal dwNewLong As Long) As Long

' windows API Constants

Private Const WM_APP = 32768

Private Const GWL_WNDPROC = -4

' HID message constants

Private Const WM_HID_EVENT = WM_APP + 200

Private Const NOTIFY_PLUGGED = 1

Private Const NOTIFY_UNPLUGGED = 2

Private Const NOTIFY_CHANGED = 3

Private Const NOTIFY_READ = 4

' local variables

Private FPrevWinProc As Long ' Handle to previous window procedure

Private FWinHandle As Long ' Handle to message window

' Set up a windows hook to receive notification

' messages from the HID controller DLL - then connect

' to the controller

Public Function ConnectToHID(ByVal pHostWin As Long) As Boolean

FWinHandle = pHostWin

ConnectToHID = hidConnect(FWinHandle)

FPrevWinProc = SetWindowLong(FWinHandle, GWL_WNDPROC, AddressOf WinProc)

End Function

' Unhook from the HID controller and disconnect...

Public Function DisconnectFromHID() As Boolean

DisconnectFromHID = hidDisconnect

SetWindowLong FWinHandle, GWL_WNDPROC, FPrevWinProc

End Function

' This is the procedure that intercepts the HID controller messages...

Private Function WinProc(ByVal pHWnd As Long, ByVal pMsg As Long, ByVal wParam As Long,

ByVal lParam As Long) As Long

If pMsg = WM_HID_EVENT Then

Select Case wParam

' HID device has been plugged message...

Case Is = NOTIFY_PLUGGED

MainForm.OnPlugged (lParam)

' HID device has been unplugged

Case Is = NOTIFY_UNPLUGGED

MainForm.OnUnplugged (lParam)

' controller has changed...

Case Is = NOTIFY_CHANGED

MainForm.OnChanged

' read event...

Case Is = NOTIFY_READ

MainForm.OnRead (lParam)

End Select

End If

' next...

WinProc = CallWindowProc(FPrevWinProc, pHWnd, pMsg, wParam, lParam)

End Function