• Domingo 7 de Agosto de 2022, 23:51

Autor Tema:  Conexión Usb-matlab  (Leído 20472 veces)

Quicksilver

  • Miembro activo
  • **
  • Mensajes: 93
  • Nacionalidad: co
    • Ver Perfil
Conexión Usb-matlab
« en: Sábado 12 de Abril de 2008, 05:40 »
0
Comprades, camaradas y socios de programación  :hola: , esta noche vengo con una duda bastante interesante y que me ha asaltado durante días (me ha robado todo el conociemiento)... :lightsabre:

Viendo yo casi todos los lenguajes de progamación, en todos encuentro que podemos hacer conexiones por los puertos serial, paralelo, usb... etc. Para el control de un motor, para captar señales del ambiente, en fin, para cada uno de nuestros proyectos universitarios o empresariales.

Pero buscando en matlab como hacer la conexión que necesito, en mi caso conexión usb, y no ecuentro como hacerla... he visto como hacerla pero con la tajerta de matlab USB-6008 :blink: , en fin, esta tarjeta cuesta una módica suma de dinero.

La cuestión y mi duda es la siguiente, y estoy mas que seguro que mas de uno de los del foro, ha tenido esta duda en algún momento, y es... ¿Cómo hacer uan comuniación Usb con algun circuito o impreso, para el manejo de un motor, o para conectar varios sensores... etc, etc.? ¿Alguien sabe como hacerlo?, espero que nos puedan ayudar, espero que alguien responda, espero que alguno sepa... he escuchado que con "PIC'S" de la serie de 18 de microchip se pueden hacer el circuito, pero no he encontrado aún en internet algo sobre esto, espero pues, que me puedan ayudar, y muchas gracias de antemano por la atención prestada
Everything that has a beginning has an end

fa61an

  • Miembro MUY activo
  • ***
  • Mensajes: 100
    • Ver Perfil
Re: Conexión Usb-matlab
« Respuesta #1 en: Domingo 13 de Abril de 2008, 01:43 »
0
Bueno yo también quisiera aprender eso. Pero ten en cuenta algo cuando se trata de serial o paralelo los protocolos son muy sencillos y no dependen del tipo de hardware usado, en cambio en el USB si se depende del hardware usado.

Se de un proyecto hecho en LabVIEW que lee y muestrea datos de una señal por medio de un dsPIC y los envía a LabVIEW por puerto USB. Al desarrollador le toco crear su propio driver o dll y algunas funciones para que labview pudiera leer los datos de USB.

Ese mismo proyecto si lo quería hacer Visual Basic le tocaba desarrollar otro driver direfente y lo mismo seria con Matlab.

Esas tarjetas USB-6008 que mencionan por eso tienen ese valor, pues están desarrollados drivers para visual, para LabVIEW para matlab, para java no se pero supongo que también y creo que para Linux.

Si se trata de una aplicación industrial lo mejor es comprar la tarjeta pero si es para un proyecto de tesis no ponerse estresado pues tanto Microchip como Motorola tienen amplia información de como crear los drivers y las estructuras de los métodos y argumentos que deben programarse.

He visto mucho de eso para PIC con Visual y algunos con LabVIEW, luego con Matlab también habría que buscar.

Quicksilver

  • Miembro activo
  • **
  • Mensajes: 93
  • Nacionalidad: co
    • Ver Perfil
Re: Conexión Usb-matlab
« Respuesta #2 en: Domingo 13 de Abril de 2008, 01:57 »
0
Os colocaré algunas cosas que he encontrado, muy utiles, yo... estaba pensando, hacer una conexión usb con "c#" tengo entendida que es mas fácil, y guardar los datos en este tipo de código, y luego, mandarlos a matlab, a través de una conexión matlab-Visual.net-usb, jajaja, algo, para mi concepto, bastante complicado, pero creo que es mas fácil así, que hacerla directamente de Matlab a Usb, espero pues que podamos llegar a una solución.

pondré algunos enlaces, en los cuales eh investigado...

PICS - MATLAB(Excelente página) :comp:

My Webpage

Por ahora, solo he encontrado estas, espero que podamos ayudarnos todos....  :hola:
Everything that has a beginning has an end

Quicksilver

  • Miembro activo
  • **
  • Mensajes: 93
  • Nacionalidad: co
    • Ver Perfil
