



Codigo:
/////////////////////////////////////////////////////////////////////////////
//
// 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
Codigo:
[Version]
Signature=$CHICAGO$
Class=%ClassName%
ClassGuid={4D36E911-E325-11CE-BFC1-08002BE10318}
Provider=%MFGNAME%
DriverVer=08/26/2005,1.0.0.0
[Manufacturer]
%MFGNAME%=DeviceList
[DestinationDirs]
DefaultDestDir=10,System32Drivers
[SourceDisksFiles]
mchpusb.sys=1
wdmstub.sys=1
[SourceDisksNames]
1=%INSTDISK%,,,
[DeviceList]
%DESCRIPTION%=DriverInstall,USBVID_04D8&PID_0011
;------------------------------------------------------------------------------
; Class section
;------------------------------------------------------------------------------
[ClassInstall32]
Addreg=PicUSBClassReg
[PicUSBClassReg]
HKR,,,0,%ClassDesc%
HKR,,Class,,%ClassName%
HKR,,Icon,,-21
;------------------------------------------------------------------------------
; Windows 2000/XP Sections
;------------------------------------------------------------------------------
[DriverInstall.ntx86]
CopyFiles=DriverCopyFiles
[DriverCopyFiles]
mchpusb.sys,,,2
[DriverInstall.ntx86.Services]
AddService=PicUSB,2,DriverService
[DriverService]
ServiceType=1
StartType=3
ErrorControl=1
ServiceBinary=%10%system32driversmchpusb.sys
;------------------------------------------------------------------------------
; Windows 98/Me Sections
;------------------------------------------------------------------------------
[DriverInstall]
AddReg=DriverAddReg
CopyFiles=DriverCopyFiles,StubCopyFiles
DriverVer=08/26/2005
[DriverAddReg]
HKR,,DevLoader,,*ntkern
HKR,,NTMPDriver,,"wdmstub.sys,mchpusb.sys"
[StubCopyFiles]
wdmstub.sys,,,2
;------------------------------------------------------------------------------
; String Definitions
;------------------------------------------------------------------------------
[Strings]
MFGNAME="J1M PicUSB"
INSTDISK="PicUSB Device Driver Disc"
DESCRIPTION="PicUSB"
ClassName="PicUSB Sample Device"
ClassDesc="PicUSB Device"



)

Estoy un poco atrazado, dónde puedo conseguir el CCS v. 3.227 o superior???

. Seguro que a partir de él y tu prometedor proyecto va a surgir una verdadera Brainstorm ...

, lo mirare a ver q sako en claro. Lo de las interrupciones del PC lo tenia d momento estancado. Pero las interrupciones del PIC ya las he sakao y funcionan muy bien, por si os interesa mirar el fichero Pic18_usb.h en la funcion void usb_isr_tok_dne() en la comparacion



.... Gracias


ni yo entiendo porque paso asi...



