PROBLEMA DE INGENIERÍA

Transcripción

1 UNIVERSIDAD TECNOLOGICA NACIONAL FACULTAD REGIONAL SAN NICOLAS INGENIERIA EN ELECTRONICA PROBLEMA DE INGENIERÍA TECNICAS DIGITALES III ADQUISIDOR GENÉRICO USB Integrantes: Docentes: Chiodín Sebastián Fernández Torres Walter - Profesor: Poblete Felipe - Auxiliar: González Mariano AÑO 2008

2 INDICE OBJETIVOS DEL TRABAJO 3 MATERIAS INTEGRADAS... 3 POSIBLES APLICACIONES... 3 PROFESORES ENTREVISTADOS...3 BIBLIOGRAFÍA...3 DESARROLLO 4 INTRODUCCIÓN...4 TEORÍA DE FUNCIONAMIENTO...9 DIAGRAMA EN BLOQUES... 9 INTERFAZ USB...11 PROGRAMACIÓN DEL MICROCONTROLADOR RESULTADOS DE LAS PRUEBAS...13 CONCLUSIONES...13 ANEXOS: 14 LISTADOS DE PROGRAMAS CIRCUITO FOTOS DEL PROTOTIPO...56 IMÁGENES DEL PROGRAMADOR...56 FOTOS DE PANTALLA

3 OBJETIVOS DEL TRABAJO Se pretende el diseño de un dispositivo que permita la adquisición de datos en una PC a través del puerto USB y una precisión de 0.1% (10 bits) para variables analógicas. Estos datos pueden ser de diversa índole, ya sean digitales o analógicos. La entradas digitales y analógicas que usaremos serán: 0-5v (ttl) y 0-5v respectivamente. La salida digital será dada por el ttl. MATERIAS INTEGRADAS Medidas Electrónicas II Instrumentación. Máquinas eléctricas. Comunicaciones II POSIBLES APLICACIONES Las posibles aplicaciones del proyecto son prácticamente inmediatas, debido a que uno de los principales roles que juega la Ingeniería Electrónica en la actualidad es principalmente la adquisición y procesamiento de datos en una gran cantidad de procesos tales como Industriales, Financieros, Biológicos, Sociales, etc. PROFESORES ENTREVISTADOS Ing. Víctor Culasso (Características del conversor A/D) Ing. Néstor Chiodin (Aplicación del adquisidor para motores trifásicos). Ing. Sebastián Shaller (Comparación de USB frente a protocolos de RED). BIBLIOGRAFÍA Apuntes de cátedra. Apunte 3, Programación de ensamblador Ing. Felipe Poblete Sitios de Internet. Microsoft MSDN, Sitio Oficial Universal Serial Bus (USB), Sitio Oficial de Microchip, Chris H. Pappas, William H. Murray, Manual de referencia Visual C++.NET, Mc. Graw Hill Andrew S. Tanenbaum, Organización de computadoras, un enfoque estructurado, Pearson Education

4 DESARROLLO INTRODUCCIÓN USB es una especificación de las empresas Compaq, Intel, Microsoft y NEC, que describe un canal serie que soporta una gran variedad de periféricos de media y baja velocidad, con soporte integral para transferencias en tiempo real (isócronas) como voz, audio y vídeo comprimido, y que permite mezclar dispositivos y aplicaciones isócronas y asíncronas. Por lo tanto, entre los dispositivos USB más característicos se pueden citar teclados, ratones, joysticks, tabletas gráficas, monitores, módems, impresoras, escáneres, CD-ROMs, dispositivos de audio (como micrófonos o altavoces digitales), cámaras digitales y otros dispositivos multimedia. Posee las siguientes características: Un acceso al bus gestionado directamente por el Controlador USB, para permitir transferencias isócronas y eliminar los tiempos de arbitración. Una velocidad de 12 Mbps (Full Speed o FS) y un subcanal de 1,5 Mbps (Low Speed o LS) para los dispositivos más lentos, como ratones y joysticks. Una conectividad excepcional, ya que puede manejar hasta 127 dispositivos simultáneamente que se pueden conectar y desconectar en caliente, sin tener que reiniciar el sistema. Una configuración automática de dispositivos, que elimina la necesidad de realizar configuraciones manuales por medio de puentes o conmutadores. La coexistencia de dispositivos isócronos y asíncronos. Los dispositivos isócronos se atienden en función del ancho de banda y latencia requeridos, y los asíncronos se atienden durante el tiempo restante no consumido por los dispositivos isócronos. Una distribución de alimentación desde el Controlador USB, que permite la conexión tanto de dispositivos alimentados desde el bus como autoalimentados. Una arquitectura fácilmente escalable para permitir la existencia de varios Controladores USB en un sistema. NIVEL FISICO A nivel físico, USB utiliza un cable de 4 conductores para transmitir una señal diferencial (D + y D - ) y alimentación (V Bus = 5V y GND) por medio de conexiones punto a punto. Los dispositivos LS van obligatoriamente equipados con un cable de longitud adecuada (hasta unos 3 m, dependiendo de sus características eléctricas), mientras que los FS pueden ir equipados con un cable o utilizar cables independientes de hasta 5 m (también dependiendo de sus características eléctricas). Los dispositivos disponen de un transmisor diferencial, receptores diferencial y S/E y resistencias de terminación con los que pueden transmitir y detectar varios estados eléctricos distintos en la línea: Amplio catálogo de modernos periféricos: ratones, teclados, escáneres, cámaras fotográficas, capturadoras TV, monitores, discos duros, otro PC, etc. Posee las siguientes características: El periférico puede alimentarse de este puerto, por lo que si no gasta mucho, no necesita fuente de alimentación (cuidado, los vatios no son infinitos). Se necesitan menos componentes, por lo que los periféricos deben ser más baratos. 4