Re: Conexión Usb-matlab
« Respuesta #3 en: Domingo 13 de Abril de 2008, 01:59 »
0
Que pena, cometí un error, jajaja, puse una canción!!!!!!! jajaja, esta si es la página web.... os aseguro

PICS-MATLAB

Aunque, también estoy seguro, que la canción les agradará :whistling:
Everything that has a beginning has an end

fa61an

  • Miembro MUY activo
  • ***
  • Mensajes: 100
    • Ver Perfil
Re: Conexión Usb-matlab
« Respuesta #4 en: Domingo 13 de Abril de 2008, 02:49 »
0
La idea de usarla por C# y luego de allí a Matlab me parece excelente. Lo que no se es que tambien se integren estas dos plataformas. Pero se estoy seguro que es mejor desarrollar el driver en C#

La canción esta bien... !!!

La pagina de Carlitos Page es de un compatriota colombiano, pero el vende la tarjeta de adquisición de datos y con un driver para Visual Basic. Eso si los precios son mejores que los de la National Instruments falta a ver si el todavía hace eso..

Y la pagina de MATLAB - PIC es para un conexión por el puerto serial RS-232 eso no tiene complique.... y creo que lo que tu quieres es USB.

Geo

  • Miembro de PLATA
  • *****
  • Mensajes: 1011
  • Nacionalidad: mx
    • Ver Perfil
    • http://hsblog.mexchip.com
Re: Conexión Usb-matlab
« Respuesta #5 en: Miércoles 16 de Abril de 2008, 14:40 »
0
Yo he probado comunicación utilizando MATLAB y un microcontrolador PIC 18f2550 con controlador USB integrado, probé dos formas:
  • Utilizando la clase CDC (Communication Device Class, una clase de dispositivos USB ya definida, no es algo de MATLAB), el PIC se programa para operar como un puerto serie virtual, en MATLAB se maneja con las funciones para manejo de puertos serie y no hay ninguna complicación extra en esta opción.</li>
  • Para modo de transferencias bulk, intenté cargar la DLL que proporciona Microchip pero, como no tuve buenos resultados, inmediatamente me cambié al uso de funciones MEX, consiguiéndolo también :).</li>
La imaginación es el límite.
Hardware & Software | Mexchip

Quicksilver

  • Miembro activo
  • **
  • Mensajes: 93
  • Nacionalidad: co
    • Ver Perfil
Re: Conexión Usb-matlab
« Respuesta #6 en: Jueves 17 de Abril de 2008, 22:05 »
0
Geo, estaría muy agradecido si me colaboras un poco mas :whistling: , por favor, me ha servido mucho tu post, pero por ejemplo, donde puedo conseguir la clase CDC.

También me gustaria saber como cargar las funciones "MEX", espero que entiendes que soy un poco nuevo en MatLab, todo un amateur ya, pero mejorando, sin embargo, soy aun mas nuevo en PIC'S, espero que no sea mucho pedir. Excelente Post Geo, muchas gracias de verdad a todos los que postean, y espero que entre todos lleguemos a una conclusión. :smartass:
Everything that has a beginning has an end

Geo

  • Miembro de PLATA
  • *****
  • Mensajes: 1011
  • Nacionalidad: mx
    • Ver Perfil
    • http://hsblog.mexchip.com
Re: Conexión Usb-matlab
« Respuesta #7 en: Viernes 18 de Abril de 2008, 08:17 »
0
Cita de: "Quicksilver"
Geo, estaría muy agradecido si me colaboras un poco mas :whistling: , por favor, me ha servido mucho tu post, pero por ejemplo, donde puedo conseguir la clase CDC.
Bueno, el tema del puerto USB no es difícil pero si extenso. Te recomiendo le des una leída a algún tutorial de USB, por ejemplo, busca en Google "USB in a nutshell", yo recomiendo el libro "USB port complete" de Jan Axelson.

A grandes rasgos, existen varios tipos de comunicación para el puerto USB: control, interrupción y bulk. También existen algunas "clases de dispositivos estándar", esto es, ya definidas, se trata de dispositivos comunes como ratones, teclados, dispositivos de almacenamiento, etc. Dentro de esas clases se encuentra CDC, que es una clase para comunicación. Esto se configura en el firmware del dispositivo con el cual te vas a comunicar.

