Integración de PIC18F2455 Con LabVIEW 8.2 Con Mpusbapi

UNIVERSIDAD MODELO
ESCUELA DE INGENIERÍA
MAESTRÍA EN MECATRÓNICA
Integración de PIC18F2455 de Microchip™ con LabVIEW™ 8.2 de National

Instruments™ con MPUSBAPI.DLL
PRESENTAN:
ING. JULIO ALEJANDRO LUGO JIMÉNEZ ING. GABRIEL JESÚS POOL BALAM
PARA LA MATERIA:
SENSORES Y ACTUADORES
PROFESOR:
MC. PEDRO NAJERA GARCIA

MÉRIDA, YUCATÁN A 28 DE JUNIO DE 2008

RESUMEN comunicación, memoria, circuitos de apoyo

adicionales (ADC, oscilador interno, puertos,
El diseño de un sistema de monitoreo etc.). Dichos microcontroladores, requieren
de variables como presión, velocidad, de muy poco componentes de soporte
temperatura, etc., y/o acción de control externo para implementarse y sus
sobre el mundo físico requiere tecnologías se han perfeccionado, de tal
tradicionalmente de una tarjeta de manera, que casi no fallan. Algunos
adquisición de datos que por lo general es fabricantes tal como Microchip, se
limitada en hardware, orientada a la preocupan en desarrollar las herramientas
interacción y trabajo exclusivo con productos para su programación, tales como lenguajes
del fabricante; un software que administre de alto nivel para compilar el programa y
los datos en la PC para el monitoreo local y programadores económicos para descargar
remoto, control de decisiones, graficar, el programa en el chip. Debido a éstas
guardar datos en disco, etc. y un herramientas, éste chip se ha vuelto muy
conocimiento amplio sobre el software de popular al grado que se proponen como
desarrollo, sin contar la gran cantidad de materias a cursar en las escuelas.
tiempo a invertir en la implementación de la
solución más apropiada. Algunos fabricantes Por otro lado, ya no basta con tener un
ofrecen soluciones a medias: poderoso chip inteligente que funcione de manera
hardware con un software pobre que no autónoma, ahora se requiere que trabajen
cumple con nuestro requerimiento ó en conjunto con la PC para el monitoreo local
hardware básico al que se requieren agregar y remoto (internet o intranet), control de
módulos adicionales para adaptarlo a decisiones, graficar, guardar datos en disco,
nuestra necesidad y con software muy etc. Esto se puede lograr con el desarrollo de
completo. En éste desarrollo se fusiona lo un software como Visual Basic, Visual C, C++,
mejor de ambos mundos: Un ó cualquier otro paquete de preferencia
microcontrolador con puerto USB de gráfico para hacer más fácil la interfaz de
Microchip y un software de desarrollo usuario. Desafortunadamente, el tiempo
LabVIEW de Nacional Instruments. para aprender y dominar estos paquetes es
muy largo. Por lo que, National Instruments
INTRODUCCIÓN desarrolló un paquete para la
Hoy en día, la miniaturización de implementación de una interfaz con
componentes electrónicos, la disminución de conectividad a sus tarjetas de adquisición
su consumo de corriente y el tamaño de los (que vende por separado). Existe una gran
semiconductores, permite la construcción de variedad de tarjetas y su costo varía de
circuitos más complejos, inteligentes y acuerdo a sus capacidades. Conforme el
eficientes. No ha sido la excepción con el software se fue volviendo popular muchos
microcontrolador, ya que éste se ha fabricantes de hardware desarrollaron
desarrollado notablemente, al punto de tarjetas compatibles con éste software. El
hacer más grande sus capacidades de software fue evolucionando al grado de que
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 2 / 15

se puede conectar casi con cualquier

dispositivo, y su manejo es muy fácil e
incluye una ayuda en línea.
ANTECEDENTES
1. LA ARQUITECTURA DEL PUERTO USB
A pesar de que el puerto USB nos ofrece Fig. 2 HUB USB
más ventajas que sus predecesores, su
complejidad para implementarlo es enorme,
ya que su funcionamiento está basado en
protocolos de software.

Sólo puede haber un Host en el bus que
Fig. 3 Múltiple velocidad en un BUS
maneja a todos los componentes conectados
como se indica en la figura 1. El cable que típicamente es usado no es
largo, debido a la velocidad de transferencia

y tiene la estructura mostrada en la figura 4.
Sus terminales son del tipo diferencial y
consta de 4 hilos.

Fig. 4 Cable USB

La arquitectura USB comprende cuatro
tipos básicos de transferencia de datos:
Fig. 1 Topología del BUS • Control Transfers: Es usado para
configurar un dispositivo al momento de que
El hub es un elemento plug and play en
se conecta. Los datos entregados pueden
la estructura USB (Figura 2) y es un perderse.
concentrador al cual, se le pueden agregar
más dispositivos USB, incluyendo otro hub. • Bulk Data Transfers: Entrega el dato por
volumen, el ancho de banda puede variar. Es
La velocidad de transferencia depende usado en escáner ó cámaras. La ráfaga de
de la velocidad del HUB que se esté datos es secuencial.
utilizando. Ver figura 3. Las velocidades
típicas son: 480Mb /s en high speed, 12Mb/s • Interrupt Data Transfers: Used for timely
full‐speed y 1.5Mb/s en Low‐speed. but reliable delivery of data, for example,
characters or coordinates with human‐

perceptible echo or feedback response usar (endpoints), VID&PID, nombre y serie
characteristics. del producto que se conecta para que el host
identifique al driver y pueda instalarlo con el
• Isochronous Data Transfers: Occupy a fin de que el dispositivo pueda formar las
prenegotiated amount of USB bandwidth “pipes” ó túneles para su comunicación con
with a prenegotiated delivery latency. (Also el host (ver figura 5).
called streaming real time transfers).