5 Facilita la compatibilidad entre Mac y PC. Podemos conectar un gran número de periféricos a un sólo PC (en teoría 127 por puerto) que por otros medios sería imposible por las limitaciones de IRQs. TIPOS DE TRANSFERENCIAS DE DATOS USB soporta 4 tipos de transferencias de datos: Transferencias de Control Se desarrollan en 3 Transacciones: Transacción de Configuración (Setup), en la que se envía al dispositivo un paquete que especifica la operación a ejecutar. Ocupa 8 bytes. Cero o más Transacciones de Datos, en las que se transfieren los paquetes de datos en el sentido indicado por la Transacción de Configuración. La información útil por paquete puede ser de 8, 16, 32 ó 64 bytes para endpoints FS, y de 8 bytes para Endpoints LS. Transacción de Estado, en la que el receptor informa del estado final de la operación. Se procesan por medio de un mecanismo "best effort", según el cual el Controlador USB las va procesando en función del tiempo disponible en cada Trama. Como mínimo se reserva el 10% del tiempo de Trama, y se puede utilizar tiempo adicional siempre que las necesidades de los tráficos isócrono y de interrupción lo permitan. Incorporan mecanismos de detección de errores (CRC) y de recuperación/retransmisión de datos. Transferencias Isócronas Sólo son utilizables por dispositivos FS. La información útil por paquete puede oscilar entre 1 y 1,023 bytes. En cada Trama se transfiere un paquete por cada conexión isócrona establecida. El sistema puede asignar como máximo el 90% del tiempo de Trama para transferencias isócronas y de interrupción. Si el sistema ya tiene asignado un tiempo de Trama de forma que no garantiza tiempo suficiente como para manejar una nueva conexión isócrona (transmitir un nuevo paquete por Trama), simplemente no se establece la conexión. Los posibles errores no se recuperan (la información que no llega a su tiempo, se descarta). Transferencias de Interrupción Aseguran una transacción (paquete) dentro de un periodo máximo (los dispositivos FS pueden solicitar entre 1 y 255 ms, y los LS entre 10 y 255 ms de periodo máximo de servicio). Incorpora detección de errores y retransmisión de datos. La información útil por paquete puede oscilar entre 1 y 64 bytes para dispositivos FS y entre 1 y 8 bytes para dispositivos LS. El sistema puede asignar como máximo el 90% del tiempo de Trama para transferencias isócronas y de interrupción. Si el sistema no puede garantizar tiempo suficiente como para manejar una nueva conexión de interrupción (transmitir un nuevo paquete dentro del periodo máximo requerido), simplemente no se establece la conexión. 5

6 Transferencias Bulk Sólo son utilizables por dispositivos FS. Se procesan por medio de un mecanismo "good effort", en el que el sistema aprovecha cualquier ancho de banda disponible y en el momento en que esté disponible (en otras palabras, no se garantiza una latencia ni un ancho de banda mínimos). Se puede utilizar el tiempo de Trama reservado y no consumido por transferencias de Control (10%). Incorporan mecanismos de control de errores para garantizar la entrega de datos. La información útil por paquete puede ser de 8, 16, 32 ó 64 bytes. DESCRIPTORES Desde el punto de vista del sistema USB, un dispositivo puede tener varias posibles Configuraciones, en cada una de las cuales el dispositivo puede funcionar de una manera distinta. En cada una de las posibles Configuraciones, el dispositivo queda organizado como un conjunto de Interfaces, donde cada Interfaz especifica qué partes del hardware del dispositivo interactúa con el sistema USB. Cada una de esas partes de hardware se denomina Endpoint. Entonces, de una manera jerárquica, un dispositivo es una colección de posibles Configuraciones, cada Configuración es una colección de Interfaces, y cada Interfaz es una colección de Endpoints. A su vez los Interfaces pueden admitir configuraciones alternativas, con distintas colecciones de Endpoints en cada una de ellas. Los dispositivos proporcionan toda la información descriptiva al sistema a través de unas estructuras de datos denominados Descriptores. Existen distintos descriptores que proporcionan información a nivel de dispositivo, de configuración, de interfaz y de endpoint. Las especificaciones de Clase USB definen las configuraciones, interfaces (y sus configuraciones alternativas) y endpoints que los dispositivos pertenecientes a dicha Clase o Subclase deben soportar. A continuación se detalla el esquema de los descriptores quien emplea el PIC18F4550 en su mapa de memoria. 6

7 CLASES, SUBCLASES Y PROTOCOLOS Los descriptores de dispositivo y de interfaz contienen una serie de campos que permiten al sistema clasificar a los dispositivos. Estos campos son la Clase, la Subclase y el Protocolo. El Sistema Operativo puede utilizar estos campos para localizar y asociar al dispositivo o interfaz un determinado Driver de Clase, de entre todos los Drivers de esa Clase disponibles en el sistema. También puede seleccionar una determinada configuración del dispositivo, o una determinada configuración alternativa de un interfaz, en función de los protocolos soportados por los distintos Drivers de Clase disponibles en el sistema para esa Clase y Subclase de dispositivo. CAPAS DE USB 7

8 La funcionalidad de los dispositivos USB se halla estructurada en un marco de capas. Cada nivel se asocia con un nivel funcional dentro del dispositivo. La capa más alta, excepto el dispositivo, es de configuración. Un dispositivo puede tener múltiples configuraciones. Por ejemplo, un particular dispositivo puede tener múltiples requisitos de alimentación basado en auto alimentación. Para cada configuración, puede haber múltiples interfaces. Cada interfaz podría apoyar un particular de modo de la configuración. Debajo de la interfaz es el Endpoint (s). Los datos son directamente trasladados a este nivel. No puede haber más de 16. El endpoint 0 siempre es un enpoint de control y por defecto, cuando el dispositivo está en el bus, el endpoint 0 debe estar disponibles para configurar el dispositivo. CARACTERÍSTICAS DE DISTINTAS INTERFACES Puerto serie y puerto paralelo Uno de los defectos de los puertos serie iníciales era su lentitud en comparación con los puertos paralelos, hablamos de 19.2 kbits por segundo, sin embargo, con el paso del tiempo, están apareciendo multitud de puertos serie de alta velocidad que los hacen muy interesantes ya que utilizan las ventajas del menor cableado y solucionan el problema de la velocidad con un mayor apantallamiento y más barato usando la técnica del par trenzado. Por ello, el puerto RS-232 e incluso multitud de puertos paralelos están siendo reemplazados por nuevos puertos serie como el USB TCP/IP La arquitectura de un sistema en TCP/IP tiene una serie de metas: La independencia de la tecnología usada en la conexión a bajo nivel y la arquitectura del ordenador Conectividad Universal a través de la red Reconocimientos de extremo a extremo Protocolos estandarizados Comparándolo con USB destacamos los siguientes aspectos Tiene Mayor velocidad de transmisión de datos que USB. Más difícil de configurar. Es más caro. Requiere de conocimientos de programación más elevados en cuanto al manejo de las tramas y capas. 8

9 BENEFICIOS DE USB Interface para muchas aplicaciones Autoconfiguración No requiere suministro propio de energía Conexión y desconexión Plug & Play Alguas configuraciones no necesita drivers particulares, por ejemplo dispositivo HID. Fácil uso Amplio código y espacio de datos para las aplicaciones complejas TEORÍA DE FUNCIONAMIENTO El dispositivo opera como HID (Human Interface Device) por lo que no requiere drivers externos, sino que emplea los mismos archivos de sistema de Windows Para realizar la conexión (Pipe) entre la aplicación. La única desventaja que conlleva emplear el dispositivo como HID es la disminución de velocidad de comunicación a un máximo de 512Kb/Seg. Además una ventaja muy importante en lo que respecta haber elegido este tipo de interface para resolver este problema de ingeniería fue el manejo de la tecnología mediante un lenguaje de programación conocido (visual C++). DIAGRAMA EN BLOQUES A continuación se detallan los elementos que componen el adquisidor. ENTRADA DIGITAL SOFTWARE SEÑAL ANALÓGICA SISTEMA DE CONTROL INTERFRAZ USB SALIDA DIGITAL PC Fig. 1 9