Cita de: "Quicksilver"
También me gustaria saber como cargar las funciones "MEX", espero que entiendes que soy un poco nuevo en MatLab, todo un amateur ya, pero mejorando, sin embargo, soy aun mas nuevo en PIC'S, espero que no sea mucho pedir. Excelente Post Geo, muchas gracias de verdad a todos los que postean, y espero que entre todos lleguemos a una conclusión. :smartass:
Existen dos formas de conectar MATLAB con programas escritos en lenguaje C, una son las funciones MX, que permiten utilizar funciones de MATLAB en programas escritos en C. La otra son las funciones MEX, que permiten escribir programas en lenguaje C que se pueden utilizar dentro de MATLAB. No sé si en este foro haya información al respecto, prueba usando el buscador, si no, en Google o coloca un nuevo tema :).
La imaginación es el límite.
Hardware & Software | Mexchip

Quicksilver

  • Miembro activo
  • **
  • Mensajes: 93
  • Nacionalidad: co
    • Ver Perfil
Re: Conexión Usb-matlab
« Respuesta #8 en: Viernes 18 de Abril de 2008, 21:12 »
0
Geo, muchisimas gracias, pronto colocaré los adelantos que he obtenido, pues, a decir verdad, ya empecé, en otro foro de otra página web, he encontrado bastante como conectar el PIC, con el matlab, pero primero hay que pasar por Visual Basic.

Consultaré mucho mas y colocaré algunos resultados.
Everything that has a beginning has an end

Quicksilver

  • Miembro activo
  • **
  • Mensajes: 93
  • Nacionalidad: co
    • Ver Perfil
Re: Conexión Usb-matlab
« Respuesta #9 en: Sábado 19 de Abril de 2008, 23:41 »
0
Bueno camaradas, he investigado bastante, he encontrado algunas páginas que me pueden ser utiles. B)

He encontrado como conectar el PIC con Visaul Basic, Con C, y tengo ya alunos programas, por ahora, pondré unas páginas que me han sido de utilidad, espero pues que las miren, y que también les sirvan y comentemos acerca de ellas, un saludo a todos.

No se si se pueda conectar Visaul Basic con MatLab, espero que si.

Tengo algunos arvhivos, pero por ahora son un poco pesados, veré como los pongo, por ahora, pondré algunas páginas en las cuales he investigado.

MICROS Y MAS MICROS
Excelente página, muy completa, y también tiene un foro, lo recomiendo. :ph34r:

FORO MICROS Y MAS MICROS

FORO1 MICROS Y MAS MICROS

En los foros se encuentara mas o menos lo que quiero hacer con mi proyecto, conectar una Lcd, falta el teclado hexadecimal, y el PIC de la serie 18f y conectar este a MatLab, seguire investigando, hasta llegar a la solución del mismo, espero pues que me colaboren, yo trataré de poner mis avances, las dudas y soluciones que consiga.

Geo, también creo haber conseguid las librerias, trataré de ponerlas aca. :smartass:

Un saludo a todos.
Everything that has a beginning has an end

Geo

  • Miembro de PLATA
  • *****
  • Mensajes: 1011
  • Nacionalidad: mx
    • Ver Perfil
    • http://hsblog.mexchip.com
Re: Conexión Usb-matlab
« Respuesta #10 en: Domingo 20 de Abril de 2008, 04:29 »
0
Este es el centro de recursos USB de Microchip, todo lo relacionado a sus microcontroladores con USB lo encuentras aquí

http://www.microchip.com/stellent/idcplg?I...6&redirects=USB
La imaginación es el límite.
Hardware & Software | Mexchip

Quicksilver

  • Miembro activo
  • **
  • Mensajes: 93
  • Nacionalidad: co
    • Ver Perfil
Re: Conexión Usb-matlab
« Respuesta #11 en: Miércoles 14 de Mayo de 2008, 05:53 »
0
Muchas gracias a todos, he tenido un poco olvidado este post, vengo a poner unas nuevas páginas, ya he logrado la conexión del PIC con la pc, gracias a esta página, ya tengo hecho el circuito, cuando tenga un tiempito libre lo colocare, ahora lo que me hace falta, es conectar el PIC con el MatLab, seguiré intentanto, un saludo a todos.


PICMANIA BY REDraven
Everything that has a beginning has an end

