Gracias por la explicación, la verdad siempre viene bien eso de 'olvidar' un poco lo que nos dan hecho, puesto que muchas veces podemos arrancarle unos cuantos bytes de optimización :)
char usb_data_buffer[USB_TOTAL_BUFFER_SPACE-USB_MAX_EP0_PACKET_LENGTH-USB_MAX_EP0_PACKET_LENGTH];
#locate usb_data_buffer=USB_BUFFER+USB_MAX_EP0_PACKET_LENGTH+USB_MAX_EP0_PACKET_LENGTH
// Array que ocupa al completo (quitando los búferes de EP0 IN y EP0 OUT,o sea 16 bytes) los bancos 5, 6 y 7 = 752 bytes
#reserve 0x400:0x4FF + USB_BUFFER_NEEDED
// Reserva el banco 4 para los descriptores de buffer,vale,eso me parece bien...pero,si ya tenemos declarado un array que ocupa prácticamente toda la USB RAM y que contendrá los búfferes de todos los endpoints exceptuando el EP0 ¿¿¿[size=15pt]POR QUÉ[/size] reserva también USB_BUFFER_NEEDED bytes??
#define USB_BUFFER_NEEDED (USB_EP0_TX_SIZE+USB_EP0_RX_SIZE+USB_EP1_TX_SIZE+USB_EP1_RX_SIZE+USB_EP2_TX_SIZE+USB_EP2_RX_SIZE
+USB_EP3_TX_SIZE+USB_EP3_RX_SIZE+USB_EP4_TX_SIZE+USB_EP4_RX_SIZE+USB_EP5_TX_SIZE+USB_EP5_RX_SIZE
+USB_EP6_TX_SIZE+USB_EP6_RX_SIZE+USB_EP7_TX_SIZE+USB_EP7_RX_SIZE+USB_EP8_TX_SIZE+USB_EP8_RX_SIZE
+USB_EP9_TX_SIZE+USB_EP9_RX_SIZE+USB_EP10_TX_SIZE+USB_EP10_RX_SIZE+USB_EP11_TX_SIZE+
USB_EP11_RX_SIZE+USB_EP12_TX_SIZE+USB_EP12_RX_SIZE+USB_EP13_TX_SIZE+USB_EP13_RX_SIZE+
USB_EP14_TX_SIZE+USB_EP14_RX_SIZE+USB_EP15_TX_SIZE+USB_EP15_RX_SIZE)
En el código, también tengo que incluir todas las librerias que se incluyen en la forma sin interrupcion? o solo copiar los código que están en los primeros posts del hilo?
Para inicializar el USB, y esperar la numeración, se hace lo mismo que en el método de no interrupción?
Talvez utilice un buffer de 128bytes como mínimo de IN y OUT, no hará falta que sea pinpong, cual es el máximo valor de buffer que puedo utilizar? y que pasa si solo necesito 1byte?
Modula, quizá sea muy atrevido de mi parte, pero si es puedes, nos colocas todo el codigo que hiciste apra poder ver las librerias qeu se incluyen, los pasos a seguir para habilitar el usb por interrupcion y todo ello.
Las rutinas que te debes traer a tu fichero principal (si lo haces de la forma que yo sugerí) y el resto de rutinas que se usan para la inicialización del usb hacen uso de otras rutinas contenidas en las librerías, por lo que las invocaciones a éstas no pueden faltar.cuando dices traer te refieres a copiarlas o a moverlas, yo supongo que debe ser moverlas, o no?
#define LEDV PIN_A0
#define LEDR PIN_A1
#define LED_ON output_high
#define LED_OFF output_low
#define modo recibe[0]
#define param1 recibe[1]
#define param2 recibe[2]
#define resultado envia[0]
int8 recibe[3]; //declaramos variables
int8 envia[1];
void main(void) {
LED_OFF(LEDV); //encendemos led rojo
LED_ON(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(LEDR); //en este nivel me daba cuenta que el micro fue configurado correctamente
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); //cojemos el paquete de tamaño 3bytes del EP1 y almacenamos en recibe, recibe es el nombre de mi buffer
if (modo == 0){ // Modo_Suma
resultado = param1 + param2; //hacemos la suma
usb_put_packet(1, envia, 1, USB_DTS_TOGGLE); //enviamos el paquete de tamaño 1byte del EP1 al PC
}
if (modo == 1){ //Modo_Led
if (param1 == 0) {LED_OFF(LEDV); LED_OFF(LEDR);} //apagamos los leds
if (param1 == 1) {LED_ON(LEDV); LED_OFF(LEDR);} //encendemos led verde
if (param1 == 2) {LED_OFF(LEDV); LED_ON(LEDR);} //encendemos led rojo
}
}
}
}
}
...Entre ellas cómo tener mi propia rutina de interrupción cuando se reciben datos por algún endpoint que no sea el endpoint 0...
PalitroqueZ, me referia a usado para los datos, siempre pense que todo,control y datos, se gestionaba mediante el endpoint 0, ahora veo que no. Gracias por las aclaraciones a los dos
#include <18F4550.h>
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,VREGEN,MCLR,NOPBADEN
// 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=4000000)
#use i2c(Master,Fast,sda=PIN_B0,scl=PIN_B1,restart_wdt,force_hw)
#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
//#define USB_CON_SENSE_PIN PIN_B2 //CCS 18F4550 development kit has optional conection sense pin
#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
/*////////////////////////////////////////////////////////////////////
0xD8,0x04, //vendor id (0x04D8 is Microchip)
0x0B,0x00, //product id
0x01,0x00, //device release number
*/////////////////////////////////////////////////////////////////////
#BYTE ADCON1 = 0x0FC1
#BYTE CMCON = 0x0FB4
int8 dato[64];
int8 dato2[64];
void main(void) {
set_tris_a(0);
set_tris_b(0);
dato2[1]=123;
output_a(0);
delay_ms(1000);
output_bit (pin_B0,1);
output_bit (pin_B1,0);
delay_ms(1000);
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
output_bit (pin_B0,0);
output_bit (pin_B1,1);
delay_ms(1000);
ADCON1 = 0x0F;
CMCON = 0x07;
set_tris_a(0);
//disable_interrupts(GLOBAL);
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
{
// disable_interrupts(GLOBAL);
delay_ms(10000);
output_toggle(PIN_B7);
delay_ms(10000);
output_toggle(PIN_B7);
delay_ms(2000);
usb_get_packet(1, dato, 64);
output_a(dato[0]);
delay_ms(1000);
dato[0] =142;// input_c();
usb_put_packet(1, dato, 64, USB_DTS_TOGGLE); //leer q es dts toggle
delay_ms(1000);
usb_detach ();
/* delay_ms(100);
i2c_start();
i2c_write(2); // Device address
i2c_write(2); // Device address
delay_ms(1000);
i2c_write(dato[0]); // Data to device
delay_ms(1000);
i2c_stop();
*/
//enable_interrupts(GLOBAL);
delay_ms(100);
usb_attach ();
usb_init(); // inicializamos el USB
usb_task(); // habilita periferico usb e interrupciones
usb_wait_for_enumeration();
}
}
}
}
bytes_recibidos = *(BD1OCNT + ep*8); // el + ep*8 es para saltar el ep0 de control?
ptr = 256*(*(BD1OADRH + 8*ep)) + (*(BD1OADRL + ep*8)); //igual aka?