10 Descripción del diagrama en bloques Señal Analógica: Es la señal de entrada proveniente del mundo real, puede ser tensión corriente, etc. Entrada Digital: Dicha fase corresponde al ingreso de señales binarias al adquisidor. Salida Digital: La presente etapa, indicará a través de una columna de diodos LEDS los valores enviados desde la PC hacia el dispositivo USB. Sistema de Control: Es el componente principal del hardware, su función radica en leer la señal analógica y convertirla a binario, así como censar la entrada digital. De este modo, envía los datos binarios a la PC a través de la interfaz USB. Así mismo puede exhibir datos provenientes de la PC en la columna de LEDS. Se empleará el microcontrolador PIC18F4550, el cual posee conversor Analógico / Digital, así como puertos de conexión USB, debido a que de otra manera se debería usar otro chip mas para la interfaz USB. Pudiendo así poder unir estos bloques de control e interfaz y lograr simplicidad en el proyecto. Interfaz USB: Corresponde al puente de comunicación entre la PC y el Hardware, se halla integrada dentro del microcontrolador en el sistema de control. PC: Constituye uno de los aspectos principales del sistema, es la encargada de comunicarse con el Hardware ya sea enviando o recibiendo datos. Software: Como ya mencionamos anteriormente se refiere al programa que permita el proceso de comunicación entre la PC y el dispositivo USB. 10

11 INTERFAZ USB A continuación se detalla una breve explicación del funcionamiento de la interfaz USB incorporada en el dispositivo PIC18F4550. La familia de dispositivos PIC18FX455/X550 contiene un motor de interfaz USB (SIE) compatible para conexión en alta velocidad y baja velocidad. El SIE puede ser conector directamente al conector USB de la PC, utilizando el transreceptor interno, o puede ser conectado por un transreceptor externo. Un regulador interno de 3.3V está también disponible para alimentar el transreceptor interno. Algunos rasgos de hardware especiales han sido incluidos para mejorar el funcionamiento. La memoria de puerto dual ha sido suministrada para compartir el acceso de memoria directo entre el microcontrolador y el SIE. También proporcionan descriptores de los buffer, permitiendo a usuarios programar libremente el uso de memoria para los Endpoints en la RAM destinada al bus USB. Además se ha proporcionado un puerto paralelo para permitir la transferencia ininterrumpida de grandes volúmenes de información, tales como la transferencia isócrona hacia o desde Buffers de memoria Externos. 11

12 PROGRAMACIÓN DEL MICROCONTROLADOR En la programación del presente dispositivo se ha modificado y adaptado el FrameWork provisto por Microchip para el tratamiento de enlace USB a través de la configuración en modo HID (Human Interface Device). Dicho código es freeware y se puede descargar del sitio El presente Firmware emplea elementos avanzados de programación y compilación condicional, por lo cual ha sido uno de los factores de más ardua realización en el desarrollo del Problema de Ingeniería. El programa principal inicializa la configuración de puertos y demás dispositivos con la función InitializeSystem() (Véase Página 40). El cuerpo principal opera como un bucle que se ejecuta indefinidamente con dos funciones dentro del mismo: USBDeviceTasks() y ProcessIO()(Véase Páginas 39 y 40). USBDeviceTasks() procesa los pedidos del sistema de interrupciones y transferencias de control entre la PC y el dispositivo USB. ProcessIO() (Véase Páginas 43y 44) es encargada de procesar las entradas y las salidas a través de USB, dicha función ha sido adaptada con una tabla de códigos para realizar el proceso de Hand-Shake entre la PC y el microcontrolador. Diagrama de Flujo Simplificado del Firmware Inicio Configurar PLL interno Configuración Puertos Puerto D Salida Puerto B entrada Configurar Conversor A/D Código de atención Interrupción conversor Analógico Digital (Pag. 38, YourLowPriorityISRCode()) Procesamiento de E/S [ProcessIO()] Atención trasferencias de control e interrupciones USB [USBDeviceTasks()] 12

13 RESULTADOS DE LAS PRUEBAS Los resultados de la pruebas han sido satisfactorios desde todo punto de vista, debido a que el adquisidor opera prácticamente en cualquier sistema operativo Windows sin necesidad de Driver Particulares al estar configurado como dispositivo HID. Sin embargo no fue un proceso de desarrollo directo, sino que hubo que solucionar varios inconvenientes tales como frecuencia de sincronismo del sistema, desarrollo de las tablas de Hand-Shake, entre otros. CONCLUSIONES Tras desarrollar, en un lapso de tiempo comprendido desde el mes de Mayo hasta Noviembre del presente año, el Problema de Ingeniería referente al Adquisidor genérico USB, hemos incorporado un amplio espectro de conocimientos relacionados con el Protocolo USB, Programación de las nuevas familias de Microcontroladores de Microchip, manejo del lenguaje Visual C ++ y.net Framework. Además se ha hecho hincapié en el trabajo grupal como herramienta integradora, permitiendo así obtener un panorama de las metodologías de trabajo grupal empleadas hoy en día a través de equipos de desarrollo. 13