Geo

  • Miembro de PLATA
  • *****
  • Mensajes: 1011
  • Nacionalidad: mx
    • Ver Perfil
    • http://hsblog.mexchip.com
Re: Conexión Usb-matlab
« Respuesta #12 en: Domingo 15 de Junio de 2008, 19:18 »
0
Qué tal, a continuación pongo el código que utilicé para probar la comunicación utilizando la clase CDC (Communication Device Class).

Este es el código del PIC, utilizando el compilador de la empresa CCS:
Código: Text
  1.  
  2. #include &#60;18F2550.h&#62;
  3. #fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL3,CPUDIV1,VREGEN
  4. #use delay(clock=48000000)
  5.  
  6. #include &#34;usb_cdc.h&#34;
  7. #include &#34;prueba_cdc.h&#34;
  8.  
  9. void main() {
  10.    char c;
  11.  
  12.    // Un retardo de espera
  13.    delay_ms(300);
  14.  
  15.    // Configuración del USB
  16.    usb_cdc_init();
  17.  
  18.    usb_init();
  19.  
  20.    // Mientras el dispositivo no sea
  21.    // reconocido, parpadear los leds
  22.    while(!usb_cdc_connected()) {
  23.  
  24.       output_high( PIN_B6 );
  25.       output_low( PIN_B7 );
  26.       delay_ms( 200 );
  27.  
  28.       output_low( PIN_B6 );
  29.       output_high( PIN_B7 );
  30.       delay_ms( 200 );
  31.    }
  32.  
  33.    // Dispositivo reconocido
  34.    // apaga los leds
  35.  
  36.    output_low( PIN_B6 );
  37.    output_low( PIN_B7 );
  38.  
  39.    // Ciclo principal
  40.    do {
  41.       usb_task();
  42.  
  43.       // Si el dispositivo se encuentra enumerado por
  44.       // el sistema operativo
  45.       if ( usb_enumerated() ) {
  46.          // Si hay datos en el búfer
  47.          if ( usb_cdc_kbhit() ) {
  48.             // Lee el dato en el búfer
  49.             c = usb_cdc_getc();
  50.  
  51.             // Ejecuta acción de acuerdo
  52.             // al valor leído
  53.             switch( c ) {
  54.                // Apaga los LEDs
  55.                case '1':
  56.                   output_low( PIN_B6 );
  57.                   output_low( PIN_B7 );
  58.                   break;
  59.                // Enciende el led verde
  60.                case '2':
  61.                   output_high( PIN_B6 );
  62.                   output_low( PIN_B7 );
  63.                   break;
  64.                // Enciende el led rojo
  65.                case '3':
  66.                   output_low( PIN_B6 );
  67.                   output_high( PIN_B7 );
  68.                   break;
  69.                // Código desconocido, envía el mensaje
  70.                // y parpadea los leds un par de ocasiones.
  71.                default:
  72.                   printf( usb_cdc_putc, &#34;Código desconocido&#34; );
  73.                   output_high( PIN_B6 );
  74.                   output_low( PIN_B7 );
  75.                   delay_ms( 500 );
  76.                   output_low( PIN_B6 );
  77.                   output_high( PIN_B7 );
  78.                   delay_ms( 500 );
  79.                   output_low( PIN_B6 );
  80.                   output_low( PIN_B7 );
  81.             }
  82.          }
  83.       }
  84.    } while (TRUE);
  85. }
  86.  
  87.  

En MATLAB; probando en la línea de comandos:
Citar
Asigna el puerto virtual
>> s = serial( 'COM3' )
   Serial Port Object : Serial-COM3
   Communication Settings
      Port:               COM3
      BaudRate:           9600
      Terminator:         'LF'

   Communication State
      Status:             closed
      RecordStatus:       off

   Read/Write State 
      TransferStatus:     idle
      BytesAvailable:     0
      ValuesReceived:     0
      ValuesSent:         0
 
Abre el puerto
>> fopen( s )
Envía datos
Apaga los LEDs
>> fprintf( s, '%c', '1' )
Enciende el led verde
>> fprintf( s, '%c', '2' )
Enciende el led rojo
>> fprintf( s, '%c', '3' )

Envía un código no reconocido
>> fprintf( s, '%c', '5' )
>> fscanf( s )
Warning: A timeout occurred before the Terminator was reached.

ans =

Código desconocido

>>

Espero les sea de utilidad :).
La imaginación es el límite.
Hardware & Software | Mexchip