Aunque el PIC no puede funcionar como
host, ya que se requiere de una gran

capacidad de manejo de datos para
administrar a cada componente del BUS, es
suficiente que se pueda administrar como un
“device”, para esto se requiere
“memorizarle” los protocolos necesarios
Fig 5. Flujo de comunicación USB
para enlazarse al host.
2. LA MPUSBAPI.DLL DE MICROCHIP
Estos protocolos se le llaman
descriptores y sirve para informarle al host Para una mayor facilidad de desarrollo
todo lo necesario para que pueda de aplicaciones basadas en el bus USB,
administrarlo. Microchip ha creado un archivo dll en el que
proporciona las funciones de acceso al
Recordemos que los PICs de la serie puerto USB con un microcontrolador de la
18Fxx5x tienen tres modos de familia PIC18Fxx5x. Para un funcionamiento
funcionamiento: correcto, se necesita el driver mchpusb.sys.

1. USB Human Interface Device Este driver sirve tanto para Visual Basic
(HID): Velocidad Baja, no como para Visual C, entre otros.

requiere driver.
Revisando ejemplos, y la ayuda que
2. USB Communication Device trae incluida sobre el manejo de la dll se
Class (CDC): Velocidad Media, verifica que el modo de abrir la pipe es el
requiere driver. Crea un Puerto siguiente:
Serie Virtual.

Primero se identifica si hay un
3. USB Custom Driver: Velocidad dispositivo con el nombre VID&PID
Alta, requiere driver. Este es el conectado a la PC con la instrucción:
modo que usa WinUSB (para (*MPUSBGetDeviceCount)(PCHAR
windows vista) y el mpusbapi pVID_PID )
(windows 2000 y posterior).
La variable pVID&PID, es una entrada de
Dentro de los protocolos hay que cadena de caracteres que da como
especificar el tipo de transferencia de datos a resultado el número de dispositivos

conectados al Host, que tienen asignado MPUSBGetDeviceCount devolverá un ‘1’. Al
el mismo pVID&PID. llamar la función tiene que haber un
mecanismo que intente llamar MPUSOpen()
Seguidamente con la instrucción desde 0 hasta MAX_NUM_MPUSB_DEV. Se
tiene que contar el número de llamadas
(*MPUSBOpen)
exitosas. Cuando este número sea igual al
(DWORD instance, // Input
número devuelto por
PCHAR pVID_PID, // Input MPUSBGetDeviceCount, hay que dejar de
hacer las llamadas porque no puede haber
PCHAR pEP, // Input más dispositivos con el mismo VID_PID.

DWORD dwDir, // Input pVID_PID: Input: String que contiene el
PID&VID del dispositivo objetivo. El formato
DWORD dwReserved); // Input <Future Use> es “vid_xxxx&pid_yyyy”. Donde xxxx es el
valor del VID y el yyyy el del PID, los dos en
Esta instrucción devuelve el acceso al pipe hexadecimal. Ejemplo: Si un dispositivo tiene
del Endpoint con el VID_PID asignado. Todas un VID=0x04d8 y un PID=0x000b, el string de
las pipes se abren con el atributo entrada es: “vid_0x04d8&pid_0x000b”.
FILE_FLAG_OVERLAPPED contenida en la
DLL, ésto permite que MPUSBRead, pEP: Input: String con el número del
MPUSBWrite y MPUSBReadInt tengan un Endpoint que se va a abrir. El formato es
valor de time‐out. “\\MCHP_EPz” o “\MCHP_EPz” dependiendo
Nota: el valor del time‐out no tiene sentido del lenguaje de programación. Donde z es el
en una pipe síncrona. número del Endpoint en decimal. Ejemplo:
“\\MCHP_EP1” o “\MCHP_EP1” Este
instance: Input: Un número de dispositivo argumento puede ser NULL (nulo) para crear
para abrir. Normalmente, se utiliza primero lazos con Endpoints de funciones no
la llamada de MPUSBGetDeviceCount para específicas. Las funciones específicas que
saber cuantos dispositivos hay. utilizan éste parámetro son: MPUSBRead,
MPUSBWrite, MPUSBReadInt.
Es importante entender que el driver
lo comparten distintos dispositivos. El Nota: Para utilizar MPUSBReadInt(), el
número devuelto por el formato de pEP tiene que ser
MPUSBGetDeviceCount tiene que ser igual o “\\MCHP_EPz_ASYNC”. Esta opción sólo está
menor que el número de todos los disponible para un Endpoint interrupción IN.
dispositivos actualmente conectados y La pipe de datos abierta con “_ASYNC” debe
usando el driver genérico. Ejemplo: Si hay almacenar datos con el intervalo
tres dispositivos con los siguientes PID_VID especificado en el Endpoint descriptor con
conectados: un máximo de 100 recepciones. Cualquier
otro dato recibido después de llenar el buffer
¢ Dispositivo tipo 0, VID 0x04d8, PID 0x0001 del driver se ignora. La aplicación del usuario
¢ Dispositivo tipo 1, VID 0x04d8, PID 0x0002 tiene que llamar MPUSBReadInt() a menudo
¢ Dispositivo tipo 2, VID 0x04d8, PID 0x0003 sin superar el máximo de 100.

y el dispositivo que nos interesa tiene dwDir: Especifica la dirección del Endpoint:
VID=0x04d8 y PID=0x0002 el

¢ MP_READ: para MPUSBRead y generalmente se declara al inicio del