14 ANEXOS: LISTADOS DE PROGRAMAS Creación del vínculo de interfaz con el dispositivo A continuación se detalla la implementación del fragmento de código en Visual C++ para poder inicializar el vínculo con el dispositivo. Para este fin empleamos las funciones de los archivos de sistema Setupapi.dll, las llamadas a las funciones se han obtenido del sitio oficial de MSDN. Aplicación de los DLL Gives us "PSP_DEVICE_INTERFACE_DATA" which contains the Interface specific GUID (different from class GUID). We need the interface GUID to get the device path. [DllImport("setupapi.dll", CharSet = CharSet::Seeifdef, EntryPoint="SetupDiEnumDeviceInterfaces")] extern "C" WINSETUPAPI BOOL WINAPI SetupDiEnumDeviceInterfacesUM( HDEVINFO DeviceInfoSet, Input: Give it the HDEVINFO we got from SetupDiGetClassDevs() PSP_DEVINFO_DATA DeviceInfoData, Input (optional) LPGUID InterfaceClassGuid, Input DWORD MemberIndex, Input: "Index" of the device you are interested in getting the path for. PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData);Output: This function fills in an "SP_DEVICE_INTERFACE_DATA" structure. SetupDiDestroyDeviceInfoList() frees up memory by destroying a DeviceInfoList [DllImport("setupapi.dll", CharSet = CharSet::Seeifdef, EntryPoint="SetupDiDestroyDeviceInfoList")] extern "C" WINSETUPAPI BOOL WINAPI SetupDiDestroyDeviceInfoListUM( HDEVINFO DeviceInfoSet); device info list to deallocate from RAM. Input: Give it a handle to a SetupDiEnumDeviceInfo() fills in an "SP_DEVINFO_DATA" structure, which we need for SetupDiGetDeviceRegistryProperty() [DllImport("setupapi.dll", CharSet = CharSet::Seeifdef, EntryPoint="SetupDiEnumDeviceInfo")] extern "C" WINSETUPAPI BOOL WINAPI SetupDiEnumDeviceInfoUM( HDEVINFO DeviceInfoSet, DWORD MemberIndex, PSP_DEVINFO_DATA DeviceInfoData); SetupDiGetDeviceRegistryProperty() gives us the hardware ID, which we use to check to see if it has matching VID/PID [DllImport("setupapi.dll", CharSet = CharSet::Seeifdef, EntryPoint="SetupDiGetDeviceRegistryProperty")] extern "C" WINSETUPAPI BOOL WINAPI SetupDiGetDeviceRegistryPropertyUM( HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Property, PDWORD PropertyRegDataType, PBYTE PropertyBuffer, DWORD PropertyBufferSize, PDWORD RequiredSize); SetupDiGetDeviceInterfaceDetail() gives us a device path, which is needed before CreateFile() can be used. [DllImport("setupapi.dll", CharSet = CharSet::Seeifdef, EntryPoint="SetupDiGetDeviceInterfaceDetail")] 14