stefaniecg

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Conexión Usb-matlab
« Respuesta #13 en: Martes 14 de Octubre de 2008, 20:47 »
0
Hola Geo, veo que sabes como conectar un PIC y Matlab, no serías tan amable de colcar el proyecto completo de PICC y de Matlab, que los he estado probando pero me dan error, asi que no se si algo no estoy colocando bien. Te lo agradecería mucho!

Geo

  • Miembro de PLATA
  • *****
  • Mensajes: 1011
  • Nacionalidad: mx
    • Ver Perfil
    • http://hsblog.mexchip.com
Re: Conexión Usb-matlab
« Respuesta #14 en: Sábado 18 de Octubre de 2008, 22:11 »
0
Qué tal, el problema para compilar en CCS debe ser por el archivo "prueba_cdc.h", pensé que lo había comentado, simplemente puedes tomar el archivo "usb_desc_cdc.h" dentro de la instalación de CCS, o usa este:

Código: Text
  1. ///////////////////////////////////////////////////////////////////////////
  2. ////                         usb_desc_cdc.h                            ////
  3. ////                                                                   ////
  4. //// An example set of device / configuration descriptors for use with ////
  5. //// CCS's CDC Virtual COM Port driver (see usb_cdc.h)                 ////
  6. ////                                                                   ////
  7. //// Two examples are provided:                                        ////
  8. ////      ex_usb_serial.c                                              ////
  9. ////      ex_usb_serial2.c                                             ////
  10. ////                                                                   ////
  11. ///////////////////////////////////////////////////////////////////////////
  12. ////                                                                   ////
  13. //// Version History:                                                  ////
  14. ////                                                                   ////
  15. //// 10/28/05:                                                         ////
  16. ////    Bulk endpoint sizes updated to allow more than 255 byte        ////
  17. ////    packets.                                                       ////
  18. ////    Changed device to USB 1.10                                     ////
  19. ////                                                                   ////
  20. ///////////////////////////////////////////////////////////////////////////
  21. ////        (C) Copyright 1996,2005 Custom Computer Services           ////
  22. //// This source code may only be used by licensed users of the CCS    ////
  23. //// C compiler.  This source code may only be distributed to other    ////
  24. //// licensed users of the CCS C compiler.  No other use,              ////
  25. //// reproduction or distribution is permitted without written         ////
  26. //// permission.  Derivative programs created using this software      ////
  27. //// in object code form are not restricted in any way.                ////
  28. ///////////////////////////////////////////////////////////////////////////
  29.  
  30.  
  31. #IFNDEF __USB_DESCRIPTORS__
  32. #DEFINE __USB_DESCRIPTORS__
  33.  
  34. #include <usb.h>
  35.  
  36.  
  37. //////////////////////////////////////////////////////////////////
  38. ///
  39. ///   start config descriptor
  40. ///   right now we only support one configuration descriptor.
  41. ///   the config, interface, class, and endpoint goes into this array.
  42. ///
  43. //////////////////////////////////////////////////////////////////
  44.  
  45.    #DEFINE USB_TOTAL_CONFIG_LEN      67  //config+interface+class+endpoint+endpoint (2 endpoints)
  46.  
  47.    const char USB_CONFIG_DESC[] = {
  48.    //IN ORDER TO COMPLY WITH WINDOWS HOSTS, THE ORDER OF THIS ARRAY MUST BE:
  49.       //    config(s)
  50.       //    interface(s)
  51.       //    class(es)
  52.       //    endpoint(s)
  53.  
  54.    //config_descriptor for config index 1
  55.          USB_DESC_CONFIG_LEN, //length of descriptor size          ==0
  56.          USB_DESC_CONFIG_TYPE, //constant CONFIGURATION (CONFIGURATION 0x02)     ==1
  57.          USB_TOTAL_CONFIG_LEN,0, //size of all data returned for this config      ==2,3
  58.          2, //number of interfaces this device supports       ==4
  59.          0x01, //identifier for this configuration.  (IF we had more than one configurations)      ==5
  60.          0x00, //index of string descriptor for this configuration      ==6
  61.          0xC0, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 unused and bit7=1         ==7
  62.          0x32, //maximum bus power required (maximum milliamperes/2)  (0x32 = 100mA)  ==8
  63.  
  64.    //interface descriptor 0 (comm class interface)
  65.          USB_DESC_INTERFACE_LEN, //length of descriptor      =9
  66.          USB_DESC_INTERFACE_TYPE, //constant INTERFACE (INTERFACE 0x04)       =10
  67.          0x00, //number defining this interface (IF we had more than one interface)    ==11
  68.          0x00, //alternate setting     ==12
  69.          1, //number of endpoints   ==13
  70.          0x02, //class code, 02 = Comm Interface Class     ==14
  71.          0x02, //subclass code, 2 = Abstract     ==15
  72.          0x01, //protocol code, 1 = v.25ter      ==16
  73.          0x00, //index of string descriptor for interface      ==17
  74.  
  75.    //class descriptor [functional header]
  76.          5, //length of descriptor    ==18
  77.          0x24, //dscriptor type (0x24 == )      ==19
  78.          0, //sub type (0=functional header) ==20
  79.          0x10,0x01, //      ==21,22 //cdc version
  80.  
  81.    //class descriptor [acm header]
  82.          4, //length of descriptor    ==23
  83.          0x24, //dscriptor type (0x24 == )      ==24
  84.          2, //sub type (2=ACM)   ==25
  85.          2, //capabilities    ==26  //we support Set_Line_Coding, Set_Control_Line_State, Get_Line_Coding, and the notification Serial_State.
  86.  
  87.    //class descriptor [union header]
  88.          5, //length of descriptor    ==27
  89.          0x24, //dscriptor type (0x24 == )      ==28
  90.          6, //sub type (6=union)    ==29
  91.          0, //master intf     ==30  //The interface number of the Communication or Dat a Cl ass interface, designated as the masteror controlling interface for the union.
  92.          1, //save intf0      ==31  //Interface number of first slave or associated interface in the union. *
  93.  
  94.    //class descriptor [call mgmt header]
  95.          5, //length of descriptor    ==32
  96.          0x24, //dscriptor type (0x24 == )      ==33
  97.          1, //sub type (1=call mgmt)   ==34
  98.          0, //capabilities          ==35  //device does not handle call management itself
  99.          1, //data interface        ==36  //interface number of data class interface
  100.  
  101.    //endpoint descriptor
  102.          USB_DESC_ENDPOINT_LEN, //length of descriptor                   ==37
  103.          USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05)          ==38
  104.          USB_CDC_COMM_IN_ENDPOINT | 0x80, //endpoint number and direction
  105.          0x03, //transfer type supported (0x03 is interrupt)         ==40
  106.          USB_CDC_COMM_IN_SIZE,0x00, //maximum packet size supported                  ==41,42
  107.          250,  //polling interval, in ms.  (cant be smaller than 10)      ==43
  108.  
  109.    //interface descriptor 1 (data class interface)
  110.          USB_DESC_INTERFACE_LEN, //length of descriptor      =44
  111.          USB_DESC_INTERFACE_TYPE, //constant INTERFACE (INTERFACE 0x04)       =45
  112.          0x01, //number defining this interface (IF we had more than one interface)    ==46
  113.          0x00, //alternate setting     ==47
  114.          2, //number of endpoints   ==48
  115.          0x0A, //class code, 0A = Data Interface Class     ==49
  116.          0x00, //subclass code      ==50
  117.          0x00, //protocol code      ==51
  118.          0x00, //index of string descriptor for interface      ==52
  119.  
  120.    //endpoint descriptor
  121.          USB_DESC_ENDPOINT_LEN, //length of descriptor                   ==60
  122.          USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05)          ==61
  123.          USB_CDC_DATA_OUT_ENDPOINT, //endpoint number and direction (0x02 = EP2 OUT)       ==62
  124.          0x02, //transfer type supported (0x02 is bulk)         ==63
  125. //         make8(USB_CDC_DATA_OUT_SIZE,0),make8(USB_CDC_DATA_OUT_SIZE,1), //maximum packet size supported                  ==64, 65
  126.          USB_CDC_DATA_OUT_SIZE & 0xFF, (USB_CDC_DATA_OUT_SIZE >> 8) & 0xFF, //maximum packet size supported                  ==64, 65
  127.          250,  //polling interval, in ms.  (cant be smaller than 10)      ==66
  128.  
  129.    //endpoint descriptor
  130.          USB_DESC_ENDPOINT_LEN, //length of descriptor                   ==53
  131.          USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (ENDPOINT 0x05)          ==54
  132.          USB_CDC_DATA_IN_ENDPOINT | 0x80, //endpoint number and direction (0x82 = EP2 IN)       ==55
  133.          0x02, //transfer type supported (0x02 is bulk)         ==56
  134. //         make8(USB_CDC_DATA_IN_SIZE,0),make8(USB_CDC_DATA_IN_SIZE,1), //maximum packet size supported                  ==57, 58
  135.          USB_CDC_DATA_IN_SIZE & 0xFF, (USB_CDC_DATA_IN_SIZE >> 8) & 0xFF, //maximum packet size supported                  ==64, 65
  136.          250,  //polling interval, in ms.  (cant be smaller than 10)      ==59
  137.    };
  138.  
  139.    //****** BEGIN CONFIG DESCRIPTOR LOOKUP TABLES ********
  140.    //since we can't make pointers to constants in certain pic16s, this is an offset table to find
  141.    //  a specific descriptor in the above table.
  142.  
  143.    //the maximum number of interfaces seen on any config
  144.    //for example, if config 1 has 1 interface and config 2 has 2 interfaces you must define this as 2
  145.    #define USB_MAX_NUM_INTERFACES   2
  146.  
  147.    //define how many interfaces there are per config.  [0] is the first config, etc.
  148.    const char USB_NUM_INTERFACES[USB_NUM_CONFIGURATIONS]={2};
  149.  
  150.    //define where to find class descriptors
  151.    //first dimension is the config number
  152.    //second dimension specifies which interface
  153.    //last dimension specifies which class in this interface to get, but most will only have 1 class per interface
  154.    //if a class descriptor is not valid, set the value to 0xFFFF
  155.    const int16 USB_CLASS_DESCRIPTORS[USB_NUM_CONFIGURATIONS][USB_MAX_NUM_INTERFACES][4]=
  156.    {
  157.    //config 1
  158.       //interface 0
  159.          //class 1-4
  160.          18,23,27,32,
  161.       //interface 1
  162.          //no classes for this interface
  163.          0xFFFF,0xFFFF,0xFFFF,0xFFFF
  164.    };
  165.  
  166.    #if (sizeof(USB_CONFIG_DESC) != USB_TOTAL_CONFIG_LEN)
  167.       #error USB_TOTAL_CONFIG_LEN not defined correctly
  168.    #endif
  169.  
  170.  
  171. //////////////////////////////////////////////////////////////////
  172. ///
  173. ///   start device descriptors
  174. ///
  175. //////////////////////////////////////////////////////////////////
  176.  
  177.    const char USB_DEVICE_DESC[USB_DESC_DEVICE_LEN] ={
  178.       //starts of with device configuration. only one possible
  179.          USB_DESC_DEVICE_LEN, //the length of this report   ==0
  180.          0x01, //the constant DEVICE (DEVICE 0x01)  ==1
  181.          0x10,0x01, //usb version in bcd  ==2,3
  182.          0x02, //class code. 0x02=Communication Device Class ==4
  183.          0x00, //subclass code ==5
  184.          0x00, //protocol code ==6
  185.          USB_MAX_EP0_PACKET_LENGTH, //max packet size for endpoint 0. (SLOW SPEED SPECIFIES 8) ==7
  186.  
  187.          0xD8,0x04,           //vendor id (0x04D8 is Microchip)
  188.          0x0A,0x00,           //product id
  189.  
  190.          0x00,0x01, //device release number  ==12,13
  191.          0x01, //index of string description of manufacturer. therefore we point to string_1 array (see below)  ==14
  192.          0x02, //index of string descriptor of the product  ==15
  193.          0x00, //index of string descriptor of serial number  ==16
  194.          USB_NUM_CONFIGURATIONS  //number of possible configurations  ==17
  195.    };
  196.  
  197.  
  198. //////////////////////////////////////////////////////////////////
  199. ///
  200. ///   start string descriptors
  201. ///   String 0 is a special language string, and must be defined.  People in U.S.A. can leave this alone.
  202. ///
  203. ///   You must define the length else get_next_string_character() will not see the string
  204. ///   Current code only supports 10 strings (0 thru 9)
  205. ///
  206. //////////////////////////////////////////////////////////////////
  207.  
  208. //the offset of the starting location of each string.  offset[0] is the start of string 0, offset[1] is the start of string 1, etc.
  209. char USB_STRING_DESC_OFFSET[]={0,4,12};
  210.  
  211. char const USB_STRING_DESC[]={
  212.    //string 0
  213.          4, //length of string index
  214.          USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
  215.          0x09,0x04,   //Microsoft Defined for US-English
  216.    //string 1
  217.          8, //length of string index
  218.          USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
  219.          'I',0,
  220.          'T',0,
  221.          'O',0,
  222.    //string 2 --> nombre del dispositivo
  223.          30, //length of string index
  224.          USB_DESC_STRING_TYPE, //descriptor type 0x03 (STRING)
  225.          'I',0,
  226.          'T',0,
  227.          'O',0,
  228.          ' ',0,
  229.          'C',0,
  230.          'O',0,
  231.          'M',0,
  232.          ' ',0,
  233.          'V',0,
  234.          'r',0,
  235.          't',0,
  236.          'u',0,
  237.          'a',0,
  238.          'l',0
  239. };
  240.  
  241. #ENDIF
  242.  
  243.  