Codigo:
por ejemplo (os lo pongo en C para CCS q no se como se declaran en Basic)
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL3,CPUDIV1,VREGEN
#use delay(clock=48000000)
en el delay debo poner a la frecuencia a la que va a ir mi sistema... no la frecuencia del cristal que esté usando. 48Mhz para obtener 12mips y los 1,5MB de transmision del protocolo USB 2.0
El siguiente paso es configurar los fuses para que apartir de un cristal X obtener la frecuencia del sistema Y (en este caso 48Mhz), para eso nos vamos al DataSheet del 18Fxx5x, y a la página 31 y 32.
Vemos un peaaazo tabla en la que tendremos q mirar primero la columna de la izquierda (Input Oscillator Frecuency), seleccionamos la casilla correspondiente al cristal q estemos usando, en mi caso es de 12Mhz, ahora nos vamos a la columna de la derecha(Microcontroller Clock Frecuency) y buscamos los 48Mhz que queremos conseguir.
Ahora tenemos que ver que parámetros nos da la tabla para poner como Fuses, para el que estamos calculando tenemos:
PLL Division: +3 (011)
Clock Mode: HSPLL, ECPLL, ECPIO (a elegir entre uno de los tres...)
MCU Clock Division: +2 (00)
Por ultimo seleccionamos los fuses adecuados a esos parametros, esto ya dependerá un poco del compilador y los nosmbres q le haya dado, aunque generalmente se respetan los del datasheet, para el caso del CCS se tiene:
PLL Division: PLL3
Clock Mode: HSPLL
MCU Clock Division: USBDIV (para indicarle q vamos a usar el divisor tb para el USB), CPUDIV1 (aunq arriba sea +2, es el 00, y es el primero, usea "1"
Para vuestro caso que es de 4Mhz tendriais:
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,VREGEN
#use delay(clock=48000000)
Bueno espero que os haya quedado un poco mas claro... y q no os haya terminado de liar :P


RedPic se que esto te va a gustar, lo malo es que esta hecho con C18. Yo lo he probado y funcina perfectamente, seguramente sepas adaptarlo a tu RRBOARD y a CCS.
http://www.geocities.com/dariuskrail20/USBUSART.html
Saludos.
Buenooooo .... yo sigo con mi experimentos. :mrgreen:
Hasta ahora hemos estado trabajando con el método Bulk Transfers (Transferencia masiva) para conectarnos con el PIC vía USB 2.0. (Firmware, Driver y Aplicación+Dll) pero hay más .... :D
Otro método posible es el CDC USB (Communications Device Classes) que logra utilizar el USB como si fuera u fuese un puerto COM serie, Virtual pero tan puerto COM como el implementado con una UART. :shock:
Este método nos permite comunicarnos con el PIC mediante cualquier programa en el PC que pueda utilizar un puerto COM serie normal y corriente, como por ejemplo el HyperTerminal de Windows o el Siow del CCS C, además de cualquier aplicación que deseemos hacer en Delphi, Visual Basic u C++ que tenga la posibilidad de leer y escribir puertos COM. :)
El firmware de nuestro PIC le dice al Windows que es un puerto serie y éste va y se lo cree, añadiendolo como un puerto normal y corriente entre sus dispositivos. Para ello utiliza el mismo driver que usa para los demás puertos serie, por lo que no tenemos instalar un nuevo driver como era el caso del método Bulk Transfer. Solo tenemos que suministrarle un fichero .inf que nos pone a nuestra disposición Microchip y que le va a servir al PC para reconocer como este tipo de dispositivo a nuestro PIC con el correspondiente firmware a través del VIP&PID correspondiente.
Si queréis todos los detalles lo tenéis disponible en EL USB DESENCADENADO : CDC USB (http://picmania.garcia-cuervo.com/USB_3_CDCTransfers.htm)(http://picmania.garcia-cuervo.com/images/RRUSB_Complete_Cdc_Install_Driver_07.gif)
HOLA A TODOS, TENGO UN PROBLEMA CON EL PICUSB, ESPERO QUE ALGUIEN TENGA RESPUESTA A MI PROBLEMA PORQUE ESTO ME ESTA VOLVIENDO LOCO.
TODO COMENZO CUANDO ARME EL PROYECTO TAL Y COMO APARECE EN EL DIAGRAMA PUBLICADO EN http://www.hobbypic.com/index.php?option=com_content&task=view&id=14&Itemid=32, EL PIC 18F2550 LO PROGRAME USANDO EL PROGRAMADOR ART2003 Y TAMBIEN LOGRE INSTALAR LOS DRIVERS EN LA PC. MI PROBLEMA ES QUE EN OCASIONES CONECTO EL CIRCUITO A LA PC Y ME SALE UN MENSAJE DICIENDO QUE EL DISPOSITIVO NO PUDO SER INICIALIZADO O QUE EL DISPOSITIVO USB NO ES RECONOCIDO Y EL LED SE QUEDA EN COLOR ROJO Y DESPUES DE VARIOS INTENTOS LA PC LOGRA RECONOCER EL PICUSB Y EL LED SE PONE EN COLOR VERDE Y BUENO YA TODO FUNCIONA DE MARAVILLA. ALGUIEN SABE COMO PUEDO RESOLVER ESE PROBLEMA????
YA HE INTENTADO DESINTALANDO Y VOLVIENDO A INSTALAR LOS DRIVES, TAMBIEN EN EL FORO LEI QUE SE PODIA USAR DIFERENTES CRISTALES SIEMPRE Y CUANDO SE MODIFIQUE EL VALOR DEL OSCILADOR PARA LOGRAR GENERAR LOS 4MHZ, PERO NADA DE ESTO ME HA DADO BUENOS RESULTADOS, EL PROBLEMA SIGUE :shock: :x
ESPERO QUE ALGUIEN ME PUEDA AYUDAR Y DE ANTEMANO GRACIAS :-/
Si vemos la línea en negrita, parece ser que podría recibir hasta 5 bits, que me da un total de 2^5=32 combinaciones posibles, con lo que ya podría manejar algunos LEDs, ¿no es asi?
El problema es que no sé que tendría que hacer en el programa del pc para poder enviar esos datos al teclado, ¿alguien puede arrojar algo de luz sobre mi ignorancia?
Windows no puede cargar el controlador de dispositivo para este hardware porque instancia anterior del controlador de dispositivo está aún en memoria. (Código 38)
HOLA A TODOS, TENGO UN PROBLEMA CON EL PICUSB, ESPERO QUE ALGUIEN TENGA RESPUESTA A MI PROBLEMA PORQUE ESTO ME ESTA VOLVIENDO LOCO.(Aunque quizá ya lo arreglaste...) estoy casi seguro que tu problema está con la configuración del oscilador, muy probablemente estás usando un cristal de diferente valor al del cto. pero no lo has indicado en el código del firmware.
La DDK no la utilicé para crear el driver, sino la DLL que exporta el icono que se pone en el panel de control, simplemente, el driver es el mismo que suministra microchip, con algunas modificaciones, precisamente esas que hacen que aparezca el icono, pero son simplemente a nivel de .inf. Relee el texto de la página, verás como dice eso, es extraño que ya sois varios diciendo lo del tema del driver, creo que debe estar mal expresado, pero no tengo claro en que punto... si me dices que es lo que te ha llevado a pensar q tienes que crear el driver lo modifico para no llevar a confusiones a la gente.
un saludo!
TX_array[17]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17];
usb_put_packet(1, TX_array, 17, USB_DTS_TOGGLE);resultado="PRUEBA"; cambiando int8 de envia[] por char pero ni asi funciono, enves se mostro los numeros 234.//Definiciones para interactuar con el USB:
#define modo recibe[0]
#define param1 recibe[1]
#define param2 recibe[2]
#define dato0 envia[0]
#define dato1 envia[1]
void main(void)
{
//Variables:
int8 recibe[3];
int8 envia[2];
while (TRUE)
{
if(usb_enumerated()) //si el PicUSB está configurado
{
if (usb_kbhit(1)) //si el endpoint de salida contiene datos del host
{
usb_get_packet(1, recibe, 3); //cojemos el paquete de tamaño 3bytes del EP1 y almacenamos en recibe
if (modo == 0) // Modo_Suma
{
dato0=24;
dato1=4;
usb_put_packet(1,envia,2,USB_DTS_TOGGLE); //enviamos el paquete de tamaño 1byte del EP1 al PC
}
}
}
}
}
public uint Tiempo()
{
uint dato = 0;
byte* receive_buf = stackalloc byte[2];
DWORD RecvLength = 2;
ReceivePacket(receive_buf, &RecvLength);
dato = receive_buf[0];
return dato;
}
ReceivePacket(receive_buf, &RecvLength);en la variable RecvLength se guarda el número de bytes leídos, allí puedes verificar que hayas leído el número que esperas, que seguramente devolvió 1 en las ocasiones que no te ha funcionado como deseas (de allí ya puedes ver que la operación de lectura no es el problema :P).int16 mul;
mul = param1 * param2;
envia[ 0 ] = mul & 0xff;
envia[ 1 ] = ( mul & 0xff00 ) >> 8;
No importa lo que haga, al leer en la computadora el segundo byte siempre es 0 :(, ¿alguien conoce alguna particularidad del compilador CCS que sobre los corrimientos?int16 mul;
int16 a, b;
a = param1; b = param2;
mul = a * b;
// o también
mul = ( int16 )param1 * ( int16 )param2;
jaja ya lo habia hecho pero no quise poner mas mensajes, por ahora ando haciendo pruebas con el y estoy haciendo mi propio programa en este momento para ver si puedo convertir una comunicacacion serial a usb, lo intentare por ahora le agradeceria a alguno de ustedes si me pudiera explicar qeu diferencias hay entre: Bulk Transfers , HID, CDC, el ultimo lo entiendo pero agradeceria que alguien me pudiera ayudar en estas vacios de interesCheca aquí:
gracias
while(1)
{
usb_task();
usb_debug_task();
if(usb_enumerated()) //Devuelve 1 si el dispositivo fue enumerado correctamente
{
void main(void) {
int8 recibe[3]; //declaramos variables
int8 envia[1];
LED_OFF(LEDV); //encendemos led rojo
LED_ON(LEDR);
usb_init(); //inicializamos el USB
usb_task(); //habilita periférico usb e interrupciones
usb_wait_for_enumeration(); //esperamos hasta que el PicUSB sea configurado por el host
LED_OFF(LEDR);
LED_ON(LEDV); //encendemos led verde
while (TRUE)
{
if(usb_enumerated()) //si el PicUSB está configurado
{
if (usb_kbhit(1)) //si el endpoint de salida contiene datos del host
{
usb_get_packet(1, recibe, 3); //cogemos el paquete de tamaño 3bytes del EP1 y almacenamos en recibe
que no se porque aún no le han puesto una chincheta, amigos moderadores please ...
No, no se puede, todos los PIC que hay hasta ahora son esclavos. En un futuro seguro que los sacaran.
Un saludo
using PVOID = System.IntPtr;
using DWORD = System.UInt32;
namespace PicUSB
{
unsafe public class PicUSBAPI
{
#region Definición de los Strings: EndPoint y VID_PID
string vid_pid_norm = "vid_04d8&pid_0011";
string out_pipe = "\\MCHP_EP1";
string in_pipe = "\\MCHP_EP1";
#endregion
#region Funciones importadas de la DLL: mpusbapi.dll
unsafe public class PicUSBAPIFuete: usb.c
/****************************************************************************
/* usb_kbhit(endpoint)
/*
/* Input: endpoint - endpoint to check
/*
/* Output: TRUE if there is new data in RX buffer, FALSE if there is not.
/*
/* Summary: Similar to kbhit(), sees if there is new data in the RX USB buffers.
/*
/*****************************************************************************/
if (receive_buf[0] == 1)
{
switchst = receive_buf[1];
}
Es porq siempre lee 0 verdad? public void Esperar_dato() //Esto se produce cuando aprieto un boton en el Form1.
{
//Estas variables son para poder ejecutar _MPUSBRead
DWORD int_ = 0;
byte* recivi = stackalloc byte[1];
DWORD reclen = 1; DWORD *lengt = &reclen;
//Variables propias de mi xD!
byte cont = 1, d1=0, d2=0, d3=0, d4=0;
while (cont <= 4) //Bien, esto porq quiero solamente cojer 4 datos.
{
int_ = 0; //Esta varialbe indica "si uvo interrupcion" por simularlo de algun manera, espero se ntienda.
OpenPipes();
while (int_ == 0) //Y esto se ejecutara infinitamente hasta q haya algun dato en el bufer y q se coja correctamente, entonces int_ cambiara a 1.
{
int_ = _MPUSBRead(myInPipe, (void*)recivi, 1, lengt, 1); //Pues eso, la revicion infita =)
}
ClosePipes();
//Esto ultimo es para revisar los 4 datos q me llegan y luego mostrarlos por un mensaje.
switch (cont)
{
case 1: d1 = recivi[0]; break;
case 2: d2 = recivi[0]; break;
case 3: d3 = recivi[0]; break;
case 4: d4 = recivi[0]; break;
}
cont++; //Aumento contador para q se cumpla lo de leer solamente 4 veces.
}
//Y pues finalmente, lo muestro todo.
MessageBox.Show(d1.ToString() + " " + d2.ToString() + " " + d3.ToString() + " " + d4.ToString());
}
#include <18F2550.h>
#fuses xtPLL, NOWDT, NOPROTECT, NOLVP, NODEBUG, USBDIV, PLL1, CPUDIV1, VREGEN
#use delay(clock=48000000)
#use rs232(baud = 9600, xmit = PIN_C6, rcv = PIN_C7)
/////////////////////////////////
#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 1 //size to allocate for the tx endpoint 1 buffer
#define USB_EP1_RX_SIZE 3 //size to allocate for the rx endpoint 1 buffer
#include <pic18_usb.h> //Microchip PIC18Fxx5x Hardware layer for CCS's PIC USB driver
#include "USB_extreme_descriptores.h" //Configuración del USB y los descriptores para este dispositivo
#include <usb.c> //handles usb setup tokens and get descriptor reports
/////////////////////////////////
#define dato_recivido_1 recibe[0]
#define dato_recivido_2 recibe[1]
#define dato_recivido_3 recibe[2]
#define dato_a_enviar_1 envia[0]
/////////////////////////////////
void main(void)
{
int8 recibe[3]; //declaramos variables
int8 envia[1];
int16 i;
short enviado = 0;
printf("\fJEREMY!");
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
printf("\r\n%u", input(PIN_A0));
while (TRUE)
{
if(usb_enumerated()) //si el PicUSB está configurado
{
//Cuando se pone a 0 el A0, por un boton.
if (input(pin_a0) == 0)
{
dato_a_enviar_1 = 128; //EL DATO Q VOY A ENVIAR ES 128.
printf("%u", usb_put_packet(1, recibe, 1, USB_DTS_TOGGLE)); //Y envio y envio asta q se suelte el boton. Lo pongo printf porq luego me muestra si se
// cumplio con el envio o no, cuando no pulso el boton para chekear el bufer e VC# me pone 0, cuando captura
//los 4 q quiero me pone algunos 1 y otros 0.
}
}
}
}
jeremylf, fíjate en la línea: printf("%u", usb_put_packet(1, recibe, 1, USB_DTS_TOGGLE));Pero q descuidado (por no decir otra cosa) soy! :mrgreen: Creo q fue por culpa d un copy/paste :D
creo que lo que quieres hacer es: printf("%u", usb_put_packet(1, envia, 1, USB_DTS_TOGGLE));
public void Ejecutar()
{
UInt16* send_buf = stackalloc UInt16[3];
send_buf[0] = 1111;
send_buf[1] = 23;
send_buf[2] = 56;
SendPacket(send_buf, 3);
}
private void SendPacket(UInt16* SendData, DWORD SendLength)
.
.
.
void main(void)
{
int16 recibe[3]; //AQUI
int8 envia[1];
printf("\fJEREMY!");
usb_init();
usb_task();
usb_wait_for_enumeration();
while (TRUE)
{
if(usb_enumerated())
{
if (usb_kbhit(1) == 1)
{
printf("\r\n%Lu ", usb_get_packet(1, recibe, 3)); //Aqui cojo y muestro por rs232 la cantidad q cojio (ocea 3).
printf(" %Lu %Lu %Lu", recibe[0], recibe[1], recibe[2]); //Y aqui muestro cada uno d los valores de recibe[].
}
}
}
}
NOTE: NOT THOUROUGHLY TESTED. I AM NOT EVEN SURE IF THIS IS A GOOD IDEAQ cosas no? :D. Aunq tampoco sabria como usarla.
int16 usb_get_packet(int8 endpoint, int8 * ptr, int16 max)
16 bits son el numero de datos cojidos del bufer y no puede ser la cantidad de cada uno de ellos, porque el puntero (variable) que contendra tal valor esta especificado en el 2do argumento de esa funcion y pues, ahi indica q solo es de 8bits. Pero es raro, porq:Hola zana.
Veras, el driver de microchip (concretamente la mpusbapi) solo funciona en win xp y 98, EN VISTA NO. Creo q Jim lo comenta en el PicWinsUSB pero creo q no lo viste bien. Bueno, creo ese es el motivo porq no te funciona :-)
Otra cosa, siquieres hacer trabajar los ejemplos de PicUSB en otro lenguaje, q no sea el VC#, q tb estan en Hobbipic (ESTOS (http://www.hobbypic.com/index.php?option=com_content&task=view&id=24&Itemid=27)), decirte q solo funcionaran en xp y 98 como te comento el xq arriba.
Suerte.
Salu2 8)
Tienes mal configurado en el PIC el VID y el PID estos valores son erroneos: VID_0000&PID_0000
Un saludo
Novedades!!!Q bien! Solo, lo q no me gusta esq no hayan cambiado en nada a la DLL. Precisamente lo q ando como loco buscando... Catch a la interrupcion en bulk :lol:
Microchip ha sacado la versión 1.3 de su stack, en otras palabras, hay nueva versión del driver mpusbapi.dll, aquí las novedades...
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Runtime.InteropServices; // Clase para importar DLL
using System.Threading; //Clase para subprocesos.
using PVOID = System.IntPtr;
using DWORD = System.UInt32;
namespace PicUSB
{
unsafe public class PicUSBAPI
{
#region Definición de los Strings: EndPoint y VID_PID
static string vid_pid_norm = "vid_04d8&pid_0011"; //AHORA ES STATIC.
static string out_pipe = "\\MCHP_EP1"; //AHORA ES STATIC.
static string in_pipe = "\\MCHP_EP1"; //AHORA ES STATIC.
#endregion
#region Funciones importadas de la DLL: mpusbapi.dll
.
.
.
[DllImport("mpusbapi.dll")]
private static extern void* _MPUSBOpen(DWORD instance, string pVID_PID, string pEP, DWORD dwDir, DWORD dwReserved);
//LA NUEVA n.n'
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBEsperarInterrupcionYLeer(void* handle, void* pData, DWORD dwLen, DWORD* pLength);
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBRead(void* handle, void* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds);
.
.
.
#endregion
static void* myOutPipe; //AHORA ES STATIC.
static void* myInPipe; //AHORA ES STATIC.
//Creo un nuevo subproceso.
static ThreadStart clase = new ThreadStart(Work);
static Thread subprocedimiento = new Thread(clase);
static void Main()
{
//Inicializo el subprocedimiento.
subprocedimiento.Start();
Application.EnableVisualStyles();
Application.Run(new PicUSB());
}
public static void OpenPipes() //AHORA ES STATIC.
{
DWORD selection = 0;
myOutPipe = _MPUSBOpen(selection, vid_pid_norm, out_pipe, 0, 0);
myInPipe = _MPUSBOpen(selection, vid_pid_norm, in_pipe, 1, 0);
}
public static void ClosePipes() //AHORA ES STATIC.
{
_MPUSBClose(myOutPipe);
_MPUSBClose(myInPipe);
}
//Lo q quieras hacer cuando halla llegado el mensaje
public static void RutinaISR(byte DatoLeido)
{
MessageBox.Show("Aja! Encontre un dato x) \r\n" + DatoLeido.ToString());
}
//Codigo del Subproceso:
public static void Work()
{
while (true)
{
DWORD OcurrioInterrupcion = 0, LongitudDelDato;
byte* BuferDeDatos = stackalloc byte[1];
OpenPipes();
OcurrioInterrupcion = _MPUSBEsperarInterrupcionYLeer(myInPipe, (void*)BuferDeDatos, 1, &LongitudDelDato);
//Verifico si realmente es correcto si regreso con datos. Porq no regresara hasta que los tenga.
if ((OcurrioInterrupcion == 1) && (LongitudDelDato != 0))
{
RutinaISR(BuferDeDatos[0]); //Ejecuto lo q quiero hacer cuando es pase.
}
ClosePipes();
}
}
public void CerarHilo()
{
subprocedimiento.Abort();
}
}
}
Cuando llamo a _MPUSBEsperarInterrupcionYLeer(...) el subproceso se queda dormido, yaq ReadFile devuelve ERROR_IO_PENDING y la estructura overlapped es la encargada ahora de esperar que se lea algo en el buffer de entrada del host. Esto hace que no se gasten recursos del sistema.private void PicUSB_FormClosing(object sender, FormClosingEventArgs e)
{
usbapi.CerarHilo();
}
Hola zspikes.
A que te refieres con tu propio codigo para PC? A la programacion para el programa de usuario?, porq este esta echo en VC#, c++, delphi, etc.
Y tampoco se a q te refieres con las librerias gtk.
Quisiera ayudarte pero no entiendo q es lo q quieres enrealidad.
zspikes, no trabajo en Linux y no sabria ayudarte en esto. Creo, que aqui postearon como hacer PicUSB en Linux. Quiza el te pueda ayudar, esta unas paginas mas arriba creo =) Intenta contactactar con el, podria ayudarte en el tema de Linux.
Salu2
Hola Zspikes,
Los archivos fundamentales para el usb son el Picusb.c y el Picusb.h.
Saludos,
Miguel Angel.
Saludos Zspikes, para linux es mejor y mucho mas versatil usar Python para interactuar con el USB, hay miles de ejemplos en internet, ademas de poder crear una interfase gtk basada en python con wxpython. SuerteLo sé, siempre q puedo trato de usar python, no cabe duda de q nos saca un gran peso de encima para poder dedicarnos de pleno al problema principal... pero como comentaba mas arriba, el proyecto debe contar con una parte en C y otra en ensamblador. De todos modos no descarto tu consejo para futuros proyectos ;)
Y ya q estamos, pregunto... el programa q va grabado en el pic, será muy dificil de hacer en ensamblador? Es q para mi proyecto me piden una parte en C y otra en ensamblador, y de principio tenia pensado programar un pic en ensamblador y sus "drivers" en C. Creo q la unica parte dificil seria la de recibir y enviar datos por USB... una vez teniendo el dato, el resto del programa es facil.Mira que es lo que hace las funciones de envio/recibo y demas, en su respectivo archivo .c o .h, entiendelo, y luego mira tb lo q el CCS te traduce eso a assembler (en el archivo .list q te crea). Y, con eso, ya tienes todas las partes q quieres en C y/o assembler. Hasta podrias "reducir" el codigo, si sabes lo que haces claro :D
Hi!
i like to know it it is possible receive more than one byte with usb_receive. vi in labview? i receive more than one byte but the format is an integer and i dont know how separate the bytes of an integer. ist possible to recive the data in a array?
thanks and sorry for my english
#use delay(clock=48000000)
#use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7,parity=N) //Modificación
#include ".\include\usb_cdc.h"
#rom int 0xf00000={1,2,3,4}
#define enviar_on PIN_B0 //Modificación
#define STX 0x02
#define ETX 0x03
void enviar(void);
void recibir(void);
void enviar(void){
output_high(enviar_on);
delay_ms(5);
}
void recibir(void){
delay_ms(5);
output_low(enviar_on);
delay_ms(1);}
void main() {
BYTE i, j, address, value;
char c;
recibir();
delay_ms(333);
usb_cdc_init();
usb_init();
while(!usb_cdc_connected()) {}
do {
usb_task();
if (usb_enumerated())
{
if (kbhit()) {
c=getc();
usb_cdc_putc(c);}
}
if (usb_cdc_kbhit()) {
c=usb_cdc_getc();
enviar(); putc(c); recibir();}
}
}
} while (TRUE);
}
Huichoman dices que en la comunicación PC <---> PIC1 <---> PIC2 el PIC que se te queda colgado es el PIC2 ¿no? , que raro, parece que fuera más lógico que el que se colgara fuera el PIC1 que es el que tiene el USB ...
En el PIC1 (el que tiene USB) utilizas para la recepción de caracteres c=getc() en el while. Esto no es recomendable, a mí en ocasiones no me ha funcionado bien. Debes de hacerlo siempre por interrupción RDA.
En el PIC2 (esclavo) utilizas las rutina de interrupción de RedPic. Quizá seria aconsejable que dejaras una rutina de interrupción más pequeña sin tanto comando. Lo digo para que no te lies y una vez que te funcione pués añade lo que quieras, al fin y al cabo lo único que vas a recibir es un byte por interrupción.
No veo las señales de control del 485. Sin el control de estas señales no te puede funcionar.Las señales para el control 485 si estan, son las funciones enviar(); y recibir ();.
La aplicación que tengo es bastante larga. A ver si la recorto y te pego lo que me has pedido.
#include <18F4550.h>
#fuses XTPLL,MCLR,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,VREGEN,NOPBADEN
#use delay(clock=48000000)
#use RS232(BAUD=9600,BITS=8,PARITY=N,XMIT=PIN_C6,RCV=PIN_C7)
#use fast_io(B)
#include "usb_cdc.h"
char a[5];
int j,k;
#int_rda
void recepcion_serie()
{
if(kbhit())
{
a[j] = getc();
j++;
}
}
void main(void)
{
char c;
int x;
set_tris_b(0x00);
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);
output_high(pin_b7);
output_low(pin_b6);
usb_cdc_init();
usb_init();
while(!usb_cdc_connected()) {}
output_low (pin_b7);
output_high (pin_b6);
for (x=0;x<6;x++) //Fundamental inicializarlas, de lo contrario no va bien
a[x] =0;
while (1)
{
usb_task();
if(usb_enumerated())
{
if (usb_cdc_kbhit())
{
c=usb_cdc_getc();
putc(c);
}
if(j==4)
{
disable_interrupts(INT_RDA);
output_bit(PIN_B0,bit_test(a[0],0));
output_bit(PIN_B1,bit_test(a[1],0));
output_bit(PIN_B2,bit_test(a[2],0));
output_bit(PIN_B3,bit_test(a[3],0));
for (k=0;k<4;k++)
usb_cdc_putc(a[k]);
j=0;
enable_interrupts(INT_RDA);
}
}
}
}
#include <16f876.h>
#fuses XT, NOPROTECT, NOWRT, PUT, NOWDT, NOLVP, NOCPD, BROWNOUT
#use delay(clock=4000000)
#use rs232(baud=9600, BITS=8, PARITY=N, xmit=pin_c6, rcv=pin_c7)
#use fast_io(B)
#byte port_b=6
int j=0,n;
char c;
#int_rda
void recepcion_serie()
{
if(kbhit())
{
c = getc();
j=1;
}
}
void main(void)
{
set_tris_b(0x00);
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);
output_b(0x00);
while(1)
{
if(j==1)
{
disable_interrupts(INT_RDA);
if(c=='0')
output_bit(PIN_B0,1);
if(c=='1')
output_bit(PIN_B1,1);
if(c=='2')
output_bit(PIN_B2,1);
if(c=='3')
output_bit(PIN_B3,1);
if(c=='*')
output_b(0x00);
for (n=0;n<4;n++)
putc(bit_test(port_b,n) + '0');
j=0;
enable_interrupts(INT_RDA);
}
}
}Novedades!!!Jaja, ahora que ya estaba usando WinUSB con C++, mmmm, bueno, al menos aprendí algo más :D. Por ahora estoy usando WinUSB con C++ (uso VC++ 2008 Express), también libusb-win32 (con wxWidgets se tiene una aplicación USB completamente portable :D).
Microchip ha sacado la versión 1.3 de su stack, en otras palabras, hay nueva versión del driver mpusbapi.dll, aquí las novedades:
What's New/Updated in Release v1.3
· Microchip General Purpose USB Windows® Driver, mchpusb.sys v1.0.0.6, is updated to support Windows Vista™ and 64-bit Windows® Operating Systems. This version is WHQL certified.
· CDC RS-232 emulation INF file, mchpcdc.inf, updated for supporting Windows Vista™ 32-bit and 64-bit.
· Some bug fixes in USB library firmware (usb9.c).
http://ww1.microchip.com/downloads/en/DeviceDoc/Release%20Notes%20for%20MCHPFSUSB%20v1.3.htm
http://ww1.microchip.com/downloads/en/DeviceDoc/MCHPFSUSB_Setup_v1.3.exe
Ya se puede volver a jugar con el driver de microchip... ahora en Vista y versiones de 64bits de windows, voy a ojearlo a ver que tal va! ;)
Novedades!!!
Microchip ha sacado la versión 1.3 de su stack, en otras palabras, hay nueva versión del driver mpusbapi.dll, aquí las novedades:
Necesito comunicar el 18f4550 con la PC via USB
Alguna otra falla? sugerencia? esperaré hasta mañana :mrgreen: para fabricar el pcb y probar el funcionamiento del mismo :-/. Ya les iré contando como va a el asunto.
No se si llegaré a tiempo de avisarte que los pad's que pone por defecto el Eagle son muy finos y si no tienes cuidado al taladrar se podrían deteriorar o alguno de ellos en el atacado podrían desaparecer.
Un saludo
Sí Sisco! han tardado un año pero bueno, la espera ha merecido la pena :) ... Aunque nada como la experiencia de hacer nuestros propios drivers ehh!! jejeje vaya tardes de verano! :D
Hola Huichoman!
Yo iria con muchos cuidado porque eso maldito electrolitico explotan y tiran fuego :D
yo te recomendaria no soldarlo pegado a la platina ya que si coge fuego te quemaria la platina, por otro lado yo veo una recuadro negro en tu condensador y ese deberia ser el positivo yo estoy mirando todos los mio que tengo y ninguno son como el tuyo :D :D los mio pone un signo + en su pata
te aconsejo muchos cuidado, otras cosas es que no se si tu pusiste un Fusible al Bus USB en el + de entrada te recomiendo que lo ponga creeme un fusible de 500mA F que son rapido te salvaria de malo digusto. ya que hay muchas gente que no lo toman en cuenta y son alguna PC o laptop con el Bus USB defectuoso.
un Saludo suerte amigo :-/ :-/ :-/
Si, huicho, se puede programar y reprogramar el PIC con el USB conectado. Lo hago "cienes" y "cienes" de veces, lo único es que oirás el "tocotlon" y "tacatlan" del USB al desconectarse al grabar y reconectarse cuando termina de "tostarse".
Hola Geo, gracias por interesarte. A ver si con vuestra ayuda logro hacerlo funcionar.¿Qué driver instalaste? Es que mencionas el PicWinUSB de J1M, para que la aplicación en VB funcione, deberías haber instalado el driver de Microchip. ¿Puedes poner una captura de lo que te aparece en el administrador de dispositivos?
La función de carga del formulario es:
-----------------------------------------
...
-------------------------------------------------------------
Hay que tener en un directorio específico la mpusbapi, el proyecto VB i driver? Puede ser debido a una instalación del driver con versión de Windows equivocada (me extranya, sinó no me lo reconocería por la parte del PIC, cuando sí lo hace)? Disponia de dos archivos ClassInstaller del PicWinUSB de J1M. Supongo que instalé el correcto pq sinó no me lo reconocería no?.
Perdón por mi ignorancia, pero cuando me salgo de la programación del PIC, me empiezo a perder ...
Gracias
Olé!Qué bien que ya esté funcionando :-/, ahora a darle y que salgan proyectos interesantes :D.
Gracias Geo, cambié al Driver de Microchip y me funciona sin más problemas.. mil gracias!!
He seguido de cerca en este foro todo el material publicado sobre el proyecto USB, que lo he adoptado como una Biblia y me dediqué a estudiar la versión en Visual Basic a los efectos de aprender la filosofía.Primero que nada, bienvenido al foro :), estoy seguro de que pasarás un buen rato por aquí e intercambiarás conocimientos :).
Sin embargo, me encontré con la dificultad de que el firmware del PIC está escrito en C y carezco del compilador con sus librerías.
Agradecería enormemente si alguien pudiera indicarme donde bajar el compilador CCS PCWH 3.227 y/o algún firmware en lenguaje ensamblador (asm de MPLab) que tenga rutinas de comunicación por USB para el PIC18F2550 o 4550 para sacar ejemplos.
Bueno, espero no haber sido demasiado extenso, los felicito nuevamente y los saludo afectuosamente,
Elflamen.
Hola Geo, muchas gracias por la respuesta, también me gustaria saber qué software usaste en tu aplicación, para ver si es que influye. Si pudieras compartirlo para hacerle pruebas. De momento estoy consiguiendo el VC# 2005 o C#. Me servirá el Visual Studio 2008?. Thanks.Usé Visual C++ 2008 en su versión Express. Trabajé con las librerías de MCHPUSB de Microchip, WinUSB de Microsoft y libusb-win32. El programa en si es muy sencillo, es una aplicación de consola que utiliza la función de la API de Windows para obtener la hora en milisegundos, más o menos trabaja así:
t1 = ObtieneMilisegundos
*Envía paquete de 64 bytes al PIC por USB
t2 = ObtieneMilisegundos
*Recibe paqute de 64 bytes del PIC por USB
t3 = ObtieneMilisegundos
TiempoEnvio = t2 - t1
TiempoRecepcion = t3 - t2
* Esta parte del código es la que varía un poco de acuerdo a la librería que se esté utilizando.... algún firmware en lenguaje ensamblador (asm de MPLab) que tenga rutinas de comunicación por USB para el PIC18F2550 o 4550 para sacar ejemplos.
....
// Cálculo de tiempos y verificación de errores
int totalErrores = 0;
double sumaEnvio = 0;
double sumaRecepcion = 0;
double promedioEnvio = 0;
double promedioRecepcion = 0;
No es como mucho seleccionar un tipo float para estas operaciones ?Hola a todos. Necesito ayuda urgente sobre como capturar datos por el puerto usb¿Y este tema del foro no sirve precisamente para eso? Dale una leída al menos.
Mi duda es la siguiente, instale ese nuevo driver pensando que el driver mpusbapi se instalaria en mi PC pero busque y busque y no consegui encontrarlo, entonces la pregunta es la siguiente de donde se descarga la nuva DLL de microchip alguien puede poner el enlace ???
Hola J1M y Hola a todos...Descarga la nueva versión del driver de Microchip, es compatible con Windows Vista y mantiene compatibilidad a nivel API, por lo que portarlo a este sistema operativo debería significar sólo recompilar el proyecto utilizando la nueva versión del driver.
Trabaje con el driver que habias hecho para USB llamado PIC USB y lo integre con la version Visual C++ 6.0 del proyecto PICUSBStuf de tu pagina.
Ahora necesito miigrar el proyecto a Windows Vista y XP 64 bits pero manteniendo la plataforma en Visual C++ 6.0, porque ya tengo desarrollado la otra parte de mi tesis en esta version de Visual.
Es una característica de la arquitectura USB: transparente al usuario pero complicado en sus interiores (imagínate implementar un HUB).
Hola amigos!!!! hace rato que vengo siguiendo este foro porque esta por demas interesante. Me decidi a largar con el USB. Estoy programando en CCS y en Visual Basic.
Desde el PIC puedo enviar y recibir todos los datos que quiera.
El problema aparece desde la PC, puedo enviar todo lo que quiera, pero recibir solo puedo recibir 1 solo byte. :(
Ya he probado las mil y una maneras de recibir mas de un byte y no me es posible. Alguien tiene una idea que es lo que me puede estar pasando?
Agradezco todo tipo de comentarios. 8) 8) 8) 8)
holaaa, a alguien le ha funcionado el picUsb, con un 18f2450, llevo como 3 semanas tratando de comunicarlo, pero me ha sido imposible, me sale dispositivo desconocido, y le tengo los dos condensadores, c7 y cusb, les agradeceria su ayuda.
Hola a todos,¿De qué forma estás enviando/recibiendo los comandos?
Estoy tratando de implementar una interfase grafica usando Labview para contralar 10 lamparas incandesentes a traves del puerto USB, para esto se me basado en el magnifico trabajo de J1M, he logrado controlar 8 lamparas en forma independiente pero no puedo tener el control con los dos ultimos :5], aparte de esto este control es muy basico es decir solo puedo controlar una lampara a la ves, yo necesito poder controlar cualquier convinacion de lamparas, alquien podria decirme como puedo hacer esto? :?:
' * Project name:
' HIDtest (Testing the USB HID connection)
' * Copyright:
' (c) MikroElektronika, 2005 - 2008
' * Revision History:
' 20050502:
' - initial release;
' * Description:
' This example establishes connection with the HID terminal that is active
' on the PC. Upon connection establishment, the HID Device Name will appear
' in the respective window. After that software will wait for data and
' it will return received data back.
' * Test configuration:
' MCU: PIC18F4550
' Dev.Board: EasyPIC5
' Oscillator: HS 8.000 MHz (USB osc. is raised with PLL to 48.000MHz)
' Ext. Modules: -
' SW: mikroBasic v7.1
' * NOTES:
' - Be VERY careful about the configuration flags for the 18F4550 - there's
' so much place for mistake!
program USB_HID_test
include "USBdsc"
dim
k, i, ch as byte
userWR_buffer as byte[64]
userRD_buffer as byte[64]
'******************************************************************************
' Main Interrupt Routine
'******************************************************************************
sub procedure interrupt
'** this is a way to call a procedure from interrupt
HID_InterruptProc
end sub
'******************************************************************************
'******************************************************************************
' Initialization Routine
'******************************************************************************
sub procedure Init_Main
'--------------------------------------
' Disable interrupts
'--------------------------------------
INTCON = 0 ' Disable GIE, PEIE, TMR0IE,INT0IE,RBIE
INTCON2 = 0xF5
INTCON3 = 0xC0
RCON.IPEN = 0 ' Disable Priority Levels on interrupts
PIE1 = 0
PIE2 = 0
PIR1 = 0
PIR2 = 0
ADCON1 = ADCON1 or 0x0F ' Configure all ports with analog function as digital
'--------------------------------------
' Ports Configuration
'--------------------------------------
TRISA = 0xFF
TRISB = 0xFF
TRISC = 0xFF
TRISD = 0
TRISE = 0x07
LATA = 0
LATB = 0
LATC = 0
LATD = 0
LATE = 0
end sub
'******************************************************************************
' Main Program Routine
'******************************************************************************
main:
Init_Main()
HID_Enable(@userRD_buffer, @userWR_buffer)
Delay_mS(1000)
Delay_mS(1000)
while true
k = HID_Read()
i = 0
while i < k
ch = userRD_buffer[0]
userWR_buffer[0] = ch
HID_Write(@userWR_buffer, 1)
inc(i)
wend
wend
HID_Disable()
end.
module USBdsc
include "HIDconstant"
' File Version 1.01
'
'******************************************************************************
'******************************************************************************
' The number of bytes in each report,
' calculated from Report Size and Report Count in the report descriptor
'******************************************************************************
const HID_INPUT_REPORT_BYTES = 1
const HID_OUTPUT_REPORT_BYTES = 1
const HID_FEATURE_REPORT_BYTES = 2
'******************************************************************************
' Byte constants
'******************************************************************************
const NUM_ENDPOINTS = 2
const ConfigDescr_wTotalLength = USB_CONFIG_DESCRIPTOR_LEN + USB_INTERF_DESCRIPTOR_LEN + USB_HID_DESCRIPTOR_LEN + (NUM_ENDPOINTS * USB_ENDP_DESCRIPTOR_LEN)
const HID_ReportDesc_len = 47
const Low_HID_ReportDesc_len = HID_ReportDesc_len
const High_HID_ReportDesc_len = HID_ReportDesc_len >> 8
const Low_HID_PACKET_SIZE = HID_PACKET_SIZE
const High_HID_PACKET_SIZE = HID_PACKET_SIZE >> 8
'******************************************************************************
' Descriptor Tables
'******************************************************************************
const DescTables as byte[USB_DEVICE_DESCRIPTOR_ALL_LEN*2] = (
' Device Descriptor
USB_DEVICE_DESCRIPTOR_LEN, 0, ' bLength - Length of Device descriptor (always 0x12)
USB_DEVICE_DESCRIPTOR_TYPE, 0, ' bDescriptorType - 1 = DEVICE descriptor
0x00, 0, ' bcdUSB - USB revision 2.00 (low byte)
0x02, 0, ' (high byte)
0x00, 0, ' bDeviceClass - Zero means each interface operates independently (class code in the interface descriptor)
0x00, 0, ' bDeviceSubClass
0x00, 0, ' bDeviceProtocol
EP0_PACKET_SIZE, 0, ' bMaxPacketSize0 - maximum size of a data packet for a control transfer over EP0
0x34, 0, ' idVendor - Vendor ID (low byte)
0x12, 0, ' (high byte)
0x01, 0, ' idProduct - Product ID (low byte)
0x00, 0, ' (high byte)
0x01, 0, ' bcdDevice - ( low byte)
0x00, 0, ' (high byte)
0x01, 0, ' iManufacturer - String1
0x02, 0, ' iProduct - String2
0x00, 0, ' iSerialNumber - ( None )
0x01, 0, ' bNumConfigurations - 1
' Configuration Descriptor
USB_CONFIG_DESCRIPTOR_LEN, 0, ' bLength - Length of Configuration descriptor (always 0x09)
USB_CONFIG_DESCRIPTOR_TYPE, 0, ' bDescriptorType - 2 = CONFIGURATION descriptor
ConfigDescr_wTotalLength, 0, ' wTotalLength - Total length of this config. descriptor plus the interface and endpoint descriptors that are part of the configuration.
0x00, 0, ' ( high byte)
0x01, 0, ' bNumInterfaces - Number of interfaces
0x01, 0, ' bConfigurationValue - Configuration Value
0x00, 0, ' iConfiguration - String Index for this configuration ( None )
0xA0, 0, ' bmAttributes - attributes - "Bus powered" and "Remote wakeup"
50, 0, ' MaxPower - bus-powered draws 50*2 mA from the bus.
' Interface Descriptor
USB_INTERF_DESCRIPTOR_LEN, 0, ' bLength - Length of Interface descriptor (always 0x09)
USB_INTERFACE_DESCRIPTOR_TYPE, 0, ' bDescriptorType - 4 = INTERFACE descriptor
0x00, 0, ' bInterfaceNumber - Number of interface, 0 based array
0x00, 0, ' bAlternateSetting - Alternate setting
NUM_ENDPOINTS, 0, ' bNumEndPoints - Number of endpoints used in this interface
0x03, 0, ' bInterfaceClass - assigned by the USB
0x00, 0, ' bInterfaceSubClass - Not A boot device
0x00, 0, ' bInterfaceProtocol - none
0x00, 0, ' iInterface - Index to string descriptor that describes this interface ( None )
' HID Descriptor
USB_HID_DESCRIPTOR_LEN, 0, ' bLength - Length of HID descriptor (always 0x09)
USB_HID_DESCRIPTOR_TYPE, 0, ' bDescriptorType - 0x21 = HID descriptor
0x01, 0, ' HID class release number (1.01)
0x01, 0,
0x00, 0, ' Localized country code (none)
0x01, 0, ' # of HID class descriptor to follow (1)
0x22, 0, ' Report descriptor type (HID)
Low_HID_ReportDesc_len, 0,
High_HID_ReportDesc_len, 0,
' EP1_RX Descriptor
USB_ENDP_DESCRIPTOR_LEN, 0, ' bLength - length of descriptor (always 0x07)
USB_ENDPOINT_DESCRIPTOR_TYPE, 0, ' bDescriptorType - 5 = ENDPOINT descriptor
0x81, 0, ' bEndpointAddress - In, EP1
USB_ENDPOINT_TYPE_INTERRUPT, 0, ' bmAttributes - Endpoint Type - Interrupt
Low_HID_PACKET_SIZE, 0, ' wMaxPacketSize - max packet size - low order byte
High_HID_PACKET_SIZE, 0, ' - max packet size - high order byte
1, 0, ' bInterval - polling interval (1 ms)
' EP1_TX Descriptor
USB_ENDP_DESCRIPTOR_LEN, 0, ' bLength - length of descriptor (always 0x07)
USB_ENDPOINT_DESCRIPTOR_TYPE, 0, ' bDescriptorType - 5 = ENDPOINT descriptor
0x01, 0, ' bEndpointAddress - Out, EP1
USB_ENDPOINT_TYPE_INTERRUPT, 0, ' bmAttributes - Endpoint Type - Interrupt
Low_HID_PACKET_SIZE, 0, ' wMaxPacketSize - max packet size - low order byte
High_HID_PACKET_SIZE, 0, ' - max packet size - high order byte
1, 0, ' bInterval - polling interval (1 ms)
' HID_Report Descriptor
0x06, 0, ' USAGE_PAGE (Vendor Defined)
0xA0, 0,
0xFF, 0,
0x09, 0, ' USAGE ID (Vendor Usage 1)
0x01, 0,
0xA1, 0, ' COLLECTION (Application)
0x01, 0,
' The Input report
0x09, 0, ' USAGE ID - Vendor defined
0x03, 0,
0x15, 0, ' LOGICAL_MINIMUM (0)
0x00, 0,
0x26, 0, ' LOGICAL_MAXIMUM (255)
0x00, 0,
0xFF, 0,
0x75, 0, ' REPORT_SIZE (8)
0x08, 0,
0x95, 0, ' REPORT_COUNT (2)
HID_INPUT_REPORT_BYTES, 0,
0x81, 0, ' INPUT (Data,Var,Abs)
0x02, 0,
' The Output report
0x09, 0, ' USAGE ID - Vendor defined
0x04, 0,
0x15, 0, ' LOGICAL_MINIMUM (0)
0x00, 0,
0x26, 0, ' LOGICAL_MAXIMUM (255)
0x00, 0,
0xFF, 0,
0x75, 0, ' REPORT_SIZE (8)
0x08, 0,
0x95, 0, ' REPORT_COUNT (2)
HID_OUTPUT_REPORT_BYTES, 0,
0x91, 0, ' OUTPUT (Data,Var,Abs)
0x02, 0,
' The Feature report
0x09, 0, ' USAGE ID - Vendor defined
0x05, 0,
0x15, 0, ' LOGICAL_MINIMUM (0)
0x00, 0,
0x26, 0, ' LOGICAL_MAXIMUM (255)
0x00, 0,
0xFF, 0,
0x75, 0, ' REPORT_SIZE (8)
0x08, 0,
0x95, 0, ' REPORT_COUNT (2)
HID_FEATURE_REPORT_BYTES, 0,
0xB1, 0, ' FEATURE (Data,Var,Abs)
0x02, 0,
' End Collection
0xC0, 0 ' END_COLLECTION
)
'******************************************************************************
const LangIDDescr as byte[8] = (
0x04, 0,
USB_STRING_DESCRIPTOR_TYPE, 0,
0x09, 0, ' LangID (0x0409) - Low
0x04, 0 ' - High
)
'******************************************************************************
const ManufacturerDescr as byte[68] = (
34, 0,
USB_STRING_DESCRIPTOR_TYPE, 0,
"m", 0, 0, 0,
"i", 0, 0, 0,
"k", 0, 0, 0,
"r", 0, 0, 0,
"o", 0, 0, 0,
"E", 0, 0, 0,
"l", 0, 0, 0,
"e", 0, 0, 0,
"k", 0, 0, 0,
"t", 0, 0, 0,
"r", 0, 0, 0,
"o", 0, 0, 0,
"n", 0, 0, 0,
"i", 0, 0, 0,
"k", 0, 0, 0,
"a", 0, 0, 0
)
'******************************************************************************
const ProductDescr as byte[48] = (
24, 0,
USB_STRING_DESCRIPTOR_TYPE, 0,
"H", 0, 0, 0,
"I", 0, 0, 0,
"D", 0, 0, 0,
" ", 0, 0, 0,
"L", 0, 0, 0,
"i", 0, 0, 0,
"b", 0, 0, 0,
"r", 0, 0, 0,
"a", 0, 0, 0,
"r", 0, 0, 0,
"y", 0, 0, 0
)
'******************************************************************************
const StrUnknownDescr as byte[4] = (
2, 0,
USB_STRING_DESCRIPTOR_TYPE, 0
)
'******************************************************************************
'******************************************************************************
' Initialization Function
'******************************************************************************
implements
sub procedure InitUSBdsc
dim dummy as byte volatile register
dummy = NUM_ENDPOINTS
dummy = ConfigDescr_wTotalLength
dummy = HID_ReportDesc_len
dummy = Low_HID_ReportDesc_len
dummy = High_HID_ReportDesc_len
dummy = Low_HID_PACKET_SIZE
dummy = High_HID_PACKET_SIZE
dummy = HID_INPUT_REPORT_BYTES
dummy = HID_OUTPUT_REPORT_BYTES
dummy = HID_FEATURE_REPORT_BYTES
'******************************************************************************
' Byte constants
'******************************************************************************
dummy = NUM_ENDPOINTS
dummy = ConfigDescr_wTotalLength
dummy = HID_ReportDesc_len
dummy = Low_HID_ReportDesc_len
dummy = High_HID_ReportDesc_len
dummy = Low_HID_PACKET_SIZE
dummy = High_HID_PACKET_SIZE
dummy = @DescTables
dummy = @LangIDDescr
dummy = @ManufacturerDescr
dummy = @LangIDDescr
dummy = @ProductDescr
dummy = @StrUnknownDescr
end sub
end.
[cambio la pregunta] Hay alguna forma de implementar comunicacion hid, transmitiendo mas de dos bytes usando ccs, es posible o no es posible, que hay que hacer?
...Algo curioso es que aun me falla de ves en cuando es decir si crea el puerto COM, pero a veces sale con un icono de mal funcionamiento, pero basta con reiniciar el PIC y ya queda.
no he podido :5]!!!
no podría alguien poner un ejemplo simple de usar la mpusbapi.dll en VB .NET ???
muchas gracias
Mig, eso ya cambió...
Por un lado los chicos de Microchip actualizaron su driver/librería para que fuera compatible con Vista/Siete y versiones de 64bits.
Y por el otro, con respecto al driver que realizé basándome en el Winusb puedes descargarlo, ahora ya sin coste, de hobbypic.com
De todas formas emilio, tu quieres un driver para el CDC verdad?? Es que lo que he comentado ahí arriba, y lo que te decía el compañero migsantiago, es para la forma de control del usb basada en dll/driver.
un saludo.
vinnymoy, es raro el asunto, comprueba que no se haya fastidiado nada en la PCB o que el puerto ese USB esté mal...
jokep, te has pasado por hobbypic? hay un ejemplo para VB llamado:
"PicUSBStuff: Conecta tu PIC al PC por USB con el driver de Microchip y VC++, VB, Java, Delphi, Labview y Linux"
Simplemente sustituye la .dll por la nueva de microchip.
S2!
Hay veces que si por lo que sea, se instala la clave en el registro, pero no lo que lo acompaña, el sistema se queda tonto perdido! Recuerdo que cuando andaba intentando meter el famoso icono en el administrador de dispositivos, muchas de mis pruebas terminaron tirando de regedit para eliminar la clave a mano, pero vamos, que para que se de el caso, tienes que estar trasteando. Si el compañero no ha modificado nada, no debería tener este problema, pero es una opción... ^^
Hola Emilio,
Ojea este post:
http://www.todopic.com.ar/foros/index.php?topic=28448.msg241475#msg241475
Un saludo!
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,[b]PLL2[/b],CPUDIV1,VREGEN
el parametro MCU Clock Division lo dejo igual ya que como tengo HSPLL con dejar el CPUDIV1 me debe generar los 48Mhz que ocupo para que funcione. mi duda en este punto es si estoy usando bien la configuracion. public void otro(uint primero, uint segundo, uint tercero, uint cuarto, uint quinto, uint sexto, uint septimo, uint octavo)
{
byte* send_buf = stackalloc byte[9];
send_buf[0] = 0x02;
send_buf[1] = (byte)primero;
send_buf[2] = (byte)segundo;
send_buf[3] = (byte)tercero;
send_buf[4] = (byte)cuarto;
send_buf[5] = (byte)quinto;
send_buf[6] = (byte)sexto;
send_buf[7] = (byte)septimo;
send_buf[8] = (byte)octavo;
SendPacket(send_buf, 9);¿Si declaraste correctamente el tamaño de los búfers para los endpoint? Ahí indicas el número máximo de bytes a recibir/enviar:Código: C
#define USB_EP1_TX_SIZE 3 #define USB_EP1_RX_SIZE 3
/*******************************************************************************
/* usb_put_packet(endpoint,*ptr,len,toggle)
/*
/* Input: endpoint - endpoint to send packet to
/* ptr - points to data to send
/* len - amount of data to send
/* toggle - whether to send data with a DATA0 pid, a DATA1 pid, or toggle from the last DATAx pid.
/*
[b]/* Output: TRUE if data was sent correctly, FALSE if it was not. The only reason it will
/* return FALSE is if because the TX buffer is still full from the last time you
/* tried to send a packet.[/b]
/*
/* Summary: Sends one packet out the EP to the host. Notice that there is a difference
/* between a packet and a message. If you wanted to send a 512 byte message you
/* would accomplish this by sending 8 64-byte packets, followed by a 0 length packet.
/* If the last (or only packet) being sent is less than the max packet size defined
/* in your descriptor then you do not need to send a 0 length packet to identify
/* an end of message.
/*
/* usb_puts() (provided in usb.c) will send a multi-packet message correctly.
/*
/********************************************************************************///////////////////////////////////////////////////////////////////////////////
// Definiciones y equivalencias para el USB
/////////////////////////////////////////////////////////////////////////////
#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 10 //size to allocate for the tx endpoint 1 buffer
#define USB_EP1_RX_SIZE 14 //size to allocate for the rx endpoint 1 buffer
// Encendemos led rojo
LED_ON(LEDR);
// Inicializamos el USB
usb_init();
// Habilita periferico usb e interrupciones
usb_task();
// Esperamos hasta que el PicUSB sea configurado por el host
usb_wait_for_enumeration();
// Encendemos led verde y apagamos el rojo,
// es indicador de que el USB comienza a funcionar
LED_OFF(LEDR);
LED_ON(LEDV1);
while (TRUE)
{
if(usb_enumerated()) // Si el USB está configurado
{
if (usb_kbhit(1)) // Si el endpoint de salida contiene datos del host
{
// Cojemos el paquete de tamaño 14 bytes del EP1 y almacenamos en recibeUSB
usb_get_packet(1, recibeUSB, 14);
// Almacenamos datos y los enviamos a las mesas.
if (modo == 0)
{
LED_OFF(LEDV2);
LED_ON(LEDV3);
LED_OFF(LEDV4);
StatusEnvio=FALSE;
ReEnvio =TRUE;
EnvioDatos(); // función que envía datos a través del modulo MRF24J40MA
SPIreload();
}
// Los datos recibidos via inalambrica son enviados al PC
if (modo == 1)
{
LED_OFF(LEDV2);
LED_OFF(LEDV3);
LED_ON(LEDV4);
// Enviamos el paquete de tamaño 10 bytes del EP1 al PC
uno=usb_put_packet(1, enviaUSB, 10, USB_DTS_TOGGLE);
if (uno==0)
{ // Encendemos led verde2 para indicar que ha habido un fallo
LED_ON(LEDV2);
LED_OFF(LEDV3);
LED_ON(LEDV4);
}
// Se recarga el modulo MRF24J40MA para que vuelva a recibir datos.
SPIreload();
}
}
}
}
uno=usb_put_packet(1, enviaUSB, 10, USB_DTS_TOGGLE);
delay_ms(100);
if (uno==0)
{ // Encendemos led verde2 para indicar que ha habido un fallo
LED_ON(LEDV2);
LED_OFF(LEDV3);
LED_ON(LEDV4); Ah entonces no has modificado el archivo usb_desc_scope.h.
También en ése hay que asignar tamaño de endpoints.
char const USB_CONFIG_DESC[] = {
//config_descriptor for config index 1
USB_DESC_CONFIG_LEN, //length of descriptor size
USB_DESC_CONFIG_TYPE, //constant CONFIGURATION (0x02)
USB_TOTAL_CONFIG_LEN,0, //size of all data returned for this config
1, //number of interfaces this device supports
0x01, //identifier for this configuration. (IF we had more than one configurations)
0x00, //index of string descriptor for this configuration
0xC0, //bit 6=1 if self powered, bit 5=1 if supports remote wakeup (we don't), bits 0-4 reserved and bit7=1
0x32, //maximum bus power required (maximum milliamperes/2) (0x32 = 100mA)
//interface descriptor 0 alt 0
USB_DESC_INTERFACE_LEN, //length of descriptor
USB_DESC_INTERFACE_TYPE, //constant INTERFACE (0x04)
0x00, //number defining this interface (IF we had more than one interface)
0x00, //alternate setting
2, //number of endpoints, not counting endpoint 0.
0xFF, //class code, FF = vendor defined
0xFF, //subclass code, FF = vendor
0xFF, //protocol code, FF = vendor
0x00, //index of string descriptor for interface
//endpoint descriptor
USB_DESC_ENDPOINT_LEN, //length of descriptor
USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (0x05)
0x81, //endpoint number and direction (0x81 = EP1 IN)
0x02, //transfer type supported (0 is control, 1 is iso, 2 is bulk, 3 is interrupt)
USB_EP1_TX_SIZE,0x00, //maximum packet size supported
0x01, //polling interval in ms. (for interrupt transfers ONLY)
//endpoint descriptor
USB_DESC_ENDPOINT_LEN, //length of descriptor
USB_DESC_ENDPOINT_TYPE, //constant ENDPOINT (0x05)
0x01, //endpoint number and direction (0x01 = EP1 OUT)
0x02, //transfer type supported (0 is control, 1 is iso, 2 is bulk, 3 is interrupt)
USB_EP1_RX_SIZE,0x00, //maximum packet size supported
0x01, //polling interval in ms. (for interrupt transfers ONLY)
};
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Runtime.InteropServices; // Clase para importar DLL
using PVOID = System.IntPtr;
using DWORD = System.UInt32;
namespace FFTM.BusinessLayer.USB
{
unsafe public class USB
{
#region Variables
void* myOutPipe;
void* myInPipe;
#endregion
#region Constantes
private static string vid_pid_norm = "vid_04d8&pid_0011";
string out_pipe = "\\MCHP_EP1";
string in_pipe = "\\MCHP_EP1";
private const uint MESSAGE_OUT_LENGTH = 14;
private const uint MESSAGE_IN_LENGTH = 9;
#endregion
#region Properties
#endregion
#region Funciones importadas de la DLL: mpusbapi.dll
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBGetDLLVersion();
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBGetDeviceCount(string pVID_PID);
[DllImport("mpusbapi.dll")]
private static extern void* _MPUSBOpen(DWORD instance, string pVID_PID, string pEP, DWORD dwDir, DWORD dwReserved);
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBRead(void* handle, void* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds);
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBWrite(void* handle, void* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds);
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBReadInt(void* handle, DWORD* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds);
[DllImport("mpusbapi.dll")]
private static extern bool _MPUSBClose(void* handle);
#endregion
#region Constructor
public USB ()
{
}
#endregion
#region Methods
#region Public
public void OpenPipes()
{
DWORD selection = 0;
myOutPipe = _MPUSBOpen(selection, vid_pid_norm, out_pipe, 0, 0);
myInPipe = _MPUSBOpen(selection, vid_pid_norm, in_pipe, 1, 0);
}
public void ClosePipes()
{
_MPUSBClose(myOutPipe);
_MPUSBClose(myInPipe);
}
/// <summary>
/// Esta es la funcion que se usa para enviar los datos por usb al
/// interface Zigbee
/// </summary>
/// <param name="SendData">Array to send</param>
/// <param name="SendLength">length of the packet to send</param>
public void SendPacket(USBOutMessage outMessage)
{
byte[] messageStream = getOutMessageArray(outMessage);
fixed (byte* SendData = messageStream)
{
DWORD SendLength = MESSAGE_OUT_LENGTH;
uint SendDelay = 1000;
DWORD SentDataLength;
OpenPipes();
_MPUSBWrite(myOutPipe, (void*)SendData, SendLength, &SentDataLength, SendDelay);
ClosePipes();
}
}
// esta es la funcion que se usa para recibir los datos por usb al interface Zigbee
public USBInMessage ReceivePacket()
{
USBInMessage inMessage = null;
fixed (byte* ReceiveData = new byte[MESSAGE_IN_LENGTH])
{
DWORD ReceiveLength = MESSAGE_IN_LENGTH;
uint ReceiveDelay = 1000;
DWORD ExpectedReceiveLength = ReceiveLength;
OpenPipes();
_MPUSBRead(myInPipe, (void*)ReceiveData, ExpectedReceiveLength, &ReceiveLength, ReceiveDelay);
ClosePipes();
inMessage = getInMessage(ReceiveData);
}
return inMessage;
}using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Runtime.InteropServices; // Clase para importar DLL
using PVOID = System.IntPtr;
using DWORD = System.UInt32;
namespace PicUSB
{
unsafe public class PicUSBAPI
{
#region Definición de los Strings: EndPoint y VID_PID
string vid_pid_norm = "vid_04d8&pid_0011";
string out_pipe = "\\MCHP_EP1";
string in_pipe = "\\MCHP_EP1";
#endregion
#region Funciones importadas de la DLL: mpusbapi.dll
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBGetDLLVersion();
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBGetDeviceCount(string pVID_PID);
[DllImport("mpusbapi.dll")]
private static extern void* _MPUSBOpen(DWORD instance, string pVID_PID, string pEP, DWORD dwDir, DWORD dwReserved);
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBRead(void* handle, void* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds);
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBWrite(void* handle, void* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds);
[DllImport("mpusbapi.dll")]
private static extern DWORD _MPUSBReadInt(void* handle, DWORD* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds);
[DllImport("mpusbapi.dll")]
private static extern bool _MPUSBClose(void* handle);
#endregion
void* myOutPipe;
void* myInPipe;
static void Main()
{
Application.EnableVisualStyles();
Application.Run(new PicUSB());
}
public void OpenPipes()
{
DWORD selection = 0;
myOutPipe = _MPUSBOpen(selection, vid_pid_norm, out_pipe, 0, 0);
myInPipe = _MPUSBOpen(selection, vid_pid_norm, in_pipe, 1, 0);
}
public void ClosePipes()
{
_MPUSBClose(myOutPipe);
_MPUSBClose(myInPipe);
}
private void SendPacket(byte* SendData, DWORD SendLength)
{
uint SendDelay = 1000;
DWORD SentDataLength;
OpenPipes();
_MPUSBWrite(myOutPipe, (void*)SendData, SendLength, &SentDataLength, SendDelay);
ClosePipes();
}
private void ReceivePacket(byte* ReceiveData, DWORD *ReceiveLength)
{
uint ReceiveDelay=1000;
DWORD ExpectedReceiveLength = *ReceiveLength;
OpenPipes();
_MPUSBRead(myInPipe, (void*)ReceiveData, ExpectedReceiveLength, ReceiveLength, ReceiveDelay);
ClosePipes();
} private const uint MESSAGE_IN_LENGTH = 9;
¿Esto no debería ser de 10?Código: [Seleccionar]private const uint MESSAGE_IN_LENGTH = 9;
¿Qué son USBOutMessage y USBInMessage? ¿Qué devuelve getOutMessage?
Hola J1m!!!
Pude hacer andar la aplicación en XP 32 sin ningun problema, Podra caminar en XP DE 64?
Imports System.Runtime.InteropServices.Marshal 'Importa el espacio de nombres que permite interactuar con código no administrado.
Public Class Cls_USB
'Convenciones de llamada a la librería mpusbapi.dll en C:
'DWORD _MPUSBGetDLLVersion(void)
'DWORD _MPUSBGetDeviceCount(PCHAR pVID_PID)
'HANDLE _MPUSBOpen(/*Input */ DWORD instance, /* Input */ PCHAR pVID_PID, /* Input */ PCHAR pEP, /*Input*/ DWORD dwDir, /*Input*/ DWORD dwReserved);
'DWORD _MPUSBRead(/*Input*/ HANDLE handle, /*Output*/ PVOID pData, /* Input */DWORD dwLen, /* Output */PDWORD pLength, /*Input*/ DWORD dwMilliseconds);
'DWORD _MPUSBWrite(/*Input*/ HANDLE handle, /*Input*/ PVOID pData, /*Input*/ DWORD dwLen, /*Output*/ PDWORD pLength, /*Input*/ DWORD dwMilliseconds);
'DWORD _MPUSBReadInt(/*Input*/ HANDLE handle, /*Output*/ PVOID pData, /* Input */DWORD dwLen, /* Output */PDWORD pLength, /*Input*/ DWORD dwMilliseconds);
'Funciones API equivalentes para llamar desde Visual Basic.NET.
Private Declare Function MPUSBGetDLLVersion Lib "mpusbapi.dll" Alias "_MPUSBGetDLLVersion" () As Integer
Private Declare Function MPUSBGetDeviceCount Lib "mpusbapi.dll" Alias "_MPUSBGetDeviceCount" (ByVal pVID_PID As String) As Integer
Private Declare Function MPUSBOpen Lib "mpusbapi.dll" Alias "_MPUSBOpen" (ByVal instance As Integer, ByVal pVID_PID As String, ByVal pEP As String, ByVal dwDir As Integer, ByVal dwReserved As Integer) As Integer
Private Declare Function MPUSBClose Lib "mpusbapi.dll" Alias "_MPUSBClose" (ByVal handle As Integer) As Integer
Private Declare Function MPUSBRead Lib "mpusbapi.dll" Alias "_MPUSBRead" (ByVal handle As Integer, ByVal pData As Integer, ByVal dwLen As Integer, ByRef pLength As Integer, ByVal dwMilliseconds As Integer) As Integer
Private Declare Function MPUSBWrite Lib "mpusbapi.dll" Alias "_MPUSBWrite" (ByVal handle As Integer, ByVal pData As Integer, ByVal dwLen As Integer, ByRef pLength As Integer, ByVal dwMilliseconds As Integer) As Integer
Private Declare Function MPUSBReadInt Lib "mpusbapi.dll" Alias "_MPUSBReadInt" (ByVal handle As Integer, ByRef pData() As Byte, ByVal dwLen As Integer, ByRef pLength As Integer, ByVal dwMilliseconds As Integer) As Integer
'Funciones API externas a mpusbapi.dll.
Private Declare Function GetLastError Lib "kernel32" () As Integer
'Constantes de la API.
Private Const VALOR_INVALIDO_HANDLE As Short = -1
Private Const ERROR_HANDLE_INVALIDO As Short = 6
'Constantes de conectividad con el PIC.
Private Const EP_SALIDA As String = "\MCHP_EP1" 'Endpoint de salida de datos.
Private Const EP_ENTRADA As String = "\MCHP_EP1" 'Endpoint de entrada de datos.
Private Const USB_FALLA As Short = 0
Private Const USB_EXITO As Short = 1
Private Const USB_TRANSMITIR As Short = 0
Private Const USB_RECIBIR As Short = 1
'Variables de la clase.
Private int_EPRecepcion As Integer 'Endpoint de entrada de datos.
Private int_EPTransmision As Integer 'Endpoint de salida de datos.
Private str_VID As String 'Cadena de 4 caracteres que contiene el Vendor ID.
Private str_PID As String 'Cadena de 4 caracteres que contiene el Periferic ID.
'Eventos de la clase.
Public Event Falla(ByVal Num_error As Integer, ByVal Descripcion_error As String, ByVal Procedimiento_error As String)
'Propiedad de lectura y escritura asociada al Vendor ID del dispositivo USB.
Public Property VID() As String
Get
Return str_VID
End Get
Set(ByVal Valor As String)
str_VID = Valor
End Set
End Property
'Propiedad de lectura y escritura asociada al Product ID del dispositivo USB.
Public Property PID() As String
Get
Return str_PID
End Get
Set(ByVal Valor As String)
str_PID = Valor
End Set
End Property
Private Sub Initialize()
'Define los valores iniciales para los Endpoints.
int_EPRecepcion = VALOR_INVALIDO_HANDLE
int_EPTransmision = VALOR_INVALIDO_HANDLE
End Sub
Public Function Conectar() As Boolean
Dim int_NumDispositivos As Integer 'Cantidad de dispositivos con el mismo PID y VID que estan conectados.
Dim str_VID_PID As String 'Cadena de identificación del dispositivo.
On Error GoTo TERMINAR
'Todos los Endpoints adquieren su valor inicial.
int_EPRecepcion = VALOR_INVALIDO_HANDLE
int_EPTransmision = VALOR_INVALIDO_HANDLE
'Arma la cadena de identificación utilizando el PID y el VID.
str_VID_PID = "vid_" & LCase(str_VID) & "&pid_" & LCase(str_PID)
'Cuenta cuandos dispositivos USB con el VID y PID requeridos hay conectados.
int_NumDispositivos = MPUSBGetDeviceCount(str_VID_PID)
'Si se detectó al menos un dispositivo USB conectado que satisfaga el VID y el PID
'se abre el puerto USB para la recepción y transmisión de datos.
If int_NumDispositivos > 0 Then
int_EPTransmision = MPUSBOpen(0, str_VID_PID, EP_SALIDA, USB_TRANSMITIR, 0)
int_EPRecepcion = MPUSBOpen(0, str_VID_PID, EP_ENTRADA, USB_RECIBIR, 0)
'Si no se puede abrir alguno de los Endpoints entonces se muestra una ventana que informa al usuario de lo sucedido.
If int_EPTransmision = VALOR_INVALIDO_HANDLE Or int_EPRecepcion = VALOR_INVALIDO_HANDLE Then
TERMINAR:
int_EPTransmision = VALOR_INVALIDO_HANDLE
int_EPRecepcion = VALOR_INVALIDO_HANDLE
'Dispara el evento que indica que se produzco un error al tratar de iniciar la comunicación USB.
RaiseEvent Falla(GetLastError(), "Error al tratar de abrir los Endpoints. EP de salida = " & CStr(int_EPTransmision) & ". EP de entrada = " & CStr(int_EPRecepcion), "Conectar")
Else
'Si se pudo abrir el puerto correctamente entonces la función termina retornando el valor TRUE.
Return True
Exit Function
End If
Else
'Si no se detecta ningun dispositivo conectado se dispara el evento.
RaiseEvent Falla(GetLastError(), "No hay ningún dispositivo USB conectado al puerto.", "Conectar")
End If
'Si ha ocurrido un error entonces la función retorna el valor False.
Return False
End Function
'Procedimiento para cerrar el periférico USB.
Public Sub Desconectar()
On Error GoTo TERMINAR
'Comprueba si los Endpoints estan abiertos y los cierra en tal caso.
If int_EPTransmision <> VALOR_INVALIDO_HANDLE Then
MPUSBClose(int_EPTransmision)
int_EPTransmision = VALOR_INVALIDO_HANDLE
End If
If int_EPRecepcion <> VALOR_INVALIDO_HANDLE Then
MPUSBClose(int_EPRecepcion)
int_EPRecepcion = VALOR_INVALIDO_HANDLE
End If
TERMINAR:
End Sub
'Función que envia un cantidad de bytes espefica a traves del puerto USB. Los parámetros son:
'
'Datos_Envio: Matriz de bytes que contienen los datos a enviar.
'Longitud_Envio: Longitud en bytes de los datos a enviar.
'Tiempo_Envio: Tiempo máximo permitido para el envío en milisegundos.
Public Function Enviar(ByRef Datos_envio() As Byte, ByVal Longitud_envio As Integer, ByVal Tiempo_envio As Integer) As Boolean
Dim int_LongDatosEnv As Integer
'Solo probara de enviar los datos si los Endpoints han sido abiertos correctamente.
'Si alguno de los Endpoints falla entonces la función retorna el valor False.
If (int_EPTransmision <> VALOR_INVALIDO_HANDLE And int_EPRecepcion <> VALOR_INVALIDO_HANDLE) Then
'Llama a la función API que permite enviar datos a traves del puerto USB.
'Si la función responde que ha podido enviar los datos satisfactoriamente entonces la función retorna el valor True,
'de lo contrario se verifica el error y la función retorna el valor False.
If (MPUSBWrite(int_EPTransmision, Runtime.InteropServices.Marshal.UnsafeAddrOfPinnedArrayElement(Datos_envio, 0).ToInt32(), Longitud_envio, int_LongDatosEnv, Tiempo_envio) = USB_EXITO) Then
Return True
Exit Function
Else
'Dispara el evento que informa sobre una falla en la comunicación USB.
RaiseEvent Falla(GetLastError(), "Error al tratar de verificar el Handle.", "Enviar")
'La causa más habitual de este error es que el circuito esté desconectado, por lo tanto cierra el puerto.
Me.Desconectar()
End If
End If
Return False
End Function
'Función que envia un pedido al dispositivo conectado para que le envie datos a traves del puerto USB. Los parámetros son:
'
'Datos_Pedido: Matriz de bytes que contiene el pedido de respuesta a enviar.
'Longitud_Pedido: Longitud en bytes del pedido de respuesta.
'Tiempo_Envio: Tiempo máximo permitido para el envío del pedido en milisegundos.
'Datos_Recepcion: Matriz de bytes que almacena los datos recibidos.
'Longitud_Recepcion: Longitud en bytes de los datos a recibir.
'Tiempo_Recepcion: Tiempo máximo permitido para la recepcion de los datos en milisegundos.
Public Function Recibir(ByRef Datos_Pedido() As Byte, ByVal Longitud_Pedido As Integer, ByRef Datos_Recepcion() As Byte, ByRef Longitud_Recepcion As Integer, ByVal Tiempo_Envio As Integer, ByVal Tiempo_Recepcion As Integer) As Boolean
Dim int_LongitudDatosEnv As Integer
Dim int_LongitudEsperada As Integer
'Se espera recibir la misma cantidad de datos que los que se piden.
int_LongitudEsperada = Longitud_Recepcion
'Solo probara de enviar los datos si los Endpoints han sido abiertos correctamente.
'Si alguno de los Endpoints falla entonces la función retorna el valor False.
If (int_EPTransmision <> VALOR_INVALIDO_HANDLE And int_EPRecepcion <> VALOR_INVALIDO_HANDLE) Then
'Llama a la función API que permite enviar el pedido de datos a traves del puerto USB.
'Si se produce un error en el envio del pedido se dispara el evento Falla.
If (MPUSBWrite(int_EPTransmision, Runtime.InteropServices.Marshal.UnsafeAddrOfPinnedArrayElement(Datos_Pedido, 0).ToInt32(), Longitud_Pedido, int_LongitudDatosEnv, Tiempo_Envio) = USB_EXITO) Then
'Si la función responde que ha podido enviar el pedido satisfactoriamente entonces se espera los datos desde el dispositivo externo.
'Si se produce un error mientras se reciben los datos se dispara el evento Falla.
If (MPUSBRead(int_EPRecepcion, Runtime.InteropServices.Marshal.UnsafeAddrOfPinnedArrayElement(Datos_Recepcion, 0).ToInt32(), int_LongitudEsperada, Longitud_Recepcion, Tiempo_Recepcion) = USB_EXITO) Then
'Si la función responde que ha podido recibir los datos satisfactoriamente entonces verifica si la longitud de la información recibida
'es igual a la esperada. Si es menor se han perdido datos en la transmisión y la función retorna el valor False.
'De lo contrario, la función retorna el valor True indicando que todo se ha desarrollado correctamente.
If (Longitud_Recepcion = int_LongitudEsperada) Then
Return True
Exit Function
ElseIf (Longitud_Recepcion < int_LongitudEsperada) Then
'Dispara el evento que informa sobre una falla en la comunicación USB.
RaiseEvent Falla(GetLastError(), "Pérdida de datos desde el dispositivo.", "Recibir")
Return False
Exit Function
End If
Else
'Dispara el evento que informa sobre una falla en la comunicación USB.
RaiseEvent Falla(GetLastError(), "Error al tratar de verificar el Handle.", "Recibir")
'La causa más habitual de este error es que el circuito esté desconectado, por lo tanto cierra el puerto.
Me.Desconectar()
End If
Else
'Dispara el evento que informa sobre una falla en la comunicación USB.
RaiseEvent Falla(GetLastError(), "Error al tratar de verificar el Handle.", "Recibir")
'La causa más habitual de este error es que el circuito esté desconectado, por lo tanto cierra el puerto.
Me.Desconectar()
End If
End If
'La función retorna el valor FALSE si se ha producido algun error durante la transmisión o recepción.
Return False
End Function
End ClassAlguien ha hecho funcionar la MPUSBAPI.DLL bajo algun sistema operativo de 64 bits??? No importa que lenguaje haya utilizado, si alguien la hizo andar, eso me va a ser de mucha ayuda...
La única duda que tenia en cuanto al montaje es sobre el condensador que va conectado con vusb que no tenia uno de 47uf a 25V y he colocado uno de 47uf a 16V. ¿Puede deberse a ésto el problema?
mustafa23
para ti tengo varios puntos:
1.- ¿no la as simulado? ____________________"con el mismo programa que metes al pic"
2.- ¿te corre bien en el simulador?____________________"con el mismo programa que metes al pic"
3.- ¿el led esta en la posicion correcta?
4.- ¿ya probaste con otro pic?
5.- al comienzo del proyecto "PICUSB", J1M recomiendo utilizar winpic800
6.- prueva con otro programador
7.- deves de tener 3.3v en el pin 14 (VUSB).
8.- 5volt y masa estan en los pines correctos
9.- MUY INPORTANTE TENER EL PIN 1 (MCLR) CONECTADO ATRAVES DE UNA RESISTENCIA A 5 VOLT
10.- realiza un programa de conmutacion de todo un puerto es muy simple pero veras signos de vida en el pic.
revisa y/o realiza estos puntos y nos informas para ver tu cazo
entiendo que talves algunos punto no sean posibles de efectuar por disponibilidad de herramienta pero solo realiza los que esten a tu alcanse.
espero y te sirvan en algo
salidos
UPS...
siertamento no hay especificacion de este tipo por ningun lado
pero por lo menos he leido algo de usb y se que la PC puede con un maximo de 500 MiliAmper por cada puerto
quiza esto aplique tambien para los micros
Hola buenos dias una duda en el punto 7 haces referencia a tener 3.3 voltios en el pin vusb que segun el datashets del micro es un valida con regulador de voltaje ese voltaje de 3.3voltios lo puedo tomar para alimentar una eeprom externa que tengo en un proyecto que estoy realizando yo revise las caracteristicas y no me dice nada del amperaje que suministra ese regulador del pin Vusb porque si es inferior al consumo de la eeprom que voy alimentar puedo crear problemas en el pic.
Saludos y espero su gentil comentario al respecto.
Atten.
Alexander Santana.
Venezuela-Barcelona.
Hola buenos dias una duda en el punto 7 haces referencia a tener 3.3 voltios en el pin vusb que segun el datashets del micro es un valida con regulador de voltaje ese voltaje de 3.3voltios lo puedo tomar para alimentar una eeprom externa que tengo en un proyecto que estoy realizando yo revise las caracteristicas y no me dice nada del amperaje que suministra ese regulador del pin Vusb porque si es inferior al consumo de la eeprom que voy alimentar puedo crear problemas en el pic.
Saludos y espero su gentil comentario al respecto.
Atten.
Alexander Santana.
Venezuela-Barcelona.
Hola Astrocar
Nunca debes usar el regulador interno USB del pic para alimentar otras cosas.
Usa un regulador aparte. ;-)
17.2.2.8 Internal Regulator
The PIC18FX455/X550 devices have a built-in 3.3V reg-
ulator to provide power to the internal transceiver and
provide a source for the internal/external pull-ups. An
external 220nF (±20%) capacitor is required for stability.
The regulator is enabled by default and can be disabled
through the VREGEN Configuration bit.
When enabled, the voltage is visible on pin VUSB. When the regulator
is disabled, a 3.3V source must be provided through
the VUSB pin for the internal transceiver. If the internal
transceiver is disabled, VUSB is not used.
Note: The drive from VUSB is sufficient to only
drive an external pull-up in addition to the
internal transceiver.
Note1: Do not enable the internal regulator if an
external regulator is connected to VUSB.
2: VDD must be greater than VUSB at all
times, even with the regulator disabled
OK, Astro. Sería interesante ver a una pequeña eeprom como parásita del pobre regulador :laugh:
Hola Astro
Por ejemplo, la AT24C64 de Atmel trabajando a 5V y en escritura, consume 3mA.
Pero si trabajara a 3.3V la corriente debería incrementarse para mantener la potencia. Haciendo el cálculo subiría a 4.54mA.
Ya nos contarás cómo se comporta el PIC. :mrgreen:
ya el link del proyecto no existe!!! :(
Alguien me lo puede facilitar por favor....
Se les agradece la ayuda!
Alguno de los expertos del USB podria decirme donde encuentro el valor para USB_DTS_TOGGLE, o en que archivo esta definido porque lo he buscado en pic18_usb.c,usb.c,usb.h y no lo encuentro, es solo para saber que es, sino me quedo con la duda y eso es peor.
gracias
Yo no hablo español, así que utilizei la herramienta de Google para traducir para mí.
Esto projectio está muy bien. Sin embargo, no está trabajando conmigo.
He utilizado los archivos originales disponibles y nada. El Windows 7 reconoce el PIC, puede instalar el com driver. OK
Las luces del LED de color rojo se acende, luego verde. Normal.
Pero el app no apaga el LED. No suma!
El hardware es idéntica a la publicada. Sólo el condensador de 100nF que no tengo aquí conmigo.
Otra de las cosas. Estoy usando un 18F4550. Solo mudei a la instrucción # include 18f2550.h por # include 18F4550.
Estoy usando cristal 12MHz. Correcta?
Resumindo, win 7 reconocido, instalado con el driver, pero la aplicación no funciona.
Gracias
Como sugerencia te pediria que plantees la pregunta en tu lengua original (aqui hay varios que podremos leerla).
hola quisiera saber qu e pic es el mas apropiado para la comunicacion usb entre un pic y labview
/////////////////////////////////////////////////////////////////////////
//// 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. ////
//// ////
//// Actualizado en Julio de 2009 para uso en Matlab ////
//// por Ing. Gabriel Pool para proyecto de la materia Diseño ////
//// Mecatrónico impartida por el profesor Dr. Alejo Mosso Vazquez ////
//// (Universidad Modelo en Mérida, Yucatán, México) ////
//// Apoyado por Centro de Investigación Científica de Yucatán AC ////
//// Depto de Instrumentación ( www.cicy.mx) ////
//// ////
/////////////////////////////////////////////////////////////////////////
// Por favor, complete los 4 pasos siguientes ...
// Paso 1:
// Cambie la siguiente instrucción de acuerdo al PIC que utilice PIC18F2455/2550/4455/4550
#include <18F4550.h>
//#device ADC=10 //Descomente ésta opción en caso de usar el ADC a 10bits
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL4,CPUDIV1,VREGEN,MCLR,NOPBADEN
// Paso 2: Ajuste el fusible del PLL de acuerdo al Xtal que utilice
// No olvide que PLL1 = Para un Xtal de 4Mhz
// PLL2 = Para un Xtal de 8Mhz
// PLL3 = Para un Xtal de 12Mhz
// PLL4 = Para un Xtal de 20Mhz , etc.
#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
#define USB_EP1_RX_SIZE 64 //size to allocate for the rx endpoint 1 buffer
/////////////////////////////////////////////////////////////////////////////
// Lo siguiente no es indispensable:
// If you are using a USB connection sense pin, define it here. If you are
// not using connection sense, comment out this line. Without connection
// sense you will not know if the device gets disconnected.
// (connection sense should look like this:
// 100k
// VBUS-----+----/\/\/\/\/\----- (I/O PIN ON PIC)
// |
// +----/\/\/\/\/\-----GND
// 100k
// (where VBUS is pin1 of the USB connector)
//
/////////////////////////////////////////////////////////////////////////////
//#define USB_CON_SENSE_PIN PIN_B2 //CCS 18F4550 development kit has optional conection sense pin
/////////////////////////////////////////////////////////////////////////////
//
// Include the CCS USB Libraries. See the comments at the top of these
// files for more information
//
/////////////////////////////////////////////////////////////////////////////
#include <pic18_usb.h> //Microchip PIC18Fxx5x Hardware layer for CCS's PIC USB driver
#include <usb_desc_scope.h> //descriptors del Pic USB
#include <usb.c> //handles usb setup tokens and get descriptor reports
/////////////////////////////////////////////////////////////////////////////
/*
Paso 3: Abra el archivo C:\Archivos de programa\PICC\Drivers\usb_desc_scope.h
( donde se instaló el compilador de CCS ) que es el descriptor del USB
ubicado en su PC, avance hasta la sección start device descriptors
(aprox en la linea 132) y reemplace los valores del vendor id,
el product id y el device release number como sigue ( puede copiar
las tres líneas siguiente y pegar en el archivo del descriptor <<usb_desc_scope.h>> ) :
0xD8,0x04, //vendor id (0x04D8 is Microchip)
0x0B,0x00, //product id
0x01,0x00, //device release number
ESTO ES IMPORTANTE HACERLO CORRECTAMENTE 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
// Direcciones de memoria válidas para PIC18F2455/2550/4455/4550 (no olvide que son la misma familia)
// Esto es con el fin de poder escribir directamente en ellos sin usar instrucciones como intermediarios.
#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
int8 dato[64];
void main(void) {
LED_ON(LEDV); //encendemos led en RB6 para indicar presencia de energia
LED_OFF(LEDR);
usb_init(); // inicializamos el USB
usb_task(); // habilita periferico usb e interrupciones
usb_wait_for_enumeration(); // esperamos hasta que el PicUSB sea configurado por el host
LED_OFF(LEDV);
LED_ON(LEDR); // encendemos led en RB7 al establecer contacto con la PC
TRISA = 0x0FF; // Se declara el puerto A como entradas (instrucción opcional)
TRISB = 0x00; // Se declara el puerto B como salidas (instrucción opcional)
ADCON1 = 0x0F; // Se configura al ADC para entradas digitales (apagar el ADC)
CMCON = 0x07; // Se configuran los comparadores para entradas digitales (apagar los comparadores)
while (TRUE)
{
if(usb_enumerated()) // si el Pic está configurado via USB
{
if (usb_kbhit(1)) // si el endpoint de salida contiene datos del host
{
usb_get_packet(1, dato, 64); // cojemos el paquete de tamaño 8bytes del EP1 y almacenamos en dato
portb = dato[0]; // Se muestra al byte completo en el puerto B
dato[1] = porta; // Se lee el puerto A y se almacena en el vector
usb_put_packet(1, dato, 64, USB_DTS_TOGGLE); //y enviamos el mismo paquete de tamaño 64bytes del EP1 al PC
}
}
}
}
//Paso 4: Compile y grabe en el PICusb_get_packet(1, iBuff, 2); // Read 2 byte packet from EP 1
if (iBuff[0] == 0) // Led_Mode
{
if (iBuff[1] == 1) output_toggle(LED); // Toggle LED
}
if (iBuff[0] == 2) // ADC_Mode
{
oBuff[0] = 1;
oBuff[1] = read_adc();
usb_put_packet(1, oBuff, 2, USB_DTS_TOGGLE); // Send 2 byte packet to EP 1
}
if (iBuff[0] == 1)
{
oBuff[0] = 1;
oBuff[1] = 1;
usb_put_packet(1, oBuff, 2, USB_DTS_TOGGLE); //enviamos el paquete de tamaño 1byte del EP1 al PC
}private void timer1_Tick(object sender, EventArgs e)
{
bool bres;
byte[] sdBuffer = new byte[1]; // Define send DataBuffer size
byte[] rdBuffer = new byte[2]; // Define recieve DataBuffer size
sdBuffer[0] = 0x02; //Mode ADC
bres = picwinusbapi.Write_PicWinUSB(iHandle, sdBuffer);
bres = picwinusbapi.Read_PicWinUSB(iHandle, rdBuffer);
if (rdBuffer[0] == 1)
{
temperatura_ambiente_var = (int)(rdBuffer[1] * 5 * 100 / 254);
adcBar.Value = temperatura_ambiente_var;
temp_ambiente_box.Text = temperatura_ambiente_var.ToString() + "ºC";
}
sdBuffer[0] = 0x01; //Mode se o PIC está conectado
bres = picwinusbapi.Write_PicWinUSB(iHandle, sdBuffer);
bres = picwinusbapi.Read_PicWinUSB(iHandle, rdBuffer);
if (rdBuffer[0] == 1)
{
if (rdBuffer[1] == 1)
{
pic_conectado_box.Text = "PIC Conectado";
}
}
etc...Problema resolvido!
Desistalei o windows 7 e instalei o windows XP e voltou a funcionar!
Podem conferir o vídeo aqui (em português! :D):
Obrigado
Saludos amigos, tengo una pregunta sencilla para ustedes pero para mi vital.
Estoy tomando muestras de una señal analogica en el pic 18F4550
las quiero enviar a la PC por USB
mi intencion es que esta comunicacion sea lo mas rapida posible he leido que existen tres formas de configurar el PIC
Bulk Transfers USB o la transferencia bidireccional masiva de información.
HID USB o los dispositivos de interfaz humana.
CDC USB o la clase de dispositivos de comunicación.
me gustaria saber cual de ellas me es mas conveniente utilizar, tomando en cuenta la descripcion me inclino por Bulk Transfers USB. Pero quiero estar seguro para comenzar.
Saludos y exitos
:( :( guaaa no me funca... bueno recie estoy empezando en este mundo de los PICusb y bueno descargue el programa de JIM por cierto felicitarle a JIM por todos los conocimientos que comparte y gracias a los maestros como el vamos aprendiendo mucho .. :P y bueno el ejemplo funciona chevere en proteus descargue el "picusb"; ya pero kise hacerlo modificarlo algunas cosas :P...y como todos supongo haciendo un copy/paste para despues hacerlo a mi modo..:P hixe la misma aplicacion de JIM y pero cuando presiono cualquier boton sale abajo este mensaje....
"Excepción del tipo 'System.FormatException' en mscorlib.dll" tb me sale el cuadro de
"Una llamada a la función PInvoke 'UnoPIC!UnoPIC.Program::_MPUSBOpen' impidió
la correspondencia de la pila. Es posible que la razón sea que la firma PInvoke administrada
no coincida con la firma de destino no administrada. Compruebe que la convención y los parámetros
de llamada de la firma PInvoke coinciden con la firma no administrada de destino."
pero eso sale en estas lineas
myOutPipe = _MPUSBOpen(selection, vid_pid_norm, out_pipe, 0, 0);
myInPipe = _MPUSBOpen(selection, vid_pid_norm, in_pipe, 1, 0);
alguien me podria explicar lo que pasa y como puedo solucionarlo :( :( :( :(.... por cierto tengo el
WS7 32b ,VisualEstudio 2010 ...
PicUSB se ha realizado con la intención de proporcionar un primer empujón para todos aquellos que quieren arrancar con los diseños por USB y que como supongo que a muchos nos ha pasado, no saben por donde engancharlo!
Orale muy buena aplicación para empezara usar el USB.....mis mas sinceras felicitaciones pana JIM <img src="http://pics.miarroba.com/caretos/wink.gif" alt="Giño" title="Giño" /> <img src="http://pics.miarroba.com/caretos/biggrin.gif" alt="Sonrisa Gigante" title="Sonrisa Gigante" /><img src="http://pics.miarroba.com/caretos/bounce.gif" alt="Rebotado" title="Rebotado" />
hola me encuentro con un problema estoy tratando de conectar un lector de codigo de barras a mi pic18f4550 pero no lo reconoce mi pic como hago para que mi pic trabaje como maestro de el lector por lo general sale es de la conexion con una computadora pero con un lector solo el pic y el lector se puede ? seria de mucha ayuda q me pudieran ayudar muchas gracias saludos
hola me encuentro con un problema estoy tratando de conectar un lector de codigo de barras a mi pic18f4550 pero no lo reconoce mi pic como hago para que mi pic trabaje como maestro de el lector por lo general sale es de la conexion con una computadora pero con un lector solo el pic y el lector se puede ? seria de mucha ayuda q me pudieran ayudar muchas gracias saludos