15 extern "C" BOOL SetupDiGetDeviceInterfaceDetailUM( HDEVINFO DeviceInfoSet, Input: Wants HDEVINFO which can be obtained from SetupDiGetClassDevs() PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, Input: Pointer to an structure which defines the device interface. PSP_DEVICE_INTERFACE_DETAIL_DATA DeviceInterfaceDetailData, Output: Pointer to a strucutre, which will contain the device path. DWORD DeviceInterfaceDetailDataSize, Input: Number of bytes to retrieve. PDWORD RequiredSize, Output (optional): Te number of bytes needed to hold the entire struct PSP_DEVINFO_DATA DeviceInfoData); Output Subrutina de Vinculo Con el dispositivo private: System::Void tmrtemp_tick(system::object^ sender, System::EventArgs^ e) Identificadores Globales Guid. GUID InterfaceClassGuid = 0x4d1e55b2, 0xf16f, 0x11cf, 0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30; HDEVINFO DeviceInfoTable = INVALID_HANDLE_VALUE; PSP_DEVICE_INTERFACE_DATA InterfaceDataStructure = new SP_DEVICE_INTERFACE_DATA; PSP_DEVICE_INTERFACE_DETAIL_DATA DetailedInterfaceDataStructure = new SP_DEVICE_INTERFACE_DETAIL_DATA; SP_DEVINFO_DATA DevInfoData; DWORD InterfaceIndex = 0; DWORD StatusLastError = 0; DWORD dwregtype; DWORD dwregsize; DWORD StructureSize = 0; PBYTE PropertyValueBuffer; bool MatchFound = false; DWORD ErrorStatus; String^ DeviceIDToFind = MY_DEVICE_ID; Obtengo la lista de dispositivos DeviceInfoTable = SetupDiGetClassDevsUM(&InterfaceClassGuid, NULL, NULL, DIGCF_PRESENT DIGCF_DEVICEINTERFACE); Examino la lista en busqueda de elementos while(true) InterfaceDataStructure->cbSize = sizeof(sp_device_interface_data); SetupDiEnumDeviceInterfacesUM(DeviceInfoTable, NULL, &InterfaceClassGuid, InterfaceIndex, InterfaceDataStructure); ErrorStatus = GetLastError(); if(error_no_more_items == GetLastError()) Si llegue al ultimo dispositivo, finalizo El dispositivo no está conectado SetupDiDestroyDeviceInfoListUM(DeviceInfoTable); Limpio la estructura que no nece return; Obtengo el Hardware ID para ver si es el del dispositivo que busco &DevInfoData); Inicializo estructuras auxiliares DevInfoData.cbSize = sizeof(sp_devinfo_data); SetupDiEnumDeviceInfoUM(DeviceInfoTable, InterfaceIndex, 15

16 Pregunto por el tamano del ID SetupDiGetDeviceRegistryPropertyUM(DeviceInfoTable, &DevInfoData, SPDRP_HARDWAREID, &dwregtype, NULL, 0, &dwregsize); memoria Almaceno memoria apropiada PropertyValueBuffer = (BYTE ) malloc (dwregsize); if(propertyvaluebuffer == NULL) Si es nulo, no puedo almacenar Salgo SetupDiDestroyDeviceInfoListUM(DeviceInfoTable); return; Retrieve the hardware IDs for the current device we are looking at. PropertyValueBuffer gets filled with a REG_MULTI_SZ (array of null terminated strings). To find a device, we only care about the very first string in the buffer, which will be the "device ID". The device ID is a string which contains the VID and PID, in the example format "Vid_04d8&Pid_003f". SetupDiGetDeviceRegistryPropertyUM(DeviceInfoTable, &DevInfoData, SPDRP_HARDWAREID, &dwregtype, PropertyValueBuffer, dwregsize, NULL); Now check if the first string in the hardware ID matches the device ID of my USB device. #ifdef UNICODE String^ DeviceIDFromRegistry = gcnew String((wchar_t )PropertyValueBuffer); #else String^ DeviceIDFromRegistry = gcnew String((char )PropertyValueBuffer); #endif Convert both strings to lower case. This makes the code more robust/portable accross OS Versions DeviceIDFromRegistry = DeviceIDFromRegistry->ToLowerInvariant(); DeviceIDToFind = DeviceIDToFind->ToLowerInvariant(); VID/PID Now check if the hardware ID we are looking at contains the correct MatchFound = DeviceIDFromRegistry->Contains(DeviceIDToFind); if(matchfound == true) DetailedInterfaceDataStructure->cbSize = sizeof(sp_device_interface_detail_data); Obtengo la Lista de dispositivos SetupDiGetDeviceInterfaceDetailUM(DeviceInfoTable, InterfaceDataStructure, NULL, NULL, &StructureSize, NULL); DetailedInterfaceDataStructure = (PSP_DEVICE_INTERFACE_DETAIL_DATA)(malloc(StructureSize)); Almacena memoria if(detailedinterfacedatastructure == NULL) Si es nulo Salgo. SetupDiDestroyDeviceInfoListUM(DeviceInfoTable); Limpio la estructura que no se emplea return; DetailedInterfaceDataStructure->cbSize = sizeof(sp_device_interface_detail_data); Llamo nuevamente a la función SetupDiGetDeviceInterfaceDetailUM(DeviceInfoTable, InterfaceDataStructure, DetailedInterfaceDataStructure, StructureSize, NULL, NULL); Almaceno los Handles en Write Handle y readhandle 16

17 WriteHandle = CreateFile((DetailedInterfaceDataStructure- >DevicePath), GENERIC_WRITE, FILE_SHARE_READ FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0); ErrorStatus = GetLastError(); if(errorstatus == ERROR_SUCCESS) ToggleLED_btn->Enabled = true; ReadHandle = CreateFile((DetailedInterfaceDataStructure- >DevicePath), GENERIC_READ, FILE_SHARE_READ FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0); ErrorStatus = GetLastError(); if(errorstatus == ERROR_SUCCESS) LblEnt->Enabled=true; groupbox1->enabled=true; LblPot->Enabled=true; b_encender->enabled=true; s_usb(v_salida); TmrEnt->Enabled=true; Habilito el timer de pedido de datos SetupDiDestroyDeviceInfoListUM(DeviceInfoTable); la Estructura que no se emplea return; Limpio lista Fin While InterfaceIndex++; Barro el Bucle hasta que se encuentre el dispositivo o finalize la Código Completo del programa en Visual C++ Debido a que se ha empleado el método de programación con las librerías CLR (Common Languaje Resourse) de windows, el código principal del programa se halla inmerso en una librería de extensión.h. El nombre del Archivo es Form1.h #pragma once #include <Windows.h> #include <setupapi.h> #include <string.h> #define MY_DEVICE_ID "Vid_04d8&Pid_003F" namespace AquisidorGenericoUSB using namespace System; using namespace System::ComponentModel; using namespace System::Collections; using namespace System::Windows::Forms; using namespace System::Data; using namespace System::Drawing; using namespace System::Runtime::InteropServices; Need this to support "unmanaged" code. / In order to use these unmanaged functions from within the managed.net environment, we need 17

18 to explicitly import the functions which we will be using from other.dll file(s). Simply including the appropriate header files is not enough. Note: In order to avoid potential name conflicts in the header files (which we still use), I have renamed the functions by adding "UM" (unmanaged) onto the end of them. To find documentation for the functions in MSDN, search for the function name without the extra "UM" attached. Note2: In the header files (such as setupapi.h), normally the function names are remapped, depending upon if UNICODE is defined or not. For example, two versions of the function SetupDiGetDeviceInterfaceDetail() exist. One for UNICODE, and one for ANSI. If the wrong version of the function is called, things won't work correctly. Therefore, in order to make sure the correct one gets called (based on your compiler settings, which may or may not define "UNICODE"), it is useful to explicity specify the CharSet when doing the DLL import. / #ifdef UNICODE #define Seeifdef Unicode #else #define Seeifdef Ansi #endif Returns a HDEVINFO type for a device information set (USB HID devices in our case). We will need the HDEVINFO as in input parameter for calling many of the other SetupDixxx() functions. [DllImport("setupapi.dll", CharSet = CharSet::Seeifdef, EntryPoint="SetupDiGetClassDevs")] extern "C" HDEVINFO SetupDiGetClassDevsUM( LPGUID ClassGuid, Input: Supply the class GUID here. PCTSTR Enumerator, Input: Use NULL here, not important for our purposes HWND hwndparent, Input: Use NULL here, not important for our purposes DWORD Flags); Input: Flags describing what kind of filtering to use. Gives us "PSP_DEVICE_INTERFACE_DATA" which contains the Interface specific GUID (different from class GUID). We need the interface GUID to get the device path. [DllImport("setupapi.dll", CharSet = CharSet::Seeifdef, EntryPoint="SetupDiEnumDeviceInterfaces")] extern "C" WINSETUPAPI BOOL WINAPI SetupDiEnumDeviceInterfacesUM( HDEVINFO DeviceInfoSet, Input: Give it the HDEVINFO we got from SetupDiGetClassDevs() PSP_DEVINFO_DATA DeviceInfoData, Input (optional) LPGUID InterfaceClassGuid, Input DWORD MemberIndex, Input: "Index" of the device you are interested in getting the path for. PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData);Output: This function fills in an "SP_DEVICE_INTERFACE_DATA" structure. SetupDiDestroyDeviceInfoList() frees up memory by destroying a DeviceInfoList [DllImport("setupapi.dll", CharSet = CharSet::Seeifdef, EntryPoint="SetupDiDestroyDeviceInfoList")] extern "C" WINSETUPAPI BOOL WINAPI SetupDiDestroyDeviceInfoListUM( HDEVINFO DeviceInfoSet); device info list to deallocate from RAM. Input: Give it a handle to a 18

19 SetupDiEnumDeviceInfo() fills in an "SP_DEVINFO_DATA" structure, which we need for SetupDiGetDeviceRegistryProperty() [DllImport("setupapi.dll", CharSet = CharSet::Seeifdef, EntryPoint="SetupDiEnumDeviceInfo")] extern "C" WINSETUPAPI BOOL WINAPI SetupDiEnumDeviceInfoUM( HDEVINFO DeviceInfoSet, DWORD MemberIndex, PSP_DEVINFO_DATA DeviceInfoData); SetupDiGetDeviceRegistryProperty() gives us the hardware ID, which we use to check to see if it has matching VID/PID [DllImport("setupapi.dll", CharSet = CharSet::Seeifdef, EntryPoint="SetupDiGetDeviceRegistryProperty")] extern "C" WINSETUPAPI BOOL WINAPI SetupDiGetDeviceRegistryPropertyUM( HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Property, PDWORD PropertyRegDataType, PBYTE PropertyBuffer, DWORD PropertyBufferSize, PDWORD RequiredSize); SetupDiGetDeviceInterfaceDetail() gives us a device path, which is needed before CreateFile() can be used. [DllImport("setupapi.dll", CharSet = CharSet::Seeifdef, EntryPoint="SetupDiGetDeviceInterfaceDetail")] extern "C" BOOL SetupDiGetDeviceInterfaceDetailUM( HDEVINFO DeviceInfoSet, Input: Wants HDEVINFO which can be obtained from SetupDiGetClassDevs() PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, Input: Pointer to an structure which defines the device interface. PSP_DEVICE_INTERFACE_DETAIL_DATA DeviceInterfaceDetailData, Output: Pointer to a strucutre, which will contain the device path. DWORD DeviceInterfaceDetailDataSize, Input: Number of bytes to retrieve. PDWORD RequiredSize, Output (optional): Te number of bytes needed to hold the entire struct PSP_DEVINFO_DATA DeviceInfoData); Output Variables that need to have wide scope. HANDLE WriteHandle = INVALID_HANDLE_VALUE; our device before we can write to it. HANDLE ReadHandle = INVALID_HANDLE_VALUE; device before we can read from it. Need to get a write "handle" to Need to get a read "handle" to our / <summary> / Summary for Form1 / / WARNING: If you change the name of this class, you will need to change the / 'Resource File Name' property for the managed resource compiler tool / associated with all.resx files this class depends on. Otherwise, / the designers will not be able to interact properly with localized / resources associated with this form. / </summary> public ref class Form1 : public System::Windows::Forms::Form public: Form1(void) InitializeComponent(); TODO: Add the constructor code here 19

20 protected: / <summary> / Clean up any resources being used. / </summary> ~Form1() if (components) delete components; private: System::Windows::Forms::Button^ ToggleLED_btn; private: System::Windows::Forms::Label^ LblEnt; private: System::Windows::Forms::GroupBox^ groupbox1; private: System::Windows::Forms::Button^ button8; private: System::Windows::Forms::Button^ button7; private: System::Windows::Forms::Button^ button6; private: System::Windows::Forms::Button^ button5; private: System::Windows::Forms::Button^ button4; private: System::Windows::Forms::Button^ button3; private: System::Windows::Forms::Button^ button2; private: System::Windows::Forms::Button^ button1; private: System::Windows::Forms::TextBox^ txtnum; private: unsigned char v_salida; Valor de la salida de los LEDS private: System::Windows::Forms::Label^ label1; private: System::Windows::Forms::Timer^ tmrtemp; private: System::Windows::Forms::Button^ b_encender; private: System::Windows::Forms::ProgressBar^ BPot; private: System::Windows::Forms::Label^ LblPot; private: System::Windows::Forms::Timer^ TmrEnt; private: System::Windows::Forms::GroupBox^ groupbox2; private: System::Windows::Forms::Label^ label8; private: System::Windows::Forms::PictureBox^ picturebox8; private: System::Windows::Forms::Label^ label7; private: System::Windows::Forms::PictureBox^ picturebox7; private: System::Windows::Forms::Label^ label6; private: System::Windows::Forms::PictureBox^ picturebox6; private: System::Windows::Forms::Label^ label5; private: System::Windows::Forms::PictureBox^ picturebox5; private: System::Windows::Forms::Label^ label4; private: System::Windows::Forms::PictureBox^ picturebox4; private: System::Windows::Forms::Label^ label3; private: System::Windows::Forms::PictureBox^ picturebox3; private: System::Windows::Forms::Label^ label2; private: System::Windows::Forms::PictureBox^ picturebox2; private: System::Windows::Forms::Label^ label9; private: System::Windows::Forms::PictureBox^ picturebox1; private: System::Windows::Forms::MenuStrip^ menustrip1; private: System::Windows::Forms::ToolStripMenuItem^ archivotoolstripmenuitem; private: System::Windows::Forms::ToolStripMenuItem^ ayudatoolstripmenuitem; private: System::Windows::Forms::ToolStripMenuItem^ acercadetoolstripmenuitem; private: System::Windows::Forms::ToolStripMenuItem^ salirtoolstripmenuitem; private: System::ComponentModel::IContainer^ components; private: void s_usb(unsigned char val) unsigned char num; unsigned char BufferSalida[65]; 20

21 DWORD BytesWritten = 0; Variable que emplea la función Write File Preparo el Buffer Para la Transmisión BufferSalida[0] = 0; Se debe inicializar en 0 por protocolo USB BufferSalida[1] = 0x0A; 0x0A es el código que indica salida a LEDS El firmware debe tratar apropiadamente dicho código BufferSalida[2] = val; Cargo el dato a mostrar WriteFile(WriteHandle, &BufferSalida, 65, &BytesWritten, 0); protected: protected: private: / <summary> / Required designer variable. / </summary> #pragma region Windows Form Designer generated code / <summary> / Required method for Designer support - do not modify / the contents of this method with the code editor. / </summary> void InitializeComponent(void) this->components = (gcnew System::ComponentModel::Container()); System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(Form1::typeid)); this->toggleled_btn = (gcnew System::Windows::Forms::Button()); this->lblent = (gcnew System::Windows::Forms::Label()); this->groupbox1 = (gcnew System::Windows::Forms::GroupBox()); this->button8 = (gcnew System::Windows::Forms::Button()); this->button7 = (gcnew System::Windows::Forms::Button()); this->button6 = (gcnew System::Windows::Forms::Button()); this->button5 = (gcnew System::Windows::Forms::Button()); this->button4 = (gcnew System::Windows::Forms::Button()); this->button3 = (gcnew System::Windows::Forms::Button()); this->button2 = (gcnew System::Windows::Forms::Button()); this->button1 = (gcnew System::Windows::Forms::Button()); this->txtnum = (gcnew System::Windows::Forms::TextBox()); this->label1 = (gcnew System::Windows::Forms::Label()); this->tmrtemp = (gcnew System::Windows::Forms::Timer(this- >components)); this->b_encender = (gcnew System::Windows::Forms::Button()); this->bpot = (gcnew System::Windows::Forms::ProgressBar()); this->lblpot = (gcnew System::Windows::Forms::Label()); this->tmrent = (gcnew System::Windows::Forms::Timer(this- >components)); this->groupbox2 = (gcnew System::Windows::Forms::GroupBox()); this->label8 = (gcnew System::Windows::Forms::Label()); this->picturebox8 = (gcnew System::Windows::Forms::PictureBox()); this->label7 = (gcnew System::Windows::Forms::Label()); this->picturebox7 = (gcnew System::Windows::Forms::PictureBox()); this->label6 = (gcnew System::Windows::Forms::Label()); this->picturebox6 = (gcnew System::Windows::Forms::PictureBox()); this->label5 = (gcnew System::Windows::Forms::Label()); this->picturebox5 = (gcnew System::Windows::Forms::PictureBox()); this->label4 = (gcnew System::Windows::Forms::Label()); this->picturebox4 = (gcnew System::Windows::Forms::PictureBox()); 21

22 this->label3 = (gcnew System::Windows::Forms::Label()); this->picturebox3 = (gcnew System::Windows::Forms::PictureBox()); this->label2 = (gcnew System::Windows::Forms::Label()); this->picturebox2 = (gcnew System::Windows::Forms::PictureBox()); this->label9 = (gcnew System::Windows::Forms::Label()); this->picturebox1 = (gcnew System::Windows::Forms::PictureBox()); this->menustrip1 = (gcnew System::Windows::Forms::MenuStrip()); this->archivotoolstripmenuitem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->salirtoolstripmenuitem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->ayudatoolstripmenuitem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->acercadetoolstripmenuitem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->groupbox1->suspendlayout(); this->groupbox2->suspendlayout(); (cli::safe_cast<system::componentmodel::isupportinitialize^ >(this- >picturebox8))->begininit(); (cli::safe_cast<system::componentmodel::isupportinitialize^ >(this- >picturebox7))->begininit(); (cli::safe_cast<system::componentmodel::isupportinitialize^ >(this- >picturebox6))->begininit(); (cli::safe_cast<system::componentmodel::isupportinitialize^ >(this- >picturebox5))->begininit(); (cli::safe_cast<system::componentmodel::isupportinitialize^ >(this- >picturebox4))->begininit(); (cli::safe_cast<system::componentmodel::isupportinitialize^ >(this- >picturebox3))->begininit(); (cli::safe_cast<system::componentmodel::isupportinitialize^ >(this- >picturebox2))->begininit(); (cli::safe_cast<system::componentmodel::isupportinitialize^ >(this- >picturebox1))->begininit(); this->menustrip1->suspendlayout(); this->suspendlayout(); ToggleLED_btn this->toggleled_btn->enabled = false; this->toggleled_btn->location = System::Drawing::Point(21, 38); this->toggleled_btn->name = L"ToggleLED_btn"; this->toggleled_btn->size = System::Drawing::Size(150, 38); this->toggleled_btn->tabindex = 1; this->toggleled_btn->text = L"Apagar LEDS"; this->toggleled_btn->usevisualstylebackcolor = true; this->toggleled_btn->click += gcnew System::EventHandler(this, &Form1::ToggleLED_btn_Click); LblEnt this->lblent->autosize = true; this->lblent->enabled = false; this->lblent->location = System::Drawing::Point(274, 278); this->lblent->name = L"LblEnt"; this->lblent->size = System::Drawing::Size(192, 17); this->lblent->tabindex = 3; this->lblent->text = L"Estado de la Entrada Digital: "; groupbox1 this->groupbox1->controls->add(this->button8); this->groupbox1->controls->add(this->button7); this->groupbox1->controls->add(this->button6); this->groupbox1->controls->add(this->button5); this->groupbox1->controls->add(this->button4); this->groupbox1->controls->add(this->button3); this->groupbox1->controls->add(this->button2); this->groupbox1->controls->add(this->button1); 22

23 this->groupbox1->enabled = false; this->groupbox1->location = System::Drawing::Point(120, 94); this->groupbox1->name = L"groupBox1"; this->groupbox1->size = System::Drawing::Size(319, 140); this->groupbox1->tabindex = 6; this->groupbox1->tabstop = false; this->groupbox1->text = L"Manejo de Salida"; this->groupbox1->enter += gcnew System::EventHandler(this, &Form1::groupBox1_Enter); button8 this->button8->location = System::Drawing::Point(240, 37); this->button8->name = L"button8"; this->button8->size = System::Drawing::Size(72, 38); this->button8->tabindex = 13; this->button8->text = L"LED 4"; this->button8->usevisualstylebackcolor = true; this->button8->click += gcnew System::EventHandler(this, &Form1::C_LED); button7 this->button7->location = System::Drawing::Point(84, 37); this->button7->name = L"button7"; this->button7->size = System::Drawing::Size(72, 38); this->button7->tabindex = 12; this->button7->text = L"LED 2"; this->button7->usevisualstylebackcolor = true; this->button7->click += gcnew System::EventHandler(this, &Form1::C_LED); button6 this->button6->location = System::Drawing::Point(162, 84); this->button6->name = L"button6"; this->button6->size = System::Drawing::Size(72, 38); this->button6->tabindex = 11; this->button6->text = L"LED 7"; this->button6->usevisualstylebackcolor = true; this->button6->click += gcnew System::EventHandler(this, &Form1::C_LED); button5 this->button5->location = System::Drawing::Point(84, 84); this->button5->name = L"button5"; this->button5->size = System::Drawing::Size(72, 38); this->button5->tabindex = 10; this->button5->text = L"LED 6"; this->button5->usevisualstylebackcolor = true; this->button5->click += gcnew System::EventHandler(this, &Form1::C_LED); button4 this->button4->location = System::Drawing::Point(162, 37); this->button4->name = L"button4"; this->button4->size = System::Drawing::Size(72, 38); this->button4->tabindex = 9; this->button4->text = L"LED 3"; this->button4->usevisualstylebackcolor = true; this->button4->click += gcnew System::EventHandler(this, &Form1::C_LED); button3 this->button3->location = System::Drawing::Point(240, 84); 23

24 &Form1::C_LED); &Form1::C_LED); this->button3->name = L"button3"; this->button3->size = System::Drawing::Size(72, 38); this->button3->tabindex = 8; this->button3->text = L"LED 8"; this->button3->usevisualstylebackcolor = true; this->button3->click += gcnew System::EventHandler(this, button2 this->button2->location = System::Drawing::Point(6, 84); this->button2->name = L"button2"; this->button2->size = System::Drawing::Size(72, 38); this->button2->tabindex = 7; this->button2->text = L"LED 5"; this->button2->usevisualstylebackcolor = true; this->button2->click += gcnew System::EventHandler(this, button1 this->button1->location = System::Drawing::Point(6, 37); this->button1->name = L"button1"; this->button1->size = System::Drawing::Size(72, 38); this->button1->tabindex = 6; this->button1->text = L"LED 1"; this->button1->usevisualstylebackcolor = true; this->button1->click += gcnew System::EventHandler(this, &Form1::C_LED); txtnum this->txtnum->enabled = false; this->txtnum->location = System::Drawing::Point(161, 273); this->txtnum->name = L"txtnum"; this->txtnum->size = System::Drawing::Size(61, 22); this->txtnum->tabindex = 8; label1 this->label1->autosize = true; this->label1->location = System::Drawing::Point(32, 273); this->label1->name = L"label1"; this->label1->size = System::Drawing::Size(123, 17); this->label1->tabindex = 9; this->label1->text = L"Valor de la Salida:"; tmrtemp this->tmrtemp->interval = 10; this->tmrtemp->tick += gcnew System::EventHandler(this, &Form1::tmrTemp_Tick); b_encender this->b_encender->enabled = false; this->b_encender->location = System::Drawing::Point(385, 38); this->b_encender->name = L"b_Encender"; this->b_encender->size = System::Drawing::Size(150, 38); this->b_encender->tabindex = 10; this->b_encender->text = L"Encender LEDS"; this->b_encender->usevisualstylebackcolor = true; this->b_encender->click += gcnew System::EventHandler(this, &Form1::b_Encender_Click); BPot this->bpot->location = System::Drawing::Point(161, 337); 24

25 this->bpot->maximum = 255; this->bpot->name = L"BPot"; this->bpot->size = System::Drawing::Size(365, 36); this->bpot->tabindex = 11; this->bpot->click += gcnew System::EventHandler(this, &Form1::BPot_Click); LblPot this->lblpot->autosize = true; this->lblpot->enabled = false; this->lblpot->location = System::Drawing::Point(32, 346); this->lblpot->name = L"LblPot"; this->lblpot->size = System::Drawing::Size(103, 17); this->lblpot->tabindex = 12; this->lblpot->text = L"Potenciometro:"; TmrEnt this->tmrent->interval = 500; this->tmrent->tick += gcnew System::EventHandler(this, &Form1::TmrEnt_Tick); groupbox2 this->groupbox2->controls->add(this->label8); this->groupbox2->controls->add(this->picturebox8); this->groupbox2->controls->add(this->label7); this->groupbox2->controls->add(this->picturebox7); this->groupbox2->controls->add(this->label6); this->groupbox2->controls->add(this->picturebox6); this->groupbox2->controls->add(this->label5); this->groupbox2->controls->add(this->picturebox5); this->groupbox2->controls->add(this->label4); this->groupbox2->controls->add(this->picturebox4); this->groupbox2->controls->add(this->label3); this->groupbox2->controls->add(this->picturebox3); this->groupbox2->controls->add(this->label2); this->groupbox2->controls->add(this->picturebox2); this->groupbox2->controls->add(this->label9); this->groupbox2->controls->add(this->picturebox1); this->groupbox2->location = System::Drawing::Point(21, 412); this->groupbox2->name = L"groupBox2"; this->groupbox2->size = System::Drawing::Size(517, 172); this->groupbox2->tabindex = 13; this->groupbox2->tabstop = false; this->groupbox2->text = L"Estado de la Entrada"; label8 this->label8->autosize = true; this->label8->location = System::Drawing::Point(450, 48); this->label8->name = L"label8"; this->label8->size = System::Drawing::Size(36, 17); this->label8->tabindex = 15; this->label8->text = L"Bit 0"; picturebox8 this->picturebox8->image = (cli::safe_cast<system::drawing::image^ >(resources->getobject(l"picturebox8.image"))); this->picturebox8->location = System::Drawing::Point(441, 78); this->picturebox8->name = L"pictureBox8"; this->picturebox8->size = System::Drawing::Size(54, 44); this->picturebox8->sizemode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; this->picturebox8->tabindex = 14; this->picturebox8->tabstop = false; 25

26 label7 this->label7->autosize = true; this->label7->location = System::Drawing::Point(390, 48); this->label7->name = L"label7"; this->label7->size = System::Drawing::Size(36, 17); this->label7->tabindex = 13; this->label7->text = L"Bit 1"; picturebox7 this->picturebox7->image = (cli::safe_cast<system::drawing::image^ >(resources->getobject(l"picturebox7.image"))); this->picturebox7->location = System::Drawing::Point(381, 78); this->picturebox7->name = L"pictureBox7"; this->picturebox7->size = System::Drawing::Size(54, 44); this->picturebox7->sizemode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; this->picturebox7->tabindex = 12; this->picturebox7->tabstop = false; label6 this->label6->autosize = true; this->label6->location = System::Drawing::Point(330, 48); this->label6->name = L"label6"; this->label6->size = System::Drawing::Size(36, 17); this->label6->tabindex = 11; this->label6->text = L"Bit 2"; picturebox6 this->picturebox6->image = (cli::safe_cast<system::drawing::image^ >(resources->getobject(l"picturebox6.image"))); this->picturebox6->location = System::Drawing::Point(321, 78); this->picturebox6->name = L"pictureBox6"; this->picturebox6->size = System::Drawing::Size(54, 44); this->picturebox6->sizemode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; this->picturebox6->tabindex = 10; this->picturebox6->tabstop = false; label5 this->label5->autosize = true; this->label5->location = System::Drawing::Point(270, 48); this->label5->name = L"label5"; this->label5->size = System::Drawing::Size(36, 17); this->label5->tabindex = 9; this->label5->text = L"Bit 3"; picturebox5 this->picturebox5->image = (cli::safe_cast<system::drawing::image^ >(resources->getobject(l"picturebox5.image"))); this->picturebox5->location = System::Drawing::Point(261, 78); this->picturebox5->name = L"pictureBox5"; this->picturebox5->size = System::Drawing::Size(54, 44); this->picturebox5->sizemode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; this->picturebox5->tabindex = 8; this->picturebox5->tabstop = false; label4 this->label4->autosize = true; this->label4->location = System::Drawing::Point(210, 48); 26

27 this->label4->name = L"label4"; this->label4->size = System::Drawing::Size(36, 17); this->label4->tabindex = 7; this->label4->text = L"Bit 4"; picturebox4 this->picturebox4->image = (cli::safe_cast<system::drawing::image^ >(resources->getobject(l"picturebox4.image"))); this->picturebox4->location = System::Drawing::Point(201, 78); this->picturebox4->name = L"pictureBox4"; this->picturebox4->size = System::Drawing::Size(54, 44); this->picturebox4->sizemode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; this->picturebox4->tabindex = 6; this->picturebox4->tabstop = false; label3 this->label3->autosize = true; this->label3->location = System::Drawing::Point(150, 48); this->label3->name = L"label3"; this->label3->size = System::Drawing::Size(36, 17); this->label3->tabindex = 5; this->label3->text = L"Bit 5"; picturebox3 this->picturebox3->image = (cli::safe_cast<system::drawing::image^ >(resources->getobject(l"picturebox3.image"))); this->picturebox3->location = System::Drawing::Point(141, 78); this->picturebox3->name = L"pictureBox3"; this->picturebox3->size = System::Drawing::Size(54, 44); this->picturebox3->sizemode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; this->picturebox3->tabindex = 4; this->picturebox3->tabstop = false; label2 this->label2->autosize = true; this->label2->location = System::Drawing::Point(90, 49); this->label2->name = L"label2"; this->label2->size = System::Drawing::Size(36, 17); this->label2->tabindex = 3; this->label2->text = L"Bit 6"; picturebox2 this->picturebox2->image = (cli::safe_cast<system::drawing::image^ >(resources->getobject(l"picturebox2.image"))); this->picturebox2->location = System::Drawing::Point(81, 79); this->picturebox2->name = L"pictureBox2"; this->picturebox2->size = System::Drawing::Size(54, 44); this->picturebox2->sizemode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; this->picturebox2->tabindex = 2; this->picturebox2->tabstop = false; label9 this->label9->autosize = true; this->label9->location = System::Drawing::Point(30, 48); this->label9->name = L"label9"; this->label9->size = System::Drawing::Size(36, 17); this->label9->tabindex = 1; this->label9->text = L"Bit 7"; 27