Al momento de conectar el dispositivo al puerto USB, se pide la instalación del mismo, basta con proporcionar un archivo .inf con la información adecuada, este lo encuentras entre las utilidades que proporciona Microchip, por cualquier cosa adjunto el que yo usé, básicamente es el mismo de Microchip con muy pequeñas modificaciones:

Código: Text
  1.  
  2. ; Windows USB CDC ACM Setup File
  3. ; Copyright (c) 2000 Microsoft Corporation
  4. ; Copyright (C) 2004 Microchip Technology Inc.
  5.  
  6. [Version]
  7. Signature="$Windows NT$"
  8. Class=Ports
  9. ClassGuid={4D36E978-E325-11CE-BFC1-08002BE10318}
  10. Provider=%MCHP%
  11. LayoutFile=layout.inf
  12. DriverVer=08/17/2001,5.1.2600.0
  13.  
  14. [Manufacturer]
  15. %MFGNAME%=DeviceList
  16.  
  17. [DestinationDirs]
  18. DefaultDestDir=12
  19.  
  20. [SourceDisksFiles]
  21.  
  22. [SourceDisksNames]
  23.  
  24. [DeviceList]
  25. %DESCRIPTION%=DriverInstall, USBVID_04D8&PID_000A
  26.  
  27. ;------------------------------------------------------------------------------
  28. ;  Windows 2000/XP Sections
  29. ;------------------------------------------------------------------------------
  30.  
  31. [DriverInstall.nt]
  32. CopyFiles=DriverCopyFiles
  33. AddReg=DriverInstall.nt.AddReg
  34.  
  35. [DriverCopyFiles]
  36. usbser.sys,,,0x20
  37.  
  38. [DriverInstall.nt.AddReg]
  39. HKR,,DevLoader,,*ntkern
  40. HKR,,NTMPDriver,,usbser.sys
  41. HKR,,EnumPropPages32,,"MsPorts.dll,SerialPortPropPageProvider"
  42.  
  43. [DriverInstall.nt.Services]
  44. AddService=usbser, 0x00000002, DriverService
  45.  
  46. [DriverService]
  47. DisplayName=%SERVICE%
  48. ServiceType=1
  49. StartType=3
  50. ErrorControl=1
  51. ServiceBinary=%12%usbser.sys
  52.  
  53. ;------------------------------------------------------------------------------
  54. ;  String Definitions
  55. ;------------------------------------------------------------------------------
  56.  
  57. [Strings]
  58. MCHP="Microchip Technology Inc."
  59. MFGNAME="Microchip Technology Inc."
  60. DESCRIPTION="Puerto virtual de comunicaciones"
  61. SERVICE="Controlador de emulación RS-232 USB"
  62.  
  63.  

Saludos, espero sea de utilidad :).
La imaginación es el límite.
Hardware & Software | Mexchip

georgegeorge

  • Nuevo Miembro
  • *
  • Mensajes: 3
    • Ver Perfil
Re:Conexión Usb-matlab
« Respuesta #15 en: Jueves 29 de Mayo de 2014, 18:20 »
0
HOLA MUCHACHOS LES DEJO UN NUEVO TEMA SOBRE PUERTO USB CON MATLAB

https://www.youtube.com/watch?v=5YMB-24a-eE