MPUSBReadInt programa en el PIC.
¢ MP_Write: para MPUSBWrite
dwLen: Input: Especifica el número de
Se abre un pipe a la vez (hay que usar dos bytes que se espera leer de la pipe.
veces ésta instrucción), con dwDir=1 se abre
la pipe para leer y con dwDir=0 se abre la pLenght: Output: Puntero al número de
pipe para escribir al PIC, el resultado que nos bytes leídos. MPUSBRead pone este valor a
arroja ésta instrucción es el número de pipe cero antes de cualquier lectura o de
que nos asigna el sistema operativo. chequear un error.

dwReserved: No asignado por el momento, dwMilliseconds: Input: Especifica el
el valor por omisión es cero. intervalo de time‐out en milisegundos. La
función vuelve si transcurre el intervalo
aunque no se complete la operación. Si
El formato típico de la instrucción es: dwMilliseconds=0, la función comprueba
MPUSBOpen(0, vid_pid, out_pipe, dwDir, 0) los datos de la pipe y vuelve
inmediatamente. Si dwMilliseconds es
Como tercer procedimiento, se lee el dato infinito, el intervalo de time‐out nunca
aplicando el número de pipe asignado por termina.
medio de la instrucción: (*MPUSBRead)
El formato típico de la instrucción es:
(HANDLE handle, // Input MPUSBRead(myInPipe, VarPtr(s(0)),
DatosDeseados, Datos, 1000)
PVOID pData, // Output
Para enviar los datos al PIC se hace
DWORD dwLen, // Input
de la misma manera con la instrucción:
PDWORD pLength, // Output (*MPUSBWrite)
DWORD dwMilliseconds); // Input (HANDLE handle, // Input
PVOID pData, // Input
handle: Input: Identifica la pipe del
Endpoint que se va a leer. La pipe unida DWORD dwLen, // Input
tiene que crearse con el atributo de acceso
PDWORD pLength, // Output
MP_READ. En conclusión, “handle” es el
número de pipe que nos arrojó la DWORD dwMilliseconds); // Input
instrucción anterior con dwDir=1.

pData: Output: Puntero al buffer que handle: Input: Identifica la pipe del
recibe el dato leído de la pipe. El formato Endpoint que se va a escribir. La pipe unida
del dato es un arreglo de N bytes, donde N tiene que crearse con el atributo de acceso
es el número de bytes que maneja el MP_WRITE. En conclusión, “handle” es el
“device” en el arreglo que envía a la PC,

número de pipe que nos arrojó la El formato típico de la instrucción es:
instrucción anterior con dwDir=0. MPUSBClose (myOutPipe)

pData: Input: Puntero al buffer que
contiene los datos que se van a escribir en Existen otras dos instrucciones que no se
la pipe. El formato del dato es un arreglo implementaron en éste desarrollo, pero es
de N bytes, donde N es el número de bytes necesario conocerlos, éstas son:
que maneja el “device” en el arreglo que
recibe de la PC, generalmente se declara al MPUSBGETDLLVERSION(VOID)
inicio del programa en el PIC.
Lee el nivel de revisión del MPUSAPI.dll. Esta

función devuelve la versión del código de la
dwLen: Input: Especifica el número de
dll en formato hexadecimal de 32bits, no
bytes que se van a escribir en la pipe.
realiza nada con el puerto USB.

pLenght: Output: Puntero que proporciona El formato típico de la instrucción es:
el número de bytes que se escriben al
MPUSBGetDLLVersion()
llamar esta función. MPUSBWrite pone
este valor a cero antes de cualquier lectura MPUSBREADINT(HANDLE, PDATA, DWLEN,
o de chequear un error. PLENGTH, DWMILLISECONDS)

dwMilliseconds: Input: Especifica el handle: Input: Identifica la pipe del Endpoint
intervalo de time‐out en milisegundos. La que se va a leer. La pipe unida tiene que
función vuelve si transcurre el intervalo crearse con el atributo de acceso MP_READ.
aunque no se complete la operación. Si
dwMilliseconds=0, la función comprueba pData: Output: Puntero al buffer que recibe
los datos de la pipe y vuelve el dato leído de la pipe.
inmediatamente. Si dwMilliseconds es
infinito, el intervalo de time‐out nunca dwLen: Input: Especifica el número de bytes
termina. que hay que leer de la pipe.

El formato típico de la instrucción es: pLenght: Output: Puntero al número de
MPUSBWrite(myOutPipe, bytes leídos. MPUSBRead pone este valor a
cero antes de cualquier lectura o de
VarPtr(SendData(0)), bytes, VarPtr(bytes),
chequear un error.
1000)
dwMilliseconds: Input: Especifica el intervalo
Por ultimo, se requiere cerrar las
de time‐out en milisegundos. La función
pipes, porque después de usarlos caducan, vuelve si transcurre el intervalo aunque no se
ya no es posible leer / escribir de nuevo. Para complete la operación. Si dwMilliseconds=0,
cerrarlos basta ejecutar la instrucción: la función comprueba los datos de la pipe y
(*MPUSBClose)(HANDLE handle); de donde vuelve inmediatamente. Si dwMilliseconds es
handle: Input: Identifica la pipe del infinito, el intervalo de time‐out nunca
termina.
Endpoint que se va a cerrar.

El formato típico de la instrucción es: En Visual Basic:

MPUSBReadInt(myOutPipe, out_pipe= “\MCHP_EPx”
VarPtr(SendData(0)), bytes, VarPtr(bytes), in_pipe= “\MCHP_EPy”
1000)
En C y Delphi:
TIPOS DE TRANSFERENCIAS SOPORTADO POR out_pipe= “\\MCHP_EPx”
ESTAS INSTRUCCIONES in_pipe= “\\MCHP_EPy”
Siendo x e y números del Endpoint por los
En este apartado se recomienda que función que se van a realizar las transmisiones.
utilizar dependiendo del tipo de
transferencia. Esta dll se llama de acuerdo a la convención
del lenguaje C, NO funciona si es llamada con
Tipo Función ¿Aplicable time‐out? el formato de STDLIB.
Interrupt IN‐MPUSRead, MPUSReadInt ‐si
Interrupt OUT‐MPUSBWrite si OBJETIVO
Bulk IN MPUSBRead si
Bulk OUT MPUSWrite si El objetivo principal del presente trabajo es
Isochronous IN‐MPUSBRead no integrar el software de LabVIEW con el
Isochronous OUT‐MPUSBWrite no PIC18F2455 de Microchip con el fin de

diseñar una tarjeta de adquisición de datos
Interrupt: tipo interrupción
Isochronous: tipo síncrono ajustada a la necesidad personalizada de
cada desarrollo.
Nota: “Input” y “output” se refiere a los
OBJETIVOS PARTICULARES
parámetros designados en las llamadas a
estas funciones, que son lo opuesto a los 1. Enlace a la PC mediante USB.
sentidos comunes desde la perspectiva de 2. Enlace de LabVIEW al PIC.
una aplicación haciendo llamadas. 3. Pruebas finales y correcciones.

DECLARACIÓN DE CONSTANTES Y VARIABLES
1. ENLACE A LA PC MEDIANTE USB.
Aquí aparecen las constantes y variables
Para lograr el enlace a USB se utilizaron
que el fabricante recomienda usar. Todas
las funciones USB, incorporadas en el
son optativas, dejando la elección al
programador. También, se comentan las lenguaje C del programa CCS para PICS,
pequeñas variaciones que existen al dichas funciones están preparadas para que
declarar estas variables en los distintos el microcontrolador sea reconocido como un
lenguajes. dispositivo personalizado usando los
descriptores que incluye el mismo lenguaje,
MPUS_FAIL=0 se estableció la cantidad de datos a 64 bytes
MPUSB_SUCCESS=1
MP_WRITE=0 (8 bits por byte) de envío y recepción hacia la
MP_READ=1 PC, en la PC se descarga el driver que nos
MAX_NUM_MPUSB_DEV=127 proporciona Microchip en su págína web. Si
vid_pid= “vid_04d8&pid_0011” tiene dudas sobre la descarga consulte el

apartado 3. Pruebas finales y correcciones en
éste documento.

Se sugiere que al descomprimir el
archivo del driver se instale en C:\Archivos
de Programa\ para que el driver quede en:
C:\Archivos de Programa\ Microchip
Solutions\USB Tools\MCHPUSB Custom
Driver\MCHPUSB Driver\Release ya que al

ejecutar la aplicación del LabVIEW se tomará
como referencia ésa dirección.
Por parte del Hardware, el mismo
compilador trae en la ayuda un diagrama
esquemático para conectar al PIC
dispositivos adicionales como teclado,

display genéricos de dos líneas y gráficos, el
puerto serie, usb, I2C, etc.
Instale el hardware a la PC de manera

similar al que se instala un dispositivo USB
que adquiere en el mercado: conecte al
dispositivo a la PC, en cuanto le solicite los
Fig. 6 Instalación del PIC en la PC
driver, sólo proporcione la dirección donde
fue descomprimido el driver.
Si todo es correcto debemos de observar
en el administrador de dispositivos un nuevo
hardware que se agregó tal como se muestra
en la figura 6.

En propiedades del dispositivo instalado

se puede observar el número PID&VID que
se configuró en el PIC tal como se muestra en
la figura 7, para esto no olvide sustituir en el
descriptor las 3 líneas que se comentan en
el código del programa que se anexa al final

de éste documento.

Una vez configurado el hardware, se
programó el PIC, modificando los Fig. 7 En propiedades del PIC instalado
descriptores para que se puedan hacer en la PC se observa el número de PID&VID

transacciones de 64 bytes, el VID&PID. Todo a. Hacer un ejecutable y llamarlo con la

esto basándose en ejemplos que el función “system exec vi”
compilador trae incluidos en la carpeta de
“examples”. Cabe aclarar que los diseños en b. Elaborar un programa en C y cargarlo en la
USB con PIC día a día se van incrementando. instrucción “Code Interface Node”
Sólo basta investigar un poco en la red para c. Manipular directamente la dll con la
ver los resultados (Consulte la bibliografía de instrucción “Call Library Function Node”
éste documento). El código del programa del
PIC se encuentra al final del documento con Los tres métodos nos ofrecen ventajas de
sus respectivos comentarios. No olvide acuerdo al nivel de lenguaje de
sustituir en el descriptor usb_desc_scope.h programación que se tenga. En los tres casos
las 3 líneas que se comentan en el código se manipula la misma librería. En este
del programa. desarrollo se utilizó el tercer método parar
manipular la librería de una manera directa y
2. ENLACE DEL LABVIEW AL PIC PARA EL sin intermediarios.
CONTROL Y MONITOREO.
Para la implementación de los métodos
Para poder iniciar el enlace con el PIC es anteriores el LabVIEW 8.2 ofrece una ayuda
necesario que se haya concluido
en línea, la cual permite saber al instante qué
satisfactoriamente la instalación del paquete
de drivers de Microchip. En el mismo es lo que se requiere para la interconexión
paquete que se descarga de la red de los módulos. Entre las ventajas que nos
obtenemos instrucciones y ejemplos en C++ ofrece el labVIEW podemos mencionar: el
que muestran como manipular el driver y los ambiente gráfico muy amigable, se puede
parámetros requeridos para aplicarlo. Sin mostrar mensajes, graficar los datos
embargo, aún no es suficiente la obtenidos, guardarlos en un archivo, habilitar
información, porque la dificultad está en
un indicador, mover un detector de nivel,
identificar el tipo de variable que acepta
cada software de desarrollo y que también etc., con el fin de visualizar la ocurrencia de
sea aceptada por la DLL. Por lo que de nuevo los eventos.
se sugiere consultar las notas de aplicaciones
de Microchip y ejemplos publicados en la Para iniciar con la implementación
web (con cualquier software de desarrollo). del código, primero inicie el programa de
LabVIEW, escoja la opción blank VI y en la
Para hacer la conexión con LabVIEW barra de menús déle un click al menú de
simplemente se “tradujeron” las window Î Show block diagram.
instrucciones al lenguaje gráfico y se
acondicionaron las variables para que la DLL Siguiendo los pasos descritos en la
pueda reconocerlo. sección de antecedentes de éste documento,
las instrucciones que se requieren
Por parte de LabVIEW es necesario conocer implementar tienen la siguiente secuencia y
qué función es más fácil de implementar: formato en LabVIEW son:
Existen tres métodos:

a. Identificar el número de dispositivos vid_04d8&pid_000b, según las instrucciones
conectados con el PID&VID y ubicar el que de uso del mpusbapi.dll tenemos que
corresponde al hardware de su desarrollo. declararla como string, y la misma función
Formato: proporciona una salida en formato numérico.
long _MPUSBGetDeviceCount(CStr vid_pid)
De donde: Fig. 8. Función Call Library Function Node
vista en el block diagram
vid_pid = vid_04d8&pid_000b

Para iniciar la programación en
LabVIEW se requiere estar en la ventana del
block diagram de LabVIEW presione el botón
derecho del mouse y en el menú que sale a
continuación presione los siguientes
submenús connectivity Î libraries &
executables Î y déle un click a Call Library
Function Node y se mostrará un pequeño

bloque como se muestra en la figura 8. Déle
doble clic en la parte amarilla y saldrá un Fig. 9. Configuración de parámetros de la
menú de configuración como se muestra en Función Call Library Function Node.
la figura 9. Presione la carpeta y proporcione
la dirección donde se instaló la dll de Conociendo esto pasos, en la misma
Microchip (Si Ud lo instaló en la dirección ventana de la figura 9 presione la flecha de
sugerida anteriormente queda en menú en el campo Function Name (que
“C:\Archivos de programa\Microchip apunta hacia abajo) y escoja la función
Solutions\USB Tools\MCHPUSB Custom MPUSBGetDeviceCount como se muestra en
Driver\Mpusbapi\Dll\Borland_C” e la figura 10, seguidamente presione la
inmediatamente cargará la dll. Al presionar la pestaña “parameters” en la parte superior de
flecha de menú en el campo de Function la ventana y aparecerá otro menú como se
Name (que apunta hacia abajo) podrá muestra en la figura 11. En los campos que
observar TODAS las funciones que la dll aparecerán a continuación llénelos como
admite, solamente tiene que anexar las sigue:
variables y acondicionar el tipo de entrada.
Name: use el que trae de manera
Recuerde que se va a implementar la predeterminada ó un nombre que pueda
primera instrucción MPUSBGetDeviceCount identificar fácilmente a la variable type:
el cual nos proporciona como resultado el Presione la flecha de opciones y seleccione
número de dispositivos conectados a la PC numeric, Data type: Use el que trae de
con el PID&VID que se va a llamar, en éste manera predeterminada, presione el botón
caso el PID&VID que se quiere llamar es

marcado como + y se agregará otra variable manera similar a lo descrito anteriormente y
a configurar como sigue: quedará implementada su función.
Name: Ponga el nombre que Ud desee en el
campo Name (se sugiere un nombre que
pueda identificar fácilmente a la variable)
type: string, String Format: se sugiere dejar la
que trae de manera predeterminada (C string
Pointer), Minimun size: se sugiere dejar la
que trae de manera predeterminada (en

blanco), presione el botón OK y la función ya
está configurada.
Ahora cree una constante, escriba Fig. 10. Configurando la función
vid_04d8&pid_000b en su interior y conecte MPUSBGetDeviceCount de mpusbapi.dll
al pin marcado PID&VID del bloque que
acaba de configurar y el resultado que nos
proporcione ésta función ya está lista para

usarse!!!

Los demás parámetros se configuran
de manera similar a lo descrito
anteriormente es importante llegar hasta el
paso (f), sólo hay que tener en cuenta lo
siguiente:

Para la función MPUSBOpen, que
Fig. 10 Configurando la función de salida de
traen una leyenda Long al inicio, se requiere
MPUSBGetDeviceCount de mpusbapi.dll
configurar de igual manera que la instrucción
que se acaba de explicar, para los que traen
la leyenda Void al inicio se configura de la
siguiente manera:
Llame a la Función Call Library Function Node
y escríbale la dirección de la dll, presione el

menú del campo Function Name y seleccione
la función a utilizar (MPUSBWrite,
MPUSBRead ó MPUSBClose) presione la
pestaña de parámeters y deje el parámetro
Function Name con los valores que trae de
Fig. 11 Agregando parámetros de la función
manera predeterminada y sólo agregue los
MPUSBGetDeviceCount de mpusbapi.dll
demás parámetros que necesita la dll de

IMPORTANTE: Para los parámetros

marcados como:

Cstr son variables del tipo String,

Long del tipo numérica,

Los marcados con * son del tipo variable
numérica con Data type: unsigned 32 bits
integer y Pass: seleccionado a Pointer to
value,
Fig. 12 Funciones de mpusbapi.dll declaradas
Y los marcados con unsigned char * son como Void
arreglos de 1X64 bytes de 8 bits (vector) y
configurados con Type: Array, Data Type:
unsigned 8 bits integer, Dimensions: 1, Array

Format: Array Data Pointer, Minimun size:
seleccione la variable asignada a la longitud
del arreglo a enviar / recibir, es el dato que
se envía y/o recibe del PIC (fig. 13).
b. Abra la pipe para leer (si no desea leer
puede omitir éste paso).

Formato:
Fig. 13 Configuración del arreglo de 1X64
long _MPUSBOpen(long instance, CStr bytes de 8 bits que se envia/recibe del PIC
VID_PID, CStr EP, long dwDir, long
desde LabVIEW
dwReserved)
De donde:
instance = 0, vid_pid = De donde:

“vid_04d8&pid_000b”, EP = “\MCHP_EP1”,
dwDir = 0, dwReserved = 0. instance = 0, vid_pid =
“vid_04d8&pid_000b”, EP = “\MCHP_EP1”,
c. Abra la pipe para escribir (si no desea dwDir = 1, dwReserved = 0.
escribir puede omitir éste paso).
d. Lea los datos de la pipe (solamente si la
Formato: pipe está abierta) Formato:
long _MPUSBOpen(long instance, CStr void _MPUSBRead(long Handle, unsigned

VID_PID, CStr EP, long dwDir, long char *data, long dwlen, long *length, long
dwReserved) dwMilliseconds)
De donde:

Handle corresponde al Número que se Recuerde que se debe abrir una “pipe” a la
obtiene como resultado de la instrucción vez (hay que usar dos veces ésta instrucción),
MPUSBOpen con dwDir = 0, data = es la una vez con dwDir=1 para abrir la pipe para
información que envía el PIC en un vector de leer y con dwDir=0 para abrir la pipe para
64 bytes, dwlen = 64, length = 64, escribir al PIC, el resultado que nos arroja
dwMiliseconds = 200. ésta instrucción es el número de pipe que
nos asigna el sistema operativo.
e. Escriba los datos de la pipe (solamente si
la pipe está abierta) Formato:: No olvide seguir la secuencia de apertura y
cierre de la “pipe” con una “structura” del
void _MPUSBWrite(long Handle, unsigned tipo “Flat sequence” para su ejecución en
char *data, long dwlen, long *length, long secuencia. El código implementado en
dwMilliseconds) labVIEW <<DAQ.vi >> puede solicitarlo a los
De donde: siguientes correos electrónicos:
gpoolb@hotmail.com, lugojim@gmail.com
Handle = Número obtenido como resultado
de la instrucción MPUSBOpen con dwDir = 1, Una vez enlazado con el PIC, los
data = es la información que se envía al PIC datos pueden fluir las veces que sea
en un vector de 64 bytes, dwlen = 64, length necesario de un sentido a otro y
= 64, dwMiliseconds = 200. manipularlos como se desee, ya que se tiene
el completo control del software del PIC (por
f. Cierre la(s) pipe(s) abierta(s), ya que una parte del Compilador C) y en la PC (por parte
vez usados, éstos caducan. Recordemos que del LabVIEW). Asegúrese que la dll quede
si se abren 2 pipes, ambas hay que cerrarlas. instalado en:
Formato: C:\Archivos de programa \Microchip
Solutions\USB Tools\MCHPUSB Custom
void _MPUSBClose(long Handle);
Driver\Mpusbapi\Dll
De donde:
3. Pruebas finales y correcciones.
Handle = Número obtenido como resultado
Para el enlace con la PC por USB es muy
de la instrucción MPUSBOpen con dwDir = 0
importante conectar el capacitor (C4) de
Y para la última “pipe”, Formato: 0.1uF como se indica en el diagrama, ya que,
si se omite generará un error al momento del
void _MPUSBClose(long Handle); enlace. También es muy importante habilitar
el fusible VREGEN para que Vusb sea
De donde:
activado.
Handle = Número que porporciona como
Es importante considerar la función del
resultado de la instrucción MPUSBOpen con
PLL del PIC ya que de acuerdo al valor de la
dwDir = 1
frecuencia del cristal depende el valor de la

multiplicación de la frecuencia del reloj para Se recomienda verificar el archivo que nos

generar los 48Mhz necesarios para el USB. proporciona Microchip en el driver, en la
siguiente dirección:
Por lo que respecta al descriptor del USB,
es importante considerar el valor del VID & "C:\ ARCHIVOS DE PROGRAMA\MICROCHIP
PID, ya que si no es configurado SOLUTIONS\USB TOOLS\MCHPUSB CUSTOM
correctamente, el driver que proporciona DRIVER\MCHPUSB DRIVER\MCHPUSB
Microchip no lo reconocerá y en DRIVER RELEASE NOTES.HTM"
consecuencia, no funcionará. Para esto no
olvide sustituir en el descriptor las 3 líneas Ahí se proporciona información sobre la
que se comentan en el código del programa compatibilidad en sistemas operativos y
que se anexa en éste documento. ejemplos desarrollados.
La DLL que proporciona Microchip se BIBLIOGRAFÍA

puede descargar desde su sitio web. http://www.usb.org/developers/docs/
Asegurese de obtener la versión más actual.
En la dirección web que se menciona en la http://slalen.iespana.es/programacion/datos
bibliografía se descarga el driver, en caso de /MPUSBApi.pdf
haber caducado busque en la sección Design
www.google.com.mx búsqueda “PIC USB”.
Î Aplication Design Center Î Wired
Conectivity Î USB Î Software/Tools Î http://www.hobbypic.com/
MCHPFSUSB Framework v2.1 ó simplemente
http://www.todopic.com.ar/foros/index.php
teclee “usb software/tools” en la ventanita
?topic=13418.0;do=Bookmark
de búsqueda y déle un clic en el botón “site
search”, generalmente el acceso a la página http://picmania.garcia‐
queda en los primeros resultados de la cuervo.com/index.php
búsqueda, el cual, al darle click lleva
directamente al driver. En el mismo paquete Driver de microchip:
incluye ejemplos que incluyen el programa
http://www.microchip.com/stellent/idcplg?I
fuente para la compresión de su uso.
dcService=SS_GET_PAGE&nodeId=2651&par
En caso de que el LabVIEW genere error al am=en534494
ejecutar el programa, es importante verificar
Descarga directa :
que el driver de Microchip quede en
C:\Archivos de Programa\ del disco duro ya http://ww1.microchip.com/downloads/en/D
que se tomará como referencia para el eviceDoc/Microchip%20MCHPFSUSB%20v2.1
llamado de la dll y que el archivo que se %20Installer.zip
descargó sea el que está llamado Microchip
MCHPFSUSB v2.1 Installer (la última versión). Asegúrese que el archivo sea el que tiene por
nombre MCHPFSUSB Framework v2.1
DAQ
Código de programa
/////////////////////////////////////////////////////////////////////////
//// DAQ.c ////
//// ////
//// Este ejemplo muestra como desarrollar un sencillo dispositivo ////
//// USB con el PIC18F2550 (para la serie 18Fxx5x) ////
//// los drivers que se requiere para éste dispositivo son los que ////
//// proporciona Microchip en su pagina web, y se basan en protocolo ////
//// USB_ENABLE_BULK su XTAL es de 12Mhz. ////
//// ////
//// ////
//// Cuando el dispositivo sea conectado al PC, saldrá el asistente ////
//// para la instalación del driver. Se instala el driver ////
//// que nos proporciona Microchip. ////
//// ////
//// Al aplicar energia al PIC se enciende el LED en RB6 y hasta ////
//// que el dispositivo halla sido configurado por la PC via puerto ////
//// USB se encende el Led en RB7. El PIC muestra el dato que le ////
//// envia la PC en el vector [0] e inmediatamente el PIC le ////
//// responde con el valor del puerto A almacenado en el vector [1]. ////
//// Sólo si la PC le envia un dato al PIC éste enviará el dato del ////
//// puerto A ////
//// ////
/////////////////////////////////////////////////////////////////////////
//// ////
//// Realizado con el compilador CCS PCWH 3.227 ////
//// Este programa fue desarrollado para estimular el uso del ////
//// puerto USB y desarrollar tarjetas de adquisición económicas ////
//// por Ing. Gabriel Pool y Ing. Julio Lugo para proyecto de ////
//// materia Sensores y Actuadores impartida por el profesor ////
//// M.C. Pedro Nájera ////
//// (Universidad Modelo en Mérida, Yucatán, México) en Junio 2008 ////
//// Este programa es de uso libre siempre y cuando que contenga ////
//// esta leyenda y nos agradaría recibir las mejoras que Ud ////
//// amablemente nos envie a estos correos: gpoolb@hotmail.com ////
//// y lugojim@gmail.com ////
//// ////
/////////////////////////////////////////////////////////////////////////
#include <18F2455.h>
//#device ADC=10 //Descomente ésta opción en caso de
usar el ADC a 10bits
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL3,CPUDIV1,VREGEN,MCLR,NOPBADEN
#use delay(clock=48000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
/////////////////////////////////////////////////////////////////////////////
//
// CCS Library dynamic defines. For dynamic configuration of the CCS Library
// for your application several defines need to be made. See the comments
// at usb.h for more information
//
/////////////////////////////////////////////////////////////////////////////
#define USB_HID_DEVICE FALSE //deshabilitamos el uso de las
directivas HID
#define USB_EP1_TX_ENABLE USB_ENABLE_BULK //turn on EP1(EndPoint1) for IN
bulk/interrupt transfers
#define USB_EP1_RX_ENABLE USB_ENABLE_BULK //turn on EP1(EndPoint1) for OUT
bulk/interrupt transfers
#define USB_EP1_TX_SIZE 64 //size to allocate for the tx
endpoint 1 buffer
Página 1
DAQ
#define USB_EP1_RX_SIZE 64 //size to allocate for the rx
endpoint 1 buffer
/////////////////////////////////////////////////////////////////////////////
//
// If you are using a USB connection sense pin, define it here. If you are
// not using connection sense, comment out this line. Without connection
// sense you will not know if the device gets disconnected.
// (connection sense should look like this:
// 100k
// VBUS-----+----/\/\/\/\/\----- (I/O PIN ON PIC)
// |
// +----/\/\/\/\/\-----GND
// 100k
// (where VBUS is pin1 of the USB connector)
//
/////////////////////////////////////////////////////////////////////////////
//#define USB_CON_SENSE_PIN PIN_B2 //CCS 18F4550 development kit has optional
conection sense pin
/////////////////////////////////////////////////////////////////////////////
//
// Include the CCS USB Libraries. See the comments at the top of these
// files for more information
//
/////////////////////////////////////////////////////////////////////////////
#include <pic18_usb.h> //Microchip PIC18Fxx5x Hardware layer for CCS's
PIC USB driver
#include <usb_desc_scope.h> //descriptors del Pic USB
#include <usb.c> //handles usb setup tokens and get
descriptor reports
/////////////////////////////////////////////////////////////////////////////
/* IMPORTANTE: No olvidar sustituir en la sección start device descriptors (aprox
en la linea 132)
al descriptor ubicado en C:\Archivos de
programa\PICC\Drivers\usb_desc_scope.h
lo siguiente:
0xD8,0x04, //vendor id (0x04D8 is Microchip)
0x0B,0x00, //product id
0x01,0x00, //device release number
**********DE LO CONTRARIO, EL DISPOSITIVO NO SERA RECONOCIDO POR EL DRIVER.********

*/
/////////////////////////////////////////////////////////////////////////////
#define LEDV PIN_B6

#define LEDR PIN_B7
#define LED_ON output_high
#define LED_OFF output_low
#BYTE TRISA = 0x0F92 // Registro de control de E/S del

puerto A
#BYTE TRISB = 0x0F93 // Registro de control de E/S del
puerto B
#BYTE PORTA = 0x0F80 // Registro del puerto A
#BYTE PORTB = 0x0F81 // Registro del puerto B
#BYTE ADCON1 = 0x0FC1 // Registro de control del ADC
#BYTE CMCON = 0x0FB4 // Registro del modulo comparador
Página 2
DAQ
int8 dato[64];
void main(void) {
LED_ON(LEDV); //encendemos led en RB6 para
indicar presencia de energia
LED_OFF(LEDR);
usb_init(); // inicializamos el USB
usb_task(); // habilita periferico usb e
interrupciones
usb_wait_for_enumeration(); // esperamos hasta que el PicUSB
sea configurado por el host
LED_OFF(LEDV);
LED_ON(LEDR); // encendemos led en RB7 al
establecer contacto con la PC
TRISA = 0x0FF; // Se declara el puerto A como
entradas
TRISB = 0x00; // Se declara el puerto B como
salidas
ADCON1 = 0x0F; // Se configura al ADC para
entradas digitales
CMCON = 0x07; // Se configuran los comparadores
para entradas digitales
while (TRUE)
{
if(usb_enumerated()) // si el Pic está configurado via
USB
{
if (usb_kbhit(1)) // si el endpoint de salida
contiene datos del host
{
usb_get_packet(1, dato, 64); // cojemos el paquete de tamaño
8bytes del EP1 y almacenamos en dato
portb = dato[0]; // Se muestra al byte completo en
el puerto B
dato[1] = porta; // Se lee el puerto A y se almacena
en el vector
usb_put_packet(1, dato, 64, USB_DTS_TOGGLE); //y enviamos el mismo
paquete de tamaño 64bytes del EP1 al PC
}
}
}
}
Página 3
5 4 3 2 1
SALIDAS
+5V
D D
+5V
D1 D2 D3 D4 D5 D6 D7 D8
R1 R2 R1 R2 R2 R2
10K 10K 10K 10K 10K 10K C5
0.1uF
20
R4 R5 R4 R5 R4 R5 R4 R5
2 150 150 150 150 150 150 150 150
VDD
RA0 RA0
RA1 3 RA1
RA2 4 RA2
RA3 5 RA3
RB0
RB1
RB2
RB3
RB4
RB5
RB6
RB7
RA4 6 RA4/T0CKI/C1OUT/RCV
RA5 7 RA5/SS RC6/TX/CK 17
RC7/RX/DT/SDO 18
+5V R6 R7 11
10K 100 RC0/T1OSO/T13CKI
C 1 MCLR/VPP/RE3 RC2 13 C
RB0 21 RB0/INT RC1 12

+5V S1 22 U2
RB1 RB1
SW 23 PIC18F2455
J4 RB2 RB2
RB3 24 J1
RB3
1 RB4 25 RB4 1
USB
OSC2/CLKO/RA6
2 RB5 26 RB5 RC4/D-/VM 15 2
3 27 RB6 RC5/D+/VP 16 3
4 28 RB7 4
OSC1/CLKI
5 RB6 VUSB 14
C4
RB7
0.1uF
GND
GND
ICSP
10
19
9
B
8 B
X1
12 MHz
RA0
RA1
RA2
RA3
RA4
RA5
J3 C7 C8
+5V +12V 22pF 22pF
POWER SUPPLY
S1 S1 S1 S1 S1 S1
4 SW SW SW SW SW SW
3
2
1
C2
2200uF C1 ENTRADAS
1000uF
A Diseñado por: Ing. Gabriel Pool, gpoolb@hotmail.com A

y Julio Lugo, lugojim@gmail.com
Title
Integración de PIC18F2455 con LabVIEW 8.2
Size Document Number Rev

A DAQ 01
Date: Monday, July 07, 2008 Sheet 1 of 1

5 4 3 2 1

Integración de PIC18F2455 Con LabVIEW 8.2 Con Mpusbapi

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Integración de PIC18F2455 Con LabVIEW 8.2 Con Mpusbapi

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD MODELO

Integración de PIC18F2455 de Microchip™ con LabVIEW™ 8.2 de National

RESUMEN comunicación, memoria, circuitos de apoyo

se puede conectar casi con cualquier

¢ MP_READ: para MPUSBRead y generalmente se declara al inicio del

DWORD dwMilliseconds); // Input (HANDLE handle, // Input

El formato típico de la instrucción es: En Visual Basic:

Instale el hardware a la PC de manera

transacciones de 64 bytes, el VID&PID. Todo a. Hacer un ejecutable y llamarlo con la

IMPORTANTE: Para los parámetros

instance = 0, vid_pid = De donde:

long _MPUSBOpen(long instance, CStr void _MPUSBRead(long Handle, unsigned

multiplicación de la frecuencia del reloj para Se recomienda verificar el archivo que nos

La DLL que proporciona Microchip se BIBLIOGRAFÍA

**DE LO CONTRARIO, EL DISPOSITIVO NO SERA RECONOCIDO POR EL DRIVER.

#define LEDV PIN_B6

#BYTE TRISA = 0x0F92 // Registro de control de E/S del

RB0 21 RB0/INT RC1 12

A Diseñado por: Ing. Gabriel Pool, gpoolb@hotmail.com A

Size Document Number Rev

Date: Monday, July 07, 2008 Sheet 1 of 1

También podría gustarte