Integración de PIC18F2455 con LabVIEW 8.2 con mpusbapi
Transcript of 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
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 2 / 15
RESUMEN
El diseño de un sistema de monitoreo de variables como presión, velocidad, temperatura, etc., y/o acción de control sobre el mundo físico requiere tradicionalmente de una tarjeta de adquisición de datos que por lo general es limitada en hardware, orientada a la interacción y trabajo exclusivo con productos del fabricante; un software que administre los datos en la PC para el monitoreo local y remoto, control de decisiones, graficar, guardar datos en disco, etc. y un conocimiento amplio sobre el software de desarrollo, sin contar la gran cantidad de tiempo a invertir en la implementación de la solución más apropiada. Algunos fabricantes ofrecen soluciones a medias: poderoso hardware con un software pobre que no cumple con nuestro requerimiento ó hardware básico al que se requieren agregar módulos adicionales para adaptarlo a nuestra necesidad y con software muy completo. En éste desarrollo se fusiona lo mejor de ambos mundos: Un microcontrolador con puerto USB de Microchip y un software de desarrollo LabVIEW de Nacional Instruments.
INTRODUCCIÓN
Hoy en día, la miniaturización de componentes electrónicos, la disminución de su consumo de corriente y el tamaño de los semiconductores, permite la construcción de circuitos más complejos, inteligentes y eficientes. No ha sido la excepción con el microcontrolador, ya que éste se ha desarrollado notablemente, al punto de hacer más grande sus capacidades de
comunicación, memoria, circuitos de apoyo adicionales (ADC, oscilador interno, puertos, etc.). Dichos microcontroladores, requieren de muy poco componentes de soporte externo para implementarse y sus tecnologías se han perfeccionado, de tal manera, que casi no fallan. Algunos fabricantes tal como Microchip, se preocupan en desarrollar las herramientas para su programación, tales como lenguajes de alto nivel para compilar el programa y programadores económicos para descargar el programa en el chip. Debido a éstas herramientas, éste chip se ha vuelto muy popular al grado que se proponen como materias a cursar en las escuelas.
Por otro lado, ya no basta con tener un chip inteligente que funcione de manera autónoma, ahora se requiere que trabajen en conjunto con la PC para el monitoreo local y remoto (internet o intranet), control de decisiones, graficar, guardar datos en disco, etc. Esto se puede lograr con el desarrollo de un software como Visual Basic, Visual C, C++, ó cualquier otro paquete de preferencia gráfico para hacer más fácil la interfaz de usuario. Desafortunadamente, el tiempo para aprender y dominar estos paquetes es muy largo. Por lo que, National Instruments desarrolló un paquete para la implementación de una interfaz con conectividad a sus tarjetas de adquisición (que vende por separado). Existe una gran variedad de tarjetas y su costo varía de acuerdo a sus capacidades. Conforme el software se fue volviendo popular muchos fabricantes de hardware desarrollaron tarjetas compatibles con éste software. El software fue evolucionando al grado de que
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 3 / 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 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 maneja a todos los componentes conectados como se indica en la figura 1.
Fig. 1 Topología del BUS
El hub es un elemento plug and play en la estructura USB (Figura 2) y es un concentrador al cual, se le pueden agregar más dispositivos USB, incluyendo otro hub.
La velocidad de transferencia depende de la velocidad del HUB que se esté utilizando. Ver figura 3. Las velocidades típicas son: 480Mb /s en high speed, 12Mb/s full‐speed y 1.5Mb/s en Low‐speed.
Fig. 2 HUB USB
Fig. 3 Múltiple velocidad en un BUS
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:
• Control Transfers: Es usado para configurar un dispositivo al momento de que se conecta. Los datos entregados pueden perderse. • Bulk Data Transfers: Entrega el dato por volumen, el ancho de banda puede variar. Es usado en escáner ó cámaras. La ráfaga de datos es secuencial. • Interrupt Data Transfers: Used for timely but reliable delivery of data, for example, characters or coordinates with human‐
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 4 / 15
perceptible echo or feedback response characteristics. • Isochronous Data Transfers: Occupy a prenegotiated amount of USB bandwidth with a prenegotiated delivery latency. (Also 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 para enlazarse al host.
Estos protocolos se le llaman descriptores y sirve para informarle al host todo lo necesario para que pueda administrarlo.
Recordemos que los PICs de la serie 18Fxx5x tienen tres modos de funcionamiento:
1. USB Human Interface Device (HID): Velocidad Baja, no requiere driver.
2. USB Communication Device Class (CDC): Velocidad Media, requiere driver. Crea un Puerto Serie Virtual.
3. USB Custom Driver: Velocidad Alta, requiere driver. Este es el modo que usa WinUSB (para windows vista) y el mpusbapi (windows 2000 y posterior).
Dentro de los protocolos hay que especificar el tipo de transferencia de datos a
usar (endpoints), VID&PID, nombre y serie del producto que se conecta para que el host identifique al driver y pueda instalarlo con el fin de que el dispositivo pueda formar las “pipes” ó túneles para su comunicación con el host (ver figura 5).
Fig 5. Flujo de comunicación USB
2. LA MPUSBAPI.DLL DE MICROCHIP
Para una mayor facilidad de desarrollo de aplicaciones basadas en el bus USB, Microchip ha creado un archivo dll en el que proporciona las funciones de acceso al puerto USB con un microcontrolador de la familia PIC18Fxx5x. Para un funcionamiento correcto, se necesita el driver mchpusb.sys.
Este driver sirve tanto para Visual Basic
como para Visual C, entre otros. Revisando ejemplos, y la ayuda que
trae incluida sobre el manejo de la dll se verifica que el modo de abrir la pipe es el siguiente:
Primero se identifica si hay un
dispositivo con el nombre VID&PID conectado a la PC con la instrucción:
(*MPUSBGetDeviceCount)(PCHAR pVID_PID ) La variable pVID&PID, es una entrada de cadena de caracteres que da como resultado el número de dispositivos
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 5 / 15
conectados al Host, que tienen asignado el mismo pVID&PID.
Seguidamente con la instrucción (*MPUSBOpen) (DWORD instance, // Input
PCHAR pVID_PID, // Input
PCHAR pEP, // Input
DWORD dwDir, // Input
DWORD dwReserved); // Input <Future Use>
Esta instrucción devuelve el acceso al pipe del Endpoint con el VID_PID asignado. Todas las pipes se abren con el atributo FILE_FLAG_OVERLAPPED contenida en la DLL, ésto permite que MPUSBRead, MPUSBWrite y MPUSBReadInt tengan un valor de time‐out. Nota: el valor del time‐out no tiene sentido en una pipe síncrona. instance: Input: Un número de dispositivo para abrir. Normalmente, se utiliza primero la llamada de MPUSBGetDeviceCount para saber cuantos dispositivos hay.
Es importante entender que el driver lo comparten distintos dispositivos. El número devuelto por el MPUSBGetDeviceCount tiene que ser igual o menor que el número de todos los dispositivos actualmente conectados y usando el driver genérico. Ejemplo: Si hay tres dispositivos con los siguientes PID_VID conectados:
Dispositivo tipo 0, VID 0x04d8, PID 0x0001 Dispositivo tipo 1, VID 0x04d8, PID 0x0002 Dispositivo tipo 2, VID 0x04d8, PID 0x0003
y el dispositivo que nos interesa tiene VID=0x04d8 y PID=0x0002 el
MPUSBGetDeviceCount devolverá un ‘1’. Al llamar la función tiene que haber un mecanismo que intente llamar MPUSOpen() desde 0 hasta MAX_NUM_MPUSB_DEV. Se tiene que contar el número de llamadas exitosas. Cuando este número sea igual al número devuelto por MPUSBGetDeviceCount, hay que dejar de hacer las llamadas porque no puede haber más dispositivos con el mismo VID_PID. pVID_PID: Input: String que contiene el PID&VID del dispositivo objetivo. El formato es “vid_xxxx&pid_yyyy”. Donde xxxx es el valor del VID y el yyyy el del PID, los dos en hexadecimal. Ejemplo: Si un dispositivo tiene un VID=0x04d8 y un PID=0x000b, el string de entrada es: “vid_0x04d8&pid_0x000b”. pEP: Input: String con el número del Endpoint que se va a abrir. El formato es “\\MCHP_EPz” o “\MCHP_EPz” dependiendo del lenguaje de programación. Donde z es el número del Endpoint en decimal. Ejemplo: “\\MCHP_EP1” o “\MCHP_EP1” Este argumento puede ser NULL (nulo) para crear lazos con Endpoints de funciones no específicas. Las funciones específicas que utilizan éste parámetro son: MPUSBRead, MPUSBWrite, MPUSBReadInt.
Nota: Para utilizar MPUSBReadInt(), el formato de pEP tiene que ser “\\MCHP_EPz_ASYNC”. Esta opción sólo está disponible para un Endpoint interrupción IN. La pipe de datos abierta con “_ASYNC” debe almacenar datos con el intervalo especificado en el Endpoint descriptor con un máximo de 100 recepciones. Cualquier otro dato recibido después de llenar el buffer del driver se ignora. La aplicación del usuario tiene que llamar MPUSBReadInt() a menudo sin superar el máximo de 100. dwDir: Especifica la dirección del Endpoint:
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 6 / 15
MP_READ: para MPUSBRead y MPUSBReadInt MP_Write: para MPUSBWrite
Se abre un pipe a la vez (hay que usar dos veces ésta instrucción), con dwDir=1 se abre la pipe para leer y con dwDir=0 se abre la pipe para escribir al PIC, el resultado que nos arroja ésta instrucción es el número de pipe que nos asigna el sistema operativo.
dwReserved: No asignado por el momento, el valor por omisión es cero.
El formato típico de la instrucción es: MPUSBOpen(0, vid_pid, out_pipe, dwDir, 0)
Como tercer procedimiento, se lee el dato aplicando el número de pipe asignado por medio de la instrucción: (*MPUSBRead)
(HANDLE handle, // Input
PVOID pData, // Output
DWORD dwLen, // Input
PDWORD pLength, // Output
DWORD dwMilliseconds); // Input
handle: Input: Identifica la pipe del Endpoint que se va a leer. La pipe unida tiene que crearse con el atributo de acceso MP_READ. En conclusión, “handle” es el número de pipe que nos arrojó la instrucción anterior con dwDir=1. pData: Output: Puntero al buffer que recibe el dato leído de la pipe. El formato del dato es un arreglo de N bytes, donde N es el número de bytes que maneja el “device” en el arreglo que envía a la PC,
generalmente se declara al inicio del programa en el PIC. dwLen: Input: Especifica el número de bytes que se espera leer de la pipe. pLenght: Output: Puntero al número de bytes leídos. MPUSBRead pone este valor a cero antes de cualquier lectura o de chequear un error. dwMilliseconds: Input: Especifica el intervalo de time‐out en milisegundos. La función vuelve si transcurre el intervalo aunque no se complete la operación. Si dwMilliseconds=0, la función comprueba los datos de la pipe y vuelve inmediatamente. Si dwMilliseconds es infinito, el intervalo de time‐out nunca termina. El formato típico de la instrucción es: MPUSBRead(myInPipe, VarPtr(s(0)), DatosDeseados, Datos, 1000)
Para enviar los datos al PIC se hace de la misma manera con la instrucción: (*MPUSBWrite)
(HANDLE handle, // Input
PVOID pData, // Input
DWORD dwLen, // Input
PDWORD pLength, // Output
DWORD dwMilliseconds); // Input
handle: Input: Identifica la pipe del Endpoint que se va a escribir. La pipe unida tiene que crearse con el atributo de acceso MP_WRITE. En conclusión, “handle” es el
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 7 / 15
número de pipe que nos arrojó la instrucción anterior con dwDir=0. pData: Input: Puntero al buffer que contiene los datos que se van a escribir en la pipe. El formato del dato es un arreglo de N bytes, donde N es el número de bytes que maneja el “device” en el arreglo que recibe de la PC, generalmente se declara al inicio del programa en el PIC. dwLen: Input: Especifica el número de bytes que se van a escribir en la pipe. pLenght: Output: Puntero que proporciona el número de bytes que se escriben al llamar esta función. MPUSBWrite pone este valor a cero antes de cualquier lectura o de chequear un error. dwMilliseconds: Input: Especifica el intervalo de time‐out en milisegundos. La función vuelve si transcurre el intervalo aunque no se complete la operación. Si dwMilliseconds=0, la función comprueba los datos de la pipe y vuelve inmediatamente. Si dwMilliseconds es infinito, el intervalo de time‐out nunca termina. El formato típico de la instrucción es: MPUSBWrite(myOutPipe, VarPtr(SendData(0)), bytes, VarPtr(bytes), 1000)
Por ultimo, se requiere cerrar las pipes, porque después de usarlos caducan, ya no es posible leer / escribir de nuevo. Para cerrarlos basta ejecutar la instrucción: (*MPUSBClose)(HANDLE handle); de donde
handle: Input: Identifica la pipe del Endpoint que se va a cerrar.
El formato típico de la instrucción es: MPUSBClose (myOutPipe)
Existen otras dos instrucciones que no se implementaron en éste desarrollo, pero es necesario conocerlos, éstas son:
MPUSBGETDLLVERSION(VOID) Lee el nivel de revisión del MPUSAPI.dll. Esta función devuelve la versión del código de la dll en formato hexadecimal de 32bits, no realiza nada con el puerto USB. El formato típico de la instrucción es: MPUSBGetDLLVersion()
MPUSBREADINT(HANDLE, PDATA, DWLEN, PLENGTH, DWMILLISECONDS) handle: Input: Identifica la pipe del Endpoint que se va a leer. La pipe unida tiene que crearse con el atributo de acceso MP_READ. pData: Output: Puntero al buffer que recibe el dato leído de la pipe. dwLen: Input: Especifica el número de bytes que hay que leer de la pipe. pLenght: Output: Puntero al número de bytes leídos. MPUSBRead pone este valor a cero antes de cualquier lectura o de chequear un error. dwMilliseconds: Input: Especifica el intervalo de time‐out en milisegundos. La función vuelve si transcurre el intervalo aunque no se complete la operación. Si dwMilliseconds=0, la función comprueba los datos de la pipe y vuelve inmediatamente. Si dwMilliseconds es infinito, el intervalo de time‐out nunca termina.
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 8 / 15
El formato típico de la instrucción es: MPUSBReadInt(myOutPipe, VarPtr(SendData(0)), bytes, VarPtr(bytes), 1000) TIPOS DE TRANSFERENCIAS SOPORTADO POR ESTAS INSTRUCCIONES En este apartado se recomienda que función utilizar dependiendo del tipo de transferencia. Tipo Función ¿Aplicable time‐out? Interrupt IN‐MPUSRead, MPUSReadInt ‐si Interrupt OUT‐MPUSBWrite si Bulk IN MPUSBRead si Bulk OUT MPUSWrite si Isochronous IN‐MPUSBRead no Isochronous OUT‐MPUSBWrite no Interrupt: tipo interrupción Isochronous: tipo síncrono Nota: “Input” y “output” se refiere a los parámetros designados en las llamadas a estas funciones, que son lo opuesto a los sentidos comunes desde la perspectiva de una aplicación haciendo llamadas.
DECLARACIÓN DE CONSTANTES Y VARIABLES Aquí aparecen las constantes y variables que el fabricante recomienda usar. Todas son optativas, dejando la elección al programador. También, se comentan las pequeñas variaciones que existen al declarar estas variables en los distintos lenguajes. MPUS_FAIL=0 MPUSB_SUCCESS=1 MP_WRITE=0 MP_READ=1 MAX_NUM_MPUSB_DEV=127 vid_pid= “vid_04d8&pid_0011”
En Visual Basic: out_pipe= “\MCHP_EPx” in_pipe= “\MCHP_EPy” En C y Delphi: out_pipe= “\\MCHP_EPx” in_pipe= “\\MCHP_EPy” Siendo x e y números del Endpoint por los que se van a realizar las transmisiones.
Esta dll se llama de acuerdo a la convención del lenguaje C, NO funciona si es llamada con el formato de STDLIB.
OBJETIVO
El objetivo principal del presente trabajo es integrar el software de LabVIEW con el PIC18F2455 de Microchip con el fin de diseñar una tarjeta de adquisición de datos ajustada a la necesidad personalizada de cada desarrollo.
OBJETIVOS PARTICULARES
1. Enlace a la PC mediante USB. 2. Enlace de LabVIEW al PIC. 3. Pruebas finales y correcciones.
1. ENLACE A LA PC MEDIANTE USB.
Para lograr el enlace a USB se utilizaron las funciones USB, incorporadas en el lenguaje C del programa CCS para PICS, dichas funciones están preparadas para que el microcontrolador sea reconocido como un dispositivo personalizado usando los descriptores que incluye el mismo lenguaje, se estableció la cantidad de datos a 64 bytes (8 bits por byte) de envío y recepción hacia la PC, en la PC se descarga el driver que nos proporciona Microchip en su págína web. Si tiene dudas sobre la descarga consulte el
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 9 / 15
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 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 descriptores para que se puedan hacer
Fig. 6 Instalación del PIC en la PC
Fig. 7 En propiedades del PIC instalado en la PC se observa el número de PID&VID
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 10 / 15
transacciones de 64 bytes, el VID&PID. Todo esto basándose en ejemplos que el compilador trae incluidos en la carpeta de “examples”. Cabe aclarar que los diseños en USB con PIC día a día se van incrementando. Sólo basta investigar un poco en la red para ver los resultados (Consulte la bibliografía de éste documento). El código del programa del PIC se encuentra al final del documento con sus respectivos comentarios. No olvide sustituir en el descriptor usb_desc_scope.h las 3 líneas que se comentan en el código del programa.
2. ENLACE DEL LABVIEW AL PIC PARA EL CONTROL Y MONITOREO.
Para poder iniciar el enlace con el PIC es necesario que se haya concluido satisfactoriamente la instalación del paquete de drivers de Microchip. En el mismo paquete que se descarga de la red obtenemos instrucciones y ejemplos en C++ que muestran como manipular el driver y los parámetros requeridos para aplicarlo. Sin embargo, aún no es suficiente la información, porque la dificultad está en identificar el tipo de variable que acepta cada software de desarrollo y que también sea aceptada por la DLL. Por lo que de nuevo se sugiere consultar las notas de aplicaciones de Microchip y ejemplos publicados en la web (con cualquier software de desarrollo). Para hacer la conexión con LabVIEW simplemente se “tradujeron” las instrucciones al lenguaje gráfico y se acondicionaron las variables para que la DLL pueda reconocerlo.
Por parte de LabVIEW es necesario conocer qué función es más fácil de implementar:
Existen tres métodos:
a. Hacer un ejecutable y llamarlo con la función “system exec vi”
b. Elaborar un programa en C y cargarlo en la instrucción “Code Interface Node”
c. Manipular directamente la dll con la instrucción “Call Library Function Node”
Los tres métodos nos ofrecen ventajas de acuerdo al nivel de lenguaje de programación que se tenga. En los tres casos se manipula la misma librería. En este desarrollo se utilizó el tercer método parar manipular la librería de una manera directa y sin intermediarios.
Para la implementación de los métodos anteriores el LabVIEW 8.2 ofrece una ayuda en línea, la cual permite saber al instante qué es lo que se requiere para la interconexión de los módulos. Entre las ventajas que nos ofrece el labVIEW podemos mencionar: el ambiente gráfico muy amigable, se puede mostrar mensajes, graficar los datos obtenidos, guardarlos en un archivo, habilitar un indicador, mover un detector de nivel, etc., con el fin de visualizar la ocurrencia de los eventos.
Para iniciar con la implementación del código, primero inicie el programa de LabVIEW, escoja la opción blank VI y en la barra de menús déle un click al menú de window Show block diagram.
Siguiendo los pasos descritos en la sección de antecedentes de éste documento, las instrucciones que se requieren implementar tienen la siguiente secuencia y formato en LabVIEW son:
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 11 / 15
a. Identificar el número de dispositivos conectados con el PID&VID y ubicar el que corresponde al hardware de su desarrollo. Formato:
long _MPUSBGetDeviceCount(CStr vid_pid)
De donde:
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 menú de configuración como se muestra en la figura 9. Presione la carpeta y proporcione la dirección donde se instaló la dll de Microchip (Si Ud lo instaló en la dirección sugerida anteriormente queda en “C:\Archivos de programa\Microchip Solutions\USB Tools\MCHPUSB Custom Driver\Mpusbapi\Dll\Borland_C” e inmediatamente cargará la dll. Al presionar la flecha de menú en el campo de Function Name (que apunta hacia abajo) podrá observar TODAS las funciones que la dll admite, solamente tiene que anexar las variables y acondicionar el tipo de entrada.
Recuerde que se va a implementar la primera instrucción MPUSBGetDeviceCount el cual nos proporciona como resultado el número de dispositivos conectados a la PC con el PID&VID que se va a llamar, en éste caso el PID&VID que se quiere llamar es
vid_04d8&pid_000b, según las instrucciones de uso del mpusbapi.dll tenemos que declararla como string, y la misma función proporciona una salida en formato numérico.
Fig. 8. Función Call Library Function Node vista en el block diagram
Fig. 9. Configuración de parámetros de la Función Call Library Function Node.
Conociendo esto pasos, en la misma ventana de la figura 9 presione la flecha de menú en el campo Function Name (que apunta hacia abajo) y escoja la función MPUSBGetDeviceCount como se muestra en la figura 10, seguidamente presione la pestaña “parameters” en la parte superior de la ventana y aparecerá otro menú como se muestra en la figura 11. En los campos que aparecerán a continuación llénelos como sigue:
Name: use el que trae de manera predeterminada ó un nombre que pueda identificar fácilmente a la variable type: Presione la flecha de opciones y seleccione numeric, Data type: Use el que trae de manera predeterminada, presione el botón
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 12 / 15
marcado como + y se agregará otra variable a configurar como sigue:
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 vid_04d8&pid_000b en su interior y conecte 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 traen una leyenda Long al inicio, se requiere 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 manera predeterminada y sólo agregue los demás parámetros que necesita la dll de
manera similar a lo descrito anteriormente y quedará implementada su función.
Fig. 10. Configurando la función MPUSBGetDeviceCount de mpusbapi.dll
Fig. 10 Configurando la función de salida de MPUSBGetDeviceCount de mpusbapi.dll
Fig. 11 Agregando parámetros de la función MPUSBGetDeviceCount de mpusbapi.dll
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 13 / 15
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,
Y los marcados con unsigned char * son 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:
long _MPUSBOpen(long instance, CStr VID_PID, CStr EP, long dwDir, long dwReserved)
De donde:
instance = 0, vid_pid = “vid_04d8&pid_000b”, EP = “\MCHP_EP1”, dwDir = 0, dwReserved = 0.
c. Abra la pipe para escribir (si no desea escribir puede omitir éste paso).
Formato:
long _MPUSBOpen(long instance, CStr VID_PID, CStr EP, long dwDir, long dwReserved)
Fig. 12 Funciones de mpusbapi.dll declaradas como Void
Fig. 13 Configuración del arreglo de 1X64 bytes de 8 bits que se envia/recibe del PIC desde LabVIEW
De donde:
instance = 0, vid_pid = “vid_04d8&pid_000b”, EP = “\MCHP_EP1”, dwDir = 1, dwReserved = 0.
d. Lea los datos de la pipe (solamente si la pipe está abierta) Formato:
void _MPUSBRead(long Handle, unsigned char *data, long dwlen, long *length, long dwMilliseconds)
De donde:
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 14 / 15
Handle corresponde al Número que se obtiene como resultado de la instrucción MPUSBOpen con dwDir = 0, data = es la información que envía el PIC en un vector de 64 bytes, dwlen = 64, length = 64, dwMiliseconds = 200.
e. Escriba los datos de la pipe (solamente si la pipe está abierta) Formato::
void _MPUSBWrite(long Handle, unsigned char *data, long dwlen, long *length, long dwMilliseconds)
De donde:
Handle = Número obtenido como resultado de la instrucción MPUSBOpen con dwDir = 1, data = es la información que se envía al PIC en un vector de 64 bytes, dwlen = 64, length = 64, dwMiliseconds = 200.
f. Cierre la(s) pipe(s) abierta(s), ya que una vez usados, éstos caducan. Recordemos que si se abren 2 pipes, ambas hay que cerrarlas.
Formato:
void _MPUSBClose(long Handle);
De donde:
Handle = Número obtenido como resultado de la instrucción MPUSBOpen con dwDir = 0
Y para la última “pipe”, Formato:
void _MPUSBClose(long Handle);
De donde:
Handle = Número que porporciona como resultado de la instrucción MPUSBOpen con dwDir = 1
Recuerde que se debe abrir una “pipe” a la vez (hay que usar dos veces ésta instrucción), una vez con dwDir=1 para abrir la pipe para leer y con dwDir=0 para abrir la pipe para escribir al PIC, el resultado que nos arroja ésta instrucción es el número de pipe que nos asigna el sistema operativo.
No olvide seguir la secuencia de apertura y cierre de la “pipe” con una “structura” del tipo “Flat sequence” para su ejecución en secuencia. El código implementado en labVIEW <<DAQ.vi >> puede solicitarlo a los siguientes correos electrónicos: [email protected], [email protected]
Una vez enlazado con el PIC, los datos pueden fluir las veces que sea necesario de un sentido a otro y manipularlos como se desee, ya que se tiene el completo control del software del PIC (por parte del Compilador C) y en la PC (por parte del LabVIEW). Asegúrese que la dll quede instalado en:
C:\Archivos de programa \Microchip Solutions\USB Tools\MCHPUSB Custom Driver\Mpusbapi\Dll
3. Pruebas finales y correcciones.
Para el enlace con la PC por USB es muy importante conectar el capacitor (C4) de 0.1uF como se indica en el diagrama, ya que, si se omite generará un error al momento del enlace. También es muy importante habilitar el fusible VREGEN para que Vusb sea activado.
Es importante considerar la función del PLL del PIC ya que de acuerdo al valor de la frecuencia del cristal depende el valor de la
Integración de PIC18Fxx5x de Microchip™ con LabVIEW™ 8.2 de National Instruments™ 15 / 15
multiplicación de la frecuencia del reloj para generar los 48Mhz necesarios para el USB.
Por lo que respecta al descriptor del USB, es importante considerar el valor del VID & PID, ya que si no es configurado correctamente, el driver que proporciona Microchip no lo reconocerá y en consecuencia, no funcionará. Para esto no olvide sustituir en el descriptor las 3 líneas que se comentan en el código del programa que se anexa en éste documento.
La DLL que proporciona Microchip se puede descargar desde su sitio web. Asegurese de obtener la versión más actual. En la dirección web que se menciona en la bibliografía se descarga el driver, en caso de
haber caducado busque en la sección Design
Aplication Design Center Wired
Conectivity USB Software/Tools
MCHPFSUSB Framework v2.1 ó simplemente teclee “usb software/tools” en la ventanita de búsqueda y déle un clic en el botón “site search”, generalmente el acceso a la página queda en los primeros resultados de la búsqueda, el cual, al darle click lleva directamente al driver. En el mismo paquete incluye ejemplos que incluyen el programa fuente para la compresión de su uso.
En caso de que el LabVIEW genere error al ejecutar el programa, es importante verificar que el driver de Microchip quede en C:\Archivos de Programa\ del disco duro ya que se tomará como referencia para el llamado de la dll y que el archivo que se descargó sea el que está llamado Microchip MCHPFSUSB v2.1 Installer (la última versión).
Se recomienda verificar el archivo que nos proporciona Microchip en el driver, en la siguiente dirección:
"C:\ ARCHIVOS DE PROGRAMA\MICROCHIP SOLUTIONS\USB TOOLS\MCHPUSB CUSTOM DRIVER\MCHPUSB DRIVER\MCHPUSB DRIVER RELEASE NOTES.HTM"
Ahí se proporciona información sobre la compatibilidad en sistemas operativos y ejemplos desarrollados.
BIBLIOGRAFÍA
http://www.usb.org/developers/docs/
http://slalen.iespana.es/programacion/datos/MPUSBApi.pdf
www.google.com.mx búsqueda “PIC USB”.
http://www.hobbypic.com/
http://www.todopic.com.ar/foros/index.php?topic=13418.0;do=Bookmark
http://picmania.garcia‐cuervo.com/index.php
Driver de microchip:
http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2651¶m=en534494
Descarga directa :
http://ww1.microchip.com/downloads/en/DeviceDoc/Microchip%20MCHPFSUSB%20v2.1%20Installer.zip
Asegúrese que el archivo sea el que tiene por nombre MCHPFSUSB Framework v2.1
DAQCó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: [email protected] //////// y [email protected] //////// /////////////////////////////////////////////////////////////////////////////
#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'sPIC 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
DAQint8 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 almacenaen 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
5
4
4
3
3
2
2
1
1
D D
C C
B B
A A
ENTRADAS
SALIDAS
Diseñado por: Ing. Gabriel Pool, [email protected] Julio Lugo, [email protected]
DAQ 01
Integración de PIC18F2455 con LabVIEW 8.2
A
1 1Monday, July 07, 2008
Title
Size Document Number Rev
Date: Sheet of
+5V
+5V +12V
+5V
+5V
+5V
S1SW
J1
US
B1234
C11000uF
C722pF
D5
J4
ICSP
12345
D2
R4150
D4
R210K
D8
S1SW
C822pF
R210K
S1SW
R5150
D1
R610K
S1SW
S1SW
X112 MHz
R4150
S1SW
R110K
R5150
D3
R7100
J3
PO
WE
R S
UP
PLY
1234
D7D6
S1SW
C22200uF
R210K
R210K
R5150
R4150
R5150
R110K
C40.1uF
C50.1uF
R4150
U2PIC18F2455
819
1
9
20
234567
2122232425262728
11
12
13
14
1516
1718
10
GN
DG
ND
MCLR/VPP/RE3
OS
C1/
CLK
I
VD
DRA0RA1RA2RA3RA4/T0CKI/C1OUT/RCVRA5/SS
RB0/INTRB1RB2RB3RB4RB5RB6RB7
RC0/T1OSO/T13CKI
RC1
RC2
VUSB
RC4/D-/VMRC5/D+/VP
RC6/TX/CKRC7/RX/DT/SDO
OS
C2/
CLK
O/R
A6
RB0RB1RB2RB3RB4RB5
RB6RB7
RB
0
RB
1
RB
2
RB
3
RB
4
RB
5
RB
6
RB
7
RA
4
RA
5
RA
0
RA
2
RA
3
RA
1
RA3
RA5RA4
RA1RA2
RA0